HEL-270: 修复闭期补录未提交即回滚丢失（补回归测试）

Co-authored-by: multica-agent <github@multica.ai>

.gitignore

@@ -9,6 +9,7 @@ data/
 uploads/
 exports/
 *.local
+deploy/.env
 server.pid
 server.out.log
 server.err.log

README.md

@@ -54,7 +54,7 @@ SHA-256 内容哈希不可变保存，重复上传返回 `duplicate` 状态并
 - 总账管理端：`http://127.0.0.1:4173/admin.html`
 - 公司业务端：`http://127.0.0.1:4173/company.html`
 
-公司端上传会把所选工作簿提交到本地 `/api/parse`，与 CLI 使用同一个确定性表头解析器；解析结果、原始文件、批次和源行会持久化到 SQLite，并按登录账号绑定的公司隔离。当前前端仍是交互原型，期初、提醒、往来匹配等业务状态仅保存在当前浏览器页面中，尚未接入数据库。
+公司端上传会把所选工作簿提交到本地 `/api/parse`，与 CLI 使用同一个确定性表头解析器；解析结果、原始文件、批次和源行会持久化到 SQLite，并按登录账号绑定的公司隔离。流水列表、往来查询、手工记录、月结与重开均走服务端接口；银行原始数据不可改，已确认与待确认金额分开计算。测试环境编排见 `deploy/`（默认 4173）。
 
 ## 样本数据政策
 

deploy/.env.example

@@ -0,0 +1,18 @@
+# 测试环境变量示例。复制为 deploy/.env 后填写。
+# 正式环境口令不得提交进仓库。
+
+# 容器运行 uid/gid：必须与 data/ 目录属主一致（宿主机 `id <用户>` 查看）
+APP_UID=10001
+APP_GID=10001
+
+APP_HOST=0.0.0.0
+APP_PORT=4173
+APP_DB_PATH=/app/data/app.db
+APP_STORAGE_DIR=/app/data/files
+
+# 引导管理员（库中尚无管理员时生效）
+APP_ADMIN_USERNAME=group-admin
+APP_BOOTSTRAP_ADMIN_PASSWORD=change-me-in-local-env
+
+# 内网测试可暂时关闭登录失败锁定；正式环境不得开启
+# APP_LOGIN_RATE_LIMIT_DISABLED=1

deploy/Dockerfile

@@ -0,0 +1,32 @@
+FROM python:3.12-slim-bookworm
+
+ENV PYTHONDONTWRITEBYTECODE=1 \
+    PYTHONUNBUFFERED=1 \
+    PYTHONPATH=/app/src \
+    APP_HOST=0.0.0.0 \
+    APP_PORT=4173 \
+    APP_DB_PATH=/app/data/app.db \
+    APP_STORAGE_DIR=/app/data/files
+
+WORKDIR /app
+
+RUN groupadd --system --gid 10001 app \
+    && useradd --system --uid 10001 --gid app --home-dir /app --shell /usr/sbin/nologin app \
+    && mkdir -p /app/data \
+    && chown -R app:app /app
+
+COPY --chown=app:app requirements.txt ./
+RUN python -m pip install --no-cache-dir --requirement requirements.txt
+
+COPY --chown=app:app server.py ./
+COPY --chown=app:app src ./src
+COPY --chown=app:app web ./web
+
+USER app
+
+EXPOSE 4173
+
+HEALTHCHECK --interval=15s --timeout=3s --start-period=10s --retries=5 \
+    CMD ["python", "-c", "import urllib.request; urllib.request.urlopen('http://127.0.0.1:4173/', timeout=2)"]
+
+CMD ["python", "server.py"]

deploy/README.md

@@ -0,0 +1,77 @@
+# 部署与运维手册（与 `release/prod` 基线一致）
+
+最后核对：2026-08-30，总工 HEL-270 上线前总验收。本手册是测试与正式环境唯一的部署/回滚/备份/巡检操作依据，取代散落在宿主机 `DEPLOYMENT.txt` 里的历史记录（旧记录仅作存档）。
+
+## 1. 物料与目录
+
+| 物料 | 说明 |
+|---|---|
+| `deploy/Dockerfile` | python:3.12-slim-bookworm，非 root（uid 10001 `app`），只读根文件系统 |
+| `deploy/compose.yaml` | cap_drop ALL、no-new-privileges、pids 128、mem 512m、cpu 1.0、healthcheck |
+| `deploy/.env.example` | 配置模板；`deploy/.env` 已 gitignore，口令永不入库 |
+| `deploy/deploy.sh` | `TAG=<tag> ./deploy.sh`，默认镜像 tag=当前提交 sha |
+| `deploy/rollback.sh` | `./rollback.sh <tag>`，只换应用不动数据 |
+| `deploy/backup.sh` | 在线热备 + 保留策略（30 天日备 + 12 个月月备） |
+| `deploy/monitor.sh` | 每 5 分钟健康 + 磁盘 ≥80% 告警，写 `ALERT.log` |
+
+数据目录：`deploy/../data/`（`app.db` + `files/`）。银行原始文件按 SHA-256 内容哈希不可变保存，任何操作不得改写。
+
+## 2. 正式配置铁律
+
+- **不得出现 `admin/admin123`**：`APP_BOOTSTRAP_ADMIN_PASSWORD` 正式环境不设值，首启由控制台读取随机生成的一次性初始口令，首登立即改密；管理员用户名避开 `admin`。
+- **登录失败限流默认开启**（5 次/10 分钟锁账号+IP）。`APP_LOGIN_RATE_LIMIT_DISABLED=1` 仅限本地调试，正式 .env 不得携带。
+- 密钥/口令/证书私钥不进仓库、不进评论、不进任务元数据。
+- **HTTPS**：正式暴露一律经反向代理（推荐同机 Caddy 容器，内网自签或内部 CA 证书，反代到容器 4173）；不占用 NAS 系统 nginx 的 80/443。公司电脑分发根证书即可。
+- **日志**：容器 stdout 走 docker json-file，限幅 `max-size=10m, max-file=3`（daemon 或 compose `logging` 配置）；审计日志在库内（append-only 触发器保护）。
+
+## 3. 部署步骤（测试与正式一致）
+
+```bash
+git fetch && git checkout release/prod && git pull
+cd deploy
+cp .env.example .env   # 首次；按上面铁律填写
+# .env 必设 APP_UID/APP_GID = data/ 目录属主的 uid/gid（宿主机 `id <用户>`），
+# 否则 SQLite WAL 写库报 readonly
+TAG=$(git rev-parse --short HEAD) ./deploy.sh
+curl -fsS http://127.0.0.1:4173/ >/dev/null && echo healthy
+```
+
+部署前手工备份（四件套 + 镜像 tag 存档）：
+
+```bash
+STAMP=$(date +%Y%m%d-%H%M%S)
+tar -C .. -czf ../backups/source-$STAMP.tar.gz --exclude='../data' --exclude='../.git' .
+cp .env ../backups/env-$STAMP
+docker exec caiwuzongzhang-app python -c "import sqlite3; s=sqlite3.connect('/app/data/app.db'); d=sqlite3.connect('/tmp/b.db'); s.backup(d); d.close(); s.close()"
+docker cp caiwuzongzhang-app:/tmp/b.db ../backups/app.db.$STAMP
+```
+
+## 4. 回滚（应用层，5 分钟内）
+
+```bash
+cd deploy && ./rollback.sh <上一个镜像tag>
+```
+
+数据层恢复见下节。两套动作互不干扰：应用回滚不改数据；数据恢复不换镜像。
+
+## 5. 备份与恢复演练
+
+- 备份：cron `15 2 * * *` 运行 `deploy/backup.sh`；月结后再手动跑一次。
+- 恢复步骤（已演练，隔离环境验证）：
+  1. `mkdir -p /tmp/restore/data && cp backups/daily/app.db.<stamp> /tmp/restore/data/app.db`
+  2. `tar -C /tmp/restore/data -xzf backups/daily/files.<stamp>.tar.gz`（解出 `files/`）
+  3. 用一份独立 `deploy-restore` 目录（`.env` 指向 `/tmp/restore`、端口错开）`docker compose up -d --build`
+  4. 核对：`PRAGMA integrity_check`、各表行数、金额合计、`source_files` 哈希清单与生产一致后才可顶替。
+- 演练频率：上线前 1 次（HEL-270 已做），之后每季度 1 次，结果记入本文件末尾。
+
+## 6. 巡检与告警
+
+cron `*/5 * * * *` 运行 `deploy/monitor.sh`；连续失败或磁盘 ≥80% 时查看 `deploy/ALERT.log` 并按需扩容/清理。容器重启策略 `unless-stopped`。
+
+## 7. 升级数据库
+
+应用启动时自动执行迁移（`MIGRATIONS`，当前版本 10）。迁移只前不改写历史；回退 schema 用对应 down 迁移，先备份后操作。
+
+## 8. 演练记录
+
+- 2026-08-30 HEL-270：备份恢复演练 + 版本回滚演练各 1 次，隔离环境完成，原始证据未改动。详见 HEL-270 验收评论。

deploy/backup.sh

@@ -0,0 +1,53 @@
+#!/usr/bin/env bash
+# 在线热备：不停服备份 SQLite（backup API 保证一致性）+ files/ 原始文件目录。
+# 用法：./backup.sh [备份根目录]（默认 ../backups）
+# 保留策略：日备保留 30 天，每月 1 号的首份备份额外保留 12 个月（monthly/）。
+# 建议宿主机 cron：15 2 * * * /path/to/deploy/backup.sh >> /path/to/deploy/backup.log 2>&1
+# 官方环境建议至少将 monthly/ 同步一份到异机/异盘。
+set -euo pipefail
+ROOT="$(cd "$(dirname "$0")" && pwd)"
+DEST="${1:-$ROOT/../backups}"
+CONTAINER="${CONTAINER:-caiwuzongzhang-app}"
+STAMP="$(date +%Y%m%d-%H%M%S)"
+DAY_DIR="$DEST/daily"
+MONTH_DIR="$DEST/monthly"
+mkdir -p "$DAY_DIR" "$MONTH_DIR"
+
+# 1) SQLite 在线热备（容器内 python sqlite3 backup API，主库可继续写入）
+#    备份文件写进数据卷 /app/data（宿主机 deploy/../data 可直接读取），避免
+#    read_only 容器 + tmpfs 下 docker cp 取不到文件的问题。
+docker exec -i "$CONTAINER" python - <<'PY'
+import os, sqlite3
+src = sqlite3.connect(os.environ.get("APP_DB_PATH", "/app/data/app.db"))
+dst = sqlite3.connect("/app/data/.backup-tmp.db")
+src.backup(dst)
+dst.close(); src.close()
+print("hot-backup ok")
+PY
+mv "$ROOT/../data/.backup-tmp.db" "$DAY_DIR/app.db.$STAMP"
+
+# 2) 原始文件目录打包（银行原始证据，只读复制，绝不改动）
+tar -C "$ROOT/.." -czf "$DAY_DIR/files.$STAMP.tar.gz" data/files
+
+# 3) 完整性自检：PRAGMA integrity_check + 关键计数
+docker run --rm -v "$DAY_DIR/app.db.$STAMP:/check/app.db:ro" python:3.12-slim-bookworm \
+    python -c "
+import sqlite3
+c = sqlite3.connect('/check/app.db')
+print('integrity:', c.execute('PRAGMA integrity_check').fetchone()[0])
+for t in ('source_rows', 'transfer_match_decisions', 'period_close_runs', 'audit_log'):
+    try:
+        print(t, c.execute(f'SELECT COUNT(*) FROM {t}').fetchone()[0])
+    except sqlite3.OperationalError:
+        print(t, 'n/a')
+"
+
+# 4) 保留策略：日备 >30 天删除；每月 1 号留档 monthly/
+find "$DAY_DIR" -name 'app.db.*' -mtime +30 -delete
+find "$DAY_DIR" -name 'files.*.tar.gz' -mtime +30 -delete
+if [ "$(date +%d)" = "01" ]; then
+    cp "$DAY_DIR/app.db.$STAMP" "$MONTH_DIR/app.db.$STAMP"
+    cp "$DAY_DIR/files.$STAMP.tar.gz" "$MONTH_DIR/files.$STAMP.tar.gz"
+    find "$MONTH_DIR" -mtime +365 -delete
+fi
+echo "backup complete: $DAY_DIR/app.db.$STAMP"

deploy/compose.yaml

@@ -0,0 +1,38 @@
+# 测试/正式环境部署编排（正式口令不得写入本文件）。
+# 使用：复制 .env.example 为 .env 填写；TAG 指定镜像标签（默认取当前提交 sha）。
+# 例：TAG=v1.0.0-rc1 docker compose -f compose.yaml up -d --build
+
+services:
+  app:
+    container_name: caiwuzongzhang-app
+    image: caiwuzongzhang:${TAG:-latest}
+    build:
+      context: ..
+      dockerfile: deploy/Dockerfile
+    env_file:
+      - .env
+    # 绑定挂载 data/ 时，容器运行 uid 必须与数据目录属主一致（.env 里设
+    # APP_UID/APP_GID，正式与测试环境各自填写，默认镜像内 app=10001）
+    user: "${APP_UID:-10001}:${APP_GID:-10001}"
+    ports:
+      - "4173:4173"
+    volumes:
+      - ../data:/app/data
+    init: true
+    restart: unless-stopped
+    read_only: true
+    tmpfs:
+      - /tmp:size=64m,mode=1777
+    security_opt:
+      - no-new-privileges:true
+    cap_drop:
+      - ALL
+    pids_limit: 128
+    mem_limit: 512m
+    cpus: 1.0
+    healthcheck:
+      test: ["CMD", "python", "-c", "import urllib.request; urllib.request.urlopen('http://127.0.0.1:4173/', timeout=2)"]
+      interval: 15s
+      timeout: 3s
+      retries: 5
+      start_period: 10s

deploy/deploy.sh

@@ -0,0 +1,17 @@
+#!/usr/bin/env bash
+# 部署（测试或正式环境通用）。施工员不执行上线；由总工运行。
+# 用法：TAG=<镜像标签，默认当前 git 提交 sha> ./deploy.sh
+set -euo pipefail
+ROOT="$(cd "$(dirname "$0")" && pwd)"
+cd "$ROOT/.."
+if [[ ! -f deploy/.env ]]; then
+    echo "缺少 deploy/.env。请复制 deploy/.env.example 后填写（正式口令不得入库）。" >&2
+    exit 1
+fi
+if [[ -z "${TAG:-}" ]]; then
+    TAG="$(git rev-parse --short HEAD 2>/dev/null || echo latest)"
+fi
+mkdir -p data/files
+cd "$ROOT"
+TAG="$TAG" docker compose -f compose.yaml up -d --build
+echo "已启动：http://127.0.0.1:${APP_PORT:-4173}/  镜像 caiwuzongzhang:$TAG"

deploy/monitor.sh

@@ -0,0 +1,32 @@
+#!/usr/bin/env bash
+# 巡检：健康端点 + 磁盘水位告警。失败/越线写 ALERT.log（供总管日检）。
+# 建议 cron：*/5 * * * * /path/to/deploy/monitor.sh >/dev/null 2>&1
+set -euo pipefail
+ROOT="$(cd "$(dirname "$0")" && pwd)"
+URL="${HEALTH_URL:-http://127.0.0.1:4173/}"
+DATA_DIR="${DATA_DIR:-$ROOT/../data}"
+ALERT="$ROOT/ALERT.log"
+DISK_THRESHOLD="${DISK_THRESHOLD:-80}"
+
+now() { date "+%Y-%m-%d %H:%M:%S"; }
+
+# 1) 健康检查：HTTP 200 才算通过
+if ! curl -fsS -m 8 -o /dev/null "$URL"; then
+    echo "[$(now)] HEALTH FAIL: $URL 无响应" >> "$ALERT"
+    exit 1
+fi
+
+# 2) 磁盘水位：数据所在分区使用率超阈值告警
+pct="$(df -P "$DATA_DIR" | awk 'NR==2 {gsub("%",""); print $5}')"
+if [ "${pct:-0}" -ge "$DISK_THRESHOLD" ]; then
+    echo "[$(now)] DISK ALERT: $DATA_DIR 使用率 ${pct}% >= ${DISK_THRESHOLD}%" >> "$ALERT"
+    exit 2
+fi
+
+# 3) 容器状态：非 running/restarting 告警
+state="$(docker inspect -f '{{.State.Status}}' "${CONTAINER:-caiwuzongzhang-app}" 2>/dev/null || echo missing)"
+if [ "$state" != "running" ]; then
+    echo "[$(now)] CONTAINER ALERT: ${CONTAINER:-caiwuzongzhang-app} state=$state" >> "$ALERT"
+    exit 3
+fi
+echo "[$(now)] ok"

deploy/rollback.sh

@@ -0,0 +1,19 @@
+#!/usr/bin/env bash
+# 回滚：回到指定镜像标签（或最近一次可用镜像）。
+# 用法：./rollback.sh <tag>   例：./rollback.sh f5e0915
+# 数据库与 files/ 原始证据不受影响；如需回退数据，见 deploy/README.md「数据恢复」。
+set -euo pipefail
+ROOT="$(cd "$(dirname "$0")" && pwd)"
+cd "$ROOT"
+TAG="${1:-}"
+if [[ -z "$TAG" ]]; then
+    echo "用法：./rollback.sh <镜像tag>（可用 tag 见 docker images caiwuzongzhang）" >&2
+    exit 1
+fi
+if ! docker image inspect "caiwuzongzhang:$TAG" >/dev/null 2>&1; then
+    echo "镜像 caiwuzongzhang:$TAG 不存在。" >&2
+    exit 1
+fi
+TAG="$TAG" docker compose -f compose.yaml down
+TAG="$TAG" docker compose -f compose.yaml up -d
+echo "已回滚到 caiwuzongzhang:$TAG"

docs/HANDOFF.md

@@ -1,3 +1,5 @@
+⚠️ 本文档已过时，仅留档备查，请勿删除。当前代码状态请看 `README.md`、`项目需求.md`、`最新进度.md` 和 `任务清单.md`。
+
 # 项目交接说明
 
 更新时间：2026-08-06

docs/issues/001-p0-repository-data-hygiene.md

@@ -1,3 +1,5 @@
+⚠️ 本文档已过时，仅留档备查，请勿删除。该历史任务已落地；当前状态见 `../任务清单.md`。
+
 # [P0] 仓库银行样本数据分级与脱敏治理
 
 ## 背景

docs/issues/002-p0-persistence-and-immutable-imports.md

@@ -1,3 +1,5 @@
+⚠️ 本文档已过时，仅留档备查，请勿删除。该历史任务已落地；当前状态见 `../任务清单.md`。
+
 # [P0] 持久化层与不可变银行导入基础
 
 ## 背景

docs/issues/003-p0-auth-and-tenant-isolation.md

@@ -1,3 +1,5 @@
+⚠️ 本文档已过时，仅留档备查，请勿删除。该历史任务已落地；当前状态见 `../任务清单.md`。
+
 # [P0] 正式认证、RBAC 与公司级数据隔离
 
 ## 背景

docs/issues/004-p1-dynamic-master-data.md

@@ -1,3 +1,5 @@
+⚠️ 本文档已过时，仅留档备查，请勿删除。该历史任务已落地；当前状态见 `../任务清单.md`。
+
 # [P1] 动态公司、用户、账户和别名主数据
 
 ## 背景

docs/issues/005-p1-import-api-hardening.md

@@ -1,3 +1,5 @@
+⚠️ 本文档已过时，仅留档备查，请勿删除。该历史任务已落地；当前状态见 `../任务清单.md`。
+
 # [P1] 银行导入 API 加固与回归测试
 
 ## 背景

docs/issues/006-p1-canonical-transfer-matching.md

@@ -1,3 +1,5 @@
+⚠️ 本文档已过时，仅留档备查，请勿删除。该历史任务已落地；当前状态见 `../任务清单.md`。
+
 # [P1] 规范转账事件、双边匹配与调拨排除
 
 ## 背景

docs/任务清单.md

@@ -1,29 +1,29 @@
 # 任务清单
 
-最后核对：2026-08-23。状态以当前代码和已合并提交为准。
+最后核对：2026-08-30。状态以当前代码和已合并提交为准。
 
 ## 正在做
 
-- 当前没有已确认正在进行的业务功能开发。下一项工作开始前，先在此处写明负责人、范围和验收标准。
+- HEL-270 上线前总验收（总工）：代码审核、测试环境部署、备份恢复与回滚演练、边界自动化证据。
 
 ## 已做完
 
 - 六类银行流水模板识别与解析。
-- 数据库迁移、不可变原始证据、导入批次和重复导入处理。
-- 管理员/公司用户登录、密码策略、会话、限流、服务端公司隔离和审计。
+- 数据库迁移（至版本 10）、不可变原始证据、导入批次和重复导入处理；文件库 WAL。
+- 管理员/公司用户登录、密码策略、会话清理、限流、服务端公司隔离和审计。
 - 动态公司、用户、银行账户、别名与账户审核流程。
 - 导入接口加固、逐工作表确认、失败诊断和导出。
 - 规范转账事件、双边匹配、同公司调拨排除与个人过账映射。
-- 登录页视觉融合改版。
+- 起算日、期初余额、流水覆盖断档检测和无业务校准。
+- 月结、重开审批、闭期补录、锁账写保护、月报与审计记录。
+- 服务端流水查询、筛选、分页和可追溯导出；往来查询与手工记录接入真实接口。
+- 站内提醒与状态流转。
+- 前端移除演示流水/往来造数和 `localStorage` 业务状态。
+- 登录页视觉融合改版；月结/重开/审计按 HEL-268 视觉规范落地。
+- 测试环境部署编排收编到 `deploy/`，含非 root 加固、备份/巡检脚本与运维手册（不在施工员职责内执行上线）。
 
 ## 还没安排
 
