fix(dist): 交叉构建 Linux 包时 tar 的盘符冒号坑（转正斜杠 + --force-local）

在 Windows 上跑 pnpm dist:server:linux 时，packLinuxTarball 传给 tar 的归档路径带盘符，GNU tar 会把 F: 当成主机名去解析远程归档，报 resolve failed 并以退出码 2 失败。现象很误导：包已经整套铺好，只差最后一步打 tar。反斜杠还会被当转义符。

改成路径统一转正斜杠并加 --force-local。该选项在 Linux 上无害（本地路径本来就该走本地分支），因此无条件加上、不做平台分支 —— Linux 上路径没有盘符，这个坑在 CI 与真机上永远复现不了，只在交叉构建时现形。已记入 AGENTS.md 第 5 节第 59 条与 README 的交付验收表。

.github/workflows/release-linux-server.yml

@@ -0,0 +1,132 @@
+name: 发布 Linux 服务端安装包
+
+# 为什么单独有这个 workflow：
+#   Linux 包的依赖（@libsql/linux-x64-gnu、@prisma/adapter-libsql 等）是平台相关的，
+#   在 Windows 开发机上 npm install 出来的 node_modules 装到 Linux 跑不起来，
+#   所以 Linux 包必须在 Linux 上构建。这个 workflow 用 ubuntu runner 产出
+#   classhelper-server-linux-x64-<版本>.tar.gz 并挂到 GitHub Release 上，
+#   服务器上的 `classhelper upgrade` 就是从这里下载 + 校验 sha256 的。
+#
+# 用法：
+#   1. 先在本地按惯例打出 Windows 包并发 Release（vX.Y.Z）；
+#   2. 到 Actions 页面手动运行本 workflow，填 tag（例如 v1.1.2）；
+#   3. 跑完 Release 里会多出 Linux 包与更新后的 SHA256SUMS-<版本>.txt。
+#
+# 也可以只跑构建不挂 Release（attach=false），产物在 workflow 的 Artifacts 里。
+
+on:
+  workflow_dispatch:
+    inputs:
+      tag:
+        description: '要构建并挂载的 Release tag（例如 v1.1.2）'
+        required: true
+        type: string
+      attach:
+        description: '构建后上传到该 Release'
+        required: false
+        default: true
+        type: boolean
+  push:
+    tags:
+      - 'v*'
+
+permissions:
+  contents: write
+
+jobs:
+  build-linux-package:
+    runs-on: ubuntu-22.04
+    timeout-minutes: 40
+
+    steps:
+      - name: 确定 tag
+        id: ref
+        run: |
+          if [ "${{ github.event_name }}" = "workflow_dispatch" ]; then
+            echo "tag=${{ inputs.tag }}" >> "$GITHUB_OUTPUT"
+            echo "attach=${{ inputs.attach }}" >> "$GITHUB_OUTPUT"
+          else
+            echo "tag=${GITHUB_REF_NAME}" >> "$GITHUB_OUTPUT"
+            echo "attach=true" >> "$GITHUB_OUTPUT"
+          fi
+
+      - name: 检出代码
+        uses: actions/checkout@v4
+        with:
+          ref: ${{ steps.ref.outputs.tag }}
+
+      - name: 安装 Node 22
+        uses: actions/setup-node@v4
+        with:
+          node-version: '22'
+
+      - name: 安装 pnpm
+        uses: pnpm/action-setup@v4
+        with:
+          version: 11.8.0
+          run_install: false
+
+      - name: 安装依赖
+        run: pnpm install --frozen-lockfile
+
+      - name: 生成 Prisma Client
+        # 必须显式生成：packages/server/src/generated/prisma 是 gitignored 的，CI 上全新检出没有它。
+        # 少了这一步，`tsc` 会因为 Prisma 类型解析不到而把回调参数全推成 any，报出一大片
+        # "TS7006 Parameter 'item' implicitly has an 'any' type" / "TS2339 Property 'id' does not exist
+        # on type '{}'" —— 看着像代码写错了，实际是缺生成物（本机因为早就生成过，永远踩不到）。
+        # deploy/Dockerfile 的构建阶段有同样的步骤与注释。
+        run: pnpm --filter @classhelper/server db:generate
+
+      - name: 构建 Linux 安装包
+        run: pnpm dist:server:linux
+
+      - name: 展示产物
+        run: ls -la releases/server/*/linux-x64/
+
+      - name: 上传构建产物（Artifacts）
+        uses: actions/upload-artifact@v4
+        with:
+          name: classhelper-server-linux-x64
+          path: |
+            releases/server/*/linux-x64/classhelper-server-linux-x64-*.tar.gz
+            releases/server/*/linux-x64/classhelper-server-linux-x64-*.tar.gz.sha256
+          if-no-files-found: error
+          retention-days: 30
+
+      - name: 挂到 Release 并更新 SHA256SUMS
+        if: steps.ref.outputs.attach == 'true'
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          TAG: ${{ steps.ref.outputs.tag }}
+        run: |
+          set -euo pipefail
+          VERSION="${TAG#v}"
+          ARTIFACT_DIR="releases/server/${VERSION}/linux-x64"
+          TARBALL="${ARTIFACT_DIR}/classhelper-server-linux-x64-${VERSION}.tar.gz"
+          SHAFILE="${TARBALL}.sha256"
+          SUMS="releases/SHA256SUMS-${VERSION}.txt"
+
+          if [ ! -f "$TARBALL" ]; then
+            echo "::error::没有找到 $TARBALL（tag 与 package.json 的版本号对得上吗？）"
+            exit 1
+          fi
+          # .sha256 必须跟着一起传：它是独立发布的资产，只更新 tar.gz 会让这个文件指向旧哈希，
+          # 拿它校验的人会得到 mismatch（classhelper upgrade 用的是 --sha256/这个文件，不是 SHA256SUMS）。
+          if [ ! -f "$SHAFILE" ]; then
+            sha256sum "$TARBALL" | sed "s#${ARTIFACT_DIR}/##" > "$SHAFILE"
+          fi
+
+          # 取回已有的校验清单（Windows 包那几行），只替换/追加本包这一行，其余内容原样保留。
+          # 注意**不要**用 `sort -u` 去重：那份文件是人读的（表头 + 体积 + 说明），排序会把它们打散。
+          gh release download "$TAG" --pattern "SHA256SUMS-*.txt" --dir releases --clobber || true
+          DOWNLOADED="$(ls releases/SHA256SUMS-*.txt 2>/dev/null | head -n 1 || true)"
+          if [ -n "$DOWNLOADED" ] && [ "$DOWNLOADED" != "$SUMS" ]; then mv "$DOWNLOADED" "$SUMS"; fi
+          touch "$SUMS"
+          grep -v "^[0-9a-f]\{64\}  classhelper-server-linux-" "$SUMS" > "${SUMS}.new" || true
+          printf '%s  %s\n' "$(sha256sum "$TARBALL" | awk '{print $1}')" "$(basename "$TARBALL")" >> "${SUMS}.new"
+          mv "${SUMS}.new" "$SUMS"
+
+          gh release upload "$TAG" "$TARBALL" "$SHAFILE" "$SUMS" --clobber
+          echo "已上传："
+          cat "$SHAFILE"
+          cat "$SUMS"

.gitignore

@@ -41,3 +41,10 @@ Thumbs.db
 
 # 参考用的第三方源码包（设计 token 已提取到 docs/winisland-design-tokens.md）
 WinIsland-master.zip
+releases/
+
+# AI 浼氳瘽浜х墿锛圸Code 璁″垝/閰嶇疆锛屼笉灞炰簬浜у搧浠ｇ爜锛�
+.zcode/
+.zcodeignore
+packages/server/prisma/backups/
+packages/server/prisma/database-settings.json

deploy/.env.example

@@ -7,7 +7,7 @@
 SERVER_PORT=4000
 
 # 应用版本（镜像标签）
-APP_VERSION=0.1.0
+APP_VERSION=1.1.2
 
 # MySQL 配置
 MYSQL_ROOT_PASSWORD=请改成强密码_root
@@ -31,7 +31,7 @@ INITIAL_ADMIN_USERNAME=admin
 INITIAL_ADMIN_PASSWORD=admin123
 
 # 各类账号的默认初始密码（新增/重置时使用）
-DEFAULT_STUDENT_PASSWORD=123456
+
 DEFAULT_CLASS_PASSWORD=123456
 DEFAULT_TEACHER_PASSWORD=123456
 

deploy/.env.sqlite.example

@@ -0,0 +1,36 @@
+# ---------------------------------------------------------------------------
+# 班级小助手 · Docker 单容器（SQLite）环境变量
+# 复制为 deploy/.env.sqlite 后填写：cp deploy/.env.sqlite.example deploy/.env.sqlite
+# 配合 deploy/docker-compose.sqlite.yml 使用
+# ---------------------------------------------------------------------------
+
+# 服务端对外端口（宿主机）。注意与同机其他服务错开：80/443 常被反代占用
+SERVER_PORT=4000
+
+# 应用版本（镜像标签）
+APP_VERSION=1.1.2
+
+# JWT 签名密钥（必填，必须 ≥32 位；不能包含 secret / change-me 等示例词）
+# 生成：node -e "console.log(require('crypto').randomBytes(48).toString('hex'))"
+JWT_SECRET=
+
+# 令牌有效期
+JWT_EXPIRES_IN=7d
+
+# 允许的跨域来源；用域名访问时建议写成具体来源，例如 https://class.example.com
+CORS_ORIGIN=*
+
+# 首次启动创建的管理员账号（**部署后请立即登录修改密码**）
+INITIAL_ADMIN_USERNAME=admin
+INITIAL_ADMIN_PASSWORD=admin123
+
+# 各类账号的默认初始密码（新增/重置时使用）
+
+DEFAULT_CLASS_PASSWORD=123456
+DEFAULT_TEACHER_PASSWORD=123456
+
+# 第 1 教学周的周一（用于"当前周次"）
+TERM_START_DATE=2026-08-31
+
+# 日志级别：debug | info | warn | error
+LOG_LEVEL=info

deploy/Dockerfile

@@ -5,13 +5,13 @@
 #   runtime —— 仅保留运行时所需内容（生产依赖 + 构建产物），镜像更小
 #
 # 构建（在仓库根目录执行）：
-#   docker build -f deploy/Dockerfile -t classhelper-server:0.1.0 .
+#   docker build -f deploy/Dockerfile -t classhelper-server:1.1.0 .
 #
 # 运行（SQLite + 数据卷）：
 #   docker run -d --name classhelper -p 4000:4000 \
 #     -e JWT_SECRET=<48字节随机串> \
 #     -v classhelper-data:/app/data \
-#     classhelper-server:0.1.0
+#     classhelper-server:1.1.0
 #
 # 生产推荐用 docker compose（见 deploy/docker-compose.yml，含 MySQL 与 HTTPS 反代）
 
@@ -33,7 +33,12 @@ RUN pnpm install --frozen-lockfile --ignore-scripts
 # 再拷贝源码并构建（只构建服务端与 Web 管理端，桌面客户端不参与）
 COPY packages ./packages
 COPY scripts ./scripts
+
+# 必须先生成 Prisma Client：`pnpm install --ignore-scripts` 跳过了 postinstall，
+# 而生成产物 `packages/server/src/generated/prisma` 是 gitignored 的（clone 下来没有），
+# 少了这一步下面的 tsc 会报 "Cannot find module '../generated/prisma/client.js'"。
 RUN pnpm build:shared \
+ && pnpm --filter @classhelper/server run db:generate \
  && pnpm --filter @classhelper/server build \
  && pnpm --filter @classhelper/web-admin build
 

deploy/Dockerfile.linux-package

@@ -0,0 +1,45 @@
+# ---------------------------------------------------------------------------
+# 班级小助手服务端 · Docker 形态镜像（由 install.sh --mode docker 使用）
+#
+# 与仓库根 deploy/Dockerfile 的区别：
+#   - 那份是"从源码构建"（两阶段、需要 pnpm 与全量源码），适合开发与自己打包镜像；
+#   - 这份是"从安装包构建"：安装包里的 server/dist、web、node_modules 已经是**linux-x64 的真实目录**，
+#     所以这里只做 COPY，不需要联网装依赖、不需要构建工具，几十秒就能出镜像。
+#
+# 构建（install.sh 自动执行，也可手工）：
+#   docker build -t classhelper-server:1.1.0 -f Dockerfile .
+# 运行：
+#   docker run -d --name classhelper-server -p 4000:4000 \
+#     --env-file /etc/classhelper/config.env -v classhelper-data:/app/data \
+#     classhelper-server:1.1.0
+# ---------------------------------------------------------------------------
+FROM node:22-slim
+
+ENV NODE_ENV=production \
+    HOST=0.0.0.0 \
+    PORT=4000
+
+WORKDIR /app
+
+# 运行时会用到的全部内容（安装包里就是这套布局）
+COPY package.json ./
+COPY node_modules ./node_modules
+COPY server ./server
+COPY web ./web
+COPY tools ./tools
+
+# 数据目录（compose 里挂成卷）
+RUN mkdir -p /app/data /app/logs
+
+# 说明：不用 `USER node`
+#   - 镜像只在本机跑，容器本身就是隔离边界；
+#   - 数据卷里的文件需要与宿主机上的 classhelper backup / restore 互通，
+#     用 root 可以避免 uid 不一致导致的权限问题。
+
+EXPOSE 4000
+
+# 健康检查用 Node 自己发请求：slim 镜像里没有 curl/wget
+HEALTHCHECK --interval=30s --timeout=5s --start-period=40s --retries=3 \
+  CMD node -e "fetch('http://127.0.0.1:'+(process.env.PORT||4000)+'/healthz').then(r=>process.exit(r.ok?0:1)).catch(()=>process.exit(1))"
+
+CMD ["node", "server/dist/index.js"]

deploy/classhelper.service

@@ -1,24 +1,33 @@
 # ---------------------------------------------------------------------------
 # 班级小助手 · 服务端 systemd 单元（Linux）
 #
-# 这是**模板**：deploy/install-linux.sh 会把 __NODE__ / __DIR__ / __USER__ 替换成真实值后
+# 这是**模板**：`deploy/install.sh` 会把占位符替换成真实值后安装到
-# 安装到 /etc/systemd/system/classhelper.service。手动部署时直接改这三处即可：
+# /etc/systemd/system/classhelper.service。手动部署时照着替换这四处即可：
 #
-#   sudo sed -e 's#__NODE__#/usr/bin/node#' \
+#   __NODE__       Node 可执行文件的绝对路径（内置运行时：<安装目录>/runtime/node/bin/node）
+#   __DIR__        安装目录（默认 /opt/classhelper）
+#   __USER__       运行服务的系统用户（默认 classhelper）
+#   __CONFIG__     环境变量文件（默认 /etc/classhelper/config.env）
+#   __CONFIGDIR__  __CONFIG__ 所在目录（需要写权限，见下面的 ReadWritePaths）
+#
+#   sudo sed -e 's#__NODE__#/opt/classhelper/runtime/node/bin/node#' \
 #            -e 's#__DIR__#/opt/classhelper#' \
 #            -e 's#__USER__#classhelper#' \
-#            deploy/classhelper.service | sudo tee /etc/systemd/system/classhelper.service
+#            -e 's#__CONFIGDIR__#/etc/classhelper#' \
+#            -e 's#__CONFIG__#/etc/classhelper/config.env#' \
+#            deploy/classhelper.service > /tmp/classhelper.service
+#   sudo install -m 644 /tmp/classhelper.service /etc/systemd/system/classhelper.service
 #   sudo systemctl daemon-reload && sudo systemctl enable --now classhelper
 #
-# 常用命令：
+# 常用命令（也有对应的 classhelper 封装）：
+#   classhelper status / start / stop / restart / logs -f
 #   systemctl status classhelper
-#   journalctl -u classhelper -f          # 实时日志
+#   journalctl -u classhelper -f
-#   systemctl restart classhelper         # 重启（改完 .env 需要）
 # ---------------------------------------------------------------------------
 
 [Unit]
 Description=ClassHelper Server (班级小助手服务端)
-Documentation=file://__DIR__/README.txt
+Documentation=https://github.com/LoveChengke/ClassHelper
 After=network-online.target
 Wants=network-online.target
 
@@ -27,15 +36,18 @@ Type=simple
 User=__USER__
 Group=__USER__
 WorkingDirectory=__DIR__
-# .env 由服务端自己从 WorkingDirectory 加载（工作目录即安装根目录）
+
+# 配置从这里注入（唯一的配置真身；安装目录里的 .env 是指向它的软链，见 docs/linux-deploy.md）。
+# systemd 会剥掉值两侧的引号，所以同一份文件给 dotenv / shell source / systemd 三种读法都能用。
+# 前面不加 "-"：文件被删掉时直接启动失败，比拿着一份假配置跑起来更容易发现。
+EnvironmentFile=__CONFIG__
 ExecStart=__NODE__ server/dist/index.js
-Environment=NODE_ENV=production
 
 Restart=always
 RestartSec=3
 # Socket.IO 长连接较多：提高文件描述符上限
 LimitNOFILE=65535
-# 优雅退出：给在途请求与 websocket 收尾时间
+# 优雅退出：给在途请求与 websocket 收尾时间（index.ts 处理 SIGTERM/SIGINT）
 KillSignal=SIGTERM
 TimeoutStopSec=20
 
@@ -44,12 +56,26 @@ StandardOutput=journal
 StandardError=journal
 SyslogIdentifier=classhelper
 
-# 基础加固（服务只需要读程序、写 data/logs）
+# ---------------------------------------------------------------- 加固
-NoNewPrivileges=true
+# 为什么 ReadWritePaths 要给整个 __DIR__ 与配置目录，而不是只给 data/logs：
-PrivateTmp=true
+#   1) Web 端「数据库管理 → 一键切换」会在运行中改写 server/prisma/schema.prisma，
+#      并把重新生成的 Prisma Client 编译进 server/dist/generated —— 那两处都在 __DIR__ 里；
+#   2) 同一功能切换成功后要改写 __CONFIG__（DATABASE_PROVIDER / DATABASE_URL 两行）。
+#   ProtectSystem=full 默认把 /etc 与 /usr 设成只读，ReadWritePaths 是官方的"打洞"方式。
+#   服务本来就以 __USER__ 身份运行，这里给的写权限没有超出它的既有边界。
 ProtectSystem=full
 ProtectHome=true
-ReadWritePaths=__DIR__/data __DIR__/logs
+PrivateTmp=true
+NoNewPrivileges=true
+ReadWritePaths=__DIR__ __CONFIGDIR__
+
+ProtectKernelTunables=true
+ProtectKernelModules=true
+ProtectControlGroups=true
+RestrictSUIDSGID=true
+LockPersonality=true
+# 需要 AF_NETLINK：glibc 解析主机名（MySQL 主机 / GitHub API）时会用到
+RestrictAddressFamilies=AF_INET AF_INET6 AF_UNIX AF_NETLINK
 
 [Install]
 WantedBy=multi-user.target

deploy/docker-compose.sqlite.yml

@@ -0,0 +1,56 @@
+# 班级小助手 · Docker 单容器部署（SQLite + 数据卷）
+#
+# 适用：云服务器 / 与别的服务共用一台机器。相比 deploy/docker-compose.yml（MySQL 变体）
+#      少跑一个数据库容器，内存占用小很多；数据落在 Docker 卷 classhelper-data 里。
+#
+# 使用：
+#   1) cp deploy/.env.sqlite.example deploy/.env.sqlite 并填 JWT_SECRET / 管理员密码
+#      （生成密钥：node -e "console.log(require('crypto').randomBytes(48).toString('hex'))"）
+#   2) docker compose -f deploy/docker-compose.sqlite.yml --env-file deploy/.env.sqlite up -d --build
+#   3) 访问：http://<服务器IP>:${SERVER_PORT}/
+#
+# 首次启动（AUTO_MIGRATE=true）会自动执行 prisma/migrations 里的建表语句并创建管理员账号，
+# 见 packages/server/src/lib/db-bootstrap.ts（"Docker 挂载空数据卷"就是它的目标场景之一）。
+#
+# 备份：docker run --rm -v classhelper-sqlite_classhelper-data:/data -v "$PWD":/backup alpine \
+#         tar czf /backup/classhelper-db.tar.gz -C /data .
+
+name: classhelper-sqlite
+
+services:
+  server:
+    build:
+      context: ..
+      dockerfile: deploy/Dockerfile
+      target: runtime
+    image: classhelper-server:${APP_VERSION:-1.1.2}
+    restart: unless-stopped
+    environment:
+      NODE_ENV: production
+      HOST: 0.0.0.0
+      PORT: 4000
+      DATABASE_PROVIDER: sqlite
+      # 必须写绝对路径：容器里 serverRoot 是 /app/server，相对路径会解析到别处
+      DATABASE_URL: file:/app/data/classhelper.db
+      # 首启动自动建表 + 建管理员；生产自检会拒绝 dev.db 与过短的 JWT_SECRET
+      AUTO_MIGRATE: 'true'
+      STARTUP_DB_CHECK: 'true'
+      JWT_SECRET: ${JWT_SECRET:?请在 deploy/.env.sqlite 中设置（≥32 位随机串）}
+      JWT_EXPIRES_IN: ${JWT_EXPIRES_IN:-7d}
+      CORS_ORIGIN: ${CORS_ORIGIN:-*}
+      TRUST_PROXY: '1'
+      RATE_LIMIT_ENABLED: 'true'
+      LOG_LEVEL: ${LOG_LEVEL:-info}
+      TERM_START_DATE: ${TERM_START_DATE:-}
+      INITIAL_ADMIN_USERNAME: ${INITIAL_ADMIN_USERNAME:-admin}
+      INITIAL_ADMIN_PASSWORD: ${INITIAL_ADMIN_PASSWORD:-admin123}
+
+      DEFAULT_CLASS_PASSWORD: ${DEFAULT_CLASS_PASSWORD:-123456}
+      DEFAULT_TEACHER_PASSWORD: ${DEFAULT_TEACHER_PASSWORD:-123456}
+    ports:
+      - '${SERVER_PORT:-4000}:4000'
+    volumes:
+      - classhelper-data:/app/data
+
+volumes:
+  classhelper-data:

deploy/docker-compose.yml

@@ -60,7 +60,7 @@ services:
       context: ..
       dockerfile: deploy/Dockerfile
       target: runtime
-    image: classhelper-server:${APP_VERSION:-0.1.0}
+    image: classhelper-server:${APP_VERSION:-1.1.2}
     restart: unless-stopped
     environment:
       NODE_ENV: production
@@ -78,7 +78,7 @@ services:
       TERM_START_DATE: ${TERM_START_DATE:-}
       INITIAL_ADMIN_USERNAME: ${INITIAL_ADMIN_USERNAME:-admin}
       INITIAL_ADMIN_PASSWORD: ${INITIAL_ADMIN_PASSWORD:-admin123}
-      DEFAULT_STUDENT_PASSWORD: ${DEFAULT_STUDENT_PASSWORD:-123456}
+
       DEFAULT_CLASS_PASSWORD: ${DEFAULT_CLASS_PASSWORD:-123456}
       DEFAULT_TEACHER_PASSWORD: ${DEFAULT_TEACHER_PASSWORD:-123456}
     ports:

deploy/install-linux.sh

@@ -1,279 +1,14 @@
 #!/usr/bin/env bash
 # ---------------------------------------------------------------------------
-# 班级小助手 · 服务端 Linux 一键部署（systemd + SQLite，单机单实例）
+# 兼容壳：早期文档、脚本与 README 里写的是 deploy/install-linux.sh，
+# 现在安装器统一在 deploy/install.sh（避免两份实现漂移）。
 #
-# 干什么：
+# 两者参数完全一致：
-#   在 Linux 服务器上把服务端装成 systemd 服务，布局与已验证的 Windows 免安装目录完全一致：
+#   sudo bash deploy/install-linux.sh --port 8080
-#     /opt/classhelper/
+# 等价于
-#     ├── .env                    全部配置（首次安装随机生成 JWT_SECRET）
+#   sudo bash deploy/install.sh --port 8080
-#     ├── server/dist             后端程序（入口 index.js）
-#     ├── server/prisma           迁移 SQL（AUTO_MIGRATE=true 时首启动自动执行）
-#     ├── web/                    Web 管理端（由后端托管，单端口 4000）
-#     ├── node_modules/           仅生产依赖（npm install --omit=dev）
-#     ├── data/                   classhelper.db + server.pid
-#     └── logs/                   预留（日志默认进 journald）
-#
-# 前置条件：
-#   - 在**仓库根目录**已执行过构建：pnpm build:shared && pnpm --filter @classhelper/server build \
-#       && pnpm --filter @classhelper/web-admin build
-#   - 目标机装好 Node.js ≥ 20.19（推荐 22 LTS）；本脚本不代装 Node
-#
-# 用法（在仓库根目录执行，需要 root）：
-#   sudo bash deploy/install-linux.sh                    # 安装/升级，默认端口 4000、目录 /opt/classhelper
-#   sudo bash deploy/install-linux.sh --port 8080        # 换端口
-#   sudo bash deploy/install-linux.sh --dir /srv/classhelper
-#   sudo bash deploy/install-linux.sh --no-service       # 只铺文件，不装 systemd（自己接管进程）
-#   bash deploy/install-linux.sh --check                 # 只体检（不需要 root）：校验构建产物/Node 版本/端口探针
-#   sudo bash deploy/install-linux.sh --uninstall        # 停止并禁用服务（保留 data 与 .env）
-#
-# 升级：把新代码构建好后**再跑一次同样的命令**即可。脚本不会覆盖已有 .env（JWT 密钥与端口保持
-#      不变，用户不用重新登录），只会补齐缺失项并覆盖程序文件。
-#
-# 注意：本脚本未在 Linux 实机验证过（开发机是 Windows，无 Docker/WSL 发行版）。
-#      它复用的是**已验证**的两套布局：Windows 免安装目录（install/ 结构）与 deploy/Dockerfile
-#      的 runtime 阶段（package.runtime.json + prisma/migrations + web/）。
 # ---------------------------------------------------------------------------
 set -euo pipefail
-
+DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-TARGET_DIR="/opt/classhelper"
+printf '\033[33m[classhelper]\033[0m install-linux.sh 已更名为 install.sh，本次自动转发（后续请直接用 install.sh）\n' >&2
-SERVICE_USER="classhelper"
+exec bash "${DIR}/install.sh" "$@"
-PORT="4000"
-WITH_SERVICE=1
-UNINSTALL=0
-CHECK_ONLY=0
-SERVICE_NAME="classhelper"
-
-while [ $# -gt 0 ]; do
-  case "$1" in
-    --dir) TARGET_DIR="$2"; shift 2 ;;
-    --port) PORT="$2"; shift 2 ;;
-    --user) SERVICE_USER="$2"; shift 2 ;;
-    --no-service) WITH_SERVICE=0; shift ;;
-    --check) CHECK_ONLY=1; shift ;;
-    --uninstall) UNINSTALL=1; shift ;;
-    -h|--help) sed -n '2,40p' "$0"; exit 0 ;;
-    *) echo "未知参数：$1（用 --help 看用法）" >&2; exit 2 ;;
-  esac
-done
-
-log()  { printf '\033[32m[classhelper]\033[0m %s\n' "$*"; }
-warn() { printf '\033[33m[classhelper]\033[0m %s\n' "$*" >&2; }
-die()  { printf '\033[31m[classhelper]\033[0m %s\n' "$*" >&2; exit 1; }
-
-# 就绪探针：优先 curl（几乎每台 Linux 都有），否则退回 node。
-# 注意不要用 `node -e "...process.exit()"` —— 在部分 Node 版本上于 promise 回调里硬退会触发
-# libuv 断言崩溃（本机 Windows 实测退出码 -1073740791），改成设置 process.exitCode 让事件循环自然结束。
-probe_ready() {
-  if command -v curl >/dev/null 2>&1; then
-    curl -fsS -o /dev/null --max-time 3 "http://127.0.0.1:${PORT}/healthz" >/dev/null 2>&1
-    return $?
-  fi
-  "$NODE_BIN" -e "fetch('http://127.0.0.1:${PORT}/healthz').then(r=>{process.exitCode=r.ok?0:1}).catch(()=>{process.exitCode=1})" >/dev/null 2>&1
-}
-
-[ "$(id -u)" = "0" ] || { [ "$CHECK_ONLY" = "1" ] || die "请用 root 执行：sudo bash deploy/install-linux.sh"; }
-
-# ---------------------------------------------------------------- 卸载分支
-if [ "$UNINSTALL" = "1" ]; then
-  if systemctl list-unit-files | grep -q "^${SERVICE_NAME}.service"; then
-    systemctl disable --now "$SERVICE_NAME" || true
-    rm -f "/etc/systemd/system/${SERVICE_NAME}.service"
-    systemctl daemon-reload
-    log "已停止并移除 systemd 服务 ${SERVICE_NAME}"
-  else
-    warn "没有找到 ${SERVICE_NAME}.service（可能没装成服务）"
-  fi
-  log "程序文件与数据保留在 ${TARGET_DIR}；确认不需要后再手动删除"
-  exit 0
-fi
-
-# ---------------------------------------------------------------- 定位仓库与产物
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-REPO_ROOT="$(cd "${SCRIPT_DIR}/.." && pwd)"
-cd "$REPO_ROOT"
-
-SERVER_DIST="packages/server/dist/index.js"
-SERVER_PRISMA="packages/server/prisma"
-WEB_DIST="packages/web-admin/dist/index.html"
-SHARED_DIST="packages/shared/dist/index.js"
-RUNTIME_PKG="deploy/package.runtime.json"
-
-for f in "$SERVER_DIST" "$WEB_DIST" "$SHARED_DIST" "$RUNTIME_PKG"; do
-  [ -e "$f" ] || die "缺少构建产物：$f
-请先在仓库根目录执行：
-  pnpm build:shared && pnpm --filter @classhelper/server build && pnpm --filter @classhelper/web-admin build"
-done
-[ -d "$SERVER_PRISMA/migrations" ] || die "缺少迁移文件目录：$SERVER_PRISMA/migrations"
-
-# ---------------------------------------------------------------- Node 检查
-NODE_BIN="$(command -v node || true)"
-[ -n "$NODE_BIN" ] || die "未找到 node，请先安装 Node.js ≥ 20.19（推荐 22 LTS）"
-NODE_MAJOR="$("$NODE_BIN" -p 'process.versions.node.split(".")[0]')"
-NODE_MINOR="$("$NODE_BIN" -p 'process.versions.node.split(".")[1]')"
-if [ "$NODE_MAJOR" -lt 20 ] || { [ "$NODE_MAJOR" -eq 20 ] && [ "$NODE_MINOR" -lt 19 ]; }; then
-  die "Node 版本过低：$("$NODE_BIN" -v)（要求 ≥ 20.19）"
-fi
-NPM_BIN="$(command -v npm || true)"
-[ -n "$NPM_BIN" ] || die "未找到 npm（随 Node 一起安装）"
-log "Node $("$NODE_BIN" -v) → $NODE_BIN"
-
-# ---------------------------------------------------------------- 只体检
-if [ "$CHECK_ONLY" = "1" ]; then
-  echo
-  echo "构建产物："
-  for f in "$SERVER_DIST" "$WEB_DIST" "$SHARED_DIST" "$RUNTIME_PKG" "$SERVER_PRISMA/migrations"; do
-    printf '  %-42s %s\n' "$f" "OK"
-  done
-  printf '  %-42s %s\n' "迁移文件数量" "$(find "$SERVER_PRISMA/migrations" -mindepth 1 -maxdepth 1 -type d | wc -l | tr -d ' ')"
-  echo
-  echo "运行环境："
-  printf '  %-42s %s\n' "node" "$("$NODE_BIN" -v)（要求 ≥ 20.19）"
-  printf '  %-42s %s\n' "npm" "$("$NPM_BIN" -v)"
-  printf '  %-42s %s\n' "systemd" "$(command -v systemctl >/dev/null 2>&1 && echo 可用 || echo '不可用（用 --no-service）')"
-  printf '  %-42s %s\n' "目标目录 ${TARGET_DIR}" "$([ -e "$TARGET_DIR" ] && echo '已存在（会就地升级，保留 .env）' || echo 尚未创建)"
-  printf '  %-42s %s\n' "端口 ${PORT} 上的既有服务" "$(probe_ready && echo '健康（就绪）' || echo '无响应')"
-  echo
-  log "--check 通过：构建产物与运行环境都满足，可以执行安装（sudo bash deploy/install-linux.sh）"
-  exit 0
-fi
-
-# ---------------------------------------------------------------- 用户与目录
-if ! id -u "$SERVICE_USER" >/dev/null 2>&1; then
-  useradd --system --create-home --shell /usr/sbin/nologin "$SERVICE_USER" 2>/dev/null \
-    || useradd --system --shell /sbin/nologin "$SERVICE_USER"
-  log "已创建系统用户 ${SERVICE_USER}"
-fi
-
-mkdir -p "${TARGET_DIR}/server" "${TARGET_DIR}/web" "${TARGET_DIR}/data" "${TARGET_DIR}/logs"
-log "安装目录：${TARGET_DIR}"
-
-# ---------------------------------------------------------------- 拷贝产物
-rm -rf "${TARGET_DIR}/server/dist"
-cp -R "packages/server/dist" "${TARGET_DIR}/server/dist"
-rm -rf "${TARGET_DIR}/server/prisma"
-cp -R "$SERVER_PRISMA" "${TARGET_DIR}/server/prisma"
-# 运行时不读 schema，但保留一份便于排查
-[ -f packages/server/prisma/schema.prisma ] && cp packages/server/prisma/schema.prisma "${TARGET_DIR}/server/prisma/schema.prisma"
-
-rm -rf "${TARGET_DIR}/web"
-cp -R "packages/web-admin/dist" "${TARGET_DIR}/web"
-
-cp "$RUNTIME_PKG" "${TARGET_DIR}/package.json"
-cp -R deploy/classhelper.service "${TARGET_DIR}/classhelper.service.template"
-
-# 生产依赖（与 Dockerfile 的 runtime 阶段同一份清单）
-if [ ! -d "${TARGET_DIR}/node_modules" ] || [ "${FORCE_NPM_INSTALL:-0}" = "1" ]; then
-  log "安装生产依赖（npm install --omit=dev，约 1~3 分钟）..."
-  ( cd "$TARGET_DIR" && "$NPM_BIN" install --omit=dev --no-audit --no-fund )
-else
-  log "复用已有 node_modules（如需强制重装：FORCE_NPM_INSTALL=1 再跑一次）"
-fi
-
-# workspace 共享包（后端 import '@classhelper/shared'）：拷进 node_modules 里
-mkdir -p "${TARGET_DIR}/node_modules/@classhelper/shared"
-rm -rf "${TARGET_DIR}/node_modules/@classhelper/shared/dist"
-cp -R "packages/shared/dist" "${TARGET_DIR}/node_modules/@classhelper/shared/dist"
-cp packages/shared/package.json "${TARGET_DIR}/node_modules/@classhelper/shared/package.json"
-
-# ---------------------------------------------------------------- .env（已存在则不覆盖）
-ENV_FILE="${TARGET_DIR}/.env"
-if [ -f "$ENV_FILE" ]; then
-  log "检测到已有 .env：保留现有配置（含 JWT_SECRET），只补齐缺失项"
-else
-  JWT_SECRET="$("$NODE_BIN" -e 'console.log(require("crypto").randomBytes(48).toString("hex"))')"
-  cat > "$ENV_FILE" <<EOF
-# 班级小助手服务端（install-linux.sh 生成，请妥善保管）
-# 修改后重启服务生效：systemctl restart ${SERVICE_NAME}
-
-NODE_ENV=production
-HOST=0.0.0.0
-PORT=${PORT}
-
-# 数据库：SQLite 文件放在安装根目录的 data 下（备份只需复制该目录）
-DATABASE_PROVIDER=sqlite
-DATABASE_URL="file:../data/classhelper.db"
-# 空库首启动自动执行随包迁移并创建管理员
-AUTO_MIGRATE=true
-
-# 令牌签名密钥（随机生成；更换后所有用户需重新登录）
-JWT_SECRET=${JWT_SECRET}
-JWT_EXPIRES_IN=7d
-
-# 允许的跨域来源：走域名/反代时建议改成具体来源，例如 https://class.example.com
-CORS_ORIGIN=*
-# 前面有 Nginx 等反向代理时设为 1，限流才会按真实客户端 IP 统计
-TRUST_PROXY=1
-
-RATE_LIMIT_ENABLED=true
-STARTUP_DB_CHECK=true
-PID_FILE=../data/server.pid
-LOG_LEVEL=info
-
-BCRYPT_ROUNDS=10
-DEFAULT_STUDENT_PASSWORD=123456
-DEFAULT_CLASS_PASSWORD=123456
-DEFAULT_TEACHER_PASSWORD=123456
-TERM_START_DATE=
-EOF
-  log "已生成 ${ENV_FILE}（含随机 JWT_SECRET）"
-fi
-
-# data/logs 必须可写；程序文件只读即可
-chown -R "${SERVICE_USER}:${SERVICE_USER}" "${TARGET_DIR}/data" "${TARGET_DIR}/logs"
-chown -R "${SERVICE_USER}:${SERVICE_USER}" "${TARGET_DIR}/node_modules"
-chown "${SERVICE_USER}:${SERVICE_USER}" "$ENV_FILE"
-chown -R root:root "${TARGET_DIR}/server" "${TARGET_DIR}/web"
-chmod 600 "$ENV_FILE"
-
-# ---------------------------------------------------------------- systemd
-if [ "$WITH_SERVICE" = "1" ]; then
-  command -v systemctl >/dev/null 2>&1 || die "本机没有 systemd；请加 --no-service 自行托管进程"
-
-  sed -e "s#__NODE__#${NODE_BIN}#g" \
-      -e "s#__DIR__#${TARGET_DIR}#g" \
-      -e "s#__USER__#${SERVICE_USER}#g" \
-      deploy/classhelper.service > "/etc/systemd/system/${SERVICE_NAME}.service"
-  systemctl daemon-reload
-  systemctl enable "$SERVICE_NAME" >/dev/null
-  systemctl restart "$SERVICE_NAME"
-
-  log "等待服务就绪..."
-  ready=0
-  for _ in $(seq 1 60); do
-    if probe_ready; then
-      ready=1
-      break
-    fi
-    sleep 1
-  done
-
-  if [ "$ready" != "1" ]; then
-    warn "60 秒内没通过 /healthz，最近日志："
-    journalctl -u "$SERVICE_NAME" -n 50 --no-pager || true
-    die "启动失败，请按上面的日志排查（常见：端口被占用、数据目录权限、JWT_SECRET 未生成）"
-  fi
-
-  log "服务已就绪 ✅"
-else
-  log "已跳过 systemd（--no-service）。手动启动："
-  echo "  sudo -u ${SERVICE_USER} sh -c 'cd ${TARGET_DIR} && ${NODE_BIN} server/dist/index.js'"
-fi
-
-# ---------------------------------------------------------------- 结果
-cat <<EOF
-
-------------------------------------------------------------------
-安装完成
-  访问管理端：http://<服务器IP>:${PORT}/
-  健康探针：  http://<服务器IP>:${PORT}/healthz  ·  /readyz
-  配置文件：  ${ENV_FILE}
-  数据目录：  ${TARGET_DIR}/data（备份只需复制这里）
-  查看日志：  journalctl -u ${SERVICE_NAME} -f
-  重启服务：  systemctl restart ${SERVICE_NAME}
-
-首次启动会自动建表并创建管理员：admin / admin123（登录后请立即在右上角「修改密码」改掉）。
-公网部署请在前面加 Nginx + HTTPS（deploy/nginx.conf 可直接用），并把 .env 里的
-TRUST_PROXY 设为 1、CORS_ORIGIN 收敛到你的域名。
-学生端客户端登录时填的「服务器地址」就是 https://你的域名（或 http://IP:${PORT}）。
-------------------------------------------------------------------
-EOF

deploy/logrotate.d/classhelper

@@ -0,0 +1,19 @@
+# ---------------------------------------------------------------------------
+# 班级小助手 · 日志轮转
+# 由 deploy/install.sh 安装到 /etc/logrotate.d/classhelper
+#
+# copytruncate 而不是 create+信号：安装器与 classhelper 都是"追加写完就关"
+# （`>>` 打开、写完立即关闭），没有常驻 fd 可通知，copytruncate 是这里唯一正确的做法。
+# ---------------------------------------------------------------------------
+
+/var/log/classhelper/*.log {
+    weekly
+    rotate 8
+    missingok
+    notifempty
+    compress
+    delaycompress
+    copytruncate
+    create 0600 root root
+    su root root
+}

deploy/package.runtime.json

@@ -1,12 +1,13 @@
 {
   "name": "classhelper-server-runtime",
-  "version": "0.1.0",
+  "version": "1.1.2",
   "private": true,
   "type": "module",
   "description": "班级小助手服务端运行时（安装包 / 容器内置）",
   "dependencies": {
     "@libsql/client": "^0.17.0",
     "@prisma/adapter-libsql": "7.10.0",
+    "@prisma/adapter-mariadb": "7.10.0",
     "@prisma/client": "7.10.0",
     "bcryptjs": "^3.0.3",
     "compression": "^1.8.2",
@@ -16,7 +17,9 @@
     "express-rate-limit": "^8.7.0",
     "helmet": "^8.3.0",
     "jsonwebtoken": "^9.0.3",
+    "prisma": "7.10.0",
     "socket.io": "^4.8.3",
+    "typescript": "~5.9.3",
     "xlsx": "0.18.5",
     "zod": "^4.6.2"
   }

deploy/profile.d/classhelper.sh

@@ -0,0 +1,28 @@
+# ---------------------------------------------------------------------------
+# 班级小助手 · 登录 shell 环境变量
+#
+# 由 deploy/install.sh 安装到 /etc/profile.d/classhelper.sh（占位符替换成真实路径）。
+# 生效方式：重新登录，或 `source /etc/profile.d/classhelper.sh`。
+#
+# 说明：`classhelper` 命令本身装在 /usr/local/bin（软链到 $CLASSHELPER_HOME/bin/classhelper），
+#       不依赖这个文件也能用；这里提供的是路径类变量，方便写脚本时引用。
+# ---------------------------------------------------------------------------
+
+# 只在目录真实存在时导出：卸载后残留的 profile.d 不应该污染别人的环境
+if [ -d '__DIR__' ]; then
+  export CLASSHELPER_HOME='__DIR__'
+  export CLASSHELPER_CONFIG='__CONFIG__'
+  export CLASSHELPER_LOG_DIR='__LOGDIR__'
+  export CLASSHELPER_BACKUP_DIR='__BACKUPDIR__'
+  export CLASSHELPER_SERVICE='classhelper'
+
+  case ":${PATH}:" in
+    *":${CLASSHELPER_HOME}/bin:"*) ;;
+    *) export PATH="${PATH}:${CLASSHELPER_HOME}/bin" ;;
+  esac
+fi
+
+# 让 `classhelper` 在非 root 登录时也能补全（bash 补全由 `classhelper completion bash` 输出）
+if [ -n "${BASH_VERSION:-}" ] && [ -r /usr/share/bash-completion/completions/classhelper ]; then
+  . /usr/share/bash-completion/completions/classhelper
+fi

deploy/systemd/classhelper-backup.service

@@ -0,0 +1,22 @@
+# ---------------------------------------------------------------------------
+# 班级小助手 · 定时备份（systemd timer）
+# 由 `classhelper backup schedule daily|weekly` 安装（占位符 __BIN__ / __KEEP__ 由命令替换）
+#
+# 手工安装：
+#   sudo sed -e 's#__BIN__#/usr/local/bin/classhelper#' -e 's#__KEEP__#7#' \
+#     deploy/systemd/classhelper-backup.service > /tmp/x.service ...
+# 然后 systemctl daemon-reload && systemctl enable --now classhelper-backup.timer
+# ---------------------------------------------------------------------------
+
+[Unit]
+Description=ClassHelper 定时备份
+Documentation=https://github.com/LoveChengke/ClassHelper
+After=classhelper.service
+
+[Service]
+Type=oneshot
+ExecStart=__BIN__ backup --quiet --keep __KEEP__
+# 备份失败时不要静默：journalctl -u classhelper-backup 里能看到退出码与原因
+StandardOutput=journal
+StandardError=journal
+SyslogIdentifier=classhelper-backup

deploy/systemd/classhelper-backup.timer

@@ -0,0 +1,19 @@
+# ---------------------------------------------------------------------------
+# 班级小助手 · 定时备份（触发器）
+# 由 `classhelper backup schedule daily|weekly` 安装；OnCalendar 行由命令按选择替换
+# ---------------------------------------------------------------------------
+
+[Unit]
+Description=ClassHelper 定时备份触发器
+Documentation=https://github.com/LoveChengke/ClassHelper
+
+[Timer]
+OnCalendar=__ONCALENDAR__
+# 错开整点：避免所有装了本服务的机器在同一秒打盘
+RandomizedDelaySec=30m
+# 机器关机期间错过的备份在开机后补一次
+Persistent=true
+Unit=classhelper-backup.service
+
+[Install]
+WantedBy=timers.target

deploy/tools/admin-cli.mjs

@@ -0,0 +1,335 @@
+#!/usr/bin/env node
+/**
+ * 班级小助手 · 离线账号工具（随 Linux 包发布，安装在 ${INSTALL_DIR}/tools/admin-cli.mjs）
+ *
+ * 为什么不用 HTTP API 改密码：`classhelper password` 要能在**服务停机**时救急，
+ * 而调 API 必须先有一个能登录的账号 —— 管理员忘了密码时就是死锁。
+ * 因此这里直连数据库，复用服务端自己的 Prisma Client 与 bcrypt 参数（`server/dist/lib/*`），
+ * 保证写入的哈希与登录校验用的是同一套实现。
+ *
+ * 安全约定（务必保持）：
+ *   - **密码只从 stdin 读**，绝不接受 argv / 环境变量形式的密码（否则会进 shell history 与 ps 输出）；
+ *   - 本工具自己**不打印任何密码**，也不写任何日志；
+ *   - `dump-hash` 会输出 bcrypt 哈希 —— 仅由 root 调用的 `classhelper password` 用于改前备份，
+ *     调用方负责把结果落到 600 权限的文件里。
+ *
+ * 用法（全部由 classhelper 封装，一般不需要手工调）：
+ *   node tools/admin-cli.mjs info
+ *   node tools/admin-cli.mjs list [--json]
+ *   node tools/admin-cli.mjs dump-hash <用户名|class:班级码>
+ *   node tools/admin-cli.mjs set-password <用户名>        # 新密码从 stdin 读
+ *   node tools/admin-cli.mjs set-class-password <班级码>  # 新密码从 stdin 读
+ *   node tools/admin-cli.mjs verify <用户名>              # 待校验密码从 stdin 读
+ *   node tools/admin-cli.mjs restore-hash <备份json路径>
+ *   node tools/admin-cli.mjs snapshot <目标db文件>         # SQLite 一致性快照（VACUUM INTO）
+ *
+ * 退出码：0 成功 / 1 通用失败 / 2 用法错误 / 3 目标不存在 / 4 密码不合规 / 5 数据库不可用
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+
+const scriptDir = path.dirname(fileURLToPath(import.meta.url));
+/** 安装根目录（tools/ 的上一级） */
+const installDir = path.resolve(scriptDir, '..');
+const serverDist = path.join(installDir, 'server', 'dist');
+
+const EXIT = { OK: 0, FAIL: 1, USAGE: 2, NOT_FOUND: 3, WEAK: 4, NO_DB: 5 };
+
+function fail(message, code = EXIT.FAIL) {
+  process.stderr.write(`admin-cli: ${message}\n`);
+  process.exitCode = code;
+  return null;
+}
+
+/** 一次性读完 stdin（去掉行尾换行；保留内部空白，密码里可以有空格） */
+async function readSecretFromStdin() {
+  const chunks = [];
+  for await (const chunk of process.stdin) chunks.push(chunk);
+  return Buffer.concat(chunks).toString('utf8').replace(/\r?\n$/, '');
+}
+
+/** 与服务端一致的密码强度规则（classhelper 里还有一份交互式版本，两边保持同样口径） */
+function checkStrength(password, username) {
+  const problems = [];
+  if (password.length < 8) problems.push('长度至少 8 位');
+  if (password.length > 128) problems.push('长度不要超过 128 位');
+  const kinds = [/[a-z]/, /[A-Z]/, /[0-9]/, /[^A-Za-z0-9]/].filter((re) => re.test(password)).length;
+  if (kinds < 3) problems.push('需包含小写字母 / 大写字母 / 数字 / 符号 中至少 3 类');
+  if (username && password.toLowerCase() === username.toLowerCase()) problems.push('不能与用户名相同');
+  if (/^(123456|password|admin|classhelper|qwerty|111111|abc123)/i.test(password) && password.length < 12) {
+    problems.push('过于常见，请换一个');
+  }
+  return problems;
+}
+
+/** 懒加载服务端模块：先做"库在不在"的检查，避免 libSQL 在连接时凭空建出一个空库 */
+async function loadServerModules() {
+  const envFile = path.join(serverDist, 'config', 'env.js');
+  if (!fs.existsSync(envFile)) {
+    fail(`找不到服务端产物：${envFile}`, EXIT.NO_DB);
+    return null;
+  }
+  const env = await import(pathToFileURL(envFile).href);
+  if (env.env.databaseProvider === 'sqlite') {
+    // classhelper 做备份时会用 CLASSHELPER_SNAPSHOT_DB 显式指定数据文件（跳过硬编码路径假设）
+    const dbFile = process.env.CLASSHELPER_SNAPSHOT_DB || env.env.sqliteFilePath;
+    if (!dbFile || !fs.existsSync(dbFile)) {
+      fail(
+        `数据库文件不存在：${dbFile || '(未配置)'}\n` +
+          '  提示：全新安装请先 systemctl start classhelper 完成建表（AUTO_MIGRATE）；',
+        EXIT.NO_DB,
+      );
+      return null;
+    }
+  }
+  const db = await import(pathToFileURL(path.join(serverDist, 'lib', 'db.js')).href);
+  const password = await import(pathToFileURL(path.join(serverDist, 'lib', 'password.js')).href);
+  return { env: env.env, prisma: db.prisma, disconnectPrisma: db.disconnectPrisma, ...password };
+}
+
+/** 目标账号：普通用户按 username，班级账号按 Class.code（学生端登录用的是班级码） */
+async function resolveTarget(prisma, key) {
+  if (key.startsWith('class:')) {
+    const code = key.slice('class:'.length).toUpperCase();
+    const klass = await prisma.class.findUnique({ where: { code } });
+    if (!klass) return { error: `班级码不存在：${code}`, code: EXIT.NOT_FOUND };
+    return { kind: 'class', id: klass.id, label: `班级 ${klass.name}（码 ${klass.code}）`, hash: klass.passwordHash };
+  }
+  const user = await prisma.user.findUnique({ where: { username: key } });
+  if (!user) return { error: `用户名不存在：${key}`, code: EXIT.NOT_FOUND };
+  if (user.role === 'STUDENT') {
+    return {
+      error: `学生没有个人账号（${key} 只是名单记录），学生端用「班级码 + 班级密码」登录，请用 --class 改班级密码`,
+      code: EXIT.NOT_FOUND,
+    };
+  }
+  return { kind: 'user', id: user.id, label: `${user.name}（${user.username} / ${user.role}）`, hash: user.passwordHash };
+}
+
+/* ------------------------------------------------------------------ 子命令 */
+
+/**
+ * SQLite 一致性快照：`VACUUM INTO` 在服务运行中也能拿到自洽的副本
+ * （直接 cp 数据文件可能抓到写入中的中间状态）。
+ * 目标文件必须不存在 —— 这是 SQLite 的硬要求，先删掉。
+ */
+async function cmdSnapshot(modules, dest) {
+  const { env, prisma } = modules;
+  if (env.databaseProvider !== 'sqlite') {
+    return fail('snapshot 只支持 SQLite；MySQL 请用 mysqldump', EXIT.FAIL);
+  }
+  const target = path.resolve(dest);
+  fs.mkdirSync(path.dirname(target), { recursive: true });
+  fs.rmSync(target, { force: true });
+  // VACUUM INTO 不接受参数占位符，只能拼字面量 —— 单引号按 SQL 规则翻倍转义
+  await prisma.$executeRawUnsafe(`VACUUM INTO '${target.replace(/'/g, "''")}'`);
+  if (!fs.existsSync(target)) return fail('快照未生成（VACUUM INTO 未报错但没有产出文件）', EXIT.FAIL);
+  process.stdout.write(`${target}\n`);
+}
+
+async function cmdInfo(modules) {
+  const { env, prisma } = modules;
+  const counts = {};
+  for (const model of ['user', 'class', 'course', 'schedule', 'homework', 'notification', 'grade']) {
+    counts[model] = await prisma[model].count();
+  }
+  const payload = {
+    provider: env.databaseProvider,
+    sqliteFile: env.sqliteFilePath || null,
+    serverRoot: env.serverRoot,
+    termStartDate: env.termStartDate || null,
+    counts,
+  };
+  process.stdout.write(`${JSON.stringify(payload, null, 2)}\n`);
+}
+
+async function cmdList(modules, asJson) {
+  const { prisma } = modules;
+  const users = await prisma.user.findMany({
+    where: { role: { in: ['ADMIN', 'TEACHER'] } },
+    select: { username: true, name: true, role: true, classId: true, updatedAt: true },
+    orderBy: [{ role: 'asc' }, { username: 'asc' }],
+  });
+  const classes = await prisma.class.findMany({
+    select: { code: true, name: true, passwordHash: true },
+    orderBy: { code: 'asc' },
+  });
+
+  if (asJson) {
+    process.stdout.write(
+      `${JSON.stringify(
+        {
+          users,
+          classes: classes.map((item) => ({ code: item.code, name: item.name, hasPassword: !!item.passwordHash })),
+        },
+        null,
+        2,
+      )}\n`,
+    );
+    return;
+  }
+
+  process.stdout.write('可登录账号（教师 / 管理员）：\n');
+  for (const user of users) {
+    process.stdout.write(`  ${user.role.padEnd(8)} ${user.username.padEnd(16)} ${user.name}\n`);
+  }
+  process.stdout.write('\n班级账号（学生端用「班级码 + 班级密码」登录）：\n');
+  for (const item of classes) {
+    const state = item.passwordHash ? '已设置' : '⚠ 未设置密码（该班当前无法登录）';
+    process.stdout.write(`  ${item.code.padEnd(8)} ${item.name.padEnd(16)} ${state}\n`);
+  }
+}
+
+async function cmdDumpHash(modules, key) {
+  const { prisma } = modules;
+  const target = await resolveTarget(prisma, key);
+  if (target.error) return fail(target.error, target.code);
+  if (!target.hash) return fail(`${target.label} 当前没有密码（passwordHash 为空）`, EXIT.NOT_FOUND);
+  // 只给调用方（root）看的原始数据，不落到本工具的日志里
+  process.stdout.write(`${JSON.stringify({ target: key, kind: target.kind, id: target.id, hash: target.hash })}\n`);
+}
+
+async function cmdSetPassword(modules, key, readSecret) {
+  const { prisma, hashPassword } = modules;
+  const target = await resolveTarget(prisma, key);
+  if (target.error) return fail(target.error, target.code);
+
+  const secret = await readSecret();
+  const problems = checkStrength(secret, key);
+  if (problems.length > 0) return fail(`密码不合规：${problems.join('；')}`, EXIT.WEAK);
+
+  const hash = await hashPassword(secret);
+  if (target.kind === 'class') {
+    await prisma.class.update({ where: { id: target.id }, data: { passwordHash: hash } });
+  } else {
+    await prisma.user.update({ where: { id: target.id }, data: { passwordHash: hash } });
+  }
+
+  // 写完立刻复核一次：曾经出现过"bcrypt 参数不一致导致写进去的哈希验证不过"的排查成本
+  const ok = await modules.verifyPassword(secret, hash);
+  if (!ok) return fail('写入后复核失败：哈希无法通过校验，请用 restore-hash 回滚', EXIT.FAIL);
+
+  process.stdout.write(`已更新密码：${target.label}\n`);
+}
+
+async function cmdVerify(modules, key, readSecret) {
+  const { prisma, verifyPassword } = modules;
+  const target = await resolveTarget(prisma, key);
+  if (target.error) return fail(target.error, target.code);
+  const secret = await readSecret();
+  const ok = !!target.hash && (await verifyPassword(secret, target.hash));
+  process.stdout.write(`${ok ? 'match' : 'mismatch'}\n`);
+  if (!ok) process.exitCode = EXIT.FAIL;
+}
+
+async function cmdRestoreHash(modules, backupFile) {
+  const { prisma } = modules;
+  if (!fs.existsSync(backupFile)) return fail(`备份文件不存在：${backupFile}`, EXIT.NOT_FOUND);
+  let payload;
+  try {
+    payload = JSON.parse(fs.readFileSync(backupFile, 'utf8'));
+  } catch (error) {
+    return fail(`备份文件不是合法 JSON：${error.message}`);
+  }
+  const { target, hash } = payload;
+  if (typeof target !== 'string' || typeof hash !== 'string') {
+    return fail('备份文件缺少 target / hash 字段，拒绝回滚');
+  }
+  if (target.startsWith('class:')) {
+    await prisma.class.update({ where: { code: target.slice('class:'.length).toUpperCase() }, data: { passwordHash: hash } });
+  } else {
+    await prisma.user.update({ where: { username: target }, data: { passwordHash: hash } });
+  }
+  process.stdout.write(`已回滚密码哈希：${target}\n`);
+}
+
+/* ------------------------------------------------------------------ 入口 */
+
+const argv = process.argv.slice(2);
+const command = argv[0] ?? 'help';
+const args = argv.slice(1);
+const wantsJson = args.includes('--json');
+const positional = args.filter((item) => !item.startsWith('--'));
+
+function usage() {
+  process.stdout.write(
+    [
+      'classhelper 离线账号工具（一般由 classhelper 命令调用）',
+      '',
+      '  info                              输出数据库与表行数（JSON）',
+      '  list [--json]                     列出可登录账号与班级账号',
+      '  dump-hash <用户名|class:班级码>    输出当前密码哈希（供改密前备份）',
+      '  set-password <用户名>             从 stdin 读新密码并写入',
+      '  set-class-password <班级码>       从 stdin 读新密码并写入班级账号',
+      '  verify <用户名>                   从 stdin 读密码，输出 match / mismatch',
+      '  restore-hash <备份json路径>       用备份文件里的哈希回滚',
+      '  snapshot <目标db文件>             把 SQLite 库一致性快照到指定路径（VACUUM INTO）',
+      '',
+    ].join('\n'),
+  );
+}
+
+if (command === 'help' || command === '--help' || command === '-h') {
+  usage();
+} else if (
+  ![
+    'info',
+    'list',
+    'dump-hash',
+    'set-password',
+    'set-class-password',
+    'verify',
+    'restore-hash',
+    'snapshot',
+  ].includes(command)
+) {
+  fail(`未知子命令：${command}\n`, EXIT.USAGE);
+  usage();
+} else {
+  const modules = await loadServerModules();
+  if (!modules) {
+    // 已经在 loadServerModules 里设了 exitCode
+  } else {
+    try {
+      switch (command) {
+        case 'info':
+          await cmdInfo(modules);
+          break;
+        case 'list':
+          await cmdList(modules, wantsJson);
+          break;
+        case 'dump-hash':
+          if (!positional[0]) fail('缺少目标账号', EXIT.USAGE);
+          else await cmdDumpHash(modules, positional[0]);
+          break;
+        case 'set-password':
+        case 'set-class-password': {
+          const key = command === 'set-class-password' ? `class:${positional[0] ?? ''}` : (positional[0] ?? '');
+          if (!positional[0]) fail('缺少目标账号', EXIT.USAGE);
+          else await cmdSetPassword(modules, key, readSecretFromStdin);
+          break;
+        }
+        case 'verify':
+          if (!positional[0]) fail('缺少目标账号', EXIT.USAGE);
+          else await cmdVerify(modules, positional[0], readSecretFromStdin);
+          break;
+        case 'restore-hash':
+          if (!positional[0]) fail('缺少备份文件路径', EXIT.USAGE);
+          else await cmdRestoreHash(modules, positional[0]);
+          break;
+        case 'snapshot':
+          if (!positional[0]) fail('缺少目标文件路径', EXIT.USAGE);
+          else await cmdSnapshot(modules, positional[0]);
+          break;
+        default:
+          usage();
+      }
+    } catch (error) {
+      fail(error instanceof Error ? error.message : String(error));
+    } finally {
+      // 不用 process.exit()：在顶层 await 里硬退会踩 libuv 断言（见 AGENTS.md §7）
+      await modules.disconnectPrisma();
+    }
+  }
+}

deploy/verify-linux.sh

@@ -0,0 +1,307 @@
+#!/usr/bin/env bash
+# ---------------------------------------------------------------------------
+# 班级小助手 · Linux 安装与运维链路验收（在**已安装的服务器上**运行）
+#
+# 覆盖：安装结果 → 服务可用性 → API 登录 → 改密（含回滚与审计）→ 备份 →
+#       配置读写 → key rotate →（可选）升级 / 回滚 / 卸载
+#
+# 用法（在服务器上，需要 root）：
+#   sudo bash verify-linux.sh                        # 基础链路
+#   sudo bash verify-linux.sh --full --package /tmp/xxx.tar.gz   # 追加升级/回滚
+#   sudo bash verify-linux.sh --admin-password-stdin # 密码从 stdin 读一行（不进 argv/history）
+#
+# 说明：
+#   - 本脚本会**真的**改一次管理员密码（换成随机强密码，再改回去），并真的发一条备份；
+#   - 除了 --purge 的卸载测试，不会删除任何数据；
+#   - 全程不需要外网（升级测试用 --package 指向本地包）。
+# ---------------------------------------------------------------------------
+set -uo pipefail
+
+INSTALL_DIR="/opt/classhelper"
+CONFIG_FILE="/etc/classhelper/config.env"
+LOG_DIR="/var/log/classhelper"
+BACKUP_DIR="/var/backups/classhelper"
+PORT=""
+ADMIN_USER="admin"
+ADMIN_PASSWORD=""
+ADMIN_PASSWORD_FROM_STDIN=0
+DO_FULL=0
+PACKAGE=""
+
+TOTAL=0; PASS=0; FAIL=0
+FAILED=()
+
+while [ $# -gt 0 ]; do
+  case "$1" in
+    --dir) INSTALL_DIR="$2"; shift 2 ;;
+    --config) CONFIG_FILE="$2"; shift 2 ;;
+    --port) PORT="$2"; shift 2 ;;
+    --user) ADMIN_USER="$2"; shift 2 ;;
+    --admin-password) ADMIN_PASSWORD="$2"; shift 2 ;;
+    --admin-password-stdin) ADMIN_PASSWORD_FROM_STDIN=1; shift ;;
+    --package) PACKAGE="$2"; shift 2 ;;
+    --full) DO_FULL=1; shift ;;
+    -h|--help) sed -n '2,18p' "$0"; exit 0 ;;
+    *) echo "未知参数：$1" >&2; exit 2 ;;
+  esac
+done
+
+if [ -t 1 ]; then G=$'\033[32m'; R=$'\033[31m'; Y=$'\033[33m'; D=$'\033[2m'; B=$'\033[1m'; N=$'\033[0m'; else G=; R=; Y=; D=; B=; N=; fi
+
+section() { printf '\n%s▶ %s%s\n' "$B" "$1" "$N"; }
+check() { # $1=描述 $2=0 通过
+  TOTAL=$((TOTAL + 1))
+  if [ "$2" = "0" ]; then
+    PASS=$((PASS + 1)); printf '  %s✔%s %s\n' "$G" "$N" "$1"
+  else
+    FAIL=$((FAIL + 1)); FAILED+=("$1"); printf '  %s✘%s %s\n' "$R" "$N" "$1"
+  fi
+}
+note() { printf '  %s· %s%s\n' "$D" "$1" "$N"; }
+
+[ "$(id -u)" = "0" ] || { echo "请用 root 运行：sudo bash verify-linux.sh" >&2; exit 1; }
+
+if [ ! -f "$CONFIG_FILE" ]; then
+  echo "找不到安装：${CONFIG_FILE} 不存在（用 --config 指定，或先跑 install.sh）" >&2
+  exit 1
+fi
+read_cfg() { sed -n "s/^[[:space:]]*$1=//p" "$CONFIG_FILE" | tail -n 1 | tr -d '"'; }
+[ -n "$PORT" ] || PORT="$(read_cfg PORT)"
+[ -n "$PORT" ] || PORT=4000
+CLASSHELPER="${INSTALL_DIR}/bin/classhelper"
+API="http://127.0.0.1:${PORT}"
+CURL=(curl -fsS --noproxy '*')
+
+if [ "$ADMIN_PASSWORD_FROM_STDIN" = "1" ]; then IFS= read -r ADMIN_PASSWORD || true; fi
+
+printf '%s班级小助手 · Linux 安装验收%s\n' "$B" "$N"
+note "安装目录 ${INSTALL_DIR}｜配置 ${CONFIG_FILE}｜端口 ${PORT}"
+
+# ---------------------------------------------------------------- 1. 安装结果
+
+section "安装结果"
+check "安装目录存在且含 server/dist/index.js" "$([ -f "${INSTALL_DIR}/server/dist/index.js" ] && echo 0 || echo 1)"
+check "版本文件 VERSION 可读" "$([ -s "${INSTALL_DIR}/VERSION" ] && echo 0 || echo 1)"
+check "安装元数据 .installed.json 存在" "$([ -f "${INSTALL_DIR}/.installed.json" ] && echo 0 || echo 1)"
+
+cfg_mode="$(stat -c '%a' "$CONFIG_FILE" 2>/dev/null || echo '?')"
+check "配置文件权限 600（实际 ${cfg_mode}）" "$([ "$cfg_mode" = "600" ] && echo 0 || echo 1)"
+dir_mode="$(stat -c '%a' "$(dirname "$CONFIG_FILE")" 2>/dev/null || echo '?')"
+check "配置目录权限 700（实际 ${dir_mode}）" "$([ "$dir_mode" = "700" ] && echo 0 || echo 1)"
+
+env_link="${INSTALL_DIR}/.env"
+check "安装目录 .env 是指向配置真身的软链（Web 端切库依赖它）" \
+  "$([ -L "$env_link" ] && [ "$(readlink "$env_link")" = "$CONFIG_FILE" ] && echo 0 || echo 1)"
+
+node_bin="${INSTALL_DIR}/runtime/node/bin/node"
+node_ver="$([ -x "$node_bin" ] && "$node_bin" -v 2>/dev/null || echo '')"
+check "内置 Node 可用（${node_ver:-未找到}）" "$([ -n "$node_ver" ] && echo 0 || echo 1)"
+
+check "classhelper 命令已装到 /usr/local/bin" "$([ -x /usr/local/bin/classhelper ] && echo 0 || echo 1)"
+check "安装日志 ${LOG_DIR}/install.log 存在" "$([ -s "${LOG_DIR}/install.log" ] && echo 0 || echo 1)"
+check "审计日志 ${LOG_DIR}/audit.log 存在" "$([ -f "${LOG_DIR}/audit.log" ] && echo 0 || echo 1)"
+check "审计/安装日志权限不放行他人（≤640）" \
+  "$([ "$(stat -c '%a' "${LOG_DIR}/audit.log" 2>/dev/null || echo 644)" -le 640 ] && echo 0 || echo 1)"
+check "/etc/profile.d/classhelper.sh 已写入" "$([ -f /etc/profile.d/classhelper.sh ] && echo 0 || echo 1)"
+profile_home="$(bash -lc 'echo "${CLASSHELPER_HOME:-}"' 2>/dev/null)"
+check "新登录 shell 里 CLASSHELPER_HOME 生效（${profile_home:-空}）" "$([ -n "$profile_home" ] && echo 0 || echo 1)"
+
+# ---------------------------------------------------------------- 2. 服务
+
+section "服务与探针"
+if command -v systemctl >/dev/null 2>&1 && [ -f /etc/systemd/system/classhelper.service ]; then
+  check "systemd 单元已安装" 0
+  check "服务处于 active" "$(systemctl is-active --quiet classhelper && echo 0 || echo 1)"
+  check "服务开机自启（enabled）" "$(systemctl is-enabled --quiet classhelper 2>/dev/null && echo 0 || echo 1)"
+else
+  check "systemd 单元已安装" 1
+fi
+check "/healthz 返回 200" "$("${CURL[@]}" -o /dev/null "${API}/healthz" 2>/dev/null && echo 0 || echo 1)"
+
+status_json="$("$CLASSHELPER" status --json 2>/dev/null || true)"
+check "classhelper status --json 是合法 JSON" "$(printf '%s' "$status_json" | grep -q '"healthy"' && echo 0 || echo 1)"
+check "status 报告 healthy=yes" "$(printf '%s' "$status_json" | grep -q '"healthy": "yes"' && echo 0 || echo 1)"
+check "status 报告的端口与实际一致" "$(printf '%s' "$status_json" | grep -q "\"port\": ${PORT}" && echo 0 || echo 1)"
+check "classhelper help 可执行（非 root 也能看）" "$("$CLASSHELPER" help >/dev/null 2>&1 && echo 0 || echo 1)"
+check "classhelper completion bash 有输出" "$("$CLASSHELPER" completion bash 2>/dev/null | grep -q 'classhelper' && echo 0 || echo 1)"
+
+doctor_out="$("$CLASSHELPER" doctor 2>&1 || true)"
+check "classhelper doctor 无待处理项" "$(printf '%s' "$doctor_out" | grep -q '体检通过' && echo 0 || echo 1)"
+if ! printf '%s' "$doctor_out" | grep -q '体检通过'; then
+  printf '%s' "$doctor_out" | sed 's/^/    /'
+fi
+
+# ---------------------------------------------------------------- 3. API
+
+section "API 与登录"
+TOKEN=""
+login() { # $1=密码 → 输出 token（失败则空）
+  "${CURL[@]}" -X POST "${API}/api/auth/login" -H 'content-type: application/json' \
+    -d "{\"username\":\"${ADMIN_USER}\",\"password\":\"$1\"}" 2>/dev/null \
+    | sed -n 's/.*"token"[[:space:]]*:[[:space:]]*"\([^"]*\)".*/\1/p'
+}
+
+if [ -z "$ADMIN_PASSWORD" ]; then
+  note "未提供 --admin-password(-stdin)，跳过登录与改密用例"
+else
+  TOKEN="$(login "$ADMIN_PASSWORD")"
+  check "管理员用提供的密码能登录并拿到 token" "$([ -n "$TOKEN" ] && echo 0 || echo 1)"
+  if [ -n "$TOKEN" ]; then
+    classes="$("${CURL[@]}" -H "Authorization: Bearer ${TOKEN}" "${API}/api/classes" 2>/dev/null || true)"
+    check "带 token 能读业务接口 /api/classes" "$(printf '%s' "$classes" | grep -q '"data"' && echo 0 || echo 1)"
+    me="$("${CURL[@]}" -H "Authorization: Bearer ${TOKEN}" "${API}/api/auth/me" 2>/dev/null || true)"
+    check "/api/auth/me 返回的是 ADMIN" "$(printf '%s' "$me" | grep -q '"ADMIN"' && echo 0 || echo 1)"
+  fi
+fi
+
+# ---------------------------------------------------------------- 4. 改密
+
+if [ -n "$TOKEN" ]; then
+  section "password 子命令（改密 → 回滚 → 审计）"
+  # 生成一个一定满足强度要求的密码（大小写+数字+符号，且不落在常见口令里）
+  GENERATED="Ch$(head -c 12 /dev/urandom | od -An -tx1 | tr -d ' \n')!a9Z"
+  before_count="$(grep -c 'action=password' "${LOG_DIR}/audit.log" 2>/dev/null || echo 0)"
+
+  # 密码经管道进 stdin，不出现在 argv / 环境变量 / shell history
+  out="$(printf '%s\n%s\n' "$GENERATED" "$GENERATED" | "$CLASSHELPER" password "$ADMIN_USER" 2>&1)"
+  check "classhelper password 执行成功" "$(printf '%s' "$out" | grep -q '密码已更新' && echo 0 || echo 1)"
+
+  new_token="$(login "$GENERATED")"
+  check "新密码能登录" "$([ -n "$new_token" ] && echo 0 || echo 1)"
+  old_token="$(login "$ADMIN_PASSWORD")"
+  check "旧密码已失效（登录被拒）" "$([ -z "$old_token" ] && echo 0 || echo 1)"
+
+  hash_backup="$(ls -1t "${BACKUP_DIR}"/password-*.json 2>/dev/null | head -n 1 || true)"
+  check "改密前备份了原哈希（${hash_backup:-无}）" "$([ -n "$hash_backup" ] && echo 0 || echo 1)"
+  check "哈希备份权限 600" \
+    "$([ -n "$hash_backup" ] && [ "$(stat -c '%a' "$hash_backup")" = "600" ] && echo 0 || echo 1)"
+
+  after_count="$(grep -c 'action=password' "${LOG_DIR}/audit.log" 2>/dev/null || echo 0)"
+  check "审计日志新增了 password 记录" "$([ "${after_count:-0}" -gt "${before_count:-0}" ] && echo 0 || echo 1)"
+  check "审计日志里没有新密码明文" "$(grep -q -- "$GENERATED" "${LOG_DIR}/audit.log" 2>/dev/null && echo 1 || echo 0)"
+  check "审计日志里没有原密码明文" "$(grep -q -- "$ADMIN_PASSWORD" "${LOG_DIR}/audit.log" 2>/dev/null && echo 1 || echo 0)"
+
+  # 先把输出收进变量再 grep：`外部命令 | grep -q` 在 `set -o pipefail` 下，grep 命中即退出会让
+  # 写端收到 SIGPIPE（退出码 141），于是"匹配到了"被算成失败
+  weak_out="$(printf 'abc\nabc\n' | "$CLASSHELPER" password "$ADMIN_USER" 2>&1 || true)"
+  check "弱密码被拒绝（长度/种数不足）" "$(printf '%s' "$weak_out" | grep -q '不合规' && echo 0 || echo 1)"
+  check "密码不合规时不会卡死（stdin 结束即退出）" \
+    "$(printf 'abc\n' | timeout 20 "$CLASSHELPER" password "$ADMIN_USER" >/dev/null 2>&1; [ $? -ne 124 ] && echo 0 || echo 1)"
+  list_out="$("$CLASSHELPER" password --list 2>&1 || true)"
+  check "password --list 能列出账号" "$(printf '%s' "$list_out" | grep -q "$ADMIN_USER" && echo 0 || echo 1)"
+
+  # 用改密前保存的哈希把账号恢复原样：比再改一次密码更可靠
+  # （原密码若是 admin123 这类弱口令，改回去会被强度校验挡下 —— 那是产品的正确行为）
+  if [ -n "$hash_backup" ]; then
+    restore_hash_out="$(LOG_LEVEL=error DOTENV_CONFIG_QUIET=true "$node_bin" "${INSTALL_DIR}/tools/admin-cli.mjs" restore-hash "$hash_backup" 2>&1 || true)"
+    check "restore-hash 能把原哈希回滚回来" "$(printf '%s' "$restore_hash_out" | grep -q '已回滚密码哈希' && echo 0 || echo 1)"
+    check "原密码重新可用" "$([ -n "$(login "$ADMIN_PASSWORD")" ] && echo 0 || echo 1)"
+  fi
+else
+  note "跳过改密用例（没有可用的登录会话）"
+fi
+
+# ---------------------------------------------------------------- 5. 备份
+
+section "backup 子命令"
+backup_out="$("$CLASSHELPER" backup --keep 5 2>&1)"
+check "classhelper backup 执行成功" "$(printf '%s' "$backup_out" | grep -q '备份完成' && echo 0 || echo 1)"
+
+latest="$(ls -1dt "${BACKUP_DIR}"/*/ 2>/dev/null | head -n 1)"
+check "生成了新的备份目录" "$([ -n "$latest" ] && echo 0 || echo 1)"
+if [ -n "$latest" ]; then
+  check "备份含 config.env" "$([ -f "${latest}config.env" ] && echo 0 || echo 1)"
+  check "备份 meta.json 带版本号" "$(grep -q '"version"' "${latest}meta.json" 2>/dev/null && echo 0 || echo 1)"
+  db_kind="$(read_cfg DATABASE_PROVIDER)"
+  if [ "$db_kind" = "sqlite" ]; then
+    snap="${latest}classhelper.db"
+    check "备份含 SQLite 快照" "$([ -s "$snap" ] && echo 0 || echo 1)"
+    # 一致性快照必须是完整的 SQLite 文件（VACUUM INTO 产物）
+    check "快照是合法 SQLite 文件（文件头正确）" \
+      "$([ -n "$snap" ] && [ "$(head -c 15 "$snap" 2>/dev/null)" = "SQLite format 3" ] && echo 0 || echo 1)"
+    check "快照权限 600" "$([ -n "$snap" ] && [ "$(stat -c '%a' "$snap")" = "600" ] && echo 0 || echo 1)"
+  else
+    note "数据库是 MySQL，跳过 SQLite 快照用例"
+  fi
+  check "备份目录权限 700" "$([ "$(stat -c '%a' "${latest%/}" 2>/dev/null)" = "700" ] && echo 0 || echo 1)"
+fi
+backup_list_out="$("$CLASSHELPER" backup list 2>&1 || true)"
+check "backup list 能列出备份" "$(printf '%s' "$backup_list_out" | grep -qE '^  [0-9]{8}-' && echo 0 || echo 1)"
+
+# ---------------------------------------------------------------- 6. 配置
+
+section "config 子命令"
+check "config get PORT 返回当前端口" "$([ "$("$CLASSHELPER" config get PORT)" = "$PORT" ] && echo 0 || echo 1)"
+masked="$("$CLASSHELPER" config show 2>/dev/null | grep '^JWT_SECRET=')"
+check "config show 对 JWT_SECRET 打码" "$(printf '%s' "$masked" | grep -q '\*\*\*\*' && echo 0 || echo 1)"
+check "config show 没打印出真实密钥" \
+  "$(secret="$(read_cfg JWT_SECRET)"; [ -n "$secret" ] && printf '%s' "$masked" | grep -q -- "$secret" && echo 1 || echo 0)"
+
+# 用一个无害的键做读写往返（不重启服务）
+printf 'CH_VERIFY_PROBE=1\n' >>"$CONFIG_FILE"
+probe="$("$CLASSHELPER" config get CH_VERIFY_PROBE 2>/dev/null)"
+check "config get 能读到新增键" "$([ "$probe" = "1" ] && echo 0 || echo 1)"
+sed -i '/^CH_VERIFY_PROBE=/d' "$CONFIG_FILE"
+
+# ---------------------------------------------------------------- 7. key rotate
+
+if [ -n "$TOKEN" ]; then
+  section "key rotate"
+  if [ "${CLASSHELPER_VERIFY_SKIP_KEY_ROTATE:-0}" = "1" ]; then
+    note "按环境变量跳过"
+  else
+    old_secret="$(read_cfg JWT_SECRET)"
+    # key rotate 无 tty 时会问两次（确认轮换、是否现在重启）；只喂一个 yes 的话第二次读到 EOF，
+    # 重启被跳过 —— 新密钥不生效，下面「旧 token 已失效」必然失败。
+    # 用 CLASSHELPER_ASSUME_YES=1 跳过问答并强制重启，语义才是"轮换后旧会话立即失效"。
+    CLASSHELPER_NO_TTY=1 CLASSHELPER_ASSUME_YES=1 "$CLASSHELPER" key rotate >/dev/null 2>&1 || true
+    new_secret="$(read_cfg JWT_SECRET)"
+    check "key rotate 改变了 JWT_SECRET" "$([ -n "$new_secret" ] && [ "$new_secret" != "$old_secret" ] && echo 0 || echo 1)"
+    check "新密钥长度 ≥32" "$([ "${#new_secret}" -ge 32 ] && echo 0 || echo 1)"
+    check "轮换后服务仍可用" "$("${CURL[@]}" -o /dev/null "${API}/healthz" && echo 0 || echo 1)"
+    check "轮换前的 token 已失效（/api/auth/me 返回 401）" \
+      "$(code="$(curl -s --noproxy '*' -o /dev/null -w '%{http_code}' -H "Authorization: Bearer ${TOKEN}" "${API}/api/auth/me")"; [ "$code" = "401" ] && echo 0 || echo 1)"
+    # 轮换后要重新登录，否则后面的用例会带着失效 token 跑
+    TOKEN="$(login "$ADMIN_PASSWORD")"
+    check "轮换后重新登录成功" "$([ -n "$TOKEN" ] && echo 0 || echo 1)"
+  fi
+fi
+
+# ---------------------------------------------------------------- 8. 升级 / 回滚
+
+if [ "$DO_FULL" = "1" ]; then
+  section "upgrade / rollback（--full）"
+  if [ -z "$PACKAGE" ]; then
+    note "未提供 --package，跳过升级用例"
+  else
+    before_version="$("$CLASSHELPER" version 2>/dev/null | awk '{print $2}')"
+    sha="$(sha256sum "$PACKAGE" | awk '{print $1}')"
+    up_out="$("$CLASSHELPER" upgrade --url "$PACKAGE" --sha256 "$sha" --force 2>&1)"
+    check "upgrade 执行成功" "$(printf '%s' "$up_out" | grep -q '升级完成' && echo 0 || echo 1)"
+    check "升级后服务仍就绪" "$("${CURL[@]}" -o /dev/null "${API}/healthz" && echo 0 || echo 1)"
+    check "升级后配置未被改动（JWT_SECRET 保持）" \
+      "$([ "$(read_cfg JWT_SECRET)" = "${new_secret:-$(read_cfg JWT_SECRET)}" ] && echo 0 || echo 1)"
+    check "产生了程序快照（可回滚）" "$(ls -1 "${BACKUP_DIR}/rollback" 2>/dev/null | grep -q . && echo 0 || echo 1)"
+    check "坏包被拒绝（sha256 不匹配时不改动任何文件）" \
+      "$("$CLASSHELPER" upgrade --url "$PACKAGE" --sha256 0000000000000000000000000000000000000000000000000000000000000000 2>&1 | grep -q '校验失败' && echo 0 || echo 1)"
+    check "校验失败后服务仍在运行" "$("${CURL[@]}" -o /dev/null "${API}/healthz" && echo 0 || echo 1)"
+
+    note "（回滚需要交互确认，这里用 yes 管道）"
+    rb_out="$(printf 'yes\n' | "$CLASSHELPER" rollback 2>&1)"
+    check "rollback 执行成功" "$(printf '%s' "$rb_out" | grep -qE '已回滚到|回滚' && echo 0 || echo 1)"
+    check "回滚后服务仍就绪" "$("${CURL[@]}" -o /dev/null "${API}/healthz" && echo 0 || echo 1)"
+    note "升级前版本 ${before_version}｜升级后 $("$CLASSHELPER" version 2>/dev/null | awk '{print $2}')"
+  fi
+fi
+
+# ---------------------------------------------------------------- 结果
+
+printf '\n'
+if [ "$FAIL" = "0" ]; then
+  printf '%s=== 结果：%s/%s 项通过 ===%s\n' "$G" "$PASS" "$TOTAL" "$N"
+else
+  printf '%s=== 结果：%s/%s 项通过，%s 项失败 ===%s\n' "$R" "$PASS" "$TOTAL" "$FAIL" "$N"
+  printf '%s失败项：%s\n' "$Y" "$N"
+  for item in "${FAILED[@]}"; do printf '  · %s\n' "$item"; done
+fi
+[ "$FAIL" = "0" ] || exit 1

docs/linux-deploy.md

@@ -0,0 +1,560 @@
+# Linux 部署与运维指南
+
+本文覆盖服务端在 Linux 上的**一键安装**与日常运维（`classhelper` 命令）。
+适用：Ubuntu 20.04+ / Debian 11+ / CentOS 7+ / Rocky Linux / AlmaLinux 8+（自动识别 apt / yum / dnf）。
+
+不想看长文的话，最短路径就是这**一行**（在服务器上执行）：
+
+```bash
+curl -fsSL -o /tmp/classhelper-install.sh https://raw.githubusercontent.com/LoveChengke/ClassHelper/master/deploy/install.sh && sudo bash /tmp/classhelper-install.sh
+```
+
+它自己会把整套流程走完：识别发行版 → 补依赖 → 建系统用户 → **从 GitHub Release 取最新版服务端包
+并校验发布页上的 `.sha256`** → 下载内置 Node 运行时 → 建库建号 → 装成 systemd 服务。装完直接：
+
+```bash
+sudo classhelper status
+```
+
+参数接在最后即可，例如先只体检（不需要 root、不改动系统）：
+
+```bash
+curl -fsSL -o /tmp/classhelper-install.sh https://raw.githubusercontent.com/LoveChengke/ClassHelper/master/deploy/install.sh && bash /tmp/classhelper-install.sh --check
+```
+
+> **别写成 `bash -c "$(curl …)" --check`**：`bash -c '代码' 第一个参数` 里那个参数会变成 `$0`，
+> 不是 `$1` —— 脚本收不到它（实测踩到：本意是体检，结果走进了交互式安装）。
+> 先落盘再执行没这个坑，也不会因为下载中断而执行到半个脚本。
+
+以下是"已有安装包 / 内网离线"的用法：
+
+```bash
+sudo bash install.sh --package /path/to/classhelper-server-linux-x64-1.1.2.tar.gz
+sudo classhelper status
+```
+
+---
+
+## 1. 三种形态怎么选
+
+| 形态 | 适合 | 命令 | 说明 |
+| --- | --- | --- | --- |
+| **直接安装（native）** | 有一台 Linux 服务器/Mini 主机，单机跑 | `install.sh` 选 1 | systemd 管理，自带 Node 运行时，SQLite 或 MySQL |
+| **直接安装 + MySQL** | 多终端共享数据、已有 MySQL | `install.sh` 选 2 | 连接串写在配置里；库要先建好 |
+| **Docker** | 机器上已有 Docker、想与其他服务隔离 | `install.sh` 选 3 | 用安装包里随带的 Dockerfile 构建镜像 + compose 起容器 |
+
+> 只想先看看这台机器能不能装：`bash install.sh --check`（**不需要 root**，不改动任何东西）。
+> Windows 机器用服务端安装包（`pnpm dist:server` 的产物），不需要本文。
+
+---
+
+## 2. 安装包从哪来
+
+Linux 安装包命名固定为：
+
+```
+classhelper-server-linux-x64-<版本>.tar.gz          ← install.sh / classhelper upgrade 都认这个名字
+classhelper-server-linux-x64-<版本>.tar.gz.sha256   ← 旁边那份校验值
+```
+
+它发布在 [GitHub Releases](https://github.com/LoveChengke/ClassHelper/releases) 上。
+
+**为什么 Linux 包要单独出一个**：`@libsql/linux-x64-gnu`、`@prisma/adapter-libsql` 这些依赖是平台相关的，
+Windows 开发机上 `npm install` 出来的 `node_modules` 拷到 Linux 跑不起来，因此 Linux 包必须在 Linux 上构建。
+仓库里的 [`.github/workflows/release-linux-server.yml`](../.github/workflows/release-linux-server.yml)
+就是干这个的（拿 ubuntu runner 跑 `pnpm dist:server:linux`，再把产物挂到对应 Release 上）：
+
+1. 本地照惯例发 Windows 包的 Release（tag 形如 `v1.1.2`）；
+2. GitHub → Actions → 「发布 Linux 服务端安装包」→ Run workflow → 填 tag → 运行；
+3. 跑完 Release 里会多出 Linux 包与更新后的 `SHA256SUMS-<版本>.txt`。
+
+内网离线分发也可以：在能上网的机器上 `pnpm dist:server:linux`，把 tar.gz 拷进去，
+用 `install.sh --package /path/to/xxx.tar.gz --sha256 <哈希>` 安装。
+
+### 没有 Linux 机器时（交叉构建）
+
+`pnpm dist:server:linux` 在非 Linux 上也**能跑**：脚本会用 npm 的 `--os=linux --cpu=x64`
+按目标平台解析可选依赖，所以 `@libsql/linux-x64-gnu` 这些"按平台分发"的包会被正确装进来。
+适合本地快速打一个包去验证安装与运维流程。已核对过的结论：
+
+| 项 | 结论 |
+| --- | --- |
+| SQLite 驱动 | ✅ 包内是 `@libsql/linux-x64-gnu` + `linux-x64-musl`，**没有任何 win32 残留** |
+| 服务端本体 | ✅ Node + libsql + express + socket.io 都是纯 JS 或已就位的 Linux 原生包 |
+| 运维命令 | ✅ `status` / `doctor` / `password` / `backup` / `upgrade` / `rollback` 都不依赖平台差异 |
+| Web 端「一键切换数据库」 | ⚠ **可能失败**：这条链路要调 prisma CLI 的 schema engine，CLI 在运行期按平台扫 `@prisma/engines/schema-engine-debian-openssl-3.0.x` 这类路径，而交叉包里只有宿主平台的 `schema-engine-windows.exe` |
+
+所以交叉包**能装、能跑、能验收**，只是那一个 Web 端功能存疑 —— 它会在包内写入 `.cross-built` 标记，
+`classhelper doctor` 会据此提示你（不会静默）。**正式发布一律用 GitHub Actions 那条路。**
+
+```bash
+# 开发机（Windows 也可以）
+pnpm dist:server:linux
+# → releases/server/<版本>/linux-x64/classhelper-server-linux-x64-<版本>.tar.gz（+ .sha256）
+#   重跑很快：node scripts/dist-server.mjs --platform linux --reuse-deps（复用已装的 node_modules）
+```
+
+---
+
+## 3. 一键安装
+
+### 3.1 交互式（推荐第一次用）
+
+```bash
+sudo bash install.sh
+```
+
+TUI 会依次问：形态 → 安装目录 → 端口 → 数据库 → 初始管理员密码 → 是否要 Nginx 配置 / 放行防火墙。
+每一问都有默认值，直接回车即可。
+
+### 3.2 非交互（自动化 / 批量部署）
+
+```bash
+# 全部默认：/opt/classhelper、4000 端口、SQLite、内置 Node
+sudo bash install.sh --yes --package ./classhelper-server-linux-x64-1.1.2.tar.gz
+
+# 指定目录与端口，从 stdin 传初始管理员密码（不进 argv / shell history）
+printf '%s\n' 'MyStrongPass!2026' | sudo bash install.sh --yes \
+  --dir /srv/classhelper --port 8080 --admin-password-stdin \
+  --package ./classhelper-server-linux-x64-1.1.2.tar.gz
+
+# MySQL 形态
+sudo bash install.sh --yes --database mysql --mysql-host 10.0.0.5 --mysql-db classhelper \
+  --mysql-user classhelper --mysql-password-stdin \
+  --package ./classhelper-server-linux-x64-1.1.2.tar.gz <<< 'MySQL密码'
+```
+
+完整参数见 `bash install.sh --help`。要点：
+
+| 参数 | 作用 |
+| --- | --- |
+| `--package <url｜file://路径>` | 安装包地址（默认从 GitHub Release 取最新版） |
+| `--sha256 <哈希>` | 强制校验安装包哈希 |
+| `--admin-password-stdin` | 从 stdin 读一行作为初始管理员密码 |
+| `--node-source bundled｜system｜tarball` | 内置 Node / 系统 Node / 指定压缩包 |
+| `--node-mirror <url>` | Node 下载镜像（默认 `https://npmmirror.com/mirrors/node`） |
+| `--node-tarball <url｜路径>` | 内网离线时直接用本地 Node 包 |
+| `--with-nginx` / `--open-firewall` | 顺带生成反代配置 / 放行端口 |
+| `--yes` | 全默认、不再交互 |
+| `--check` | 只体检（无需 root） |
+| `--force` | 覆盖已有配置；在无 systemd 的机器上只铺文件不装服务 |
+
+**幂等性**：重复执行就是覆盖安装。已有的 `config.env`（含 `JWT_SECRET`）与 `data/` 一律保留，
+用户不会被踢下线；端口与数据库形态也沿用旧配置，不会被改回默认值。
+
+### 3.3 安装器做了什么
+
+1. 识别发行版与包管理器，补齐 `curl / tar / gzip / ca-certificates`（只装缺的）；
+2. 创建系统用户与组 `classhelper`（`--system`，nologin）；
+3. 建目录、收权限（见下一节）；
+4. 下载安装包 → 校验 sha256 → 解压铺文件；
+5. 下载 Node（默认走 npmmirror 镜像，从 `SHASUMS256.txt` 同时取版本号与哈希）；
+6. 生成 `/etc/classhelper/config.env`（随机 `JWT_SECRET`，权限 600）；
+7. 装 systemd 单元、`/usr/local/bin/classhelper`、`/etc/profile.d/classhelper.sh`、logrotate；
+8. 启动服务并轮询 `/healthz`，通过后才算安装成功；
+9. 全过程写 `/var/log/classhelper/install.log`。
+
+### 3.4 Docker 形态
+
+`install.sh` 选 3（或 `--mode docker`）：用安装包里随带的 `Dockerfile` 直接构建镜像
+（包的 `node_modules` 已经是 linux 的真实目录，**构建时不需要联网装依赖**，几十秒出镜像），
+然后写一份 `/etc/classhelper/compose.yml` 拉起容器。
+
+```bash
+classhelper status          # 走 docker compose ps / logs
+classhelper restart         # 重建容器
+classhelper password admin  # 通过 docker exec 在容器里执行同一份 admin-cli
+classhelper backup          # 容器内做一致性快照再取出来
+```
+
+Docker 形态与直接安装的差异：
+
+| | 直接安装 | Docker |
+| --- | --- | --- |
+| 数据位置 | `<安装目录>/data` | Docker 卷 `classhelper-data` |
+| 配置 | `/etc/classhelper/config.env`（systemd 注入） | 同一份文件（compose `env_file`） |
+| 升级 / 回滚 | 替换程序文件后重启服务 | 同一套流程：替换构建上下文 → 重建镜像（`classhelper-server:local`）→ `compose up -d --force-recreate` |
+| 恢复数据 | `classhelper backup restore <目录>` | 需手工 `docker cp` 回容器（命令里有提示） |
+| `backup schedule` | 支持（systemd timer） | 用宿主机 cron 调 `classhelper backup --quiet` |
+
+> Docker 形态的镜像用**稳定标签** `classhelper-server:local`（另打一个 `classhelper-server:<版本>` 便于追溯）。
+> 版本号写在 compose 里的话，升级替换完程序文件后那个标签就过期了，`compose up` 会一直沿用旧镜像 ——
+> 表现为"升级成功但行为没变"。`classhelper` 自己按 `VERSION` 决定要不要重建镜像。
+
+---
+
+## 4. 目录、权限与配置
+
+```
+/opt/classhelper/                 安装目录（--dir 可改）
+├── server/                       后端程序（入口 server/dist/index.js）
+│   ├── dist/  prisma/            产物 + 迁移 SQL（首启动 AUTO_MIGRATE 自动执行）
+│   ├── prisma.config.ts  tsconfig.generate.json    数据库「一键切换」用
+├── web/                          Web 管理端（由后端托管）
+├── node_modules/                 生产依赖（真实目录，非软链）
+├── tools/admin-cli.mjs           离线改密 / 数据库快照工具
+├── bin/classhelper               运维命令本体（/usr/local/bin/classhelper 软链到它）
+├── runtime/node/                 内置 Node 运行时
+├── systemd/ logrotate.d/ profile.d/   模板（安装时拷到 /etc 下）
+├── Dockerfile                    Docker 形态构建用
+├── data/                         数据库 + Web 端自建快照（备份就是拷这里）
+├── logs/                         预留
+├── VERSION                       当前版本
+├── .installed.json               安装元数据（形态/版本/端口，classhelper 靠它决策）
+└── .env  →  /etc/classhelper/config.env    （软链，见下）
+
+/etc/classhelper/                 目录 700，属主 classhelper
+└── config.env                    配置文件，**权限 600**，唯一真身
+/var/log/classhelper/             安装日志 install.log + 审计日志 audit.log
+/var/backups/classhelper/         备份 + 程序快照（回滚用）
+```
+
+### 4.1 为什么安装目录里的 `.env` 是软链
+
+Web 端「数据库管理 → 一键切换数据库」在运行中改写的是 **`<安装目录>/.env`**
+（`packages/server/src/modules/database/database.service.ts`），而 systemd 是通过
+`EnvironmentFile=/etc/classhelper/config.env` 注入环境变量的。dotenv 不覆盖已存在的环境变量 →
+如果这两处不是同一份文件，**切换看起来成功、重启后又连回旧库**。
+
+所以安装器把 `<安装目录>/.env` 做成指向 `config.env` 的软链：两种读法落到同一个真身。
+`classhelper doctor` 会专门检查这条软链，别手工删掉。
+
+### 4.2 配置项
+
+配置就是一份 `KEY=VALUE` 的 env 文件，systemd / dotenv / `source` 三种读法都兼容
+（含空白或 `#` 的值请加双引号）。最常见的几项：
+
+| KEY | 默认 | 说明 |
+| --- | --- | --- |
+| `PORT` / `HOST` | `4000` / `0.0.0.0` | 监听端口与地址 |
+| `DATABASE_PROVIDER` | `sqlite` | `sqlite` 或 `mysql` |
+| `DATABASE_URL` | `file:../data/classhelper.db` | SQLite 相对 `<安装目录>/server` 解析；MySQL 是连接串 |
+| `JWT_SECRET` | 随机 | 登录令牌签名密钥。**换掉＝所有用户重新登录**（`classhelper key rotate`） |
+| `JWT_EXPIRES_IN` | `7d` | 令牌有效期 |
+| `CORS_ORIGIN` | `*` | 走域名/反代时建议收敛成 `https://你的域名` |
+| `TRUST_PROXY` | `1` | 前面有 Nginx 时保持 1，限流才按真实 IP 统计 |
+| `AUTO_MIGRATE` | `true` | 空库首启动自动建表 + 建管理员 |
+| `INITIAL_ADMIN_USERNAME` / `INITIAL_ADMIN_PASSWORD` | `admin` / `admin123` | **只在空库首次初始化时生效**，之后改密码用 `classhelper password` |
+| `DEFAULT_CLASS_PASSWORD` / `DEFAULT_TEACHER_PASSWORD` | `123456` | 新建班级 / 重置教师时的初始密码 |
+| `TERM_START_DATE` | 空 | 第 1 教学周的周一（`YYYY-MM-DD`），影响"当前周次" |
+
+改配置的三种方式（都会先自动备份、改完问你是否重启）：
+
+```bash
+sudo classhelper config show                 # 敏感值打码查看
+sudo classhelper config get PORT
+sudo classhelper config set CORS_ORIGIN https://class.example.com   # 敏感项会改成交互输入
+sudo classhelper config edit                 # 用 $EDITOR 直接编辑
+sudo classhelper port 8080                   # 改端口的快捷方式
+```
+
+> 手工改也可以（`vim /etc/classhelper/config.env`），但记得改完 `classhelper restart`，
+> 并确认权限仍是 600。
+
+---
+
+## 5. `classhelper` 运维命令
+
+安装后可直接使用（`/usr/local/bin/classhelper`）。除 `help` / `version` / `completion` 外都需要 root。
+
+### 5.1 查看与诊断
+
+```bash
+classhelper status              # 服务状态、版本、端口、数据库、各类路径
+classhelper status --json       # 同上，机器可读（接监控用）
+classhelper doctor              # 完整体检：权限 / Node / 服务单元 / 探针 / 数据库 / 磁盘 / 备份
+classhelper logs -f             # 实时日志（= journalctl -u classhelper -f）
+classhelper logs -n 200 --since "1 hour ago"
+classhelper logs --unit classhelper-backup     # 看定时备份的日志
+```
+
+`doctor` 会把每一项标成 `✔` / `✘`，失败项后面直接跟修复建议，例如：
+
+```
+  ✘ 安装目录 .env 是指向配置真身的软链
+  ✔ Node 运行时可用且 ≥20.19（v22.20.0）
+  ✘ 最近 7 天内有备份（无）
+建议依次处理：
+  · ln -sfn /etc/classhelper/config.env /opt/classhelper/.env（Web 端「一键切换数据库」依赖它）
+  · classhelper backup；长期可用 classhelper backup schedule daily
+```
+
+### 5.2 改密码
+
+```bash
+sudo classhelper password                 # 改 admin
+sudo classhelper password teacher1        # 改指定教师
+sudo classhelper password --list          # 列出可登录账号与班级账号（含是否已设密码）
+sudo classhelper password --class G101    # 改某个班的班级密码（学生端登录用）
+```
+
+安全约定（照要求逐条落实）：
+
+- 密码**交互输入、不回显**；不接受命令行传参，因此不会进 shell history、也不出现在 `ps` 里；
+- 强度校验：≥8 位，小写/大写/数字/符号至少 3 类，不得与用户名相同，常见弱口令直接拒绝；
+  需二次确认，连续 3 次不合规即退出（密码不变）；
+- 改前把**原密码哈希**备份到 `/var/backups/classhelper/password-<时间戳>.json`（权限 600），
+  写入失败或写入后复核不通过会**自动回滚**原哈希；
+- 全过程写审计日志，**审计里只有"谁对谁做了什么、结果如何"，没有密码**；
+- 自动化可以用管道传入（仍不进 history）：
+
+```bash
+printf '%s\n%s\n' "$NEW_PW" "$NEW_PW" | sudo classhelper password admin
+```
+
+> 顺带说明：改密码不需要重启服务（登录时读库校验）；已登录的会话仍有效，
+> 要让所有会话立刻失效用 `classhelper key rotate`。
+
+### 5.3 备份与恢复
+
+```bash
+sudo classhelper backup                       # 备份配置 + 数据库
+sudo classhelper backup --note "升级前" --keep 7
+sudo classhelper backup list
+sudo classhelper backup restore 20261005-033000       # 用某个备份覆盖当前配置与数据（会先停服务）
+sudo classhelper backup schedule daily        # 每天 03:30 自动备份（systemd timer，保留 7 份）
+sudo classhelper backup schedule off
+```
+
+- 备份落在 `/var/backups/classhelper/<时间戳>[-说明]/`：`config.env` + `classhelper.db` + `meta.json`，
+  目录 700、文件 600；
+- SQLite 用 `VACUUM INTO` 做**一致性快照**（服务在跑也安全，比直接 `cp` 可靠）；
+- MySQL 用 `mysqldump --single-transaction`（密码经 `MYSQL_PWD` 传给子进程，不进 argv）；
+- `restore` 前会先自动备份现状，恢复对象是配置与数据（不是程序）；
+- 程序文件快照（回滚用）在 `/var/backups/classhelper/rollback/`，是另一类东西，`backup list` 会分开列。
+
+### 5.4 升级与回滚
+
+```bash
+sudo classhelper upgrade --check          # 只检查有没有新版本（查 GitHub Release）
+sudo classhelper upgrade                  # 升到最新版
+sudo classhelper upgrade --version 1.2.0  # 升到指定版本
+sudo classhelper upgrade --url ./classhelper-server-linux-x64-1.0.1.tar.gz --sha256 <哈希>   # 内网离线
+sudo classhelper upgrade --url <包> --force        # 强制重装同一版本
+
+sudo classhelper rollback --list          # 看有哪些程序快照
+sudo classhelper rollback                 # 回滚到最近一份（会问一次确认）
+```
+
+`upgrade` 的完整链路（任一步失败都不改动程序文件）：
+
+```
+解析目标版本 → 下载 → 校验 sha256 → 备份数据与配置 → 快照当前程序文件 →
+停服 → 替换程序文件（mv 原子替换，data/ 配置/ 运行时原地不动）→ 起服 → 轮询 /healthz
+   ↘ 失败：自动用刚才的快照回滚并重新起服，再告诉你失败原因
+```
+
+两点必须知道：
+
+1. **升级不会回滚数据库结构**。如果新版执行过迁移，回滚程序前要确认旧版还能读新库，
+   必要时用 `classhelper backup restore` 连数据一起回退；
+2. 替换程序文件用的是"改名 + 就位"而不是删除重写 —— 升级时正在运行的就是 `bin/classhelper` 自己，
+   必须先改名再放新文件，运行中的进程继续读旧 inode，否则会读到半个脚本。
+
+### 5.5 服务与配置
+
+```bash
+sudo classhelper start | stop | restart | reload    # reload 与 restart 同义（服务端不支持热重载）
+sudo classhelper port                               # 看当前端口
+sudo classhelper port 8080                          # 改端口（顺带提示放行防火墙）
+sudo classhelper config show [--reveal]
+sudo classhelper config set KEY VALUE
+sudo classhelper key rotate                         # 轮换 JWT_SECRET（所有用户需重新登录）
+```
+
+### 5.6 其它
+
+```bash
+classhelper version
+classhelper help
+source <(classhelper completion bash)     # 补全（安装时已装到 /usr/share/bash-completion）
+```
+
+### 5.7 卸载
+
+```bash
+sudo classhelper uninstall
+```
+
+会依次问：保留配置？保留数据？保留备份？默认全部保留 —— 数据与配置会被**搬到**
+`/var/backups/classhelper/uninstall-<时间戳>/`，然后才删除程序目录，不会悄悄丢数据。
+
+```bash
+sudo classhelper uninstall --yes      # 不问，用默认（保留配置/数据/备份）
+sudo classhelper uninstall --purge    # 全删（含备份与数据），不可恢复
+```
+
+---
+
+## 6. 环境变量文件
+
+安装器会写 `/etc/profile.d/classhelper.sh`（内容见
+[`deploy/profile.d/classhelper.sh`](../deploy/profile.d/classhelper.sh)）：
+
+```sh
+export CLASSHELPER_HOME=/opt/classhelper
+export CLASSHELPER_CONFIG=/etc/classhelper/config.env
+export CLASSHELPER_LOG_DIR=/var/log/classhelper
+export CLASSHELPER_BACKUP_DIR=/var/backups/classhelper
+export PATH=$PATH:$CLASSHELPER_HOME/bin
+```
+
+新登录的 shell 自动生效；当前会话要手工 `source /etc/profile.d/classhelper.sh`。
+`classhelper` 命令本身装在 `/usr/local/bin`（软链），所以**不登录也照样能用**。
+
+---
+
+## 7. 反向代理与 HTTPS（公网部署必做）
+
+```bash
+sudo bash install.sh --with-nginx     # 或者安装后手工：
+sudo cp deploy/nginx.conf /etc/nginx/conf.d/classhelper.conf
+```
+
+要点：
+
+- `client_max_body_size 12m`（表格导入最大 8MB，base64 后约 11MB）；
+- Socket.IO 需要 `Upgrade` / `Connection` 头与较长的 `proxy_read_timeout`（模板里已配）；
+- 配置里保持 `TRUST_PROXY=1`，并把 `CORS_ORIGIN` 收敛成你的域名；
+- 证书用 certbot 或你自己的证书，装好后 `nginx -t && nginx -s reload`。
+
+---
+
+## 8. 故障排查
+
+| 现象 | 先查什么 |
+| --- | --- |
+| 服务起不来 | `classhelper doctor` → `classhelper logs -n 100`。常见：端口被占用、MySQL 连接串错、`data/` 权限 |
+| 装完打不开页面 | `classhelper status` 看探针与监听地址；云服务器还要在**安全组**放行端口 |
+| 页面能打开但是**空白** | 1.1.0 的服务端在 HTTP 直连访问时会下发 CSP `upgrade-insecure-requests`，浏览器把所有子资源改写成 https 加载而服务器没有 TLS，于是整页空白（HTML/接口都正常）。已修复的版本按请求协议条件下发；若暂不能升级，唯一正解是上 HTTPS 反代 |
+| 改了配置没生效 | 是否重启过（`classhelper config set` 会问）；`EnvironmentFile` 的值优先于文件里的同项 |
+| Web 端切库后还是连旧库 | `classhelper doctor` 看 `.env` 软链是否被破坏（`ln -sfn /etc/classhelper/config.env <安装目录>/.env`） |
+| 升级卡住/失败 | 失败会自动回滚；看 `classhelper logs -n 100`，确认磁盘余量 ≥1GB |
+| `classhelper` 命令找不到 | `ls -l /usr/local/bin/classhelper`；被删了就重装或 `ln -sfn <安装目录>/bin/classhelper /usr/local/bin/classhelper` |
+| 忘记管理员密码 | `sudo classhelper password admin`（直连数据库，不需要登录） |
+| 学生端连不上 | 客户端「服务器地址」填 `http://IP:端口` 或域名；确认没有多余路径与斜杠 |
+| CentOS 7 装完立刻退出 | glibc < 2.28，见下面的"已知限制" |
+
+---
+
+## 9. 已知限制
+
+### CentOS 7 / glibc < 2.28
+
+Node 官方的 linux-x64 二进制要求 **glibc ≥ 2.28**，而 CentOS 7 是 2.17 —— 直接装官方包会表现成
+"装完服务立刻退出、日志里什么也没有"。安装器会自动检测 glibc，低于 2.28 时改用
+[unofficial-builds](https://unofficial-builds.nodejs.org/) 的 **glibc-217** 构建（功能一致，只是编译基线更低）。
+
+但即便这样，个别原生依赖仍可能不兼容，CentOS 7 支持属于**尽力而为**：
+
+- CentOS 7 已于 2024-06 EOL，**新部署请用 Rocky Linux 9 / AlmaLinux 9 / Ubuntu 22.04+**；
+- 若坚持用 CentOS 7，建议装完立刻跑一遍 `classhelper doctor` 与本文第 10 节的验收清单。
+
+### 其它
+
+- 直接安装形态要求 **systemd**（容器里没有 `/run/systemd/system` 时会明确拒绝；
+  容器场景请用 Docker 形态）。
+- Docker 形态的数据恢复需要手工 `docker cp`（数据在容器卷里，宿主机上看不到那个文件）；
+  `classhelper backup restore` 会给出具体命令。
+- `classhelper reload` 等价于 restart（服务端没有 SIGHUP 处理）。
+- 升级包只发 x64；arm64 需要自行构建（`node scripts/dist-server.mjs --platform linux` 跑在 arm64 机器上）。
+
+---
+
+## 10. 验收清单
+
+下面这套在干净的 **Ubuntu 22.04** 与 **Rocky Linux 9** 上各跑一遍。
+`deploy/verify-linux.sh` 会把第 3~8 步自动跑完并打印 `=== 结果：N/N 项通过 ===`。
+
+### 10.0 准备
+
+```bash
+# 在开发机：做出 Linux 包（或在 Actions 里下载）
+pnpm dist:server:linux
+scp releases/server/*/linux-x64/classhelper-server-linux-x64-*.tar.gz root@<服务器>:/tmp/
+scp deploy/install.sh deploy/verify-linux.sh root@<服务器>:/tmp/
+```
+
+### 10.1 体检（不需要 root）
+
+```bash
+bash /tmp/install.sh --check
+```
+
+期望：系统/包管理器/glibc/docker/端口/磁盘逐项列出，末尾「体检通过」。
+端口被占用、缺 curl、没有 systemd 都会在这里被点出来。
+
+### 10.2 安装
+
+```bash
+sudo bash /tmp/install.sh --yes \
+  --package /tmp/classhelper-server-linux-x64-1.1.2.tar.gz \
+  --admin-password-stdin <<< 'Verify-Pass-2026!'
+```
+
+期望：末尾出现「安装完成」与「服务已就绪 ✅」，并打印管理端地址。
+
+### 10.3 自动验收
+
+```bash
+sudo bash /tmp/verify-linux.sh --admin-password-stdin <<< 'Verify-Pass-2026!'
+```
+
+覆盖项：
+
+| 分组 | 检查内容 |
+| --- | --- |
+| 安装结果 | 程序文件、`VERSION`、`.installed.json`、`config.env` 600、配置目录 700、`.env` 软链、内置 Node、`/usr/local/bin/classhelper`、安装/审计日志、profile.d 生效 |
+| 服务 | systemd 单元、active、enabled、`/healthz` 200、`status --json` 合法且 healthy |
+| 体检 | `classhelper doctor` 无待处理项、`help` / `completion` 可用 |
+| API | 用初始密码登录拿 token、带 token 读 `/api/classes` 与 `/api/auth/me` |
+| 改密 | 改密成功 → 新密码可登录 → **旧密码被拒** → 原哈希已备份且 600 → 审计有记录且**不含密码明文** → 弱密码被拒 → stdin 结束不卡死 → `restore-hash` 把原密码回滚回来 |
+| 备份 | 备份目录/文件/权限、SQLite 快照是合法库文件、`backup list` |
+| 配置 | `config get/show`、敏感值打码、读写往返 |
+| key rotate | 密钥确实变了且 ≥32 位、服务仍可用、**旧 token 变 401**、重新登录成功 |
+
+追加升级/回滚链路（会真的替换一次程序文件）：
+
+```bash
+sudo bash /tmp/verify-linux.sh --full --package /tmp/classhelper-server-linux-x64-1.0.1.tar.gz \
+  --admin-password-stdin <<< 'Verify-Pass-2026!'
+```
+
+覆盖：升级成功 → 服务恢复 → 配置未被改动 → 产生程序快照 → **坏哈希被拒绝且服务不受影响** →
+`rollback` 回到旧版且服务可用。
+
+### 10.4 手工补验（自动化覆盖不到的）
+
+```bash
+# ① 浏览器打开 http://<IP>:4000/ ，用 admin 登录，改一次密码再登录
+# ② 学生端客户端填 http://<IP>:4000 用班级码 G101/123456 登录，收到一条老师发的通知
+# ③ 重跑安装器（幂等性）：sudo bash /tmp/install.sh --yes --package <同一个包>
+#    期望：配置与数据保留、JWT_SECRET 不变（已登录用户不被踢下线）
+# ④ 卸载：sudo classhelper uninstall --yes
+#    期望：服务停止、单元删除、/usr/local/bin/classhelper 消失、
+#         数据与配置被搬到 /var/backups/classhelper/uninstall-*/
+# ⑤ 重启机器后服务自动起来（systemctl is-enabled classhelper）
+```
+
+### 10.5 Rocky 9 的差异点
+
+- 包管理器走 `dnf`，依赖包名与 apt 不同（`install.sh` 已按 `PKG` 分支处理）；
+- 默认没有 `curl` 之外的工具时会被补装，注意首次安装需要能访问 dnf 源；
+- 防火墙默认是 `firewalld`：用 `--open-firewall` 或手工
+  `firewall-cmd --add-port=4000/tcp --permanent && firewall-cmd --reload`；
+- SELinux（Enforcing）：服务读写 `/opt/classhelper` 与 `/etc/classhelper` 一般不受影响，
+  若日志里出现 `Permission denied` 且路径正常，先 `ausearch -m avc -ts recent` 看是不是 SELinux，
+  可以用 `semanage fcontext` 加规则，或临时 `setenforce 0` 验证判断。
+
+---
+
+## 11. 安全清单
+
+- [ ] 改掉默认管理员密码：`classhelper password admin`（**公网部署第一件事**）
+- [ ] 公网服务前面加 Nginx + HTTPS，`CORS_ORIGIN` 收敛到具体域名
+- [ ] 定期备份：`classhelper backup schedule daily`，并确认备份能恢复（`backup restore` 演练一次）
+- [ ] 配置与备份权限：`config.env` 600、`/etc/classhelper` 700、备份目录 700
+- [ ] `classhelper doctor` 无待处理项；关注"最近 7 天内有备份"
+- [ ] 审计日志（`/var/log/classhelper/audit.log`）随日志轮转保留，必要时接集中日志
+- [ ] 只在需要时使用 `--purge`；卸载默认保留数据与备份
+- [ ] 升级包一律校验 sha256（`upgrade` 内网分发时也要带 `--sha256`）

docs/mysql.md

@@ -19,28 +19,62 @@ MySQL 兼容方式设计，可平滑切换到云端 MySQL / MariaDB 统一存储
 | 唯一约束仅使用 `@@unique` / `@unique` | SQLite 与 MySQL 语义一致                                                                                                          |
 | 级联删除使用 Prisma 的 `onDelete`     | 由 Prisma 生成对应外键动作                                                                                                        |
 
-## 切换步骤
+## 切换到 MySQL
 
-### 1. 修改 provider
+### 方式一：Web 管理端「数据库管理 → 一键切换」（推荐，v1.0.0 新增）
+
+管理员在 Web 管理端打开 **数据库管理** 页（`/database`，仅 ADMIN 可见），在「一键切换数据库」卡片里：
+
+1. 选目标类型（SQLite ⇄ MySQL）并填**空库**连接串（有表的库会被拒绝，防误覆盖）；
+2. 输入「确认迁移」→ 点「开始迁移」。
+
+界面会自动依次执行（带步骤进度条）：
+
+1. **备份当前数据库**（gzip JSON 快照存 `<数据目录>/backups/`，失败可回滚）；
+2. 导出当前数据为快照；
+3. 测试目标库连接；
+4. 检查目标库为空；
+5. 改写 `schema.prisma` 的 provider；
+6. 子进程 `prisma generate` 生成新方言的 Prisma 客户端；
+7. （打包形态）把生成的 `.ts` 客户端编译进 `dist/generated`；
+8. 子进程 `prisma db push` 在目标库建表；
+9. 子进程 `dist/tools/apply-snapshot.js` 把快照写入目标库；
+10. 全部成功后改写 `.env` 的 `DATABASE_PROVIDER` / `DATABASE_URL`。
+
+**完成后必须重启服务端**（安装版运行 `restart.cmd`，开发模式重跑 `pnpm dev:server`）才会连接新库。
+中途任一步失败会**回滚 `schema.prisma`**，`.env` 不被改写 —— 现有数据库与配置保持可用。
+
+> 同一页还提供：连接状态检测（版本 / 体积 / 各表行数）、连接测试、手动与**定时备份**、
+> 备份恢复、快照导出导入、SQLite 数据库文件下载。备份与导入导出共用同一种 JSON 快照格式，
+> 因此**任意备份都能恢复回任意一种受支持的数据库**。
+>
+> 只支持 SQLite 与 MySQL 两种主库：Redis 等键值库不是 Prisma 支持的主数据库（无法建表/迁移），
+> 接口层直接拒绝。
+
+### 方式二：命令行手工切换
+
+#### 1. 修改 provider
 
 ```bash
 # 自动把 prisma/schema.prisma 的 provider 改成 mysql
 node scripts/use-database.mjs mysql
 ```
 
-### 2. 安装 MySQL 驱动适配器
+#### 2. MySQL 驱动适配器（自 v1.0.0 起已随包内置）
 
 Prisma 7 要求所有数据库都通过 driver adapter 接入，MySQL 对应 `@prisma/adapter-mariadb`
-（该适配器基于 `mariadb` 驱动，兼容 MySQL 8）。
+（该适配器基于 `mariadb` 驱动，兼容 MySQL 8）。**它已在 `packages/server/package.json` 的
+依赖里**（数据库管理模块的连接测试/迁移需要），因此无需再手动安装：
 
 ```bash
+# 仅当从旧版本升级、依赖里还没有时才需要
 pnpm --filter @classhelper/server add @prisma/adapter-mariadb
 ```
 
-`packages/server/src/lib/db.ts` 已经内置分支：当 `DATABASE_PROVIDER=mysql` 时会动态加载该适配器，
+`packages/server/src/lib/db.ts` 内置分支：当 `DATABASE_PROVIDER=mysql` 时会动态加载该适配器，
-因此只需要安装依赖 + 配置环境变量，服务端代码无需改动。
+服务端代码无需改动。
 
-### 3. 配置环境变量
+#### 3. 配置环境变量
 
 编辑 `packages/server/.env`：
 
@@ -52,7 +86,7 @@ DATABASE_URL="mysql://classhelper:your-password@127.0.0.1:3306/classhelper"
 > 云端部署时把 `127.0.0.1` 换成云数据库内网/公网地址；
 > 生产环境请同时修改 `JWT_SECRET` 与 `CORS_ORIGIN`。
 
-### 4. 重建迁移并生成客户端
+#### 4. 重建迁移并生成客户端
 
 SQLite 与 MySQL 的 DDL 方言不同，**必须重新生成迁移文件**：
 
@@ -71,7 +105,11 @@ pnpm db:seed
 pnpm --filter @classhelper/server exec prisma migrate dev --create-only --name init_mysql
 ```
 
-### 5. 回到 SQLite
+> 只搬数据、不要演示数据时，用界面的「下载快照 / 导入快照」更省事：
+> 旧库导出 JSON → 切库建表 → 新库导入，一份快照也可用 CLI 迁移：
+> `node server/dist/tools/apply-snapshot.js --provider mysql --url "mysql://..." --file snapshot.json`
+
+#### 5. 回到 SQLite
 
 ```bash
 node scripts/use-database.mjs sqlite
@@ -80,6 +118,8 @@ rm -rf packages/server/prisma/migrations   # 若之前已切换成 MySQL 迁移
 pnpm db:migrate
 ```
 
+> 用界面「一键切换」回 SQLite 时，目标库同样必须是空文件：删除旧 `.db` 或指定一个新路径。
+
 ## 生产部署注意事项
 
 1. **连接池**：Prisma 7 的 driver adapter 使用底层驱动（`mariadb`）的连接池设置，
@@ -88,3 +128,7 @@ pnpm db:migrate
    三端展示时再按本地时区格式化（前端使用 `@classhelper/shared` 的 `formatDate`）。
 3. **迁移部署**：CI/CD 中使用 `prisma migrate deploy`（对应 `pnpm db:deploy`）而不是 `migrate dev`。
 4. **备份**：切换云数据库后，`packages/server/prisma/dev.db` 不再被使用，可从 `.gitignore` 之外移除。
+   界面「定时备份」把快照写进 `<数据目录>/backups/`（MySQL 模式下即安装根 `data/backups/`），
+   **服务端进程不运行时不会补跑**；关键环境建议同时用数据库自带的备份策略。
+5. **安装包体积**：切换链路需要随包内置 `prisma` CLI 与 `typescript` 编译器（Prisma 7 生成器产出
+   `.ts`，切换后需在目标机编译进 `dist/generated`），服务端安装包因此约 34MB → 71MB。

docs/production.md

@@ -4,9 +4,9 @@
 
 | 形态                  | 适用场景                                     | 产物                                                     | 本机验证情况                           |
 | --------------------- | -------------------------------------------- | -------------------------------------------------------- | -------------------------------------- |
-| **A. Windows 安装包** | 学校机房、教师办公电脑（单机即完整系统）     | `release-server/班级小助手服务端-<版本>-x64-setup.exe`   | ✅ 已完整实测（静默安装/启停/卸载/UI） |
+| **A. Windows 安装包** | 学校机房、教师办公电脑（单机即完整系统）     | `releases/server/<版本>/安装包/班级小助手服务端-<版本>-x64-setup.exe` | ✅ 已完整实测（静默安装/启停/卸载/UI） |
 | **B. Docker + MySQL** | 云服务器、多终端共享一套数据（推荐长期方案） | `deploy/Dockerfile` + `deploy/docker-compose.yml`        | ⚠️ 文件已提供，本机无 Docker 未实测    |
-| **C. Linux 原生部署** | 已有 Linux 服务器（systemd + SQLite）        | `deploy/install-linux.sh` + `deploy/classhelper.service` | ⚠️ 脚本已提供，本机无 Linux 未实测     |
+| **C. Linux 原生部署** | 已有 Linux 服务器（systemd，SQLite 或 MySQL） | [`deploy/install.sh`](../deploy/install.sh) + `classhelper` 运维命令             | ⚠️ 本机无 Linux，实机验收见 [linux-deploy.md](linux-deploy.md) §10 |
 | **D. 手动部署**       | 已有 Node 环境的服务器、需要自定义           | `pnpm dist:server` 的免安装目录                          | ✅ 免安装目录已实测（163 项端到端）    |
 
 ---
@@ -23,9 +23,9 @@ pnpm dist:server -- --reuse-deps   # 迭代打包：复用已安装依赖，跳
 产物：
 
 | 路径                                                                    | 说明                                            |
-| ----------------------------------------------------- | ----------------------------------------------- |
+| ----------------------------------------------------------------------- | ----------------------------------------------- |
-| `release-server/classhelper-server/`                  | 免安装目录，可直接拷到任意 Windows x64 机器运行 |
+| `releases/server/<版本>/免安装/`                                        | 免安装目录，可直接拷到任意 Windows x64 机器运行 |
-| `release-server/班级小助手服务端-0.1.0-x64-setup.exe` | 安装程序（约 34 MB，NSIS）                      |
+| `releases/server/<版本>/安装包/班级小助手服务端-<版本>-x64-setup.exe`   | 安装程序（约 62 MB，NSIS）                      |
 
 打包内容：内置 **Node 运行时**（目标机无需安装 Node.js）、后端产物、Web 管理端产物、
 生产依赖（真实目录，非软链）、迁移 SQL、`.env`（随机 JWT 密钥）、启停脚本。
@@ -35,7 +35,7 @@ pnpm dist:server -- --reuse-deps   # 迭代打包：复用已安装依赖，跳
 双击安装程序即可，**无需管理员权限**（当前用户级安装）：
 
 - 安装目录：`%LOCALAPPDATA%\Programs\ClassHelperServer`
-- 静默安装：`"班级小助手服务端-0.1.0-x64-setup.exe" /S`
+- 静默安装：`"班级小助手服务端-1.1.2-x64-setup.exe" /S`
 - 开始菜单：启动服务 / 停止服务 / 重启服务 / 打开管理端 / 使用说明 / 卸载
 - 桌面：`班级小助手服务端.lnk`（打开管理端）
 - 自动加入当前用户开机自启（`HKCU\...\CurrentVersion\Run`）
@@ -125,110 +125,121 @@ docker compose -f deploy/docker-compose.yml --env-file deploy/.env up -d --build
 - 反向代理上启用 HTTPS：见 `deploy/nginx.conf`，并在服务端环境变量中设置
   `TRUST_PROXY=1`、`CORS_ORIGIN=https://你的域名`。
 
+### 2.1 单容器变体（SQLite，推荐给内存小的机器 / 与别的服务共用一台机器）
+
+`deploy/docker-compose.sqlite.yml` 只跑**服务端一个容器**，不额外起 MySQL：数据落在 Docker 卷
+`classhelper-data` 的 `/app/data/classhelper.db`，首次启动由 `AUTO_MIGRATE=true` 自动建表并创建管理员
+（`packages/server/src/lib/db-bootstrap.ts` 的"空数据卷"分支）。
+
+```bash
+cp deploy/.env.sqlite.example deploy/.env.sqlite   # 填 JWT_SECRET、管理员密码、端口
+docker compose -f deploy/docker-compose.sqlite.yml --env-file deploy/.env.sqlite up -d --build
+```
+
+适用场景与注意点：
+
+- 机器内存紧张（比如 2G 小机器上还跑着别的服务）时，比 MySQL 变体少一个数据库进程；
+- 端口用 `SERVER_PORT` 指定，**别抢占 80/443**（那通常是同机反代占用的）；
+- 生产自检会拒绝 `dev.db` 与过短的 `JWT_SECRET`，因此 `DATABASE_URL` 必须是绝对路径且不含 `dev.db`；
+- 备份就是整个卷：`docker run --rm -v classhelper-sqlite_classhelper-data:/data -v "$PWD":/backup alpine tar czf /backup/classhelper-db.tar.gz -C /data .`
+
+> `deploy/Dockerfile` 的构建阶段会先跑 `pnpm --filter @classhelper/server run db:generate`：
+> 生成产物 `packages/server/src/generated/prisma` 是 gitignored 的，而 `--ignore-scripts` 跳过了
+> postinstall，少了这一步 `tsc` 会直接编译失败。
+
 ---
 
-## 三、Linux 原生部署（形态 C，systemd + SQLite）
+## 三、Linux 部署（形态 C，推荐一键安装器）
 
-适用：Ubuntu / Debian / CentOS / Rocky 等有 systemd 的服务器，单机跑一套（SQLite），
+适用：Ubuntu 20.04+ / Debian 11+ / CentOS 7+ / Rocky / AlmaLinux，任何有 systemd 的服务器
-用 Nginx 挂 HTTPS 给校内网/公网访问。
+（容器环境用下面的 Docker 形态）。**完整指南见 [linux-deploy.md](linux-deploy.md)**，这里是速查。
 
-### 3.1 一键脚本（推荐）
+### 3.1 一键安装（推荐）
 
-在**仓库根目录**先构建，然后执行脚本（需要 root）：
+Linux 包由 GitHub Actions 在 ubuntu runner 上构建（平台相关的依赖只能在 Linux 上装），
+产物挂在 Release 上；也可以本地 `pnpm dist:server:linux` 后把 tar.gz 拷到服务器。
+安装器脚本两个文件都在仓库的 `deploy/` 下：
 
 ```bash
-# 1) 构建（Node ≥ 20.19，推荐 22 LTS；目标机没有 pnpm 时可在别的机器上构建后拷仓库过来）
+# 开发机：做出 Linux 包并连同脚本一起拷到服务器
-corepack enable && corepack prepare pnpm@11.8.0 --activate
+pnpm dist:server:linux
-pnpm install
+scp releases/server/*/linux-x64/classhelper-server-linux-x64-*.tar.gz deploy/install.sh deploy/verify-linux.sh \
-pnpm build:shared
+    root@<服务器>:/tmp/
-pnpm --filter @classhelper/server build
-pnpm --filter @classhelper/web-admin build
 
-# 2) 安装成 systemd 服务
+# 服务器上
-sudo bash deploy/install-linux.sh                     # 默认端口 4000、目录 /opt/classhelper
+bash /tmp/install.sh --check            # 只体检（不需要 root，不改动系统）
-# 常用变体：
+sudo bash /tmp/install.sh               # 交互式：选形态 → 选目录 → 选库 → 设初始管理员密码
-#   bash deploy/install-linux.sh --check               # 只体检（不需要 root）：校验构建产物/Node/端口探针
-#   sudo bash deploy/install-linux.sh --port 8080
-#   sudo bash deploy/install-linux.sh --dir /srv/classhelper
-#   sudo bash deploy/install-linux.sh --no-service     # 只铺文件，自己托管进程
-#   sudo bash deploy/install-linux.sh --uninstall      # 停服务并移除 unit（保留 data 与 .env）
 ```
 
-> 建议先跑一次 `--check`：它只读地校验"构建产物齐不齐、Node 版本够不够、目标端口上有没有旧实例"，
+非交互（批量部署 / 验收用）：
-> 不需要 root，也不会改任何东西。输出示例见 `deploy/install-linux.sh` 头部注释。
-
-脚本做的事：建系统用户 `classhelper` → 把后端产物、`prisma/migrations`、Web 管理端拷到
-`/opt/classhelper` → `npm install --omit=dev`（清单就是 `deploy/package.runtime.json`，与
-容器运行时同一份）→ 生成 `.env`（随机 `JWT_SECRET`、`AUTO_MIGRATE=true`）→ 装 systemd unit →
-`enable --now` → 轮询 `/healthz` 就绪后打印地址与初始管理员。
-
-安装后的目录（与已验证的 Windows 免安装目录同构，因此 `.env` 里的相对路径语义一致）：
-
-```
-/opt/classhelper/
-├── .env                  全部配置（权限 600）
-├── server/dist           后端程序（入口 index.js）
-├── server/prisma         迁移 SQL（首启动自动执行）
-├── web/                  Web 管理端（后端托管，单端口）
-├── node_modules/         仅生产依赖
-├── data/                 classhelper.db + server.pid（备份只复制这里）
-└── logs/
-```
-
-首次启动会自动建表并创建管理员 `admin / admin123`（**登录后立刻改密码**）。
-
-### 3.2 手动部署（不想用脚本 / 没有 systemd）
-
-等价的手工步骤，便于排查：
 
 ```bash
-sudo useradd --system --shell /usr/sbin/nologin classhelper
+printf '%s\n' 'StrongPass!2026' | sudo bash /tmp/install.sh --yes \
-sudo mkdir -p /opt/classhelper/{server,web,data,logs}
+  --dir /srv/classhelper --port 8080 --admin-password-stdin \
+  --package /tmp/classhelper-server-linux-x64-1.1.2.tar.gz
+```
 
-# 程序产物
+安装器做的事：识别发行版与包管理器补依赖 → 建系统用户 `classhelper` → 下载包并校验 sha256 →
-sudo cp -R packages/server/dist        /opt/classhelper/server/dist
+铺文件（`server/` `web/` `node_modules/` `tools/` `bin/`）→ 下载内置 Node 运行时 →
-sudo cp -R packages/server/prisma      /opt/classhelper/server/prisma
+写 `/etc/classhelper/config.env`（随机 `JWT_SECRET`，权限 600）→ 装 systemd 单元与
-sudo cp -R packages/web-admin/dist     /opt/classhelper/web
+`/usr/local/bin/classhelper` → 启动并轮询 `/healthz` 通过为止。全过程写
-sudo cp deploy/package.runtime.json    /opt/classhelper/package.json
+`/var/log/classhelper/install.log`。
 
-# 生产依赖 + 工作区共享包
+重跑就是**覆盖安装**：`config.env`（含密钥）与 `data/` 保留，已登录用户不会被踢下线。
-cd /opt/classhelper && sudo npm install --omit=dev --no-audit --no-fund
-sudo mkdir -p /opt/classhelper/node_modules/@classhelper/shared
-sudo cp -R packages/shared/dist         /opt/classhelper/node_modules/@classhelper/shared/dist
-sudo cp packages/shared/package.json    /opt/classhelper/node_modules/@classhelper/shared/package.json
 
-# 配置（参考脚本生成的 .env，务必自己生成 JWT_SECRET）
+### 3.2 安装后的布局与运维
-sudo tee /opt/classhelper/.env >/dev/null <<'EOF'
-NODE_ENV=production
-HOST=0.0.0.0
-PORT=4000
-DATABASE_PROVIDER=sqlite
-DATABASE_URL="file:../data/classhelper.db"
-AUTO_MIGRATE=true
-JWT_SECRET=换成 openssl rand -hex 48 的输出
-JWT_EXPIRES_IN=7d
-CORS_ORIGIN=https://class.example.com
-TRUST_PROXY=1
-RATE_LIMIT_ENABLED=true
-STARTUP_DB_CHECK=true
-PID_FILE=../data/server.pid
-LOG_LEVEL=info
-EOF
 
-sudo chown -R classhelper:classhelper /opt/classhelper/{data,logs,node_modules} /opt/classhelper/.env
+```
-sudo chmod 600 /opt/classhelper/.env
+/opt/classhelper/              程序、node_modules、内置 Node、data/、tools/、bin/
+/etc/classhelper/config.env    唯一配置真身（600）；安装目录里的 .env 是指向它的软链
+/var/log/classhelper/          install.log + audit.log
+/var/backups/classhelper/      备份与程序快照（回滚用）
+```
 
-# systemd
+> 为什么安装目录的 `.env` 是软链：Web 端「数据库管理 → 一键切换」改写的是 `<安装目录>/.env`，
-sudo sed -e 's#__NODE__#/usr/bin/node#' -e 's#__DIR__#/opt/classhelper#' -e 's#__USER__#classhelper#' \
+> 而 systemd 用 `EnvironmentFile=` 注入同一份配置；两处不是同一个文件时，切换会"看起来成功、
-  deploy/classhelper.service | sudo tee /etc/systemd/system/classhelper.service
+> 重启后又连回旧库"。软链把两者收成一份真身（`classhelper doctor` 会检查它）。
+
+日常运维全部走 `classhelper`（`classhelper help` 看全部）：
+
+| 事项   | 命令                                                                                    |
+| ------ | --------------------------------------------------------------------------------------- |
+| 状态   | `classhelper status [--json]`                                                           |
+| 体检   | `classhelper doctor`（权限 / Node / 服务单元 / 探针 / 数据库 / 磁盘 / 备份）            |
+| 改密码 | `classhelper password [用户名]`（交互输入、不回显、不进 shell history）                 |
+| 备份   | `classhelper backup`；每日自动：`classhelper backup schedule daily`                     |
+| 升级   | `classhelper upgrade [--check]`（下载 + 校验 sha256 + 备份 + 替换 + 探针，失败自动回滚） |
+| 回滚   | `classhelper rollback [--list]`                                                         |
+| 日志   | `classhelper logs -f`                                                                   |
+| 改配置 | `classhelper config set KEY VALUE` / `config show` / `port 8080`                        |
+| 换密钥 | `classhelper key rotate`（所有用户需重新登录）                                          |
+| 卸载   | `classhelper uninstall`（默认保留配置、数据与备份）                                     |
+| 服务   | `classhelper start｜stop｜restart｜reload`                                              |
+
+### 3.3 手动部署（不想用安装器 / 没有 systemd）
+
+没有 systemd 的容器里可以用安装器的"只铺文件"模式，再自己托管进程：
+
+```bash
+sudo bash /tmp/install.sh --yes --force --package /tmp/classhelper-server-linux-x64-1.1.2.tar.gz
+sudo -u classhelper /opt/classhelper/runtime/node/bin/node /opt/classhelper/server/dist/index.js
+```
+
+完全手工也可以（等价步骤，便于排查）：解包后把 `server/` `web/` `node_modules/` `tools/` 铺到安装目录，
+配置写到 `/etc/classhelper/config.env`（`JWT_SECRET` 用 `openssl rand -hex 48`），再用
+`deploy/classhelper.service` 模板生成单元 —— 注意模板有 5 个占位符
+（`__NODE__` `__DIR__` `__USER__` `__CONFIG__` `__CONFIGDIR__`）：
+
+```bash
+sudo sed -e "s#__NODE__#/opt/classhelper/runtime/node/bin/node#" \
+         -e "s#__DIR__#/opt/classhelper#" -e "s#__USER__#classhelper#" \
+         -e "s#__CONFIG__#/etc/classhelper/config.env#" -e "s#__CONFIGDIR__#/etc/classhelper#" \
+  deploy/classhelper.service > /tmp/classhelper.service
+sudo install -m 644 /tmp/classhelper.service /etc/systemd/system/classhelper.service
 sudo systemctl daemon-reload && sudo systemctl enable --now classhelper
-systemctl status classhelper --no-pager
 ```
 
-也可以用 PM2 之类托管（`pm2 start /opt/classhelper/server/dist/index.js --name classhelper`），
+### 3.4 Nginx + HTTPS
-但 systemd 更省心：`Restart=always`、日志进 journald、开机自启一次配好。
-
-### 3.3 Nginx + HTTPS
 
 ```bash
 sudo cp deploy/nginx.conf /etc/nginx/conf.d/classhelper.conf
@@ -237,7 +248,7 @@ sudo nginx -t && sudo systemctl reload nginx
 ```
 
 `deploy/nginx.conf` 已经处理了最容易踩的两点：`/socket.io/` 的 WebSocket 升级头，
-以及 `X-Forwarded-For/X-Forwarded-Proto` 透传（配合 `.env` 里 `TRUST_PROXY=1`，限流才会按真实 IP 统计）。
+以及 `X-Forwarded-For/X-Forwarded-Proto` 透传（配合配置里的 `TRUST_PROXY=1`，限流才会按真实 IP 统计）。
 用 certbot 签证书：
 
 ```bash
@@ -245,31 +256,19 @@ sudo apt install -y certbot python3-certbot-nginx
 sudo certbot --nginx -d class.example.com
 ```
 
-### 3.4 升级 / 备份 / 排障
+### 3.5 验收
-
-升级（不会动 `.env`，JWT 密钥不变，学生端不用重新登录）：
 
 ```bash
-git pull && pnpm install
+sudo bash /tmp/verify-linux.sh --admin-password-stdin <<< 'StrongPass!2026'
-pnpm build:shared && pnpm --filter @classhelper/server build && pnpm --filter @classhelper/web-admin build
+# 追加升级 / 回滚链路（会真的替换一次程序文件）：
-sudo bash deploy/install-linux.sh        # 覆盖程序文件 + 自动补迁移（AUTO_MIGRATE）
+sudo bash /tmp/verify-linux.sh --full --package /tmp/classhelper-server-linux-x64-1.0.1.tar.gz \
-journalctl -u classhelper -n 30 --no-pager
+  --admin-password-stdin <<< 'StrongPass!2026'
 ```
 
-| 事项     | 命令                                                                                                       |
+覆盖安装结果、服务探针、API 登录、改密（含审计与回滚）、备份、配置读写、key rotate、
-| -------- | ---------------------------------------------------------------------------------------------------------- |
+升级与回滚整条链路，末尾打印 `=== 结果：N/N 项通过 ===`。逐条清单见
-| 备份     | `systemctl stop classhelper && cp -a /opt/classhelper/data /root/classhelper-data-$(date +%F)`（然后启动） |
+[linux-deploy.md](linux-deploy.md) 第 10 节。
-| 恢复     | 停服务 → 用备份覆盖 `data/` → 启动                                                                         |
-| 看日志   | `journalctl -u classhelper -f`                                                                             |
-| 重启     | `systemctl restart classhelper`（改 `.env` 后必须重启）                                                    |
-| 探针     | `curl -s localhost:4000/healthz` / `/readyz`（就绪 200，数据库不可用 503）                                 |
-| 换端口   | 改 `.env` 的 `PORT` → 重启；同时改 Nginx 的 `upstream`                                                     |
-| 换数据库 | 见 `docs/mysql.md`：切 provider + 装 `@prisma/adapter-mariadb` + `npx prisma migrate deploy`               |
 
-> 注意：本机（开发环境）是 Windows 且无 Docker/WSL 发行版，因此 **3.1 的脚本没有在 Linux 实机跑过**。
-> 它复用的两套东西都已验证：Windows 免安装目录（同样的目录结构、`.env` 相对路径与
-> `AUTO_MIGRATE` 首启动行为）和 `deploy/Dockerfile` 的 runtime 阶段（同样的依赖清单与产物布局）。
-> 首次在服务器上执行后请按 3.4 的探针 + Web 登录 + `pnpm verify:e2e`（把 `VERIFY_BASE_URL` 指向服务器）确认。
 
 ---
 
@@ -280,7 +279,7 @@ pnpm install
 pnpm build:shared
 pnpm --filter @classhelper/server build
 pnpm --filter @classhelper/web-admin build
-pnpm dist:server -- --reuse-deps      # 得到 release-server/classhelper-server 免安装目录
+pnpm dist:server -- --reuse-deps      # 得到 releases/server/<版本>/免安装/ 免安装目录
 ```
 
 把该目录拷贝到目标机，编辑 `.env`（端口、数据库、密钥、跨域），然后：
@@ -315,7 +314,6 @@ start.cmd      :: Windows
 | `PID_FILE`                                          | —                      | PID 文件路径（安装包启停脚本依赖），相对 `server` 根      |
 | `WEB_DIST_DIR`                                      | 自动探测               | Web 管理端产物目录（`../web-admin/dist` 或 `./web`）      |
 | `LOG_LEVEL`                                         | `info`                 | `debug` / `info` / `warn` / `error`                       |
-| `DEFAULT_STUDENT_PASSWORD`                          | `123456`               | 新增/重置学生账号的默认密码                               |
 | `DEFAULT_CLASS_PASSWORD`                            | `123456`               | 新建班级时班级账号（学生端登录）的默认密码                |
 | `DEFAULT_TEACHER_PASSWORD`                          | `123456`               | 新增/重置教师账号的默认密码（管理员录入教师用）           |
 | `TERM_START_DATE`                                   | —                      | 第 1 教学周的周一，用于"当前周次"与课表默认视图           |

package.json

@@ -1,6 +1,6 @@
 {
   "name": "class-helper",
-  "version": "0.1.0",
+  "version": "1.1.2",
   "private": true,
   "description": "班级小助手 - 班级信息管理系统（Web 管理端 + 后端服务 + 桌面客户端）",
   "packageManager": "pnpm@11.8.0",
@@ -16,6 +16,7 @@
     "build": "pnpm build:shared && pnpm --filter @classhelper/server build && pnpm --filter @classhelper/web-admin build && pnpm --filter @classhelper/desktop-client build",
     "build:desktop": "pnpm build:shared && pnpm --filter @classhelper/desktop-client build",
     "build:classisland-plugin": "node packages/classisland-plugin/scripts/build.mjs",
+    "check:icons": "node scripts/check-icons.mjs",
     "typecheck": "pnpm build:shared && pnpm -r --no-bail typecheck",
     "lint": "eslint .",
     "lint:fix": "eslint . --fix",
@@ -38,6 +39,7 @@
     "dist:win": "pnpm --filter @classhelper/desktop-client dist:win",
     "dist:dir": "pnpm --filter @classhelper/desktop-client dist:dir",
     "dist:server": "pnpm build:shared && pnpm --filter @classhelper/server build && pnpm --filter @classhelper/web-admin build && node scripts/dist-server.mjs",
+    "dist:server:linux": "pnpm build:shared && pnpm --filter @classhelper/server build && pnpm --filter @classhelper/web-admin build && node scripts/dist-server.mjs --platform linux",
     "dist:classisland-plugin": "node packages/classisland-plugin/scripts/build.mjs --cipx",
     "dist:all": "pnpm dist:server && pnpm dist:win && pnpm dist:classisland-plugin"
   },

packages/classisland-plugin/manifest.yml

@@ -14,6 +14,6 @@ description: |-
   4. 可选：把班级小助手上排好的课表镜像回 ClassIsland。
 entranceAssembly: 'ClassHelper.ClassIslandPlugin.dll'
 url: https://github.com/LoveChengke/ClassHelper
-version: 0.1.0.0
+version: 1.1.2.0
 apiVersion: 2.0.0.0
 author: 班级小助手

packages/classisland-plugin/scripts/build.mjs

@@ -3,7 +3,7 @@
  *
  * 用法：
  *   node scripts/build.mjs              # Release 构建，产物在 packages/classisland-plugin/bin/Release
- *   node scripts/build.mjs --cipx       # 追加打包 .cipx（ClassIsland 插件包）并归集到 releases/classisland-plugin/
+ *   node scripts/build.mjs --cipx       # 追加打包 .cipx 并归集到 releases/classisland-plugin/<版本>/
  *   额外参数会原样透传给 `dotnet build`（例如 `-p:ClassIslandPluginSdkVersion=2.1.1.1`）
  *
  * 为什么需要这层包装（本机踩过的坑，写在这里免得换台机器又踩一遍）：
@@ -21,7 +21,7 @@ import { fileURLToPath } from 'node:url';
 const pluginDir = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
 const repoRoot = path.resolve(pluginDir, '..', '..');
 const cacheDir = path.join(repoRoot, '.cache');
-const releasesDir = path.join(repoRoot, 'releases', 'classisland-plugin');
+const releasesRoot = path.join(repoRoot, 'releases', 'classisland-plugin');
 
 const argv = process.argv.slice(2);
 const withCipx = argv.includes('--cipx');
@@ -146,14 +146,19 @@ if (!fs.existsSync(cipxFile)) {
   throw new Error(`未生成插件包：${path.relative(pluginDir, cipxFile)}`);
 }
 
-// 归集到 releases/classisland-plugin/（与客户端、服务端交付产物同级；releases/ 不入库）
+// 归集到 releases/classisland-plugin/<版本>/（与客户端、服务端交付产物同一约定；releases/ 不入库）。
-fs.rmSync(releasesDir, { recursive: true, force: true });
+// 只清理**当前版本**目录，历史版本原样保留 —— 原先这里是 rmSync 整个组件目录，重打一次就把
-fs.mkdirSync(releasesDir, { recursive: true });
+// 上一版的留档抹掉了（插件版本是四段 <产品版本>.0，目录名取前三段与产品版本对齐）。
-fs.copyFileSync(cipxFile, path.join(releasesDir, path.basename(cipxFile)));
+const pluginVersion = manifestVersion.split('.').slice(0, 3).join('.');
+const versionDir = path.join(releasesRoot, pluginVersion);
+const installerDir = path.join(versionDir, '安装包');
+const portableDir = path.join(versionDir, '免安装', 'ClassHelper.ClassIslandPlugin');
+fs.rmSync(installerDir, { recursive: true, force: true });
+fs.rmSync(path.dirname(portableDir), { recursive: true, force: true });
+fs.mkdirSync(installerDir, { recursive: true });
+fs.mkdirSync(portableDir, { recursive: true });
 
 // 免安装目录：解压即用，直接放进 ClassIsland 的 Plugins 目录也能加载
-const portableDir = path.join(releasesDir, 'ClassHelper.ClassIslandPlugin');
-fs.mkdirSync(portableDir, { recursive: true });
 for (const name of fs.readdirSync(outputDir)) {
   const from = path.join(outputDir, name);
   if (!fs.statSync(from).isFile()) continue;
@@ -165,10 +170,11 @@ for (const name of fs.readdirSync(outputDir)) {
 }
 
 for (const file of fs.readdirSync(cipxDir)) {
-  fs.copyFileSync(path.join(cipxDir, file), path.join(releasesDir, file));
+  // .cipx 是插件包本体，校验清单跟着版本目录走
+  const to = file.toLowerCase().endsWith('.cipx') ? installerDir : versionDir;
+  fs.copyFileSync(path.join(cipxDir, file), path.join(to, file));
 }
 
-log(`插件包已归集到 ${path.relative(repoRoot, releasesDir)}`);
+log(`插件包已归集到 ${path.relative(repoRoot, versionDir)}`);
-for (const file of fs.readdirSync(releasesDir)) {
+for (const file of fs.readdirSync(installerDir)) log(`  安装包/${file}`);
-  log(`  ${file}`);
+for (const file of fs.readdirSync(portableDir)) log(`  免安装/ClassHelper.ClassIslandPlugin/${file}`);
-}

packages/classisland-plugin/scripts/verify.mjs

@@ -295,6 +295,57 @@ check(
     bridgeSource.includes('NotificationPollSeconds'),
 );
 
+/* ------------------------------------------------------------ 8. 回归护栏：本次修复过的坑 */
+
+check(
+  '课表配对用原始 TimeType==0 列表，**不用** ValidTimeLayoutItems（后者会剔除被停用的节次，导致整份课表错位）',
+  // 只查代码形态（`.Count`），因为源码注释里特意点名了这个属性来说明"为什么不能用它"
+  mapperSource.includes('classPoints[index]') && !mapperSource.includes('.ValidTimeLayoutItems.Count'),
+);
+check(
+  '上报字段按服务端 zod 上限截断（一个超长名字会让整批上报 400，连状态与心跳一起丢掉）',
+  mapperSource.includes('Truncate(') &&
+    mapperSource.includes('SubjectMaxLength') &&
+    mapperSource.includes('PlanNameMaxLength'),
+);
+check(
+  '课表镜像在 UI 线程改写档案（线程池上改 Observable 集合会与落盘并发，可能写坏档案）',
+  bridgeSource.includes('Dispatcher.UIThread.InvokeAsync') && bridgeSource.includes('SaveProfile()'),
+);
+check(
+  '镜像内容未变化时跳过（否则每次上报都重建课表并全量落盘）',
+  bridgeSource.includes('_lastMirrorSignature') && bridgeSource.includes('MirrorSignature('),
+);
+check(
+  '上报异常有 catch（fire-and-forget 的异常会被静默吞掉）',
+  bridgeSource.includes('catch (Exception exception)') && bridgeSource.includes('上报异常'),
+);
+check(
+  '镜像前过滤时间非法的条目（避免档案里出现 00:00 的课次，且必须与 Classes 同步过滤）',
+  read('src/Services/ClassPlanWriter.cs').includes('IsValidTime'),
+);
+check(
+  '上报体带上 deviceKey，且服务端 schema 也声明了该字段（回填机器码的契约两端一致）',
+  clientSource.includes('"deviceKey"') && serverSchemas.includes('deviceKey:'),
+);
+check(
+  '2xx 但不是本服务响应体时给出原因（而不是"成功但无数据 + 空消息"），并限制响应体大小',
+  clientSource.includes('响应不是班级小助手的标准格式') &&
+    clientSource.includes('MaxResponseContentBufferSize'),
+);
+check(
+  '提醒提供方惰性获取课程服务并重试（拿不到服务时"上课暂存"会永久失效且静默）',
+  providerSource.includes('EnsureLessons') && providerSource.includes('_lessonsHooked'),
+);
+check(
+  '设置落盘先写临时文件再原子替换（逐字符写盘 + 截断式写入会留下坏 JSON）',
+  pluginSource.includes('File.Move(temp, path, overwrite: true)'),
+);
+check(
+  '服务器地址只接受 http/https（裸 Uri.TryCreate 会放过 file:// / ftp://）',
+  settingsSource.includes('TryGetServerUri') && settingsSource.includes('UriSchemeHttp'),
+);
+
 /* ------------------------------------------------------------ 结果 */
 
 const failed = results.filter((item) => !item.ok);

packages/classisland-plugin/src/Interop/ClassHelperClient.cs

@@ -69,6 +69,8 @@ public class ReportRequestDto
 {
     [JsonPropertyName("pluginVersion")] public string PluginVersion { get; set; } = "";
     [JsonPropertyName("classIslandVersion")] public string ClassIslandVersion { get; set; } = "";
+    /// <summary>本机机器码：设备创建时服务端还不知道它，靠这里回填（见服务端 syncDeviceKey）。</summary>
+    [JsonPropertyName("deviceKey")] public string DeviceKey { get; set; } = "";
     [JsonPropertyName("state")] public StateDto? State { get; set; }
     [JsonPropertyName("schedule")] public SchedulePayloadDto? Schedule { get; set; }
     [JsonPropertyName("timeLayout")] public TimeLayoutPayloadDto? TimeLayout { get; set; }
@@ -198,6 +200,12 @@ public sealed class ClassHelperClient : IDisposable
     /// </summary>
     private static readonly TimeSpan Timeout = TimeSpan.FromSeconds(12);
 
+    /// <summary>
+    /// 响应体上限（4MB）。默认是 2GB —— 服务器地址填错（指到一个会吐大页面的地址）时，
+    /// 一次请求就能在 12 秒内把内存吃光。
+    /// </summary>
+    private const long MaxResponseBytes = 4 * 1024 * 1024;
+
     private static readonly JsonSerializerOptions JsonOptions = new()
     {
         PropertyNameCaseInsensitive = true,
@@ -216,6 +224,7 @@ public sealed class ClassHelperClient : IDisposable
     private readonly HttpClient _http = new(new SocketsHttpHandler { Proxy = new LocalAwareProxy() })
     {
         Timeout = Timeout,
+        MaxResponseContentBufferSize = MaxResponseBytes,
     };
 
     public string LastError { get; private set; } = "";
@@ -334,6 +343,17 @@ public sealed class ClassHelperClient : IDisposable
                 return envelope ?? new ApiEnvelope<T> { Success = false, Message = message! };
             }
 
+            if (envelope is null)
+            {
+                // 2xx 但响应不是本服务的统一响应体（网关/反代的 HTML 错误页、地址指到了别的服务等）。
+                // 必须留下原因：否则调用方拿到的是"成功但无数据 + 空错误消息"，
+                // 设置页显示"连接异常"却没有原因，与上面专门为代理错误页写的诊断自相矛盾。
+                LastError =
+                    $"HTTP {(int)response.StatusCode}（{method.Method} {request.RequestUri}）——" +
+                    "响应不是班级小助手的标准格式，请检查服务器地址是否正确，或该系统代理是否拦截了内网请求";
+                return new ApiEnvelope<T> { Success = false, Message = LastError };
+            }
+
             LastError = "";
             LastSuccessAt = DateTimeOffset.Now;
             return envelope;

packages/classisland-plugin/src/Models/PluginSettings.cs

@@ -40,7 +40,10 @@ public class PluginSettings : ObservableObject
     public string DeviceToken
     {
         get => _deviceToken;
-        set => SetProperty(ref _deviceToken, value);
+        // 在 setter 里就去掉首尾空白：粘贴令牌时带前导空格非常常见，
+        // 而 Normalize() 只在启动加载时跑一次 —— 运行期粘进来的脏值会让 IsConfigured
+        // 一直为 false，用户看着明明填好了却查不出原因。
+        set => SetProperty(ref _deviceToken, (value ?? "").Trim());
     }
 
     /// <summary>
@@ -154,5 +157,20 @@ public class PluginSettings : ObservableObject
 
     /// <summary>是否已经配置好（地址 + 令牌都填了）。</summary>
     public bool IsConfigured =>
-        Uri.TryCreate(ServerUrl, UriKind.Absolute, out _) && DeviceToken.StartsWith("chci_", StringComparison.Ordinal);
+        TryGetServerUri(out _) && DeviceToken.StartsWith("chci_", StringComparison.Ordinal);
+
+    /// <summary>
+    /// 解析服务器地址，**只接受 http/https 绝对地址**。
+    ///
+    /// 不用裸的 `Uri.TryCreate(..., UriKind.Absolute)`：它会接受 `file://` / `ftp://`，
+    /// 那种地址会在发请求时抛一句难以理解的 NotSupportedException，用户根本猜不到是地址填错了。
+    /// </summary>
+    public bool TryGetServerUri(out Uri uri)
+    {
+        uri = null!;
+        if (!Uri.TryCreate((ServerUrl ?? "").Trim(), UriKind.Absolute, out var parsed)) return false;
+        if (parsed.Scheme != Uri.UriSchemeHttp && parsed.Scheme != Uri.UriSchemeHttps) return false;
+        uri = parsed;
+        return true;
+    }
 }

packages/classisland-plugin/src/Plugin.cs

@@ -127,9 +127,15 @@ public class Plugin : PluginBase
         settings.Normalize();
         if (needGenerateKey)
         {
-            // 机器名 + 随机短码：既是人眼可读的"这台机器"，又不会两台同名机器撞车
+            // 机器名 + 随机短码：既是人眼可读的"这台机器"，又不会两台同名机器撞车。
+            // 注意长度：原先写的是 `[..Math.Min(24, machine.Length + 33)]`，而 machine.Length + 33
+            // 恒大于 24，所以实际**永远只取前 24 个字符** —— 机器名稍长就把随机段整个切掉，
+            // "同名机器不撞车"的保障就没了。这里改成"机器名按需截短 + 保留 8 位随机段"。
             var machine = Environment.MachineName.ToLowerInvariant();
-            settings.DeviceKey = $"{machine}-{Guid.NewGuid():N}"[..Math.Min(24, machine.Length + 33)];
+            var suffix = Guid.NewGuid().ToString("N")[..8];
+            var maxMachineLength = Math.Max(4, 24 - suffix.Length - 1);
+            if (machine.Length > maxMachineLength) machine = machine[..maxMachineLength];
+            settings.DeviceKey = $"{machine}-{suffix}";
         }
 
         Settings = settings;
@@ -146,7 +152,15 @@ public class Plugin : PluginBase
         {
             var folder = Path.GetDirectoryName(path);
             if (!string.IsNullOrEmpty(folder)) Directory.CreateDirectory(folder);
-            File.WriteAllText(path, JsonSerializer.Serialize(settings, JsonOptions));
+            // 先写临时文件再原子替换。
+            //
+            // 设置页的地址/令牌输入框是 TwoWay 绑定（逐字符提交），直接 `File.WriteAllText`
+            // 会就地截断原文件；一旦此刻进程被杀或断电，留下的是半截 JSON，而 LoadSettings 的
+            // catch 会**静默回退到默认设置** —— 用户看到的是"令牌和地址莫名其妙没了"，
+            // 而且原文件已被覆盖，无从恢复。
+            var temp = path + ".tmp";
+            File.WriteAllText(temp, JsonSerializer.Serialize(settings, JsonOptions));
+            File.Move(temp, path, overwrite: true);
         }
         catch (Exception exception)
         {

packages/classisland-plugin/src/Services/BridgeService.cs

@@ -1,5 +1,7 @@
 using System.ComponentModel;
 using System.Runtime.CompilerServices;
+using System.Text;
+using Avalonia.Threading;
 using ClassHelper.ClassIslandPlugin.Interop;
 using ClassHelper.ClassIslandPlugin.Models;
 using ClassIsland.Core;
@@ -39,6 +41,11 @@ public sealed class BridgeService : INotifyPropertyChanged, IDisposable
     private bool _reporting;
     private bool _pulling;
     private bool _eventsHooked;
+    /// <summary>
+    /// 上次成功镜像的课表内容指纹。内容没变就完全跳过镜像：既省掉每分钟一次的全量重建 + 落盘，
+    /// 也把"跨线程改档案"的窗口从"每分钟一次"降回"只在课表真的变化时"。
+    /// </summary>
+    private volatile string? _lastMirrorSignature;
 
     public BridgeService(PluginSettings settings, ILogger<BridgeService> logger)
     {
@@ -237,6 +244,8 @@ public sealed class BridgeService : INotifyPropertyChanged, IDisposable
             {
                 PluginVersion = PluginVersion,
                 ClassIslandVersion = SafeAppVersion(),
+                // 机器码：设备创建时服务端只能用 pending-… 占位，靠这里回填，Web 端设备列表才能与教室机器对上
+                DeviceKey = _settings.DeviceKey,
                 State = BuildState(lessons),
             };
 
@@ -274,7 +283,9 @@ public sealed class BridgeService : INotifyPropertyChanged, IDisposable
                     layoutCount = items.Count;
                     request.TimeLayout = new TimeLayoutPayloadDto
                     {
-                        Name = string.IsNullOrWhiteSpace(layout.Name) ? "ClassIsland 时间表" : layout.Name,
+                        Name = ScheduleMapper.Truncate(
+                            string.IsNullOrWhiteSpace(layout.Name) ? "ClassIsland 时间表" : layout.Name,
+                            ScheduleMapper.PlanNameMaxLength)!,
                         Mode = "replace",
                         Items = items,
                     };
@@ -321,6 +332,16 @@ public sealed class BridgeService : INotifyPropertyChanged, IDisposable
 
             return true;
         }
+        catch (Exception exception)
+        {
+            // ReportAsync 是通过 `_ = ReportAsync(reason)` 这种 fire-and-forget 方式发起的
+            // （事件回调与定时器都是），没有这个 catch，中途抛出的异常（例如跨线程改档案时的
+            // "Collection was modified"）会被 unobserved task 静默吞掉：日志里一条都没有，
+            // 而 LastReportMessage 还停在上一次的成功结果，用户以为一切正常。
+            _logger.LogError(exception, "班级小助手联动：上报异常（{Reason}）", reason);
+            SetState(false, $"上报异常：{exception.Message}", 0, 0, null);
+            return false;
+        }
         finally
         {
             Busy = false;
@@ -397,23 +418,48 @@ public sealed class BridgeService : INotifyPropertyChanged, IDisposable
             return;
         }
 
+        // 内容没变就直接返回：上报是"启动 + 每个课程事件 + 每 N 秒"触发的，原先每次都要
+        // 重建全部课表对象并整体落盘 —— 无谓的网络/磁盘 I/O，还会把档案页刷得不停重绘。
+        var signature = MirrorSignature(plan);
+        if (signature == _lastMirrorSignature)
+        {
+            _logger.LogDebug("班级小助手联动：课表内容与上次一致，跳过镜像");
+            return;
+        }
+
         try
+        {
+            // **必须在 UI 线程上改写档案**：ClassIsland 的档案是 ObservableDictionary /
+            // ObservableCollection，落盘是"属性变化即整体序列化 + FileStream 就地截断"。
+            // 而本方法是从线程池线程继续执行的（ReportAsync 里 ConfigureAwait(false) 之后，
+            // 定时器回调本就在线程池上），在线程池上改集合会与 UI 线程的保存/绑定并发：
+            // 轻则 InvalidOperationException（Collection was modified），重则两次写入互相截断，
+            // **把整个档案写成半截 JSON**（老师的课表/科目全丢，只能靠 .bak 兜底）。
+            var outcome = await Dispatcher.UIThread.InvokeAsync(() =>
             {
                 var applied = ClassPlanWriter.Apply(profile, plan);
                 if (!applied.Applied)
                 {
-                _logger.LogInformation("班级小助手联动：课表镜像未生效（{Reason}）",
+                    return applied;
-                    applied.Warnings.FirstOrDefault() ?? "服务端课表为空");
-                return;
                 }
 
                 // 改写的是 Profile 里的集合，ClassIsland 会靠 INotifyCollectionChanged 落盘；
                 // 这里显式 SaveProfile() 是为了"打开开关马上就能在课表里看到"，不用等下一次自动保存。
                 IAppHost.TryGetService<IProfileService>()?.SaveProfile();
+                return applied;
+            });
 
+            if (!outcome.Applied)
+            {
+                _logger.LogInformation("班级小助手联动：课表镜像未生效（{Reason}）",
+                    outcome.Warnings.FirstOrDefault() ?? "服务端课表为空");
+                return;
+            }
+
+            _lastMirrorSignature = signature;
             _logger.LogInformation("班级小助手联动：已把班级课表写入 ClassIsland（{Plans}）",
-                string.Join("、", applied.PlanNames.Select(name => $"「{name}」")));
+                string.Join("、", outcome.PlanNames.Select(name => $"「{name}」")));
-            foreach (var warning in applied.Warnings)
+            foreach (var warning in outcome.Warnings)
             {
                 _logger.LogWarning("班级小助手联动镜像提示：{Warning}", warning);
             }
@@ -424,10 +470,32 @@ public sealed class BridgeService : INotifyPropertyChanged, IDisposable
         }
     }
 
+    /// <summary>镜像载荷的内容指纹（只用于"内容没变就跳过"，不参与任何业务判断）</summary>
+    private static string MirrorSignature(ClassPlanMirrorDto plan)
+    {
+        var builder = new StringBuilder();
+        foreach (var entry in plan.Entries)
+        {
+            builder.Append(entry.WeekDay).Append('|').Append(entry.WeekCountDiv).Append('|')
+                .Append(entry.WeekCountDivTotal).Append('|').Append(entry.Subject).Append('|')
+                .Append(entry.StartTime).Append('|').Append(entry.EndTime).Append(';');
+        }
+        foreach (var layout in plan.TimeLayouts)
+        {
+            builder.Append('#').Append(layout.Id).Append(':');
+            foreach (var item in layout.Layouts)
+            {
+                builder.Append(item.StartTime).Append('-').Append(item.EndTime).Append('@')
+                    .Append(item.TimeType).Append(',');
+            }
+        }
+        return builder.ToString();
+    }
+
     /* ---------------------------------------------------------------- 内部实现 */
 
     /// <summary>插件版本（与 manifest.yml / csproj 保持一致）。</summary>
-    private const string PluginVersion = "0.1.0.0";
+    private const string PluginVersion = "1.1.2.0";
 
     /// <summary>ClassIsland 版本读不到时不该让上报失败（开发版可能为 null）。</summary>
     private static string SafeAppVersion()

packages/classisland-plugin/src/Services/ClassHelperNotificationProvider.cs

@@ -63,6 +63,7 @@ public sealed class ClassHelperNotificationProvider : NotificationProviderBase
     private readonly List<PushNotificationDto> _deferred = new();
 
     private ILessonsService? _lessons;
+    private bool _lessonsHooked;
 
     public ClassHelperNotificationProvider(
         BridgeService bridge,
@@ -74,26 +75,43 @@ public sealed class ClassHelperNotificationProvider : NotificationProviderBase
         _logger = logger;
         _bridge.NotificationReceived += OnNotificationReceived;
 
-        // 订阅课程事件：下课后把上课时段暂存的提醒补弹出来
+        // 尽力而为地先订阅一次；拿不到也没关系，后面每次需要判定时都会重试
+        // （本类的构造函数可能在课程服务建好之前就被 DI 调用）
+        EnsureLessons();
+    }
+
+    /// <summary>
+    /// 惰性获取课程服务并**只订阅一次**课程事件（下课后补弹上课时段暂存的提醒）。
+    ///
+    /// 为什么不能只在构造函数里订阅：提供方是随主机启动被构造的，而课程服务在启动流程里的
+    /// 创建时机并不固定。一旦构造函数里拿到 null，原先的实现既不重试、也不打日志，
+    /// 于是 `IsInClass()` 恒为 false —— "上课时段先暂存、下课再补弹"这条规则**永久失效**，
+    /// 老师在课上发的通知会直接全屏打断课堂，而且完全静默、无从排查。
+    /// </summary>
+    private void EnsureLessons()
+    {
+        if (_lessonsHooked) return;
         try
         {
             _lessons = IAppHost.TryGetService<ILessonsService>();
-            if (_lessons is not null)
+            if (_lessons is null) return;
-            {
+
             _lessons.OnBreakingTime += (_, _) => Dispatcher.UIThread.Post(FlushDeferred);
             _lessons.OnAfterSchool += (_, _) => Dispatcher.UIThread.Post(FlushDeferred);
             _lessons.CurrentTimeStateChanged += (_, _) => Dispatcher.UIThread.Post(FlushDeferred);
-            }
+            _lessonsHooked = true;
+            _logger.LogInformation("班级小助手联动：提醒提供方已订阅课程事件（上课时段暂存、下课补弹）");
         }
         catch (Exception exception)
         {
-            _logger.LogWarning(exception, "班级小助手联动：订阅课程事件失败，上课暂存将退化为「立即弹出」");
+            _logger.LogWarning(exception, "班级小助手联动：订阅课程事件失败，将在下次提醒时重试");
         }
     }
 
     /// <summary>当前是否处于上课时段（读不到课程服务时按"不在上课"处理，宁可弹也不静默丢）</summary>
     private bool IsInClass()
     {
+        EnsureLessons();
         try
         {
             return _lessons?.CurrentState == TimeState.OnClass;

packages/classisland-plugin/src/Services/ClassPlanWriter.cs

@@ -79,9 +79,22 @@ public static class ClassPlanWriter
         {
             var planName = BuildPlanName(source.ProfileName, group.WeekDay, group.WeekCountDiv,
                 group.WeekCountDivTotal, groups.Count);
+
+            // 时间非法的条目必须**在这里**就整批丢掉：`Classes` 与时间表里的上课点必须等长且同序，
+            // 只在一处跳过会让整份课表错位。原先 ParseTime 把无法解析的值悄悄变成 00:00，
+            // 于是档案里凭空出现 00:00-00:00 的课次（时间轴显示与当前节次判断都会乱），还没有任何日志。
+            var usable = group.Entries
+                .Where(entry => IsValidTime(entry.StartTime) && IsValidTime(entry.EndTime))
+                .ToList();
+            if (usable.Count < group.Entries.Count)
+            {
+                result.Warnings.Add(
+                    $"「{planName}」有 {group.Entries.Count - usable.Count} 节的时间无法解析（需要 HH:mm），已跳过");
+            }
+            if (usable.Count == 0) continue;
+
             var planId = FindPlanId(profile, planName);
-            var (timeLayoutId, timeLayout) = BuildTimeLayout(
+            var (timeLayoutId, timeLayout) = BuildTimeLayout(profile, planName, usable);
-                profile, planName, group.Entries);
 
             var plan = profile.ClassPlans.TryGetValue(planId, out var existing)
                 ? existing
@@ -102,7 +115,7 @@ public static class ClassPlanWriter
             // 档案不会重新触发刷新，课次就会停留在旧时间点上。
             var classes = new ObservableCollection<ClassInfo>();
             var index = 0;
-            foreach (var entry in group.Entries)
+            foreach (var entry in usable)
             {
                 var subjectId = profile.Subjects
                     .FirstOrDefault(pair => pair.Value.Name == entry.Subject).Key;
@@ -251,4 +264,19 @@ public static class ClassPlanWriter
     {
         return TimeSpan.TryParse(value, out var parsed) ? parsed : TimeSpan.Zero;
     }
+
+    /// <summary>
+    /// 时间字符串是否可用（HH:mm / HH:mm:ss）。
+    ///
+    /// 服务端输出侧没有校验 `Schedule.startTime`（老数据/异常数据可能是空串），
+    /// 而 <see cref="ParseTime"/> 会把非法值变成 0 点 —— 因此调用方必须先用本方法过滤，
+    /// 并把 Classes 与时间表**同时**按过滤后的列表构造，保证索引仍然一致。
+    /// </summary>
+    private static bool IsValidTime(string? value)
+    {
+        if (string.IsNullOrWhiteSpace(value)) return false;
+        return TimeSpan.TryParse(value, out var parsed)
+               && parsed >= TimeSpan.Zero
+               && parsed < TimeSpan.FromDays(1);
+    }
 }

packages/classisland-plugin/src/Services/ScheduleMapper.cs

@@ -61,9 +61,16 @@ public static class ScheduleMapper
     /// 把档案里的一张课表（ClassPlan）展开成"每个上课时间点一条"的课表条目。
     ///
     /// 与 ClassIsland 的语义严格对齐：<c>ClassPlan.Classes[i]</c> 对应
-    /// <c>TimeLayout.Layouts</c> 里**第 i 个 TimeType=0（上课）的点**，
+    /// <c>TimeLayout.Layouts</c> 里**第 i 个 TimeType=0（上课）的点**，课间 / 分割线 / 行动不占位。
-    /// 课间 / 分割线 / 行动不占 Classes 的位置。因此这里必须按 TimeType 过滤后再配对，
+    ///
-    /// 否则整张课表会错位。
+    /// **注意不要用 `plan.ValidTimeLayoutItems`**：它的口径与 `Classes` 不同 ——
+    /// `GetValidTimeLayoutItems()`（ClassIsland ClassPlan.cs）会正反两遍扫描，
+    /// 把 `ClassInfo.IsEnabled == false`（老师在课表编辑里"停用"这一节）的课**连同其后的课间**
+    /// 一起从结果里剔除；而 `RefreshClassesList()` 只按 `TimeType == 0` 的**总数**对齐
+    /// `Classes` 的长度，`ClassInfo.CurrentTimeLayoutItem` 也是按原始列表的第 `Index` 个取的。
+    /// 于是只要停用过任意一节，用 ValidTimeLayoutItems 配对就会让索引整体前移：
+    /// 第 i 节配上第 i+1 节的时间点、最后一节丢失，且 `Math.Min` 会把缺口静默吃掉 ——
+    /// 表现就是"课表看着有内容、每节课都对不上"，极难排查。
     /// </summary>
     public static List<ScheduleEntryDto> MapClassPlan(ClassPlan plan, Profile profile, out string? warning)
     {
@@ -77,11 +84,8 @@ public static class ScheduleMapper
             return entries;
         }
 
-        // 只保留上课类型的时间点，顺序必须与 Classes 的索引一致
+        // 只保留上课类型的时间点，顺序必须与 Classes 的索引一致（见上面注释）
         var classPoints = timeLayout.Layouts.Where(item => item.TimeType == 0).ToList();
-        var validPoints = plan.ValidTimeLayoutItems.Count > 0
-            ? plan.ValidTimeLayoutItems.Where(item => item.TimeType == 0).ToList()
-            : classPoints;
 
         var weekDay = ToServerDayOfWeek(plan.TimeRule.WeekDay);
         var parity = ToWeekParity(plan.TimeRule.WeekCountDiv, plan.TimeRule.WeekCountDivTotal);
@@ -91,12 +95,15 @@ public static class ScheduleMapper
         }
 
         var classes = plan.Classes;
-        var count = Math.Min(classes.Count, validPoints.Count);
+        var count = Math.Min(classes.Count, classPoints.Count);
         for (var index = 0; index < count; index++)
         {
             var info = classes[index];
-            var point = validPoints[index];
+            // 索引必须与 Classes 对齐：这里按下标取时间点，**不能**先用 Where 过滤再取
+            var point = classPoints[index];
             if (info is null) continue;
+            // 老师停用的一节：本系统没有"停用"概念，不上报（否则学生端会看到一节实际上不上的课）
+            if (!info.IsEnabled) continue;
 
             // 空课（未安排科目）不上报：服务端的科目是必填的，空课由课表里的缺席表达
             var subject = ResolveSubjectName(info.SubjectId, profile);
@@ -107,18 +114,33 @@ public static class ScheduleMapper
                 DayOfWeek = weekDay,
                 StartTime = ToHhMm(point.StartTime),
                 EndTime = ToHhMm(point.EndTime),
-                Subject = subject,
+                // 服务端对这几个字段有 zod 长度上限，且是**整批**校验：一个超长名字会让整次上报
-                TeacherName = ResolveSubjectTeacher(info.SubjectId, profile),
+                // 400，连"现在上什么课"的状态与心跳都不更新，Web 端把教室显示成离线。
+                Subject = Truncate(subject, SubjectMaxLength)!,
+                TeacherName = Truncate(ResolveSubjectTeacher(info.SubjectId, profile), NameMaxLength),
                 WeekParity = parity,
                 WeekCountDiv = plan.TimeRule.WeekCountDiv,
                 WeekCountDivTotal = plan.TimeRule.WeekCountDivTotal,
-                PlanName = plan.Name,
+                PlanName = Truncate(plan.Name, PlanNameMaxLength),
             });
         }
 
         return entries;
     }
 
+    /// <summary>服务端 zod 对各类名称的长度上限（超出会让整批上报 400，所以要截断） */
+    public const int SubjectMaxLength = 40;
+    public const int NameMaxLength = 40;
+    public const int PlanNameMaxLength = 60;
+
+    /// <summary>按服务端上限截断（null / 空串原样返回）</summary>
+    public static string? Truncate(string? value, int max)
+    {
+        if (string.IsNullOrEmpty(value)) return value;
+        var trimmed = value.Trim();
+        return trimmed.Length <= max ? trimmed : trimmed[..max];
+    }
+
     /// <summary>把时间表（TimeLayout）转成本系统的节次时间配置。</summary>
     public static List<TimeLayoutItemDto> MapTimeLayout(TimeLayout layout)
     {
@@ -131,7 +153,8 @@ public static class ScheduleMapper
             items.Add(new TimeLayoutItemDto
             {
                 Index = index + 1,
-                Name = BuildTimePointName(point, ref classPointIndex),
+                // 节次名同样是服务端有上限的字段（max 40），超长会让整批上报失败
+                Name = Truncate(BuildTimePointName(point, ref classPointIndex), NameMaxLength)!,
                 StartTime = ToHhMm(point.StartTime),
                 EndTime = ToHhMm(point.EndTime),
                 Type = ToTimeLayoutType(point.TimeType),

packages/classisland-plugin/src/Views/BridgeSettingsPage.axaml

@@ -26,6 +26,10 @@
                      Watermark="chci_..."
                      PasswordChar="●"
                      Text="{Binding Settings.DeviceToken, Mode=TwoWay}" />
+            <!-- 令牌是设备级长期凭证（只有管理员在 Web 端重置才会失效），而 ClassIsland 的插件配置
+                 是明文 JSON 且会随档案备份/迁移一起被带走，所以这里明确提示用户别外传。 -->
+            <TextBlock Margin="0 6 0 0" TextWrapping="Wrap" Opacity="0.7"
+                       Text="令牌是这台教室机器的长期凭证（仅管理员在 Web 端重置才会失效），会明文保存在本机配置文件里并随 ClassIsland 档案备份一起复制，请不要外传或提交到版本库。" />
 
             <StackPanel Orientation="Horizontal" Margin="0 12 0 0" Spacing="8">
                 <Button Content="立即上报" Command="{Binding ReportCommand}" IsEnabled="{Binding !Bridge.Busy}" />

packages/desktop-client/electron-builder.yml

@@ -2,10 +2,29 @@ appId: com.classhelper.desktop
 productName: 班级小助手
 copyright: Copyright © 2026 Class Helper
 
+# 语言包：Electron 发行版自带 55 个 `locales/*.pak`（实测 48.3MB 未压缩 / 约 10MB 压缩后），
+# 而本应用界面文案只有中文，其余 54 个语言包纯属白占体积（`win-unpacked` 372MB → 约 324MB）。
+# 这是 electron-builder 的官方选项：`app-builder-lib` 的 removeUnusedLanguagesIfNeeded()
+# 会对 `locales/*.pak` 做精确匹配删除，只留 `zh-CN.pak`（0.6MB）。
+#
+# 注意：**不要**为了继续压体积去删 dxcompiler/vk_swiftshader/d3dcompiler_47 这些 GPU 回退组件，
+# 或 LICENSES.chromium.html —— 前者是教室老显卡/虚拟机上的 D3D12/D3D11/Vulkan 渲染回退，
+# 后者是 Chromium 的许可证声明，合计只能再省约 12MB，风险不成比例。
+# 另外安装包有硬底：`班级小助手.exe`（就是 electron.exe）压缩后本身就有 85~90MB，别再指望压到 60MB。
+electronLanguages:
+  - zh-CN
+
 directories:
+  # 这里的 output 只是 electron-builder 的兜底值：scripts/dist-win.mjs 会把它覆盖成
+  # releases/client/<版本>/（与服务端、插件同一约定）。直接手敲 electron-builder 才会落到这里。
   output: release
   buildResources: build
 
+# 注意：这里**不要**加 afterPack 去改 appOutDir 的完整性标签。
+# 归档内部的载荷标签不会被还原（装到正常位置拿到的是默认 Medium 文件），
+# 而在打包前把 appOutDir 改成 Medium 会让 7za（自身带 Low 标签、进程被降到 Low）
+# 因"不能向上读"而无法生成归档。交付物的标签统一在 scripts/dist-win.mjs 收尾时修正。
+
 # 渲染进程产物已由 Vite 打包、主进程/preload 已由 esbuild 打包，
 # 运行时不需要任何 node_modules（electron 模块由 Electron 运行时提供）。
 files:
@@ -26,7 +45,10 @@ win:
       arch: [x64]
     - target: portable
       arch: [x64]
-  # 未提供 build/icon.ico 时使用 Electron 默认图标
+  # 应用/安装包图标。**显式指定**而不是靠 electron-builder 的默认约定（默认找 build/icon.ico）：
+  # 现在生效的是仓库根 build/classhelper.{ico,png}（设计导出、手工放入），
+  # 而 `pnpm icons` 那条 SVG 流水线只会重写 icon.*，两者不打架。
+  icon: build/classhelper.ico
   artifactName: ${productName}-${version}-${arch}.${ext}
 
 nsis:

packages/desktop-client/index.html

@@ -3,7 +3,24 @@
   <head>
     <meta charset="UTF-8" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-    <!-- Electron 渲染进程安全策略：只允许加载本地资源与后端 HTTP/WS 连接 -->
+    <!--
+      内容安全策略（Electron 渲染进程）。
+
+      为什么必须有：渲染进程通过 preload 桥能拿到 `getConfig()` 返回的**明文登录令牌**
+      （代表该班全班身份），因此一旦出现一次注入（未来某个 v-html、某个依赖被投毒），
+      脚本就能把令牌发到外网。CSP 是唯一能拦住"加载并执行远程脚本"的那一层。
+
+      各指令口径：
+      - default-src/script-src 'self'：只允许执行本应用自己的脚本（挡住远程脚本注入）；
+      - style-src 需要 'unsafe-inline'：Vue SFC 与 Element Plus 运行时会注入行内样式；
+      - connect-src 放开 http/https/ws/wss：服务器地址由用户在设置页填写（可能是内网 IP、域名、
+        HTTPS 反代），无法预先枚举，且连接本身不是"执行代码"的入口；
+      - object-src/frame-src/form-action 一律关掉：本应用不需要插件、内嵌页面与表单提交。
+    -->
+    <meta
+      http-equiv="Content-Security-Policy"
+      content="default-src 'self'; script-src 'self'; style-src 'self' 'unsafe-inline'; img-src 'self' data: blob:; font-src 'self' data:; connect-src 'self' http: https: ws: wss:; object-src 'none'; frame-src 'none'; form-action 'none'; base-uri 'self'"
+    />
     <title>班级小助手</title>
   </head>
   <body>

packages/desktop-client/island.html

@@ -3,6 +3,11 @@
   <head>
     <meta charset="UTF-8" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <!-- 与主窗口同一套 CSP（理由见 index.html）：灵动岛同样是持有 preload 桥的渲染进程 -->
+    <meta
+      http-equiv="Content-Security-Policy"
+      content="default-src 'self'; script-src 'self'; style-src 'self' 'unsafe-inline'; img-src 'self' data: blob:; font-src 'self' data:; connect-src 'self' http: https: ws: wss:; object-src 'none'; frame-src 'none'; form-action 'none'; base-uri 'self'"
+    />
     <title>班级小助手 · 灵动岛</title>
     <style>
       /* 透明背景：窗口本身无边框透明，由页面绘制圆角卡片 */

packages/desktop-client/package.json

@@ -1,15 +1,16 @@
 {
   "name": "@classhelper/desktop-client",
-  "version": "0.1.0",
+  "version": "1.1.2",
   "private": true,
   "description": "班级小助手 EXE 客户端（Electron + Vue 3 + Element Plus + Socket.IO + IndexedDB 离线缓存）",
   "author": "Class Helper",
   "main": "dist/main/index.js",
   "scripts": {
     "dev": "node scripts/dev.mjs",
-    "build": "npm run build:main && npm run build:renderer",
+    "build": "node ../../scripts/check-icons.mjs && npm run build:main && npm run build:renderer && npm run check:secrets",
     "build:main": "node scripts/build-main.mjs",
     "build:renderer": "vite build",
+    "check:secrets": "node scripts/check-bundle-secrets.mjs",
     "start": "electron .",
     "smoke": "node scripts/smoke.mjs",
     "typecheck": "vue-tsc --noEmit -p tsconfig.json && tsc --noEmit -p tsconfig.node.json",
@@ -20,7 +21,6 @@
     "@classhelper/shared": "workspace:*",
     "@element-plus/icons-vue": "^2.3.2",
     "axios": "^1.20.0",
-    "echarts": "^6.1.0",
     "element-plus": "^2.14.5",
     "pinia": "^4.0.3",
     "socket.io-client": "^4.8.3",

packages/desktop-client/scripts/check-bundle-secrets.mjs

@@ -0,0 +1,75 @@
+#!/usr/bin/env node
+/**
+ * 构建产物凭据自检：`dist` 里不允许出现种子账号 / 口令字面量。
+ *
+ * 为什么单独立一条门禁：`dist/main/index.js` 与 `dist/renderer/assets/*.js` 会被 electron-builder
+ * 打进 `app.asar`，随安装包发到每台学生机，而 **asar 可以直接解包**。
+ * 冒烟/自检代码里写死 `teacher1 / teacher123` 这类字面量，等于把教师账号随安装包一起发出去
+ * （历史上真的发生过：`grep teacher123 dist/main/index.js` 命中 3 次）。
+ *
+ * 凭据一律由 `scripts/smoke.mjs` / `scripts/verify-packaged.mjs` 通过环境变量提供
+ * （`ELECTRON_SMOKE_USER` / `ELECTRON_SMOKE_PASSWORD` / `ELECTRON_SMOKE_CLASS_CODE` / `..._CLASS_PASSWORD`），
+ * 那两个脚本不进安装包。
+ *
+ * 命中即构建失败（exit 1）。
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const distDir = path.join(root, 'dist');
+
+/** 明确的种子口令：任何情况下都不该出现在产物里 */
+const FORBIDDEN_STRINGS = ['teacher123', 'admin123', 'student123'];
+
+/** 组合形态：把种子班级码 / 默认班级密码当凭据使用的写法 */
+const FORBIDDEN_PATTERNS = [
+  { label: '种子班级码当凭据', pattern: /["'](?:code|classCode)["']\s*[:=]\s*["']G(?:101|102|203)["']/ },
+  {
+    label: '默认班级密码当凭据',
+    pattern: /["'](?:password|classPassword)["']\s*[:=]\s*["']123456["']/,
+  },
+];
+
+/** 递归收集文件（跳过 sourcemap 与二进制） */
+function collectFiles(dir) {
+  const found = [];
+  for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+    const full = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      found.push(...collectFiles(full));
+    } else if (/\.(?:js|mjs|cjs|html|json|css)$/i.test(entry.name)) {
+      found.push(full);
+    }
+  }
+  return found;
+}
+
+if (!fs.existsSync(distDir)) {
+  console.log('[check-secrets] 未找到 dist（尚未构建），跳过凭据自检');
+  process.exit(0);
+}
+
+const hits = [];
+for (const file of collectFiles(distDir)) {
+  const content = fs.readFileSync(file, 'utf8');
+  const relative = path.relative(root, file);
+  for (const needle of FORBIDDEN_STRINGS) {
+    if (content.includes(needle)) hits.push(`${relative}：出现种子口令「${needle}」`);
+  }
+  for (const { label, pattern } of FORBIDDEN_PATTERNS) {
+    if (pattern.test(content)) hits.push(`${relative}：${label}`);
+  }
+}
+
+if (hits.length > 0) {
+  console.error('[check-secrets] 构建产物里出现了种子凭据（asar 可被解包，不能随包分发）：');
+  for (const hit of hits) console.error(`  - ${hit}`);
+  console.error(
+    '\n请把凭据改为从环境变量读取（见 scripts/smoke.mjs 的 ELECTRON_SMOKE_USER 等），不要写进源码。',
+  );
+  process.exit(1);
+}
+
+console.log(`[check-secrets] 通过：${collectFiles(distDir).length} 个产物文件里没有任何种子凭据字面量`);

packages/desktop-client/scripts/dist-win.mjs

@@ -10,9 +10,16 @@
  *
  * 用法：
  *   node scripts/dist-win.mjs            # nsis 安装包 + portable 单文件
- *   node scripts/dist-win.mjs --dir      # 仅生成免安装目录 release/win-unpacked
+ *   node scripts/dist-win.mjs --dir      # 仅生成免安装目录
+ *
+ * 产物统一落到 releases/client/<版本>/（releases/ 不入库，与服务端、插件同级）：
+ *   安装包/   班级小助手-<版本>-x64-setup.exe / -portable.exe（+ .blockmap）
+ *   免安装/   electron-builder 的 win-unpacked 内容
+ *   构建中间/ builder-*.yml、*.nsis.7z
+ * electron-builder 自身的 `directories.output` 由本脚本用 --config 覆盖成上面的版本目录；
+ * 显式传入 `-c.directories.output=...` 时不覆盖，整理（tidyArtifacts）以传入的目录为准。
  */
-import { spawn } from 'node:child_process';
+import { execFileSync, spawn } from 'node:child_process';
 import fs from 'node:fs';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
@@ -24,8 +31,17 @@ const args = process.argv.slice(2);
 const dirOnly = args.includes('--dir');
 const passthrough = args.filter((item) => item !== '--dir');
 
+// makensis 会在 %TEMP% 所在位置建临时文件：Git Bash 里 TEMP=/tmp 是 MSYS 路径，
+// 原生程序会把它当成「当前盘根下的 tmp」（D:\tmp，不存在）而报
+// `!tempfile: Unable to create temporary file!`，NSIS 那一步就失败（磁盘并不紧张）。
+// 统一指到仓库内的真实目录，避开宿主终端带来的环境差异。
+const tmpDir = path.join(repoRoot, '.cache', 'tmp');
+fs.mkdirSync(tmpDir, { recursive: true });
+
 const env = {
   ...process.env,
+  TEMP: tmpDir,
+  TMP: tmpDir,
   ELECTRON_MIRROR: process.env.ELECTRON_MIRROR ?? 'https://cdn.npmmirror.com/binaries/electron/',
   ELECTRON_BUILDER_BINARIES_MIRROR:
     process.env.ELECTRON_BUILDER_BINARIES_MIRROR ??
@@ -50,6 +66,14 @@ if (!fs.existsSync(cli)) {
   process.exit(2);
 }
 
+// 交付产物落到 releases/client/<版本>/（与服务端、插件同一约定；releases/ 不入库）
+const clientVersion = JSON.parse(fs.readFileSync(path.join(root, 'package.json'), 'utf8')).version;
+const explicitOutput = passthrough.find((item) => item.includes('directories.output'));
+const destDir = explicitOutput
+  ? path.resolve(root, explicitOutput.slice(explicitOutput.indexOf('=') + 1))
+  : path.join(repoRoot, 'releases', 'client', clientVersion);
+if (!explicitOutput) overrides.push(`--config.directories.output=${destDir}`);
+
 const cliArgs = [cli, '--win', ...(dirOnly ? ['--dir'] : []), ...overrides, ...passthrough];
 console.log('[dist] electron-builder', cliArgs.slice(1).join(' '));
 
@@ -60,12 +84,94 @@ console.log('[dist] electron-builder', cliArgs.slice(1).join(' '));
 const runtime = resolveNodeRuntime();
 console.log(`[dist] Node 运行时：${runtime.path}（${runtime.version}）`);
 
+// 清理上一轮产物：本仓库目录树带沙箱 ACL（含 Everyone 的 DENY(delete child)），
+// 已存在的产物会被工具（makensis / 7za）判为"Can't open output file / 拒绝访问"而失败，
+// 手动删掉再打包即可 —— 顺手也保证产物集合确定，不会残留上一轮的旧安装包。
+let cleaned = false;
+for (const name of ['win-unpacked', '免安装', '安装包', '构建中间']) {
+  const target = path.join(destDir, name);
+  if (!fs.existsSync(target)) continue;
+  try {
+    fs.rmSync(target, { recursive: true, force: true });
+    cleaned = true;
+  } catch (error) {
+    console.warn(`[dist] 无法清理旧产物 ${name}：${error.message}`);
+  }
+}
+if (cleaned) console.log('[dist] 已清理上一轮的免安装目录 / 安装包 / 构建中间');
+
 const child = spawn(runtime.path, cliArgs, { cwd: root, stdio: 'inherit', env });
 
+/**
+ * 把交付产物的完整性标签修正为 Medium（Windows）。
+ *
+ * 背景（踩过一次，代价是"客户端装不上、便捷版也双击没反应"）：
+ *   本仓库目录树被宿主沙箱打上了 `Low Mandatory Level` 标签（可继承），
+ *   因此在仓库内构建出的 exe 自身也带 Low 标签。Windows 会把这类进程降到 Low 完整性，
+ *   于是 setup.exe 写不进 `%LOCALAPPDATA%`（报"拒绝访问"→ 装不上）、
+ *   便捷版解不出 `%TEMP%`（→ 起不来）；即使装上了，Low 标签的应用文件也会让
+ *   Chromium 的 AppContainer 子进程读不到（0x80000003 秒崩）。
+ *
+ *   要点：**只有交付物自身的标签要紧**。归档内部的载荷标签不会被还原
+ *   （装到正常位置得到的是默认 Medium 文件），所以打包完成后再统一修正即可 ——
+ *   反过来说，不能在打包前把 appOutDir 改成 Medium：那样 7za（自身 Low）
+ *   会因"不能向上读/写"而无法生成归档。
+ */
+function normalizeIntegrityLabel(dir) {
+  if (process.platform !== 'win32') return;
+  const run = (args) => execFileSync('icacls', args, { stdio: 'pipe', windowsHide: true });
+  // 这一行才是"交付物能不能用"的关键，失败必须喊出来
+  try {
+    run([dir, '/setintegritylevel', 'Medium', '/T', '/C']);
+    console.log('[dist] 已把交付物完整性标签修正为 Medium：', dir);
+  } catch (error) {
+    console.warn('[dist] 完整性标签修正失败（交付物可能装不上，见 AGENTS.md §7 第 7 条）：', error.message);
+  }
+  // 目录自身恢复为"继承父目录的 Low"，保证下次构建时带 Low 标签的 7za 仍能写进这个目录。
+  // 宿主目录树本来就没有 Low 标签体系时，这一步会被系统拒绝（保持继承即可），属正常，不提示。
+  try {
+    run([dir, '/setintegritylevel', '(OI)(CI)Low']);
+  } catch {
+    /* 忽略 */
+  }
+}
+
+/**
+ * 把 electron-builder 的原始输出整理成 releases 的固定分层：
+ *   win-unpacked/     → 免安装/
+ *   *.exe / *.blockmap → 安装包/
+ *   *.yml / *.nsis.7z  → 构建中间/
+ * electron-builder 每次都会按自己的布局重写这些路径，因此整理只放在打包成功之后做；
+ * 同名文件用 renameSync 同盘移动，不会产生大文件的额外拷贝。
+ */
+function tidyArtifacts(dir) {
+  if (!fs.existsSync(dir)) return;
+  const moveInto = (from, sub) => {
+    const to = path.join(dir, sub);
+    fs.mkdirSync(to, { recursive: true });
+    fs.renameSync(from, path.join(to, path.basename(from)));
+  };
+
+  const unpacked = path.join(dir, 'win-unpacked');
+  const portableDir = path.join(dir, '免安装');
+  if (fs.existsSync(unpacked)) {
+    fs.rmSync(portableDir, { recursive: true, force: true });
+    fs.renameSync(unpacked, portableDir);
+  }
+
+  for (const name of fs.readdirSync(dir)) {
+    const from = path.join(dir, name);
+    if (!fs.statSync(from).isFile()) continue;
+    if (/\.(exe|blockmap)$/i.test(name)) moveInto(from, '安装包');
+    else if (/\.(yml|7z)$/i.test(name)) moveInto(from, '构建中间');
+  }
+}
+
 child.on('exit', (code) => {
   if (code === 0) {
-    const output = path.join(root, 'release');
+    tidyArtifacts(destDir);
-    console.log('\n[dist] 打包完成，产物目录：', output);
+    normalizeIntegrityLabel(destDir);
+    console.log('\n[dist] 打包完成，产物目录：', destDir);
   }
   process.exit(code ?? 1);
 });

packages/desktop-client/scripts/smoke.mjs

@@ -169,6 +169,10 @@ function launchSmoke(extraEnv) {
         ELECTRON_SMOKE_PROFILE: profileDir,
         ELECTRON_SMOKE_CLASS_CODE: classCredentials?.code ?? '',
         ELECTRON_SMOKE_CLASS_PASSWORD: classCredentials?.password ?? '',
+        // 教师凭据只从这里传入：主进程的冒烟代码从环境变量读，
+        // 因此安装包（app.asar）里不会留下教师口令字面量（本脚本不进安装包）
+        ELECTRON_SMOKE_USER: process.env.ELECTRON_SMOKE_USER ?? 'teacher1',
+        ELECTRON_SMOKE_PASSWORD: process.env.ELECTRON_SMOKE_PASSWORD ?? 'teacher123',
         ...extraEnv,
       }),
     });

packages/desktop-client/src/island/IslandApp.vue

@@ -5,9 +5,12 @@ import {
   ISLAND_SHADOW_PAD,
   ISLAND_SIZE_DELTA,
   ISLAND_SLIVER_WIDTH,
+  PRIORITY_RANK,
+  islandListLayout,
   type IslandAppearance,
   PRIORITY_LABELS,
   formatDate,
+  type IslandListLayout,
   type IslandNotification,
   type IslandNotificationKind,
   type IslandState,
@@ -28,7 +31,9 @@ import { squirclePath } from './squircle.js';
  * - 阴影：只在展开态，`0 2px 3px rgba(0,0,0,.11)`（WinIsland `draw_expanded_shadow`）；
  * - 排版：白字 + alpha 分级（.92/.72/.58），**所有文本 = 基础字号 × 排版系数**，
  *   因此「字号」设置一改，岛内文字整体等比缩放（WinIsland `font_size` 模型）；
- * - 动效：单调缓动（无过冲、无回弹），只有淡入淡出与窗口形变，符合"开合不震动"。
+ * - 动效：**单调缓动（无过冲、无回弹）**，只有淡入淡出与窗口形变，符合"开合不震动"。
+ *   曲线取自共享令牌（`--ch-ease-out`，见 packages/shared/src/motion.ts）；
+ *   刻意**不用** beUI 那几组带过冲的弹簧 —— 理由写在文件末尾"悬停微交互"那段。
  *
  * 窗口尺寸仍由主进程按状态缓动（见 src/main/island.ts），渲染进程负责形状、排版与交互回传。
  */
@@ -39,9 +44,19 @@ const state = ref<IslandState>({
   inClass: false,
   currentPeriodEnd: null,
   reason: null,
+  listExpanded: false,
+  maxCardHeight: 1024,
   updatedAt: 0,
 });
 
+/**
+ * 渲染状态直接来自主进程（**与仓库版一致，不再有"收回"快照层**）。
+ *
+ * 早先这里有一层 `closing`/`closingSnapshot`：点"知道了 / 标为已读"后把卡片按"胶囊摘要"收回再淡出。
+ * 那套是自研的形变状态机，实测在触摸屏（窗口贴合岛体、形变时要动窗口）上会露出旧帧/重影，
+ * 用户明确要求"动画就用仓库里那套"—— 于是整段删掉：收起一律走主进程的 `hide()`（窗口淡出），
+ * 展开/收缩仍是弹簧形变（仓库机制，见 targetSize/progress）。
+ */
 const bridge = window.island;
 
 const notification = computed<IslandNotification | null>(() => state.value.active);
@@ -52,6 +67,48 @@ const isCall = computed(() => kind.value === 'call');
 const isHomework = computed(() => kind.value === 'homework');
 const queueCount = computed(() => state.value.queued.length);
 
+/**
+ * 这一批**未处理**的消息（正在展示的 + 队列里的），按「重要程度 → 时间」排序。
+ * 与主进程 `pendingNotifications()` 同一口径（同一份 `PRIORITY_RANK`）。
+ */
+const pendingNotifications = computed<IslandNotification[]>(() => {
+  const list: IslandNotification[] = [];
+  if (state.value.active) list.push(state.value.active);
+  for (const item of state.value.queued) {
+    if (!list.some((existing) => existing.id === item.id)) list.push(item);
+  }
+  return list.sort((a, b) => {
+    const rank = (PRIORITY_RANK[b.priority] ?? 0) - (PRIORITY_RANK[a.priority] ?? 0);
+    if (rank !== 0) return rank;
+    return String(b.createdAt ?? '').localeCompare(String(a.createdAt ?? ''));
+  });
+});
+
+const pendingCount = computed(() => pendingNotifications.value.length);
+
+/**
+ * 多条消息时的**列表布局**：显示几条、要不要"展开更多"、卡片多高。
+ * 与主进程用同一个 `islandListLayout`（同一份度量）—— 主进程据此把窗口长高，两边必须算出一个数。
+ */
+const listLayout = computed<IslandListLayout | null>(() => {
+  if (mode.value !== 'expanded' || pendingCount.value < 2) return null;
+  return islandListLayout({
+    count: pendingCount.value,
+    fontSize: appearance.value.fontSize,
+    maxHeight: state.value.maxCardHeight,
+    expanded: state.value.listExpanded,
+  });
+});
+
+const isListMode = computed(() => listLayout.value !== null);
+/** 列表里实际渲染出来的通知 */
+const listItems = computed<IslandNotification[]>(() =>
+  listLayout.value ? pendingNotifications.value.slice(0, listLayout.value.rows) : [],
+);
+/** 没能展示出来的条数（点"展开更多"能看到一部分，剩下的只能去应用里看） */
+const hiddenCount = computed(() => Math.max(0, pendingCount.value - listItems.value.length));
+const listHint = computed<IslandListLayout['hint']>(() => listLayout.value?.hint ?? null);
+
 /** 胶囊标题：按消息类型区分（新消息 / 新作业 / 叫人） */
 const pillTitle = computed(() => {
   if (isCall.value) return '老师叫你';
@@ -72,23 +129,12 @@ const TYPE_LABELS: Record<IslandNotificationKind, string> = {
 /** 汇总展示顺序：叫人 > 作业 > 通知（与用户示例一致） */
 const TYPE_ORDER: IslandNotificationKind[] = ['call', 'homework', 'notification'];
 
-const pendingNotifications = computed<IslandNotification[]>(() => {
-  const list: IslandNotification[] = [];
-  if (state.value.active) list.push(state.value.active);
-  for (const item of state.value.queued) {
-    if (!list.some((existing) => existing.id === item.id)) list.push(item);
-  }
-  return list;
-});
-
 /** 这批未处理消息覆盖了哪些类型（按"叫人/作业/通知"顺序） */
 const pendingTypes = computed<string[]>(() => {
   const kinds = new Set(pendingNotifications.value.map((item) => item.kind ?? 'notification'));
   return TYPE_ORDER.filter((item) => kinds.has(item)).map((item) => TYPE_LABELS[item]);
 });
 
-const pendingCount = computed(() => pendingNotifications.value.length);
-
 /** 多条消息时把类型摊开：`新消息：叫人/作业/通知（共 3 条）` */
 const pillSummaryTitle = computed(() => {
   if (pendingCount.value <= 1) return pillTitle.value;
@@ -122,6 +168,45 @@ const subtitle = computed(() => {
 /** 叫人消息下方的附加说明（例如"请到办公室找我"） */
 const callHint = computed(() => notification.value?.subtitle ?? '');
 
+/**
+ * 是否显示「标为已读」。
+ *
+ * 作业卡片的 id 是本地合成的 `homework-<作业id>`（见 renderer/island/bridge.ts），
+ * 库里并没有这条通知，点它会让通知中心去调 `POST /notifications/homework-xxx/read` 并弹「通知不存在」。
+ * 因此作业卡不提供该按钮（它本来也不是"通知"，用「知道了」收起即可）。
+ * 列表形态下只要**至少有一条真通知**就提供（作业行会被主进程按 kind 过滤掉）。
+ */
+const canMarkRead = computed(() => {
+  if (isListMode.value) {
+    return pendingNotifications.value.some((item) => item.kind !== 'homework');
+  }
+  return notification.value?.kind !== 'homework';
+});
+
+/** 列表里单行的类型（徽标/图标配色） */
+function rowKind(item: IslandNotification): IslandNotificationKind {
+  return item.kind ?? 'notification';
+}
+
+function rowBadgeText(item: IslandNotification): string {
+  const itemKind = rowKind(item);
+  if (itemKind === 'call') return '叫人';
+  if (itemKind === 'homework') return '新作业';
+  return PRIORITY_LABELS[item.priority] ?? item.priority;
+}
+
+function rowBadgeClass(item: IslandNotification): string {
+  const itemKind = rowKind(item);
+  if (itemKind === 'call') return 'badge-call';
+  if (itemKind === 'homework') return 'badge-homework';
+  return `badge-${item.priority.toLowerCase()}`;
+}
+
+function rowSubText(item: IslandNotification): string {
+  const teacher = item.teacherName ? `${item.teacherName} · ` : '';
+  return `${teacher}${formatDate(item.createdAt, true)}`;
+}
+
 /** 下课补发时提示"其实上课期间就到了" */
 const showAfterClassHint = computed(() => state.value.reason === 'after-class' && !state.value.inClass);
 
@@ -150,10 +235,20 @@ function onCardClick(event: MouseEvent): void {
 }
 
 function dismiss(): void {
-  bridge?.sendAction('dismiss');
+  // 多条消息时"知道了"是**整批**处理：卡片上就一排按钮，点它就是把这批都放下去
+  bridge?.sendAction(isListMode.value ? 'dismiss-all' : 'dismiss');
+}
+
+/** "展开更多"：把列表铺到屏幕放得下的程度（主进程负责把窗口长高） */
+function expandList(): void {
+  bridge?.sendAction('expand-list');
 }
 
 function markRead(): void {
+  if (isListMode.value) {
+    bridge?.sendAction('mark-all-read');
+    return;
+  }
   if (notification.value) bridge?.sendAction('mark-read', notification.value.id);
 }
 
@@ -184,6 +279,9 @@ function targetSize(): { width: number; height: number } {
     return { width: ISLAND_SLIVER_WIDTH, height: Math.max(12, Math.min(28, height - 22)) };
   }
   if (mode.value !== 'expanded') return { width, height };
+  // 多条消息的列表：高度由共享的列表布局算出（与主进程算的窗口包围盒同一个数）
+  const layout = listLayout.value;
+  if (layout) return { width: width + EXTRA.expanded.width, height: layout.height };
   const extra = isCall.value ? EXTRA.call : isUrgent.value ? EXTRA.urgent : EXTRA.expanded;
   return { width: width + extra.width, height: height + extra.height };
 }
@@ -324,6 +422,12 @@ const expandedAlpha = computed(() => progress.value * progress.value);
  * 岛在**固定窗口**内的定位（照搬 WinIsland：窗口不动，岛在画布内居中/贴边形变）。
  * 水平：居中锚点用 `left: 50% + translateX(-50%)`；左/右锚点贴边（留阴影余量）。
  */
+/** 水平锚点（供 CSS 决定胶囊内容贴哪条边：左贴左、右贴右、居中则居中对齐） */
+const anchorName = computed<'left' | 'center' | 'right'>(() => {
+  const position = appearance.value.position;
+  return position.endsWith('left') ? 'left' : position.endsWith('right') ? 'right' : 'center';
+});
+
 const islandStyle = computed(() => {
   const position = appearance.value.position;
   const style: Record<string, string> = {
@@ -484,6 +588,18 @@ function applyAppearance(next: IslandAppearance | null | undefined): void {
 
 onMounted(async () => {
   window.addEventListener('mousemove', (event) => updateInteractive(event.clientX, event.clientY));
+  /**
+   * 触摸屏上报：主进程据此把窗口改为**贴合岛体**并始终接收输入。
+   *
+   * 为什么必须报：触摸屏上"点不开"是机制性的 —— 打开命中的两条链路（本进程的 mousemove 转发、
+   * 主进程读系统光标）都以"鼠标指针移动"为前提，而手指触摸既不产生 mousemove、也不移动系统光标，
+   * 窗口会永远停在 `setIgnoreMouseEvents(true)` 的穿透态，手指点下去只落到桌面。
+   * Chromium 在带触摸数字化仪的机器上会把 `maxTouchPoints` 置为非 0，用它当判据。
+   */
+  const reportTouchMode = (): void => bridge?.setTouchMode?.(true);
+  if ((navigator.maxTouchPoints ?? 0) > 0) reportTouchMode();
+  // 兜底：个别设备 maxTouchPoints 判定不到（或接的是外接触摸屏），真收到触摸事件时再补报一次
+  window.addEventListener('touchstart', reportTouchMode, { passive: true, once: true });
   // 心跳：主进程据此判断本渲染进程是否还活着。一旦卡死/崩溃，主进程会隐藏这扇"幽灵窗口"
   // 并重建（否则 Windows 会把最后一帧留在屏幕上：岛看着还在，怎么点都没反应）。
   bridge?.alive?.();
@@ -516,6 +632,7 @@ onMounted(async () => {
     <div
       class="island-card"
       :class="islandClass"
+      :data-anchor="anchorName"
       :data-style="appearance.style"
       :style="islandStyle"
       @click="mode === 'expanded' ? onCardClick($event) : expand()"
@@ -540,6 +657,12 @@ onMounted(async () => {
 
         <!-- 胶囊层（WinIsland compact）：进度 > 2/3 时完全退净 -->
         <span class="layer pill-layer" :style="{ opacity: pillAlpha }">
+          <!--
+            胶囊内容固定成"胶囊自己的几何"（宽 = 外观宽度、贴合停靠边/中线）：
+            卡片在开合时会变宽变窄，若让内容跟着卡片宽度走，文字会先按宽卡片铺开、
+            再随卡片变窄被省略号收回（用户反馈的"新消息那行字往右跳一下再缩回"）。
+          -->
+          <span class="pill-inner">
           <span class="pill-icon" :class="{ urgent: isUrgent, call: isCall, homework: isHomework }">
             <svg v-if="isHomework" viewBox="0 0 24 24" aria-hidden="true">
               <path
@@ -583,11 +706,19 @@ onMounted(async () => {
               </svg>
             </span>
           </span>
+        </span>
 
         <!-- 展开层（WinIsland expanded）：进度²淡入 -->
-        <span class="layer expanded-layer" :style="{ opacity: expandedAlpha }">
+        <span
+          class="layer expanded-layer"
+          :class="{ 'list-mode': isListMode }"
+          :style="{ opacity: expandedAlpha }"
+        >
           <header class="head">
-            <span class="head-icon" :class="{ urgent: isUrgent, call: isCall, homework: isHomework }">
+            <span
+              class="head-icon"
+              :class="{ urgent: isUrgent, call: isCall, homework: isHomework, list: isListMode }"
+            >
               <svg v-if="isHomework" viewBox="0 0 24 24" aria-hidden="true">
                 <path
                   fill="currentColor"
@@ -608,11 +739,19 @@ onMounted(async () => {
               </svg>
             </span>
             <div class="head-meta">
-              <span class="badge" :class="badgeClass">{{ badgeText }}</span>
+              <span class="badge" :class="isListMode ? 'badge-normal' : badgeClass">
+                {{ isListMode ? `共 ${pendingCount} 条` : badgeText }}
+              </span>
+              <template v-if="isListMode">
+                <span v-if="pendingTypes.length > 1" class="head-sub">{{ pendingTypes.join(' / ') }}</span>
+                <span v-else class="head-sub">按重要程度排列</span>
+              </template>
+              <template v-else>
                 <span v-if="isCall" class="live-dot call">老师正在等你</span>
                 <span v-else-if="isUrgent" class="live-dot">需立即查看</span>
                 <span v-else-if="showAfterClassHint" class="live-dot muted">下课后补发</span>
                 <span class="head-sub">{{ subtitle }}</span>
+              </template>
             </div>
             <button type="button" class="icon-btn" title="收起" @click.stop="collapse">
               <svg viewBox="0 0 24 24" aria-hidden="true">
@@ -627,21 +766,75 @@ onMounted(async () => {
             </button>
           </header>
 
+          <!-- 多条消息：竖向排列，按重要程度排序，默认只显示前三条 -->
+          <template v-if="isListMode">
+            <h3 class="title">{{ pendingCount }} 条待处理通知</h3>
+            <div class="body list-body">
+              <button
+                v-for="item in listItems"
+                :key="item.id"
+                type="button"
+                class="list-row"
+                :title="`打开应用查看：${item.title}`"
+                @click.stop="openApp"
+              >
+                <span class="row-icon" :class="rowKind(item)">
+                  <svg v-if="rowKind(item) === 'homework'" viewBox="0 0 24 24" aria-hidden="true">
+                    <path
+                      fill="currentColor"
+                      d="M6 3h9a3 3 0 0 1 3 3v13.5a.5.5 0 0 1-.75.43L15 18.5l-2.25 1.43a.5.5 0 0 1-.53 0L10 18.5l-2.25 1.43a.5.5 0 0 1-.53 0L5 18.5V5a2 2 0 0 1 1-2Zm2 4v1.6h7V7H8Zm0 3.4V12h7v-1.6H8Z"
+                    />
+                  </svg>
+                  <svg v-else-if="rowKind(item) === 'call'" viewBox="0 0 24 24" aria-hidden="true">
+                    <path
+                      fill="currentColor"
+                      d="M4 10v4a1 1 0 0 0 1 1h2l4 3.5a1 1 0 0 0 1.65-.76V5.26A1 1 0 0 0 11 4.5L7 8H5a1 1 0 0 0-1 1Zm12.5-2.9a1 1 0 0 1 1.4.1 8 8 0 0 1 0 9.6 1 1 0 1 1-1.5-1.3 6 6 0 0 0 0-7 1 1 0 0 1 .1-1.4Z"
+                    />
+                  </svg>
+                  <svg v-else viewBox="0 0 24 24" aria-hidden="true">
+                    <path
+                      fill="currentColor"
+                      d="M12 2a6 6 0 0 0-6 6v3.1L4.6 14a1 1 0 0 0 .9 1.5h13a1 1 0 0 0 .9-1.5L18 11.1V8a6 6 0 0 0-6-6Zm0 20a3 3 0 0 0 3-2.6H9A3 3 0 0 0 12 22Z"
+                    />
+                  </svg>
+                </span>
+                <span class="row-text">
+                  <span class="row-title">{{ item.title }}</span>
+                  <span class="row-sub">{{ rowSubText(item) }}</span>
+                </span>
+                <span class="row-badge" :class="rowBadgeClass(item)">{{ rowBadgeText(item) }}</span>
+              </button>
+              <!-- 还有没显示出来的：能展开就"展开更多"，屏幕到任务栏了就只能去应用里看 -->
+              <div v-if="listHint" class="list-hint">
+                <button v-if="listHint === 'more'" type="button" class="more-btn" @click.stop="expandList">
+                  展开更多（还有 {{ hiddenCount }} 条）
+                </button>
+                <span v-else class="more-app">更多请前往应用内操作</span>
+              </div>
+            </div>
+          </template>
+
+          <template v-else>
             <h3 class="title">{{ notification?.title ?? '' }}</h3>
             <div class="body">
               <p class="content-text">{{ notification?.content ?? '' }}</p>
               <p v-if="callHint" class="call-hint">{{ callHint }}</p>
               <p v-else-if="notification?.subtitle" class="call-hint">{{ notification?.subtitle }}</p>
             </div>
+          </template>
 
+          <!-- 一排按钮（多条消息时也是这一排）：展开态的操作都收在这里 -->
           <footer class="foot">
-            <span v-if="queueCount > 0" class="more">还有 {{ queueCount }} 条通知</span>
+            <span v-if="isListMode" class="more">共 {{ pendingCount }} 条待处理</span>
+            <span v-else-if="queueCount > 0" class="more">还有 {{ queueCount }} 条通知</span>
             <span v-else class="more muted">来自班级小助手</span>
             <span class="actions">
               <button type="button" class="ghost-btn" @click.stop="openApp">打开应用</button>
-              <button type="button" class="ghost-btn" @click.stop="markRead">标为已读</button>
+              <button v-if="canMarkRead" type="button" class="ghost-btn" @click.stop="markRead">
+                标为已读
+              </button>
               <button type="button" class="solid-btn" @click.stop="dismiss">
-                {{ isCall ? '收到' : '知道了' }}
+                {{ isCall && !isListMode ? '收到' : '知道了' }}
               </button>
             </span>
           </footer>
@@ -743,6 +936,16 @@ body {
   fill: var(--wn-bg);
   stroke: var(--wn-border);
   stroke-width: 1;
+  /*
+    投影**始终声明**，形态切换只改参数 —— 不要写成"只在 .expanded 上挂 filter"。
+    给元素加 / 去 CSS filter 会让 Chromium 新建或销毁它的渲染表面（effect node），
+    而首帧的合成可能发生在新表面栅格化完成之前，那一帧会被当作空内容画出去；
+    卡片的底色恰恰就画在这个被过滤的元素上（fill 在本元素），于是**开/合的那一瞬间
+    底座会闪掉一帧、只剩未过滤的文字层**（用户反馈的"开合时一瞬间的闪动"）。
+    胶囊态用 0 0 0：硬轮廓投影正好压在路径底下，肉眼等同无投影，与 WinIsland
+    "只有展开态有投影"的观感一致。
+  */
+  filter: drop-shadow(0 var(--card-shadow-y, 0px) var(--card-shadow-blur, 0px) rgba(0, 0, 0, 0.11));
 }
 
 /* 内容层裁切到同一形状内；内部两层（胶囊层 / 展开层）交叉淡入 */
@@ -767,9 +970,11 @@ body {
   pointer-events: auto;
 }
 
-/* 展开态投影（WinIsland: rgba(0,0,0,.11)、y+2、σ=3 → CSS 0 2px 3px） */
+/* 展开态投影（WinIsland: rgba(0,0,0,.11)、y+2、σ=3 → CSS 0 2px 3px）。
+   只改参数、不动 filter 声明本身，理由见上面的 .shape path。 */
 .island-card.expanded .shape path {
-  filter: drop-shadow(0 2px 3px rgba(0, 0, 0, 0.11));
+  --card-shadow-y: 2px;
+  --card-shadow-blur: 3px;
 }
 
 /* 状态色：只做"内层微染 + 描边"，不外溢（保持桌面干净，也不会有光晕硬边） */
@@ -809,10 +1014,40 @@ body {
 .pill-layer {
   flex-direction: row;
   align-items: center;
+  /* 水平对齐交给 .pill-inner（它固定为胶囊几何，且按停靠方式贴边/居中） */
+  justify-content: flex-start;
+}
+
+/**
+ * 胶囊内容盒：**固定为胶囊自己的宽高与内边距**，不随卡片形变重排。
+ *
+ * 为什么必须固定：卡片在开合时 268 ⇄ 424 变宽变窄，而中心停靠下卡片的左右边都会动。
+ * 内容若跟着卡片宽度走，就会出现"文字先按宽卡片铺开、再随卡片收窄被省略号收回"
+ * （用户反馈的"新消息那行字往右跳一下再缩回"），底部也会被收缩的形状裁掉一块。
+ * 固定成胶囊几何后：文字在整段动画里位置与省略号都不变，只是随卡片一起淡出/淡入。
+ *
+ * 贴哪条边与卡片停靠方式一致（左停靠贴左、右停靠贴右、居中则居中对齐）——
+ * 这样卡片变宽时内容也不会横移，静止态外观与之前完全一致。
+ */
+.pill-inner {
+  display: inline-flex;
+  flex-direction: row;
+  align-items: center;
+  flex: 0 0 auto;
   gap: calc(var(--island-font, 13px) * 0.62);
+  width: var(--island-w, 268px);
+  height: 100%;
   padding: 0 calc(var(--island-font, 13px) * 0.78);
 }
 
+.island-card[data-anchor='center'] .pill-layer {
+  justify-content: center;
+}
+
+.island-card[data-anchor='right'] .pill-layer {
+  justify-content: flex-end;
+}
+
 .pill-icon {
   display: inline-flex;
   align-items: center;
@@ -912,6 +1147,158 @@ body {
   justify-content: center;
 }
 
+/*
+ * 多条通知的列表形态。
+ *
+ * 这里的每个尺寸都必须与 @classhelper/shared 的 `ISLAND_LIST_METRICS` 一一对应：
+ * 主进程按那份度量算出**窗口包围盒**（列表比普通展开卡高，窗口不够高会把底部按钮裁掉），
+ * 渲染进程按同一份度量排布。改这里就必须改那里，否则会出现"最后一行被切掉"。
+ * 选择器一律写成 `.expanded-layer.list-mode ...`（比基类的单类选择器更具体），
+ * 免得被后面定义的 `.title` / `.body` 覆盖掉尺寸——那样高度就对不上算出来的值了。
+ */
+.expanded-layer.list-mode {
+  /* 高度已经算准，改 flex-start：居中排版一旦有像素级误差会把上下两端同时切掉 */
+  justify-content: flex-start;
+}
+
+.expanded-layer.list-mode .head {
+  height: calc(var(--island-font, 13px) * 1.7);
+}
+
+.expanded-layer.list-mode .title {
+  flex: 0 0 auto;
+  display: block;
+  height: calc(var(--island-font, 13px) * 1.4);
+  line-height: 1.4;
+  -webkit-line-clamp: unset;
+  white-space: nowrap;
+  overflow: hidden;
+  text-overflow: ellipsis;
+}
+
+.expanded-layer.list-mode .body {
+  flex: 1 1 auto;
+  min-height: 0;
+  gap: calc(var(--island-font, 13px) * 0.4);
+  justify-content: flex-start;
+  overflow: hidden;
+}
+
+.head-icon.list {
+  background: color-mix(in srgb, var(--island-accent) 20%, transparent);
+  color: var(--island-accent);
+}
+
+.list-row {
+  display: flex;
+  align-items: center;
+  gap: calc(var(--island-font, 13px) * 0.55);
+  flex: 0 0 auto;
+  width: 100%;
+  height: calc(var(--island-font, 13px) * 2.7);
+  padding: 0 calc(var(--island-font, 13px) * 0.6);
+  border: none;
+  border-radius: calc(var(--island-font, 13px) * 0.5);
+  background: rgba(255, 255, 255, 0.045);
+  color: var(--wn-text-1);
+  text-align: left;
+  cursor: pointer;
+  transition: background var(--ch-dur-fast) var(--ch-ease-out);
+}
+
+.row-icon {
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  flex: 0 0 auto;
+  width: calc(var(--island-font, 13px) * 1.3);
+  height: calc(var(--island-font, 13px) * 1.3);
+  border-radius: calc(var(--island-font, 13px) * 0.36);
+  background: var(--wn-surface);
+  color: var(--wn-text-2);
+}
+
+.row-icon svg {
+  width: calc(var(--island-font, 13px) * 0.86);
+  height: calc(var(--island-font, 13px) * 0.86);
+}
+
+.row-icon.call {
+  color: #ff9f0a;
+}
+
+.row-icon.homework {
+  color: var(--island-accent);
+}
+
+.row-text {
+  display: flex;
+  flex-direction: column;
+  justify-content: center;
+  gap: 1px;
+  min-width: 0;
+  flex: 1 1 auto;
+}
+
+.row-title {
+  font-size: calc(var(--island-font, 13px) * 0.9);
+  font-weight: 600;
+  line-height: 1.2;
+  white-space: nowrap;
+  overflow: hidden;
+  text-overflow: ellipsis;
+}
+
+.row-sub {
+  font-size: calc(var(--island-font, 13px) * 0.68);
+  line-height: 1.1;
+  color: var(--wn-text-3);
+  white-space: nowrap;
+  overflow: hidden;
+  text-overflow: ellipsis;
+}
+
+.row-badge {
+  display: inline-flex;
+  align-items: center;
+  flex: 0 0 auto;
+  height: calc(var(--island-font, 13px) * 1.25);
+  padding: 0 calc(var(--island-font, 13px) * 0.5);
+  border-radius: 999px;
+  font-size: calc(var(--island-font, 13px) * 0.68);
+  font-weight: 600;
+  background: rgba(255, 255, 255, 0.12);
+  color: rgba(255, 255, 255, 0.78);
+}
+
+/* 列表底部的提示行：能展开时是按钮，屏幕到任务栏了就是一句"去应用里看" */
+.list-hint {
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  flex: 0 0 auto;
+  height: calc(var(--island-font, 13px) * 2.1);
+}
+
+.more-btn {
+  border: none;
+  background: var(--wn-surface);
+  color: var(--wn-text-1);
+  height: 100%;
+  width: 100%;
+  border-radius: calc(var(--island-font, 13px) * 0.5);
+  font-size: calc(var(--island-font, 13px) * 0.76);
+  font-weight: 600;
+  cursor: pointer;
+  transition: background var(--ch-dur-fast) var(--ch-ease-out);
+}
+
+.more-app {
+  font-size: calc(var(--island-font, 13px) * 0.76);
+  color: var(--wn-text-3);
+  white-space: nowrap;
+}
+
 .head {
   display: flex;
   align-items: center;
@@ -1037,13 +1424,8 @@ body {
   cursor: pointer;
   flex: 0 0 auto;
   transition:
-    background 0.15s ease,
+    background var(--ch-dur-fast) var(--ch-ease-out),
-    color 0.15s ease;
+    color var(--ch-dur-fast) var(--ch-ease-out);
-}
-
-.icon-btn:hover {
-  background: var(--wn-surface-hover);
-  color: #fff;
 }
 
 .icon-btn svg {
@@ -1128,8 +1510,8 @@ body {
   cursor: pointer;
   white-space: nowrap;
   transition:
-    background 0.15s ease,
+    background var(--ch-dur-fast) var(--ch-ease-out),
-    transform 0.12s ease;
+    transform var(--ch-dur-instant) var(--ch-ease-out);
 }
 
 .ghost-btn {
@@ -1137,10 +1519,6 @@ body {
   color: var(--wn-text-1);
 }
 
-.ghost-btn:hover {
-  background: var(--wn-surface-hover);
-}
-
 .solid-btn {
   background: #ffffff;
   color: #0b0b0f;
@@ -1161,35 +1539,40 @@ body {
   transform: scale(0.97);
 }
 
-/* ---------------------------------------------------------------- 过渡（无缩放、无回弹） */
+/* --------------------------------------------------------------- 悬停微交互
-
+ *
-.island-instant-enter-active {
+ * **必须关在 `@media (hover: hover) and (pointer: fine)` 里**：教室机器上的希沃触摸屏
-  transition: none;
+ * 点一下会产生"幽灵 hover"并**一直粘着**，直到点别处才消失 —— 不关的话，点过「知道了」
+ * 的按钮会永远保持高亮（同 AGENTS.md §5 第 30 条那类问题）。
+ * 这是 beUI `useHoverCapable` 的 CSS 版：纯样式效果用媒体查询就够，不必挂 composable。
+ */
+@media (hover: hover) and (pointer: fine) {
+  .list-row:hover {
+    background: var(--wn-surface);
   }
 
-.island-instant-enter-from {
+  .more-btn:hover,
-  opacity: 1;
+  .ghost-btn:hover {
+    background: var(--wn-surface-hover);
   }
 
-.island-instant-leave-active {
+  .icon-btn:hover {
-  transition: opacity calc(var(--island-dur, 320ms) * 0.28) ease-out;
+    background: var(--wn-surface-hover);
+    color: #ffffff;
+  }
 }
 
-.island-instant-leave-to {
+/*
-  opacity: 0;
+ * 关于本岛的动效：**只有单调缓动（无过冲、无回弹）**，曲线取自共享令牌
-}
+ * （`--ch-ease-out`，见 packages/shared/src/motion.ts）。
-
+ *
-/* 展开 / 收回：只做淡入淡出，形变交给窗口尺寸（避免任何缩放回弹"震动"） */
+ * 这里刻意**不用** beUI 那几组弹簧：弹簧带过冲，而本岛的形变由主进程按状态缓动窗口尺寸
-.island-fade-enter-active {
+ * （`src/main/island.ts`），任何回弹都会让"开合"看起来在震动 ——
-  transition: opacity calc(var(--island-dur, 320ms) * 0.45) ease-out;
+ * 冒烟断言「展开过程不震动」「收回过程不抖动」逐帧采样岛体几何，正是为这条立的规矩。
-}
+ * 岛的物理是自己的一套（`./spring.ts`，从 WinIsland 逐行移植），不该被换掉。
-
+ *
-.island-fade-leave-active {
+ * （这里原本还有 `.island-instant-*` / `.island-fade-*` 两组过渡类 —— 它们**是死规则**：
-  transition: opacity calc(var(--island-dur, 320ms) * 0.3) ease-out;
+ * 全包只有 `<style>` 里出现，没有任何地方挂类名，是 §5 第 34 条删掉"收回快照"动画后的残留。
-}
+ * 已删除，免得后人以为岛上存在一层 Vue `<Transition>`。）
-
+ */
-.island-fade-enter-from,
-.island-fade-leave-to {
-  opacity: 0;
-}
 </style>

packages/desktop-client/src/island/main.ts

@@ -1,5 +1,6 @@
 import { createApp } from 'vue';
 import IslandApp from './IslandApp.vue';
+import { applyMotionTokens } from '../renderer/composables/motion.js';
 
 /**
  * 灵动岛渲染进程入口。
@@ -8,6 +9,19 @@ import IslandApp from './IslandApp.vue';
  */
 const app = createApp(IslandApp);
 
+/**
+ * 动效令牌（beUI 的缓动曲线，见 packages/shared/src/motion.ts）写进 `:root`。
+ *
+ * **必须在这里也注入一次**：灵动岛是**另一个渲染进程**，不共享主窗口的 `:root`。
+ * 而 `IslandApp.vue` 的悬停微交互引用了 `var(--ch-dur-fast)` / `var(--ch-ease-out)`——
+ * 变量缺席会让整条 `transition` 简写失效（自定义属性解析不出来 → 声明作废），
+ * 结果是**完全没有过渡**，比改造前还差。
+ *
+ * 成本可控：多出来的是共享模块里的令牌常量与弹簧积分（约 2KB），
+ * 相比岛内已经打包的 Vue 可以忽略；换来的是"两端一岛同一套曲线、不各抄一份"。
+ */
+applyMotionTokens();
+
 app.config.errorHandler = (error) => {
   console.error('[island] 渲染异常', error);
 };

packages/desktop-client/src/main/config.ts

@@ -12,6 +12,7 @@ import {
   type ClassIslandNotificationChannel,
   type IslandAppearance,
 } from '@classhelper/shared';
+import { logger } from './logger.js';
 import type { DesktopStoredConfig, HomeworkBoardSettings } from '../types/desktop.js';
 
 /** 作业页展示偏好默认值（看板 + 不显示时间 + 15px） */
@@ -35,6 +36,14 @@ interface PersistedConfig {
   notificationChannel?: ClassIslandNotificationChannel;
   /** 作业录入快捷短语（向后兼容：旧配置没有该字段时用默认那一组） */
   homeworkPhrases?: string[];
+  /** 是否已看过初次启动引导（向后兼容：旧配置没有该字段视为没看过，首启弹一次） */
+  onboardingDone?: boolean;
+  /** 界面主题（向后兼容：旧配置没有该字段用浅色） */
+  theme?: 'light' | 'dark';
+  /** 主侧边栏是否折叠（向后兼容：旧配置没有该字段视为展开） */
+  sidebarCollapsed?: boolean;
+  /** 用户选择「忽略此版本」的版本号（向后兼容：旧配置没有该字段视为没忽略过任何版本） */
+  ignoredUpdateVersion?: string;
 }
 
 const DEFAULT_CONFIG: PersistedConfig = {
@@ -46,8 +55,17 @@ const DEFAULT_CONFIG: PersistedConfig = {
   homeworkBoard: { ...DEFAULT_HOMEWORK_BOARD },
   notificationChannel: DEFAULT_CLASSISLAND_NOTIFICATION_CHANNEL,
   homeworkPhrases: [...HOMEWORK_PHRASE_DEFAULTS],
+  onboardingDone: false,
+  theme: 'light',
+  sidebarCollapsed: false,
+  ignoredUpdateVersion: '',
 };
 
+/** 主题白名单：非法值一律回落浅色 */
+function normalizeTheme(input?: 'light' | 'dark'): 'light' | 'dark' {
+  return input === 'dark' ? 'dark' : 'light';
+}
+
 /**
  * 作业快捷短语的合法化：去空白、去重、限长限量。
  * 空数组是**合法值**（老师把短语全删了 = 不想用快捷短语），因此不能拿默认值顶回去。
@@ -142,8 +160,15 @@ function encryptToken(token: string | null): { token: string | null; tokenEncryp
       return { token: safeStorage.encryptString(token).toString('base64'), tokenEncrypted: true };
     }
   } catch {
-    // 某些环境下 DPAPI 不可用，降级为明文存储（仅本地开发场景）
+    // 见下方降级分支
   }
+  // 降级为明文存储（DPAPI 不可用，一般只在本地开发环境出现）。
+  // 必须留下日志：明文 token 代表该班的全班身份，任何能读用户目录的进程/备份/同步盘都能拿到，
+  // 静默降级会让"为什么换个环境就得重新登录/凭据是怎么泄露的"无从查起。
+  logger.warn(
+    `系统加密存储不可用，登录令牌将以**明文**写入配置（${configFilePath()}）；` +
+      '如需加密请确认 Windows 凭据保护（DPAPI）可用',
+  );
   return { token, tokenEncrypted: false };
 }
 
@@ -157,14 +182,14 @@ function decryptToken(raw: PersistedConfig): string | null {
   }
 }
 
-function readPersisted(): PersistedConfig {
+function readPersistedFromDisk(): PersistedConfig {
   try {
     const content = fs.readFileSync(configFilePath(), 'utf8');
     const parsed = JSON.parse(content) as Partial<PersistedConfig>;
     return {
       serverUrl:
         typeof parsed.serverUrl === 'string' && parsed.serverUrl
-          ? parsed.serverUrl
+          ? (normalizeServerUrl(parsed.serverUrl) ?? DEFAULT_CONFIG.serverUrl)
           : DEFAULT_CONFIG.serverUrl,
       username: typeof parsed.username === 'string' ? parsed.username : '',
       token: typeof parsed.token === 'string' ? parsed.token : null,
@@ -173,38 +198,181 @@ function readPersisted(): PersistedConfig {
       homeworkBoard: normalizeHomeworkBoard(parsed.homeworkBoard),
       notificationChannel: normalizeNotificationChannel(parsed.notificationChannel),
       homeworkPhrases: normalizeHomeworkPhrases(parsed.homeworkPhrases),
+      onboardingDone: parsed.onboardingDone === true,
+      theme: normalizeTheme(parsed.theme),
+      sidebarCollapsed: parsed.sidebarCollapsed === true,
+      ignoredUpdateVersion:
+        typeof parsed.ignoredUpdateVersion === 'string' ? parsed.ignoredUpdateVersion : '',
     };
   } catch {
     return { ...DEFAULT_CONFIG };
   }
 }
 
-function writePersisted(config: PersistedConfig): void {
+/* ------------------------------------------------------------ 内存缓存 + 异步合并写
-  const target = configFilePath();
+ *
-  fs.mkdirSync(path.dirname(target), { recursive: true });
+ * 为什么不能每次 saveConfig 都同步读写盘（原来的写法）：
-  fs.writeFileSync(target, JSON.stringify(config, null, 2), 'utf8');
+ * 侧栏折叠（`stores/ui.ts` 的 toggleSidebar）、主题切换、通知渠道、作业看板偏好、登录/登出
+ * 全都走 `saveConfig`，而它一次调用要做「readFileSync + JSON.parse + 8 个 normalize」**两遍**
+ * （开头读一遍、结尾 `getConfig()` 又读一遍）+ `writeFileSync` 一遍 + DPAPI 解密一遍，
+ * **全部同步跑在主进程主线程上**。主进程是 Electron 的消息泵进程，被它摁住的那一拍
+ * 渲染进程也跟着掉帧 —— 用户反馈的"点汉堡展开/收回侧栏时卡一下"就是这一拍。
+ *
+ * 现在：配置常驻内存（连已解密的 token 一起缓存），写盘改成**异步 + 合并** ——
+ * 同一拍内的多次改动只落最后一次，写入串行不会互相覆盖；退出前由 `flushConfigSync()` 兜底。
+ *
+ * **语义变化（有意为之）**：`saveConfig()` 返回时数据可能还没落盘（延迟 CONFIG_WRITE_DEBOUNCE_MS）。
+ * 正常退出（托盘 → 退出）会走 `flushConfigSync()`，不会丢最后一次改动；只有进程被强杀
+ * 才可能丢这最后 120ms 内的改动。
+ */
+
+/** 写入合并窗口：拖动同类控件（滑块/连续点击）时的连续改动只落最后一次 */
+const CONFIG_WRITE_DEBOUNCE_MS = 120;
+
+interface ConfigCache {
+  config: PersistedConfig;
+  /** 已解密的登录令牌（null = 未登录 / 解密失败）。缓存它是为了不再每次都走一遍 DPAPI */
+  token: string | null;
 }
 
-/** 读取配置（token 已解密），供渲染进程使用 */
+/**
-export function getConfig(): DesktopStoredConfig {
+ * 内存配置。**必须懒初始化**：`main/index.ts` 会先 `app.setPath('userData', smokeProfile)`
-  const persisted = readPersisted();
+ * 把配置目录指到冒烟专用 profile，之后才第一次读配置；在模块顶层立即读盘会读错文件。
+ */
+let cache: ConfigCache | null = null;
+
+function loadCache(): ConfigCache {
+  if (cache) return cache;
+  const config = readPersistedFromDisk();
+  cache = { config, token: decryptToken(config) };
+  return cache;
+}
+
+/** 待写入的配置快照（合并窗口内只保留最后一次） */
+let pendingWrite: PersistedConfig | null = null;
+let writeTimer: ReturnType<typeof setTimeout> | null = null;
+/** 是否有一次异步写入正在进行（用它把写入串行化，避免两次写互相覆盖） */
+let writing = false;
+
+/** 排一次落盘。合并窗口内的多次调用只会写最后一次；`immediate` 用于不该被延迟的场景 */
+function scheduleWrite(config: PersistedConfig, immediate = false): void {
+  pendingWrite = config;
+  if (immediate) {
+    if (writeTimer !== null) {
+      clearTimeout(writeTimer);
+      writeTimer = null;
+    }
+    void flushConfigAsync();
+    return;
+  }
+  // 已有待写任务（定时器在跑或正在写）：内容已经记在 pendingWrite 里，等它自己收尾即可。
+  // 正在写的那次结束后会再检查一次 pendingWrite（见 flushConfigAsync 的 finally）。
+  if (writeTimer !== null || writing) return;
+  writeTimer = setTimeout(() => {
+    writeTimer = null;
+    void flushConfigAsync();
+  }, CONFIG_WRITE_DEBOUNCE_MS);
+}
+
+/** 异步落盘（不阻塞主进程消息泵）。失败只记日志 —— 与 readPersistedFromDisk 的容错口径一致 */
+async function flushConfigAsync(): Promise<void> {
+  if (writing) return;
+  const target = pendingWrite;
+  if (!target) return;
+  pendingWrite = null;
+  writing = true;
+  // 先把内容序列化下来：写入期间的后续改动由 pendingWrite 负责补一次，
+  // 不会出现"这一次写的是半新半旧的对象"
+  const payload = JSON.stringify(target, null, 2);
+  try {
+    const file = configFilePath();
+    await fs.promises.mkdir(path.dirname(file), { recursive: true });
+    await fs.promises.writeFile(file, payload, 'utf8');
+  } catch (error) {
+    logger.warn(`写入配置失败（${configFilePath()}）：${error instanceof Error ? error.message : error}`);
+  } finally {
+    writing = false;
+    // 写入期间又有改动：再写一次（内容已被 pendingWrite 合并成最后一次）
+    if (pendingWrite) void flushConfigAsync();
+  }
+}
+
+/**
+ * 退出前同步落地一次（`main/index.ts` 的 shutdownResources 调用）。
+ *
+ * 即使没有待写内容也把内存里的配置重写一遍：那一时刻可能正有一次异步写在进行中，
+ * 它未必来得及完成；退出时多写一次的代价可以忽略。
+ */
+export function flushConfigSync(): void {
+  if (writeTimer !== null) {
+    clearTimeout(writeTimer);
+    writeTimer = null;
+  }
+  const target = pendingWrite ?? cache?.config ?? null;
+  if (!target) return;
+  pendingWrite = null;
+  try {
+    const file = configFilePath();
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.writeFileSync(file, JSON.stringify(target, null, 2), 'utf8');
+  } catch (error) {
+    logger.warn(
+      `退出前写入配置失败（${configFilePath()}）：${error instanceof Error ? error.message : error}`,
+    );
+  }
+}
+
+/**
+ * 服务器地址只接受 http/https 绝对地址。
+ *
+ * 渲染进程的输入框走 `normalizeServerUrl` 校验过，但 IPC（`saveConfig`）与手工改过的
+ * config.json 都会绕过它，而该值随后会作为 axios baseURL 与 Socket.IO 地址使用 ——
+ * 因此必须在**主进程这一侧也收口**，非法值一律丢弃（保留原值）。
+ */
+function normalizeServerUrl(input: string): string | null {
+  const trimmed = input.trim().replace(/\/+$/, '');
+  if (!trimmed) return null;
+  try {
+    const url = new URL(trimmed);
+    if (url.protocol !== 'http:' && url.protocol !== 'https:') return null;
+    return trimmed;
+  } catch {
+    return null;
+  }
+}
+
+/** 由内存缓存组装对渲染进程暴露的配置（不再读盘、不再解密） */
+function toDesktopConfig(state: ConfigCache): DesktopStoredConfig {
+  const persisted = state.config;
   return {
     serverUrl: persisted.serverUrl,
     username: persisted.username,
-    token: decryptToken(persisted),
+    token: state.token,
     island: normalizeIslandAppearance(persisted.island),
     homeworkBoard: normalizeHomeworkBoard(persisted.homeworkBoard),
     notificationChannel: normalizeNotificationChannel(persisted.notificationChannel),
     homeworkPhrases: normalizeHomeworkPhrases(persisted.homeworkPhrases),
+    onboardingDone: persisted.onboardingDone === true,
+    theme: normalizeTheme(persisted.theme),
+    sidebarCollapsed: persisted.sidebarCollapsed === true,
+    ignoredUpdateVersion: persisted.ignoredUpdateVersion ?? '',
   };
 }
 
+/** 读取配置（token 已解密），供渲染进程使用 */
+export function getConfig(): DesktopStoredConfig {
+  return toDesktopConfig(loadCache());
+}
+
 /** 局部更新配置：只覆盖传入的字段 */
 export function saveConfig(patch: Partial<DesktopStoredConfig>): DesktopStoredConfig {
-  const persisted = readPersisted();
+  const state = loadCache();
+  const persisted = state.config;
 
   if (typeof patch.serverUrl === 'string' && patch.serverUrl.trim()) {
-    persisted.serverUrl = patch.serverUrl.trim().replace(/\/+$/, '');
+    const normalized = normalizeServerUrl(patch.serverUrl);
+    if (normalized) persisted.serverUrl = normalized;
+    else logger.warn(`忽略非法的服务器地址（只接受 http/https）：${patch.serverUrl}`);
   }
   if (typeof patch.username === 'string') {
     persisted.username = patch.username;
@@ -224,20 +392,39 @@ export function saveConfig(patch: Partial<DesktopStoredConfig>): DesktopStoredCo
   if (patch.notificationChannel !== undefined) {
     persisted.notificationChannel = normalizeNotificationChannel(patch.notificationChannel);
   }
+  // 引导只接受"已看过"：重看入口不走这里（看过与否只有 true 与"没看过"两种状态，
+  // 想 re-arm 只能清配置 clearConfig）。传 false 一律忽略，避免任何调用点误把用户退回首启状态。
+  if (patch.onboardingDone === true) {
+    persisted.onboardingDone = true;
+  }
+  if (patch.theme !== undefined) {
+    persisted.theme = normalizeTheme(patch.theme);
+  }
+  if (patch.sidebarCollapsed !== undefined) {
+    persisted.sidebarCollapsed = patch.sidebarCollapsed === true;
+  }
+  // 空串是合法值（= 没有忽略任何版本），因此这里只判类型不判空
+  if (typeof patch.ignoredUpdateVersion === 'string') {
+    persisted.ignoredUpdateVersion = patch.ignoredUpdateVersion;
+  }
   if (patch.token !== undefined) {
     const encrypted = encryptToken(patch.token);
     persisted.token = encrypted.token;
     persisted.tokenEncrypted = encrypted.tokenEncrypted;
+    // 明文一并进缓存：既省掉一次 DPAPI 解密，也保证紧接着的 getConfig() 读到的就是刚存的令牌
+    state.token = patch.token;
   }
 
-  writePersisted(persisted);
+  scheduleWrite(persisted);
-  return getConfig();
+  return toDesktopConfig(state);
 }
 
-/** 清空为默认配置（退出登录 / 重置） */
+/** 清空为默认配置（退出登录 / 重置）。立即落盘：它对应退出登录，不该被合并窗口延迟 */
 export function clearConfig(): DesktopStoredConfig {
-  writePersisted({ ...DEFAULT_CONFIG });
+  const state: ConfigCache = { config: { ...DEFAULT_CONFIG }, token: null };
-  return getConfig();
+  cache = state;
+  scheduleWrite(state.config, true);
+  return toDesktopConfig(state);
 }
 
 export function getConfigPath(): string {

packages/desktop-client/src/main/index.ts

@@ -1,10 +1,13 @@
 import path from 'node:path';
+import { pathToFileURL } from 'node:url';
 import { BrowserWindow, app, shell } from 'electron';
+import { flushConfigSync, getConfig } from './config.js';
 import { registerIpcHandlers } from './ipc.js';
 import { island, registerIslandIpc } from './island.js';
 import { logger } from './logger.js';
 import { runSmokeTest } from './smoke.js';
 import { createTray, destroyTray, isTrayReady } from './tray.js';
+import { scheduleStartupUpdateCheck } from './update.js';
 
 // 主进程由 esbuild 打包为 CommonJS，因此这里可以直接使用 __dirname
 // （dist/main/index.js -> dist/preload/index.js 与 dist/renderer/index.html）
@@ -23,17 +26,45 @@ let mainWindow: BrowserWindow | null = null;
 /** 是否正在退出：用于区分「关闭窗口 = 隐藏到托盘」与「真正退出」 */
 let isQuitting = false;
 
+/** 生产环境下主窗口加载的本页地址（用于导航白名单的精确比对） */
+const prodRendererUrl = pathToFileURL(path.join(currentDir, '../renderer/index.html')).href;
+
+/**
+ * 是否允许窗口导航到这个地址。
+ *
+ * 为什么不能用 `url.startsWith(...)`：
+ * - 开发态 `url.startsWith(devServerUrl)` 没有主机边界，`http://localhost:5174.evil.com` 也会被放行；
+ * - 生产态 `url.startsWith('file://')` 等于放行**任意本地页面**。
+ * 而 preload 是挂在窗口上的（不是挂在 URL 上）：一旦窗口被导航到别处，那个页面照样持有
+ * `window.desktop`（含 `getConfig` 返回的明文 token）。因此这里按"精确同源 / 精确同一文件"比对。
+ */
+function isAllowedNavigation(url: string): boolean {
+  try {
+    const target = new URL(url);
+    if (devServerUrl) return target.origin === new URL(devServerUrl).origin;
+    target.hash = '';
+    target.search = '';
+    return target.href === prodRendererUrl;
+  } catch {
+    return false;
+  }
+}
+
 function createWindow(): BrowserWindow {
+  // 启动底色跟主题走：深色主题下若仍用浅色底，窗口先白后黑会"闪一下"
+  const theme = getConfig().theme;
   const win = new BrowserWindow({
-    width: 1200,
+    // 初始尺寸与 ClassIsland 主窗口对齐（实测其可视区 1242x582），保持同一观感
-    height: 800,
+    width: 1242,
-    minWidth: 980,
+    height: 582,
-    minHeight: 640,
+    minWidth: 1000,
+    minHeight: 540,
+    center: true,
     title: '班级小助手',
     // 冒烟验证时不弹窗，避免打扰使用者
     show: !isSmokeTest,
     autoHideMenuBar: true,
-    backgroundColor: '#f5f7fa',
+    backgroundColor: theme === 'dark' ? '#161719' : '#f3f3f3',
     webPreferences: {
       preload: path.join(currentDir, '../preload/index.js'),
       contextIsolation: true,
@@ -49,11 +80,10 @@ function createWindow(): BrowserWindow {
     return { action: 'deny' };
   });
   win.webContents.on('will-navigate', (event, url) => {
-    const allowed = devServerUrl ? url.startsWith(devServerUrl) : url.startsWith('file://');
+    if (isAllowedNavigation(url)) return;
-    if (!allowed) {
     event.preventDefault();
     if (/^https?:\/\//i.test(url)) void shell.openExternal(url);
-    }
+    logger.warn(`主窗口拒绝了页面导航：${url}`);
   });
 
   win.on('closed', () => {
@@ -106,6 +136,11 @@ if (!gotLock) {
         if (!mainWindow || mainWindow.isDestroyed()) return;
         mainWindow.webContents.send('island:mark-read', id);
       });
+      // 多条通知时的"标为已读"是**整批**操作：一次把列表里的通知都标上
+      island.setMarkAllReadHandler((ids) => {
+        if (!mainWindow || mainWindow.isDestroyed()) return;
+        mainWindow.webContents.send('island:mark-all-read', ids);
+      });
     } catch (error) {
       logger.error('灵动岛初始化失败（不影响主功能）', error);
     }
@@ -129,6 +164,9 @@ if (!gotLock) {
       logger.warn(`系统托盘初始化失败（不影响主功能）：${error instanceof Error ? error.message : error}`);
     }
 
+    // 启动后自动查一次更新（延迟几秒，不跟首屏抢带宽）；冒烟模式下自动跳过，见 main/update.ts
+    scheduleStartupUpdateCheck(() => mainWindow);
+
     if (isSmokeTest) {
       try {
         await runSmokeTest(mainWindow);
@@ -156,6 +194,11 @@ if (!gotLock) {
    */
   function shutdownResources(): string {
     const done: string[] = [];
+    // 配置是**异步合并写**的（见 main/config.ts）：退出前必须同步落地一次，
+    // 否则"刚改完设置就退出"这一类操作会丢掉最后一次改动。
+    // 放在最前面：后面会销毁窗口与灵动岛，先落盘不依赖任何窗口是否还在。
+    flushConfigSync();
+    done.push('配置已落盘');
     if (isTrayReady()) {
       destroyTray();
       done.push('托盘已销毁');

packages/desktop-client/src/main/ipc.ts

@@ -1,5 +1,7 @@
 import { app, ipcMain, shell } from 'electron';
+import type { UpdateInfo } from '@classhelper/shared';
 import { clearConfig, getConfig, getConfigPath, saveConfig } from './config.js';
+import { checkForUpdates, ignoreUpdateVersion } from './update.js';
 import type { DesktopAppInfo, DesktopStoredConfig } from '../types/desktop.js';
 
 /** IPC 通道名集中管理，preload 与主进程共用同一份字符串 */
@@ -9,6 +11,8 @@ export const IPC_CHANNELS = {
   clearConfig: 'classhelper:config:clear',
   appInfo: 'classhelper:app:info',
   openExternal: 'classhelper:shell:open-external',
+  updateCheck: 'classhelper:update:check',
+  updateIgnore: 'classhelper:update:ignore',
 } as const;
 
 export function registerIpcHandlers(): void {
@@ -30,6 +34,7 @@ export function registerIpcHandlers(): void {
     node: process.versions.node ?? '',
     platform: `${process.platform} ${process.arch}`,
     userDataPath: app.getPath('userData'),
+    configPath: getConfigPath(),
     smokeTest: process.env.ELECTRON_SMOKE_TEST === '1',
   }));
 
@@ -38,6 +43,21 @@ export function registerIpcHandlers(): void {
     await shell.openExternal(url);
     return true;
   });
+
+  /**
+   * 检查更新（走主进程直连 GitHub，见 main/update.ts 的说明）。
+   *
+   * `force` 为 true 时绕过主进程缓存 —— 对应「关于」页里用户主动点的那次检查；
+   * 启动自动检查一律用缓存（避免同一分钟内重复请求打满匿名限流）。
+   */
+  ipcMain.handle(IPC_CHANNELS.updateCheck, (_event, force?: boolean): Promise<UpdateInfo> => {
+    return checkForUpdates(force === true);
+  });
+
+  /** 忽略某个版本的更新提示（记入 config.json，启动自动检查不再提示它） */
+  ipcMain.handle(IPC_CHANNELS.updateIgnore, (_event, version: string): void => {
+    if (typeof version === 'string') ignoreUpdateVersion(version);
+  });
 }
 
 export function getDiagnostics(): { configPath: string; config: DesktopStoredConfig } {

packages/desktop-client/src/main/island.ts

@@ -1,4 +1,5 @@
 import path from 'node:path';
+import { pathToFileURL } from 'node:url';
 import { BrowserWindow, ipcMain, screen } from 'electron';
 import {
   DEFAULT_ISLAND_APPEARANCE,
@@ -7,7 +8,10 @@ import {
   ISLAND_SIZE_DELTA,
   ISLAND_SLIVER_WIDTH,
   ISLAND_STYLES,
+  PRIORITY_RANK,
+  islandListLayout,
   type IslandAppearance,
+  type IslandListLayout,
   type IslandMode,
   type IslandNotification,
   type IslandState,
@@ -15,6 +19,26 @@ import {
 import { logger } from './logger.js';
 import { getConfig } from './config.js';
 
+/** 生产环境的灵动岛页面地址（导航白名单的精确比对用） */
+const prodIslandUrl = pathToFileURL(path.join(__dirname, '../renderer/island.html')).href;
+
+/**
+ * 是否允许灵动岛窗口导航到这个地址。
+ * 与主窗口同一套理由：preload 挂在窗口上而不是 URL 上，被导航走就等于把 `window.desktop`
+ * 交给了一个陌生页面；而灵动岛还是置顶窗口，陌生页面会停在屏幕最上层。
+ */
+function isAllowedIslandNavigation(url: string, devUrl: string | null): boolean {
+  try {
+    const target = new URL(url);
+    if (devUrl) return target.origin === new URL(devUrl).origin;
+    target.hash = '';
+    target.search = '';
+    return target.href === prodIslandUrl;
+  } catch {
+    return false;
+  }
+}
+
 /**
  * 灵动岛（Dynamic Island）主进程控制器。
  *
@@ -102,7 +126,18 @@ export interface IslandClassStatePayload {
   week?: number;
 }
 
-type IslandActionName = 'expand' | 'collapse' | 'dismiss' | 'mark-read' | 'open-app';
+type IslandActionName =
+  | 'expand'
+  | 'collapse'
+  /** 多条通知时点"展开更多"：把列表铺到屏幕放得下的程度 */
+  | 'expand-list'
+  | 'dismiss'
+  /** 多条通知时点"知道了"：整批关闭，但不改通知中心的已读状态 */
+  | 'dismiss-all'
+  | 'mark-read'
+  /** 多条通知时点"标为已读"：整批已读并关闭 */
+  | 'mark-all-read'
+  | 'open-app';
 
 interface IslandActionPayload {
   action: IslandActionName;
@@ -127,12 +162,35 @@ class IslandController {
   /** 是否允许"失焦自动收起"（冒烟可临时关闭，避免焦点抖动干扰断言） */
   private blurCollapseEnabled = true;
   private interactive = false;
+  /**
+   * 触摸模式：触摸屏机器上由渲染进程按 `navigator.maxTouchPoints` 上报（见 `setTouchMode`）。
+   *
+   * 为什么触摸屏必须单独一套：触摸屏上"点不动"是**机制性**的，不是偶发 —— 打开命中的两条链路
+   * （渲染进程的 mousemove 转发、主进程读系统光标位置）都以"鼠标指针移动"为前提，而手指触摸
+   * 既不产生 mousemove、也不移动系统光标。于是窗口永远停在 `setIgnoreMouseEvents(true)` 的
+   * 穿透态，手指点下去只落到桌面（用户反馈：希沃白板上触摸灵动岛无法展开）。
+   *
+   * 修法只有一条：**窗口在触摸点处必须可命中**。Electron 没有 SetWindowRgn 那种"窗口区域"能力，
+   * 所以改成在触摸模式下让窗口**贴合岛体**（岛体 + 阴影留白）并始终接收输入 —— 贴身后多出来的
+   * 只有投影所需的 10px 留白，不再吞掉桌面点击。
+   */
+  private touchMode = false;
   /** 渲染进程上报的岛体矩形（窗口内 CSS px）：主进程据此做光标命中兜底轮询 */
   private hitRect: { x: number; y: number; width: number; height: number } | null = null;
   /** 光标命中兜底轮询定时器（见 syncHitFromCursor 注释） */
   private hitTimer: ReturnType<typeof setInterval> | null = null;
   /** 诊断/冒烟用：覆盖光标位置（屏幕坐标），null 表示使用真实光标 */
   private cursorOverride: { x: number; y: number } | null = null;
+  /**
+   * 冒烟/诊断用：让窗口**不接收真实鼠标**（真实点击穿透到桌面）。
+   *
+   * 为什么需要：自动化验证时长分钟计，而岛上那套命中逻辑是按"真实光标位置"开的 ——
+   * 若此时用户正在用同一块屏幕（他自己的客户端和冒烟窗口都在屏幕顶部居中、互相叠着），
+   * 他点到的是**冒烟这个窗口**，冒烟就会收到人的点击（实测：冒烟从未发出的 collapse / mark-read
+   * 混进了断言，把「点胶囊展开」「点空白处收起」等用例整片弄红）。
+   * 打开后所有命中请求一律按"穿透"处理；合成 DOM 点击（executeJavaScript）不受影响。
+   */
+  private testInputPassthrough = false;
   /** 上次按矩形立即校正命中的时刻（限流用） */
   private lastHitSyncAt = 0;
   /** 设置页"预览效果"的示例通知 id（预览期间失焦不收起） */
@@ -147,7 +205,10 @@ class IslandController {
   private recovering = false;
   /** 最近的窗口重建时刻（限流用） */
   private recoverAt: number[] = [];
-
+  /** 上一次计算锚点所依据的显示器 id：用于发现"光标换屏 / 显示器插拔"并重排窗口 */
+  private anchorDisplayId: number | null = null;
+  /** 展开卡可用高度上限（CSS px）：由工作区/停靠位置算出，随状态下发给渲染进程 */
+  private maxCardHeight = 1024;
   private state: IslandState = {
     mode: 'hidden',
     active: null,
@@ -155,6 +216,8 @@ class IslandController {
     inClass: false,
     currentPeriodEnd: null,
     reason: null,
+    listExpanded: false,
+    maxCardHeight: 1024,
     updatedAt: Date.now(),
   };
 
@@ -164,6 +227,9 @@ class IslandController {
   /** 灵动岛点"标为已读"时交给外部（主窗口渲染进程）同步通知中心 */
   private markReadHandler: ((id: string) => void) | null = null;
 
+  /** 灵动岛一次"标为已读"要标记的多条通知（多条列表时的整批已读） */
+  private markAllReadHandler: ((ids: string[]) => void) | null = null;
+
   setOpenAppHandler(handler: () => void): void {
     this.openAppHandler = handler;
   }
@@ -172,6 +238,10 @@ class IslandController {
     this.markReadHandler = handler;
   }
 
+  setMarkAllReadHandler(handler: (ids: string[]) => void): void {
+    this.markAllReadHandler = handler;
+  }
+
   async init(rendererUrl: string | null): Promise<void> {
     this.rendererUrl = rendererUrl;
     // 恢复用户保存的个性化外观（尺寸/位置/透明度/动画…），失败则用默认值
@@ -181,6 +251,7 @@ class IslandController {
       this.appearance = { ...DEFAULT_ISLAND_APPEARANCE };
     }
     recomputeSizes(this.appearance);
+    this.refreshViewport();
     if (this.win && !this.win.isDestroyed()) return;
 
     const win = new BrowserWindow({
@@ -219,6 +290,13 @@ class IslandController {
 
     win.setAlwaysOnTop(this.appearance.alwaysOnTop, 'screen-saver');
     win.setVisibleOnAllWorkspaces(true, { visibleOnFullScreen: true });
+    // 拒绝一切导航与新开窗口（理由见 isAllowedIslandNavigation）
+    win.webContents.setWindowOpenHandler(() => ({ action: 'deny' }));
+    win.webContents.on('will-navigate', (event, url) => {
+      if (isAllowedIslandNavigation(url, this.rendererUrl)) return;
+      event.preventDefault();
+      logger.warn(`灵动岛拒绝了页面导航：${url}`);
+    });
     // 注意：这里**不能**调用 `win.setBackgroundMaterial()`（亚克力/mica），
     // 见 `applyBackgroundMaterial` 移除处的说明。
     // 默认整块窗口不接收鼠标（避免大面积透明窗口吞掉桌面点击），
@@ -254,7 +332,10 @@ class IslandController {
         );
         return;
       }
-      if (sinceActivated < BLUR_GRACE_MS) {
+      // 触摸屏上没有"指针"可依据（isCursorOnIsland 恒为 false），只能用更宽的宽限期覆盖
+      // 上面实测到的 70~520ms 抖动区间，否则手指点开后约 0.5s 会莫名缩回胶囊。
+      const grace = this.touchMode ? BLUR_GRACE_TOUCH_MS : BLUR_GRACE_MS;
+      if (sinceActivated < grace) {
         logger.info(`灵动岛：忽略激活后 ${sinceActivated}ms 内的失焦（宽限期内不收起）`);
         return;
       }
@@ -360,13 +441,10 @@ class IslandController {
   ): IslandNotification {
     if (!existing || existing.id !== incoming.id) return incoming;
     const kind = existing.kind === 'call' || incoming.kind === 'call' ? 'call' : incoming.kind;
-    const rank: Record<IslandNotification['priority'], number> = {
+    const priority =
-      LOW: 0,
+      (PRIORITY_RANK[incoming.priority] ?? 0) >= (PRIORITY_RANK[existing.priority] ?? 0)
-      NORMAL: 1,
+        ? incoming.priority
-      HIGH: 2,
+        : existing.priority;
-      URGENT: 3,
-    };
-    const priority = rank[incoming.priority] >= rank[existing.priority] ? incoming.priority : existing.priority;
     return { ...incoming, kind, priority };
   }
 
@@ -376,6 +454,61 @@ class IslandController {
     return this.state.queued.find((item) => item.id === id) ?? null;
   }
 
+  /**
+   * 当前**未处理**的消息（正在展示的 + 队列里的），按「重要程度 → 时间」倒序。
+   *
+   * 排序口径与共享常量 `PRIORITY_RANK` 一致：紧急 > 重要 > 普通 > 低，同级按时间新的在前。
+   * 用户在展开卡里看到的就是这个顺序（"默认按重要程度排列"）。
+   */
+  private pendingNotifications(): IslandNotification[] {
+    const merged: IslandNotification[] = [];
+    if (this.state.active) merged.push(this.state.active);
+    for (const item of this.state.queued) {
+      if (!merged.some((existing) => existing.id === item.id)) merged.push(item);
+    }
+    return merged.sort((a, b) => {
+      const rank = (PRIORITY_RANK[b.priority] ?? 0) - (PRIORITY_RANK[a.priority] ?? 0);
+      if (rank !== 0) return rank;
+      return String(b.createdAt ?? '').localeCompare(String(a.createdAt ?? ''));
+    });
+  }
+
+  /**
+   * 多条通知时的列表布局（几条、要不要"展开更多"、卡片多高）。
+   * 只有展开态且待处理 ≥ 2 条时才有列表形态，单条通知仍然是原来那张详情卡。
+   */
+  private listLayout(): IslandListLayout | null {
+    if (this.state.mode !== 'expanded') return null;
+    const count = this.pendingNotifications().length;
+    if (count < 2) return null;
+    return islandListLayout({
+      count,
+      fontSize: this.appearance.fontSize,
+      maxHeight: this.maxCardHeight,
+      expanded: this.state.listExpanded,
+    });
+  }
+
+  /**
+   * 展开卡在当前屏幕 / 停靠位置下的可用高度上限：
+   * 从"岛被锚定的那条边"量到屏幕工作区的另一端（也就是任务栏上方）。
+   *
+   * 用锚点 `vValue` 而不是窗口矩形来算：锚点与窗口尺寸无关，因此**列表长高后再算还是同一个数**
+   * （用窗口矩形会自引用：窗口高度取决于列表高度，列表高度又取决于可用高度）。
+   */
+  private refreshViewport(): void {
+    const area = this.targetDisplay().workArea;
+    const anchor = this.resolveAnchor();
+    const marginY = Math.round(this.appearance.marginY ?? ISLAND_MARGIN);
+    const available =
+      anchor.vMode === 'bottom'
+        ? anchor.vValue - (area.y + marginY)
+        : area.y + area.height - marginY - anchor.vValue;
+    // 下限兜底：屏幕再小也不能用 0 去算布局（否则连一行都排不出来）
+    this.maxCardHeight = Math.max(MIN_CARD_HEIGHT, Math.floor(available));
+    this.state.maxCardHeight = this.maxCardHeight;
+  }
+
   /**
    * 收到一条消息。
    * - 紧急（含紧急叫人）：立刻展开（无视上课时段）
@@ -384,6 +517,7 @@ class IslandController {
    * - 其它：显示"新消息/新作业/叫人"胶囊，等待点击展开
    */
   pushNotification(raw: IslandNotification, context: IslandPushContext = {}): void {
+    this.state.listExpanded = false;
     // 同一 id 的第二条链路（通知/叫人双播）：合并而不是覆盖，保住"叫人/紧急"语义
     const notification = this.mergeNotification(this.findKnownNotification(raw.id), raw);
     const inClass = context.inClass ?? this.state.inClass;
@@ -398,7 +532,7 @@ class IslandController {
       this.state.queued = this.state.queued.filter((item) => item.id !== notification.id);
       this.state.active = notification;
       this.state.updatedAt = Date.now();
-      this.setState({ mode: 'expanded' });
+      this.setState({ mode: 'expanded', listExpanded: false });
       this.previewTimer = setTimeout(() => {
         this.previewTimer = null;
         this.endPreview(notification.id);
@@ -561,7 +695,8 @@ class IslandController {
           // 记下这条 id，syncWindow 的上课守卫对它是放行的（否则展开后会被立刻隐藏，
           // 表现为"点不开新作业"——用户反馈的联合通知场景）。
           this.explicitShowId = this.state.inClass ? active.id : null;
-          this.setState({ mode: 'expanded' });
+          // 每次重新点开都从"只显示前三条"开始（上文的 setState 只在离开 expanded 时复位）
+          this.setState({ mode: 'expanded', listExpanded: false });
           this.scheduleCollapse(
             this.isImmediate(active)
               ? active.kind === 'call'
@@ -572,6 +707,18 @@ class IslandController {
         }
         break;
       }
+      case 'expand-list': {
+        // 多条通知时点"展开更多"：把列表铺到屏幕放得下的程度（窗口跟着长高，见 setState）
+        if (this.state.mode === 'hidden' || this.state.listExpanded) break;
+        const layout = this.listLayout();
+        if (!layout) break;
+        logger.info(
+          `灵动岛：展开更多（共 ${this.pendingNotifications().length} 条，显示 ${layout.rows} 条，提示=${layout.hint ?? '无'}）`,
+        );
+        this.setState({ mode: 'expanded', listExpanded: true });
+        this.scheduleCollapse(TIMEOUTS.expanded);
+        break;
+      }
       case 'collapse':
         // 点击卡片空白处 / 右上角收起按钮 / 点击屏幕任意位置：回缩到灵动岛（胶囊）
         // 上课时段：普通通知彻底隐藏；**叫人 / 紧急消息**回缩为胶囊（保持可见，允许再次展开）
@@ -589,6 +736,11 @@ class IslandController {
       case 'dismiss':
         this.dismissActive();
         break;
+      case 'dismiss-all':
+        // 多条通知时点"知道了"：整批关闭（通知中心仍是未读，学生回应用里再看）
+        logger.info(`灵动岛：整批知道了（${this.pendingNotifications().length} 条）`);
+        this.clearPendingForClose();
+        break;
       case 'mark-read': {
         const id = payload.id;
         const queue = this.state.queued.filter((item) => item.id !== id);
@@ -604,6 +756,18 @@ class IslandController {
         }
         break;
       }
+      case 'mark-all-read': {
+        // 多条通知时点"标为已读"：**默认把这一批全部标记已读**再关闭。
+        // 作业卡的 id 是本地合成的（`homework-<id>`，库里没有这条通知），交给通知中心只会报"通知不存在"，
+        // 因此这里先按 kind 过滤掉，单条模式的 canMarkRead 守卫同理。
+        const ids = this.pendingNotifications()
+          .filter((item) => item.kind !== 'homework')
+          .map((item) => item.id);
+        logger.info(`灵动岛：整批标为已读（${ids.length} 条）`);
+        if (ids.length > 0) this.markAllReadHandler?.(ids);
+        this.clearPendingForClose();
+        break;
+      }
       case 'open-app':
         this.openAppHandler?.();
         break;
@@ -676,6 +840,19 @@ class IslandController {
     this.hide();
   }
 
+  /**
+   * 整批清空并关闭（"知道了 / 标为已读"的多条场景）。
+   * 状态同步落地（渲染进程随之收起卡片，窗口由 `hide()` 淡出）。
+   */
+  private clearPendingForClose(): void {
+    this.clearTimers();
+    this.state.active = null;
+    this.state.queued = [];
+    this.state.listExpanded = false;
+    this.hide();
+  }
+
+
   private activate(notification: IslandNotification, reason: IslandState['reason'], mode: IslandMode): void {
     this.clearTimers();
     // 正在展示的通知从队列中移出，queue 只保留"尚未看过"的
@@ -756,9 +933,7 @@ class IslandController {
    */
   private resolveAnchor(): IslandAnchor {
     // 多显示器教室电脑：打开"跟随鼠标屏幕"后，岛出现在鼠标所在的那块屏（讲台切换投影时不用改设置）
-    const display = this.appearance.followCursorDisplay
+    const display = this.targetDisplay();
-      ? screen.getDisplayNearestPoint(screen.getCursorScreenPoint())
-      : screen.getPrimaryDisplay();
     const area = display.workArea;
     const marginX = Math.round(this.appearance.marginX ?? ISLAND_MARGIN);
     const marginY = Math.round(this.appearance.marginY ?? ISLAND_MARGIN);
@@ -782,9 +957,41 @@ class IslandController {
     return { hMode, hValue, vMode, vValue };
   }
 
+  /** 当前应该把岛放在哪块屏上：跟随鼠标时用光标所在屏，否则用主屏 */
+  private targetDisplay(cursor?: { x: number; y: number } | null): Electron.Display {
+    return this.appearance.followCursorDisplay
+      ? screen.getDisplayNearestPoint(cursor ?? this.cursorOverride ?? screen.getCursorScreenPoint())
+      : screen.getPrimaryDisplay();
+  }
+
+  /**
+   * 锚点所在屏幕变化时重排窗口（"跟随鼠标屏幕"、主屏切换、显示器插拔都会走到这里）。
+   *
+   * 原先锚点只在 `setAppearance()` 里算一次，于是"跟随鼠标屏幕"实际上**只在改设置的那一瞬间**
+   * 生效：讲台从投影切回来之后，岛还留在原来那块屏上，直到用户再动一次外观设置。
+   * 这里挂在已有的 60ms 命中轮询上（不新增定时器），并且只在目标屏幕真的变了、且窗口可见时才动窗口。
+   *
+   * 不需要额外监听 `screen` 的 display-* 事件：目标屏是由**当前光标位置**或主屏推出来的，
+   * 插拔/切主屏之后下一轮 tick 自然会算出不同的 id，一样能触发重排。
+   */
+  private syncAnchorDisplay(cursor?: { x: number; y: number } | null): void {
+    if (!this.win || this.win.isDestroyed()) return;
+    const displayId = this.targetDisplay(cursor).id;
+    if (this.anchorDisplayId === displayId) return;
+    this.anchorDisplayId = displayId;
+    // 换屏了：可用高度（工作区）也跟着换，列表"能放几行"要重算
+    this.refreshViewport();
+    if (!this.win.isVisible()) return;
+    this.relayout();
+  }
+
   /** 状态变更：先通知渲染进程，再驱动窗口尺寸/透明度动画 */
   private setState(patch: Partial<IslandState>, options: { skipWindow?: boolean } = {}): void {
     this.state = { ...this.state, ...patch, updatedAt: Date.now() };
+    // 离开展开态就把"展开更多"复位：下次再点开时默认回到"只显示前三条"
+    if (this.state.mode !== 'expanded') this.state.listExpanded = false;
+    // 列表形态比普通展开卡高：窗口要**先**长高，卡片才开始形变，否则底部会被窗口裁掉
+    if (!options.skipWindow) this.relayout();
     this.emit();
     if (!options.skipWindow) this.syncWindow();
   }
@@ -825,6 +1032,11 @@ class IslandController {
 
     // 展开态才允许获得焦点，这样点击屏幕其他位置会 blur → 自动收起
     this.applyFocusable();
+    // 窗口不可见时先把包围盒对齐到当前形态：列表形态留下的"高窗口"在这里收回去。
+    // 必须挑"不可见"的时刻做 —— 可见时改大小会把正在形变的卡片裁掉一截。
+    if (!this.win.isVisible()) this.applyWindowLayout();
+    // 触摸模式：形态变了，窗口要立刻跟着变大（缩小交给岛体矩形上报后判定，避免裁掉形变中的卡片）
+    this.syncTouchLayout();
 
     if (this.state.mode === 'hidden') {
       // 空闲"细缝"（参考 WinIsland）：打开后空闲不再完全隐藏，而是留一条很窄的圆角柱；
@@ -857,9 +1069,69 @@ class IslandController {
     this.syncHitFromCursor();
   }
 
+  /**
+   * 窗口包围盒：
+   * - 普通（鼠标）模式：固定取"最大形态 + 2×阴影留白"，**开合过程中一帧都不动**（照搬 WinIsland）；
+   *   唯一的例外是**多条通知的列表**：它比任何普通形态都高，窗口必须当场长高，否则卡片底部
+   *   （那排按钮）会被窗口裁掉。窗口是在卡片开始形变**之前**改的，用户看不到这一步。
+   * - 触摸模式：贴合当前形态（岛体 + 2×阴影留白），否则大包围盒的透明区会吞掉桌面的触摸。
+   */
+  private windowBox(): { width: number; height: number } {
+    const size = this.formSize();
+    if (!this.touchMode) {
+      return {
+        width: Math.round(Math.max(BBOX_SIZE.width, size.width + ISLAND_SHADOW_PAD * 2)),
+        height: Math.round(Math.max(BBOX_SIZE.height, size.height + ISLAND_SHADOW_PAD * 2)),
+      };
+    }
+    return {
+      width: Math.round(size.width + ISLAND_SHADOW_PAD * 2),
+      height: Math.round(size.height + ISLAND_SHADOW_PAD * 2),
+    };
+  }
+
+  /**
+   * 触摸模式下重排窗口（贴合岛体）：
+   * **变大立刻生效**（否则形变中的卡片会被窗口裁掉一半）；**变小要等岛真的收小**——
+   * 判据是渲染进程上报的真实岛体矩形已经装得下，见 `cardFitsFormSize`。
+   */
+  private syncTouchLayout(): void {
+    if (!this.touchMode || !this.win || this.win.isDestroyed()) return;
+    const target = this.windowBox();
+    const current = this.win.getBounds();
+    const shrinking = target.width < current.width || target.height < current.height;
+    /**
+     * **窗口可见期间只增不减**（触摸模式）。
+     *
+     * 为什么：触摸模式下窗口是"贴合岛体"的（手指要能点到岛），所以形态变化时窗口本该跟着变
+     * —— 但**收小会让出一块区域**，Windows/DWM 在那一瞬间可能还留着上一帧的内容，
+     * 用户看到的就是"一缩回/一展开就闪一下、像旧画面残留在那里"（反复反馈、逐帧抓过的那一类）。
+     * 变大属于"只增不减"，不会让出任何区域；所以：
+     * - 需要**变大**就立刻变大（否则形变中的卡片会被窗口裁掉）；
+     * - 需要**变小**一律等窗口隐藏之后再收（`syncWindow` 里"不可见时对齐包围盒"，
+     *   不可见时改尺寸不会有残影），这也顺带修掉"隐藏态改停靠/边距不生效"那条。
+     */
+    if (shrinking && this.win.isVisible()) return;
+    this.applyWindowLayout();
+  }
+
+  /** 渲染进程上报的岛体是否已经收进"当前形态"的尺寸里（触摸模式下判断能否缩小窗口） */
+  private cardFitsFormSize(): boolean {
+    const rect = this.hitRect;
+    if (!rect) return false;
+    const size = this.formSize();
+    return rect.width <= size.width + 1 && rect.height <= size.height + 1;
+  }
+
+  /** 外观 / 锚点变化后的窗口重排：普通模式按固定包围盒重排，触摸模式走贴合逻辑 */
+  private relayout(): void {
+    if (this.touchMode) this.syncTouchLayout();
+    else this.applyWindowLayout();
+  }
+
   /**
    * 按当前外观把窗口放到锚点上（**只在尺寸/位置设置变化时调用**，开合时不调用）。
-   * 窗口尺寸 = 最大形态 + 2×阴影留白，因此任何形态的岛都能完整容纳。
+   * 尺寸见 `windowBox`：普通模式恒为"最大形态 + 阴影留白"，触摸模式贴合当前形态。
    */
   private applyWindowLayout(): void {
     if (!this.win || this.win.isDestroyed()) return;
@@ -876,10 +1148,11 @@ class IslandController {
     this.win.setBounds(next);
   }
 
-  /** 固定包围盒窗口的矩形：以锚点定位，尺寸恒为"最大形态 + 阴影留白" */
+  /** 窗口矩形：以锚点定位（尺寸由 `windowBox` 决定，触摸模式随形态变化） */
   private windowBounds(): Bounds {
-    const width = Math.round(BBOX_SIZE.width);
+    const box = this.windowBox();
-    const height = Math.round(BBOX_SIZE.height);
+    const width = box.width;
+    const height = box.height;
     const anchor = this.resolveAnchor();
 
     // 窗口比岛大 ISLAND_SHADOW_PAD（给投影留白），因此窗口要再偏移一个 pad，
@@ -1005,8 +1278,16 @@ class IslandController {
    * 窗口只在尺寸/位置变化时**重排一次**（`applyWindowLayout`），开合过程不碰窗口。
    */
   setAppearance(patch: Partial<IslandAppearance>): void {
-    this.appearance = normalizeAppearance({ ...this.appearance, ...patch });
+    // 先丢掉显式 undefined 的键：设置页/冒烟脚本传的都是**部分补丁**，
+    // 一个残缺字段不该把对应外观重置成默认值（NaN 的兜底在 normalizeAppearance 里）
+    const clean: Record<string, unknown> = {};
+    for (const [key, value] of Object.entries(patch ?? {})) {
+      if (value !== undefined) clean[key] = value;
+    }
+    this.appearance = normalizeAppearance({ ...this.appearance, ...clean } as IslandAppearance);
     recomputeSizes(this.appearance);
+    // 字号/边距会影响"列表能放几行"，可用高度也随停靠位置变化 —— 重算一次并随状态下发
+    this.refreshViewport();
 
     if (this.win && !this.win.isDestroyed()) {
       this.win.setAlwaysOnTop(this.appearance.alwaysOnTop, 'screen-saver');
@@ -1017,7 +1298,7 @@ class IslandController {
     }
     this.emitAppearance();
     // 包围盒/锚点可能变化：窗口重排一次（**不是逐帧**，开合过程中绝不会再碰窗口）
-    this.applyWindowLayout();
+    this.relayout();
     // 外观变化后按新尺寸重新同步（隐藏态不显示，不做额外动作）
     if (this.state.mode !== 'hidden') this.syncWindow();
     logger.info(
@@ -1039,10 +1320,17 @@ class IslandController {
    * "点开了再收起，就再也点不开了"。
    */
   setInteractive(interactive: boolean, source = '未知'): void {
-    if (this.interactive === interactive) return;
+    // 触摸模式：窗口已贴合岛体，必须**始终**接收输入。触摸不会产生光标移动，按光标判定命中的
-    this.interactive = interactive;
+    // 那套逻辑在触摸屏上永远不会打开，一旦让它把命中关掉，手指就再也点不到（"点不动"）。
+    // 测试输入穿透：真实鼠标一律不接收（理由见 testInputPassthrough 字段）；
+    // 但**注入光标**（冒烟用 setHitTestCursor 模拟指针在岛上/岛外）照常生效，
+    // 否则「光标轮询校正命中」「岛外穿透」这类断言全会被自己的开关弄红。
+    const passthrough = this.testInputPassthrough && this.cursorOverride === null;
+    const next = passthrough ? false : this.touchMode ? true : interactive;
+    if (this.interactive === next) return;
+    this.interactive = next;
     logger.info(
-      `灵动岛：鼠标命中=${interactive}（来自${source}）mode=${this.state.mode} ` +
+      `灵动岛：鼠标命中=${next}（请求=${interactive}，来自${source}）mode=${this.state.mode} ` +
         `窗口可见=${this.win?.isVisible() ?? false} 岛体矩形=${
           this.hitRect ? `${Math.round(this.hitRect.width)}x${Math.round(this.hitRect.height)}` : '无'
         }`,
@@ -1050,7 +1338,9 @@ class IslandController {
     if (!this.win || this.win.isDestroyed()) return;
     // forward: true 让窗口在"忽略鼠标"时仍把 mousemove 转发给渲染进程，
     // 这样渲染进程才能发现指针进入岛体并重新打开命中。
-    this.win.setIgnoreMouseEvents(!interactive, { forward: true });
+    // 注意传的是 next 而不是入参：触摸模式下入参可能是 false（按光标判定），
+    // 直接用它会把窗口又打回穿透态 —— 那正是"手指点不开"的根因。
+    this.win.setIgnoreMouseEvents(!next, { forward: true });
   }
 
   /** 渲染进程上报的岛体矩形（窗口内 CSS px，坐标系与窗口 DIP 一致） */
@@ -1062,6 +1352,9 @@ class IslandController {
       this.lastHitSyncAt = now;
       this.syncHitFromCursor();
     }
+    // 触摸模式：窗口要一直贴合岛体，而"收小"必须等岛真的收小之后再做（否则形变中的卡片被窗口裁掉）。
+    // 渲染进程每 ≥50ms 就会上报一次真实几何，正好拿来当这个判据。
+    this.syncTouchLayout();
   }
 
   /** 当前岛体矩形（供冒烟验证） */
@@ -1069,6 +1362,42 @@ class IslandController {
     return this.hitRect ? { ...this.hitRect } : null;
   }
 
+  /**
+   * 设置触摸模式（触摸屏机器由渲染进程上报，冒烟也可显式开关）。
+   *
+   * 开启后：窗口贴合岛体（见 `windowBox`）且不再穿透（见 `setInteractive`）——
+   * 这是让"手指按在岛上"能被 Windows 命中到本窗口的唯一办法（详见 `touchMode` 字段的注释）。
+   * 关闭后回到"固定大包围盒 + 按光标命中"的原行为，因此非触摸屏机器的表现完全不变。
+   */
+  setTouchMode(enabled: boolean): void {
+    if (this.touchMode === enabled) return;
+    this.touchMode = enabled;
+    logger.info(
+      `灵动岛：触摸模式=${enabled}（窗口${enabled ? '贴合岛体并始终接收输入' : '回到固定包围盒穿透'}）`,
+    );
+    // 直接重排到目标包围盒：开启时贴合岛体，关闭时回到"最大形态 + 阴影留白"的固定大包围盒
+    this.applyWindowLayout();
+    if (enabled) this.setInteractive(true, '触摸模式');
+    else this.syncHitFromCursor();
+  }
+
+  /** 是否处于触摸模式（供冒烟验证） */
+  getTouchMode(): boolean {
+    return this.touchMode;
+  }
+
+  /**
+   * 开关"测试输入穿透"（冒烟用，见 `testInputPassthrough`）：
+   * 打开后真实鼠标点击穿透到桌面，不会污染自动化断言；关闭后立刻按真实光标位置恢复命中。
+   */
+  setTestInputPassthrough(enabled: boolean): void {
+    if (this.testInputPassthrough === enabled) return;
+    this.testInputPassthrough = enabled;
+    logger.info(`灵动岛：测试输入穿透=${enabled}（供自动化验证不被并行人工操作打扰）`);
+    if (enabled) this.setInteractive(false, '测试输入穿透');
+    else this.syncHitFromCursor();
+  }
+
   /**
    * 诊断 / 冒烟专用：覆盖"光标位置"（屏幕坐标），让命中兜底轮询按指定坐标校正。
    *
@@ -1083,11 +1412,14 @@ class IslandController {
   /**
    * 光标相对窗口左上角的本地坐标（CSS px / DIP，与渲染进程上报的岛体矩形同一坐标系）。
    * 冒烟里用 `setHitTestCursor` 注入，真实场景读系统光标。
+   *
+   * `cursor`：调用方在本轮 tick 里已经读过的光标位置（见 `startHitPoll`）。
+   * 传进来就复用它，避免同一个 tick 里重复调 `screen.getCursorScreenPoint()`。
    */
-  private cursorLocal(): { x: number; y: number } | null {
+  private cursorLocal(cursor?: { x: number; y: number } | null): { x: number; y: number } | null {
     if (!this.win || this.win.isDestroyed()) return null;
     const bounds = this.win.getBounds();
-    const point = this.cursorOverride ?? screen.getCursorScreenPoint();
+    const point = cursor ?? this.cursorOverride ?? screen.getCursorScreenPoint();
     return { x: point.x - bounds.x, y: point.y - bounds.y };
   }
 
@@ -1099,23 +1431,39 @@ class IslandController {
     return this.hitRect ?? this.expectedHitRect();
   }
 
-  /** 按当前形态/停靠位置算出岛体目标矩形（窗口内 CSS px），仅作兜底 */
+  /** 当前形态下**岛本身**的尺寸（不是窗口尺寸；响应进程的 `.island-card` 宽高） */
-  private expectedHitRect(): { x: number; y: number; width: number; height: number } {
+  private formSize(): { width: number; height: number } {
-    let size = SIZES.pill;
+    // 多条通知的列表形态：高度由统一布局算法算出（渲染进程算的是同一个数）
+    const layout = this.listLayout();
+    if (layout) return { width: SIZES.expanded.width, height: layout.height };
     if (this.state.mode === 'expanded') {
-      size =
+      return this.state.active?.kind === 'call'
-        this.state.active?.kind === 'call'
         ? CALL_SIZE
         : this.state.active?.priority === 'URGENT'
           ? URGENT_SIZE
           : SIZES.expanded;
-    } else if (this.state.mode === 'hidden' && this.appearance.idleSliver) {
-      size = SLIVER_SIZE;
     }
+    if (this.state.mode === 'hidden' && this.appearance.idleSliver) return SLIVER_SIZE;
+    return SIZES.pill;
+  }
+
+  /**
+   * 按当前形态/停靠位置算出岛体目标矩形（窗口内 CSS px），仅作兜底。
+   *
+   * 定位规则必须与渲染进程的 CSS 完全一致（`islandStyle`）：左/右停靠贴边留 pad，
+   * 居中则水平居中；上/下停靠同理。这里用**窗口实际尺寸**而不是 BBOX_SIZE 计算 ——
+   * 触摸模式下窗口会贴合岛体，用固定的 BBOX_SIZE 会算出错误偏移。
+   */
+  private expectedHitRect(): { x: number; y: number; width: number; height: number } {
+    const size = this.formSize();
     const pad = ISLAND_SHADOW_PAD;
     const position = this.appearance.position;
-    const width = Math.round(BBOX_SIZE.width);
+    const bounds =
-    const height = Math.round(BBOX_SIZE.height);
+      this.win && !this.win.isDestroyed()
+        ? this.win.getBounds()
+        : { width: Math.round(BBOX_SIZE.width), height: Math.round(BBOX_SIZE.height) };
+    const width = bounds.width;
+    const height = bounds.height;
     const x = position.endsWith('left')
       ? pad
       : position.endsWith('right')
@@ -1152,7 +1500,7 @@ class IslandController {
   }
 
   /** 按光标位置校正命中（不依赖渲染进程是否收到 mousemove） */
-  private syncHitFromCursor(): void {
+  private syncHitFromCursor(cursor?: { x: number; y: number } | null): void {
     if (!this.win || this.win.isDestroyed() || !this.win.isVisible()) {
       this.setInteractive(false, '窗口不可见');
       return;
@@ -1163,15 +1511,34 @@ class IslandController {
       this.setInteractive(false, '隐藏态');
       return;
     }
-    this.setInteractive(this.isInsideHitRect(this.cursorLocal()), '光标轮询');
+    this.setInteractive(this.isInsideHitRect(this.cursorLocal(cursor)), '光标轮询');
   }
 
   private startHitPoll(): void {
     if (this.hitTimer) return;
     // 60ms：渲染进程的 mousemove 转发在 Windows 上并不可靠，这里是命中的**权威来源**，
     // 间隔必须足够小，否则"指针移上胶囊后立刻点击"会因窗口还没接收鼠标而点空（用户反馈过）。
+    //
+    // 每一跳的成本要压到最低（这个定时器从岛初始化一直跑到进程退出）：
+    // 1) 光标位置**每跳只读一次**，命中判定与"跟随鼠标屏幕"共用 —— 原先 cursorLocal() 与
+    //    targetDisplay() 各读一次，等于每跳两次 `screen.getCursorScreenPoint()`；
+    // 2) 窗口不可见时直接返回：此时命中判定与心跳检查本来就各自早退（窗口不可见 ⇒ 无命中可言），
+    //    留着那两次系统调用纯属白跑。
     this.hitTimer = setInterval(() => {
-      this.syncHitFromCursor();
+      if (!this.win || this.win.isDestroyed()) return;
+      const visible = this.win.isVisible();
+      // 不可见、且不跟随鼠标屏幕时，连读光标都可省掉（targetDisplay 会走主屏分支）
+      const cursor =
+        visible || this.appearance.followCursorDisplay
+          ? (this.cursorOverride ?? screen.getCursorScreenPoint())
+          : null;
+
+      // 先按目标屏幕校正窗口位置（换屏/插拔显示器），再算命中与心跳：
+      // 顺序不能反，否则命中判定会用上一块屏的窗口坐标
+      this.syncAnchorDisplay(cursor);
+      if (!visible) return;
+
+      this.syncHitFromCursor(cursor);
       this.checkRendererAlive();
     }, 60);
     // 定时器不应拖住进程退出
@@ -1325,24 +1692,36 @@ export function getSliverSize(): { width: number; height: number } {
 
 /** 夹紧外观取值（越界值直接收敛，避免用户配置破坏布局） */
 export function normalizeAppearance(input: IslandAppearance): IslandAppearance {
-  const clamp = (value: number, min: number, max: number): number =>
+  /**
-    Math.min(max, Math.max(min, Math.round(value * 100) / 100));
+   * 夹紧数值：**非法值回落到该字段的默认值**，而不是变成 NaN。
+   *
+   * 注意 `Math.max(min, NaN)` 仍是 NaN、`Math.min(max, NaN)` 也是 NaN —— 也就是说"只夹紧"
+   * 并不能防住 NaN。而 `setAppearance()` 的入参来自 IPC（`island:set-appearance` 只判了 `if (patch)`），
+   * 渲染进程传一个显式 `undefined` 字段就会得到 NaN，随后 `setOpacity(NaN)` / `setBounds({x:NaN})`
+   * 抛异常；它在非 async 的 ipcMain 监听里抛出，主进程没有兜底，会直接崩掉
+   * （连带托盘、灵动岛、实时连接一起消失）。因此这里补上 fallback。
+   */
+  const clamp = (value: number, min: number, max: number, fallback: number): number => {
+    if (typeof value !== 'number' || !Number.isFinite(value)) return fallback;
+    return Math.min(max, Math.max(min, Math.round(value * 100) / 100));
+  };
+  const fallbackOf = DEFAULT_ISLAND_APPEARANCE;
   return {
-    height: clamp(input.height, 36, 72),
+    height: clamp(input.height, 36, 72, fallbackOf.height),
-    width: clamp(input.width, 220, 420),
+    width: clamp(input.width, 220, 420, fallbackOf.width),
-    radius: clamp(input.radius, 8, 32),
+    radius: clamp(input.radius, 8, 32, fallbackOf.radius),
-    opacity: clamp(input.opacity, 0.4, 1),
+    opacity: clamp(input.opacity, 0.4, 1, fallbackOf.opacity),
     accent: /^#[0-9a-fA-F]{6}$/.test(input.accent) ? input.accent : DEFAULT_ISLAND_APPEARANCE.accent,
-    fontSize: clamp(input.fontSize, 11, 20),
+    fontSize: clamp(input.fontSize, 11, 20, fallbackOf.fontSize),
     animations: input.animations !== false,
-    speed: clamp(input.speed, 0.5, 2),
+    speed: clamp(input.speed, 0.5, 2, fallbackOf.speed),
     position: ISLAND_POSITIONS.includes(input.position) ? input.position : 'top-center',
     alwaysOnTop: input.alwaysOnTop !== false,
     style: ISLAND_STYLES.includes(input.style) ? input.style : 'black',
     idleSliver: input.idleSliver === true,
     // 边距：0 表示贴着屏幕边缘，上限给到 200/160 是为了"多显示器 + 任务栏在侧面"这类布局
-    marginX: clamp(input.marginX ?? DEFAULT_ISLAND_APPEARANCE.marginX, 0, 200),
+    marginX: clamp(input.marginX ?? DEFAULT_ISLAND_APPEARANCE.marginX, 0, 200, fallbackOf.marginX),
-    marginY: clamp(input.marginY ?? DEFAULT_ISLAND_APPEARANCE.marginY, 0, 160),
+    marginY: clamp(input.marginY ?? DEFAULT_ISLAND_APPEARANCE.marginY, 0, 160, fallbackOf.marginY),
     followCursorDisplay: input.followCursorDisplay === true,
   };
 }
@@ -1370,16 +1749,33 @@ const ISLAND_MARGIN = 8;
  */
 const BLUR_GRACE_MS = 500;
 
+/**
+ * 触摸屏上的失焦宽限期（触摸模式专用，见 `touchMode`）。
+ *
+ * 触摸没有光标，`isCursorOnIsland()` 这条"指针还在岛上就判定为激活抖动"的兜底恒为 false，
+ * 只剩宽限期这一层防线。而实测的假失焦出现在 focus 之后 70~520ms，正好跨过 500ms 的边界，
+ * 不放开的话手指点开后会偶发地立刻缩回胶囊。取 1200ms 给它 2 倍余量；
+ * 真正的"点屏幕别处收起"仍会在 1.2s 后生效。
+ */
+const BLUR_GRACE_TOUCH_MS = 1200;
+
 /** 设置页"预览效果"的示例岛停留时长（到点自动收尾，避免一直挂在桌面上） */
 const PREVIEW_DURATION_MS = 30_000;
 
 /**
- * 渲染进程心跳（渲染进程每 5s 上报一次）：超过这个时间没上报就认为它已经卡死/不响应。
+ * 展开卡可用高度的下限（CSS px）：屏幕再矮也要留出这么多，
+ * 否则"列表能放几行"会算出负数。真正的工作区空间由 `refreshViewport` 算，这里只是防呆。
+ */
+const MIN_CARD_HEIGHT = 120;
+
+
+/**
+ * 渲染进程心跳（渲染进程每 5s 上报一次，间隔写死在 `src/island/IslandApp.vue`）：
+ * 超过这个时间没上报就认为它已经卡死/不响应。
  * 岛是"无边框透明置顶窗口"，渲染进程一旦挂掉，Windows 会把**最后一帧留在屏幕上**
  * 形成"幽灵胶囊"：窗口还在、看着正常，但怎么点都没反应（实测复现：崩掉渲染进程后
  * 点击完全不产生任何动作）。所以必须有心跳 + 重建来兜底。
  */
-const RENDERER_ALIVE_INTERVAL_MS = 5_000;
 const RENDERER_ALIVE_TIMEOUT_MS = 20_000;
 /** 窗口重建限流：一段时间内最多重建几次，避免持续崩坏时无限重建 */
 const RECOVER_MAX_TIMES = 3;
@@ -1446,6 +1842,12 @@ export function registerIslandIpc(): void {
     },
   );
 
+  // 触摸屏上报（渲染进程按 navigator.maxTouchPoints 判定）→ 窗口改为贴合岛体并始终接收输入。
+  // 触摸屏上按光标判定命中的那套永远打不开命中，手指点不到岛（详见 IslandController.touchMode）。
+  ipcMain.on('island:set-touch-mode', (_event, enabled: boolean) => {
+    island.setTouchMode(enabled === true);
+  });
+
   ipcMain.on('island:action', (_event, payload: IslandActionPayload) => {
     if (!payload?.action) return;
     island.handleAction(payload);

packages/desktop-client/src/main/update.ts

@@ -0,0 +1,215 @@
+import { app, type BrowserWindow } from 'electron';
+import {
+  GITHUB_RELEASES_LATEST_API,
+  GITHUB_RELEASES_PAGE,
+  UPDATE_CHECK_CACHE_TTL_MS,
+  UPDATE_CHECK_TIMEOUT_MS,
+  UPDATE_CHECK_USER_AGENT,
+  isNewerVersion,
+  normalizeVersion,
+  type UpdateAssetDto,
+  type UpdateInfo,
+} from '@classhelper/shared';
+import { getConfig, saveConfig } from './config.js';
+import { logger } from './logger.js';
+
+/**
+ * 更新检查（桌面客户端）。
+ *
+ * **为什么在主进程做**：渲染进程通过 preload 能拿到 `getConfig()` 的明文 token（代表全班身份），
+ * 它的 CSP 与导航防线是整个安全模型里最要紧的一层；让它额外去连一个外部域名、
+ * 解析外部 JSON，等于把"外部数据"请进最有价值的那一侧。主进程本来就在做网络与文件，
+ * 放这里也顺带复用 Node 的 fetch（无需额外依赖）。
+ *
+ * 与 Web 管理端的差别：Web 端受服务端 CSP 的 `connect-src` 限制，只能走 `/api/update/check` 转发；
+ * 客户端没有这个限制，按用户选择**直连 GitHub**。两边归一化出的 `UpdateInfo` 结构一致。
+ */
+
+/** 主进程 → 渲染进程：发现新版本（渲染进程据此弹一次性提示） */
+export const UPDATE_AVAILABLE_CHANNEL = 'classhelper:update:available';
+
+/** 启动后多久自动查一次：等窗口与登录流程就绪，也不跟首屏请求抢带宽 */
+const STARTUP_DELAY_MS = 5_000;
+
+interface GithubReleasePayload {
+  tag_name?: unknown;
+  name?: unknown;
+  published_at?: unknown;
+  body?: unknown;
+  html_url?: unknown;
+  assets?: unknown;
+}
+
+let cache: { at: number; info: UpdateInfo } | null = null;
+let startupTimer: ReturnType<typeof setTimeout> | null = null;
+/** 冒烟断言用：启动自动检查是否被跳过（冒烟模式下必须是 true） */
+let startupCheckSkipped = false;
+
+/** 失败的统一出口：结构完整，界面不必做 null 判断 */
+function failure(error: string): UpdateInfo {
+  return {
+    ok: false,
+    error,
+    currentVersion: app.getVersion(),
+    latestVersion: null,
+    hasUpdate: false,
+    releaseUrl: GITHUB_RELEASES_PAGE,
+    releaseName: null,
+    publishedAt: null,
+    notes: null,
+    assets: [],
+    checkedAt: new Date().toISOString(),
+  };
+}
+
+function toAssets(raw: unknown): UpdateAssetDto[] {
+  if (!Array.isArray(raw)) return [];
+  return raw
+    .map((item) => item as { name?: unknown; browser_download_url?: unknown; size?: unknown })
+    .filter(
+      (item): item is { name: string; browser_download_url: string; size?: unknown } =>
+        typeof item.name === 'string' && typeof item.browser_download_url === 'string',
+    )
+    .map((item) => ({
+      name: item.name,
+      downloadUrl: item.browser_download_url,
+      size: typeof item.size === 'number' && Number.isFinite(item.size) ? item.size : 0,
+    }));
+}
+
+function toInfo(payload: GithubReleasePayload, currentVersion: string): UpdateInfo {
+  const latestVersion = normalizeVersion(typeof payload.tag_name === 'string' ? payload.tag_name : '');
+  if (!latestVersion) {
+    logger.warn('更新检查：GitHub 返回的 Release 里没有可识别的 tag_name');
+    return failure('GitHub 返回的版本号无法识别');
+  }
+
+  return {
+    ok: true,
+    error: null,
+    currentVersion,
+    latestVersion,
+    hasUpdate: isNewerVersion(currentVersion, latestVersion),
+    releaseUrl:
+      typeof payload.html_url === 'string' && payload.html_url ? payload.html_url : GITHUB_RELEASES_PAGE,
+    releaseName: typeof payload.name === 'string' ? payload.name : null,
+    publishedAt: typeof payload.published_at === 'string' ? payload.published_at : null,
+    notes: typeof payload.body === 'string' ? payload.body : null,
+    assets: toAssets(payload.assets),
+    checkedAt: new Date().toISOString(),
+  };
+}
+
+/** 把各种失败翻译成一句用户能看懂的话（教室里最常见的就是"这台机器没有外网"） */
+function describeFailure(error: unknown): string {
+  const message = error instanceof Error ? error.message : String(error);
+  if (error instanceof Error && error.name === 'TimeoutError') {
+    return `连接 GitHub 超时（${UPDATE_CHECK_TIMEOUT_MS / 1000} 秒），本机可能没有外网`;
+  }
+  if (/fetch failed|ENOTFOUND|ECONNREFUSED|EAI_AGAIN|ETIMEDOUT|certificate|net::/i.test(message)) {
+    return '无法连接 GitHub，本机可能没有外网';
+  }
+  return `检查更新失败：${message}`;
+}
+
+/**
+ * 检查 GitHub 上有没有比本机新的版本（结果带缓存）。
+ *
+ * 缓存的意义：匿名调用 GitHub API 的限流是 60 次/小时/IP，而「关于」页的按钮可以随便点。
+ * 失败结果同样进缓存 —— 否则离线时每点一次都要白等一个超时。
+ */
+export async function checkForUpdates(force = false): Promise<UpdateInfo> {
+  const currentVersion = app.getVersion();
+  const now = Date.now();
+  if (!force && cache && now - cache.at < UPDATE_CHECK_CACHE_TTL_MS) {
+    return cache.info;
+  }
+
+  let info: UpdateInfo;
+  try {
+    const response = await fetch(GITHUB_RELEASES_LATEST_API, {
+      headers: {
+        // GitHub API 强制要求 User-Agent，不带会直接 403
+        'User-Agent': UPDATE_CHECK_USER_AGENT,
+        Accept: 'application/vnd.github+json',
+      },
+      signal: AbortSignal.timeout(UPDATE_CHECK_TIMEOUT_MS),
+    });
+
+    if (!response.ok) {
+      info =
+        response.status === 403 || response.status === 429
+          ? failure('GitHub 暂时拒绝了请求（匿名查询次数过多），请过一会儿再试')
+          : failure(`GitHub 返回 HTTP ${response.status}`);
+      logger.warn(`更新检查失败：HTTP ${response.status}（本机版本 ${currentVersion}）`);
+    } else {
+      info = toInfo((await response.json()) as GithubReleasePayload, currentVersion);
+      logger.info(
+        `更新检查：本机 ${currentVersion} / 最新 ${info.latestVersion ?? '-'}` +
+          `${info.hasUpdate ? '（有新版本）' : '（已是最新）'}`,
+      );
+    }
+  } catch (error) {
+    info = failure(describeFailure(error));
+    logger.warn(`更新检查失败：${info.error}（本机版本 ${currentVersion}）`);
+  }
+
+  cache = { at: now, info };
+  return info;
+}
+
+/** 「知道了 / 忽略此版本」：记到配置里，同一个版本不再重复弹提示 */
+export function ignoreUpdateVersion(version: string): void {
+  const normalized = normalizeVersion(version);
+  if (!normalized) return;
+  saveConfig({ ignoredUpdateVersion: normalized });
+  logger.info(`已忽略版本 ${normalized} 的更新提示`);
+}
+
+/** 该版本是否已被用户忽略 */
+export function isUpdateIgnored(version: string): boolean {
+  return normalizeVersion(getConfig().ignoredUpdateVersion) === normalizeVersion(version);
+}
+
+/**
+ * 启动后的自动检查：延迟 `STARTUP_DELAY_MS` 查一次，有新版本（且没被忽略）就通知渲染进程弹提示。
+ *
+ * **冒烟模式直接跳过**：自动化验证不该每次都发真实网络请求（既抖动又依赖外网），
+ * 而且凭空多出来的提示条会撞坏既有 UI 断言。冒烟用例改为直接调 IPC 验证返回结构。
+ */
+export function scheduleStartupUpdateCheck(getWindow: () => BrowserWindow | null): void {
+  if (process.env.ELECTRON_SMOKE_TEST === '1') {
+    startupCheckSkipped = true;
+    logger.info('更新检查：冒烟模式下跳过启动自动检查');
+    return;
+  }
+  if (startupTimer) clearTimeout(startupTimer);
+
+  startupTimer = setTimeout(() => {
+    startupTimer = null;
+    void (async () => {
+      try {
+        const info = await checkForUpdates();
+        if (!info.ok || !info.hasUpdate || !info.latestVersion) return;
+        if (isUpdateIgnored(info.latestVersion)) {
+          logger.info(`更新检查：${info.latestVersion} 已被用户忽略，本次不提示`);
+          return;
+        }
+        const win = getWindow();
+        if (!win || win.isDestroyed()) return;
+        win.webContents.send(UPDATE_AVAILABLE_CHANNEL, info);
+        logger.info(`更新检查：已提示新版本 ${info.latestVersion}`);
+      } catch (error) {
+        // 自动检查失败不该打扰用户（手动检查才需要看到原因）
+        logger.warn(`启动自动检查更新失败：${error instanceof Error ? error.message : error}`);
+      }
+    })();
+  }, STARTUP_DELAY_MS);
+  // 不阻止进程退出：这个定时器只是"顺便查一下"
+  startupTimer.unref?.();
+}
+
+/** 冒烟断言用：启动自动检查是否被跳过（冒烟模式下应为 true —— 否则每次验证都会发真实网络请求） */
+export function wasStartupCheckSkipped(): boolean {
+  return startupCheckSkipped;
+}

packages/desktop-client/src/preload/index.ts

@@ -1,5 +1,6 @@
 import { contextBridge, ipcRenderer } from 'electron';
 import { IPC_CHANNELS } from '../main/ipc.js';
+import { UPDATE_AVAILABLE_CHANNEL } from '../main/update.js';
 import type {
   DesktopAppInfo,
   DesktopBridge,
@@ -7,7 +8,7 @@ import type {
   IslandClassStatePayload,
   IslandPushContext,
 } from '../types/desktop.js';
-import type { IslandNotification } from '@classhelper/shared';
+import type { IslandNotification, UpdateInfo } from '@classhelper/shared';
 
 /**
  * 预加载脚本：在开启了 contextIsolation + sandbox 的前提下，
@@ -19,6 +20,17 @@ import type { IslandNotification } from '@classhelper/shared';
  */
 const bridge: DesktopBridge = {
   smokeTest: process.env.ELECTRON_SMOKE_TEST === '1',
+  // 冒烟凭据：只在冒烟模式下透传，供渲染进程的冒烟钩子构造测试数据用。
+  // **不走代码字面量**——本文件与渲染产物都会进 app.asar，写死账号等于随安装包把教师口令发出去。
+  smokeCredentials:
+    process.env.ELECTRON_SMOKE_TEST === '1'
+      ? {
+          username: process.env.ELECTRON_SMOKE_USER ?? '',
+          password: process.env.ELECTRON_SMOKE_PASSWORD ?? '',
+          classCode: process.env.ELECTRON_SMOKE_CLASS_CODE ?? '',
+          classPassword: process.env.ELECTRON_SMOKE_CLASS_PASSWORD ?? '',
+        }
+      : undefined,
   getConfig: (): Promise<DesktopStoredConfig> => ipcRenderer.invoke(IPC_CHANNELS.getConfig),
   saveConfig: (patch: Partial<DesktopStoredConfig>): Promise<DesktopStoredConfig> =>
     ipcRenderer.invoke(IPC_CHANNELS.saveConfig, patch),
@@ -26,6 +38,15 @@ const bridge: DesktopBridge = {
   getAppInfo: (): Promise<DesktopAppInfo> => ipcRenderer.invoke(IPC_CHANNELS.appInfo),
   openExternal: (url: string): Promise<boolean> => ipcRenderer.invoke(IPC_CHANNELS.openExternal, url),
 
+  /* 更新检查（主进程直连 GitHub，见 main/update.ts） */
+  checkForUpdates: (force = false): Promise<UpdateInfo> =>
+    ipcRenderer.invoke(IPC_CHANNELS.updateCheck, force),
+  ignoreUpdateVersion: (version: string): Promise<void> =>
+    ipcRenderer.invoke(IPC_CHANNELS.updateIgnore, version),
+  onUpdateAvailable: (handler: (info: UpdateInfo) => void): void => {
+    ipcRenderer.on(UPDATE_AVAILABLE_CHANNEL, (_event, info: UpdateInfo) => handler(info));
+  },
+
   islandPush: (payload: { notification: IslandNotification; context?: IslandPushContext }): void => {
     ipcRenderer.send('island:push', payload);
   },
@@ -41,6 +62,10 @@ const bridge: DesktopBridge = {
   onIslandMarkRead: (handler: (id: string) => void): void => {
     ipcRenderer.on('island:mark-read', (_event, id: string) => handler(id));
   },
+  /** 灵动岛点了"标为已读"（多条通知的整批）：一次同步这一批 */
+  onIslandMarkAllRead: (handler: (ids: string[]) => void): void => {
+    ipcRenderer.on('island:mark-all-read', (_event, ids: string[]) => handler(ids ?? []));
+  },
 };
 
 contextBridge.exposeInMainWorld('desktop', bridge);

packages/desktop-client/src/preload/island.ts

@@ -7,7 +7,18 @@ import type { IslandAppearance, IslandState } from '@classhelper/shared';
  */
 export interface IslandBridge {
   onState(handler: (state: IslandState) => void): void;
-  sendAction(action: 'expand' | 'collapse' | 'dismiss' | 'mark-read' | 'open-app', id?: string): void;
+  sendAction(
+    action:
+      | 'expand'
+      | 'expand-list'
+      | 'collapse'
+      | 'dismiss'
+      | 'dismiss-all'
+      | 'mark-read'
+      | 'mark-all-read'
+      | 'open-app',
+    id?: string,
+  ): void;
   getState(): Promise<IslandState>;
   /** 订阅个性化外观（设置页改动后实时生效） */
   onAppearance(handler: (appearance: IslandAppearance) => void): void;
@@ -16,6 +27,12 @@ export interface IslandBridge {
   setInteractive(interactive: boolean): void;
   /** 上报岛体矩形（窗口内 CSS px）：主进程据此按光标位置兜底校正命中 */
   setHitRect(rect: { x: number; y: number; width: number; height: number } | null): void;
+  /**
+   * 上报"本机是触摸屏"：主进程据此把窗口改为贴合岛体并始终接收输入。
+   * 触摸屏上按光标判定命中的那套永远打不开（触摸不产生 mousemove、也不动系统光标），
+   * 不上报的话手指点不到岛（希沃白板等触摸设备）。
+   */
+  setTouchMode(enabled: boolean): void;
   /** 心跳：主进程据此发现"渲染进程卡死的幽灵窗口"（岛还在屏幕上但点不动）并重建窗口 */
   alive(): void;
 }
@@ -38,6 +55,9 @@ const bridge: IslandBridge = {
   setHitRect: (rect) => {
     ipcRenderer.send('island:set-hit-rect', rect);
   },
+  setTouchMode: (enabled) => {
+    ipcRenderer.send('island:set-touch-mode', enabled);
+  },
   alive: () => {
     ipcRenderer.send('island:alive');
   },

packages/desktop-client/src/renderer/App.vue

@@ -1,19 +1,77 @@
 <script setup lang="ts">
-import { onMounted, onUnmounted, ref } from 'vue';
+import { h, onMounted, onUnmounted, ref } from 'vue';
 import { useRouter } from 'vue-router';
-import { startIslandBridge, stopIslandBridge, subscribeIslandMarkRead } from './island/bridge.js';
+import { ElButton, ElNotification } from 'element-plus';
+import type { UpdateInfo } from '@classhelper/shared';
+import {
+  startIslandBridge,
+  stopIslandBridge,
+  subscribeIslandMarkAllRead,
+  subscribeIslandMarkRead,
+} from './island/bridge.js';
+import OnboardingWelcome from './components/OnboardingWelcome.vue';
 import { useAppStore } from './stores/app.js';
 import { useAuthStore } from './stores/auth.js';
+import { useOnboardingStore } from './stores/onboarding.js';
 import { useRealtimeStore } from './stores/realtime.js';
+import { useUiStore } from './stores/ui.js';
 
 const router = useRouter();
 const appStore = useAppStore();
 const auth = useAuthStore();
+const onboarding = useOnboardingStore();
+const ui = useUiStore();
 const realtime = useRealtimeStore();
 
 const booting = ref(true);
 const bootText = ref('正在读取本地配置...');
 
+/**
+ * 启动自动检查发现新版本时的提示（主进程查出后推过来，见 main/update.ts）。
+ *
+ * **为什么订阅放在 App.vue**：`onUpdateAvailable` 底层是 `ipcRenderer.on`，
+ * 桥接层没有对应的 off —— 挂在会随"登出 → 登录"反复挂载的 ClientLayout 里，
+ * 处理器会越堆越多（与灵动岛订阅同一个坑）。App.vue 整个应用生命周期只挂载一次。
+ *
+ * 提示是**一次性**且可永久消音：点「忽略此版本」写进 config.json，同一版本不再提示；
+ * 「关于」页里仍可随时手动检查。
+ */
+function showUpdateAvailable(info: UpdateInfo): void {
+  if (!info.latestVersion) return;
+  ElNotification({
+    title: `发现新版本 v${info.latestVersion}`,
+    type: 'info',
+    // 不自动消失：这是需要用户决定的事（去下载 / 忽略），滑过去就只能靠「关于」页再想起来
+    duration: 0,
+    message: h('div', { style: 'line-height: 1.7' }, [
+      h('p', { style: 'margin: 0 0 10px' }, `当前版本 ${info.currentVersion}，可前往下载更新。`),
+      h('div', { style: 'display: flex; gap: 8px' }, [
+        h(
+          ElButton,
+          {
+            size: 'small',
+            type: 'primary',
+            onClick: () => {
+              void window.desktop?.openExternal(info.releaseUrl);
+            },
+          },
+          () => '前往下载',
+        ),
+        h(
+          ElButton,
+          {
+            size: 'small',
+            onClick: () => {
+              void window.desktop?.ignoreUpdateVersion(info.latestVersion ?? '');
+            },
+          },
+          () => '忽略此版本',
+        ),
+      ]),
+    ]),
+  });
+}
+
 /**
  * 启动流程：
  * 1) 从主进程配置恢复服务器地址与登录令牌
@@ -22,6 +80,10 @@ const bootText = ref('正在读取本地配置...');
  */
 onMounted(async () => {
   try {
+    bootText.value = '正在读取本地配置...';
+    // 主题与侧栏折叠最先恢复：在首屏渲染前挂好 html.dark，避免"先白后黑"闪一下
+    await ui.init();
+
     bootText.value = '正在恢复登录状态...';
     const session = await auth.restore();
 
@@ -41,11 +103,26 @@ onMounted(async () => {
     // 灵动岛：开始按课表计算上课状态（上课隐藏、下课自动弹出）
     if (auth.token) startIslandBridge();
 
-    // 灵动岛"标为已读" → 同步通知中心（未读红点）
+    // 灵动岛"标为已读" → 同步通知中心（未读红点）；多条通知时是整批已读
     subscribeIslandMarkRead();
+    subscribeIslandMarkAllRead();
+
+    // 启动自动检查发现新版本时由主进程推过来（订阅只挂一次，理由见 showUpdateAvailable）
+    window.desktop?.onUpdateAvailable?.(showUpdateAvailable);
 
     if (auth.isAuthenticated) await router.replace('/schedule');
     else await router.replace('/login');
+
+    // 初次启动引导：配置里没记「已看过」就自动弹一次（完成/跳过后由引导组件写入配置）。
+    // 稍等一拍再弹：让登录页/主界面先渲染完，避免和启动过渡的收尾抢帧。
+    window.setTimeout(() => {
+      void window.desktop
+        ?.getConfig()
+        .then((config) => {
+          if (config.onboardingDone !== true) onboarding.open();
+        })
+        .catch(() => undefined);
+    }, 400);
   } finally {
     booting.value = false;
   }
@@ -60,9 +137,21 @@ onUnmounted(() => {
   <div v-if="booting" class="boot-screen">
     <el-icon :size="30" class="is-loading" color="#409eff"><Loading /></el-icon>
     <p class="boot-title">班级小助手</p>
-    <p class="boot-text">{{ bootText }}</p>
+    <!--
+      启动文案会依次经过「读取本地配置 → 恢复登录状态」，直接换字是一下"啪"的跳变。
+      交叉淡入（旧的上移淡出、新的从下方淡入）把两次状态读成**同一行字在更新**，
+      而不是"屏幕闪了一下"。
+
+      `:duration` 是必需的（理由同 ClientLayout 的页面过渡）：靠 `animationend` 判断的话，
+      窗口不可见时动画被冻结、事件不触发，文案会一直停在第一句。
+    -->
+    <transition name="boot-text" mode="out-in" :duration="{ enter: 200, leave: 90 }">
+      <p class="boot-text" :key="bootText">{{ bootText }}</p>
+    </transition>
   </div>
   <router-view v-else />
+  <!-- 初次启动引导：常驻挂载，由 onboarding store 控制显隐（登录页/主界面/设置页都能唤起） -->
+  <OnboardingWelcome v-if="!booting" />
 </template>
 
 <style scoped>
@@ -81,6 +170,19 @@ onUnmounted(() => {
   margin: 6px 0 0;
   font-size: 20px;
   font-weight: 600;
+  /* 启动页是"整个应用的第一帧"，给标题一点入场分量是值得的 */
+  animation: boot-title-in var(--ch-spring-panel-dur) var(--ch-spring-panel) both;
+}
+
+@keyframes boot-title-in {
+  from {
+    opacity: 0;
+    transform: translateY(6px) scale(0.98);
+  }
+  to {
+    opacity: 1;
+    transform: none;
+  }
 }
 
 .boot-text {
@@ -88,4 +190,34 @@ onUnmounted(() => {
   font-size: 13px;
   color: rgba(255, 255, 255, 0.75);
 }
+
+@keyframes boot-text-in {
+  from {
+    opacity: 0;
+    transform: translateY(4px);
+  }
+  to {
+    opacity: 1;
+    transform: none;
+  }
+}
+
+@keyframes boot-text-out {
+  from {
+    opacity: 1;
+    transform: none;
+  }
+  to {
+    opacity: 0;
+    transform: translateY(-4px);
+  }
+}
+
+.boot-text-enter-active {
+  animation: boot-text-in var(--ch-dur-base) var(--ch-ease-out) both;
+}
+
+.boot-text-leave-active {
+  animation: boot-text-out var(--ch-dur-instant) var(--ch-ease-out) both;
+}
 </style>

packages/desktop-client/src/renderer/api/index.ts

@@ -21,13 +21,22 @@ import { api } from './http.js';
 
 /** 客户端只需用到学生视角的这批接口（与后端同一套 REST 契约） */
 export const authApi = {
-  /** 个人账号登录（教师/管理员/个人学生；客户端界面已不再展示，保留以兼容旧流程与排障） */
+  /** 账号登录（教师/管理员用；客户端界面走班级登录，学生个人账号已清理不能登录） */
   login: (payload: LoginRequest): Promise<LoginResponse> => api.post(API_PATHS.auth.login, payload),
   /** 班级账号登录（学生端主入口）：班级码 + 班级密码 */
   classLogin: (payload: { code: string; password: string }): Promise<LoginResponse> =>
     api.post('/auth/class-login', payload),
   logout: (): Promise<{ loggedOut: boolean }> => api.post(API_PATHS.auth.logout, {}),
   me: (): Promise<StudentDto> => api.get(API_PATHS.auth.me),
+  /**
+   * 修改密码（设置页「账号信息」里的入口）。
+   * 服务端同一个接口按会话类型分流：班级账号改的是**班级密码**，教师/管理员改的是本人登录密码 ——
+   * 因此这台机器无论以哪种身份登录，改密入口都走这一条。
+   */
+  changePassword: (payload: {
+    currentPassword: string;
+    newPassword: string;
+  }): Promise<{ changed: boolean }> => api.patch(API_PATHS.auth.changePassword, payload),
 };
 
 export const classApi = {
@@ -110,8 +119,10 @@ export const notificationApi = {
   list: (params?: { classId?: string; unreadOnly?: boolean }): Promise<NotificationDto[]> =>
     api.get(API_PATHS.notifications, params),
   unreadCount: (): Promise<{ count: number }> => api.get(`${API_PATHS.notifications}/unread-count`),
+  // id 来自服务端或灵动岛（作业卡是本地合成的 `homework-…`），一律 encodeURIComponent：
+  // 否则含 `/` 或 `..` 的 id 会改变实际请求的路径
   markRead: (id: string): Promise<{ notificationId: string; readAt: string }> =>
-    api.post(`${API_PATHS.notifications}/${id}/read`, {}),
+    api.post(`${API_PATHS.notifications}/${encodeURIComponent(id)}/read`, {}),
   markAllRead: (): Promise<{ marked: number }> => api.post(`${API_PATHS.notifications}/read-all`, {}),
 };
 

packages/desktop-client/src/renderer/cache/self-test.ts

@@ -6,6 +6,31 @@ export interface SmokeCheckResult {
   detail: string;
 }
 
+/**
+ * 冒烟用的教师凭据：**由 preload 从环境变量注入，不写死在代码里**。
+ *
+ * 本文件会进渲染进程产物（`dist/renderer/assets/*.js`）→ `app.asar` → 每台学生机，
+ * 而 asar 可以直接解包。因此任何口令字面量都不能留在这里；
+ * 凭据由 `scripts/smoke.mjs` / `scripts/verify-packaged.mjs` 通过环境变量提供
+ * （见 `main/smoke.ts` 顶部关于 app.asar 的完整说明）。
+ */
+let smokeTeacherCredentials: { username: string; password: string } = { username: '', password: '' };
+
+/** 由 main.ts 在注册冒烟钩子时注入（来源：ELECTRON_SMOKE_USER / ELECTRON_SMOKE_PASSWORD） */
+export function setSmokeTeacherCredentials(next: { username: string; password: string }): void {
+  smokeTeacherCredentials = {
+    username: next?.username ?? '',
+    password: next?.password ?? '',
+  };
+}
+
+/** 教师登录请求体；未注入凭据时返回 null（调用方据此跳过并说明原因） */
+function teacherLoginBody(): { username: string; password: string } | null {
+  return smokeTeacherCredentials.username && smokeTeacherCredentials.password
+    ? { username: smokeTeacherCredentials.username, password: smokeTeacherCredentials.password }
+    : null;
+}
+
 /**
  * 冒烟自检 1：IndexedDB 写入 / 读回 / 统计 / 删除。
  * 由主进程通过 webContents.executeJavaScript 调用。
@@ -68,19 +93,31 @@ async function waitUntil(predicate: () => boolean, timeoutMs = 3000, intervalMs
   return predicate();
 }
 
-/** 侧边栏菜单与期望路由的对应关系（按显示文案匹配） */
+/** 侧边栏菜单与期望路由的对应关系（按显示文案匹配；侧边栏是「分组 + 子菜单」结构） */
 const EXPECTED_MENU: Array<{ label: string; path: string }> = [
   { label: '课表', path: '/schedule' },
   { label: '作业', path: '/homeworks' },
   { label: '通知', path: '/notifications' },
   { label: '成绩', path: '/grades' },
-  { label: '设置', path: '/settings' },
+  /** 设置组的代表子项：设置入口改成分组后，用「通用」验证设置子页导航可用 */
+  { label: '通用', path: '/settings/general' },
 ];
 
 /**
- * 冒烟自检 3：侧边栏点击导航。
+ * 一级菜单项：2026-10-05 起「学习」分组已拆掉，课表/作业/通知/成绩**直接铺在侧栏一级**。
- * 直接对真实 DOM 触发 click，验证每次点击后路由与视图都发生切换 ——
+ * 下面的结构自检会确认它们真的不在任何 `el-sub-menu` 里。
- * 这是"点击左侧边栏没反应"这类问题的回归测试。
+ */
+const PRIMARY_MENU_ITEMS = ['课表', '作业', '通知', '成绩'];
+
+/** 分组标题（el-sub-menu）与应包含的子项，点击分组展开后再点子项。设置组自成一类，保留分组 */
+const MENU_GROUPS: Array<{ title: string; labels: string[] }> = [
+  { title: '设置', labels: ['通用', '外观', '灵动岛', '提醒', '账号', '关于'] },
+];
+
+/**
+ * 冒烟自检 3：侧边栏点击导航（分组结构版）。
+ * 先点分组标题展开，再逐个点击子项，验证每次点击后路由与视图都发生切换 ——
+ * 这是"点击左侧边栏没反应"这类问题的回归测试（侧边栏改为「学习/设置」分组后重写）。
  */
 export async function layoutNavigationSelfTest(): Promise<SmokeCheckResult> {
   const { router } = await import('../router/index.js');
@@ -88,20 +125,51 @@ export async function layoutNavigationSelfTest(): Promise<SmokeCheckResult> {
   // 按**文案那一层 span 的完整文本**匹配，而不是整项 textContent：
   // "通知"项里还有一个未读红点徽标（sup），整项 textContent 会变成 "2通知"，
   // 用 startsWith 匹配就会误报"菜单项缺失"（历史失败原因）。
-  const findMenuItem = (label: string): HTMLElement | undefined =>
+  const findByLabel = (selector: string, label: string): HTMLElement | undefined =>
-    (Array.from(document.querySelectorAll('.el-menu-item')) as HTMLElement[]).find((element) =>
+    (Array.from(document.querySelectorAll(selector)) as HTMLElement[]).find((element) =>
-      Array.from(element.querySelectorAll('span')).some(
+      Array.from(element.querySelectorAll('span')).some((span) => (span.textContent ?? '').trim() === label),
-        (span) => (span.textContent ?? '').trim() === label,
-      ),
     );
+  const findMenuItem = (label: string): HTMLElement | undefined => findByLabel('.el-menu-item', label);
+  const findGroupTitle = (title: string): HTMLElement | undefined =>
+    findByLabel('.el-sub-menu__title', title);
 
-  if (!findMenuItem('课表')) {
+  if (!findGroupTitle('设置')) {
-    return { ok: false, detail: '侧边栏未渲染（当前不在主布局或未登录）' };
+    return { ok: false, detail: '侧边栏「设置」分组未渲染（当前不在主布局或未登录）' };
+  }
+  const missingPrimary = PRIMARY_MENU_ITEMS.filter((label) => !findMenuItem(label));
+  if (missingPrimary.length > 0) {
+    return { ok: false, detail: `侧边栏缺少一级项：${missingPrimary.join('、')}` };
   }
 
   const visited: string[] = [];
   const failures: string[] = [];
 
+  // 展开分组：默认只展开"当前路由所在分组"，其它组需要先点开。
+  // 判据用"子项是否可见"而不是"盲点一次标题" —— 标题点击是 toggle，
+  // 对已经展开的组再点一下会把它**收起**，后续点不到子项。
+  const isVisible = (element: HTMLElement | undefined): boolean =>
+    Boolean(element && element.offsetParent !== null);
+  for (const group of MENU_GROUPS) {
+    const firstItem = findMenuItem(group.labels[0] ?? '');
+    if (!isVisible(firstItem)) {
+      findGroupTitle(group.title)?.click();
+      await new Promise((resolve) => setTimeout(resolve, 250));
+    }
+  }
+
+  // 结构自检：
+  //   ① 一级项必须**真的在一级** —— 不能还挂在某个 el-sub-menu 里（用户要求把"学习"拆掉）；
+  //   ② 分组各自应包含全部子项
+  for (const label of PRIMARY_MENU_ITEMS) {
+    const element = findMenuItem(label);
+    if (element?.closest('.el-sub-menu')) failures.push(`${label}(仍挂在分组里，应在一级)`);
+  }
+  for (const group of MENU_GROUPS) {
+    for (const label of group.labels) {
+      if (!findMenuItem(label)) failures.push(`${group.title}组缺少子项 ${label}`);
+    }
+  }
+
   for (const { label, path } of EXPECTED_MENU) {
     const element = findMenuItem(label);
     if (!element) {
@@ -144,10 +212,18 @@ async function seedSmokeContent(
   const stamp = `自检 ${new Date().toLocaleTimeString('zh-CN')}`;
 
   try {
+    // 凭据由环境变量注入（理由见文件顶部）：没给就明确跳过，而不是拿种子账号兜底
+    const loginBody = teacherLoginBody();
+    if (!loginBody) {
+      return {
+        ok: false,
+        detail: '未提供冒烟教师凭据（ELECTRON_SMOKE_USER / ELECTRON_SMOKE_PASSWORD），无法自建测试数据',
+      };
+    }
     const login = await fetch(`${serverUrl}/api/auth/login`, {
       method: 'POST',
       headers: { 'content-type': 'application/json' },
-      body: JSON.stringify({ username: 'teacher1', password: 'teacher123' }),
+      body: JSON.stringify(loginBody),
     }).then((response) => response.json());
     const token: string | undefined = login?.data?.token;
     if (!token) return { ok: false, detail: `教师登录失败：${JSON.stringify(login).slice(0, 120)}` };
@@ -239,10 +315,18 @@ export async function onlineScenario(credentials?: {
   const detail: string[] = [];
 
   try {
-    // 学生端已改为「班级账号」登录：凭据由 scripts/smoke.mjs 通过管理端接口准备并传入
+    // 学生端已改为「班级账号」登录：凭据由 scripts/smoke.mjs 通过管理端接口准备并传入。
-    const code = credentials?.code ?? 'G101';
+    // 这里**不再回退到种子班级码**（G101/123456 也是真实可用的登录凭据，不能写进安装包）：
-    const password = credentials?.password ?? '123456';
+    // 没有凭据就明确跳过，由 scripts/smoke.mjs 打印"未能准备班级账号"。
-    if (!credentials?.code) detail.push('未收到班级凭据，回退到种子班级码 G101');
+    const code = credentials?.code ?? '';
+    const password = credentials?.password ?? '';
+    if (!code) {
+      return {
+        ok: false,
+        detail:
+          '未收到班级凭据（ELECTRON_SMOKE_CLASS_CODE / ELECTRON_SMOKE_CLASS_PASSWORD），已跳过联网集成自检',
+      };
+    }
 
     await auth.login(serverUrl, code, password);
     detail.push(`login=${auth.user?.name ?? '-'}`);
@@ -363,10 +447,17 @@ export async function islandRealtimeScenario(): Promise<{
 
   const title = `灵动岛真机链路自检 ${Date.now()}`;
   try {
+    const loginBody = teacherLoginBody();
+    if (!loginBody) {
+      return {
+        ok: false,
+        detail: '未提供冒烟教师凭据（ELECTRON_SMOKE_USER / ELECTRON_SMOKE_PASSWORD），无法投递通知',
+      };
+    }
     const login = await fetch(`${serverUrl}/api/auth/login`, {
       method: 'POST',
       headers: { 'content-type': 'application/json' },
-      body: JSON.stringify({ username: 'teacher1', password: 'teacher123' }),
+      body: JSON.stringify(loginBody),
     }).then((response) => response.json());
     const teacherToken: string | undefined = login?.data?.token;
     if (!teacherToken) return { ok: false, detail: `教师登录失败：${JSON.stringify(login).slice(0, 120)}` };
@@ -378,6 +469,8 @@ export async function islandRealtimeScenario(): Promise<{
         classId,
         title,
         content: '自动化验证：这条通知用于确认「服务端广播 → 客户端实时通道 → 灵动岛」整条链路可用。',
+        // 普通优先级：冒烟客户端登录的是**临时班级**（无课表 → 判定不在上课），
+        // 普通通知也会立刻弹出胶囊，链路断言与真实上课时段无关。
         priority: 'NORMAL',
       }),
     }).then((response) => response.json());
@@ -465,10 +558,17 @@ export async function scheduleTimelineSelfTest(): Promise<SmokeCheckResult> {
   let teacherToken = '';
 
   try {
+    const loginBody = teacherLoginBody();
+    if (!loginBody) {
+      return {
+        ok: false,
+        detail: '未提供冒烟教师凭据（ELECTRON_SMOKE_USER / ELECTRON_SMOKE_PASSWORD），无法构造课表',
+      };
+    }
     const login = await fetch(`${serverUrl}/api/auth/login`, {
       method: 'POST',
       headers: { 'content-type': 'application/json' },
-      body: JSON.stringify({ username: 'teacher1', password: 'teacher123' }),
+      body: JSON.stringify(loginBody),
     }).then((response) => response.json());
     teacherToken = login?.data?.token ?? '';
     if (!teacherToken) return { ok: false, detail: '教师登录失败' };
@@ -613,7 +713,9 @@ export async function homeworkBoardSelfTest(): Promise<SmokeCheckResult> {
 
     // 今天可能恰好没有作业：切到「最近一个有作业的日期」保证看板一定有卡片（断言才有意义）。
     // 按天查看支持 ?date=YYYY-MM-DD 深链，切天不需要去操作日期选择器。
-    if (!document.querySelector('.board-host')) {
+    // 注意判据是「看板里没有卡片」而不是「没有 board-host 容器」——空看板照样渲染容器，
+    // 拿容器当判据会导致切日期的兜底永远不触发（今天的日期没作业时看板必然为空）。
+    if (!document.querySelector('.board-card')) {
       const [{ homeworkApi }, { useAuthStore }] = await Promise.all([
         import('../api/index.js'),
         import('../stores/auth.js'),
@@ -704,6 +806,117 @@ export async function homeworkBoardSelfTest(): Promise<SmokeCheckResult> {
   }
 }
 
+/**
+ * 冒烟自检（不需要后端）：**本机录入的作业不再上灵动岛**（用户要求）。
+ *
+ * 场景：教室机器上录完作业，服务端照样广播 `homework:new`，但"自己通知自己"没有意义。
+ * 判定按**内容指纹 + id**（发起请求前就登记，避免"广播晚于响应"漏判），因此这里两条都要验：
+ * 1) 登记过的这条：投递后灵动岛状态不变；
+ * 2) 没登记过的同形作业（别班/别的标题）：照常上岛。
+ */
+export async function islandHomeworkSuppressionCheck(): Promise<SmokeCheckResult> {
+  const [{ markHomeworkCreatedLocally, isLocalHomework, pushHomeworkToIsland }, { useAuthStore }] =
+    await Promise.all([import('../island/bridge.js'), import('../stores/auth.js')]);
+  try {
+    const classId = useAuthStore().classId ?? 'smoke-class';
+    const assignDate = '2030-01-01';
+    const draft = {
+      id: 'smoke-homework-suppressed',
+      classId,
+      title: '本机录入的作业',
+      content: '这条不应该弹上岛',
+      assignDate,
+    };
+    markHomeworkCreatedLocally(draft);
+    const recognized = isLocalHomework(draft);
+    // 同 id、同内容 → 必须认出来；换个标题 → 不算本机录入
+    const recognizedByFingerprint = isLocalHomework({ ...draft, id: '' });
+    const foreign = isLocalHomework({ ...draft, id: 'other', title: '别的作业' });
+
+    const before = await window.desktop?.islandGetState?.();
+    pushHomeworkToIsland({
+      ...draft,
+      courseId: null,
+      attachmentUrl: null,
+      createdBy: '',
+      createdAt: new Date().toISOString(),
+    } as never);
+    await new Promise((resolve) => setTimeout(resolve, 400));
+    const after = await window.desktop?.islandGetState?.();
+    const untouched =
+      (before?.active?.id ?? null) === (after?.active?.id ?? null) &&
+      (before?.queued.length ?? 0) === (after?.queued.length ?? 0);
+
+    return {
+      ok: recognized && recognizedByFingerprint && !foreign && untouched,
+      detail:
+        `按 id 认出=${recognized} 按内容指纹认出=${recognizedByFingerprint} 别的作业误判=${foreign} ` +
+        `投递后灵动岛未变=${untouched}`,
+    };
+  } catch (error) {
+    return {
+      ok: false,
+      detail: `本机作业不上岛自检异常：${error instanceof Error ? error.message : String(error)}`,
+    };
+  }
+}
+
+/**
+ * 冒烟自检（不需要后端）：**初次启动引导**。
+ *
+ * 冒烟每次都用全新配置目录（等于"首次启动"），因此引导必须自动弹出；
+ * 这里真实点击把它一步步走完，断言：遮罩关闭 + `onboardingDone` 已写入配置。
+ * 关闭判据用「元素从 DOM 消失」——引导是 v-if 自绘遮罩（特意不用 el-dialog，
+ * 避免"关闭后 DOM 残留在文档里"的误报，见 AGENTS §7 第 22 条）。
+ */
+export async function onboardingSelfTest(): Promise<SmokeCheckResult> {
+  try {
+    // 引导在启动后延迟 ~400ms 弹出，这里轮询等它出现
+    const appearDeadline = Date.now() + 5000;
+    while (Date.now() < appearDeadline && !document.querySelector('.onboarding-welcome')) {
+      await new Promise((resolve) => setTimeout(resolve, 100));
+    }
+    if (!document.querySelector('.onboarding-welcome')) {
+      const config = await window.desktop?.getConfig?.();
+      return {
+        ok: false,
+        detail: `初次启动引导未自动出现（onboardingDone=${config?.onboardingDone ?? '-'}）`,
+      };
+    }
+
+    // 逐页「下一步」到最后一页再点「开始使用」（按钮由 data-action 标识，不依赖文案）
+    const clicks: string[] = [];
+    for (let attempt = 0; attempt < 12; attempt += 1) {
+      const action = document.querySelector('.onboarding-welcome [data-action="finish"]') ? 'finish' : 'next';
+      const button = document.querySelector<HTMLElement>(`.onboarding-welcome [data-action="${action}"]`);
+      if (!button) break;
+      clicks.push(action);
+      button.click();
+      if (action === 'finish') break;
+      await new Promise((resolve) => setTimeout(resolve, 150));
+    }
+
+    let closed = !document.querySelector('.onboarding-welcome');
+    const closeDeadline = Date.now() + 2000;
+    while (Date.now() < closeDeadline && !closed) {
+      await new Promise((resolve) => setTimeout(resolve, 100));
+      closed = !document.querySelector('.onboarding-welcome');
+    }
+
+    const config = await window.desktop?.getConfig?.();
+    const done = config?.onboardingDone === true;
+    return {
+      ok: closed && done,
+      detail: `步骤点击=[${clicks.join(',')}] 已关闭=${closed} onboardingDone=${config?.onboardingDone ?? '-'}`,
+    };
+  } catch (error) {
+    return {
+      ok: false,
+      detail: `引导自检异常：${error instanceof Error ? error.message : String(error)}`,
+    };
+  }
+}
+
 /** 冒烟收尾：删除自检临时数据 → 断开实时通道 → 退出登录，保证下次冒烟从登录页开始 */
 export async function sessionCleanup(): Promise<SmokeCheckResult> {
   const [{ useAuthStore }, { useRealtimeStore }] = await Promise.all([
@@ -720,6 +933,232 @@ export async function sessionCleanup(): Promise<SmokeCheckResult> {
   }
 }
 
+/**
+ * 冒烟自检（不需要后端）：主界面外观件 —— 主题切换与侧边栏折叠。
+ * 走**真实 DOM 点击**（顶栏日月按钮 / 汉堡按钮），验证：
+ * 1) html.dark 类与 store 同步翻转，且写入主进程配置；
+ * 2) 侧边栏折叠后 el-menu 进入 collapse 态、宽度收窄，配置同步；
+ * 结束时把主题还原为初始值（后续截图/几何用例依赖固定主题）。
+ */
+export async function layoutChromeSelfTest(): Promise<SmokeCheckResult> {
+  try {
+    const { router } = await import('../router/index.js');
+    await router.push('/schedule');
+    if (!(await waitUntil(() => Boolean(document.querySelector('[data-test="theme-toggle"]')), 6000))) {
+      return { ok: false, detail: '主布局未渲染（找不到主题切换按钮）' };
+    }
+
+    const clickToggle = (selector: string): boolean => {
+      const node = document.querySelector<HTMLElement>(selector);
+      if (!node) return false;
+      node.click();
+      return true;
+    };
+
+    // 1) 主题：真实点击日月按钮 → html.dark 翻转 → 配置落盘
+    const initialDark = document.documentElement.classList.contains('dark');
+    if (!clickToggle('[data-test="theme-toggle"]')) return { ok: false, detail: '主题按钮点击失败' };
+    const flipped = await waitUntil(
+      () => document.documentElement.classList.contains('dark') !== initialDark,
+      2500,
+    );
+    const flippedDark = document.documentElement.classList.contains('dark');
+    const configAfterFlip = await window.desktop?.getConfig?.();
+    const themePersisted = configAfterFlip?.theme === (flippedDark ? 'dark' : 'light');
+
+    // 1.5) 顶栏右侧必须水平对齐（用户反馈"深色模式没对齐"，两种主题其实都偏）。
+    //   Element Plus 给按钮的是 `vertical-align:middle`、给下拉容器的是 `vertical-align:top`，
+    //   容器不是 flex 的话两个 inline-level 子元素会各按各的规则落位，错开几像素。
+    const centerYOf = (element: Element | null | undefined): number | null => {
+      if (!element) return null;
+      const rect = element.getBoundingClientRect();
+      return rect.height > 0 ? rect.top + rect.height / 2 : null;
+    };
+    const themeToggleY = centerYOf(document.querySelector('[data-test="theme-toggle"]'));
+    const userChipY = centerYOf(document.querySelector('.user-chip'));
+    const headerCenterDelta =
+      themeToggleY !== null && userChipY !== null ? Math.abs(themeToggleY - userChipY) : null;
+    const headerAligned = headerCenterDelta !== null && headerCenterDelta <= 1.5;
+
+    // 2) 侧边栏：点汉堡折叠 → 图标导轨态 + 宽度收窄（是动画，要等它走完）→ 配置落盘 → 再展开还原
+    const asideBefore = document.querySelector<HTMLElement>('.aside.ch-nav');
+    const widthBefore = asideBefore?.offsetWidth ?? 0;
+    // 2.0) 折叠必须是**动画**而不是瞬切（用户要求"重写菜单的动画"）。
+    //      不去抓中间帧（时序敏感），直接断言侧栏上挂着 width 的过渡 —— 确定性的。
+    const asideComputed = asideBefore ? getComputedStyle(asideBefore) : null;
+    const asideTransitionProperty = asideComputed?.transitionProperty ?? '';
+    const asideTransitionSeconds = asideComputed ? Number.parseFloat(asideComputed.transitionDuration) : 0;
+    const widthAnimated =
+      asideTransitionProperty.includes('width') &&
+      Number.isFinite(asideTransitionSeconds) &&
+      asideTransitionSeconds > 0.05;
+    if (!clickToggle('[data-test="sidebar-toggle"]')) return { ok: false, detail: '汉堡按钮点击失败' };
+    /*
+     * 判据是「宽度收拢到**稳态**」而不是「宽度小于 80」。
+     *
+     * 折叠的目标宽度是 64px（ClientLayout 的 `:width="ui.sidebarCollapsed ? '64px' : '200px'"`），
+     * 而宽度与菜单项内边距是同一条过渡在驱动 —— 只等「≤80」会在动画还剩几十毫秒时就往下走，
+     * 下面量图标中心时内边距仍在变化，量到的是中间帧而非稳态（实测出现过 0.5px 与 2.3px 两个值，
+     * 全看当时机器有多忙）。等它真正到位之后再量，这条断言才是它想表达的"折叠后同列"。
+     */
+    const collapsed = await waitUntil(() => {
+      const aside = document.querySelector<HTMLElement>('.aside.ch-nav');
+      return Boolean(aside?.classList.contains('is-collapsed')) && (aside?.offsetWidth ?? 999) <= 65;
+    }, 4000);
+    const asideAfter = document.querySelector<HTMLElement>('.aside.ch-nav');
+    const widthAfter = asideAfter?.offsetWidth ?? 0;
+    const configAfterCollapse = await window.desktop?.getConfig?.();
+    const collapsePersisted = configAfterCollapse?.sidebarCollapsed === true;
+
+    // 2.1) 折叠态的两条观感硬要求（用户反馈回归）：
+    //   a) 菜单里不允许残留任何**可见**的文字。折叠实现是"文字宽度被 flex 压到 0 + overflow:hidden
+    //      裁掉 + opacity 归零"（`display:none` 无法过渡，用不了），所以判据是"看得见"
+    //      —— 有宽度且未透明 —— 而不是"根本没参与布局"；
+    //   b) 折叠后的图标必须与顶部汉堡按钮在同一竖列（中心 x 相差 ≤ 2px）。
+    //      分组标题里还有个绝对定位的折叠箭头，它同样带 el-icon 类但已淡出，量它没有意义，排除。
+    const centerXOf = (element: Element | null | undefined): number | null => {
+      if (!element) return null;
+      const rect = element.getBoundingClientRect();
+      return rect.width > 0 ? rect.left + rect.width / 2 : null;
+    };
+    const leftoverText: string[] = [];
+    for (const node of Array.from(
+      document.querySelectorAll('.aside .el-menu-item > span, .aside .el-sub-menu__title > span'),
+    )) {
+      const element = node as HTMLElement;
+      if (element.classList.contains('menu-icon-slot')) continue;
+      const text = (element.textContent ?? '').trim();
+      if (!text || element.getClientRects().length === 0) continue;
+      const rect = element.getBoundingClientRect();
+      const opacity = Number(getComputedStyle(element).opacity || '1');
+      if (rect.width >= 1 && opacity > 0.05) leftoverText.push(`可见:${text.slice(0, 6)}`);
+    }
+    const toggleCenter = centerXOf(document.querySelector('[data-test="sidebar-toggle"]'));
+    const iconCenters = Array.from(
+      document.querySelectorAll(
+        '.aside.is-collapsed .menu-icon-slot .el-icon, ' +
+          '.aside.is-collapsed .el-sub-menu__title > .el-icon:not([class*="icon-arrow"])',
+      ),
+    ).map((node) => centerXOf(node));
+    const iconDeltas = iconCenters
+      .filter((value): value is number => value !== null && toggleCenter !== null)
+      .map((value) => Math.abs(value - (toggleCenter as number)));
+    const iconsAligned = iconDeltas.length > 0 && Math.max(...iconDeltas) <= 2;
+
+    // 2.2) 导轨必须"一眼看全"：先把设置组展开（11 行图标 = 最坏情况），再断言菜单区没有纵向溢出。
+    //      折叠态页脚必须把**高度**也收成 0 —— 只淡出不留高度的话，那 ~70px 会把最后两个图标
+    //      顶出可视区，用户就得上下滑动（反馈原话："菜单图标无法完全显示需要上下滑动"）。
+    const settingsItem = Array.from(
+      document.querySelectorAll<HTMLElement>('.aside .el-sub-menu .el-menu-item'),
+    ).find((element) =>
+      Array.from(element.querySelectorAll('span')).some((span) => (span.textContent ?? '').trim() === '通用'),
+    );
+    const submenuOpen = (): boolean => Boolean(settingsItem && settingsItem.offsetParent !== null);
+    if (!submenuOpen()) {
+      // el-sub-menu__title 的点击是 **toggle**：先判"子项是否可见"再点，
+      // 盲点一次会把已展开的组收起来（AGENTS §5 第 49 条）
+      document.querySelector<HTMLElement>('.aside .el-sub-menu__title')?.click();
+      await waitUntil(() => submenuOpen(), 2000);
+    }
+    const railMenu = document.querySelector<HTMLElement>('.aside .menu');
+    const railOverflowPx = railMenu ? railMenu.scrollHeight - railMenu.clientHeight : Number.NaN;
+    const railFits = Number.isFinite(railOverflowPx) && railOverflowPx <= 1;
+
+    clickToggle('[data-test="sidebar-toggle"]');
+    // 展开同样是动画：等宽度回到 200 再继续，否则下面量页脚时侧栏还停在中间宽度
+    const expandedBack = await waitUntil(() => {
+      const aside = document.querySelector<HTMLElement>('.aside.ch-nav');
+      return !aside?.classList.contains('is-collapsed') && (aside?.offsetWidth ?? 0) >= 190;
+    }, 4000);
+
+    // 3) 侧栏不溢出：菜单区自己滚动（.menu 有 min-height:0 + overflow-y:auto），
+    //    底部「第 N 周 / 最近同步」始终留在窗口内 —— 窗口默认高 582px，
+    //    在加这条结构性保证之前，两个分组全展开会把 footer 挤出屏幕（用户反馈）。
+    const footer = document.querySelector<HTMLElement>('.aside-footer');
+    const footerRect = footer?.getBoundingClientRect();
+    const footerVisible =
+      Boolean(footer && footer.offsetParent !== null) &&
+      Boolean(footerRect && footerRect.bottom <= window.innerHeight + 1);
+
+    // 3) 还原主题，避免影响后续用例
+    clickToggle('[data-test="theme-toggle"]');
+    await waitUntil(() => document.documentElement.classList.contains('dark') === initialDark, 2500);
+
+    const ok =
+      flipped &&
+      themePersisted &&
+      headerAligned &&
+      widthAnimated &&
+      collapsed &&
+      collapsePersisted &&
+      widthAfter < widthBefore &&
+      widthAfter <= 80 &&
+      expandedBack &&
+      leftoverText.length === 0 &&
+      iconsAligned &&
+      railFits &&
+      footerVisible;
+    return {
+      ok,
+      detail:
+        `主题翻转=${flipped} 落盘=${themePersisted}(${configAfterFlip?.theme ?? '-'}) ` +
+        `顶栏对齐=${headerAligned}（中线差=${headerCenterDelta === null ? '-' : headerCenterDelta.toFixed(1)}px，要求 ≤1.5px） ` +
+        `宽度过渡=${widthAnimated}(${asideTransitionProperty} ${asideTransitionSeconds}s) ` +
+        `折叠=${collapsed} 宽度=${widthBefore}→${widthAfter} 展开还原=${expandedBack} 落盘=${collapsePersisted} ` +
+        `文字残影=${leftoverText.length === 0 ? '无' : leftoverText.join(',')} ` +
+        `图标与汉堡同列=${iconsAligned}（中心差=${iconDeltas.map((d) => d.toFixed(1)).join('/') || '-'}，要求 ≤2px） ` +
+        `导轨无溢出=${railFits}（溢出=${Number.isFinite(railOverflowPx) ? `${railOverflowPx}px` : '-'}） ` +
+        `侧栏底部可见=${footerVisible}`,
+    };
+  } catch (error) {
+    return {
+      ok: false,
+      detail: `外观件自检异常：${error instanceof Error ? error.message : String(error)}`,
+    };
+  }
+}
+
+/**
+ * 冒烟自检（不需要后端）：关于页（/settings/about）。
+ * 断言页面渲染出标题与「鸣谢 / 诊断信息」区块，且 getAppInfo 返回了新增的 configPath
+ * （诊断信息依赖它）。
+ */
+export async function aboutPageSelfTest(): Promise<SmokeCheckResult> {
+  try {
+    const { router } = await import('../router/index.js');
+    await router.push('/settings/about');
+    const rendered = await waitUntil(
+      () => (document.querySelector('.page-title')?.textContent ?? '').includes('关于'),
+      6000,
+    );
+    if (!rendered) return { ok: false, detail: '关于页未挂载' };
+
+    const text = document.body.innerText.replace(/\s+/g, ' ');
+    const hasThanks = text.includes('鸣谢');
+    const hasDiagnostics = text.includes('诊断信息');
+    const info = await window.desktop?.getAppInfo?.();
+    const hasConfigPath = Boolean(info?.configPath);
+
+    // 检查更新入口（新功能回归）：关于页要有这一块，且按钮可点。
+    // 这里只断言"入口存在"——是否真有新版本取决于 GitHub，不该绑进冒烟（见 main/update.ts）
+    const updateBlock = document.querySelector('[data-test="update-check"]');
+    const updateButton = document.querySelector('[data-test="update-check-button"]');
+
+    await router.push('/schedule');
+    return {
+      ok: hasThanks && hasDiagnostics && hasConfigPath && Boolean(updateBlock) && Boolean(updateButton),
+      detail:
+        `鸣谢=${hasThanks} 诊断=${hasDiagnostics} configPath=${hasConfigPath ? '有' : '无'} ` +
+        `检查更新块=${updateBlock ? '有' : '无'} 按钮=${updateButton ? '有' : '无'}`,
+    };
+  } catch (error) {
+    return {
+      ok: false,
+      detail: `关于页自检异常：${error instanceof Error ? error.message : String(error)}`,
+    };
+  }
+}
+
 /** 注册到 window，供主进程冒烟脚本调用 */
 export function registerSmokeHooks(): void {
   window.__classhelperSmoke__ = {
@@ -730,6 +1169,10 @@ export function registerSmokeHooks(): void {
     islandRealtimeScenario,
     islandRealtimeCleanup,
     islandReadState,
+    islandHomeworkSuppressionCheck,
+    onboardingSelfTest,
+    layoutChromeSelfTest,
+    aboutPageSelfTest,
     scheduleTimelineSelfTest,
     homeworkBoardSelfTest,
     sessionCleanup,

packages/desktop-client/src/renderer/components/OnboardingWelcome.vue

@@ -0,0 +1,311 @@
+<script setup lang="ts">
+import { computed, onUnmounted, ref, watch } from 'vue';
+import { useOnboardingStore } from '../stores/onboarding.js';
+
+/**
+ * 初次启动引导（六步向导）。
+ *
+ * - 首次启动自动弹出（App.vue 按 `onboardingDone` 判定）；完成 / 跳过（右上角按钮 / Esc）
+ *   都算看过，由这里写入主进程配置，之后不再自动弹出。
+ * - 登录页与设置页的「使用引导」入口可随时重看（重看关闭时再写一次也无副作用）。
+ * - **用 v-if 自绘遮罩而不是 el-dialog**：关闭即从 DOM 卸载。冒烟断言"引导已关闭"时
+ *   不会踩 el-dialog「DOM 残留在文档里」的坑（AGENTS §7 第 22 条）。
+ * - 操作按钮用 `data-action` 标识（prev/next/finish/skip），冒烟点击不依赖按钮文案。
+ */
+const onboarding = useOnboardingStore();
+
+const steps = [
+  {
+    icon: 'School',
+    title: '欢迎使用班级小助手',
+    lines: [
+      '这台电脑将以「班级」的身份使用班级小助手：实时接收课表、作业、通知与成绩。',
+      '第一次使用，先花半分钟看看怎么开始。',
+    ],
+  },
+  {
+    icon: 'Link',
+    title: '第一步 · 连接服务器',
+    lines: [
+      '在登录页填写老师或管理员提供的服务器地址（通常形如 http://192.168.x.x:4000）。',
+      '点「测试连接」确认可达；以后也能在「设置」里随时修改。',
+    ],
+  },
+  {
+    icon: 'Key',
+    title: '第二步 · 登录班级',
+    lines: [
+      '使用班级码 + 班级密码登录（向老师或管理员索取）。',
+      '登录后这台设备就代表全班：作业完成、通知已读都会按全班记录，不需要每个学生单独登录。',
+    ],
+  },
+  {
+    icon: 'Calendar',
+    title: '登录之后',
+    lines: [
+      '左侧菜单切换「课表 / 作业 / 通知 / 成绩」四个页面，作业支持看板全屏展示。',
+      '断网时自动显示最近同步的缓存数据，联网后自动更新。',
+    ],
+  },
+  {
+    icon: 'Bell',
+    title: '灵动岛提醒',
+    lines: [
+      '屏幕上方会有一条「灵动岛」浮窗：新通知、叫人、作业都会在那里弹出。',
+      '上课时段自动隐藏、下课自动弹出；外观与位置可在「设置 → 灵动岛」调整。',
+    ],
+  },
+  {
+    icon: 'CircleCheckFilled',
+    title: '准备好了',
+    lines: [
+      '按上面的步骤登录就可以开始使用了。',
+      '侧边栏「设置」分组里有通用、外观（深色模式）、灵动岛等页面；这份引导可以在登录页或「设置 → 通用 → 使用引导」随时重看。',
+    ],
+  },
+];
+
+const index = ref(0);
+const current = computed(() => steps[index.value] ?? steps[0]);
+const isFirst = computed(() => index.value === 0);
+const isLast = computed(() => index.value === steps.length - 1);
+
+/** 每次打开都从第一步开始（重看入口也走完整流程） */
+watch(
+  () => onboarding.visible,
+  (visible) => {
+    if (visible) index.value = 0;
+  },
+);
+
+function goNext(): void {
+  if (isLast.value) finish();
+  else index.value += 1;
+}
+
+function goPrev(): void {
+  if (!isFirst.value) index.value -= 1;
+}
+
+/** 完成 / 跳过统一走这里：记「已看过」并关闭（重看时重复写一次无副作用） */
+function finish(): void {
+  const bridge = window.desktop;
+  // 桥接不可用（浏览器调试）也要能正常关掉引导
+  if (!bridge) {
+    onboarding.close();
+    return;
+  }
+  void bridge
+    .saveConfig({ onboardingDone: true })
+    .then(() => onboarding.close())
+    .catch(() => onboarding.close());
+}
+
+function onKeydown(event: KeyboardEvent): void {
+  if (event.key === 'Escape') finish();
+}
+if (typeof window !== 'undefined') {
+  window.addEventListener('keydown', onKeydown);
+}
+onUnmounted(() => {
+  window.removeEventListener('keydown', onKeydown);
+});
+</script>
+
+<template>
+  <Transition name="onboarding-fade">
+    <div
+      v-if="onboarding.visible"
+      class="onboarding-mask"
+      role="dialog"
+      aria-modal="true"
+      aria-label="初次启动引导"
+    >
+      <div class="onboarding-card onboarding-welcome">
+        <div class="onboarding-head">
+          <span class="onboarding-logo">
+            <el-icon :size="18"><School /></el-icon>
+          </span>
+          <div class="onboarding-heading">
+            <h2 class="onboarding-title">班级小助手</h2>
+            <p class="onboarding-sub">初次启动引导 · 第 {{ index + 1 }} / {{ steps.length }} 步</p>
+          </div>
+          <el-button link class="onboarding-skip" data-action="skip" @click="finish">跳过引导</el-button>
+        </div>
+
+        <div class="onboarding-body">
+          <span class="onboarding-icon">
+            <el-icon :size="30"><component :is="current.icon" /></el-icon>
+          </span>
+          <h3 class="onboarding-step-title">{{ current.title }}</h3>
+          <p v-for="(line, lineIndex) in current.lines" :key="lineIndex" class="onboarding-line">
+            {{ line }}
+          </p>
+        </div>
+
+        <div class="onboarding-foot">
+          <div class="onboarding-dots">
+            <span
+              v-for="(step, dotIndex) in steps"
+              :key="dotIndex"
+              class="dot"
+              :class="{ active: dotIndex === index }"
+            />
+          </div>
+          <div class="onboarding-actions">
+            <el-button v-if="!isFirst" data-action="prev" @click="goPrev">上一步</el-button>
+            <el-button v-if="!isLast" type="primary" data-action="next" @click="goNext">
+              下一步
+            </el-button>
+            <el-button v-else type="primary" data-action="finish" @click="finish">开始使用</el-button>
+          </div>
+        </div>
+      </div>
+    </div>
+  </Transition>
+</template>
+
+<style scoped>
+.onboarding-mask {
+  position: fixed;
+  inset: 0;
+  z-index: 3000;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  padding: 24px;
+  background: rgba(15, 30, 50, 0.55);
+}
+
+.onboarding-card {
+  width: 520px;
+  max-width: 92vw;
+  max-height: 86vh;
+  overflow-y: auto;
+  background: var(--ch-layer-solid);
+  border-radius: 16px;
+  padding: 22px 24px 18px;
+  box-shadow: 0 24px 64px rgba(15, 30, 50, 0.35);
+}
+
+.onboarding-head {
+  display: flex;
+  align-items: center;
+  gap: 10px;
+}
+
+.onboarding-logo {
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  width: 34px;
+  height: 34px;
+  border-radius: 9px;
+  color: #fff;
+  background: linear-gradient(135deg, var(--ch-accent) 0%, #4d94d1 100%);
+}
+
+.onboarding-heading {
+  flex: 1;
+  min-width: 0;
+}
+
+.onboarding-title {
+  margin: 0;
+  font-size: 15px;
+  line-height: 1.3;
+}
+
+.onboarding-sub {
+  margin: 2px 0 0;
+  font-size: 12px;
+  color: var(--ch-text-tertiary);
+}
+
+.onboarding-body {
+  display: flex;
+  flex-direction: column;
+  align-items: flex-start;
+  padding: 18px 4px 6px;
+}
+
+.onboarding-icon {
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  width: 58px;
+  height: 58px;
+  border-radius: 16px;
+  margin-bottom: 14px;
+  color: var(--ch-accent);
+  background: var(--ch-accent-soft);
+}
+
+.onboarding-step-title {
+  margin: 0 0 10px;
+  font-size: 18px;
+}
+
+.onboarding-line {
+  margin: 0 0 8px;
+  font-size: 13px;
+  line-height: 1.8;
+  color: var(--ch-text-regular, #606266);
+}
+
+.onboarding-foot {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 12px;
+  margin-top: 14px;
+  padding-top: 14px;
+  border-top: 1px solid var(--ch-divider);
+}
+
+.onboarding-dots {
+  display: flex;
+  align-items: center;
+  gap: 6px;
+}
+
+.dot {
+  width: 7px;
+  height: 7px;
+  border-radius: 999px;
+  background: var(--ch-border-strong);
+  transition: all 0.2s ease;
+}
+
+.dot.active {
+  width: 20px;
+  background: var(--ch-accent);
+}
+
+.onboarding-actions {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+}
+
+/* 进出场：淡入 + 轻微上浮，跟随系统"动画"开关无强依赖 */
+.onboarding-fade-enter-active,
+.onboarding-fade-leave-active {
+  transition: opacity 0.22s ease;
+}
+
+.onboarding-fade-enter-active .onboarding-card,
+.onboarding-fade-leave-active .onboarding-card {
+  transition: transform 0.22s ease;
+}
+
+.onboarding-fade-enter-from,
+.onboarding-fade-leave-to {
+  opacity: 0;
+}
+
+.onboarding-fade-enter-from .onboarding-card,
+.onboarding-fade-leave-to .onboarding-card {
+  transform: translateY(10px) scale(0.98);
+}
+</style>

packages/desktop-client/src/renderer/components/ScoreBarChart.vue

@@ -0,0 +1,193 @@
+<script setup lang="ts">
+import { computed } from 'vue';
+
+/**
+ * 轻量柱状图（纯 HTML/CSS，不依赖任何图表库）。
+ *
+ * 为什么不用 echarts：成绩页只需要「分组柱 + 数值标签 + 坐标轴」这点东西，
+ * 而 `import * as echarts from 'echarts'` 会给渲染产物加 1.1MB（客户端里最大的一块），
+ * 按需引入 echarts/core 也仍有约 500KB。
+ *
+ * 实现要点（决定了这里为什么不需要 resize 监听）：
+ * - 柱高用**百分比**：`.bar-track` 是行方向 flex 里 `flex:1` 的子项，高度确定，
+ *   柱子的 `height: X%` 直接按它解析；
+ * - 刻度与网格线用**零高度 flex 行 + `justify-content: space-between`**：
+ *   零高度元素的中心正好落在 i/(N-1) 处，与柱状区上下边界精确对齐；
+ * - 纵轴刻度列与绘图区共用同一套上下留白（数值行 18px / 标签行 30px），因此永远对齐。
+ */
+interface BarItem {
+  label: string;
+  value: number;
+}
+
+const props = withDefaults(
+  defineProps<{
+    /** 每根柱：分类名 + 数值（0 ~ max） */
+    items: BarItem[];
+    /** 柱色 */
+    color?: string;
+    /** 纵轴上限 */
+    max?: number;
+    /** 数值单位（显示在刻度与柱顶数值后面） */
+    unit?: string;
+    /** 图表高度（px） */
+    height?: number;
+  }>(),
+  { color: '#409eff', max: 100, unit: '%', height: 300 },
+);
+
+/** 纵轴刻度（自上而下）：100 / 75 / 50 / 25 / 0（按 max 换算） */
+const ticks = computed(() => [1, 0.75, 0.5, 0.25, 0].map((ratio) => Math.round(props.max * ratio)));
+
+function barHeight(value: number): string {
+  const ratio = props.max > 0 ? value / props.max : 0;
+  return `${Math.min(1, Math.max(0, ratio)) * 100}%`;
+}
+
+function formatValue(value: number): string {
+  return `${Number.isInteger(value) ? value : value.toFixed(1)}${props.unit}`;
+}
+</script>
+
+<template>
+  <div class="bar-chart" :style="{ height: `${height}px` }">
+    <div v-if="items.length === 0" class="bar-chart-empty">暂无数据</div>
+    <template v-else>
+      <div class="axis-y" aria-hidden="true">
+        <span v-for="tick in ticks" :key="tick" class="tick">{{ tick }}{{ unit }}</span>
+      </div>
+
+      <div class="plot">
+        <div class="gridlines" aria-hidden="true">
+          <span v-for="tick in ticks" :key="tick" class="gridline"></span>
+        </div>
+
+        <div class="bars">
+          <div v-for="item in items" :key="item.label" class="bar-col">
+            <div class="bar-value">{{ formatValue(item.value) }}</div>
+            <div class="bar-track">
+              <div
+                class="bar"
+                :style="{ height: barHeight(item.value), background: color }"
+                :title="`${item.label}：${formatValue(item.value)}`"
+              ></div>
+            </div>
+            <div class="bar-label" :title="item.label">{{ item.label }}</div>
+          </div>
+        </div>
+      </div>
+    </template>
+  </div>
+</template>
+
+<style scoped>
+.bar-chart {
+  display: grid;
+  grid-template-columns: 46px 1fr;
+  width: 100%;
+}
+
+.bar-chart-empty {
+  grid-column: 1 / -1;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  height: 100%;
+  font-size: 13px;
+  color: var(--ch-text-tertiary);
+}
+
+/* 纵轴刻度：上下留白与 .bars 里的数值行 / 标签行一一对应 */
+.axis-y {
+  display: flex;
+  flex-direction: column;
+  justify-content: space-between;
+  padding: 18px 0 30px;
+}
+
+.tick {
+  height: 0;
+  display: flex;
+  align-items: center;
+  justify-content: flex-end;
+  padding-right: 8px;
+  font-size: 11px;
+  line-height: 1;
+  white-space: nowrap;
+  color: var(--ch-text-tertiary);
+}
+
+.plot {
+  position: relative;
+  min-width: 0;
+}
+
+.gridlines {
+  position: absolute;
+  inset: 18px 0 30px;
+  display: flex;
+  flex-direction: column;
+  justify-content: space-between;
+  pointer-events: none;
+}
+
+.gridline {
+  height: 0;
+  border-top: 1px solid var(--ch-border);
+}
+
+.bars {
+  display: flex;
+  align-items: stretch;
+  gap: 10px;
+  height: 100%;
+  padding: 0 6px;
+}
+
+.bar-col {
+  flex: 1 1 0;
+  min-width: 0;
+  display: flex;
+  flex-direction: column;
+  height: 100%;
+}
+
+.bar-value {
+  flex: none;
+  height: 18px;
+  font-size: 11px;
+  line-height: 1;
+  text-align: center;
+  white-space: nowrap;
+  overflow: hidden;
+  color: var(--ch-text-secondary);
+}
+
+.bar-track {
+  flex: 1 1 auto;
+  min-height: 0;
+  display: flex;
+  align-items: flex-end;
+  justify-content: center;
+}
+
+.bar {
+  width: 100%;
+  max-width: 46px;
+  border-radius: 4px 4px 0 0;
+  transition: height 0.2s ease;
+}
+
+.bar-label {
+  flex: none;
+  height: 30px;
+  padding-top: 6px;
+  font-size: 11px;
+  line-height: 1.3;
+  text-align: center;
+  white-space: nowrap;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  color: var(--ch-text-secondary);
+}
+</style>

packages/desktop-client/src/renderer/composables/motion.ts

@@ -0,0 +1,239 @@
+/**
+ * 动效组合式函数 —— beUI 那套动效语言在客户端的落地层。
+ *
+ * 令牌的**数值**在 `@classhelper/shared` 的 `motion.ts`（单一来源）；
+ * 这里只放需要 DOM / Vue 的部分。内容与 Web 管理端的
+ * `packages/web-admin/src/composables/motion.ts` 一致 —— 与 `ScoreBarChart.vue`
+ * 一样，两端各一份是仓库既有做法。
+ *
+ * 客户端相较 Web 端多一层现实约束：教室机器多为**希沃触摸屏**，
+ * 触摸点按会产生粘住的幽灵 hover，因此 `useHoverCapable()` 在客户端是**必需**的，
+ * 不是锦上添花（见 AGENTS.md §5 第 30 条）。
+ */
+import { computed, onUnmounted, ref, watch, type CSSProperties, type Ref } from 'vue';
+import {
+  EASE_OUT,
+  HOVER_CAPABLE_QUERY,
+  MOTION_DURATION,
+  REDUCED_MOTION_QUERY,
+  cubicBezierCss,
+  motionCssVars,
+} from '@classhelper/shared';
+
+/**
+ * 把动效令牌写进 `:root` 的自定义属性。
+ *
+ * **必须在 `app.mount()` 之前调用**：那样 CSS 里可以放心写 `var(--ch-spring-panel)`，
+ * 首帧之前就已就位，既没有 FOUC，也不需要到处写兜底值。
+ *
+ * ⚠️ 只给**主渲染进程**注入。灵动岛是另一个渲染进程（`src/island/main.ts`），
+ * 它有自己那套从 WinIsland 移植的弹簧物理，刻意不参与这里的动效体系。
+ *
+ * 弹簧用 CSS `linear()` 表达；Electron 44（Chromium 13x）原生支持，
+ * 仍保留 `cubic-bezier` 回落分支以防将来降版本。
+ */
+export function applyMotionTokens(): void {
+  if (typeof document === 'undefined') return;
+  const linear =
+    typeof CSS !== 'undefined' &&
+    typeof CSS.supports === 'function' &&
+    CSS.supports('transition-timing-function', 'linear(0, 1)');
+
+  for (const [name, value] of Object.entries(motionCssVars({ linear }))) {
+    document.documentElement.style.setProperty(name, value);
+  }
+}
+
+/**
+ * 监听 `prefers-reduced-motion`。
+ *
+ * 三元表达式而非直接返回 `matchMedia(...)` 的结果：这条偏好可能在运行中被改动，
+ * 必须跟着变；JS 驱动的动画（数字滚动、位置测量）拿不到 CSS 那层自动降级，得自己看这个值。
+ */
+export function useReducedMotion(): Ref<boolean> {
+  const matches = ref(false);
+  if (typeof window === 'undefined' || typeof window.matchMedia !== 'function') return matches;
+
+  const query = window.matchMedia(REDUCED_MOTION_QUERY);
+  matches.value = query.matches;
+
+  const update = (): void => {
+    matches.value = query.matches;
+  };
+  // Electron 的 Chromium 支持 addEventListener；保留旧接口兜底
+  if (typeof query.addEventListener === 'function') {
+    query.addEventListener('change', update);
+    onUnmounted(() => query.removeEventListener('change', update));
+  } else if (typeof query.addListener === 'function') {
+    query.addListener(update);
+    onUnmounted(() => query.removeListener(update));
+  }
+  return matches;
+}
+
+/**
+ * 是否有真正的悬停能力（鼠标 / 触控板）。
+ *
+ * 触摸设备在点按时会触发**幽灵 hover** 并一直粘着，直到点别处才消失 ——
+ * 教室里的希沃触摸屏正属于这种，所有 hover-only 效果（抬升、磁吸、光标跟随）
+ * 都必须先过这一关，否则触摸屏上会出现"点一下，卡片就永远浮着"。
+ */
+export function useHoverCapable(): Ref<boolean> {
+  const capable = ref(false);
+  if (typeof window === 'undefined' || typeof window.matchMedia !== 'function') return capable;
+
+  const query = window.matchMedia(HOVER_CAPABLE_QUERY);
+  capable.value = query.matches;
+
+  const update = (): void => {
+    capable.value = query.matches;
+  };
+  if (typeof query.addEventListener === 'function') {
+    query.addEventListener('change', update);
+    onUnmounted(() => query.removeEventListener('change', update));
+  } else if (typeof query.addListener === 'function') {
+    query.addListener(update);
+    onUnmounted(() => query.removeListener(update));
+  }
+  return capable;
+}
+
+/** 缓动函数：给定进度 t∈[0,1]，返回缓动后的进度。即 EASE_OUT 那条贝塞尔的求值。 */
+function easeOutProgress(t: number): number {
+  const [x1, y1, x2, y2] = EASE_OUT;
+  // 牛顿迭代反解 x(u) = t，再用同一个 u 求 y —— 三次贝塞尔求值的标准做法
+  let u = t;
+  for (let i = 0; i < 6; i += 1) {
+    const x = 3 * (1 - u) ** 2 * u * x1 + 3 * (1 - u) * u ** 2 * x2 + u ** 3;
+    const dx = 3 * (1 - u) ** 2 * x1 + 6 * (1 - u) * u * (x2 - x1) + 3 * u ** 2 * (1 - x2);
+    if (Math.abs(dx) < 1e-6) break;
+    u = Math.min(1, Math.max(0, u - (x - t) / dx));
+  }
+  return 3 * (1 - u) ** 2 * u * y1 + 3 * (1 - u) * u ** 2 * y2 + u ** 3;
+}
+
+export interface CountUpOptions {
+  /** 时长（毫秒）。默认 `MOTION_DURATION.slow`。 */
+  duration?: number;
+}
+
+/**
+ * 数字滚动：目标值变化时从当前显示值滚过去，而不是直接跳。
+ *
+ * `reduced-motion` 下**直接落位**（不启动 rAF）。
+ *
+ * 刻意**不**给"首次变化"开豁免：数据是异步加载的，挂载那一刻目标值还是 0，
+ * 真正想看到滚动的恰恰是"0 → 实际值"这第一跳；而如果数据在挂载时就已就位
+ * （离线缓存命中），`displayed` 初始化即等于目标值、根本不会触发 watch。
+ */
+export function useCountUp(source: () => number, options: CountUpOptions = {}): Ref<number> {
+  const reduce = useReducedMotion();
+  const duration = options.duration ?? MOTION_DURATION.slow;
+  const displayed = ref(source());
+  let frame = 0;
+
+  function stop(): void {
+    if (frame) {
+      cancelAnimationFrame(frame);
+      frame = 0;
+    }
+  }
+
+  watch(source, (target) => {
+    stop();
+    if (reduce.value || duration <= 0) {
+      displayed.value = target;
+      return;
+    }
+    const from = displayed.value;
+    const delta = target - from;
+    if (delta === 0) return;
+
+    const start = performance.now();
+    const tick = (now: number): void => {
+      const progress = Math.min(1, (now - start) / duration);
+      displayed.value = from + delta * easeOutProgress(progress);
+      if (progress < 1) frame = requestAnimationFrame(tick);
+      else {
+        displayed.value = target;
+        frame = 0;
+      }
+    };
+    frame = requestAnimationFrame(tick);
+  });
+
+  onUnmounted(stop);
+  return displayed;
+}
+
+/**
+ * 列表错峰入场：返回一个"给第 index 项算内联样式"的函数，
+ * 配合 CSS 类 `.ch-reveal`（见 `styles/index.css`）使用。
+ *
+ * 延迟**封顶**（默认第 8 项之后不再累加）：一屏几十行时，最后一行不该等一秒才出现。
+ */
+export function useStaggerIn(step = 35, maxIndex = 8): (index: number) => CSSProperties {
+  const reduce = useReducedMotion();
+  return (index: number): CSSProperties =>
+    reduce.value ? {} : ({ '--ch-reveal-delay': `${Math.min(index, maxIndex) * step}ms` } as CSSProperties);
+}
+
+/** 把 reduced-motion 折成一个布尔，供模板里判断"要不要挂动画类"。 */
+export function useMotionEnabled(): Ref<boolean> {
+  const reduce = useReducedMotion();
+  return computed(() => !reduce.value);
+}
+
+/**
+ * 整页换肤的揭示动画（beUI 的 `theme-toggle`）：新旧两帧各存一张快照，
+ * 让新帧从一个**从点击位置扩散的圆**里长出来 —— 这是"整个界面换了张皮"这件事
+ * 唯一能让人**看见**的表达方式，比整页硬切一下好懂得多。
+ *
+ * 返回的函数直接挂 `@click`：`@click="reveal($event, () => ui.setTheme(next))"`。
+ *
+ * 三条守卫缺一不可：
+ *   ① 不认识 View Transition API 的浏览器直接走同步切换；
+ *   ② 系统开了「减少动态效果」时不放全屏动画；
+ *   ③ **文档不可见时不放**（最小化、被遮挡、无头浏览器）—— 那种情况下浏览器不产生帧，
+ *      而 View Transition 的更新回调要等到下一个渲染时机才执行，**主题会一直不切**。
+ *      教室机器上窗口被别的窗口盖住是常态，这条尤其要守。
+ */
+export function useThemeReveal(): (event: MouseEvent, apply: () => void) => void {
+  const reduce = useReducedMotion();
+
+  return (event, apply) => {
+    const doc = document as Document & {
+      startViewTransition?: (callback: () => void) => { ready: Promise<void> };
+    };
+    if (
+      typeof doc.startViewTransition !== 'function' ||
+      reduce.value ||
+      document.visibilityState !== 'visible'
+    ) {
+      apply();
+      return;
+    }
+
+    const { clientX: x, clientY: y } = event;
+    void doc
+      .startViewTransition(apply)
+      .ready.then(() => {
+        // 半径取到最远的那个角，圆才能把整屏吃完
+        const radius = Math.hypot(
+          Math.max(x, window.innerWidth - x),
+          Math.max(y, window.innerHeight - y),
+        );
+        document.documentElement.animate(
+          { clipPath: [`circle(0px at ${x}px ${y}px)`, `circle(${radius}px at ${x}px ${y}px)`] },
+          {
+            // 比常规过渡长一点 —— 它是一次**整屏**的变化，太快会读成"闪了一下"而不是"换了一层皮"
+            duration: MOTION_DURATION.slow * 1.5,
+            // 缓动取自共享令牌，别在这里手写曲线字面量（那是漂移的起点）
+            easing: cubicBezierCss(EASE_OUT),
+            pseudoElement: '::view-transition-new(root)',
+          },
+        );
+      })
+      .catch(() => undefined);
+  };
+}

packages/desktop-client/src/renderer/config.ts

@@ -3,6 +3,19 @@ import { DEFAULT_SERVER_URL } from '@classhelper/shared';
 /** 默认后端地址（首次启动的预填值） */
 export const DEFAULT_SERVER = DEFAULT_SERVER_URL;
 
+/**
+ * 品牌标地址（侧栏与登录页的 `<img>` 用它）。
+ *
+ * 模板里既不能写 `src="logo.png"`、也不能写 `src="/logo.png"`：
+ *   ① 字面量的**相对** `src` 会被 Vite 当成模块导入去解析 —— 构建直接失败
+ *      （`Rolldown failed to resolve import "logo.png" from "LoginView.vue"`）；
+ *   ② 根绝对路径在打包形态下是坏的：Electron 用 `file://` 加载
+ *      `dist/renderer/index.html`，`/logo.png` 会解析到**盘符根目录**。
+ * 所以只能「绑定属性 + 跟着 vite base 走」：base 为 `'./'`，结果是 `./logo.png`，
+ * 开发态（5174 静态服务）与打包态（`dist/renderer/logo.png`）都指向 public/ 拷过去的那份。
+ */
+export const BRAND_LOGO_URL = `${import.meta.env.BASE_URL}logo.png`;
+
 /** 由服务器地址推导 API 基地址，例如 http://127.0.0.1:4000 -> http://127.0.0.1:4000/api */
 export function apiBaseOf(serverUrl: string): string {
   return `${serverUrl.trim().replace(/\/+$/, '')}/api`;

packages/desktop-client/src/renderer/icons.ts

@@ -0,0 +1,94 @@
+import type { App } from 'vue';
+import {
+  AlarmClock,
+  ArrowDown,
+  ArrowLeft,
+  ArrowRight,
+  Bell,
+  Brush,
+  Calendar,
+  CircleCheckFilled,
+  Connection,
+  Expand,
+  Fold,
+  FullScreen,
+  Guide,
+  InfoFilled,
+  Key,
+  Link,
+  Loading,
+  Lock,
+  MagicStick,
+  Moon,
+  Notebook,
+  Plus,
+  Pointer,
+  Refresh,
+  School,
+  Setting,
+  Sunny,
+  SwitchButton,
+  Tools,
+  Trophy,
+  UserFilled,
+  Warning,
+} from '@element-plus/icons-vue';
+
+/**
+ * Element Plus 图标注册表（桌面客户端渲染进程）。
+ *
+ * **为什么不 `import * as ElementPlusIconsVue` 全量注册**：
+ * 图标库有 293 个组件（实测全量打包 minified 203KB，实际用到的只有 33 个），
+ * 全量注册既把死代码打进主 chunk，又要在启动时执行 293 次 `app.component()`。
+ *
+ * **为什么不改成模板里逐个 import**：本项目的图标是按**字符串名**引用的
+ * （`ClientLayout.vue` 的菜单配置 `icon: 'Setting'`、`OnboardingWelcome.vue` 的引导步骤、
+ * 按钮上的 `:icon="'FullScreen'"`、`<component :is="item.icon">`），Element Plus 会用
+ * `<component :is="'Setting'">` 去解析**全局组件名**，因此图标必须以全局组件存在。
+ *
+ * 新增视图时若用了新图标，`scripts/check-icons.mjs` 会在构建前报错，
+ * 不会静默渲染成空白。
+ */
+const APP_ICONS = {
+  AlarmClock,
+  ArrowDown,
+  ArrowLeft,
+  ArrowRight,
+  Bell,
+  Brush,
+  Calendar,
+  CircleCheckFilled,
+  Connection,
+  Expand,
+  Fold,
+  FullScreen,
+  Guide,
+  InfoFilled,
+  Key,
+  Link,
+  Loading,
+  Lock,
+  MagicStick,
+  Moon,
+  Notebook,
+  Plus,
+  Pointer,
+  Refresh,
+  School,
+  Setting,
+  Sunny,
+  SwitchButton,
+  Tools,
+  Trophy,
+  UserFilled,
+  Warning,
+} as const;
+
+/** 供 `scripts/check-icons.mjs` 读取的名单（构建期静态校验用） */
+export const APP_ICON_NAMES: readonly string[] = Object.keys(APP_ICONS).sort();
+
+export function registerAppIcons(app: App): void {
+  for (const [name, component] of Object.entries(APP_ICONS)) {
+    app.component(name, component);
+  }
+}

packages/desktop-client/src/renderer/island/bridge.ts

@@ -92,6 +92,11 @@ export function pushNotificationToIsland(notification: NotificationDto): void {
 
 /** 新作业上岛（homework:new）：胶囊提示"新作业"，点击展开看作业要求 */
 export function pushHomeworkToIsland(homework: HomeworkDto): void {
+  // 本机刚录入的作业不再上岛：教室机器上录作业的人就是眼前这台设备的主人，
+  // 再弹一张"新作业"卡片纯属自己通知自己（用户反馈）。
+  if (isLocalHomework(homework)) {
+    return;
+  }
   window.desktop?.islandPush({
     notification: {
       id: `homework-${homework.id}`,
@@ -107,6 +112,62 @@ export function pushHomeworkToIsland(homework: HomeworkDto): void {
   });
 }
 
+/* ------------------------------------------------------------ 本机录入的作业 */
+
+/**
+ * 本机刚录入的作业指纹。
+ *
+ * 为什么按指纹而不只按 id：`homework:new` 是服务端**先广播、后回响应**的，
+ * 录入接口返回的 id 很可能比实时事件到得还晚 —— 只记 id 会漏掉"事件先到"的那一半，
+ * 于是本机录的作业照样弹上岛。因此在发请求**之前**就按内容记一份指纹，
+ * 回来后补记 id（覆盖事件晚到的情况）。指纹带 TTL，避免长期占用内存。
+ */
+const localHomeworkKeys = new Set<string>();
+let localHomeworkKeysAt = 0;
+const LOCAL_HOMEWORK_TTL_MS = 60_000;
+
+/** 作业内容指纹：同一班、同一天、同标题同正文 = 就是本机刚录的那条 */
+function homeworkFingerprint(homework: {
+  classId?: string | null;
+  title?: string | null;
+  content?: string | null;
+  assignDate?: string | null;
+}): string {
+  return [
+    homework.classId ?? '',
+    homework.assignDate ?? '',
+    (homework.title ?? '').trim(),
+    (homework.content ?? '').trim(),
+  ].join('|');
+}
+
+/** 录入前/后登记"这条作业是本机录的"（id 可后补） */
+export function markHomeworkCreatedLocally(homework: {
+  id?: string | null;
+  classId?: string | null;
+  title?: string | null;
+  content?: string | null;
+  assignDate?: string | null;
+}): void {
+  const now = Date.now();
+  if (now - localHomeworkKeysAt > LOCAL_HOMEWORK_TTL_MS) localHomeworkKeys.clear();
+  localHomeworkKeysAt = now;
+  localHomeworkKeys.add(homeworkFingerprint(homework));
+  if (homework.id) localHomeworkKeys.add(homework.id);
+}
+
+/** 这条作业是不是本机刚录的（供投递前判定与冒烟验证） */
+export function isLocalHomework(homework: {
+  id?: string | null;
+  classId?: string | null;
+  title?: string | null;
+  content?: string | null;
+  assignDate?: string | null;
+}): boolean {
+  if (homework.id && localHomeworkKeys.has(homework.id)) return true;
+  return localHomeworkKeys.has(homeworkFingerprint(homework));
+}
+
 /**
  * "叫人"上岛：紧急叫人（priority=URGENT）无视上课时段立即展开；
  * 普通叫人按普通通知处理（课间先显示胶囊、点击展开，上课时段只排队）。
@@ -148,15 +209,40 @@ export function subscribeIslandMarkRead(): void {
   });
 }
 
+/**
+ * 灵动岛点了"标为已读"（多条通知的整批）→ 把这一批都在通知中心里标记已读。
+ * 与单条版本同一套兜底：离线时先在本地记为已读。
+ */
+export function subscribeIslandMarkAllRead(): void {
+  window.desktop?.onIslandMarkAllRead?.((ids) => {
+    void (async () => {
+      const store = useNotificationStore();
+      await Promise.all(
+        (ids ?? []).map(async (id) => {
+          try {
+            await store.markRead(id);
+          } catch {
+            const target = store.items.find((item) => item.id === id);
+            if (target) target.read = true;
+          }
+        }),
+      );
+    })();
+  });
+}
+
+/** 具名的课表变更处理器：匿名函数在停止时无法 off 掉，会随"登出→登录"越挂越多 */
+function onScheduleUpdated(): void {
+  void refreshIslandSchedules().catch(() => undefined);
+}
+
 export function startIslandBridge(): void {
   if (tickTimer) return;
 
   void refreshIslandSchedules().catch(() => undefined);
 
   // 课表变更（教师改课）立即复算，避免"下课后不弹出"或"上课没隐藏"
-  useRealtimeStore().on(SOCKET_EVENTS.scheduleUpdated, () => {
+  useRealtimeStore().on(SOCKET_EVENTS.scheduleUpdated, onScheduleUpdated);
-    void refreshIslandSchedules().catch(() => undefined);
-  });
 
   tickTimer = setInterval(() => recomputeClassState(), TICK_INTERVAL_MS);
   refreshTimer = setInterval(() => {
@@ -164,9 +250,31 @@ export function startIslandBridge(): void {
   }, REFRESH_INTERVAL_MS);
 }
 
+/**
+ * 停止桥接：退出登录 / 切换账号时必须调用。
+ *
+ * 只清定时器是不够的：
+ * - 订阅要 off，否则每次"登出 → 登录"都会多挂一份监听；
+ * - 本地课表缓存要清空，否则登出后仍会按**上一个班**的课表继续给主进程下发"上课/下课"
+ *   （灵动岛按陈旧课表隐藏或弹出），换班登录时第一轮刷新回来之前用的也是旧课表。
+ */
 export function stopIslandBridge(): void {
   if (tickTimer) clearInterval(tickTimer);
   if (refreshTimer) clearInterval(refreshTimer);
   tickTimer = null;
   refreshTimer = null;
+
+  useRealtimeStore().off(SOCKET_EVENTS.scheduleUpdated, onScheduleUpdated);
+  schedules = [];
+  currentPeriod = null;
+  inClass = false;
+
+  // 把"不在上课"同步给主进程：否则主进程还记着上一个会话的"上课中"，
+  // 重新登录后若第一轮课表刷新失败（离线且无缓存），灵动岛会继续按上课态把通知压着不弹，
+  // 直到下一次刷新成功为止。这里主动对齐一次，代价是登出瞬间可能补弹一条此前被暂存的通知。
+  window.desktop?.islandSetClassState({
+    inClass: false,
+    currentPeriodEnd: null,
+    week: useAppStore().currentWeek,
+  });
 }

packages/desktop-client/src/renderer/layouts/ClientLayout.vue

@@ -1,12 +1,16 @@
 <script setup lang="ts">
-import { computed, onMounted, onUnmounted } from 'vue';
+import { computed, nextTick, onMounted, onUnmounted, ref, watch } from 'vue';
 import { useRoute, useRouter } from 'vue-router';
-import { ElMessage, ElMessageBox } from 'element-plus';
+import { ElMessage, ElMessageBox, type MenuInstance } from 'element-plus';
 import { SOCKET_EVENTS, type NotificationDto } from '@classhelper/shared';
+import { startIslandBridge, stopIslandBridge } from '../island/bridge.js';
+import { useThemeReveal } from '../composables/motion.js';
+import { BRAND_LOGO_URL } from '../config.js';
 import { useAppStore } from '../stores/app.js';
 import { useAuthStore } from '../stores/auth.js';
 import { useNotificationStore } from '../stores/notifications.js';
 import { useRealtimeStore } from '../stores/realtime.js';
+import { useUiStore } from '../stores/ui.js';
 
 const route = useRoute();
 const router = useRouter();
@@ -14,18 +18,186 @@ const appStore = useAppStore();
 const auth = useAuthStore();
 const realtime = useRealtimeStore();
 const notifications = useNotificationStore();
+const ui = useUiStore();
 
-const menuItems = [
+/**
+ * 主侧边栏。
+ *
+ * - **一级项**：课表 / 作业 / 通知 / 成绩 —— 直接铺在侧栏上，**不再套「学习」分组**。
+ *   分组标题白占一行、还得多点一次展开，折叠成图标导轨时尤其明显（用户要求拆掉）。
+ * - **分组**：只剩「设置」（通用 / 外观 / 灵动岛 / 提醒 / 账号 / 关于，各自是独立路由）。
+ *   6 个子项平铺太长，保留分组与"默认只展开当前路由所在分组"。折叠后是图标导轨，
+ *   分组子项与一级项一样以图标列出（见 styles/index.css 的折叠态规则）。
+ *
+ * 顶栏左侧汉堡按钮把整栏收成图标导轨（状态持久化在主进程配置里）。
+ */
+const primaryItems = [
   { path: '/schedule', title: '课表', icon: 'Calendar' },
   { path: '/homeworks', title: '作业', icon: 'Notebook' },
   { path: '/notifications', title: '通知', icon: 'Bell' },
   { path: '/grades', title: '成绩', icon: 'Trophy' },
-  { path: '/settings', title: '设置', icon: 'Setting' },
 ];
 
+const menuGroups = [
+  {
+    title: '设置',
+    icon: 'Setting',
+    items: [
+      { path: '/settings/general', title: '通用', icon: 'Tools' },
+      { path: '/settings/appearance', title: '外观', icon: 'Brush' },
+      { path: '/settings/island', title: '灵动岛', icon: 'MagicStick' },
+      { path: '/settings/reminder', title: '提醒', icon: 'AlarmClock' },
+      { path: '/settings/account', title: '账号', icon: 'UserFilled' },
+      { path: '/settings/about', title: '关于', icon: 'InfoFilled' },
+    ],
+  },
+];
+
+/* -------------------------------------------------------------- 导航指示器 */
+
+/**
+ * 侧栏激活项的**滑动指示器**（beUI 的 `shared-layout-bg` / tabs 的 layoutId 手法）。
+ *
+ * 做法是**一个**绝对定位的底片跟着激活项平移，而不是让每个菜单项各自画一块底色 ——
+ * 后者在切换时是"旧的瞬间消失、新的瞬间出现"，看不出两者之间的关系。
+ *
+ * 位置靠**量 DOM**：菜单项的位置由 Element Plus 的 padding 与行高决定，
+ * 写死会在组件库升级或文案变长时错位；折叠成图标导轨时宽度还会变，量出来才跟得上。
+ *
+ * ⚠️ 这里用 `document.querySelector` 而不是模板 ref：`.aside` 是 `el-aside` **组件**，
+ * 模板 ref 拿到的是组件实例（`.querySelector` 不是函数，实测踩过）；
+ * 客户端只有一个主侧栏，直接查文档反而更直白。
+ */
+const indicator = ref({ x: 0, y: 0, width: 0, height: 0, visible: false });
+
+function syncIndicator(): void {
+  const aside = document.querySelector<HTMLElement>('.aside.ch-nav');
+  const active = aside?.querySelector<HTMLElement>('.el-menu-item.is-active');
+  if (!aside || !active) {
+    indicator.value = { ...indicator.value, visible: false };
+    return;
+  }
+  const asideRect = aside.getBoundingClientRect();
+  const rect = active.getBoundingClientRect();
+  indicator.value = {
+    x: rect.left - asideRect.left,
+    y: rect.top - asideRect.top,
+    width: rect.width,
+    height: rect.height,
+    visible: rect.width > 0 && rect.height > 0,
+  };
+}
+
+const indicatorStyle = computed(() => ({
+  width: `${indicator.value.width}px`,
+  height: `${indicator.value.height}px`,
+  transform: `translate(${indicator.value.x}px, ${indicator.value.y}px)`,
+  opacity: indicator.value.visible ? '1' : '0',
+}));
+
+let asideObserver: ResizeObserver | null = null;
+let indicatorFrame = 0;
+
+/**
+ * 把测量推迟到下一帧再跑。
+ *
+ * 侧栏折叠时 `.aside` 的宽度有一整段过渡，`ResizeObserver` 会逐帧回调；若在回调里**同步**
+ * 读 `getBoundingClientRect()` 再写样式，就是在每一帧中间强行插入一次同步布局
+ * （Chromium 还会因此报 "ResizeObserver loop completed with undelivered notifications"）。
+ * 放进 rAF 就变成"本帧布局完成后统一量一次"，代价是跟随慢一帧，肉眼无感。
+ */
+function scheduleIndicatorSync(): void {
+  if (indicatorFrame) return;
+  indicatorFrame = requestAnimationFrame(() => {
+    indicatorFrame = 0;
+    syncIndicator();
+  });
+}
+
+/**
+ * 首次测量放在 `onMounted`：子组件先于父组件挂载完成，此刻 `.el-menu-item.is-active`
+ * 已在文档里，量完再让浏览器首帧绘制 —— 指示器第一次出现就是正确位置，不会从左上角滑过去。
+ *
+ * `ResizeObserver` 不是为了窗口缩放，而是为了**侧栏折叠**：折叠时 `.aside` 的宽度
+ * 有一整段过渡（`--nav-dur`），观察它会逐帧回调，指示器于是跟着栏宽一起收 ——
+ * 否则图标导轨形成后，底片还停在展开态的宽度上。
+ */
+onMounted(() => {
+  syncIndicator();
+  const aside = document.querySelector<HTMLElement>('.aside.ch-nav');
+  if (aside && typeof ResizeObserver !== 'undefined') {
+    asideObserver = new ResizeObserver(scheduleIndicatorSync);
+    asideObserver.observe(aside);
+  }
+});
+
+onUnmounted(() => {
+  if (indicatorFrame) cancelAnimationFrame(indicatorFrame);
+  indicatorFrame = 0;
+  asideObserver?.disconnect();
+  asideObserver = null;
+});
+
+// 路由变化后菜单的 active 类由 Element Plus 更新，等一拍再量
+watch(
+  () => route.path,
+  () => {
+    void nextTick(syncIndicator);
+  },
+);
+
+/* ---------------------------------------------------------- 主题切换动画 */
+
+/**
+ * 顶栏的日夜快捷切换。
+ *
+ * "从点击位置扩散的圆"那套整页揭示由 `useThemeReveal()` 提供 ——
+ * **与 Web 管理端共用同一份实现**（两端 `composables/motion.ts` 里的同名函数），
+ * 这里只负责把"点击事件"和"切换主题"接起来。那三条守卫（不支持 View Transition /
+ * 减少动态效果 / 文档不可见）都在组合式函数里，别在这里再判一遍。
+ */
+const revealThemeChange = useThemeReveal();
+
+function handleThemeToggle(event: MouseEvent): void {
+  revealThemeChange(event, () => ui.toggleTheme());
+}
+
+/** 未读红点挂在「通知」项的图标右上角 */
+function showBadge(path: string): boolean {
+  return path === '/notifications' && notifications.unreadCount > 0;
+}
+
 /** 高亮当前菜单：直接比较路由路径，避免依赖路由名 */
 const activeMenu = computed(() => route.path);
 
+/** 当前路由所属的分组标题（用于"只默认展开所在分组"，与 ClassIsland 一致） */
+const activeGroupTitle = computed(() => {
+  const group = menuGroups.find((item) => item.items.some((entry) => route.path === entry.path));
+  // 落在**一级项**（课表/作业/通知/成绩）上没有所属分组 —— 返回 null，别拿某个组的名字顶上去
+  return group?.title ?? null;
+});
+
+/**
+ * 分组展开控制：默认只展开**当前路由所在的分组**（一级项不属于任何分组，此时一个都不展开）。
+ *
+ * 窗口默认高度与 ClassIsland 对齐（582px），设置组 6 个子项展开后会超出可视高度、
+ * 把底部的「账号 / 关于」挤出屏幕；只展开当前组既符合 ClassIsland 的观感（它也只展开当前组），
+ * 又让小窗口下的侧栏始终完整可见。用户手动展开其它分组不受限制（可多个同时展开）。
+ */
+const menuRef = ref<MenuInstance>();
+const openedGroups = ref<string[]>(activeGroupTitle.value ? [activeGroupTitle.value] : []);
+
+watch(
+  () => route.path,
+  async (path) => {
+    const group = menuGroups.find((item) => item.items.some((entry) => path === entry.path));
+    if (!group) return;
+    // 展开当前组（不主动关闭用户已展开的其它组）
+    await nextTick();
+    menuRef.value?.open(group.title);
+  },
+);
+
 /**
  * 菜单点击回调。
  * 注意：el-menu 的 @select 抛出的是 index（这里即路由路径），
@@ -43,12 +215,14 @@ function go(name: string): void {
 /** 开发期自检：菜单路径必须存在于路由表中 */
 if (import.meta.env.DEV) {
   const knownPaths = new Set(router.getRoutes().map((item) => item.path));
-  for (const item of menuItems) {
+  for (const group of menuGroups) {
+    for (const item of group.items) {
       if (!knownPaths.has(item.path)) {
         console.error(`[ClientLayout] 菜单项未注册对应路由：${item.path}`);
       }
     }
   }
+}
 
 const connectionType = computed(() => {
   if (realtime.connected) return 'success';
@@ -70,10 +244,14 @@ async function handleLogout(): Promise<void> {
   void router.push({ name: 'login' });
 }
 
-/** 通知实时推送：更新列表 + 红点 + 缓存 */
+/**
+ * 通知实时推送：更新通知中心列表与红点。
+ *
+ * 这里**不再**额外弹一条"收到新通知"的 toast —— `stores/realtime.ts` 收到
+ * notification:new 时已经弹过带优先级与标题的那条，两条堆在屏幕上纯属噪音。
+ */
 function onNotification(payload: unknown): void {
   void notifications.pushRealtime(payload as NotificationDto);
-  ElMessage({ message: '收到新通知，点击「通知」查看', type: 'info', duration: 3000 });
 }
 
 /** 服务器从不可达恢复为可达：自动同步一次（联网后自动同步） */
@@ -87,30 +265,59 @@ onMounted(async () => {
   await notifications.refreshUnreadCount();
   realtime.on(SOCKET_EVENTS.notificationNew, onNotification);
   appStore.onServerRecovered(onRecovered);
+  // 灵动岛桥接跟着"已登录布局"的生命周期走：这样退出登录会随布局卸载而停止，
+  // 重新登录（或换班登录）时又会重新启动，不会拿旧课表算上课状态。
+  if (auth.token) startIslandBridge();
 });
 
 onUnmounted(() => {
   realtime.off(SOCKET_EVENTS.notificationNew, onNotification);
   appStore.offServerRecovered(onRecovered);
+  stopIslandBridge();
 });
 </script>
 
 <template>
   <el-container class="layout">
-    <el-aside width="200px" class="aside ch-nav">
+    <el-aside
+      :width="ui.sidebarCollapsed ? '64px' : '200px'"
+      class="aside ch-nav"
+      :class="{ 'is-collapsed': ui.sidebarCollapsed }"
+    >
       <div class="brand">
-        <span class="brand-logo">
+        <button
-          <el-icon :size="16"><School /></el-icon>
+          type="button"
-        </span>
+          class="nav-toggle"
+          aria-label="折叠或展开侧边栏"
+          :aria-expanded="ui.sidebarCollapsed ? 'false' : 'true'"
+          data-test="sidebar-toggle"
+          @click="ui.toggleSidebar()"
+        >
+          <el-icon :size="16"><Expand v-if="ui.sidebarCollapsed" /><Fold v-else /></el-icon>
+        </button>
+        <!-- 品牌区在折叠时**不是 v-if 删掉**，而是靠 CSS 收宽度 + 淡出：
+             v-if 会在动画中途把节点直接摘掉，看上去是"啪"地一跳；收放要连续就得让它们一直在。 -->
+        <img class="brand-logo" :src="BRAND_LOGO_URL" alt="" width="26" height="26" />
         <span class="brand-text">班级小助手</span>
       </div>
-      <el-menu :default-active="activeMenu" class="menu" @select="handleMenuSelect">
+      <!-- 激活项的滑动指示器：单个底片在菜单项之间平移，位置由 syncIndicator() 量出来。
-        <el-menu-item v-for="item in menuItems" :key="item.path" :index="item.path">
+           pointer-events:none 是必需的 —— 它盖在菜单项上，否则会把点击吃掉。 -->
-          <!-- 未读红点挂在图标右上角（之前挂在文字后面，位置不对） -->
+      <div class="nav-indicator" :style="indicatorStyle" aria-hidden="true" />
+      <el-menu
+        ref="menuRef"
+        :default-active="activeMenu"
+        :default-openeds="openedGroups"
+        class="menu"
+        @select="handleMenuSelect"
+      >
+        <!-- 一级项：直接铺在侧栏上（不再套「学习」分组）。
+             下面 el-sub-menu 里的菜单项与本段是同一套标记（图标槽 + 未读红点 + 标题），
+             改动时两处要一起改。 -->
+        <el-menu-item v-for="item in primaryItems" :key="item.path" :index="item.path">
           <span class="menu-icon-slot">
             <el-icon><component :is="item.icon" /></el-icon>
             <el-badge
-              v-if="item.path === '/notifications' && notifications.unreadCount > 0"
+              v-if="showBadge(item.path)"
               :value="notifications.unreadCount"
               :max="99"
               class="menu-badge"
@@ -118,7 +325,27 @@ onUnmounted(() => {
           </span>
           <span>{{ item.title }}</span>
         </el-menu-item>
+        <el-sub-menu v-for="group in menuGroups" :key="group.title" :index="group.title">
+          <template #title>
+            <el-icon><component :is="group.icon" /></el-icon>
+            <span>{{ group.title }}</span>
+          </template>
+          <el-menu-item v-for="item in group.items" :key="item.path" :index="item.path">
+            <!-- 未读红点挂在图标右上角（之前挂在文字后面，位置不对） -->
+            <span class="menu-icon-slot">
+              <el-icon><component :is="item.icon" /></el-icon>
+              <el-badge
+                v-if="showBadge(item.path)"
+                :value="notifications.unreadCount"
+                :max="99"
+                class="menu-badge"
+              />
+            </span>
+            <span>{{ item.title }}</span>
+          </el-menu-item>
+        </el-sub-menu>
       </el-menu>
+      <!-- 同上：折叠时不删节点，只淡出并收掉内边距 -->
       <div class="aside-footer">
         <div class="aside-meta">第 {{ appStore.currentWeek }} 周</div>
         <div class="aside-meta">最近同步：{{ appStore.lastSyncText }}</div>
@@ -133,6 +360,19 @@ onUnmounted(() => {
           <span class="server-url">{{ appStore.serverUrl }}</span>
         </div>
         <div class="header-right">
+          <!-- 黑夜/白天快捷切换：外观页里也有同样的设置，两处写同一份配置 -->
+          <el-tooltip :content="ui.theme === 'dark' ? '切换到浅色模式' : '切换到深色模式'" placement="bottom">
+            <el-button
+              class="theme-toggle"
+              text
+              circle
+              data-test="theme-toggle"
+              :aria-label="ui.theme === 'dark' ? '切换到浅色模式' : '切换到深色模式'"
+              @click="handleThemeToggle"
+            >
+              <el-icon><Sunny v-if="ui.theme === 'dark'" /><Moon v-else /></el-icon>
+            </el-button>
+          </el-tooltip>
           <el-dropdown trigger="click">
             <span class="user-chip">
               <el-icon><UserFilled /></el-icon>
@@ -141,7 +381,7 @@ onUnmounted(() => {
             </span>
             <template #dropdown>
               <el-dropdown-menu>
-                <el-dropdown-item @click="go('settings')">
+                <el-dropdown-item @click="go('settings-general')">
                   <el-icon><Setting /></el-icon>
                   设置
                 </el-dropdown-item>
@@ -165,6 +405,19 @@ onUnmounted(() => {
           title="当前处于离线状态"
           :description="`服务器不可达，正在显示本地缓存数据（最近同步：${appStore.lastSyncText}）。恢复网络后会自动同步。`"
         />
+        <!--
+          这里**刻意不用** `<transition>` 包 router-view。
+          页面切换的动效由 `.page > *` 的错峰入场承担（styles/index.css）——
+          那是随组件挂载同步触发的，不推迟任何东西。
+
+          包一层过渡（尤其 `mode="out-in"`）会把"旧组件卸载、新组件挂载"推迟到退场动画结束
+          （90ms 起）。代价有两个，都不值得：
+            ① 点菜单后有一小段时间页面上还是**上一页**，用户和自动化看到的都是旧内容；
+            ② 退场判定依赖 `animationend`，窗口被遮挡时 Chromium 冻结 CSS 动画、
+               事件永不触发，新页面就永远不挂载 —— 整个客户端卡死在当前页。
+               教室机器上窗口被别的东西盖住是常态，这条尤其要守。
+          真要加回来，必须先确认这两条都有人兜住。
+        -->
         <router-view v-slot="{ Component }">
           <component :is="Component" />
         </router-view>
@@ -182,6 +435,54 @@ onUnmounted(() => {
 .aside {
   display: flex;
   flex-direction: column;
+  /* 展开/收回动画：宽度来自 el-aside 的内联 --el-aside-width，这里只负责过渡。
+     overflow:hidden 是必需的 —— 收窄过程中文字要被栏边裁掉，不能溢出到主区域；
+     菜单自己的滚动由内部的 .menu（flex:1 + min-height:0 + overflow-y:auto）负责。 */
+  overflow: hidden;
+  transition: width var(--nav-dur) var(--nav-ease);
+  /* 滑动指示器（.nav-indicator）的定位父级 */
+  position: relative;
+}
+
+/*
+ * 导航指示器：一个跟着激活项平移的底片，承载了原先"激活项底色 + 左侧强调条"两件事。
+ *
+ * 位置与尺寸都由 syncIndicator() 量出来后内联下发，这里只负责外观与过渡。
+ * 缓动用 LAYOUT 弹簧（397ms）—— 它是"共享布局滑动"的专用参数：比 SWAP（263ms）更有分量，
+ * 因为这一跳可能跨越好几个菜单项，太快会显得"闪"而不是"滑"。
+ *
+ * 折叠成图标导轨时，栏宽有一整段 260ms 的过渡，ResizeObserver 会逐帧把新宽度送进来，
+ * 底片于是跟着栏宽一起收窄 —— 两个时长不一致是**故意的**：底片比栏慢一点，
+ * 读起来像"被栏宽带着走"，同步反而显得僵硬。
+ */
+.nav-indicator {
+  position: absolute;
+  top: 0;
+  left: 0;
+  z-index: 0;
+  border-radius: var(--ch-radius-control);
+  background: var(--ch-accent-soft);
+  /* 必须穿透：它盖在菜单项上，否则点击会被它吃掉 */
+  pointer-events: none;
+  will-change: transform;
+  transition:
+    transform var(--ch-spring-layout-dur) var(--ch-spring-layout),
+    width var(--ch-spring-layout-dur) var(--ch-spring-layout),
+    height var(--ch-spring-layout-dur) var(--ch-spring-layout),
+    opacity var(--ch-dur-fast) var(--ch-ease-out);
+}
+
+/* 左侧强调条（原有观感，现在跟着底片一起滑） */
+.nav-indicator::before {
+  content: '';
+  position: absolute;
+  left: 0;
+  top: 50%;
+  transform: translateY(-50%);
+  width: 3px;
+  height: 16px;
+  border-radius: 2px;
+  background: var(--ch-accent);
 }
 
 .brand {
@@ -189,34 +490,119 @@ onUnmounted(() => {
   align-items: center;
   gap: 10px;
   height: 52px;
-  padding: 0 16px;
+  padding: 0 10px 0 12px;
   font-weight: 600;
   font-size: 14px;
   color: var(--ch-text);
+  transition:
+    padding-left var(--nav-dur) var(--nav-ease),
+    gap var(--nav-dur) var(--nav-ease);
 }
 
-/* Fluent 品牌标：强调色圆角方块 + 白色图标 */
+/* 汉堡按钮：折叠/展开整个侧边栏（状态持久化） */
-.brand-logo {
+.nav-toggle {
   display: inline-flex;
   align-items: center;
   justify-content: center;
-  width: 26px;
+  width: 28px;
-  height: 26px;
+  height: 28px;
-  border-radius: 6px;
+  flex: 0 0 auto;
-  color: #fff;
+  border: none;
-  background: linear-gradient(135deg, var(--ch-accent) 0%, #4d94d1 100%);
+  border-radius: var(--ch-radius-control);
+  background: transparent;
+  color: var(--ch-text-secondary);
+  cursor: pointer;
+  transition: background 0.15s ease;
 }
 
+.nav-toggle:hover {
+  background: var(--ch-hover-soft);
+}
+
+/* 折叠态：侧栏只剩 64px，汉堡按钮水平居中。
+   用**位移 padding-left** 而不是 `justify-content: center` —— 后者不可过渡，会在动画中途"跳"一下。
+   汉堡宽 28px，padding-left 18px ⇒ 中心 = 18 + 14 = 32px，正好是 64/2，与折叠后的图标导轨同列
+   （冒烟断言中心差 ≤ 2px）。
+   这里刻意用**自己的类名**（`.is-collapsed`）而不是 `:has(.el-menu--collapse)`：
+   `:has()` 的失效会让 Chromium 标记整棵文档树重新计算样式。 */
+.aside.ch-nav.is-collapsed .brand {
+  padding-left: 18px;
+}
+
+/*
+ * 品牌标：与应用图标同一份图（`public/logo.png`，由 `pnpm icons` 从 `build/classhelper.png` 生成）。
+ * 上一版这里是"强调色渐变方块 + 白色 School 字形"手搓的占位标，换成真图标之后
+ * `background` / `color` / `border-radius` / `overflow` 全部撤掉 —— 圆角与透明边角本来就在图里，
+ * 再叠一层只会出现双重圆角。
+ *
+ * `src` 走 `BRAND_LOGO_URL`（见 `config.ts`）：模板里既不能写字面量的相对 `src`（Vite 会把它
+ * 当模块导入去解析、构建失败），也不能写根绝对路径（Electron 生产环境走 file://，会解析到盘符根目录）。
+ *
+ * 折叠态的 `.is-collapsed .brand-logo { width: 0 }` 照旧生效：img 的 width 一样可过渡，
+ * 而且它本来就带 opacity 淡出，收放观感与改造前完全一致。
+ */
+.brand-logo {
+  display: block;
+  width: 26px;
+  height: 26px;
+  flex: 0 0 auto;
+  transition:
+    width var(--nav-dur) var(--nav-ease),
+    opacity calc(var(--nav-dur) * 0.6) var(--nav-ease);
+}
+
+/*
+ * 品牌文字 / 菜单文字在折叠时**不靠 max-width 归零**（那要么写死一个魔法数字，要么
+ * `none → 0` 根本不可过渡），而是：
+ *   - `min-width: 0` 让这个 flex 子项能被压缩（默认的 `min-width: auto` 会撑住内容宽度）；
+ *   - 宽度自然跟着栏宽收缩，多出来的字被 `overflow: hidden` 裁掉；
+ *   - 再叠一层 opacity 淡出，避免在中间帧里留下"半截字"。
+ * 于是文字宽度是**跟着侧栏宽度连续变化**的，不需要给它单独设动画终点。
+ */
 .brand-text {
+  min-width: 0;
+  overflow: hidden;
+  white-space: nowrap;
   letter-spacing: 0.2px;
+  transition: opacity calc(var(--nav-dur) * 0.6) var(--nav-ease);
+}
+
+/* 折叠：品牌区收成 0 宽并淡出（不是删节点，理由见模板上的注释） */
+.aside.ch-nav.is-collapsed .brand {
+  gap: 0;
+}
+
+/*
+ * 图标导轨里**不显示滚动条**：所有图标应当一眼看全（用户要求"不要用滚轮、删掉滚动条"）。
+ * 导轨之所以放得下，靠的是页脚在折叠态把高度也收成 0（见 .is-collapsed .aside-footer）——
+ * 不再有那 ~70px 的留白，11 行图标（462px）在 540px 的最小窗口里也够。
+ * 这里只隐藏滚动条本身，`overflow-y: auto` 保留：窗口被拉到极矮时还能滚，不至于把图标直接裁掉。
+ * 展开态**不隐藏** —— 那一栏确实会超（设置组展开时约 606px > 582px），
+ * 滚动条是"下面还有内容"的唯一提示，不能拿掉。
+ */
+.aside.ch-nav.is-collapsed .menu {
+  scrollbar-width: none;
+}
+
+.aside.ch-nav.is-collapsed .brand-logo {
+  width: 0;
+  opacity: 0;
+}
+
+.aside.ch-nav.is-collapsed .brand-text {
+  opacity: 0;
 }
 
 .menu {
   flex: 1;
+  /* min-height:0 是 flex 子项能滚动的关键：否则内容撑高、底部 footer 被挤出窗口 */
+  min-height: 0;
+  overflow-y: auto;
+  overflow-x: hidden;
   border-right: none;
   background: transparent;
   --el-menu-bg-color: transparent;
-  --el-menu-hover-bg-color: rgba(0, 0, 0, 0.04);
+  --el-menu-hover-bg-color: var(--ch-hover-soft);
   --el-menu-text-color: var(--ch-text);
   --el-menu-active-color: var(--ch-text);
 }
@@ -260,6 +646,30 @@ onUnmounted(() => {
 .aside-footer {
   padding: 10px 16px 14px;
   border-top: 1px solid var(--ch-divider);
+  overflow: hidden;
+  /* max-height 是给折叠动画用的终点：`* { box-sizing: border-box }`，展开态给一个略高于
+     内容（约 70px）的值，折叠时归零 —— 导轨里**一个像素都不给页脚留**。
+     不这么做的话，文字淡出后仍占着 ~70px，10 个图标在 540px 的最小窗口里就放不下、被迫滚动
+     （用户反馈："图标无法完全显示、需要上下滑动、滚动条碍眼"）。 */
+  max-height: 96px;
+  transition:
+    opacity calc(var(--nav-dur) * 0.7) var(--nav-ease),
+    padding var(--nav-dur) var(--nav-ease),
+    max-height var(--nav-dur) var(--nav-ease),
+    border-top-color var(--nav-dur) var(--nav-ease);
+}
+
+/* 折叠：页脚淡出、内边距与高度一起收到 0，分隔线也透明掉。
+   `min-height: 0` 是必需的：flex 子项默认 `min-height: auto`（= 内容高度），
+   而 CSS 里 min-height 优先于 max-height —— 不显式归零的话 max-height:0 根本压不下去。 */
+.aside.ch-nav.is-collapsed .aside-footer {
+  opacity: 0;
+  padding-top: 0;
+  padding-bottom: 0;
+  max-height: 0;
+  min-height: 0;
+  border-top-color: transparent;
+  pointer-events: none;
 }
 
 .aside-meta {
@@ -270,7 +680,7 @@ onUnmounted(() => {
 
 .header {
   height: 52px;
-  background: rgba(255, 255, 255, 0.6);
+  background: var(--ch-header-bg);
   backdrop-filter: blur(20px);
   border-bottom: 1px solid var(--ch-border);
   display: flex;
@@ -292,6 +702,17 @@ onUnmounted(() => {
   color: var(--ch-text-tertiary);
 }
 
+.header-right {
+  /* 必须是 flex：Element Plus 的按钮是 `vertical-align: middle`、下拉容器是 `vertical-align: top`，
+     放在普通 block 容器里两个 inline-level 子元素会按各自的垂直对齐规则落位，主题切换按钮与
+     用户名牌就会错开几像素（用户反馈的"深色模式没对齐"，其实两种主题下都偏，只是深色下更显眼）。
+     与 Web 管理端 AdminLayout 的同名容器保持同一套写法。 */
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  flex: 0 0 auto;
+}
+
 .user-chip {
   display: flex;
   align-items: center;
@@ -304,7 +725,12 @@ onUnmounted(() => {
 }
 
 .user-chip:hover {
-  background: rgba(0, 0, 0, 0.04);
+  background: var(--ch-hover-soft);
+}
+
+.theme-toggle {
+  /* 与用户名牌的间距由 .header-right 的 gap 负责，这里不再自带 margin */
+  color: var(--ch-text-secondary);
 }
 
 .main {

packages/desktop-client/src/renderer/main.ts

@@ -2,28 +2,53 @@ import { createApp } from 'vue';
 import { createPinia } from 'pinia';
 import ElementPlus from 'element-plus';
 import zhCn from 'element-plus/es/locale/lang/zh-cn';
-import * as ElementPlusIconsVue from '@element-plus/icons-vue';
 import 'element-plus/dist/index.css';
+// 深色主题：html.dark 下的 --el-* 变量（品牌覆盖在 styles/index.css 的 html.dark 块）
+import 'element-plus/theme-chalk/dark/css-vars.css';
 
 import App from './App.vue';
 import router from './router/index.js';
-import { registerSmokeHooks } from './cache/self-test.js';
+import { registerAppIcons } from './icons.js';
+import { applyMotionTokens } from './composables/motion.js';
 import './styles/index.css';
 
 const app = createApp(App);
 
-for (const [name, component] of Object.entries(ElementPlusIconsVue)) {
+// 按需注册图标（见 icons.ts：只注册用到的那些，而不是全量 293 个）
-  app.component(name, component);
+registerAppIcons(app);
-}
 
 app.use(createPinia());
 app.use(router);
 app.use(ElementPlus, { locale: zhCn });
 
-// 冒烟验证模式：把缓存自检钩子暴露给主进程调用（正常运行时不存在）
+// 冒烟验证模式：把缓存自检钩子暴露给主进程调用（正常运行时不存在）。
+//
+// **动态 import 是刻意的**：`cache/self-test.ts` 有 1000 多行自检代码，
+// 静态 import 会把它打进渲染进程入口 chunk，每次启动都要解析一遍。改成动态 import 后
+// Vite/Rollup 会把它切成独立 chunk，只在冒烟模式下才加载（`verify:desktop` /
+// `verify:packaged` 的那条路径）。
+//
+// 教师凭据由 preload 从环境变量透传（**不写在代码里**：渲染产物会进 app.asar 发给学生机）。
 if (window.desktop?.smokeTest) {
+  const { registerSmokeHooks, setSmokeTeacherCredentials } = await import('./cache/self-test.js');
+  setSmokeTeacherCredentials({
+    username: window.desktop.smokeCredentials?.username ?? '',
+    password: window.desktop.smokeCredentials?.password ?? '',
+  });
   registerSmokeHooks();
 }
 
+/**
+ * 动效令牌（beUI 那套缓动与弹簧，见 packages/shared/src/motion.ts）写进 :root。
+ *
+ * 必须在 mount 之前：CSS 里引用的 `var(--ch-spring-*)` 要在首帧之前就已就位，
+ * 否则第一帧会按"变量不存在"渲染一遍（表现为入场动画闪一下）。
+ * 也刻意排在主题恢复（stores/ui.ts 的 init）之前 —— 令牌与主题互不相干，
+ * 但先落令牌能让首屏的入场动画从第一帧起就是对的节奏。
+ *
+ * ⚠️ 灵动岛是**另一个渲染进程**（src/island/main.ts），不经过这里。
+ */
+applyMotionTokens();
+
 await router.isReady();
 app.mount('#app');

packages/desktop-client/src/renderer/router/index.ts

@@ -41,11 +41,46 @@ const routes: RouteRecordRaw[] = [
         component: () => import('../views/GradeView.vue'),
         meta: { title: '成绩' },
       },
+      /* 设置：主侧边栏「设置」分组下的六个子页（ClassIsland 式 主菜单+子菜单） */
       {
         path: 'settings',
-        name: 'settings',
+        redirect: '/settings/general',
-        component: () => import('../views/SettingsView.vue'),
+      },
-        meta: { title: '设置' },
+      {
+        path: 'settings/general',
+        name: 'settings-general',
+        component: () => import('../views/settings/GeneralSettingsView.vue'),
+        meta: { title: '通用设置' },
+      },
+      {
+        path: 'settings/appearance',
+        name: 'settings-appearance',
+        component: () => import('../views/settings/AppearanceView.vue'),
+        meta: { title: '外观' },
+      },
+      {
+        path: 'settings/island',
+        name: 'settings-island',
+        component: () => import('../views/settings/IslandSettingsView.vue'),
+        meta: { title: '灵动岛' },
+      },
+      {
+        path: 'settings/reminder',
+        name: 'settings-reminder',
+        component: () => import('../views/settings/ReminderSettingsView.vue'),
+        meta: { title: '提醒' },
+      },
+      {
+        path: 'settings/account',
+        name: 'settings-account',
+        component: () => import('../views/settings/AccountSettingsView.vue'),
+        meta: { title: '账号' },
+      },
+      {
+        path: 'settings/about',
+        name: 'settings-about',
+        component: () => import('../views/settings/AboutView.vue'),
+        meta: { title: '关于' },
       },
     ],
   },

packages/desktop-client/src/renderer/stores/onboarding.ts

@@ -0,0 +1,24 @@
+import { ref } from 'vue';
+import { defineStore } from 'pinia';
+
+/**
+ * 初次启动引导的显示状态。
+ *
+ * 首次启动由 App.vue 按「配置里是否记过 onboardingDone」自动弹出；
+ * 登录页与设置页的「使用引导」入口调用 open() 随时重看。
+ * 单独一个 store 而不是组件内部 ref：触发入口（登录页 / 设置页）与
+ * 渲染点（App.vue 顶层）分处两棵互不相干的子树。
+ */
+export const useOnboardingStore = defineStore('onboarding', () => {
+  const visible = ref(false);
+
+  function open(): void {
+    visible.value = true;
+  }
+
+  function close(): void {
+    visible.value = false;
+  }
+
+  return { visible, open, close };
+});

packages/desktop-client/src/renderer/stores/ui.ts

@@ -0,0 +1,73 @@
+import { ref } from 'vue';
+import { defineStore } from 'pinia';
+import type { DesktopStoredConfig } from '../../types/desktop.js';
+
+/**
+ * 界面偏好（主题 / 侧边栏折叠）。
+ *
+ * 持久化在主进程配置（DesktopStoredConfig.theme / sidebarCollapsed）里，
+ * 与灵动岛外观等设置同一套落盘机制；浏览器调试（无 window.desktop）回落 localStorage。
+ * 深色主题 = 在 <html> 上挂 .dark 类（Element Plus dark css-vars + styles/index.css 的
+ * html.dark 品牌变量），应用主题的全部入口都必须走 setTheme，保证类名与配置同步。
+ */
+
+const THEME_KEY = 'classhelper.theme';
+const SIDEBAR_KEY = 'classhelper.sidebarCollapsed';
+
+function applyThemeClass(theme: 'light' | 'dark'): void {
+  document.documentElement.classList.toggle('dark', theme === 'dark');
+}
+
+export const useUiStore = defineStore('ui', () => {
+  const theme = ref<'light' | 'dark'>('light');
+  const sidebarCollapsed = ref(false);
+
+  /** 启动时从主进程配置恢复（App.vue 的 boot 流程里调用，早于首屏渲染） */
+  async function init(): Promise<void> {
+    if (window.desktop) {
+      const config = await window.desktop.getConfig().catch(() => null);
+      if (config) {
+        theme.value = config.theme === 'dark' ? 'dark' : 'light';
+        sidebarCollapsed.value = config.sidebarCollapsed === true;
+      }
+    } else {
+      theme.value = localStorage.getItem(THEME_KEY) === 'dark' ? 'dark' : 'light';
+      sidebarCollapsed.value = localStorage.getItem(SIDEBAR_KEY) === '1';
+    }
+    applyThemeClass(theme.value);
+  }
+
+  /** 切换主题（外观页单选 / 顶栏快捷切换共用），写回配置 */
+  async function setTheme(next: 'light' | 'dark'): Promise<void> {
+    theme.value = next;
+    applyThemeClass(next);
+    if (window.desktop) {
+      await window.desktop.saveConfig({ theme: next }).catch(() => undefined);
+    } else {
+      localStorage.setItem(THEME_KEY, next);
+    }
+  }
+
+  function toggleTheme(): void {
+    void setTheme(theme.value === 'dark' ? 'light' : 'dark');
+  }
+
+  /** 主侧边栏折叠/展开（汉堡按钮），写回配置 */
+  async function setSidebarCollapsed(collapsed: boolean): Promise<void> {
+    sidebarCollapsed.value = collapsed;
+    if (window.desktop) {
+      await window.desktop.saveConfig({ sidebarCollapsed: collapsed }).catch(() => undefined);
+    } else {
+      localStorage.setItem(SIDEBAR_KEY, collapsed ? '1' : '0');
+    }
+  }
+
+  function toggleSidebar(): void {
+    void setSidebarCollapsed(!sidebarCollapsed.value);
+  }
+
+  return { theme, sidebarCollapsed, init, setTheme, toggleTheme, setSidebarCollapsed, toggleSidebar };
+});
+
+/** 供类型检查使用（仅引用类型） */
+export type UiConfig = Pick<DesktopStoredConfig, 'theme' | 'sidebarCollapsed'>;

packages/desktop-client/src/renderer/styles/index.css

@@ -1,12 +1,19 @@
 /* ============================================================================
- * 班级小助手客户端主题 —— ClassIsland 同款 Fluent 风格
+ * 班级小助手客户端主题 —— ClassIsland 同款 Fluent 风格（浅色 / 深色双主题）
  *
  * 参考 ClassIsland（Windows 课件表应用）的观感：
- *  - WinUI / Fluent 设计语言：浅色 Mica 底 + 半透明"亚克力"卡片 + 1px 细腻描边
+ *  - WinUI / Fluent 设计语言：Mica 底 + 半透明"亚克力"卡片 + 1px 细腻描边
  *  - 强调色 #0F6CBD（悬停 #115EA3），选中项用强调色淡底 + 左侧强调条
  *  - 圆角：卡片 8px、控件 4~6px、胶囊 999px
  *  - 字体：Segoe UI Variable / 微软雅黑 UI，字号偏小、行距偏松
  *  - 阴影极轻（0 2px 4px rgba(0,0,0,.04)），层次主要靠描边与底色区分
+ *
+ * 主题机制：
+ *  - 全部颜色走 --ch-* / --el-* 变量，:root 是浅色值；
+ *  - 深色主题 = html 根元素挂 .dark 类（由 stores/ui.ts 按配置切换），
+ *    Element Plus 的 dark/css-vars.css（main.ts 引入）提供 --el-* 深色默认，
+ *    下面的 html.dark 块覆盖品牌变量（特异性高于 :root，必定生效）；
+ *  - 组件里**不要写死颜色**，一律用变量——深色回归靠这条纪律守着。
  * ========================================================================== */
 
 :root {
@@ -33,12 +40,40 @@
   --ch-text-secondary: #5c5c5c;
   --ch-text-tertiary: #8a8a8a;
 
+  /* 交互态（悬停底色 / 侧栏与顶栏的亚克力底 / 滚动条） */
+  --ch-hover-soft: rgba(0, 0, 0, 0.04);
+  --ch-nav-bg: rgba(255, 255, 255, 0.65);
+  --ch-header-bg: rgba(255, 255, 255, 0.6);
+  --ch-scrollbar: rgba(0, 0, 0, 0.18);
+  --ch-scrollbar-hover: rgba(0, 0, 0, 0.3);
+
   /* 圆角与阴影 */
   --ch-radius-card: 8px;
   --ch-radius-control: 4px;
   --ch-shadow-flyout: 0 8px 16px rgba(0, 0, 0, 0.08);
   --ch-shadow-card: 0 2px 4px rgba(0, 0, 0, 0.04);
 
+  /*
+   * 侧栏收放动画。组件（ClientLayout 的 .aside/.brand/.brand-logo/.aside-footer）
+   * 与全局的菜单导轨规则（下面的 .ch-nav.is-collapsed …）共用这一份参数，
+   * 改时长/缓动只改这里，两边不会漂。
+   *
+   * ⚠️ 缓动**刻意保留 Material 的 cubic-bezier(.4, 0, .2, 1)**，没有换成全站统一的
+   * beUI EASE_OUT。试过的后果：EASE_OUT 起步极快，宽度掉到 80px 以下时动画才走了约 35%，
+   * 而冒烟自检 layoutChromeSelfTest 一旦读到"宽度 ≤ 80"就立刻量图标中心 ——
+   * 此刻内边距还在动，量出来 6 个分组子项偏 2.3px（要求 ≤2px），直接判红。
+   * 原曲线的 0.882 进度点落在 74% 处，剩下的时间足够动画跑完，量到的是稳态。
+   * 换句话说：**这条断言是按"收完之后的几何"写的，而它采样的时机取决于缓动的形状**，
+   * 想换曲线就得连那条断言一起重新商量。
+   *
+   * ⚠️ 时长**不要**改到 0.05s 以下：同一条自检断言"折叠必须真的是动画"
+   * （读 getComputedStyle 的 transitionDuration，要求 > 0.05）。
+   */
+  --nav-dur: 260ms;
+  --nav-ease: cubic-bezier(0.4, 0, 0.2, 1);
+  /* 图标与文字的间距（折叠时收到 0） */
+  --nav-gap: 8px;
+
   /* 兼容旧变量名 */
   --ch-sidebar: #ffffff;
 
@@ -62,6 +97,55 @@
   --el-font-size-base: 13px;
 }
 
+/* ---------------------------------------------------------------- 深色主题 */
+
+html.dark {
+  --ch-accent: #5aabec;
+  --ch-accent-hover: #7cc0f4;
+  --ch-accent-soft: rgba(90, 171, 236, 0.16);
+  --ch-accent-soft-strong: rgba(90, 171, 236, 0.26);
+
+  --ch-bg: #161719;
+  --ch-layer: rgba(32, 33, 36, 0.72);
+  --ch-layer-solid: #1e1f23;
+  --ch-layer-alt: rgba(28, 29, 32, 0.5);
+  --ch-card-subtle: rgba(255, 255, 255, 0.04);
+
+  --ch-border: rgba(255, 255, 255, 0.08);
+  --ch-border-strong: rgba(255, 255, 255, 0.14);
+  --ch-divider: rgba(255, 255, 255, 0.06);
+
+  --ch-text: #e8e8ea;
+  --ch-text-secondary: #b0b1b5;
+  --ch-text-tertiary: #7e7f85;
+
+  --ch-hover-soft: rgba(255, 255, 255, 0.07);
+  --ch-nav-bg: rgba(28, 29, 32, 0.65);
+  --ch-header-bg: rgba(30, 31, 34, 0.6);
+  --ch-scrollbar: rgba(255, 255, 255, 0.22);
+  --ch-scrollbar-hover: rgba(255, 255, 255, 0.36);
+
+  --ch-shadow-flyout: 0 8px 16px rgba(0, 0, 0, 0.45);
+  --ch-shadow-card: 0 2px 4px rgba(0, 0, 0, 0.3);
+
+  --ch-sidebar: #1e1f23;
+
+  /* Element Plus 深色下的品牌色对齐（dark/css-vars.css 的默认蓝偏亮，这里对齐品牌） */
+  --el-color-primary: #4a9eff;
+  --el-color-primary-light-3: #337fd6;
+  --el-color-primary-light-5: #2563ab;
+  --el-color-primary-light-7: #1b4a82;
+  --el-color-primary-light-8: #163c6b;
+  --el-color-primary-light-9: #122f55;
+  --el-color-primary-dark-2: #6cb4ff;
+  --el-text-color-primary: #e8e8ea;
+  --el-text-color-regular: #c9cacd;
+  --el-text-color-secondary: #9a9b9f;
+  --el-border-color: rgba(255, 255, 255, 0.12);
+  --el-border-color-light: rgba(255, 255, 255, 0.08);
+  --el-border-color-lighter: rgba(255, 255, 255, 0.06);
+}
+
 * {
   box-sizing: border-box;
 }
@@ -179,12 +263,12 @@ textarea {
 }
 
 .el-button--default {
-  background: rgba(255, 255, 255, 0.7) !important;
+  background: var(--ch-layer) !important;
   border-color: var(--ch-border-strong) !important;
 }
 
 .el-button--default:hover {
-  background: rgba(0, 0, 0, 0.04) !important;
+  background: var(--ch-hover-soft) !important;
 }
 
 .el-button--primary {
@@ -195,7 +279,7 @@ textarea {
 .el-textarea__inner,
 .el-select__wrapper {
   border-radius: var(--ch-radius-control) !important;
-  background: rgba(255, 255, 255, 0.7) !important;
+  background: var(--ch-layer) !important;
   box-shadow: 0 0 0 1px var(--ch-border-strong) inset !important;
 }
 
@@ -224,12 +308,38 @@ textarea {
   box-shadow: var(--ch-shadow-flyout) !important;
 }
 
+/* 关于页的折叠卡片：与 el-card 同一套观感（分割线代替卡片描边） */
+.el-collapse {
+  --el-collapse-border-color: var(--ch-divider);
+  border: none !important;
+}
+
+.el-collapse-item__header {
+  background: var(--ch-layer) !important;
+  border: 1px solid var(--ch-border) !important;
+  border-radius: var(--ch-radius-card) !important;
+  padding: 0 16px;
+  margin-top: 8px;
+  font-weight: 600;
+  font-size: 13.5px;
+}
+
+.el-collapse-item__wrap {
+  background: transparent !important;
+  border-bottom: none !important;
+}
+
+.el-collapse-item__content {
+  padding: 12px 6px 4px !important;
+  color: var(--ch-text);
+}
+
 /* ---------------------------------------------------------------- 表格 */
 
 .el-table {
   --el-table-border-color: var(--ch-divider);
   --el-table-header-bg-color: transparent;
-  --el-table-row-hover-bg-color: rgba(0, 0, 0, 0.03);
+  --el-table-row-hover-bg-color: var(--ch-hover-soft);
   background: transparent !important;
 }
 
@@ -251,12 +361,13 @@ textarea {
 /* ---------------------------------------------------------------- 侧边导航（Fluent NavigationView 观感） */
 
 .ch-nav {
-  background: rgba(255, 255, 255, 0.65);
+  background: var(--ch-nav-bg);
   backdrop-filter: blur(24px) saturate(1.2);
   border-right: 1px solid var(--ch-border);
 }
 
-.ch-nav .el-menu-item {
+.ch-nav .el-menu-item,
+.ch-nav .el-sub-menu__title {
   height: 40px;
   line-height: 40px;
   margin: 2px 8px;
@@ -266,26 +377,122 @@ textarea {
   position: relative;
 }
 
-.ch-nav .el-menu-item:hover {
+.ch-nav .el-menu-item:hover,
-  background: rgba(0, 0, 0, 0.04);
+.ch-nav .el-sub-menu__title:hover {
+  background: var(--ch-hover-soft);
+}
+
+/* 分组标题：比普通菜单项轻一档（分组是"容器"，不是目的地） */
+.ch-nav .el-sub-menu__title {
+  font-weight: 600;
+  color: var(--ch-text-secondary);
+}
+
+.ch-nav .el-sub-menu .el-menu {
+  background: transparent;
+}
+
+/*
+ * 选中项：强调色淡底 + 左侧强调条（WinUI 经典样式）。
+ *
+ * 底色与强调条**都改由滑动指示器承担**（见 ClientLayout.vue 的 `.nav-indicator`）——
+ * 原先每个激活项各画一块，切换时是"旧的瞬间消失、新的瞬间出现"，看不出两者之间的关系；
+ * 现在由同一个底片滑过去。指示器是 z-index:0 的绝对定位元素，菜单项抬到 1 层，
+ * 文字才不会被它盖住（`.ch-nav .el-menu-item` 上面已有 `position: relative`）。
+ */
+.ch-nav .el-menu-item {
+  z-index: 1;
 }
 
-/* 选中项：强调色淡底 + 左侧强调条（WinUI 经典样式） */
 .ch-nav .el-menu-item.is-active {
-  background: var(--ch-accent-soft);
   color: var(--ch-text);
 }
 
-.ch-nav .el-menu-item.is-active::before {
+/* ---------------------------------------------------------------- 折叠态：图标导轨
-  content: '';
+ *
-  position: absolute;
+ * 折叠**不再用** el-menu 的 `:collapse`：那会把每个分组的子项卸载进浮层（一次结构切换），
-  left: 0;
+ * 并让整条菜单重排一遍 —— 既做不出连续动画，也是"点汉堡卡一下"的渲染侧来源。
-  top: 50%;
+ * 现在改成纯粹的 CSS 收拢：栏宽、文字宽度、图标位置全是可过渡属性，全程没有结构变化，
-  transform: translateY(-50%);
+ * 折叠后就是一条图标导轨（分组标题与子项都以图标列出）。
-  width: 3px;
+ *
-  height: 16px;
+ * 几何（64px 栏、菜单项左右各 8px margin）：
-  border-radius: 2px;
+ *   展开  一级项 padding-left 20px、二级项 40px（Element Plus 自带）→ 图标中心 40 / 60px
-  background: var(--ch-accent);
+ *   折叠  所有项 padding-left / padding-right 都是 12px → 图标中心 8 + 12 + 12 = 32px，
+ *         正好与顶部汉堡按钮的居中位置同列（冒烟断言中心差 ≤ 2px）。
+ * 图标槽（.menu-icon-slot）与分组标题里的裸图标都是 Element Plus 给的 24px 宽。
+ */
+
+/* 图标与文字的间距改由文字的 margin-left 负责：Element Plus 给图标挂了 margin-right:5px，
+   那会让图标在 24px 的槽里偏左 2.5px（折叠时肉眼可见地不居中）。 */
+.ch-nav .el-menu-item [class^='el-icon'],
+.ch-nav .el-sub-menu__title > [class^='el-icon'] {
+  margin-right: 0;
+}
+
+.ch-nav .el-menu-item,
+.ch-nav .el-sub-menu__title {
+  transition:
+    padding-left var(--nav-dur) var(--nav-ease),
+    padding-right var(--nav-dur) var(--nav-ease),
+    border-color var(--el-transition-duration),
+    background-color var(--el-transition-duration),
+    color var(--el-transition-duration);
+}
+
+/*
+ * 文字：**不给它单独设动画终点**，宽度靠 flex 被压缩 —— `min-width:0` 让这个 flex 子项
+ * 能被压到 0（默认的 `min-width:auto` 会撑住内容宽度），多出来的字由 `overflow:hidden` 裁掉。
+ * 于是文字宽度天然跟着栏宽连续变化，不需要写什么魔法 max-width；再叠一层 opacity 淡出，
+ * 避免中间帧留下"半截字"（`display:none` 没法过渡，用不了）。
+ */
+.ch-nav .el-menu-item > span:not(.menu-icon-slot),
+.ch-nav .el-sub-menu__title > span:not(.menu-icon-slot) {
+  min-width: 0;
+  margin-left: var(--nav-gap);
+  overflow: hidden;
+  white-space: nowrap;
+  transition:
+    margin-left var(--nav-dur) var(--nav-ease),
+    opacity calc(var(--nav-dur) * 0.6) var(--nav-ease);
+}
+
+/* 分组标题右侧的折叠箭头：导轨里没有它的位置 */
+.ch-nav .el-sub-menu__icon-arrow {
+  transition: opacity calc(var(--nav-dur) * 0.5) var(--nav-ease);
+}
+
+.ch-nav.is-collapsed .el-menu-item > span:not(.menu-icon-slot),
+.ch-nav.is-collapsed .el-sub-menu__title > span:not(.menu-icon-slot) {
+  margin-left: 0;
+  opacity: 0;
+  pointer-events: none;
+}
+
+.ch-nav.is-collapsed .el-sub-menu__icon-arrow {
+  opacity: 0;
+}
+
+/*
+ * 折叠后的内边距。
+ *
+ * 这三条选择器形状都是**照抄 Element Plus 的**，不是冗余 —— 它按层级用三个不同的选择器算缩进
+ * （一级项 20px、分组标题 20px、分组内子项 40px），特异度分别是 0-4-0 / 0-4-0 / 0-5-0：
+ *   `.el-menu--vertical:not(.el-menu--collapse):not(.el-menu--popup-container) .el-menu-item`
+ *   `.el-menu--vertical:not(.el-menu--collapse):not(.el-menu--popup-container) .el-sub-menu__title`
+ *   `.el-menu--vertical:not(.el-menu--collapse):not(.el-menu--popup-container) .el-sub-menu .el-menu-item`
+ * 写成 `.ch-nav.is-collapsed .el-sub-menu__title` 这种（0-3-0）压不住任何一条 —— 实测踩过两次：
+ * 第一版漏了分组标题（偏 8.0px），把「学习」拆成一级项后又漏了一级项（同样偏 8.0px）。
+ * 下面两条（0-5-0 / 0-6-0）把它们全覆盖，且不用 !important。
+ */
+.ch-nav.is-collapsed .el-menu--vertical:not(.el-menu--collapse) .el-menu-item,
+.ch-nav.is-collapsed .el-menu--vertical:not(.el-menu--collapse) .el-sub-menu__title {
+  padding-left: 12px;
+  padding-right: 12px;
+}
+
+.ch-nav.is-collapsed .el-menu--vertical:not(.el-menu--collapse) .el-sub-menu .el-menu-item {
+  padding-left: 12px;
+  padding-right: 12px;
 }
 
 /* ---------------------------------------------------------------- 课表时间轴 */
@@ -320,17 +527,422 @@ textarea {
 }
 
 ::-webkit-scrollbar-thumb {
-  background: rgba(0, 0, 0, 0.18);
+  background: var(--ch-scrollbar);
   border: 3px solid transparent;
   background-clip: content-box;
   border-radius: 8px;
 }
 
 ::-webkit-scrollbar-thumb:hover {
-  background: rgba(0, 0, 0, 0.3);
+  background: var(--ch-scrollbar-hover);
   background-clip: content-box;
 }
 
 ::-webkit-scrollbar-track {
   background: transparent;
 }
+
+/* ============================================================================
+ * 动效层 —— beUI 的动效语言
+ *
+ * 令牌（缓动曲线、六组弹簧、时长）在 `packages/shared/src/motion.ts`，
+ * 由 `main.ts` 在 mount 之前写进 `:root`；这里只负责**用**它们。
+ * 与 Web 管理端（packages/web-admin/src/styles/index.css）是同一套词汇表。
+ *
+ * ⚠️ 灵动岛**不在**这套体系里：它是另一个渲染进程，用自研的 WinIsland 弹簧物理
+ * （src/island/spring.ts），刻意保持独立，不要往那边接这里的变量。
+ *
+ * 分三层，越往下越"重"：
+ *   ① 变量调音 —— 改写 Element Plus 自己的过渡变量，一次性改掉全站组件库过渡；
+ *   ② 弹簧覆盖 —— 弹窗 / 抽屉 / 浮层换成真正的物理曲线；
+ *   ③ 自有动效 —— 页面过渡、列表错峰入场、按钮按压、卡片抬升。
+ * ========================================================================== */
+
+/* ------------------------------------------------- ① 变量调音（覆盖组件库）
+ *
+ * Element Plus 的每个过渡都由这几个变量拼出来（`--el-transition-all` / `-fade` /
+ * `-md-fade`），调这里等于一次性调完全站，比逐个覆盖类名安全。
+ *
+ * Fluent/ClassIsland 观感本来就偏"轻快"，原来 300/200ms 的默认值在这套界面里更显拖沓，
+ * 收到 200/140ms；缓动换成 beUI 的 EASE_OUT。
+ *
+ * 只改时长与缓动、不改颜色，所以不需要在 html.dark 里再写一份。
+ * 侧栏的 `--nav-ease` 也在文件开头的 :root 里改成了同一条曲线（与折叠几何放在一起，
+ * 免得"改侧栏动画要翻两个地方"）。
+ */
+:root {
+  --el-transition-duration: 200ms;
+  --el-transition-duration-fast: 140ms;
+  --el-transition-function-ease-in-out-bezier: cubic-bezier(0.16, 1, 0.3, 1);
+  --el-transition-function-fast-bezier: cubic-bezier(0.16, 1, 0.3, 1);
+}
+
+/* ------------------------------------------------------------ ② 弹簧覆盖 */
+
+/*
+ * 弹窗（el-dialog）。Element Plus 的入场做在 `.el-overlay-dialog`（居中容器）上，
+ * 遮罩淡入在 `.dialog-fade-enter-active` 自己身上，两条都要换 ——
+ * 否则遮罩先到位、弹窗还在动，看起来是"背景已经变暗了但框还没出来"。
+ *
+ * 弹簧 PANEL 总时长 463ms 看着偏长，但它 95% 的行程在 262ms 就走完了，
+ * 剩下的是极慢的收尾 —— 观感上就是"200ms 到位、再轻轻落定一下"。
+ */
+@keyframes ch-panel-in {
+  from {
+    opacity: 0;
+    transform: translateY(-12px) scale(0.97);
+  }
+  to {
+    opacity: 1;
+    transform: none;
+  }
+}
+
+@keyframes ch-panel-out {
+  from {
+    opacity: 1;
+    transform: none;
+  }
+  to {
+    opacity: 0;
+    transform: translateY(-6px) scale(0.985);
+  }
+}
+
+/*
+ * 位移与缩放挂在 `.el-dialog` **自己**身上，不挂在 `.el-overlay-dialog`（居中容器）上。
+ *
+ * 挂外层容器有个隐蔽的坑：Element Plus 的「打开完成」回调（@opened）按**根元素**
+ * （`.el-overlay`，只有 200ms 的淡入）的动画结束触发，而外层容器上的弹簧要跑 463ms ——
+ * 于是任何在 @opened 里量容器尺寸做自适应的弹窗，都会量到"还带着 scale(0.97) 的缩小版"。
+ * **本客户端的作业看板正是这么算 scale 的**：测小了会被最小缩放兜住，反而超出屏幕 7px
+ * （冒烟断言「作业看板全屏自适应（铺满屏幕、内容不溢出）」实测逮到，两次跑出来都是 550 > 543）。
+ * 挂到 `.el-dialog` 上还有个好处：全屏弹窗能靠 `is-fullscreen` 精确豁免（见下）。
+ */
+.dialog-fade-enter-active .el-overlay-dialog,
+.dialog-fade-leave-active .el-overlay-dialog {
+  /* 抵消 Element Plus 自带的那两条（它们同样带 translateY，会与下面这两条叠起来） */
+  animation: none;
+}
+
+.dialog-fade-enter-active .el-dialog {
+  animation: ch-panel-in var(--ch-spring-panel-dur) var(--ch-spring-panel) both;
+}
+
+/*
+ * 退出**刻意比入场快得多**：用户已经决定关掉它了，这时候再让他等一段"有分量"的动画
+ * 只会显得卡。而且冒烟里多处断言"窗口/弹窗已消失"，退出越快越稳。
+ */
+.dialog-fade-leave-active .el-dialog {
+  animation: ch-panel-out var(--ch-dur-fast) var(--ch-ease-out) both;
+}
+
+/*
+ * 全屏弹窗（`is-fullscreen`，就是作业看板）**不做位移缩放**。
+ * 它本来就是铺满整屏的表面，"从略小处落下来"既看不出效果，又会让内部的
+ * fitBoard / fitFullscreen 在 @opened 那一刻量到被 scale 过的容器 —— 测小了会被
+ * 最小缩放兜住，结果反而超出屏幕。只留淡入。
+ */
+.dialog-fade-enter-active .el-dialog.is-fullscreen {
+  animation: ch-fade-in var(--ch-dur-base) var(--ch-ease-out) both;
+}
+
+.dialog-fade-leave-active .el-dialog.is-fullscreen {
+  animation: ch-fade-out var(--ch-dur-fast) var(--ch-ease-out) both;
+}
+
+/*
+ * 确认框（ElMessageBox）。这条沿用了"动画挂在遮罩层上"的做法：
+ * 它内部没有任何按容器尺寸做自适应的内容，不存在上面那个 @opened 测量的坑。
+ */
+.el-overlay-message-box {
+  animation: ch-panel-in var(--ch-spring-panel-dur) var(--ch-spring-panel) both;
+}
+
+.dialog-fade-enter-active {
+  animation: ch-fade-in var(--ch-dur-base) var(--ch-ease-out) both;
+}
+
+.dialog-fade-leave-active {
+  animation: ch-fade-out var(--ch-dur-fast) var(--ch-ease-out) both;
+}
+
+@keyframes ch-fade-in {
+  from {
+    opacity: 0;
+  }
+  to {
+    opacity: 1;
+  }
+}
+
+@keyframes ch-fade-out {
+  from {
+    opacity: 1;
+  }
+  to {
+    opacity: 0;
+  }
+}
+
+/*
+ * 抽屉。位移由 `.el-drawer` **自身**的 `transition: all` 承载
+ * （`.el-drawer-fade-*` 那组类只管遮罩与 overflow），所以弹簧挂在 `.el-drawer` 上，
+ * 且显式列出属性 —— 不想让背景色的变化也走弹簧曲线。
+ */
+.el-drawer {
+  transition:
+    transform var(--ch-spring-panel-dur) var(--ch-spring-panel),
+    opacity var(--ch-dur-base) var(--ch-ease-out);
+}
+
+/*
+ * 浮层（下拉菜单 / 选择器 / 气泡）。Element Plus 用 `el-zoom-in-*` 系列，
+ * transform-origin 已按 placement 设好。换成 SWAP 弹簧（263ms，比 PANEL 短）：
+ * 这类浮层是高频出现的，每次点下拉都等半秒会烦。
+ */
+.el-zoom-in-top-enter-active,
+.el-zoom-in-top-leave-active,
+.el-zoom-in-bottom-enter-active,
+.el-zoom-in-bottom-leave-active,
+.el-zoom-in-center-enter-active,
+.el-zoom-in-center-leave-active,
+.el-zoom-in-left-enter-active,
+.el-zoom-in-left-leave-active {
+  transition:
+    transform var(--ch-spring-swap-dur) var(--ch-spring-swap),
+    opacity var(--ch-dur-fast) var(--ch-ease-out);
+}
+
+.el-zoom-in-top-enter-from,
+.el-zoom-in-bottom-enter-from,
+.el-zoom-in-center-enter-from,
+.el-zoom-in-left-enter-from {
+  opacity: 0;
+  transform: scale(0.95);
+}
+
+.el-zoom-in-top-leave-active,
+.el-zoom-in-bottom-leave-active,
+.el-zoom-in-center-leave-active,
+.el-zoom-in-left-leave-active {
+  opacity: 0;
+  transform: scale(0.97);
+}
+
+/* 消息条与通知：原生的位移是 0.4s，连弹三条时明显拖沓 */
+.el-message {
+  transition:
+    opacity var(--ch-dur-fast) var(--ch-ease-out),
+    transform var(--ch-spring-swap-dur) var(--ch-spring-swap),
+    top var(--ch-spring-swap-dur) var(--ch-spring-swap),
+    bottom var(--ch-spring-swap-dur) var(--ch-spring-swap);
+}
+
+.el-notification {
+  transition:
+    opacity var(--ch-dur-fast) var(--ch-ease-out),
+    transform var(--ch-spring-swap-dur) var(--ch-spring-swap),
+    left var(--ch-spring-swap-dur) var(--ch-spring-swap),
+    right var(--ch-spring-swap-dur) var(--ch-spring-swap),
+    top var(--ch-spring-swap-dur) var(--ch-spring-swap),
+    bottom var(--ch-spring-swap-dur) var(--ch-spring-swap);
+}
+
+/* ------------------------------------------------------------ ③ 自有动效 */
+
+/*
+ * 按钮按压。Fluent 的按钮只有颜色过渡，没有"按下去"的物理反馈。
+ *
+ * 上行/下行用**不同的缓动**，这是这里唯一需要技巧的地方：
+ *   - 按下（`:active` 生效时）：90ms 直落，要"跟手"，慢了就是延迟；
+ *   - 抬起（`:active` 撤销后回到基础规则）：走 PRESS 弹簧，轻轻弹回原位。
+ * CSS 的规则是"进入某状态用该状态的 transition、离开用目标状态的 transition"，
+ * 所以把弹簧写在基础规则、把快落写在 `:active` 里，正好得到想要的一对。
+ */
+.el-button {
+  transition:
+    transform var(--ch-spring-press-dur) var(--ch-spring-press),
+    color var(--el-transition-duration-fast) var(--ch-ease-out),
+    border-color var(--el-transition-duration-fast) var(--ch-ease-out),
+    background-color var(--el-transition-duration-fast) var(--ch-ease-out),
+    box-shadow var(--el-transition-duration-fast) var(--ch-ease-out);
+}
+
+.el-button:not(.is-disabled):active {
+  transform: scale(var(--ch-press-scale));
+  transition-duration: var(--ch-dur-instant);
+  transition-timing-function: var(--ch-ease-out);
+}
+
+/*
+ * 卡片抬升。**必须关在 `@media (hover: hover) and (pointer: fine)` 里**：
+ * 教室机器的希沃触摸屏点一下会产生"幽灵 hover"并一直粘着，
+ * 不加这层的话卡片被点过之后就永远浮着（见 AGENTS.md §5 第 30 条）。
+ * 这也正是 `composables/motion.ts` 里 `useHoverCapable()` 的 CSS 版本 ——
+ * 纯 CSS 效果用媒体查询就够了，不必为它挂一个 composable。
+ */
+@media (hover: hover) and (pointer: fine) {
+  .el-card {
+    transition:
+      border-color var(--el-transition-duration-fast) var(--ch-ease-out),
+      box-shadow var(--el-transition-duration) var(--ch-ease-out),
+      transform var(--ch-spring-swap-dur) var(--ch-spring-swap);
+  }
+
+  .el-card:hover {
+    transform: translateY(-1px);
+  }
+}
+
+/* 表格行：hover 底色快速跟上，别用 Element Plus 的 0.3s */
+.el-table td.el-table__cell {
+  transition: background-color var(--el-transition-duration-fast) var(--ch-ease-out);
+}
+
+/*
+ * 列表错峰入场。配合 `composables/motion.ts` 的 `useStaggerIn()` 使用 ——
+ * 那个函数按索引下发 `--ch-reveal-delay`，延迟在 CSS 里生效。
+ * `both` 是必需的：否则带延迟的元素会在延迟期间先按终态渲染一下（闪一帧）。
+ */
+@keyframes ch-reveal-in {
+  from {
+    opacity: 0;
+    transform: translateY(6px);
+  }
+  to {
+    opacity: 1;
+    transform: none;
+  }
+}
+
+.ch-reveal {
+  animation: ch-reveal-in var(--ch-dur-slow) var(--ch-ease-out) both;
+  animation-delay: var(--ch-reveal-delay, 0ms);
+}
+
+/*
+ * 页面切换**没有**容器级的过渡 —— 这里曾经有一对 `.ch-page-enter-active` /
+ * `-leave-active`（配 `<transition mode="out-in">`），已经去掉，原因写在
+ * ClientLayout.vue 的 router-view 注释里（延期换页 + 窗口被遮挡时卡死）。
+ * 页面切换的动效全部由下面的 `.page > *` 错峰入场承担。
+ */
+
+/*
+ * 页面内容的错峰入场。
+ *
+ * 挂在 `.page > *` 上而不是逐个视图去写类名：所有视图（含六个设置子页）的根容器
+ * 都叫 `.page`，一条规则覆盖全部，新增视图自动享有，也不会有人忘记加。
+ *
+ * 延迟按**块**递进（30ms 一档、封顶 180ms）：一屏通常是"页头 + 两三块内容"，
+ * 这个节奏读起来是依次浮现；给更多块继续累加就变成排队了，所以第 7 块起不再递增。
+ */
+@keyframes ch-page-block-in {
+  from {
+    opacity: 0;
+    transform: translateY(6px);
+  }
+  to {
+    opacity: 1;
+    transform: none;
+  }
+}
+
+.page > * {
+  animation: ch-page-block-in var(--ch-dur-slow) var(--ch-ease-out) both;
+}
+
+.page > *:nth-child(2) {
+  animation-delay: 30ms;
+}
+
+.page > *:nth-child(3) {
+  animation-delay: 60ms;
+}
+
+.page > *:nth-child(4) {
+  animation-delay: 90ms;
+}
+
+.page > *:nth-child(5) {
+  animation-delay: 120ms;
+}
+
+.page > *:nth-child(6) {
+  animation-delay: 150ms;
+}
+
+.page > *:nth-child(n + 7) {
+  animation-delay: 180ms;
+}
+
+/*
+ * 三个例外，都是"动了就会破坏别人的测量"：
+ *   ① `v-loading` 的遮罩是插在 `.page` 里的直接子元素，让它跟着淡入会闪一下；
+ *   ② **弹窗遮罩**（`.el-overlay`）。Element Plus 的 `el-dialog` 默认 `append-to-body=false`，
+ *      所以声明在视图里的弹窗，它的遮罩是 `.page` 的**直接子元素**。而 `.el-overlay` 是
+ *      `position: fixed; inset: 0` 的全屏层，整体下移 6px 就会把"刚好铺满"的内容顶出屏幕 ——
+ *      作业看板正是这样被顶出去的（冒烟断言「作业看板全屏自适应」读到可视底 550 > 视口高 543）。
+ *      全屏层本来也不该参与"内容块依次浮现"，它一出现就该盖住整屏。
+ *   ③ **看板容器**（`.board-host`）：它的尺寸是按"刚好铺满屏幕"用 `transform: scale()`
+ *      精确算出来的（见 HomeworkView 的 computeScale），算完就是贴边的，同样经不起位移。
+ *   一句话：**凡是 `position: fixed` 的整屏层、或自己量几何再据此设尺寸的元素，
+ *   都不要叠位移类动画。**
+ */
+.page > .el-loading-mask,
+.page > .el-overlay,
+.page > .board-host {
+  animation: none;
+}
+
+/* ------------------------------------------------------- 降低动态效果偏好
+ *
+ * 系统开了「减少动态效果」时，把全站的动画压到 1ms —— 不是删掉，
+ * 而是让它在同一帧内完成（`transition: none` 会让依赖 transitionend 的逻辑失灵）。
+ */
+@media (prefers-reduced-motion: reduce) {
+  *,
+  *::before,
+  *::after {
+    animation-duration: 1ms !important;
+    animation-iteration-count: 1 !important;
+    transition-duration: 1ms !important;
+    scroll-behavior: auto !important;
+  }
+
+  /*
+   * 例外：加载指示旋的是"状态"不是"装饰"。把它一起停掉会让界面看起来像卡死了
+   * （用户会去重复点击），所以这里改为**放慢**而不是停。
+   */
+  .el-icon.is-loading,
+  .el-loading-spinner .circular,
+  .el-loading-spinner svg,
+  .is-loading {
+    animation-duration: 1.6s !important;
+    animation-iteration-count: infinite !important;
+  }
+}
+
+/* ------------------------------------------------- 整页换肤（View Transition）
+ *
+ * `handleThemeToggle`（ClientLayout.vue）用 View Transition API 做"从点击位置扩散的圆"。
+ * 浏览器默认会给新旧两帧做一次交叉淡入 —— 这里把它关掉，改由 JS 用 WAAPI 驱动
+ * `::view-transition-new(root)` 的 clip-path。不关掉的话两套动画会叠在一起，
+ * 观感是"圆在扩散的同时整页又在闪"。
+ *
+ * 层级：老帧在下（z-index 1）、新帧在上（z-index 2），新帧的圆从无到有地盖住老帧。
+ * 不支持这个 API 的浏览器不会渲染这些伪元素，规则自然失效（JS 侧也有守卫）。
+ */
+::view-transition-old(root),
+::view-transition-new(root) {
+  animation: none;
+  mix-blend-mode: normal;
+}
+
+::view-transition-old(root) {
+  z-index: 1;
+}
+
+::view-transition-new(root) {
+  z-index: 2;
+}

packages/desktop-client/src/renderer/views/GradeView.vue

@@ -1,6 +1,5 @@
 <script setup lang="ts">
 import { computed, onMounted, onUnmounted, ref } from 'vue';
-import * as echarts from 'echarts';
 import {
   SOCKET_EVENTS,
   averageOf,
@@ -11,6 +10,7 @@ import {
 } from '@classhelper/shared';
 import { gradeApi } from '../api/index.js';
 import { fetchWithCache } from '../cache/index.js';
+import ScoreBarChart from '../components/ScoreBarChart.vue';
 import { useAppStore } from '../stores/app.js';
 import { useAuthStore } from '../stores/auth.js';
 import { useRealtimeStore } from '../stores/realtime.js';
@@ -24,8 +24,6 @@ const loading = ref(false);
 const grades = ref<GradeDto[]>([]);
 const fromCache = ref(false);
 const updatedAt = ref<number | null>(null);
-const chartRef = ref<HTMLDivElement>();
-let chart: ReturnType<typeof echarts.init> | null = null;
 
 const averagePercent = computed(() =>
   grades.value.length === 0
@@ -53,6 +51,21 @@ const levelCounts = computed(() => {
   return levels;
 });
 
+/**
+ * 按考试聚合平均得分率（最近 8 次考试），交给 ScoreBarChart 渲染。
+ * 这里原先调的是 `echarts.setOption(...)`；改用纯 CSS 柱状图是为了去掉
+ * echarts（渲染产物里最大的一块，1.1MB）。聚合口径与之前完全一致。
+ */
+const examAverages = computed(() => {
+  const byExam = new Map<string, number[]>();
+  for (const item of grades.value) {
+    const bucket = byExam.get(item.examName) ?? [];
+    bucket.push(gradePercent(item.score, item.totalScore));
+    byExam.set(item.examName, bucket);
+  }
+  return [...byExam.entries()].slice(-8).map(([label, percents]) => ({ label, value: averageOf(percents) }));
+});
+
 async function loadGrades(): Promise<void> {
   loading.value = true;
   try {
@@ -61,50 +74,11 @@ async function loadGrades(): Promise<void> {
     fromCache.value = result.fromCache;
     updatedAt.value = result.updatedAt;
     if (!result.fromCache) appStore.markSynced();
-    renderChart();
   } finally {
     loading.value = false;
   }
 }
 
-function renderChart(): void {
-  if (!chartRef.value) return;
-  chart ??= echarts.init(chartRef.value);
-
-  // 按考试聚合平均得分率（最近 8 次考试）
-  const byExam = new Map<string, number[]>();
-  for (const item of grades.value) {
-    const bucket = byExam.get(item.examName) ?? [];
-    bucket.push(gradePercent(item.score, item.totalScore));
-    byExam.set(item.examName, bucket);
-  }
-  const exams = [...byExam.entries()].slice(-8);
-
-  chart.setOption({
-    tooltip: { trigger: 'axis' },
-    grid: { left: 44, right: 18, top: 30, bottom: 34 },
-    xAxis: {
-      type: 'category',
-      data: exams.map(([name]) => name),
-      axisLabel: { interval: 0, rotate: exams.length > 4 ? 20 : 0, fontSize: 11 },
-    },
-    yAxis: { type: 'value', max: 100, name: '得分率%' },
-    series: [
-      {
-        type: 'bar',
-        barMaxWidth: 46,
-        itemStyle: { color: '#409eff', borderRadius: [4, 4, 0, 0] },
-        label: { show: true, position: 'top', formatter: '{c}%', fontSize: 11 },
-        data: exams.map(([, percents]) => averageOf(percents)),
-      },
-    ],
-  });
-}
-
-function handleResize(): void {
-  chart?.resize();
-}
-
 function onGradeEvent(): void {
   void loadGrades();
 }
@@ -115,15 +89,11 @@ function onRecovered(): void {
 
 onMounted(async () => {
   await loadGrades();
-  window.addEventListener('resize', handleResize);
   realtime.on(SOCKET_EVENTS.gradeUpdated, onGradeEvent);
   appStore.onServerRecovered(onRecovered);
 });
 
 onUnmounted(() => {
-  window.removeEventListener('resize', handleResize);
-  chart?.dispose();
-  chart = null;
   realtime.off(SOCKET_EVENTS.gradeUpdated, onGradeEvent);
   appStore.offServerRecovered(onRecovered);
 });
@@ -172,7 +142,7 @@ onUnmounted(() => {
       <el-col :xs="24" :md="16">
         <el-card v-loading="loading" shadow="never">
           <template #header><span>各次考试平均得分率</span></template>
-          <div ref="chartRef" class="chart"></div>
+          <ScoreBarChart :items="examAverages" />
         </el-card>
       </el-col>
     </el-row>
@@ -226,7 +196,7 @@ onUnmounted(() => {
 
 <style scoped>
 .stat-card {
-  background: #fff;
+  background: var(--ch-layer-solid);
   border: 1px solid var(--ch-border);
   border-radius: 10px;
   padding: 16px;
@@ -234,7 +204,7 @@ onUnmounted(() => {
 
 .stat-label {
   font-size: 13px;
-  color: #909399;
+  color: var(--ch-text-secondary);
 }
 
 .stat-value {
@@ -246,7 +216,7 @@ onUnmounted(() => {
 .stat-hint {
   margin-top: 4px;
   font-size: 12px;
-  color: #c0c4cc;
+  color: var(--ch-text-tertiary);
 }
 
 .level-list {
@@ -255,9 +225,4 @@ onUnmounted(() => {
   gap: 6px;
   margin-top: 8px;
 }
-
-.chart {
-  width: 100%;
-  height: 300px;
-}
 </style>

packages/desktop-client/src/renderer/views/HomeworkView.vue

@@ -1,5 +1,5 @@
 <script setup lang="ts">
-import { computed, nextTick, onMounted, onUnmounted, ref } from 'vue';
+import { computed, nextTick, onMounted, onUnmounted, ref, watch } from 'vue';
 import { useRoute, useRouter } from 'vue-router';
 import { ElMessage } from 'element-plus';
 import {
@@ -15,6 +15,7 @@ import {
 } from '@classhelper/shared';
 import { courseApi, homeworkApi } from '../api/index.js';
 import { fetchWithCache } from '../cache/index.js';
+import { markHomeworkCreatedLocally } from '../island/bridge.js';
 import { useAppStore } from '../stores/app.js';
 import { useAuthStore } from '../stores/auth.js';
 import { useRealtimeStore } from '../stores/realtime.js';
@@ -80,6 +81,17 @@ async function selectDate(value: string | null): Promise<void> {
   await loadHomework();
 }
 
+// 深链 ?date= 不止在首次挂载生效：已在作业页时（看板/列表之间切换、冒烟直接推 query），
+// 路由 query 变了也要跟着切换日期 —— 组件被复用，没有这条监听就停在原日期。
+watch(
+  () => route.query.date,
+  (value) => {
+    if (typeof value !== 'string' || !isDayKey(value) || value === selectedDate.value) return;
+    selectedDate.value = value;
+    void loadHomework();
+  },
+);
+
 /** 前后一天（教室电脑上不用打开日历也能翻） */
 async function shiftDate(delta: number): Promise<void> {
   await selectDate(shiftDayKey(selectedDate.value, delta));
@@ -412,13 +424,19 @@ async function submitCreate(): Promise<void> {
 
   createSaving.value = true;
   try {
-    await homeworkApi.create({
+    // 先按内容登记"This 是本机录的"：服务端是**先广播 homework:new、后回响应**的，
+    // 等响应拿到 id 再登记就晚了 —— 实时事件可能已经到了，岛已经弹出来了。
+    const draft = { classId, title, content, assignDate: selectedDate.value };
+    markHomeworkCreatedLocally(draft);
+    const created = await homeworkApi.create({
       classId,
       courseId: createForm.value.courseId || null,
       title,
       content,
       assignDate: selectedDate.value,
     });
+    // 回执里带上 id 再记一次（覆盖"广播晚于响应"的另一半）
+    if (created?.id) markHomeworkCreatedLocally({ ...draft, id: created.id });
     ElMessage.success(`已录入到 ${selectedDate.value}`);
     createVisible.value = false;
     await loadHomework();
@@ -898,7 +916,7 @@ onUnmounted(() => {
 .content-block {
   white-space: pre-wrap;
   line-height: 1.75;
-  background: #fafafa;
+  background: var(--ch-layer-alt);
   border-radius: 12px;
   padding: 12px;
   margin: 0;
@@ -1130,7 +1148,7 @@ onUnmounted(() => {
   transform: translateX(-50%);
   font-size: 14px;
   font-weight: 500;
-  color: #6b7280;
+  color: var(--ch-text-tertiary);
   white-space: nowrap;
 }
 
@@ -1158,7 +1176,7 @@ onUnmounted(() => {
 .submission-list {
   max-height: 46vh;
   overflow-y: auto;
-  border: 1px solid #ebeef5;
+  border: 1px solid var(--ch-divider);
   border-radius: 12px;
   padding: 12px;
 }

packages/desktop-client/src/renderer/views/LoginView.vue

@@ -5,12 +5,14 @@ import { ElMessage, type FormInstance, type FormRules } from 'element-plus';
 import { pingHealth, setApiBaseUrl } from '../api/http.js';
 import { useAppStore } from '../stores/app.js';
 import { useAuthStore } from '../stores/auth.js';
+import { useOnboardingStore } from '../stores/onboarding.js';
 import { useRealtimeStore } from '../stores/realtime.js';
-import { DEFAULT_SERVER, normalizeServerUrl } from '../config.js';
+import { DEFAULT_SERVER, BRAND_LOGO_URL, normalizeServerUrl } from '../config.js';
 
 const router = useRouter();
 const appStore = useAppStore();
 const auth = useAuthStore();
+const onboarding = useOnboardingStore();
 const realtime = useRealtimeStore();
 
 const formRef = ref<FormInstance>();
@@ -91,7 +93,7 @@ async function enterOffline(): Promise<void> {
   <div class="login-page">
     <div class="login-card">
       <div class="login-head">
-        <el-icon :size="30" color="#409eff"><School /></el-icon>
+        <img class="login-logo" :src="BRAND_LOGO_URL" alt="" width="44" height="44" />
         <div>
           <h1 class="login-title">班级小助手</h1>
           <p class="login-sub">班级客户端 · 以班级账号登录，实时接收课表、作业、通知与成绩</p>
@@ -134,6 +136,14 @@ async function enterOffline(): Promise<void> {
           <el-button type="primary" :loading="auth.loading" @click="submit">登录</el-button>
         </div>
 
+        <!-- 重看初次启动引导：首次启动会自动弹出过一次，这里供随时回看 -->
+        <div class="login-guide">
+          <el-button link type="primary" @click="onboarding.open()">
+            <el-icon><Guide /></el-icon>
+            查看使用引导
+          </el-button>
+        </div>
+
         <el-alert
           v-if="testResult === 'ok'"
           class="mt-12"
@@ -177,7 +187,7 @@ async function enterOffline(): Promise<void> {
 
 .login-card {
   width: 420px;
-  background: #fff;
+  background: var(--ch-layer-solid);
   border-radius: 14px;
   padding: 28px 26px 20px;
   box-shadow: 0 18px 40px rgba(15, 30, 50, 0.28);
@@ -190,6 +200,16 @@ async function enterOffline(): Promise<void> {
   margin-bottom: 18px;
 }
 
+/*
+ * 品牌标：与应用图标同一份图（`public/logo.png`）。
+ * 图自带圆角与透明边角，不要再加 border-radius；`src` 走 `BRAND_LOGO_URL` 的理由同 ClientLayout。
+ * （表单里「班级码」输入框的前缀仍用 School 字形 —— 那是字段语义图标，不是品牌标。）
+ */
+.login-logo {
+  flex: none;
+  display: block;
+}
+
 .login-title {
   margin: 0;
   font-size: 20px;
@@ -198,7 +218,7 @@ async function enterOffline(): Promise<void> {
 .login-sub {
   margin: 4px 0 0;
   font-size: 12px;
-  color: #909399;
+  color: var(--ch-text-secondary);
 }
 
 .login-actions {
@@ -210,6 +230,12 @@ async function enterOffline(): Promise<void> {
   flex: 1;
 }
 
+.login-guide {
+  display: flex;
+  justify-content: center;
+  margin-top: 10px;
+}
+
 .offline-button {
   width: 100%;
 }
@@ -218,6 +244,6 @@ async function enterOffline(): Promise<void> {
   margin: 16px 0 0;
   font-size: 12px;
   line-height: 1.7;
-  color: #c0c4cc;
+  color: var(--ch-text-tertiary);
 }
 </style>

packages/desktop-client/src/renderer/views/NotificationView.vue

@@ -165,11 +165,11 @@ onUnmounted(() => {
 }
 
 .notice-item:hover {
-  background: #f7f9fc;
+  background: var(--ch-hover-soft);
 }
 
 .notice-item.unread {
-  background: #f0f7ff;
+  background: var(--ch-accent-soft);
 }
 
 .notice-item:last-child {
@@ -194,7 +194,7 @@ onUnmounted(() => {
 .notice-content {
   margin-top: 6px;
   font-size: 13px;
-  color: #606266;
+  color: var(--ch-text-secondary);
   display: -webkit-box;
   -webkit-line-clamp: 2;
   -webkit-box-orient: vertical;
@@ -220,7 +220,7 @@ onUnmounted(() => {
 .content-block {
   white-space: pre-wrap;
   line-height: 1.8;
-  background: #fafafa;
+  background: var(--ch-layer-alt);
   border-radius: 8px;
   padding: 14px;
   margin: 0 0 16px;

packages/desktop-client/src/renderer/views/ScheduleView.vue

@@ -460,7 +460,7 @@ onUnmounted(() => {
 }
 
 .hero-status.status-idle {
-  background: rgba(0, 0, 0, 0.03);
+  background: var(--ch-hover-soft);
 }
 
 .status-title {
@@ -553,7 +553,7 @@ onUnmounted(() => {
   width: 10px;
   height: 10px;
   border-radius: 50%;
-  background: #fff;
+  background: var(--ch-layer-solid);
   border: 2px solid var(--ch-border-strong);
 }
 
@@ -574,7 +574,8 @@ onUnmounted(() => {
   padding: 10px 14px;
   border: 1px solid var(--ch-border);
   border-radius: var(--ch-radius-card);
-  background: rgba(255, 255, 255, 0.6);
+  /* 走主题变量：浅色是白玻璃、深色是深玻璃（写死白色会在深色主题下变成"浅灰卡 + 浅字"看不清） */
+  background: var(--ch-layer);
   transition:
     border-color 0.15s ease,
     background 0.15s ease,
@@ -595,7 +596,7 @@ onUnmounted(() => {
 }
 
 .timeline-item.is-past .timeline-card-inner {
-  background: rgba(255, 255, 255, 0.35);
+  background: var(--ch-layer-alt);
   color: var(--ch-text-tertiary);
 }
 

packages/desktop-client/src/renderer/views/SettingsView.vue

@@ -1,702 +0,0 @@
-<script setup lang="ts">
-import { computed, onMounted, ref } from 'vue';
-import { useRouter } from 'vue-router';
-import { ElMessage, ElMessageBox } from 'element-plus';
-import {
-  CLASSISLAND_NOTIFICATION_CHANNEL_HINTS,
-  CLASSISLAND_NOTIFICATION_CHANNEL_LABELS,
-  CLASSISLAND_NOTIFICATION_CHANNELS,
-  HOMEWORK_PHRASE_DEFAULTS,
-  HOMEWORK_PHRASE_MAX_COUNT,
-  HOMEWORK_PHRASE_MAX_LENGTH,
-  DEFAULT_ISLAND_APPEARANCE,
-  ISLAND_APPEARANCE_RANGES as RANGES,
-  ISLAND_POSITION_LABELS,
-  ISLAND_STYLE_LABELS,
-  ISLAND_STYLES,
-  ISLAND_POSITIONS,
-  formatDate,
-  type ClassIslandNotificationChannel,
-  type IslandAppearance,
-  type IslandPosition,
-  type IslandStyle,
-} from '@classhelper/shared';
-import type { DesktopAppInfo } from '../../types/desktop.js';
-import { classIslandStatusApi } from '../api/index.js';
-import { pingHealth, setApiBaseUrl } from '../api/http.js';
-import { normalizeServerUrl } from '../config.js';
-import { useAppStore } from '../stores/app.js';
-import { useAuthStore } from '../stores/auth.js';
-import { useNotificationStore } from '../stores/notifications.js';
-import { useRealtimeStore } from '../stores/realtime.js';
-
-const router = useRouter();
-const appStore = useAppStore();
-const auth = useAuthStore();
-const realtime = useRealtimeStore();
-const notifications = useNotificationStore();
-
-const serverInput = ref(appStore.serverUrl);
-const testing = ref(false);
-const saving = ref(false);
-const appInfo = ref<DesktopAppInfo | null>(null);
-
-const storeLabels: Record<string, string> = {
-  profile: '登录资料',
-  classes: '班级 / 学期',
-  schedules: '课表',
-  homeworks: '作业',
-  notifications: '通知',
-  grades: '成绩',
-};
-
-const cacheRows = computed(() =>
-  appStore.cacheStoreStats.map((item) => ({
-    label: storeLabels[item.store] ?? item.store,
-    store: item.store,
-    count: item.count,
-    updatedAt: item.updatedAt ? formatDate(item.updatedAt, true) : '—',
-  })),
-);
-
-async function loadAppInfo(): Promise<void> {
-  if (!window.desktop) return;
-  appInfo.value = await window.desktop.getAppInfo();
-}
-
-async function saveServer(): Promise<void> {
-  const normalized = normalizeServerUrl(serverInput.value);
-  if (!normalized) {
-    ElMessage.error('服务器地址格式不正确，例如 http://127.0.0.1:4000');
-    return;
-  }
-  saving.value = true;
-  try {
-    await appStore.applyServerUrl(normalized);
-    serverInput.value = normalized;
-    ElMessage.success('服务器地址已保存');
-    await testConnection();
-    if (auth.token) realtime.connect(normalized, auth.token);
-  } finally {
-    saving.value = false;
-  }
-}
-
-async function testConnection(): Promise<void> {
-  testing.value = true;
-  try {
-    const result = await pingHealth();
-    if (result.ok) ElMessage.success('服务器连接正常');
-    else ElMessage.error('无法连接服务器，请检查地址与网络');
-  } finally {
-    testing.value = false;
-  }
-}
-
-async function manualSync(): Promise<void> {
-  setApiBaseUrl(appStore.serverUrl);
-  await appStore.ping();
-  if (appStore.offline) {
-    ElMessage.warning('当前无法连接服务器，已保留缓存数据');
-    return;
-  }
-  await notifications.load();
-  appStore.markSynced();
-  ElMessage.success('已同步最新数据');
-}
-
-async function clearCache(): Promise<void> {
-  await ElMessageBox.confirm('清空后离线时将无法查看历史数据，确认继续？', '清空离线缓存', {
-    type: 'warning',
-  });
-  await appStore.clearCache();
-  ElMessage.success('离线缓存已清空');
-}
-
-async function logout(): Promise<void> {
-  await ElMessageBox.confirm('确认退出当前账号？', '退出登录', { type: 'warning' });
-  realtime.disconnect();
-  await auth.logout();
-  ElMessage.success('已退出登录');
-  await router.replace('/login');
-}
-
-/* ------------------------------------------------------------ 通知显示位置 */
-
-/**
- * 通知显示位置：这台教室机器把提醒弹在哪个端。
- *
- * - both：ClassHelper 客户端（弹窗 + 灵动岛）与 ClassIsland 都弹（默认）
- * - client：只弹 ClassHelper 客户端
- * - classisland：只弹 ClassIsland（客户端只进通知中心，不弹窗、不上岛）
- *
- * 值会落本地配置（本机立刻生效）并写回班级记录（服务端据此决定要不要推 ClassIsland）。
- */
-const channelSaving = ref(false);
-/**
- * 本班有没有接入 ClassIsland 设备。
- *
- * 只用来禁用「只在 ClassIsland 上弹」——没有设备时选它等于把提醒静默丢掉；
- * 注意**不能**顺手把「两端都弹」也禁掉：那样教室一旦选过"只在客户端"，没设备时就再也切不回来了。
- */
-const classIslandConnected = ref(false);
-/** 本班 ClassIsland 设备的展示信息（设备名 / 最后上报），来自 /classes/:id/classisland-status */
-const classIslandStatus = ref<{
-  connected: boolean;
-  deviceName: string | null;
-  deviceCount: number;
-  lastSeenAt: string | null;
-  pluginVersion: string | null;
-  classIslandVersion: string | null;
-} | null>(null);
-
-const classIslandStatusText = computed(() => {
-  const status = classIslandStatus.value;
-  if (!status || !status.connected) return '未接入';
-  const seen = status.lastSeenAt ? `最后上报 ${formatDate(status.lastSeenAt, true)}` : '尚未上报过';
-  return `已接入 · ${status.deviceName ?? 'ClassIsland 设备'} · ${seen}`;
-});
-
-const channelOptions = computed(() =>
-  CLASSISLAND_NOTIFICATION_CHANNELS.map((value) => ({
-    value,
-    label: CLASSISLAND_NOTIFICATION_CHANNEL_LABELS[value],
-    disabled: value === 'classisland' && !classIslandConnected.value,
-  })),
-);
-
-async function loadClassChannel(): Promise<void> {
-  const classId = auth.classId;
-  if (!classId) return;
-  await appStore.loadNotificationChannel(classId);
-}
-
-async function applyChannel(value: ClassIslandNotificationChannel): Promise<void> {
-  channelSaving.value = true;
-  try {
-    const saved = await appStore.setNotificationChannel(auth.classId, value);
-    if (saved) ElMessage.success('提醒显示位置已更新');
-    else ElMessage.warning('已保存在本机，但同步到服务器失败（离线或权限不足），联网后请再点一次');
-  } finally {
-    channelSaving.value = false;
-  }
-}
-
-/* ------------------------------------------------------------ 作业录入快捷短语 */
-
-/**
- * 作业快捷短语：录作业时点一下就把词追加到标题/内容里（P、大本、背诵…）。
- *
- * 存在客户端本地配置（这台教室机器自己的习惯），不占用服务端字段；
- * 空数组是合法值 —— 老师把短语全删了就是"不想用快捷短语"。
- */
-const phrases = ref<string[]>([...HOMEWORK_PHRASE_DEFAULTS]);
-const phraseInput = ref('');
-const savingPhrases = ref(false);
-
-async function loadPhrases(): Promise<void> {
-  const config = await window.desktop?.getConfig?.();
-  if (config?.homeworkPhrases) phrases.value = [...config.homeworkPhrases];
-}
-
-async function savePhrases(): Promise<void> {
-  if (!window.desktop?.saveConfig) return;
-  savingPhrases.value = true;
-  try {
-    const saved = await window.desktop.saveConfig({ homeworkPhrases: [...phrases.value] });
-    phrases.value = [...saved.homeworkPhrases];
-  } finally {
-    savingPhrases.value = false;
-  }
-}
-
-async function addPhrase(): Promise<void> {
-  const value = phraseInput.value.trim().slice(0, HOMEWORK_PHRASE_MAX_LENGTH);
-  if (!value) return;
-  if (phrases.value.includes(value)) {
-    ElMessage.warning('这条短语已经有了');
-    return;
-  }
-  if (phrases.value.length >= HOMEWORK_PHRASE_MAX_COUNT) {
-    ElMessage.warning(`最多 ${HOMEWORK_PHRASE_MAX_COUNT} 条快捷短语`);
-    return;
-  }
-  phrases.value = [...phrases.value, value];
-  phraseInput.value = '';
-  await savePhrases();
-  ElMessage.success('已添加');
-}
-
-async function removePhrase(value: string): Promise<void> {
-  phrases.value = phrases.value.filter((item) => item !== value);
-  await savePhrases();
-}
-
-async function resetPhrases(): Promise<void> {
-  await ElMessageBox.confirm('恢复为默认快捷短语？', '恢复默认', { type: 'warning' });
-  phrases.value = [...HOMEWORK_PHRASE_DEFAULTS];
-  await savePhrases();
-  ElMessage.success('已恢复默认');
-}
-
-/* ------------------------------------------------------------ 灵动岛个性化 */
-
-const island = ref<IslandAppearance>({ ...DEFAULT_ISLAND_APPEARANCE });
-
-/**
- * 左右边距是否有效：只在停靠左 / 右时生效。
- *
- * 岛是"居中停靠"时（默认就是顶部居中），水平方向的锚点就是屏幕中线 ——
- * 这时调左右边距不会有任何变化。之前没把这点说清楚，用户会以为"调了不生效"。
- */
-const marginXApplies = computed(() => !island.value.position.endsWith('center'));
-const savingIsland = ref(false);
-
-const positionOptions = ISLAND_POSITIONS.map((value) => ({
-  value,
-  label: ISLAND_POSITION_LABELS[value],
-}));
-
-const styleOptions = ISLAND_STYLES.map((value) => ({
-  value,
-  label: ISLAND_STYLE_LABELS[value],
-}));
-
-/** 读取当前生效的外观（主进程为单一事实来源） */
-async function loadIslandAppearance(): Promise<void> {
-  if (!window.desktop?.islandGetAppearance) return;
-  island.value = await window.desktop.islandGetAppearance();
-}
-
-/**
- * 改动即生效：属性变化时先应用（实时预览），点"保存"再落盘。
- * 高度/宽度只影响窗口与卡片尺寸变量，内容用 flex + 溢出滚动承载，不会溢出或错乱。
- *
- * 注意：必须传**展开后的纯对象**。`island` 是 `ref`，它的 `.value` 在 Vue 里是响应式
- * Proxy，Proxy 过不了 IPC 的结构化克隆（`An object could not be cloned.`）——
- * 那正是"拖了滑块、数字在变、灵动岛却没反应"的原因。
- */
-function applyIslandAppearance(patch: Partial<IslandAppearance> = {}): void {
-  island.value = { ...island.value, ...patch };
-  window.desktop?.islandSetAppearance({ ...island.value });
-}
-
-async function saveIslandAppearance(): Promise<void> {
-  if (!window.desktop?.saveConfig) return;
-  savingIsland.value = true;
-  try {
-    await window.desktop.saveConfig({ island: { ...island.value } });
-    ElMessage.success('个性化设置已保存');
-  } finally {
-    savingIsland.value = false;
-  }
-}
-
-async function resetIslandAppearance(): Promise<void> {
-  await ElMessageBox.confirm('恢复灵动岛的默认外观？', '恢复默认', { type: 'warning' });
-  applyIslandAppearance({ ...DEFAULT_ISLAND_APPEARANCE });
-  await saveIslandAppearance();
-}
-
-/** 本地推一条测试通知，立刻确认外观效果（预览模式：直接展开、失焦不收起、30 秒后自动消失） */
-function testIsland(): void {
-  window.desktop?.islandPush?.({
-    notification: {
-      id: `appearance-test-${Date.now()}`,
-      title: '灵动岛外观预览',
-      content: '拖动滑块即可实时预览：高度、宽度、圆角、透明度、字号、主题色、位置与动画。',
-      priority: 'NORMAL',
-      createdAt: new Date().toISOString(),
-      courseName: null,
-      teacherName: '本地预览',
-    },
-    context: { inClass: false, currentPeriodEnd: null, preview: true },
-  });
-}
-
-onMounted(async () => {
-  await loadAppInfo();
-  await appStore.refreshCacheStats();
-  await loadIslandAppearance();
-  await loadClassChannel();
-  await loadPhrases();
-  // 本班 ClassIsland 联动状态：没接设备就别让选「只在 ClassIsland 上弹」
-  if (auth.classId) {
-    const status = await classIslandStatusApi.get(auth.classId).catch(() => null);
-    classIslandStatus.value = status;
-    classIslandConnected.value = status?.connected === true;
-  }
-});
-</script>
-
-<template>
-  <div class="page">
-    <div class="page-header">
-      <div>
-        <h2 class="page-title">设置</h2>
-        <p class="page-subtitle">服务器连接、账号信息与离线缓存管理</p>
-      </div>
-    </div>
-
-    <el-row :gutter="12">
-      <el-col :xs="24" :md="12">
-        <el-card shadow="never">
-          <template #header><span>服务器连接</span></template>
-          <el-form label-position="top">
-            <el-form-item label="服务器地址">
-              <el-input v-model="serverInput" placeholder="http://127.0.0.1:4000">
-                <template #prefix>
-                  <el-icon><Link /></el-icon>
-                </template>
-              </el-input>
-            </el-form-item>
-          </el-form>
-          <div class="toolbar">
-            <el-button type="primary" :loading="saving" @click="saveServer">保存并测试</el-button>
-            <el-button :loading="testing" @click="testConnection">测试连接</el-button>
-            <el-button @click="manualSync">立即同步</el-button>
-          </div>
-
-          <el-descriptions class="mt-16" :column="1" border size="small">
-            <el-descriptions-item label="当前状态">
-              <el-tag :type="appStore.serverReachable ? 'success' : 'danger'" size="small">
-                {{ appStore.serverReachable ? '服务器可达' : '离线（显示缓存数据）' }}
-              </el-tag>
-              <el-tag class="ml-8" :type="realtime.connected ? 'success' : 'info'" size="small">
-                {{ realtime.statusText }}
-              </el-tag>
-            </el-descriptions-item>
-            <el-descriptions-item label="最近同步">{{ appStore.lastSyncText }}</el-descriptions-item>
-            <el-descriptions-item label="实时事件数">{{ realtime.eventCount }} 条</el-descriptions-item>
-          </el-descriptions>
-        </el-card>
-
-        <el-card shadow="never" class="mt-12">
-          <template #header>
-            <span>灵动岛 · 个性化</span>
-          </template>
-          <el-form label-width="96px" label-position="left">
-            <el-form-item :label="`高度 ${island.height}px`">
-              <el-slider
-                :model-value="island.height"
-                :min="RANGES.height.min"
-                :max="RANGES.height.max"
-                :step="1"
-                @input="(value: number) => applyIslandAppearance({ height: value })"
-              />
-            </el-form-item>
-            <el-form-item :label="`宽度 ${island.width}px`">
-              <el-slider
-                :model-value="island.width"
-                :min="RANGES.width.min"
-                :max="RANGES.width.max"
-                :step="2"
-                @input="(value: number) => applyIslandAppearance({ width: value })"
-              />
-            </el-form-item>
-            <el-form-item :label="`圆角 ${island.radius}px`">
-              <el-slider
-                :model-value="island.radius"
-                :min="RANGES.radius.min"
-                :max="RANGES.radius.max"
-                :step="1"
-                @input="(value: number) => applyIslandAppearance({ radius: value })"
-              />
-            </el-form-item>
-            <el-form-item :label="`不透明度 ${Math.round(island.opacity * 100)}%`">
-              <el-slider
-                :model-value="island.opacity"
-                :min="RANGES.opacity.min"
-                :max="RANGES.opacity.max"
-                :step="0.05"
-                @input="(value: number) => applyIslandAppearance({ opacity: value })"
-              />
-            </el-form-item>
-            <el-form-item :label="`字号 ${island.fontSize}px`">
-              <el-slider
-                :model-value="island.fontSize"
-                :min="RANGES.fontSize.min"
-                :max="RANGES.fontSize.max"
-                :step="1"
-                @input="(value: number) => applyIslandAppearance({ fontSize: value })"
-              />
-            </el-form-item>
-            <el-form-item :label="`动画速度 ${island.speed.toFixed(1)}x`">
-              <el-slider
-                :model-value="island.speed"
-                :min="RANGES.speed.min"
-                :max="RANGES.speed.max"
-                :step="0.1"
-                @input="(value: number) => applyIslandAppearance({ speed: value })"
-              />
-            </el-form-item>
-            <el-form-item label="主题色">
-              <el-color-picker
-                :model-value="island.accent"
-                @change="(value: string | null) => applyIslandAppearance({ accent: value ?? '#0a84ff' })"
-              />
-              <span class="text-muted ml-8">用于高亮、按钮与进度条</span>
-            </el-form-item>
-            <el-form-item label="视觉风格">
-              <el-select
-                :model-value="island.style"
-                style="width: 180px"
-                @change="(value: IslandStyle) => applyIslandAppearance({ style: value })"
-              >
-                <el-option
-                  v-for="item in styleOptions"
-                  :key="item.value"
-                  :label="item.label"
-                  :value="item.value"
-                />
-              </el-select>
-              <span class="text-muted ml-8">纯黑 / 毛玻璃（半透明）/ 主题色渐变</span>
-            </el-form-item>
-            <el-form-item label="显示位置">
-              <el-select
-                :model-value="island.position"
-                style="width: 180px"
-                @change="(value: IslandPosition) => applyIslandAppearance({ position: value })"
-              >
-                <el-option
-                  v-for="item in positionOptions"
-                  :key="item.value"
-                  :label="item.label"
-                  :value="item.value"
-                />
-              </el-select>
-            </el-form-item>
-            <el-form-item :label="`左右边距 ${island.marginX}px`">
-              <el-slider
-                :model-value="island.marginX"
-                :min="RANGES.marginX.min"
-                :max="RANGES.marginX.max"
-                :step="2"
-                :disabled="!marginXApplies"
-                @input="(value: number) => applyIslandAppearance({ marginX: value })"
-              />
-              <span v-if="marginXApplies" class="text-muted ml-8">停靠左/右时距屏幕边缘的距离</span>
-              <span v-else class="text-muted ml-8">
-                当前是「居中」停靠，左右边距不生效 —— 把上面的「显示位置」改成左 / 右停靠即可看到效果
-              </span>
-            </el-form-item>
-            <el-form-item :label="`上下边距 ${island.marginY}px`">
-              <el-slider
-                :model-value="island.marginY"
-                :min="RANGES.marginY.min"
-                :max="RANGES.marginY.max"
-                :step="2"
-                @input="(value: number) => applyIslandAppearance({ marginY: value })"
-              />
-              <span class="text-muted ml-8">停靠顶/底时距屏幕边缘的距离（任务栏在侧面时调大）</span>
-            </el-form-item>
-            <el-form-item label="跟随鼠标屏幕">
-              <el-switch
-                :model-value="island.followCursorDisplay"
-                @change="
-                  (value: boolean | string | number) =>
-                    applyIslandAppearance({ followCursorDisplay: Boolean(value) })
-                "
-              />
-              <span class="text-muted ml-8">多显示器教室电脑：岛出现在鼠标所在的那块屏幕</span>
-            </el-form-item>
-            <el-form-item label="动画">
-              <el-switch
-                :model-value="island.animations"
-                @change="
-                  (value: boolean | string | number) => applyIslandAppearance({ animations: Boolean(value) })
-                "
-              />
-              <span class="text-muted ml-8">关闭后展开/收起为瞬时生效</span>
-            </el-form-item>
-            <el-form-item label="始终置顶">
-              <el-switch
-                :model-value="island.alwaysOnTop"
-                @change="
-                  (value: boolean | string | number) => applyIslandAppearance({ alwaysOnTop: Boolean(value) })
-                "
-              />
-            </el-form-item>
-            <el-form-item label="空闲细缝">
-              <el-switch
-                :model-value="island.idleSliver"
-                @change="
-                  (value: boolean | string | number) => applyIslandAppearance({ idleSliver: Boolean(value) })
-                "
-              />
-              <span class="text-muted ml-8">参考 WinIsland：没有消息时保留一条细缝（关闭则完全隐藏）</span>
-            </el-form-item>
-          </el-form>
-          <div class="toolbar">
-            <el-button type="primary" :loading="savingIsland" @click="saveIslandAppearance">
-              保存设置
-            </el-button>
-            <el-button @click="testIsland">预览效果</el-button>
-            <el-button @click="resetIslandAppearance">恢复默认</el-button>
-          </div>
-          <el-alert
-            class="mt-12"
-            type="info"
-            :closable="false"
-            title="拖动滑块即为实时预览；保存后写入本地配置，重启客户端仍然生效"
-          />
-        </el-card>
-        <el-card shadow="never" class="mt-12">
-          <template #header><span>ClassIsland 联动</span></template>
-          <el-descriptions :column="1" border size="small" class="mb-12">
-            <el-descriptions-item label="联动状态">{{ classIslandStatusText }}</el-descriptions-item>
-            <el-descriptions-item label="插件 / ClassIsland">
-              {{ classIslandStatus?.pluginVersion ?? '—' }} /
-              {{ classIslandStatus?.classIslandVersion ?? '—' }}
-            </el-descriptions-item>
-          </el-descriptions>
-          <p class="text-muted">
-            <strong>通知模式</strong>
-            ：老师在班级小助手上发布通知 / 叫人时，提醒弹在灵动岛还是 ClassIsland，
-            由这台教室机器决定。选择会同步到班级，服务端据此决定是否推送到教室的 ClassIsland。
-          </p>
-          <el-radio-group
-            :model-value="appStore.notificationChannel"
-            :disabled="channelSaving"
-            class="channel-group"
-            @change="
-              (value: string | number | boolean | undefined) =>
-                applyChannel(value as ClassIslandNotificationChannel)
-            "
-          >
-            <el-radio
-              v-for="item in channelOptions"
-              :key="item.value"
-              :value="item.value"
-              :disabled="item.disabled"
-            >
-              {{ item.label }}
-            </el-radio>
-          </el-radio-group>
-          <p class="text-muted channel-hint">
-            {{ CLASSISLAND_NOTIFICATION_CHANNEL_HINTS[appStore.notificationChannel] }}
-            <template v-if="!classIslandConnected">
-              <br />
-              提示：本班还没有接入 ClassIsland 设备（在 Web 端「ClassIsland 联动」里接入后才能选"只在
-              ClassIsland 上弹"）。
-            </template>
-          </p>
-        </el-card>
-
-        <el-card shadow="never" class="mt-12">
-          <template #header><span>作业录入</span></template>
-          <p class="text-muted">
-            在教室电脑上录作业时，点一下短语就会追加到标题 / 内容里（例如 P、大本、背诵）。 最多
-            {{ HOMEWORK_PHRASE_MAX_COUNT }} 条、每条
-            {{ HOMEWORK_PHRASE_MAX_LENGTH }} 字；全部删掉即不在录入页显示。
-          </p>
-          <div class="phrase-row">
-            <el-tag
-              v-for="item in phrases"
-              :key="item"
-              closable
-              type="info"
-              effect="plain"
-              @close="removePhrase(item)"
-            >
-              {{ item }}
-            </el-tag>
-            <span v-if="phrases.length === 0" class="text-muted">（已清空）</span>
-          </div>
-          <div class="toolbar mt-12">
-            <el-input
-              v-model="phraseInput"
-              placeholder="新增短语，如 大本"
-              style="width: 200px"
-              :maxlength="HOMEWORK_PHRASE_MAX_LENGTH"
-              @keyup.enter="addPhrase"
-            />
-            <el-button type="primary" :loading="savingPhrases" @click="addPhrase">添加</el-button>
-            <el-button @click="resetPhrases">恢复默认</el-button>
-          </div>
-        </el-card>
-
-        <el-card shadow="never" class="mt-12">
-          <template #header><span>账号信息</span></template>
-          <el-descriptions :column="1" border size="small">
-            <el-descriptions-item label="姓名">{{ auth.user?.name ?? '-' }}</el-descriptions-item>
-            <el-descriptions-item :label="auth.isClassSession ? '班级码' : '用户名'">
-              {{ auth.user?.username ?? '-' }}
-            </el-descriptions-item>
-            <el-descriptions-item label="登录方式">
-              {{ auth.isClassSession ? '班级账号（本机代表全班）' : '个人学生账号' }}
-            </el-descriptions-item>
-            <el-descriptions-item label="班级">{{ auth.user?.className ?? '未分班' }}</el-descriptions-item>
-            <el-descriptions-item label="年级">{{ auth.user?.grade ?? '-' }}</el-descriptions-item>
-          </el-descriptions>
-          <el-button class="mt-16" type="danger" plain @click="logout">退出登录</el-button>
-        </el-card>
-      </el-col>
-
-      <el-col :xs="24" :md="12">
-        <el-card shadow="never">
-          <template #header><span>离线缓存（IndexedDB）</span></template>
-          <el-table :data="cacheRows" size="small" empty-text="暂无缓存数据">
-            <el-table-column prop="label" label="数据类型" width="130" />
-            <el-table-column label="条目数" width="90">
-              <template #default="{ row }">{{ row.count }}</template>
-            </el-table-column>
-            <el-table-column label="最近更新" min-width="150">
-              <template #default="{ row }">{{ row.updatedAt }}</template>
-            </el-table-column>
-          </el-table>
-          <div class="toolbar mt-12">
-            <el-button :icon="'Refresh'" @click="appStore.refreshCacheStats()">刷新统计</el-button>
-            <el-button type="danger" plain @click="clearCache">清空缓存</el-button>
-          </div>
-          <el-alert
-            class="mt-12"
-            type="info"
-            :closable="false"
-            show-icon
-            title="离线可用"
-            description="断网后课表、作业、通知、成绩都会从本地缓存读取；恢复网络后自动向服务器同步最新数据。"
-          />
-        </el-card>
-
-        <el-card shadow="never" class="mt-12">
-          <template #header><span>客户端信息</span></template>
-          <el-descriptions :column="1" border size="small">
-            <el-descriptions-item label="应用版本">{{ appInfo?.appVersion ?? '-' }}</el-descriptions-item>
-            <el-descriptions-item label="Electron">{{ appInfo?.electron ?? '-' }}</el-descriptions-item>
-            <el-descriptions-item label="Chromium">{{ appInfo?.chrome ?? '-' }}</el-descriptions-item>
-            <el-descriptions-item label="Node.js">{{ appInfo?.node ?? '-' }}</el-descriptions-item>
-            <el-descriptions-item label="平台">{{ appInfo?.platform ?? '-' }}</el-descriptions-item>
-            <el-descriptions-item label="数据目录">{{ appInfo?.userDataPath ?? '-' }}</el-descriptions-item>
-          </el-descriptions>
-        </el-card>
-      </el-col>
-    </el-row>
-  </div>
-</template>
-
-<style scoped>
-.channel-group {
-  display: flex;
-  flex-direction: column;
-  align-items: flex-start;
-  gap: 6px;
-  margin-top: 10px;
-}
-
-.channel-hint {
-  margin-top: 10px;
-}
-
-.phrase-row {
-  display: flex;
-  flex-wrap: wrap;
-  align-items: center;
-  gap: 8px;
-  margin-top: 12px;
-}
-
-.ml-8 {
-  margin-left: 8px;
-}
-</style>

packages/desktop-client/src/renderer/views/settings/AboutView.vue

@@ -0,0 +1,301 @@
+<script setup lang="ts">
+import { onMounted, ref } from 'vue';
+import { ElMessage } from 'element-plus';
+import type { UpdateInfo } from '@classhelper/shared';
+import type { DesktopAppInfo } from '../../../types/desktop.js';
+import { useAppStore } from '../../stores/app.js';
+
+/**
+ * 关于（ClassIsland 同款折叠卡片式）：
+ * 应用信息（版本/运行时/常用链接/检查更新）→ 诊断信息（排查问题用）→ 鸣谢。
+ * 所有外链走主进程 openExternal（只放行 http/https，见 main/ipc.ts 的白名单）。
+ */
+const appStore = useAppStore();
+
+const appInfo = ref<DesktopAppInfo | null>(null);
+/** 折叠面板默认展开第一项（应用信息），诊断信息默认收起 */
+const expandedNames = ref(['app']);
+
+/** 检查更新：结果由主进程直连 GitHub 得到（见 main/update.ts） */
+const checking = ref(false);
+const updateInfo = ref<UpdateInfo | null>(null);
+
+const PROJECT_URL = 'https://github.com/LoveChengke/ClassHelper';
+const ISSUES_URL = 'https://github.com/LoveChengke/ClassHelper/issues';
+
+const collapseItems = [
+  { name: 'app', title: '应用信息', icon: 'School' },
+  { name: 'diagnostics', title: '查看诊断信息', icon: 'Warning' },
+  { name: 'thanks', title: '鸣谢', icon: 'Pointer' },
+];
+
+async function openExternal(url: string): Promise<void> {
+  if (window.desktop?.openExternal) {
+    const handled = await window.desktop.openExternal(url);
+    if (handled) return;
+  }
+  window.open(url, '_blank');
+}
+
+/**
+ * 检查更新。
+ *
+ * @param force true = 用户主动点击（绕过主进程缓存）；false = 进页面时带出启动自动检查的结果
+ */
+async function checkUpdate(force: boolean): Promise<void> {
+  if (!window.desktop?.checkForUpdates) return;
+  checking.value = true;
+  try {
+    updateInfo.value = await window.desktop.checkForUpdates(force);
+  } finally {
+    checking.value = false;
+  }
+}
+
+/** 忽略这个版本：写进配置，启动自动检查不再提示它 */
+async function ignoreVersion(): Promise<void> {
+  const version = updateInfo.value?.latestVersion;
+  if (!version) return;
+  await window.desktop?.ignoreUpdateVersion(version);
+  ElMessage.success(`已忽略 v${version} 的更新提示`);
+}
+
+onMounted(async () => {
+  if (!window.desktop) return;
+  appInfo.value = await window.desktop.getAppInfo().catch(() => null);
+  // 带出启动自动检查的结果（命中主进程缓存，不会再发一次请求）
+  void checkUpdate(false);
+});
+</script>
+
+<template>
+  <div class="page">
+    <div class="page-header">
+      <div>
+        <h2 class="page-title">关于</h2>
+        <p class="page-subtitle">版本、诊断信息与鸣谢</p>
+      </div>
+    </div>
+
+    <el-collapse v-model="expandedNames" class="about-collapse">
+      <!-- 应用信息 -->
+      <el-collapse-item name="app">
+        <template #title>
+          <span class="about-title">
+            <el-icon><School /></el-icon>
+            {{ collapseItems[0].title }}
+          </span>
+          <span class="about-extra">班级小助手 v{{ appInfo?.appVersion ?? '-' }}</span>
+        </template>
+        <div class="about-section">
+          <p class="about-copy">
+            Copyright © 2025-2026 班级小助手
+            <br />
+            面向班级的课表 · 作业 · 通知 · 成绩信息工具（Web 管理端 + 桌面客户端 + 灵动岛）
+          </p>
+          <div class="about-links">
+            <span class="about-links-label">常用链接</span>
+            <el-button link type="primary" @click="openExternal(PROJECT_URL)">项目主页</el-button>
+            <el-button link type="primary" @click="openExternal(ISSUES_URL)">问题反馈</el-button>
+          </div>
+          <el-descriptions :column="1" border size="small" class="mt-12">
+            <el-descriptions-item label="应用版本">{{ appInfo?.appVersion ?? '-' }}</el-descriptions-item>
+            <el-descriptions-item label="运行时">
+              Electron {{ appInfo?.electron ?? '-' }} · Chromium {{ appInfo?.chrome ?? '-' }} · Node
+              {{ appInfo?.node ?? '-' }}
+            </el-descriptions-item>
+            <el-descriptions-item label="平台">{{ appInfo?.platform ?? '-' }}</el-descriptions-item>
+          </el-descriptions>
+
+          <!-- 检查更新：直连 GitHub 看最新的 Release 是不是比本机新 -->
+          <div class="about-update" data-test="update-check">
+            <div class="about-update-head">
+              <span class="about-update-label">检查更新</span>
+              <el-button
+                size="small"
+                :loading="checking"
+                data-test="update-check-button"
+                @click="checkUpdate(true)"
+              >
+                检查更新
+              </el-button>
+            </div>
+            <div class="about-update-body">
+              <template v-if="checking">正在检查…</template>
+              <template v-else-if="!updateInfo">尚未检查</template>
+              <template v-else-if="!updateInfo.ok">
+                <!-- 教室机器没有外网是常态，这里只是"查不到"，不是错误 -->
+                <span class="about-update-muted">{{ updateInfo.error ?? '暂时无法检查更新' }}</span>
+              </template>
+              <template v-else-if="updateInfo.hasUpdate">
+                <el-tag size="small" type="success" effect="light">
+                  发现新版本 v{{ updateInfo.latestVersion }}
+                </el-tag>
+                <span class="about-update-muted">当前 v{{ updateInfo.currentVersion }}</span>
+                <el-button
+                  link
+                  type="primary"
+                  size="small"
+                  data-test="update-download"
+                  @click="openExternal(updateInfo.releaseUrl)"
+                >
+                  前往下载
+                </el-button>
+                <el-button link size="small" @click="ignoreVersion">忽略此版本</el-button>
+              </template>
+              <template v-else>
+                <el-tag size="small" type="info" effect="plain">已是最新版本</el-tag>
+                <span class="about-update-muted">
+                  v{{ updateInfo.currentVersion }} · {{ updateInfo.latestVersion }}
+                </span>
+              </template>
+            </div>
+          </div>
+        </div>
+      </el-collapse-item>
+
+      <!-- 诊断信息 -->
+      <el-collapse-item name="diagnostics">
+        <template #title>
+          <span class="about-title">
+            <el-icon><Warning /></el-icon>
+            {{ collapseItems[1].title }}
+          </span>
+          <span class="about-extra">报障时请附带本页信息</span>
+        </template>
+        <div class="about-section">
+          <el-descriptions :column="1" border size="small">
+            <el-descriptions-item label="服务器地址">{{ appStore.serverUrl }}</el-descriptions-item>
+            <el-descriptions-item label="连接状态">
+              <el-tag size="small" :type="appStore.serverReachable ? 'success' : 'danger'">
+                {{ appStore.serverReachable ? '服务器可达' : '离线（显示缓存数据）' }}
+              </el-tag>
+            </el-descriptions-item>
+            <el-descriptions-item label="最近同步">{{ appStore.lastSyncText }}</el-descriptions-item>
+            <el-descriptions-item label="缓存条目">{{ appStore.cacheItemCount }} 条</el-descriptions-item>
+            <el-descriptions-item label="数据目录">{{ appInfo?.userDataPath ?? '-' }}</el-descriptions-item>
+            <el-descriptions-item label="配置文件">{{ appInfo?.configPath ?? '-' }}</el-descriptions-item>
+          </el-descriptions>
+        </div>
+      </el-collapse-item>
+
+      <!-- 鸣谢 -->
+      <el-collapse-item name="thanks">
+        <template #title>
+          <span class="about-title">
+            <el-icon><Pointer /></el-icon>
+            {{ collapseItems[2].title }}
+          </span>
+        </template>
+        <div class="about-section">
+          <ul class="about-thanks">
+            <li>
+              <strong>ClassIsland</strong>
+              —— 界面风格、设置页与「今天」时间轴的交互参考
+            </li>
+            <li>
+              <strong>WinIsland</strong>
+              —— 灵动岛的窗口形态与弹簧动画参考
+            </li>
+            <li>
+              <strong>Vue / Element Plus / Prisma / Express / Socket.IO</strong>
+              —— 本项目赖以构建的开源基石
+            </li>
+          </ul>
+        </div>
+      </el-collapse-item>
+    </el-collapse>
+
+    <p class="about-quote">谨以此应用，献给朝夕相伴的班级与同窗；愿时光流转，情谊常在。</p>
+  </div>
+</template>
+
+<style scoped>
+.about-title {
+  display: inline-flex;
+  align-items: center;
+  gap: 8px;
+}
+
+.about-extra {
+  margin-left: auto;
+  margin-right: 12px;
+  font-size: 12px;
+  font-weight: 400;
+  color: var(--ch-text-tertiary);
+}
+
+.about-section {
+  padding: 0 4px;
+}
+
+.about-copy {
+  margin: 0 0 10px;
+  line-height: 1.8;
+  color: var(--ch-text-secondary);
+  font-size: 12.5px;
+}
+
+.about-links {
+  display: flex;
+  align-items: center;
+  gap: 4px;
+}
+
+.about-links-label {
+  font-size: 12.5px;
+  color: var(--ch-text-secondary);
+  margin-right: 4px;
+}
+
+/* 检查更新：颜色一律走 --ch-* 变量（深色主题下不能写死浅色底/深色字） */
+.about-update {
+  margin-top: 12px;
+  padding: 10px 12px;
+  border: 1px solid var(--ch-border);
+  border-radius: var(--ch-radius-card);
+  background: var(--ch-layer-alt);
+}
+
+.about-update-head {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 8px;
+}
+
+.about-update-label {
+  font-size: 12.5px;
+  font-weight: 600;
+  color: var(--ch-text-secondary);
+}
+
+.about-update-body {
+  display: flex;
+  align-items: center;
+  flex-wrap: wrap;
+  gap: 8px;
+  margin-top: 8px;
+  font-size: 12.5px;
+  color: var(--ch-text);
+}
+
+.about-update-muted {
+  color: var(--ch-text-tertiary);
+}
+
+.about-thanks {
+  margin: 0;
+  padding-left: 18px;
+  line-height: 2;
+  font-size: 12.5px;
+  color: var(--ch-text-secondary);
+}
+
+.about-quote {
+  margin: 18px 0 4px;
+  text-align: center;
+  font-size: 12px;
+  color: var(--ch-text-tertiary);
+}
+</style>

packages/desktop-client/src/renderer/views/settings/AccountSettingsView.vue

@@ -0,0 +1,55 @@
+<script setup lang="ts">
+import { useRouter } from 'vue-router';
+import { ElMessage, ElMessageBox } from 'element-plus';
+import { useAuthStore } from '../../stores/auth.js';
+import { useRealtimeStore } from '../../stores/realtime.js';
+
+/**
+ * 账号设置：本机登录的班级账号信息 + 退出登录。
+ * 班级密码由管理员在 Web 管理端维护（本机按用户要求不提供改密入口）。
+ */
+const router = useRouter();
+const auth = useAuthStore();
+const realtime = useRealtimeStore();
+
+async function logout(): Promise<void> {
+  await ElMessageBox.confirm('确认退出当前账号？', '退出登录', { type: 'warning' });
+  realtime.disconnect();
+  await auth.logout();
+  ElMessage.success('已退出登录');
+  await router.replace('/login');
+}
+</script>
+
+<template>
+  <div class="page">
+    <div class="page-header">
+      <div>
+        <h2 class="page-title">账号</h2>
+        <p class="page-subtitle">本机登录的班级账号</p>
+      </div>
+    </div>
+
+    <el-card shadow="never">
+      <template #header><span>账号信息</span></template>
+      <el-descriptions :column="1" border size="small">
+        <el-descriptions-item label="姓名">{{ auth.user?.name ?? '-' }}</el-descriptions-item>
+        <el-descriptions-item :label="auth.isClassSession ? '班级码' : '用户名'">
+          {{ auth.user?.username ?? '-' }}
+        </el-descriptions-item>
+        <el-descriptions-item label="登录方式">
+          {{ auth.isClassSession ? '班级账号（本机代表全班）' : '班级账号' }}
+        </el-descriptions-item>
+        <el-descriptions-item label="班级">{{ auth.user?.className ?? '未分班' }}</el-descriptions-item>
+        <el-descriptions-item label="年级">{{ auth.user?.grade ?? '-' }}</el-descriptions-item>
+      </el-descriptions>
+      <div class="toolbar mt-16">
+        <el-button type="danger" plain @click="logout">退出登录</el-button>
+      </div>
+      <div class="text-muted mt-12">
+        班级密码由管理员在 Web 管理端「班级管理 → 修改班级账号」中设置；本机退出后用班级码 +
+        班级密码重新登录。
+      </div>
+    </el-card>
+  </div>
+</template>

packages/desktop-client/src/renderer/views/settings/AppearanceView.vue

@@ -0,0 +1,162 @@
+<script setup lang="ts">
+import { ElMessage } from 'element-plus';
+import { useUiStore } from '../../stores/ui.js';
+
+/**
+ * 外观：黑夜 / 白天模式。
+ * 状态与持久化都在 stores/ui.ts（主进程配置 theme 字段），顶栏右上角的
+ * 日月按钮与本页写同一份配置，切换立即生效（html.dark + Element Plus dark css-vars）。
+ */
+const ui = useUiStore();
+
+const options = [
+  { value: 'light', label: '浅色', desc: '明亮界面，适合白天与投影环境' },
+  { value: 'dark', label: '深色', desc: '黑夜模式，适合晚自习与暗教室' },
+] as const;
+
+async function selectTheme(value: 'light' | 'dark'): Promise<void> {
+  if (value === ui.theme) return;
+  await ui.setTheme(value);
+  ElMessage.success(value === 'dark' ? '已切换到深色模式' : '已切换到浅色模式');
+}
+</script>
+
+<template>
+  <div class="page">
+    <div class="page-header">
+      <div>
+        <h2 class="page-title">外观</h2>
+        <p class="page-subtitle">黑夜与白天模式，切换立即生效并自动保存</p>
+      </div>
+    </div>
+
+    <el-card shadow="never">
+      <template #header><span>界面主题</span></template>
+      <div class="theme-options">
+        <button
+          v-for="option in options"
+          :key="option.value"
+          type="button"
+          class="theme-option"
+          :class="[`theme-${option.value}`, { active: ui.theme === option.value }]"
+          :data-theme-option="option.value"
+          @click="selectTheme(option.value)"
+        >
+          <span class="theme-preview">
+            <span class="preview-side" />
+            <span class="preview-body">
+              <span class="preview-line" />
+              <span class="preview-line short" />
+            </span>
+          </span>
+          <span class="theme-name">
+            <el-icon><Sunny v-if="option.value === 'light'" /><Moon v-else /></el-icon>
+            {{ option.label }}
+          </span>
+          <span class="theme-desc">{{ option.desc }}</span>
+        </button>
+      </div>
+      <el-alert
+        class="mt-12"
+        type="info"
+        :closable="false"
+        title="顶栏右上角也有主题快捷切换按钮"
+        description="灵动岛始终为深色浮窗，不随主题变化；登录页与全屏作业看板为固定配色，亦不受影响。"
+      />
+    </el-card>
+  </div>
+</template>
+
+<style scoped>
+.theme-options {
+  display: flex;
+  gap: 12px;
+  flex-wrap: wrap;
+}
+
+.theme-option {
+  width: 200px;
+  display: flex;
+  flex-direction: column;
+  align-items: flex-start;
+  gap: 6px;
+  padding: 12px;
+  border: 1px solid var(--ch-border-strong);
+  border-radius: var(--ch-radius-card);
+  background: var(--ch-layer);
+  cursor: pointer;
+  color: var(--ch-text);
+  text-align: left;
+  transition:
+    border-color 0.15s ease,
+    box-shadow 0.15s ease;
+}
+
+.theme-option:hover {
+  border-color: var(--ch-accent);
+}
+
+.theme-option.active {
+  border-color: var(--ch-accent);
+  box-shadow: 0 0 0 1px var(--ch-accent) inset;
+}
+
+/* 主题缩略预览：两块小色板直接表现各自配色 */
+.theme-preview {
+  display: flex;
+  width: 100%;
+  height: 64px;
+  border-radius: 6px;
+  overflow: hidden;
+  border: 1px solid var(--ch-border-strong);
+}
+
+.theme-light .theme-preview {
+  background: #f3f3f3;
+}
+
+.theme-dark .theme-preview {
+  background: #161719;
+}
+
+.preview-side {
+  width: 28px;
+  background: rgba(255, 255, 255, 0.65);
+}
+
+.theme-dark .preview-side {
+  background: rgba(32, 33, 36, 0.9);
+}
+
+.preview-body {
+  flex: 1;
+  padding: 8px;
+  display: flex;
+  flex-direction: column;
+  gap: 6px;
+}
+
+.preview-line {
+  height: 8px;
+  border-radius: 4px;
+  width: 80%;
+  background: rgba(15, 108, 189, 0.55);
+}
+
+.preview-line.short {
+  width: 50%;
+  background: rgba(128, 128, 128, 0.35);
+}
+
+.theme-name {
+  display: inline-flex;
+  align-items: center;
+  gap: 6px;
+  font-weight: 600;
+}
+
+.theme-desc {
+  font-size: 12px;
+  color: var(--ch-text-tertiary);
+}
+</style>

packages/desktop-client/src/renderer/views/settings/GeneralSettingsView.vue

@@ -0,0 +1,285 @@
+<script setup lang="ts">
+import { computed, onMounted, ref } from 'vue';
+import { ElMessage, ElMessageBox } from 'element-plus';
+import {
+  HOMEWORK_PHRASE_DEFAULTS,
+  HOMEWORK_PHRASE_MAX_COUNT,
+  HOMEWORK_PHRASE_MAX_LENGTH,
+  formatDate,
+} from '@classhelper/shared';
+import { pingHealth, setApiBaseUrl } from '../../api/http.js';
+import { normalizeServerUrl } from '../../config.js';
+import { useAppStore } from '../../stores/app.js';
+import { useAuthStore } from '../../stores/auth.js';
+import { useNotificationStore } from '../../stores/notifications.js';
+import { useOnboardingStore } from '../../stores/onboarding.js';
+import { useRealtimeStore } from '../../stores/realtime.js';
+
+/**
+ * 通用设置：服务器连接、离线缓存与作业录入短语。
+ * （外观 / 灵动岛 / 提醒 / 账号 / 关于 各自是独立子页，见侧边栏「设置」分组。）
+ */
+const appStore = useAppStore();
+const auth = useAuthStore();
+const onboarding = useOnboardingStore();
+const realtime = useRealtimeStore();
+const notifications = useNotificationStore();
+
+const serverInput = ref(appStore.serverUrl);
+const testing = ref(false);
+const saving = ref(false);
+
+const storeLabels: Record<string, string> = {
+  profile: '登录资料',
+  classes: '班级 / 学期',
+  schedules: '课表',
+  homeworks: '作业',
+  notifications: '通知',
+  grades: '成绩',
+};
+
+const cacheRows = computed(() =>
+  appStore.cacheStoreStats.map((item) => ({
+    label: storeLabels[item.store] ?? item.store,
+    store: item.store,
+    count: item.count,
+    updatedAt: item.updatedAt ? formatDate(item.updatedAt, true) : '—',
+  })),
+);
+
+async function saveServer(): Promise<void> {
+  const normalized = normalizeServerUrl(serverInput.value);
+  if (!normalized) {
+    ElMessage.error('服务器地址格式不正确，例如 http://127.0.0.1:4000');
+    return;
+  }
+  saving.value = true;
+  try {
+    await appStore.applyServerUrl(normalized);
+    serverInput.value = normalized;
+    ElMessage.success('服务器地址已保存');
+    await testConnection();
+    if (auth.token) realtime.connect(normalized, auth.token);
+  } finally {
+    saving.value = false;
+  }
+}
+
+async function testConnection(): Promise<void> {
+  testing.value = true;
+  try {
+    const result = await pingHealth();
+    if (result.ok) ElMessage.success('服务器连接正常');
+    else ElMessage.error('无法连接服务器，请检查地址与网络');
+  } finally {
+    testing.value = false;
+  }
+}
+
+async function manualSync(): Promise<void> {
+  setApiBaseUrl(appStore.serverUrl);
+  await appStore.ping();
+  if (appStore.offline) {
+    ElMessage.warning('当前无法连接服务器，已保留缓存数据');
+    return;
+  }
+  await notifications.load();
+  appStore.markSynced();
+  ElMessage.success('已同步最新数据');
+}
+
+async function clearCache(): Promise<void> {
+  await ElMessageBox.confirm('清空后离线时将无法查看历史数据，确认继续？', '清空离线缓存', {
+    type: 'warning',
+  });
+  await appStore.clearCache();
+  ElMessage.success('离线缓存已清空');
+}
+
+/* ------------------------------------------------------------ 作业录入快捷短语 */
+
+/**
+ * 作业快捷短语：录作业时点一下就把词追加到标题/内容里（P、大本、背诵…）。
+ *
+ * 存在客户端本地配置（这台教室机器自己的习惯），不占用服务端字段；
+ * 空数组是合法值 —— 老师把短语全删了就是"不想用快捷短语"。
+ */
+const phrases = ref<string[]>([...HOMEWORK_PHRASE_DEFAULTS]);
+const phraseInput = ref('');
+const savingPhrases = ref(false);
+
+async function loadPhrases(): Promise<void> {
+  const config = await window.desktop?.getConfig?.();
+  if (config?.homeworkPhrases) phrases.value = [...config.homeworkPhrases];
+}
+
+async function savePhrases(): Promise<void> {
+  if (!window.desktop?.saveConfig) return;
+  savingPhrases.value = true;
+  try {
+    const saved = await window.desktop.saveConfig({ homeworkPhrases: [...phrases.value] });
+    phrases.value = [...saved.homeworkPhrases];
+  } finally {
+    savingPhrases.value = false;
+  }
+}
+
+async function addPhrase(): Promise<void> {
+  const value = phraseInput.value.trim().slice(0, HOMEWORK_PHRASE_MAX_LENGTH);
+  if (!value) return;
+  if (phrases.value.includes(value)) {
+    ElMessage.warning('这条短语已经有了');
+    return;
+  }
+  if (phrases.value.length >= HOMEWORK_PHRASE_MAX_COUNT) {
+    ElMessage.warning(`最多 ${HOMEWORK_PHRASE_MAX_COUNT} 条快捷短语`);
+    return;
+  }
+  phrases.value = [...phrases.value, value];
+  phraseInput.value = '';
+  await savePhrases();
+  ElMessage.success('已添加');
+}
+
+async function removePhrase(value: string): Promise<void> {
+  phrases.value = phrases.value.filter((item) => item !== value);
+  await savePhrases();
+}
+
+async function resetPhrases(): Promise<void> {
+  await ElMessageBox.confirm('恢复为默认快捷短语？', '恢复默认', { type: 'warning' });
+  phrases.value = [...HOMEWORK_PHRASE_DEFAULTS];
+  await savePhrases();
+  ElMessage.success('已恢复默认');
+}
+
+onMounted(async () => {
+  await appStore.refreshCacheStats();
+  await loadPhrases();
+});
+</script>
+
+<template>
+  <div class="page">
+    <div class="page-header">
+      <div>
+        <h2 class="page-title">通用</h2>
+        <p class="page-subtitle">服务器连接、离线缓存与作业录入</p>
+      </div>
+      <!-- 重看初次启动引导（首启时由 App.vue 自动弹出过一次） -->
+      <el-button @click="onboarding.open()">
+        <el-icon><Guide /></el-icon>
+        使用引导
+      </el-button>
+    </div>
+
+    <el-row :gutter="12">
+      <el-col :xs="24" :md="12">
+        <el-card shadow="never">
+          <template #header><span>服务器连接</span></template>
+          <el-form label-position="top">
+            <el-form-item label="服务器地址">
+              <el-input v-model="serverInput" placeholder="http://127.0.0.1:4000">
+                <template #prefix>
+                  <el-icon><Link /></el-icon>
+                </template>
+              </el-input>
+            </el-form-item>
+          </el-form>
+          <div class="toolbar">
+            <el-button type="primary" :loading="saving" @click="saveServer">保存并测试</el-button>
+            <el-button :loading="testing" @click="testConnection">测试连接</el-button>
+            <el-button @click="manualSync">立即同步</el-button>
+          </div>
+
+          <el-descriptions class="mt-16" :column="1" border size="small">
+            <el-descriptions-item label="当前状态">
+              <el-tag :type="appStore.serverReachable ? 'success' : 'danger'" size="small">
+                {{ appStore.serverReachable ? '服务器可达' : '离线（显示缓存数据）' }}
+              </el-tag>
+              <el-tag class="ml-8" :type="realtime.connected ? 'success' : 'info'" size="small">
+                {{ realtime.statusText }}
+              </el-tag>
+            </el-descriptions-item>
+            <el-descriptions-item label="最近同步">{{ appStore.lastSyncText }}</el-descriptions-item>
+            <el-descriptions-item label="实时事件数">{{ realtime.eventCount }} 条</el-descriptions-item>
+          </el-descriptions>
+        </el-card>
+
+        <el-card shadow="never" class="mt-12">
+          <template #header><span>作业录入</span></template>
+          <p class="text-muted">
+            在教室电脑上录作业时，点一下短语就会追加到标题 / 内容里（例如 P、大本、背诵）。 最多
+            {{ HOMEWORK_PHRASE_MAX_COUNT }} 条、每条
+            {{ HOMEWORK_PHRASE_MAX_LENGTH }} 字；全部删掉即不在录入页显示。
+          </p>
+          <div class="phrase-row">
+            <el-tag
+              v-for="item in phrases"
+              :key="item"
+              closable
+              type="info"
+              effect="plain"
+              @close="removePhrase(item)"
+            >
+              {{ item }}
+            </el-tag>
+            <span v-if="phrases.length === 0" class="text-muted">（已清空）</span>
+          </div>
+          <div class="toolbar mt-12">
+            <el-input
+              v-model="phraseInput"
+              placeholder="新增短语，如 大本"
+              style="width: 200px"
+              :maxlength="HOMEWORK_PHRASE_MAX_LENGTH"
+              @keyup.enter="addPhrase"
+            />
+            <el-button type="primary" :loading="savingPhrases" @click="addPhrase">添加</el-button>
+            <el-button @click="resetPhrases">恢复默认</el-button>
+          </div>
+        </el-card>
+      </el-col>
+
+      <el-col :xs="24" :md="12">
+        <el-card shadow="never">
+          <template #header><span>离线缓存（IndexedDB）</span></template>
+          <el-table :data="cacheRows" size="small" empty-text="暂无缓存数据">
+            <el-table-column prop="label" label="数据类型" width="130" />
+            <el-table-column label="条目数" width="90">
+              <template #default="{ row }">{{ row.count }}</template>
+            </el-table-column>
+            <el-table-column label="最近更新" min-width="150">
+              <template #default="{ row }">{{ row.updatedAt }}</template>
+            </el-table-column>
+          </el-table>
+          <div class="toolbar mt-12">
+            <el-button :icon="'Refresh'" @click="appStore.refreshCacheStats()">刷新统计</el-button>
+            <el-button type="danger" plain @click="clearCache">清空缓存</el-button>
+          </div>
+          <el-alert
+            class="mt-12"
+            type="info"
+            :closable="false"
+            show-icon
+            title="离线可用"
+            description="断网后课表、作业、通知、成绩都会从本地缓存读取；恢复网络后自动向服务器同步最新数据。"
+          />
+        </el-card>
+      </el-col>
+    </el-row>
+  </div>
+</template>
+
+<style scoped>
+.phrase-row {
+  display: flex;
+  flex-wrap: wrap;
+  align-items: center;
+  gap: 8px;
+  margin-top: 12px;
+}
+
+.ml-8 {
+  margin-left: 8px;
+}
+</style>

packages/desktop-client/src/renderer/views/settings/IslandSettingsView.vue

@@ -0,0 +1,276 @@
+<script setup lang="ts">
+import { computed, onMounted, ref } from 'vue';
+import { ElMessage, ElMessageBox } from 'element-plus';
+import {
+  DEFAULT_ISLAND_APPEARANCE,
+  ISLAND_APPEARANCE_RANGES as RANGES,
+  ISLAND_POSITION_LABELS,
+  ISLAND_POSITIONS,
+  ISLAND_STYLE_LABELS,
+  ISLAND_STYLES,
+  type IslandAppearance,
+  type IslandPosition,
+  type IslandStyle,
+} from '@classhelper/shared';
+
+/**
+ * 灵动岛个性化（原设置页「灵动岛 · 个性化」卡整块迁移）。
+ *
+ * 注意：必须传**展开后的纯对象**。`island` 是 `ref`，它的 `.value` 在 Vue 里是响应式
+ * Proxy，Proxy 过不了 IPC 的结构化克隆（`An object could not be cloned.`）——
+ * 那正是"拖了滑块、数字在变、灵动岛却没反应"的原因。
+ */
+const island = ref<IslandAppearance>({ ...DEFAULT_ISLAND_APPEARANCE });
+const savingIsland = ref(false);
+
+/**
+ * 左右边距是否有效：只在停靠左 / 右时生效。
+ *
+ * 岛是"居中停靠"时（默认就是顶部居中），水平方向的锚点就是屏幕中线 ——
+ * 这时调左右边距不会有任何变化。之前没把这点说清楚，用户会以为"调了不生效"。
+ */
+const marginXApplies = computed(() => !island.value.position.endsWith('center'));
+
+const positionOptions = ISLAND_POSITIONS.map((value) => ({
+  value,
+  label: ISLAND_POSITION_LABELS[value],
+}));
+
+const styleOptions = ISLAND_STYLES.map((value) => ({
+  value,
+  label: ISLAND_STYLE_LABELS[value],
+}));
+
+/** 读取当前生效的外观（主进程为单一事实来源） */
+async function loadIslandAppearance(): Promise<void> {
+  if (!window.desktop?.islandGetAppearance) return;
+  island.value = await window.desktop.islandGetAppearance();
+}
+
+/** 改动即生效：属性变化时先应用（实时预览），点"保存"再落盘 */
+function applyIslandAppearance(patch: Partial<IslandAppearance> = {}): void {
+  island.value = { ...island.value, ...patch };
+  window.desktop?.islandSetAppearance({ ...island.value });
+}
+
+async function saveIslandAppearance(): Promise<void> {
+  if (!window.desktop?.saveConfig) return;
+  savingIsland.value = true;
+  try {
+    await window.desktop.saveConfig({ island: { ...island.value } });
+    ElMessage.success('个性化设置已保存');
+  } finally {
+    savingIsland.value = false;
+  }
+}
+
+async function resetIslandAppearance(): Promise<void> {
+  await ElMessageBox.confirm('恢复灵动岛的默认外观？', '恢复默认', { type: 'warning' });
+  applyIslandAppearance({ ...DEFAULT_ISLAND_APPEARANCE });
+  await saveIslandAppearance();
+}
+
+/** 本地推一条测试通知，立刻确认外观效果（预览模式：直接展开、失焦不收起、30 秒后自动消失） */
+function testIsland(): void {
+  window.desktop?.islandPush?.({
+    notification: {
+      id: `appearance-test-${Date.now()}`,
+      title: '灵动岛外观预览',
+      content: '拖动滑块即可实时预览：高度、宽度、圆角、透明度、字号、主题色、位置与动画。',
+      priority: 'NORMAL',
+      createdAt: new Date().toISOString(),
+      courseName: null,
+      teacherName: '本地预览',
+    },
+    context: { inClass: false, currentPeriodEnd: null, preview: true },
+  });
+}
+
+onMounted(async () => {
+  await loadIslandAppearance();
+});
+</script>
+
+<template>
+  <div class="page">
+    <div class="page-header">
+      <div>
+        <h2 class="page-title">灵动岛</h2>
+        <p class="page-subtitle">屏幕上方的消息浮窗：外观、停靠位置与动画</p>
+      </div>
+    </div>
+
+    <el-card shadow="never">
+      <template #header><span>灵动岛 · 个性化</span></template>
+      <el-form label-width="96px" label-position="left">
+        <el-form-item :label="`高度 ${island.height}px`">
+          <el-slider
+            :model-value="island.height"
+            :min="RANGES.height.min"
+            :max="RANGES.height.max"
+            :step="1"
+            @input="(value: number) => applyIslandAppearance({ height: value })"
+          />
+        </el-form-item>
+        <el-form-item :label="`宽度 ${island.width}px`">
+          <el-slider
+            :model-value="island.width"
+            :min="RANGES.width.min"
+            :max="RANGES.width.max"
+            :step="2"
+            @input="(value: number) => applyIslandAppearance({ width: value })"
+          />
+        </el-form-item>
+        <el-form-item :label="`圆角 ${island.radius}px`">
+          <el-slider
+            :model-value="island.radius"
+            :min="RANGES.radius.min"
+            :max="RANGES.radius.max"
+            :step="1"
+            @input="(value: number) => applyIslandAppearance({ radius: value })"
+          />
+        </el-form-item>
+        <el-form-item :label="`不透明度 ${Math.round(island.opacity * 100)}%`">
+          <el-slider
+            :model-value="island.opacity"
+            :min="RANGES.opacity.min"
+            :max="RANGES.opacity.max"
+            :step="0.05"
+            @input="(value: number) => applyIslandAppearance({ opacity: value })"
+          />
+        </el-form-item>
+        <el-form-item :label="`字号 ${island.fontSize}px`">
+          <el-slider
+            :model-value="island.fontSize"
+            :min="RANGES.fontSize.min"
+            :max="RANGES.fontSize.max"
+            :step="1"
+            @input="(value: number) => applyIslandAppearance({ fontSize: value })"
+          />
+        </el-form-item>
+        <el-form-item :label="`动画速度 ${island.speed.toFixed(1)}x`">
+          <el-slider
+            :model-value="island.speed"
+            :min="RANGES.speed.min"
+            :max="RANGES.speed.max"
+            :step="0.1"
+            @input="(value: number) => applyIslandAppearance({ speed: value })"
+          />
+        </el-form-item>
+        <el-form-item label="主题色">
+          <el-color-picker
+            :model-value="island.accent"
+            @change="(value: string | null) => applyIslandAppearance({ accent: value ?? '#0a84ff' })"
+          />
+          <span class="text-muted ml-8">用于高亮、按钮与进度条</span>
+        </el-form-item>
+        <el-form-item label="视觉风格">
+          <el-select
+            :model-value="island.style"
+            style="width: 180px"
+            @change="(value: IslandStyle) => applyIslandAppearance({ style: value })"
+          >
+            <el-option
+              v-for="item in styleOptions"
+              :key="item.value"
+              :label="item.label"
+              :value="item.value"
+            />
+          </el-select>
+          <span class="text-muted ml-8">纯黑 / 毛玻璃（半透明）/ 主题色渐变</span>
+        </el-form-item>
+        <el-form-item label="显示位置">
+          <el-select
+            :model-value="island.position"
+            style="width: 180px"
+            @change="(value: IslandPosition) => applyIslandAppearance({ position: value })"
+          >
+            <el-option
+              v-for="item in positionOptions"
+              :key="item.value"
+              :label="item.label"
+              :value="item.value"
+            />
+          </el-select>
+        </el-form-item>
+        <el-form-item :label="`左右边距 ${island.marginX}px`">
+          <el-slider
+            :model-value="island.marginX"
+            :min="RANGES.marginX.min"
+            :max="RANGES.marginX.max"
+            :step="2"
+            :disabled="!marginXApplies"
+            @input="(value: number) => applyIslandAppearance({ marginX: value })"
+          />
+          <span v-if="marginXApplies" class="text-muted ml-8">停靠左/右时距屏幕边缘的距离</span>
+          <span v-else class="text-muted ml-8">
+            当前是「居中」停靠，左右边距不生效 —— 把上面的「显示位置」改成左 / 右停靠即可看到效果
+          </span>
+        </el-form-item>
+        <el-form-item :label="`上下边距 ${island.marginY}px`">
+          <el-slider
+            :model-value="island.marginY"
+            :min="RANGES.marginY.min"
+            :max="RANGES.marginY.max"
+            :step="2"
+            @input="(value: number) => applyIslandAppearance({ marginY: value })"
+          />
+          <span class="text-muted ml-8">停靠顶/底时距屏幕边缘的距离（任务栏在侧面时调大）</span>
+        </el-form-item>
+        <el-form-item label="跟随鼠标屏幕">
+          <el-switch
+            :model-value="island.followCursorDisplay"
+            @change="
+              (value: boolean | string | number) =>
+                applyIslandAppearance({ followCursorDisplay: Boolean(value) })
+            "
+          />
+          <span class="text-muted ml-8">多显示器教室电脑：岛出现在鼠标所在的那块屏幕</span>
+        </el-form-item>
+        <el-form-item label="动画">
+          <el-switch
+            :model-value="island.animations"
+            @change="
+              (value: boolean | string | number) => applyIslandAppearance({ animations: Boolean(value) })
+            "
+          />
+          <span class="text-muted ml-8">关闭后展开/收起为瞬时生效</span>
+        </el-form-item>
+        <el-form-item label="始终置顶">
+          <el-switch
+            :model-value="island.alwaysOnTop"
+            @change="
+              (value: boolean | string | number) => applyIslandAppearance({ alwaysOnTop: Boolean(value) })
+            "
+          />
+        </el-form-item>
+        <el-form-item label="空闲细缝">
+          <el-switch
+            :model-value="island.idleSliver"
+            @change="
+              (value: boolean | string | number) => applyIslandAppearance({ idleSliver: Boolean(value) })
+            "
+          />
+          <span class="text-muted ml-8">参考 WinIsland：没有消息时保留一条细缝（关闭则完全隐藏）</span>
+        </el-form-item>
+      </el-form>
+      <div class="toolbar">
+        <el-button type="primary" :loading="savingIsland" @click="saveIslandAppearance">保存设置</el-button>
+        <el-button @click="testIsland">预览效果</el-button>
+        <el-button @click="resetIslandAppearance">恢复默认</el-button>
+      </div>
+      <el-alert
+        class="mt-12"
+        type="info"
+        :closable="false"
+        title="拖动滑块即为实时预览；保存后写入本地配置，重启客户端仍然生效"
+      />
+    </el-card>
+  </div>
+</template>
+
+<style scoped>
+.ml-8 {
+  margin-left: 8px;
+}
+</style>

packages/desktop-client/src/renderer/views/settings/ReminderSettingsView.vue

@@ -0,0 +1,141 @@
+<script setup lang="ts">
+import { computed, onMounted, ref } from 'vue';
+import { ElMessage } from 'element-plus';
+import {
+  CLASSISLAND_NOTIFICATION_CHANNEL_HINTS,
+  CLASSISLAND_NOTIFICATION_CHANNEL_LABELS,
+  CLASSISLAND_NOTIFICATION_CHANNELS,
+  formatDate,
+  type ClassIslandNotificationChannel,
+} from '@classhelper/shared';
+import { classIslandStatusApi } from '../../api/index.js';
+import { useAppStore } from '../../stores/app.js';
+import { useAuthStore } from '../../stores/auth.js';
+
+/**
+ * 提醒设置：这台教室机器把提醒弹在哪个端（客户端 / ClassIsland / 两端都弹）。
+ * 值同时落本地配置与班级记录（服务端据此决定是否推送 ClassIsland）。
+ */
+const appStore = useAppStore();
+const auth = useAuthStore();
+
+const channelSaving = ref(false);
+/**
+ * 本班有没有接入 ClassIsland 设备。
+ *
+ * 只用来禁用「只在 ClassIsland 上弹」——没有设备时选它等于把提醒静默丢掉；
+ * 注意**不能**顺手把「两端都弹」也禁掉：那样教室一旦选过"只在客户端"，没设备时就再也切不回来了。
+ */
+const classIslandConnected = ref(false);
+/** 本班 ClassIsland 设备的展示信息（设备名 / 最后上报），来自 /classes/:id/classisland-status */
+const classIslandStatus = ref<{
+  connected: boolean;
+  deviceName: string | null;
+  deviceCount: number;
+  lastSeenAt: string | null;
+  pluginVersion: string | null;
+  classIslandVersion: string | null;
+} | null>(null);
+
+const classIslandStatusText = computed(() => {
+  const status = classIslandStatus.value;
+  if (!status || !status.connected) return '未接入';
+  const seen = status.lastSeenAt ? `最后上报 ${formatDate(status.lastSeenAt, true)}` : '尚未上报过';
+  return `已接入 · ${status.deviceName ?? 'ClassIsland 设备'} · ${seen}`;
+});
+
+const channelOptions = computed(() =>
+  CLASSISLAND_NOTIFICATION_CHANNELS.map((value) => ({
+    value,
+    label: CLASSISLAND_NOTIFICATION_CHANNEL_LABELS[value],
+    disabled: value === 'classisland' && !classIslandConnected.value,
+  })),
+);
+
+async function applyChannel(value: ClassIslandNotificationChannel): Promise<void> {
+  channelSaving.value = true;
+  try {
+    const saved = await appStore.setNotificationChannel(auth.classId, value);
+    if (saved) ElMessage.success('提醒显示位置已更新');
+    else ElMessage.warning('已保存在本机，但同步到服务器失败（离线或权限不足），联网后请再点一次');
+  } finally {
+    channelSaving.value = false;
+  }
+}
+
+onMounted(async () => {
+  await appStore.loadNotificationChannel(auth.classId);
+  // 本班 ClassIsland 联动状态：没接设备就别让选「只在 ClassIsland 上弹」
+  if (auth.classId) {
+    const status = await classIslandStatusApi.get(auth.classId).catch(() => null);
+    classIslandStatus.value = status;
+    classIslandConnected.value = status?.connected === true;
+  }
+});
+</script>
+
+<template>
+  <div class="page">
+    <div class="page-header">
+      <div>
+        <h2 class="page-title">提醒</h2>
+        <p class="page-subtitle">老师发通知 / 叫人时，提醒弹在哪个端</p>
+      </div>
+    </div>
+
+    <el-card shadow="never">
+      <template #header><span>ClassIsland 联动</span></template>
+      <el-descriptions :column="1" border size="small" class="mb-12">
+        <el-descriptions-item label="联动状态">{{ classIslandStatusText }}</el-descriptions-item>
+        <el-descriptions-item label="插件 / ClassIsland">
+          {{ classIslandStatus?.pluginVersion ?? '—' }} /
+          {{ classIslandStatus?.classIslandVersion ?? '—' }}
+        </el-descriptions-item>
+      </el-descriptions>
+      <p class="text-muted">
+        <strong>通知模式</strong>
+        ：老师在班级小助手上发布通知 / 叫人时，提醒弹在灵动岛还是 ClassIsland，
+        由这台教室机器决定。选择会同步到班级，服务端据此决定是否推送到教室的 ClassIsland。
+      </p>
+      <el-radio-group
+        :model-value="appStore.notificationChannel"
+        :disabled="channelSaving"
+        class="channel-group"
+        @change="
+          (value: string | number | boolean | undefined) =>
+            applyChannel(value as ClassIslandNotificationChannel)
+        "
+      >
+        <el-radio v-for="item in channelOptions" :key="item.value" :value="item.value" :disabled="item.disabled">
+          {{ item.label }}
+        </el-radio>
+      </el-radio-group>
+      <p class="text-muted channel-hint">
+        {{ CLASSISLAND_NOTIFICATION_CHANNEL_HINTS[appStore.notificationChannel] }}
+        <template v-if="!classIslandConnected">
+          <br />
+          提示：本班还没有接入 ClassIsland 设备（在 Web 端「ClassIsland 联动」里接入后才能选"只在
+          ClassIsland 上弹"）。
+        </template>
+      </p>
+    </el-card>
+  </div>
+</template>
+
+<style scoped>
+.channel-group {
+  display: flex;
+  flex-direction: column;
+  align-items: flex-start;
+  gap: 6px;
+  margin-top: 10px;
+}
+
+.channel-hint {
+  margin-top: 10px;
+}
+
+.mb-12 {
+  margin-bottom: 12px;
+}
+</style>

packages/desktop-client/src/types/desktop.d.ts

@@ -7,6 +7,7 @@ import type {
   IslandAppearance,
   IslandNotification,
   IslandState,
+  UpdateInfo,
 } from '@classhelper/shared';
 
 /** 作业页展示偏好（看板 / 列表，看板外观） */
@@ -47,6 +48,24 @@ export interface DesktopStoredConfig {
    * 与班级记录（服务端据此决定要不要推给 ClassIsland）。
    */
   notificationChannel: ClassIslandNotificationChannel;
+  /**
+   * 是否已看过「初次启动引导」。
+   *
+   * 首次启动自动弹出一次（完成或跳过即记为看过并写入配置，之后不再自动弹出）；
+   * 登录页与设置页的「使用引导」入口可随时重看（重看不改变该值）。
+   */
+  onboardingDone: boolean;
+  /** 界面主题：light=浅色（默认）/ dark=深色（黑夜模式） */
+  theme: 'light' | 'dark';
+  /** 主侧边栏是否折叠成图标栏（可由顶栏汉堡按钮切换） */
+  sidebarCollapsed: boolean;
+  /**
+   * 用户点过「忽略此版本」的版本号（空串 = 没忽略过）。
+   *
+   * 启动时的自动检查会跳过这个版本，避免每次开客户端都弹一次同样的提示；
+   * 在「关于」页手动检查时仍会正常显示结果。
+   */
+  ignoredUpdateVersion: string;
 }
 
 export interface DesktopAppInfo {
@@ -56,6 +75,8 @@ export interface DesktopAppInfo {
   node: string;
   platform: string;
   userDataPath: string;
+  /** 主进程配置文件（config.json）的绝对路径（关于页「诊断信息」展示） */
+  configPath: string;
   /** 是否处于冒烟验证模式（由 ELECTRON_SMOKE_TEST=1 触发） */
   smokeTest: boolean;
 }
@@ -80,6 +101,20 @@ export interface IslandClassStatePayload {
 export interface DesktopBridge {
   /** 是否处于冒烟验证模式（由 ELECTRON_SMOKE_TEST=1 触发），同步可读 */
   smokeTest: boolean;
+  /**
+   * 冒烟凭据（仅冒烟模式下发，否则 `undefined`）。
+   *
+   * 为什么要从环境变量绕一圈：这些凭据被渲染进程的冒烟钩子用来"造测试数据"，
+   * 而渲染产物（`dist/renderer/assets/*.js`）会进 `app.asar` 发给每台学生机 —— asar 可直接解包，
+   * 把账号口令写在代码里等于随安装包一起发出去。凭据只由
+   * `scripts/smoke.mjs` / `scripts/verify-packaged.mjs` 通过环境变量提供（这两个脚本不进安装包）。
+   */
+  smokeCredentials?: {
+    username: string;
+    password: string;
+    classCode: string;
+    classPassword: string;
+  };
   getConfig(): Promise<DesktopStoredConfig>;
   /**
    * 局部更新配置。
@@ -94,6 +129,21 @@ export interface DesktopBridge {
   getAppInfo(): Promise<DesktopAppInfo>;
   openExternal(url: string): Promise<boolean>;
 
+  /* 更新检查 */
+  /**
+   * 检查 GitHub 上有没有新版本（主进程直连，不经后端）。
+   *
+   * @param force true = 绕过主进程缓存（对应「关于」页里用户主动点的那次检查）
+   *
+   * 返回的 `ok:false` 是**正常结果**（教室机器没有外网 / GitHub 限流 / 超时），不是异常，
+   * 界面按"暂时查不到更新"呈现即可。
+   */
+  checkForUpdates(force?: boolean): Promise<UpdateInfo>;
+  /** 忽略某个版本的更新提示（写入 config.json，启动自动检查不再提示它） */
+  ignoreUpdateVersion(version: string): Promise<void>;
+  /** 订阅"启动自动检查发现新版本"（仅新版本且未被忽略时触发一次） */
+  onUpdateAvailable(handler: (info: UpdateInfo) => void): void;
+
   /* 灵动岛 */
   /** 把一条通知投递到灵动岛（payload 必须是纯数据，说明见 saveConfig） */
   islandPush(payload: { notification: IslandNotification; context?: IslandPushContext }): void;
@@ -113,6 +163,8 @@ export interface DesktopBridge {
   islandGetAppearance(): Promise<IslandAppearance>;
   /** 订阅"灵动岛点了标为已读"事件，用于同步通知中心 */
   onIslandMarkRead(handler: (id: string) => void): void;
+  /** 订阅"灵动岛点了标为已读（多条通知的整批）"，一次把这一批都标记已读 */
+  onIslandMarkAllRead(handler: (ids: string[]) => void): void;
 }
 
 /** 灵动岛窗口自身的桥接（只暴露订阅状态与发送操作） */
@@ -121,7 +173,18 @@ export interface IslandRendererBridge {
   /** 订阅外观设置（CSS 变量实时生效） */
   onAppearance(handler: (appearance: IslandAppearance) => void): void;
   getAppearance(): Promise<IslandAppearance>;
-  sendAction(action: 'expand' | 'collapse' | 'dismiss' | 'mark-read' | 'open-app', id?: string): void;
+  sendAction(
+    action:
+      | 'expand'
+      | 'expand-list'
+      | 'collapse'
+      | 'dismiss'
+      | 'dismiss-all'
+      | 'mark-read'
+      | 'mark-all-read'
+      | 'open-app',
+    id?: string,
+  ): void;
   getState(): Promise<IslandState>;
   /**
    * 命中提示：指针在岛体上时应让固定大窗口接收鼠标（比主进程 60ms 轮询更快）。
@@ -131,6 +194,11 @@ export interface IslandRendererBridge {
   setInteractive(interactive: boolean): void;
   /** 上报岛体矩形（窗口内 CSS px）：主进程据此按光标位置兜底校正命中 */
   setHitRect(rect: { x: number; y: number; width: number; height: number } | null): void;
+  /**
+   * 上报"本机是触摸屏"（`navigator.maxTouchPoints > 0`）：主进程据此让窗口贴合岛体并始终接收
+   * 输入，否则触摸屏上手指永远点不到岛（触摸不产生 mousemove、也不移动系统光标）。
+   */
+  setTouchMode(enabled: boolean): void;
   /** 心跳：主进程据此发现"渲染进程卡死的幽灵窗口"（岛还在屏幕上但点不动）并重建窗口 */
   alive(): void;
 }
@@ -175,6 +243,14 @@ declare global {
       scheduleTimelineSelfTest(): Promise<{ ok: boolean; detail: string }>;
       /** 作业看板全屏自适应自检（切看板 → 打开全屏 → 量尺寸） */
       homeworkBoardSelfTest(): Promise<{ ok: boolean; detail: string }>;
+      /** 本机录入的作业不上灵动岛自检（内容指纹 + id 双重判定） */
+      islandHomeworkSuppressionCheck(): Promise<{ ok: boolean; detail: string }>;
+      /** 初次启动引导自检（首启自动出现 → 真实点击走完 → 完成状态写入配置） */
+      onboardingSelfTest(): Promise<{ ok: boolean; detail: string }>;
+      /** 主界面外观件自检（真实点击：主题切换 html.dark + 落盘、侧边栏折叠 + 落盘） */
+      layoutChromeSelfTest(): Promise<{ ok: boolean; detail: string }>;
+      /** 关于页自检（/settings/about 渲染 + getAppInfo 含 configPath） */
+      aboutPageSelfTest(): Promise<{ ok: boolean; detail: string }>;
       sessionCleanup(): Promise<{ ok: boolean; detail: string }>;
     };
   }

packages/server/.env.example

@@ -29,9 +29,10 @@ CORS_ORIGIN=*
 # bcrypt 加密强度
 BCRYPT_ROUNDS=10
 
-# 教师新增学生账号时未指定密码所使用的初始密码
+# 新建班级 / 新增教师未指定密码时使用的初始密码
-DEFAULT_STUDENT_PASSWORD=123456
+# （学生没有个人账号，因此没有 DEFAULT_STUDENT_PASSWORD —— 见 AGENTS.md §5 第 31 条）
-
+DEFAULT_CLASS_PASSWORD=123456
+DEFAULT_TEACHER_PASSWORD=123456
 # 学期配置：第 1 教学周的周一日期（YYYY-MM-DD），用于“当前周次”换算
 TERM_START_DATE=2026-02-23
 

packages/server/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@classhelper/server",
-  "version": "0.1.0",
+  "version": "1.1.2",
   "private": true,
   "description": "班级小助手后端服务：REST API + Socket.IO 实时推送 + Prisma 数据访问",
   "type": "module",
@@ -25,6 +25,7 @@
     "@classhelper/shared": "workspace:*",
     "@libsql/client": "^0.17.0",
     "@prisma/adapter-libsql": "7.10.0",
+    "@prisma/adapter-mariadb": "7.10.0",
     "@prisma/client": "7.10.0",
     "bcryptjs": "^3.0.3",
     "compression": "^1.8.2",
@@ -34,7 +35,9 @@
     "express-rate-limit": "^8.7.0",
     "helmet": "^8.3.0",
     "jsonwebtoken": "^9.0.3",
+    "prisma": "7.10.0",
     "socket.io": "^4.8.3",
+    "typescript": "~5.9.3",
     "xlsx": "0.18.5",
     "zod": "^4.6.2"
   },

packages/server/prisma/migrations/20260930120000_add_schedule_source/migration.sql

@@ -0,0 +1,7 @@
+-- 课表行来源：manual=手工建立（Web 端录入 / JSON 导入）/ classisland=ClassIsland 插件上报同步。
+--
+-- 用途：插件每次全量上报课表时，只清理「source=classisland 且本次未再上报」的行。
+-- 这样"老师在 ClassIsland 里删掉一节"能被真正同步下来（原先 merge 只 upsert，
+-- 服务端会永远留着那行幽灵课），同时老师在小助手这边手排的课不受影响。
+-- 存量数据默认按 manual 处理（保守：宁可留下也不误删）。
+ALTER TABLE "Schedule" ADD COLUMN "source" TEXT NOT NULL DEFAULT 'manual';

packages/server/prisma/schema.prisma

@@ -4,7 +4,8 @@
 // 1) 本 schema 使用 sqlite provider（本地 MVP / 离线开发）。
 //    字段全部使用 String / Int / Float / Boolean / DateTime 等跨库通用类型，
 //    不使用 Prisma enum 与 @db.* 原生类型，因此可平移到 MySQL。
-//    MySQL 版本见同目录 schema.mysql.prisma，切换步骤见 docs/mysql.md。
+//    MySQL 复用这一份 schema（就地改写下面的 provider，见 `pnpm db:switch:mysql`），
+//    没有第二份 schema.mysql.prisma；切换步骤见 docs/mysql.md。
 // 2) 角色与优先级用 String 存储（'ADMIN' | 'TEACHER' | 'STUDENT'、
 //    'LOW' | 'NORMAL' | 'HIGH' | 'URGENT'），在 API 层用 zod 校验，
 //    这样 SQLite / MySQL 行为完全一致。
@@ -146,6 +147,11 @@ model Schedule {
   weekEnd   Int      @default(20)
   /// 单双周：ALL=每周（默认）/ ODD=单周 / EVEN=双周（ClassIsland WeekCountDiv + WeekCountDivTotal 的映射）
   weekParity String @default("ALL")
+  /// 该行的来源：manual=手工建立（Web 端录入 / ClassIsland JSON 导入）
+  /// / classisland=插件上报同步得到。
+  /// 插件每次全量上报时只清理「classisland 来源且本次未再上报」的行（解决"老师在 ClassIsland
+  /// 里删掉一节、服务端却永远留着"的幽灵课），老师手排的课一律不删。
+  source     String @default("manual")
   createdAt  DateTime @default(now())
   updatedAt  DateTime @updatedAt
 

packages/server/prisma/seed.ts

@@ -86,10 +86,10 @@ async function main(): Promise<void> {
   const random = createRandom(20260901);
 
   // 同一角色共用密码，只需各哈希一次
-  const [adminHash, teacherHash, studentHash, classPasswordHash] = await Promise.all([
+  // 学生没有密码：个人学生账号已清理（2026-10-01），学生端统一用班级码 + 班级密码登录
+  const [adminHash, teacherHash, classPasswordHash] = await Promise.all([
     hashPassword('admin123'),
     hashPassword('teacher123'),
-    hashPassword('student123'),
     // 班级账号默认密码（学生端「班级登录」）
     hashPassword('123456'),
   ]);
@@ -142,7 +142,8 @@ async function main(): Promise<void> {
         name: STUDENT_NAMES[index] ?? `学生${index + 1}`,
         role: 'STUDENT',
         classId: targetClass.id,
-        passwordHash: studentHash,
+        // 空串占位：User.passwordHash 必填，但学生登录的 403 判定在密码校验之前，永远用不到
+        passwordHash: '',
       },
     });
     students.push(student);
@@ -376,10 +377,8 @@ async function main(): Promise<void> {
   console.log(`管理员    admin       / admin123      (${admin.name})`);
   console.log(`教师      teacher1    / teacher123    (${teacher1.name} · 高一(1)班、高二(3)班)`);
   console.log(`教师      teacher2    / teacher123    (${teacher2.name} · 高一(2)班、高二(3)班协作)`);
-  console.log('学生      student01   / student123    (高一(1)班)');
+  console.log('学生端（班级账号）：G101 / G102 / G203，密码 123456');
-  console.log('学生      student06   / student123    (高一(2)班)');
+  console.log('（学生只有名单、没有个人账号，成绩/未交/叫人按名单记录）');
-  console.log('学生      student11   / student123    (高二(3)班)');
-  console.log('学生      student15   / student123    (高二(3)班)');
   console.log('==========================================\n');
 }
 

packages/server/scripts/verify-classisland.mjs

@@ -105,6 +105,34 @@ async function loginWithCandidates(username, passwords) {
   return null;
 }
 
+/**
+ * 反复「拉取待提醒 → 逐条确认」，直到该设备视角下没有积压。
+ *
+ * 为什么验证脚本要做这件事：`GET /integrations/classisland/pending` 是
+ * 「本班全部未确认且未过期的提醒，按时间升序取前 20 条」。而 `verify:desktop` /
+ * `verify:web` 等冒烟会**真的往演示班发通知**（AGENTS.md §5 第 38 条），
+ * 那些条如果没被确认就会一直堆着 —— 攒够 20 条之后，本脚本刚发的提醒会被挤到窗口之外，
+ * 表现为「待提醒里找不到刚发的那条」，与代码对不对完全无关（2026-10-05 实测踩过：
+ * 库里积了 45 条历次冒烟残条，本脚本从 42/42 掉到 35/40）。
+ *
+ * 这里做的事情与真实插件重连后的行为完全一致（补弹积压并逐条确认），
+ * 因此不会掩盖任何产品侧问题。可见范围也一致：只处理 `deviceId` 为空的班级广播
+ * 与本设备自己的推送，别的设备的目标推送取不到、也确认不了。
+ */
+async function drainPending(deviceToken) {
+  let total = 0;
+  for (let round = 0; round < 20; round += 1) {
+    const pending = await api('/integrations/classisland/pending', { deviceToken });
+    const items = pending.payload?.data?.notifications ?? [];
+    if (items.length === 0) break;
+    for (const item of items) {
+      await api('/integrations/classisland/ack', { method: 'POST', deviceToken, body: { id: item.id } });
+      total += 1;
+    }
+  }
+  return total;
+}
+
 async function main() {
   console.log(`\n=== ClassIsland 联动验证（${BASE_URL}）===\n`);
 
@@ -182,7 +210,7 @@ async function main() {
 
   // ---------------------------------------------------------------- 3. 上报（状态 + 课表 + 节次）
   const reportBody = {
-    pluginVersion: '0.1.0.0',
+    pluginVersion: '1.1.2.0',
     classIslandVersion: '2.1.0.0',
     state: {
       inClass: true,
@@ -237,6 +265,13 @@ async function main() {
   );
 
   // ---------------------------------------------------------------- 4. 下发提醒
+  // 先确认掉本班的历史积压（历次冒烟留下的未确认提醒），否则 /pending 的前 20 条窗口
+  // 会被它们占满，下面「插件拉取到待提醒」等用例会拿不到刚发的这条（理由见 drainPending）
+  const drained = await drainPending(deviceToken);
+  if (drained > 0) {
+    console.log(`（已确认本班 ${drained} 条历史积压提醒，避免挤占待提醒窗口）\n`);
+  }
+
   const notify = await api('/integrations/classisland/notify', {
     method: 'POST',
     token: teacherToken,
@@ -466,6 +501,109 @@ async function main() {
     `上课点=${classPoints.length} 条目=${(plan?.entries ?? []).length}`,
   );
 
+  /* ---------------------------------------------------------------- 5.1 课表同步：幽灵行清理 + 机器码回填 */
+  // 老师在 Web 端手排的一节课（source=manual）：插件同步时**绝不能**删它
+  const courseList = await api(`/courses?classId=${target.id}`, { token: teacherToken });
+  const courseId = (courseList.payload?.data ?? [])[0]?.id;
+  const manualCreated = await api('/schedules', {
+    method: 'POST',
+    token: teacherToken,
+    body: {
+      classId: target.id,
+      courseId,
+      dayOfWeek: 7,
+      startTime: '21:00',
+      endTime: '21:45',
+      weekStart: 1,
+      weekEnd: 20,
+      weekParity: 'ALL',
+    },
+  });
+  const manualScheduleId = manualCreated.payload?.data?.id;
+  record(
+    '（准备）Web 端手排一节课（source=manual）',
+    manualCreated.status === 201 && Boolean(manualScheduleId),
+    `status=${manualCreated.status}`,
+  );
+
+  const entry = (startTime, endTime) => ({
+    dayOfWeek: 6,
+    startTime,
+    endTime,
+    subject: '语文',
+    weekParity: 'ALL',
+  });
+
+  /** 该班课表里"周六 19:xx"的行（插件上报写入的那些） */
+  const listSaturday = async () => {
+    const list = await api(`/schedules?classId=${target.id}`, { token: teacherToken });
+    return (list.payload?.data ?? []).filter(
+      (item) => item.dayOfWeek === 6 && item.startTime.startsWith('19:'),
+    );
+  };
+
+  // 第一次上报：两节（第二节随后会被"老师在 ClassIsland 里删掉"）
+  const ghostReport = await api('/integrations/classisland/report', {
+    method: 'POST',
+    deviceToken,
+    body: {
+      deviceKey: 'smoke-machine-01',
+      schedule: { mode: 'merge', entries: [entry('19:00', '19:45'), entry('19:50', '20:35')] },
+    },
+  });
+  record(
+    '插件上报两节课（其中一节随后会被删除）',
+    ghostReport.payload?.data?.scheduleApplied === true,
+    `status=${ghostReport.status}`,
+  );
+
+  const beforePrune = await listSaturday();
+  record('上报后两节都在库里', beforePrune.length === 2, `周六 19 点=${beforePrune.length} 节`);
+
+  // 第二次上报：只报第二节 → 第一节应当被清理。
+  // 原先 merge 只 upsert、从不删除，老师删掉的课会永远留在服务端（幽灵课），
+  // 学生端与 Web 端会一直显示一节实际上已经不上的课。
+  const pruneReport = await api('/integrations/classisland/report', {
+    method: 'POST',
+    deviceToken,
+    body: {
+      deviceKey: 'smoke-machine-01',
+      schedule: { mode: 'merge', entries: [entry('19:50', '20:35')] },
+    },
+  });
+  const afterPrune = await listSaturday();
+  record(
+    '插件侧删除的课被同步清理（不再留幽灵课）',
+    pruneReport.payload?.data?.scheduleApplied === true &&
+      afterPrune.length === 1 &&
+      afterPrune[0]?.startTime === '19:50',
+    `周六 19 点=${afterPrune.map((item) => item.startTime).join(',') || '空'}`,
+  );
+
+  // 只清理"插件同步出来的行"：老师手排的课必须活着
+  const scheduleList = await api(`/schedules?classId=${target.id}`, { token: teacherToken });
+  const manualAlive = (scheduleList.payload?.data ?? []).some((item) => item.id === manualScheduleId);
+  record('Web 端手排的课不被插件同步删除', manualAlive, `手排行 id=${manualScheduleId ?? '-'}`);
+
+  // 机器码回填：设备列表里不再是 pending-…
+  const deviceList = await api(`/integrations/devices?classId=${target.id}`, { token: teacherToken });
+  const backfilledKey =
+    (deviceList.payload?.data ?? []).find((item) => item.id === deviceId)?.deviceKey ?? '';
+  record(
+    '插件上报的机器码已回填到设备记录',
+    backfilledKey === 'smoke-machine-01',
+    `deviceKey=${backfilledKey}`,
+  );
+
+  // 清理：把手排的课与本次上报写进去的课都删掉，避免污染演示数据
+  if (manualScheduleId) {
+    await api(`/schedules/${manualScheduleId}`, { method: 'DELETE', token: teacherToken });
+  }
+  for (const row of await listSaturday()) {
+    await api(`/schedules/${row.id}`, { method: 'DELETE', token: teacherToken });
+  }
+  record('清理：本次验证写入的课表与手排课已删除', (await listSaturday()).length === 0, '周六 19 点已清空');
+
   // ---------------------------------------------------------------- 6. 停用设备
   await api(`/integrations/devices/${deviceId}`, {
     method: 'PATCH',

packages/server/scripts/verify-e2e.mjs

@@ -67,6 +67,17 @@ async function main() {
   }
   console.log(`  已挂载模块：${(health.payload?.data?.modules ?? []).join(', ')}\n`);
 
+  // 版本号不再硬编码（见 lib/version.ts）：健康检查必须暴露一个像样的版本，
+  // 更新检查要靠它判断"本机是不是旧版"；同时确认 update 模块已进注册表。
+  const healthData = health.payload?.data ?? {};
+  record(
+    '健康检查暴露版本号与模块清单（含 update 模块）',
+    typeof healthData.version === 'string' &&
+      /^\d+\.\d+\.\d+/.test(healthData.version) &&
+      (healthData.modules ?? []).includes('update'),
+    `版本=${healthData.version} 模块数=${(healthData.modules ?? []).length}`,
+  );
+
   // ---------------------------------------------------------------- 1. 登录
   const teacherLogin = await api('/auth/login', {
     method: 'POST',
@@ -676,12 +687,13 @@ async function main() {
       `共 ${studentListAfter.payload?.data?.length ?? 0} 人`,
     );
 
-    const resetResult = await api(`/students/${addedStudentId}/reset-password`, {
+    // 学生没有密码相关接口（个人学生账号已清理，重置密码入口已下线）：这里改为断言接口确实不存在
+    const resetGone = await api(`/students/${addedStudentId}/reset-password`, {
       method: 'POST',
       token: adminToken,
       body: {},
     });
-    record('重置学生密码', resetResult.status === 200, `status=${resetResult.status}`);
+    record('学生重置密码接口已下线（404）', resetGone.status === 404, `status=${resetGone.status}`);
 
     const renamed = await api(`/students/${addedStudentId}`, {
       method: 'PATCH',
@@ -1597,11 +1609,8 @@ async function main() {
 
   // 8.4 学生名单导入（仅管理员）+ 数据清理
   const importedUsername = `imp${Date.now().toString(36).slice(-6)}`;
-  const studentsCsv = [
+  // 学生导入模板已无"初始密码"列（学生没有账号属性）
-    '用户名,姓名,初始密码',
+  const studentsCsv = ['用户名,姓名', `${importedUsername},导入测试生`, 'bad user,非法用户名'].join(NL);
-    `${importedUsername},导入测试生,imp123456`,
-    'bad user,非法用户名,imp123456',
-  ].join(NL);
   const studentsCommit = await api('/imports/table/commit', {
     method: 'POST',
     token: adminToken,
@@ -1610,7 +1619,7 @@ async function main() {
       classId,
       fileName: 'students.csv',
       contentBase64: Buffer.from(`\ufeff${studentsCsv}${NL}`, 'utf8').toString('base64'),
-      mapping: { username: '用户名', name: '姓名', password: '初始密码' },
+      mapping: { username: '用户名', name: '姓名' },
       mode: 'append',
     },
   });
@@ -1740,7 +1749,7 @@ async function main() {
       classId,
       fileName: 'students.csv',
       contentBase64: Buffer.from(`\ufeff${studentsCsv}${NL}`, 'utf8').toString('base64'),
-      mapping: { username: '用户名', name: '姓名', password: '初始密码' },
+      mapping: { username: '用户名', name: '姓名' },
       mode: 'append',
     },
   });
@@ -2228,6 +2237,68 @@ async function main() {
     `班主任账号=${deleteHeadTeacher.status}（${deleteHeadTeacher.payload?.message ?? ''}） 冒烟账号=${deleteSmokeTeacher.status}`,
   );
 
+  // 级联删除护栏：`Homework.createdBy` / `Notification.createdBy` 都是 ON DELETE CASCADE，
+  // 因此"已不在任何班级、名下无课程，但发布过内容"的账号也必须被拒 ——
+  // 否则"班主任转给别人 → 解除协作 → 删除账号"会静默清掉他在各班发过的作业与通知。
+  const cascadeTeacherUsername = `smoke_cas_${Date.now().toString().slice(-8)}`;
+  const cascadeTeacher = await api('/teachers', {
+    method: 'POST',
+    token: adminToken,
+    body: { username: cascadeTeacherUsername, name: '冒烟级联教师', password: 'cascade123456' },
+  });
+  const cascadeTeacherId = cascadeTeacher.payload?.data?.id;
+  const cascadeTeacherLogin = await api('/auth/login', {
+    method: 'POST',
+    body: { username: cascadeTeacherUsername, password: 'cascade123456' },
+  });
+  const cascadeTeacherToken = cascadeTeacherLogin.payload?.data?.token;
+
+  // 1) 先让他成为该班科任（这样才有发布权限），发一条通知
+  await api(`/classes/${classId}/teachers`, {
+    method: 'POST',
+    token: adminToken,
+    body: { teacherId: cascadeTeacherId },
+  });
+  const cascadeNotification = await api('/notifications', {
+    method: 'POST',
+    token: cascadeTeacherToken,
+    body: { classId, title: '级联删除回归', content: '用于验证删除教师不会连带删除已发布内容' },
+  });
+  const cascadeNotificationId = cascadeNotification.payload?.data?.id;
+  // 2) 解除班级分配：此时他"不在任何班级、名下无课程"，但发布过内容
+  await api(`/classes/${classId}/teachers/${cascadeTeacherId}`, {
+    method: 'DELETE',
+    token: adminToken,
+  });
+  // 3) 删除账号应当被拒（409），且那条通知必须还在
+  const cascadeDelete = await api(`/teachers/${cascadeTeacherId}`, {
+    method: 'DELETE',
+    token: adminToken,
+  });
+  const afterCascadeList = await api(`/notifications?classId=${classId}`, { token: adminToken });
+  const notificationAlive = (afterCascadeList.payload?.data ?? []).some(
+    (item) => item.id === cascadeNotificationId,
+  );
+  record(
+    '删除教师护栏覆盖"发布过作业/通知"的账号（不再级联删除内容）',
+    cascadeDelete.status === 409 && notificationAlive,
+    `删除=${cascadeDelete.status}（${cascadeDelete.payload?.message ?? ''}） 通知仍在=${notificationAlive}`,
+  );
+
+  // 清理：内容删掉后账号即可删除
+  if (cascadeNotificationId) {
+    await api(`/notifications/${cascadeNotificationId}`, { method: 'DELETE', token: adminToken });
+  }
+  const cascadeDeleteAfter = await api(`/teachers/${cascadeTeacherId}`, {
+    method: 'DELETE',
+    token: adminToken,
+  });
+  record(
+    '清理：内容删除后该教师账号可删除',
+    cascadeDeleteAfter.status === 200,
+    `status=${cascadeDeleteAfter.status}`,
+  );
+
   // 创建班级仅管理员 + 设置/更改班主任
   const teacherCreateClass = await api('/classes', {
     method: 'POST',
@@ -2279,6 +2350,236 @@ async function main() {
     `教师改=${teacherChangeHead.status} 管理员改=${changedHead.status} 详情班主任=${changedDetail.payload?.data?.teacher?.name ?? '-'}`,
   );
 
+  // 清理：删除实时推送用例造的通知/作业、冒烟班级、临时权限校验班级与冒烟教师账号
+  // ---------------------------------------------------------------- 数据库管理（仅管理员）
+  // 覆盖：状态 / 越权 403 / 连接测试 / 备份→导入导出→恢复 roundtrip / 定时配置校验 / 切换校验分支。
+  // 注意：**不真跑切换**（会改写 .env 与 schema.prisma），只验证拒绝分支；真实切换需人工复验。
+  const dbStatus = await api('/database/status', { token: adminToken });
+  const dbStatusData = dbStatus.payload?.data ?? {};
+  record(
+    '数据库状态（管理员）：已连接且返回 14 张表行数',
+    dbStatus.status === 200 &&
+      dbStatusData.connected === true &&
+      Array.isArray(dbStatusData.tables) &&
+      dbStatusData.tables.length === 14 &&
+      dbStatusData.tables.every((item) => item.count >= 0),
+    `provider=${dbStatusData.provider} 延迟=${dbStatusData.latencyMs}ms 版本=${dbStatusData.version} 表=${
+      (dbStatusData.tables ?? []).length
+    }`,
+  );
+
+  const dbStatusTeacher = await api('/database/status', { token: teacherToken });
+  const dbBackupTeacher = await api('/database/backups', { method: 'POST', token: teacherToken });
+  const dbScheduleTeacher = await api('/database/backup-schedule', {
+    method: 'PUT',
+    token: teacherToken,
+    body: { enabled: true, intervalHours: 24, keepCount: 7 },
+  });
+  const dbSwitchTeacher = await api('/database/switch', {
+    method: 'POST',
+    token: teacherToken,
+    body: { provider: 'sqlite', url: 'file:./data/teacher-forbidden.db' },
+  });
+  record(
+    '数据库管理越权（教师全部 403）',
+    dbStatusTeacher.status === 403 &&
+      dbBackupTeacher.status === 403 &&
+      dbScheduleTeacher.status === 403 &&
+      dbSwitchTeacher.status === 403,
+    `status=${dbStatusTeacher.status} 备份=${dbBackupTeacher.status} 定时=${dbScheduleTeacher.status} 切换=${dbSwitchTeacher.status}`,
+  );
+
+  // 连接测试：当前库必须可达（SQLite 用相对路径，MySQL 用一个不可达地址测失败分支）
+  let testOkResult;
+  let testOkName;
+  if (dbStatusData.provider === 'sqlite') {
+    testOkResult = await api('/database/test-connection', {
+      method: 'POST',
+      token: adminToken,
+      body: { provider: 'sqlite', url: 'file:./prisma/dev.db' },
+    });
+    testOkName = '连接测试（当前 SQLite 库可达）';
+  } else {
+    testOkResult = await api('/database/test-connection', {
+      method: 'POST',
+      token: adminToken,
+      body: { provider: 'mysql', url: 'mysql://root:wrong-password@127.0.0.1:1/none' },
+    });
+    testOkName = '连接测试（不可达 MySQL 返回 ok=false）';
+  }
+  record(
+    testOkName,
+    testOkResult.status === 200 &&
+      (dbStatusData.provider === 'sqlite'
+        ? testOkResult.payload?.data?.ok === true
+        : testOkResult.payload?.data?.ok === false),
+    `ok=${testOkResult.payload?.data?.ok} 版本=${testOkResult.payload?.data?.version} 详情=${testOkResult.payload?.data?.error ?? testOkResult.payload?.data?.note ?? '-'}`,
+  );
+
+  const dbTestRedis = await api('/database/test-connection', {
+    method: 'POST',
+    token: adminToken,
+    body: { provider: 'redis', url: 'redis://127.0.0.1:6379' },
+  });
+  record(
+    'Redis 作为主库被拒绝（schema 层面 422，产品口径：主库仅 SQLite/MySQL）',
+    dbTestRedis.status === 422,
+    `status=${dbTestRedis.status}`,
+  );
+
+  const badConnection = await api('/database/test-connection', {
+    method: 'POST',
+    token: adminToken,
+    body: { provider: 'mysql', url: 'mysql://root:wrong@127.0.0.1:1/none' },
+  });
+  record(
+    '连接测试（不可达 MySQL → ok=false 且不抛 500）',
+    badConnection.status === 200 && badConnection.payload?.data?.ok === false,
+    `ok=${badConnection.payload?.data?.ok} error=${(badConnection.payload?.data?.error ?? '').slice(0, 60)}`,
+  );
+
+  // 切换校验分支：同库拒绝（真实切换不在此跑，避免改写 .env）
+  const switchSame =
+    dbStatusData.provider === 'sqlite'
+      ? await api('/database/switch', {
+          method: 'POST',
+          token: adminToken,
+          body: { provider: 'sqlite', url: dbStatusData.databaseUrlMasked },
+        })
+      : { status: 0, payload: null };
+  const switchInvalid = await api('/database/switch', {
+    method: 'POST',
+    token: adminToken,
+    body: { provider: 'redis', url: 'redis://127.0.0.1:6379' },
+  });
+  record(
+    '一键切换校验分支（同库 400 / 非法 provider 422，不真跑切换）',
+    (dbStatusData.provider === 'sqlite' ? switchSame.status === 400 : true) && switchInvalid.status === 422,
+    `同库=${switchSame.status}（${dbStatusData.provider === 'sqlite' ? 'sqlite 当前库' : 'mysql 跳过'}） redis=${switchInvalid.status}`,
+  );
+
+  // 备份 → 导出快照 → 造数据 → 快照导入 → 造数据 → 从备份恢复（三个恢复路径全验）
+  const dbBackup = await api('/database/backups', { method: 'POST', token: adminToken });
+  const backupName = dbBackup.payload?.data?.name ?? '';
+  record(
+    '手动备份（201，文件名符合约定格式）',
+    dbBackup.status === 201 && /^backup-manual-\d{8}-\d{6}\.json\.gz$/.test(backupName),
+    `name=${backupName} size=${dbBackup.payload?.data?.sizeBytes ?? '-'}`,
+  );
+
+  const dbExport = await fetch(`${BASE_URL}/api/database/export`, {
+    headers: { Authorization: `Bearer ${adminToken}` },
+  });
+  const snapshotJson = dbExport.status === 200 ? await dbExport.text() : '';
+  let snapshotParsed = null;
+  try {
+    snapshotParsed = JSON.parse(snapshotJson);
+  } catch {
+    snapshotParsed = null;
+  }
+  record(
+    '导出快照（JSON 格式正确、14 张表、用户数 > 0）',
+    dbExport.status === 200 &&
+      snapshotParsed?.format === 'classhelper-snapshot' &&
+      Object.keys(snapshotParsed?.data ?? {}).length === 14 &&
+      (snapshotParsed?.counts?.User ?? 0) > 0,
+    `status=${dbExport.status} 格式=${snapshotParsed?.format ?? '-'} 用户=${snapshotParsed?.counts?.User ?? '-'}`,
+  );
+
+  // 造一条临时通知 → 快照导入（应被清掉）→ 再造一条 → 从备份恢复（也应被清掉）
+  const dbRoundtripNotice = await api('/notifications', {
+    method: 'POST',
+    token: adminToken,
+    body: { classId, title: '数据库roundtrip自检', content: '导入/恢复后应消失' },
+  });
+  const dbRoundtripNoticeId = dbRoundtripNotice.payload?.data?.id;
+  const dbImport = await api('/database/import', {
+    method: 'POST',
+    token: adminToken,
+    body: { data: Buffer.from(snapshotJson, 'utf8').toString('base64') },
+  });
+  const afterImport = await api(`/notifications?classId=${classId}`, { token: adminToken });
+  const roundtripNoticeGone = !(afterImport.payload?.data ?? []).some(
+    (item) => item.id === dbRoundtripNoticeId,
+  );
+  record(
+    '快照导入（整库覆盖：导入后临时通知消失）',
+    dbImport.status === 200 && roundtripNoticeGone,
+    `导入=${dbImport.status} 通知已清除=${roundtripNoticeGone} 行数=${JSON.stringify(dbImport.payload?.data?.counts ?? {}).slice(0, 80)}`,
+  );
+
+  const dbRoundtripNotice2 = await api('/notifications', {
+    method: 'POST',
+    token: adminToken,
+    body: { classId, title: '数据库roundtrip自检2', content: '备份恢复后应消失' },
+  });
+  const dbRoundtripNotice2Id = dbRoundtripNotice2.payload?.data?.id;
+  const dbRestore = await api(`/database/backups/${backupName}/restore`, {
+    method: 'POST',
+    token: adminToken,
+  });
+  const afterRestore = await api(`/notifications?classId=${classId}`, { token: adminToken });
+  const restoreNoticeGone = !(afterRestore.payload?.data ?? []).some(
+    (item) => item.id === dbRoundtripNotice2Id,
+  );
+  record(
+    '从备份恢复（整库覆盖：恢复后临时通知消失）',
+    dbRestore.status === 200 && restoreNoticeGone,
+    `恢复=${dbRestore.status} 通知已清除=${restoreNoticeGone}`,
+  );
+  if (dbRoundtripNoticeId) {
+    await api(`/notifications/${dbRoundtripNoticeId}`, { method: 'DELETE', token: adminToken });
+  }
+  if (dbRoundtripNotice2Id) {
+    await api(`/notifications/${dbRoundtripNotice2Id}`, { method: 'DELETE', token: adminToken });
+  }
+
+  const dbBackupList = await api('/database/backups', { token: adminToken });
+  const dbBackupDelete = await api(`/database/backups/${backupName}`, {
+    method: 'DELETE',
+    token: adminToken,
+  });
+  const dbBackupListAfter = await api('/database/backups', { token: adminToken });
+  record(
+    '备份列表与删除（创建后可见，删除后消失）',
+    dbBackupList.status === 200 &&
+      (dbBackupList.payload?.data ?? []).some((item) => item.name === backupName) &&
+      dbBackupDelete.status === 200 &&
+      !(dbBackupListAfter.payload?.data ?? []).some((item) => item.name === backupName),
+    `删除前=${(dbBackupList.payload?.data ?? []).length} 删除后=${(dbBackupListAfter.payload?.data ?? []).length}`,
+  );
+
+  const dbScheduleInvalid = await api('/database/backup-schedule', {
+    method: 'PUT',
+    token: adminToken,
+    body: { enabled: true, intervalHours: 0, keepCount: 7 },
+  });
+  const dbScheduleSave = await api('/database/backup-schedule', {
+    method: 'PUT',
+    token: adminToken,
+    body: { enabled: false, intervalHours: 24, keepCount: 7 },
+  });
+  record(
+    '定时备份配置（非法间隔 422 / 合法保存并回读）',
+    dbScheduleInvalid.status === 422 &&
+      dbScheduleSave.status === 200 &&
+      dbScheduleSave.payload?.data?.enabled === false &&
+      dbScheduleSave.payload?.data?.intervalHours === 24,
+    `非法=${dbScheduleInvalid.status} 保存=${dbScheduleSave.status} enabled=${dbScheduleSave.payload?.data?.enabled}`,
+  );
+
+  if (dbStatusData.provider === 'sqlite') {
+    const sqliteFile = await fetch(`${BASE_URL}/api/database/sqlite-file`, {
+      headers: { Authorization: `Bearer ${adminToken}` },
+    });
+    const sqliteBytes = sqliteFile.status === 200 ? (await sqliteFile.arrayBuffer()).byteLength : 0;
+    record(
+      'SQLite 数据文件下载（快捷导出 .db 文件）',
+      sqliteFile.status === 200 && sqliteBytes > 0,
+      `status=${sqliteFile.status} bytes=${sqliteBytes}`,
+    );
+  }
+
   // 清理：删除实时推送用例造的通知/作业、冒烟班级、临时权限校验班级与冒烟教师账号
   const realtimeNoticeId = createdNotification.payload?.data?.id;
   if (realtimeNoticeId) {
@@ -2328,6 +2629,42 @@ async function main() {
     } 残留班级=${leftoverClasses.map((item) => item.name).join(',') || '无'}`,
   );
 
+  // ---------------------------------------------------------------- 更新检查
+  // 验的是"结构完整 + 权限 + 可降级"，**刻意不断言"一定有新版本"** ——
+  // 那会把用例绑死在外网可达上，而学校机房/内网服务器查不到 GitHub 是常态
+  // （`ok:false` 是设计内的结果，不是失败）。真实联网取值在交付前人工验一次。
+  const updateAnon = await api('/update/check');
+  record('更新检查未登录 401', updateAnon.status === 401, `status=${updateAnon.status}`);
+
+  const updateRes = await api('/update/check', { token: adminToken });
+  const updateData = updateRes.payload?.data ?? {};
+  const isVersionLike = (value) => typeof value === 'string' && /^\d/.test(value);
+  record(
+    '更新检查（管理员）：结构完整，本机版本取自 package.json',
+    updateRes.status === 200 &&
+      isVersionLike(updateData.currentVersion) &&
+      typeof updateData.ok === 'boolean' &&
+      typeof updateData.hasUpdate === 'boolean' &&
+      (updateData.ok
+        ? isVersionLike(updateData.latestVersion) &&
+          Array.isArray(updateData.assets) &&
+          /^https:\/\//.test(updateData.releaseUrl ?? '') &&
+          updateData.error === null
+        : typeof updateData.error === 'string' && updateData.error.length > 0),
+    `ok=${updateData.ok} 本机=${updateData.currentVersion} 最新=${updateData.latestVersion ?? '-'} ` +
+      `有新版本=${updateData.hasUpdate} 附件=${(updateData.assets ?? []).length}` +
+      `${updateData.error ? ` 原因=${updateData.error}` : ''}`,
+  );
+
+  // force 只对管理员生效：教师带 force=1 也必须命中缓存（否则任意登录用户都能刷爆匿名限流）
+  const updateTeacherForced = await api('/update/check?force=1', { token: teacherToken });
+  record(
+    '更新检查：教师可查（公开信息），但 force 仅管理员生效',
+    updateTeacherForced.status === 200 &&
+      updateTeacherForced.payload?.data?.checkedAt === updateData.checkedAt,
+    `status=${updateTeacherForced.status} 命中缓存=${updateTeacherForced.payload?.data?.checkedAt === updateData.checkedAt}`,
+  );
+
   socket.close();
 
   // ---------------------------------------------------------------- 汇总

packages/server/src/app.ts

@@ -6,6 +6,7 @@ import { env } from './config/env.js';
 import { pingDatabase } from './lib/db.js';
 import { sendOk } from './lib/http.js';
 import { logger } from './lib/logger.js';
+import { APP_VERSION } from './lib/version.js';
 import { mountWebAdmin, resolveWebDistDir } from './lib/web-static.js';
 import { errorHandler, notFoundHandler } from './middleware/error.js';
 import { apiRateLimiter, loginRateLimiter, requestLogger, securityHeaders } from './middleware/security.js';
@@ -37,7 +38,8 @@ async function healthHandler(_req: Request, res: Response): Promise<void> {
     res,
     {
       status: 'ok',
-      version: '0.1.0',
+      // 版本号取自 package.json（见 lib/version.ts）：更新检查要拿它跟 GitHub 上的 Release 比
+      version: APP_VERSION,
       env: env.nodeEnv,
       uptimeSeconds: Math.round(process.uptime()),
       database: {
@@ -68,7 +70,7 @@ function createRootHandler(webDistDir: string | null) {
         res,
         {
           service: 'class-helper-server',
-          version: '0.1.0',
+          version: APP_VERSION,
           environment: env.nodeEnv,
           apiPrefix: API_PREFIX,
           socket: '/socket.io',
@@ -115,7 +117,7 @@ function renderLandingPage(webAdminServed: boolean): string {
   <body>
     <div class="card">
       <h1>班级小助手 · 后端服务 <span class="ok">running</span></h1>
-      <p class="sub">版本 0.1.0 · 运行环境 ${env.nodeEnv} · 数据库 ${env.databaseProvider}</p>
+      <p class="sub">版本 ${APP_VERSION} · 运行环境 ${env.nodeEnv} · 数据库 ${env.databaseProvider}</p>
       <p class="sub">
         健康检查 <a href="${API_PREFIX}/health">${API_PREFIX}/health</a> ·
         存活 /healthz · 就绪 /readyz
@@ -145,8 +147,15 @@ export function createApp(): Express {
   app.use(securityHeaders());
   app.use(compression());
   app.use(cors({ origin: env.corsOrigins, credentials: true }));
-  app.use(express.json({ limit: '2mb' }));
+  /**
-  app.use(express.urlencoded({ extended: true }));
+   * 请求体上限：表格导入是把文件以 **base64** 放进 JSON 的，base64 约为原文件的 4/3，
+   * 再算上 JSON 包装，8MB 的表格文件约需 11MB 请求体。
+   * 这里必须留够余量，否则「导入模板写的 8MB 上限」永远到不了（文件到 1.5MB 就被 body-parser 拦掉），
+   * 而且用户看到的是一句 500「服务器内部错误：request entity too large」——
+   * 与 `table-import.service.ts` 的 MAX_IMPORT_BYTES(8MB) 校验完全对不上。
+   */
+  app.use(express.json({ limit: '12mb' }));
+  app.use(express.urlencoded({ extended: true, limit: '1mb' }));
   app.use(requestLogger());
 
   // 探针（不参与限流）
@@ -173,7 +182,10 @@ export function createApp(): Express {
 
   // 限流：先挂通用限流，再挂更严格的登录限流（后挂者决定响应头里的策略，便于观察暴力破解防护）
   app.use(API_PREFIX, apiRateLimiter());
-  app.use(`${API_PREFIX}/auth/login`, loginRateLimiter());
+  // 登录限流必须覆盖**两个**登录入口：`/auth/login`（教师/管理员）与 `/auth/class-login`（学生端
+  // 班级账号）。后者的密码默认就是 123456，漏掉它等于形同虚设 —— 这里用数组形式挂载，
+  // 两个路径共享同一个计数器（同一 IP 对两种登录的失败次数合并计算）。
+  app.use([`${API_PREFIX}/auth/login`, `${API_PREFIX}/auth/class-login`], loginRateLimiter());
 
   // 模块化装配：注册表里的每个模块挂载到 /api<basePath>
   for (const module of apiModules) {