patch

Reviewed-on: #1

.dockerignore

@@ -0,0 +1,21 @@
+.git
+.agents
+.codex
+node_modules
+tests
+
+.env
+.env.*
+!.env.example
+!.env.docker.example
+
+data/*
+!data/.gitkeep
+
+*.log
+npm-debug.log*
+Dockerfile*
+compose*.yml
+compose*.yaml
+README.md
+LICENSE

.env.docker.example

@@ -0,0 +1,22 @@
+# 首次启动前请复制为 .env.docker，并替换下面两个值。
+# TOTP_ENCRYPTION_KEY 必须至少 32 个字符，部署后不得随意更换。
+TOTP_ENCRYPTION_KEY=replace-with-a-random-secret-of-at-least-32-characters
+
+INITIAL_ADMIN_USERNAME=admin
+INITIAL_ADMIN_PASSWORD=replace-with-a-strong-admin-password
+INITIAL_ADMIN_DISPLAY_NAME=系统管理员
+
+# 下列公开站点信息可按需修改。
+PUBLIC_SITE_NAME=海州市教育考试中心
+PUBLIC_SITE_CODE=HZ-EDU-032
+PUBLIC_SITE_PHONE=0518-8602 3158
+PUBLIC_SITE_ADDRESS=江苏省连云港市海州区文教路 18 号
+PUBLIC_SITE_EMAIL=
+PUBLIC_SITE_HERO_EYEBROW=HAIZHOU EXAMINATION SERVICE
+PUBLIC_SITE_HERO_TITLE=一个报名号，
+PUBLIC_SITE_HERO_HIGHLIGHT=贯穿每一次考试。
+PUBLIC_SITE_HERO_DESCRIPTION=使用学校下发的报名号登录，完成密码更新和个人信息核验后，即可办理所有考试事项。
+PUBLIC_SITE_FOOTER_NOTICE=本平台展示数据仅用于系统演示
+
+# 可选 Redis 缓存；容器外的 Redis 不应填写 127.0.0.1。
+# REDIS_URL=redis://redis-host:6379/0

.gitea/workflows/docker-publish.yml

@@ -0,0 +1,103 @@
+name: Build and publish Docker images
+
+on:
+  push:
+    tags:
+      - "v*"
+  workflow_dispatch:
+
+jobs:
+  publish:
+    name: Test, build and publish
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      releases: write
+
+    steps:
+      - name: Check out repository
+        uses: https://github.com/actions/checkout@v4
+
+      - name: Set up Node.js
+        uses: https://github.com/actions/setup-node@v4
+        with:
+          node-version: "22"
+
+      - name: Install dependencies
+        run: npm ci
+
+      - name: Run tests
+        run: npm test
+
+      - name: Set up QEMU
+        uses: https://github.com/docker/setup-qemu-action@v3
+
+      - name: Set up Docker Buildx
+        uses: https://github.com/docker/setup-buildx-action@v3
+
+      - name: Log in to Docker Hub
+        uses: https://github.com/docker/login-action@v3
+        with:
+          registry: docker.io
+          username: ${{ secrets.DOCKERHUB_USERNAME }}
+          password: ${{ secrets.DOCKERHUB_TOKEN }}
+
+      - name: Log in to Gitea Container Registry
+        uses: https://github.com/docker/login-action@v3
+        with:
+          registry: git.biss.click
+          username: ${{ vars.REGISTRY_USERNAME }}
+          password: ${{ secrets.REGISTRY_TOKEN }}
+
+      - name: Generate image tags and labels
+        id: metadata
+        uses: https://github.com/docker/metadata-action@v5
+        with:
+          images: |
+            docker.io/${{ vars.DOCKERHUB_IMAGE }}
+            git.biss.click/biss/exam-information-system
+          flavor: latest=false
+          tags: |
+            type=raw,value=latest,enable=${{ gitea.ref == 'refs/heads/master' }}
+            type=sha,format=short,prefix=sha-
+            type=semver,pattern={{version}}
+            type=semver,pattern={{major}}.{{minor}}
+
+      - name: Build and push image
+        uses: https://github.com/docker/build-push-action@v6
+        with:
+          context: .
+          file: ./Dockerfile
+          platforms: linux/amd64,linux/arm64
+          push: true
+          tags: ${{ steps.metadata.outputs.tags }}
+          labels: ${{ steps.metadata.outputs.labels }}
+          cache-from: type=registry,ref=docker.io/${{ vars.DOCKERHUB_IMAGE }}:buildcache
+          cache-to: type=registry,ref=docker.io/${{ vars.DOCKERHUB_IMAGE }}:buildcache,mode=max
+
+      - name: Detect release type
+        id: release_type
+        if: gitea.ref_type == 'tag'
+        shell: bash
+        run: |
+          case "$GITHUB_REF_NAME" in
+            *-*) prerelease=true ;;
+            *) prerelease=false ;;
+          esac
+          echo "prerelease=$prerelease" >> "$GITHUB_OUTPUT"
+
+      - name: Create Gitea release
+        if: gitea.ref_type == 'tag'
+        uses: https://gitea.com/actions/gitea-release-action@v1
+        with:
+          token: ${{ secrets.GITEA_TOKEN }}
+          tag_name: ${{ gitea.ref_name }}
+          name: ${{ gitea.ref_name }}
+          prerelease: ${{ steps.release_type.outputs.prerelease }}
+          body: |
+            Docker 镜像已发布：
+
+            ```text
+            docker pull docker.io/${{ vars.DOCKERHUB_IMAGE }}:${{ steps.metadata.outputs.version }}
+            docker pull git.biss.click/biss/exam-information-system:${{ steps.metadata.outputs.version }}
+            ```

.gitignore

@@ -5,4 +5,5 @@ data/*.sqlite-shm
 data/*.sqlite-wal
 node_modules/
 .env
+.env.docker
 *.log

Dockerfile

@@ -0,0 +1,25 @@
+FROM node:22-bookworm-slim
+
+WORKDIR /app
+
+COPY package.json package-lock.json ./
+RUN npm ci --omit=dev --ignore-scripts \
+    && npm cache clean --force
+
+COPY --chown=node:node . .
+
+ENV NODE_ENV=production \
+    HOST=0.0.0.0 \
+    PORT=4173 \
+    DATABASE_CLIENT=sqlite \
+    SQLITE_PATH=/app/data/exam.sqlite
+
+EXPOSE 4173
+VOLUME ["/app/data"]
+
+USER node
+
+HEALTHCHECK --interval=30s --timeout=5s --start-period=20s --retries=3 \
+  CMD ["node", "-e", "fetch('http://127.0.0.1:' + (process.env.PORT || '4173') + '/api/public/home').then(response => { if (!response.ok) process.exit(1); }).catch(() => process.exit(1));"]
+
+CMD ["node", "server.mjs"]

README.md

@@ -94,7 +94,72 @@ npm start
 
 本地开发无需额外配置，首次运行会自动创建 `data/exam.sqlite` 和完整关系型数据库结构，但不会导入学校、考生、考试或报名测试数据。首次建库只写入系统基础配置和一个超级管理员；账号、密码和显示名可通过 `INITIAL_ADMIN_USERNAME`、`INITIAL_ADMIN_PASSWORD`、`INITIAL_ADMIN_DISPLAY_NAME` 设置。当前数据库结构版本为 v17；v16 数据库会自动增加 TOTP 字段，低于 v15 的开发库会提示重建。
 
-需要清空并重建空业务库时运行 `npm run reset-db`。需要测试数据时再手动运行 `npm run seed-test-data`；导入脚本会读取项目根目录的 `.env`，并根据 `DATABASE_CLIENT` 选择 SQLite 或 MySQL。它会生成 4 所学校、360 名批量考生及 360 条不同状态的报名数据，并明确不生成考场编排计划和准考证。省市区县下拉数据位于 `src/data/china-regions.mjs`，当前版本为国家地名信息库截至 2025-12-31 的三级快照，并补入和康县（653228）与和安县（653229）；从新版 CSV 更新时可运行 `node scripts/build-regions.mjs <CSV路径> src/data/china-regions.mjs`。
+### Docker
+
+项目根目录包含生产镜像和 Docker Compose 配置。默认使用 SQLite，数据库保存在命名卷 `exam-information-data` 中，因此重建容器不会丢失数据。
+
+先创建容器环境文件，并将其中的 TOTP 主密钥和初始管理员密码替换为安全随机值：
+
+```powershell
+Copy-Item .env.docker.example .env.docker
+```
+
+然后构建并启动：
+
+```powershell
+docker compose up --build --detach
+```
+
+启动完成后访问 <http://127.0.0.1:4173>。查看状态和日志可运行：
+
+```powershell
+docker compose ps
+docker compose logs --follow app
+```
+
+停止服务使用 `docker compose down`；该命令会保留数据库卷。只有明确需要删除全部 SQLite 数据时才使用 `docker compose down --volumes`。
+
+也可以只构建镜像：
+
+```powershell
+docker build --tag hengzhun-exam-system:local .
+```
+
+镜像默认监听 `0.0.0.0:4173`，以非 root 用户运行，并通过 `/api/public/home` 执行健康检查。需要连接 MySQL 或 Redis 时，用运行环境变量覆盖 `DATABASE_CLIENT`、`DATABASE_URL`/`MYSQL_*`、`REDIS_URL`；此时 SQLite 数据卷可以移除。
+
+#### Gitea Actions 自动发布到 Docker Hub 与 Gitea 软件包
+
+工作流位于 `.gitea/workflows/docker-publish.yml`。它会先安装依赖并运行测试，然后构建 `linux/amd64`、`linux/arm64` 双架构镜像，并同时推送到 Docker Hub 与 `git.biss.click/biss/exam-information-system`。
+
+使用前需要完成以下配置：
+
+1. 在 Docker Hub 创建目标仓库，并创建具有该仓库 Read & Write 权限的访问令牌。
+2. 在 Gitea 仓库的 Actions Variables 中添加 `DOCKERHUB_IMAGE`，值为不带 registry 和 tag 的完整镜像名，例如 `yourname/exam-information-system`。
+3. 在 Gitea 仓库的 Actions Secrets 中添加 `DOCKERHUB_USERNAME` 和 `DOCKERHUB_TOKEN`。前者填写 Docker Hub 用户名，后者填写访问令牌，不要填写账户密码。
+4. 使用对 `biss` 组织拥有软件包写权限的 Gitea 账号，在“设置 → 应用 → 生成新令牌”中创建具有 Package Read & Write 权限的个人访问令牌。在仓库 Actions Variables 中添加 `REGISTRY_USERNAME`，值为该令牌所属的用户名；在 Actions Secrets 中添加 `REGISTRY_TOKEN`，值为个人访问令牌。自定义 Secret 不能使用 Gitea 保留的 `GITEA_` 前缀，也不能用工作流内置的 `GITEA_TOKEN` 代替该软件包令牌。
+5. 确保 Gitea Actions 与仓库的软件包注册表已启用，并且 `ubuntu-latest` Runner 能访问 Docker daemon、GitHub、Docker Hub 和 `git.biss.click`。双架构构建还需要 Runner 允许 QEMU 注册步骤运行。
+
+推送到 `master` 后会发布 `latest` 和 `sha-<短提交号>`；推送形如 `v1.2.3` 的 Git 标签后会发布 `1.2.3`、`1.2` 和对应的提交标签，并在镜像推送成功后自动创建同名正式 Gitea Release。例如：
+
+```powershell
+git tag v1.2.3
+git push origin v1.2.3
+```
+
+带连字符预发布后缀的语义化版本标签会自动创建 Gitea Pre-release，例如：
+
+```powershell
+git tag v1.3.0-rc.1
+git push origin v1.3.0-rc.1
+```
+
+该版本的镜像标签为 `1.3.0-rc.1`，不会覆盖稳定版的 `1.3` 或 `latest` 标签。
+
+工作流也支持从 Gitea Actions 页面手动运行。构建缓存保存为同一 Docker Hub 仓库中的 `buildcache` 标签，以加快后续构建。Release 使用工作流内置的 `GITEA_TOKEN` 创建，无需添加额外 Secret；仓库或组织“Actions → General”中的任务令牌最大权限必须允许 Releases Write。
+
+首次成功推送后，容器镜像会出现在 `biss` 所有者的软件包列表。Gitea 的软件包归属于用户或组织，不会天然归属于某个仓库；打开该软件包的设置页面，将它关联到 `Exam-Information-System`，即可让它显示在此仓库的“软件包”页。之后可使用 `docker pull git.biss.click/biss/exam-information-system:latest` 拉取。
+
+需要清空并重建空业务库时运行 `npm run reset-db`；该命令与 `npm run initialize-system` 使用同一套初始化流程，会读取项目根目录的 `.env`，并根据 `DATABASE_CLIENT` 选择 SQLite 或 MySQL。也可通过 `npm run reset-db -- --sqlite` 或 `npm run reset-db -- --mysql` 显式选择数据库；MySQL 中存在无法识别为样例数据的业务记录时仍会拒绝覆盖，只有确认目标可清空后才能追加 `--force`。需要测试数据时再手动运行 `npm run seed-test-data`；导入脚本会生成 5 所学校、1200 名批量考生及对应的不同状态报名数据。省市区县下拉数据位于 `src/data/china-regions.mjs`，当前版本为国家地名信息库截至 2025-12-31 的三级快照，并补入和康县（653228）与和安县（653229）；从新版 CSV 更新时可运行 `node scripts/build-regions.mjs <CSV路径> src/data/china-regions.mjs`。
 
 ## 数据库配置
 
@@ -191,6 +256,24 @@ npm run seed-test-data:mysql -- --force
 
 强制模式会删除该 MySQL 数据库内现有应用数据并在同一事务中写入样例数据，但不会删除数据库或数据表。导入完成后再重新启动应用，避免导入期间出现并发写入或保留旧登录会话。不要对生产业务库执行此命令。本地需要明确使用 SQLite 时可运行 `npm run seed-test-data:sqlite`。
 
+## 中考志愿填报与招生录取
+
+系统可按考试单独启用志愿填报，未启用的考试不会出现志愿入口。完整流程如下：
+
+1. 超级管理员设置填报时间、普通志愿数、最多提交次数和当前阶段；考生只有在当次成绩全部发布后才能填报，达到提交上限后自动锁定。
+2. 招生学校账号以结构化表单上传本校普通生、特长生与生源校指标分配计划，超级管理员审核后生效；超级管理员也可代上传并直接审核。
+3. 生源校学校管理员按考试逐人确认指标分配资格；本校资料已完善的在册考生全部确认后，系统自动公开有无资格及对应特长类型。超级管理员和班级管理员均不能代确认。
+4. 每名考生有一个专用指标分配志愿栏，只有确认有资格且招生校对本校分配了对应指标时可选；其余均为普通志愿。志愿只能由考生本人保存或修改，班级、校级管理员无权查看，超级管理员只读可见。
+5. 超级管理员结束填报并执行投档。系统按总成绩降序逐个检索志愿，严格区分指标计划池与普通计划池，并遵循“分数优先、遵循志愿”。
+6. 投档材料只发送到对应招生学校，包含必要考生资料与当次成绩，不包含考生其余志愿。学校可接收或填写特殊理由申请退档，退档由超级管理员统一审核。
+7. 未完成计划可开启下一轮补录；已正式录取的考生不会被覆盖。录取结束后系统发送个人通知，并在独立“招生公示”页面自动发布脱敏录取名单及按学校、类别统计的录取分数线。
+
+公开公示固定包含报名号、姓名、考生总成绩和录取学校；证件号、手机号等重要身份信息只提供脱敏值。考生档案中的特长资格按“体育 / 艺术”大类与对应小类登记，志愿页面先按学校代码选择招生校，再仅显示符合本人资格的该校类别。
+
+学校统一在“学校管理”中维护，并可分别标记为生源校、招生校或同时具备两类职责。每场考试报名都包含独立于科目的 `feature_score`（特征分），默认 0，由超级管理员登记；招生学校可在录取结束后下载本校全部正式录取考生信息 Excel。
+
+数据结构版本为 v20，`admission_records` 关系表新增指标资格、资格公示和分数线公告记录，并支持 SQLite / MySQL 自动迁移。新角色值为 `admission_school`。
+
 ## 手动测试数据账号
 
 测试数据脚本会提供以下账号；其中初始超级管理员也可能由正常首次建库创建，并可通过环境变量改名、改密，其余校级、班级和考生账号不会在正常启动时创建：

app.js

@@ -1,10 +1,13 @@
 import { api } from './src/client/api.mjs';
 import { createAdminViews, numberSegmentMeta } from './src/client/admin-views.mjs';
 import { createCandidateViews } from './src/client/candidate-views.mjs';
+import { createAdmissionViews } from './src/client/admission-views.mjs';
+import { admissionCategoryEditor, indicatorAllocationEditor } from './src/client/admission-plan-editor.mjs';
 import { createPublicViews } from './src/client/public-views.mjs';
 import { state } from './src/client/state.mjs';
 import { badge, dateRange, formatDate, h, icons, money, passPolicyText, statusLabels } from './src/client/ui.mjs';
 import { formatRegionAddress, mountRegionSelects, updateRegionSelects } from './src/client/region-select.mjs';
+import { specialtyCatalog } from './src/data/specialty-types.mjs';
 
 const app = document.querySelector('#app');
 const modalRoot = document.querySelector('#modalRoot');
@@ -21,14 +24,22 @@ function toast(title, message = '') {
 }
 
 function setModal(content) {
+  document.body.classList.remove('review-subpage-open');
   modalRoot.innerHTML = `<div class="modal-layer" data-modal-backdrop><div class="modal-card" role="dialog" aria-modal="true">${content}</div></div>`;
   setTimeout(() => modalRoot.querySelector('input,textarea,button')?.focus(), 30);
 }
 
+function setReviewSubpage(content) {
+  document.body.classList.add('review-subpage-open');
+  modalRoot.innerHTML = `<div class="review-subpage-layer"><main class="review-subpage" role="dialog" aria-modal="true">${content}</main></div>`;
+  setTimeout(() => modalRoot.querySelector('button,input,textarea,select')?.focus(), 30);
+}
+
 function closeModal() {
   const editor = noticeEditor;
   noticeEditor = null;
   if (editor) editor.destroy().catch(error => console.error('CKEditor cleanup failed', error));
+  document.body.classList.remove('review-subpage-open');
   modalRoot.innerHTML = '';
 }
 
@@ -52,13 +63,30 @@ function emptyState(title, description, route, action) {
 }
 
 function renderError(error) {
-  app.innerHTML = `<section class="fatal-error"><span>!</span><h1>页面暂时无法加载</h1><p>${h(error.message)}</p><button class="solid-button" data-action="retry">重新加载</button></section>`;
+  if (error?.status === 401) return requireLogin();
+  console.error('Page failed to render', error);
+  const message = error?.status ? error.message : '请求未能完成，请稍后重试或返回首页。';
+  app.innerHTML = `<section class="fatal-error"><span>!</span><h1>页面暂时无法加载</h1><p>${h(message)}</p><div class="fatal-error-actions"><button class="ghost-button" data-route="home">返回首页</button><button class="solid-button" data-action="retry">重试</button></div></section>`;
 }
 
-const baseViewContext = { state, app, h, formatDate, dateRange, badge, money, passPolicyText, statusLabels, icons, api, renderError, emptyState };
+function requireLogin() {
-const { brand, renderHome, renderAuth } = createPublicViews(baseViewContext);
+  state.user = null;
+  state.profile = null;
+  state.permissions = [];
+  state.scopeLabel = '';
+  state.pageData = null;
+  state.resultExamFilter = '';
+  state.resultSubjectFilter = '';
+  state.resultExamCatalog = null;
+  state.authNotice = '登录状态已失效，请重新登录。';
+  navigate('login');
+}
+
+const baseViewContext = { state, app, h, formatDate, dateRange, badge, money, passPolicyText, statusLabels, icons, api, renderError, requireLogin, emptyState };
+const { brand, renderHome, renderNoticeCenter, renderAuth } = createPublicViews(baseViewContext);
 const { adminNavForUser, portalShell, loadingPanel, renderCandidate, accountSecurity } = createCandidateViews({ ...baseViewContext, brand });
 const { renderAdmin, workflowStepEditor } = createAdminViews({ ...baseViewContext, brand, portalShell, loadingPanel, adminNavForUser, accountSecurity });
+const { renderAdmission } = createAdmissionViews({ ...baseViewContext, brand });
 
 function navigate(route) {
   location.hash = route;
@@ -70,10 +98,14 @@ async function renderRoute() {
   window.scrollTo({ top: 0, behavior: 'instant' });
   const route = location.hash.slice(1) || 'home';
   const [section, page = 'dashboard'] = route.split('/');
+  if (section !== 'login') state.authNotice = '';
   if (section === 'home') renderHome();
+  else if (section === 'notices' || section === 'announcements') { state.publicAnnouncements = await api('/api/public/announcements'); renderNoticeCenter(state.publicAnnouncements); }
+  else if (section === 'notice') { state.publicAnnouncements = await api('/api/public/announcements'); renderNoticeCenter(state.publicAnnouncements, page); }
   else if (section === 'login' || section === 'register') renderAuth(section);
   else if (section === 'candidate') await renderCandidate(page);
   else if (section === 'admin') await renderAdmin(page);
+  else if (section === 'admission_school') await renderAdmission(page);
   else navigate('home');
 }
 
@@ -97,6 +129,67 @@ function updateRegistrationSelection() {
   document.querySelectorAll('[data-action="bulk-registration-review"]').forEach(button => { button.disabled = selected.length === 0; });
 }
 
+function updateCandidateSelection() {
+  const table = document.querySelector('#candidateTable');
+  if (!table) return;
+  const selectable = [...table.querySelectorAll('[data-candidate-select]:not(:disabled)')];
+  const visible = selectable.filter(input => !input.closest('tr').hidden);
+  const selected = selectable.filter(input => input.checked);
+  const selectAll = table.querySelector('[data-candidate-select-all]');
+  if (selectAll) {
+    selectAll.checked = visible.length > 0 && visible.every(input => input.checked);
+    selectAll.indeterminate = visible.some(input => input.checked) && !selectAll.checked;
+  }
+  const count = document.querySelector('[data-candidate-selection-count]');
+  if (count) count.textContent = selected.length;
+  document.querySelectorAll('[data-action="bulk-candidate-review"]').forEach(button => { button.disabled = selected.length === 0; });
+}
+
+function updatePaymentSelection() {
+  const table = document.querySelector('#paymentTable');
+  if (!table) return;
+  const selectable = [...table.querySelectorAll('[data-payment-select]:not(:disabled)')];
+  const visible = selectable.filter(input => !input.closest('tr').hidden);
+  const selected = selectable.filter(input => input.checked);
+  const selectAll = table.querySelector('[data-payment-select-all]');
+  if (selectAll) {
+    selectAll.checked = visible.length > 0 && visible.every(input => input.checked);
+    selectAll.indeterminate = visible.some(input => input.checked) && !selectAll.checked;
+  }
+  const count = document.querySelector('[data-payment-selection-count]');
+  if (count) count.textContent = selected.length;
+  document.querySelectorAll('[data-action="bulk-payment-update"]').forEach(button => { button.disabled = selected.length === 0; });
+}
+
+function updateQualificationSelection(container) {
+  if (!container) return;
+  const rows = [...container.querySelectorAll('[data-qualification-select]')];
+  const visible = rows.filter(input => !input.closest('tr').hidden);
+  const selected = rows.filter(input => input.checked);
+  const selectAll = container.querySelector('[data-action="qualification-select-all"]');
+  if (selectAll) {
+    selectAll.checked = visible.length > 0 && visible.every(input => input.checked);
+    selectAll.indeterminate = visible.some(input => input.checked) && !selectAll.checked;
+  }
+  const count = container.querySelector('[data-qualification-selected-count]');
+  if (count) count.textContent = `已选 ${selected.length} 人`;
+}
+
+function updatePlacementSelection() {
+  const table = document.getElementById('placementReviewTable');
+  if (!table) return;
+  const selectable = [...table.querySelectorAll('[data-placement-select]:not(:disabled)')];
+  const visible = selectable.filter(input => !input.closest('tr').hidden);
+  const selected = selectable.filter(input => input.checked);
+  const selectAll = document.querySelector('[data-placement-select-all][data-target="placementReviewTable"]');
+  if (selectAll) {
+    selectAll.checked = visible.length > 0 && visible.every(input => input.checked);
+    selectAll.indeterminate = visible.some(input => input.checked) && !selectAll.checked;
+  }
+  const count = document.querySelector('[data-placement-selected-count]');
+  if (count) count.textContent = `已选 ${selected.length} 人`;
+}
+
 function applyTableFilters(tableId) {
   const table = document.getElementById(tableId);
   if (!table) return;
@@ -104,13 +197,50 @@ function applyTableFilters(tableId) {
   const query = search?.value.trim().toLowerCase() || '';
   const status = [...document.querySelectorAll('[data-action="status-filter"]')].find(button => button.dataset.target === tableId && button.classList.contains('active'))?.dataset.status || 'all';
   const filters = [...document.querySelectorAll('[data-table-filter]')].filter(select => select.dataset.target === tableId && select.value);
-  table.querySelectorAll('tbody tr[data-filter-row], tbody tr[data-status]').forEach(row => {
+  table.querySelectorAll('[data-filter-row], tbody tr[data-status]').forEach(row => {
     const matchesSearch = !query || row.textContent.toLowerCase().includes(query);
     const matchesStatus = status === 'all' || String(row.dataset.status || '').split(/\s+/).includes(status);
-    const matchesFilters = filters.every(select => String(row.dataset[select.dataset.tableFilter] || '') === select.value);
+    const matchesFilters = filters.every(select => String(row.dataset[select.dataset.tableFilter] || '').split('|').includes(select.value));
     row.hidden = !(matchesSearch && matchesStatus && matchesFilters);
   });
   if (tableId === 'registrationTable') updateRegistrationSelection();
+  if (tableId === 'candidateTable') updateCandidateSelection();
+  if (tableId === 'paymentTable') updatePaymentSelection();
+  if (tableId === 'placementReviewTable') updatePlacementSelection();
+  if (table.closest('.qualification-ledger')) updateQualificationSelection(table.closest('.qualification-ledger'));
+}
+
+function updateResultScoreInput(input) {
+  const row = input.closest('tr');
+  const error = row?.querySelector('[data-score-error]');
+  const value = input.value.trim();
+  const score = Number(value);
+  const max = Number(input.max);
+  const invalid = value !== '' && (!Number.isFinite(score) || score < 0 || score > max);
+  input.dataset.dirty = String(value !== input.defaultValue);
+  input.setAttribute('aria-invalid', String(invalid));
+  row?.classList.toggle('score-row-invalid', invalid);
+  if (error) error.textContent = invalid ? `须在 0—${max} 之间` : '';
+  const form = input.closest('form');
+  const dirty = form?.querySelectorAll('[data-result-score][data-dirty="true"]').length || 0;
+  const count = form?.querySelector('[data-result-dirty-count]');
+  if (count) count.textContent = dirty ? `${dirty} 条成绩尚未暂存` : '尚无未保存修改';
+}
+
+function updateFeatureScoreInput(input) {
+  const row = input.closest('tr');
+  const error = row?.querySelector('[data-feature-score-error]');
+  const value = input.value.trim();
+  const score = Number(value);
+  const invalid = value === '' || !Number.isFinite(score) || score < 0 || score > 1000;
+  input.dataset.dirty = String(value !== input.defaultValue);
+  input.setAttribute('aria-invalid', String(invalid));
+  row?.classList.toggle('score-row-invalid', invalid);
+  if (error) error.textContent = invalid ? '须在 0—1000 之间' : '';
+  const form = input.closest('form');
+  const dirty = form?.querySelectorAll('[data-feature-score][data-dirty="true"]').length || 0;
+  const count = form?.querySelector('[data-feature-dirty-count]');
+  if (count) count.textContent = dirty ? `${dirty} 条特征分尚未保存` : '尚无未保存修改';
 }
 
 async function refreshPublic() {
@@ -127,6 +257,7 @@ async function refreshSession() {
 
 async function finishLogin(data) {
   state.user = data.user;
+  state.authNotice = '';
   await refreshSession();
   closeModal();
   toast(data.usedRecoveryCode ? '已使用恢复码登录' : '登录成功', data.usedRecoveryCode ? '该恢复码已失效，请检查剩余恢复码' : `欢迎，${data.user.displayName}`);
@@ -172,15 +303,157 @@ document.addEventListener('click', async event => {
     }
     if (action === 'logout') {
       await api('/api/auth/logout', { method: 'POST' });
-      state.user = null; state.profile = null; state.pageData = null; state.permissions = []; state.scopeLabel = '';
+      state.user = null; state.profile = null; state.pageData = null; state.permissions = []; state.scopeLabel = ''; state.resultExamFilter = ''; state.resultSubjectFilter = ''; state.resultExamCatalog = null;
       await refreshPublic(); navigate('home'); toast('已安全退出', '期待下次见面'); return;
     }
     if (action === 'open-notice') {
-      const notice = state.publicData.notices.find(item => item.id === target.dataset.id) || (await api(`/api/public/notices/${target.dataset.id}`)).notice;
+      return navigate(`notice/${target.dataset.id}`);
-      const contentHtml = notice.contentHtml || `<p>${h(notice.content).replace(/\r?\n/g, '</p><p>')}</p>`;
+    }
-      setModal(`<div class="modal-head"><div><span>${h(notice.category)}</span><h2>${h(notice.title)}</h2><p>${formatDate(notice.publishAt,true)} · ${h(notice.author)}</p></div><button data-action="close-modal">×</button></div><article class="notice-content">${contentHtml}</article><div class="modal-foot"><button class="ghost-button" data-action="close-modal">关闭</button></div>`); return;
+    if (action === 'notice-category') {
+      state.noticeCategory = target.dataset.category;
+      state.noticePage = 1;
+      renderNoticeCenter(state.publicAnnouncements);
+      return;
+    }
+    if (action === 'notice-page') {
+      if (target.disabled) return;
+      state.noticePage = Number(target.dataset.page || 1);
+      renderNoticeCenter(state.publicAnnouncements);
+      window.scrollTo({ top: 0, behavior: 'smooth' });
+      return;
     }
     if (action === 'download-admit') { window.location.href = `/api/candidate/registrations/${target.dataset.id}/admit-card`; return; }
+    if (action === 'download-admitted-candidates') {
+      const examId = target.closest('.admission-export-bar')?.querySelector('[name="exportExamId"]')?.value;
+      if (!examId) return toast('请选择考试', '仅录取工作结束的考试可以下载');
+      window.location.href = `/api/admission/placements/export?examId=${encodeURIComponent(examId)}`;
+      return;
+    }
+    if (action === 'admission-plan-review') {
+      const reviewNote = window.prompt(target.dataset.status === 'approved' ? '填写审核意见（可留空）' : '请填写退回原因', '') ?? null;
+      if (reviewNote == null) return;
+      await api(`/api/admin/admission-plans/${target.dataset.id}`, { method: 'PATCH', body: { status: target.dataset.status, reviewNote } });
+      toast(target.dataset.status === 'approved' ? '招生计划已通过并自动公示' : '招生计划已退回', target.dataset.status === 'approved' ? '公开通知公告已同步生成招生计划公示' : '招生学校可以修改后重新提交'); return renderRoute();
+    }
+    if (action === 'admission-match') {
+      if (!window.confirm('确认按“分数优先、遵循志愿”执行本轮投档？填报顺序将锁定。')) return;
+      const data = await api(`/api/admin/admissions/${target.dataset.examId}/match`, { method: 'POST' });
+      toast('投档完成', `${data.placementCount} 名考生已发送招生学校`); return renderRoute();
+    }
+    if (action === 'admission-finalize') {
+      if (!window.confirm('确认结束本次录取？系统会向考生发送通知，并按设置自动公示。')) return;
+      const data = await api(`/api/admin/admissions/${target.dataset.examId}/finalize`, { method: 'POST' });
+      await refreshPublic(); toast('录取工作已结束', `${data.admittedCount} 人正式录取`); return renderRoute();
+    }
+    if (action === 'admission-supplementary') {
+      const preferenceEnd = window.prompt('请输入补录志愿截止时间（例如 2026-07-25T18:00）', '');
+      if (!preferenceEnd) return;
+      await api(`/api/admin/admissions/${target.dataset.examId}/supplementary`, { method: 'POST', body: { preferenceEnd } });
+      toast('补录已开启', '未录取考生可以填报新一轮志愿'); return renderRoute();
+    }
+    if (action === 'withdrawal-review') {
+      const approved = target.dataset.approved === 'true';
+      const reviewNote = window.prompt(approved ? '填写批准退档意见' : '填写驳回退档意见', '');
+      if (reviewNote == null) return;
+      await api(`/api/admin/admission-withdrawals/${target.dataset.id}`, { method: 'PATCH', body: { approved, reviewNote } });
+      toast(approved ? '退档已批准' : '退档申请已驳回'); return renderRoute();
+    }
+    if (action === 'save-indicator-qualification') {
+      const row = target.closest('tr');
+      const value = row?.querySelector('[data-indicator-eligible]')?.value;
+      if (!value) return toast('请选择资格结论', '必须明确选择有资格或无资格');
+      const data = await api(`/api/admin/indicator-qualifications/${row.dataset.examId}/${row.dataset.userId}`, { method: 'PUT', body: { eligible: value === 'true' } });
+      toast(data.published ? '资格已确认并自动公示' : '资格已确认', data.published ? '本校全部考生已确认完成' : '继续核对其他考生');
+      return renderRoute();
+    }
+    if (action === 'qualification-select-all') {
+      const container = target.closest('[data-qualification-bulk]')?.closest('.qualification-ledger');
+      container?.querySelectorAll('[data-qualification-select]').forEach(input => {
+        if (!input.closest('tr').hidden) input.checked = target.checked;
+      });
+      updateQualificationSelection(container);
+      return;
+    }
+    if (action === 'clear-table-filters') {
+      const tableId = target.dataset.target;
+      document.querySelectorAll(`[data-table-filter][data-target="${tableId}"]`).forEach(select => { select.value = ''; });
+      document.querySelectorAll(`[data-action="table-search"][data-target="${tableId}"]`).forEach(input => { input.value = ''; });
+      document.querySelectorAll(`[data-action="status-filter"][data-target="${tableId}"]`).forEach((button, index) => button.classList.toggle('active', index === 0));
+      applyTableFilters(tableId);
+      return;
+    }
+    if (action === 'bulk-indicator-qualification') {
+      const toolbar = target.closest('[data-qualification-bulk]');
+      const ledger = toolbar?.closest('.qualification-ledger');
+      const userIds = [...ledger.querySelectorAll('[data-qualification-select]:checked')].map(input => input.closest('tr').dataset.userId);
+      const value = toolbar.querySelector('[data-bulk-eligible]').value;
+      if (!userIds.length) return toast('请先选择考生', '可使用左侧复选框或全选');
+      if (!value) return toast('请选择批量资格结论');
+      if (!window.confirm(`确认将所选 ${userIds.length} 名考生批量设为“${value === 'true' ? '有' : '无'}指标分配资格”？`)) return;
+      const data = await api(`/api/admin/indicator-qualifications/${toolbar.dataset.examId}/bulk`, { method: 'PUT', body: { userIds, eligible: value === 'true' } });
+      toast(data.published ? '批量确认完成并自动公示' : '批量确认完成', `已更新 ${data.count} 名考生`);
+      return renderRoute();
+    }
+    if (action === 'bulk-placement-review') {
+      const ids = [...document.querySelectorAll('#placementReviewTable [data-placement-select]:checked')].map(input => input.value);
+      const decision = target.dataset.decision;
+      if (!ids.length) return toast('请先选择待审核考生', '可勾选单人，或选择当前筛选结果');
+      let note = '';
+      if (decision === 'withdraw') {
+        note = window.prompt(`将为所选 ${ids.length} 名考生申请退档，请填写统一的特殊理由（至少 8 个字）`, '') ?? '';
+        if (!note) return;
+        if (note.trim().length < 8) return toast('退档理由至少需要 8 个字');
+      } else if (!window.confirm(`确认批量接收所选 ${ids.length} 名投档考生吗？`)) return;
+      const result = await api('/api/admission/placements/bulk', { method: 'POST', body: { ids, decision, note } });
+      toast(decision === 'accept' ? '批量接收完成' : '批量退档申请已提交', `已处理 ${result.count} 名考生`);
+      return renderRoute();
+    }
+    if (action === 'toggle-admin-account') {
+      const active = target.dataset.active === 'true';
+      if (!active && !window.confirm('确认停用该管理员账户？其现有登录会话会立即失效，历史审批记录将保留。')) return;
+      await api(`/api/admin/admins/${target.dataset.id}`, { method: 'PATCH', body: { active } });
+      toast(active ? '管理员账户已启用' : '管理员账户已停用', active ? '该账号可以重新登录' : '现有会话已结束，历史记录仍保留');
+      return renderRoute();
+    }
+    if (action === 'reset-admin-password') {
+      if (!window.confirm('确认重置该管理员密码？其现有登录会话会立即失效。')) return;
+      const data = await api(`/api/admin/admins/${target.dataset.id}/reset-password`, { method: 'POST' });
+      setModal(`<div class="modal-head"><div><span>ADMIN PASSWORD RESET</span><h2>管理员临时密码已生成</h2><p>请通过线下安全渠道交给管理员，本页面关闭后不再展示。</p></div><button data-action="close-modal">×</button></div><div class="issued-number"><span>登录账号</span><strong>${h(data.username)}</strong><span>临时密码</span><strong>${h(data.temporaryPassword)}</strong><p>旧密码和现有登录会话均已失效。</p></div><div class="modal-foot"><button class="solid-button" data-action="close-modal">我已保存</button></div>`);
+      return;
+    }
+    if (action === 'toggle-admission-account') {
+      const active = target.dataset.active === 'true';
+      if (!active && !window.confirm('确认停用该招生学校账户？现有登录会话会立即失效，历史审核记录继续保留。')) return;
+      await api(`/api/admin/admission-school-accounts/${target.dataset.id}`, { method: 'PATCH', body: { active } });
+      toast(active ? '招生学校账户已启用' : '招生学校账户已停用');
+      return renderRoute();
+    }
+    if (action === 'reset-admission-account-password') {
+      if (!window.confirm('确认重置该招生学校账户密码？旧密码和现有登录会话会立即失效。')) return;
+      const data = await api(`/api/admin/admission-school-accounts/${target.dataset.id}/reset-password`, { method: 'POST' });
+      setModal(`<div class="modal-head"><div><span>ADMISSION ACCOUNT RESET</span><h2>招生学校临时密码已生成</h2><p>请通过线下安全渠道交给招生学校，本页面关闭后不再展示。</p></div><button data-action="close-modal">×</button></div><div class="issued-number"><span>登录账号</span><strong>${h(data.username)}</strong><span>临时密码</span><strong>${h(data.temporaryPassword)}</strong><p>账户已同步启用，旧密码和现有会话均已失效。</p></div><div class="modal-foot"><button class="solid-button" data-action="close-modal">我已保存</button></div>`);
+      return;
+    }
+    if (action === 'add-admission-category') {
+      const sources = state.pageData?.sourceSchools || [];
+      target.closest('form')?.querySelector('[data-admission-categories]')?.insertAdjacentHTML('beforeend', admissionCategoryEditor(h, sources));
+      return;
+    }
+    if (action === 'remove-admission-category') {
+      const list = target.closest('[data-admission-categories]');
+      if (list?.children.length <= 1) return toast('至少保留一个招生类别');
+      target.closest('.admission-category-editor')?.remove();
+      return;
+    }
+    if (action === 'add-indicator-allocation') {
+      const sources = state.pageData?.sourceSchools || [];
+      target.closest('.indicator-allocation-editor')?.querySelector('[data-indicator-allocations]')?.insertAdjacentHTML('beforeend', indicatorAllocationEditor(h, sources));
+      return;
+    }
+    if (action === 'remove-indicator-allocation') {
+      target.closest('.indicator-allocation-row')?.remove();
+      return;
+    }
     if (['batch-admit-download', 'admit-info-export', 'center-materials-export'].includes(action)) {
       event.preventDefault();
       const examId = target.closest('.admission-export-panel')?.querySelector('[data-admission-export-exam]')?.value;
@@ -190,6 +463,7 @@ document.addEventListener('click', async event => {
       return;
     }
     if (action === 'new-notice') { await openNoticeForm(); return; }
+    if (action === 'edit-notice') { await openNoticeForm(state.pageData.notices.find(item => item.id === target.dataset.id)); return; }
     if (action === 'new-exam') return openExamForm();
     if (action === 'new-admin') return openAdminForm();
     if (action === 'new-school') return openSchoolForm();
@@ -280,6 +554,24 @@ document.addEventListener('click', async event => {
       toast(status === 'rejected' ? `已退回 ${completed} 条报名` : `已处理 ${completed} 条报名`, failures.length ? `${failures.length} 条未完成，请刷新后重试` : '报名状态与流程轨迹已同步更新');
       return renderRoute();
     }
+    if (action === 'bulk-candidate-review') {
+      const ids = [...document.querySelectorAll('#candidateTable [data-candidate-select]:checked')].map(input => input.value);
+      if (!ids.length) return toast('请先选择考生', '仅当前步骤可由你处理的资料可以勾选');
+      const status = target.dataset.status;
+      const reviewNote = window.prompt(status === 'rejected' ? '请填写批量退回原因（必填）' : '填写批量审核意见（可留空）', '');
+      if (reviewNote === null) return;
+      if (status === 'rejected' && !reviewNote.trim()) return toast('请填写退回原因', '考生需要根据原因补充或修改资料');
+      let completed = 0;
+      const failures = [];
+      for (const id of ids) {
+        try {
+          await api(`/api/admin/candidates/${id}`, { method: 'PATCH', body: { status, reviewNote } });
+          completed += 1;
+        } catch (error) { failures.push(error.message); }
+      }
+      toast(status === 'rejected' ? `已退回 ${completed} 名考生资料` : `已处理 ${completed} 名考生资料`, failures.length ? `${failures.length} 名未完成，请检查其流程责任人` : '资料状态与流程轨迹已同步更新');
+      return renderRoute();
+    }
     if (action === 'confirm-payment') {
       if (!window.confirm(`确认已收到 ${target.dataset.name} 的“${target.dataset.exam}”考试费用吗？`)) return;
       await api(`/api/admin/payments/${target.dataset.id}`, { method: 'PATCH' });
@@ -296,11 +588,31 @@ document.addEventListener('click', async event => {
       toast(paid ? '已标记为已缴费' : '已改为待缴费', paid ? '确认人和确认时间已同步记录' : '原确认人和确认时间已清除');
       return renderRoute();
     }
+    if (action === 'bulk-payment-update') {
+      const selected = [...document.querySelectorAll('#paymentTable [data-payment-select]:checked')];
+      if (!selected.length) return toast('请先选择缴费记录');
+      const status = target.dataset.status;
+      const changed = selected.filter(input => input.dataset.status !== status);
+      const skipped = selected.length - changed.length;
+      if (!changed.length) return toast('所选记录无需更改', status === 'paid' ? '所选考生都已缴费' : '所选考生都处于待缴费状态');
+      if (!window.confirm(`确认将 ${changed.length} 条缴费记录批量改为“${status === 'paid' ? '已缴费' : '待缴费'}”吗？`)) return;
+      let completed = 0;
+      const failures = [];
+      for (const input of changed) {
+        try {
+          await api(`/api/admin/payments/${input.value}`, { method: 'PATCH', body: { status } });
+          completed += 1;
+        } catch (error) { failures.push(error.message); }
+      }
+      toast(`已更新 ${completed} 条缴费记录`, [skipped ? `${skipped} 条状态相同已跳过` : '', failures.length ? `${failures.length} 条未完成` : ''].filter(Boolean).join('；'));
+      return renderRoute();
+    }
     if (action === 'excel-download') {
       const query = new URLSearchParams();
       if (target.dataset.template === '1') query.set('template', '1');
       if (target.dataset.batchId) query.set('batchId', target.dataset.batchId);
       if (target.dataset.examId) query.set('examId', target.dataset.examId);
+      else if (target.dataset.resource === 'results' && state.resultExamFilter) query.set('examId', state.resultExamFilter);
       window.location.href = `/api/admin/excel/${target.dataset.resource}?${query}`;
       return;
     }
@@ -310,6 +622,16 @@ document.addEventListener('click', async event => {
     }
     if (action === 'result-exam-filter') {
       state.resultExamFilter = target.dataset.id;
+      state.resultSubjectFilter = '';
+      ['resultEntryTable', 'featureScoreTable', 'resultTable'].forEach(key => {
+        if (state.tablePages[key]) state.tablePages[key].page = 1;
+      });
+      return renderRoute();
+    }
+    if (action === 'table-page') {
+      const key = target.dataset.tableKey;
+      const current = state.tablePages[key] || { page: 1, pageSize: 50 };
+      state.tablePages[key] = { ...current, page: Math.max(1, Number(target.dataset.page) || 1) };
       return renderRoute();
     }
     if (action === 'cancel-result-import') {
@@ -356,7 +678,12 @@ document.addEventListener('click', async event => {
     }
     if (action === 'toggle-notice') {
       await api(`/api/admin/notices/${target.dataset.id}`, { method: 'PATCH', body: { status: target.dataset.status } });
-      toast(target.dataset.status === 'published' ? '通知已发布' : '通知已撤回', '首页展示状态已更新'); return refreshPublic().then(renderRoute);
+      toast(target.dataset.status === 'published' ? '通知已发布' : '通知已隐藏', '公开展示状态已更新'); return refreshPublic().then(renderRoute);
+    }
+    if (action === 'toggle-publication') {
+      const visible = target.dataset.visible === 'true';
+      await api(`/api/admin/publications/${target.dataset.sourceType}/${target.dataset.id}`, { method: 'PATCH', body: { visible } });
+      toast(visible ? '系统公示已显示' : '系统公示已隐藏', '只调整公开目录展示，不修改公示内容'); return refreshPublic().then(renderRoute);
     }
     if (action === 'status-filter') {
       target.parentElement.querySelectorAll('button').forEach(button => button.classList.toggle('active', button === target));
@@ -369,6 +696,8 @@ document.addEventListener('input', event => {
   if (event.target.matches('[data-action="table-search"]')) {
     applyTableFilters(event.target.dataset.target);
   }
+  if (event.target.matches('[data-result-score]')) updateResultScoreInput(event.target);
+  if (event.target.matches('[data-feature-score]')) updateFeatureScoreInput(event.target);
   if (event.target.matches('.subject-options input')) {
     const form = event.target.closest('form');
     const checked = [...form.querySelectorAll('.subject-options input:checked')];
@@ -382,8 +711,38 @@ document.addEventListener('input', event => {
 });
 
 document.addEventListener('change', event => {
+  if (event.target.matches('[data-action="table-page-size"]')) {
+    const key = event.target.dataset.tableKey;
+    state.tablePages[key] = { page: 1, pageSize: Number(event.target.value) || 50 };
+    renderRoute();
+    return;
+  }
+  if (event.target.matches('[data-placement-select]')) updatePlacementSelection();
+  if (event.target.matches('[data-placement-select-all]')) {
+    const table = document.getElementById(event.target.dataset.target);
+    table?.querySelectorAll('[data-placement-select]:not(:disabled)').forEach(input => {
+      if (!input.closest('tr').hidden) input.checked = event.target.checked;
+    });
+    updatePlacementSelection();
+  }
+  if (event.target.matches('[data-action="result-bulk-exam"]')) {
+    state.resultExamFilter = event.target.value;
+    state.resultSubjectFilter = '';
+    ['resultEntryTable', 'featureScoreTable', 'resultTable'].forEach(key => {
+      if (state.tablePages[key]) state.tablePages[key].page = 1;
+    });
+    renderRoute();
+  }
+  if (event.target.matches('[data-action="result-bulk-subject"]')) {
+    state.resultSubjectFilter = event.target.value;
+    if (state.tablePages.resultEntryTable) state.tablePages.resultEntryTable.page = 1;
+    renderRoute();
+  }
+  if (event.target.matches('[data-qualification-select]')) updateQualificationSelection(event.target.closest('.qualification-ledger'));
   if (event.target.matches('[data-table-filter]')) applyTableFilters(event.target.dataset.target);
   if (event.target.matches('[data-registration-select]')) updateRegistrationSelection();
+  if (event.target.matches('[data-candidate-select]')) updateCandidateSelection();
+  if (event.target.matches('[data-payment-select]')) updatePaymentSelection();
   if (event.target.matches('[data-registration-select-all]')) {
     const table = document.getElementById(event.target.dataset.target);
     table?.querySelectorAll('[data-registration-select]:not(:disabled)').forEach(input => {
@@ -391,6 +750,20 @@ document.addEventListener('change', event => {
     });
     updateRegistrationSelection();
   }
+  if (event.target.matches('[data-candidate-select-all]')) {
+    const table = document.getElementById(event.target.dataset.target);
+    table?.querySelectorAll('[data-candidate-select]:not(:disabled)').forEach(input => {
+      if (!input.closest('tr').hidden) input.checked = event.target.checked;
+    });
+    updateCandidateSelection();
+  }
+  if (event.target.matches('[data-payment-select-all]')) {
+    const table = document.getElementById(event.target.dataset.target);
+    table?.querySelectorAll('[data-payment-select]:not(:disabled)').forEach(input => {
+      if (!input.closest('tr').hidden) input.checked = event.target.checked;
+    });
+    updatePaymentSelection();
+  }
   if (event.target.matches('[data-excel-file]')) {
     const input = event.target;
     const file = input.files?.[0];
@@ -426,6 +799,36 @@ document.addEventListener('change', event => {
       classSelect.innerHTML = `<option value="">请选择班级</option>${classes.filter(item => item.schoolId === event.target.value).map(item => `<option value="${h(item.id)}">${h(item.name)}</option>`).join('')}`;
     }
   }
+  if (event.target.matches('[data-action="specialty-category"]')) {
+    const typeSelect = event.target.closest('.admission-category-editor')?.querySelector('[data-specialty-type]') || event.target.closest('form')?.querySelector('[data-specialty-type]');
+    const category = specialtyCatalog.find(item => item.code === event.target.value);
+    if (typeSelect) {
+      typeSelect.disabled = !category;
+      typeSelect.innerHTML = `<option value="">${category ? '请选择小类' : '请先选择大类'}</option>${(category?.types || []).map(item => `<option value="${h(item.code)}">${h(item.name)}</option>`).join('')}`;
+    }
+  }
+  if (event.target.matches('[data-action="plan-category-kind"]')) {
+    const editor = event.target.closest('.admission-category-editor');
+    const specialtyFields = editor?.querySelector('[data-plan-specialty]');
+    const enabled = event.target.value === 'specialty';
+    specialtyFields?.classList.toggle('hidden', !enabled);
+    specialtyFields?.querySelectorAll('select').forEach(select => { select.disabled = !enabled || (select.hasAttribute('data-specialty-type') && !specialtyFields.querySelector('[name="categorySpecialtyCategory"]')?.value); });
+  }
+  if (event.target.matches('[name="categoryName"]')) {
+    const title = event.target.closest('.admission-category-editor')?.querySelector('header strong');
+    if (title) title.textContent = event.target.value.trim() || '新类别';
+  }
+  if (event.target.matches('[data-action="preference-school"]')) {
+    const row = event.target.closest('.preference-choice-row');
+    const categorySelect = row?.querySelector('[name="choiceCategory"]');
+    const admission = state.pageData?.admissions?.find(item => item.examId === event.target.dataset.examId);
+    const plan = admission?.plans?.find(item => item.schoolId === event.target.value);
+    const preferenceType = row?.dataset.preferenceType || 'general';
+    if (categorySelect) {
+      categorySelect.disabled = !plan;
+      categorySelect.innerHTML = `<option value="">${plan ? '请选择招生类别' : '请先按代码选择学校'}</option>${(plan?.categories || []).filter(item => item.preferenceTypes?.includes(preferenceType) && Number(preferenceType === 'indicator' ? item.indicatorRemaining : item.generalRemaining) > 0).map(item => `<option value="${h(item.code)}">${h(item.name)} · 对应余 ${h(preferenceType === 'indicator' ? item.indicatorRemaining : item.generalRemaining)}</option>`).join('')}`;
+    }
+  }
   if (event.target.matches('[data-region-level]')) updateRegionSelects(event.target);
   if (event.target.matches('[data-action="admin-level"]')) {
     const form = event.target.closest('form');
@@ -479,7 +882,7 @@ document.addEventListener('submit', async event => {
   const form = event.target.closest('form[data-form]');
   if (!form) return;
   event.preventDefault();
-  const submit = form.querySelector('button[type="submit"]');
+  const submit = event.submitter || form.querySelector('button[type="submit"]');
   const original = submit?.innerHTML;
   if (submit) { submit.disabled = true; submit.textContent = '正在处理…'; }
   try {
@@ -527,6 +930,10 @@ document.addEventListener('submit', async event => {
     } else if (kind === 'candidate-profile') {
       const data = await api('/api/candidate/profile', { method: 'PUT', body: formObject(form) });
       state.profile = data.profile; await refreshSession(); toast('资料已提交', '管理员审核后会更新状态'); navigate('candidate/dashboard');
+    } else if (kind === 'volunteer-preference') {
+      const choices = [...form.querySelectorAll('.preference-choice-row')].map(row => ({ schoolId: row.querySelector('[name="choiceSchool"]').value, categoryCode: row.querySelector('[name="choiceCategory"]').value, preferenceType: row.dataset.preferenceType || 'general' })).filter(item => item.schoolId && item.categoryCode);
+      const data = await api(`/api/candidate/admissions/${form.examId.value}/preferences`, { method: 'PUT', body: { choices } });
+      toast(data.locked ? '志愿已保存并锁定' : '志愿已保存', data.locked ? '已达到本轮提交次数上限' : `还可提交 ${data.remainingSubmissions} 次`); renderRoute();
     } else if (kind === 'exam-registration') {
       const body = { examId: form.examId.value, subjectIds: [...form.querySelectorAll('input[name="subjectIds"]:checked')].map(input => input.value) };
       if (!body.subjectIds.length) throw new Error('请至少选择一个报考科目');
@@ -548,8 +955,30 @@ document.addEventListener('submit', async event => {
       const body = formObject(form);
       await api('/api/admin/admins', { method: 'POST', body });
       closeModal(); toast('管理员已创建', '权限范围已按层级绑定'); renderRoute();
+    } else if (kind === 'admission-setting') {
+      const body = formObject(form); body.enabled = form.enabled.checked; body.autoPublish = form.autoPublish.checked; body.maxChoices = Number(body.maxChoices || 5); body.maxSubmissions = Number(body.maxSubmissions || 3);
+      await api(`/api/admin/admissions/${body.examId}/setting`, { method: 'PUT', body });
+      toast('志愿设置已保存', '考生端阶段与进度已同步'); renderRoute();
+    } else if (kind === 'admission-account') {
+      await api('/api/admin/admission-school-accounts', { method: 'POST', body: formObject(form) });
+      form.reset(); toast('招生学校账号已创建'); renderRoute();
+    } else if (kind === 'admission-plan' || kind === 'school-admission-plan') {
+      const body = formObject(form);
+      body.categories = [...form.querySelectorAll('.admission-category-editor')].map((editor, index) => {
+        const specialty = editor.querySelector('[name="categoryKind"]').value === 'specialty';
+        const indicatorAllocations = [...editor.querySelectorAll('.indicator-allocation-row')].map(row => ({ sourceSchoolId: row.querySelector('[name="indicatorSchool"]').value, quota: Number(row.querySelector('[name="indicatorQuota"]').value || 0) })).filter(item => item.sourceSchoolId && item.quota > 0);
+        return { code: `category_${index + 1}`, name: editor.querySelector('[name="categoryName"]').value.trim(), quota: Number(editor.querySelector('[name="categoryQuota"]').value || 0), isSpecialty: specialty, specialtyCategory: specialty ? editor.querySelector('[name="categorySpecialtyCategory"]').value : '', specialtyType: specialty ? editor.querySelector('[name="categorySpecialtyType"]').value : '', indicatorAllocations };
+      }).filter(item => item.name && item.quota > 0);
+      if (!body.categories.length) throw new Error('请至少添加一个有效招生类别');
+      if (body.categories.some(item => item.isSpecialty && (!item.specialtyCategory || !item.specialtyType))) throw new Error('特长生类别必须同时选择对应的大类和小类');
+      await api(kind === 'admission-plan' ? '/api/admin/admission-plans' : '/api/admission/plans', { method: 'POST', body });
+      toast(kind === 'admission-plan' ? '招生计划已代上传并通过' : '招生计划已提交审核'); renderRoute();
+    } else if (kind === 'placement-review') {
+      const body = formObject(form);
+      await api(`/api/admission/placements/${body.id}`, { method: 'PATCH', body });
+      toast(body.decision === 'accept' ? '已接收投档考生' : '退档申请已提交超级管理员'); renderRoute();
     } else if (kind === 'school-form') {
-      const body = formObject(form); body.active = form.active.checked;
+      const body = formObject(form); body.active = form.active.checked; body.isSourceSchool = form.isSourceSchool.checked; body.isAdmissionSchool = form.isAdmissionSchool.checked;
       await api(body.id ? `/api/admin/schools/${body.id}` : '/api/admin/schools', { method: body.id ? 'PATCH' : 'POST', body });
       closeModal(); await refreshPublic(); toast(body.id ? '学校档案已更新' : '学校已创建', `${body.name} · ${body.code.toUpperCase()}`); renderRoute();
     } else if (kind === 'school-class') {
@@ -631,8 +1060,9 @@ document.addEventListener('submit', async event => {
       const body = formObject(form);
       if (noticeEditor) body.content = noticeEditor.getData();
       body.pinned = form.pinned.checked;
-      await api('/api/admin/notices', { method: 'POST', body });
+      const endpoint = body.id ? `/api/admin/notices/${body.id}` : '/api/admin/notices';
-      closeModal(); await refreshPublic(); toast(body.status === 'published' ? '通知已发布' : '草稿已保存', '公开首页状态已同步'); renderRoute();
+      await api(endpoint, { method: body.id ? 'PATCH' : 'POST', body });
+      closeModal(); await refreshPublic(); toast(body.status === 'published' ? '通知已发布' : '草稿已保存', body.id ? '草稿内容已更新' : '公开首页状态已同步'); renderRoute();
     } else if (kind === 'exam-form') {
       const body = formObject(form);
       body.subjects = [...form.querySelectorAll('.exam-subject-editor')].map(row => ({
@@ -654,6 +1084,42 @@ document.addEventListener('submit', async event => {
       const body = formObject(form); body.published = form.published.checked;
       await api('/api/admin/results', { method: 'POST', body });
       toast(body.published ? '成绩已发布' : '成绩已保存', '考生端可见状态已更新'); renderRoute();
+    } else if (kind === 'result-bulk-entry') {
+      const mode = event.submitter?.dataset.resultMode || 'draft';
+      const inputs = [...form.querySelectorAll('[data-result-score]')];
+      const invalid = inputs.find(input => input.value.trim() !== '' && (!Number.isFinite(Number(input.value)) || Number(input.value) < 0 || Number(input.value) > Number(input.max)));
+      if (invalid) { invalid.focus(); throw new Error(`成绩须在 0—${invalid.max} 之间`); }
+      const targets = mode === 'publish'
+        ? inputs.filter(input => input.value.trim() !== '')
+        : inputs.filter(input => input.dataset.dirty === 'true' && input.value.trim() !== '');
+      if (mode === 'publish') {
+        const missing = inputs.filter(input => input.value.trim() === '');
+        if (missing.length) { missing[0].focus(); throw new Error(`还有 ${missing.length} 名考生未录入成绩，补齐后才能整科发布`); }
+        if (!window.confirm(`确认发布本科学目 ${targets.length} 名考生的成绩吗？发布后考生可立即查询。`)) return;
+      }
+      if (!targets.length) throw new Error(mode === 'publish' ? '当前科目没有可发布的成绩' : '请先修改至少一条成绩');
+      const body = {
+        examId: form.examId.value,
+        subjectId: form.subjectId.value,
+        published: mode === 'publish',
+        rows: targets.map(input => ({ registrationId: input.dataset.registrationId, score: Number(input.value) }))
+      };
+      const result = await api('/api/admin/results/bulk', { method: 'POST', body });
+      toast(mode === 'publish' ? '本科学目成绩已发布' : '成绩已暂存', `${result.count} 条成绩已在同一事务中保存`);
+      renderRoute();
+    } else if (kind === 'feature-score-entry') {
+      const body = formObject(form); body.featureScore = Number(body.featureScore || 0);
+      await api(`/api/admin/registrations/${body.registrationId}/feature-score`, { method: 'PATCH', body });
+      toast('特征分已登记', '该分数独立于考试科目，默认值为 0'); renderRoute();
+    } else if (kind === 'feature-score-bulk') {
+      const inputs = [...form.querySelectorAll('[data-feature-score]')];
+      const invalid = inputs.find(input => input.value.trim() === '' || !Number.isFinite(Number(input.value)) || Number(input.value) < 0 || Number(input.value) > 1000);
+      if (invalid) { invalid.focus(); throw new Error('特征分必须在 0—1000 之间；未参加时填写 0'); }
+      const targets = inputs.filter(input => input.dataset.dirty === 'true');
+      if (!targets.length) throw new Error('请先修改至少一名考生的特征分');
+      const result = await api('/api/admin/feature-scores/bulk', { method: 'POST', body: { examId: form.examId.value, rows: targets.map(input => ({ registrationId: input.dataset.registrationId, featureScore: Number(input.value) })) } });
+      toast('特征分已保存', `${result.count} 名考生已更新；其余考生继续保持 0 分`);
+      renderRoute();
     } else if (kind === 'result-import-commit') {
       const rows = state.resultImportPreview?.rows || [];
       if (!rows.length) throw new Error('没有可提交的成绩预览');
@@ -671,7 +1137,7 @@ function openAdminForm() {
 }
 
 function openSchoolForm(school = null) {
-  setModal(`<div class="modal-head"><div><span>SCHOOL DIRECTORY</span><h2>${school ? '编辑学校档案' : '创建学校'}</h2><p>学校代码用于管理员范围、报名号规则和数据识别，建议使用稳定且唯一的简称。</p></div><button data-action="close-modal">×</button></div><form class="modal-form" data-form="school-form">${school ? `<input type="hidden" name="id" value="${h(school.id)}">` : ''}<div class="field-row"><label><span>学校名称 *</span><input name="name" required maxlength="100" value="${h(school?.name || '')}" placeholder="例如 海州市第四中学"></label><label><span>学校代码 *</span><input name="code" required maxlength="40" pattern="[A-Za-z0-9_-]+" value="${h(school?.code || '')}" placeholder="例如 HZ04"></label></div><label><span>学校地址</span><input name="address" maxlength="200" value="${h(school?.address || '')}" placeholder="省、市、区县及详细地址"></label><label class="agreement"><input type="checkbox" name="active" ${school?.active === false ? '' : 'checked'}><span>启用该学校，可在公开入口选择并继续绑定管理员、班级和考点</span></label><div class="modal-foot"><button type="button" class="ghost-button" data-action="close-modal">取消</button><button type="submit" class="solid-button">${school ? '保存学校' : '创建学校'}</button></div></form>`);
+  setModal(`<div class="modal-head"><div><span>SCHOOL DIRECTORY</span><h2>${school ? '编辑学校档案' : '创建学校'}</h2><p>学校代码统一标识学校；同一学校可以同时承担生源校和招生校职责。</p></div><button data-action="close-modal">×</button></div><form class="modal-form" data-form="school-form">${school ? `<input type="hidden" name="id" value="${h(school.id)}">` : ''}<div class="field-row"><label><span>学校名称 *</span><input name="name" required maxlength="100" value="${h(school?.name || '')}" placeholder="例如 海州市第四中学"></label><label><span>学校代码 *</span><input name="code" required maxlength="40" pattern="[A-Za-z0-9_-]+" value="${h(school?.code || '')}" placeholder="例如 HZ04"></label></div><label><span>学校地址</span><input name="address" maxlength="200" value="${h(school?.address || '')}" placeholder="省、市、区县及详细地址"></label><section class="school-role-selector"><strong>学校类型（至少选择一项）</strong><div><label><input type="checkbox" name="isSourceSchool" ${school?.isSourceSchool === false ? '' : 'checked'}><span><b>生源校</b><small>可建立班级、管理考生，并接收指标名额</small></span></label><label><input type="checkbox" name="isAdmissionSchool" ${school?.isAdmissionSchool === false ? '' : 'checked'}><span><b>招生校</b><small>可配置招生账号、上传计划并审核投档</small></span></label></div></section><label class="agreement"><input type="checkbox" name="active" ${school?.active === false ? '' : 'checked'}><span>启用该学校；公开报名入口只显示已启用的生源校</span></label><div class="modal-foot"><button type="button" class="ghost-button" data-action="close-modal">取消</button><button type="submit" class="solid-button">${school ? '保存学校' : '创建学校'}</button></div></form>`);
 }
 
 function openSchoolClassForm(schoolClass = null) {
@@ -733,8 +1199,11 @@ function openFlowDetail(id) {
 function openCandidateReview(id) {
   const source = state.pageData.candidates.find(candidate => candidate.id === id);
   const item = { ...source, address: formatRegionAddress(source) };
-  const canReview = item.status === 'pending' && item.workflow?.assignee?.id === state.user.id;
+  const canReview = item.status === 'pending' && (item.workflow?.assignee?.id === state.user.id || state.user.adminLevel === 'super');
-  setModal(`<div class="modal-head"><div><span>CANDIDATE REVIEW</span><h2>${canReview ? '处理' : '查看'} ${h(item.name)} 的资料</h2><p class="mono">报名号 ${h(item.candidateNumber)} · 更新于 ${formatDate(item.updatedAt,true)}</p></div><button data-action="close-modal">×</button></div><div class="review-profile"><dl><div><dt>证件号码</dt><dd class="mono">${h(item.idNumberMasked)}</dd></div><div><dt>性别 / 籍贯</dt><dd>${h(item.gender)} · ${h(item.nativePlace)}</dd></div><div><dt>联系电话</dt><dd>${h(item.phone)}</dd></div><div><dt>电子邮箱</dt><dd>${h(item.email)}</dd></div><div><dt>就读学校</dt><dd>${h(item.school)}</dd></div><div><dt>年级班级</dt><dd>${h(item.grade)}</dd></div><div><dt>家庭住址</dt><dd>${h(item.address)}</dd></div><div><dt>监护人</dt><dd>${h(item.guardianName || item.emergencyContact)} · ${h(item.guardianPhone || item.emergencyPhone)}</dd></div><div><dt>当前步骤</dt><dd>${h(item.workflow?.currentStepDetail?.name || '流程已结束')}</dd></div><div><dt>当前责任人</dt><dd>${h(item.workflow?.assignee?.displayName || '—')}</dd></div></dl></div>${canReview ? `<form class="modal-form" data-form="candidate-review"><input type="hidden" name="id" value="${h(item.id)}"><label><span>审核结论</span><select name="status"><option value="approved">通过当前步骤</option><option value="rejected">退回考生修改</option></select></label><label><span>审核意见</span><textarea name="reviewNote" rows="3" placeholder="填写核验说明或需要补充的资料">${h(item.reviewNote)}</textarea></label><div class="modal-foot"><button type="button" class="ghost-button" data-action="close-modal">取消</button><button type="submit" class="solid-button">确认处理</button></div></form>` : '<div class="modal-foot"><button class="solid-button" data-action="close-modal">关闭</button></div>'}`);
+  const registrations = item.registrations || [];
+  const examCards = registrations.map(registration => `<article class="review-exam-card"><header><div><span class="exam-code">${h(registration.exam?.code || '')}</span><h3>${h(registration.exam?.name || '考试信息异常')}</h3></div>${badge(registration.exam?.archivedAt ? 'archived' : registration.status)}</header><dl><div><dt>考试时间</dt><dd>${dateRange(registration.exam?.examStart, registration.exam?.examEnd)}</dd></div><div><dt>考试地点</dt><dd>${h(registration.exam?.location || '待公布')}</dd></div><div><dt>报名科目</dt><dd><div class="review-subject-list">${registration.subjects?.map(subject => `<span><strong>${h(subject.name)}</strong><small>${h(subject.date || '')} ${h(subject.start || '')} · 满分 ${h(subject.fullScore)} · ${money(subject.fee || 0)}</small></span>`).join('') || '<em>未选择科目</em>'}</div></dd></div><div><dt>报名 / 缴费</dt><dd>${badge(registration.status)} ${badge(registration.paymentStatus)} · 应缴 ${money(registration.amountDue || 0)}</dd></div></dl></article>`).join('');
+  const decision = canReview ? `<form class="review-decision-form" data-form="candidate-review"><input type="hidden" name="id" value="${h(item.id)}"><div><span>当前审核步骤</span><strong>${h(item.workflow?.currentStepDetail?.name || '流程已结束')}</strong><small>责任人：${h(item.workflow?.assignee?.displayName || '—')}</small></div><label><span>审核结论</span><select name="status"><option value="approved">通过当前步骤</option><option value="rejected">退回考生修改</option></select></label><label><span>审核意见</span><textarea name="reviewNote" rows="5" placeholder="填写核验说明；退回时请明确指出需要补充或修改的资料">${h(item.reviewNote || '')}</textarea></label><button type="submit" class="solid-button">确认处理</button></form>` : `<aside class="review-readonly"><strong>当前为只读查看</strong><p>${item.status === 'pending' ? `本步骤由 ${h(item.workflow?.assignee?.displayName || '其他管理员')} 处理。` : `资料状态：${h(statusLabels[item.status] || item.status)}`}</p><button class="ghost-button" data-action="close-modal">返回列表</button></aside>`;
+  setReviewSubpage(`<header class="review-subpage-header"><button class="review-back" data-action="close-modal">← 返回考生资料审核</button><div><span>CANDIDATE DOSSIER</span><h1>${h(item.name)} · 资料审核</h1><p><b class="mono">${h(item.candidateNumber)}</b><i></i>${h(item.school || '学校未填写')} · ${h(item.grade || '班级未填写')}<i></i>更新于 ${formatDate(item.updatedAt, true)}</p></div>${badge(item.status)}</header><div class="review-subpage-layout"><div class="review-subpage-main"><section class="review-section"><header><span>01</span><div><h2>身份与学籍信息</h2><p>核对实名、学籍范围以及联系方式。</p></div></header><dl class="review-detail-grid"><div><dt>证件号码</dt><dd class="mono">${h(item.idNumberMasked)}</dd></div><div><dt>性别 / 出生日期</dt><dd>${h(item.gender || '未填写')} · ${h(item.birthDate || '未填写')}</dd></div><div><dt>籍贯 / 民族</dt><dd>${h(item.nativePlace || '未填写')} · ${h(item.ethnicity || '未填写')}</dd></div><div><dt>就读学校 / 班级</dt><dd>${h(item.school || '未填写')} · ${h(item.grade || '未填写')}</dd></div><div><dt>联系电话</dt><dd>${h(item.phone || '未填写')}</dd></div><div><dt>电子邮箱</dt><dd>${h(item.email || '未填写')}</dd></div><div class="wide"><dt>家庭住址</dt><dd>${h(item.address || '未填写')}</dd></div><div><dt>监护人</dt><dd>${h(item.guardianName || '未填写')} · ${h(item.guardianPhone || '电话未填写')}</dd></div><div><dt>紧急联系人</dt><dd>${h(item.emergencyContact || '未填写')} · ${h(item.emergencyPhone || '电话未填写')}</dd></div></dl></section><section class="review-section"><header><span>02</span><div><h2>关联考试与报名科目</h2><p>审核资料时同时查看该考生历次报名上下文。</p></div><strong>${registrations.length} 场</strong></header><div class="review-exam-list">${examCards || '<div class="review-empty-context"><strong>暂无考试报名</strong><p>该考生当前尚未提交考试报名；资料审核通过后才能选择考试与科目。</p></div>'}</div></section></div>${decision}</div>`);
 }
 
 function openCandidatePasswordReset(id) {
@@ -746,11 +1215,18 @@ function openCandidatePasswordReset(id) {
 function openRegistrationReview(id) {
   const reg = state.pageData.registrations.find(item => item.id === id);
   const canReview = reg.status === 'pending' && (reg.workflow?.assignee?.id === state.user.id || state.user.adminLevel === 'super');
-  setModal(`<div class="modal-head"><div><span>REGISTRATION REVIEW</span><h2>${canReview ? '处理' : '查看'}考试报名</h2><p>${h(reg.candidate?.name)} · ${h(reg.exam.name)}</p></div><button data-action="close-modal">×</button></div><div class="registration-review"><div><span>报考科目</span><p>${reg.subjects.map(subject => `<b>${h(subject.name)}</b>`).join('')}</p></div><dl><div><dt>账户报名号</dt><dd class="mono">${h(reg.registrationNumber || reg.candidate?.candidateNumber || '账户号码异常')}</dd></div><div><dt>当前步骤</dt><dd>${h(reg.workflow?.currentStepDetail?.name || '流程已结束')}</dd></div><div><dt>责任人</dt><dd>${h(reg.workflow?.assignee?.displayName || '—')}</dd></div><div><dt>缴费状态</dt><dd>${badge(reg.paymentStatus)}</dd></div></dl></div>${canReview ? `<form class="modal-form" data-form="registration-review"><input type="hidden" name="id" value="${h(reg.id)}"><label><span>审核结论</span><select name="status"><option value="approved">通过当前步骤</option><option value="rejected">退回报名</option></select></label><label><span>审核意见</span><textarea name="reviewNote" rows="3" placeholder="可填写审核说明">${h(reg.reviewNote || '')}</textarea></label><div class="modal-foot"><button type="button" class="ghost-button" data-action="close-modal">取消</button><button type="submit" class="solid-button">确认处理</button></div></form>` : '<div class="modal-foot"><button class="solid-button" data-action="close-modal">关闭</button></div>'}`);
+  const subjects = reg.subjects || [];
+  const subjectCards = subjects.map((subject, index) => `<article><i>${index + 1}</i><div><strong>${h(subject.name)}</strong><span>${h(subject.date || '日期待定')} ${h(subject.start || '')}${subject.end ? `—${h(subject.end)}` : ''}</span></div><dl><div><dt>满分</dt><dd>${h(subject.fullScore)} 分</dd></div><div><dt>报名费</dt><dd>${money(subject.fee || 0)}</dd></div></dl></article>`).join('');
+  const decision = canReview ? `<form class="review-decision-form" data-form="registration-review"><input type="hidden" name="id" value="${h(reg.id)}"><div><span>当前审核步骤</span><strong>${h(reg.workflow?.currentStepDetail?.name || '流程已结束')}</strong><small>责任人：${h(reg.workflow?.assignee?.displayName || '—')}</small></div><label><span>审核结论</span><select name="status"><option value="approved">通过当前步骤</option><option value="rejected">退回本次报名</option></select></label><label><span>审核意见</span><textarea name="reviewNote" rows="5" placeholder="填写审核依据；退回时请说明考试或科目问题">${h(reg.reviewNote || '')}</textarea></label><button type="submit" class="solid-button">确认处理</button></form>` : `<aside class="review-readonly"><strong>当前为只读查看</strong><p>${reg.status === 'pending' ? `本步骤由 ${h(reg.workflow?.assignee?.displayName || '其他管理员')} 处理。` : `报名状态：${h(statusLabels[reg.status] || reg.status)}`}</p><button class="ghost-button" data-action="close-modal">返回列表</button></aside>`;
+  setReviewSubpage(`<header class="review-subpage-header"><button class="review-back" data-action="close-modal">← 返回报名审核</button><div><span>REGISTRATION DOSSIER</span><h1>${h(reg.candidate?.name)} · 报名审核</h1><p><b class="mono">${h(reg.registrationNumber || reg.candidate?.candidateNumber || '号码待同步')}</b><i></i>${h(reg.schoolName || reg.candidate?.school || '')} · ${h([reg.gradeName, reg.className].filter(Boolean).join(' · '))}</p></div>${badge(reg.status)}</header><div class="review-subpage-layout"><div class="review-subpage-main"><section class="review-section exam-context-hero"><header><span>考试</span><div><p class="exam-code">${h(reg.exam.code)}</p><h2>${h(reg.exam.name)}</h2></div></header><dl class="review-detail-grid"><div><dt>报名时间</dt><dd>${dateRange(reg.exam.registrationStart, reg.exam.registrationEnd)}</dd></div><div><dt>考试时间</dt><dd>${dateRange(reg.exam.examStart, reg.exam.examEnd)}</dd></div><div><dt>考试地点</dt><dd>${h(reg.exam.location || '待公布')}</dd></div><div><dt>本次报名</dt><dd><strong>${subjects.length} 个科目 · 应缴 ${money(reg.amountDue || 0)}</strong></dd></div><div><dt>缴费状态</dt><dd>${badge(reg.paymentStatus)}</dd></div><div><dt>账户报名号</dt><dd class="mono">${h(reg.registrationNumber || reg.candidate?.candidateNumber || '待同步')}</dd></div></dl></section><section class="review-section subject-review-section"><header><span>科目</span><div><h2>本次所报科目</h2><p>逐科核对日期、时间、满分和报名费用。</p></div><strong>${subjects.length} 科</strong></header><div class="review-subject-cards">${subjectCards || '<div class="review-empty-context"><strong>未选择任何科目</strong><p>该报名记录数据异常，不应通过审核。</p></div>'}</div><footer><span>费用合计</span><strong>${money(reg.amountDue || 0)}</strong></footer></section><section class="review-section"><header><span>考生</span><div><h2>考生资料摘要</h2><p>报名审核同时核验身份与学校范围。</p></div></header><dl class="review-detail-grid"><div><dt>姓名 / 性别</dt><dd>${h(reg.candidate?.name || '未填写')} · ${h(reg.candidate?.gender || '未填写')}</dd></div><div><dt>证件号码</dt><dd class="mono">${h(reg.candidate?.idNumber || '未填写')}</dd></div><div><dt>学校 / 班级</dt><dd>${h(reg.schoolName || '')} · ${h([reg.gradeName, reg.className].filter(Boolean).join(' · '))}</dd></div><div><dt>联系电话</dt><dd>${h(reg.candidate?.phone || '未填写')}</dd></div></dl></section></div>${decision}</div>`);
 }
 
-async function openNoticeForm() {
+async function openNoticeForm(notice = null) {
-  setModal(`<div class="modal-head"><div><span>NEW NOTICE</span><h2>发布通知公告</h2><p>发布后将立即显示在公开首页和考生中心。</p></div><button data-action="close-modal">×</button></div><form class="modal-form notice-editor-form" data-form="notice-form"><div class="field-row"><label><span>通知分类</span><select name="category"><option>报名通知</option><option>考试须知</option><option>考点公告</option><option>成绩通知</option><option>系统公告</option></select></label><label><span>发布方式</span><select name="status"><option value="published">立即发布</option><option value="draft">保存草稿</option></select></label></div><label><span>通知标题 *</span><input name="title" required placeholder="清楚说明通知事项"></label><label><span>首页摘要</span><input name="summary" placeholder="用于首页列表展示；留空将从正文自动提取"></label><div class="notice-editor-field"><span>通知正文 *</span><textarea name="content" rows="10" data-notice-editor placeholder="请输入完整通知内容"></textarea><small>图片请点工具栏“通过 URL 插入图片”并填写专用服务器地址；普通文件仍使用超链接。</small></div><label class="agreement"><input type="checkbox" name="pinned"><span>在公开首页置顶展示</span></label><div class="modal-foot"><button type="button" class="ghost-button" data-action="close-modal">取消</button><button type="submit" class="solid-button">保存通知</button></div></form>`);
+  if (notice === undefined) return toast('草稿不存在', '请刷新页面后重试');
+  const editing = Boolean(notice);
+  const categories = ['报名通知', '考试须知', '考点公告', '成绩通知', '系统公告'];
+  if (notice?.category && !categories.includes(notice.category)) categories.push(notice.category);
+  setModal(`<div class="modal-head"><div><span>${editing ? 'EDIT DRAFT' : 'NEW NOTICE'}</span><h2>${editing ? '编辑通知草稿' : '发布通知公告'}</h2><p>${editing ? '修改后可继续保存草稿，也可直接发布。' : '发布后将立即显示在公开首页和考生中心。'}</p></div><button data-action="close-modal">×</button></div><form class="modal-form notice-editor-form" data-form="notice-form">${editing ? `<input type="hidden" name="id" value="${h(notice.id)}">` : ''}<div class="field-row"><label><span>通知分类</span><select name="category">${categories.map(category => `<option ${category === notice?.category ? 'selected' : ''}>${h(category)}</option>`).join('')}</select></label><label><span>发布方式</span><select name="status"><option value="published" ${notice?.status === 'published' ? 'selected' : ''}>立即发布</option><option value="draft" ${!notice || notice.status === 'draft' ? 'selected' : ''}>保存草稿</option></select></label></div><label><span>通知标题 *</span><input name="title" required placeholder="清楚说明通知事项" value="${h(notice?.title || '')}"></label><label><span>首页摘要</span><input name="summary" placeholder="用于首页列表展示；留空将从正文自动提取" value="${h(notice?.summary || '')}"></label><div class="notice-editor-field"><span>通知正文 *</span><textarea name="content" rows="10" data-notice-editor placeholder="请输入完整通知内容">${h(notice?.content || '')}</textarea><small>图片请点工具栏“通过 URL 插入图片”并填写专用服务器地址；普通文件仍使用超链接。</small></div><label class="agreement"><input type="checkbox" name="pinned" ${notice?.pinned ? 'checked' : ''}><span>在公开首页置顶展示</span></label><div class="modal-foot"><button type="button" class="ghost-button" data-action="close-modal">取消</button><button type="submit" class="solid-button">${editing ? '保存修改' : '保存通知'}</button></div></form>`);
   const source = modalRoot.querySelector('[data-notice-editor]');
   try {
     const [ckeditor, translation] = await loadCKEditor();
@@ -885,7 +1361,16 @@ function openAdmitPreview(reg) {
 }
 
 window.addEventListener('hashchange', renderRoute);
-window.addEventListener('keydown', event => { if (event.key === 'Escape') closeModal(); });
+window.addEventListener('keydown', event => {
+  if (event.key === 'Escape') closeModal();
+  if ((event.ctrlKey || event.metaKey) && event.key.toLowerCase() === 's') {
+    const form = document.querySelector('form[data-form="result-bulk-entry"]');
+    if (form) {
+      event.preventDefault();
+      form.requestSubmit(form.querySelector('[data-result-mode="draft"]'));
+    }
+  }
+});
 
 try {
   await Promise.all([refreshPublic(), refreshSession()]);

compose.yaml

@@ -0,0 +1,22 @@
+services:
+  app:
+    build:
+      context: .
+    image: exam-information-system:local
+    init: true
+    restart: unless-stopped
+    env_file:
+      - .env.docker
+    environment:
+      NODE_ENV: production
+      HOST: 0.0.0.0
+      PORT: 4173
+      DATABASE_CLIENT: sqlite
+      SQLITE_PATH: /app/data/exam.sqlite
+    ports:
+      - "4173:4173"
+    volumes:
+      - exam-information-data:/app/data
+
+volumes:
+  exam-information-data:

database.mjs

@@ -3,6 +3,7 @@ import { dirname, join, resolve } from 'node:path';
 import { mysqlSchema, sqliteSchema } from './src/database/schema.mjs';
 import { createSqliteAdapter } from './src/database/sqlite-adapter.mjs';
 import { createMysqlAdapter } from './src/database/mysql-adapter.mjs';
+import { CURRENT_SCHEMA_VERSION } from './src/database/version.mjs';
 
 export const relationalTables = [
   'schema_metadata',
@@ -35,6 +36,7 @@ export const relationalTables = [
   'workflow_steps',
   'workflow_instances',
   'workflow_actions',
+  'admission_records',
   'audit_logs'
 ];
 
@@ -44,7 +46,7 @@ function validateState(state, source = '数据库') {
     'testCenters', 'testRooms', 'centerChangeRequests', 'centerChangeRooms',
     'admissionNumberRules', 'arrangementPlans',
     'numberRules', 'candidateAccountBatches', 'candidateAccountBatchItems',
-    'workflows', 'workflowInstances', 'workflowActions', 'auditLogs'
+    'workflows', 'workflowInstances', 'workflowActions', 'admissionRecords', 'auditLogs'
   ];
   if (!state || typeof state !== 'object' || collections.some(name => !Array.isArray(state[name]))) {
     throw new Error(`${source}中的应用数据格式无效`);
@@ -59,7 +61,7 @@ export function buildSeedOperations(state) {
   const nullable = value => value == null || value === '' ? null : value;
 
   add(
-    'UPDATE schema_metadata SET schema_version = 17, app_version = ?, self_registration_enabled = ?, created_at = ? WHERE id = 1',
+    `UPDATE schema_metadata SET schema_version = ${CURRENT_SCHEMA_VERSION}, app_version = ?, self_registration_enabled = ?, created_at = ? WHERE id = 1`,
     Number(state.meta?.version || 1), state.settings?.selfRegistrationEnabled ? 1 : 0,
     state.meta?.createdAt || new Date().toISOString()
   );
@@ -70,8 +72,9 @@ export function buildSeedOperations(state) {
 
   for (const school of state.schools) {
     add(
-      'INSERT INTO schools (id, name, code, address, active) VALUES (?, ?, ?, ?, ?)',
+      'INSERT INTO schools (id, name, code, address, is_source_school, is_admission_school, active) VALUES (?, ?, ?, ?, ?, ?, ?)',
-      school.id, school.name, school.code, nullable(school.address), school.active === false ? 0 : 1
+      school.id, school.name, school.code, nullable(school.address), school.isSourceSchool === false ? 0 : 1,
+      school.isAdmissionSchool === false ? 0 : 1, school.active === false ? 0 : 1
     );
   }
 
@@ -100,8 +103,9 @@ export function buildSeedOperations(state) {
         id, user_id, name, gender, id_number, phone, email, school, grade, school_id, class_id,
         province_code, province_name, city_code, city_name, district_code, district_name, address,
         emergency_contact, emergency_phone, native_place, birth_date, ethnicity, postal_code, guardian_name,
-        guardian_phone, profile_completed, status, review_note, reviewed_at, reviewer_id, updated_at
+        guardian_phone, specialty_category, specialty_type, specialty_types, specialty_certificate, policy_eligibility,
-      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+        profile_completed, status, review_note, reviewed_at, reviewer_id, updated_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
       profile.id, profile.userId, profile.name, nullable(profile.gender), profile.idNumber, profile.phone,
       nullable(profile.email), nullable(profile.school), nullable(profile.grade), nullable(profile.schoolId),
       nullable(profile.classId), nullable(profile.provinceCode), nullable(profile.provinceName),
@@ -109,6 +113,8 @@ export function buildSeedOperations(state) {
       nullable(profile.address),
       nullable(profile.emergencyContact), nullable(profile.emergencyPhone), nullable(profile.nativePlace), nullable(profile.birthDate),
       nullable(profile.ethnicity), nullable(profile.postalCode), nullable(profile.guardianName), nullable(profile.guardianPhone),
+      nullable(profile.specialtyCategory), nullable(profile.specialtyType), JSON.stringify(profile.specialtyTypes || []),
+      nullable(profile.specialtyCertificate), nullable(profile.policyEligibility),
       profile.profileCompleted ? 1 : 0, profile.status, nullable(profile.reviewNote),
       nullable(profile.reviewedAt), nullable(profile.reviewerId), profile.updatedAt
     );
@@ -150,12 +156,12 @@ export function buildSeedOperations(state) {
     add(
       `INSERT INTO registrations (
         id, user_id, exam_id, status, payment_status, paid_at, paid_by, created_at, reviewed_at, review_note,
-        registration_number, number_rule_id
+        registration_number, number_rule_id, feature_score
-      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
       registration.id, registration.userId, registration.examId, registration.status,
       registration.paymentStatus, nullable(registration.paidAt), nullable(registration.paidBy), registration.createdAt,
       nullable(registration.reviewedAt), nullable(registration.reviewNote),
-      nullable(registration.registrationNumber), nullable(registration.numberRuleId)
+      nullable(registration.registrationNumber), nullable(registration.numberRuleId), Number(registration.featureScore || 0)
     );
     for (const subjectId of registration.subjectIds) {
       add('INSERT INTO registration_subjects (registration_id, subject_id) VALUES (?, ?)', registration.id, subjectId);
@@ -335,6 +341,16 @@ export function buildSeedOperations(state) {
     );
   }
 
+  for (const record of state.admissionRecords) {
+    add(
+      `INSERT INTO admission_records (
+        id, kind, exam_id, user_id, school_id, status, payload_json, created_at, updated_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+      record.id, record.kind, record.examId, nullable(record.userId), nullable(record.schoolId), record.status,
+      JSON.stringify(record.payload || {}), record.createdAt, record.updatedAt
+    );
+  }
+
   for (const log of state.auditLogs) {
     add(
       'INSERT INTO audit_logs (id, actor_id, action, detail, created_at) VALUES (?, ?, ?, ?, ?)',
@@ -346,6 +362,10 @@ export function buildSeedOperations(state) {
 }
 
 function stateFromRows(rows) {
+  const parseJson = (value, fallback) => {
+    if (value != null && typeof value === 'object') return value;
+    try { return JSON.parse(value || JSON.stringify(fallback)); } catch { return fallback; }
+  };
   const subjectsByExam = new Map();
   for (const row of rows.subjects) {
     const fullScore = Number(row.full_score ?? 150);
@@ -451,6 +471,8 @@ function stateFromRows(rows) {
       name: row.name,
       code: row.code,
       address: row.address || '',
+      isSourceSchool: row.is_source_school == null ? true : Boolean(row.is_source_school),
+      isAdmissionSchool: row.is_admission_school == null ? true : Boolean(row.is_admission_school),
       active: Boolean(row.active)
     })),
     classes: rows.classes.map(row => ({
@@ -507,6 +529,11 @@ function stateFromRows(rows) {
       postalCode: row.postal_code || '',
       guardianName: row.guardian_name || '',
       guardianPhone: row.guardian_phone || '',
+      specialtyCategory: row.specialty_category || '',
+      specialtyType: row.specialty_type || '',
+      specialtyTypes: parseJson(row.specialty_types, []),
+      specialtyCertificate: row.specialty_certificate || '',
+      policyEligibility: row.policy_eligibility || '',
       profileCompleted: Boolean(row.profile_completed),
       status: row.status,
       reviewNote: row.review_note || '',
@@ -560,6 +587,7 @@ function stateFromRows(rows) {
       reviewNote: row.review_note || '',
       registrationNumber: row.registration_number || '',
       numberRuleId: row.number_rule_id || null,
+      featureScore: Number(row.feature_score || 0),
       admitCard: admitCards.get(row.id) || null
     })),
     results: rows.results.map(row => ({
@@ -738,6 +766,17 @@ function stateFromRows(rows) {
       toAssigneeId: row.to_assignee_id,
       createdAt: row.created_at
     })),
+    admissionRecords: rows.admissionRecords.map(row => ({
+      id: row.id,
+      kind: row.kind,
+      examId: row.exam_id,
+      userId: row.user_id || null,
+      schoolId: row.school_id || null,
+      status: row.status,
+      payload: parseJson(row.payload_json, {}),
+      createdAt: row.created_at,
+      updatedAt: row.updated_at
+    })),
     auditLogs: rows.auditLogs.map(row => ({
       id: row.id,
       actorId: row.actor_id,
@@ -779,6 +818,7 @@ function readSqliteRows(connection) {
     workflowSteps: connection.prepare('SELECT * FROM workflow_steps ORDER BY workflow_id, position, id').all(),
     workflowInstances: connection.prepare('SELECT * FROM workflow_instances ORDER BY created_at DESC, id').all(),
     workflowActions: connection.prepare('SELECT * FROM workflow_actions ORDER BY created_at, id').all(),
+    admissionRecords: connection.prepare('SELECT * FROM admission_records ORDER BY created_at, id').all(),
     auditLogs: connection.prepare('SELECT * FROM audit_logs ORDER BY created_at DESC, id DESC').all()
   };
 }
@@ -815,6 +855,7 @@ async function readMysqlRows(connection) {
     workflowSteps: await query('SELECT * FROM workflow_steps ORDER BY workflow_id, position, id'),
     workflowInstances: await query('SELECT * FROM workflow_instances ORDER BY created_at DESC, id'),
     workflowActions: await query('SELECT * FROM workflow_actions ORDER BY created_at, id'),
+    admissionRecords: await query('SELECT * FROM admission_records ORDER BY created_at, id'),
     auditLogs: await query('SELECT * FROM audit_logs ORDER BY created_at DESC, id DESC')
   };
 }
@@ -925,6 +966,7 @@ function createRepository({ client, location, read, transaction, close }) {
             province_code = ?, province_name = ?, city_code = ?, city_name = ?, district_code = ?, district_name = ?, address = ?,
             school_id = ?, class_id = ?, emergency_contact = ?, emergency_phone = ?, status = ?, review_note = ?,
             native_place = ?, birth_date = ?, ethnicity = ?, postal_code = ?, guardian_name = ?, guardian_phone = ?,
+            specialty_category = ?, specialty_type = ?, specialty_types = ?, specialty_certificate = ?, policy_eligibility = ?,
             profile_completed = ?, reviewed_at = ?, reviewer_id = ?, updated_at = ?
           WHERE id = ?`,
           profile.name, optional(profile.gender), profile.idNumber, profile.phone, optional(profile.email),
@@ -933,7 +975,9 @@ function createRepository({ client, location, read, transaction, close }) {
           optional(profile.address), optional(profile.schoolId),
           optional(profile.classId), optional(profile.emergencyContact), optional(profile.emergencyPhone), profile.status,
           optional(profile.reviewNote), optional(profile.nativePlace), optional(profile.birthDate), optional(profile.ethnicity),
-          optional(profile.postalCode), optional(profile.guardianName), optional(profile.guardianPhone), profile.profileCompleted ? 1 : 0, optional(profile.reviewedAt),
+          optional(profile.postalCode), optional(profile.guardianName), optional(profile.guardianPhone), optional(profile.specialtyCategory),
+          optional(profile.specialtyType), JSON.stringify(profile.specialtyTypes || []),
+          optional(profile.specialtyCertificate), optional(profile.policyEligibility), profile.profileCompleted ? 1 : 0, optional(profile.reviewedAt),
           optional(profile.reviewerId), profile.updatedAt, profile.id
         ),
         operation('UPDATE users SET display_name = ? WHERE id = ?', displayName, profile.userId)
@@ -978,12 +1022,12 @@ function createRepository({ client, location, read, transaction, close }) {
       const operations = [operation(
         `INSERT INTO registrations (
           id, user_id, exam_id, status, payment_status, paid_at, paid_by, created_at, reviewed_at, review_note,
-          registration_number, number_rule_id
+          registration_number, number_rule_id, feature_score
-        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
         registration.id, registration.userId, registration.examId, registration.status,
         registration.paymentStatus, optional(registration.paidAt), optional(registration.paidBy), registration.createdAt,
         optional(registration.reviewedAt), optional(registration.reviewNote),
-        optional(registration.registrationNumber), optional(registration.numberRuleId)
+        optional(registration.registrationNumber), optional(registration.numberRuleId), Number(registration.featureScore || 0)
       )];
       for (const subjectId of registration.subjectIds) {
         operations.push(operation(
@@ -1186,15 +1230,68 @@ function createRepository({ client, location, read, transaction, close }) {
         auditOperation(log)
       ]);
     },
+    async createAdmissionSchoolAccount(user, log) {
+      await transaction([
+        operation(
+          `INSERT INTO users (
+            id, username, password_hash, role, admin_level, school_id, class_id, active, display_name, created_at
+          ) VALUES (?, ?, ?, 'admission_school', NULL, ?, NULL, ?, ?, ?)`,
+          user.id, user.username, user.passwordHash, user.schoolId, user.active === false ? 0 : 1, user.displayName, user.createdAt
+        ),
+        auditOperation(log)
+      ]);
+    },
+    async updateFeatureScore(registration, log) {
+      await transaction([
+        operation('UPDATE registrations SET feature_score = ? WHERE id = ?', Number(registration.featureScore || 0), registration.id),
+        auditOperation(log)
+      ]);
+    },
+    async updateFeatureScores(entries) {
+      const operations = [];
+      for (const { registration, log } of entries) {
+        operations.push(operation('UPDATE registrations SET feature_score = ? WHERE id = ?', Number(registration.featureScore || 0), registration.id));
+        operations.push(auditOperation(log));
+      }
+      await transaction(operations);
+    },
+    async saveAdmissionRecord(record, log = null) {
+      const operations = [operation('DELETE FROM admission_records WHERE id = ?', record.id), operation(
+        `INSERT INTO admission_records (
+          id, kind, exam_id, user_id, school_id, status, payload_json, created_at, updated_at
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+        record.id, record.kind, record.examId, optional(record.userId), optional(record.schoolId), record.status,
+        JSON.stringify(record.payload || {}), record.createdAt, record.updatedAt
+      )];
+      if (log) operations.push(auditOperation(log));
+      await transaction(operations);
+    },
+    async saveAdmissionRecords(records, log = null) {
+      const operations = [];
+      for (const record of records) {
+        operations.push(operation('DELETE FROM admission_records WHERE id = ?', record.id));
+        operations.push(operation(
+          `INSERT INTO admission_records (
+            id, kind, exam_id, user_id, school_id, status, payload_json, created_at, updated_at
+          ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+          record.id, record.kind, record.examId, optional(record.userId), optional(record.schoolId), record.status,
+          JSON.stringify(record.payload || {}), record.createdAt, record.updatedAt
+        ));
+      }
+      if (log) operations.push(auditOperation(log));
+      await transaction(operations);
+    },
     async saveSchool(school, isNew, log) {
       const change = isNew
         ? operation(
-            'INSERT INTO schools (id, name, code, address, active) VALUES (?, ?, ?, ?, ?)',
+            'INSERT INTO schools (id, name, code, address, is_source_school, is_admission_school, active) VALUES (?, ?, ?, ?, ?, ?, ?)',
-            school.id, school.name, school.code, optional(school.address), school.active ? 1 : 0
+            school.id, school.name, school.code, optional(school.address), school.isSourceSchool ? 1 : 0,
+            school.isAdmissionSchool ? 1 : 0, school.active ? 1 : 0
           )
         : operation(
-            'UPDATE schools SET name = ?, code = ?, address = ?, active = ? WHERE id = ?',
+            'UPDATE schools SET name = ?, code = ?, address = ?, is_source_school = ?, is_admission_school = ?, active = ? WHERE id = ?',
-            school.name, school.code, optional(school.address), school.active ? 1 : 0, school.id
+            school.name, school.code, optional(school.address), school.isSourceSchool ? 1 : 0,
+            school.isAdmissionSchool ? 1 : 0, school.active ? 1 : 0, school.id
           );
       await transaction([change, auditOperation(log)]);
     },

excel.mjs

@@ -85,7 +85,8 @@ const resourceSpecs = {
   results: {
     title: '考试成绩台账', sheet: '成绩',
     columns: [
-      ['candidateNumber', '报名号*', 26, '2026-HZ01-X-0001'], ['candidateName', '姓名（只读参考）', 16, ''],
+      ['candidateNumber', '报名号*', 26, '2026-HZ01-X-0001'], ['cardNumber', '准考证号（只读参考）', 24, ''],
+      ['candidateName', '姓名（只读参考）', 16, ''], ['schoolName', '学校（只读参考）', 24, ''], ['className', '班级（只读参考）', 20, ''],
       ['examCode', '考试代码*', 20, 'EX-2026-AUT'], ['examName', '考试名称（只读参考）', 28, ''],
       ['subjectName', '科目*', 16, '语文'], ['fullScore', '科目满分（只读参考）', 18, ''],
       ['passRule', '单科及格规则（只读参考）', 26, ''], ['passScore', '实际及格分（只读参考）', 20, ''],
@@ -108,6 +109,21 @@ const resourceSpecs = {
       ['examRoomCode', '考试考场序号', 16, ''], ['roomName', '考场通用名称', 20, ''], ['roomCode', '物理场地代码', 16, ''],
       ['building', '楼栋', 16, ''], ['floor', '楼层', 12, ''], ['seat', '座位号', 12, '']
     ]
+  },
+  admitted_candidates: {
+    title: '录取考生信息表', sheet: '录取考生',
+    columns: [
+      ['candidateNumber', '报名号', 26, ''], ['name', '姓名', 14, ''], ['gender', '性别', 10, ''],
+      ['idNumber', '证件号码', 24, ''], ['phone', '手机号', 18, ''], ['email', '邮箱', 24, ''],
+      ['birthDate', '出生日期', 14, ''], ['ethnicity', '民族', 12, ''], ['nativePlace', '籍贯', 18, ''],
+      ['sourceSchoolCode', '生源学校代码', 16, ''], ['sourceSchool', '生源学校', 26, ''], ['className', '班级', 18, ''],
+      ['address', '家庭住址', 36, ''], ['guardianName', '监护人', 14, ''], ['guardianPhone', '监护人电话', 18, ''],
+      ['specialty', '特长生资格', 20, ''], ['specialtyCertificate', '特长证明编号', 20, ''], ['policyEligibility', '政策资格说明', 24, ''],
+      ['featureScore', '特征分', 12, ''], ['subjectScores', '各科成绩', 42, ''], ['totalScore', '考生总成绩', 14, ''],
+      ['admittedSchool', '录取学校', 26, ''], ['categoryName', '录取类别', 20, ''], ['preferenceOrder', '志愿序号', 12, '']
+    ],
+    numberColumns: ['featureScore', 'totalScore', 'preferenceOrder'],
+    numberFormats: { featureScore: '0.00', totalScore: '0.00', preferenceOrder: '0' }
   }
 };
 

package-lock.json

@@ -1787,12 +1787,12 @@
       ]
     },
     "node_modules/escape-string-regexp": {
-      "version": "4.0.0",
+      "version": "5.0.0",
-      "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-4.0.0.tgz",
+      "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-5.0.0.tgz",
-      "integrity": "sha512-TtpcNJ3XAzx3Gq8sWRzJaVajRs0uVxA2YAkdb1jm2YkPz4G6egUFAyA3n5vtEIZefPk5Wa4UXbKuS5fKkJWdgA==",
+      "integrity": "sha512-/veY75JbMK4j1yjvuUxuVsiS/hr/4iHs9FTT6cgTexxdE0Ly/glccBAkloH/DofkjRbZU3bnoj38mOmhkZ0lHw==",
       "license": "MIT",
       "engines": {
-        "node": ">=10"
+        "node": ">=12"
       },
       "funding": {
         "url": "https://github.com/sponsors/sindresorhus"
@@ -2543,18 +2543,6 @@
         "url": "https://opencollective.com/unified"
       }
     },
-    "node_modules/mdast-util-find-and-replace/node_modules/escape-string-regexp": {
-      "version": "5.0.0",
-      "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-5.0.0.tgz",
-      "integrity": "sha512-/veY75JbMK4j1yjvuUxuVsiS/hr/4iHs9FTT6cgTexxdE0Ly/glccBAkloH/DofkjRbZU3bnoj38mOmhkZ0lHw==",
-      "license": "MIT",
-      "engines": {
-        "node": ">=12"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
     "node_modules/mdast-util-from-markdown": {
       "version": "2.0.3",
       "resolved": "https://registry.npmjs.org/mdast-util-from-markdown/-/mdast-util-from-markdown-2.0.3.tgz",
@@ -3843,6 +3831,18 @@
         "node": ">=22.12.0"
       }
     },
+    "node_modules/sanitize-html/node_modules/escape-string-regexp": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-4.0.0.tgz",
+      "integrity": "sha512-TtpcNJ3XAzx3Gq8sWRzJaVajRs0uVxA2YAkdb1jm2YkPz4G6egUFAyA3n5vtEIZefPk5Wa4UXbKuS5fKkJWdgA==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
     "node_modules/saxes": {
       "version": "5.0.1",
       "resolved": "https://registry.npmjs.org/saxes/-/saxes-5.0.1.tgz",

package.json

@@ -5,7 +5,7 @@
   "type": "module",
   "scripts": {
     "start": "node server.mjs",
-    "test": "node tests/cache.test.mjs && node tests/system.test.mjs",
+    "test": "node tests/client-auth.test.mjs && node tests/cache.test.mjs && node tests/admission.test.mjs && node tests/seed.test.mjs && node tests/system.test.mjs",
     "test:cache": "node tests/cache.test.mjs",
     "reset-db": "node scripts/reset-dev-database.mjs",
     "seed-test-data": "node scripts/import-test-data.mjs",

scripts/import-test-data.mjs

@@ -6,6 +6,7 @@ import { loadEnvFile } from 'node:process';
 import { buildSeedOperations, createDatabase, relationalTables } from '../database.mjs';
 import { createBaseDatabase } from '../src/data/base.mjs';
 import { createSeedDatabase } from '../src/data/seed.mjs';
+import { CURRENT_SCHEMA_VERSION } from '../src/database/version.mjs';
 
 const root = resolve(process.cwd());
 const envPath = join(root, '.env');
@@ -73,7 +74,7 @@ const mysqlBusinessTables = [
   'schools', 'school_classes', 'candidate_profiles', 'notices', 'exams', 'exam_subjects',
   'registrations', 'registration_subjects', 'exam_arrangement_plans', 'admit_cards', 'admit_card_subjects',
   'results', 'test_centers', 'test_rooms', 'center_change_requests', 'center_change_rooms',
-  'candidate_account_batches', 'candidate_account_batch_items', 'workflow_instances', 'workflow_actions', 'audit_logs'
+  'candidate_account_batches', 'candidate_account_batch_items', 'workflow_instances', 'workflow_actions', 'admission_records', 'audit_logs'
 ];
 
 async function prepareMysql() {
@@ -101,8 +102,8 @@ async function prepareMysql() {
     }
 
     const [metadataRows] = await connection.query('SELECT schema_version FROM schema_metadata WHERE id = 1');
-    if (Number(metadataRows[0]?.schema_version) !== 16) {
+    if (Number(metadataRows[0]?.schema_version) !== CURRENT_SCHEMA_VERSION) {
-      throw new Error(`MySQL 数据库结构版本不是 v16（当前 ${metadataRows[0]?.schema_version ?? '未知'}），请先完成结构初始化`);
+      throw new Error(`MySQL 数据库结构版本不是 v${CURRENT_SCHEMA_VERSION}（当前 ${metadataRows[0]?.schema_version ?? '未知'}），请先完成结构初始化`);
     }
 
     const [examPartitionRows] = await connection.query(
@@ -127,8 +128,8 @@ async function prepareMysql() {
     let recognizedTestData = false;
     if (initializeEmpty && nonEmpty.length) {
       const [[bulkUsers]] = await connection.query("SELECT COUNT(*) AS count FROM users WHERE id LIKE 'usr_bulk_%'");
-      const [[testSchools]] = await connection.query("SELECT COUNT(*) AS count FROM schools WHERE id IN ('school_hz1', 'school_hz3', 'school_hz5', 'school_hz7')");
+      const [[testSchools]] = await connection.query("SELECT COUNT(*) AS count FROM schools WHERE id IN ('school_hz1', 'school_hz3', 'school_hz5', 'school_hz7', 'school_hz9')");
-      recognizedTestData = Number(bulkUsers.count) >= 300 && Number(testSchools.count) === 4;
+      recognizedTestData = Number(bulkUsers.count) >= 1100 && Number(testSchools.count) === 5;
     }
     if (nonEmpty.length && !force && !recognizedTestData) {
       const forceCommand = initializeEmpty
@@ -193,8 +194,9 @@ if (initializeEmpty) {
   console.log(`${state.users.length} initial administrator, ${state.schools.length} schools, ${state.candidateProfiles.length} candidates, ${state.registrations.length} registrations`);
 } else {
   console.log(`Imported test data into ${location}${mysqlAlreadyImported ? ' (transactional replace)' : ''}`);
-  console.log(`${state.schools.length} schools, ${state.candidateProfiles.length} candidates, ${state.registrations.length} registrations`);
+  console.log(`${state.schools.filter(item => item.isSourceSchool).length} source schools, ${state.schools.filter(item => item.isAdmissionSchool).length} admission schools, ${state.candidateProfiles.length} candidates, ${state.registrations.length} registrations`);
   console.log(`pending ${pending}, rejected ${rejected}, approved/unpaid ${unpaid}, approved/paid ${paid}`);
+  console.log(`${state.results.length} published subject scores, ${state.admissionRecords.filter(item => item.kind === 'preference' && Number(item.payload?.round || 1) === 1).length} first-round preferences`);
   console.log(`arrangement plans ${state.arrangementPlans.length}, admit cards ${state.registrations.filter(item => item.admitCard).length}`);
   console.log('all predefined test account passwords: 12345678');
 }

scripts/reset-dev-database.mjs

@@ -1,35 +1,4 @@
-import { pbkdf2Sync, randomBytes } from 'node:crypto';
+// Keep the historical reset-db entry point, but run the same guarded initializer used
-import { rm } from 'node:fs/promises';
+// by initialize-system so SQLite, MySQL, .env loading and schema checks stay in sync.
-import { isAbsolute, join, relative, resolve } from 'node:path';
+if (!process.argv.slice(2).includes('--empty')) process.argv.push('--empty');
-import { createDatabase } from '../database.mjs';
+await import('./import-test-data.mjs');
-import { createBaseDatabase } from '../src/data/base.mjs';
-
-const root = resolve(process.cwd());
-const databasePath = join(root, 'data', 'exam.sqlite');
-const relativePath = relative(root, databasePath);
-if (!relativePath || relativePath.startsWith('..') || isAbsolute(relativePath)) throw new Error('拒绝重建工作区以外的数据库');
-
-for (const path of [databasePath, `${databasePath}-shm`, `${databasePath}-wal`]) await rm(path, { force: true });
-
-function hashPassword(password, salt = randomBytes(16).toString('hex')) {
-  const hash = pbkdf2Sync(password, salt, 120000, 32, 'sha256').toString('hex');
-  return `${salt}:${hash}`;
-}
-
-process.env.DATABASE_CLIENT = 'sqlite';
-process.env.SQLITE_PATH = databasePath;
-const database = await createDatabase({
-  root,
-  seed: () => createBaseDatabase({
-    nowIso: () => new Date().toISOString(),
-    hashPassword,
-    initialAdmin: {
-      username: process.env.INITIAL_ADMIN_USERNAME,
-      password: process.env.INITIAL_ADMIN_PASSWORD,
-      displayName: process.env.INITIAL_ADMIN_DISPLAY_NAME
-    }
-  })
-});
-const state = await database.read();
-await database.close();
-console.log(`Rebuilt empty ${databasePath} (schema ${state.meta.version}, ${state.candidateProfiles.length} candidates)`);

server.mjs

@@ -8,6 +8,7 @@ import { createDatabase } from './database.mjs';
 import { buildCenterMaterialsWorkbook, buildWorkbook, hasExcelResource, parseWorkbook } from './excel.mjs';
 import { createAdminRoutes } from './src/routes/admin.routes.mjs';
 import { createCandidateRoutes } from './src/routes/candidate.routes.mjs';
+import { createAdmissionRoutes } from './src/routes/admission.routes.mjs';
 import { createAuthRoutes } from './src/routes/auth.routes.mjs';
 import { createPublicRoutes } from './src/routes/public.routes.mjs';
 import { adminLevelNames, adminScopeLabel, createPermissionGuard, hasPermission, permissionsByLevel, profileInScope, registrationInScope } from './src/security/authorization.mjs';
@@ -45,11 +46,14 @@ const staticFiles = new Set([
   '/src/client/api.mjs',
   '/src/client/admin-views.mjs',
   '/src/client/candidate-views.mjs',
+  '/src/client/admission-views.mjs',
+  '/src/client/admission-plan-editor.mjs',
   '/src/client/public-views.mjs',
   '/src/client/state.mjs',
   '/src/client/ui.mjs',
   '/src/client/region-select.mjs',
-  '/src/data/china-regions.mjs'
+  '/src/data/china-regions.mjs',
+  '/src/data/specialty-types.mjs'
 ]);
 const vendorStaticFiles = new Map([
   ['/vendor/ckeditor5/ckeditor5.js', join(root, 'node_modules', 'ckeditor5', 'dist', 'browser', 'ckeditor5.js')],
@@ -96,7 +100,7 @@ const initializeDatabase = () => createBaseDatabase({
 });
 const persistentDatabase = await createDatabase({ root, seed: initializeDatabase });
 const cache = await createRedisCache();
-const resultCacheWriteMethods = new Set(['saveResult', 'saveResults', 'updateExam', 'archiveExam']);
+const resultCacheWriteMethods = new Set(['saveResult', 'saveResults', 'updateFeatureScore', 'updateFeatureScores', 'updateExam', 'archiveExam']);
 const database = withCacheInvalidation(persistentDatabase, cache, (method, args) => {
   const namespaces = ['public'];
   const instance = args[0];
@@ -353,12 +357,46 @@ function gradeForRank(rank, cohortSize) {
   return 'D';
 }
 
+const resultIndexCache = new WeakMap();
+const examSummaryCache = new WeakMap();
+
+function resultIndexes(db) {
+  let indexes = resultIndexCache.get(db);
+  if (indexes) return indexes;
+  const publishedScoresBySubject = new Map();
+  const publishedByRegistration = new Map();
+  for (const result of db.results) {
+    if (!result.published) continue;
+    if (!publishedScoresBySubject.has(result.subjectId)) publishedScoresBySubject.set(result.subjectId, []);
+    publishedScoresBySubject.get(result.subjectId).push(Number(result.score));
+    if (!publishedByRegistration.has(result.registrationId)) publishedByRegistration.set(result.registrationId, []);
+    publishedByRegistration.get(result.registrationId).push(result);
+  }
+  for (const scores of publishedScoresBySubject.values()) scores.sort((left, right) => left - right);
+  indexes = { publishedScoresBySubject, publishedByRegistration };
+  resultIndexCache.set(db, indexes);
+  return indexes;
+}
+
+function countScoresGreaterThan(sortedScores, score) {
+  let low = 0;
+  let high = sortedScores.length;
+  while (low < high) {
+    const middle = Math.floor((low + high) / 2);
+    if (sortedScores[middle] <= score) low = middle + 1;
+    else high = middle;
+  }
+  return sortedScores.length - low;
+}
+
 function resultRankInfo(db, result, scoreOverride = result?.score) {
   if (!result?.subjectId || !Number.isFinite(Number(scoreOverride))) return { rank: null, cohortSize: 0, rankPercent: null, grade: '' };
   const score = Number(scoreOverride);
-  const peers = db.results.filter(item => item.id !== result.id && item.subjectId === result.subjectId && item.published);
+  const scores = resultIndexes(db).publishedScoresBySubject.get(result.subjectId) || [];
-  const cohortSize = peers.length + 1;
+  const cohortSize = scores.length + (result.published ? 0 : 1);
-  const rank = 1 + peers.filter(item => Number(item.score) > score).length;
+  let greater = countScoresGreaterThan(scores, score);
+  if (result.published && Number(result.score) > score) greater -= 1;
+  const rank = 1 + Math.max(0, greater);
   const rankPercent = Number((rank / cohortSize * 100).toFixed(2));
   return { rank, cohortSize, rankPercent, grade: gradeForRank(rank, cohortSize) };
 }
@@ -375,15 +413,43 @@ function subjectPassEvaluation(db, result, subject, scoreOverride = result?.scor
   return { ...resultRankInfo(db, result, scoreOverride), qualified: Number(scoreOverride) >= passScore, passScore, cutoffRank: null };
 }
 
+function examSummaryIndexes(db) {
+  let indexes = examSummaryCache.get(db);
+  if (indexes) return indexes;
+  const examById = new Map(db.exams.map(exam => [exam.id, exam]));
+  const publishedByRegistration = resultIndexes(db).publishedByRegistration;
+  const baseByRegistration = new Map();
+  const totalsByCohort = new Map();
+  for (const registration of db.registrations) {
+    if (registration.status !== 'approved') continue;
+    const exam = examById.get(registration.examId);
+    if (!exam) continue;
+    const subjects = exam.subjects.filter(subject => registration.subjectIds.includes(subject.id));
+    const published = publishedByRegistration.get(registration.id) || [];
+    const resultsBySubject = new Map(published.map(result => [result.subjectId, result]));
+    const complete = subjects.length > 0 && subjects.every(subject => resultsBySubject.has(subject.id));
+    const total = subjects.reduce((sum, subject) => sum + Number(resultsBySubject.get(subject.id)?.score || 0), 0);
+    const fullScore = subjects.reduce((sum, subject) => sum + Number(subject.fullScore || 0), 0);
+    const subjectKey = [...registration.subjectIds].sort().join('|');
+    const cohortKey = `${exam.id}\u0000${subjectKey}`;
+    const base = { exam, subjects, published, resultsBySubject, complete, total, fullScore, cohortKey };
+    baseByRegistration.set(registration.id, base);
+    if (complete) {
+      if (!totalsByCohort.has(cohortKey)) totalsByCohort.set(cohortKey, []);
+      totalsByCohort.get(cohortKey).push(total);
+    }
+  }
+  for (const totals of totalsByCohort.values()) totals.sort((left, right) => left - right);
+  indexes = { baseByRegistration, totalsByCohort };
+  examSummaryCache.set(db, indexes);
+  return indexes;
+}
+
 function examResultSummary(db, registration) {
-  const exam = db.exams.find(item => item.id === registration.examId);
+  const summaryIndexes = examSummaryIndexes(db);
-  if (!exam) return null;
+  const base = summaryIndexes.baseByRegistration.get(registration.id);
-  const subjects = exam.subjects.filter(subject => registration.subjectIds.includes(subject.id));
+  if (!base) return null;
-  const published = db.results.filter(result => result.registrationId === registration.id && result.published);
+  const { exam, subjects, published, resultsBySubject, complete, total, fullScore, cohortKey } = base;
-  const resultsBySubject = new Map(published.map(result => [result.subjectId, result]));
-  const complete = subjects.length > 0 && subjects.every(subject => resultsBySubject.has(subject.id));
-  const total = subjects.reduce((sum, subject) => sum + Number(resultsBySubject.get(subject.id)?.score || 0), 0);
-  const fullScore = subjects.reduce((sum, subject) => sum + Number(subject.fullScore || 0), 0);
   const scoreRatio = fullScore ? total / fullScore * 100 : 0;
   const policy = exam.passPolicy === 'score_ratio' ? 'rank_percent' : (exam.passPolicy || 'rank_percent');
   const value = Number(exam.passValue ?? 60);
@@ -398,17 +464,9 @@ function examResultSummary(db, registration) {
   });
   if (complete && policy === 'none') qualified = null;
   if (complete && policy === 'rank_percent') {
-    const subjectKey = [...registration.subjectIds].sort().join('|');
+    const totals = summaryIndexes.totalsByCohort.get(cohortKey) || [];
-    const totals = db.registrations
-      .filter(item => item.examId === exam.id && item.status === 'approved' && [...item.subjectIds].sort().join('|') === subjectKey)
-      .map(item => {
-        const itemResults = db.results.filter(result => result.registrationId === item.id && result.published);
-        if (!item.subjectIds.every(id => itemResults.some(result => result.subjectId === id))) return null;
-        return itemResults.filter(result => item.subjectIds.includes(result.subjectId)).reduce((sum, result) => sum + Number(result.score), 0);
-      })
-      .filter(item => item != null);
     cohortSize = totals.length;
-    rank = 1 + totals.filter(item => item > total).length;
+    rank = 1 + countScoresGreaterThan(totals, total);
     qualified = rank <= Math.max(1, Math.ceil(cohortSize * value / 100));
   }
 
@@ -421,6 +479,7 @@ function examResultSummary(db, registration) {
     complete,
     publishedSubjects: published.length,
     subjectCount: subjects.length,
+    featureScore: Number(registration.featureScore || 0),
     total,
     fullScore,
     scoreRatio: Number(scoreRatio.toFixed(2)),
@@ -457,7 +516,7 @@ function logAction(db, user, action, detail) {
 const excelResourceNames = {
   classes: '班级台账', class_admins: '班级管理员', account_quotas: '报名号班级配额',
   account_results: '报名号下发结果', candidates: '考生资料', payments: '考试缴费名单', centers: '考点考场档案', results: '成绩台账',
-  admit_cards: '准考证信息台账'
+  admit_cards: '准考证信息台账', admitted_candidates: '录取考生信息'
 };
 
 function admissionRowsForRegistrations(db, registrations) {
@@ -553,23 +612,26 @@ function excelRowsForResource(db, user, resource, searchParams) {
   });
   if (resource === 'results') {
     const examId = cleanText(searchParams.get('examId'), 64);
-    const scopedRegistrations = db.registrations.filter(item => registrationInScope(db, user, item));
+    const scopedRegistrations = db.registrations.filter(item => item.status === 'approved' && registrationInScope(db, user, item) && (!examId || item.examId === examId));
-    return db.results.filter(result => scopedRegistrations.some(item => item.id === result.registrationId && (!examId || item.examId === examId))).map(result => {
+    return scopedRegistrations.flatMap(registration => {
-      const registration = db.registrations.find(item => item.id === result.registrationId);
       const exam = db.exams.find(item => item.id === registration?.examId);
-      const subject = exam?.subjects.find(item => item.id === result.subjectId);
       const account = db.users.find(item => item.id === registration?.userId);
       const profile = db.candidateProfiles.find(item => item.userId === registration?.userId);
-      const evaluation = subjectPassEvaluation(db, result, subject);
+      const schoolClass = db.classes.find(item => item.id === profile?.classId);
-      const rank = resultRankInfo(db, result);
+      return (exam?.subjects || []).filter(subject => registration.subjectIds.includes(subject.id)).map(subject => {
-      return {
+        const result = db.results.find(item => item.registrationId === registration.id && item.subjectId === subject.id);
-        candidateNumber: account?.candidateNumber || '', candidateName: profile?.name || account?.displayName || '',
+        const evaluation = result ? subjectPassEvaluation(db, result, subject) : null;
-        examCode: exam?.code || '', examName: exam?.name || '', subjectName: subject?.name || '',
+        const rank = result ? resultRankInfo(db, result) : null;
-        fullScore: subject?.fullScore || '', passRule: subjectPassText(subject), passScore: evaluation.passScore ?? '', score: result.score,
+        return {
-        rank: rank.rank, rankPercent: rank.rankPercent,
+          candidateNumber: account?.candidateNumber || registration.registrationNumber || '', cardNumber: registration.admitCard?.number || '',
-        qualified: evaluation.qualified == null ? '不判定' : evaluation.qualified ? '达线' : '未达线',
+          candidateName: profile?.name || account?.displayName || '', schoolName: profile?.school || '', className: schoolClass?.name || profile?.grade || '',
-        grade: result.published ? resultRankInfo(db, result).grade : '待发布', published: result.published ? '发布' : '不发布', updatedAt: result.updatedAt || result.publishedAt || ''
+          examCode: exam?.code || '', examName: exam?.name || '', subjectName: subject?.name || '',
-      };
+          fullScore: subject?.fullScore || '', passRule: subjectPassText(subject), passScore: evaluation?.passScore ?? '', score: result?.score ?? '',
+          rank: rank?.rank ?? '', rankPercent: rank?.rankPercent ?? '',
+          qualified: !result || evaluation?.qualified == null ? '' : evaluation.qualified ? '达线' : '未达线',
+          grade: result ? (result.published ? rank?.grade || '' : '待发布') : '', published: result?.published ? '发布' : '不发布', updatedAt: result?.updatedAt || result?.publishedAt || ''
+        };
+      });
     });
   }
   if (resource === 'admit_cards') {
@@ -904,6 +966,7 @@ const routeContext = {
 const handlePublic = createPublicRoutes(routeContext);
 const handleAuth = createAuthRoutes(routeContext);
 const handleCandidate = createCandidateRoutes(routeContext);
+const handleAdmission = createAdmissionRoutes(routeContext);
 const handleAdmin = createAdminRoutes(routeContext);
 
 async function serveStatic(response, pathname) {
@@ -929,6 +992,8 @@ const server = createServer(async (request, response) => {
     if (authHandled !== false) return;
     const candidateHandled = await handleCandidate(request, response, pathname);
     if (candidateHandled !== false) return;
+    const admissionHandled = await handleAdmission(request, response, pathname);
+    if (admissionHandled !== false) return;
     const adminHandled = await handleAdmin(request, response, pathname);
     if (adminHandled !== false) return;
     if (await serveStatic(response, pathname)) return;

src/client/admission-plan-editor.mjs

@@ -0,0 +1,16 @@
+import { specialtyCatalog } from '../data/specialty-types.mjs';
+
+export function indicatorAllocationEditor(h, sourceSchools = [], allocation = {}) {
+  return `<div class="indicator-allocation-row"><label><span>生源学校</span><select name="indicatorSchool"><option value="">请选择生源校</option>${sourceSchools.map(school => `<option value="${h(school.id)}" ${school.id === allocation.sourceSchoolId ? 'selected' : ''}>${h(school.code)} · ${h(school.name)}</option>`).join('')}</select></label><label><span>分配名额</span><input name="indicatorQuota" type="number" min="1" step="1" value="${h(allocation.quota || '')}" placeholder="人数"></label><button type="button" class="row-action" data-action="remove-indicator-allocation">移除</button></div>`;
+}
+
+export function admissionCategoryEditor(h, sourceSchools = [], category = {}) {
+  const specialty = Boolean(category.specialtyCategory);
+  const selectedCategory = specialtyCatalog.find(item => item.code === category.specialtyCategory);
+  return `<article class="admission-category-editor"><header><div><span>招生类别</span><strong>${h(category.name || '新类别')}</strong></div><button type="button" data-action="remove-admission-category">移除类别</button></header><div class="admission-category-fields"><label><span>类别名称 *</span><input name="categoryName" required maxlength="80" value="${h(category.name || '')}" placeholder="例如：普通生、艺术特长生"></label><label><span>计划人数 *</span><input name="categoryQuota" required type="number" min="1" step="1" value="${h(category.quota || '')}" placeholder="人数"></label><label><span>类别性质</span><select name="categoryKind" data-action="plan-category-kind"><option value="general" ${specialty ? '' : 'selected'}>普通 / 政策类</option><option value="specialty" ${specialty ? 'selected' : ''}>特长生</option></select></label><div class="specialty-plan-fields ${specialty ? '' : 'hidden'}" data-plan-specialty><label><span>特长大类 *</span><select name="categorySpecialtyCategory" data-action="specialty-category" ${specialty ? '' : 'disabled'}><option value="">请选择大类</option>${specialtyCatalog.map(item => `<option value="${h(item.code)}" ${item.code === category.specialtyCategory ? 'selected' : ''}>${h(item.name)}</option>`).join('')}</select></label><label><span>特长小类 *</span><select name="categorySpecialtyType" data-specialty-type ${specialty && selectedCategory ? '' : 'disabled'}><option value="">${selectedCategory ? '请选择小类' : '请先选择大类'}</option>${(selectedCategory?.types || []).map(item => `<option value="${h(item.code)}" ${item.code === category.specialtyType ? 'selected' : ''}>${h(item.name)}</option>`).join('')}</select></label></div></div><section class="indicator-allocation-editor"><div class="indicator-allocation-head"><div><strong>指标分配</strong><small>可把本类别计划的一部分定向分配给生源校，合计不得超过计划人数。</small></div><button type="button" class="row-action" data-action="add-indicator-allocation">添加生源校指标</button></div><div data-indicator-allocations>${(category.indicatorAllocations || []).map(item => indicatorAllocationEditor(h, sourceSchools, item)).join('')}</div></section></article>`;
+}
+
+export function admissionCategoriesEditor(h, sourceSchools = [], categories = []) {
+  const initial = categories.length ? categories : [{ name: '普通生', quota: '', indicatorAllocations: [] }];
+  return `<section class="admission-categories-builder"><div class="admission-builder-head"><div><strong>招生类别与计划</strong><small>逐项设置类别、资格范围和生源校指标。</small></div><button type="button" class="row-action primary" data-action="add-admission-category">添加招生类别</button></div><div data-admission-categories>${initial.map(category => admissionCategoryEditor(h, sourceSchools, category)).join('')}</div></section>`;
+}

src/client/admission-views.mjs

@@ -0,0 +1,61 @@
+export function createAdmissionViews(context) {
+  const { state, app, h, formatDate, badge, icons, api, renderError, requireLogin, brand } = context;
+  const nav = [['dashboard','工作台','home'],['plans','招生计划','exam'],['placements','投档审核','check']];
+
+  function shell(page, content, title, description) {
+    return `<div class="portal"><aside class="portal-sidebar" id="portalSidebar"><div class="portal-brand">${brand()}<button data-action="close-sidebar">×</button></div><p class="portal-role">招生学校 · ${h(state.pageData?.school?.name || '')}</p><nav>${nav.map(([id,label,icon]) => `<button class="${page === id ? 'active' : ''}" data-route="admission_school/${id}"><span>${icons[icon]}</span>${label}</button>`).join('')}</nav><div class="sidebar-help"><span>当前数据范围</span><strong>仅本校招生数据</strong><small>考生志愿不可见、不可修改</small></div></aside><main class="portal-main"><header class="portal-topbar"><button class="sidebar-toggle" data-action="open-sidebar">${icons.menu}</button><div><span>招生学校</span><b>/</b><strong>${h(title)}</strong></div><div class="portal-user"><span class="user-avatar">${h((state.user?.displayName || '招').slice(0,1))}</span><span><strong>${h(state.user?.displayName)}</strong><small>招生学校账号</small></span><button class="logout-button" data-action="logout">${icons.logout}</button></div></header><section class="portal-content"><div class="portal-heading"><div><p class="overline">SCHOOL ADMISSION</p><h1>${h(title)}</h1><p>${h(description)}</p></div></div>${content}</section></main></div>`;
+  }
+
+  async function renderAdmission(page) {
+    if (state.user?.role !== 'admission_school') return requireLogin();
+    if (!nav.some(item => item[0] === page)) page = 'dashboard';
+    const meta = { dashboard:['招生工作台','查看本校计划与待审核投档概况。'], plans:['本校招生计划','上传本年度普通生、特长生计划及指标分配，提交后由超级管理员审核。'], placements:['投档考生审核','查看投档考生资料和本场成绩；无特殊理由不得申请退档。'] };
+    app.innerHTML = shell(page, '<div class="loading-panel"><i></i><span>正在读取数据</span></div>', ...meta[page]);
+    try {
+      const endpoint = page === 'dashboard' ? 'context' : page;
+      const data = await api(`/api/admission/${endpoint}`); state.pageData = data;
+      const content = page === 'dashboard' ? dashboard(data) : page === 'plans' ? plans(data) : placements(data);
+      app.innerHTML = shell(page, content, ...meta[page]);
+    } catch (error) { renderError(error); }
+  }
+
+  function dashboard(data) {
+    return `<section class="admission-command-banner school"><div><span>ADMISSION OFFICE</span><h2>${h(data.school.name)}</h2><p>学校只接收超级管理员正式投档的数据，不可查看考生完整志愿表。</p></div></section><div class="admin-dashboard-grid"><section class="panel admin-todos"><div class="panel-title"><h2>本校工作入口</h2><span>${data.exams.length} 场启用志愿</span></div><button data-route="admission_school/plans"><i>计</i><span><strong>上传招生计划</strong><small>普通生、特长生与指标分配</small></span>${icons.arrow}</button><button data-route="admission_school/placements"><i>审</i><span><strong>审核投档考生</strong><small>接收或提交特殊退档理由</small></span>${icons.arrow}</button></section></div>`;
+  }
+
+  function paged(items, key, defaultPageSize = 50) {
+    const current = state.tablePages[key] || {};
+    const pageSize = [20, 50, 100].includes(Number(current.pageSize)) ? Number(current.pageSize) : defaultPageSize;
+    const total = items.length;
+    const totalPages = Math.max(1, Math.ceil(total / pageSize));
+    const page = Math.min(Math.max(1, Number(current.page) || 1), totalPages);
+    state.tablePages[key] = { page, pageSize };
+    return { items: items.slice((page - 1) * pageSize, page * pageSize), page, pageSize, total, totalPages, key };
+  }
+
+  function pagination(meta) {
+    if (!meta || meta.total <= meta.pageSize) return '';
+    const start = (meta.page - 1) * meta.pageSize + 1;
+    const end = Math.min(meta.total, meta.page * meta.pageSize);
+    const pages = [...new Set([1, meta.page - 1, meta.page, meta.page + 1, meta.totalPages])].filter(page => page >= 1 && page <= meta.totalPages);
+    return `<nav class="table-pagination" aria-label="列表分页"><span>第 ${start}—${end} 条，共 ${meta.total} 条</span><div><button type="button" data-action="table-page" data-table-key="${h(meta.key)}" data-page="${meta.page - 1}" ${meta.page === 1 ? 'disabled' : ''}>上一页</button>${pages.map((page, index) => `${index && page - pages[index - 1] > 1 ? '<i>…</i>' : ''}<button type="button" class="${page === meta.page ? 'active' : ''}" data-action="table-page" data-table-key="${h(meta.key)}" data-page="${page}">${page}</button>`).join('')}<button type="button" data-action="table-page" data-table-key="${h(meta.key)}" data-page="${meta.page + 1}" ${meta.page === meta.totalPages ? 'disabled' : ''}>下一页</button><label>每页 <select data-action="table-page-size" data-table-key="${h(meta.key)}">${[20, 50, 100].map(size => `<option value="${size}" ${size === meta.pageSize ? 'selected' : ''}>${size}</option>`).join('')}</select> 条</label></div></nav>`;
+  }
+
+  function plans(data) {
+    const planPage = paged(data.plans, 'schoolAdmissionPlanTable', 20);
+    return `<section class="panel admission-plan-console structured"><div class="panel-title"><div><h2>提交本校招生计划</h2><p>按招生类别设置计划人数、特长资格和各生源校指标，提交后由超级管理员审核。</p></div></div><form data-form="school-admission-plan"><label><span>招生考试 *</span><select name="examId" required>${data.exams.map(exam => `<option value="${h(exam.id)}">${h(exam.name)}</option>`).join('')}</select></label>${admissionCategoriesEditor(h, data.sourceSchools)}<label><span>计划说明</span><textarea name="note" rows="2" placeholder="填写政策依据或补充说明"></textarea></label><button class="solid-button" type="submit">提交超级管理员审核</button></form></section><section class="panel data-panel"><div class="table-scroll"><table id="schoolAdmissionPlanTable"><thead><tr><th>考试</th><th>类别计划</th><th>指标分配</th><th>状态</th><th>审核意见</th></tr></thead><tbody>${planPage.items.map(plan => `<tr><td>${h(data.exams.find(exam => exam.id === plan.examId)?.name || plan.examId)}</td><td>${plan.payload.categories.map(item => `<strong>${h(item.name)} ${h(item.quota)} 人</strong><small>${h(specialtyLabel(item.specialtyCategory, item.specialtyType) || '普通 / 政策类')}</small>`).join('')}</td><td>${plan.payload.categories.flatMap(category => (category.indicatorAllocations || []).map(allocation => `${h(data.sourceSchools.find(item => item.id === allocation.sourceSchoolId)?.name || allocation.sourceSchoolId)} ${h(allocation.quota)} 人`)).join('<br>') || '无定向指标'}</td><td>${badge(plan.status)}</td><td>${h(plan.payload.reviewNote || '等待审核')}</td></tr>`).join('') || '<tr><td colspan="5" class="empty-state">尚未提交计划</td></tr>'}</tbody></table></div>${pagination(planPage)}</section>`;
+  }
+
+  function placements(data) {
+    const exportBar = data.completedExams?.length ? `<section class="panel admission-export-bar"><div><span>FINAL ROSTER</span><strong>正式录取考生信息 Excel</strong><small>仅录取工作结束后开放，包含本校全部正式录取考生资料与当次成绩。</small></div><label><span>已完成考试</span><select name="exportExamId">${data.completedExams.map(exam => `<option value="${h(exam.id)}">${h(exam.name)}</option>`).join('')}</select></label><button class="solid-button" data-action="download-admitted-candidates">下载 Excel</button></section>` : '';
+    const exams = [...new Map(data.placements.map(item => [item.examId, item.examName])).entries()];
+    const categories = [...new Set(data.placements.map(item => item.payload.categoryName).filter(Boolean))];
+    const pendingCount = data.placements.filter(item => item.status === 'school_review').length;
+    const placementPage = paged(data.placements, 'placementReviewTable');
+    const rows = placementPage.items.map(item => `<tr data-status="${h(item.status)}" data-exam="${h(item.examId)}" data-category="${h(item.payload.categoryName)}"><td><input type="checkbox" data-placement-select value="${h(item.id)}" ${item.status === 'school_review' ? '' : 'disabled'} aria-label="选择 ${h(item.candidate.name)}"></td><td><strong>${h(item.candidate.name)}</strong><small class="mono">${h(item.candidate.registrationNumber)} · ${h(item.candidate.idNumberMasked)}</small><small>${h(item.examName)}</small></td><td>${h(item.candidate.specialtyLabel || '普通生')}<small>${h(item.candidate.specialtyCertificate || '')}</small><small>${h(item.candidate.policyEligibility || '')}</small></td><td>${item.results.map(result => `${h(result.subjectName)} ${h(result.score)}`).join('<br>')}<strong>投档分 ${h(item.payload.totalScore)} · 特征分 ${h(item.featureScore || 0)}</strong></td><td>${h(item.payload.categoryName)}<small>第 ${h(item.payload.preferenceOrder)} 志愿</small></td><td>${badge(item.status)}</td><td>${item.status === 'school_review' ? `<form class="placement-review-form" data-form="placement-review"><input type="hidden" name="id" value="${h(item.id)}"><select name="decision"><option value="accept">接收</option><option value="withdraw">申请退档</option></select><input name="note" placeholder="退档须填写至少 8 字理由"><button class="row-action primary" type="submit">确认</button></form>` : `<small>${h(item.payload.schoolDecisionNote || '已处理')}</small>`}</td></tr>`).join('');
+    return `${exportBar}<section class="panel data-panel placement-review-ledger"><div class="panel-title"><div><h2>本校投档审核台账</h2><p>可搜索、筛选和多选批量处理；仅待审核记录可被选中。</p></div><span>${pendingCount} 人待审 / 共 ${data.placements.length} 人</span></div><div class="data-toolbar"><label class="search-box">${icons.search}<input data-action="table-search" data-target="placementReviewTable" placeholder="搜索当前页的姓名、报名号、考试、类别或资格"></label><div class="table-filter-selects"><select data-table-filter="exam" data-target="placementReviewTable"><option value="">全部考试</option>${exams.map(([id, name]) => `<option value="${h(id)}">${h(name)}</option>`).join('')}</select><select data-table-filter="category" data-target="placementReviewTable"><option value="">全部招生类别</option>${categories.map(category => `<option value="${h(category)}">${h(category)}</option>`).join('')}</select><button type="button" class="row-action" data-action="clear-table-filters" data-target="placementReviewTable">清除筛选</button></div></div><div class="filter-pills placement-status-pills"><button type="button" class="active" data-action="status-filter" data-target="placementReviewTable" data-status="all">全部</button><button type="button" data-action="status-filter" data-target="placementReviewTable" data-status="school_review">待审核</button><button type="button" data-action="status-filter" data-target="placementReviewTable" data-status="admitted">已接收</button><button type="button" data-action="status-filter" data-target="placementReviewTable" data-status="withdrawal_pending">退档待审</button><button type="button" data-action="status-filter" data-target="placementReviewTable" data-status="final">正式录取</button></div><div class="placement-bulk-toolbar"><label><input type="checkbox" data-placement-select-all data-target="placementReviewTable"><span>选择当前页筛选结果中的待审核考生</span></label><div><strong data-placement-selected-count>已选 0 人</strong><button type="button" class="ghost-button" data-action="bulk-placement-review" data-decision="withdraw">批量申请退档</button><button type="button" class="solid-button" data-action="bulk-placement-review" data-decision="accept">批量接收</button></div></div><div class="table-scroll"><table id="placementReviewTable"><thead><tr><th class="select-column">选择</th><th>考生 / 考试</th><th>资格</th><th>当次成绩</th><th>投档类别</th><th>状态</th><th>单人审核</th></tr></thead><tbody>${rows || '<tr><td colspan="7" class="empty-state">暂无投档考生</td></tr>'}</tbody></table></div>${pagination(placementPage)}</section>`;
+  }
+  return { renderAdmission };
+}
+import { admissionCategoriesEditor } from './admission-plan-editor.mjs';
+import { specialtyLabel } from '../data/specialty-types.mjs';

src/client/api.mjs

@@ -8,6 +8,10 @@ export async function api(path, options = {}) {
   });
   const type = response.headers.get('content-type') || '';
   const data = type.includes('application/json') ? await response.json() : await response.text();
-  if (!response.ok) throw new Error(data?.message || '操作未完成，请稍后重试');
+  if (!response.ok) {
+    const error = new Error(data?.message || '操作未完成，请稍后重试');
+    error.status = response.status;
+    throw error;
+  }
   return data;
 }

src/client/candidate-views.mjs

@@ -1,4 +1,5 @@
 import { mountRegionSelects } from './region-select.mjs';
+import { resolveProfileSpecialty, specialtyCatalog, specialtyLabel } from '../data/specialty-types.mjs';
 
 export function createCandidateViews(context) {
   const {
@@ -14,23 +15,23 @@ export function createCandidateViews(context) {
     icons,
     api,
     renderError,
+    requireLogin,
     emptyState,
     brand
   } = context;
 
   const candidateNav = [
     ['dashboard', '总览', 'home'], ['profile', '个人资料', 'user'], ['exams', '考试报名', 'exam'],
-    ['registrations', '我的报名', 'check'], ['admit', '准考证', 'ticket'], ['results', '成绩查询', 'chart'], ['notices', '通知公告', 'bell'],
+    ['registrations', '我的报名', 'check'], ['admit', '准考证', 'ticket'], ['results', '成绩查询', 'chart'], ['admissions', '志愿与录取', 'check'], ['notices', '通知公告', 'bell'],
     ['security', '账户安全', 'user']
   ];
   function adminNavForUser() {
     const level = state.user?.adminLevel || 'super';
     const core = [['dashboard', '工作台', 'home'], ['candidates', level === 'class' ? '本班考生' : '考生信息', 'users'], ['registrations', level === 'class' ? '报名状态' : '报名审核', 'check'], ['payments', level === 'class' ? '缴费确认' : '缴费名单', 'ticket'], ['results', level === 'super' ? '成绩发布' : '成绩查看', 'chart']];
     const security = ['security', '账户安全', 'user'];
-    if (level === 'class') return [core[0], core[1], core[2], core[3], ['admit', '本班准考证', 'ticket'], ['flows', '流程中心', 'check'], core[4], security];
+    if (level === 'class') return [core[0], core[1], core[2], core[3], ['admit', '本班准考证', 'ticket'], core[4], ['flows', '流程中心', 'check'], security];
-    const operations = [['flows', '流程中心', 'check'], ['centers', '考场信息', 'exam']];
+    if (level === 'school') return [core[0], ['organization', '本校组织', 'users'], ['account-batches', '批量建号', 'ticket'], core[1], ['indicator-qualifications', '指标资格确认', 'check'], core[2], core[3], ['admit', '校内准考证', 'ticket'], core[4], ['centers', '考场信息', 'exam'], ['flows', '流程中心', 'check'], security];
-    if (level === 'school') return [core[0], ['organization', '本校组织', 'users'], ['account-batches', '批量建号', 'ticket'], core[1], core[2], core[3], ['admit', '校内准考证', 'ticket'], ...operations, core[4], security];
+    return [core[0], ['schools', '学校管理', 'exam'], ['admins', '管理员', 'users'], core[1], ['exams', '考试与科目', 'exam'], core[2], core[3], ['admit', '准考证编排', 'ticket'], core[4], ['admissions', '招生录取', 'check'], ['notices', '通知发布', 'bell'], ['centers', '考场信息', 'exam'], ['flows', '流程监督', 'check'], ['flow-design', '流程设计', 'exam'], ['number-rules', '报名号规则', 'ticket'], security];
-    return [core[0], ['schools', '学校管理', 'exam'], ['admins', '管理员', 'users'], core[1], core[2], core[3], ['flows', '流程监督', 'check'], ['flow-design', '流程设计', 'exam'], ['number-rules', '报名号规则', 'ticket'], ['centers', '考场信息', 'exam'], ['exams', '考试与科目', 'exam'], ['notices', '通知发布', 'bell'], ['admit', '准考证编排', 'ticket'], core[4], security];
   }
   
   function portalShell(role, page, content, title, description) {
@@ -55,6 +56,14 @@ export function createCandidateViews(context) {
     return `<div class="loading-panel"><i></i><span>正在读取数据</span></div>`;
   }
 
+  function mountAdmissionProfileFields(profile = {}) {
+    const actions = app.querySelector('.profile-form .form-actions');
+    if (!actions || app.querySelector('[data-admission-profile-fields]')) return;
+    const qualification = resolveProfileSpecialty(profile);
+    const selectedCategory = specialtyCatalog.find(item => item.code === qualification.category);
+    actions.insertAdjacentHTML('beforebegin', `<div class="form-section-title" data-admission-profile-fields><span>04</span><div><h2>中考招生资格</h2><p>特长资格按大类和小类登记，填志愿时系统只显示与本人资格相符的招生类别。</p></div></div><div class="form-grid specialty-qualification-grid"><label><span>特长生大类</span><select name="specialtyCategory" data-action="specialty-category"><option value="">无特长生资格</option>${specialtyCatalog.map(item => `<option value="${h(item.code)}" ${item.code === qualification.category ? 'selected' : ''}>${h(item.name)}</option>`).join('')}</select></label><label><span>特长生小类</span><select name="specialtyType" data-specialty-type ${selectedCategory ? '' : 'disabled'}><option value="">${selectedCategory ? '请选择小类' : '请先选择大类'}</option>${(selectedCategory?.types || []).map(item => `<option value="${h(item.code)}" ${item.code === qualification.type ? 'selected' : ''}>${h(item.name)}</option>`).join('')}</select></label><label><span>特长证明编号</span><input name="specialtyCertificate" value="${h(profile.specialtyCertificate || '')}" placeholder="证书或统一测试材料编号"></label><label class="wide-field"><span>政策资格说明</span><input name="policyEligibility" value="${h(profile.policyEligibility || '')}" placeholder="例如：指标生资格已核验"></label></div>`);
+  }
+  
   function onboardingShell(stage, content) {
     const passwordDone = stage !== 'password';
     return `<main class="onboarding-page"><aside class="onboarding-identity">${brand()}<span>固定报名号</span><strong>${h(state.user.candidateNumber)}</strong><p>这个号码就是你的考生账户。以后参加不同考试，仍然使用同一个报名号。</p><div class="onboarding-steps"><div class="${stage === 'password' ? 'current' : 'done'}"><i>${passwordDone ? '✓' : '1'}</i><span><b>修改初始密码</b><small>设置仅本人知道的新密码</small></span></div><div class="${stage === 'profile' ? 'current' : passwordDone ? '' : ''}"><i>2</i><span><b>补全个人信息</b><small>实名、籍贯、住址和学籍信息</small></span></div><div><i>3</i><span><b>等待资料审核</b><small>审核通过后开始考试报名</small></span></div></div><button data-action="logout">退出当前账户</button></aside><section class="onboarding-work"><div class="onboarding-work-head"><span>FIRST SIGN-IN</span><h1>${stage === 'password' ? '先保护你的账户' : '建立完整考生档案'}</h1><p>${stage === 'password' ? '初始密码只用于第一次登录。修改成功后才可填写个人信息。' : '带 * 的信息会用于身份核验、学校管理范围和考试联系。'}</p></div>${content}</section></main>`;
@@ -65,7 +74,7 @@ export function createCandidateViews(context) {
   }
   
   async function renderCandidate(page) {
-    if (state.user?.role !== 'candidate') return navigate('login');
+    if (state.user?.role !== 'candidate') return requireLogin();
     app.classList.remove('admin-readable');
     if (state.user.mustChangePassword) {
       app.innerHTML = onboardingShell('password', passwordOnboardingForm());
@@ -76,6 +85,7 @@ export function createCandidateViews(context) {
         const data = await api('/api/candidate/profile');
         state.pageData = data; state.profile = data.profile;
         app.innerHTML = onboardingShell('profile', candidateProfile(data, true));
+        mountAdmissionProfileFields(data.profile);
         mountRegionSelects(app, data.profile, { className: 'region-selects wide-field' });
       } catch (error) { renderError(error); }
       return;
@@ -87,23 +97,24 @@ export function createCandidateViews(context) {
       registrations: ['我的报名', '查看已提交的考试、科目与审核进度。'],
       admit: ['准考证', '管理员生成后，可在规定下载时间内保存准考证。'],
       results: ['成绩查询', '仅显示考试中心已经正式发布的成绩。'],
+      admissions: ['志愿填报与录取', '成绩发布后由本人填报志愿，并在这里查看投档与录取进度。'],
       notices: ['通知公告', '查看与报名、考试和成绩相关的最新消息。'],
       security: ['账户安全', '使用当前密码设置新的登录密码。']
     };
     if (!meta[page]) page = 'dashboard';
     app.innerHTML = portalShell('candidate', page, loadingPanel(), ...meta[page]);
     try {
-      const endpoint = page === 'dashboard' ? 'dashboard' : page === 'profile' ? 'profile' : page === 'exams' ? 'exams' : page === 'results' ? 'results' : 'registrations';
+      const endpoint = page === 'dashboard' ? 'dashboard' : page === 'profile' ? 'profile' : page === 'exams' ? 'exams' : page === 'results' ? 'results' : page === 'admissions' ? 'admissions' : 'registrations';
       const data = page === 'notices' ? { notices: state.publicData.notices } : page === 'security' ? await api('/api/auth/totp') : await api(`/api/candidate/${endpoint}`);
       state.pageData = data;
       if (data.profile) state.profile = data.profile;
       const content = {
         dashboard: () => candidateDashboard(data), profile: () => candidateProfile(data), exams: () => candidateExams(data),
         registrations: () => candidateRegistrations(data.registrations), admit: () => candidateAdmit(data.registrations),
-        results: () => candidateResults(data), notices: () => candidateNotices(data.notices), security: () => accountSecurity(data)
+        results: () => candidateResults(data), admissions: () => candidateAdmissions(data), notices: () => candidateNotices(data.notices), security: () => accountSecurity(data)
       }[page]();
       app.innerHTML = portalShell('candidate', page, content, ...meta[page]);
-      if (page === 'profile') mountRegionSelects(app, data.profile, { className: 'region-selects wide-field' });
+      if (page === 'profile') { mountAdmissionProfileFields(data.profile); mountRegionSelects(app, data.profile, { className: 'region-selects wide-field' }); }
     } catch (error) { renderError(error); }
   }
   
@@ -177,11 +188,38 @@ export function createCandidateViews(context) {
         const lineState = item.qualified == null ? 'neutral' : item.qualified ? 'qualified' : 'unqualified';
         return `<article class="${lineState}"><div class="score-subject-head"><span>${h(item.subjectName)}</span><i>${item.qualified == null ? '不判定单科' : item.qualified ? '单科达线' : '单科未达线'}</i></div><strong>${h(item.score)}<small> / ${h(item.fullScore)}</small></strong><em>${h(item.grade)} · 第 ${h(item.rank)} / ${h(item.cohortSize)} 名 · 前 ${h(item.rankPercent)}%</em><div class="rank-rule-line"><span>本科排名</span><b>${h(item.passText || '不设单科线')}</b></div>${appealPanel}</article>`;
       }).join('');
-      const panel = `<section class="panel result-panel ${items[0].archivedAt ? 'archived' : ''}"><header><div><span>${h(items[0].examCode)}</span><h2>${h(examName)}</h2></div><small>${items[0].archivedAt ? `${formatDate(items[0].archivedAt, true)} 归档并锁定` : `最近发布 ${formatDate([...items].sort((a,b) => new Date(b.publishedAt) - new Date(a.publishedAt))[0].publishedAt, true)}`}</small></header><div class="result-summary ${summary?.qualified === true ? 'qualified' : summary?.qualified === false ? 'unqualified' : ''}"><span><small>当前总分</small><strong>${h(summary?.total ?? '—')}<em> / ${h(summary?.fullScore ?? '—')}</em></strong><i>科目等级按排名</i></span><span><small>整场合格判定</small><strong>${h(stateText)}</strong><em>${h(detail)}</em></span><span><small>发布进度</small><strong>${h(summary?.publishedSubjects ?? items.length)}<em> / ${h(summary?.subjectCount ?? items.length)} 科</em></strong><i>${summary?.complete ? '成绩已出齐' : '持续发布中'}</i></span></div><div class="score-grid">${scores}</div><footer><p>${items[0].archivedAt ? '本场所有成绩已永久锁定，以下内容仅保留历史查阅。' : '等级按同场同科已发布成绩排名计算；复议改分后只重新判断本人成绩所在排名区间。'}</p><strong>已发布 ${items.length} 科</strong></footer></section>`;
+      const panel = `<section class="panel result-panel ${items[0].archivedAt ? 'archived' : ''}"><header><div><span>${h(items[0].examCode)}</span><h2>${h(examName)}</h2></div><small>${items[0].archivedAt ? `${formatDate(items[0].archivedAt, true)} 归档并锁定` : `最近发布 ${formatDate([...items].sort((a,b) => new Date(b.publishedAt) - new Date(a.publishedAt))[0].publishedAt, true)}`}</small></header><div class="result-summary ${summary?.qualified === true ? 'qualified' : summary?.qualified === false ? 'unqualified' : ''}"><span><small>当前总分</small><strong>${h(summary?.total ?? '—')}<em> / ${h(summary?.fullScore ?? '—')}</em></strong><i>科目等级按排名</i></span><span><small>特征分</small><strong>${h(summary?.featureScore ?? 0)}</strong><i>独立于考试科目</i></span><span><small>整场合格判定</small><strong>${h(stateText)}</strong><em>${h(detail)}</em></span><span><small>发布进度</small><strong>${h(summary?.publishedSubjects ?? items.length)}<em> / ${h(summary?.subjectCount ?? items.length)} 科</em></strong><i>${summary?.complete ? '成绩已出齐' : '持续发布中'}</i></span></div><div class="score-grid">${scores}</div><footer><p>${items[0].archivedAt ? '本场所有成绩已永久锁定，以下内容仅保留历史查阅。' : '等级按同场同科已发布成绩排名计算；特征分单独登记，不计入文化课总分。'}</p><strong>已发布 ${items.length} 科</strong></footer></section>`;
       return items[0].archivedAt ? `<details class="candidate-archive-fold result-archive-fold"><summary><span><strong>${h(examName)}</strong><small>${h(items[0].examCode)} · ${items.length} 科成绩 · 已永久锁定</small></span><b>历史成绩</b></summary>${panel}</details>` : panel;
     }).join('')}</div>`;
   }
   
+  function candidateAdmissions(data) {
+    const phaseLabels = { draft: '尚未开放', filling: '志愿填报中', closed: '填报已截止', matching: '正在投档', school_review: '招生学校审核中', supplementary: '补录填报中', completed: '录取结束' };
+    if (!data.admissions?.length) return emptyState('暂无志愿填报安排', '只有启用志愿功能且成绩已经发布的考试会显示在这里。', 'candidate/results', '查看成绩');
+    return `${data.notifications?.length ? `<section class="panel admission-notification"><strong>${h(data.notifications[0].payload.title)}</strong><p>${h(data.notifications[0].payload.message)}</p><small>${formatDate(data.notifications[0].createdAt, true)}</small></section>` : ''}<div class="admission-candidate-list">${data.admissions.map(item => {
+      const choices = item.preference?.payload?.choices || [];
+      const canFill = ['filling', 'supplementary'].includes(item.status) && item.totalScore != null && !item.preferenceLocked;
+      const placementSchool = item.plans.find(plan => plan.schoolId === item.placement?.schoolId)?.schoolName || '';
+      const progressSteps = ['filling', 'closed', 'school_review', 'completed'];
+      const progressIndex = item.status === 'supplementary' ? 1 : Math.max(0, progressSteps.indexOf(item.status));
+      const indicatorChoice = choices.find(choice => choice.preferenceType === 'indicator') || {};
+      const generalChoices = choices.filter(choice => choice.preferenceType !== 'indicator');
+      const indicatorEligible = item.indicatorQualification?.payload?.eligible === true;
+      const choiceRow = (choice, preferenceType, index) => {
+        const eligiblePlans = item.plans.filter(plan => plan.categories.some(category => category.preferenceTypes?.includes(preferenceType)));
+        const plan = eligiblePlans.find(entry => entry.schoolId === choice.schoolId);
+        const categoryOptions = (plan?.categories || []).filter(category => category.preferenceTypes?.includes(preferenceType) && ((preferenceType === 'indicator' ? category.indicatorRemaining : category.generalRemaining) > 0 || category.code === choice.categoryCode));
+        const disabled = preferenceType === 'indicator' && !indicatorEligible;
+        return `<div class="preference-choice-row ${preferenceType}" data-preference-type="${preferenceType}"><b>${preferenceType === 'indicator' ? '指标' : index + 1}</b><label><span>${preferenceType === 'indicator' ? '指标分配志愿学校' : `普通志愿 ${index + 1} · 招生学校`}</span><select name="choiceSchool" data-action="preference-school" data-exam-id="${h(item.examId)}" ${disabled ? 'disabled' : ''}><option value="">${disabled ? '本场无指标分配资格' : '可不填'}</option>${eligiblePlans.map(entry => `<option value="${h(entry.schoolId)}" ${entry.schoolId === choice.schoolId ? 'selected' : ''}>${h(entry.schoolCode)} · ${h(entry.schoolName)}</option>`).join('')}</select></label><label><span>该校招生类别</span><select name="choiceCategory" ${plan && !disabled ? '' : 'disabled'}><option value="">${plan ? '请选择招生类别' : '请先按代码选择学校'}</option>${categoryOptions.map(category => `<option value="${h(category.code)}" ${category.code === choice.categoryCode ? 'selected' : ''}>${h(category.name)}${category.specialtyCategory ? `（${h(specialtyLabel(category.specialtyCategory, category.specialtyType))}）` : ''} · 对应余 ${h(preferenceType === 'indicator' ? category.indicatorRemaining : category.generalRemaining)}</option>`).join('')}</select></label></div>`;
+      };
+      const choiceRows = choiceRow(indicatorChoice, 'indicator', 0) + Array.from({ length: Number(item.payload.maxChoices || 5) }, (_, index) => choiceRow(generalChoices[index] || {}, 'general', index)).join('');
+      const lockedRows = choices.map((choice, index) => { const plan = item.plans.find(entry => entry.schoolId === choice.schoolId); const category = plan?.categories.find(entry => entry.code === choice.categoryCode); return `<span><b>${choice.preferenceType === 'indicator' ? '指标' : index + 1}</b>${h(plan ? `${plan.schoolCode} · ${plan.schoolName} · ${category?.name || choice.categoryCode}` : `${choice.schoolId} · ${choice.categoryCode}`)}</span>`; }).join('');
+      const qualification = specialtyLabel(item.specialtyQualification?.category, item.specialtyQualification?.type) || '普通生';
+      const indicatorText = !item.indicatorQualification ? '待生源校确认' : indicatorEligible ? '有指标分配资格' : '无指标分配资格';
+      return `<section class="panel admission-candidate-card"><header><div><span>${h(item.exam.code)} · 第 ${h(item.payload.round || 1)} 轮</span><h2>${h(item.exam.name)}</h2></div>${badge(item.status)}</header><div class="admission-progress-track">${['填报志愿','志愿锁定','投档审核','录取结束'].map((label, index) => `<div class="${index < progressIndex ? 'done' : index === progressIndex ? 'current' : ''}"><i>${index < progressIndex ? '✓' : index + 1}</i><span>${label}</span></div>`).join('')}</div><div class="admission-score-strip"><span>本场总成绩</span><strong>${item.totalScore == null ? '成绩尚未完整发布' : `${h(item.totalScore)} 分`}</strong><span>特征分 <b>${h(item.featureScore || 0)}</b></span><span>特长类型 <b>${h(qualification)}</b></span><span>指标资格 <b>${h(indicatorText)}</b></span><em>${h(phaseLabels[item.status] || item.status)}</em></div><p class="admission-progress-copy">${h(item.payload.progress || '等待录取工作更新')}</p>${item.placement ? `<div class="admission-result-banner ${h(item.placement.status)}"><span>当前结果</span><strong>${h(placementSchool)} · ${h(item.placement.payload.categoryName)}</strong><small>${item.placement.status === 'final' ? '已正式录取，通知已发送' : item.placement.status === 'withdrawal_pending' ? '招生学校申请退档，等待超级管理员审核' : '材料已发送招生学校审核'}</small></div>` : ''}${canFill ? `<form class="preference-form" data-form="volunteer-preference"><input type="hidden" name="examId" value="${h(item.examId)}"><div class="preference-form-head"><div><strong>1 个指标分配志愿 + ${h(item.payload.maxChoices)} 个普通志愿</strong><small>指标栏仅在生源校确认有资格时开放；每次保存计为一次提交。</small></div><span>已提交 ${h(item.submissionCount)} / ${h(item.maxSubmissions)} 次</span></div><div class="preference-choice-list">${choiceRows}</div><button class="solid-button" type="submit">保存本人志愿（剩余 ${h(item.remainingSubmissions)} 次）</button></form>` : choices.length ? `<div class="locked-preferences"><strong>${item.preferenceLocked ? `达到 ${h(item.maxSubmissions)} 次上限，志愿已自动锁定` : '已锁定志愿顺序'}</strong>${lockedRows}</div>` : `<div class="read-only-callout">${item.preferenceLocked ? '志愿提交次数已用完，系统已自动锁定。' : '当前不能填报：请等待成绩完整发布或志愿填报窗口开放。'}</div>`}</section>`;
+    }).join('')}</div>`;
+  }
+
   function candidateNotices(notices) {
     return `<section class="panel notice-center"><div class="notice-center-list">${notices.map(notice => `<button data-action="open-notice" data-id="${h(notice.id)}"><time><strong>${new Date(notice.publishAt).getDate()}</strong><span>${new Date(notice.publishAt).toLocaleString('zh-CN',{month:'short'})}</span></time><span><em>${h(notice.category)}</em><strong>${h(notice.title)}</strong><small>${h(notice.summary)}</small></span>${notice.pinned ? '<i>置顶</i>' : ''}${icons.arrow}</button>`).join('')}</div></section>`;
   }

src/client/public-views.mjs

@@ -20,7 +20,7 @@ export function createPublicViews(context) {
   }
   
   function publicHeader() {
-    return `<header class="public-header"><div class="public-nav">${brand()}<nav><a href="#home" data-route="home">首页</a><a href="#home-exams" data-action="scroll-to" data-target="home-exams">考试报名</a><a href="#home-notices" data-action="scroll-to" data-target="home-notices">通知公告</a><a href="#service-flow" data-action="scroll-to" data-target="service-flow">办事指南</a></nav><div class="nav-actions">${state.user ? `<button class="text-button" data-route="${state.user.role}/dashboard">进入${state.user.role === 'admin' ? '管理后台' : '考生中心'}</button><button class="solid-button" data-action="logout">退出</button>` : `<button class="text-button" data-route="login">登录</button><button class="solid-button" data-route="register">考生注册</button>`}<button class="mobile-menu" data-action="toggle-public-nav" aria-label="打开导航">${icons.menu}</button></div></div></header>`;
+    return `<header class="public-header"><div class="public-nav">${brand()}<nav><a href="#home" data-route="home">首页</a><a href="#home-exams" data-action="scroll-to" data-target="home-exams">考试报名</a><a href="#notices" data-route="notices">通知公告</a><a href="#service-flow" data-action="scroll-to" data-target="service-flow">办事指南</a></nav><div class="nav-actions">${state.user ? `<button class="text-button" data-route="${state.user.role}/dashboard">进入${state.user.role === 'admin' ? '管理后台' : state.user.role === 'admission_school' ? '招生学校' : '考生中心'}</button><button class="solid-button" data-action="logout">退出</button>` : `<button class="text-button" data-route="login">登录</button><button class="solid-button" data-route="register">考生注册</button>`}<button class="mobile-menu" data-action="toggle-public-nav" aria-label="打开导航">${icons.menu}</button></div></div></header>`;
   }
   
   function renderHome() {
@@ -32,23 +32,60 @@ export function createPublicViews(context) {
     app.innerHTML = `${publicHeader()}<main class="public-main">
       <section class="hero">
         <div class="hero-grid">
-          <div class="hero-copy"><div class="notice-ticker"><span>最新</span><button data-action="open-notice" data-id="${h(topNotice?.id)}">${h(topNotice?.title || '欢迎使用衡准考试服务平台')}</button></div><p class="overline">${h(siteCopy.heroEyebrow || 'EXAMINATION SERVICE')}</p><h1>${h(siteCopy.heroTitle || '一个报名号，')}<br><em>${h(siteCopy.heroHighlight || '贯穿每一次考试。')}</em></h1><p class="hero-lead">${h(siteCopy.heroDescription || '')}</p><div class="hero-actions">${state.user?.role === 'candidate' ? `<button class="solid-button large" data-route="candidate/dashboard">进入考生中心 ${icons.arrow}</button>` : state.publicData.selfRegistrationEnabled ? `<button class="solid-button large" data-route="register">申请报名号 ${icons.arrow}</button>` : `<button class="solid-button large" data-route="login">使用报名号登录 ${icons.arrow}</button>`}<button class="ghost-button large" data-action="scroll-to" data-target="home-exams">查看开放考试</button></div><div class="hero-stats"><div><strong>${h(stats.candidates || 0)}</strong><span>在册考生</span></div><div><strong>${h(stats.registrations || 0)}</strong><span>报名记录</span></div><div><strong>${h(stats.exams || 0)}</strong><span>开放考试</span></div></div></div>
+          <div class="hero-copy"><div class="notice-ticker"><span>最新</span><button data-route="notice/${h(topNotice?.id)}">${h(topNotice?.title || '欢迎使用衡准考试服务平台')}</button></div><p class="overline">${h(siteCopy.heroEyebrow || 'EXAMINATION SERVICE')}</p><h1>${h(siteCopy.heroTitle || '一个报名号，')}<br><em>${h(siteCopy.heroHighlight || '贯穿每一次考试。')}</em></h1><p class="hero-lead">${h(siteCopy.heroDescription || '')}</p><div class="hero-actions">${state.user?.role === 'candidate' ? `<button class="solid-button large" data-route="candidate/dashboard">进入考生中心 ${icons.arrow}</button>` : state.publicData.selfRegistrationEnabled ? `<button class="solid-button large" data-route="register">申请报名号 ${icons.arrow}</button>` : `<button class="solid-button large" data-route="login">使用报名号登录 ${icons.arrow}</button>`}<button class="ghost-button large" data-action="scroll-to" data-target="home-exams">查看开放考试</button></div><div class="hero-stats"><div><strong>${h(stats.candidates || 0)}</strong><span>在册考生</span></div><div><strong>${h(stats.registrations || 0)}</strong><span>报名记录</span></div><div><strong>${h(stats.exams || 0)}</strong><span>开放考试</span></div></div></div>
           ${featured ? renderHeroTicket(featured) : '<div class="hero-ticket empty-state">暂无开放考试</div>'}
         </div>
       </section>
-      <section class="content-section" id="home-notices"><div class="section-heading"><div><p class="overline">NOTICE BOARD</p><h2>通知公告</h2></div><p>报名、考试、准考证与成绩发布的重要时间，请以平台通知为准。</p></div><div class="notice-layout"><article class="featured-notice">${topNotice ? `<span>${h(topNotice.category)}</span><h3>${h(topNotice.title)}</h3><p>${h(topNotice.summary)}</p><footer><time>${formatDate(topNotice.publishAt)}</time><button data-action="open-notice" data-id="${h(topNotice.id)}">阅读通知 ${icons.arrow}</button></footer>` : '<p>暂无通知</p>'}</article><div class="notice-list">${notices.slice(1, 5).map(renderNoticeRow).join('') || '<div class="empty-state">暂无更多通知</div>'}</div></div></section>
+      <section class="content-section" id="home-notices"><div class="section-heading"><div><p class="overline">NOTICE BOARD</p><h2>通知公告</h2></div><p>招生录取公示已纳入通知公告，可按类别统一查询。</p></div><div class="notice-layout"><article class="featured-notice">${topNotice ? `<span>${h(topNotice.category)}</span><h3>${h(topNotice.title)}</h3><p>${h(topNotice.summary)}</p><footer><time>${formatDate(topNotice.publishAt)}</time><button data-route="notice/${h(topNotice.id)}">阅读通知 ${icons.arrow}</button></footer>` : '<p>暂无通知</p>'}</article><div class="notice-list">${notices.slice(1, 5).map(renderNoticeRow).join('') || '<div class="empty-state">暂无更多通知</div>'}</div><button class="notice-archive-link" data-route="notices">查看全部通知与录取公示 ${icons.arrow}</button></div></section>
       <section class="content-section exam-section" id="home-exams"><div class="section-heading"><div><p class="overline">OPEN EXAMINATIONS</p><h2>考试报名</h2></div><p>登录后选择考试，并按实际需要勾选报考科目。</p></div><div class="public-exam-grid">${exams.map(renderPublicExam).join('') || '<div class="empty-state">当前没有已发布的考试</div>'}</div></section>
       <section class="service-flow" id="service-flow"><div class="section-heading light"><div><p class="overline">SERVICE FLOW</p><h2>报名号是唯一账户</h2></div><p>报名号不会随考试改变，每场考试只新增一条报名记录。</p></div><div class="flow-track">${[['01','领取报名号','学校创建账户并下发初始密码。'],['02','修改初始密码','首次登录必须设置自己的新密码。'],['03','补全个人信息','填写籍贯、住址、手机、邮箱和班级等资料。'],['04','选择考试科目','资料审核通过后自主选择考试。'],['05','下载准考证与查分','继续使用同一报名号办理后续事项。']].map(item => `<article><span>${item[0]}</span><h3>${item[1]}</h3><p>${item[2]}</p></article>`).join('')}</div></section>
     </main><footer class="public-footer"><div>${brand()}<p>${[organization.name, organization.phone].filter(Boolean).map(h).join(' · ')}</p>${organization.address || organization.email ? `<p class="public-contact-detail">${[organization.address, organization.email].filter(Boolean).map(h).join(' · ')}</p>` : ''}</div><span>${h(siteCopy.footerNotice || '')}</span></footer>`;
   }
 
+  function noticeDocuments(data = state.publicAnnouncements) {
+    const ordinary = (state.publicData.notices || []).map(item => ({ ...item, documentId: item.id, documentType: 'notice', subtype: item.category || '通知公告', publishedAt: item.publishAt }));
+    const plans = (data.plans || []).map(item => ({ ...item, documentId: `plan-${item.id}`, documentType: 'plan', category: '招生公示', subtype: '招生计划', title: `${item.examName} · ${item.schoolName}招生计划公示`, summary: `共 ${item.rows.reduce((sum, row) => sum + Number(row.quota || 0), 0)} 个招生名额，计划审核通过后由系统自动公示。` }));
+    const qualifications = (data.qualifications || []).map(item => ({ ...item, documentId: `qualification-${item.id}`, documentType: 'qualification', category: '录取公示', subtype: '指标资格', title: `${item.examName} · ${item.schoolName}指标分配资格公示`, summary: `本次公开 ${item.rows.length} 名考生的指标分配资格及特长类型。` }));
+    const admissions = (data.admissions || []).map(item => ({ ...item, documentId: `admission-${item.id}`, documentType: 'admission', category: '录取公示', subtype: '录取名单', title: `${item.examName}最终录取名单`, summary: `共 ${item.rows.length} 名考生正式录取，公开报名号、姓名、总成绩和录取学校。` }));
+    const cutoffs = (data.cutoffs || []).map(item => ({ ...item, documentId: `cutoff-${item.id}`, documentType: 'cutoff', category: '录取公示', subtype: '录取分数线', title: `${item.examName}录取分数线`, summary: `按招生学校和招生类别公布 ${item.rows.length} 条最低录取分数线。` }));
+    return [...ordinary, ...plans, ...qualifications, ...admissions, ...cutoffs].sort((left, right) => new Date(right.publishedAt) - new Date(left.publishedAt));
+  }
+
+  function renderDocumentBody(document) {
+    if (document.documentType === 'notice') return `<article class="notice-document-content">${document.contentHtml || `<p>${h(document.content || '').replace(/\r?\n/g, '</p><p>')}</p>`}</article>`;
+    if (document.documentType === 'plan') return `<p class="document-lead">招生计划经考试中心审核通过后由系统自动公示。计划人数包含普通计划与定向指标，具体执行以本公示为准。</p><div class="table-scroll"><table><thead><tr><th>类别代码</th><th>招生类别</th><th>计划人数</th><th>其中定向指标</th><th>指标分配</th></tr></thead><tbody>${document.rows.map(row => `<tr><td class="mono">${h(row.code)}</td><td><strong>${h(row.name)}</strong><small>${h(row.specialtyLabel || '普通 / 政策类')}</small></td><td><strong>${h(row.quota)} 人</strong></td><td>${h(row.indicatorQuota || 0)} 人</td><td>${row.indicatorAllocations?.length ? row.indicatorAllocations.map(allocation => `<span>${h(allocation.sourceSchoolName)} ${h(allocation.quota)} 人</span>`).join('<br>') : '无定向指标'}</td></tr>`).join('')}</tbody></table></div>${document.note ? `<p class="document-note"><strong>计划说明：</strong>${h(document.note)}</p>` : ''}`;
+    if (document.documentType === 'qualification') return `<p class="document-lead">本公示由生源校完成全部考生资格确认后自动生成。</p><div class="table-scroll"><table><thead><tr><th>报名号</th><th>姓名</th><th>指标分配资格</th><th>特长类型</th></tr></thead><tbody>${document.rows.map(row => `<tr><td class="mono">${h(row.registrationNumber)}</td><td><strong>${h(row.name)}</strong></td><td><span class="qualification-result ${row.eligible ? 'eligible' : ''}">${row.eligible ? '有' : '无'}</span></td><td>${h(row.specialtyLabel || '普通生')}</td></tr>`).join('')}</tbody></table></div>`;
+    if (document.documentType === 'admission') return `<p class="document-lead">报名号、姓名、考生总成绩与录取学校公开透明；证件号和联系方式不在本页展示。</p><div class="table-scroll"><table><thead><tr><th>报名号</th><th>姓名</th><th>总成绩</th><th>录取学校</th><th>录取类别</th></tr></thead><tbody>${document.rows.map(row => `<tr><td class="mono">${h(row.registrationNumber)}</td><td><strong>${h(row.name)}</strong></td><td>${h(row.totalScore)}</td><td>${h(row.admittedSchool)}</td><td>${h(row.categoryName)}</td></tr>`).join('')}</tbody></table></div>`;
+    return `<p class="document-lead">录取分数线为对应学校、招生类别最终录取考生的最低总成绩。</p><div class="table-scroll"><table><thead><tr><th>招生学校</th><th>招生类别</th><th>计划数</th><th>录取数</th><th>最高分</th><th>录取分数线</th></tr></thead><tbody>${document.rows.map(row => `<tr><td><strong>${h(row.schoolName)}</strong></td><td>${h(row.categoryName)}</td><td>${h(row.planQuota)}</td><td>${h(row.admittedCount)}</td><td>${h(row.highestScore)}</td><td><strong class="cutoff-score">${h(row.cutoffScore)}</strong></td></tr>`).join('')}</tbody></table></div>`;
+  }
+
+  function renderNoticeCenter(data = state.publicAnnouncements, selectedId = '') {
+    app.classList.remove('admin-readable');
+    const documents = noticeDocuments(data);
+    const selected = documents.find(item => item.documentId === selectedId);
+    const organization = state.publicData.organization || {};
+    if (selected) {
+      app.innerHTML = `${publicHeader()}<main class="public-main notice-document-page"><div class="notice-breadcrumb"><button data-route="notices">通知公告</button><span>/</span><strong>${h(selected.subtype)}</strong></div><article class="notice-document"><header><span>${h(selected.category)} · ${h(selected.subtype)}</span><h1>${h(selected.title)}</h1><p>${formatDate(selected.publishedAt, true)}${selected.author ? ` · ${h(selected.author)}` : ''}</p></header><section>${renderDocumentBody(selected)}</section><footer><button class="ghost-button" data-route="notices">返回通知公告列表</button></footer></article></main><footer class="public-footer"><div>${brand()}<p>${[organization.name, organization.phone].filter(Boolean).map(h).join(' · ')}</p></div><span>公开信息以本页面正式发布内容为准</span></footer>`;
+      return;
+    }
+    const categories = ['全部', ...new Set(documents.map(item => item.category || '通知公告'))];
+    const category = categories.includes(state.noticeCategory) ? state.noticeCategory : '全部';
+    const filtered = category === '全部' ? documents : documents.filter(item => item.category === category);
+    const pageSize = 8;
+    const totalPages = Math.max(1, Math.ceil(filtered.length / pageSize));
+    const page = Math.min(totalPages, Math.max(1, Number(state.noticePage || 1)));
+    state.noticeCategory = category; state.noticePage = page;
+    const pageRows = filtered.slice((page - 1) * pageSize, page * pageSize);
+    app.innerHTML = `${publicHeader()}<main class="public-main notice-center-page"><section class="notice-center-hero"><div><p class="overline">PUBLIC NOTICE ARCHIVE</p><h1>通知公告</h1><p>考试通知、成绩发布与招生录取公示统一归档，按发布时间倒序公开。</p></div><strong>${h(documents.length)}<small>份公开文件</small></strong></section><section class="notice-center-shell"><nav class="notice-category-nav">${categories.map(item => `<button class="${item === category ? 'active' : ''}" data-action="notice-category" data-category="${h(item)}">${h(item)}<span>${item === '全部' ? documents.length : documents.filter(document => document.category === item).length}</span></button>`).join('')}</nav><div class="notice-directory"><header><div><strong>${h(category)}</strong><span>第 ${h(page)} / ${h(totalPages)} 页</span></div><small>共 ${h(filtered.length)} 条</small></header><div class="notice-directory-list">${pageRows.map(item => `<button data-route="notice/${h(item.documentId)}"><time><strong>${String(new Date(item.publishedAt).getDate()).padStart(2,'0')}</strong><span>${new Date(item.publishedAt).toLocaleDateString('zh-CN',{year:'numeric',month:'2-digit'}).replace('/','.')}</span></time><span class="notice-directory-copy"><em>${h(item.subtype)}</em><strong>${h(item.title)}</strong><small>${h(item.summary || '')}</small></span><span class="notice-directory-arrow">${icons.arrow}</span></button>`).join('') || '<div class="empty-state">当前分类暂无公开信息</div>'}</div><footer class="notice-pagination"><button data-action="notice-page" data-page="${page - 1}" ${page <= 1 ? 'disabled' : ''}>上一页</button>${Array.from({length:totalPages},(_,index) => index + 1).map(value => `<button class="${value === page ? 'active' : ''}" data-action="notice-page" data-page="${value}">${value}</button>`).join('')}<button data-action="notice-page" data-page="${page + 1}" ${page >= totalPages ? 'disabled' : ''}>下一页</button></footer></div></section></main><footer class="public-footer"><div>${brand()}<p>${[organization.name, organization.phone].filter(Boolean).map(h).join(' · ')}</p></div><span>录取公示为通知公告中的公开类别</span></footer>`;
+  }
+  
   function renderHeroTicket(exam) {
     const status = exam.registrationState;
     return `<article class="hero-ticket"><div class="ticket-main"><header><span>${badge(status)}</span><small>${h(exam.code)}</small></header><p>UPCOMING EXAM</p><h2>${h(exam.name)}</h2><dl><div><dt>报名时间</dt><dd>${dateRange(exam.registrationStart, exam.registrationEnd)}</dd></div><div><dt>考试时间</dt><dd>${dateRange(exam.examStart, exam.examEnd)}</dd></div><div><dt>考试地点</dt><dd>${h(exam.location)}</dd></div></dl><div class="subject-chips">${exam.subjects.slice(0, 5).map(subject => `<span>${h(subject.name)}</span>`).join('')}${exam.subjects.length > 5 ? `<span>+${exam.subjects.length - 5}</span>` : ''}</div></div><div class="ticket-stub"><span>报名人数</span><strong>${h(exam.registrationCount || 0)}</strong><i></i><button data-route="${state.user?.role === 'candidate' ? 'candidate/exams' : 'login'}">${status === 'open' ? '立即报名' : '查看详情'}</button></div></article>`;
   }
   
   function renderNoticeRow(notice) {
-    return `<button class="notice-row" data-action="open-notice" data-id="${h(notice.id)}"><time>${formatDate(notice.publishAt)}</time><span><em>${h(notice.category)}</em><strong>${h(notice.title)}</strong><small>${h(notice.summary)}</small></span>${icons.arrow}</button>`;
+    return `<button class="notice-row" data-route="notice/${h(notice.id)}"><time>${formatDate(notice.publishAt)}</time><span><em>${h(notice.category)}</em><strong>${h(notice.title)}</strong><small>${h(notice.summary)}</small></span>${icons.arrow}</button>`;
   }
   
   function renderPublicExam(exam) {
@@ -59,7 +96,8 @@ export function createPublicViews(context) {
     app.classList.remove('admin-readable');
     const login = kind === 'login';
     const selfRegistration = state.publicData.selfRegistrationEnabled;
-    app.innerHTML = `<main class="auth-page"><section class="auth-story"><div>${brand()}<p class="overline">CANDIDATE SERVICE</p><h1>${login ? '凭一个号码，' : '自主申请，'}<br><em>${login ? '办理每一次考试。' : '领取固定报名号。'}</em></h1><p>报名号就是考生账户，不因考试、科目或年度报名而改变。</p></div><div class="auth-quote"><span>首次登录顺序</span><p>修改初始密码 → 补全个人信息 → 等待资料审核。</p></div></section><section class="auth-panel"><button class="back-link" data-route="home">← 返回首页</button><div class="auth-card"><p class="overline">${login ? 'ACCOUNT LOGIN' : 'CANDIDATE NUMBER'}</p><h2>${login ? '报名号登录' : '自主申请报名号'}</h2><p>${login ? '考生填写报名号和密码；管理员继续使用管理账号。' : selfRegistration ? '提交基础学籍范围后，系统生成一个长期使用的报名号。' : '当前未开放自主注册，请联系学校领取报名号和初始密码。'}</p>${login ? loginForm() : selfRegistration ? registerForm() : '<div class="registration-closed"><strong>自主注册已关闭</strong><span>学校管理员会为考生创建账户并下发初始密码。</span><button class="solid-button" data-route="login">返回报名号登录</button></div>'}${login && selfRegistration ? `<div class="auth-switch">还没有报名号？<button data-route="register">自主申请</button></div>` : !login ? '<div class="auth-switch">已经有报名号？<button data-route="login">返回登录</button></div>' : ''}</div></section></main>`;
+    const authNotice = login && state.authNotice ? `<div class="auth-session-notice" role="status"><strong>需要重新登录</strong><span>${h(state.authNotice)}</span></div>` : '';
+    app.innerHTML = `<main class="auth-page"><section class="auth-story"><div>${brand()}<p class="overline">CANDIDATE SERVICE</p><h1>${login ? '凭一个号码，' : '自主申请，'}<br><em>${login ? '办理每一次考试。' : '领取固定报名号。'}</em></h1><p>报名号就是考生账户，不因考试、科目或年度报名而改变。</p></div><div class="auth-quote"><span>首次登录顺序</span><p>修改初始密码 → 补全个人信息 → 等待资料审核。</p></div></section><section class="auth-panel"><button class="back-link" data-route="home">← 返回首页</button><div class="auth-card"><p class="overline">${login ? 'ACCOUNT LOGIN' : 'CANDIDATE NUMBER'}</p><h2>${login ? '报名号登录' : '自主申请报名号'}</h2><p>${login ? '考生填写报名号和密码；管理员继续使用管理账号。' : selfRegistration ? '提交基础学籍范围后，系统生成一个长期使用的报名号。' : '当前未开放自主注册，请联系学校领取报名号和初始密码。'}</p>${authNotice}${login ? loginForm() : selfRegistration ? registerForm() : '<div class="registration-closed"><strong>自主注册已关闭</strong><span>学校管理员会为考生创建账户并下发初始密码。</span><button class="solid-button" data-route="login">返回报名号登录</button></div>'}${login && selfRegistration ? `<div class="auth-switch">还没有报名号？<button data-route="register">自主申请</button></div>` : !login ? '<div class="auth-switch">已经有报名号？<button data-route="login">返回登录</button></div>' : ''}</div></section></main>`;
   }
   
   function loginForm() {
@@ -71,5 +109,5 @@ export function createPublicViews(context) {
     return `<form class="stack-form register-form" data-form="register"><div class="field-row"><label><span>考生姓名 *</span><input name="name" required placeholder="与证件一致"></label><label><span>性别 *</span><select name="gender" required><option value="">请选择</option><option>男</option><option>女</option></select></label></div><div class="field-row"><label><span>就读学校 *</span><select name="schoolId" data-action="school-select" required><option value="">请选择学校</option>${schools.map(item => `<option value="${h(item.id)}">${h(item.name)}</option>`).join('')}</select></label><label><span>班级 *</span><select name="classId" required><option value="">请先选择学校</option></select></label></div><label><span>设置登录密码 *</span><input name="password" type="password" required minlength="8" placeholder="至少 8 位字符"></label><label class="agreement"><input type="checkbox" required><span>我会妥善保存系统生成的报名号，并在登录后补全真实个人信息。</span></label><button class="solid-button large" type="submit">生成我的报名号 ${icons.arrow}</button></form>`;
   }
 
-  return { brand, renderHome, renderAuth };
+  return { brand, renderHome, renderNoticeCenter, renderAuth };
 }

src/client/state.mjs

@@ -2,10 +2,17 @@ export const state = {
   user: null,
   profile: null,
   publicData: { organization: {}, notices: [], exams: [], stats: {} },
+  publicAnnouncements: { plans: [], qualifications: [], admissions: [], cutoffs: [] },
+  noticeCategory: '全部',
+  noticePage: 1,
   permissions: [],
   scopeLabel: '',
+  authNotice: '',
   pageData: null,
   resultExamFilter: '',
+  resultSubjectFilter: '',
+  resultExamCatalog: null,
   resultImportPreview: null,
+  tablePages: {},
   loading: false
 };

src/client/ui.mjs

@@ -1,8 +1,10 @@
 export const statusLabels = {
   pending: '待审核', approved: '已通过', rejected: '需修改',
-  published: '已发布', draft: '草稿', closed: '已结束', archived: '已归档',
+  published: '已发布', visible: '已显示', hidden: '已隐藏', draft: '草稿', closed: '已结束', archived: '已归档',
   open: '报名中', upcoming: '即将开始', paid: '已缴费', unpaid: '待缴费',
   super: '超级管理员', school: '校级管理员', class: '班级管理员'
+  , admission_school: '招生学校', filling: '志愿填报中', matching: '投档中', school_review: '学校审核中',
+  supplementary: '补录中', completed: '录取完成', admitted: '学校已接收', withdrawal_pending: '退档待审', withdrawn: '已退档', final: '正式录取', unread: '未读'
 };
 
 export const icons = {

src/data/base.mjs

@@ -1,3 +1,5 @@
+import { CURRENT_SCHEMA_VERSION } from '../database/version.mjs';
+
 const admissionNumberRules = (nowIso) => [
   {
     id: 'admit_rule_district_room_seat', code: 'district_room_seat', name: '县区编号 + 考场号 + 座位号',
@@ -63,7 +65,7 @@ export function createBaseDatabase({ nowIso, hashPassword, initialAdmin = {} })
   const adminId = 'usr_admin';
   const createdAt = nowIso();
   return {
-    meta: { version: 17, createdAt },
+    meta: { version: CURRENT_SCHEMA_VERSION, createdAt },
     settings: { selfRegistrationEnabled: false },
     organization: { name: '考试服务平台', code: 'EXAM-SERVICE', phone: '', address: '' },
     schools: [], classes: [],
@@ -83,6 +85,6 @@ export function createBaseDatabase({ nowIso, hashPassword, initialAdmin = {} })
         { id: 'segment_sequence', position: 4, type: 'sequence', value: '', width: 4 }
       ]
     }],
-    workflows: workflows(adminId, nowIso), workflowInstances: [], workflowActions: [], auditLogs: []
+    workflows: workflows(adminId, nowIso), workflowInstances: [], workflowActions: [], admissionRecords: [], auditLogs: []
   };
 }

src/data/seed.mjs

@@ -1,4 +1,4 @@
-export function createSeedDatabase({ nowIso, hashPassword }) {
+export function createSeedDatabase({ nowIso, hashPassword, candidateCount = 1200 }) {
   const adminId = 'usr_admin';
   const schoolAdminId = 'usr_school_admin';
   const schoolAdmin2Id = 'usr_school_admin_2';
@@ -6,6 +6,39 @@ export function createSeedDatabase({ nowIso, hashPassword }) {
   const examId = 'exam_autumn_2026';
   const registrationId = 'reg_demo_2026';
   const testPasswordHash = hashPassword('12345678');
+  const mainSubjectDefinitions = [
+    { id: 'sub_chinese', name: '语文', date: '2026-06-20', start: '09:00', end: '11:00', fullScore: 120 },
+    { id: 'sub_math', name: '数学', date: '2026-06-20', start: '14:30', end: '16:30', fullScore: 120 },
+    { id: 'sub_english', name: '外语', date: '2026-06-21', start: '09:00', end: '11:00', fullScore: 120 },
+    { id: 'sub_history', name: '历史', date: '2026-06-21', start: '14:30', end: '15:45', fullScore: 75 },
+    { id: 'sub_politics', name: '政治', date: '2026-06-21', start: '16:10', end: '17:25', fullScore: 75 },
+    { id: 'sub_physics', name: '物理', date: '2026-06-22', start: '09:00', end: '10:20', fullScore: 80 },
+    { id: 'sub_chemistry', name: '化学', date: '2026-06-22', start: '10:45', end: '12:00', fullScore: 70 },
+    { id: 'sub_experiment', name: '实验', date: '2026-06-22', start: '14:30', end: '15:00', fullScore: 20 },
+    { id: 'sub_it', name: '信息技术', date: '2026-06-22', start: '15:30', end: '16:00', fullScore: 10 }
+  ].map((subject, index) => ({
+    ...subject, fee: 0, passRule: 'fixed_score', passValue: subject.fullScore * 0.6,
+    passScore: subject.fullScore * 0.6, order: index + 1
+  }));
+  const mainSubjectIds = mainSubjectDefinitions.map(subject => subject.id);
+  const mainCandidateCount = Math.max(1, Math.trunc(Number(candidateCount) || 1200));
+  const specialtyCandidateCount = Math.min(150, mainCandidateCount);
+
+  // 固定种子使每次导入得到相同的近似正态成绩，便于复现测试。
+  let randomState = 0x20260620;
+  const seededRandom = () => {
+    randomState = (randomState + 0x6D2B79F5) >>> 0;
+    let value = randomState;
+    value = Math.imul(value ^ (value >>> 15), value | 1);
+    value ^= value + Math.imul(value ^ (value >>> 7), value | 61);
+    return ((value ^ (value >>> 14)) >>> 0) / 4294967296;
+  };
+  const normalRandom = () => {
+    const first = Math.max(seededRandom(), Number.EPSILON);
+    return Math.sqrt(-2 * Math.log(first)) * Math.cos(2 * Math.PI * seededRandom());
+  };
+  const normalScore = fullScore => Number(Math.min(fullScore, Math.max(0, fullScore * 0.72 + fullScore * 0.14 * normalRandom())).toFixed(1));
+  const scoreGrade = (score, fullScore) => score >= fullScore * 0.9 ? 'A' : score >= fullScore * 0.75 ? 'B' : score >= fullScore * 0.6 ? 'C' : 'D';
   const database = {
     meta: { version: 15, createdAt: nowIso() },
     settings: { selfRegistrationEnabled: false },
@@ -16,8 +49,8 @@ export function createSeedDatabase({ nowIso, hashPassword }) {
       address: '江苏省连云港市海州区文教路 18 号'
     },
     schools: [
-      { id: 'school_hz1', name: '海州市第一中学', code: 'HZ01', address: '江苏省连云港市海州区学府路 8 号', active: true },
+      { id: 'school_hz1', name: '海州市第一中学', code: 'HZ01', address: '江苏省连云港市海州区学府路 8 号', isSourceSchool: true, isAdmissionSchool: false, active: true },
-      { id: 'school_hz3', name: '海州市第三中学', code: 'HZ03', address: '江苏省连云港市连云区育才路 16 号', active: true }
+      { id: 'school_hz3', name: '海州市第三中学', code: 'HZ03', address: '江苏省连云港市连云区育才路 16 号', isSourceSchool: true, isAdmissionSchool: false, active: true }
     ],
     classes: [
       { id: 'class_hz1_301', schoolId: 'school_hz1', name: '高三（1）班', grade: '高三', active: true },
@@ -39,7 +72,8 @@ export function createSeedDatabase({ nowIso, hashPassword }) {
         phone: '13800138000', email: 'zhou@example.com', school: '海州市第一中学', grade: '高三（2）班', schoolId: 'school_hz1', classId: 'class_hz1_302',
         provinceCode: '320000', provinceName: '江苏省', cityCode: '320700', cityName: '连云港市', districtCode: '320706', districtName: '海州区',
         address: '学府路 8 号', emergencyContact: '周建国', emergencyPhone: '13900139000',
-        nativePlace: '江苏海州', birthDate: '2008-08-16', ethnicity: '汉族', postalCode: '222000', guardianName: '周建国', guardianPhone: '13900139000', profileCompleted: false,
+        nativePlace: '江苏海州', birthDate: '2008-08-16', ethnicity: '汉族', postalCode: '222000', guardianName: '周建国', guardianPhone: '13900139000',
+        specialtyCategory: 'arts', specialtyType: 'fine_arts', specialtyTypes: ['fine_arts'], specialtyCertificate: 'ART-DEMO-0001', policyEligibility: '特长生资格已核验', profileCompleted: true,
         status: 'approved', reviewNote: '身份信息与学籍信息核验一致', reviewedAt: '2026-07-18T08:30:00.000Z', updatedAt: '2026-07-17T09:20:00.000Z'
       }
     ],
@@ -50,33 +84,29 @@ export function createSeedDatabase({ nowIso, hashPassword }) {
     ],
     exams: [
       {
-        id: examId, code: 'EX-2026-AUT', name: '2026 年秋季统一考试', description: '面向全市普通高中高三在籍学生的统一学业考试。',
+        id: examId, code: 'EX-2026-ZK', name: '2026 年海州市初中学业水平考试', description: '演示数据主考试：覆盖成绩发布、特长生和第一轮志愿填报。',
-        registrationStart: '2026-07-01T00:00:00.000Z', registrationEnd: '2026-07-31T15:59:59.000Z',
+        registrationStart: '2026-04-01T00:00:00.000Z', registrationEnd: '2026-04-30T15:59:59.000Z',
-        examStart: '2026-08-16T01:00:00.000Z', examEnd: '2026-08-18T09:00:00.000Z',
+        examStart: '2026-06-20T01:00:00.000Z', examEnd: '2026-06-22T08:00:00.000Z',
-        admitDownloadStart: '2026-07-19T00:00:00.000Z', admitDownloadEnd: '2026-08-16T00:45:00.000Z',
+        admitDownloadStart: '2026-06-10T00:00:00.000Z', admitDownloadEnd: '2026-06-20T00:45:00.000Z',
-        location: '海州市各指定考点', passPolicy: 'rank_percent', passValue: 60, status: 'published', createdAt: '2026-06-18T02:00:00.000Z',
+        location: '海州市各指定考点', passPolicy: 'rank_percent', passValue: 60, status: 'published', createdAt: '2026-03-18T02:00:00.000Z',
-        subjects: [
+        subjects: mainSubjectDefinitions
-          { id: 'sub_chinese', name: '语文', date: '2026-08-16', start: '09:00', end: '11:30', fee: 30, fullScore: 150, passRule: 'fixed_score', passValue: 90, passScore: 90 },
-          { id: 'sub_math', name: '数学', date: '2026-08-16', start: '15:00', end: '17:00', fee: 30, fullScore: 150, passRule: 'rank_percent', passValue: 60, passScore: null },
-          { id: 'sub_physics', name: '物理', date: '2026-08-17', start: '09:00', end: '10:30', fee: 25, fullScore: 100, passScore: 60 },
-          { id: 'sub_history', name: '历史', date: '2026-08-17', start: '09:00', end: '10:30', fee: 25, fullScore: 100, passScore: 60 },
-          { id: 'sub_english', name: '外语', date: '2026-08-17', start: '15:00', end: '16:30', fee: 30, fullScore: 150, passScore: 90 },
-          { id: 'sub_chemistry', name: '化学', date: '2026-08-18', start: '09:00', end: '10:15', fee: 25, fullScore: 100, passScore: 60 },
-          { id: 'sub_biology', name: '生物', date: '2026-08-18', start: '15:00', end: '16:15', fee: 25, fullScore: 100, passScore: 60 }
-        ]
       },
       {
         id: 'exam_mock_2026', code: 'EX-2026-MOCK-2', name: '第二次全市模拟考试', description: '秋季统一考试前的全流程模拟考试。',
         registrationStart: '2026-10-01T00:00:00.000Z', registrationEnd: '2026-10-20T15:59:59.000Z',
         examStart: '2026-11-08T01:00:00.000Z', examEnd: '2026-11-10T09:00:00.000Z',
         admitDownloadStart: '2026-11-01T00:00:00.000Z', admitDownloadEnd: '2026-11-08T00:45:00.000Z',
-        location: '考点待公布', passPolicy: 'rank_percent', passValue: 60, status: 'draft', createdAt: nowIso(), subjects: []
+        location: '考点待公布', passPolicy: 'rank_percent', passValue: 60, status: 'draft', createdAt: nowIso(), subjects: [
+          { id: 'mock_sub_chinese', name: '语文', date: '2026-11-08', start: '09:00', end: '11:00', fee: 0, fullScore: 120, passRule: 'fixed_score', passValue: 72, passScore: 72 },
+          { id: 'mock_sub_math', name: '数学', date: '2026-11-08', start: '14:30', end: '16:30', fee: 0, fullScore: 120, passRule: 'fixed_score', passValue: 72, passScore: 72 },
+          { id: 'mock_sub_english', name: '外语', date: '2026-11-09', start: '09:00', end: '11:00', fee: 0, fullScore: 120, passRule: 'fixed_score', passValue: 72, passScore: 72 }
+        ]
       }
     ],
     registrations: [
       {
-        id: registrationId, userId: candidateId, examId, subjectIds: ['sub_chinese', 'sub_math', 'sub_physics', 'sub_english', 'sub_chemistry'],
+        id: registrationId, userId: candidateId, examId, subjectIds: mainSubjectIds,
-        status: 'approved', paymentStatus: 'paid', paidAt: '2026-07-18T09:00:00.000Z', paidBy: 'usr_class_admin', createdAt: '2026-07-08T05:18:00.000Z', reviewedAt: '2026-07-18T08:32:00.000Z', registrationNumber: '2026-HZ01-F-0001', numberRuleId: 'rule_default'
+        status: 'approved', paymentStatus: 'paid', paidAt: '2026-05-18T09:00:00.000Z', paidBy: 'usr_class_admin', createdAt: '2026-04-08T05:18:00.000Z', reviewedAt: '2026-04-18T08:32:00.000Z', reviewNote: '报名审核通过', registrationNumber: '2026-HZ01-F-0001', numberRuleId: 'rule_default', featureScore: 90
       }
     ],
     results: [],
@@ -165,20 +195,27 @@ export function createSeedDatabase({ nowIso, hashPassword }) {
     ],
     workflowInstances: [],
     workflowActions: [],
+    admissionRecords: [],
     auditLogs: [
       { id: 'log_1', actorId: adminId, action: '发布通知', detail: '发布《市第三中学考点交通提示》', createdAt: '2026-07-18T06:00:00.000Z' }
     ]
   };
 
-  const schoolDefinitions = [
+  const sourceSchools = [
     { key: 'hz1', id: 'school_hz1', code: 'HZ01', name: '海州市第一中学', districtCode: '320706', districtName: '海州区', address: '学府路 8 号' },
     { key: 'hz3', id: 'school_hz3', code: 'HZ03', name: '海州市第三中学', districtCode: '320703', districtName: '连云区', address: '育才路 16 号' },
     { key: 'hz5', id: 'school_hz5', code: 'HZ05', name: '海州市第五中学', districtCode: '320707', districtName: '赣榆区', address: '青口路 28 号' },
-    { key: 'hz7', id: 'school_hz7', code: 'HZ07', name: '海州市第七中学', districtCode: '320723', districtName: '灌云县', address: '胜利路 66 号' }
+    { key: 'hz7', id: 'school_hz7', code: 'HZ07', name: '海州市第七中学', districtCode: '320723', districtName: '灌云县', address: '胜利路 66 号' },
+    { key: 'hz9', id: 'school_hz9', code: 'HZ09', name: '海州市第九中学', districtCode: '320724', districtName: '灌南县', address: '新安路 39 号' }
   ];
-  for (const school of schoolDefinitions) {
+  const admissionSchools = [
+    { key: 'admission_1', id: 'school_admission_1', code: 'AD01', name: '海州市高级中学', address: '江苏省连云港市海州区苍梧路 100 号' },
+    { key: 'admission_2', id: 'school_admission_2', code: 'AD02', name: '海州市实验高级中学', address: '江苏省连云港市连云区海棠路 88 号' },
+    { key: 'admission_3', id: 'school_admission_3', code: 'AD03', name: '海州市外国语高级中学', address: '江苏省连云港市赣榆区黄海路 66 号' }
+  ];
+  for (const school of sourceSchools) {
     if (!database.schools.some(item => item.id === school.id)) {
-      database.schools.push({ id: school.id, name: school.name, code: school.code, address: `江苏省连云港市${school.districtName}${school.address}`, active: true });
+      database.schools.push({ id: school.id, name: school.name, code: school.code, address: `江苏省连云港市${school.districtName}${school.address}`, isSourceSchool: true, isAdmissionSchool: false, active: true });
     }
     for (let classIndex = 1; classIndex <= 3; classIndex += 1) {
       const classId = `class_${school.key}_30${classIndex}`;
@@ -188,14 +225,25 @@ export function createSeedDatabase({ nowIso, hashPassword }) {
     }
   }
 
-  for (const school of schoolDefinitions) {
+  for (const school of admissionSchools) {
-    const generatedSchoolAdminId = `usr_test_school_admin_${school.key}`;
+    database.schools.push({ id: school.id, name: school.name, code: school.code, address: school.address, isSourceSchool: false, isAdmissionSchool: true, active: true });
     database.users.push({
-      id: generatedSchoolAdminId, username: `test_school_admin_${school.key}`, passwordHash: testPasswordHash,
+      id: `usr_${school.key}`, username: `${school.key}_admin`, passwordHash: testPasswordHash, role: 'admission_school',
-      role: 'admin', adminLevel: 'school', schoolId: school.id, displayName: `${school.name}测试校管`, active: true, createdAt: nowIso()
+      schoolId: school.id, displayName: `${school.name}招生办`, active: true, mustChangePassword: false, createdAt: nowIso()
     });
+  }
+
+  for (const school of sourceSchools) {
+    if (school.id !== 'school_hz1') {
+      const generatedSchoolAdminId = `usr_test_school_admin_${school.key}`;
+      database.users.push({
+        id: generatedSchoolAdminId, username: `test_school_admin_${school.key}`, passwordHash: testPasswordHash,
+        role: 'admin', adminLevel: 'school', schoolId: school.id, displayName: `${school.name}测试校管`, active: true, createdAt: nowIso()
+      });
+    }
     for (let classIndex = 1; classIndex <= 3; classIndex += 1) {
       const classId = `class_${school.key}_30${classIndex}`;
+      if (classId === 'class_hz1_302') continue;
       database.users.push({
         id: `usr_test_class_admin_${school.key}_${classIndex}`, username: `test_class_admin_${school.key}_${classIndex}`,
         passwordHash: testPasswordHash, role: 'admin', adminLevel: 'class', schoolId: school.id, classId,
@@ -204,7 +252,7 @@ export function createSeedDatabase({ nowIso, hashPassword }) {
     }
   }
 
-  for (const school of schoolDefinitions) {
+  for (const school of sourceSchools) {
     let center = database.testCenters.find(item => item.schoolId === school.id);
     if (!center) {
       center = {
@@ -227,21 +275,20 @@ export function createSeedDatabase({ nowIso, hashPassword }) {
     }
   }
 
-  // 测试库停留在考场编排前：不预置编排计划、准考证或成绩。
+  // 测试库停留在考场编排前：不预置编排计划或准考证；主考试成绩与志愿已完成。
   const familyNames = ['赵', '钱', '孙', '李', '周', '吴', '郑', '王', '冯', '陈', '褚', '卫'];
   const givenNames = ['子涵', '梓萱', '宇航', '雨欣', '浩然', '思远', '佳宁', '晨曦', '明轩', '若彤', '嘉诚', '欣怡'];
-  const subjectSets = [
+  const specialtyDefinitions = [
-    ['sub_chinese', 'sub_math', 'sub_english'],
+    { category: 'sports', type: 'track_field', label: '田径' },
-    ['sub_chinese', 'sub_math', 'sub_physics', 'sub_chemistry'],
+    { category: 'sports', type: 'basketball', label: '篮球' },
-    ['sub_chinese', 'sub_math', 'sub_history', 'sub_biology'],
+    { category: 'arts', type: 'fine_arts', label: '美术' },
-    ['sub_chinese', 'sub_math', 'sub_english', 'sub_physics', 'sub_chemistry'],
+    { category: 'arts', type: 'vocal_music', label: '声乐' },
-    ['sub_chinese', 'sub_math', 'sub_english', 'sub_history', 'sub_biology']
+    { category: 'arts', type: 'dance', label: '舞蹈' }
   ];
-  const registrationWorkflowId = 'workflow_registration';
+  for (let index = 0; index < mainCandidateCount - 1; index += 1) {
-  for (let index = 0; index < 360; index += 1) {
     const serial = index + 1001;
-    const school = schoolDefinitions[index % schoolDefinitions.length];
+    const school = sourceSchools[index % sourceSchools.length];
-    const classIndex = Math.floor(index / schoolDefinitions.length) % 3 + 1;
+    const classIndex = Math.floor(index / sourceSchools.length) % 3 + 1;
     const classId = `class_${school.key}_30${classIndex}`;
     const gender = index % 2 === 0 ? '男' : '女';
     const genderCode = gender === '男' ? 'M' : 'F';
@@ -249,7 +296,7 @@ export function createSeedDatabase({ nowIso, hashPassword }) {
     const profileId = `profile_bulk_${String(index + 1).padStart(4, '0')}`;
     const registrationIdBulk = `reg_bulk_${String(index + 1).padStart(4, '0')}`;
     const candidateNumber = `2026-${school.code}-${genderCode}-${String(serial).padStart(4, '0')}`;
-    const createdAt = new Date(Date.UTC(2026, 6, 2 + (index % 20), 1 + (index % 8), index % 60)).toISOString();
+    const createdAt = new Date(Date.UTC(2026, 3, 2 + (index % 20), 1 + (index % 8), index % 60)).toISOString();
     const name = `${familyNames[index % familyNames.length]}${givenNames[Math.floor(index / familyNames.length) % givenNames.length]}${Math.floor(index / 144) + 1}`;
     const idNumber = `3207002008${String(index % 12 + 1).padStart(2, '0')}${String(index % 28 + 1).padStart(2, '0')}${String(index + 1).padStart(4, '0')}`;
     const phone = `138${String(10000000 + index).padStart(8, '0')}`;
@@ -257,6 +304,8 @@ export function createSeedDatabase({ nowIso, hashPassword }) {
       id: userId, username: candidateNumber, candidateNumber, passwordHash: testPasswordHash, role: 'candidate',
       displayName: name, active: true, mustChangePassword: false, createdAt
     });
+    const isSpecialtyCandidate = index < specialtyCandidateCount - 1;
+    const specialty = isSpecialtyCandidate ? specialtyDefinitions[index % specialtyDefinitions.length] : null;
     database.candidateProfiles.push({
       id: profileId, userId, name, gender, idNumber, phone, email: `candidate${String(index + 1).padStart(4, '0')}@example.test`,
       school: school.name, grade: `高三（${classIndex}）班`, schoolId: school.id, classId,
@@ -265,41 +314,77 @@ export function createSeedDatabase({ nowIso, hashPassword }) {
       emergencyContact: `${familyNames[index % familyNames.length]}家长`, emergencyPhone: `139${String(10000000 + index).padStart(8, '0')}`,
       nativePlace: `江苏${school.districtName}`, birthDate: `2008-${String(index % 12 + 1).padStart(2, '0')}-${String(index % 28 + 1).padStart(2, '0')}`,
       ethnicity: index % 19 === 0 ? '回族' : '汉族', postalCode: '222000', guardianName: `${familyNames[index % familyNames.length]}家长`,
-      guardianPhone: `139${String(10000000 + index).padStart(8, '0')}`, profileCompleted: true, status: 'approved',
+      guardianPhone: `139${String(10000000 + index).padStart(8, '0')}`,
-      reviewNote: '批量测试数据：学籍核验通过', reviewedAt: '2026-06-30T08:00:00.000Z', reviewerId: adminId, updatedAt: createdAt
+      specialtyCategory: specialty?.category || '', specialtyType: specialty?.type || '', specialtyTypes: specialty ? [specialty.type] : [],
+      specialtyCertificate: specialty ? `SPECIAL-2026-${String(index + 2).padStart(4, '0')}` : '', policyEligibility: specialty ? `${specialty.label}特长生资格已核验` : '',
+      profileCompleted: true, status: 'approved', reviewNote: '批量演示数据：学籍核验通过',
+      reviewedAt: '2026-04-30T08:00:00.000Z', reviewerId: adminId, updatedAt: createdAt
     });
 
-    const scenario = index % 4;
+    const paymentStatus = index % 2 === 0 ? 'paid' : 'unpaid';
-    const status = scenario === 0 ? 'pending' : scenario === 1 ? 'rejected' : 'approved';
+    const classAdminId = classId === 'class_hz1_302' ? 'usr_class_admin' : `usr_test_class_admin_${school.key}_${classIndex}`;
-    const paymentStatus = scenario === 3 ? 'paid' : 'unpaid';
-    const classAdminId = `usr_test_class_admin_${school.key}_${classIndex}`;
-    const schoolAdmin = `usr_test_school_admin_${school.key}`;
     database.registrations.push({
-      id: registrationIdBulk, userId, examId, subjectIds: subjectSets[index % subjectSets.length], status, paymentStatus,
+      id: registrationIdBulk, userId, examId, subjectIds: mainSubjectIds, status: 'approved', paymentStatus,
-      paidAt: paymentStatus === 'paid' ? '2026-07-25T08:30:00.000Z' : null,
+      paidAt: paymentStatus === 'paid' ? '2026-05-18T08:30:00.000Z' : null,
       paidBy: paymentStatus === 'paid' ? classAdminId : null,
-      createdAt, reviewedAt: status === 'pending' ? null : '2026-07-22T08:00:00.000Z',
+      createdAt, reviewedAt: '2026-04-30T08:00:00.000Z', reviewNote: '批量演示数据：报名审核通过',
-      reviewNote: status === 'rejected' ? '测试场景：报名资料被退回' : status === 'approved' ? '测试场景：报名审核通过' : '',
+      registrationNumber: candidateNumber, numberRuleId: 'rule_default',
-      registrationNumber: candidateNumber, numberRuleId: 'rule_default'
+      featureScore: specialty ? Number((80 + seededRandom() * 20).toFixed(1)) : 0
     });
-    if (status === 'pending' || status === 'rejected') {
+  }
-      const instanceId = `flow_reg_bulk_${String(index + 1).padStart(4, '0')}`;
+
-      database.workflowInstances.push({
+  const admissionCreatedAt = '2026-07-01T00:00:00.000Z';
-        id: instanceId, workflowId: registrationWorkflowId, businessType: 'registration_review', businessId: registrationIdBulk,
+  database.admissionRecords.push({
-        status, currentStep: 1, assigneeId: status === 'pending' ? schoolAdmin : null, createdAt,
+    id: 'admission_setting_main_2026', kind: 'setting', examId, userId: adminId, schoolId: null, status: 'closed',
-        completedAt: status === 'rejected' ? '2026-07-22T08:00:00.000Z' : null
+    payload: {
+      enabled: true, preferenceStart: '2026-07-01T00:00:00.000Z', preferenceEnd: '2026-07-15T15:59:59.000Z',
+      maxChoices: 3, maxSubmissions: 1, round: 1, autoPublish: true, progress: '第一轮志愿已全部填报完毕，等待投档'
+    },
+    createdAt: admissionCreatedAt, updatedAt: '2026-07-16T00:00:00.000Z'
+  });
+  for (const school of admissionSchools) {
+    database.admissionRecords.push({
+      id: `admission_plan_${school.key}`, kind: 'plan', examId, userId: `usr_${school.key}`, schoolId: school.id, status: 'approved',
+      payload: {
+        categories: [
+          { code: 'general', name: '普通生', quota: mainCandidateCount, specialtyCategory: '', specialtyType: '', indicatorAllocations: [] },
+          { code: 'sports', name: '体育特长生', quota: specialtyCandidateCount, specialtyCategory: 'sports', specialtyType: '', indicatorAllocations: [] },
+          { code: 'arts', name: '艺术特长生', quota: specialtyCandidateCount, specialtyCategory: 'arts', specialtyType: '', indicatorAllocations: [] }
+        ],
+        note: '演示数据招生计划', submittedBy: `${school.name}招生办`, reviewedBy: '林老师', reviewedAt: admissionCreatedAt, publicVisible: true
+      },
+      createdAt: admissionCreatedAt, updatedAt: admissionCreatedAt
+    });
+  }
+
+  const mainRegistrations = database.registrations.filter(registration => registration.examId === examId);
+  for (const [candidateIndex, registration] of mainRegistrations.entries()) {
+    const profile = database.candidateProfiles.find(item => item.userId === registration.userId);
+    const isSpecialtyCandidate = Boolean(profile?.specialtyCategory);
+    for (const subject of mainSubjectDefinitions) {
+      const score = normalScore(subject.fullScore);
+      database.results.push({
+        id: `result_main_${String(candidateIndex + 1).padStart(4, '0')}_${subject.id.slice(4)}`,
+        registrationId: registration.id, subjectId: subject.id, score, grade: scoreGrade(score, subject.fullScore),
+        published: true, updatedAt: '2026-06-30T08:00:00.000Z', publishedAt: '2026-06-30T08:00:00.000Z'
       });
-      database.workflowActions.push({
-        id: `flow_action_submit_bulk_${String(index + 1).padStart(4, '0')}`, instanceId, actorId: userId, action: 'submit',
-        note: '提交考试报名', fromAssigneeId: null, toAssigneeId: schoolAdmin, createdAt
-      });
-      if (status === 'rejected') {
-        database.workflowActions.push({
-          id: `flow_action_reject_bulk_${String(index + 1).padStart(4, '0')}`, instanceId, actorId: schoolAdmin, action: 'reject',
-          note: '测试场景：报名资料被退回', fromAssigneeId: schoolAdmin, toAssigneeId: null, createdAt: '2026-07-22T08:00:00.000Z'
-        });
-      }
     }
+    const rotatedAdmissionSchools = admissionSchools.map((_, offset) => admissionSchools[(candidateIndex + offset) % admissionSchools.length]);
+    database.admissionRecords.push({
+      id: `preference_main_${String(candidateIndex + 1).padStart(4, '0')}`, kind: 'preference', examId,
+      userId: registration.userId, schoolId: null, status: 'submitted',
+      payload: {
+        round: 1, submissionCount: 1, submittedAt: new Date(Date.UTC(2026, 6, 5 + (candidateIndex % 10), 1 + (candidateIndex % 8), candidateIndex % 60)).toISOString(),
+        choices: rotatedAdmissionSchools.map(school => ({ schoolId: school.id, categoryCode: 'general', preferenceType: 'general' }))
+      },
+      createdAt: admissionCreatedAt, updatedAt: '2026-07-15T08:00:00.000Z'
+    });
+    database.admissionRecords.push({
+      id: `qualification_main_${String(candidateIndex + 1).padStart(4, '0')}`, kind: 'indicator_qualification', examId,
+      userId: registration.userId, schoolId: profile.schoolId, status: 'confirmed',
+      payload: { eligible: isSpecialtyCandidate, confirmedAt: '2026-06-28T08:00:00.000Z', note: isSpecialtyCandidate ? '特长资格核验通过' : '普通生' },
+      createdAt: '2026-06-28T08:00:00.000Z', updatedAt: '2026-06-28T08:00:00.000Z'
+    });
   }
 
   return database;

src/data/specialty-types.mjs

@@ -0,0 +1,76 @@
+export const specialtyCatalog = Object.freeze([
+  Object.freeze({
+    code: 'sports',
+    name: '体育',
+    types: Object.freeze([
+      Object.freeze({ code: 'track_field', name: '田径' }),
+      Object.freeze({ code: 'basketball', name: '篮球' }),
+      Object.freeze({ code: 'football', name: '足球' }),
+      Object.freeze({ code: 'volleyball', name: '排球' }),
+      Object.freeze({ code: 'table_tennis', name: '乒乓球' }),
+      Object.freeze({ code: 'badminton', name: '羽毛球' }),
+      Object.freeze({ code: 'swimming', name: '游泳' }),
+      Object.freeze({ code: 'martial_arts', name: '武术' }),
+      Object.freeze({ code: 'aerobics_cheer', name: '健美操与啦啦操' })
+    ])
+  }),
+  Object.freeze({
+    code: 'arts',
+    name: '艺术',
+    types: Object.freeze([
+      Object.freeze({ code: 'vocal_music', name: '声乐' }),
+      Object.freeze({ code: 'instrumental_music', name: '器乐' }),
+      Object.freeze({ code: 'dance', name: '舞蹈' }),
+      Object.freeze({ code: 'fine_arts', name: '美术' }),
+      Object.freeze({ code: 'calligraphy', name: '书法' }),
+      Object.freeze({ code: 'drama_broadcasting', name: '戏剧与播音' })
+    ])
+  })
+]);
+
+const categoryMap = new Map(specialtyCatalog.map(category => [category.code, category]));
+const typeMap = new Map(specialtyCatalog.flatMap(category => category.types.map(type => [type.code, { ...type, categoryCode: category.code, categoryName: category.name }])));
+const legacyTypeMap = new Map(specialtyCatalog.flatMap(category => category.types.map(type => [type.name, { category: category.code, type: type.code }])));
+
+export function specialtyCategory(code) {
+  return categoryMap.get(String(code || '')) || null;
+}
+
+export function specialtyType(code) {
+  return typeMap.get(String(code || '')) || null;
+}
+
+export function isValidSpecialty(categoryCode, typeCode) {
+  if (!categoryCode && !typeCode) return true;
+  const category = specialtyCategory(categoryCode);
+  const type = specialtyType(typeCode);
+  return Boolean(category && type && type.categoryCode === category.code);
+}
+
+export function resolveProfileSpecialty(profile = {}) {
+  if (isValidSpecialty(profile.specialtyCategory, profile.specialtyType) && profile.specialtyCategory) {
+    return { category: profile.specialtyCategory, type: profile.specialtyType };
+  }
+  const legacy = (Array.isArray(profile.specialtyTypes) ? profile.specialtyTypes : []).map(value => legacyTypeMap.get(String(value))).find(Boolean);
+  return legacy || { category: '', type: '' };
+}
+
+export function specialtyLabel(categoryCode, typeCode) {
+  const category = specialtyCategory(categoryCode);
+  const type = specialtyType(typeCode);
+  if (!category) {
+    const legacy = legacyTypeMap.get(String(typeCode || ''));
+    return legacy ? specialtyLabel(legacy.category, legacy.type) : '';
+  }
+  return type?.categoryCode === category.code ? `${category.name}·${type.name}` : category.name;
+}
+
+export function candidateEligibleForCategory(profile, category) {
+  const legacy = !category?.specialtyCategory ? legacyTypeMap.get(String(category?.specialtyType || '')) : null;
+  const requiredCategory = category?.specialtyCategory || legacy?.category || '';
+  const requiredType = legacy?.type || category?.specialtyType || '';
+  if (!requiredCategory) return true;
+  const qualification = resolveProfileSpecialty(profile);
+  if (qualification.category !== requiredCategory) return false;
+  return !requiredType || qualification.type === requiredType;
+}

src/database/mysql-adapter.mjs

@@ -54,7 +54,7 @@ export function createMysqlAdapter(context) {
       hasSchemaMetadata = metadataRows.length > 0;
       existingSchemaVersion = hasSchemaMetadata ? Number(metadataRows[0].schema_version) : null;
     }
-    if (existingAppTables.length && (!hasSchemaMetadata || ![15, 16, 17].includes(existingSchemaVersion))) {
+    if (existingAppTables.length && (!hasSchemaMetadata || ![15, 16, 17, 18, 19, 20].includes(existingSchemaVersion))) {
       for (const table of [...mysqlTableNames].reverse()) {
         await pool.query(`DROP TABLE IF EXISTS \`${table}\``);
       }
@@ -167,6 +167,35 @@ export function createMysqlAdapter(context) {
         await pool.execute('UPDATE schema_metadata SET schema_version = 17 WHERE id = 1');
         metadataRows[0].schema_version = 17;
       }
+      if (Number(metadataRows[0]?.schema_version || 1) < 18) {
+        await pool.query("ALTER TABLE users MODIFY COLUMN role ENUM('admin', 'candidate', 'admission_school') NOT NULL");
+        const [profileColumns] = await pool.query("SHOW COLUMNS FROM candidate_profiles WHERE Field IN ('specialty_types', 'specialty_certificate', 'policy_eligibility')");
+        const existingProfileColumns = new Set(profileColumns.map(item => item.Field));
+        if (!existingProfileColumns.has('specialty_types')) await pool.query('ALTER TABLE candidate_profiles ADD COLUMN specialty_types JSON NOT NULL DEFAULT (JSON_ARRAY()) AFTER guardian_phone');
+        if (!existingProfileColumns.has('specialty_certificate')) await pool.query('ALTER TABLE candidate_profiles ADD COLUMN specialty_certificate VARCHAR(255) NULL AFTER specialty_types');
+        if (!existingProfileColumns.has('policy_eligibility')) await pool.query('ALTER TABLE candidate_profiles ADD COLUMN policy_eligibility VARCHAR(255) NULL AFTER specialty_certificate');
+        await pool.execute('UPDATE schema_metadata SET schema_version = 18, app_version = 18 WHERE id = 1');
+        metadataRows[0].schema_version = 18;
+      }
+      if (Number(metadataRows[0]?.schema_version || 1) < 19) {
+        const [schoolColumns] = await pool.query("SHOW COLUMNS FROM schools WHERE Field IN ('is_source_school', 'is_admission_school')");
+        const existingSchoolColumns = new Set(schoolColumns.map(item => item.Field));
+        if (!existingSchoolColumns.has('is_source_school')) await pool.query('ALTER TABLE schools ADD COLUMN is_source_school BOOLEAN NOT NULL DEFAULT TRUE AFTER address');
+        if (!existingSchoolColumns.has('is_admission_school')) await pool.query('ALTER TABLE schools ADD COLUMN is_admission_school BOOLEAN NOT NULL DEFAULT TRUE AFTER is_source_school');
+        const [specialtyColumns] = await pool.query("SHOW COLUMNS FROM candidate_profiles WHERE Field IN ('specialty_category', 'specialty_type')");
+        const existingSpecialtyColumns = new Set(specialtyColumns.map(item => item.Field));
+        if (!existingSpecialtyColumns.has('specialty_category')) await pool.query('ALTER TABLE candidate_profiles ADD COLUMN specialty_category VARCHAR(30) NULL AFTER guardian_phone');
+        if (!existingSpecialtyColumns.has('specialty_type')) await pool.query('ALTER TABLE candidate_profiles ADD COLUMN specialty_type VARCHAR(40) NULL AFTER specialty_category');
+        const [registrationColumns] = await pool.query("SHOW COLUMNS FROM registrations WHERE Field = 'feature_score'");
+        if (!registrationColumns.length) await pool.query('ALTER TABLE registrations ADD COLUMN feature_score DECIMAL(8,2) NOT NULL DEFAULT 0 AFTER number_rule_id');
+        await pool.execute('UPDATE schema_metadata SET schema_version = 19, app_version = 19 WHERE id = 1');
+        metadataRows[0].schema_version = 19;
+      }
+      if (Number(metadataRows[0]?.schema_version || 1) < 20) {
+        await pool.query("ALTER TABLE admission_records MODIFY COLUMN kind ENUM('setting', 'plan', 'preference', 'placement', 'notification', 'indicator_qualification', 'qualification_publication', 'cutoff_publication') NOT NULL");
+        await pool.execute('UPDATE schema_metadata SET schema_version = 20, app_version = 20 WHERE id = 1');
+        metadataRows[0].schema_version = 20;
+      }
       if (Number(metadataRows[0]?.app_version || 1) < 2) {
         const extension = seed();
         const connection = await pool.getConnection();
@@ -349,7 +378,7 @@ export function createMysqlAdapter(context) {
         await connection.beginTransaction();
         const [insert] = await connection.execute(`
           INSERT IGNORE INTO schema_metadata (id, schema_version, app_version, self_registration_enabled, created_at)
-          VALUES (1, 17, ?, ?, ?)
+          VALUES (1, 18, ?, ?, ?)
         `, [Number(initialState.meta?.version || 1), initialState.settings?.selfRegistrationEnabled ? 1 : 0, initialState.meta?.createdAt || new Date().toISOString()]);
         if (insert.affectedRows === 1) {
           for (const item of buildSeedOperations(initialState)) await connection.execute(item.sql, item.params);

src/database/schema.mjs

@@ -22,6 +22,8 @@ export const sqliteSchema = `
     name TEXT NOT NULL UNIQUE,
     code TEXT NOT NULL UNIQUE,
     address TEXT,
+    is_source_school INTEGER NOT NULL DEFAULT 1 CHECK (is_source_school IN (0, 1)),
+    is_admission_school INTEGER NOT NULL DEFAULT 1 CHECK (is_admission_school IN (0, 1)),
     active INTEGER NOT NULL DEFAULT 1 CHECK (active IN (0, 1))
   ) STRICT;
 
@@ -47,7 +49,7 @@ export const sqliteSchema = `
     username TEXT NOT NULL UNIQUE,
     candidate_number TEXT UNIQUE,
     password_hash TEXT NOT NULL,
-    role TEXT NOT NULL CHECK (role IN ('admin', 'candidate')),
+    role TEXT NOT NULL CHECK (role IN ('admin', 'candidate', 'admission_school')),
     admin_level TEXT CHECK (admin_level IN ('super', 'school', 'class')),
     school_id TEXT REFERENCES schools(id) ON DELETE SET NULL,
     class_id TEXT REFERENCES school_classes(id) ON DELETE SET NULL,
@@ -90,6 +92,11 @@ export const sqliteSchema = `
     postal_code TEXT,
     guardian_name TEXT,
     guardian_phone TEXT,
+    specialty_category TEXT,
+    specialty_type TEXT,
+    specialty_types TEXT NOT NULL DEFAULT '[]',
+    specialty_certificate TEXT,
+    policy_eligibility TEXT,
     profile_completed INTEGER NOT NULL DEFAULT 0 CHECK (profile_completed IN (0, 1)),
     status TEXT NOT NULL CHECK (status IN ('pending', 'approved', 'rejected')),
     review_note TEXT,
@@ -171,6 +178,7 @@ export const sqliteSchema = `
     review_note TEXT,
     registration_number TEXT,
     number_rule_id TEXT,
+    feature_score REAL NOT NULL DEFAULT 0 CHECK (feature_score >= 0),
     UNIQUE (user_id, exam_id)
   ) STRICT;
 
@@ -426,6 +434,18 @@ export const sqliteSchema = `
     created_at TEXT NOT NULL
   ) STRICT;
 
+  CREATE TABLE IF NOT EXISTS admission_records (
+    id TEXT PRIMARY KEY,
+    kind TEXT NOT NULL CHECK (kind IN ('setting', 'plan', 'preference', 'placement', 'notification', 'indicator_qualification', 'qualification_publication', 'cutoff_publication')),
+    exam_id TEXT NOT NULL REFERENCES exams(id) ON DELETE CASCADE,
+    user_id TEXT REFERENCES users(id) ON DELETE CASCADE,
+    school_id TEXT REFERENCES schools(id) ON DELETE CASCADE,
+    status TEXT NOT NULL,
+    payload_json TEXT NOT NULL DEFAULT '{}',
+    created_at TEXT NOT NULL,
+    updated_at TEXT NOT NULL
+  ) STRICT;
+
   CREATE INDEX IF NOT EXISTS idx_profiles_status ON candidate_profiles(status);
   CREATE INDEX IF NOT EXISTS idx_users_archive_scope ON users(role, school_id, class_id, archived_at);
   CREATE INDEX IF NOT EXISTS idx_exams_archive ON exams(archived_at, exam_end);
@@ -446,6 +466,7 @@ export const sqliteSchema = `
   CREATE INDEX IF NOT EXISTS idx_account_batch_items ON candidate_account_batch_items(batch_id, class_id, position);
   CREATE INDEX IF NOT EXISTS idx_results_registration ON results(registration_id, published);
   CREATE INDEX IF NOT EXISTS idx_audit_created ON audit_logs(created_at);
+  CREATE INDEX IF NOT EXISTS idx_admission_records_lookup ON admission_records(kind, exam_id, school_id, user_id, status);
 
   CREATE TRIGGER IF NOT EXISTS trg_results_lock_archived_insert
   BEFORE INSERT ON results
@@ -505,6 +526,8 @@ export const mysqlSchema = [
     name VARCHAR(160) NOT NULL,
     code VARCHAR(40) NOT NULL,
     address VARCHAR(255) NULL,
+    is_source_school BOOLEAN NOT NULL DEFAULT TRUE,
+    is_admission_school BOOLEAN NOT NULL DEFAULT TRUE,
     active BOOLEAN NOT NULL DEFAULT TRUE,
     PRIMARY KEY (id),
     UNIQUE KEY uq_schools_name (name),
@@ -536,7 +559,7 @@ export const mysqlSchema = [
     username VARCHAR(100) NOT NULL,
     candidate_number VARCHAR(120) NULL,
     password_hash VARCHAR(255) NOT NULL,
-    role ENUM('admin', 'candidate') NOT NULL,
+    role ENUM('admin', 'candidate', 'admission_school') NOT NULL,
     admin_level ENUM('super', 'school', 'class') NULL,
     school_id VARCHAR(64) NULL,
     class_id VARCHAR(64) NULL,
@@ -586,6 +609,11 @@ export const mysqlSchema = [
     postal_code VARCHAR(20) NULL,
     guardian_name VARCHAR(100) NULL,
     guardian_phone VARCHAR(60) NULL,
+    specialty_category VARCHAR(30) NULL,
+    specialty_type VARCHAR(40) NULL,
+    specialty_types JSON NOT NULL DEFAULT (JSON_ARRAY()),
+    specialty_certificate VARCHAR(255) NULL,
+    policy_eligibility VARCHAR(255) NULL,
     profile_completed BOOLEAN NOT NULL DEFAULT FALSE,
     status ENUM('pending', 'approved', 'rejected') NOT NULL,
     review_note VARCHAR(500) NULL,
@@ -687,6 +715,7 @@ export const mysqlSchema = [
     review_note VARCHAR(500) NULL,
     registration_number VARCHAR(120) NULL,
     number_rule_id VARCHAR(64) NULL,
+    feature_score DECIMAL(8,2) NOT NULL DEFAULT 0,
     PRIMARY KEY (id),
     UNIQUE KEY uq_registrations_user_exam (user_id, exam_id),
     KEY idx_registrations_status (status),
@@ -987,6 +1016,22 @@ export const mysqlSchema = [
     CONSTRAINT fk_workflow_action_from FOREIGN KEY (from_assignee_id) REFERENCES users(id) ON DELETE SET NULL,
     CONSTRAINT fk_workflow_action_to FOREIGN KEY (to_assignee_id) REFERENCES users(id) ON DELETE SET NULL
   ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci`,
+  `CREATE TABLE IF NOT EXISTS admission_records (
+    id VARCHAR(64) NOT NULL,
+    kind ENUM('setting', 'plan', 'preference', 'placement', 'notification', 'indicator_qualification', 'qualification_publication', 'cutoff_publication') NOT NULL,
+    exam_id VARCHAR(64) NOT NULL,
+    user_id VARCHAR(64) NULL,
+    school_id VARCHAR(64) NULL,
+    status VARCHAR(40) NOT NULL,
+    payload_json JSON NOT NULL,
+    created_at VARCHAR(35) NOT NULL,
+    updated_at VARCHAR(35) NOT NULL,
+    PRIMARY KEY (id),
+    KEY idx_admission_records_lookup (kind, exam_id, school_id, user_id, status),
+    CONSTRAINT fk_admission_record_exam FOREIGN KEY (exam_id) REFERENCES exams(id) ON DELETE CASCADE,
+    CONSTRAINT fk_admission_record_user FOREIGN KEY (user_id) REFERENCES users(id) ON DELETE CASCADE,
+    CONSTRAINT fk_admission_record_school FOREIGN KEY (school_id) REFERENCES schools(id) ON DELETE CASCADE
+  ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci`,
   `CREATE TABLE IF NOT EXISTS audit_logs (
     id VARCHAR(64) NOT NULL,
     actor_id VARCHAR(64) NULL,

src/database/sqlite-adapter.mjs

@@ -32,16 +32,23 @@ export function createSqliteAdapter(context) {
     ensureColumns('users', [
       ['admin_level', 'TEXT'], ['school_id', 'TEXT'], ['class_id', 'TEXT'], ['active', 'INTEGER NOT NULL DEFAULT 1'],
       ['candidate_number', 'TEXT'], ['must_change_password', 'INTEGER NOT NULL DEFAULT 0'],
+      ['totp_enabled', 'INTEGER NOT NULL DEFAULT 0'], ['totp_secret_encrypted', 'TEXT'],
+      ['totp_recovery_codes', "TEXT NOT NULL DEFAULT '[]'"], ['totp_last_used_step', 'INTEGER'],
       ['archived_at', 'TEXT'], ['archived_by', 'TEXT']
     ]);
     ensureColumns('schema_metadata', [['self_registration_enabled', 'INTEGER NOT NULL DEFAULT 0']]);
+    ensureColumns('schools', [
+      ['is_source_school', 'INTEGER NOT NULL DEFAULT 1'], ['is_admission_school', 'INTEGER NOT NULL DEFAULT 1']
+    ]);
     ensureColumns('candidate_profiles', [
       ['school_id', 'TEXT'], ['class_id', 'TEXT'], ['native_place', 'TEXT'], ['birth_date', 'TEXT'], ['ethnicity', 'TEXT'],
       ['postal_code', 'TEXT'], ['guardian_name', 'TEXT'], ['guardian_phone', 'TEXT'], ['profile_completed', 'INTEGER NOT NULL DEFAULT 0'],
       ['province_code', 'TEXT'], ['province_name', 'TEXT'], ['city_code', 'TEXT'], ['city_name', 'TEXT'],
-      ['district_code', 'TEXT'], ['district_name', 'TEXT']
+      ['district_code', 'TEXT'], ['district_name', 'TEXT'], ['specialty_types', "TEXT NOT NULL DEFAULT '[]'"],
+      ['specialty_category', 'TEXT'], ['specialty_type', 'TEXT'],
+      ['specialty_certificate', 'TEXT'], ['policy_eligibility', 'TEXT']
     ]);
-    ensureColumns('registrations', [['registration_number', 'TEXT'], ['number_rule_id', 'TEXT']]);
+    ensureColumns('registrations', [['registration_number', 'TEXT'], ['number_rule_id', 'TEXT'], ['feature_score', 'REAL NOT NULL DEFAULT 0']]);
     ensureColumns('exams', [
       ['pass_policy', "TEXT NOT NULL DEFAULT 'rank_percent'"], ['pass_value', 'REAL NOT NULL DEFAULT 60'],
       ['archived_at', 'TEXT'], ['archived_by', 'TEXT']
@@ -68,6 +75,32 @@ export function createSqliteAdapter(context) {
     ensureColumns('admit_card_subjects', [
       ['building', "TEXT NOT NULL DEFAULT ''"], ['floor', "TEXT NOT NULL DEFAULT ''"]
     ]);
+    if (tableExists('users')) {
+      const usersSql = connection.prepare("SELECT sql FROM sqlite_master WHERE type = 'table' AND name = 'users'").get()?.sql || '';
+      if (!usersSql.includes('admission_school')) {
+        connection.exec(`
+          PRAGMA foreign_keys = OFF;
+          BEGIN IMMEDIATE;
+          CREATE TABLE users_v18 (
+            id TEXT PRIMARY KEY, username TEXT NOT NULL UNIQUE, candidate_number TEXT UNIQUE, password_hash TEXT NOT NULL,
+            role TEXT NOT NULL CHECK (role IN ('admin', 'candidate', 'admission_school')),
+            admin_level TEXT CHECK (admin_level IN ('super', 'school', 'class')),
+            school_id TEXT REFERENCES schools(id) ON DELETE SET NULL, class_id TEXT REFERENCES school_classes(id) ON DELETE SET NULL,
+            active INTEGER NOT NULL DEFAULT 1 CHECK (active IN (0, 1)), must_change_password INTEGER NOT NULL DEFAULT 0 CHECK (must_change_password IN (0, 1)),
+            totp_enabled INTEGER NOT NULL DEFAULT 0 CHECK (totp_enabled IN (0, 1)), totp_secret_encrypted TEXT,
+            totp_recovery_codes TEXT NOT NULL DEFAULT '[]', totp_last_used_step INTEGER, archived_at TEXT,
+            archived_by TEXT REFERENCES users_v18(id) ON DELETE RESTRICT, display_name TEXT NOT NULL, created_at TEXT NOT NULL
+          ) STRICT;
+          INSERT INTO users_v18 SELECT id, username, candidate_number, password_hash, role, admin_level, school_id, class_id,
+            active, must_change_password, COALESCE(totp_enabled, 0), totp_secret_encrypted, COALESCE(totp_recovery_codes, '[]'),
+            totp_last_used_step, archived_at, archived_by, display_name, created_at FROM users;
+          DROP TABLE users;
+          ALTER TABLE users_v18 RENAME TO users;
+          COMMIT;
+          PRAGMA foreign_keys = ON;
+        `);
+      }
+    }
     if (tableExists('workflow_definitions')) {
       const definitionSql = connection.prepare("SELECT sql FROM sqlite_master WHERE type = 'table' AND name = 'workflow_definitions'").get()?.sql || '';
       if (!definitionSql.includes('candidate_account_batch')) {
@@ -246,12 +279,36 @@ export function createSqliteAdapter(context) {
       connection.prepare('UPDATE schema_metadata SET schema_version = 16 WHERE id = 1').run();
     }
     if (existingSystem && Number(existingSystem.schema_version || 1) < 17) {
+      connection.prepare('UPDATE schema_metadata SET schema_version = 17 WHERE id = 1').run();
+    }
+    if (existingSystem && Number(existingSystem.schema_version || 1) < 18) {
+      connection.prepare('UPDATE schema_metadata SET schema_version = 18, app_version = 18 WHERE id = 1').run();
+    }
+    if (existingSystem && Number(existingSystem.schema_version || 1) < 19) {
+      connection.prepare('UPDATE schema_metadata SET schema_version = 19, app_version = 19 WHERE id = 1').run();
+    }
+    if (existingSystem && Number(existingSystem.schema_version || 1) < 20) {
       connection.exec(`
-        ALTER TABLE users ADD COLUMN totp_enabled INTEGER NOT NULL DEFAULT 0 CHECK (totp_enabled IN (0, 1));
+        PRAGMA foreign_keys = OFF;
-        ALTER TABLE users ADD COLUMN totp_secret_encrypted TEXT;
+        BEGIN IMMEDIATE;
-        ALTER TABLE users ADD COLUMN totp_recovery_codes TEXT NOT NULL DEFAULT '[]';
+        CREATE TABLE admission_records_v20 (
-        ALTER TABLE users ADD COLUMN totp_last_used_step INTEGER;
+          id TEXT PRIMARY KEY,
-        UPDATE schema_metadata SET schema_version = 17 WHERE id = 1;
+          kind TEXT NOT NULL CHECK (kind IN ('setting', 'plan', 'preference', 'placement', 'notification', 'indicator_qualification', 'qualification_publication', 'cutoff_publication')),
+          exam_id TEXT NOT NULL REFERENCES exams(id) ON DELETE CASCADE,
+          user_id TEXT REFERENCES users(id) ON DELETE CASCADE,
+          school_id TEXT REFERENCES schools(id) ON DELETE CASCADE,
+          status TEXT NOT NULL,
+          payload_json TEXT NOT NULL DEFAULT '{}',
+          created_at TEXT NOT NULL,
+          updated_at TEXT NOT NULL
+        ) STRICT;
+        INSERT INTO admission_records_v20 SELECT id, kind, exam_id, user_id, school_id, status, payload_json, created_at, updated_at FROM admission_records;
+        DROP TABLE admission_records;
+        ALTER TABLE admission_records_v20 RENAME TO admission_records;
+        CREATE INDEX idx_admission_records_lookup ON admission_records(kind, exam_id, school_id, user_id, status);
+        UPDATE schema_metadata SET schema_version = 20, app_version = 20 WHERE id = 1;
+        COMMIT;
+        PRAGMA foreign_keys = ON;
       `);
     }
     if (existingSystem && Number(existingSystem.app_version || 1) < 2) {
@@ -414,7 +471,7 @@ export function createSqliteAdapter(context) {
       try {
         connection.prepare(`
           INSERT INTO schema_metadata (id, schema_version, app_version, self_registration_enabled, created_at)
-          VALUES (1, 17, ?, ?, ?)
+          VALUES (1, 18, ?, ?, ?)
         `).run(Number(initialState.meta?.version || 1), initialState.settings?.selfRegistrationEnabled ? 1 : 0, initialState.meta?.createdAt || new Date().toISOString());
         for (const item of buildSeedOperations(initialState)) connection.prepare(item.sql).run(...item.params);
         connection.exec('COMMIT');

src/database/version.mjs

@@ -0,0 +1 @@
+export const CURRENT_SCHEMA_VERSION = 20;

src/routes/admin.routes.mjs

@@ -1,5 +1,7 @@
 import { admissionMixingScopes, buildAdmissionArrangement } from '../services/admission-arrangement.mjs';
 import { noticeForClient, noticePlainText, sanitizeNoticeContent } from '../security/notice-content.mjs';
+import { admissionCutoffRows, admissionPhases, admissionRecords, admissionSetting, buildVolunteerPlacements, candidateTotalScore, publicAdmissionRows, remainingPlanQuota, sourceSchoolQualificationStatus } from '../services/volunteer-admission.mjs';
+import { isValidSpecialty, resolveProfileSpecialty, specialtyLabel } from '../data/specialty-types.mjs';
 
 export function createAdminRoutes(context) {
   const {
@@ -108,11 +110,78 @@ export function createAdminRoutes(context) {
     return '';
   }
 
+  function normalizeAdmissionCategories(input) {
+    return (Array.isArray(input) ? input : []).map((item, index) => ({
+      code: cleanText(item.code || `category_${index + 1}`, 40), name: cleanText(item.name, 80),
+      quota: Math.max(0, Math.trunc(Number(item.quota || 0))), specialtyCategory: cleanText(item.specialtyCategory, 30), specialtyType: cleanText(item.specialtyType, 80),
+      indicatorAllocations: (Array.isArray(item.indicatorAllocations) ? item.indicatorAllocations : []).map(allocation => ({
+        sourceSchoolId: cleanText(allocation.sourceSchoolId, 64), quota: Math.max(0, Math.trunc(Number(allocation.quota || 0)))
+      })).filter(item => item.sourceSchoolId && item.quota > 0)
+    })).filter(item => item.code && item.name && item.quota > 0);
+  }
+
+  function systemPublications(db) {
+    const examName = examId => db.exams.find(item => item.id === examId)?.name || '未知考试';
+    const schoolName = schoolId => db.schools.find(item => item.id === schoolId)?.name || '未知学校';
+    const view = (record, sourceType, category, title, publishedAt, summary) => ({
+      id: record.id,
+      sourceType,
+      category,
+      title,
+      summary,
+      author: '系统自动发布',
+      publishedAt,
+      visible: record.payload?.publicVisible !== false,
+      status: record.payload?.publicVisible === false ? 'hidden' : 'visible'
+    });
+    const plans = admissionRecords(db, 'plan').filter(item => item.status === 'approved').map(item => view(
+      item,
+      'plan',
+      '招生计划',
+      `${examName(item.examId)} · ${schoolName(item.schoolId)}招生计划公示`,
+      item.payload?.reviewedAt || item.updatedAt,
+      '审核通过后由系统生成，当前页面仅控制是否在公开通知目录显示。'
+    ));
+    const qualifications = admissionRecords(db, 'qualification_publication').filter(item => item.status === 'published').map(item => view(
+      item,
+      'qualification',
+      '指标资格',
+      `${examName(item.examId)} · ${schoolName(item.schoolId)}指标分配资格公示`,
+      item.payload?.publishedAt || item.updatedAt,
+      '资格确认完成后由系统生成，内容随资格确认结果更新。'
+    ));
+    const admissions = admissionRecords(db, 'setting').filter(item => item.status === 'completed' && item.payload?.autoPublish !== false).map(item => view(
+      item,
+      'admission',
+      '录取名单',
+      `${examName(item.examId)}最终录取名单`,
+      item.payload?.completedAt || item.updatedAt,
+      '录取结束后由系统生成，内容取自最终录取结果。'
+    ));
+    const cutoffs = admissionRecords(db, 'cutoff_publication').filter(item => item.status === 'published' && admissionSetting(db, item.examId)?.payload?.autoPublish !== false).map(item => view(
+      item,
+      'cutoff',
+      '录取分数线',
+      `${examName(item.examId)}录取分数线`,
+      item.payload?.publishedAt || item.updatedAt,
+      '录取结束后由系统生成，内容取自各招生类别最低录取分数。'
+    ));
+    return [...plans, ...qualifications, ...admissions, ...cutoffs]
+      .sort((left, right) => new Date(right.publishedAt) - new Date(left.publishedAt));
+  }
+
   async function handleAdmin(request, response, pathname) {
     if (!pathname.startsWith('/api/admin/')) return false;
     const user = await requireUser(request, response, 'admin');
     if (!user) return true;
-    const db = await readDb();
+    if (request.method === 'GET' && pathname === '/api/admin/results') {
+      const requestedExamId = new URL(request.url, `http://${request.headers.host || '127.0.0.1'}`).searchParams.get('examId');
+      if (!requestedExamId) {
+        if (!requirePermission(user, response, 'results.read')) return true;
+        return sendJson(response, 200, { ok: true, selectedExamId: '', results: [], appeals: [], registrations: [], exams: [], resultCache: { enabled: cache.enabled, status: cache.status } });
+      }
+    }
+    const db = request.authDb || await readDb();
     if (request.method === 'DELETE' && /^\/api\/admin\/(?:admins|candidates|candidate-accounts)(?:\/|$)/.test(pathname)) {
       return sendError(response, 405, '账户不得删除；考生账户请由校方归档，管理员账户可停用');
     }
@@ -129,6 +198,237 @@ export function createAdminRoutes(context) {
       });
     }
 
+    if (pathname === '/api/admin/indicator-qualifications' && request.method === 'GET') {
+      if (user.adminLevel !== 'school' || !user.schoolId) return sendError(response, 403, '只有生源校学校管理员可以确认指标分配资格');
+      const school = db.schools.find(item => item.id === user.schoolId && item.active && item.isSourceSchool);
+      if (!school) return sendError(response, 403, '当前学校未设置为生源学校');
+      const exams = admissionRecords(db, 'setting').filter(item => item.payload?.enabled).map(setting => {
+        const exam = db.exams.find(item => item.id === setting.examId);
+        return { ...setting, exam: exam ? publicExam(exam) : null, qualificationStatus: sourceSchoolQualificationStatus(db, setting.examId, school.id) };
+      }).filter(item => item.exam);
+      return sendJson(response, 200, { ok: true, school, exams });
+    }
+    const qualificationBulkMatch = pathname.match(/^\/api\/admin\/indicator-qualifications\/([^/]+)\/bulk$/);
+    if (qualificationBulkMatch && request.method === 'PUT') {
+      if (user.adminLevel !== 'school' || !user.schoolId) return sendError(response, 403, '只有生源校学校管理员可以批量确认指标分配资格');
+      const setting = admissionSetting(db, qualificationBulkMatch[1]);
+      if (!setting?.payload?.enabled) return sendError(response, 404, '该考试未启用志愿填报');
+      const body = await readJson(request);
+      if (typeof body.eligible !== 'boolean') return sendError(response, 400, '请选择批量设置为有资格或无资格');
+      const userIds = [...new Set((Array.isArray(body.userIds) ? body.userIds : []).map(value => cleanText(value, 64)).filter(Boolean))];
+      if (!userIds.length) return sendError(response, 400, '请至少选择一名考生');
+      const profiles = userIds.map(userId => db.candidateProfiles.find(item => item.userId === userId && item.schoolId === user.schoolId && item.profileCompleted));
+      if (profiles.some(item => !item) || profiles.some(profile => !db.users.some(item => item.id === profile.userId && item.role === 'candidate' && item.active))) return sendError(response, 403, '批量名单中包含不属于本校的有效考生');
+      const now = nowIso();
+      const existing = new Map(admissionRecords(db, 'indicator_qualification', setting.examId).map(item => [item.userId, item]));
+      const qualifications = profiles.map(profile => {
+        const qualification = existing.get(profile.userId) || { id: uid('indicator_qualification'), kind: 'indicator_qualification', examId: setting.examId, userId: profile.userId, schoolId: user.schoolId, createdAt: now };
+        Object.assign(qualification, { status: 'confirmed', updatedAt: now, payload: { eligible: body.eligible, confirmedBy: user.displayName, confirmedAt: now } });
+        return qualification;
+      });
+      const replacementIds = new Set(qualifications.map(item => item.id));
+      const nextDb = { ...db, admissionRecords: [...db.admissionRecords.filter(item => !replacementIds.has(item.id)), ...qualifications] };
+      const status = sourceSchoolQualificationStatus(nextDb, setting.examId, user.schoolId);
+      const records = [...qualifications];
+      if (status.complete) {
+        const published = admissionRecords(nextDb, 'qualification_publication', setting.examId).find(item => item.schoolId === user.schoolId);
+        const publication = published || { id: uid('qualification_publication'), kind: 'qualification_publication', examId: setting.examId, userId: user.id, schoolId: user.schoolId, createdAt: now };
+        Object.assign(publication, { status: 'published', updatedAt: now, payload: { ...publication.payload, publishedAt: now, rows: status.rows } });
+        records.push(publication);
+      }
+      await database.saveAdmissionRecords(records, logAction(db, user, '批量确认指标分配资格', `${qualifications.length} 人 · ${body.eligible ? '有资格' : '无资格'}${status.complete ? ' · 全校已自动公示' : ''}`));
+      return sendJson(response, 200, { ok: true, count: qualifications.length, qualificationStatus: status, published: status.complete });
+    }
+    const qualificationMatch = pathname.match(/^\/api\/admin\/indicator-qualifications\/([^/]+)\/([^/]+)$/);
+    if (qualificationMatch && request.method === 'PUT') {
+      if (user.adminLevel !== 'school' || !user.schoolId) return sendError(response, 403, '只有生源校学校管理员可以确认指标分配资格');
+      const setting = admissionSetting(db, qualificationMatch[1]);
+      const profile = db.candidateProfiles.find(item => item.userId === qualificationMatch[2] && item.schoolId === user.schoolId && item.profileCompleted);
+      const account = db.users.find(item => item.id === profile?.userId && item.role === 'candidate' && item.active);
+      if (!setting?.payload?.enabled) return sendError(response, 404, '该考试未启用志愿填报');
+      if (!profile || !account) return sendError(response, 404, '本校有效考生不存在');
+      const body = await readJson(request);
+      if (typeof body.eligible !== 'boolean') return sendError(response, 400, '请选择有或无指标分配资格');
+      const now = nowIso();
+      const existing = admissionRecords(db, 'indicator_qualification', setting.examId).find(item => item.userId === profile.userId);
+      const qualification = existing || { id: uid('indicator_qualification'), kind: 'indicator_qualification', examId: setting.examId, userId: profile.userId, schoolId: user.schoolId, createdAt: now };
+      Object.assign(qualification, { status: 'confirmed', updatedAt: now, payload: { eligible: body.eligible, confirmedBy: user.displayName, confirmedAt: now } });
+      const nextRecords = [...db.admissionRecords.filter(item => item.id !== qualification.id), qualification];
+      const nextDb = { ...db, admissionRecords: nextRecords };
+      const status = sourceSchoolQualificationStatus(nextDb, setting.examId, user.schoolId);
+      const records = [qualification];
+      if (status.complete) {
+        const published = admissionRecords(nextDb, 'qualification_publication', setting.examId).find(item => item.schoolId === user.schoolId);
+        const publication = published || { id: uid('qualification_publication'), kind: 'qualification_publication', examId: setting.examId, userId: user.id, schoolId: user.schoolId, createdAt: now };
+        Object.assign(publication, { status: 'published', updatedAt: now, payload: { ...publication.payload, publishedAt: now, rows: status.rows } });
+        records.push(publication);
+      }
+      await database.saveAdmissionRecords(records, logAction(db, user, '确认指标分配资格', `${account.candidateNumber} · ${body.eligible ? '有资格' : '无资格'}${status.complete ? ' · 全校已自动公示' : ''}`));
+      return sendJson(response, 200, { ok: true, qualification, qualificationStatus: status, published: status.complete, message: status.complete ? '资格已确认；本校全部考生确认完成，公示已自动发布' : '资格已确认' });
+    }
+
+    if (pathname === '/api/admin/admissions' && request.method === 'GET') {
+      if (user.adminLevel !== 'super') return sendError(response, 403, '只有超级管理员可以查看志愿与录取数据');
+      const examById = new Map(db.exams.map(item => [item.id, item]));
+      const schoolById = new Map(db.schools.map(item => [item.id, item]));
+      const userById = new Map(db.users.map(item => [item.id, item]));
+      const profileByUserId = new Map(db.candidateProfiles.map(item => [item.userId, item]));
+      const settings = admissionRecords(db, 'setting').map(setting => ({ ...setting, exam: examById.get(setting.examId) }));
+      const plans = admissionRecords(db, 'plan').map(plan => ({ ...plan, schoolName: schoolById.get(plan.schoolId)?.name || '', examName: examById.get(plan.examId)?.name || '', remainingCategories: remainingPlanQuota(db, plan) }));
+      const placements = admissionRecords(db, 'placement').map(placement => {
+        const account = userById.get(placement.userId) || {};
+        const profile = profileByUserId.get(placement.userId) || {};
+        const qualification = resolveProfileSpecialty(profile);
+        return { ...placement, candidate: { registrationNumber: account.candidateNumber, name: profile.name, idNumberMasked: maskId(profile.idNumber), specialtyLabel: specialtyLabel(qualification.category, qualification.type) }, schoolName: schoolById.get(placement.schoolId)?.name || '' };
+      });
+      const preferences = admissionRecords(db, 'preference').map(preference => {
+        const account = userById.get(preference.userId) || {};
+        const profile = profileByUserId.get(preference.userId) || {};
+        return { ...preference, candidate: { registrationNumber: account.candidateNumber, name: profile.name }, choices: (preference.payload?.choices || []).map(choice => ({ ...choice, schoolName: schoolById.get(choice.schoolId)?.name || '' })) };
+      });
+      const schoolAccounts = db.users.filter(item => item.role === 'admission_school').map(item => {
+        const school = schoolById.get(item.schoolId);
+        return { ...safeUser(item), active: item.active !== false, createdAt: item.createdAt, schoolName: school?.name || '', schoolCode: school?.code || '' };
+      });
+      return sendJson(response, 200, { ok: true, settings, plans, preferences, placements, schoolAccounts, schools: db.schools.filter(item => item.active), admissionSchools: db.schools.filter(item => item.active && item.isAdmissionSchool), sourceSchools: db.schools.filter(item => item.active && item.isSourceSchool), exams: db.exams.filter(item => !item.archivedAt) });
+    }
+    if (pathname === '/api/admin/admission-school-accounts' && request.method === 'POST') {
+      if (user.adminLevel !== 'super') return sendError(response, 403, '只有超级管理员可以创建招生学校账号');
+      const body = await readJson(request);
+      const school = db.schools.find(item => item.id === cleanText(body.schoolId, 64) && item.active && item.isAdmissionSchool);
+      const username = cleanText(body.username, 80);
+      const password = String(body.password || '');
+      if (!school || !username || password.length < 8) return sendError(response, 400, '请选择学校，并填写登录账号和至少 8 位密码');
+      if (db.users.some(item => item.username.toLowerCase() === username.toLowerCase())) return sendError(response, 409, '登录账号已存在');
+      const account = { id: uid('usr'), username, passwordHash: hashPassword(password), role: 'admission_school', schoolId: school.id, displayName: cleanText(body.displayName, 80) || `${school.name}招生办`, active: true, createdAt: nowIso() };
+      await database.createAdmissionSchoolAccount(account, logAction(db, user, '创建招生学校账号', `${school.name} · ${username}`));
+      return sendJson(response, 201, { ok: true, account: safeUser(account) });
+    }
+    const admissionAccountMatch = pathname.match(/^\/api\/admin\/admission-school-accounts\/([^/]+)$/);
+    if (admissionAccountMatch && request.method === 'PATCH') {
+      if (user.adminLevel !== 'super') return sendError(response, 403, '只有超级管理员可以维护招生学校账号');
+      const target = db.users.find(item => item.id === admissionAccountMatch[1] && item.role === 'admission_school');
+      if (!target) return sendError(response, 404, '招生学校账号不存在');
+      const body = await readJson(request);
+      target.active = body.active == null ? target.active : Boolean(body.active);
+      target.displayName = cleanText(body.displayName || target.displayName, 80);
+      await database.updateAdmin(target, false, logAction(db, user, target.active ? '启用招生学校账号' : '停用招生学校账号', `${target.displayName} · ${target.username}`));
+      if (!target.active) for (const [token, session] of sessions) if (session.userId === target.id) sessions.delete(token);
+      return sendJson(response, 200, { ok: true, account: { ...safeUser(target), active: target.active } });
+    }
+    const admissionAccountResetMatch = pathname.match(/^\/api\/admin\/admission-school-accounts\/([^/]+)\/reset-password$/);
+    if (admissionAccountResetMatch && request.method === 'POST') {
+      if (user.adminLevel !== 'super') return sendError(response, 403, '只有超级管理员可以重置招生学校账号密码');
+      const target = db.users.find(item => item.id === admissionAccountResetMatch[1] && item.role === 'admission_school');
+      if (!target) return sendError(response, 404, '招生学校账号不存在');
+      const temporaryPassword = `Reset-${randomBytes(7).toString('base64url')}`;
+      target.passwordHash = hashPassword(temporaryPassword);
+      target.active = true;
+      await database.updateAdmin(target, true, logAction(db, user, '重置招生学校账号密码', `${target.displayName} · ${target.username}`));
+      for (const [token, session] of sessions) if (session.userId === target.id) sessions.delete(token);
+      return sendJson(response, 200, { ok: true, username: target.username, temporaryPassword });
+    }
+    const settingMatch = pathname.match(/^\/api\/admin\/admissions\/([^/]+)\/setting$/);
+    if (settingMatch && request.method === 'PUT') {
+      if (user.adminLevel !== 'super') return sendError(response, 403, '只有超级管理员可以设置志愿填报');
+      const exam = db.exams.find(item => item.id === settingMatch[1] && !item.archivedAt);
+      if (!exam) return sendError(response, 404, '考试不存在或已经归档');
+      const body = await readJson(request);
+      const now = nowIso();
+      const setting = admissionSetting(db, exam.id) || { id: uid('admission_setting'), kind: 'setting', examId: exam.id, userId: user.id, schoolId: null, createdAt: now };
+      const requestedStatus = admissionPhases.has(body.status) ? body.status : 'draft';
+      const manualPhases = ['draft', 'filling', 'closed'];
+      const status = setting.status && !manualPhases.includes(setting.status) ? setting.status : manualPhases.includes(requestedStatus) ? requestedStatus : (setting.status || 'draft');
+      setting.status = status;
+      setting.updatedAt = now;
+      setting.payload = { ...setting.payload, enabled: body.enabled === true, preferenceStart: cleanText(body.preferenceStart, 35), preferenceEnd: cleanText(body.preferenceEnd, 35), maxChoices: Math.min(20, Math.max(1, Math.trunc(Number(body.maxChoices || 5)))), maxSubmissions: Math.min(50, Math.max(1, Math.trunc(Number(body.maxSubmissions || 3)))), round: Math.max(1, Math.trunc(Number(body.round || setting.payload?.round || 1))), autoPublish: body.autoPublish !== false, progress: cleanText(body.progress, 200) || '等待志愿填报开始' };
+      if (setting.payload.preferenceStart && setting.payload.preferenceEnd && new Date(setting.payload.preferenceStart) >= new Date(setting.payload.preferenceEnd)) return sendError(response, 400, '志愿填报结束时间必须晚于开始时间');
+      await database.saveAdmissionRecord(setting, logAction(db, user, '设置志愿填报', `${exam.name} · ${status}`));
+      return sendJson(response, 200, { ok: true, setting });
+    }
+    if (pathname === '/api/admin/admission-plans' && request.method === 'POST') {
+      if (user.adminLevel !== 'super') return sendError(response, 403, '只有超级管理员可以代招生学校上传计划');
+      const body = await readJson(request);
+      const exam = db.exams.find(item => item.id === cleanText(body.examId, 64) && !item.archivedAt);
+      const school = db.schools.find(item => item.id === cleanText(body.schoolId, 64) && item.active && item.isAdmissionSchool);
+      const categories = normalizeAdmissionCategories(body.categories);
+      if (!exam || !school || !categories.length) return sendError(response, 400, '请选择考试、招生学校并填写有效计划');
+      if (new Set(categories.map(item => item.code)).size !== categories.length) return sendError(response, 400, '招生类别代码不能重复');
+      if (categories.some(item => !isValidSpecialty(item.specialtyCategory, item.specialtyType))) return sendError(response, 400, '特长生招生类别的大类与小类不对应');
+      if (categories.some(item => new Set(item.indicatorAllocations.map(allocation => allocation.sourceSchoolId)).size !== item.indicatorAllocations.length)) return sendError(response, 400, '同一招生类别不能重复分配同一生源校指标');
+      if (categories.some(item => item.indicatorAllocations.reduce((sum, allocation) => sum + allocation.quota, 0) > item.quota)) return sendError(response, 400, '指标分配合计不能超过类别计划人数');
+      if (categories.some(item => item.indicatorAllocations.some(allocation => !db.schools.some(entry => entry.id === allocation.sourceSchoolId && entry.active && entry.isSourceSchool)))) return sendError(response, 400, '指标分配中包含无效的生源学校');
+      const existing = admissionRecords(db, 'plan', exam.id).find(item => item.schoolId === school.id);
+      if (admissionRecords(db, 'placement', exam.id).some(item => item.schoolId === school.id && item.status !== 'withdrawn')) return sendError(response, 409, '已经产生投档记录，不能再修改该校本轮招生计划');
+      const now = nowIso();
+      const plan = existing || { id: uid('plan'), kind: 'plan', examId: exam.id, schoolId: school.id, createdAt: now };
+      Object.assign(plan, { userId: user.id, status: 'approved', updatedAt: now, payload: { ...plan.payload, categories, note: cleanText(body.note, 500), submittedBy: user.displayName, reviewedBy: user.displayName, reviewedAt: now, reviewNote: '超级管理员代上传并审核通过' } });
+      await database.saveAdmissionRecord(plan, logAction(db, user, '代上传招生计划', `${school.name} · ${exam.name}`));
+      await cache.invalidate('public');
+      return sendJson(response, existing ? 200 : 201, { ok: true, plan });
+    }
+    const planReviewMatch = pathname.match(/^\/api\/admin\/admission-plans\/([^/]+)$/);
+    if (planReviewMatch && request.method === 'PATCH') {
+      if (user.adminLevel !== 'super') return sendError(response, 403, '只有超级管理员可以审核招生计划');
+      const plan = admissionRecords(db, 'plan').find(item => item.id === planReviewMatch[1]);
+      if (!plan) return sendError(response, 404, '招生计划不存在');
+      const body = await readJson(request);
+      if (!['approved', 'rejected'].includes(body.status)) return sendError(response, 400, '审核状态无效');
+      plan.status = body.status;
+      plan.updatedAt = nowIso();
+      plan.payload = { ...plan.payload, reviewNote: cleanText(body.reviewNote, 500), reviewedBy: user.displayName, reviewedAt: plan.updatedAt };
+      await database.saveAdmissionRecord(plan, logAction(db, user, body.status === 'approved' ? '审核通过招生计划' : '退回招生计划', plan.id));
+      await cache.invalidate('public');
+      return sendJson(response, 200, { ok: true, plan });
+    }
+    const actionMatch = pathname.match(/^\/api\/admin\/admissions\/([^/]+)\/(match|finalize|supplementary)$/);
+    if (actionMatch && request.method === 'POST') {
+      if (user.adminLevel !== 'super') return sendError(response, 403, '只有超级管理员可以执行投档与录取操作');
+      const setting = admissionSetting(db, actionMatch[1]);
+      if (!setting?.payload?.enabled) return sendError(response, 404, '该考试未开启志愿填报');
+      const action = actionMatch[2];
+      if (action === 'match') {
+        if (!['closed', 'supplementary'].includes(setting.status)) return sendError(response, 409, '请先结束当前填报阶段再投档');
+        const placements = buildVolunteerPlacements(db, setting, { uid, nowIso });
+        setting.status = 'school_review'; setting.updatedAt = nowIso(); setting.payload.progress = `第 ${setting.payload.round || 1} 轮投档完成，${placements.length} 人已发送招生学校审核`;
+        await database.saveAdmissionRecords([setting, ...placements], logAction(db, user, '执行分数优先志愿投档', `${setting.examId} · ${placements.length} 人`));
+        return sendJson(response, 200, { ok: true, setting, placementCount: placements.length });
+      }
+      if (action === 'finalize') {
+        const placements = admissionRecords(db, 'placement', setting.examId);
+        if (placements.some(item => ['school_review', 'withdrawal_pending'].includes(item.status))) return sendError(response, 409, '仍有招生学校审核或退档申请未处理');
+        const now = nowIso();
+        const admitted = placements.filter(item => item.status === 'admitted').map(item => ({ ...item, status: 'final', updatedAt: now }));
+        const notifications = admitted.map(item => ({ id: uid('notification'), kind: 'notification', examId: setting.examId, userId: item.userId, schoolId: item.schoolId, status: 'unread', createdAt: now, updatedAt: now, payload: { title: '录取结果通知', message: `你已被${db.schools.find(school => school.id === item.schoolId)?.name || '招生学校'}录取`, placementId: item.id } }));
+        setting.status = 'completed'; setting.updatedAt = now; setting.payload.progress = '本次录取工作已结束，录取结果与分数线已经自动公告'; setting.payload.completedAt = now;
+        const completedDb = { ...db, admissionRecords: [...db.admissionRecords.filter(item => !admitted.some(entry => entry.id === item.id)), ...admitted] };
+        const cutoffRows = admissionCutoffRows(completedDb, setting.examId);
+        const existingCutoff = admissionRecords(db, 'cutoff_publication', setting.examId)[0];
+        const cutoffPublication = existingCutoff || { id: uid('cutoff_publication'), kind: 'cutoff_publication', examId: setting.examId, userId: user.id, schoolId: null, createdAt: now };
+        Object.assign(cutoffPublication, { status: 'published', updatedAt: now, payload: { ...cutoffPublication.payload, publishedAt: now, rows: cutoffRows } });
+        await database.saveAdmissionRecords([setting, ...admitted, ...notifications, cutoffPublication], logAction(db, user, '结束录取并发布结果与分数线', `${setting.examId} · ${admitted.length} 人`));
+        return sendJson(response, 200, { ok: true, admittedCount: admitted.length, publicRows: publicAdmissionRows(completedDb, setting.examId), cutoffRows });
+      }
+      const body = await readJson(request);
+      const now = nowIso();
+      if (admissionRecords(db, 'placement', setting.examId).some(item => ['school_review', 'withdrawal_pending'].includes(item.status))) return sendError(response, 409, '仍有学校审核或退档申请待处理，暂不能开启补录');
+      setting.status = 'supplementary'; setting.updatedAt = now; setting.payload = { ...setting.payload, round: Number(setting.payload.round || 1) + 1, preferenceStart: cleanText(body.preferenceStart, 35) || now, preferenceEnd: cleanText(body.preferenceEnd, 35), progress: '招生计划未满，补录志愿填报进行中' };
+      await database.saveAdmissionRecord(setting, logAction(db, user, '开启补录', `${setting.examId} · 第 ${setting.payload.round} 轮`));
+      return sendJson(response, 200, { ok: true, setting });
+    }
+    const withdrawalMatch = pathname.match(/^\/api\/admin\/admission-withdrawals\/([^/]+)$/);
+    if (withdrawalMatch && request.method === 'PATCH') {
+      if (user.adminLevel !== 'super') return sendError(response, 403, '只有超级管理员可以审核退档');
+      const placement = admissionRecords(db, 'placement').find(item => item.id === withdrawalMatch[1] && item.status === 'withdrawal_pending');
+      if (!placement) return sendError(response, 404, '待审核退档申请不存在');
+      const body = await readJson(request);
+      placement.status = body.approved === true ? 'withdrawn' : 'admitted';
+      placement.updatedAt = nowIso();
+      placement.payload.withdrawalReviewNote = cleanText(body.reviewNote, 500);
+      await database.saveAdmissionRecord(placement, logAction(db, user, body.approved === true ? '批准退档' : '驳回退档', placement.id));
+      return sendJson(response, 200, { ok: true, placement });
+    }
+  
     const excelMatch = pathname.match(/^\/api\/admin\/excel\/(classes|class_admins|account_quotas|account_results|candidates|payments|centers|results)$/);
     if (excelMatch && request.method === 'GET') {
       const resource = excelMatch[1];
@@ -140,7 +440,7 @@ export function createAdminRoutes(context) {
       if (resource === 'results' && !hasPermission(user, 'results.read')) return sendError(response, 403, '当前账号不能导出成绩');
       const requestUrl = new URL(request.url, `http://${request.headers.host || '127.0.0.1'}`);
       const template = requestUrl.searchParams.get('template') === '1';
-      const rows = template ? [] : excelRowsForResource(db, user, resource, requestUrl.searchParams);
+      const rows = template && resource !== 'results' ? [] : excelRowsForResource(db, user, resource, requestUrl.searchParams);
       const subtitle = user.adminLevel === 'super' ? '全部数据范围' : adminScopeLabel(db, user);
       const buffer = Buffer.from(await buildWorkbook(resource, rows, { template, subtitle }));
       return sendWorkbook(response, buffer, `${excelResourceNames[resource]}-${template ? '导入模板' : '导出'}-${new Date().toISOString().slice(0, 10)}.xlsx`);
@@ -174,11 +474,14 @@ export function createAdminRoutes(context) {
       const name = cleanText(body.name, 100);
       const code = cleanText(body.code, 40).toUpperCase();
       const address = cleanText(body.address, 200);
+      const isSourceSchool = body.isSourceSchool !== false;
+      const isAdmissionSchool = body.isAdmissionSchool !== false;
       if (!name || !code) return sendError(response, 400, '学校名称和学校代码不能为空');
+      if (!isSourceSchool && !isAdmissionSchool) return sendError(response, 400, '学校至少应设置为生源校或招生校');
       if (!/^[A-Z0-9_-]+$/.test(code)) return sendError(response, 400, '学校代码只能包含字母、数字、下划线和连字符');
       if (db.schools.some(item => item.code.toLowerCase() === code.toLowerCase())) return sendError(response, 409, '学校代码已存在');
       if (db.schools.some(item => item.name.toLowerCase() === name.toLowerCase())) return sendError(response, 409, '学校名称已存在');
-      const school = { id: uid('school'), name, code, address, active: body.active !== false };
+      const school = { id: uid('school'), name, code, address, isSourceSchool, isAdmissionSchool, active: body.active !== false };
       await database.saveSchool(school, true, logAction(db, user, '创建学校', `${name} · ${code}`));
       return sendJson(response, 201, { ok: true, school });
     }
@@ -191,11 +494,14 @@ export function createAdminRoutes(context) {
       const name = cleanText(body.name ?? school.name, 100);
       const code = cleanText(body.code ?? school.code, 40).toUpperCase();
       const address = cleanText(body.address ?? school.address, 200);
+      const isSourceSchool = body.isSourceSchool == null ? school.isSourceSchool : Boolean(body.isSourceSchool);
+      const isAdmissionSchool = body.isAdmissionSchool == null ? school.isAdmissionSchool : Boolean(body.isAdmissionSchool);
       if (!name || !code) return sendError(response, 400, '学校名称和学校代码不能为空');
+      if (!isSourceSchool && !isAdmissionSchool) return sendError(response, 400, '学校至少应设置为生源校或招生校');
       if (!/^[A-Z0-9_-]+$/.test(code)) return sendError(response, 400, '学校代码只能包含字母、数字、下划线和连字符');
       if (db.schools.some(item => item.id !== school.id && item.code.toLowerCase() === code.toLowerCase())) return sendError(response, 409, '学校代码已存在');
       if (db.schools.some(item => item.id !== school.id && item.name.toLowerCase() === name.toLowerCase())) return sendError(response, 409, '学校名称已存在');
-      Object.assign(school, { name, code, address, active: body.active == null ? school.active : Boolean(body.active) });
+      Object.assign(school, { name, code, address, isSourceSchool, isAdmissionSchool, active: body.active == null ? school.active : Boolean(body.active) });
       await database.saveSchool(school, false, logAction(db, user, '维护学校', `${name} · ${code} · ${school.active ? '启用' : '停用'}`));
       return sendJson(response, 200, { ok: true, school });
     }
@@ -212,6 +518,7 @@ export function createAdminRoutes(context) {
     }
     if (pathname === '/api/admin/classes' && request.method === 'POST') {
       if (user.adminLevel !== 'school') return sendError(response, 403, '只有校级管理员可以新增本校班级');
+      if (!db.schools.some(item => item.id === user.schoolId && item.active && item.isSourceSchool)) return sendError(response, 409, '当前学校未设置为已启用的生源校');
       const body = await readJson(request);
       const name = cleanText(body.name, 100); const grade = cleanText(body.grade, 60);
       if (!name || !grade) return sendError(response, 400, '年级和班级名称不能为空');
@@ -243,7 +550,7 @@ export function createAdminRoutes(context) {
         schoolName: db.schools.find(school => school.id === item.schoolId)?.name || '',
         className: db.classes.find(schoolClass => schoolClass.id === item.classId)?.name || ''
       }));
-      return sendJson(response, 200, { ok: true, admins, schools: db.schools, classes: db.classes, selfRegistrationEnabled: db.settings.selfRegistrationEnabled });
+      return sendJson(response, 200, { ok: true, admins, schools: db.schools.filter(item => item.isSourceSchool), classes: db.classes, selfRegistrationEnabled: db.settings.selfRegistrationEnabled });
     }
     if (pathname === '/api/admin/admins' && request.method === 'POST') {
       const body = await readJson(request);
@@ -256,7 +563,7 @@ export function createAdminRoutes(context) {
       if (db.users.some(item => item.username.toLowerCase() === username.toLowerCase())) return sendError(response, 409, '该登录账号已存在');
       const schoolId = adminLevel === 'super' ? null : user.adminLevel === 'school' ? user.schoolId : cleanText(body.schoolId, 64);
       const classId = adminLevel === 'class' ? cleanText(body.classId, 64) : null;
-      if (adminLevel !== 'super' && !db.schools.some(item => item.id === schoolId)) return sendError(response, 400, '校级和班级管理员必须绑定学校');
+      if (adminLevel !== 'super' && !db.schools.some(item => item.id === schoolId && item.active && item.isSourceSchool)) return sendError(response, 400, '校级和班级管理员必须绑定已启用的生源校');
       if (adminLevel === 'class' && !db.classes.some(item => item.id === classId && item.schoolId === schoolId)) return sendError(response, 400, '请选择该学校下的有效班级');
       const created = { id: uid('usr'), username, passwordHash: hashPassword(password), role: 'admin', adminLevel, schoolId, classId, displayName, active: true, createdAt: nowIso() };
       const log = logAction(db, user, '创建管理员', `${displayName} · ${adminLevelNames[adminLevel]}`);
@@ -265,19 +572,34 @@ export function createAdminRoutes(context) {
     }
     const adminMatch = pathname.match(/^\/api\/admin\/admins\/([^/]+)$/);
     if (adminMatch && request.method === 'PATCH') {
-      if (user.adminLevel !== 'school') return sendError(response, 403, '只有校级管理员可以维护本校班级管理员');
+      if (!['super', 'school'].includes(user.adminLevel)) return sendError(response, 403, '当前账号不能维护管理员');
       const body = await readJson(request);
-      const target = db.users.find(item => item.id === adminMatch[1] && item.role === 'admin' && item.adminLevel === 'class' && item.schoolId === user.schoolId);
+      const target = db.users.find(item => item.id === adminMatch[1] && item.role === 'admin' && (user.adminLevel === 'super' || (item.adminLevel === 'class' && item.schoolId === user.schoolId)));
-      if (!target) return sendError(response, 404, '班级管理员不存在');
+      if (!target) return sendError(response, 404, '管理员账户不存在或不在当前管理范围');
-      const schoolClass = db.classes.find(item => item.id === cleanText(body.classId || target.classId, 64) && item.schoolId === user.schoolId);
+      if (target.id === user.id && body.active === false) return sendError(response, 409, '不能停用当前正在使用的管理员账户');
-      if (!schoolClass) return sendError(response, 400, '请选择本校有效班级');
+      const schoolClass = target.adminLevel === 'class' ? db.classes.find(item => item.id === cleanText(body.classId || target.classId, 64) && item.schoolId === target.schoolId) : null;
+      if (target.adminLevel === 'class' && !schoolClass) return sendError(response, 400, '请选择该管理员所属学校的有效班级');
       const password = String(body.password || '');
       if (password && password.length < 8) return sendError(response, 400, '重置密码至少 8 位');
-      Object.assign(target, { displayName: cleanText(body.displayName || target.displayName, 50), classId: schoolClass.id, active: body.active == null ? target.active : Boolean(body.active) });
+      Object.assign(target, { displayName: cleanText(body.displayName || target.displayName, 50), classId: schoolClass?.id || target.classId || null, active: body.active == null ? target.active : Boolean(body.active) });
       if (password) target.passwordHash = hashPassword(password);
-      await database.updateAdmin(target, Boolean(password), logAction(db, user, '维护班级管理员', `${target.displayName} · ${schoolClass.name}`));
+      await database.updateAdmin(target, Boolean(password), logAction(db, user, '维护管理员账户', `${target.displayName} · ${adminLevelNames[target.adminLevel]} · ${target.active ? '启用' : '停用'}`));
+      if (!target.active || password) for (const [token, session] of sessions) if (session.userId === target.id) sessions.delete(token);
       return sendJson(response, 200, { ok: true, admin: safeUser(target) });
     }
+    const adminPasswordResetMatch = pathname.match(/^\/api\/admin\/admins\/([^/]+)\/reset-password$/);
+    if (adminPasswordResetMatch && request.method === 'POST') {
+      if (!['super', 'school'].includes(user.adminLevel)) return sendError(response, 403, '当前账号不能重置管理员密码');
+      const target = db.users.find(item => item.id === adminPasswordResetMatch[1] && item.role === 'admin' && (user.adminLevel === 'super' || (item.adminLevel === 'class' && item.schoolId === user.schoolId)));
+      if (!target) return sendError(response, 404, '管理员账户不存在或不在当前管理范围');
+      if (target.id === user.id) return sendError(response, 409, '当前账号请在“账户安全”中修改自己的密码');
+      const temporaryPassword = `Reset-${randomBytes(7).toString('base64url')}`;
+      target.passwordHash = hashPassword(temporaryPassword);
+      target.active = true;
+      await database.updateAdmin(target, true, logAction(db, user, '重置管理员密码', `${target.displayName} · ${target.username}`));
+      for (const [token, session] of sessions) if (session.userId === target.id) sessions.delete(token);
+      return sendJson(response, 200, { ok: true, username: target.username, temporaryPassword });
+    }
     if (pathname === '/api/admin/settings/self-registration' && request.method === 'PUT') {
       if (!requirePermission(user, response, '*')) return true;
       const body = await readJson(request);
@@ -294,7 +616,7 @@ export function createAdminRoutes(context) {
         .sort((a, b) => new Date(b.createdAt) - new Date(a.createdAt))
         .map(item => candidateAccountBatchView(db, item));
       const classes = db.classes.filter(item => item.active && (user.adminLevel === 'super' || item.schoolId === user.schoolId));
-      return sendJson(response, 200, { ok: true, batches, classes, schools: db.schools.filter(item => item.active) });
+      return sendJson(response, 200, { ok: true, batches, classes, schools: db.schools.filter(item => item.active && item.isSourceSchool) });
     }
     if (pathname === '/api/admin/candidate-account-batches' && request.method === 'POST') {
       if (user.adminLevel !== 'school' || !requirePermission(user, response, 'candidates.write')) return user.adminLevel === 'school' ? true : sendError(response, 403, '批量报名号由校级管理员发起申领');
@@ -629,6 +951,10 @@ export function createAdminRoutes(context) {
       const candidates = db.candidateProfiles.filter(profile => profileInScope(user, profile)).map(profile => {
         const instance = pendingWorkflow(db, 'profile_change', profile.id) || db.workflowInstances.filter(item => item.businessType === 'profile_change' && item.businessId === profile.id)[0];
         const account = db.users.find(item => item.id === profile.userId);
+        const registrations = db.registrations
+          .filter(item => item.userId === profile.userId)
+          .map(item => examRegistrationView(db, item))
+          .sort((left, right) => new Date(right.createdAt || 0) - new Date(left.createdAt || 0));
         return {
           ...profile,
           idNumberMasked: profile.idNumber.startsWith('PENDING-') ? '待考生补充' : maskId(profile.idNumber),
@@ -638,6 +964,7 @@ export function createAdminRoutes(context) {
           accountArchived: Boolean(account?.archivedAt),
           archivedAt: account?.archivedAt || null,
           archivedByName: db.users.find(item => item.id === account?.archivedBy)?.displayName || '',
+          registrations,
           workflow: workflowView(db, instance)
         };
       });
@@ -1061,7 +1388,7 @@ export function createAdminRoutes(context) {
       const notices = db.notices
         .sort((a, b) => new Date(b.publishAt || b.createdAt) - new Date(a.publishAt || a.createdAt))
         .map(noticeForClient);
-      return sendJson(response, 200, { ok: true, notices });
+      return sendJson(response, 200, { ok: true, notices, publications: systemPublications(db) });
     }
     if (request.method === 'POST' && pathname === '/api/admin/notices') {
       if (!requirePermission(user, response, '*')) return true;
@@ -1073,8 +1400,24 @@ export function createAdminRoutes(context) {
       const notice = { id: uid('notice'), title, summary: cleanText(body.summary, 260) || contentText.slice(0, 80), content, category: cleanText(body.category, 30) || '通知公告', pinned: Boolean(body.pinned), status: body.status === 'draft' ? 'draft' : 'published', publishAt: body.status === 'draft' ? null : nowIso(), createdAt: nowIso(), author: user.displayName };
       const log = logAction(db, user, notice.status === 'published' ? '发布通知' : '保存通知草稿', notice.title);
       await database.createNotice(notice, log);
+      await cache.invalidate('public');
       return sendJson(response, 201, { ok: true, notice: noticeForClient(notice) });
     }
+    const publicationMatch = pathname.match(/^\/api\/admin\/publications\/(plan|qualification|admission|cutoff)\/([^/]+)$/);
+    if (request.method === 'PATCH' && publicationMatch) {
+      if (!requirePermission(user, response, '*')) return true;
+      const kindByType = { plan: 'plan', qualification: 'qualification_publication', admission: 'setting', cutoff: 'cutoff_publication' };
+      const sourceType = publicationMatch[1];
+      const record = admissionRecords(db, kindByType[sourceType]).find(item => item.id === publicationMatch[2]);
+      if (!record) return sendError(response, 404, '系统公示不存在');
+      const body = await readJson(request);
+      if (typeof body.visible !== 'boolean') return sendError(response, 400, '请明确设置是否显示');
+      record.payload = { ...record.payload, publicVisible: body.visible };
+      record.updatedAt = nowIso();
+      await database.saveAdmissionRecord(record, logAction(db, user, body.visible ? '显示系统公示' : '隐藏系统公示', `${sourceType} · ${record.id}`));
+      await cache.invalidate('public');
+      return sendJson(response, 200, { ok: true, publication: systemPublications({ ...db, admissionRecords: db.admissionRecords.map(item => item.id === record.id ? record : item) }).find(item => item.id === record.id && item.sourceType === sourceType) });
+    }
     const noticeMatch = pathname.match(/^\/api\/admin\/notices\/([^/]+)$/);
     if (request.method === 'PATCH' && noticeMatch) {
       if (!requirePermission(user, response, '*')) return true;
@@ -1094,6 +1437,7 @@ export function createAdminRoutes(context) {
       }
       const log = logAction(db, user, '更新通知', `${notice.title} · ${notice.status}`);
       await database.updateNotice(notice, log);
+      await cache.invalidate('public');
       return sendJson(response, 200, { ok: true, notice: noticeForClient(notice) });
     }
     if (request.method === 'POST' && pathname === '/api/admin/results/cache/refresh') {
@@ -1108,53 +1452,67 @@ export function createAdminRoutes(context) {
     }
     if (request.method === 'GET' && pathname === '/api/admin/results') {
       if (!requirePermission(user, response, 'results.read')) return true;
+      const requestedExamId = new URL(request.url, `http://${request.headers.host || '127.0.0.1'}`).searchParams.get('examId');
+      const selectedExam = db.exams.find(item => item.id === requestedExamId);
+      if (!selectedExam) return sendError(response, 404, '请选择有效的考试后再读取成绩');
       const scopedRegistrations = db.registrations.filter(item => registrationInScope(db, user, item));
-      const results = db.results.filter(result => scopedRegistrations.some(item => item.id === result.registrationId)).map(result => {
+      const selectedScopedRegistrations = scopedRegistrations.filter(item => item.examId === selectedExam.id);
-        const registration = db.registrations.find(item => item.id === result.registrationId);
+      if (user.adminLevel !== 'super' && !selectedScopedRegistrations.length) return sendError(response, 404, '该考试不在当前管理范围内');
-        const profile = db.candidateProfiles.find(item => item.userId === registration?.userId);
+      const approved = selectedScopedRegistrations.filter(item => item.status === 'approved');
-        const account = db.users.find(item => item.id === registration?.userId);
+      const selectedRegistrationIds = new Set(selectedScopedRegistrations.map(item => item.id));
-        const exam = db.exams.find(item => item.id === registration?.examId);
+      const examRegistrations = db.registrations.filter(item => item.examId === selectedExam.id && item.status === 'approved');
-        const subject = exam?.subjects.find(item => item.id === result.subjectId);
+      const examRegistrationIds = new Set(examRegistrations.map(item => item.id));
-        const pass = subjectPassEvaluation(db, result, subject);
+      const examResults = db.results.filter(result => examRegistrationIds.has(result.registrationId));
-        const rank = resultRankInfo(db, result);
+      const scoreDb = { ...db, registrations: examRegistrations, results: examResults };
+      const registrationById = new Map(selectedScopedRegistrations.map(item => [item.id, item]));
+      const profileByUserId = new Map(db.candidateProfiles.map(item => [item.userId, item]));
+      const accountById = new Map(db.users.map(item => [item.id, item]));
+      const classById = new Map(db.classes.map(item => [item.id, item]));
+      const rawScopedResults = examResults.filter(result => selectedRegistrationIds.has(result.registrationId));
+      const results = rawScopedResults.map(result => {
+        const registration = registrationById.get(result.registrationId);
+        const profile = profileByUserId.get(registration?.userId);
+        const account = accountById.get(registration?.userId);
+        const subject = selectedExam.subjects.find(item => item.id === result.subjectId);
+        const pass = subjectPassEvaluation(scoreDb, result, subject);
         return {
-          ...result, grade: result.published ? rank.grade : result.grade, rank: rank.rank, cohortSize: rank.cohortSize, rankPercent: rank.rankPercent,
+          ...result, grade: result.published ? pass.grade : result.grade, rank: pass.rank, cohortSize: pass.cohortSize, rankPercent: pass.rankPercent,
           candidateName: profile?.name, candidateNumber: account?.candidateNumber || registration?.registrationNumber || '',
-          schoolName: profile?.school || '', className: db.classes.find(item => item.id === profile?.classId)?.name || profile?.grade || '',
+          schoolName: profile?.school || '', className: classById.get(profile?.classId)?.name || profile?.grade || '',
-          examId: exam?.id, examCode: exam?.code, examName: exam?.name, subjectName: subject?.name,
+          examId: selectedExam.id, examCode: selectedExam.code, examName: selectedExam.name, subjectName: subject?.name,
           fullScore: subject?.fullScore, passRule: subject?.passRule || 'fixed_score', passValue: subject?.passValue ?? subject?.passScore,
           passScore: pass.passScore, cutoffRank: pass.cutoffRank, passText: subjectPassText(subject),
           qualified: pass.qualified
         };
       });
-      const appeals = db.workflowInstances.filter(instance => instance.businessType === 'score_appeal' && results.some(result => result.id === instance.businessId)).map(instance => {
+      const resultById = new Map(results.map(result => [result.id, result]));
-        const result = results.find(item => item.id === instance.businessId);
+      const appeals = db.workflowInstances.filter(instance => instance.businessType === 'score_appeal' && resultById.has(instance.businessId)).map(instance => {
+        const result = resultById.get(instance.businessId);
         const workflow = workflowView(db, instance);
         return { ...workflow, result, reason: workflow.actions.find(action => action.action === 'submit')?.note || '' };
       });
-      const approved = scopedRegistrations.filter(item => item.status === 'approved');
       const exams = db.exams.map(exam => {
-        const examRegistrations = approved.filter(item => item.examId === exam.id);
+        if (exam.id !== selectedExam.id) return publicExam(exam);
-        const examResults = results.filter(item => item.examId === exam.id);
+        const summaries = approved.map(item => examResultSummary(scoreDb, item)).filter(Boolean);
-        const summaries = examRegistrations.map(item => examResultSummary(db, item)).filter(Boolean);
+        const enrolledSubjects = approved.reduce((sum, item) => sum + item.subjectIds.length, 0);
-        const enrolledSubjects = examRegistrations.reduce((sum, item) => sum + item.subjectIds.length, 0);
+        const scored = rawScopedResults.length;
-        const scored = examResults.length;
         return {
-          ...publicExam(exam), registrationCount: examRegistrations.length, enrolledSubjects, scored,
+          ...publicExam(exam), registrationCount: approved.length, enrolledSubjects, scored,
-          published: examResults.filter(item => item.published).length, missing: Math.max(0, enrolledSubjects - scored),
+          published: rawScopedResults.filter(item => item.published).length, missing: Math.max(0, enrolledSubjects - scored),
           complete: summaries.filter(item => item.complete).length,
           qualified: summaries.filter(item => item.complete && item.qualified === true).length,
           unqualified: summaries.filter(item => item.complete && item.qualified === false).length,
-          appeals: appeals.filter(item => item.result?.examId === exam.id).length
+          appeals: appeals.length
         };
-      }).filter(exam => exam.registrationCount || results.some(item => item.examId === exam.id) || user.adminLevel === 'super');
+      });
       const registrations = user.adminLevel === 'super' ? approved.map(item => {
         const view = examRegistrationView(db, item);
-        const profile = db.candidateProfiles.find(profileItem => profileItem.userId === item.userId);
+        const profile = profileByUserId.get(item.userId);
-        const account = db.users.find(accountItem => accountItem.id === item.userId);
+        const account = accountById.get(item.userId);
-        return { ...view, candidateName: profile?.name || account?.displayName || '', candidateNumber: account?.candidateNumber || item.registrationNumber || '', schoolName: profile?.school || '', className: db.classes.find(classItem => classItem.id === profile?.classId)?.name || profile?.grade || '' };
+        const specialty = resolveProfileSpecialty(profile || {});
+        return { ...view, candidateName: profile?.name || account?.displayName || '', candidateNumber: account?.candidateNumber || item.registrationNumber || '', schoolName: profile?.school || '', className: classById.get(profile?.classId)?.name || profile?.grade || '', specialtyCategory: specialty.category, specialtyType: specialty.type, specialtyLabel: specialtyLabel(specialty.category, specialty.type) || '普通生' };
       }) : [];
-      return sendJson(response, 200, { ok: true, results, appeals, registrations, exams, resultCache: { enabled: cache.enabled, status: cache.status } });
+      return sendJson(response, 200, { ok: true, selectedExamId: selectedExam.id, results, appeals, registrations, exams, resultCache: { enabled: cache.enabled, status: cache.status } });
     }
     if (request.method === 'POST' && pathname === '/api/admin/results/import') {
       if (!requirePermission(user, response, '*')) return true;
@@ -1162,6 +1520,68 @@ export function createAdminRoutes(context) {
       const result = await commitResultImport(db, user, body.rows);
       return sendJson(response, 200, { ok: true, ...result });
     }
+    if (request.method === 'POST' && pathname === '/api/admin/results/bulk') {
+      if (!requirePermission(user, response, '*')) return true;
+      const body = await readJson(request);
+      const exam = db.exams.find(item => item.id === cleanText(body.examId, 64) && !item.archivedAt);
+      const subject = exam?.subjects.find(item => item.id === cleanText(body.subjectId, 64));
+      if (!exam || !subject) return sendError(response, 400, '请选择有效且未归档的考试科目');
+      const sourceRows = [];
+      const seen = new Set();
+      for (const [index, row] of (Array.isArray(body.rows) ? body.rows : []).entries()) {
+        const registration = db.registrations.find(item => item.id === row.registrationId && item.examId === exam.id && item.status === 'approved' && item.subjectIds.includes(subject.id));
+        if (!registration || seen.has(registration.id)) return sendError(response, 400, `第 ${index + 1} 条考生成绩无效或重复`);
+        seen.add(registration.id);
+        const account = db.users.find(item => item.id === registration.userId);
+        sourceRows.push({
+          __row: index + 3,
+          candidateNumber: account?.candidateNumber || registration.registrationNumber || '',
+          examCode: exam.code,
+          subjectName: subject.name,
+          score: row.score,
+          published: body.published === true
+        });
+      }
+      if (!sourceRows.length) return sendError(response, 400, '没有需要保存的成绩');
+      const result = await commitResultImport(db, user, sourceRows);
+      return sendJson(response, 200, { ok: true, published: body.published === true, ...result });
+    }
+    if (request.method === 'POST' && pathname === '/api/admin/feature-scores/bulk') {
+      if (!requirePermission(user, response, '*')) return true;
+      const body = await readJson(request);
+      const exam = db.exams.find(item => item.id === cleanText(body.examId, 64) && !item.archivedAt);
+      if (!exam) return sendError(response, 400, '请选择有效且未归档的考试');
+      const entries = [];
+      const seen = new Set();
+      for (const [index, row] of (Array.isArray(body.rows) ? body.rows : []).entries()) {
+        const registration = db.registrations.find(item => item.id === row.registrationId && item.examId === exam.id && item.status === 'approved');
+        const featureScore = Number(row.featureScore);
+        if (!registration || seen.has(registration.id)) return sendError(response, 400, `第 ${index + 1} 条考生记录无效或重复`);
+        if (!Number.isFinite(featureScore) || featureScore < 0 || featureScore > 1000) return sendError(response, 400, `第 ${index + 1} 条特征分必须在 0—1000 之间`);
+        seen.add(registration.id);
+        registration.featureScore = Number(featureScore.toFixed(2));
+        const profile = db.candidateProfiles.find(item => item.userId === registration.userId);
+        entries.push({ registration, log: logAction(db, user, '批量登记特征分', `${profile?.name || registration.userId} · ${exam.name} · ${registration.featureScore}`) });
+      }
+      if (!entries.length) return sendError(response, 400, '没有需要保存的特征分');
+      await database.updateFeatureScores(entries);
+      return sendJson(response, 200, { ok: true, count: entries.length });
+    }
+    const featureScoreMatch = pathname.match(/^\/api\/admin\/registrations\/([^/]+)\/feature-score$/);
+    if (request.method === 'PATCH' && featureScoreMatch) {
+      if (!requirePermission(user, response, '*')) return true;
+      const registration = db.registrations.find(item => item.id === featureScoreMatch[1] && item.status === 'approved');
+      if (!registration) return sendError(response, 404, '已通过的报名记录不存在');
+      const exam = db.exams.find(item => item.id === registration.examId);
+      if (exam?.archivedAt) return sendError(response, 409, '该考试已归档，特征分已永久锁定');
+      const body = await readJson(request);
+      const featureScore = Number(body.featureScore);
+      if (!Number.isFinite(featureScore) || featureScore < 0 || featureScore > 1000) return sendError(response, 400, '特征分必须在 0—1000 之间');
+      registration.featureScore = Number(featureScore.toFixed(2));
+      const profile = db.candidateProfiles.find(item => item.userId === registration.userId);
+      await database.updateFeatureScore(registration, logAction(db, user, '登记特征分', `${profile?.name || registration.userId} · ${exam?.name || registration.examId} · ${registration.featureScore}`));
+      return sendJson(response, 200, { ok: true, registration });
+    }
     if (request.method === 'POST' && pathname === '/api/admin/results') {
       if (!requirePermission(user, response, '*')) return true;
       const body = await readJson(request);

src/routes/admission.routes.mjs

@@ -0,0 +1,147 @@
+import { admissionRecords, approvedPlans, remainingPlanQuota } from '../services/volunteer-admission.mjs';
+import { isValidSpecialty, resolveProfileSpecialty, specialtyLabel } from '../data/specialty-types.mjs';
+
+function normalizeCategories(input, cleanText) {
+  const source = Array.isArray(input) ? input : [];
+  return source.map((item, index) => ({
+    code: cleanText(item.code || `category_${index + 1}`, 40),
+    name: cleanText(item.name, 80),
+    quota: Math.max(0, Math.trunc(Number(item.quota || 0))),
+    specialtyCategory: cleanText(item.specialtyCategory, 30),
+    specialtyType: cleanText(item.specialtyType, 80),
+    indicatorAllocations: (Array.isArray(item.indicatorAllocations) ? item.indicatorAllocations : []).map(allocation => ({
+      sourceSchoolId: cleanText(allocation.sourceSchoolId, 64), quota: Math.max(0, Math.trunc(Number(allocation.quota || 0)))
+    })).filter(item => item.sourceSchoolId && item.quota > 0)
+  })).filter(item => item.code && item.name && item.quota > 0);
+}
+
+export function createAdmissionRoutes(context) {
+  const { database, readDb, sendJson, sendError, readJson, sendWorkbook, buildWorkbook, requireUser, cleanText, maskId, uid, nowIso, logAction } = context;
+
+  async function handleAdmission(request, response, pathname) {
+    if (!pathname.startsWith('/api/admission/')) return false;
+    const user = await requireUser(request, response, 'admission_school');
+    if (!user) return true;
+    const db = request.authDb || await readDb();
+    const school = db.schools.find(item => item.id === user.schoolId && item.active && item.isAdmissionSchool);
+    if (!school) return sendError(response, 403, '招生学校账号未绑定有效学校');
+
+    if (request.method === 'GET' && pathname === '/api/admission/context') {
+      return sendJson(response, 200, { ok: true, school, exams: db.exams.filter(item => !item.archivedAt && admissionRecords(db, 'setting', item.id).some(setting => setting.payload?.enabled)) });
+    }
+    if (request.method === 'GET' && pathname === '/api/admission/plans') {
+      const plans = admissionRecords(db, 'plan').filter(item => item.schoolId === school.id).map(plan => ({ ...plan, remainingCategories: remainingPlanQuota(db, plan) }));
+      return sendJson(response, 200, { ok: true, school, plans, exams: db.exams.filter(item => !item.archivedAt), sourceSchools: db.schools.filter(item => item.active && item.isSourceSchool) });
+    }
+    if (request.method === 'POST' && pathname === '/api/admission/plans') {
+      const body = await readJson(request);
+      const exam = db.exams.find(item => item.id === cleanText(body.examId, 64) && !item.archivedAt);
+      if (!exam) return sendError(response, 404, '考试不存在或已经归档');
+      const categories = normalizeCategories(body.categories, cleanText);
+      if (!categories.length) return sendError(response, 400, '请至少填写一个有效招生类别和计划人数');
+      if (new Set(categories.map(item => item.code)).size !== categories.length) return sendError(response, 400, '招生类别代码不能重复');
+      if (categories.some(item => !isValidSpecialty(item.specialtyCategory, item.specialtyType))) return sendError(response, 400, '特长生招生类别的大类与小类不对应');
+      if (categories.some(item => new Set(item.indicatorAllocations.map(allocation => allocation.sourceSchoolId)).size !== item.indicatorAllocations.length)) return sendError(response, 400, '同一招生类别不能重复分配同一生源校指标');
+      if (categories.some(item => item.indicatorAllocations.reduce((sum, entry) => sum + entry.quota, 0) > item.quota)) return sendError(response, 400, '指标分配合计不能超过该类别计划人数');
+      if (categories.some(item => item.indicatorAllocations.some(allocation => !db.schools.some(entry => entry.id === allocation.sourceSchoolId && entry.active && entry.isSourceSchool)))) return sendError(response, 400, '指标分配中包含无效的生源学校');
+      const existing = admissionRecords(db, 'plan', exam.id).find(item => item.schoolId === school.id);
+      if (existing?.status === 'approved') return sendError(response, 409, '已审核通过的招生计划只能由超级管理员调整');
+      const now = nowIso();
+      const plan = existing || { id: uid('plan'), kind: 'plan', examId: exam.id, userId: user.id, schoolId: school.id, createdAt: now };
+      Object.assign(plan, { status: 'pending', updatedAt: now, payload: { categories, note: cleanText(body.note, 500), submittedBy: user.displayName, reviewNote: '' } });
+      await database.saveAdmissionRecord(plan, logAction(db, user, '提交招生计划', `${school.name} · ${exam.name}`));
+      return sendJson(response, existing ? 200 : 201, { ok: true, plan });
+    }
+    if (request.method === 'GET' && pathname === '/api/admission/placements') {
+      const accountById = new Map(db.users.map(item => [item.id, item]));
+      const profileByUserId = new Map(db.candidateProfiles.map(item => [item.userId, item]));
+      const examById = new Map(db.exams.map(item => [item.id, item]));
+      const registrationByExamUser = new Map(db.registrations.map(item => [`${item.examId}\u0000${item.userId}`, item]));
+      const publishedResultsByRegistration = new Map();
+      for (const result of db.results) {
+        if (!result.published) continue;
+        const rows = publishedResultsByRegistration.get(result.registrationId) || [];
+        rows.push(result);
+        publishedResultsByRegistration.set(result.registrationId, rows);
+      }
+      const placements = admissionRecords(db, 'placement').filter(item => item.schoolId === school.id).map(item => {
+        const account = accountById.get(item.userId) || {};
+        const profile = profileByUserId.get(item.userId) || {};
+        const exam = examById.get(item.examId);
+        const registration = registrationByExamUser.get(`${item.examId}\u0000${item.userId}`);
+        const results = (publishedResultsByRegistration.get(registration?.id) || []).map(result => ({ subjectName: exam?.subjects.find(subject => subject.id === result.subjectId)?.name || result.subjectId, score: result.score }));
+        const qualification = resolveProfileSpecialty(profile);
+        return { ...item, examName: exam?.name || item.examId, candidate: { registrationNumber: account.candidateNumber, name: profile.name, gender: profile.gender, idNumberMasked: maskId(profile.idNumber), specialtyCategory: qualification.category, specialtyType: qualification.type, specialtyLabel: specialtyLabel(qualification.category, qualification.type), specialtyCertificate: profile.specialtyCertificate || '', policyEligibility: profile.policyEligibility || '' }, featureScore: Number(registration?.featureScore || 0), results };
+      });
+      const completedExams = db.exams.filter(exam => admissionRecords(db, 'setting', exam.id).some(setting => setting.status === 'completed') && placements.some(item => item.examId === exam.id && item.status === 'final'));
+      return sendJson(response, 200, { ok: true, school, placements, completedExams });
+    }
+    if (request.method === 'GET' && pathname === '/api/admission/placements/export') {
+      const examId = cleanText(new URL(request.url, 'http://localhost').searchParams.get('examId'), 64);
+      const exam = db.exams.find(item => item.id === examId);
+      const setting = admissionRecords(db, 'setting', examId)[0];
+      if (!exam || setting?.status !== 'completed') return sendError(response, 409, '录取工作结束后才能下载正式录取名单');
+      const rows = admissionRecords(db, 'placement', examId).filter(item => item.schoolId === school.id && item.status === 'final').map(item => {
+        const account = db.users.find(entry => entry.id === item.userId) || {};
+        const profile = db.candidateProfiles.find(entry => entry.userId === item.userId) || {};
+        const registration = db.registrations.find(entry => entry.examId === examId && entry.userId === item.userId) || {};
+        const sourceSchool = db.schools.find(entry => entry.id === profile.schoolId) || {};
+        const schoolClass = db.classes.find(entry => entry.id === profile.classId) || {};
+        const qualification = resolveProfileSpecialty(profile);
+        const scoreRows = db.results.filter(entry => entry.registrationId === registration.id && entry.published).map(result => ({ name: exam.subjects.find(subject => subject.id === result.subjectId)?.name || result.subjectId, score: result.score }));
+        return {
+          candidateNumber: account.candidateNumber || registration.registrationNumber || '', name: profile.name || account.displayName || '', gender: profile.gender || '',
+          idNumber: profile.idNumber || '', phone: profile.phone || '', email: profile.email || '', birthDate: profile.birthDate || '', ethnicity: profile.ethnicity || '', nativePlace: profile.nativePlace || '',
+          sourceSchool: sourceSchool.name || profile.school || '', sourceSchoolCode: sourceSchool.code || '', className: schoolClass.name || profile.grade || '',
+          address: [profile.provinceName, profile.cityName, profile.districtName, profile.address].filter(Boolean).join(' '), guardianName: profile.guardianName || profile.emergencyContact || '', guardianPhone: profile.guardianPhone || profile.emergencyPhone || '',
+          specialty: specialtyLabel(qualification.category, qualification.type) || '普通生', specialtyCertificate: profile.specialtyCertificate || '', policyEligibility: profile.policyEligibility || '',
+          featureScore: Number(registration.featureScore || 0), subjectScores: scoreRows.map(score => `${score.name} ${score.score}`).join('；'), totalScore: Number(item.payload?.totalScore || 0),
+          admittedSchool: school.name, categoryName: item.payload?.categoryName || '', preferenceOrder: Number(item.payload?.preferenceOrder || 0)
+        };
+      });
+      const buffer = Buffer.from(await buildWorkbook('admitted_candidates', rows, { subtitle: `${exam.name}｜${school.name}` }));
+      return sendWorkbook(response, buffer, `${exam.name}-${school.name}-录取考生信息.xlsx`);
+    }
+    if (request.method === 'POST' && pathname === '/api/admission/placements/bulk') {
+      const body = await readJson(request);
+      const ids = [...new Set((Array.isArray(body.ids) ? body.ids : []).map(id => cleanText(id, 64)).filter(Boolean))];
+      const decision = cleanText(body.decision, 30);
+      const note = cleanText(body.note, 500);
+      if (!ids.length) return sendError(response, 400, '请至少选择一名待审核考生');
+      if (!['accept', 'withdraw'].includes(decision)) return sendError(response, 400, '请选择接收或申请退档');
+      if (decision === 'withdraw' && note.length < 8) return sendError(response, 400, '批量申请退档必须填写至少 8 个字的特殊理由');
+      const placements = admissionRecords(db, 'placement').filter(item => ids.includes(item.id) && item.schoolId === school.id && item.status === 'school_review');
+      if (placements.length !== ids.length) return sendError(response, 409, '所选记录中包含已处理或不属于本校的投档记录，请刷新后重试');
+      const now = nowIso();
+      for (const placement of placements) {
+        placement.status = decision === 'accept' ? 'admitted' : 'withdrawal_pending';
+        placement.payload.schoolDecisionNote = note;
+        if (decision === 'withdraw') placement.payload.withdrawalReason = note;
+        placement.updatedAt = now;
+      }
+      await database.saveAdmissionRecords(placements, logAction(db, user, decision === 'accept' ? '批量接收投档考生' : '批量申请退档', `${school.name} · ${placements.length} 人`));
+      return sendJson(response, 200, { ok: true, count: placements.length, decision });
+    }
+    const placementMatch = pathname.match(/^\/api\/admission\/placements\/([^/]+)$/);
+    if (request.method === 'PATCH' && placementMatch) {
+      const placement = admissionRecords(db, 'placement').find(item => item.id === placementMatch[1] && item.schoolId === school.id);
+      if (!placement || placement.status !== 'school_review') return sendError(response, 404, '待审核投档记录不存在');
+      const body = await readJson(request);
+      const decision = cleanText(body.decision, 30);
+      const note = cleanText(body.note, 500);
+      if (decision === 'accept') placement.status = 'admitted';
+      else if (decision === 'withdraw') {
+        if (note.length < 8) return sendError(response, 400, '申请退档必须填写至少 8 个字的特殊理由');
+        placement.status = 'withdrawal_pending';
+        placement.payload.withdrawalReason = note;
+      } else return sendError(response, 400, '请选择接收或申请退档');
+      placement.payload.schoolDecisionNote = note;
+      placement.updatedAt = nowIso();
+      await database.saveAdmissionRecord(placement, logAction(db, user, decision === 'accept' ? '接收投档考生' : '申请退档', `${school.name} · ${placement.id}`));
+      return sendJson(response, 200, { ok: true, placement });
+    }
+    return sendError(response, 404, '招生学校功能接口不存在');
+  }
+
+  return handleAdmission;
+}

src/routes/auth.routes.mjs

@@ -115,7 +115,7 @@ export function createAuthRoutes(context) {
       if (!db.settings.selfRegistrationEnabled) return sendError(response, 403, '当前未开放自主注册，请使用学校下发的报名号和初始密码登录');
       const schoolId = cleanText(body.schoolId, 64);
       const classId = cleanText(body.classId, 64);
-      const school = db.schools.find(item => item.id === schoolId && item.active);
+      const school = db.schools.find(item => item.id === schoolId && item.active && item.isSourceSchool);
       const schoolClass = db.classes.find(item => item.id === classId && item.schoolId === schoolId && item.active);
       if (!school || !schoolClass) return sendError(response, 400, '请选择有效的学校和班级');
       const draftProfile = { schoolId, classId, gender };

src/routes/candidate.routes.mjs

@@ -1,4 +1,6 @@
 import { noticeForClient } from '../security/notice-content.mjs';
+import { admissionRecords, admissionSetting, activePreference, approvedPlans, candidateTotalScore, indicatorQualification, remainingPlanQuota } from '../services/volunteer-admission.mjs';
+import { candidateEligibleForCategory, isValidSpecialty, resolveProfileSpecialty } from '../data/specialty-types.mjs';
 
 export function createCandidateRoutes(context) {
   const {
@@ -77,16 +79,20 @@ export function createCandidateRoutes(context) {
     if (request.method === 'GET' && pathname === '/api/candidate/profile') {
       const instance = pendingWorkflow(db, 'profile_change', profile.id)
         || db.workflowInstances.filter(item => item.businessType === 'profile_change' && item.businessId === profile.id)[0];
-      return sendJson(response, 200, { ok: true, profile, workflow: workflowView(db, instance), schools: db.schools.filter(item => item.active), classes: db.classes.filter(item => item.active) });
+      return sendJson(response, 200, { ok: true, profile, workflow: workflowView(db, instance), schools: db.schools.filter(item => item.active && item.isSourceSchool), classes: db.classes.filter(item => item.active) });
     }
     if (request.method === 'PUT' && pathname === '/api/candidate/profile') {
       const body = await readJson(request);
-      const fields = ['name', 'gender', 'idNumber', 'phone', 'email', 'address', 'emergencyContact', 'emergencyPhone', 'nativePlace', 'birthDate', 'ethnicity', 'postalCode', 'guardianName', 'guardianPhone'];
+      const fields = ['name', 'gender', 'idNumber', 'phone', 'email', 'address', 'emergencyContact', 'emergencyPhone', 'nativePlace', 'birthDate', 'ethnicity', 'postalCode', 'guardianName', 'guardianPhone', 'specialtyCertificate', 'policyEligibility'];
       for (const field of fields) profile[field] = cleanText(body[field], field === 'address' ? 160 : 80);
+      profile.specialtyCategory = cleanText(body.specialtyCategory, 30);
+      profile.specialtyType = cleanText(body.specialtyType, 40);
+      if (!isValidSpecialty(profile.specialtyCategory, profile.specialtyType)) return sendError(response, 400, '请选择对应的特长生大类和小类');
+      profile.specialtyTypes = profile.specialtyType ? [profile.specialtyType] : [];
       const region = resolveRegion(body);
       if (!region) return sendError(response, 400, '请选择有效的省、市和区县');
       Object.assign(profile, region);
-      const school = db.schools.find(item => item.id === cleanText(body.schoolId, 64) && item.active);
+      const school = db.schools.find(item => item.id === cleanText(body.schoolId, 64) && item.active && item.isSourceSchool);
       const schoolClass = db.classes.find(item => item.id === cleanText(body.classId, 64) && item.schoolId === school?.id && item.active);
       if (!school || !schoolClass) return sendError(response, 400, '请选择有效的学校和班级');
       profile.schoolId = school.id;
@@ -151,6 +157,81 @@ export function createCandidateRoutes(context) {
       }, { ttlSeconds: resultsCacheTtlSeconds });
       return sendJson(response, 200, payload);
     }
+    if (request.method === 'GET' && pathname === '/api/candidate/admissions') {
+      const settings = admissionRecords(db, 'setting').filter(item => item.payload?.enabled).map(setting => {
+        const exam = db.exams.find(item => item.id === setting.examId);
+        const round = Number(setting.payload?.round || 1);
+        const preference = activePreference(db, setting.examId, user.id, round);
+        const qualification = indicatorQualification(db, setting.examId, user.id);
+        const placement = admissionRecords(db, 'placement', setting.examId).find(item => item.userId === user.id && item.status !== 'withdrawn');
+        const plans = approvedPlans(db, setting.examId).map(plan => {
+          const school = db.schools.find(item => item.id === plan.schoolId);
+          const placements = admissionRecords(db, 'placement', setting.examId).filter(item => item.schoolId === plan.schoolId && item.status !== 'withdrawn');
+          return {
+            id: plan.id, schoolId: plan.schoolId, schoolCode: school?.code || '', schoolName: school?.name || '',
+            categories: remainingPlanQuota(db, plan).filter(category => candidateEligibleForCategory(profile, category)).map(category => {
+              const indicatorAllocation = (category.indicatorAllocations || []).find(item => item.sourceSchoolId === profile.schoolId);
+              const indicatorUsed = placements.filter(item => item.payload?.categoryCode === category.code && item.payload?.quotaBucket === `indicator:${profile.schoolId}`).length;
+              const generalQuota = Math.max(0, Number(category.quota || 0) - (category.indicatorAllocations || []).reduce((sum, item) => sum + Number(item.quota || 0), 0));
+              const generalUsed = placements.filter(item => item.payload?.categoryCode === category.code && item.payload?.quotaBucket === 'general').length;
+              const indicatorRemaining = Math.max(0, Number(indicatorAllocation?.quota || 0) - indicatorUsed);
+              const generalRemaining = Math.max(0, generalQuota - generalUsed);
+              const preferenceTypes = [generalRemaining > 0 ? 'general' : '', qualification?.payload?.eligible && indicatorRemaining > 0 ? 'indicator' : ''].filter(Boolean);
+              return { ...category, generalRemaining, indicatorRemaining, preferenceTypes };
+            }).filter(category => category.preferenceTypes.length)
+          };
+        }).filter(plan => plan.categories.length);
+        const registration = db.registrations.find(item => item.examId === setting.examId && item.userId === user.id);
+        const submissionCount = Number(preference?.payload?.submissionCount || 0);
+        const maxSubmissions = Math.max(1, Number(setting.payload?.maxSubmissions || 3));
+        return { ...setting, exam: exam ? publicExam(exam) : null, preference, placement, plans, totalScore: candidateTotalScore(db, setting.examId, user.id), featureScore: Number(registration?.featureScore || 0), specialtyQualification: resolveProfileSpecialty(profile), indicatorQualification: qualification, submissionCount, maxSubmissions, remainingSubmissions: Math.max(0, maxSubmissions - submissionCount), preferenceLocked: submissionCount >= maxSubmissions };
+      }).filter(item => item.exam);
+      const notifications = admissionRecords(db, 'notification').filter(item => item.userId === user.id);
+      return sendJson(response, 200, { ok: true, admissions: settings, notifications });
+    }
+    const preferenceMatch = pathname.match(/^\/api\/candidate\/admissions\/([^/]+)\/preferences$/);
+    if (request.method === 'PUT' && preferenceMatch) {
+      const setting = admissionSetting(db, preferenceMatch[1]);
+      if (!setting?.payload?.enabled) return sendError(response, 404, '该考试未开放志愿填报');
+      if (!['filling', 'supplementary'].includes(setting.status)) return sendError(response, 409, '当前不在志愿填报阶段');
+      const now = Date.now();
+      if (setting.payload.preferenceStart && now < new Date(setting.payload.preferenceStart).getTime()) return sendError(response, 409, '志愿填报尚未开始');
+      if (setting.payload.preferenceEnd && now > new Date(setting.payload.preferenceEnd).getTime()) return sendError(response, 409, '志愿填报已经截止');
+      if (candidateTotalScore(db, setting.examId, user.id) == null) return sendError(response, 403, '本场考试成绩全部发布后才能填报志愿');
+      const body = await readJson(request);
+      const maxChoices = Math.max(1, Number(setting.payload.maxChoices || 5));
+      const round = Number(setting.payload.round || 1);
+      const currentPreference = activePreference(db, setting.examId, user.id, round);
+      const maxSubmissions = Math.max(1, Number(setting.payload.maxSubmissions || 3));
+      const submissionCount = Number(currentPreference?.payload?.submissionCount || 0);
+      if (submissionCount >= maxSubmissions) return sendError(response, 409, `志愿已达到 ${maxSubmissions} 次提交上限，现已自动锁定`);
+      const choices = (Array.isArray(body.choices) ? body.choices : []).slice(0, maxChoices + 1).map(item => ({ schoolId: cleanText(item.schoolId, 64), categoryCode: cleanText(item.categoryCode, 40), preferenceType: item.preferenceType === 'indicator' ? 'indicator' : 'general' }));
+      if (!choices.length) return sendError(response, 400, '请至少选择一个志愿');
+      const indicatorChoices = choices.filter(item => item.preferenceType === 'indicator');
+      const generalChoices = choices.filter(item => item.preferenceType === 'general');
+      if (indicatorChoices.length > 1 || generalChoices.length > maxChoices) return sendError(response, 400, `本轮最多填报 1 个指标分配志愿和 ${maxChoices} 个普通志愿`);
+      if (indicatorChoices.length && choices[0].preferenceType !== 'indicator') return sendError(response, 400, '指标分配志愿必须位于专用第一栏');
+      if (new Set(choices.map(item => `${item.preferenceType}|${item.schoolId}|${item.categoryCode}`)).size !== choices.length) return sendError(response, 400, '同类志愿中同一学校和招生类别不能重复填报');
+      const plans = approvedPlans(db, setting.examId);
+      const indicator = indicatorQualification(db, setting.examId, user.id);
+      const invalidChoice = choices.some(choice => !plans.some(plan => plan.schoolId === choice.schoolId && plan.payload?.categories?.some(category => {
+        if (category.code !== choice.categoryCode || !candidateEligibleForCategory(profile, category)) return false;
+        const placements = admissionRecords(db, 'placement', setting.examId).filter(item => item.schoolId === plan.schoolId && item.payload?.categoryCode === category.code && item.status !== 'withdrawn');
+        if (choice.preferenceType === 'indicator') {
+          const allocation = (category.indicatorAllocations || []).find(item => item.sourceSchoolId === profile.schoolId);
+          const used = placements.filter(item => item.payload?.quotaBucket === `indicator:${profile.schoolId}`).length;
+          return indicator?.payload?.eligible === true && Number(allocation?.quota || 0) > used;
+        }
+        const quota = Number(category.quota || 0) - (category.indicatorAllocations || []).reduce((sum, item) => sum + Number(item.quota || 0), 0);
+        return quota > placements.filter(item => item.payload?.quotaBucket === 'general').length;
+      })));
+      if (invalidChoice) return sendError(response, 400, '志愿中包含未审核通过、无剩余对应计划或与本人资格不符的招生类别');
+      const nowValue = nowIso();
+      const preference = currentPreference || { id: uid('preference'), kind: 'preference', examId: setting.examId, userId: user.id, schoolId: null, createdAt: nowValue };
+      Object.assign(preference, { status: 'submitted', updatedAt: nowValue, payload: { round, choices, submittedAt: nowValue, submissionCount: submissionCount + 1 } });
+      await database.saveAdmissionRecord(preference);
+      return sendJson(response, 200, { ok: true, preference, remainingSubmissions: Math.max(0, maxSubmissions - submissionCount - 1), locked: submissionCount + 1 >= maxSubmissions, message: submissionCount + 1 >= maxSubmissions ? '志愿已保存并达到提交上限，现已自动锁定' : '志愿已由本人保存' });
+    }
     const scoreAppealMatch = pathname.match(/^\/api\/candidate\/results\/([^/]+)\/appeals$/);
     if (request.method === 'POST' && scoreAppealMatch) {
       const result = db.results.find(item => item.id === scoreAppealMatch[1] && item.published);

src/routes/public.routes.mjs

@@ -1,4 +1,6 @@
 import { noticeForClient } from '../security/notice-content.mjs';
+import { admissionRecords, admissionSetting, publicAdmissionRows, sourceSchoolQualificationStatus } from '../services/volunteer-admission.mjs';
+import { specialtyLabel } from '../data/specialty-types.mjs';
 
 export function createPublicRoutes(context) {
   const {
@@ -57,7 +59,41 @@ export function createPublicRoutes(context) {
         const db = await readDb();
         const publishedNotices = db.notices.filter(item => item.status === 'published').sort((a, b) => Number(b.pinned) - Number(a.pinned) || new Date(b.publishAt) - new Date(a.publishAt)).map(noticeForClient);
         const exams = db.exams.filter(item => item.status === 'published' && !item.archivedAt).map(exam => ({ ...publicExam(exam), registrationCount: db.registrations.filter(reg => reg.examId === exam.id).length }));
-        return { ok: true, organization: publicSiteConfig.organization, siteCopy: { heroEyebrow: publicSiteConfig.heroEyebrow, heroTitle: publicSiteConfig.heroTitle, heroHighlight: publicSiteConfig.heroHighlight, heroDescription: publicSiteConfig.heroDescription, footerNotice: publicSiteConfig.footerNotice }, schools: db.schools.filter(item => item.active), classes: db.classes.filter(item => item.active), selfRegistrationEnabled: db.settings.selfRegistrationEnabled, notices: publishedNotices, exams, stats: { candidates: db.candidateProfiles.length, exams: exams.length, registrations: db.registrations.length } };
+        return { ok: true, organization: publicSiteConfig.organization, siteCopy: { heroEyebrow: publicSiteConfig.heroEyebrow, heroTitle: publicSiteConfig.heroTitle, heroHighlight: publicSiteConfig.heroHighlight, heroDescription: publicSiteConfig.heroDescription, footerNotice: publicSiteConfig.footerNotice }, schools: db.schools.filter(item => item.active && item.isSourceSchool), classes: db.classes.filter(item => item.active), selfRegistrationEnabled: db.settings.selfRegistrationEnabled, notices: publishedNotices, exams, stats: { candidates: db.candidateProfiles.length, exams: exams.length, registrations: db.registrations.length } };
+      });
+      return sendJson(response, 200, payload);
+    }
+    if (pathname === '/api/public/announcements') {
+      const payload = await cache.remember('public', 'admission-announcements', async () => {
+        const db = await readDb();
+        const plans = admissionRecords(db, 'plan').filter(item => item.status === 'approved' && item.payload?.publicVisible !== false).map(item => ({
+          id: item.id,
+          examId: item.examId,
+          examName: db.exams.find(exam => exam.id === item.examId)?.name || '',
+          schoolName: db.schools.find(school => school.id === item.schoolId)?.name || '',
+          publishedAt: item.payload?.reviewedAt || item.updatedAt,
+          note: item.payload?.note || '',
+          rows: (item.payload?.categories || []).map(category => ({
+            code: category.code,
+            name: category.name,
+            quota: Number(category.quota || 0),
+            specialtyCategory: category.specialtyCategory || '',
+            specialtyType: category.specialtyType || '',
+            specialtyLabel: specialtyLabel(category.specialtyCategory, category.specialtyType) || '普通 / 政策类',
+            indicatorQuota: (category.indicatorAllocations || []).reduce((sum, allocation) => sum + Number(allocation.quota || 0), 0),
+            indicatorAllocations: (category.indicatorAllocations || []).map(allocation => ({
+              sourceSchoolName: db.schools.find(school => school.id === allocation.sourceSchoolId)?.name || allocation.sourceSchoolId,
+              quota: Number(allocation.quota || 0)
+            }))
+          }))
+        })).sort((a, b) => new Date(b.publishedAt) - new Date(a.publishedAt));
+        const qualifications = admissionRecords(db, 'qualification_publication').filter(item => item.status === 'published' && item.payload?.publicVisible !== false && sourceSchoolQualificationStatus(db, item.examId, item.schoolId).complete).map(item => ({
+          id: item.id, examId: item.examId, examName: db.exams.find(exam => exam.id === item.examId)?.name || '', schoolName: db.schools.find(school => school.id === item.schoolId)?.name || '', publishedAt: item.payload?.publishedAt || item.updatedAt,
+          rows: (item.payload?.rows || []).map(row => ({ registrationNumber: row.registrationNumber, name: row.name, eligible: row.eligible === true, specialtyLabel: row.specialtyLabel || '普通生' }))
+        })).sort((a, b) => new Date(b.publishedAt) - new Date(a.publishedAt));
+        const admissions = admissionRecords(db, 'setting').filter(item => item.status === 'completed' && item.payload?.autoPublish !== false && item.payload?.publicVisible !== false).map(setting => ({ id: setting.id, examId: setting.examId, examName: db.exams.find(item => item.id === setting.examId)?.name || '', publishedAt: setting.payload?.completedAt || setting.updatedAt, rows: publicAdmissionRows(db, setting.examId) })).sort((a, b) => new Date(b.publishedAt) - new Date(a.publishedAt));
+        const cutoffs = admissionRecords(db, 'cutoff_publication').filter(item => item.status === 'published' && item.payload?.publicVisible !== false && admissionSetting(db, item.examId)?.payload?.autoPublish !== false).map(item => ({ id: item.id, examId: item.examId, examName: db.exams.find(exam => exam.id === item.examId)?.name || '', publishedAt: item.payload?.publishedAt || item.updatedAt, rows: item.payload?.rows || [] })).sort((a, b) => new Date(b.publishedAt) - new Date(a.publishedAt));
+        return { ok: true, plans, qualifications, admissions, cutoffs };
       });
       return sendJson(response, 200, payload);
     }

src/security/session.mjs

@@ -19,6 +19,7 @@ export function createSessionManager({ sessions, readDb, sendError }) {
       return null;
     }
     const db = await readDb();
+    request.authDb = db;
     const user = db.users.find(item => item.id === session.userId) || null;
     return user?.active === false || user?.archivedAt ? null : normalizeUser(user);
   }

src/services/volunteer-admission.mjs

@@ -0,0 +1,215 @@
+export const admissionPhases = new Set(['draft', 'filling', 'closed', 'matching', 'school_review', 'supplementary', 'completed']);
+
+export function admissionRecords(db, kind, examId = null) {
+  return (db.admissionRecords || []).filter(item => item.kind === kind && (!examId || item.examId === examId));
+}
+
+export function admissionSetting(db, examId) {
+  return admissionRecords(db, 'setting', examId)[0] || null;
+}
+
+export function candidateTotalScore(db, examId, userId) {
+  const registration = db.registrations.find(item => item.examId === examId && item.userId === userId && item.status === 'approved');
+  if (!registration) return null;
+  const results = db.results.filter(item => item.registrationId === registration.id && item.published);
+  if (!registration.subjectIds.length || registration.subjectIds.some(id => !results.some(result => result.subjectId === id))) return null;
+  return Number(results.reduce((sum, item) => sum + Number(item.score || 0), 0).toFixed(2));
+}
+
+export function candidateAdmissionScore(db, examId, userId, category = {}) {
+  const culturalScore = candidateTotalScore(db, examId, userId);
+  if (culturalScore == null) return null;
+  const registration = db.registrations.find(item => item.examId === examId && item.userId === userId && item.status === 'approved');
+  const featureScore = Number(registration?.featureScore || 0);
+  const usesFeatureScore = Boolean(category.specialtyCategory || category.specialtyType);
+  return Number((culturalScore + (usesFeatureScore ? featureScore : 0)).toFixed(2));
+}
+
+export function activePreference(db, examId, userId, round) {
+  return admissionRecords(db, 'preference', examId).find(item => item.userId === userId && Number(item.payload?.round || 1) === Number(round || 1)) || null;
+}
+
+export function indicatorQualification(db, examId, userId) {
+  return admissionRecords(db, 'indicator_qualification', examId).find(item => item.userId === userId) || null;
+}
+
+export function sourceSchoolQualificationStatus(db, examId, schoolId) {
+  const profiles = db.candidateProfiles.filter(profile => profile.schoolId === schoolId && profile.profileCompleted && db.users.some(user => user.id === profile.userId && user.role === 'candidate' && user.active));
+  const qualifications = admissionRecords(db, 'indicator_qualification', examId).filter(item => item.schoolId === schoolId && item.status === 'confirmed');
+  const byUser = new Map(qualifications.map(item => [item.userId, item]));
+  const rows = profiles.map(profile => {
+    const account = db.users.find(item => item.id === profile.userId) || {};
+    const specialty = resolveProfileSpecialty(profile);
+    const qualification = byUser.get(profile.userId) || null;
+    return {
+      userId: profile.userId,
+      registrationNumber: account.candidateNumber || '',
+      name: profile.name || account.displayName || '',
+      eligible: qualification?.payload?.eligible === true,
+      confirmed: Boolean(qualification),
+      confirmedAt: qualification?.payload?.confirmedAt || qualification?.updatedAt || '',
+      specialtyCategory: specialty.category,
+      specialtyType: specialty.type,
+      specialtyLabel: specialtyLabel(specialty.category, specialty.type) || '普通生'
+    };
+  }).sort((left, right) => left.registrationNumber.localeCompare(right.registrationNumber));
+  return { total: rows.length, confirmed: rows.filter(item => item.confirmed).length, complete: rows.length > 0 && rows.every(item => item.confirmed), rows };
+}
+
+export function approvedPlans(db, examId) {
+  return admissionRecords(db, 'plan', examId).filter(item => item.status === 'approved');
+}
+
+export function planSummary(plan) {
+  const categories = Array.isArray(plan.payload?.categories) ? plan.payload.categories : [];
+  return { ...plan, totalQuota: categories.reduce((sum, item) => sum + Number(item.quota || 0), 0) };
+}
+
+export function publicAdmissionRows(db, examId) {
+  return admissionRecords(db, 'placement', examId).filter(item => item.status === 'final').map(item => {
+    const user = db.users.find(entry => entry.id === item.userId) || {};
+    const profile = db.candidateProfiles.find(entry => entry.userId === item.userId) || {};
+    const school = db.schools.find(entry => entry.id === item.schoolId) || {};
+    return {
+      registrationNumber: user.candidateNumber || '',
+      name: profile.name || user.displayName || '',
+      totalScore: Number(item.payload?.totalScore || 0),
+      admittedSchool: school.name || '',
+      categoryName: item.payload?.categoryName || '',
+      idNumberMasked: profile.idNumber ? `${profile.idNumber.slice(0, 3)}***********${profile.idNumber.slice(-2)}` : '',
+      phoneMasked: profile.phone ? `${profile.phone.slice(0, 3)}****${profile.phone.slice(-4)}` : ''
+    };
+  }).sort((a, b) => b.totalScore - a.totalScore || a.registrationNumber.localeCompare(b.registrationNumber));
+}
+
+export function admissionCutoffRows(db, examId) {
+  const groups = new Map();
+  for (const placement of admissionRecords(db, 'placement', examId).filter(item => item.status === 'final')) {
+    const key = categoryKey(placement.schoolId, placement.payload?.categoryCode);
+    const row = groups.get(key) || {
+      schoolId: placement.schoolId,
+      schoolName: db.schools.find(item => item.id === placement.schoolId)?.name || '',
+      categoryCode: placement.payload?.categoryCode || '',
+      categoryName: placement.payload?.categoryName || '',
+      admittedCount: 0,
+      planQuota: 0,
+      highestScore: null,
+      cutoffScore: null
+    };
+    const score = Number(placement.payload?.totalScore || 0);
+    row.admittedCount += 1;
+    row.highestScore = row.highestScore == null ? score : Math.max(row.highestScore, score);
+    row.cutoffScore = row.cutoffScore == null ? score : Math.min(row.cutoffScore, score);
+    groups.set(key, row);
+  }
+  for (const plan of approvedPlans(db, examId)) for (const category of plan.payload?.categories || []) {
+    const row = groups.get(categoryKey(plan.schoolId, category.code));
+    if (row) row.planQuota = Number(category.quota || 0);
+  }
+  return [...groups.values()].sort((left, right) => left.schoolName.localeCompare(right.schoolName) || left.categoryName.localeCompare(right.categoryName));
+}
+
+function categoryKey(schoolId, code) {
+  return `${schoolId}|${code}`;
+}
+
+export function buildVolunteerPlacements(db, setting, { uid, nowIso }) {
+  const examId = setting.examId;
+  const round = Number(setting.payload?.round || 1);
+  const plans = approvedPlans(db, examId);
+  const categories = new Map();
+  for (const plan of plans) for (const category of plan.payload?.categories || []) {
+    categories.set(categoryKey(plan.schoolId, category.code), { plan, category });
+  }
+
+  const existing = admissionRecords(db, 'placement', examId).filter(item => item.status !== 'withdrawn');
+  const occupiedIndicators = new Map();
+  const occupiedGeneral = new Map();
+  for (const placement of existing) {
+    const key = categoryKey(placement.schoolId, placement.payload?.categoryCode);
+    if (placement.payload?.quotaBucket?.startsWith('indicator:')) {
+      const indicatorKey = `${key}|${placement.payload.quotaBucket.slice(10)}`;
+      occupiedIndicators.set(indicatorKey, (occupiedIndicators.get(indicatorKey) || 0) + 1);
+    } else occupiedGeneral.set(key, (occupiedGeneral.get(key) || 0) + 1);
+  }
+
+  const preferences = admissionRecords(db, 'preference', examId).filter(item => Number(item.payload?.round || 1) === round && item.status === 'submitted');
+  const candidates = preferences.map(preference => {
+    const profile = db.candidateProfiles.find(item => item.userId === preference.userId) || {};
+    const account = db.users.find(item => item.id === preference.userId) || {};
+    const registration = db.registrations.find(item => item.examId === examId && item.userId === preference.userId && item.status === 'approved');
+    return { preference, profile, account, registration, culturalScore: candidateTotalScore(db, examId, preference.userId), featureScore: Number(registration?.featureScore || 0), nextChoiceIndex: 0 };
+  }).filter(item => item.culturalScore != null && !existing.some(entry => entry.userId === item.preference.userId && ['school_review', 'admitted', 'final', 'withdrawal_pending'].includes(entry.status)));
+
+  const compareProposals = (left, right) => right.totalScore - left.totalScore || String(left.candidate.account.candidateNumber || '').localeCompare(String(right.candidate.account.candidateNumber || ''));
+  const acceptedByBucket = new Map();
+  const queue = [...candidates].sort((left, right) => right.culturalScore - left.culturalScore || String(left.account.candidateNumber || '').localeCompare(String(right.account.candidateNumber || '')));
+  while (queue.length) {
+    const candidate = queue.shift();
+    const choices = candidate.preference.payload?.choices || [];
+    while (candidate.nextChoiceIndex < choices.length) {
+      const index = candidate.nextChoiceIndex;
+      const choice = choices[candidate.nextChoiceIndex++];
+      const target = categories.get(categoryKey(choice.schoolId, choice.categoryCode));
+      if (!target) continue;
+      const { category } = target;
+      if (!candidateEligibleForCategory(candidate.profile, category)) continue;
+      const key = categoryKey(choice.schoolId, choice.categoryCode);
+      let quotaBucket = null;
+      let bucketKey = '';
+      let capacity = 0;
+      let occupiedCount = 0;
+      if (choice.preferenceType === 'indicator') {
+        const qualification = indicatorQualification(db, examId, candidate.preference.userId);
+        const allocation = (category.indicatorAllocations || []).find(item => item.sourceSchoolId === candidate.profile.schoolId);
+        if (!qualification?.payload?.eligible || !allocation) continue;
+        const indicatorKey = `${key}|${candidate.profile.schoolId}`;
+        quotaBucket = `indicator:${candidate.profile.schoolId}`;
+        bucketKey = quotaBucket + '|' + key;
+        capacity = Number(allocation.quota || 0);
+        occupiedCount = occupiedIndicators.get(indicatorKey) || 0;
+      } else {
+        const generalQuota = Math.max(0, Number(category.quota || 0) - (category.indicatorAllocations || []).reduce((sum, item) => sum + Number(item.quota || 0), 0));
+        quotaBucket = 'general';
+        bucketKey = `general|${key}`;
+        capacity = generalQuota;
+        occupiedCount = occupiedGeneral.get(key) || 0;
+      }
+      const available = Math.max(0, capacity - occupiedCount);
+      if (!available) continue;
+      const usesFeatureScore = Boolean(category.specialtyCategory || category.specialtyType);
+      const proposal = {
+        candidate, choice, category, index, quotaBucket,
+        culturalScore: candidate.culturalScore,
+        featureScore: candidate.featureScore,
+        totalScore: Number((candidate.culturalScore + (usesFeatureScore ? candidate.featureScore : 0)).toFixed(2))
+      };
+      const accepted = acceptedByBucket.get(bucketKey) || [];
+      accepted.push(proposal);
+      accepted.sort(compareProposals);
+      const rejected = accepted.length > available ? accepted.pop() : null;
+      acceptedByBucket.set(bucketKey, accepted);
+      if (rejected && rejected !== proposal) queue.push(rejected.candidate);
+      if (rejected === proposal) continue;
+      break;
+    }
+  }
+
+  const accepted = [...acceptedByBucket.values()].flat().sort(compareProposals);
+  return accepted.map(({ candidate, choice, category, index, quotaBucket, culturalScore, featureScore, totalScore }) => ({
+        id: uid('placement'), kind: 'placement', examId, userId: candidate.preference.userId, schoolId: choice.schoolId,
+        status: 'school_review', createdAt: nowIso(), updatedAt: nowIso(), payload: {
+          round, categoryCode: category.code, categoryName: category.name, preferenceOrder: index + 1,
+          culturalScore, totalScore, featureScore,
+          specialtyQualification: resolveProfileSpecialty(candidate.profile), quotaBucket, schoolDecisionNote: '', withdrawalReason: '', withdrawalReviewNote: ''
+        }
+      }));
+}
+
+export function remainingPlanQuota(db, plan) {
+  return (plan.payload?.categories || []).map(category => {
+    const used = admissionRecords(db, 'placement', plan.examId).filter(item => item.schoolId === plan.schoolId && item.payload?.categoryCode === category.code && item.status !== 'withdrawn').length;
+    return { ...category, used, remaining: Math.max(0, Number(category.quota || 0) - used) };
+  });
+}
+import { candidateEligibleForCategory, resolveProfileSpecialty, specialtyLabel } from '../data/specialty-types.mjs';

styles.css

@@ -152,10 +152,10 @@ button:disabled { cursor: not-allowed; opacity: .5; }
 .overline { margin: 0; color: #8c96ae; font-family: Consolas, ui-monospace, monospace; font-size: 10px; font-weight: 700; letter-spacing: 2px; }
 .status { display: inline-flex; align-items: center; gap: 5px; padding: 4px 8px; border-radius: 6px; font-size: 10px; font-style: normal; font-weight: 700; white-space: nowrap; }
 .status::before { content: ""; width: 5px; height: 5px; border-radius: 50%; background: currentColor; }
-.status-open, .status-published, .status-approved, .status-paid { color: #247a5c; background: #e3f3ed; }
+.status-open, .status-published, .status-visible, .status-approved, .status-paid { color: #247a5c; background: #e3f3ed; }
 .status-pending, .status-upcoming, .status-unpaid { color: #9b6817; background: #fff1d3; }
 .status-rejected, .status-closed { color: #af443d; background: #fbe6e4; }
-.status-draft { color: #6d7589; background: #eef0f4; }
+.status-draft, .status-hidden { color: #6d7589; background: #eef0f4; }
 .exam-code { color: #6f7b98; font-family: Consolas, monospace; font-size: 10px; letter-spacing: .8px; }
 
 /* Public site */
@@ -237,6 +237,7 @@ button:disabled { cursor: not-allowed; opacity: .5; }
 .auth-story { position: relative; display: flex; flex-direction: column; justify-content: space-between; padding: 55px max(45px,8vw) 50px; color: #fff; background-color: var(--navy); background-image: radial-gradient(circle at 20% 85%,rgba(49,95,186,.3),transparent 35%), linear-gradient(rgba(255,255,255,.025) 1px,transparent 1px), linear-gradient(90deg,rgba(255,255,255,.025) 1px,transparent 1px); background-size: auto,26px 26px,26px 26px; overflow:hidden; }
 .auth-story::after { content:"准"; position:absolute; right:-55px; bottom:-105px; color:rgba(255,255,255,.03); font-family:"STKaiti"; font-size:420px; }.auth-story .brand { color:#fff; }.auth-story .brand small { color:#7e8db9; }.auth-story .overline { margin-top: 110px; color:#6f82b7; }.auth-story h1 { margin:16px 0 20px; font-family:"STKaiti",serif; font-size:clamp(42px,5vw,66px); font-weight:400; line-height:1.22; }.auth-story h1 em { color:#f07b70; font-style:normal; }.auth-story > div > p:last-child { max-width:470px; color:#aab5d4; font-size:12px; line-height:1.9; }.auth-quote { position:relative; z-index:1; padding-top:20px; border-top:1px solid rgba(255,255,255,.12); }.auth-quote span { color:#7484b1; font-size:9px; }.auth-quote p { margin:8px 0 0; color:#d4daeb; font-family:"STKaiti"; font-size:18px; }
 .auth-panel { display:grid; place-items:center; padding:60px 28px; position:relative; }.back-link { position:absolute; top:28px; right:34px; border:0; color:#778096; background:transparent; font-size:10px; }.auth-card { width:min(480px,100%); }.auth-card h2 { margin:8px 0 7px; font-family:"STKaiti"; font-size:34px; font-weight:400; }.auth-card > p:not(.overline) { margin:0 0 30px; color:#848c9d; font-size:11px; }.stack-form { display:grid; gap:15px; }.stack-form label,.modal-form label,.profile-form label,.result-entry label { display:grid; gap:7px; }.stack-form label > span,.modal-form label > span,.profile-form label > span,.result-entry label > span { color:#555f75; font-size:10px; font-weight:700; }.stack-form input,.stack-form select,.modal-form input,.modal-form select,.modal-form textarea,.profile-form input,.profile-form select,.result-entry input,.result-entry select { width:100%; min-height:44px; padding:10px 12px; border:1px solid #dce1ea; border-radius:8px; color:var(--ink); background:#fff; font-size:11px; outline:0; }.stack-form textarea,.modal-form textarea { resize:vertical; }.stack-form input:focus,.stack-form select:focus,.modal-form input:focus,.modal-form select:focus,.modal-form textarea:focus,.profile-form input:focus,.profile-form select:focus,.result-entry input:focus,.result-entry select:focus { border-color:#8999c0; box-shadow:0 0 0 3px rgba(49,95,186,.08); }.field-row { display:grid; grid-template-columns:1fr 1fr; gap:13px; }.region-selects { display:grid; grid-template-columns:repeat(3,minmax(0,1fr)); gap:13px; }.agreement { display:flex !important; grid-template-columns:auto 1fr; align-items:center; gap:8px !important; color:#767f91; font-size:9px; }.agreement input { width:15px !important; min-height:auto !important; height:15px; }.agreement span { color:#767f91 !important; font-weight:400 !important; }.auth-switch { margin-top:20px; color:#858d9d; font-size:10px; text-align:center; }.auth-switch button { border:0; color:var(--blue); background:transparent; font-weight:700; }.demo-accounts { display:grid; gap:6px; margin-top:25px; padding:14px; border-radius:8px; background:#f5f7fa; }.demo-accounts strong { color:#70798d; font-size:9px; }.demo-accounts button { border:0; color:#6a748a; background:transparent; font-family:Consolas,monospace; font-size:9px; text-align:left; }
+.auth-session-notice { display:grid; gap:4px; margin:-12px 0 18px; padding:12px 14px; border-left:3px solid var(--red); border-radius:7px; color:#814b47; background:#fceceb; }.auth-session-notice strong { font-size:10px; }.auth-session-notice span { font-size:9px; line-height:1.7; }
 
 /* Portal shell */
 .portal { min-height:100vh; }.portal-sidebar { position:fixed; inset:0 auto 0 0; z-index:35; width:238px; display:flex; flex-direction:column; padding:24px 17px 18px; color:#fff; background:var(--navy); overflow:hidden; }.portal-sidebar::after { content:""; position:absolute; width:260px; height:260px; left:-130px; bottom:-80px; border:1px solid rgba(255,255,255,.06); border-radius:50%; box-shadow:0 0 0 45px rgba(255,255,255,.02),0 0 0 90px rgba(255,255,255,.015); }.portal-brand { z-index:1; display:flex; align-items:center; justify-content:space-between; padding:0 9px 22px; border-bottom:1px solid rgba(255,255,255,.1); }.portal-brand .brand { color:#fff; }.portal-brand .brand small { color:#7e8db9; }.portal-brand > button { display:none; border:0; color:#fff; background:transparent; font-size:25px; }.portal-role { margin:20px 12px 9px; color:#6f7fae; font-family:Consolas,monospace; font-size:9px; letter-spacing:1.5px; }.portal-sidebar nav { z-index:1; display:grid; gap:4px; }.portal-sidebar nav button { width:100%; min-height:42px; display:flex; align-items:center; gap:12px; padding:0 13px; border:0; border-radius:8px; color:#aab5d4; background:transparent; font-size:11px; text-align:left; transition:.18s; }.portal-sidebar nav button > span { width:20px; display:grid; place-items:center; }.portal-sidebar nav button svg { width:17px; }.portal-sidebar nav button:hover { color:#fff; background:rgba(255,255,255,.05); }.portal-sidebar nav button.active { color:#fff; background:var(--navy-soft); box-shadow:inset 3px 0 var(--red); }.portal-sidebar nav button em { margin-left:auto; padding:2px 5px; border-radius:8px; color:#fff; background:var(--red); font-size:7px; font-style:normal; }.sidebar-help { z-index:1; display:grid; gap:4px; margin-top:auto; padding:15px 12px; border:1px solid rgba(255,255,255,.08); border-radius:9px; background:rgba(255,255,255,.03); }.sidebar-help span { color:#7484b1; font-size:8px; }.sidebar-help strong { font-family:Consolas,monospace; font-size:11px; }.sidebar-help small { color:#8897bd; font-size:8px; }.portal-main { min-height:100vh; margin-left:238px; }.portal-topbar { height:70px; display:flex; align-items:center; gap:20px; padding:0 30px; border-bottom:1px solid var(--line); background:rgba(255,255,255,.9); backdrop-filter:blur(16px); }.portal-topbar > div:first-of-type { display:flex; gap:8px; align-items:center; font-size:10px; }.portal-topbar > div:first-of-type span,.portal-topbar > div:first-of-type b { color:#9aa1b0; font-weight:400; }.portal-user { display:flex; align-items:center; gap:9px; margin-left:auto; }.portal-user > span:nth-of-type(2) { display:grid; }.portal-user > span strong { font-size:10px; }.portal-user > span small { color:#8c94a6; font-size:8px; }.user-avatar { width:32px; height:32px; display:grid; place-items:center; flex:0 0 auto; border-radius:9px; color:#43578b; background:#e4e9f5; font-size:11px; font-weight:700; }.notification-button,.logout-button,.sidebar-toggle { width:36px; height:36px; display:grid; place-items:center; border:1px solid var(--line); border-radius:8px; color:#687287; background:#fff; }.notification-button { position:relative; }.notification-button i { position:absolute; top:8px; right:8px; width:5px; height:5px; border-radius:50%; background:var(--red); }.notification-button svg,.logout-button svg,.sidebar-toggle svg { width:15px; }.logout-button { border:0; background:transparent; }.sidebar-toggle { display:none; }.portal-content { padding:31px; }.portal-heading { display:flex; align-items:flex-end; justify-content:space-between; gap:25px; margin-bottom:24px; }.portal-heading h1 { margin:5px 0 5px; font-family:"STKaiti"; font-size:31px; font-weight:400; }.portal-heading > div > p:last-child { margin:0; color:#81899a; font-size:11px; }.heading-status { color:#7f8798; font-size:10px; }.heading-status .status { margin-left:6px; }
@@ -254,6 +255,7 @@ button:disabled { cursor: not-allowed; opacity: .5; }
 /* Admin */
 .admin-metrics { display:grid; grid-template-columns:repeat(4,1fr); gap:12px; margin-bottom:16px; }.admin-metrics article { display:flex; align-items:center; gap:13px; padding:20px; border:1px solid var(--line); border-radius:12px; background:#fff; }.admin-metrics article > span { width:40px; height:40px; display:grid; place-items:center; border-radius:9px; color:var(--blue); background:#ecf1fb; }.admin-metrics article:nth-child(2)>span { color:var(--amber); background:#fff3dd; }.admin-metrics article:nth-child(3)>span { color:var(--red); background:#fbe9e7; }.admin-metrics article:nth-child(4)>span { color:var(--jade); background:#e4f3ee; }.admin-metrics article > span svg { width:18px; }.admin-metrics div { display:grid; }.admin-metrics small { color:#8d95a6; font-size:8px; }.admin-metrics strong { margin:2px 0; font-family:Georgia,serif; font-size:23px; font-weight:400; }.admin-metrics em { color:#818a9c; font-size:7px; font-style:normal; }.admin-dashboard-grid { display:grid; grid-template-columns:1.05fr 1fr; gap:16px; }.admin-todos { overflow:hidden; }.admin-todos > button { width:100%; display:grid; grid-template-columns:36px 1fr 18px; align-items:center; gap:11px; padding:14px 18px; border:0; border-bottom:1px solid var(--line); color:var(--ink); background:#fff; text-align:left; }.admin-todos > button:last-child { border-bottom:0; }.admin-todos > button:hover { background:#fafbfc; }.admin-todos > button > i { width:34px; height:34px; display:grid; place-items:center; border-radius:9px; color:#65728d; background:#edf0f6; font-size:10px; font-style:normal; font-weight:700; }.admin-todos > button > i.urgent { color:#a8463f; background:#fbe8e6; }.admin-todos button > span { display:grid; gap:3px; }.admin-todos strong { font-size:9px; }.admin-todos small { color:#9299aa; font-size:7px; }.admin-todos button > svg { color:#9ba2b1; }.audit-feed > div { display:grid; grid-template-columns:32px 1fr auto; align-items:center; gap:10px; padding:14px 18px; border-bottom:1px solid var(--line); }.audit-feed > div:last-child { border-bottom:0; }.audit-feed p { display:grid; gap:3px; margin:0; }.audit-feed p strong { font-size:9px; }.audit-feed p small { color:#9098a8; font-size:7px; }.audit-feed time { color:#8d95a5; font-size:7px; }
 .data-panel { overflow:hidden; }.data-toolbar { min-height:64px; display:flex; align-items:center; justify-content:space-between; gap:15px; padding:13px 17px; border-bottom:1px solid var(--line); }.data-toolbar > p { margin:0; color:#878f9f; font-size:8px; }.search-box { width:min(330px,40%); min-height:36px; display:flex; align-items:center; gap:8px; padding:0 11px; border:1px solid var(--line); border-radius:8px; }.search-box svg { width:14px; color:#9098a9; }.search-box input { width:100%; border:0; outline:0; background:transparent; font-size:9px; }.filter-pills { display:flex; gap:4px; }.filter-pills button { min-height:31px; padding:0 11px; border:1px solid var(--line); border-radius:7px; color:#778094; background:#fff; font-size:8px; }.filter-pills button.active { border-color:var(--navy); color:#fff; background:var(--navy); }.table-scroll { overflow-x:auto; }table { width:100%; border-collapse:collapse; white-space:nowrap; }th { padding:11px 14px; color:#858d9f; background:#fafbfc; font-size:8px; font-weight:600; text-align:left; }td { padding:13px 14px; border-top:1px solid #edf0f5; color:#5b657a; font-size:9px; }tbody tr { transition:background .15s; }tbody tr:hover { background:#fafbfe; }td > strong,td > small { display:block; }td > strong { color:var(--ink); font-size:9px; }td > small { max-width:230px; margin-top:3px; overflow:hidden; color:#9299a9; font-size:7px; text-overflow:ellipsis; }.person-cell { display:flex; align-items:center; gap:9px; }.person-cell > span { width:31px; height:31px; display:grid; place-items:center; border-radius:8px; color:#536691; background:#e8edf7; font-size:10px; font-weight:700; }.person-cell > div { display:grid; gap:2px; }.person-cell strong { color:var(--ink); font-size:9px; }.person-cell small { color:#9299a9; font-size:7px; }.mono { font-family:Consolas,monospace; }.row-action { border:0; color:var(--blue); background:transparent; font-size:8px; font-weight:700; }.row-action.primary { padding:6px 9px; border-radius:6px; color:#fff; background:var(--navy); }.table-chips { display:flex; gap:3px; }.table-chips span { padding:3px 5px; border-radius:4px; color:#5e6980; background:#eef1f6; font-size:7px; }.pin-label { color:var(--red); font-size:8px; }
+.notice-admin-toolbar { flex-wrap:wrap; }.notice-admin-toolbar > p { flex:1 0 100%; }.notice-row-actions { display:flex; align-items:center; gap:8px; }
 .registration-toolbar,.payment-toolbar { flex-wrap:wrap; }.table-filter-selects { flex:1 0 100%; display:grid; grid-template-columns:repeat(4,minmax(130px,1fr)); gap:8px; }.table-filter-selects select { width:100%; min-height:35px; padding:7px 10px; border:1px solid var(--line); border-radius:7px; color:#59647a; background:#fff; font-size:8px; }.registration-bulk-bar { min-height:54px; display:flex; align-items:center; justify-content:space-between; gap:14px; padding:10px 17px; border-bottom:1px solid #dce4f1; background:#f4f7fc; }.registration-bulk-bar > span { color:#6e788d; font-size:8px; }.registration-bulk-bar > span strong { margin:0 3px; color:var(--navy); font-size:13px; }.registration-bulk-bar > div { display:flex; gap:7px; }.registration-bulk-bar .row-action { padding:7px 10px; border:1px solid #ccd6e7; border-radius:7px; background:#fff; }.registration-bulk-bar .row-action.primary { border-color:var(--navy); background:var(--navy); }.registration-bulk-bar .row-action:disabled { border-color:#e1e5ec; color:#aab1bf; background:#f8f9fb; }.selection-cell { width:42px; padding-right:8px; text-align:center; }.selection-cell input { width:15px; height:15px; accent-color:var(--navy); }.row-action.danger { color:#a64b48; }
 .admin-exam-grid { display:grid; grid-template-columns:repeat(2,1fr); gap:15px; }.admin-exam-card { position:relative; padding:22px; border:1px solid var(--line); border-radius:var(--radius); background:#fff; overflow:hidden; }.admin-exam-card.editable { cursor:pointer; transition:border-color .18s,box-shadow .18s,transform .18s; }.admin-exam-card.editable:hover { border-color:#bdc8df; box-shadow:var(--shadow); transform:translateY(-2px); }.admin-exam-card.published::before { content:""; position:absolute; top:0; bottom:0; left:0; width:4px; background:var(--jade); }.admin-exam-card header { display:flex; align-items:center; justify-content:space-between; }.admin-exam-card h2 { margin:16px 0 7px; font-family:"STKaiti"; font-size:21px; font-weight:400; }.admin-exam-card > p { min-height:34px; margin:0; color:#828a9a; font-size:9px; line-height:1.8; }.admin-exam-card dl { display:grid; grid-template-columns:1fr 1fr; gap:12px; margin:19px 0; }.admin-exam-card dl div:last-child { grid-column:1/-1; }.admin-exam-card dt { color:#999fac; font-size:7px; }.admin-exam-card dd { margin:3px 0 0; color:#5e687d; font-size:8px; }.admin-subjects { display:flex; flex-wrap:wrap; gap:5px; padding:12px; border-radius:8px; background:#f7f8fb; }.admin-subjects span { display:grid; gap:2px; padding:6px 8px; border:1px solid #e3e7ef; border-radius:5px; background:#fff; }.admin-subjects b { font-size:8px; }.admin-subjects small { color:#969dac; font-size:6px; }.admin-exam-card footer { display:flex; align-items:center; justify-content:space-between; gap:12px; margin-top:15px; padding-top:13px; border-top:1px solid var(--line); }.admin-exam-card footer > span { color:#858d9e; font-size:8px; }.exam-card-actions { display:flex; align-items:center; gap:7px; }.results-admin-grid { display:grid; grid-template-columns:.8fr 1.2fr; gap:16px; }.result-entry form { display:grid; gap:14px; padding:20px; }.publish-switch { justify-content:flex-start; }.published-results > div:not(.panel-title) { display:grid; grid-template-columns:32px 1fr auto auto; align-items:center; gap:10px; padding:12px 18px; border-bottom:1px solid var(--line); }.published-results > div:last-child { border-bottom:0; }.published-results p { display:grid; gap:3px; margin:0; }.published-results p strong { font-size:9px; }.published-results p small { color:#9098a9; font-size:7px; }.published-results b { font-family:Georgia,serif; font-size:17px; font-weight:400; }
 .exam-score-band { display:grid; grid-template-columns:140px 1fr; margin:17px -22px 0; color:#fff; background:var(--navy); }
@@ -267,6 +269,7 @@ button:disabled { cursor: not-allowed; opacity: .5; }
 
 /* Modals and feedback */
 .modal-layer { position:fixed; inset:0; z-index:100; display:grid; place-items:center; padding:22px; background:rgba(12,22,48,.55); backdrop-filter:blur(5px); animation:fadeIn .18s ease; }.modal-card { width:min(620px,100%); max-height:90vh; border-radius:16px; background:#fff; box-shadow:0 30px 90px rgba(13,23,51,.3); overflow-y:auto; animation:modalIn .22s ease; }.modal-head { display:flex; align-items:flex-start; justify-content:space-between; gap:20px; padding:22px 24px 18px; border-bottom:1px solid var(--line); }.modal-head span { color:#8b94a8; font-family:Consolas,monospace; font-size:8px; letter-spacing:1.5px; }.modal-head h2 { margin:5px 0; font-family:"STKaiti"; font-size:23px; font-weight:400; }.modal-head p { margin:0; color:#8c94a5; font-size:8px; }.modal-head > button { border:0; color:#8a92a2; background:transparent; font-size:23px; }.notice-content { padding:25px; color:#525d73; overflow-wrap:anywhere; }.notice-content p,.notice-content li { color:#525d73; font-size:11px; line-height:2; }.notice-content p { margin:0 0 13px; }.notice-content h2,.notice-content h3,.notice-content h4 { margin:22px 0 10px; color:var(--navy); font-family:"STKaiti"; font-weight:400; }.notice-content h2 { font-size:22px; }.notice-content h3 { font-size:18px; }.notice-content h4 { font-size:15px; }.notice-content ul,.notice-content ol { margin:0 0 14px; padding-left:24px; }.notice-content blockquote { margin:15px 0; padding:10px 14px; border-left:3px solid var(--blue); background:#f4f7fc; }.notice-content blockquote p { margin:0; }.notice-content a { color:var(--blue); text-decoration:underline; text-underline-offset:2px; }.modal-form { display:grid; gap:14px; padding:22px 24px 0; }.modal-foot { display:flex; justify-content:flex-end; gap:8px; margin:20px -24px 0; padding:15px 24px; border-top:1px solid var(--line); background:#fafbfc; }.modal-card > .modal-foot { margin:0; }.review-profile,.registration-review,.admit-preview { padding:22px 24px 0; }.review-profile dl { display:grid; grid-template-columns:1fr 1fr; gap:13px; margin:0; }.review-profile dl div,.registration-review dl div,.admit-preview dl div { display:grid; gap:4px; padding:10px; border-radius:7px; background:#f7f8fb; }.review-profile dt,.registration-review dt,.admit-preview dt { color:#969dac; font-size:7px; }.review-profile dd,.registration-review dd,.admit-preview dd { margin:0; color:#525d73; font-size:9px; }.registration-review > div > span { color:#9199a9; font-size:8px; }.registration-review > div p { display:flex; flex-wrap:wrap; gap:5px; }.registration-review > div b { padding:5px 8px; border-radius:5px; color:#54617a; background:#eef1f6; font-size:8px; }.registration-review dl,.admit-preview dl { display:grid; grid-template-columns:repeat(3,1fr); gap:9px; }.admit-preview > strong { display:block; margin:5px 0 18px; color:var(--navy); font-family:Consolas,monospace; font-size:26px; letter-spacing:2px; }.admit-preview > p { margin:16px 0 0; padding:11px; border-radius:7px; color:#7a5a24; background:#fff3dc; font-size:8px; }.toast { position:fixed; right:24px; bottom:24px; z-index:130; min-width:245px; display:flex; align-items:center; gap:11px; padding:13px 15px; border:1px solid #dfe7e3; border-radius:10px; background:#fff; box-shadow:0 17px 50px rgba(18,39,30,.17); opacity:0; transform:translateY(25px); pointer-events:none; transition:.25s; }.toast.show { opacity:1; transform:none; }.toast-icon { width:29px; height:29px; display:grid; place-items:center; border-radius:50%; color:#fff; background:var(--jade); font-size:11px; }.toast div { display:grid; gap:2px; }.toast strong { font-size:9px; }.toast small { color:#858d9e; font-size:8px; }.fatal-error { min-height:100vh; display:grid; place-content:center; justify-items:center; padding:25px; text-align:center; }.fatal-error > span { width:55px; height:55px; display:grid; place-items:center; border-radius:50%; color:#fff; background:var(--red); font-family:Georgia,serif; font-size:28px; }.fatal-error h1 { margin:18px 0 8px; font-family:"STKaiti"; font-size:28px; font-weight:400; }.fatal-error p { margin:0 0 18px; color:#7f8799; font-size:10px; }.empty-state { padding:35px; color:#8b93a4; font-size:9px; text-align:center; }
+.fatal-error-actions { display:flex; gap:9px; }
 .modal-card:has(.exam-config-form) { width:min(980px,100%); }
 .modal-card:has(.notice-editor-form) { width:min(820px,100%); }
 .notice-editor-field { display:grid; gap:7px; }
@@ -370,6 +373,51 @@ button:disabled { cursor: not-allowed; opacity: .5; }
 .result-metric-grid strong { display:block; margin:7px 0 5px; color:#173f60; font:400 25px Georgia,serif; }
 .result-metric-grid strong em { color:#8c96aa; font-size:13px; font-style:normal; }
 .result-excel-toolbar { margin-bottom:14px; }
+.result-entry-workbench { margin-bottom:14px; overflow:hidden; border-color:#cbd6e6; box-shadow:0 14px 34px rgba(20,36,81,.07); }
+.result-workbench-head { display:grid; grid-template-columns:minmax(280px,1fr) minmax(430px,1.1fr); align-items:end; gap:28px; padding:22px 24px; color:#fff; background:linear-gradient(112deg,#12244d 0%,#1c4269 72%,#236b78 100%); }
+.result-workbench-head > div:first-child > span { color:#8ed0d4; font:700 9px Consolas,monospace; letter-spacing:.18em; }
+.result-workbench-head h2 { margin:6px 0 4px; font-family:"STKaiti","KaiTi",serif; font-size:25px; font-weight:400; }
+.result-workbench-head p { margin:0; color:#c6d4e3; font-size:10px; line-height:1.7; }
+.result-workbench-selectors { display:grid; grid-template-columns:1.25fr .75fr; gap:10px; }
+.result-workbench-selectors label { display:grid; gap:6px; color:#dbe6f2; font-size:9px; font-weight:700; }
+.result-workbench-selectors select { width:100%; min-height:42px; padding:8px 11px; border:1px solid rgba(255,255,255,.3); border-radius:8px; color:#15264b; background:#fff; font-size:11px; outline:0; }
+.result-workbench-selectors select:focus { box-shadow:0 0 0 3px rgba(142,208,212,.24); }
+.result-workbench-summary { display:grid; grid-template-columns:repeat(4,110px) 1fr; align-items:center; min-height:69px; padding:10px 24px; border-bottom:1px solid #e2e8f0; background:#f5f8fc; }
+.result-workbench-summary > span { display:grid; gap:3px; border-right:1px solid #dce4ee; }
+.result-workbench-summary small { color:#8a94a7; font-size:8px; }
+.result-workbench-summary strong { color:#143a5b; font:400 19px Georgia,serif; }
+.result-workbench-summary p { justify-self:end; margin:0; padding-left:18px; color:#60708a; font-size:10px; }
+.result-entry-toolbar { min-height:62px; border-bottom:1px solid #e5eaf1; }
+.result-entry-table-wrap { max-height:560px; overflow:auto; }
+.result-entry-table-wrap table { min-width:1050px; }
+.result-entry-table-wrap thead { position:sticky; top:0; z-index:3; }
+.result-entry-table-wrap th { color:#56647c; background:#eef3f8; box-shadow:0 1px #dbe3ed; }
+.result-entry-table-wrap tbody tr { transition:background .12s; }
+.result-entry-table-wrap tbody tr:focus-within { background:#f1f7ff; }
+.result-row-index { color:#97a1b1; text-align:center; }
+.result-score-input-cell { min-width:170px; }
+.result-score-input-cell input { width:126px; height:38px; padding:7px 11px; border:1px solid #cbd5e3; border-radius:7px; color:#102c4d; background:#fff; font:700 14px Consolas,monospace; outline:0; }
+.result-score-input-cell input:focus { border-color:#315fba; box-shadow:0 0 0 3px rgba(49,95,186,.1); }
+.result-score-input-cell input[data-dirty="true"] { border-color:#bd7d19; background:#fffaf0; }
+.result-score-input-cell small { display:block; min-height:12px; margin-top:3px; color:#b23838; font-size:8px; }
+.score-row-invalid { background:#fff6f5 !important; }
+.score-row-invalid input { border-color:#c74646; }
+.result-missing { display:inline-flex; padding:4px 8px; border-radius:99px; color:#7b8495; background:#eef1f5; font-size:8px; }
+.result-workbench-actions { display:flex; align-items:center; justify-content:flex-end; gap:9px; min-height:74px; padding:13px 24px; border-top:1px solid #dfe6ef; background:#fff; box-shadow:0 -8px 20px rgba(20,36,81,.03); }
+.result-workbench-actions > div { display:grid; gap:4px; margin-right:auto; }
+.result-workbench-actions > div strong { color:#32435f; font-size:10px; }
+.result-workbench-actions > div small { color:#8b95a7; font-size:8px; }
+.feature-score-workbench { margin-bottom:14px; overflow:hidden; border-color:#bcd9dc; box-shadow:0 14px 34px rgba(25,86,95,.07); }
+.feature-score-workbench > form > header { display:grid; grid-template-columns:minmax(300px,1fr) auto; align-items:center; gap:24px; padding:21px 24px; color:#133d48; background:linear-gradient(110deg,#eef9f8,#dceff0); border-left:4px solid #287486; }
+.feature-score-workbench header > div:first-child > span { color:#287486; font:700 9px Consolas,monospace; letter-spacing:.18em; }
+.feature-score-workbench h2 { margin:5px 0; font-family:"STKaiti","KaiTi",serif; font-size:24px; font-weight:400; }
+.feature-score-workbench header p { max-width:720px; margin:0; color:#5b7780; font-size:10px; line-height:1.7; }
+.feature-score-rule { display:grid; gap:5px; min-width:265px; padding:12px 15px; border:1px solid #b9d9da; border-radius:9px; background:rgba(255,255,255,.72); }
+.feature-score-rule strong { color:#245b65; font-size:10px; }
+.feature-score-rule span { color:#607a81; font-size:9px; }
+.feature-score-input-cell input { width:140px; }
+.feature-score-workbench td > small { display:block; margin-top:3px; color:#8a95a6; }
+.feature-score-summary { grid-template-columns:repeat(4,125px) 1fr; }
 .result-entry-console { margin-bottom:14px; overflow:hidden; }
 .result-entry-console .panel-title { height:auto; min-height:74px; }
 .result-entry-console .panel-title p { margin:4px 0 0; color:#8791a4; font-size:10px; }
@@ -581,3 +629,254 @@ button:disabled { cursor: not-allowed; opacity: .5; }
 @media (max-width: 620px) {
   .scope-banner { align-items:flex-start; }.candidate-flow-note { grid-template-columns:1fr; }.segment-option { grid-template-columns:18px 52px 1fr; }.segment-value,.segment-width { grid-column:2/-1; }.workflow-step-row { grid-template-columns:28px 1fr 26px; }.workflow-step-row > i { width:28px;height:28px; }.workflow-step-row select { grid-column:2/3; }.workflow-owner { grid-template-columns:1fr; }.center-card dl { grid-template-columns:1fr; }.number-rule-layout { display:block; }.rule-preview { margin-top:14px; }.center-summary,.center-metrics,.center-profile,.batch-number-panel form,.room-editor-grid,.flow-center-snapshot dl { grid-template-columns:1fr; }.center-dossier > header,.center-dossier > footer,.center-form-section > header,.approval-callout { align-items:flex-start; flex-direction:column; }.center-dossier > header > div:last-child { flex-wrap:wrap; }.room-editor-grid .room-notes { grid-column:auto; }.onboarding-page { display:block; }.onboarding-identity { position:relative; min-height:auto; padding:25px 20px; }.onboarding-identity > span { margin-top:35px; }.onboarding-identity > p { display:none; }.onboarding-identity > button { position:absolute; top:26px; right:20px; }.onboarding-steps { margin-top:30px; }.onboarding-steps > div { min-height:58px; }.onboarding-work { padding:30px 14px 45px; }.profile-form .wide-field { grid-column:auto; }.registration-policy { align-items:flex-start; flex-direction:column; }.registration-policy form { width:100%; justify-content:space-between; }.account-number-principle { grid-template-columns:1fr; }.account-number-principle span { grid-row:auto; writing-mode:horizontal-tb; }
 }
+
+/* 中考志愿与招生录取：唯一强调元素是贯穿全流程的进度轨道。 */
+.admission-command-banner { display:flex; justify-content:space-between; gap:28px; margin-bottom:18px; padding:26px 30px; border-radius:14px; color:#fff; background:linear-gradient(118deg,#17375f 0%,#245783 62%,#2b7180 100%); box-shadow:0 16px 34px rgba(23,55,95,.18); }
+.admission-command-banner > div span { color:#9fcad5; font:700 10px/1.2 Consolas,monospace; letter-spacing:1.8px; }.admission-command-banner h2 { margin:8px 0 6px; font-size:24px; }.admission-command-banner p { max-width:650px; margin:0; color:#dceaf0; line-height:1.7; }.admission-command-banner dl { display:grid; grid-template-columns:repeat(4,minmax(70px,1fr)); gap:10px; margin:0; }.admission-command-banner dl div { padding:12px; border:1px solid rgba(255,255,255,.16); border-radius:9px; background:rgba(255,255,255,.07); }.admission-command-banner dt { color:#b8d6df; }.admission-command-banner dd { margin:4px 0 0; font-size:22px; font-weight:800; }
+.admission-admin-grid { display:grid; grid-template-columns:1.35fr .85fr; gap:16px; margin-bottom:16px; }.admission-settings-panel form,.admission-account-panel form,.admission-plan-console form { display:grid; gap:12px; }.admission-control-actions { display:flex; flex-wrap:wrap; gap:8px; margin-top:18px; padding-top:16px; border-top:1px solid var(--line); }
+.admission-admin-grid.single { grid-template-columns:1fr; }
+.admission-candidate-list { display:grid; gap:18px; }.admission-candidate-card { padding:24px; }.admission-candidate-card > header { display:flex; justify-content:space-between; gap:18px; }.admission-candidate-card > header span { color:var(--muted); font:700 10px Consolas,monospace; }.admission-candidate-card h2 { margin:5px 0 0; }
+.admission-progress-track { position:relative; display:grid; grid-template-columns:repeat(4,1fr); margin:26px 0; }.admission-progress-track::before { content:""; position:absolute; top:15px; left:10%; right:10%; height:2px; background:#dbe4ec; }.admission-progress-track div { position:relative; z-index:1; display:grid; justify-items:center; gap:7px; color:#8190a0; }.admission-progress-track i { display:grid; place-items:center; width:32px; height:32px; border:2px solid #dbe4ec; border-radius:50%; background:#fff; font-style:normal; font-weight:800; }.admission-progress-track .done i,.admission-progress-track .current i { border-color:#287486; color:#fff; background:#287486; }.admission-progress-track .current i { box-shadow:0 0 0 6px rgba(40,116,134,.12); }.admission-progress-track .done,.admission-progress-track .current { color:#214d5a; font-weight:700; }
+.admission-score-strip { display:flex; align-items:center; gap:12px; padding:14px 16px; border-radius:10px; background:#f2f7f8; }.admission-score-strip strong { margin-right:auto; font-size:18px; }.admission-score-strip em { color:#287486; font-style:normal; font-weight:700; }.admission-progress-copy { color:var(--muted); }.admission-result-banner { display:grid; gap:4px; margin:14px 0; padding:16px; border-left:4px solid #287486; border-radius:8px; background:#eef7f8; }.admission-result-banner strong { font-size:17px; }
+.preference-form { margin-top:18px; padding-top:18px; border-top:1px solid var(--line); }.preference-form-head { display:flex; justify-content:space-between; gap:12px; margin-bottom:12px; }.preference-form-head small { display:block; margin-top:4px; color:var(--muted); }.preference-choice-list { display:grid; gap:9px; margin-bottom:14px; }.preference-choice-list label { display:grid; grid-template-columns:34px 1fr; align-items:center; gap:9px; }.preference-choice-list b { display:grid; place-items:center; width:30px; height:30px; border-radius:50%; color:#fff; background:#244e72; }.preference-choice-list select,.placement-review-form select,.placement-review-form input { min-height:40px; padding:8px 10px; border:1px solid var(--line); border-radius:8px; background:#fff; }.locked-preferences { display:grid; gap:8px; margin-top:16px; }.locked-preferences span { display:flex; gap:10px; padding:10px 12px; border-radius:8px; background:#f5f7fa; }.locked-preferences b { color:#287486; }
+.placement-review-form { display:grid; min-width:210px; gap:7px; }.public-admission-board { margin-bottom:18px; overflow:hidden; }.public-admission-board > header { display:flex; justify-content:space-between; padding:20px 22px; color:#fff; background:#214d5a; }.public-admission-board h3 { margin:5px 0 0; font-size:19px; }.public-admission-board table { margin:0; }
+.placement-review-ledger { margin-bottom:16px; overflow:hidden; }.placement-review-ledger .data-toolbar { flex-wrap:wrap; }.placement-review-ledger table { min-width:1250px; }.placement-review-ledger td > small,.placement-review-ledger td > strong { display:block; margin-top:3px; }.placement-status-pills,.account-status-pills { margin:0 24px 12px; }.placement-bulk-toolbar { display:flex; align-items:center; justify-content:space-between; gap:18px; margin:0 24px 16px; padding:14px 16px; border:1px solid #d8e2e9; border-radius:10px; background:#f6f9fb; }.placement-bulk-toolbar > label,.placement-bulk-toolbar > div { display:flex; align-items:center; gap:10px; }.placement-bulk-toolbar input { width:17px; height:17px; }.placement-bulk-toolbar strong { margin-right:5px; color:#287486; }.placement-bulk-toolbar button { min-height:40px; }
+@media (max-width:1000px) { .admission-command-banner { flex-direction:column; }.admission-admin-grid { grid-template-columns:1fr; } }
+@media (max-width:620px) { .admission-command-banner { padding:20px; }.admission-command-banner dl { grid-template-columns:repeat(2,1fr); }.admission-progress-track span { font-size:9px; }.admission-score-strip,.preference-form-head { align-items:flex-start; flex-direction:column; }.admission-score-strip strong { margin-right:0; } }
+
+/* 招生资格与计划台账：配额卡片是本轮的唯一结构化视觉重点。 */
+.admission-plan-console.structured { padding:22px; margin-bottom:16px; }
+.admission-categories-builder { display:grid; gap:12px; }
+.admission-builder-head,.indicator-allocation-head { display:flex; align-items:center; justify-content:space-between; gap:16px; }
+.admission-builder-head small,.indicator-allocation-head small { display:block; margin-top:3px; color:var(--muted); }
+[data-admission-categories] { display:grid; gap:13px; }
+.admission-category-editor { overflow:hidden; border:1px solid #d8e2ec; border-radius:12px; background:#fbfdfe; }
+.admission-category-editor > header { display:flex; align-items:center; justify-content:space-between; gap:12px; padding:11px 14px; color:#fff; background:linear-gradient(100deg,#244e72,#287486); }
+.admission-category-editor > header div { display:flex; align-items:center; gap:10px; }.admission-category-editor > header span { color:#b9d8df; font:700 10px Consolas,monospace; }.admission-category-editor > header strong { font-size:13px; }
+.admission-category-editor > header button { border:0; color:#dbeef1; background:transparent; cursor:pointer; }
+.admission-category-fields { display:grid; grid-template-columns:1.2fr .55fr .7fr; gap:11px; padding:14px; }
+.specialty-plan-fields { grid-column:1/-1; display:grid; grid-template-columns:1fr 1fr; gap:11px; padding:12px; border-left:3px solid #2b7e89; border-radius:8px; background:#edf7f7; }.specialty-plan-fields.hidden { display:none; }
+.indicator-allocation-editor { padding:0 14px 14px; }.indicator-allocation-head { padding-top:12px; border-top:1px solid #dfe7ee; }
+[data-indicator-allocations] { display:grid; gap:8px; margin-top:10px; }.indicator-allocation-row { display:grid; grid-template-columns:1fr 150px auto; align-items:end; gap:9px; padding:10px; border-radius:9px; background:#f1f5f8; }
+.indicator-allocation-row label,.admission-category-fields label { display:grid; gap:5px; }.indicator-allocation-row label span,.admission-category-fields label > span,.school-role-selector > strong { color:#607087; font-size:11px; font-weight:700; }
+.indicator-allocation-row input,.indicator-allocation-row select,.admission-category-fields input,.admission-category-fields select { width:100%; min-height:40px; padding:8px 10px; border:1px solid var(--line); border-radius:8px; background:#fff; }
+.preference-choice-row { display:grid; grid-template-columns:34px 1fr 1fr; align-items:end; gap:10px; padding:11px; border:1px solid #dce5eb; border-radius:10px; background:#f8fbfc; }
+.preference-choice-list .preference-choice-row > b { align-self:center; }.preference-choice-list .preference-choice-row > label { display:grid; grid-template-columns:1fr; align-items:stretch; gap:5px; }.preference-choice-row label > span { color:#687789; font-size:10px; font-weight:700; }
+.admission-score-strip > span b { margin-left:4px; color:#244e72; }.admission-score-strip > span:not(:first-child) { padding-left:12px; border-left:1px solid #cadde1; }
+.school-type-summary { grid-template-columns:repeat(4,1fr); }.school-role-tags { display:flex; flex-wrap:wrap; gap:5px; }.school-role { padding:5px 8px; border-radius:99px; font-size:11px; font-weight:700; }.school-role.source { color:#245c72; background:#e5f2f7; }.school-role.admission { color:#3c6651; background:#e5f3eb; }
+.school-role-selector { display:grid; gap:9px; padding:13px; border:1px solid var(--line); border-radius:10px; background:#f7f9fc; }.school-role-selector > div { display:grid; grid-template-columns:1fr 1fr; gap:9px; }.school-role-selector label { display:grid; grid-template-columns:auto 1fr; gap:9px; padding:11px; border:1px solid #dce3ed; border-radius:8px; background:#fff; }.school-role-selector label span { display:grid; gap:3px; }.school-role-selector small { color:var(--muted); }
+.feature-score-console { display:grid; grid-template-columns:minmax(260px,.8fr) minmax(420px,1.2fr); align-items:end; gap:24px; margin-bottom:15px; padding:21px; border-left:4px solid #287486; background:linear-gradient(105deg,#fff,#edf7f7); }.feature-score-console > div > span,.admission-export-bar > div > span { color:#2c7180; font:700 10px Consolas,monospace; letter-spacing:1.2px; }.feature-score-console h2 { margin:5px 0; }.feature-score-console p { margin:0; color:var(--muted); line-height:1.7; }.feature-score-console form { display:grid; grid-template-columns:1fr 130px auto; align-items:end; gap:10px; }.feature-score-console label { display:grid; gap:5px; }.feature-score-console select,.feature-score-console input,.admission-export-bar select { min-height:40px; padding:8px 10px; border:1px solid var(--line); border-radius:8px; background:#fff; }
+.admission-export-bar { display:grid; grid-template-columns:1fr minmax(250px,.5fr) auto; align-items:end; gap:18px; margin-bottom:15px; padding:20px 22px; border-left:4px solid #287486; background:linear-gradient(105deg,#fff,#eef7f8); }.admission-export-bar > div { display:grid; gap:4px; }.admission-export-bar label { display:grid; gap:5px; }.admission-export-bar small { color:var(--muted); }
+.specialty-qualification-grid select:disabled { color:#8f99a8; background:#f1f3f6; }
+.result-panel .result-summary { grid-template-columns:repeat(4,1fr); }
+.result-panel .result-summary.qualified > span:last-child strong,.result-panel .result-summary.unqualified > span:last-child strong { color:var(--navy); }.result-panel .result-summary.qualified > span:nth-child(3) strong { color:#237358; }.result-panel .result-summary.unqualified > span:nth-child(3) strong { color:#a24f43; }
+@media (max-width:1000px) { .admission-category-fields { grid-template-columns:1fr 1fr; }.admission-category-fields > label:first-child { grid-column:1/-1; }.feature-score-console,.admission-export-bar { grid-template-columns:1fr; }.school-type-summary { grid-template-columns:repeat(2,1fr); } }
+@media (max-width:620px) { .admission-category-fields,.specialty-plan-fields,.indicator-allocation-row,.preference-choice-row,.school-role-selector > div,.feature-score-console form,.school-type-summary { grid-template-columns:1fr; }.admission-category-fields > label:first-child { grid-column:auto; }.preference-choice-list .preference-choice-row > b { justify-self:start; }.admission-builder-head,.indicator-allocation-head { align-items:flex-start; flex-direction:column; }.result-panel .result-summary { grid-template-columns:1fr; } }
+
+.qualification-ledger-intro { margin-bottom:22px; padding:30px 34px; border-radius:22px; color:#fff; background:linear-gradient(125deg,#17375f,#245783 68%,#287486); box-shadow:0 18px 40px rgba(23,55,95,.18); }
+.qualification-ledger-intro span,.announcement-hero .overline { color:#a9d9df; font:700 12px/1.4 Consolas,monospace; letter-spacing:.16em; }
+.qualification-ledger-intro h2 { margin:8px 0; font:700 28px/1.2 STKaiti,KaiTi,serif; }.qualification-ledger-intro p { max-width:780px; margin:0; color:rgba(255,255,255,.78); }
+.qualification-ledger { margin-bottom:22px; overflow:hidden; }.qualification-ledger > header { display:flex; align-items:center; justify-content:space-between; padding:22px 24px 14px; }.qualification-ledger > header span { color:#287486; font:700 12px Consolas,monospace; }.qualification-ledger > header h2 { margin:5px 0 0; }
+.qualification-ledger > header > strong { padding:8px 13px; border-radius:999px; color:#9a6818; background:#fff6df; }.qualification-ledger > header > strong.complete { color:#17665b; background:#e5f5f1; }
+.qualification-progress { height:4px; margin:0 24px; overflow:hidden; border-radius:99px; background:#e6ebf1; }.qualification-progress i { display:block; height:100%; background:linear-gradient(90deg,#287486,#5ea8a0); }
+.qualification-publication-state { margin:14px 24px; padding:10px 13px; border-left:3px solid #287486; color:#17665b; background:#eef8f7; }.qualification-publication-state.pending { border-color:#c69037; color:#76551d; background:#fff8e9; }.qualification-ledger select { min-width:190px; }
+.preference-choice-row.indicator { border-color:#d5c38f; background:#fffaf0; }.preference-choice-row.indicator > b { color:#8a641d; }
+
+.disclosure-entry { display:flex; align-items:center; justify-content:space-between; gap:32px; padding:34px 40px; border-radius:24px; color:#fff; background:#17375f; }.disclosure-entry h2 { margin:5px 0 10px; font:700 32px/1.15 STKaiti,KaiTi,serif; }.disclosure-entry p:last-child { margin:0; color:rgba(255,255,255,.72); }
+.announcement-page { padding-bottom:70px; background:#f4f7fa; }.announcement-hero { min-height:360px; display:grid; grid-template-columns:minmax(0,1fr) auto; align-items:end; gap:60px; padding:80px max(5vw,24px) 55px; color:#fff; background:radial-gradient(circle at 75% 15%,rgba(73,151,154,.38),transparent 32%),linear-gradient(132deg,#102a49,#17375f 55%,#245783); }
+.announcement-hero h1 { margin:12px 0 18px; font:700 clamp(42px,6vw,74px)/.95 STKaiti,KaiTi,serif; letter-spacing:-.03em; }.announcement-hero h1 em { color:#9bd0d2; font-style:normal; }.announcement-hero p:last-child { max-width:700px; color:rgba(255,255,255,.75); font-size:16px; line-height:1.8; }
+.announcement-hero dl { display:grid; grid-template-columns:repeat(3,110px); margin:0; border:1px solid rgba(255,255,255,.2); }.announcement-hero dl div { padding:20px; border-right:1px solid rgba(255,255,255,.2); }.announcement-hero dl div:last-child { border:0; }.announcement-hero dt { color:rgba(255,255,255,.6); font-size:12px; }.announcement-hero dd { margin:7px 0 0; font:700 30px Georgia,serif; }
+.announcement-index { position:sticky; top:72px; z-index:5; display:flex; justify-content:center; gap:4px; padding:12px; border-bottom:1px solid #dfe5ec; background:rgba(247,249,252,.94); backdrop-filter:blur(12px); }.announcement-index a { padding:10px 18px; border-radius:999px; color:#17375f; font-weight:700; text-decoration:none; }.announcement-index a:hover { color:#287486; background:#e3eef2; }
+.announcement-register { scroll-margin-top:130px; }.announcement-sheet { margin-top:20px; overflow:hidden; }.announcement-sheet > header { display:flex; align-items:center; justify-content:space-between; padding:22px 25px; border-bottom:1px solid #e6ebf1; background:linear-gradient(90deg,#fff,#f4f8fa); }.announcement-sheet > header span { color:#637386; font-size:13px; }.announcement-sheet > header h3 { margin:5px 0 0; font-size:20px; }.announcement-sheet > header > strong { color:#17375f; }
+.qualification-result { display:inline-flex; min-width:38px; justify-content:center; padding:4px 9px; border-radius:99px; color:#7b5b24; background:#fff5db; font-weight:700; }.qualification-result.eligible { color:#17665b; background:#e4f4ef; }.cutoff-score { color:#a75c18; font:700 20px Georgia,serif; }
+@media (max-width:760px) { .disclosure-entry,.announcement-hero { display:block; }.disclosure-entry button { margin-top:22px; }.announcement-hero dl { margin-top:28px; grid-template-columns:repeat(3,1fr); }.announcement-hero dl div { padding:14px 10px; }.announcement-index { justify-content:flex-start; overflow-x:auto; }.announcement-index a { white-space:nowrap; } }
+
+/* 招生控制台：用稳定的表单栅格替代浏览器默认控件排版 */
+.admission-settings-panel,.admission-account-panel,.admission-plan-console { overflow:hidden; }
+.admission-account-management { margin-bottom:16px; }.admission-account-management > form { grid-template-columns:minmax(240px,1fr) minmax(380px,1.4fr) minmax(220px,.8fr) auto; align-items:end; }.admission-account-management > form > .field-row { grid-template-columns:1fr 1fr; }.admission-account-management > form > .solid-button { min-width:170px; }.account-management-divider { display:flex; align-items:center; justify-content:space-between; padding:15px 24px; border-top:1px solid #e1e7ee; border-bottom:1px solid #e1e7ee; background:#f7f9fc; }.account-management-divider strong { color:#263a54; }.account-management-divider span { color:#8390a3; font-size:12px; }.admission-account-management .data-toolbar { padding-top:16px; padding-bottom:12px; }.admission-account-management table { min-width:980px; }
+.admission-settings-panel .panel-title,.admission-account-panel .panel-title,.admission-plan-console .panel-title { min-height:88px; height:auto; padding:20px 24px; background:linear-gradient(100deg,#fff,#f6f9fc); }
+.admission-settings-panel .panel-title h2,.admission-account-panel .panel-title h2,.admission-plan-console .panel-title h2 { font:400 23px/1.2 STKaiti,KaiTi,serif; }
+.admission-settings-panel .panel-title p,.admission-account-panel .panel-title p,.admission-plan-console .panel-title p { margin:7px 0 0; color:#69778c; font-size:13px; line-height:1.6; }
+.admission-settings-panel form,.admission-account-panel form,.admission-plan-console form { padding:22px 24px 24px; gap:17px; }
+.admission-settings-panel form label,.admission-account-panel form label,.admission-plan-console form > label { display:grid; align-content:start; gap:7px; min-width:0; color:#45546a; font-size:13px; font-weight:700; }
+.admission-settings-panel input,.admission-settings-panel select,.admission-account-panel input,.admission-account-panel select,.admission-plan-console form > label input,.admission-plan-console form > label select,.admission-plan-console form > label textarea { width:100%; min-height:44px; padding:9px 12px; border:1px solid #ccd6e2; border-radius:8px; color:#26364b; background:#fff; font-size:14px; }
+.admission-settings-panel input:focus,.admission-settings-panel select:focus,.admission-account-panel input:focus,.admission-account-panel select:focus,.admission-plan-console input:focus,.admission-plan-console select:focus { border-color:#287486; outline:3px solid rgba(40,116,134,.12); }
+.admission-settings-panel label small { color:#7d899a; font-size:12px; font-weight:400; line-height:1.5; }
+.admission-settings-panel .field-row,.admission-account-panel .field-row,.admission-plan-console > form > .field-row { gap:16px; }
+.admission-settings-panel .agreement,.admission-account-panel .agreement { display:flex; align-items:center; gap:10px; font-weight:500; }
+.admission-settings-panel .agreement input,.admission-account-panel .agreement input { width:18px; min-height:18px; }
+.admission-settings-panel form > .solid-button,.admission-account-panel form > .solid-button,.admission-plan-console form > .solid-button { justify-self:end; min-width:190px; min-height:44px; }
+.admission-control-actions { margin:0; padding:17px 24px; border-top:1px solid #e1e7ee; background:#f8fafc; }
+.admission-control-actions button { min-height:42px; }
+.admission-plan-console .admission-builder-head { margin-bottom:2px; }.admission-plan-console .admission-builder-head strong { font-size:16px; }.admission-plan-console .admission-builder-head small { font-size:12px; }
+.admission-plan-console .admission-category-fields label > span,.admission-plan-console .indicator-allocation-row label span { font-size:12px; }.admission-plan-console .admission-category-fields input,.admission-plan-console .admission-category-fields select,.admission-plan-console .indicator-allocation-row input,.admission-plan-console .indicator-allocation-row select { min-height:43px; font-size:14px; }
+
+/* 指标资格批处理 */
+.qualification-bulk-toolbar { display:flex; align-items:center; justify-content:space-between; gap:18px; margin:16px 24px; padding:14px 16px; border:1px solid #d8e2e9; border-radius:10px; background:#f6f9fb; }
+.qualification-bulk-toolbar > label { display:flex; align-items:center; gap:9px; color:#3d4e63; font-size:13px; font-weight:700; }.qualification-bulk-toolbar input[type="checkbox"] { width:17px; height:17px; }
+.qualification-bulk-toolbar > div { display:flex; align-items:center; gap:10px; }.qualification-bulk-toolbar strong { margin-right:4px; color:#287486; font-size:13px; }.qualification-bulk-toolbar select { min-width:210px; min-height:40px; padding:7px 10px; border:1px solid #cbd6df; border-radius:7px; background:#fff; }.qualification-bulk-toolbar .solid-button { min-height:40px; padding:8px 14px; }
+.qualification-ledger tbody td:first-child { width:52px; text-align:center; }.qualification-ledger [data-qualification-select] { width:17px; height:17px; }
+
+/* 管理员账户操作 */
+.admin-account-actions { display:flex; flex-wrap:wrap; gap:7px; }.row-action.danger { color:#a1463e; border-color:#e3bcb8; background:#fff8f7; }.row-action.danger:hover { color:#fff; background:#a94e45; }.admin-account-ledger td:last-child { min-width:180px; }
+
+/* 完整通知目录与正文页 */
+.notice-archive-link { grid-column:1/-1; justify-self:end; border:0; color:#245783; background:transparent; font-weight:700; cursor:pointer; }
+.notice-center-page,.notice-document-page { min-height:calc(100vh - 76px); padding-bottom:80px; background:#f3f6f9; }
+.notice-center-hero { display:flex; align-items:flex-end; justify-content:space-between; min-height:255px; padding:70px max(5vw,28px) 42px; color:#fff; background:linear-gradient(118deg,#132f52 0 62%,#20677a); }
+.notice-center-hero h1 { margin:8px 0 12px; font:400 clamp(40px,5vw,62px)/1 STKaiti,KaiTi,serif; }.notice-center-hero p:last-child { margin:0; color:rgba(255,255,255,.72); font-size:15px; }.notice-center-hero > strong { display:grid; justify-items:end; font:400 52px/1 Georgia,serif; }.notice-center-hero > strong small { margin-top:8px; color:#a9d9df; font:12px/1.2 system-ui,sans-serif; letter-spacing:.12em; }
+.notice-center-shell { width:min(1180px,calc(100% - 48px)); display:grid; grid-template-columns:210px minmax(0,1fr); gap:0; margin:38px auto 0; border:1px solid #dbe2ea; background:#fff; box-shadow:0 16px 44px rgba(22,46,75,.08); }
+.notice-category-nav { padding:24px 0; border-right:1px solid #e1e6ec; background:#f7f9fb; }.notice-category-nav button { width:100%; display:flex; justify-content:space-between; padding:13px 20px; border:0; border-left:3px solid transparent; color:#5f6d80; background:transparent; text-align:left; cursor:pointer; }.notice-category-nav button span { color:#9aa4b2; }.notice-category-nav button.active { border-left-color:#287486; color:#17375f; background:#eaf2f4; font-weight:700; }
+.notice-directory > header { display:flex; align-items:center; justify-content:space-between; min-height:72px; padding:0 28px; border-bottom:1px solid #e1e6ec; }.notice-directory > header div { display:flex; align-items:baseline; gap:13px; }.notice-directory > header strong { color:#17375f; font-size:18px; }.notice-directory > header span,.notice-directory > header small { color:#8894a4; font-size:12px; }
+.notice-directory-list > button { width:100%; display:grid; grid-template-columns:76px minmax(0,1fr) 24px; align-items:center; gap:20px; min-height:112px; padding:18px 28px; border:0; border-bottom:1px solid #e6eaf0; color:inherit; background:#fff; text-align:left; cursor:pointer; transition:background .16s,padding-left .16s; }.notice-directory-list > button:hover { padding-left:34px; background:#f7fafb; }.notice-directory-list time { display:grid; justify-items:center; padding-right:18px; border-right:1px solid #dce3e9; color:#8190a2; }.notice-directory-list time strong { color:#245783; font:400 27px Georgia,serif; }.notice-directory-list time span { margin-top:5px; font-size:11px; }
+.notice-directory-copy { display:grid; gap:6px; min-width:0; }.notice-directory-copy em { color:#287486; font-size:11px; font-style:normal; font-weight:700; letter-spacing:.08em; }.notice-directory-copy strong { color:#24354b; font-size:17px; }.notice-directory-copy small { overflow:hidden; color:#7d8998; font-size:13px; line-height:1.55; text-overflow:ellipsis; white-space:nowrap; }.notice-directory-arrow { color:#8092a6; }
+.notice-pagination { display:flex; justify-content:center; gap:7px; padding:22px; }.notice-pagination button { min-width:36px; height:36px; padding:0 10px; border:1px solid #d7dee7; color:#526176; background:#fff; cursor:pointer; }.notice-pagination button.active { border-color:#17375f; color:#fff; background:#17375f; }.notice-pagination button:disabled { opacity:.42; cursor:not-allowed; }
+.notice-breadcrumb { width:min(980px,calc(100% - 48px)); display:flex; gap:10px; margin:0 auto; padding:38px 0 18px; color:#8792a1; }.notice-breadcrumb button { border:0; color:#245783; background:transparent; cursor:pointer; }.notice-document { width:min(980px,calc(100% - 48px)); margin:0 auto; border-top:5px solid #245783; background:#fff; box-shadow:0 14px 42px rgba(22,46,75,.08); }.notice-document > header { padding:46px 56px 34px; border-bottom:1px solid #dfe5eb; }.notice-document > header span { color:#287486; font-size:12px; font-weight:700; letter-spacing:.1em; }.notice-document > header h1 { margin:15px 0 18px; color:#1e3047; font:400 clamp(30px,4vw,44px)/1.25 STKaiti,KaiTi,serif; }.notice-document > header p { margin:0; color:#8994a2; }.notice-document > section { padding:40px 56px 50px; }.notice-document > footer { padding:20px 56px; border-top:1px solid #e1e6ec; background:#f8fafb; }.notice-document-content { color:#334257; font-size:15px; line-height:1.9; }.document-lead { margin:0 0 25px; padding:14px 17px; border-left:3px solid #287486; color:#526176; background:#f2f7f8; line-height:1.7; }.notice-document table { font-size:13px; }
+@media (max-width:800px) { .admission-settings-panel form,.admission-account-panel form,.admission-plan-console form { padding:18px; }.admission-settings-panel form > .solid-button,.admission-account-panel form > .solid-button,.admission-plan-console form > .solid-button { width:100%; }.qualification-bulk-toolbar { align-items:stretch; flex-direction:column; }.qualification-bulk-toolbar > div { align-items:stretch; flex-direction:column; }.notice-center-shell { width:calc(100% - 28px); grid-template-columns:1fr; }.notice-category-nav { display:flex; overflow-x:auto; padding:8px; border-right:0; border-bottom:1px solid #e1e6ec; scrollbar-width:none; }.notice-category-nav::-webkit-scrollbar { display:none; }.notice-category-nav button { width:auto; min-width:max-content; border-left:0; border-bottom:3px solid transparent; }.notice-category-nav button.active { border-bottom-color:#287486; }.notice-directory-list > button { grid-template-columns:58px minmax(0,1fr) 18px; gap:12px; padding:15px; }.notice-directory-copy small { white-space:normal; }.notice-center-hero { display:block; }.notice-center-hero > strong { display:none; }.notice-document > header,.notice-document > section,.notice-document > footer { padding-left:22px; padding-right:22px; } }
+
+/* 审核工作台：以完整子页面承载资料、考试和处理结论 */
+body.review-subpage-open { overflow:hidden; }
+.review-subpage-layer { position:fixed; inset:0; z-index:120; overflow:auto; background:#eef2f6; animation:fadeIn .16s ease; }
+.review-subpage { min-height:100vh; color:#27364a; background:linear-gradient(90deg,#f8fafc 0 72%,#edf2f5 72%); }
+.review-subpage-header { min-height:190px; display:grid; grid-template-columns:minmax(190px,1fr) minmax(420px,2.2fr) minmax(140px,1fr); align-items:center; gap:28px; padding:34px clamp(28px,5vw,76px); color:#fff; background:linear-gradient(112deg,#132f52 0 62%,#216b79); box-shadow:0 12px 35px rgba(23,55,95,.16); }
+.review-back { justify-self:start; align-self:start; padding:10px 0; border:0; color:#c5dbe4; background:transparent; font-size:14px; font-weight:700; cursor:pointer; }
+.review-back:hover { color:#fff; }
+.review-subpage-header > div > span { color:#9bd0d6; font:700 12px/1.3 Consolas,monospace; letter-spacing:.16em; }
+.review-subpage-header h1 { margin:9px 0 12px; font:500 clamp(28px,3vw,42px)/1.18 STKaiti,KaiTi,serif; }
+.review-subpage-header p { display:flex; flex-wrap:wrap; align-items:center; gap:10px; margin:0; color:#d2dce7; font-size:14px; }
+.review-subpage-header p i { width:4px; height:4px; border-radius:50%; background:#7fa8b8; }
+.review-subpage-header > .status { justify-self:end; min-width:82px; justify-content:center; padding:9px 14px; font-size:13px; }
+.review-subpage-layout { width:min(1500px,100%); display:grid; grid-template-columns:minmax(0,1fr) 360px; gap:28px; margin:0 auto; padding:32px clamp(24px,4vw,58px) 70px; }
+.review-subpage-main { min-width:0; display:grid; align-content:start; gap:24px; }
+.review-section { overflow:hidden; border:1px solid #dbe3ea; border-radius:14px; background:#fff; box-shadow:0 9px 28px rgba(28,52,76,.05); }
+.review-section > header { min-height:86px; display:flex; align-items:center; gap:16px; padding:20px 24px; border-bottom:1px solid #e3e9ee; background:linear-gradient(90deg,#fff,#f6f9fa); }
+.review-section > header > span { min-width:45px; height:34px; display:grid; place-items:center; border-radius:6px; color:#fff; background:#245783; font:700 12px Consolas,monospace; }
+.review-section > header > div { min-width:0; margin-right:auto; }
+.review-section > header h2 { margin:0; color:#21364e; font-size:21px; }
+.review-section > header p { margin:5px 0 0; color:#748396; font-size:14px; }
+.review-section > header > strong { color:#287486; font-size:15px; }
+.review-detail-grid { display:grid; grid-template-columns:repeat(2,minmax(0,1fr)); gap:1px; margin:0; background:#e5eaef; }
+.review-detail-grid > div { min-width:0; padding:17px 20px; background:#fff; }
+.review-detail-grid > div.wide { grid-column:1/-1; }
+.review-detail-grid dt { margin-bottom:7px; color:#798799; font-size:13px; }
+.review-detail-grid dd { margin:0; overflow-wrap:anywhere; color:#293b51; font-size:15px; line-height:1.65; }
+.review-exam-list { display:grid; gap:14px; padding:20px 22px 24px; }
+.review-exam-card { overflow:hidden; border:1px solid #dfe6eb; border-radius:11px; background:#fbfcfd; }
+.review-exam-card > header { display:flex; align-items:center; justify-content:space-between; gap:20px; padding:16px 18px; border-bottom:1px solid #e4e9ed; background:#fff; }
+.review-exam-card h3 { margin:5px 0 0; font-size:18px; }
+.review-exam-card dl { display:grid; grid-template-columns:1fr 1fr; gap:0; margin:0; }
+.review-exam-card dl > div { padding:15px 18px; border-top:1px solid #e8edf0; }
+.review-exam-card dl > div:nth-child(-n+2) { border-top:0; }
+.review-exam-card dt { color:#7d8997; font-size:13px; }
+.review-exam-card dd { margin:6px 0 0; color:#33465a; font-size:14px; line-height:1.6; }
+.review-subject-list { display:flex; flex-wrap:wrap; gap:8px; }
+.review-subject-list > span { display:grid; gap:3px; padding:9px 11px; border:1px solid #d9e3e7; border-radius:8px; background:#fff; }
+.review-subject-list small { color:#738395; font-size:12px; }
+.review-empty-context { padding:25px; border:1px dashed #cdd8df; border-radius:10px; color:#67788b; background:#f7fafb; text-align:center; }
+.review-empty-context strong { color:#33485e; font-size:16px; }
+.review-empty-context p { margin:7px 0 0; font-size:14px; }
+.review-decision-form,.review-readonly { position:sticky; top:24px; align-self:start; display:grid; gap:18px; padding:24px; border-top:5px solid #287486; border-radius:12px; background:#fff; box-shadow:0 14px 38px rgba(26,52,76,.12); }
+.review-decision-form > div { display:grid; gap:5px; padding-bottom:18px; border-bottom:1px solid #e1e7eb; }
+.review-decision-form > div span,.review-decision-form label > span { color:#708093; font-size:13px; font-weight:700; }
+.review-decision-form > div strong { color:#1f3853; font-size:18px; }
+.review-decision-form > div small { color:#7e8a99; font-size:13px; }
+.review-decision-form label { display:grid; gap:7px; }
+.review-decision-form select,.review-decision-form textarea { width:100%; padding:11px 12px; border:1px solid #cbd6df; border-radius:8px; color:#293b50; background:#fff; font-size:14px; line-height:1.6; }
+.review-decision-form select:focus,.review-decision-form textarea:focus { border-color:#287486; outline:3px solid rgba(40,116,134,.12); }
+.review-decision-form .solid-button { min-height:46px; font-size:14px; }
+.review-readonly strong { color:#233c56; font-size:18px; }.review-readonly p { margin:0; color:#697b8e; font-size:14px; line-height:1.7; }
+.exam-context-hero { border-top:5px solid #245783; }
+.subject-review-section > footer { display:flex; align-items:baseline; justify-content:flex-end; gap:14px; padding:18px 24px; border-top:1px solid #e1e7eb; background:#f8fafb; }
+.subject-review-section > footer span { color:#6d7e91; font-size:14px; }.subject-review-section > footer strong { color:#17375f; font-size:24px; }
+.review-subject-cards { display:grid; grid-template-columns:repeat(2,minmax(0,1fr)); gap:13px; padding:20px 22px; }
+.review-subject-cards > article { display:grid; grid-template-columns:34px minmax(0,1fr) auto; align-items:center; gap:12px; padding:16px; border:1px solid #dbe4ea; border-radius:10px; background:#fff; }
+.review-subject-cards > article > i { width:32px; height:32px; display:grid; place-items:center; border-radius:50%; color:#fff; background:#287486; font-size:13px; font-style:normal; }
+.review-subject-cards > article > div { display:grid; gap:4px; min-width:0; }.review-subject-cards > article > div strong { font-size:16px; }.review-subject-cards > article > div span { color:#718194; font-size:13px; }
+.review-subject-cards dl { display:flex; gap:16px; margin:0; }.review-subject-cards dl div { display:grid; gap:4px; }.review-subject-cards dt { color:#8290a0; font-size:12px; }.review-subject-cards dd { margin:0; font-size:14px; font-weight:700; }
+
+/* 高频台账筛选与批量操作 */
+.candidate-toolbar { flex-wrap:wrap; }.table-filter-selects.five-columns { grid-template-columns:repeat(5,minmax(120px,1fr)); }
+.candidate-exam-summary { min-width:190px; }.candidate-exam-summary strong,.candidate-exam-summary small { display:block; }.candidate-exam-summary span { color:#8793a2; }
+.registration-exam-cell { min-width:220px; }.subject-summary { display:flex; flex-wrap:wrap; gap:5px; margin:7px 0 4px; }.subject-summary span { padding:4px 7px; border-radius:5px; color:#36576e; background:#e9f1f4; font-size:12px; font-weight:700; }.subject-summary em { color:#a14c43; font-style:normal; }
+.qualification-filter-toolbar { flex-wrap:wrap; margin-top:14px; border-top:1px solid #e4e9ed; }.qualification-specialty-filter { flex:1 0 100%; display:flex; gap:9px; }.qualification-specialty-filter select { flex:1; min-height:40px; padding:8px 11px; border:1px solid #ccd7df; border-radius:7px; color:#45576b; background:#fff; font-size:14px; }.qualification-specialty-filter .row-action { padding:0 12px; border:1px solid #d6dfe5; border-radius:7px; background:#fff; }
+.workflow-filter-toolbar { flex-wrap:wrap; margin-bottom:16px; }.workflow-type-filter { flex:1 0 100%; }.workflow-type-filter select { width:100%; min-height:40px; padding:8px 11px; border:1px solid #ccd7df; border-radius:7px; color:#45576b; background:#fff; font-size:14px; }
+
+/* 全站可读性下限：正文 14px，辅助信息不低于 12px */
+.admin-readable .portal-sidebar nav button { font-size:14px; }.admin-readable .portal-sidebar nav button em { font-size:12px; }
+.admin-readable .portal-topbar > div:first-of-type,.admin-readable .portal-user > span strong { font-size:14px; }
+.admin-readable .portal-user > span small,.admin-readable .sidebar-help span,.admin-readable .sidebar-help small { font-size:12px; }
+.admin-readable .portal-content :where(p,time,dt,dd,label > span,th,td,button,input,select,textarea,em) { font-size:14px !important; line-height:1.55; }
+.admin-readable .portal-content small { font-size:12px !important; line-height:1.55; }
+.admin-readable .portal-content span:not(:has(svg)):not(.status):not(.user-avatar) { font-size:14px !important; }
+.admin-readable .portal-content :where(td strong,button strong,p strong) { font-size:14px !important; }
+.admin-readable .portal-content .status,.admin-readable .portal-content .overline,.admin-readable .portal-content .exam-code { font-size:12px !important; }
+.admin-readable .portal-content :where(.solid-button,.ghost-button,.row-action) { min-height:38px; }
+.portal-content :where(p,time,dt,dd,label > span,th,td,button,input,select,textarea,em) { font-size:14px !important; line-height:1.55; }
+.portal-content small { font-size:12px !important; line-height:1.55; }.portal-content span:not(:has(svg)):not(.status):not(.user-avatar) { font-size:14px !important; }.portal-content .status,.portal-content .overline,.portal-content .exam-code { font-size:12px !important; }
+.portal-sidebar nav button { font-size:14px; }.portal-sidebar nav button em,.portal-user small,.sidebar-help small { font-size:12px; }.portal-topbar button { font-size:13px; }
+.auth-page :where(p,label > span,button,input,select,textarea) { font-size:14px; line-height:1.65; }.auth-page span:not(:has(svg)) { font-size:14px; }.auth-page small { font-size:12px; }
+.onboarding-page :where(p,label > span,button,input,select,textarea) { font-size:14px; line-height:1.65; }.onboarding-page span:not(:has(svg)) { font-size:14px; }.onboarding-page small { font-size:12px; }
+.modal-card :where(p,dt,dd,label > span,button,input,select,textarea,li) { font-size:14px; line-height:1.65; }.modal-card span:not(:has(svg)) { font-size:14px; }.modal-card small,.modal-head span { font-size:12px; }
+.public-footer p,.public-footer > span { font-size:13px; line-height:1.65; }
+.notice-document table th,.notice-document table td { padding:15px 17px; font-size:15px; line-height:1.55; }
+.notice-document .document-lead { font-size:15px; }.notice-document .qualification-result { min-width:46px; padding:6px 11px; font-size:14px; }
+.public-main :where(button,input,select,textarea) { font-size:14px; }.public-main :where(p,dt,dd) { font-size:14px; line-height:1.7; }.public-main span:not(:has(svg)):not(.status) { font-size:14px; }.public-main small { font-size:12px; line-height:1.55; }
+
+@media (max-width:1000px) {
+  .review-subpage { background:#f4f7f9; }.review-subpage-header { grid-template-columns:1fr auto; min-height:0; }.review-subpage-header > div { grid-column:1/-1; grid-row:2; }.review-subpage-header > .status { grid-column:2; grid-row:1; }.review-subpage-layout { grid-template-columns:1fr; }.review-decision-form,.review-readonly { position:static; }.table-filter-selects.five-columns { grid-template-columns:repeat(2,minmax(130px,1fr)); }
+}
+@media (max-width:650px) {
+  .review-subpage-header { padding:24px 20px; }.review-subpage-layout { padding:20px 14px 45px; }.review-detail-grid,.review-exam-card dl { grid-template-columns:1fr; }.review-detail-grid > div.wide { grid-column:auto; }.review-exam-card dl > div:nth-child(2) { border-top:1px solid #e8edf0; }.review-subject-cards { grid-template-columns:1fr; padding:14px; }.review-subject-cards > article { grid-template-columns:32px minmax(0,1fr); }.review-subject-cards dl { grid-column:2; }.qualification-specialty-filter { flex-direction:column; }.table-filter-selects.five-columns { grid-template-columns:1fr; }
+}
+@media (max-width:1000px) {
+  .result-workbench-head,.feature-score-workbench > form > header { grid-template-columns:1fr; }.result-workbench-summary { grid-template-columns:repeat(4,1fr); }.result-workbench-summary p { grid-column:1/-1; justify-self:start; padding:8px 0 0; }.feature-score-rule { min-width:0; }
+}
+@media (max-width:650px) {
+  .result-workbench-selectors,.result-workbench-summary { grid-template-columns:1fr; }.result-workbench-summary > span { padding:6px 0; border-right:0; border-bottom:1px solid #e2e8f0; }.result-workbench-actions { align-items:stretch; flex-direction:column; }.result-workbench-actions > div { margin:0 0 5px; }.result-workbench-actions button { width:100%; }
+}
+@media (max-width:1100px) {
+  .admission-account-management > form { grid-template-columns:1fr 1fr; }.admission-account-management > form > .solid-button { width:100%; }
+}
+@media (max-width:800px) {
+  .admission-account-management > form { grid-template-columns:1fr; }.placement-bulk-toolbar,.placement-bulk-toolbar > div { align-items:stretch; flex-direction:column; }.placement-bulk-toolbar button { width:100%; }.placement-status-pills,.account-status-pills { margin-right:18px; margin-left:18px; }
+}
+.table-pagination {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 16px;
+  padding: 16px 18px;
+  border-top: 1px solid var(--line, #e5e7eb);
+  color: var(--muted, #64748b);
+  font-size: 13px;
+}
+
+.table-pagination > div {
+  display: flex;
+  align-items: center;
+  flex-wrap: wrap;
+  gap: 6px;
+}
+
+.table-pagination button,
+.table-pagination select {
+  min-width: 34px;
+  height: 34px;
+  padding: 0 10px;
+  border: 1px solid var(--line, #dbe2ea);
+  border-radius: 8px;
+  background: #fff;
+  color: inherit;
+  font: inherit;
+}
+
+.table-pagination button:not(:disabled) { cursor: pointer; }
+.table-pagination button:hover:not(:disabled) { border-color: #1f6f5f; color: #1f6f5f; }
+.table-pagination button.active { border-color: #1f6f5f; background: #1f6f5f; color: #fff; }
+.table-pagination button:disabled { opacity: .45; }
+.table-pagination label { display: inline-flex; align-items: center; gap: 6px; margin-left: 6px; }
+.table-pagination i { font-style: normal; padding: 0 2px; }
+
+@media (max-width: 720px) {
+  .table-pagination { align-items: flex-start; flex-direction: column; }
+}

tests/admission.test.mjs

@@ -0,0 +1,91 @@
+import assert from 'node:assert/strict';
+import { admissionCutoffRows, buildVolunteerPlacements, candidateAdmissionScore, candidateTotalScore, publicAdmissionRows, remainingPlanQuota, sourceSchoolQualificationStatus } from '../src/services/volunteer-admission.mjs';
+import { candidateEligibleForCategory, specialtyLabel } from '../src/data/specialty-types.mjs';
+
+const now = '2026-07-21T08:00:00.000Z';
+let sequence = 0;
+const db = {
+  users: [
+    { id: 'u-high', role: 'candidate', active: true, candidateNumber: '20260001', displayName: '高分考生' },
+    { id: 'u-low', role: 'candidate', active: true, candidateNumber: '20260002', displayName: '次高考生' },
+    { id: 'u-sport', role: 'candidate', active: true, candidateNumber: '20260003', displayName: '特长考生' }
+  ],
+  candidateProfiles: [
+    { userId: 'u-high', name: '高分考生', schoolId: 'source-a', profileCompleted: true, idNumber: '320101200901011234', phone: '13812345678', specialtyTypes: [] },
+    { userId: 'u-low', name: '次高考生', schoolId: 'source-b', profileCompleted: true, idNumber: '320101200902021234', phone: '13912345678', specialtyTypes: [] },
+    { userId: 'u-sport', name: '特长考生', schoolId: 'source-b', profileCompleted: true, idNumber: '320101200903031234', phone: '13712345678', specialtyCategory: 'sports', specialtyType: 'track_field', specialtyTypes: ['track_field'] }
+  ],
+  schools: [
+    { id: 'source-a', name: '生源学校 A' }, { id: 'source-b', name: '生源学校 B' },
+    { id: 'target-a', name: '第一中学' }, { id: 'target-b', name: '第二中学' }
+  ],
+  registrations: [
+    { id: 'r-high', examId: 'exam', userId: 'u-high', status: 'approved', subjectIds: ['cn', 'math'] },
+    { id: 'r-low', examId: 'exam', userId: 'u-low', status: 'approved', subjectIds: ['cn', 'math'] },
+    { id: 'r-sport', examId: 'exam', userId: 'u-sport', status: 'approved', subjectIds: ['cn', 'math'], featureScore: 88.5 }
+  ],
+  results: [
+    { registrationId: 'r-high', subjectId: 'cn', score: 120, published: true }, { registrationId: 'r-high', subjectId: 'math', score: 130, published: true },
+    { registrationId: 'r-low', subjectId: 'cn', score: 118, published: true }, { registrationId: 'r-low', subjectId: 'math', score: 126, published: true },
+    { registrationId: 'r-sport', subjectId: 'cn', score: 105, published: true }, { registrationId: 'r-sport', subjectId: 'math', score: 110, published: true }
+  ],
+  admissionRecords: [
+    { id: 'plan-a', kind: 'plan', examId: 'exam', schoolId: 'target-a', status: 'approved', payload: { categories: [{ code: 'general', name: '普通生', quota: 1, specialtyType: '', indicatorAllocations: [] }] } },
+    { id: 'plan-b', kind: 'plan', examId: 'exam', schoolId: 'target-b', status: 'approved', payload: { categories: [
+      { code: 'general', name: '普通生', quota: 1, specialtyType: '', indicatorAllocations: [] },
+      { code: 'sport', name: '田径特长生', quota: 1, specialtyCategory: 'sports', specialtyType: 'track_field', indicatorAllocations: [{ sourceSchoolId: 'source-b', quota: 1 }] }
+    ] } },
+    { id: 'qual-low', kind: 'indicator_qualification', examId: 'exam', userId: 'u-low', schoolId: 'source-b', status: 'confirmed', payload: { eligible: false } },
+    { id: 'qual-sport', kind: 'indicator_qualification', examId: 'exam', userId: 'u-sport', schoolId: 'source-b', status: 'confirmed', payload: { eligible: true } },
+    { id: 'pref-high', kind: 'preference', examId: 'exam', userId: 'u-high', status: 'submitted', payload: { round: 1, choices: [{ schoolId: 'target-b', categoryCode: 'general', preferenceType: 'general' }, { schoolId: 'target-a', categoryCode: 'general', preferenceType: 'general' }] } },
+    { id: 'pref-low', kind: 'preference', examId: 'exam', userId: 'u-low', status: 'submitted', payload: { round: 1, choices: [{ schoolId: 'target-b', categoryCode: 'general', preferenceType: 'general' }, { schoolId: 'target-a', categoryCode: 'general', preferenceType: 'general' }] } },
+    { id: 'pref-sport', kind: 'preference', examId: 'exam', userId: 'u-sport', status: 'submitted', payload: { round: 1, choices: [{ schoolId: 'target-b', categoryCode: 'sport', preferenceType: 'indicator' }] } }
+  ]
+};
+
+const setting = { examId: 'exam', payload: { round: 1 } };
+const placements = buildVolunteerPlacements(db, setting, { uid: prefix => `${prefix}-${++sequence}`, nowIso: () => now });
+assert.equal(candidateTotalScore(db, 'exam', 'u-high'), 250, '投档总分应取当次全部已发布科目之和');
+assert.equal(candidateAdmissionScore(db, 'exam', 'u-sport', { code: 'general' }), 215, '普通招生类别不得加入特征分');
+assert.equal(candidateAdmissionScore(db, 'exam', 'u-sport', { specialtyCategory: 'sports', specialtyType: 'track_field' }), 303.5, '特长生招生类别应使用文化课总分加特征分');
+assert.equal(placements.length, 3, '三个符合条件且计划充足的考生都应投档');
+assert.equal(placements.find(item => item.userId === 'u-high').schoolId, 'target-b', '最高分考生应优先满足第一志愿');
+assert.equal(placements.find(item => item.userId === 'u-low').schoolId, 'target-a', '第一志愿已满时应继续遵循下一志愿');
+assert.equal(placements.find(item => item.userId === 'u-sport').payload.quotaBucket, 'indicator:source-b', '特长生指标应使用对应生源学校指标名额');
+assert.equal(placements.find(item => item.userId === 'u-sport').payload.featureScore, 88.5, '特征分应随投档材料发送');
+assert.equal(placements.find(item => item.userId === 'u-sport').payload.culturalScore, 215, '特长生投档材料应保留文化课原始总分');
+assert.equal(placements.find(item => item.userId === 'u-sport').payload.totalScore, 303.5, '特长生类别投档总分应加入特征分');
+assert.equal(specialtyLabel('sports', 'track_field'), '体育·田径', '特长资格应显示大类和小类');
+assert.equal(candidateEligibleForCategory(db.candidateProfiles[2], { specialtyCategory: 'arts', specialtyType: 'fine_arts' }), false, '体育资格考生不得填报艺术类计划');
+
+const specialtyPriorityDb = structuredClone(db);
+specialtyPriorityDb.users.push({ id: 'u-sport-rival', role: 'candidate', active: true, candidateNumber: '20260004', displayName: '特长竞争考生' });
+specialtyPriorityDb.candidateProfiles.push({ userId: 'u-sport-rival', name: '特长竞争考生', schoolId: 'source-b', profileCompleted: true, specialtyCategory: 'sports', specialtyType: 'track_field', specialtyTypes: ['track_field'] });
+specialtyPriorityDb.registrations.push({ id: 'r-sport-rival', examId: 'exam', userId: 'u-sport-rival', status: 'approved', subjectIds: ['cn', 'math'], featureScore: 0 });
+specialtyPriorityDb.results.push({ registrationId: 'r-sport-rival', subjectId: 'cn', score: 125, published: true }, { registrationId: 'r-sport-rival', subjectId: 'math', score: 125, published: true });
+specialtyPriorityDb.admissionRecords.push(
+  { id: 'qual-sport-rival', kind: 'indicator_qualification', examId: 'exam', userId: 'u-sport-rival', schoolId: 'source-b', status: 'confirmed', payload: { eligible: true } },
+  { id: 'pref-sport-rival', kind: 'preference', examId: 'exam', userId: 'u-sport-rival', status: 'submitted', payload: { round: 1, choices: [{ schoolId: 'target-b', categoryCode: 'sport', preferenceType: 'indicator' }] } }
+);
+const specialtyPriorityPlacements = buildVolunteerPlacements(specialtyPriorityDb, setting, { uid: prefix => `${prefix}-priority-${++sequence}`, nowIso: () => now });
+assert.equal(specialtyPriorityPlacements.find(item => item.payload.categoryCode === 'sport').userId, 'u-sport', '特长类别应按文化课加特征分排序，而不是只按文化课排序');
+
+db.admissionRecords.push(...placements.map(item => ({ ...item, status: 'final' })));
+const remaining = remainingPlanQuota(db, db.admissionRecords.find(item => item.id === 'plan-b'));
+assert.equal(remaining.find(item => item.code === 'general').remaining, 0, '普通生计划占用应准确统计');
+assert.equal(remaining.find(item => item.code === 'sport').remaining, 0, '特长生计划占用应准确统计');
+const publicRows = publicAdmissionRows(db, 'exam');
+const highPublicRow = publicRows.find(item => item.registrationNumber === '20260001');
+assert.equal(highPublicRow.registrationNumber, '20260001', '公示必须公开报名号');
+assert.equal(highPublicRow.name, '高分考生', '公示必须公开姓名');
+assert.equal(highPublicRow.totalScore, 250, '普通类别公示总成绩不得加入特征分');
+assert.equal(highPublicRow.admittedSchool, '第二中学', '公示必须公开录取学校');
+assert.ok(highPublicRow.idNumberMasked.includes('*') && !highPublicRow.idNumberMasked.includes('20090101'), '重要身份信息必须脱敏');
+assert.equal(publicRows.find(item => item.registrationNumber === '20260003').totalScore, 303.5, '特长生类别公示总成绩应包含特征分');
+const cutoffs = admissionCutoffRows(db, 'exam');
+assert.equal(cutoffs.find(item => item.schoolId === 'target-b' && item.categoryCode === 'general').cutoffScore, 250, '录取分数线应取学校招生类别最终录取最低总分');
+const qualificationStatus = sourceSchoolQualificationStatus(db, 'exam', 'source-b');
+assert.equal(qualificationStatus.complete, true, '生源校全部考生确认后应达到自动公示条件');
+assert.equal(qualificationStatus.rows.find(item => item.userId === 'u-sport').specialtyLabel, '体育·田径', '资格公示应包含对应特长类型');
+
+console.log('志愿投档、指标名额与脱敏公示测试通过');

tests/client-auth.test.mjs

@@ -0,0 +1,57 @@
+import assert from 'node:assert/strict';
+import { createAdminViews } from '../src/client/admin-views.mjs';
+import { createAdmissionViews } from '../src/client/admission-views.mjs';
+import { api } from '../src/client/api.mjs';
+import { createCandidateViews } from '../src/client/candidate-views.mjs';
+import { createPublicViews } from '../src/client/public-views.mjs';
+
+function protectedViewContext() {
+  let loginRequests = 0;
+  const context = {
+    state: { user: null },
+    app: { classList: { add() {}, remove() {} } },
+    requireLogin() { loginRequests += 1; }
+  };
+  return { context, loginRequests: () => loginRequests };
+}
+
+for (const createView of [createAdminViews, createCandidateViews, createAdmissionViews]) {
+  const fixture = protectedViewContext();
+  const views = createView(fixture.context);
+  const render = views.renderAdmin || views.renderCandidate || views.renderAdmission;
+  await render('dashboard');
+  assert.equal(fixture.loginRequests(), 1, '未登录访问受保护视图时应交给统一登录处理');
+}
+
+{
+  const app = { classList: { remove() {} }, innerHTML: '' };
+  const state = {
+    user: null,
+    authNotice: '登录状态已失效，请重新登录。',
+    publicData: { selfRegistrationEnabled: false }
+  };
+  const { renderAuth } = createPublicViews({
+    state,
+    app,
+    h: value => String(value ?? ''),
+    icons: { arrow: '', menu: '' }
+  });
+  renderAuth('login');
+  assert.match(app.innerHTML, /需要重新登录/);
+  assert.match(app.innerHTML, /登录状态已失效，请重新登录/);
+}
+
+{
+  const originalFetch = globalThis.fetch;
+  globalThis.fetch = async () => new Response(JSON.stringify({ message: '请先登录' }), {
+    status: 401,
+    headers: { 'content-type': 'application/json' }
+  });
+  try {
+    await assert.rejects(() => api('/api/protected'), error => error.status === 401 && error.message === '请先登录');
+  } finally {
+    globalThis.fetch = originalFetch;
+  }
+}
+
+console.log('客户端登录失效处理测试通过');

tests/seed.test.mjs

@@ -0,0 +1,38 @@
+import assert from 'node:assert/strict';
+import { createSeedDatabase } from '../src/data/seed.mjs';
+
+const state = createSeedDatabase({ nowIso: () => '2026-07-21T00:00:00.000Z', hashPassword: password => `test-${password}` });
+const mainExam = state.exams.find(exam => exam.id === 'exam_autumn_2026');
+const mainRegistrations = state.registrations.filter(registration => registration.examId === mainExam.id);
+const mainRegistrationIds = new Set(mainRegistrations.map(registration => registration.id));
+const mainResults = state.results.filter(result => mainRegistrationIds.has(result.registrationId));
+const mainPreferences = state.admissionRecords.filter(record => record.kind === 'preference' && record.examId === mainExam.id && Number(record.payload?.round || 1) === 1);
+const specialtyProfiles = state.candidateProfiles.filter(profile => profile.specialtyCategory && profile.specialtyType);
+const specialtyUserIds = new Set(specialtyProfiles.map(profile => profile.userId));
+
+assert.ok(state.exams.length >= 2, '演示数据至少包含两场考试');
+assert.equal(state.schools.filter(school => school.isSourceSchool).length, 5, '演示数据应包含 5 所生源校');
+assert.equal(state.schools.filter(school => school.isAdmissionSchool).length, 3, '演示数据应包含 3 所招生校');
+assert.deepEqual(Object.fromEntries(mainExam.subjects.map(subject => [subject.name, subject.fullScore])), {
+  语文: 120, 数学: 120, 外语: 120, 历史: 75, 政治: 75, 物理: 80, 化学: 70, 实验: 20, 信息技术: 10
+});
+assert.equal(mainRegistrations.length, 1200, '主考试应有 1200 名考生');
+assert.ok(mainRegistrations.every(registration => registration.status === 'approved' && registration.subjectIds.length === 9), '主考试报名应全部审核通过并包含 9 科');
+assert.equal(mainResults.length, 1200 * 9, '每名主考试考生都应有完整的 9 科成绩');
+assert.ok(mainResults.every(result => result.published), '主考试成绩应全部发布');
+assert.equal(mainPreferences.length, 1200, '主考试每名考生都应完成第一轮志愿');
+assert.ok(mainPreferences.every(record => record.status === 'submitted' && record.payload.submissionCount === 1 && record.payload.choices.length === 3), '第一轮志愿应提交并填满 3 个招生校');
+assert.equal(specialtyProfiles.length, 150, '应有 150 名特长生');
+assert.ok(mainRegistrations.filter(registration => specialtyUserIds.has(registration.userId)).every(registration => registration.featureScore >= 80 && registration.featureScore <= 100), '特长生特征分应分布在 80-100 分');
+assert.deepEqual(new Set(state.users.map(user => user.passwordHash)), new Set(['test-12345678']), '所有预置账号密码应统一为 12345678');
+
+for (const subject of mainExam.subjects) {
+  const scores = mainResults.filter(result => result.subjectId === subject.id).map(result => result.score);
+  const mean = scores.reduce((sum, score) => sum + score, 0) / scores.length;
+  const standardDeviation = Math.sqrt(scores.reduce((sum, score) => sum + (score - mean) ** 2, 0) / scores.length);
+  assert.ok(mean > subject.fullScore * 0.66 && mean < subject.fullScore * 0.78, `${subject.name}平均分应符合正态样本预期`);
+  assert.ok(standardDeviation > subject.fullScore * 0.09 && standardDeviation < subject.fullScore * 0.18, `${subject.name}标准差应符合正态样本预期`);
+  assert.ok(scores.every(score => score >= 0 && score <= subject.fullScore), `${subject.name}成绩不得超出满分`);
+}
+
+console.log('演示数据规模、学校角色、科目、志愿、特长生、成绩分布与密码校验通过');

tests/system.test.mjs

@@ -2,18 +2,27 @@ import { spawn } from 'node:child_process';
 import { pbkdf2Sync, randomBytes } from 'node:crypto';
 import { readFile, rm } from 'node:fs/promises';
 import { resolve } from 'node:path';
+import { createServer as createNetServer } from 'node:net';
 import assert from 'node:assert/strict';
 import ExcelJS from 'exceljs';
 import { createDatabase, relationalTables } from '../database.mjs';
 import { createBaseDatabase } from '../src/data/base.mjs';
 import { createSeedDatabase } from '../src/data/seed.mjs';
 import { mysqlSchema } from '../src/database/schema.mjs';
+import { CURRENT_SCHEMA_VERSION } from '../src/database/version.mjs';
 import { totpAtStep } from '../src/security/totp.mjs';
 import { buildCenterMaterialsWorkbook, buildWorkbook } from '../excel.mjs';
 
 const root = resolve(process.cwd());
 assert.equal(totpAtStep('GEZDGNBVGY3TQOJQGEZDGNBVGY3TQOJQ', 1), '287082', 'TOTP 实现应符合 RFC 6238 SHA-1 测试向量的 6 位结果');
-const port = 4182;
+const port = await new Promise((resolvePort, rejectPort) => {
+  const probe = createNetServer();
+  probe.once('error', rejectPort);
+  probe.listen(0, '127.0.0.1', () => {
+    const selectedPort = probe.address().port;
+    probe.close(error => error ? rejectPort(error) : resolvePort(selectedPort));
+  });
+});
 const baseUrl = `http://127.0.0.1:${port}`;
 const testDb = resolve(root, 'data', 'test-db.sqlite');
 const mysqlRuleSchemas = mysqlSchema.filter(statement => /CREATE TABLE IF NOT EXISTS (?:admission_number_rules|number_rules)\b/.test(statement));
@@ -39,7 +48,7 @@ assert.doesNotMatch(mysqlAdapterSource, /ADD\s+COLUMN\s+IF\s+NOT\s+EXISTS/i, 'My
 assert.match(mysqlAdapterSource, /for \(const statement of mysqlSchema\) await pool\.query\(statement\)/, 'MySQL DDL 应使用文本协议执行');
 assert.match(mysqlAdapterSource, /existingResultLockTriggers\.has\(name\)\) await pool\.query\(statement\)/, 'MySQL 触发器不得通过预处理协议创建');
 assert.doesNotMatch(mysqlAdapterSource, /\.execute\(\s*['"`]\s*(?:CREATE|ALTER|DROP|SHOW)\b/i, 'MySQL DDL 和 SHOW 语句不得通过预处理协议执行');
-assert.match(mysqlAdapterSource, /existingAppTables\.length && \(!hasSchemaMetadata \|\| !\[15, 16, 17\]\.includes\(existingSchemaVersion\)\)/, 'MySQL 应保留可迁移的 v15-v17 结构并重建更旧或未完成的开发结构');
+assert.match(mysqlAdapterSource, /existingAppTables\.length && \(!hasSchemaMetadata \|\| !\[15, 16, 17, 18, 19, 20\]\.includes\(existingSchemaVersion\)\)/, 'MySQL 应保留可迁移的 v15-v20 结构并重建更旧或未完成的开发结构');
 assert.match(mysqlAdapterSource, /\[\.\.\.mysqlTableNames\]\.reverse\(\)/, 'MySQL 半成品表应按外键依赖逆序清理');
 const serverSource = await readFile(resolve(root, 'server.mjs'), 'utf8');
 assert.doesNotMatch(serverSource, /src\/data\/seed\.mjs|createSeedDatabase/, '服务启动不得引用测试数据生成器');
@@ -52,7 +61,12 @@ assert.match(testDataImportSource, /SET FOREIGN_KEY_CHECKS = 0/, 'MySQL 样例
 assert.match(testDataImportSource, /beginTransaction\(\).*buildSeedOperations\(state\).*commit\(\)/s, 'MySQL 样例数据应在同一事务内清理并写入');
 assert.match(testDataImportSource, /initializeEmpty.*createBaseDatabase/s, '测试结束后应支持恢复空业务系统');
 assert.match(testDataImportSource, /recognizedTestData/, 'MySQL 初始化系统时应识别样例数据并保护非样例业务库');
+assert.match(testDataImportSource, /CURRENT_SCHEMA_VERSION/, '数据库导入脚本应复用统一的当前结构版本');
+const resetDatabaseSource = await readFile(resolve(root, 'scripts', 'reset-dev-database.mjs'), 'utf8');
+assert.match(resetDatabaseSource, /import\(['"]\.\/import-test-data\.mjs['"]\)/, '重置入口应复用统一的数据库初始化流程');
+assert.doesNotMatch(resetDatabaseSource, /DATABASE_CLIENT\s*=\s*['"]sqlite['"]/, '重置入口不得再强制使用 SQLite');
 const baseState = createBaseDatabase({ nowIso: () => new Date().toISOString(), hashPassword: password => `test-${password}` });
+assert.equal(baseState.meta.version, CURRENT_SCHEMA_VERSION, '空库初始状态必须使用当前结构版本');
 assert.equal(baseState.schools.length, 0, '正常首次建库不得预置学校');
 assert.equal(baseState.candidateProfiles.length, 0, '正常首次建库不得预置考生');
 assert.equal(baseState.exams.length, 0, '正常首次建库不得预置考试');
@@ -75,7 +89,8 @@ process.env.SQLITE_PATH = testDb;
 const seededTestDatabase = await createDatabase({
   root,
   seed: () => {
-    const state = createSeedDatabase({ nowIso: () => new Date().toISOString(), hashPassword });
+    // 全量 1200 人规模由 seed.test.mjs 单独验证；端到端流程使用较小样本控制运行时间。
+    const state = createSeedDatabase({ nowIso: () => new Date().toISOString(), hashPassword, candidateCount: 360 });
     const currentSuperAdmin = state.users.find(user => user.role === 'admin' && user.adminLevel === 'super');
     state.users.push({
       ...currentSuperAdmin,
@@ -137,6 +152,7 @@ const classAdmin2 = createClient();
 const candidate = createClient();
 const selfCandidate = createClient();
 const batchCandidate = createClient();
+const admissionSchoolClient = createClient();
 const anonymous = createClient();
 
 try {
@@ -147,6 +163,7 @@ try {
   const clientSources = await Promise.all([
     'app.js',
     'src/client/admin-views.mjs',
+    'src/client/admission-views.mjs',
     'src/client/candidate-views.mjs',
     'src/client/public-views.mjs'
   ].map(file => readFile(resolve(root, file), 'utf8')));
@@ -161,6 +178,9 @@ try {
   assert.match(appSource, /data-action="edit-exam"/, '考试草稿应提供编辑入口');
   assert.match(appSource, /data-action="archive-exam"/, '超级管理员界面应提供不可逆考试归档入口');
   assert.match(appSource, /data-action="refresh-results-cache"/, '成绩管理中心应提供 Redis 成绩缓存刷新入口');
+  assert.match(appSource, /data-action="bulk-placement-review"/, '招生学校投档审核应提供批量处理入口');
+  assert.match(appSource, /data-action="toggle-admission-account"/, '超级管理员应有招生学校账户启停入口');
+  assert.match(appSource, /data-action="reset-admission-account-password"/, '超级管理员应有招生学校账户密码重置入口');
   assert.match(appSource, /归档不可撤销/, '归档前应明确提示成绩将永久锁定');
 
   const { DatabaseSync } = await import('node:sqlite');
@@ -177,6 +197,8 @@ try {
   const examSubjectColumns = inspector.prepare('PRAGMA table_info(exam_subjects)').all().map(row => row.name);
   const examColumns = inspector.prepare('PRAGMA table_info(exams)').all().map(row => row.name);
   const userColumns = inspector.prepare('PRAGMA table_info(users)').all().map(row => row.name);
+  const schoolColumns = inspector.prepare('PRAGMA table_info(schools)').all().map(row => row.name);
+  const profileColumns = inspector.prepare('PRAGMA table_info(candidate_profiles)').all().map(row => row.name);
   const registrationColumns = inspector.prepare('PRAGMA table_info(registrations)').all().map(row => row.name);
   const seededSchoolCount = inspector.prepare('SELECT COUNT(*) AS count FROM schools').get().count;
   const seededExamCount = inspector.prepare('SELECT COUNT(*) AS count FROM exams').get().count;
@@ -221,7 +243,7 @@ try {
   inspector.close();
   assert.ok(relationalTables.every(table => tableNames.includes(table)), '所有关系模型总表与分表登记表都必须存在');
   assert.ok(!tableNames.includes('app_state'), '不得使用单表 JSON 状态存储');
-  assert.equal(schemaVersion, 17, 'TOTP 账户安全应使用 v17 数据结构');
+  assert.equal(schemaVersion, 20, '指标资格、资格公示与分数线公告应使用 v20 数据结构');
   assert.ok(examPartitions.length > 0, '每场考试都应登记一组专属物理表');
   assert.equal(examPartitions.length, seededExamCount, '考试分表登记不得缺漏');
   assert.ok(examPartitionCoverage.every(item => item.candidates === item.expectedCandidates && item.admissions === item.expectedAdmissions && item.results === item.expectedResults), '考试专属表应与该场考试的考生、准考信息和成绩数据一致');
@@ -232,7 +254,10 @@ try {
   assert.equal(resultLockTriggers.length, 3, '数据库应从插入、更新、删除三个方向永久锁定归档成绩');
   assert.ok(['archived_at', 'archived_by'].every(column => userColumns.includes(column)), '账户应保存独立归档状态和校方操作人');
   assert.ok(['totp_enabled', 'totp_secret_encrypted', 'totp_recovery_codes', 'totp_last_used_step'].every(column => userColumns.includes(column)), '账户应保存加密 TOTP 状态、恢复码哈希和防重放时间片');
+  assert.ok(['is_source_school', 'is_admission_school'].every(column => schoolColumns.includes(column)), '学校档案应统一保存生源校和招生校类型');
+  assert.ok(['specialty_category', 'specialty_type'].every(column => profileColumns.includes(column)), '考生档案应保存特长生大类和小类');
   assert.ok(['payment_status', 'paid_at', 'paid_by'].every(column => registrationColumns.includes(column)), '报名应保存缴费状态、确认时间和班级负责人');
+  assert.ok(registrationColumns.includes('feature_score'), '每场考试报名应有独立且默认 0 分的特征分');
   assert.ok(seededSchoolCount >= 4, '独立测试数据应覆盖至少四所学校');
   assert.ok(seededCandidateCount >= 360, '独立测试数据应包含数百名考生');
   assert.ok(seededRegistrationCounts.some(item => item.status === 'approved' && item.payment_status === 'unpaid' && item.count >= 90), '测试数据应包含大量已报名未缴费记录');
@@ -334,11 +359,15 @@ try {
   assert.equal((await candidate.request('/api/candidate/dashboard')).response.status, 428, '未补全个人信息前仍不得进入考试业务');
   const updateProfile = await candidate.request('/api/candidate/profile', {
     method: 'PUT',
-    body: { name: '测试考生新名', gender: '男', idNumber: '320101200801019999', nativePlace: '江苏海州', birthDate: '2008-01-01', ethnicity: '汉族', phone: '13900009999', email: 'test@example.com', schoolId: 'school_hz1', classId: 'class_hz1_302', provinceCode: '320000', cityCode: '320700', districtCode: '320706', address: '测试路 1 号', postalCode: '222000', guardianName: '测试家长', guardianPhone: '13800008888', emergencyContact: '测试家长', emergencyPhone: '13800008888' }
+    body: { name: '测试考生新名', gender: '男', idNumber: '320101200801019999', nativePlace: '江苏海州', birthDate: '2008-01-01', ethnicity: '汉族', phone: '13900009999', email: 'test@example.com', schoolId: 'school_hz1', classId: 'class_hz1_302', provinceCode: '320000', cityCode: '320700', districtCode: '320706', address: '测试路 1 号', postalCode: '222000', guardianName: '测试家长', guardianPhone: '13800008888', emergencyContact: '测试家长', emergencyPhone: '13800008888', specialtyCategory: 'arts', specialtyType: 'fine_arts', specialtyCertificate: 'ART-2026-001' }
   });
   assert.equal(updateProfile.response.status, 200, '考生应补全包含籍贯、住址、手机、邮箱和班级的完整资料');
   assert.equal(updateProfile.data.profile.profileCompleted, true, '完整资料提交后应标记完成');
   assert.equal(updateProfile.data.profile.status, 'pending', '完整资料应进入审核');
+  assert.equal(updateProfile.data.profile.specialtyCategory, 'arts', '考生资料应保存艺术大类资格');
+  assert.equal(updateProfile.data.profile.specialtyType, 'fine_arts', '考生资料应保存对应的美术小类资格');
+  const mismatchedSpecialty = await candidate.request('/api/candidate/profile', { method: 'PUT', body: { ...updateProfile.data.profile, schoolId: 'school_hz1', classId: 'class_hz1_302', provinceCode: '320000', cityCode: '320700', districtCode: '320706', specialtyCategory: 'arts', specialtyType: 'track_field' } });
+  assert.equal(mismatchedSpecialty.response.status, 400, '艺术大类不得选择体育小类');
   const refreshedSession = await candidate.request('/api/auth/me');
   assert.equal(refreshedSession.data.user.displayName, '测试考生新名', '考生姓名修改后账号显示名应同步');
   const candidateCannotAdmin = await candidate.request('/api/admin/dashboard');
@@ -359,7 +388,16 @@ try {
   const createSchool = await admin.request('/api/admin/schools', { method: 'POST', body: { name: '海州市第四中学', code: 'hz04', address: '海州市测试区学校路 4 号', active: true } });
   assert.equal(createSchool.response.status, 201, '超级管理员应能创建学校');
   assert.equal(createSchool.data.school.code, 'HZ04', '学校代码应规范化为大写');
+  assert.equal(createSchool.data.school.isSourceSchool, true, '新建学校默认兼容生源校职责');
+  assert.equal(createSchool.data.school.isAdmissionSchool, true, '新建学校默认兼容招生校职责');
   const createdSchoolId = createSchool.data.school.id;
+  const admissionOnlySchool = await admin.request('/api/admin/schools', { method: 'POST', body: { name: '海州市招生实验学校', code: 'HZ-ADMISSION', isSourceSchool: false, isAdmissionSchool: true, active: true } });
+  assert.equal(admissionOnlySchool.response.status, 201, '学校管理应支持只设置为招生校');
+  assert.equal(admissionOnlySchool.data.school.isSourceSchool, false);
+  assert.ok(!(await anonymous.request('/api/public/home')).data.schools.some(item => item.id === admissionOnlySchool.data.school.id), '仅招生校不得出现在考生生源学校选择中');
+  const admissionAccount = await admin.request('/api/admin/admission-school-accounts', { method: 'POST', body: { schoolId: admissionOnlySchool.data.school.id, username: 'admission_only_test', password: 'Admission123!', displayName: '招生实验校招办' } });
+  assert.equal(admissionAccount.response.status, 201, '招生校应可创建招生学校账号');
+  assert.equal((await admissionSchoolClient.request('/api/auth/login', { method: 'POST', body: { username: 'admission_only_test', password: 'Admission123!' } })).response.status, 200, '招生学校账号应可登录独立工作台');
   assert.equal((await admin.request('/api/admin/schools', { method: 'POST', body: { name: '重复代码学校', code: 'HZ04' } })).response.status, 409, '学校代码必须唯一');
   const disableSchool = await admin.request(`/api/admin/schools/${createdSchoolId}`, { method: 'PATCH', body: { name: '海州市第四实验中学', active: false } });
   assert.equal(disableSchool.response.status, 200, '超级管理员应能编辑和停用学校');
@@ -369,6 +407,16 @@ try {
 
   const adminDirectory = await admin.request('/api/admin/admins');
   assert.ok(adminDirectory.data.admins.filter(item => item.adminLevel === 'school' && item.schoolId === 'school_hz1').length >= 2, '同一学校应支持多个同级管理员');
+  const managedAdmin = adminDirectory.data.admins.find(item => item.username === 'school_admin_2');
+  assert.ok(managedAdmin, '管理员台账应返回可管理的校级管理员');
+  assert.equal((await admin.request(`/api/admin/admins/${adminDirectory.data.admins.find(item => item.username === 'admin')?.id}`, { method: 'PATCH', body: { active: false } })).response.status, 409, '超级管理员不能停用当前正在使用的自己');
+  assert.equal((await admin.request(`/api/admin/admins/${managedAdmin.id}`, { method: 'PATCH', body: { active: false } })).response.status, 200, '超级管理员应能停用其他管理员账户');
+  assert.equal((await admin.request('/api/admin/admins')).data.admins.find(item => item.id === managedAdmin.id).active, false, '管理员台账应同步显示停用状态');
+  const adminPasswordReset = await admin.request(`/api/admin/admins/${managedAdmin.id}/reset-password`, { method: 'POST' });
+  assert.equal(adminPasswordReset.response.status, 200, '超级管理员应能重置其他管理员密码');
+  assert.match(adminPasswordReset.data.temporaryPassword, /^Reset-/, '管理员密码重置应返回一次性临时密码');
+  assert.equal((await admin.request('/api/admin/admins')).data.admins.find(item => item.id === managedAdmin.id).active, true, '重置密码应重新启用目标管理员账户');
+  assert.equal((await schoolAdmin2.request('/api/auth/login', { method: 'POST', body: { username: managedAdmin.username, password: adminPasswordReset.data.temporaryPassword } })).response.status, 200, '被重置的管理员应可使用临时密码重新登录');
   const schoolCenters = await schoolAdmin.request('/api/admin/centers');
   assert.ok(schoolCenters.data.centers.every(item => item.schoolId === 'school_hz1'), '校级管理员只能读取本校考点');
   const legacySuperCenters = await legacyAdmin.request('/api/admin/centers');
@@ -427,6 +475,12 @@ try {
   assert.match(classTemplate.response.headers.get('content-type'), /spreadsheetml/);
   const classWorkbook = new ExcelJS.Workbook(); await classWorkbook.xlsx.load(classTemplate.data);
   assert.equal(classWorkbook.worksheets[0].getCell('A2').value, '学校代码*', 'Excel 模板应包含中文字段表头');
+  const admittedWorkbook = new ExcelJS.Workbook();
+  await admittedWorkbook.xlsx.load(await buildWorkbook('admitted_candidates', [{ candidateNumber: '20260001', name: '录取考生', featureScore: 87.5, totalScore: 650, admittedSchool: '第一中学', categoryName: '艺术特长生', preferenceOrder: 1 }]));
+  const admittedSheet = admittedWorkbook.getWorksheet('录取考生');
+  assert.equal(admittedSheet.getCell('A3').value, '20260001', '录取考生 Excel 应包含报名号');
+  assert.ok(admittedSheet.getRow(2).values.includes('特征分'), '录取考生 Excel 应单列特征分');
+  assert.ok(admittedSheet.getRow(2).values.includes('录取学校'), '录取考生 Excel 应包含录取学校');
   const classImportFile = Buffer.from(await buildWorkbook('classes', [{ schoolCode: 'HZ01', grade: '高一', name: '高一（8）班', status: '启用' }]));
   const classImport = await schoolAdmin.request('/api/admin/excel/classes', { method: 'POST', headers: { 'Content-Type': 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet' }, body: classImportFile });
   assert.equal(classImport.response.status, 200, '校级管理员应能从 Excel 导入本校班级');
@@ -544,6 +598,95 @@ try {
   assert.equal(createExam.data.exam.subjects[2].passRule, 'rank_percent', '每科应可独立按排名比例计算及格线');
   assert.equal(createExam.data.exam.subjects[2].passScore, null, '排名比例不应伪造固定分数线');
   const exam = createExam.data.exam;
+  assert.equal((await admin.request(`/api/admin/admissions/${exam.id}/setting`, { method: 'PUT', body: { enabled: true, status: 'draft', maxChoices: 5, maxSubmissions: 1 } })).response.status, 200, '超级管理员应能按考试启用志愿功能并设置填报次数');
+  const structuredPlan = await admissionSchoolClient.request('/api/admission/plans', { method: 'POST', body: { examId: exam.id, note: '结构化计划测试', categories: [
+    { code: 'general', name: '普通生', quota: 20, specialtyCategory: '', specialtyType: '', indicatorAllocations: [{ sourceSchoolId: 'school_hz1', quota: 5 }] },
+    { code: 'arts', name: '美术特长生', quota: 4, specialtyCategory: 'arts', specialtyType: 'fine_arts', indicatorAllocations: [] }
+  ] } });
+  assert.equal(structuredPlan.response.status, 201, '招生校应能提交结构化类别与生源校指标计划');
+  assert.equal(structuredPlan.data.plan.payload.categories[1].specialtyType, 'fine_arts');
+  assert.equal((await admin.request(`/api/admin/admission-plans/${structuredPlan.data.plan.id}`, { method: 'PATCH', body: { status: 'approved', reviewNote: '系统测试通过' } })).response.status, 200, '超级管理员应能审核结构化招生计划');
+  const publicPlanAnnouncements = await anonymous.request('/api/public/announcements');
+  const publicPlan = publicPlanAnnouncements.data.plans.find(item => item.id === structuredPlan.data.plan.id);
+  assert.ok(publicPlan, '招生计划审核通过后应立即自动进入公开公示接口');
+  assert.equal(publicPlan.schoolName, '海州市招生实验学校', '招生计划公示应标明招生学校');
+  assert.deepEqual(publicPlan.rows.map(item => item.quota), [20, 4], '招生计划公示应保留各类别计划人数');
+  const noticeControlList = await admin.request('/api/admin/notices');
+  const controlledPlan = noticeControlList.data.publications.find(item => item.sourceType === 'plan' && item.id === structuredPlan.data.plan.id);
+  assert.ok(controlledPlan?.visible, '自动发布的招生计划应出现在通知发布管理页并默认显示');
+  assert.equal((await admin.request(`/api/admin/publications/plan/${structuredPlan.data.plan.id}`, { method: 'PATCH', body: { visible: false } })).response.status, 200, '通知发布管理页应能隐藏系统招生计划公示');
+  const hiddenPlanAnnouncements = await anonymous.request('/api/public/announcements');
+  assert.equal(hiddenPlanAnnouncements.data.plans.some(item => item.id === structuredPlan.data.plan.id), false, '隐藏系统公示后公开通知目录不得继续返回该招生计划');
+  assert.equal((await admin.request(`/api/admin/publications/plan/${structuredPlan.data.plan.id}`, { method: 'PATCH', body: { visible: true } })).response.status, 200, '已隐藏的系统招生计划公示应能重新显示');
+  const restoredPlanAnnouncements = await anonymous.request('/api/public/announcements');
+  assert.ok(restoredPlanAnnouncements.data.plans.some(item => item.id === structuredPlan.data.plan.id), '重新显示后招生计划应恢复到公开通知目录');
+  assert.equal((await classAdmin.request('/api/admin/indicator-qualifications')).response.status, 403, '班级管理员不得查看或确认指标分配资格');
+  assert.equal((await admin.request('/api/admin/indicator-qualifications')).response.status, 403, '超级管理员不得代替生源校确认指标分配资格');
+  const qualificationLedger = await schoolAdmin.request('/api/admin/indicator-qualifications');
+  const qualificationExam = qualificationLedger.data.exams.find(item => item.examId === exam.id);
+  assert.ok(qualificationExam?.qualificationStatus.rows.length, '生源校学校管理员应看到本校待确认考生');
+  const bulkQualification = await schoolAdmin.request(`/api/admin/indicator-qualifications/${exam.id}/bulk`, { method: 'PUT', body: { userIds: qualificationExam.qualificationStatus.rows.map(row => row.userId), eligible: false } });
+  assert.equal(bulkQualification.response.status, 200, '生源校应能多选后一键批量确认指标分配资格');
+  assert.equal(bulkQualification.data.count, qualificationExam.qualificationStatus.rows.length, '批量确认应返回实际更新人数');
+  assert.equal(bulkQualification.data.published, true, '批量确认覆盖全校考生时应自动完成公示');
+  const candidateQualificationRow = qualificationExam.qualificationStatus.rows.find(row => row.registrationNumber === candidateNumber);
+  const confirmation = await schoolAdmin.request(`/api/admin/indicator-qualifications/${exam.id}/${candidateQualificationRow.userId}`, { method: 'PUT', body: { eligible: true } });
+  assert.equal(confirmation.response.status, 200, '批量确认后仍应支持逐人修正资格');
+  const completedQualificationLedger = await schoolAdmin.request('/api/admin/indicator-qualifications');
+  assert.equal(completedQualificationLedger.data.exams.find(item => item.examId === exam.id).qualificationStatus.complete, true, '本校全部考生确认后应自动完成资格公示');
+  const publicQualification = await anonymous.request('/api/public/announcements');
+  const qualificationPublication = publicQualification.data.qualifications.find(item => item.examId === exam.id && item.schoolName === '海州市第一中学');
+  assert.ok(qualificationPublication, '资格全部确认后应自动出现在独立公开公告接口');
+  assert.equal(qualificationPublication.rows.find(item => item.registrationNumber === candidateNumber).eligible, true, '资格公示应公开考生有无指标分配资格');
+  const invalidSpecialtyPlan = await admissionSchoolClient.request('/api/admission/plans', { method: 'POST', body: { examId: exam.id, categories: [{ code: 'bad', name: '错误特长类别', quota: 1, specialtyCategory: 'arts', specialtyType: 'track_field', indicatorAllocations: [] }] } });
+  assert.equal(invalidSpecialtyPlan.response.status, 400, '招生计划不得把艺术大类与体育小类混用');
+
+  const placementCandidates = qualificationExam.qualificationStatus.rows.slice(0, 3);
+  assert.equal(placementCandidates.length, 3, '批量投档测试至少需要三名候选考生');
+  const placementIds = placementCandidates.map((row, index) => `placement_bulk_test_${index + 1}`);
+  const placementCreatedAt = new Date().toISOString();
+  const placementWriter = new DatabaseSync(testDb);
+  const insertPlacement = placementWriter.prepare(`
+    INSERT INTO admission_records (id, kind, exam_id, user_id, school_id, status, payload_json, created_at, updated_at)
+    VALUES (?, 'placement', ?, ?, ?, 'school_review', ?, ?, ?)
+  `);
+  for (const [index, row] of placementCandidates.entries()) {
+    insertPlacement.run(
+      placementIds[index], exam.id, row.userId, admissionOnlySchool.data.school.id,
+      JSON.stringify({ categoryCode: index === 2 ? 'arts' : 'general', categoryName: index === 2 ? '美术特长生' : '普通生', totalScore: 620 - index, preferenceOrder: index + 1 }),
+      placementCreatedAt, placementCreatedAt
+    );
+  }
+  placementWriter.close();
+
+  const placementReviewLedger = await admissionSchoolClient.request('/api/admission/placements');
+  const seededPlacements = placementReviewLedger.data.placements.filter(item => placementIds.includes(item.id));
+  assert.equal(seededPlacements.length, 3, '招生学校投档台账应返回可供筛选、搜索的完整候选记录');
+  assert.ok(seededPlacements.every(item => item.examName === exam.name && item.candidate.registrationNumber), '投档台账应包含考试名称和考生报名号');
+  const bulkAccept = await admissionSchoolClient.request('/api/admission/placements/bulk', { method: 'POST', body: { ids: placementIds.slice(0, 2), decision: 'accept', note: '批量核验通过' } });
+  assert.equal(bulkAccept.response.status, 200, '招生学校应能批量接收多名投档考生');
+  assert.equal(bulkAccept.data.count, 2, '批量接收应返回实际处理人数');
+  const shortBulkWithdrawal = await admissionSchoolClient.request('/api/admission/placements/bulk', { method: 'POST', body: { ids: [placementIds[2]], decision: 'withdraw', note: '材料不符' } });
+  assert.equal(shortBulkWithdrawal.response.status, 400, '批量退档必须填写充分的特殊理由');
+  const bulkWithdrawal = await admissionSchoolClient.request('/api/admission/placements/bulk', { method: 'POST', body: { ids: [placementIds[2]], decision: 'withdraw', note: '专项资格证明材料复核不通过' } });
+  assert.equal(bulkWithdrawal.response.status, 200, '招生学校应能批量申请退档');
+  const processedPlacementLedger = await admissionSchoolClient.request('/api/admission/placements');
+  assert.ok(processedPlacementLedger.data.placements.filter(item => placementIds.slice(0, 2).includes(item.id)).every(item => item.status === 'admitted'), '批量接收后所选记录应全部进入拟录取状态');
+  assert.equal(processedPlacementLedger.data.placements.find(item => item.id === placementIds[2]).status, 'withdrawal_pending', '批量退档后记录应进入上级审核状态');
+  assert.equal((await admissionSchoolClient.request('/api/admission/placements/bulk', { method: 'POST', body: { ids: placementIds.slice(0, 2), decision: 'accept' } })).response.status, 409, '已处理记录不得被重复批量审核');
+
+  const admissionAccountLedger = await admin.request('/api/admin/admissions');
+  const managedAdmissionAccount = admissionAccountLedger.data.schoolAccounts.find(item => item.id === admissionAccount.data.account.id);
+  assert.equal(managedAdmissionAccount.schoolName, '海州市招生实验学校', '招生学校账户台账应显示绑定学校');
+  assert.equal(managedAdmissionAccount.active, true, '招生学校账户台账应返回真实启停状态');
+  const disabledAdmissionAccount = await admin.request(`/api/admin/admission-school-accounts/${managedAdmissionAccount.id}`, { method: 'PATCH', body: { active: false } });
+  assert.equal(disabledAdmissionAccount.data.account.active, false, '超级管理员应能停用招生学校账户');
+  assert.equal((await admissionSchoolClient.request('/api/admission/context')).response.status, 401, '停用招生学校账户应立即使既有会话失效');
+  assert.equal((await admin.request(`/api/admin/admission-school-accounts/${managedAdmissionAccount.id}`, { method: 'PATCH', body: { active: true } })).data.account.active, true, '超级管理员应能重新启用招生学校账户');
+  const resetAdmissionPassword = await admin.request(`/api/admin/admission-school-accounts/${managedAdmissionAccount.id}/reset-password`, { method: 'POST' });
+  assert.match(resetAdmissionPassword.data.temporaryPassword, /^Reset-/, '重置招生学校账户密码应返回一次性临时密码');
+  assert.equal((await createClient().request('/api/auth/login', { method: 'POST', body: { username: managedAdmissionAccount.username, password: 'Admission123!' } })).response.status, 401, '招生学校账户重置后原密码应失效');
+  assert.equal((await createClient().request('/api/auth/login', { method: 'POST', body: { username: managedAdmissionAccount.username, password: resetAdmissionPassword.data.temporaryPassword } })).response.status, 200, '招生学校账户应能使用临时密码重新登录');
   const createdExamInspector = new DatabaseSync(testDb, { readOnly: true });
   const createdExamPartition = createdExamInspector.prepare('SELECT * FROM exam_data_partitions WHERE exam_id = ?').get(exam.id);
   assert.ok(createdExamPartition, '创建考试时应同步登记该场考试的专属物理表');
@@ -618,6 +761,10 @@ try {
   const adminRegistration = adminRegistrations.data.registrations.find(item => item.id === registrationId);
   assert.equal(adminRegistration.status, 'pending', '新报名应进入管理员审核队列');
   assert.ok(adminRegistration.exam?.name && adminRegistration.schoolName && adminRegistration.gradeName && adminRegistration.className, '报名审核列表应提供考试、学校、年级和班级筛选字段');
+  assert.deepEqual(adminRegistration.subjects.map(item => item.id), [exam.subjects[0].id, exam.subjects[2].id], '报名审核详情应完整提供考生所报科目');
+  const candidateReviewList = await admin.request('/api/admin/candidates');
+  const candidateReviewItem = candidateReviewList.data.candidates.find(item => item.id === profile.id);
+  assert.ok(candidateReviewItem.registrations.some(item => item.id === registrationId && item.exam?.id === exam.id && item.subjects.length === 2), '考生资料审核应同时提供关联考试和所报科目上下文');
 
   const schoolFlows = await schoolAdmin.request('/api/admin/workflow-instances');
   const registrationFlow = schoolFlows.data.instances.find(item => item.businessId === registrationId && item.status === 'pending');
@@ -815,26 +962,62 @@ try {
   assert.match(publishNotice.data.notice.summary, /成绩发布/, '首页摘要留空时应从富文本正文提取纯文本');
   const emptyRichNotice = await admin.request('/api/admin/notices', { method: 'POST', body: { title: '空富文本', content: '<script>alert(1)</script>', status: 'draft' } });
   assert.equal(emptyRichNotice.response.status, 400, '清洗后没有正文的通知必须拒绝保存');
+  const draftNotice = await admin.request('/api/admin/notices', { method: 'POST', body: { title: '待编辑草稿', content: '<p>初始草稿内容</p>', status: 'draft' } });
+  assert.equal(draftNotice.response.status, 201, '管理员应能保存通知草稿');
+  const editedDraftNotice = await admin.request(`/api/admin/notices/${draftNotice.data.notice.id}`, { method: 'PATCH', body: { title: '已编辑草稿', content: '<p>修改后的草稿内容</p>', status: 'draft' } });
+  assert.equal(editedDraftNotice.response.status, 200, '草稿编辑入口应通过原通知修改接口保存');
+  assert.equal(editedDraftNotice.data.notice.title, '已编辑草稿');
+  const noticeListAfterEdit = await admin.request('/api/admin/notices');
+  assert.equal(noticeListAfterEdit.data.notices.filter(item => item.id === draftNotice.data.notice.id).length, 1, '编辑草稿不得重复新建通知');
+  assert.match(noticeListAfterEdit.data.notices.find(item => item.id === draftNotice.data.notice.id).contentHtml, /修改后的草稿内容/, '草稿正文修改后应正确回填到管理接口');
   const refreshedHome = await anonymous.request('/api/public/home');
   const publicRichNotice = refreshedHome.data.notices.find(item => item.title === '系统测试成绩发布通知');
   assert.ok(publicRichNotice, '管理员发布通知后首页应可见');
   assert.equal(publicRichNotice.contentHtml, publishNotice.data.notice.contentHtml, '公开接口应返回已清洗的富文本正文');
 
+  const resultTemplate = await admin.request(`/api/admin/excel/results?template=1&examId=${encodeURIComponent(exam.id)}`);
+  assert.equal(resultTemplate.response.status, 200, '成绩模板应支持按考试下载完整录分名单');
+  const resultTemplateWorkbook = new ExcelJS.Workbook();
+  await resultTemplateWorkbook.xlsx.load(resultTemplate.data);
+  const resultTemplateSheet = resultTemplateWorkbook.getWorksheet('成绩');
+  const templateHeaders = resultTemplateSheet.getRow(2).values;
+  assert.ok(templateHeaders.includes('报名号*') && templateHeaders.includes('准考证号（只读参考）') && templateHeaders.includes('姓名（只读参考）'), '成绩模板应包含报名号、准考证号与姓名列');
+  const templateCandidateNumberColumn = templateHeaders.indexOf('报名号*');
+  const templateCandidateNameColumn = templateHeaders.indexOf('姓名（只读参考）');
+  const templateRows = resultTemplateSheet.getRows(3, Math.max(0, resultTemplateSheet.rowCount - 2)) || [];
+  const candidateTemplateRow = templateRows.find(row => row.getCell(templateCandidateNumberColumn).text === candidateNumber);
+  assert.ok(candidateTemplateRow, '成绩模板应预填已通过报名的真实考生，而不是空白示例行');
+  assert.ok(candidateTemplateRow.getCell(templateCandidateNameColumn).text, '成绩模板应预填考生姓名供核对');
+
   const stagedResultFile = Buffer.from(await buildWorkbook('results', [{ candidateNumber, examCode: exam.code, subjectName: exam.subjects[0].name, score: 125, grade: 'A', published: '不发布' }]));
   const stagedPreview = await admin.request('/api/admin/excel/results', { method: 'POST', headers: { 'Content-Type': 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet' }, body: stagedResultFile });
   assert.equal(stagedPreview.response.status, 200, '成绩 Excel 应先解析为预览');
   assert.equal(stagedPreview.data.preview, true);
   assert.equal(stagedPreview.data.summary.valid, 1);
-  assert.ok(!(await admin.request('/api/admin/results')).data.results.some(item => item.registrationId === registrationId && item.subjectId === exam.subjects[0].id), '预览阶段不得写入数据库');
+  const unselectedResults = await admin.request('/api/admin/results');
+  assert.deepEqual(unselectedResults.data.results, [], '未选择考试时不得读取成绩数据');
+  assert.deepEqual(unselectedResults.data.registrations, [], '未选择考试时不得读取录分名单');
+  assert.ok(!(await admin.request(`/api/admin/results?examId=${encodeURIComponent(exam.id)}`)).data.results.some(item => item.registrationId === registrationId && item.subjectId === exam.subjects[0].id), '预览阶段不得写入数据库');
   const stagedCommit = await admin.request('/api/admin/results/import', { method: 'POST', body: { rows: stagedPreview.data.rows } });
   assert.equal(stagedCommit.response.status, 200, '确认后应批量提交预览成绩');
   assert.equal(stagedCommit.data.count, 1);
-  assert.ok((await admin.request('/api/admin/results')).data.results.some(item => item.registrationId === registrationId && item.subjectId === exam.subjects[0].id && item.score === 125 && !item.published), '批量提交后成绩应以预览状态写库');
+  assert.ok((await admin.request(`/api/admin/results?examId=${encodeURIComponent(exam.id)}`)).data.results.some(item => item.registrationId === registrationId && item.subjectId === exam.subjects[0].id && item.score === 125 && !item.published), '批量提交后成绩应以预览状态写库');
-  const publishResult = await admin.request('/api/admin/results', { method: 'POST', body: { registrationId, subjectId: exam.subjects[0].id, score: 126, grade: 'A', published: true } });
+  const bulkDraftResult = await admin.request('/api/admin/results/bulk', { method: 'POST', body: { examId: exam.id, subjectId: exam.subjects[0].id, published: false, rows: [{ registrationId, score: 125.5 }] } });
-  assert.equal(publishResult.response.status, 200);
+  assert.equal(bulkDraftResult.response.status, 200, '名单式录分应支持按科目批量暂存');
+  assert.equal(bulkDraftResult.data.published, false);
+  const publishResult = await admin.request('/api/admin/results/bulk', { method: 'POST', body: { examId: exam.id, subjectId: exam.subjects[0].id, published: true, rows: [{ registrationId, score: 126 }] } });
+  assert.equal(publishResult.response.status, 200, '名单式录分应支持按科目批量发布');
+  assert.equal(publishResult.data.published, true);
   assert.equal((await admin.request('/api/admin/results', { method: 'POST', body: { registrationId, subjectId: exam.subjects[0].id, score: 151, published: true } })).response.status, 400, '成绩不得超过该科配置的满分');
   assert.equal((await admin.request('/api/admin/results', { method: 'POST', body: { registrationId, subjectId: exam.subjects[2].id, score: 90, published: true } })).response.status, 200);
-  const adminResults = await admin.request('/api/admin/results');
+  const adminResults = await admin.request(`/api/admin/results?examId=${encodeURIComponent(exam.id)}`);
+  assert.equal(adminResults.data.registrations.find(item => item.id === registrationId).featureScore, 0, '所有考试的特征分默认应为 0');
+  const featureScoreUpdate = await admin.request('/api/admin/feature-scores/bulk', { method: 'POST', body: { examId: exam.id, rows: [{ registrationId, featureScore: 87.5 }] } });
+  assert.equal(featureScoreUpdate.response.status, 200, '超级管理员应能按考试名单批量登记特征分');
+  assert.equal(featureScoreUpdate.data.count, 1);
+  assert.equal((await admin.request(`/api/admin/results?examId=${encodeURIComponent(exam.id)}`)).data.registrations.find(item => item.id === registrationId).featureScore, 87.5, '批量保存后应立即回填特征分');
+  assert.equal((await classAdmin.request(`/api/admin/registrations/${registrationId}/feature-score`, { method: 'PATCH', body: { featureScore: 10 } })).response.status, 403, '班级管理员不得登记特征分');
+  assert.equal((await classAdmin.request('/api/admin/feature-scores/bulk', { method: 'POST', body: { examId: exam.id, rows: [{ registrationId, featureScore: 10 }] } })).response.status, 403, '班级管理员不得批量登记特征分');
   assert.equal(adminResults.data.resultCache.status, 'disabled', '未配置 REDIS_URL 时成绩管理接口应报告缓存未启用');
   assert.equal((await schoolAdmin.request('/api/admin/results/cache/refresh', { method: 'POST' })).response.status, 403, '仅超级管理员可以手动刷新成绩缓存');
   const cacheRefresh = await admin.request('/api/admin/results/cache/refresh', { method: 'POST' });
@@ -843,11 +1026,24 @@ try {
   const results = await candidate.request('/api/candidate/results');
   assert.ok(results.data.results.some(item => item.score === 126 && item.subjectName === '语文'), '已发布成绩应在考生端可查询');
   const resultSummary = results.data.summaries.find(item => item.examId === exam.id);
+  assert.equal(resultSummary.featureScore, 87.5, '考生端整场成绩应单独显示特征分');
   assert.equal(resultSummary.total, 216, '考生端应汇总已报科目的总分');
   assert.equal(resultSummary.fullScore, 300, '考生总分满分应按实际报考科目汇总');
   assert.equal(resultSummary.qualified, true, '全部科目发布后应按总成绩排名比例自动判定合格');
   assert.ok(results.data.results.filter(item => item.examId === exam.id).every(item => item.rank === 1 && item.cohortSize === 1 && item.grade === 'A+'), '单科等级应按同场同科排名计算');
-  const classResults = await classAdmin.request('/api/admin/results');
+  assert.equal((await admin.request(`/api/admin/admissions/${exam.id}/setting`, { method: 'PUT', body: { enabled: true, status: 'filling', maxChoices: 5, maxSubmissions: 1 } })).response.status, 200, '超级管理员应能开放志愿填报并限制提交次数');
+  const candidateAdmissions = await candidate.request('/api/candidate/admissions');
+  const candidateAdmission = candidateAdmissions.data.admissions.find(item => item.examId === exam.id);
+  assert.equal(candidateAdmission.indicatorQualification.payload.eligible, true, '考生页面应显示生源校确认的指标分配资格');
+  assert.equal(candidateAdmission.maxSubmissions, 1, '考生页面应显示管理员设置的提交次数上限');
+  const firstPreference = await candidate.request(`/api/candidate/admissions/${exam.id}/preferences`, { method: 'PUT', body: { choices: [
+    { schoolId: structuredPlan.data.plan.schoolId, categoryCode: 'general', preferenceType: 'indicator' },
+    { schoolId: structuredPlan.data.plan.schoolId, categoryCode: 'general', preferenceType: 'general' }
+  ] } });
+  assert.equal(firstPreference.response.status, 200, '有资格考生应能分别填报一个指标志愿和普通志愿');
+  assert.equal(firstPreference.data.locked, true, '达到管理员设置的提交次数后应自动锁定');
+  assert.equal((await candidate.request(`/api/candidate/admissions/${exam.id}/preferences`, { method: 'PUT', body: { choices: [{ schoolId: structuredPlan.data.plan.schoolId, categoryCode: 'general', preferenceType: 'general' }] } })).response.status, 409, '超过填报次数后服务端必须拒绝继续修改');
+  const classResults = await classAdmin.request(`/api/admin/results?examId=${encodeURIComponent(exam.id)}`);
   assert.ok(classResults.data.results.some(item => item.score === 126 && item.candidateName === '测试考生新名'), '班级管理员应可查看本班成绩');
   assert.equal((await classAdmin.request('/api/admin/results', { method: 'POST', body: { registrationId, subjectId: exam.subjects[0].id, score: 1 } })).response.status, 403, '班级管理员不得录入或发布成绩');
 
@@ -928,7 +1124,7 @@ try {
   assert.match(archivedPreview.data.rows[0].errors.join(''), /永久锁定/, '归档场次的 Excel 行必须标记为不可提交');
   assert.equal((await admin.request('/api/admin/results/import', { method: 'POST', body: { rows: archivedPreview.data.rows } })).response.status, 400, '归档后 Excel 批量提交不得修改成绩');
   assert.equal((await candidate.request(`/api/candidate/results/${appealResults[0].id}/appeals`, { method: 'POST', body: { reason: '归档后再次申请复议' } })).response.status, 409, '归档后考生不得再发起成绩复议');
-  const archivedAdminResults = await admin.request('/api/admin/results');
+  const archivedAdminResults = await admin.request(`/api/admin/results?examId=${encodeURIComponent(exam.id)}`);
   assert.ok(archivedAdminResults.data.exams.find(item => item.id === exam.id)?.archivedAt, '管理端成绩中心应返回归档状态');
   const archivedCandidateResults = await candidate.request('/api/candidate/results');
   assert.ok(archivedCandidateResults.data.results.filter(item => item.examId === exam.id).every(item => item.archivedAt), '考生历史成绩应标记为归档并进入折叠区');
@@ -961,8 +1157,11 @@ try {
   console.log('✓ 成绩录入、发布与考生查询');
   console.log('✓ 成绩复议、班级审批、范围匹配与多人均分');
 } finally {
-  server.kill('SIGTERM');
+  if (server.exitCode == null && server.signalCode == null) {
-  await new Promise(resolveWait => server.once('exit', resolveWait));
+    const serverExit = new Promise(resolveWait => server.once('exit', resolveWait));
+    server.kill('SIGTERM');
+    await serverExit;
+  }
   await rm(testDb, { force: true });
   await rm(`${testDb}-shm`, { force: true });
   await rm(`${testDb}-wal`, { force: true });