-- 公司间余额和四类往来科目的正式计算，已批准手工记录入账，以及从余额逐层查回原始流水。
-- 起算日、期初余额、流水覆盖断档检测和无业务校准。
-- 月结、重开、调整/冲销审批与审计报告。
-- 服务端流水查询、筛选、分页和可追溯导出。
-- 站内提醒与状态流转；外部通知只预留扩展位置，不默认启用。
-- 前端全面接入真实接口，移除模拟金额、静态业务记录和 `localStorage` 业务状态。
-- 测试环境之外的运行保障，包括 HTTPS、备份、监控和正式部署方案。
+- 正式部署（P4）：HTTPS 反代落地、异机备份副本、正式账号交接。覆盖正式环境必须老板明确同意。
 
 每完成或新增一项任务，必须在同一次提交里把它从本清单的相应栏目移走或补上，并同步更新 `最新进度.md`。

docs/最新进度.md

@@ -1,24 +1,27 @@
 # 最新进度
 
-最后核对：2026-08-23。以下“已完成”均以当前代码、数据库迁移、接口和自动化测试为依据，不把页面演示当作真实功能。
+最后核对：2026-08-30。以下“已完成”均以当前代码、数据库迁移、接口和自动化测试为依据，不把页面演示当作真实功能。
 
 ## 已经真实完成
 
 - 支持中信、农行、工行、建行、河南农商行、郑州银行六类样本的 `.xls` / `.xlsx` 流水解析；能识别变动的表头位置和列顺序，并校验余额连续性。
-- 已有 SQLite 数据库和 5 次版本迁移。原始文件按内容哈希保存，导入批次、工作表、源行和异常都有记录；原始文件、工作表和源行被数据库规则保护，不能直接改或删。
-- 已实现管理员与公司用户登录、首次改密、会话失效、登录失败限流、服务端权限隔离和审计记录。
+- 已有 SQLite 数据库和 10 次版本迁移。原始文件按内容哈希保存，导入批次、工作表、源行和异常都有记录；原始文件、工作表和源行被数据库规则保护，不能直接改或删。文件库启用 WAL。
+- 已实现管理员与公司用户登录、首次改密、会话失效（过期会话在发新会话时清理）、登录失败限流、服务端权限隔离和审计记录。
 - 已实现公司、用户、银行账户、别名等主数据管理；公司提交的银行账户需管理员审核后才能参与上传和识别。
 - 已实现导入、逐工作表确认或忽略、失败诊断、重复上传处理和 CSV 导出；未确认的工作表不进入后续处理。
 - 已实现规范转账事件和双边流水匹配。匹配决定保留历史，无法自动判断的记录进入人工审核；同公司调拨、外部流水和未锁定的单边记录不进入已确认的公司间往来。
-- 已有登录页、总账端和公司端页面，最近一次合并完成了登录页视觉改版。
+- 已实现全局起算日、公司对期初余额、流水覆盖断档与无业务说明审核。
+- 已实现月结：结账日到达后生成待结账任务，管理员确认后锁账并生成带 SHA-256 的月报；重开须审批，窗口到期自动恢复锁定；闭期补录进入 `period_late_arrivals`，不改已结快照；写保护拒绝锁定月的普通修改。
+- 流水列表/导出、往来查询、公司端手工记录已改为服务器真实数据；空列表显示「暂无数据」。页面不再使用 `FLOW_DEMO` / `localStorage` 业务状态。
+- 已有登录页、总账端和公司端页面。管理端「结账与期初」承接月结，「审核中心」增加重开审批，「结账与期初」之后增加「审计记录」。
+- `deploy/` 收编测试环境 Dockerfile、compose、`.env.example` 与部署/回滚脚本（4173、非 root、只读根文件系统、drop ALL、pids/mem/cpu 限制、healthcheck）。正式口令不进仓库。
+- 备份（在线热备 + 30 天日备/12 个月月备保留策略）、巡检（健康 + 磁盘 ≥80% 告警）脚本与《部署与运维手册》`deploy/README.md` 已入库；HTTPS 走反向代理方案已在手册写明。
 
 ## 仍未完成或不能当成已完成
 
-- 公司间余额与会计科目的正式计算、已批准手工记录入账和逐层余额追溯尚未完成。
-- 全局起算日、期初余额、流水覆盖断档、无业务校准、月结、重开和调整审批尚未完成。
-- 提醒、完整的服务端查询导出，以及前端彻底移除演示数据和浏览器本地业务状态尚未完成。
-- 生产部署所需的 HTTPS、反向代理、备份、监控和正式运行保障尚未完成；本项目当前只允许测试环境部署。
+- 正式环境尚未部署（P4）：HTTPS 反代、异机备份副本、正式账号交接在上线时落地。覆盖正式环境必须老板明确同意。
+- 发布基线：`release/prod` 长期分支已建立，`main` 待发布时快进。
 
 ## 最近验证
 
-2026-08-23 已运行完整 Python 自动化测试：解析、持久化、认证与权限、导入接口、主数据和双边匹配相关测试均通过。后续修改功能时，必须再次运行完整测试并在本文件记录结果。
+2026-08-30 已运行完整 Python 自动化测试（`PYTHONPATH=src python -m unittest discover -s tests -v`），覆盖解析、持久化、认证、导入、主数据、匹配、月结/重开/写保护、前端契约与 360/820/1440 布局冒烟（有 Chromium 时）。后续修改功能时必须再次运行完整测试并在本文件记录结果。

src/bank_importer/auth.py

@@ -204,6 +204,7 @@ def create_session(
     token = secrets.token_urlsafe(32)
     token_hash = hashlib.sha256(token.encode("utf-8")).hexdigest()
     now = datetime.now(timezone.utc)
+    purge_expired_sessions(connection)
     with connection:
         connection.execute(
             """
@@ -220,6 +221,17 @@ def create_session(
     return token
 
 
+def purge_expired_sessions(connection: sqlite3.Connection) -> int:
+    """Drop expired or revoked session rows so they do not accumulate."""
+    now = utc_now()
+    with connection:
+        cursor = connection.execute(
+            "DELETE FROM sessions WHERE expires_at <= ? OR revoked_at IS NOT NULL",
+            (now,),
+        )
+    return int(cursor.rowcount or 0)
+
+
 def resolve_session(connection: sqlite3.Connection, token: str) -> sqlite3.Row | None:
     """Return the user row for a live session token, else None.
 

src/bank_importer/dashboard.py

@@ -109,11 +109,46 @@ def _company_rows(connection: sqlite3.Connection) -> list[sqlite3.Row]:
     ).fetchall()
 
 
+def _period_status_for_cutoff(
+    connection: sqlite3.Connection, cutoff: str
+) -> tuple[str | None, str]:
+    ym = str(cutoff or "")[:7]
+    exists = connection.execute(
+        "SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = 'period_close_runs'"
+    ).fetchone()
+    if exists is None:
+        return None, "—"
+    row = connection.execute(
+        """
+        SELECT status FROM period_close_runs
+        WHERE year_month = ?
+        ORDER BY version DESC LIMIT 1
+        """,
+        (ym,),
+    ).fetchone()
+    mapping = {
+        "closed": ("closed", "已锁定"),
+        "reopened": ("reopened", "已重开"),
+        "failed": ("failed", "结账失败"),
+        "pending": ("pending", "待结账"),
+        "closing": ("closing", "处理中"),
+    }
+    if row is not None:
+        return mapping.get(row["status"], (row["status"], str(row["status"])))
+    locked = connection.execute(
+        "SELECT 1 FROM closed_periods WHERE year_month = ?", (ym,)
+    ).fetchone()
+    if locked is not None:
+        return "closed", "已锁定"
+    return None, "—"
+
+
 def company_summaries(
     connection: sqlite3.Connection, *, from_date: str, cutoff: str
 ) -> tuple[list[dict[str, object]], dict[str, object]]:
     companies = _company_rows(connection)
     events = _load_eligible(connection, from_date=from_date, cutoff=cutoff)
+    period_status, period_label = _period_status_for_cutoff(connection, cutoff)
 
     debit_total = ZERO
     credit_total = ZERO
@@ -125,8 +160,8 @@ def company_summaries(
             "detail_count": 0,
             "debit": ZERO,
             "credit": ZERO,
-            "period_status": None,
-            "period_status_label": "—",
+            "period_status": period_status,
+            "period_status_label": period_label,
         }
 
     for event in events:

src/bank_importer/db.py

@@ -1011,6 +1011,191 @@ MIGRATIONS: tuple[Migration, ...] = (
         DROP TABLE IF EXISTS closed_periods;
         """,
     ),
+
+    Migration(
+        version=9,
+        name="0009_reminders_engine",
+        # HEL-195/215 auto-reminder engine. The old manual reminders table
+        # from 0007 is preserved verbatim under reminders_legacy_manual so
+        # existing test-env history stays queryable; the new engine uses its
+        # own append-only reminders/reminder_events schema.
+        up="""
+        ALTER TABLE reminders RENAME TO reminders_legacy_manual;
+        DROP INDEX IF EXISTS idx_reminders_company;
+        CREATE INDEX idx_reminders_legacy_company
+            ON reminders_legacy_manual (company_id);
+
+        CREATE TABLE reminder_settings (
+            key TEXT PRIMARY KEY,
+            value TEXT NOT NULL,
+            updated_at TEXT NOT NULL
+        );
+
+        INSERT INTO reminder_settings (key, value, updated_at) VALUES
+            ('monthly_start_day', '5', datetime('now')),
+            ('gap_days', '5', datetime('now')),
+            ('scan_time', '08:00', datetime('now'));
+
+        CREATE TABLE reminders (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            company_id INTEGER NOT NULL REFERENCES companies (id),
+            rule_key TEXT NOT NULL CHECK (rule_key IN (
+                'unsubmitted', 'gap', 'pending_review', 'manual'
+            )),
+            dedupe_key TEXT NOT NULL UNIQUE,
+            rule_params TEXT NOT NULL DEFAULT '{}',
+            title TEXT NOT NULL,
+            content TEXT NOT NULL,
+            deadline TEXT,
+            source TEXT NOT NULL CHECK (source IN ('auto', 'manual')),
+            status TEXT NOT NULL DEFAULT 'open'
+                CHECK (status IN ('open', 'acknowledged', 'resolved')),
+            send_count INTEGER NOT NULL DEFAULT 0,
+            first_sent_at TEXT,
+            last_sent_at TEXT,
+            created_by TEXT NOT NULL,
+            created_at TEXT NOT NULL,
+            action_link TEXT
+        );
+
+        CREATE INDEX idx_reminders_company ON reminders (company_id);
+        CREATE INDEX idx_reminders_status ON reminders (status);
+
+        CREATE TABLE reminder_events (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            reminder_id INTEGER NOT NULL REFERENCES reminders (id),
+            event_type TEXT NOT NULL CHECK (event_type IN (
+                'sent', 'acknowledged', 'resolved', 'escalated'
+            )),
+            actor TEXT NOT NULL,
+            detail TEXT,
+            created_at TEXT NOT NULL
+        );
+
+        CREATE INDEX idx_reminder_events_reminder ON reminder_events (reminder_id);
+
+        CREATE TRIGGER reminder_events_no_update BEFORE UPDATE ON reminder_events
+            BEGIN SELECT RAISE (ABORT, 'reminder_events rows are append-only'); END;
+        CREATE TRIGGER reminder_events_no_delete BEFORE DELETE ON reminder_events
+            BEGIN SELECT RAISE (ABORT, 'reminder_events rows are append-only'); END;
+        CREATE TRIGGER reminders_no_delete BEFORE DELETE ON reminders
+            BEGIN SELECT RAISE (ABORT, 'reminders rows are immutable history'); END;
+        """,
+        down="""
+        DROP TRIGGER IF EXISTS reminders_no_delete;
+        DROP TRIGGER IF EXISTS reminder_events_no_delete;
+        DROP TRIGGER IF EXISTS reminder_events_no_update;
+        DROP INDEX IF EXISTS idx_reminder_events_reminder;
+        DROP TABLE IF EXISTS reminder_events;
+        DROP INDEX IF EXISTS idx_reminders_status;
+        DROP INDEX IF EXISTS idx_reminders_company;
+        DROP TABLE IF EXISTS reminders;
+        DROP TABLE IF EXISTS reminder_settings;
+        DROP INDEX IF EXISTS idx_reminders_legacy_company;
+        ALTER TABLE reminders_legacy_manual RENAME TO reminders;
+        CREATE INDEX idx_reminders_company ON reminders (company_id);
+        """,
+    ),
+
+    Migration(
+        version=10,
+        name="00010_period_close_reopen",
+        # HEL-196/269: monthly close snapshots, reopen approval, late arrivals
+        # after lock, and an append-only period audit trail. closed_periods
+        # (from 0008) remains the live lock index; this table is the versioned
+        # report history.
+        up="""
+        CREATE TABLE period_close_runs (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            year_month TEXT NOT NULL,
+            version INTEGER NOT NULL,
+            status TEXT NOT NULL CHECK (status IN (
+                'pending', 'closing', 'closed', 'failed', 'reopened'
+            )),
+            snapshot_json TEXT,
+            snapshot_hash TEXT,
+            report_no TEXT,
+            blockers_json TEXT,
+            fail_reason TEXT,
+            closed_at TEXT,
+            closed_by INTEGER REFERENCES users (id),
+            closed_by_username TEXT,
+            reopen_window_end TEXT,
+            created_at TEXT NOT NULL,
+            updated_at TEXT NOT NULL,
+            UNIQUE (year_month, version)
+        );
+
+        CREATE TABLE period_reopen_requests (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            period_close_id INTEGER NOT NULL REFERENCES period_close_runs (id),
+            year_month TEXT NOT NULL,
+            reason TEXT NOT NULL,
+            companies_note TEXT,
+            window_days INTEGER NOT NULL DEFAULT 3,
+            status TEXT NOT NULL CHECK (status IN ('pending', 'approved', 'rejected')),
+            requester_id INTEGER REFERENCES users (id),
+            requester_username TEXT,
+            requested_at TEXT NOT NULL,
+            reviewer_id INTEGER REFERENCES users (id),
+            reviewer_username TEXT,
+            reviewed_at TEXT,
+            review_comment TEXT,
+            before_json TEXT,
+            after_json TEXT
+        );
+
+        CREATE TABLE period_late_arrivals (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            year_month TEXT NOT NULL,
+            source_row_id INTEGER NOT NULL UNIQUE REFERENCES source_rows (id),
+            status TEXT NOT NULL DEFAULT 'open' CHECK (status IN ('open', 'absorbed')),
+            created_at TEXT NOT NULL,
+            actor_user_id INTEGER REFERENCES users (id),
+            actor_username TEXT
+        );
+
+        CREATE TABLE period_audit_events (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            created_at TEXT NOT NULL,
+            actor_user_id INTEGER REFERENCES users (id),
+            actor_username TEXT,
+            actor_role TEXT,
+            action TEXT NOT NULL,
+            year_month TEXT,
+            object_label TEXT,
+            reason TEXT,
+            before_json TEXT,
+            after_json TEXT,
+            report_no TEXT,
+            related_id INTEGER
+        );
+
+        CREATE INDEX idx_period_close_month ON period_close_runs (year_month, version);
+        CREATE INDEX idx_period_reopen_status ON period_reopen_requests (status, year_month);
+        CREATE INDEX idx_period_audit_created ON period_audit_events (created_at);
+
+        CREATE TRIGGER period_audit_no_update BEFORE UPDATE ON period_audit_events
+            BEGIN SELECT RAISE (ABORT, 'period_audit_events rows are append-only'); END;
+        CREATE TRIGGER period_audit_no_delete BEFORE DELETE ON period_audit_events
+            BEGIN SELECT RAISE (ABORT, 'period_audit_events rows are immutable history'); END;
+        CREATE TRIGGER period_close_snapshot_no_update BEFORE UPDATE ON period_close_runs
+            WHEN OLD.snapshot_json IS NOT NULL AND NEW.snapshot_json IS NOT OLD.snapshot_json
+            BEGIN SELECT RAISE (ABORT, 'closed snapshots cannot be rewritten'); END;
+        """,
+        down="""
+        DROP TRIGGER IF EXISTS period_close_snapshot_no_update;
+        DROP TRIGGER IF EXISTS period_audit_no_delete;
+        DROP TRIGGER IF EXISTS period_audit_no_update;
+        DROP INDEX IF EXISTS idx_period_audit_created;
+        DROP INDEX IF EXISTS idx_period_reopen_status;
+        DROP INDEX IF EXISTS idx_period_close_month;
+        DROP TABLE IF EXISTS period_audit_events;
+        DROP TABLE IF EXISTS period_late_arrivals;
+        DROP TABLE IF EXISTS period_reopen_requests;
+        DROP TABLE IF EXISTS period_close_runs;
+        """,
+    ),
 )
 
 
@@ -1023,6 +1208,10 @@ def connect(path: str | Path) -> sqlite3.Connection:
     connection = sqlite3.connect(str(db_path), timeout=30)
     connection.row_factory = sqlite3.Row
     connection.execute("PRAGMA foreign_keys = ON")
+    # WAL lowers write-lock contention on file databases. Skip :memory:
+    # because WAL requires a real file.
+    if str(db_path) != ":memory:":
+        connection.execute("PRAGMA journal_mode=WAL")
     return connection
 
 

src/bank_importer/flows.py

@@ -0,0 +1,172 @@
+"""Server-side flow listing and export from confirmed source rows.
+
+Lists and exports only cashier-confirmed worksheets. Match state is derived
+from current transfer decisions when a source row is claimed; otherwise the
+row is labelled 未归集. Company users only see their own company.
+"""
+
+from __future__ import annotations
+
+from decimal import Decimal, InvalidOperation
+import sqlite3
+
+
+def _dec(value: object) -> Decimal:
+    try:
+        return Decimal(str(value or "0"))
+    except (InvalidOperation, TypeError):
+        return Decimal("0")
+
+
+def _direction(income: object, expense: object) -> tuple[str, Decimal]:
+    income_d = _dec(income)
+    expense_d = _dec(expense)
+    if expense_d > 0 and income_d <= 0:
+        return "付", expense_d
+    return "收", income_d if income_d > 0 else expense_d
+
+
+def _status_label(classification: str | None, pairing: str | None, locked: int | None) -> tuple[str, str]:
+    if classification in ("unresolved", "needs_review"):
+        return "单边", "danger"
+    if classification == "intercompany" and pairing == "paired":
+        return "已归集", "success"
+    if classification == "intercompany" and locked:
+        return "已归集", "success"
+    if classification == "intercompany":
+        return "待确认", "warn"
+    if classification == "same_company":
+        return "同公司调拨", "muted"
+    if classification == "external":
+        return "未归集 · 外部", "muted"
+    if classification:
+        return "未归集", "muted"
+    return "未归集", "muted"
+
+
+def list_flows(
+    connection: sqlite3.Connection,
+    *,
+    company_id: int | None = None,
+    bank: str | None = None,
+    account: str | None = None,
+    start: str | None = None,
+    end: str | None = None,
+    keyword: str | None = None,
+    limit: int = 200,
+    offset: int = 0,
+) -> dict[str, object]:
+    clauses = ["rv.review_status = 'confirmed'"]
+    params: list[object] = []
+    if company_id is not None:
+        clauses.append("b.company_id = ?")
+        params.append(int(company_id))
+    if start:
+        clauses.append("date(r.transaction_at) >= date(?)")
+        params.append(start)
+    if end:
+        clauses.append("date(r.transaction_at) <= date(?)")
+        params.append(end)
+    if account:
+        clauses.append("r.own_account LIKE ?")
+        params.append(f"%{account}%")
+    if bank:
+        clauses.append("(COALESCE(ba.bank_name, '') LIKE ? OR r.own_name LIKE ?)")
+        params.extend([f"%{bank}%", f"%{bank}%"])
+    if keyword:
+        like = f"%{keyword}%"
+        clauses.append(
+            "(r.counterparty_name LIKE ? OR r.summary LIKE ? OR r.reference LIKE ? "
+            "OR r.purpose LIKE ? OR c.name LIKE ?)"
+        )
+        params.extend([like, like, like, like, like])
+    where = " AND ".join(clauses)
+    limit = max(1, min(int(limit), 500))
+    offset = max(0, int(offset))
+    count_row = connection.execute(
+        f"""
+        SELECT COUNT(*) AS n
+        FROM source_rows r
+        JOIN sheet_batches s ON s.id = r.sheet_batch_id
+        JOIN import_batches b ON b.id = s.import_batch_id
+        JOIN sheet_reviews rv ON rv.sheet_batch_id = s.id
+        JOIN companies c ON c.id = b.company_id
+        LEFT JOIN bank_accounts ba ON ba.account_number = r.own_account
+        WHERE {where}
+        """,
+        params,
+    ).fetchone()
+    rows = connection.execute(
+        f"""
+        SELECT r.id, r.transaction_at, r.income, r.expense, r.balance,
+               r.own_account, r.own_name, r.counterparty_account, r.counterparty_name,
+               r.counterparty_bank, r.summary, r.purpose, r.reference, r.currency,
+               b.id AS batch_id, b.company_id, c.name AS company_name,
+               COALESCE(ba.bank_name, '') AS bank_name,
+               s.sheet_name, r.source_row,
+               d.classification, d.pairing, d.locked, d.effective_at
+        FROM source_rows r
+        JOIN sheet_batches s ON s.id = r.sheet_batch_id
+        JOIN import_batches b ON b.id = s.import_batch_id
+        JOIN sheet_reviews rv ON rv.sheet_batch_id = s.id
+        JOIN companies c ON c.id = b.company_id
+        LEFT JOIN bank_accounts ba ON ba.account_number = r.own_account
+        LEFT JOIN transfer_observation_claims toc ON toc.source_row_id = r.id
+        LEFT JOIN transfer_match_decisions d ON d.id = toc.decision_id
+        WHERE {where}
+        ORDER BY r.transaction_at DESC, r.id DESC
+        LIMIT ? OFFSET ?
+        """,
+        [*params, limit, offset],
+    ).fetchall()
+    items = []
+    inflow = Decimal("0")
+    outflow = Decimal("0")
+    for row in rows:
+        direction, amount = _direction(row["income"], row["expense"])
+        if direction == "收":
+            inflow += amount
+        else:
+            outflow += amount
+        status, status_kind = _status_label(
+            row["classification"], row["pairing"], row["locked"]
+        )
+        tail = str(row["own_account"] or "")[-4:]
+        items.append(
+            {
+                "id": int(row["id"]),
+                "date": str(row["transaction_at"] or "")[:10],
+                "time": str(row["transaction_at"] or ""),
+                "company_id": int(row["company_id"]),
+                "company": row["company_name"],
+                "bank": row["bank_name"] or "",
+                "account": row["own_account"],
+                "account_label": (
+                    f"{row['bank_name']} · 尾号 {tail}" if row["bank_name"] and tail else (row["own_account"] or "—")
+                ),
+                "own_name": row["own_name"],
+                "direction": direction,
+                "peer": row["counterparty_name"] or "—",
+                "peer_account": row["counterparty_account"] or "—",
+                "peer_bank": row["counterparty_bank"] or "—",
+                "summary": row["summary"] or row["purpose"] or "—",
+                "serial": row["reference"] or "—",
+                "status": status,
+                "status_kind": status_kind,
+                "amount": str(amount),
+                "balance": str(row["balance"] or ""),
+                "currency": row["currency"] or "CNY",
+                "batch_id": int(row["batch_id"]),
+                "batch": f"IMP-{int(row['batch_id']):06d}",
+                "locator": f"{row['sheet_name']}!R{row['source_row']}",
+                "year_month": str(row["transaction_at"] or "")[:7],
+            }
+        )
+    return {
+        "items": items,
+        "total": int(count_row["n"]),
+        "inflow": str(inflow),
+        "outflow": str(outflow),
+        "limit": limit,
+        "offset": offset,
+    }

src/bank_importer/reminders.py

@@ -0,0 +1,757 @@
+"""Read-only reminder rule engine and delivery helpers.
+
+Scans existing tables to surface pending items; delivery writes append-only
+``reminders`` / ``reminder_events`` rows without touching bank or business data.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from datetime import date, datetime, timedelta, timezone
+import json
+import sqlite3
+from typing import Any
+import uuid
+
+from bank_importer import auth
+from bank_importer.db import utc_now
+
+RULE_UNSUBMITTED = "unsubmitted"
+RULE_GAP = "gap"
+RULE_PENDING = "pending_review"
+RULE_MANUAL = "manual"
+
+SETTING_MONTHLY_START_DAY = "monthly_start_day"
+SETTING_GAP_DAYS = "gap_days"
+SETTING_SCAN_TIME = "scan_time"
+
+DEFAULT_SETTINGS: dict[str, str] = {
+    SETTING_MONTHLY_START_DAY: "5",
+    SETTING_GAP_DAYS: "5",
+    SETTING_SCAN_TIME: "08:00",
+}
+
+RULE_LABELS = {
+    RULE_UNSUBMITTED: "流水未提交",
+    RULE_GAP: "流水断档",
+    RULE_PENDING: "待确认/待审核",
+}
+
+ACTION_LINKS = {
+    RULE_UNSUBMITTED: "upload",
+    RULE_GAP: "flows",
+    RULE_PENDING: "reconcile",
+}
+
+
+@dataclass(frozen=True)
+class ScanFinding:
+    company_id: int
+    company_name: str
+    rule_key: str
+    dedupe_key: str
+    rule_params: dict[str, Any]
+    title: str
+    content: str
+    reason: str
+    days_open: int
+    deadline: str | None
+    action_link: str
+    existing_reminder_id: int | None
+    send_count: int
+
+
+def _today() -> date:
+    return datetime.now(timezone.utc).date()
+
+
+def get_settings(connection: sqlite3.Connection) -> dict[str, str]:
+    rows = connection.execute("SELECT key, value FROM reminder_settings").fetchall()
+    settings = dict(DEFAULT_SETTINGS)
+    for row in rows:
+        settings[row["key"]] = row["value"]
+    return settings
+
+
+def _valid_scan_time(value: str) -> bool:
+    parts = value.strip().split(":")
+    if len(parts) != 2 or not parts[0].isdigit() or not parts[1].isdigit():
+        return False
+    if len(parts[1]) != 2:
+        return False
+    hour, minute = int(parts[0]), int(parts[1])
+    return 0 <= hour <= 23 and 0 <= minute <= 59
+
+
+def validate_setting(key: str, value: str) -> str:
+    raw = str(value).strip()
+    if key == SETTING_MONTHLY_START_DAY:
+        try:
+            day = int(raw)
+        except ValueError as exc:
+            raise ValueError("每月起始日须为 1 到 28 的整数。") from exc
+        if day < 1 or day > 28:
+            raise ValueError("每月起始日须为 1 到 28 的整数。")
+        return str(day)
+    if key == SETTING_GAP_DAYS:
+        try:
+            days = int(raw)
+        except ValueError as exc:
+            raise ValueError("断档天数须为大于等于 1 的整数。") from exc
+        if days < 1:
+            raise ValueError("断档天数须为大于等于 1 的整数。")
+        return str(days)
+    if key == SETTING_SCAN_TIME:
+        if not _valid_scan_time(raw):
+            raise ValueError("扫描时间须为合法的 HH:MM。")
+        hour, minute = raw.split(":")
+        return f"{int(hour):02d}:{minute}"
+    raise ValueError(f"unknown setting: {key}")
+
+
+def update_settings(connection: sqlite3.Connection, updates: dict[str, str]) -> dict[str, str]:
+    allowed = set(DEFAULT_SETTINGS)
+    cleaned: dict[str, str] = {}
+    for key, value in updates.items():
+        if key not in allowed:
+            raise ValueError(f"unknown setting: {key}")
+        cleaned[key] = validate_setting(key, value)
+    now = utc_now()
+    with connection:
+        for key, value in cleaned.items():
+            connection.execute(
+                """
+                INSERT INTO reminder_settings (key, value, updated_at)
+                VALUES (?, ?, ?)
+                ON CONFLICT(key) DO UPDATE SET value = excluded.value, updated_at = excluded.updated_at
+                """,
+                (key, value, now),
+            )
+    return get_settings(connection)
+
+
+def _setting_int(settings: dict[str, str], key: str) -> int:
+    try:
+        return int(validate_setting(key, settings.get(key, DEFAULT_SETTINGS[key])))
+    except (TypeError, ValueError):
+        return int(DEFAULT_SETTINGS[key])
+
+
+def _month_period(day: date | None = None) -> str:
+    ref = day or _today()
+    return f"{ref.year:04d}-{ref.month:02d}"
+
+
+def _parse_date(value: str | None) -> date | None:
+    if not value:
+        return None
+    try:
+        return date.fromisoformat(value[:10])
+    except ValueError:
+        return None
+
+
+def _days_between(start: date, end: date) -> int:
+    return max(0, (end - start).days)
+
+
+def _duration_pill_class(days: int) -> str:
+    if days >= 7:
+        return "pill-danger"
+    if days >= 3:
+        return "pill-warn"
+    return "pill-muted"
+
+
+def _existing_reminder(connection: sqlite3.Connection, dedupe_key: str) -> sqlite3.Row | None:
+    return connection.execute(
+        """
+        SELECT id, send_count, status, last_sent_at
+        FROM reminders
+        WHERE dedupe_key = ? AND status != 'resolved'
+        """,
+        (dedupe_key,),
+    ).fetchone()
+
+
+def _company_has_month_batch(connection: sqlite3.Connection, company_id: int, period: str) -> bool:
+    year, month = period.split("-")
+    prefix = f"{year}-{month}"
+    row = connection.execute(
+        """
+        SELECT 1
+        FROM import_batches b
+        JOIN sheet_batches s ON s.import_batch_id = b.id
+        WHERE b.company_id = ?
+          AND (
+              substr(s.period_start, 1, 7) = ?
+              OR substr(s.period_end, 1, 7) = ?
+              OR (s.period_start <= ? || '-31' AND s.period_end >= ? || '-01')
+          )
+        LIMIT 1
+        """,
+        (company_id, prefix, prefix, prefix, prefix),
+    ).fetchone()
+    return row is not None
+
+
+def _latest_batch_end(connection: sqlite3.Connection, company_id: int) -> date | None:
+    row = connection.execute(
+        """
+        SELECT MAX(s.period_end) AS latest_end
+        FROM import_batches b
+        JOIN sheet_batches s ON s.import_batch_id = b.id
+        WHERE b.company_id = ?
+        """,
+        (company_id,),
+    ).fetchone()
+    return _parse_date(row["latest_end"] if row else None)
+
+
+def _pending_review_count(connection: sqlite3.Connection, company_id: int) -> int:
+    match_count = connection.execute(
+        """
+        SELECT COUNT(DISTINCT e.id)
+        FROM canonical_transfer_events e
+        JOIN current_transfer_decisions c ON c.event_id = e.id
+        JOIN transfer_match_decisions d ON d.id = c.decision_id
+        JOIN transfer_decision_participants payer ON payer.decision_id = d.id AND payer.role = 'payer'
+        JOIN transfer_decision_participants payee ON payee.decision_id = d.id AND payee.role = 'payee'
+        WHERE e.lifecycle = 'active'
+          AND d.classification IN ('unresolved', 'needs_review')
+          AND (payer.company_id = ? OR payee.company_id = ?)
+        """,
+        (company_id, company_id),
+    ).fetchone()[0]
+    sheet_count = connection.execute(
+        """
+        SELECT COUNT(*)
+        FROM sheet_reviews r
+        JOIN import_batches b ON b.id = r.import_batch_id
+        WHERE b.company_id = ?
+          AND r.outcome = 'parsed'
+          AND r.review_status = 'pending'
+        """,
+        (company_id,),
+    ).fetchone()[0]
+    account_count = connection.execute(
+        """
+        SELECT COUNT(*) FROM bank_accounts
+        WHERE company_id = ? AND status = 'pending'
+        """,
+        (company_id,),
+    ).fetchone()[0]
+    return int(match_count) + int(sheet_count) + int(account_count)
+
+
+def _active_companies(connection: sqlite3.Connection) -> list[sqlite3.Row]:
+    return connection.execute(
+        """
+        SELECT id, name FROM companies
+        WHERE COALESCE(status, 'active') != 'disabled'
+        ORDER BY name
+        """
+    ).fetchall()
+
+
+def scan_findings(connection: sqlite3.Connection) -> list[ScanFinding]:
+    settings = get_settings(connection)
+    today = _today()
+    period = _month_period(today)
+    monthly_start = _setting_int(settings, SETTING_MONTHLY_START_DAY)
+    gap_days = _setting_int(settings, SETTING_GAP_DAYS)
+    findings: list[ScanFinding] = []
+
+    for company in _active_companies(connection):
+        company_id = int(company["id"])
+        company_name = company["name"]
+
+        if today.day >= monthly_start and not _company_has_month_batch(connection, company_id, period):
+            dedupe_key = f"{company_id}:{RULE_UNSUBMITTED}:{period}"
+            days_open = _days_between(date(today.year, today.month, monthly_start), today)
+            existing = _existing_reminder(connection, dedupe_key)
+            findings.append(
+                ScanFinding(
+                    company_id=company_id,
+                    company_name=company_name,
+                    rule_key=RULE_UNSUBMITTED,
+                    dedupe_key=dedupe_key,
+                    rule_params={"period": period},
+                    title=f"{company_name} · {today.month} 月流水未提交",
+                    content=(
+                        f"贵公司 {period} 银行流水尚未提交。"
+                        f"请于截止日前完成全部账户流水上传。"
+                    ),
+                    reason=f"应交 {today.month:02d}-{monthly_start:02d} · 已逾期 {days_open} 天",
+                    days_open=days_open,
+                    deadline=None,
+                    action_link=ACTION_LINKS[RULE_UNSUBMITTED],
+                    existing_reminder_id=int(existing["id"]) if existing else None,
+                    send_count=int(existing["send_count"]) if existing else 0,
+                )
+            )
+
+        latest_end = _latest_batch_end(connection, company_id)
+        if latest_end is not None:
+            gap = _days_between(latest_end, today)
+            if gap > gap_days:
+                dedupe_key = f"{company_id}:{RULE_GAP}:{latest_end.isoformat()}"
+                existing = _existing_reminder(connection, dedupe_key)
+                findings.append(
+                    ScanFinding(
+                        company_id=company_id,
+                        company_name=company_name,
+                        rule_key=RULE_GAP,
+                        dedupe_key=dedupe_key,
+                        rule_params={"latest_end": latest_end.isoformat(), "gap_days": gap},
+                        title=f"{company_name} · 流水断档 {gap} 天",
+                        content=(
+                            f"最近流水截止日为 {latest_end.isoformat()}，"
+                            f"已连续 {gap} 天无新数据，请补传断档期间银行流水。"
+                        ),
+                        reason=f"最近截止 {latest_end.strftime('%m-%d')} · 断档 {gap} 天",
+                        days_open=gap,
+                        deadline=None,
+                        action_link=ACTION_LINKS[RULE_GAP],
+                        existing_reminder_id=int(existing["id"]) if existing else None,
+                        send_count=int(existing["send_count"]) if existing else 0,
+                    )
+                )
+
+        pending_count = _pending_review_count(connection, company_id)
+        if pending_count > 0:
+            dedupe_key = f"{company_id}:{RULE_PENDING}:active"
+            existing = _existing_reminder(connection, dedupe_key)
+            first_seen = _parse_date(existing["last_sent_at"][:10] if existing and existing["last_sent_at"] else None)
+            days_open = _days_between(first_seen, today) if first_seen else 0
+            findings.append(
+                ScanFinding(
+                    company_id=company_id,
+                    company_name=company_name,
+                    rule_key=RULE_PENDING,
+                    dedupe_key=dedupe_key,
+                    rule_params={"pending_count": pending_count},
+                    title=f"{company_name} · {pending_count} 项待确认/待审核",
+                    content=(
+                        f"贵公司当前有 {pending_count} 项往来确认、流水审核或账户登记待处理，"
+                        f"请尽快完成确认以免影响结账。"
+                    ),
+                    reason=f"待处理 {pending_count} 项",
+                    days_open=days_open,
+                    deadline=None,
+                    action_link=ACTION_LINKS[RULE_PENDING],
+                    existing_reminder_id=int(existing["id"]) if existing else None,
+                    send_count=int(existing["send_count"]) if existing else 0,
+                )
+            )
+
+    findings.sort(key=lambda item: item.days_open, reverse=True)
+    return findings
+
+
+def run_scan(
+    connection: sqlite3.Connection,
+    *,
+    actor: sqlite3.Row | None = None,
+    ip: str | None = None,
+) -> dict[str, Any]:
+    findings = scan_findings(connection)
+    counts = {
+        RULE_UNSUBMITTED: sum(1 for f in findings if f.rule_key == RULE_UNSUBMITTED),
+        RULE_GAP: sum(1 for f in findings if f.rule_key == RULE_GAP),
+        RULE_PENDING: sum(1 for f in findings if f.rule_key == RULE_PENDING),
+    }
+    auth.audit(
+        connection,
+        "reminder_scan",
+        actor=actor,
+        detail=json.dumps({"total": len(findings), "by_rule": counts}, ensure_ascii=False),
+        ip=ip,
+    )
+    return {"findings": findings, "counts": counts}
+
+
+def finding_to_dict(finding: ScanFinding) -> dict[str, Any]:
+    return {
+        "company_id": finding.company_id,
+        "company_name": finding.company_name,
+        "rule_key": finding.rule_key,
+        "rule_label": RULE_LABELS.get(finding.rule_key, finding.rule_key),
+        "dedupe_key": finding.dedupe_key,
+        "rule_params": finding.rule_params,
+        "title": finding.title,
+        "content": finding.content,
+        "reason": finding.reason,
+        "days_open": finding.days_open,
+        "duration_pill": _duration_pill_class(finding.days_open),
+        "deadline": finding.deadline,
+        "action_link": finding.action_link,
+        "existing_reminder_id": finding.existing_reminder_id,
+        "send_count": finding.send_count,
+    }
+
+
+def _append_event(
+    connection: sqlite3.Connection,
+    reminder_id: int,
+    event_type: str,
+    actor: str,
+    detail: str | None = None,
+) -> None:
+    connection.execute(
+        """
+        INSERT INTO reminder_events (reminder_id, event_type, actor, detail, created_at)
+        VALUES (?, ?, ?, ?, ?)
+        """,
+        (reminder_id, event_type, actor, detail, utc_now()),
+    )
+
+
+def _actor_label(actor: sqlite3.Row | None) -> str:
+    if actor is None:
+        return "system"
+    return str(actor["id"])
+
+
+def deliver_finding(
+    connection: sqlite3.Connection,
+    dedupe_key: str,
+    *,
+    actor: sqlite3.Row | None = None,
+    ip: str | None = None,
+) -> int | None:
+    findings = {item.dedupe_key: item for item in scan_findings(connection)}
+    finding = findings.get(dedupe_key)
+    if finding is None:
+        return None
+    return _deliver(connection, finding, actor=actor, ip=ip)
+
+
+def _deliver(
+    connection: sqlite3.Connection,
+    finding: ScanFinding,
+    *,
+    actor: sqlite3.Row | None = None,
+    ip: str | None = None,
+) -> int:
+    now = utc_now()
+    actor_ref = _actor_label(actor)
+    existing = connection.execute(
+        "SELECT id, send_count, status FROM reminders WHERE dedupe_key = ?",
+        (finding.dedupe_key,),
+    ).fetchone()
+
+    with connection:
+        if existing is not None:
+            reminder_id = int(existing["id"])
+            send_count = int(existing["send_count"]) + 1
+            connection.execute(
+                """
+                UPDATE reminders
+                SET send_count = ?, last_sent_at = ?, status = 'open',
+                    title = ?, content = ?, rule_params = ?, action_link = ?
+                WHERE id = ?
+                """,
+                (
+                    send_count,
+                    now,
+                    finding.title,
+                    finding.content,
+                    json.dumps(finding.rule_params, ensure_ascii=False),
+                    finding.action_link,
+                    reminder_id,
+                ),
+            )
+            event_type = "sent" if existing["status"] == "resolved" else (
+                "escalated" if send_count > 1 else "sent"
+            )
+            _append_event(
+                connection,
+                reminder_id,
+                event_type,
+                actor_ref,
+                f"第 {send_count} 次催办",
+            )
+        else:
+            connection.execute(
+                """
+                INSERT INTO reminders (
+                    company_id, rule_key, dedupe_key, rule_params, title, content,
+                    deadline, source, status, send_count, first_sent_at, last_sent_at,
+                    created_by, created_at, action_link
+                ) VALUES (?, ?, ?, ?, ?, ?, ?, 'auto', 'open', 1, ?, ?, ?, ?, ?)
+                """,
+                (
+                    finding.company_id,
+                    finding.rule_key,
+                    finding.dedupe_key,
+                    json.dumps(finding.rule_params, ensure_ascii=False),
+                    finding.title,
+                    finding.content,
+                    finding.deadline,
+                    now,
+                    now,
+                    actor_ref,
+                    now,
+                    finding.action_link,
+                ),
+            )
+            reminder_id = int(connection.execute("SELECT last_insert_rowid()").fetchone()[0])
+            _append_event(connection, reminder_id, "sent", actor_ref, finding.reason)
+
+        auth.audit(
+            connection,
+            "reminder_send",
+            actor=actor,
+            target=f"reminder:{reminder_id}",
+            detail=finding.dedupe_key,
+            ip=ip,
+        )
+    return reminder_id
+
+
+def deliver_many(
+    connection: sqlite3.Connection,
+    dedupe_keys: list[str],
+    *,
+    actor: sqlite3.Row | None = None,
+    ip: str | None = None,
+) -> list[int]:
+    sent: list[int] = []
+    for key in dedupe_keys:
+        try:
+            reminder_id = deliver_finding(connection, key, actor=actor, ip=ip)
+        except Exception:
+            continue
+        if reminder_id is not None:
+            sent.append(reminder_id)
+    return sent
+
+
+def send_manual(
+    connection: sqlite3.Connection,
+    *,
+    company_id: int,
+    display_type: str,
+    content: str,
+    deadline: str | None,
+    actor: sqlite3.Row,
+    ip: str | None = None,
+) -> int:
+    company = connection.execute(
+        "SELECT name FROM companies WHERE id = ?", (company_id,)
+    ).fetchone()
+    if company is None:
+        raise ValueError("company not found")
+    now = utc_now()
+    dedupe_key = f"{company_id}:{RULE_MANUAL}:{uuid.uuid4().hex}"
+    title = f"{company['name']} · {display_type}"
+    with connection:
+        connection.execute(
+            """
+            INSERT INTO reminders (
+                company_id, rule_key, dedupe_key, rule_params, title, content,
+                deadline, source, status, send_count, first_sent_at, last_sent_at,
+                created_by, created_at, action_link
+            ) VALUES (?, ?, ?, ?, ?, ?, ?, 'manual', 'open', 1, ?, ?, ?, ?, NULL)
+            """,
+            (
+                company_id,
+                RULE_MANUAL,
+                dedupe_key,
+                json.dumps({"display_type": display_type}, ensure_ascii=False),
+                title,
+                content,
+                deadline,
+                now,
+                now,
+                str(actor["id"]),
+                now,
+            ),
+        )
+        reminder_id = int(connection.execute("SELECT last_insert_rowid()").fetchone()[0])
+        _append_event(connection, reminder_id, "sent", str(actor["id"]), display_type)
+        auth.audit(
+            connection,
+            "reminder_send_manual",
+            actor=actor,
+            target=f"reminder:{reminder_id}",
+            detail=display_type,
+            ip=ip,
+        )
+    return reminder_id
+
+
+def resend_reminder(
+    connection: sqlite3.Connection,
+    reminder_id: int,
+    *,
+    actor: sqlite3.Row,
+    ip: str | None = None,
+) -> None:
+    row = connection.execute(
+        "SELECT id, send_count, status FROM reminders WHERE id = ?", (reminder_id,)
+    ).fetchone()
+    if row is None or row["status"] == "resolved":
+        raise ValueError("reminder not available")
+    now = utc_now()
+    send_count = int(row["send_count"]) + 1
+    with connection:
+        connection.execute(
+            """
+            UPDATE reminders
+            SET send_count = ?, last_sent_at = ?, status = 'open'
+            WHERE id = ?
+            """,
+            (send_count, now, reminder_id),
+        )
+        _append_event(
+            connection,
+            reminder_id,
+            "escalated",
+            str(actor["id"]),
+            f"第 {send_count} 次催办",
+        )
+        auth.audit(
+            connection,
+            "reminder_resend",
+            actor=actor,
+            target=f"reminder:{reminder_id}",
+            ip=ip,
+        )
+
+
+def _reminder_row_to_dict(row: sqlite3.Row, *, company_name: str | None = None) -> dict[str, Any]:
+    params = json.loads(row["rule_params"]) if row["rule_params"] else {}
+    rule_key = row["rule_key"]
+    display_type = params.get("display_type") if rule_key == RULE_MANUAL else RULE_LABELS.get(rule_key, rule_key)
+    status = row["status"]
+    status_ui = {"open": "unread", "acknowledged": "doing", "resolved": "done"}[status]
+    return {
+        "id": row["id"],
+        "company_id": row["company_id"],
+        "company_name": company_name or row["company_name"],
+        "rule_key": rule_key,
+        "display_type": display_type,
+        "title": row["title"],
+        "content": row["content"],
+        "deadline": row["deadline"],
+        "source": row["source"],
+        "status": status,
+        "status_ui": status_ui,
+        "send_count": row["send_count"],
+        "first_sent_at": row["first_sent_at"],
+        "last_sent_at": row["last_sent_at"],
+        "created_by": row["created_by"],
+        "created_at": row["created_at"],
+        "action_link": row["action_link"],
+        "rule_params": params,
+    }
+
+
+def list_admin_reminders(
+    connection: sqlite3.Connection,
+    *,
+    source: str | None = None,
+) -> list[dict[str, Any]]:
+    conditions = ["r.send_count > 0"]
+    params: list[Any] = []
+    if source in {"auto", "manual"}:
+        conditions.append("r.source = ?")
+        params.append(source)
+    where = " AND ".join(conditions)
+    rows = connection.execute(
+        f"""
+        SELECT r.*, c.name AS company_name
+        FROM reminders r
+        JOIN companies c ON c.id = r.company_id
+        WHERE {where}
+        ORDER BY r.last_sent_at DESC, r.id DESC
+        """,
+        params,
+    ).fetchall()
+    return [_reminder_row_to_dict(row) for row in rows]
+
+
+def list_company_reminders(connection: sqlite3.Connection, company_id: int) -> list[dict[str, Any]]:
+    rows = connection.execute(
+        """
+        SELECT r.*, c.name AS company_name
+        FROM reminders r
+        JOIN companies c ON c.id = r.company_id
+        WHERE r.company_id = ? AND r.send_count > 0
+        ORDER BY
+            CASE r.status WHEN 'open' THEN 0 WHEN 'acknowledged' THEN 1 ELSE 2 END,
+            r.last_sent_at DESC
+        """,
+        (company_id,),
+    ).fetchall()
+    return [_reminder_row_to_dict(row) for row in rows]
+
+
+def get_reminder_detail(connection: sqlite3.Connection, reminder_id: int) -> dict[str, Any] | None:
+    row = connection.execute(
+        """
+        SELECT r.*, c.name AS company_name
+        FROM reminders r
+        JOIN companies c ON c.id = r.company_id
+        WHERE r.id = ?
+        """,
+        (reminder_id,),
+    ).fetchone()
+    if row is None:
+        return None
+    events = connection.execute(
+        """
+        SELECT event_type, actor, detail, created_at
+        FROM reminder_events
+        WHERE reminder_id = ?
+        ORDER BY id
+        """,
+        (reminder_id,),
+    ).fetchall()
+    payload = _reminder_row_to_dict(row)
+    payload["events"] = [dict(item) for item in events]
+    return payload
+
+
+def update_reminder_status(
+    connection: sqlite3.Connection,
+    reminder_id: int,
+    new_status: str,
+    *,
+    company_id: int | None = None,
+    actor: sqlite3.Row | None = None,
+) -> bool:
+    if new_status not in {"acknowledged", "resolved"}:
+        raise ValueError("invalid status")
+    row = connection.execute(
+        "SELECT id, company_id, status FROM reminders WHERE id = ?",
+        (reminder_id,),
+    ).fetchone()
+    if row is None:
+        return False
+    if company_id is not None and int(row["company_id"]) != company_id:
+        return False
+    if row["status"] == "resolved":
+        return False
+    event_type = "acknowledged" if new_status == "acknowledged" else "resolved"
+    actor_ref = _actor_label(actor)
+    with connection:
+        connection.execute(
+            "UPDATE reminders SET status = ? WHERE id = ?",
+            (new_status, reminder_id),
+        )
+        _append_event(connection, reminder_id, event_type, actor_ref, None)
+    return True
+
+
+def company_unread_count(connection: sqlite3.Connection, company_id: int) -> int:
+    row = connection.execute(
+        """
+        SELECT COUNT(*) AS n FROM reminders
+        WHERE company_id = ? AND status = 'open' AND send_count > 0
+        """,
+        (company_id,),
+    ).fetchone()
+    return int(row["n"])

src/bank_importer/settings.py

@@ -1,20 +1,20 @@
-"""System settings and reminder item generation.
+"""System settings.
 
 System-wide parameters (closing day, global start date, auto-reminder toggle
 and lead days) are persisted in ``system_settings`` with an append-only
-``system_setting_changes`` trail. Reminder pending items are derived from real
-backend data (per-sheet reviews, bank accounts, canonical transfer decisions)
-rather than hard-coded rosters.
+``system_setting_changes`` trail. The auto-reminder engine itself lives in
+``reminders.py`` (HEL-195); this module only owns the settings store.
 """
 
 from __future__ import annotations
 
 import re
 import sqlite3
-from datetime import datetime, timezone
+from datetime import datetime
 
 from .db import utc_now
 
+
 # Defaults are applied when a key is absent; the value type is always string.
 DEFAULT_SETTINGS: dict[str, str] = {
     "closing_day": "5",
@@ -131,179 +131,3 @@ def update_settings(
 # ----------------------------------------------------------------------
 # Reminder pending items
 # ----------------------------------------------------------------------
-
-def _current_period() -> tuple[str, str]:
-    """Return the current calendar month as ``(start, end_exclusive)`` dates."""
-    today = datetime.now(timezone.utc)
-    start = today.strftime("%Y-%m-01")
-    year, month = today.year, today.month
-    if month == 12:
-        end = f"{year + 1}-01-01"
-    else:
-        end = f"{year}-{month + 1:02d}-01"
-    return start, end
-
-
-def pending_items(connection: sqlite3.Connection, company_id: int) -> list[dict[str, str]]:
-    """Derive the list of pending reminder items for one company."""
-    items: list[dict[str, str]] = []
-
-    company = connection.execute(
-        "SELECT id, name FROM companies WHERE id = ?", (company_id,)
-    ).fetchone()
-    if company is None:
-        return items
-
-    period_start, _ = _current_period()
-
-    # 1) 本月流水未提交：有已启用账户，但本月没有任何已确认的工作表。
-    active_accounts = connection.execute(
-        """
-        SELECT id, account_number FROM bank_accounts
-        WHERE company_id = ? AND status = 'active'
-        """,
-        (company_id,),
-    ).fetchall()
-    confirmed_this_period = connection.execute(
-        """
-        SELECT COUNT(*) AS n
-        FROM sheet_reviews rv
-        JOIN import_batches b ON b.id = rv.import_batch_id
-        WHERE b.company_id = ? AND rv.review_status = 'confirmed'
-          AND rv.sheet_batch_id IN (
-              SELECT id FROM sheet_batches s
-              WHERE s.period_end >= ?
-          )
-        """,
-        (company_id, period_start),
-    ).fetchone()["n"]
-    if active_accounts and confirmed_this_period == 0:
-        items.append(
-            {
-                "kind": "流水未提交",
-                "content": "本月各银行账户流水尚未提交，请尽快上传本月银行流水。",
-            }
-        )
-
-    # 2) 待确认工作表：仍有未确认的解析结果。
-    pending_sheets = connection.execute(
-        """
-        SELECT COUNT(*) AS n
-        FROM sheet_reviews rv
-        JOIN import_batches b ON b.id = rv.import_batch_id
-        WHERE b.company_id = ? AND rv.review_status = 'pending'
-        """,
-        (company_id,),
-    ).fetchone()["n"]
-    if pending_sheets:
-        items.append(
-            {
-                "kind": "待确认工作表",
-                "content": f"有 {pending_sheets} 个导入工作表尚未确认，请核对后确认。",
-            }
-        )
-
-    # 3) 待审核账户登记：处于待复核状态的银行账户。
-    pending_accounts = connection.execute(
-        """
-        SELECT COUNT(*) AS n FROM bank_accounts
-        WHERE company_id = ? AND status = 'pending'
-        """,
-        (company_id,),
-    ).fetchone()["n"]
-    if pending_accounts:
-        items.append(
-            {
-                "kind": "账户登记",
-                "content": f"有 {pending_accounts} 个银行账户登记待审核。",
-            }
-        )
-
-    # 4) 待确认往来事项：尚未解决的往来匹配。
-    pending_transfers = connection.execute(
-        """
-        SELECT COUNT(*) AS n
-        FROM current_transfer_decisions c
-        JOIN transfer_match_decisions d ON d.id = c.decision_id
-        JOIN transfer_decision_participants p
-             ON p.decision_id = d.id AND p.company_id = ?
-        WHERE d.classification IN ('unresolved', 'needs_review')
-        """,
-        (company_id,),
-    ).fetchone()["n"]
-    if pending_transfers:
-        items.append(
-            {
-                "kind": "往来待确认",
-                "content": f"有 {pending_transfers} 项往来流水待确认，请核对对方银行流水佐证。",
-            }
-        )
-
-    return items
-
-
-def send_reminders(
-    connection: sqlite3.Connection,
-    company_id: int,
-    actor: sqlite3.Row,
-) -> tuple[list[dict[str, str]], str | None]:
-    """Create reminder rows for a company's pending items.
-
-    Returns ``(created, deadline)``. ``created`` is the list of persisted
-    reminder payloads; ``deadline`` is derived from the closing-day setting.
-    """
-    items = pending_items(connection, company_id)
-    if not items:
-        return [], None
-
-    settings = get_settings(connection)
-    try:
-        closing_day = int(settings["closing_day"])
-    except ValueError:
-        closing_day = 5
-    today = datetime.now(timezone.utc)
-    # Deadline: next month's closing day (current month if today is before it).
-    if today.day < closing_day:
-        deadline = today.strftime(f"%Y-%m-{closing_day:02d}")
-    else:
-        year, month = today.year, today.month
-        if month == 12:
-            year, month = year + 1, 1
-        else:
-            month += 1
-        deadline = f"{year}-{month:02d}-{closing_day:02d}"
-
-    created: list[dict[str, str]] = []
-    with connection:
-        for item in items:
-            cursor = connection.execute(
-                """
-                INSERT INTO reminders (
-                    company_id, kind, content, deadline, source,
-                    actor_user_id, actor_username, created_at
-                ) VALUES (?, ?, ?, ?, 'manual', ?, ?, ?)
-                """,
-                (
-                    company_id,
-                    item["kind"],
-                    item["content"],
-                    deadline,
-                    actor["id"],
-                    actor["username"],
-                    utc_now(),
-                ),
-            )
-            created.append(
-                {
-                    "id": cursor.lastrowid,
-                    "company_id": company_id,
-                    "kind": item["kind"],
-                    "content": item["content"],
-                    "deadline": deadline,
-                    "source": "manual",
-                    "status": "unread",
-                    "actor_username": actor["username"],
-                    "created_at": utc_now(),
-                }
-            )
-    return created, deadline

tests/test_company_confirm_status_color.py

@@ -50,7 +50,7 @@ class ConfirmStatusSourceContractTests(unittest.TestCase):
         self.assertIn('id="workspacePendingStatus"', html)
         self.assertIn('id="workspaceFlowSub"', html)
         self.assertIn('data-view-link="reconcile"', html)
-        self.assertIn("app.js?v=13", html)
+        self.assertIn("app.js?v=15", html)
         # 静态初值仍为进行中（黄），由 JS 在 pending=0 时切 done
         self.assertRegex(html, r'class="flow-step doing"[^>]*data-view-link="reconcile"')
 

tests/test_company_transfers_page.py

@@ -31,8 +31,8 @@ class TransfersPageSourceContractTests(unittest.TestCase):
         self.assertIn('id="transferEvidenceDrawer"', html)
         self.assertIn("期间净变动", html)
         self.assertNotIn("本公司往来合计", html)
-        self.assertIn("design-system.css?v=6", html)
-        self.assertIn("app.js?v=13", html)
+        self.assertIn("design-system.css?v=7", html)
+        self.assertIn("app.js?v=15", html)
         # 侧栏顺序：流水管理 → 转账往来 → 往来确认
         flows = html.index('data-view="flows"')
         transfers = html.index('data-view="transfers"')
@@ -54,6 +54,10 @@ class TransfersPageSourceContractTests(unittest.TestCase):
         self.assertIn("initTransfers()", js)
         self.assertIn("期间净变动", js)
         self.assertIn("has_opening", js)
+        self.assertNotIn("FLOW_DEMO", js)
+        self.assertNotIn("COMPANY_FLOWS", js)
+        self.assertNotIn("IMP-DEMO", js)
+        self.assertNotIn("ledger-demo-manual-records", js)
         # 不得把「期末余额」写死为无期初时的标签
         self.assertNotRegex(js, r'netLabelForWindow[^{]+{[^}]*return "期末余额"')
 
@@ -112,10 +116,8 @@ class TransfersPageLayoutSmokeTests(unittest.TestCase):
             page = browser.new_page()
             for width in (360, 820, 1440):
                 page.set_viewport_size({"width": width, "height": 900})
-                page.set_content(
-                    html.replace('src="app.js?v=13"', 'src=""'),
-                    base_url=self.base,
-                )
+                page.route("**/app.js**", lambda route: route.abort())
+                page.goto(f"{self.base}/company.html")
                 page.evaluate(
                     """() => {
                       document.querySelectorAll('.app-view').forEach((el) => {

tests/test_period_close.py

@@ -0,0 +1,198 @@
+"""Monthly close, reopen approval, snapshot hash and locked-period writes."""
+
+from __future__ import annotations
+
+from datetime import date
+import hashlib
+import json
+from pathlib import Path
+import sys
+import unittest
+
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+
+from bank_importer import period_close
+from ledger_helpers import LedgerBase
+
+
+class PeriodCloseTests(LedgerBase):
+    TODAY = date(2026, 8, 30)
+    MONTH = "2026-07"
+
+    def _cover_month(self) -> None:
+        self.add_row(
+            self.company_a, own_account="6222000000000001",
+            expense="100.00", at="2026-07-10T10:00:00",
+        )
+        self.add_row(
+            self.company_b, own_account="6222000000000002",
+            income="80.00", at="2026-07-12T10:00:00",
+        )
+
+    def _close(self, month: str = MONTH):
+        period_close.ensure_pending_tasks(self.connection, today=self.TODAY)
+        return period_close.execute_close(
+            self.connection, month, self.admin, confirm=True,
+        )
+
+    def test_execute_requires_confirm_checkbox(self) -> None:
+        self._cover_month()
+        with self.assertRaises(period_close.PeriodCloseError) as ctx:
+            period_close.execute_close(
+                self.connection, self.MONTH, self.admin, confirm=False,
+            )
+        self.assertIn("勾选", str(ctx.exception))
+
+    def test_blockers_reject_close(self) -> None:
+        period_close.ensure_pending_tasks(self.connection, today=self.TODAY)
+        evaluation = period_close.evaluate_preconditions(self.connection, self.MONTH)
+        self.assertFalse(evaluation["ready"])
+        with self.assertRaises(period_close.PeriodCloseError):
+            period_close.execute_close(
+                self.connection, self.MONTH, self.admin, confirm=True,
+            )
+
+    def test_close_snapshot_hash_stable_and_idempotent(self) -> None:
+        self._cover_month()
+        period_close.ensure_pending_tasks(self.connection, today=self.TODAY)
+        before = period_close.build_snapshot(self.connection, self.MONTH)
+        digest_before = hashlib.sha256(
+            json.dumps(before, ensure_ascii=False, sort_keys=True, separators=(",", ":")).encode("utf-8")
+        ).hexdigest()
+        first = period_close.execute_close(
+            self.connection, self.MONTH, self.admin, confirm=True,
+        )
+        self.assertEqual("closed", first["status"])
+        self.assertTrue(first["report_no"].startswith("MR-202607-"))
+        digest = first["snapshot_hash"]
+        self.assertEqual(64, len(digest))
+        self.assertEqual(digest_before, digest)
+        run = self.connection.execute(
+            "SELECT snapshot_json, snapshot_hash FROM period_close_runs WHERE year_month = ?",
+            (self.MONTH,),
+        ).fetchone()
+        self.assertEqual(digest, run["snapshot_hash"])
+        self.assertEqual(
+            digest,
+            hashlib.sha256(run["snapshot_json"].encode("utf-8")).hexdigest(),
+        )
+        self.assertEqual(
+            digest,
+            hashlib.sha256(run["snapshot_json"].encode("utf-8")).hexdigest(),
+        )
+        with self.assertRaises(period_close.PeriodConflictError):
+            period_close.execute_close(
+                self.connection, self.MONTH, self.admin, confirm=True,
+            )
+
+    def test_locked_month_rejects_writes(self) -> None:
+        self._cover_month()
+        self._close()
+        with self.assertRaises(period_close.PeriodLockedError) as ctx:
+            period_close.assert_date_writable(self.connection, "2026-07-15")
+        self.assertIn("2026-07", str(ctx.exception))
+        self.assertIn("已结账锁定", str(ctx.exception))
+        period_close.assert_date_writable(self.connection, "2026-08-01")
+
+    def test_late_arrivals_do_not_rewrite_snapshot(self) -> None:
+        self._cover_month()
+        closed = self._close()
+        digest = closed["snapshot_hash"]
+        late_id = self.add_row(
+            self.company_a, own_account="6222000000000001",
+            expense="12.00", at="2026-07-28T11:00:00",
+        )
+        writable, locked = period_close.split_writable_row_ids(self.connection, [late_id])
+        self.assertEqual([], writable)
+        self.assertEqual([(late_id, "2026-07")], locked)
+        n = period_close.record_late_arrivals(self.connection, locked, self.admin)
+        self.assertEqual(1, n)
+        again = period_close.close_payload(self.connection, self.MONTH)
+        self.assertEqual(digest, again["snapshot_hash"])
+
+    def test_late_arrivals_survive_connection_close(self) -> None:
+        """Regression: the reconcile handler closes its connection right after
+        recording locked rows; uncommitted inserts used to vanish silently."""
+        from bank_importer.db import connect as db_connect
+
+        self._cover_month()
+        self._close()
+        late_id = self.add_row(
+            self.company_a, own_account="6222000000000001",
+            expense="12.00", at="2026-07-28T11:00:00",
+        )
+        writable, locked = period_close.split_writable_row_ids(self.connection, [late_id])
+        self.assertEqual(1, period_close.record_late_arrivals(self.connection, locked, self.admin))
+        self.connection.close()
+        fresh = db_connect(self.db_path)
+        try:
+            rows = fresh.execute(
+                "SELECT source_row_id FROM period_late_arrivals"
+            ).fetchall()
+            audits = fresh.execute(
+                "SELECT action FROM period_audit_events WHERE action = 'late_arrival'"
+            ).fetchall()
+        finally:
+            fresh.close()
+        self.assertEqual([late_id], [r["source_row_id"] for r in rows])
+        self.assertEqual(1, len(audits))
+
+    def test_snapshot_row_cannot_be_updated(self) -> None:
+        self._cover_month()
+        self._close()
+        with self.assertRaises(Exception):
+            with self.connection:
+                self.connection.execute(
+                    "UPDATE period_close_runs SET snapshot_json = '{}' WHERE year_month = ?",
+                    (self.MONTH,),
+                )
+
+    def test_reopen_reject_then_approve_and_reclose_version_chain(self) -> None:
+        self._cover_month()
+        first = self._close()
+        with self.assertRaises(period_close.PeriodCloseError):
+            period_close.request_reopen(
+                self.connection, self.MONTH, self.admin, reason="太短",
+            )
+        req = period_close.request_reopen(
+            self.connection, self.MONTH, self.admin,
+            reason="补录金牛煤业七月运输费并核对金额",
+            companies_note="甲公司 ↔ 乙公司",
+            window_days=3,
+        )
+        self.assertEqual("pending", req["status"])
+        rejected = period_close.decide_reopen(
+            self.connection, req["id"], self.admin, approve=False, comment="证据不足",
+        )
+        self.assertEqual("rejected", rejected["status"])
+        self.assertTrue(period_close.is_month_locked(self.connection, self.MONTH))
+        req2 = period_close.request_reopen(
+            self.connection, self.MONTH, self.admin,
+            reason="已补齐银行回单，申请重开更正科目",
+        )
+        approved = period_close.decide_reopen(
+            self.connection, req2["id"], self.admin, approve=True, comment="同意",
+        )
+        self.assertEqual("approved", approved["status"])
+        self.assertFalse(period_close.is_month_locked(self.connection, self.MONTH))
+        period_close.assert_date_writable(self.connection, "2026-07-15")
+        second = period_close.execute_close(
+            self.connection, self.MONTH, self.admin, confirm=True,
+        )
+        self.assertEqual("closed", second["status"])
+        self.assertNotEqual(first["report_no"], second["report_no"])
+        versions = self.connection.execute(
+            "SELECT version, report_no FROM period_close_runs WHERE year_month = ? ORDER BY version",
+            (self.MONTH,),
+        ).fetchall()
+        self.assertGreaterEqual(len(versions), 2)
+        self.assertEqual(1, versions[0]["version"])
+        self.assertEqual(2, versions[-1]["version"])
+
+    def test_wal_on_file_database(self) -> None:
+        mode = self.connection.execute("PRAGMA journal_mode").fetchone()[0]
+        self.assertEqual("wal", str(mode).lower())
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/test_period_close_page.py

@@ -0,0 +1,101 @@
+"""HEL-269: 月结面板、重开审批、审计记录页结构与三档宽度。"""
+
+from __future__ import annotations
+
+import threading
+import unittest
+from functools import partial
+from http.server import SimpleHTTPRequestHandler, ThreadingHTTPServer
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[1]
+WEB = ROOT / "web"
+
+try:
+    from playwright.sync_api import sync_playwright
+except ImportError:  # pragma: no cover
+    sync_playwright = None
+
+
+class PeriodClosePageContractTests(unittest.TestCase):
+    def test_admin_has_closing_reopen_and_audit_surfaces(self) -> None:
+        html = (WEB / "admin.html").read_text(encoding="utf-8")
+        self.assertIn('id="closingPanel"', html)
+        self.assertIn('id="periodTimeline"', html)
+        self.assertIn('data-page="period-audit"', html)
+        self.assertIn('data-view="period-audit"', html)
+        self.assertIn("重开审批", html)
+        self.assertIn('id="reopenQueue"', html)
+        self.assertIn('id="reopenRequestDialog"', html)
+        self.assertIn('id="reopenDecideDialog"', html)
+        self.assertIn("btn-warn", html)
+        settings = html.index('data-view="settings"')
+        audit_nav = html.index('data-view="period-audit"')
+        reminders = html.index('data-view="reminders"')
+        self.assertLess(settings, audit_nav)
+        self.assertLess(audit_nav, reminders)
+        css = (WEB / "design-system.css").read_text(encoding="utf-8")
+        self.assertIn(".btn-warn", css)
+        self.assertIn(".pill-lock", css)
+        self.assertIn(".tl-cell.locked", css)
+        self.assertIn(".diff-grid", css)
+        self.assertIn(".empty-icon", css)
+        js = (WEB / "app.js").read_text(encoding="utf-8")
+        self.assertIn("/api/admin/period-closes", js)
+        self.assertIn("/api/admin/period-reopens", js)
+        self.assertIn("/api/admin/period-audit", js)
+        self.assertIn("/api/flows", js)
+        self.assertIn("/api/company/manual-records", js)
+
+
+def _chromium_available() -> bool:
+    try:
+        import ctypes.util
+        return bool(ctypes.util.find_library("atk-1.0"))
+    except Exception:
+        return False
+
+
+@unittest.skipUnless(sync_playwright, "playwright 未安装，跳过布局冒烟")
+@unittest.skipUnless(_chromium_available(), "系统缺少 chromium 依赖库（如 libatk），跳过布局冒烟")
+class PeriodCloseLayoutSmokeTests(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls) -> None:
+        handler = partial(SimpleHTTPRequestHandler, directory=str(WEB))
+        cls.httpd = ThreadingHTTPServer(("127.0.0.1", 0), handler)
+        cls.port = cls.httpd.server_address[1]
+        cls.thread = threading.Thread(target=cls.httpd.serve_forever, daemon=True)
+        cls.thread.start()
+        cls.base = f"http://127.0.0.1:{cls.port}"
+
+    @classmethod
+    def tearDownClass(cls) -> None:
+        cls.httpd.shutdown()
+        cls.httpd.server_close()
+
+    def test_settings_and_audit_no_horizontal_overflow(self) -> None:
+        with sync_playwright() as p:
+            browser = p.chromium.launch()
+            page = browser.new_page()
+            page.route("**/app.js**", lambda route: route.abort())
+            for width in (360, 820, 1440):
+                page.set_viewport_size({"width": width, "height": 900})
+                page.goto(f"{self.base}/admin.html")
+                for view in ("settings", "period-audit"):
+                    page.evaluate(
+                        """(view) => {
+                          document.querySelectorAll('.app-view').forEach((el) => {
+                            el.classList.toggle('is-active', el.dataset.page === view);
+                          });
+                        }""",
+                        view,
+                    )
+                    overflow = page.evaluate(
+                        "() => document.documentElement.scrollWidth > document.documentElement.clientWidth + 1"
+                    )
+                    self.assertFalse(overflow, f"{width}px {view} 出现横向溢出")
+            browser.close()
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/test_persistence.py

@@ -41,7 +41,7 @@ class PersistenceTestCase(unittest.TestCase):
 class MigrationTests(PersistenceTestCase):
     def test_migrate_creates_schema_and_is_idempotent(self) -> None:
         first = applied_versions(self.connection)
-        self.assertEqual([1, 2, 3, 4, 5, 6, 7, 8], first)
+        self.assertEqual([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], first)
         self.assertEqual([], migrate(self.connection))
         self.assertEqual(first, applied_versions(self.connection))
         tables = {
@@ -84,24 +84,28 @@ class MigrationTests(PersistenceTestCase):
             "ledger_subject_suggestions",
             "system_settings",
             "system_setting_changes",
-            "reminders",
             "closed_periods",
             "opening_balance_revisions",
             "coverage_gaps",
             "no_business_attestations",
+            "reminders_legacy_manual",
+            "period_close_runs",
+            "period_reopen_requests",
+            "period_late_arrivals",
+            "period_audit_events",
             "schema_migrations",
         ):
             self.assertIn(table, tables)
 
     def test_rollback_removes_schema_and_forward_rebuilds_it(self) -> None:
-        self.assertEqual([8, 7, 6, 5, 4, 3, 2, 1], rollback(self.connection, 0))
+        self.assertEqual([10, 9, 8, 7, 6, 5, 4, 3, 2, 1], rollback(self.connection, 0))
         self.assertEqual([], applied_versions(self.connection))
         remaining = self.connection.execute(
             "SELECT name FROM sqlite_master WHERE type = 'table' AND name = 'source_rows'"
         ).fetchone()
         self.assertIsNone(remaining)
-        self.assertEqual([1, 2, 3, 4, 5, 6, 7, 8], migrate(self.connection))
-        self.assertEqual([1, 2, 3, 4, 5, 6, 7, 8], applied_versions(self.connection))
+        self.assertEqual([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], migrate(self.connection))
+        self.assertEqual([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], applied_versions(self.connection))
 
     def test_rollback_to_4_keeps_bank_evidence_and_drops_event_layer(self) -> None:
         self.import_sample()
@@ -109,7 +113,7 @@ class MigrationTests(PersistenceTestCase):
             "SELECT COUNT(*) AS n FROM source_rows"
         ).fetchone()["n"]
         self.assertGreater(row_count, 0)
-        self.assertEqual([8, 7, 6, 5], rollback(self.connection, 4))
+        self.assertEqual([10, 9, 8, 7, 6, 5], rollback(self.connection, 4))
         # The pre-migration evidence and schema are untouched.
         self.assertEqual(
             row_count,

tests/test_reminders.py

@@ -0,0 +1,495 @@
+"""Tests for automatic reminder detection, delivery, isolation and audit trail."""
+
+from __future__ import annotations
+
+from datetime import date, timedelta
+from pathlib import Path
+import json
+import sqlite3
+import unittest
+from unittest.mock import patch
+
+from bank_importer import auth, reminders
+from bank_importer.db import connect, migrate, utc_now
+
+
+class ReminderTestCase(unittest.TestCase):
+    def setUp(self) -> None:
+        self.connection = connect(":memory:")
+        self.addCleanup(self.connection.close)
+        migrate(self.connection)
+        now = utc_now()
+        with self.connection:
+            self.connection.execute(
+                "INSERT INTO companies (name, created_at, updated_at) VALUES ('甲公司', ?, ?)",
+                (now, now),
+            )
+            self.connection.execute(
+                "INSERT INTO companies (name, created_at, updated_at) VALUES ('乙公司', ?, ?)",
+                (now, now),
+            )
+        self.company_a = int(
+            self.connection.execute("SELECT id FROM companies WHERE name = '甲公司'").fetchone()["id"]
+        )
+        self.company_b = int(
+            self.connection.execute("SELECT id FROM companies WHERE name = '乙公司'").fetchone()["id"]
+        )
+        self.admin_id = auth.create_user(self.connection, "admin1", "AdminPass123", "admin")
+        self.user_a = auth.create_user(
+            self.connection, "cashier-a", "CashierA123", "company", company_id=self.company_a
+        )
+        self.user_b = auth.create_user(
+            self.connection, "cashier-b", "CashierB123", "company", company_id=self.company_b
+        )
+        self.admin = self.connection.execute(
+            "SELECT * FROM users WHERE id = ?", (self.admin_id,)
+        ).fetchone()
+        self.actor_a = self.connection.execute(
+            "SELECT * FROM users WHERE id = ?", (self.user_a,)
+        ).fetchone()
+
+    def _insert_batch(
+        self,
+        company_id: int,
+        *,
+        period_start: str,
+        period_end: str,
+    ) -> None:
+        now = utc_now()
+        with self.connection:
+            self.connection.execute(
+                """
+                INSERT INTO source_files (sha256, original_filename, size_bytes, storage_path, created_at)
+                VALUES (?, 'f.xls', 1, '/tmp/f.xls', ?)
+                """,
+                (f"sha-{company_id}-{period_end}", now),
+            )
+            file_id = int(self.connection.execute("SELECT last_insert_rowid()").fetchone()[0])
+            self.connection.execute(
+                """
+                INSERT INTO import_batches (source_file_id, status, company_id, created_at, updated_at)
+                VALUES (?, 'parsed', ?, ?, ?)
+                """,
+                (file_id, company_id, now, now),
+            )
+            batch_id = int(self.connection.execute("SELECT last_insert_rowid()").fetchone()[0])
+            self.connection.execute(
+                """
+                INSERT INTO sheet_batches (
+                    import_batch_id, sheet_name, bank_name, template_id, template_version,
+                    header_row, period_start, period_end, transaction_count, created_at
+                ) VALUES (?, 's1', '工行', 'tpl', 1, 1, ?, ?, 1, ?)
+                """,
+                (batch_id, period_start, period_end, now),
+            )
+
+    def _insert_pending_account(self, company_id: int) -> None:
+        now = utc_now()
+        with self.connection:
+            self.connection.execute(
+                """
+                INSERT INTO bank_accounts (
+                    company_id, account_number, bank_name, status, created_at, updated_at
+                ) VALUES (?, ?, '工行', 'pending', ?, ?)
+                """,
+                (company_id, f"622{company_id:012d}", now, now),
+            )
+
+
+class RuleDetectionTests(ReminderTestCase):
+    def test_unsubmitted_detected_when_no_current_month_batch(self) -> None:
+        today = date.today()
+        if today.day < 5:
+            self.skipTest("monthly start day gate not reached today")
+        findings = reminders.scan_findings(self.connection)
+        keys = {item.company_id: item for item in findings if item.rule_key == reminders.RULE_UNSUBMITTED}
+        self.assertIn(self.company_a, keys)
+        self.assertIn(self.company_b, keys)
+
+    def test_unsubmitted_not_reported_when_batch_exists(self) -> None:
+        today = date.today()
+        if today.day < 5:
+            self.skipTest("monthly start day gate not reached today")
+        period = f"{today.year:04d}-{today.month:02d}"
+        self._insert_batch(self.company_a, period_start=f"{period}-01", period_end=f"{period}-15")
+        findings = reminders.scan_findings(self.connection)
+        for item in findings:
+            if item.rule_key == reminders.RULE_UNSUBMITTED:
+                self.assertNotEqual(self.company_a, item.company_id)
+
+    def test_gap_detected_after_threshold(self) -> None:
+        old_end = (date.today() - timedelta(days=10)).isoformat()
+        self._insert_batch(self.company_a, period_start="2026-01-01", period_end=old_end)
+        findings = reminders.scan_findings(self.connection)
+        gap = [item for item in findings if item.rule_key == reminders.RULE_GAP and item.company_id == self.company_a]
+        self.assertEqual(1, len(gap))
+
+    def test_gap_not_reported_for_recent_batch(self) -> None:
+        recent = (date.today() - timedelta(days=1)).isoformat()
+        self._insert_batch(self.company_a, period_start="2026-07-01", period_end=recent)
+        findings = reminders.scan_findings(self.connection)
+        gap = [item for item in findings if item.rule_key == reminders.RULE_GAP and item.company_id == self.company_a]
+        self.assertEqual(0, len(gap))
+
+    def test_pending_review_detected_with_pending_account(self) -> None:
+        self._insert_pending_account(self.company_a)
+        findings = reminders.scan_findings(self.connection)
+        pending = [
+            item for item in findings
+            if item.rule_key == reminders.RULE_PENDING and item.company_id == self.company_a
+        ]
+        self.assertEqual(1, len(pending))
+        self.assertGreater(pending[0].rule_params["pending_count"], 0)
+
+    def test_pending_review_not_reported_when_clean(self) -> None:
+        findings = reminders.scan_findings(self.connection)
+        pending = [
+            item for item in findings
+            if item.rule_key == reminders.RULE_PENDING and item.company_id == self.company_a
+        ]
+        self.assertEqual(0, len(pending))
+
+
+class DeliveryAndDedupTests(ReminderTestCase):
+    def test_send_creates_reminder_and_event(self) -> None:
+        today = date.today()
+        if today.day < 5:
+            self.skipTest("monthly start day gate not reached today")
+        findings = reminders.scan_findings(self.connection)
+        self.assertTrue(findings)
+        key = findings[0].dedupe_key
+        reminder_id = reminders.deliver_finding(self.connection, key, actor=self.admin)
+        self.assertIsNotNone(reminder_id)
+        row = self.connection.execute(
+            "SELECT send_count, status FROM reminders WHERE id = ?", (reminder_id,)
+        ).fetchone()
+        self.assertEqual(1, row["send_count"])
+        self.assertEqual("open", row["status"])
+        events = self.connection.execute(
+            "SELECT event_type FROM reminder_events WHERE reminder_id = ?", (reminder_id,)
+        ).fetchall()
+        self.assertEqual(["sent"], [item["event_type"] for item in events])
+
+    def test_repeat_send_increments_count_without_new_row(self) -> None:
+        today = date.today()
+        if today.day < 5:
+            self.skipTest("monthly start day gate not reached today")
+        findings = reminders.scan_findings(self.connection)
+        key = findings[0].dedupe_key
+        first = reminders.deliver_finding(self.connection, key, actor=self.admin)
+        second = reminders.deliver_finding(self.connection, key, actor=self.admin)
+        self.assertEqual(first, second)
+        row = self.connection.execute(
+            "SELECT send_count FROM reminders WHERE dedupe_key = ?", (key,)
+        ).fetchone()
+        self.assertEqual(2, row["send_count"])
+        count = self.connection.execute("SELECT COUNT(*) FROM reminders WHERE dedupe_key = ?", (key,)).fetchone()[0]
+        self.assertEqual(1, count)
+        events = self.connection.execute(
+            "SELECT COUNT(*) FROM reminder_events WHERE reminder_id = ?", (first,)
+        ).fetchone()[0]
+        self.assertEqual(2, events)
+
+    def test_resolved_reminder_reopens_same_row(self) -> None:
+        self._insert_pending_account(self.company_a)
+        finding = next(
+            item
+            for item in reminders.scan_findings(self.connection)
+            if item.rule_key == reminders.RULE_PENDING and item.company_id == self.company_a
+        )
+        first = reminders.deliver_finding(self.connection, finding.dedupe_key, actor=self.admin)
+        self.assertIsNotNone(first)
+        reminders.update_reminder_status(
+            self.connection, first, "resolved", company_id=self.company_a, actor=self.actor_a
+        )
+        second = reminders.deliver_finding(self.connection, finding.dedupe_key, actor=self.admin)
+        self.assertEqual(first, second)
+        row = self.connection.execute(
+            "SELECT send_count, status, dedupe_key FROM reminders WHERE id = ?",
+            (first,),
+        ).fetchone()
+        self.assertEqual(2, row["send_count"])
+        self.assertEqual("open", row["status"])
+        count = self.connection.execute(
+            "SELECT COUNT(*) FROM reminders WHERE dedupe_key = ?", (finding.dedupe_key,)
+        ).fetchone()[0]
+        self.assertEqual(1, count)
+        events = [
+            item["event_type"]
+            for item in self.connection.execute(
+                "SELECT event_type FROM reminder_events WHERE reminder_id = ? ORDER BY id",
+                (first,),
+            ).fetchall()
+        ]
+        self.assertEqual(["sent", "resolved", "sent"], events)
+
+    def test_deliver_many_continues_after_one_failure(self) -> None:
+        self._insert_pending_account(self.company_a)
+        finding = next(
+            item
+            for item in reminders.scan_findings(self.connection)
+            if item.rule_key == reminders.RULE_PENDING and item.company_id == self.company_a
+        )
+        original = reminders.deliver_finding
+
+        def flaky(connection, key, **kwargs):
+            if key == "boom":
+                raise sqlite3.IntegrityError("UNIQUE constraint failed: reminders.dedupe_key")
+            return original(connection, key, **kwargs)
+
+        with patch.object(reminders, "deliver_finding", side_effect=flaky):
+            sent = reminders.deliver_many(
+                self.connection, ["boom", finding.dedupe_key], actor=self.admin
+            )
+        self.assertEqual(1, len(sent))
+        self.assertEqual(
+            1,
+            self.connection.execute("SELECT COUNT(*) FROM reminders").fetchone()[0],
+        )
+
+    def test_manual_reminder_each_send_is_separate(self) -> None:
+        first = reminders.send_manual(
+            self.connection,
+            company_id=self.company_a,
+            display_type="其他",
+            content="请尽快处理",
+            deadline="2026-09-01",
+            actor=self.admin,
+        )
+        second = reminders.send_manual(
+            self.connection,
+            company_id=self.company_a,
+            display_type="其他",
+            content="再次提醒",
+            deadline=None,
+            actor=self.admin,
+        )
+        self.assertNotEqual(first, second)
+
+
+class IsolationTests(ReminderTestCase):
+    def setUp(self) -> None:
+        super().setUp()
+        reminders.send_manual(
+            self.connection,
+            company_id=self.company_a,
+            display_type="流水未提交",
+            content="甲公司专属",
+            deadline=None,
+            actor=self.admin,
+        )
+        reminders.send_manual(
+            self.connection,
+            company_id=self.company_b,
+            display_type="流水未提交",
+            content="乙公司专属",
+            deadline=None,
+            actor=self.admin,
+        )
+
+    def test_company_sees_only_own_reminders(self) -> None:
+        items_a = reminders.list_company_reminders(self.connection, self.company_a)
+        items_b = reminders.list_company_reminders(self.connection, self.company_b)
+        self.assertEqual(1, len(items_a))
+        self.assertEqual(1, len(items_b))
+        self.assertIn("甲公司", items_a[0]["title"])
+        self.assertIn("乙公司", items_b[0]["title"])
+
+    def test_company_cannot_update_other_company_reminder(self) -> None:
+        other_id = reminders.list_company_reminders(self.connection, self.company_b)[0]["id"]
+        ok = reminders.update_reminder_status(
+            self.connection, other_id, "acknowledged", company_id=self.company_a, actor=self.actor_a
+        )
+        self.assertFalse(ok)
+
+
+class AuditTrailTests(ReminderTestCase):
+    def test_scan_writes_audit_log(self) -> None:
+        reminders.run_scan(self.connection, actor=self.admin, ip="127.0.0.1")
+        row = self.connection.execute(
+            "SELECT action, detail FROM audit_log WHERE action = 'reminder_scan'"
+        ).fetchone()
+        self.assertIsNotNone(row)
+        detail = json.loads(row["detail"])
+        self.assertIn("total", detail)
+
+    def test_events_are_append_only(self) -> None:
+        reminder_id = reminders.send_manual(
+            self.connection,
+            company_id=self.company_a,
+            display_type="测试",
+            content="内容",
+            deadline=None,
+            actor=self.admin,
+        )
+        with self.assertRaises(Exception):
+            with self.connection:
+                self.connection.execute(
+                    "UPDATE reminder_events SET detail = 'tampered' WHERE reminder_id = ?",
+                    (reminder_id,),
+                )
+        with self.assertRaises(Exception):
+            with self.connection:
+                self.connection.execute(
+                    "DELETE FROM reminder_events WHERE reminder_id = ?", (reminder_id,)
+                )
+
+    def test_reminders_cannot_be_deleted(self) -> None:
+        reminder_id = reminders.send_manual(
+            self.connection,
+            company_id=self.company_a,
+            display_type="测试",
+            content="内容",
+            deadline=None,
+            actor=self.admin,
+        )
+        with self.assertRaises(Exception):
+            with self.connection:
+                self.connection.execute("DELETE FROM reminders WHERE id = ?", (reminder_id,))
+
+
+class StatusFlowTests(ReminderTestCase):
+    def test_acknowledge_and_resolve(self) -> None:
+        reminder_id = reminders.send_manual(
+            self.connection,
+            company_id=self.company_a,
+            display_type="待确认",
+            content="请处理",
+            deadline=None,
+            actor=self.admin,
+        )
+        ok = reminders.update_reminder_status(
+            self.connection, reminder_id, "acknowledged", company_id=self.company_a, actor=self.actor_a
+        )
+        self.assertTrue(ok)
+        row = self.connection.execute(
+            "SELECT status FROM reminders WHERE id = ?", (reminder_id,)
+        ).fetchone()
+        self.assertEqual("acknowledged", row["status"])
+        ok = reminders.update_reminder_status(
+            self.connection, reminder_id, "resolved", company_id=self.company_a, actor=self.actor_a
+        )
+        self.assertTrue(ok)
+        events = self.connection.execute(
+            "SELECT event_type FROM reminder_events WHERE reminder_id = ? ORDER BY id",
+            (reminder_id,),
+        ).fetchall()
+        self.assertEqual(
+            ["sent", "acknowledged", "resolved"],
+            [item["event_type"] for item in events],
+        )
+
+
+class SettingsTests(ReminderTestCase):
+    def test_default_settings_and_update(self) -> None:
+        settings = reminders.get_settings(self.connection)
+        self.assertEqual("5", settings["monthly_start_day"])
+        self.assertEqual("5", settings["gap_days"])
+        updated = reminders.update_settings(
+            self.connection, {"gap_days": "7", "monthly_start_day": "6"}
+        )
+        self.assertEqual("7", updated["gap_days"])
+        self.assertEqual("6", updated["monthly_start_day"])
+
+    def test_unknown_setting_rejected(self) -> None:
+        with self.assertRaises(ValueError):
+            reminders.update_settings(self.connection, {"unknown_key": "1"})
+
+    def test_invalid_monthly_start_day_rejected(self) -> None:
+        with self.assertRaises(ValueError):
+            reminders.update_settings(self.connection, {"monthly_start_day": "0"})
+        with self.assertRaises(ValueError):
+            reminders.update_settings(self.connection, {"monthly_start_day": "29"})
+        self.assertEqual("5", reminders.get_settings(self.connection)["monthly_start_day"])
+
+    def test_invalid_gap_days_rejected(self) -> None:
+        with self.assertRaises(ValueError):
+            reminders.update_settings(self.connection, {"gap_days": "0"})
+        with self.assertRaises(ValueError):
+            reminders.update_settings(self.connection, {"gap_days": "abc"})
+        self.assertEqual("5", reminders.get_settings(self.connection)["gap_days"])
+
+    def test_invalid_scan_time_rejected(self) -> None:
+        with self.assertRaises(ValueError):
+            reminders.update_settings(self.connection, {"scan_time": "25:00"})
+        with self.assertRaises(ValueError):
+            reminders.update_settings(self.connection, {"scan_time": "8:0"})
+        self.assertEqual("08:00", reminders.get_settings(self.connection)["scan_time"])
+
+    def test_corrupt_settings_do_not_break_scan(self) -> None:
+        with self.connection:
+            self.connection.execute(
+                "UPDATE reminder_settings SET value = 'not-a-number' WHERE key = 'monthly_start_day'"
+            )
+            self.connection.execute(
+                "UPDATE reminder_settings SET value = '0' WHERE key = 'gap_days'"
+            )
+        findings = reminders.scan_findings(self.connection)
+        self.assertIsInstance(findings, list)
+
+
+class NoticeListDelegationTests(unittest.TestCase):
+    def test_async_notice_go_handle_uses_event_delegation(self) -> None:
+        source = (Path(__file__).resolve().parents[1] / "web" / "app.js").read_text(
+            encoding="utf-8"
+        )
+        init_body = source.split("function initNotifications()", 1)[1].split("\nfunction ", 1)[0]
+        self.assertIn('list.addEventListener("click"', init_body)
+        self.assertIn('closest("[data-view-link]")', init_body)
+        self.assertIn("showView(viewLink.dataset.viewLink)", init_body)
+        self.assertIn('document.addEventListener("click"', source)
+        self.assertNotIn(
+            '$$("[data-view-link]").forEach((button) => button.addEventListener("click"',
+            source,
+        )
+
+    def test_delegated_lookup_finds_button_inserted_after_init(self) -> None:
+        """Simulate #notice-list after async replaceChildren: click target is the new button."""
+        list_root = {"id": "notice-list", "parent": None, "attrs": {}}
+        side = {"id": "lr-side", "parent": list_root, "attrs": {}}
+        button = {
+            "id": "go",
+            "parent": side,
+            "attrs": {"data-view-link": "reconcile"},
+        }
+        list_root["children"] = [side]
+        side["children"] = [button]
+
+        def closest(node, attr):
+            current = node
+            while current is not None:
+                if attr in current.get("attrs", {}):
+                    return current
+                current = current.get("parent")
+            return None
+
+        clicked = closest(button, "data-view-link")
+        self.assertIsNotNone(clicked)
+        self.assertEqual("reconcile", clicked["attrs"]["data-view-link"])
+        self.assertIs(list_root, clicked["parent"]["parent"])
+
+
+class MigrationTests(unittest.TestCase):
+    def test_v6_migration_applies_and_rolls_back(self) -> None:
+        connection = connect(":memory:")
+        self.addCleanup(connection.close)
+        migrate(connection)
+        versions = connection.execute(
+            "SELECT version FROM schema_migrations ORDER BY version"
+        ).fetchall()
+        self.assertEqual(10, versions[-1]["version"])
+        connection.execute("DELETE FROM schema_migrations WHERE version = 10")
+        connection.executescript(
+            """
+            DROP TRIGGER IF EXISTS reminders_no_delete;
+            DROP TRIGGER IF EXISTS reminder_events_no_delete;
+            DROP TRIGGER IF EXISTS reminder_events_no_update;
+            DROP TABLE IF EXISTS reminder_events;
+            DROP TABLE IF EXISTS reminders;
+            DROP TABLE IF EXISTS reminder_settings;
+            """
+        )
+        row = connection.execute(
+            "SELECT name FROM sqlite_master WHERE name = 'reminders'"
+        ).fetchone()
+        self.assertIsNone(row)

tests/test_reminders_page.py

@@ -0,0 +1,168 @@
+"""HEL-230: 提醒管理页通栏三块与三步发送流的结构/响应式契约。"""
+
+from __future__ import annotations
+
+import threading
+import unittest
+from functools import partial
+from http.server import SimpleHTTPRequestHandler, ThreadingHTTPServer
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[1]
+WEB = ROOT / "web"
+
+try:
+    from playwright.sync_api import sync_playwright
+except ImportError:  # pragma: no cover
+    sync_playwright = None
+
+
+class RemindersPageSourceContractTests(unittest.TestCase):
+    def test_admin_html_order_and_send_flow(self) -> None:
+        html = (WEB / "admin.html").read_text(encoding="utf-8")
+        self.assertIn('data-page="reminders"', html)
+        self.assertIn('id="pending-reminders-card"', html)
+        self.assertIn('id="reminder-history-card"', html)
+        self.assertIn('id="send-reminder-card"', html)
+        self.assertIn('class="send-flow"', html)
+        self.assertIn('class="sf-step"', html)
+        self.assertIn('id="pick-count"', html)
+        self.assertIn('id="reminderForm"', html)
+        self.assertIn('id="reminderCompanyList"', html)
+        self.assertIn('id="reminder-type"', html)
+        self.assertIn('id="reminder-content"', html)
+        self.assertIn('id="reminder-deadline"', html)
+        self.assertIn('id="send-btn"', html)
+        self.assertIn('id="send-hint"', html)
+        self.assertIn('id="reminder-tbody"', html)
+        self.assertIn('id="reminder-tabs"', html)
+        self.assertIn('id="reminder-detail-drawer"', html)
+        self.assertIn("design-system.css?v=10", html)
+        self.assertIn("app.js?v=15", html)
+        pending = html.index('id="pending-reminders-card"')
+        history = html.index('id="reminder-history-card"')
+        send = html.index('id="send-reminder-card"')
+        self.assertLess(pending, history)
+        self.assertLess(history, send)
+        reminders = html[html.index('data-page="reminders"') : html.index("新增公司弹窗")]
+        self.assertNotIn("grid-1-2", reminders)
+        self.assertEqual(reminders.count('class="sf-step"'), 3)
+        self.assertIn("选择接收公司", reminders)
+        self.assertIn("填写提醒内容", reminders)
+        self.assertIn("设定截止并发送", reminders)
+
+    def test_app_js_keeps_real_reminder_apis(self) -> None:
+        js = (WEB / "app.js").read_text(encoding="utf-8")
+        self.assertIn('label.className = "pick"', js)
+        self.assertIn("function updatePickCount", js)
+        self.assertIn("function syncPendingPicks", js)
+        self.assertIn("/api/admin/reminders/pending", js)
+        self.assertIn("/api/admin/reminders/manual", js)
+        self.assertIn("/api/admin/reminders/send", js)
+        self.assertIn("/api/admin/reminders/scan", js)
+        self.assertIn("function loadAdminRemindersPending", js)
+        self.assertIn("function loadAdminRemindersHistory", js)
+        self.assertIn("function openReminderDetailDrawer", js)
+        self.assertIn("initAdminReminders()", js)
+        self.assertIn("dataset.companyId", js)
+
+    def test_design_system_send_flow_uses_tokens(self) -> None:
+        css = (WEB / "design-system.css").read_text(encoding="utf-8")
+        self.assertIn(".send-flow", css)
+        self.assertIn(".sf-step", css)
+        self.assertIn(".pick", css)
+        self.assertIn("minmax(0, 1.5fr)", css)
+        block_start = css.index("提醒管理：三步发送流")
+        block = css[block_start:]
+        self.assertIn("var(--border)", block)
+        self.assertIn("var(--accent-soft)", block)
+        self.assertIn("var(--accent)", block)
+        self.assertIn("@media (max-width: 1100px)", block)
+        self.assertNotRegex(block, r"#[0-9a-fA-F]{3,8}")
+        self.assertNotRegex(block, r"rgb\(")
+        self.assertNotIn("box-shadow: 0 0", block)
+
+
+def _chromium_available() -> bool:
+    try:
+        import ctypes.util
+
+        return bool(ctypes.util.find_library("atk-1.0"))
+    except Exception:
+        return False
+
+
+@unittest.skipUnless(sync_playwright, "playwright 未安装，跳过布局冒烟")
+@unittest.skipUnless(_chromium_available(), "系统缺少 chromium 依赖库（如 libatk），跳过布局冒烟")
+class RemindersPageLayoutSmokeTests(unittest.TestCase):
+    """桌面三列 / 窄屏竖排，360 / 820 / 1440 无页面级横向溢出。"""
+
+    @classmethod
+    def setUpClass(cls) -> None:
+        handler = partial(SimpleHTTPRequestHandler, directory=str(WEB))
+        cls.httpd = ThreadingHTTPServer(("127.0.0.1", 0), handler)
+        cls.port = cls.httpd.server_address[1]
+        cls.thread = threading.Thread(target=cls.httpd.serve_forever, daemon=True)
+        cls.thread.start()
+        cls.base = f"http://127.0.0.1:{cls.port}"
+
+    @classmethod
+    def tearDownClass(cls) -> None:
+        cls.httpd.shutdown()
+        cls.httpd.server_close()
+
+    def _open_reminders(self, page, width: int) -> None:
+        page.route("**/app.js**", lambda route: route.abort())
+        page.set_viewport_size({"width": width, "height": 900})
+        page.goto(f"{self.base}/admin.html")
+        page.evaluate(
+            """() => {
+              document.querySelectorAll('.app-view').forEach((el) => {
+                el.classList.toggle('is-active', el.dataset.page === 'reminders');
+              });
+              const list = document.getElementById('reminderCompanyList');
+              if (list && !list.children.length) {
+                ['A公司', 'B公司', '郑州金牛建业煤炭有限责任公司'].forEach((name, i) => {
+                  const label = document.createElement('label');
+                  label.className = 'pick';
+                  label.innerHTML = '<input type="checkbox" name="company" value="' + (i + 1) + '">' + name;
+                  if (i < 2) label.querySelector('input').checked = true;
+                  list.append(label);
+                });
+              }
+            }"""
+        )
+
+    def test_send_flow_columns_and_no_page_overflow(self) -> None:
+        html = (WEB / "admin.html").read_text(encoding="utf-8")
+        self.assertIn("app.js?v=15", html)
+        with sync_playwright() as p:
+            browser = p.chromium.launch()
+            page = browser.new_page()
+            self._open_reminders(page, 1440)
+            cols_wide = page.evaluate(
+                "() => getComputedStyle(document.querySelector('.send-flow')).gridTemplateColumns"
+            )
+            self.assertEqual(len(cols_wide.split()), 3, f"桌面端应为三列，实际: {cols_wide}")
+            overflow_wide = page.evaluate(
+                "() => document.documentElement.scrollWidth > document.documentElement.clientWidth + 1"
+            )
+            self.assertFalse(overflow_wide, "1440px 出现页面级横向溢出")
+
+            self._open_reminders(page, 900)
+            cols_narrow = page.evaluate(
+                "() => getComputedStyle(document.querySelector('.send-flow')).gridTemplateColumns"
+            )
+            self.assertEqual(len(cols_narrow.split()), 1, f"窄屏应为单列，实际: {cols_narrow}")
+
+            for width in (360, 820, 1440):
+                self._open_reminders(page, width)
+                overflow = page.evaluate(
+                    "() => document.documentElement.scrollWidth > document.documentElement.clientWidth + 1"
+                )
+                self.assertFalse(overflow, f"{width}px 出现页面级横向溢出")
+            browser.close()
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/test_server_auth.py

@@ -287,6 +287,8 @@ class ServerAuthMatrixTests(unittest.TestCase):
             lambda: anon.get("/api/admin/users"),
             lambda: anon.get("/api/admin/companies"),
             lambda: anon.get("/api/admin/audit-log"),
+            lambda: anon.get("/api/admin/reminders"),
+            lambda: anon.get("/api/company/reminders"),
             lambda: anon.get("/api/me"),
         ):
             status, _, data = method_check()
@@ -387,6 +389,10 @@ class ServerAuthMatrixTests(unittest.TestCase):
             lambda: self.cashier_a.request("POST", "/api/admin/users/1/enable"),
             lambda: self.cashier_a.request("POST", "/api/admin/users/1/reset-password"),
             lambda: self.cashier_a.get("/api/admin/audit-log"),
+            lambda: self.cashier_a.get("/api/admin/reminders"),
+            lambda: self.cashier_a.get("/api/admin/reminders/pending"),
+            lambda: self.cashier_a.post_json("/api/admin/reminder-settings", {"gap_days": "3"}),
+            lambda: self.cashier_a.post_json("/api/admin/reminders/send", {"dedupe_keys": ["x"]}),
         )
         for call in calls:
             status, _, data = call()
@@ -557,6 +563,28 @@ class ServerAuthMatrixTests(unittest.TestCase):
                 self.assertNotIn(password, row["detail"] or "")
                 self.assertNotIn(password, row["target"] or "")
 
+    def test_invalid_reminder_settings_return_400_and_do_not_persist(self) -> None:
+        cases = (
+            {"monthly_start_day": "0"},
+            {"gap_days": "0"},
+            {"scan_time": "25:99"},
+        )
+        for payload in cases:
+            with self.subTest(payload=payload):
+                status, _, data = self.admin.post_json(
+                    "/api/admin/reminder-settings", {"settings": payload}
+                )
+                self.assertEqual(400, status, data)
+                self.assertEqual("error", as_json(data)["status"])
+        status, _, data = self.admin.get("/api/admin/reminder-settings")
+        self.assertEqual(200, status)
+        settings = as_json(data)["settings"]
+        self.assertEqual("5", settings["monthly_start_day"])
+        self.assertEqual("5", settings["gap_days"])
+        self.assertEqual("08:00", settings["scan_time"])
+        status, _, data = self.admin.get("/api/admin/reminders/pending")
+        self.assertEqual(200, status, data)
+
 
 if __name__ == "__main__":
     unittest.main()

tests/test_settings_reminders.py

@@ -166,28 +166,6 @@ class SettingsAndRemindersTests(unittest.TestCase):
         self.assertNotEqual(rows[0]["before_value"], rows[0]["after_value"])
         self.assertEqual("group-admin", rows[0]["actor_username"])
 
-    def test_reminder_pending_and_send(self) -> None:
-        status, data = self.admin.get(
-            f"/api/admin/reminders/pending?company_id={self.company_id}"
-        )
-        self.assertEqual(200, status, data)
-        items = as_json(data)["items"]
-        self.assertTrue(items)
-
-        status, data = self.admin.post_json(
-            "/api/admin/reminders/send", {"company_id": self.company_id}
-        )
-        self.assertEqual(200, status, data)
-        payload = as_json(data)
-        self.assertGreaterEqual(len(payload["reminders"]), 1)
-        self.assertTrue(payload["deadline"])
-
-        status, data = self.admin.get("/api/admin/reminders")
-        self.assertEqual(200, status)
-        history = as_json(data)["reminders"]
-        self.assertGreaterEqual(len(history), 1)
-        self.assertEqual(self.company_id, history[0]["company_id"])
-
     def test_company_user_forbidden_on_settings_and_reminders(self) -> None:
         # A company user must not be able to read or write admin settings.
         status, data = self.admin.post_json(

web/admin.html

@@ -5,7 +5,7 @@
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
     <meta name="description" content="金牛集团管理端" />
     <title>管理端 · 金牛集团</title>
-    <link rel="stylesheet" href="design-system.css?v=8" />
+    <link rel="stylesheet" href="design-system.css?v=10" />
   </head>
   <body data-portal="admin">
     <a class="skip-link" href="#main-content">跳到主要内容</a>
@@ -25,6 +25,7 @@
           <div class="nav-group">基础与结账</div>
           <a data-view="companies" href="#companies"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.7"><path d="M4 21V8l8-5 8 5v13"/><path d="M9 21v-6h6v6"/></svg><span class="nav-label">公司与账号</span></a>
           <a data-view="settings" href="#settings"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.7"><circle cx="12" cy="12" r="8.5"/><path d="M12 7v5l3.5 2"/></svg><span class="nav-label">结账与期初</span></a>
+          <a data-view="period-audit" href="#period-audit"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.7"><path d="M12 8v5l3 1.5"/><circle cx="12" cy="12" r="8.5"/></svg><span class="nav-label">审计记录</span></a>
           <a data-view="reminders" href="#reminders"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.7"><path d="M6 9a6 6 0 1 1 12 0c0 5 2 6 2 6H4s2-1 2-6"/><path d="M10 19a2 2 0 0 0 4 0"/></svg><span class="nav-label">提醒管理</span></a>
         </nav>
         <div class="side-foot">
@@ -241,7 +242,7 @@
             <div class="notice warn" id="pairNotice" style="display: none; margin-bottom: 14px;">
               <div>
                 <div class="n-title">该公司组合暂无归集数据</div>
-                <div class="n-body">所选组合在正式环境中将按相同口径实时归集，当前仅内置演示数据组合。</div>
+                <div class="n-body">所选组合暂无已确认往来，列表将显示「暂无数据」。</div>
               </div>
             </div>
 
@@ -336,6 +337,7 @@
                 <button data-audit-filter="起算" data-label="起算区间校准" aria-pressed="false">起算区间校准<span class="tab-count">0</span></button>
                 <button data-audit-filter="账户" data-label="银行账户登记" aria-pressed="false">银行账户登记<span class="tab-count">0</span></button>
                 <button data-audit-filter="手工" data-label="公司手工记录" aria-pressed="false">公司手工记录<span class="tab-count">0</span></button>
+                <button data-audit-filter="reopen" data-label="重开审批" aria-pressed="false">重开审批<span class="tab-count" id="reopenTabCount">0</span></button>
               </div>
               <div class="field" style="min-width: 180px;">
                 <label for="auditCompany">公司</label>
@@ -343,7 +345,7 @@
               </div>
             </div>
 
-            <div class="table-wrap" style="margin-top: 14px;">
+            <div class="table-wrap" style="margin-top: 14px;" id="auditTableWrap">
               <table class="ds-table audit-table">
                 <thead>
                   <tr>
@@ -364,6 +366,19 @@
                 <span>审核人：系统管理员 · 操作实时写入审核日志</span>
               </div>
             </div>
+            <div id="reopenQueue" hidden style="margin-top: 14px;">
+              <div class="card">
+                <div class="card-head">
+                  <span class="card-title">重开审批<span class="sub">待审批申请需管理员确认后才解除锁定</span></span>
+                </div>
+                <div id="reopenQueueList"></div>
+                <div class="empty" id="reopenQueueEmpty">
+                  <svg class="empty-icon" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.4"><circle cx="12" cy="12" r="8.5"/><path d="M12 8v5l3 1.5"/></svg>
+                  <div class="e-title">暂无重开申请</div>
+                  锁定账期的重开申请会显示在这里。
+                </div>
+              </div>
+            </div>
           </section>
 
           <section class="app-view" data-page="flows">
@@ -426,9 +441,14 @@
                 </thead>
                 <tbody></tbody>
               </table>
+              <div class="empty" id="flowEmpty" hidden>
+                <svg class="empty-icon" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.4"><rect x="4" y="5" width="16" height="14" rx="2"/><path d="M4 10h16"/></svg>
+                <div class="e-title">暂无数据</div>
+                当前筛选条件下没有已确认工作表的银行流水。
+              </div>
               <div class="table-foot">
                 <span id="flowCount">共 0 笔</span>
-                <span class="meta" id="flowsRangeMeta">数据范围：加载中…</span>
+                <span class="num" id="flowSum"></span>
               </div>
             </div>
           </section>
@@ -491,15 +511,8 @@
               <div class="card-head">
                 <span class="card-title">账期时间轴<span class="sub" id="timelineSub">全局起算日 2026-01-01 起，每月 5 日结账</span></span>
               </div>
-              <div class="timeline">
-                <div class="tl-cell closed"><div class="tl-month">2026-01</div><div class="tl-state">已结账</div></div>
-                <div class="tl-cell closed"><div class="tl-month">2026-02</div><div class="tl-state">已结账</div></div>
-                <div class="tl-cell closed"><div class="tl-month">2026-03</div><div class="tl-state">已结账</div></div>
-                <div class="tl-cell closed"><div class="tl-month">2026-04</div><div class="tl-state">已结账</div></div>
-                <div class="tl-cell closed"><div class="tl-month">2026-05</div><div class="tl-state">已结账</div></div>
-                <div class="tl-cell closed"><div class="tl-month">2026-06</div><div class="tl-state">已结账</div></div>
-                <div class="tl-cell current" id="tl-current"><div class="tl-month">2026-07</div><div class="tl-state" id="tl-current-state">进行中</div></div>
-                <div class="tl-cell open"><div class="tl-month">2026-08</div><div class="tl-state">归集中</div></div>
+              <div class="timeline" id="periodTimeline">
+                <div class="tl-cell open"><div class="tl-month">—</div><div class="tl-state">加载中</div></div>
               </div>
             </div>
 
@@ -579,115 +592,258 @@
 
               <div class="card" id="closingPanel">
                 <div class="card-head">
-                  <span class="card-title">月度结账<span class="sub" id="closingDescription">2026 年 7 月 · 当前未达到结账条件</span></span>
-                  <span class="pill pill-danger" id="closingStatus">已阻断</span>
+                  <span class="card-title">月度结账<span class="sub" id="closingDescription">加载账期状态…</span></span>
+                  <span class="pill pill-muted" id="closingStatus">—</span>
                 </div>
+                <div id="closingBody">
                 <div class="closing-check-list">
-                  <div class="list-row">
-                    <span class="pill pill-success" data-closing-check>公司流水提交</span>
-                    <div class="lr-main"><div class="lr-title">流水提交</div><div class="lr-sub" data-closing-sub>5 / 6 家已完成</div></div>
-                    <div class="lr-side"><span class="pill pill-warn" data-closing-state>待处理</span></div>
+                  <div class="list-row" data-closing-key="submissions">
+                    <span class="pill pill-muted" data-closing-check>流水提交</span>
+                    <div class="lr-main"><div class="lr-title">流水提交</div><div class="lr-sub" data-closing-sub>—</div></div>
+                    <div class="lr-side"><span class="pill pill-muted" data-closing-state>—</span></div>
                   </div>
-                  <div class="list-row">
-                    <span class="pill pill-success" data-closing-check>账户连续性</span>
-                    <div class="lr-main"><div class="lr-title">账户连续</div><div class="lr-sub" data-closing-sub>2 个账户存在断档</div></div>
-                    <div class="lr-side"><span class="pill pill-danger" data-closing-state>阻断</span></div>
+                  <div class="list-row" data-closing-key="coverage">
+                    <span class="pill pill-muted" data-closing-check>账户连续</span>
+                    <div class="lr-main"><div class="lr-title">账户连续</div><div class="lr-sub" data-closing-sub>—</div></div>
+                    <div class="lr-side"><span class="pill pill-muted" data-closing-state>—</span></div>
                   </div>
-                  <div class="list-row">
-                    <span class="pill pill-success" data-closing-check>审核事项</span>
-                    <div class="lr-main"><div class="lr-title">审核完成</div><div class="lr-sub" data-closing-sub>0 项尚未处理</div></div>
-                    <div class="lr-side"><span class="pill pill-danger" data-closing-state>阻断</span></div>
+                  <div class="list-row" data-closing-key="reviews">
+                    <span class="pill pill-muted" data-closing-check>审核完成</span>
+                    <div class="lr-main"><div class="lr-title">审核完成</div><div class="lr-sub" data-closing-sub>—</div></div>
+                    <div class="lr-side"><span class="pill pill-muted" data-closing-state>—</span></div>
                   </div>
-                  <div class="list-row">
-                    <span class="pill pill-success" data-closing-check>期初余额</span>
-                    <div class="lr-main"><div class="lr-title">期初锁定</div><div class="lr-sub" data-closing-sub>已锁定 2026.01.01</div></div>
-                    <div class="lr-side"><span class="pill pill-success" data-closing-state>已通过</span></div>
+                  <div class="list-row" data-closing-key="opening">
+                    <span class="pill pill-muted" data-closing-check>期初锁定</span>
+                    <div class="lr-main"><div class="lr-title">期初锁定</div><div class="lr-sub" data-closing-sub>—</div></div>
+                    <div class="lr-side"><span class="pill pill-muted" data-closing-state>—</span></div>
                   </div>
                 </div>
 
+                <div class="grid grid-4" id="closingSummary" style="margin-top: 16px;">
+                  <div><div class="meta">账期</div><div class="num" id="ckMonth">—</div></div>
+                  <div><div class="meta">期末归集</div><div class="num" id="ckNet">—</div></div>
+                  <div><div class="meta">结转去向</div><div class="num" id="ckCarry">—</div></div>
+                  <div><div class="meta">月报编号</div><div class="num" id="ckReport">尚未生成</div></div>
+                </div>
+
                 <div class="notice danger" id="block-notice" style="margin-top: 16px; display: none;">
                   <div>
-                    <div class="n-title">存在阻断项，暂不能执行 2026-07 月度结账</div>
+                    <div class="n-title" id="block-notice-title">存在阻断项，暂不能执行月度结账</div>
                     <div class="n-body" id="block-notice-body">请先处理待审核事项与账户断档。</div>
                   </div>
                 </div>
+                <div class="notice danger" id="failed-notice" style="margin-top: 16px; display: none;">
+                  <div>
+                    <div class="n-title">结账失败</div>
+                    <div class="n-body" id="failed-notice-body">未改动任何数据，可重新执行结账。</div>
+                  </div>
+                </div>
                 <div class="notice info" id="closed-notice" style="margin-top: 16px; display: none;">
                   <div>
-                    <div class="n-title">2026-07 已结账</div>
-                    <div class="n-body" id="closed-notice-body">结账后各公司 7 月往来数据已锁定，期初数将结转至 2026-08 账期。</div>
+                    <div class="n-title" id="closed-notice-title">账期已锁定</div>
+                    <div class="n-body" id="closed-notice-body">结账后各公司往来数据已锁定，期初数将结转至下一账期。</div>
                   </div>
                 </div>
+                <div class="notice warn" id="reopened-notice" style="margin-top: 16px; display: none;">
+                  <div>
+                    <div class="n-title">账期已重开</div>
+                    <div class="n-body" id="reopened-notice-body">窗口内可更正并留痕，到期自动恢复锁定。</div>
+                  </div>
+                </div>
+                </div>
 
-                <div class="row" style="margin-top: 16px; justify-content: flex-end; flex-wrap: wrap;">
-                  <span class="meta" id="closingHistory" style="margin-right: auto;">最近结账：2026 年 6 月 · 系统管理员 · 2026.07.05 18:10</span>
+                <div class="row" style="margin-top: 16px; justify-content: flex-end; flex-wrap: wrap; gap: 8px;">
+                  <span class="meta" id="closingHistory" style="margin-right: auto;">—</span>
+                  <span class="loading-inline" id="closingBusy" hidden>正在锁定账期并生成月报…请勿关闭页面</span>
+                  <button class="btn" id="downloadMonthReport" hidden>下载月报</button>
                   <button class="btn" id="runClosingCheck">重新检查</button>
-                  <button class="btn btn-primary" id="executeClosing" disabled title="请先处理全部阻断事项">执行 2026-07 月度结账</button>
+                  <button class="btn btn-primary" id="executeClosing" disabled title="请先处理全部阻断事项">执行月度结账</button>
                 </div>
               </div>
             </div>
           </section>
 
+          <section class="app-view" data-page="period-audit">
+            <div class="page-head">
+              <div>
+                <h1>审计记录</h1>
+                <p class="page-sub">谁、什么时间、改了什么、为什么。记录只增不改，可倒查至银行原始流水。</p>
+              </div>
+            </div>
+            <div class="filters">
+              <div class="field">
+                <label for="paSince">起始日期</label>
+                <input class="input" id="paSince" type="date" />
+              </div>
+              <div class="field">
+                <label for="paUntil">结束日期</label>
+                <input class="input" id="paUntil" type="date" />
+              </div>
+              <div class="field">
+                <label for="paAction">动作类型</label>
+                <select class="select" id="paAction">
+                  <option value="">全部动作</option>
+                  <option value="close_execute">月结</option>
+                  <option value="reopen_request">重开申请</option>
+                  <option value="reopen_approve">重开审批通过</option>
+                  <option value="reopen_reject">重开驳回</option>
+                  <option value="reopen_expire">重开到期恢复</option>
+                  <option value="close_fail">月结失败</option>
+                </select>
+              </div>
+              <div class="field">
+                <label for="paCompany">涉及公司</label>
+                <input class="input" id="paCompany" type="text" placeholder="公司名 / 月报号" />
+              </div>
+              <button class="btn" id="paApply" type="button">查询</button>
+              <button class="btn btn-ghost" id="paReset" type="button">清除筛选条件</button>
+            </div>
+            <div class="notice danger" id="paError" style="display: none; margin-bottom: 14px;">
+              <div>
+                <div class="n-title">审计记录加载失败</div>
+                <div class="n-body">已加载的数据未被改动 · 请稍后重试</div>
+              </div>
+              <button class="btn btn-primary btn-sm" type="button" id="paReload">重新加载</button>
+            </div>
+            <div class="table-wrap">
+              <table class="ds-table">
+                <thead>
+                  <tr>
+                    <th>时间</th>
+                    <th>操作人</th>
+                    <th>动作</th>
+                    <th class="wrap">对象与原因</th>
+                    <th>前后变化</th>
+                    <th>凭证</th>
+                  </tr>
+                </thead>
+                <tbody id="periodAuditRows"></tbody>
+              </table>
+              <div class="table-foot">
+                <span id="periodAuditFoot">共 0 条</span>
+                <span>审计记录只增不改 · 永久保留</span>
+              </div>
+            </div>
+            <div class="audit-event-cards" id="periodAuditCards"></div>
+            <div class="empty" id="periodAuditEmpty" hidden>
+              <svg class="empty-icon" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.4"><circle cx="12" cy="12" r="8.5"/><path d="M12 8v5l3 1.5"/></svg>
+              <div class="e-title">没有符合条件的审计记录</div>
+              调整筛选条件后再查询，或清除筛选查看全部留痕。
+            </div>
+          </section>
+
           <section class="app-view" data-page="reminders">
             <div class="page-head">
               <div>
                 <h1>提醒管理</h1>
                 <p class="page-sub">向成员公司发送处理提醒，并跟踪系统提醒与人工提醒的触达与处理状态。</p>
               </div>
+              <div class="page-actions">
+                <button type="button" class="btn btn-sm" id="reminder-scan-btn">立即扫描</button>
+              </div>
             </div>
 
-            <div class="grid grid-1-2">
-              <div class="card">
-                <div class="card-head">
-                  <span class="card-title">发送处理提醒<span class="sub">选择公司后系统自动列出待提醒事项，核对后一键发送</span></span>
+            <div class="stack">
+            <div class="card" id="pending-reminders-card">
+              <div class="card-head">
+                <span class="card-title">待提醒清单<span class="sub">系统按流水提交、断档、待确认自动发现，点发送即送达对应公司</span></span>
+                <div class="row" style="gap: 10px; align-items: center;">
+                  <span class="meta" id="pending-summary">—</span>
+                  <button type="button" class="btn btn-primary btn-sm" id="pending-send-all" disabled>全部一键发送</button>
                 </div>
-                <form id="reminderForm" novalidate>
-                  <div class="field" style="margin-bottom: 14px;">
-                    <label for="reminder-company">接收公司</label>
-                    <select class="select" id="reminder-company"><option value="">请选择公司</option></select>
-                    <span class="hint error" id="company-error" style="display: none;">请选择一家接收公司</span>
-                  </div>
-                  <div class="field" style="margin-bottom: 16px;">
-                    <label>待提醒事项（系统自动列出）</label>
-                    <div id="reminder-items">
-                      <div class="empty">请先选择公司，系统将自动列出该公司待提醒事项。</div>
-                    </div>
-                    <span class="hint error" id="reminder-error" style="display: none;">该公司当前没有待提醒事项</span>
-                  </div>
-                  <button type="submit" class="btn btn-primary" id="send-btn" style="width: 100%;" disabled>发送提醒</button>
-                  <p class="hint" id="send-hint" style="margin-top: 10px; display: none;"></p>
-                </form>
               </div>
+              <div id="pending-list">
+                <div class="empty" id="pending-empty">暂无需要提醒的事项 · 各公司流水与确认进度正常</div>
+              </div>
+            </div>
 
-              <div class="card">
-                <div class="card-head">
-                  <span class="card-title">提醒历史<span class="sub">含系统自动触发与人工发送的全部提醒记录</span></span>
-                </div>
-                <div class="tabs" id="reminder-tabs">
-                  <button type="button" class="active" data-filter="all">全部<span class="tab-count" id="count-all">0</span></button>
-                  <button type="button" data-filter="system">系统提醒<span class="tab-count" id="count-system">0</span></button>
-                  <button type="button" data-filter="manual">人工提醒<span class="tab-count" id="count-manual">0</span></button>
-                </div>
-                <div class="table-wrap" style="border: 0;">
-                  <table class="ds-table">
-                    <thead>
-                      <tr>
-                        <th>公司</th>
-                        <th>类型</th>
-                        <th class="wrap">内容摘要</th>
-                        <th>发送时间</th>
-                        <th>截止日期</th>
-                        <th>处理状态</th>
-                        <th>操作</th>
-                      </tr>
-                    </thead>
-                    <tbody id="reminder-tbody"></tbody>
-                  </table>
-                </div>
-                <div class="table-foot">
-                  <span id="table-foot-count">共 0 条提醒记录</span>
-                  <span id="table-foot-state">未读 0 · 处理中 0 · 已完成 0</span>
-                </div>
+            <div class="card" id="reminder-history-card">
+              <div class="card-head">
+                <span class="card-title">提醒历史<span class="sub">含系统自动触发与人工发送的全部提醒记录</span></span>
               </div>
+              <div class="tabs" id="reminder-tabs">
+                <button type="button" class="active" data-filter="all">全部<span class="tab-count" id="count-all">0</span></button>
+                <button type="button" data-filter="system">系统提醒<span class="tab-count" id="count-system">0</span></button>
+                <button type="button" data-filter="manual">人工提醒<span class="tab-count" id="count-manual">0</span></button>
+              </div>
+              <div class="table-wrap history-table">
+                <table class="ds-table">
+                  <thead>
+                    <tr>
+                      <th>公司</th>
+                      <th>来源</th>
+                      <th>类型</th>
+                      <th class="wrap">内容摘要</th>
+                      <th>发送时间</th>
+                      <th>截止日期</th>
+                      <th>处理状态</th>
+                      <th>操作</th>
+                    </tr>
+                  </thead>
+                  <tbody id="reminder-tbody"></tbody>
+                </table>
+              </div>
+              <div class="table-foot">
+                <span id="table-foot-count">共 0 条提醒记录</span>
+                <span id="table-foot-state">未读 0 · 处理中 0 · 已完成 0</span>
+              </div>
+            </div>
+
+            <div class="card" id="send-reminder-card">
+              <div class="card-head">
+                <span class="card-title">发送处理提醒<span class="sub">将以人工提醒形式送达所选公司出纳与财务负责人</span></span>
+              </div>
+              <form id="reminderForm" novalidate>
+                <div class="send-flow">
+                  <div class="sf-step">
+                    <div class="sf-step-head">
+                      <span class="sf-idx">01</span>
+                      <span>选择接收公司</span>
+                      <span class="meta" id="pick-count">已选 0 家</span>
+                    </div>
+                    <div class="pick-list" id="reminderCompanyList"></div>
+                    <span class="hint error" id="company-error" style="display: none;">请至少选择一家接收公司</span>
+                    <p class="hint">每家公司将分别生成一条提醒，可在上方「待提醒清单」勾选后自动带入。</p>
+                  </div>
+                  <div class="sf-step">
+                    <div class="sf-step-head">
+                      <span class="sf-idx">02</span>
+                      <span>填写提醒内容</span>
+                    </div>
+                    <div class="field">
+                      <label for="reminder-type">提醒类型</label>
+                      <select class="select" id="reminder-type">
+                        <option selected>流水未提交</option>
+                        <option>单边待确认</option>
+                        <option>科目待确认</option>
+                        <option>账户登记</option>
+                        <option>其他</option>
+                      </select>
+                    </div>
+                    <div class="field">
+                      <label for="reminder-content">提醒内容</label>
+                      <textarea class="textarea" id="reminder-content">请于截止日期前完成 2026 年 7 月银行流水上传与待确认事项处理。</textarea>
+                      <span class="hint error" id="content-error" style="display: none;">提醒内容不能为空</span>
+                    </div>
+                  </div>
+                  <div class="sf-step">
+                    <div class="sf-step-head">
+                      <span class="sf-idx">03</span>
+                      <span>设定截止并发送</span>
+                    </div>
+                    <div class="field">
+                      <label for="reminder-deadline">截止日期</label>
+                      <input class="input" type="date" id="reminder-deadline" value="2026-08-29" min="2026-08-20" />
+                    </div>
+                    <div class="sf-send">
+                      <button type="submit" class="btn btn-primary" id="send-btn">发送提醒</button>
+                      <p class="hint" id="send-result-hint">发送后可在上方「提醒历史」中跟踪触达与处理状态。</p>
+                      <p class="hint" id="send-hint" style="display: none;"></p>
+                    </div>
+                  </div>
+                </div>
+              </form>
+            </div>
             </div>
           </section>
         </main>
@@ -862,29 +1018,99 @@
     <div class="modal-backdrop" id="closingDialog">
       <div class="modal">
         <div class="modal-head">
-          <span class="modal-title">确认执行 2026-07 月度结账</span>
+          <span class="modal-title" id="closingDialogTitle">确认执行月度结账</span>
           <button type="button" class="modal-close" data-close-closing aria-label="关闭">×</button>
         </div>
-        <p class="modal-sub">结账后成员公司的 7 月流水与往来确认将锁定，不可再修改。</p>
+        <p class="modal-sub" id="closingDialogSub">结账后该月流水与往来确认将锁定，不可再直接修改。</p>
         <form id="closingForm" novalidate>
+          <div class="notice warn" style="margin-bottom: 14px;">
+            <div>
+              <div class="n-title">请确认后果</div>
+              <div class="n-body" id="closingConsequences">① 该账期往来结果锁定，普通写入将被拒绝。<br />② 生成不可静默改写的月报并结转期末。<br />③ 确需更正须申请重开，经审批后留痕修改。</div>
+            </div>
+          </div>
           <div class="detail-box">
             <dl class="kv">
-              <dt>结账账期</dt><dd>2026-07</dd>
-              <dt>检查通过</dt><dd>全部前置检查已通过</dd>
-              <dt>期末归集</dt><dd>往来净额将结转至 2026-08 期初</dd>
+              <dt>结账账期</dt><dd id="cdMonth">—</dd>
+              <dt>检查通过</dt><dd id="cdChecks">—</dd>
+              <dt>期末归集</dt><dd id="cdCarry">往来净额将结转至下一账期期初</dd>
             </dl>
           </div>
           <label class="row" style="gap: 6px; font-size: 13px; margin-top: 14px; cursor: pointer;">
-            <input type="checkbox" name="confirm" required style="width: auto;" />我已复核 2026 年 7 月结账结果
+            <input type="checkbox" name="confirm" id="closingConfirmBox" required style="width: auto;" />我已复核结账结果并知晓锁定后果
           </label>
           <div class="modal-actions">
             <button type="button" class="btn" data-close-closing>再想想</button>
-            <button type="submit" class="btn btn-primary">确认结账</button>
+            <button type="submit" class="btn btn-primary" id="closingConfirmBtn">确认结账并锁定</button>
           </div>
         </form>
       </div>
     </div>
 
+    <div class="modal-backdrop" id="reopenRequestDialog">
+      <div class="modal">
+        <div class="modal-head">
+          <span class="modal-title" id="reopenRequestTitle">申请重开账期</span>
+          <button type="button" class="modal-close" data-close-reopen-req aria-label="关闭">×</button>
+        </div>
+        <p class="modal-sub">重开解除锁定但保留原月报；更正后须重新结账。</p>
+        <form id="reopenRequestForm" novalidate>
+          <div class="notice warn" style="margin-bottom: 14px;">
+            <div>
+              <div class="n-title">请确认后果</div>
+              <div class="n-body">① 批准后该账期暂时解除锁定，所有更正留痕。<br />② 原月报作废，窗口结束后或提前结束须重新结账。<br />③ 申请人、原因、时间与前后变化可倒查。</div>
+            </div>
+          </div>
+          <div class="field">
+            <label for="reopenReason">重开原因 *</label>
+            <textarea class="textarea" id="reopenReason" minlength="10" required placeholder="不少于 10 个字，将写入审计记录"></textarea>
+            <span class="hint">原因会进入审计记录，不可事后删改。</span>
+          </div>
+          <div class="field" style="margin-top: 12px;">
+            <label for="reopenCompanies">涉及公司与事项</label>
+            <input class="input" id="reopenCompanies" placeholder="例如：金牛煤业 ↔ 金牛物流 运输费补录" />
+          </div>
+          <div class="field" style="margin-top: 12px;">
+            <label for="reopenDays">申请窗口（天）</label>
+            <input class="input num-input" id="reopenDays" type="number" min="1" max="30" value="3" />
+            <span class="hint">到期自动恢复锁定；默认 3 天。</span>
+          </div>
+          <div class="modal-actions">
+            <button type="button" class="btn" data-close-reopen-req>取消</button>
+            <button type="submit" class="btn btn-warn">提交重开申请</button>
+          </div>
+        </form>
+      </div>
+    </div>
+
+    <div class="modal-backdrop" id="reopenDecideDialog">
+      <div class="modal wide">
+        <div class="modal-head">
+          <span class="modal-title" id="reopenDecideTitle">重开审批</span>
+          <button type="button" class="modal-close" data-close-reopen-dec aria-label="关闭">×</button>
+        </div>
+        <p class="modal-sub" id="reopenDecideSub">—</p>
+        <div class="detail-box">
+          <dl class="kv" id="reopenDecideKv"></dl>
+        </div>
+        <div class="diff-grid" id="reopenDiff" style="margin-top: 16px;"></div>
+        <div class="notice info" style="margin-top: 14px;">
+          <div>
+            <div class="n-title">凭证与入账方式</div>
+            <div class="n-body">批准后按审批窗口解除锁定；银行原始流水永不改写，更正通过新决定与留痕完成。</div>
+          </div>
+        </div>
+        <div class="field" style="margin-top: 14px;">
+          <label for="reopenComment">审批意见（驳回必填）</label>
+          <textarea class="textarea" id="reopenComment" placeholder="通过可写备注；驳回须说明原因"></textarea>
+        </div>
+        <div class="modal-actions">
+          <button type="button" class="btn btn-danger" id="reopenRejectBtn">驳回申请</button>
+          <button type="button" class="btn btn-warn" id="reopenApproveBtn">同意重开</button>
+        </div>
+      </div>
+    </div>
+
     <!-- 往来穿透弹窗 -->
     <div class="modal-backdrop" id="traceModal">
       <div class="modal wide">
@@ -947,6 +1173,26 @@
       </div>
     </div>
 
+    <!-- 提醒详情抽屉 -->
+    <aside class="drawer" id="reminder-detail-drawer" aria-label="提醒详情">
+      <div class="drawer-head">
+        <div>
+          <span class="pill pill-info" id="rd-source-pill">系统</span>
+          <h2 class="d-title" id="rd-title">提醒详情</h2>
+          <p class="d-desc" id="rd-sub"></p>
+        </div>
+        <button type="button" class="icon-button" data-close-rd aria-label="关闭详情" title="关闭详情">×</button>
+      </div>
+      <div class="drawer-body">
+        <dl class="kv" id="rd-fields"></dl>
+        <h3 style="font-size: 13px; margin: 16px 0 8px; color: var(--muted);">事件留痕</h3>
+        <div id="rd-events"></div>
+      </div>
+      <div class="drawer-foot">
+        <button type="button" class="btn" data-close-rd>关闭</button>
+      </div>
+    </aside>
+
     <!-- 提醒历史弹窗 -->
     <div class="modal-backdrop" id="history-modal">
       <div class="modal">
@@ -962,6 +1208,6 @@
       </div>
     </div>
     <div class="toast-region" id="toastRegion" aria-live="polite"></div>
-    <script src="app.js?v=13"></script>
+    <script src="app.js?v=15"></script>
   </body>
 </html>

web/company.html

@@ -5,7 +5,7 @@
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
     <meta name="description" content="金牛集团公司业务端" />
     <title>公司业务端 · 金牛集团</title>
-    <link rel="stylesheet" href="design-system.css?v=6" />
+    <link rel="stylesheet" href="design-system.css?v=7" />
   </head>
   <body data-portal="company">
     <a class="skip-link" href="#main-content">跳到主要内容</a>
@@ -26,7 +26,7 @@
           <a data-view="reconcile" href="#reconcile"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.7"><path d="M9 11.5l2 2 4-4.5"/><rect x="4" y="3" width="16" height="18" rx="2"/></svg><span class="nav-label">往来确认</span><span class="nav-badge">5</span></a>
           <div class="nav-group">账户与消息</div>
           <a data-view="accounts" href="#accounts"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.7"><rect x="3" y="5" width="18" height="14" rx="2"/><path d="M3 10h18"/></svg><span class="nav-label">银行账户</span></a>
-          <a data-view="notifications" href="#notifications"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.7"><path d="M6 9a6 6 0 1 1 12 0c0 5 2 6 2 6H4s2-1 2-6"/><path d="M10 19a2 2 0 0 0 4 0"/></svg><span class="nav-label">通知</span><span class="nav-badge">3</span></a>
+          <a data-view="notifications" href="#notifications"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.7"><path d="M6 9a6 6 0 1 1 12 0c0 5 2 6 2 6H4s2-1 2-6"/><path d="M10 19a2 2 0 0 0 4 0"/></svg><span class="nav-label">通知</span><span class="nav-badge" id="notice-nav-badge" style="display: none;">0</span></a>
         </nav>
         <div class="side-foot">
           <div class="user-row">
@@ -181,31 +181,10 @@
                 <div class="card">
                   <div class="card-head">
                     <span class="card-title">最新通知<span class="sub">来自管理端</span></span>
-                    <button class="btn btn-sm btn-ghost" data-view-link="notifications">全部通知 (3) →</button>
+                    <button class="btn btn-sm btn-ghost" data-view-link="notifications" id="workspace-notice-link">全部通知 →</button>
                   </div>
-                  <div class="list-row">
-                    <span class="pill pill-warn">提醒</span>
-                    <div class="lr-main">
-                      <div class="lr-title">7 月账期结账日顺延至 08-29</div>
-                      <div class="lr-sub">请在此之前完成往来确认事项</div>
-                    </div>
-                    <span class="lr-side meta">08-18</span>
-                  </div>
-                  <div class="list-row">
-                    <span class="pill pill-warn">提醒</span>
-                    <div class="lr-main">
-                      <div class="lr-title">3 笔单边流水待确认</div>
-                      <div class="lr-sub">涉及金牛置业、金牛贸易往来</div>
-                    </div>
-                    <span class="lr-side meta">08-16</span>
-                  </div>
-                  <div class="list-row">
-                    <span class="pill pill-success">通过</span>
-                    <div class="lr-main">
-                      <div class="lr-title">中行尾号 9916 流水导入成功</div>
-                      <div class="lr-sub">流水覆盖至 08-12</div>
-                    </div>
-                    <span class="lr-side meta">08-12</span>
+                  <div id="workspace-notice-list">
+                    <div class="empty"><div class="e-title">暂无通知</div></div>
                   </div>
                 </div>
               </div>
@@ -322,7 +301,7 @@
                     <div class="field"><label>金额（元）*</label><input class="input num-input" name="amount" type="number" min="0.01" step="0.01" required /></div>
                     <div class="field"><label>资金来源 *</label><select class="select" name="sourceAccount" required><option value="">请选择</option><option>个人过账</option></select></div>
                     <div class="field"><label>对方类型 *</label><select class="select" name="counterpartyType" required><option>集团内部公司</option><option>个人过账方</option><option>外部单位</option></select></div>
-                    <div class="field"><label>对方名称 *</label><input class="input" name="counterparty" maxlength="100" placeholder="公司全称或个人姓名" required /></div>
+                    <div class="field"><label>对方公司 *</label><select class="select" name="counterparty" id="manualCounterparty" required><option value="">请选择集团内公司</option></select></div>
                     <div class="field"><label>对方账号</label><input class="input" name="counterpartyAccount" maxlength="64" placeholder="可选" /></div>
                     <div class="field"><label>往来科目 *</label><select class="select" name="subject" required><option>应收</option><option>应付</option><option>其他应收</option><option>其他应付</option></select></div>
                   </div>
@@ -804,93 +783,15 @@
 
             <div class="card">
               <div class="tabs" id="notice-tabs">
-                <button type="button" class="active" data-filter="all" aria-pressed="true">全部<span class="tab-count" id="count-all">9</span></button>
-                <button type="button" data-filter="unread" aria-pressed="false">未读<span class="tab-count" id="count-unread">3</span></button>
-                <button type="button" data-filter="doing" aria-pressed="false">处理中<span class="tab-count" id="count-doing">2</span></button>
-                <button type="button" data-filter="done" aria-pressed="false">已完成<span class="tab-count" id="count-done">4</span></button>
+                <button type="button" class="active" data-filter="all" aria-pressed="true">全部<span class="tab-count" id="count-all">0</span></button>
+                <button type="button" data-filter="unread" aria-pressed="false">未读<span class="tab-count" id="count-unread">0</span></button>
+                <button type="button" data-filter="doing" aria-pressed="false">处理中<span class="tab-count" id="count-doing">0</span></button>
+                <button type="button" data-filter="done" aria-pressed="false">已完成<span class="tab-count" id="count-done">0</span></button>
               </div>
 
-              <div id="notice-list">
-                <div class="list-row" data-status="unread">
-                  <span class="pill pill-danger" style="flex: none;">未读</span>
-                  <span class="tag">系统</span>
-                  <div class="lr-main">
-                    <div class="lr-title">7 月流水存在断档风险：交行 尾号 7710 未上传</div>
-                    <div class="lr-sub"><span class="meta">2026-08-20 14:32</span> · 交行 7710 账户（待审核）7 月流水尚未上传，距 7 月结账日（顺延至 08-29）仅剩 9 天，请尽快补传。</div>
-                  </div>
-                  <div class="lr-side"><button class="btn btn-sm btn-mark-read">标记已读</button></div>
-                </div>
-                <div class="list-row" data-status="unread">
-                  <span class="pill pill-danger" style="flex: none;">未读</span>
-                  <span class="tag">系统</span>
-                  <div class="lr-main">
-                    <div class="lr-title">您有 2 笔单边流水待选择对方证据</div>
-                    <div class="lr-sub"><span class="meta">2026-08-19 09:15</span> · 与金牛置业的煤炭采购款 ¥3,200,000.00 等 2 笔流水仅有本方记录，需选择对方银行流水佐证。</div>
-                  </div>
-                  <div class="lr-side"><button class="btn btn-sm btn-mark-read">标记已读</button></div>
-                </div>
-                <div class="list-row" data-status="unread">
-                  <span class="pill pill-danger" style="flex: none;">未读</span>
-                  <span class="tag">管理员</span>
-                  <div class="lr-main">
-                    <div class="lr-title">管理员提醒：请于 08-29 前完成待确认事项</div>
-                    <div class="lr-sub"><span class="meta">2026-08-18 16:40</span> · 7 月账期结账顺延至 08-29，贵公司当前仍有 5 项往来确认未完成，请合理安排时间。</div>
-                  </div>
-                  <div class="lr-side"><button class="btn btn-sm btn-mark-read">标记已读</button></div>
-                </div>
-                <div class="list-row" data-status="doing">
-                  <span class="pill pill-warn" style="flex: none;">处理中</span>
-                  <span class="tag">系统</span>
-                  <div class="lr-main">
-                    <div class="lr-title">手工记录科目待确认：其他应收 ¥86,500.00</div>
-                    <div class="lr-sub"><span class="meta">2026-08-15 10:02</span> · 07-28 录入的矿区备用金垫付记录，往来科目「其他应收」待管理员复核。</div>
-                  </div>
-                  <div class="lr-side"><button class="btn btn-sm btn-primary" data-view-link="manual">去处理</button></div>
-                </div>
-                <div class="list-row" data-status="doing">
-                  <span class="pill pill-warn" style="flex: none;">处理中</span>
-                  <span class="tag">管理员</span>
-                  <div class="lr-main">
-                    <div class="lr-title">往来确认回复：置业已确认 320 万煤炭采购款</div>
-                    <div class="lr-sub"><span class="meta">2026-08-12 11:26</span> · 金牛置业已确认 07-14 煤炭采购款 ¥3,200,000.00，请补充本方工行 3305 账户流水证据完成闭环。</div>
-                  </div>
-                  <div class="lr-side"><button class="btn btn-sm btn-primary" data-view-link="reconcile">去处理</button></div>
-                </div>
-                <div class="list-row" data-status="done">
-                  <span class="pill pill-success" style="flex: none;">已完成</span>
-                  <span class="tag">系统</span>
-                  <div class="lr-main">
-                    <div class="lr-title">流水导入成功：中行 尾号 9916 · 42 笔</div>
-                    <div class="lr-sub"><span class="meta">2026-08-06 15:52</span> · 7 月中行一般户流水已导入，42 笔全部校验通过，无重复记录。</div>
-                  </div>
-                </div>
-                <div class="list-row" data-status="done">
-                  <span class="pill pill-success" style="flex: none;">已完成</span>
-                  <span class="tag">系统</span>
-                  <div class="lr-main">
-                    <div class="lr-title">流水导入成功：工行 尾号 3305 · 86 笔</div>
-                    <div class="lr-sub"><span class="meta">2026-08-06 15:48</span> · 7 月工行基本户流水已导入，86 笔全部校验通过，无重复记录。</div>
-                  </div>
-                </div>
-                <div class="list-row" data-status="done">
-                  <span class="pill pill-success" style="flex: none;">已完成</span>
-                  <span class="tag">管理员</span>
-                  <div class="lr-main">
-                    <div class="lr-title">交行 尾号 7710 账户开户资料已受理</div>
-                    <div class="lr-sub"><span class="meta">2026-07-22 13:10</span> · 新账户开户资料已提交管理员，审核通过后方可启用并上传流水。</div>
-                  </div>
-                </div>
-                <div class="list-row" data-status="done">
-                  <span class="pill pill-success" style="flex: none;">已完成</span>
-                  <span class="tag">系统</span>
-                  <div class="lr-main">
-                    <div class="lr-title">2026 年 6 月账期已结账</div>
-                    <div class="lr-sub"><span class="meta">2026-07-05 09:00</span> · 6 月账期已按每月 5 日结账规则完成结账，期末数据已锁定，不可再修改。</div>
-                  </div>
-                </div>
-              </div>
+              <div id="notice-list"></div>
 
-              <div class="empty" id="notice-empty" style="display: none;">
+              <div class="empty" id="notice-empty">
                 <div class="e-title">暂无该状态的通知</div>
                 <div>切换其他状态查看，或等待新的系统与管理员消息。</div>
               </div>
@@ -1108,6 +1009,6 @@
     </aside>
 
     <div class="toast-region" id="toastRegion" aria-live="polite"></div>
-    <script src="app.js?v=13"></script>
+    <script src="app.js?v=15"></script>
   </body>
 </html>

web/design-system.css

@@ -1083,3 +1083,211 @@ body[data-portal="company"] .side-nav a[data-view="transfers"].active svg {
   .xfer-split { grid-template-columns: 1fr; }
   .xfer-split-pane.confirmed { border-right: 0; border-bottom: 1px solid var(--border); }
 }
+
+/* ─── 提醒管理：三步发送流（HEL-230） ─────────────────────────── */
+.send-flow {
+  display: grid;
+  grid-template-columns: minmax(0, 1fr) minmax(0, 1.5fr) minmax(0, 1fr);
+  align-items: stretch;
+  gap: 0;
+}
+.sf-step {
+  display: flex;
+  flex-direction: column;
+  gap: 10px;
+  min-width: 0;
+  padding: 0 18px;
+}
+.sf-step:first-child { padding-left: 0; }
+.sf-step:last-child { padding-right: 0; }
+.sf-step + .sf-step { border-left: 1px solid var(--border); }
+.sf-step-head {
+  display: flex;
+  align-items: baseline;
+  gap: 8px;
+}
+.sf-idx {
+  font-family: var(--font-mono);
+  font-size: 12px;
+  font-weight: 650;
+  color: var(--accent);
+  flex: none;
+}
+.sf-step-head > span:nth-child(2) { font-size: 13px; font-weight: 650; }
+.sf-step-head .meta { margin-left: auto; }
+.sf-step .hint { font-size: 11.5px; color: var(--muted); }
+.sf-step .hint.error { color: var(--danger); }
+.pick-list {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 8px;
+  align-items: center;
+}
+.pick {
+  display: inline-flex;
+  align-items: center;
+  gap: 6px;
+  padding: 5px 10px;
+  border: 1px solid var(--border);
+  border-radius: 999px;
+  background: var(--surface);
+  color: var(--fg);
+  font-size: 13px;
+  cursor: pointer;
+  transition: background 0.12s ease, border-color 0.12s ease, color 0.12s ease;
+}
+.pick:hover { background: var(--fg-soft); }
+.pick:has(input:checked) {
+  background: var(--accent-soft);
+  border-color: var(--accent);
+  color: var(--accent);
+}
+.pick input { width: auto; margin: 0; }
+.sf-send {
+  margin-top: auto;
+  display: flex;
+  flex-direction: column;
+  gap: 8px;
+}
+.sf-send .btn-primary { width: 100%; }
+
+[data-page="reminders"] .history-table {
+  border: 0;
+}
+[data-page="reminders"] .history-table .ds-table {
+  min-width: 0;
+}
+[data-page="reminders"] .history-table .ds-table th:nth-child(1),
+[data-page="reminders"] .history-table .ds-table td:nth-child(1) {
+  width: 14%;
+}
+[data-page="reminders"] .history-table .ds-table th:nth-child(4),
+[data-page="reminders"] .history-table .ds-table td:nth-child(4) {
+  width: 28%;
+  white-space: normal;
+  min-width: 160px;
+}
+
+@media (max-width: 1100px) {
+  .send-flow { grid-template-columns: minmax(0, 1fr); }
+  .sf-step { padding: 14px 0 0; }
+  .sf-step:first-child { padding-top: 0; }
+  .sf-step + .sf-step {
+    border-left: 0;
+    border-top: 1px solid var(--border);
+  }
+}
+
+/* ─── 月结 / 重开 / 审计（HEL-268，仅 5 条组件规则） ───────────── */
+.btn-warn {
+  background: var(--warn);
+  border-color: var(--warn);
+  color: var(--surface);
+}
+.btn-warn:hover {
+  background: color-mix(in oklch, var(--warn) 88%, black);
+  border-color: color-mix(in oklch, var(--warn) 88%, black);
+}
+.btn-warn[disabled] {
+  opacity: 1;
+  background: var(--fg-soft);
+  border-color: var(--border);
+  color: var(--muted);
+}
+
+.pill-lock {
+  background: var(--fg-soft);
+  color: var(--muted);
+  height: 23px;
+}
+.pill-lock::before {
+  width: 11px;
+  height: 11px;
+  border-radius: 0;
+  background-color: currentColor;
+  mask: url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 24 24' fill='none' stroke='black' stroke-width='2'%3E%3Crect x='5' y='11' width='14' height='10' rx='1.5'/%3E%3Cpath d='M8 11V8a4 4 0 0 1 8 0v3'/%3E%3C/svg%3E") center / contain no-repeat;
+}
+
+.tl-cell.locked { background: var(--fg-soft); }
+.tl-cell.locked .tl-state { color: var(--muted); }
+.tl-cell.locked .tl-state::before {
+  content: "";
+  width: 11px;
+  height: 11px;
+  background-color: currentColor;
+  mask: url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 24 24' fill='none' stroke='black' stroke-width='2'%3E%3Crect x='5' y='11' width='14' height='10' rx='1.5'/%3E%3Cpath d='M8 11V8a4 4 0 0 1 8 0v3'/%3E%3C/svg%3E") center / contain no-repeat;
+}
+.tl-cell.reopened { background: var(--warn-soft); }
+.tl-cell.reopened .tl-state { color: color-mix(in oklch, var(--warn) 80%, black); }
+.tl-cell.failed { background: var(--danger-soft); }
+.tl-cell.failed .tl-state { color: var(--danger); }
+
+.diff-grid {
+  display: grid;
+  grid-template-columns: minmax(0, 1fr) auto minmax(0, 1fr);
+  gap: 10px 12px;
+  align-items: start;
+}
+.diff-grid .diff-row {
+  display: contents;
+}
+.diff-grid .diff-label {
+  grid-column: 1 / -1;
+  font-size: 12px;
+  color: var(--muted);
+}
+.diff-grid .diff-before {
+  color: var(--muted);
+  text-decoration: line-through;
+  font-family: var(--font-mono);
+  font-size: 13px;
+}
+.diff-grid .diff-arrow {
+  color: var(--muted);
+  align-self: center;
+}
+.diff-grid .diff-after {
+  color: color-mix(in oklch, var(--warn) 78%, black);
+  font-family: var(--font-mono);
+  font-size: 13px;
+}
+.diff-grid .diff-row.changed .diff-before,
+.diff-grid .diff-row.changed .diff-after,
+.diff-grid .diff-row.changed .diff-arrow {
+  box-shadow: inset 3px 0 0 var(--warn);
+  padding-left: 8px;
+}
+@media (max-width: 860px) {
+  .diff-grid { grid-template-columns: minmax(0, 1fr); }
+  .diff-grid .diff-arrow { transform: rotate(90deg); justify-self: center; }
+}
+
+.empty-icon {
+  width: 48px;
+  height: 48px;
+  margin: 0 auto 12px;
+  color: var(--border);
+  display: block;
+}
+
+.closing-panel.is-processing {
+  pointer-events: none;
+  opacity: 0.55;
+}
+.closing-kv {
+  display: grid;
+  grid-template-columns: repeat(4, minmax(0, 1fr));
+  gap: 12px;
+  margin-top: 16px;
+  padding-top: 14px;
+  border-top: 1px solid var(--border);
+}
+.closing-kv .ck-label { font-size: 12px; color: var(--muted); }
+.closing-kv .ck-value { font-family: var(--font-mono); font-size: 13px; margin-top: 4px; }
+.lock-view-only { color: var(--muted); font-size: 12px; }
+.audit-event-cards { display: none; }
+@media (max-width: 460px) {
+  .closing-kv { grid-template-columns: 1fr 1fr; }
+  [data-page="period-audit"] .table-wrap { display: none; }
+  .audit-event-cards { display: grid; gap: 10px; }
+}