HEL-222: 整合自动提醒引擎(212b1f9)到现行测试版 d6f39e0

- 迁移链追加 0009_reminders_engine：旧 manual reminders 表改名
  reminders_legacy_manual 保留历史，新建 reminders/reminder_events/
  reminder_settings（append-only 触发器）
- server.py：新提醒 API（pending/scan/send/manual/resend/settings/
  公司端收件与状态流转）替换旧 manual-send 端点
- web：admin 待提醒清单+扫描+详情抽屉，公司端通知动态化+
  去处理事件委托；设置保存同步提醒扫描参数
- 移除被取代的 settings.pending_items/send_reminders 与旧 UI 逻辑
- 全量测试 346 项通过（5 项浏览器跳过与历史一致）

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

.gitignore

@@ -1,6 +1,7 @@
 __pycache__/
 *.py[cod]
 .venv/
+.chrome-libs/
 .tmp-*/
 
 # 运行时数据与真实银行文件一律不进仓库（样本仅限流水模板/中已脱敏的六份）

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] 规范转账事件、双边匹配与调拨排除
 
 ## 背景

src/bank_importer/calculation.py

@@ -0,0 +1,960 @@
+"""Calculation window: start date, opening balances, coverage gaps and balances."""
+
+from __future__ import annotations
+
+from datetime import date, datetime, timedelta, timezone
+from decimal import Decimal, InvalidOperation
+import json
+import sqlite3
+
+from .db import utc_now
+from . import master_data, matching
+
+
+SETTING_START_DATE = "calculation_start_date"
+OPENING_STATUSES = ("draft", "confirmed", "superseded", "void")
+GAP_KINDS = ("head", "mid", "tail")
+GAP_STATUSES = ("open", "closed_attested")
+ATTESTATION_STATUSES = ("pending", "approved", "rejected")
+
+
+class LockedError(ValueError):
+    """Start date cannot change after a period is closed."""
+
+
+class ConflictError(ValueError):
+    """Revision or state conflict."""
+
+
+def utc_today() -> str:
+    return datetime.now(timezone.utc).date().isoformat()
+
+
+def _parse_decimal(value: object) -> Decimal:
+    try:
+        return Decimal(str(value))
+    except (InvalidOperation, TypeError):
+        raise ValueError("金额格式无效。") from None
+
+
+def normalize_pair(company_a: int, company_b: int) -> tuple[int, int]:
+    if company_a == company_b:
+        raise ValueError("两家公司不能相同。")
+    return (company_a, company_b) if company_a < company_b else (company_b, company_a)
+
+
+def signed_from_viewer(viewer_id: int, low_id: int, high_id: int, amount: Decimal) -> Decimal:
+    return amount if viewer_id == low_id else -amount
+
+
+def get_setting(connection: sqlite3.Connection, key: str) -> str | None:
+    row = connection.execute(
+        "SELECT value FROM system_settings WHERE key = ?", (key,)
+    ).fetchone()
+    return row["value"] if row is not None else None
+
+
+def get_calculation_start_date(connection: sqlite3.Connection) -> str | None:
+    return get_setting(connection, SETTING_START_DATE)
+
+
+def has_closed_periods(connection: sqlite3.Connection) -> bool:
+    row = connection.execute("SELECT 1 FROM closed_periods LIMIT 1").fetchone()
+    return row is not None
+
+
+def is_start_date_locked(connection: sqlite3.Connection) -> bool:
+    return has_closed_periods(connection)
+
+
+def set_calculation_start_date(
+    connection: sqlite3.Connection,
+    start_date: str,
+    reason: str,
+    actor: sqlite3.Row,
+) -> dict[str, object]:
+    start_date = master_data.validate_date(start_date, "起算日", required=True)
+    reason = str(reason or "").strip()
+    if len(reason) < 2:
+        raise ValueError("修改起算日必须填写原因。")
+    if is_start_date_locked(connection):
+        raise LockedError("已有结账月份，起算日已锁定。")
+    before = get_calculation_start_date(connection)
+    now = utc_now()
+    with connection:
+        connection.execute(
+            """
+            INSERT INTO system_settings (key, value, updated_at, updated_by)
+            VALUES (?, ?, ?, ?)
+            ON CONFLICT(key) DO UPDATE SET
+                value = excluded.value,
+                updated_at = excluded.updated_at,
+                updated_by = excluded.updated_by
+            """,
+            (SETTING_START_DATE, start_date, now, actor["id"]),
+        )
+        connection.execute(
+            """
+            INSERT INTO system_setting_changes (
+                key, before_value, after_value,
+                actor_user_id, actor_username, created_at
+            ) VALUES (?, ?, ?, ?, ?, ?)
+            """,
+            (
+                SETTING_START_DATE,
+                before,
+                start_date,
+                actor["id"],
+                actor["username"],
+                now,
+            ),
+        )
+        master_data.record_change(
+            connection,
+            "system_setting",
+            0,
+            "update_start_date",
+            {"calculation_start_date": before},
+            {"calculation_start_date": start_date},
+            reason,
+            actor,
+        )
+        recalculate_coverage_gaps(connection)
+    return {
+        "calculation_start_date": start_date,
+        "locked": False,
+        "previous": before,
+    }
+
+
+def start_date_payload(connection: sqlite3.Connection) -> dict[str, object]:
+    return {
+        "calculation_start_date": get_calculation_start_date(connection),
+        "locked": is_start_date_locked(connection),
+    }
+
+
+def _current_opening_revision(
+    connection: sqlite3.Connection, low_id: int, high_id: int
+) -> sqlite3.Row | None:
+    return connection.execute(
+        """
+        SELECT * FROM opening_balance_revisions
+        WHERE company_id_low = ? AND company_id_high = ?
+          AND status IN ('draft', 'confirmed')
+        ORDER BY revision DESC
+        LIMIT 1
+        """,
+        (low_id, high_id),
+    ).fetchone()
+
+
+def _next_revision(connection: sqlite3.Connection, low_id: int, high_id: int) -> int:
+    row = connection.execute(
+        """
+        SELECT MAX(revision) AS max_rev FROM opening_balance_revisions
+        WHERE company_id_low = ? AND company_id_high = ?
+        """,
+        (low_id, high_id),
+    ).fetchone()
+    return int(row["max_rev"] or 0) + 1
+
+
+def create_opening_balance(
+    connection: sqlite3.Connection,
+    company_a: int,
+    company_b: int,
+    amount: object,
+    reason: str,
+    actor: sqlite3.Row,
+    *,
+    currency: str = "CNY",
+    viewer_company_id: int | None = None,
+) -> dict[str, object]:
+    low_id, high_id = normalize_pair(company_a, company_b)
+    decimal_amount = _parse_decimal(amount)
+    if viewer_company_id is not None and viewer_company_id == high_id:
+        decimal_amount = -decimal_amount
+    reason = str(reason or "").strip()
+    if len(reason) < 2:
+        raise ValueError("录入期初必须填写原因。")
+    existing = _current_opening_revision(connection, low_id, high_id)
+    if existing is not None and existing["status"] == "draft":
+        raise ConflictError("该公司对已有待确认期初，请先确认或作废后再录入。")
+    if existing is not None and existing["status"] == "confirmed":
+        raise ConflictError("该对公司已有确认期初，请使用修订。")
+    revision = _next_revision(connection, low_id, high_id)
+    now = utc_now()
+    with connection:
+        cursor = connection.execute(
+            """
+            INSERT INTO opening_balance_revisions (
+                company_id_low, company_id_high, amount, currency, revision,
+                status, reason, actor_user_id, actor_username, created_at
+            ) VALUES (?, ?, ?, ?, ?, 'draft', ?, ?, ?, ?)
+            """,
+            (
+                low_id,
+                high_id,
+                str(decimal_amount),
+                currency,
+                revision,
+                reason,
+                actor["id"],
+                actor["username"],
+                now,
+            ),
+        )
+        row_id = int(cursor.lastrowid)
+        master_data.record_change(
+            connection,
+            "opening_balance",
+            row_id,
+            "create_draft",
+            None,
+            {"company_id_low": low_id, "company_id_high": high_id, "amount": str(decimal_amount)},
+            reason,
+            actor,
+        )
+    return opening_balance_payload(connection, row_id)
+
+
+def confirm_opening_balance(
+    connection: sqlite3.Connection,
+    revision_id: int,
+    reason: str,
+    actor: sqlite3.Row,
+) -> dict[str, object]:
+    row = connection.execute(
+        "SELECT * FROM opening_balance_revisions WHERE id = ?", (revision_id,)
+    ).fetchone()
+    if row is None:
+        raise ValueError("期初记录不存在。")
+    if row["status"] != "draft":
+        raise ConflictError("只能确认待确认状态的期初。")
+    reason = str(reason or "").strip()
+    if len(reason) < 2:
+        raise ValueError("确认期初必须填写原因。")
+    with connection:
+        connection.execute(
+            """
+            UPDATE opening_balance_revisions SET status = 'confirmed', reason = ?
+            WHERE id = ?
+            """,
+            (reason, revision_id),
+        )
+        master_data.record_change(
+            connection,
+            "opening_balance",
+            revision_id,
+            "confirm",
+            {"status": "draft"},
+            {"status": "confirmed"},
+            reason,
+            actor,
+        )
+    return opening_balance_payload(connection, revision_id)
+
+
+def revise_opening_balance(
+    connection: sqlite3.Connection,
+    revision_id: int,
+    amount: object,
+    reason: str,
+    actor: sqlite3.Row,
+) -> dict[str, object]:
+    row = connection.execute(
+        "SELECT * FROM opening_balance_revisions WHERE id = ?", (revision_id,)
+    ).fetchone()
+    if row is None:
+        raise ValueError("期初记录不存在。")
+    if row["status"] != "confirmed":
+        raise ConflictError("只能修订已确认期初。")
+    decimal_amount = _parse_decimal(amount)
+    reason = str(reason or "").strip()
+    if len(reason) < 2:
+        raise ValueError("修订期初必须填写原因。")
+    low_id = int(row["company_id_low"])
+    high_id = int(row["company_id_high"])
+    revision = _next_revision(connection, low_id, high_id)
+    now = utc_now()
+    with connection:
+        connection.execute(
+            "UPDATE opening_balance_revisions SET status = 'superseded' WHERE id = ?",
+            (revision_id,),
+        )
+        cursor = connection.execute(
+            """
+            INSERT INTO opening_balance_revisions (
+                company_id_low, company_id_high, amount, currency, revision,
+                status, reason, actor_user_id, actor_username, supersedes_id, created_at
+            ) VALUES (?, ?, ?, ?, ?, 'draft', ?, ?, ?, ?, ?)
+            """,
+            (
+                low_id,
+                high_id,
+                str(decimal_amount),
+                row["currency"],
+                revision,
+                reason,
+                actor["id"],
+                actor["username"],
+                revision_id,
+                now,
+            ),
+        )
+        new_id = int(cursor.lastrowid)
+        master_data.record_change(
+            connection,
+            "opening_balance",
+            new_id,
+            "revise",
+            {"amount": row["amount"], "revision_id": revision_id},
+            {"amount": str(decimal_amount), "revision_id": new_id},
+            reason,
+            actor,
+        )
+    return opening_balance_payload(connection, new_id)
+
+
+def void_opening_balance(
+    connection: sqlite3.Connection,
+    revision_id: int,
+    reason: str,
+    actor: sqlite3.Row,
+) -> dict[str, object]:
+    row = connection.execute(
+        "SELECT * FROM opening_balance_revisions WHERE id = ?", (revision_id,)
+    ).fetchone()
+    if row is None:
+        raise ValueError("期初记录不存在。")
+    if row["status"] not in ("draft", "confirmed"):
+        raise ConflictError("该期初已作废或已被替代。")
+    reason = str(reason or "").strip()
+    if len(reason) < 2:
+        raise ValueError("作废期初必须填写原因。")
+    with connection:
+        connection.execute(
+            "UPDATE opening_balance_revisions SET status = 'void', reason = ? WHERE id = ?",
+            (reason, revision_id),
+        )
+        master_data.record_change(
+            connection,
+            "opening_balance",
+            revision_id,
+            "void",
+            {"status": row["status"]},
+            {"status": "void"},
+            reason,
+            actor,
+        )
+    return opening_balance_payload(connection, revision_id)
+
+
+def opening_balance_payload(connection: sqlite3.Connection, revision_id: int) -> dict[str, object]:
+    row = connection.execute(
+        """
+        SELECT r.*, cl.name AS company_low_name, ch.name AS company_high_name
+        FROM opening_balance_revisions r
+        JOIN companies cl ON cl.id = r.company_id_low
+        JOIN companies ch ON ch.id = r.company_id_high
+        WHERE r.id = ?
+        """,
+        (revision_id,),
+    ).fetchone()
+    if row is None:
+        raise ValueError("期初记录不存在。")
+    amount = _parse_decimal(row["amount"])
+    return {
+        "id": row["id"],
+        "company_id_low": row["company_id_low"],
+        "company_id_high": row["company_id_high"],
+        "company_low_name": row["company_low_name"],
+        "company_high_name": row["company_high_name"],
+        "amount": str(amount),
+        "currency": row["currency"],
+        "revision": row["revision"],
+        "status": row["status"],
+        "reason": row["reason"],
+        "actor_username": row["actor_username"],
+        "supersedes_id": row["supersedes_id"],
+        "created_at": row["created_at"],
+        "direction_low": "receivable" if amount >= 0 else "payable",
+    }
+
+
+def list_opening_balances(connection: sqlite3.Connection) -> list[dict[str, object]]:
+    rows = connection.execute(
+        """
+        SELECT r.id FROM opening_balance_revisions r
+        JOIN (
+            SELECT company_id_low, company_id_high, MAX(revision) AS max_rev
+            FROM opening_balance_revisions
+            WHERE status IN ('draft', 'confirmed', 'void')
+            GROUP BY company_id_low, company_id_high
+        ) latest ON latest.company_id_low = r.company_id_low
+               AND latest.company_id_high = r.company_id_high
+               AND latest.max_rev = r.revision
+        WHERE r.status IN ('draft', 'confirmed', 'void')
+        ORDER BY r.company_id_low, r.company_id_high
+        """
+    ).fetchall()
+    return [opening_balance_payload(connection, row["id"]) for row in rows]
+
+
+def confirmed_opening_amount(
+    connection: sqlite3.Connection, low_id: int, high_id: int
+) -> Decimal | None:
+    row = connection.execute(
+        """
+        SELECT amount FROM opening_balance_revisions
+        WHERE company_id_low = ? AND company_id_high = ? AND status = 'confirmed'
+        ORDER BY revision DESC LIMIT 1
+        """,
+        (low_id, high_id),
+    ).fetchone()
+    if row is None:
+        return None
+    return _parse_decimal(row["amount"])
+
+
+def _date_add(day: str, delta: int) -> str:
+    return (date.fromisoformat(day) + timedelta(days=delta)).isoformat()
+
+
+def _merge_intervals(intervals: list[tuple[str, str]]) -> list[tuple[str, str]]:
+    if not intervals:
+        return []
+    sorted_intervals = sorted(intervals, key=lambda item: item[0])
+    merged = [sorted_intervals[0]]
+    for start, end in sorted_intervals[1:]:
+        last_start, last_end = merged[-1]
+        if date.fromisoformat(start) <= date.fromisoformat(_date_add(last_end, 1)):
+            if date.fromisoformat(end) > date.fromisoformat(last_end):
+                merged[-1] = (last_start, end)
+        else:
+            merged.append((start, end))
+    return merged
+
+
+def _account_coverage_intervals(
+    connection: sqlite3.Connection, account: sqlite3.Row
+) -> list[tuple[str, str]]:
+    rows = connection.execute(
+        """
+        SELECT MIN(substr(r.transaction_at, 1, 10)) AS interval_start,
+               MAX(substr(r.transaction_at, 1, 10)) AS interval_end
+        FROM source_rows r
+        JOIN sheet_batches s ON s.id = r.sheet_batch_id
+        JOIN sheet_reviews rv ON rv.sheet_batch_id = s.id AND rv.review_status = 'confirmed'
+        JOIN import_batches b ON b.id = s.import_batch_id
+        WHERE b.upload_bank_account_id = ?
+           OR r.own_account = ?
+        GROUP BY s.id
+        ORDER BY interval_start
+        """,
+        (account["id"], account["account_number"]),
+    ).fetchall()
+    return [
+        (row["interval_start"], row["interval_end"])
+        for row in rows
+        if row["interval_start"] and row["interval_end"]
+    ]
+
+
+def _account_transaction_dates(
+    connection: sqlite3.Connection, account: sqlite3.Row
+) -> list[str]:
+    intervals = _account_coverage_intervals(connection, account)
+    dates: list[str] = []
+    for start, end in intervals:
+        current = date.fromisoformat(start)
+        end_day = date.fromisoformat(end)
+        while current <= end_day:
+            dates.append(current.isoformat())
+            current += timedelta(days=1)
+    return dates
+
+
+def _dates_to_intervals(dates: list[str]) -> list[tuple[str, str]]:
+    if not dates:
+        return []
+    intervals: list[tuple[str, str]] = []
+    start = dates[0]
+    prev = dates[0]
+    for current in dates[1:]:
+        if date.fromisoformat(current) == date.fromisoformat(prev) + timedelta(days=1):
+            prev = current
+            continue
+        intervals.append((start, prev))
+        start = current
+        prev = current
+    intervals.append((start, prev))
+    return intervals
+
+
+def _detect_gaps(
+    required_start: str,
+    required_end: str,
+    covered: list[tuple[str, str]],
+) -> list[tuple[str, str, str]]:
+    if required_start > required_end:
+        return []
+    gaps: list[tuple[str, str, str]] = []
+    if not covered:
+        gaps.append((required_start, required_end, "head"))
+        return gaps
+    merged = _merge_intervals(covered)
+    first_start, first_end = merged[0]
+    if required_start < first_start:
+        gaps.append((required_start, _date_add(first_start, -1), "head"))
+    for index in range(len(merged) - 1):
+        _, left_end = merged[index]
+        right_start, _ = merged[index + 1]
+        gap_start = _date_add(left_end, 1)
+        gap_end = _date_add(right_start, -1)
+        if gap_start <= gap_end:
+            gaps.append((gap_start, gap_end, "mid"))
+    last_start, last_end = merged[-1]
+    tail_start = _date_add(last_end, 1)
+    gap_from = max(tail_start, required_start)
+    if gap_from <= required_end:
+        kind = "tail" if last_end >= required_start else "head"
+        gaps.append((gap_from, required_end, kind))
+    return gaps
+
+
+def detect_account_gaps(
+    connection: sqlite3.Connection,
+    account: sqlite3.Row,
+    *,
+    start_date: str | None,
+    today: str | None = None,
+) -> list[tuple[str, str, str]]:
+    if account["status"] != "active":
+        return []
+    today = today or utc_today()
+    effective_from = account["effective_from"] or start_date or today
+    effective_to = account["effective_to"] or today
+    required_start = max(filter(None, [start_date, effective_from]))
+    required_end = min(today, effective_to)
+    if not master_data.is_usable(account, required_start):
+        return []
+    intervals = _account_coverage_intervals(connection, account)
+    return _detect_gaps(required_start, required_end, intervals)
+
+
+def recalculate_coverage_gaps(connection: sqlite3.Connection) -> int:
+    start_date = get_calculation_start_date(connection)
+    today = utc_today()
+    accounts = connection.execute(
+        "SELECT * FROM bank_accounts WHERE status = 'active'"
+    ).fetchall()
+    rebuilt = 0
+    with connection:
+        for account in accounts:
+            connection.execute(
+                """
+                DELETE FROM coverage_gaps
+                WHERE bank_account_id = ? AND status = 'open'
+                """,
+                (account["id"],),
+            )
+            for gap_start, gap_end, gap_kind in detect_account_gaps(
+                connection, account, start_date=start_date, today=today
+            ):
+                connection.execute(
+                    """
+                    INSERT INTO coverage_gaps (
+                        bank_account_id, gap_start, gap_end, gap_kind,
+                        status, first_detected_at
+                    ) VALUES (?, ?, ?, ?, 'open', ?)
+                    ON CONFLICT(bank_account_id, gap_start, gap_end) DO UPDATE SET
+                        gap_kind = excluded.gap_kind,
+                        status = CASE coverage_gaps.status
+                            WHEN 'closed_attested' THEN 'closed_attested'
+                            ELSE 'open'
+                        END
+                    """,
+                    (account["id"], gap_start, gap_end, gap_kind, utc_now()),
+                )
+                rebuilt += 1
+    return rebuilt
+
+
+def coverage_gap_payload(connection: sqlite3.Connection, row: sqlite3.Row) -> dict[str, object]:
+    account = master_data.get_account(connection, row["bank_account_id"])
+    if account is None:
+        raise ValueError("账户不存在。")
+    company = connection.execute(
+        "SELECT name FROM companies WHERE id = ?", (account["company_id"],)
+    ).fetchone()
+    start = date.fromisoformat(row["gap_start"])
+    end = date.fromisoformat(row["gap_end"])
+    gap_days = (end - start).days + 1
+    pending = connection.execute(
+        """
+        SELECT id FROM no_business_attestations
+        WHERE bank_account_id = ?
+          AND gap_start = ? AND gap_end = ?
+          AND status = 'pending'
+        ORDER BY id DESC LIMIT 1
+        """,
+        (row["bank_account_id"], row["gap_start"], row["gap_end"]),
+    ).fetchone()
+    return {
+        "id": row["id"],
+        "bank_account_id": row["bank_account_id"],
+        "company_id": account["company_id"],
+        "company_name": company["name"] if company else None,
+        "account_number_masked": master_data.mask_account_number(account["account_number"]),
+        "gap_start": row["gap_start"],
+        "gap_end": row["gap_end"],
+        "gap_kind": row["gap_kind"],
+        "gap_days": gap_days,
+        "day_count": gap_days,
+        "status": row["status"],
+        "first_detected_at": row["first_detected_at"],
+        "pending_attestation_id": pending["id"] if pending else None,
+    }
+
+
+def list_coverage_gaps(
+    connection: sqlite3.Connection,
+    *,
+    company_id: int | None = None,
+    status: str | None = None,
+) -> list[dict[str, object]]:
+    clauses: list[str] = []
+    params: list[object] = []
+    if company_id is not None:
+        clauses.append("ba.company_id = ?")
+        params.append(company_id)
+    if status is not None:
+        clauses.append("g.status = ?")
+        params.append(status)
+    where = f"WHERE {' AND '.join(clauses)}" if clauses else ""
+    rows = connection.execute(
+        f"""
+        SELECT g.* FROM coverage_gaps g
+        JOIN bank_accounts ba ON ba.id = g.bank_account_id
+        {where}
+        ORDER BY g.gap_start, g.bank_account_id
+        """,
+        params,
+    ).fetchall()
+    return [coverage_gap_payload(connection, row) for row in rows]
+
+
+def submit_no_business_attestation(
+    connection: sqlite3.Connection,
+    *,
+    company_id: int,
+    bank_account_id: int,
+    gap_start: str,
+    gap_end: str,
+    reason: str,
+    evidence: str | None,
+    actor: sqlite3.Row,
+) -> dict[str, object]:
+    gap_start = master_data.validate_date(gap_start, "断档起始日", required=True)
+    gap_end = master_data.validate_date(gap_end, "断档结束日", required=True)
+    if gap_start > gap_end:
+        raise ValueError("断档起始日不能晚于结束日。")
+    reason = str(reason or "").strip()
+    if len(reason) < 5:
+        raise ValueError("无业务说明至少 5 个字符。")
+    account = master_data.get_account(connection, bank_account_id)
+    if account["company_id"] != company_id:
+        raise ValueError("只能为本公司账户提交说明。")
+    now = utc_now()
+    with connection:
+        cursor = connection.execute(
+            """
+            INSERT INTO no_business_attestations (
+                bank_account_id, gap_start, gap_end, reason, evidence,
+                submitted_by, company_id, status, created_at
+            ) VALUES (?, ?, ?, ?, ?, ?, ?, 'pending', ?)
+            """,
+            (
+                bank_account_id,
+                gap_start,
+                gap_end,
+                reason,
+                evidence,
+                actor["id"],
+                company_id,
+                now,
+            ),
+        )
+        attestation_id = int(cursor.lastrowid)
+    return attestation_payload(connection, attestation_id)
+
+
+def review_no_business_attestation(
+    connection: sqlite3.Connection,
+    attestation_id: int,
+    decision: str,
+    review_reason: str,
+    actor: sqlite3.Row,
+) -> dict[str, object]:
+    row = connection.execute(
+        "SELECT * FROM no_business_attestations WHERE id = ?", (attestation_id,)
+    ).fetchone()
+    if row is None:
+        raise ValueError("无业务说明不存在。")
+    if row["status"] != "pending":
+        raise ConflictError("该说明已审核。")
+    review_reason = str(review_reason or "").strip()
+    if decision not in ("approve", "reject"):
+        raise ValueError("审核决定无效。")
+    if len(review_reason) < 2:
+        raise ValueError("审核必须填写理由。")
+    status = "approved" if decision == "approve" else "rejected"
+    now = utc_now()
+    with connection:
+        connection.execute(
+            """
+            UPDATE no_business_attestations
+            SET status = ?, reviewed_by = ?, reviewed_at = ?, review_reason = ?
+            WHERE id = ?
+            """,
+            (status, actor["id"], now, review_reason, attestation_id),
+        )
+        if status == "approved":
+            # Exact match first so the attested row survives recalculate's
+            # "DELETE ... status='open'" and stays closed_attested.
+            connection.execute(
+                """
+                UPDATE coverage_gaps
+                SET status = 'closed_attested'
+                WHERE bank_account_id = ?
+                  AND gap_start = ? AND gap_end = ?
+                """,
+                (row["bank_account_id"], row["gap_start"], row["gap_end"]),
+            )
+        recalculate_coverage_gaps(connection)
+        if status == "approved":
+            # Overlap match: if recalculate shifts boundaries, still close
+            # any open gap that intersects the attested interval.
+            connection.execute(
+                """
+                UPDATE coverage_gaps
+                SET status = 'closed_attested'
+                WHERE bank_account_id = ?
+                  AND status = 'open'
+                  AND gap_start <= ?
+                  AND gap_end >= ?
+                """,
+                (row["bank_account_id"], row["gap_end"], row["gap_start"]),
+            )
+    return attestation_payload(connection, attestation_id)
+
+
+def attestation_payload(connection: sqlite3.Connection, attestation_id: int) -> dict[str, object]:
+    row = connection.execute(
+        "SELECT * FROM no_business_attestations WHERE id = ?", (attestation_id,)
+    ).fetchone()
+    if row is None:
+        raise ValueError("无业务说明不存在。")
+    account = master_data.get_account(connection, row["bank_account_id"])
+    if account is None:
+        raise ValueError("账户不存在。")
+    return {
+        "id": row["id"],
+        "bank_account_id": row["bank_account_id"],
+        "company_id": row["company_id"],
+        "gap_start": row["gap_start"],
+        "gap_end": row["gap_end"],
+        "reason": row["reason"],
+        "evidence": row["evidence"],
+        "status": row["status"],
+        "review_reason": row["review_reason"],
+        "reviewed_at": row["reviewed_at"],
+        "created_at": row["created_at"],
+        "account_number_masked": master_data.mask_account_number(account["account_number"]),
+    }
+
+
+def list_change_log(connection: sqlite3.Connection, limit: int = 100) -> list[dict[str, object]]:
+    rows = connection.execute(
+        """
+        SELECT * FROM master_data_changes
+        WHERE entity_type IN ('system_setting', 'opening_balance')
+        ORDER BY id DESC LIMIT ?
+        """,
+        (limit,),
+    ).fetchall()
+    items: list[dict[str, object]] = []
+    for row in rows:
+        before = json.loads(row["before_json"]) if row["before_json"] else None
+        after = json.loads(row["after_json"]) if row["after_json"] else None
+        target = "起算日"
+        if row["entity_type"] == "opening_balance":
+            target = f"期初 #{row['entity_id']}"
+        items.append(
+            {
+                "id": row["id"],
+                "created_at": row["created_at"],
+                "actor_username": row["actor_username"],
+                "action": row["action"],
+                "target": target,
+                "before": before,
+                "after": after,
+                "reason": row["reason"],
+            }
+        )
+    return items
+
+
+def _pair_net_change(
+    connection: sqlite3.Connection,
+    viewer_id: int,
+    counterparty_id: int,
+    *,
+    cutoff: str | None,
+    start_date: str | None,
+) -> Decimal:
+    cutoff_where = ""
+    params: list[object] = [viewer_id, counterparty_id, counterparty_id, viewer_id]
+    if cutoff:
+        cutoff_where = "AND substr(d.effective_at, 1, 10) <= ?"
+        params.append(cutoff)
+    start_where = ""
+    if start_date:
+        start_where = "AND substr(d.effective_at, 1, 10) >= ?"
+        params.append(start_date)
+    rows = connection.execute(
+        f"""
+        SELECT d.amount, payer.company_id AS payer_id, payee.company_id AS payee_id
+        FROM eligible_intercompany_events e
+        JOIN transfer_match_decisions d ON d.id = e.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 (
+            (payer.company_id = ? AND payee.company_id = ?)
+            OR (payer.company_id = ? AND payee.company_id = ?)
+        )
+        {cutoff_where}
+        {start_where}
+        """,
+        params,
+    ).fetchall()
+    # 站在本公司视角：正数=应收方向。转出/垫付（payer）使应收增加。
+    # 与 company_transfers.net = outflow − inflow 及页面文案口径一致。
+    total = Decimal("0")
+    for row in rows:
+        amount = _parse_decimal(row["amount"])
+        if row["payer_id"] == viewer_id:
+            total += amount
+        elif row["payee_id"] == viewer_id:
+            total -= amount
+    return total
+
+
+def pair_has_confirmed_opening(
+    connection: sqlite3.Connection, company_a: int, company_b: int
+) -> bool:
+    low_id, high_id = normalize_pair(company_a, company_b)
+    return confirmed_opening_amount(connection, low_id, high_id) is not None
+
+
+def compute_pair_balance(
+    connection: sqlite3.Connection,
+    viewer_id: int,
+    counterparty_id: int,
+    *,
+    cutoff: str | None = None,
+) -> dict[str, object]:
+    cutoff = cutoff or utc_today()
+    cutoff = master_data.validate_date(cutoff, "截止日", required=True)
+    start_date = get_calculation_start_date(connection)
+    low_id, high_id = normalize_pair(viewer_id, counterparty_id)
+    opening_amount: Decimal | None = None
+    if start_date and pair_has_confirmed_opening(connection, viewer_id, counterparty_id):
+        stored = confirmed_opening_amount(connection, low_id, high_id)
+        assert stored is not None
+        opening_amount = signed_from_viewer(viewer_id, low_id, high_id, stored)
+    net_change = _pair_net_change(
+        connection,
+        viewer_id,
+        counterparty_id,
+        cutoff=cutoff,
+        start_date=start_date,
+    )
+    unresolved = matching.unresolved_amounts(connection, viewer_id, cutoff=cutoff)
+    pending_total = Decimal("0")
+    for row in unresolved:
+        pending_total += _parse_decimal(row["amount"] or "0")
+    basis = "full" if opening_amount is not None and start_date else "net_change"
+    payload: dict[str, object] = {
+        "viewer_company_id": viewer_id,
+        "counterparty_company_id": counterparty_id,
+        "effective_at": cutoff,
+        "calculation_start_date": start_date,
+        "net_change": str(net_change),
+        "basis": basis,
+        "pending_unconfirmed": str(pending_total),
+        "currency": "CNY",
+    }
+    if basis == "full" and opening_amount is not None:
+        closing = opening_amount + net_change
+        payload["opening"] = str(opening_amount)
+        payload["closing"] = str(closing)
+        payload["opening_effective_at"] = _date_add(start_date, -1)
+    return payload
+
+
+def list_company_counterparties(
+    connection: sqlite3.Connection, company_id: int
+) -> list[int]:
+    rows = connection.execute(
+        """
+        SELECT DISTINCT CASE
+            WHEN payer.company_id = ? THEN payee.company_id
+            ELSE payer.company_id
+        END AS other_id
+        FROM eligible_intercompany_events e
+        JOIN transfer_decision_participants payer ON payer.decision_id = e.decision_id AND payer.role = 'payer'
+        JOIN transfer_decision_participants payee ON payee.decision_id = e.decision_id AND payee.role = 'payee'
+        WHERE payer.company_id = ? OR payee.company_id = ?
+        """,
+        (company_id, company_id, company_id),
+    ).fetchall()
+    return [int(row["other_id"]) for row in rows if row["other_id"] is not None]
+
+
+def compute_company_balances(
+    connection: sqlite3.Connection,
+    company_id: int,
+    *,
+    cutoff: str | None = None,
+) -> dict[str, object]:
+    cutoff = cutoff or utc_today()
+    start_date = get_calculation_start_date(connection)
+    counterparties = list_company_counterparties(connection, company_id)
+    pairs = [
+        compute_pair_balance(connection, company_id, other_id, cutoff=cutoff)
+        for other_id in counterparties
+    ]
+    complete = bool(start_date) and all(item["basis"] == "full" for item in pairs)
+    return {
+        "company_id": company_id,
+        "cutoff": cutoff,
+        "calculation_start_date": start_date,
+        "basis": "full" if complete and pairs else "net_change",
+        "pairs": pairs,
+    }
+
+
+def opening_coverage_summary(connection: sqlite3.Connection) -> dict[str, int]:
+    companies = connection.execute(
+        "SELECT COUNT(*) AS n FROM companies"
+    ).fetchone()["n"]
+    recorded = connection.execute(
+        """
+        SELECT COUNT(DISTINCT company_id_low || ':' || company_id_high) AS n
+        FROM opening_balance_revisions WHERE status = 'confirmed'
+        """
+    ).fetchone()["n"]
+    return {"company_count": companies, "confirmed_pair_count": recorded}

src/bank_importer/company_transfers.py

@@ -20,7 +20,7 @@ from decimal import Decimal, InvalidOperation
 import re
 import sqlite3
 
-from . import matching, settings
+from . import calculation, matching, settings
 
 _DATE_RE = re.compile(r"^\d{4}-\d{2}-\d{2}$")
 _ZERO = Decimal("0.00")
@@ -72,7 +72,8 @@ def _window_bounds(
     connection: sqlite3.Connection, as_of: str | None
 ) -> tuple[str, str]:
     end = _validate_date(as_of, "as_of") if as_of else today_shanghai()
-    start = settings.get_settings(connection).get("start_date") or "2026-01-01"
+    calc_start = calculation.get_calculation_start_date(connection)
+    start = calc_start or settings.get_settings(connection).get("start_date") or "2026-01-01"
     start = _validate_date(start, "start_date")
     if start > end:
         # Opening / start-date plumbing may lag; clamp rather than 500.
@@ -282,15 +283,28 @@ def company_intercompany_summary(
             }
         )
 
+    # Enrich window with calculation-basis opening/ending when configured.
+    balances = calculation.compute_company_balances(
+        connection, company_id, cutoff=end
+    )
+    has_opening = balances.get("basis") == "full"
+    opening_total = _ZERO
+    ending_total = _ZERO
+    if has_opening:
+        for pair in balances.get("pairs") or []:
+            opening_total += _as_decimal(pair.get("opening") or "0")
+            ending_total += _as_decimal(pair.get("closing") or "0")
+
     return {
         "own_company": own,
         "window": {
             "start": start,
             "end": end,
-            "has_opening": False,
-            # Reserved for opening-balance rollout; callers must not invent balances.
-            "opening": None,
-            "ending": None,
+            "has_opening": has_opening,
+            "opening": _money(opening_total) if has_opening else None,
+            "ending": _money(ending_total) if has_opening else None,
+            "basis": balances.get("basis"),
+            "calculation_start_date": balances.get("calculation_start_date"),
         },
         "confirmed": {
             "outflow_total": _money(outflow),

src/bank_importer/db.py

@@ -846,6 +846,256 @@ MIGRATIONS: tuple[Migration, ...] = (
         DROP TABLE IF EXISTS system_settings;
         """,
     ),
+
+    Migration(
+        version=8,
+        name="0008_calculation_window",
+        # HEL-194/202: opening balances, coverage gaps, no-business attestations.
+        # Reuses system_settings / system_setting_changes from 0007; does not
+        # recreate them. Extends master_data_changes CHECK and overlays the
+        # calculation_start_date filter onto eligible_intercompany_events.
+        up="""
+        CREATE TABLE closed_periods (
+            year_month TEXT PRIMARY KEY,
+            closed_at TEXT NOT NULL,
+            closed_by INTEGER REFERENCES users (id)
+        );
+
+        CREATE TABLE opening_balance_revisions (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            company_id_low INTEGER NOT NULL REFERENCES companies (id),
+            company_id_high INTEGER NOT NULL REFERENCES companies (id),
+            amount TEXT NOT NULL,
+            currency TEXT NOT NULL DEFAULT 'CNY',
+            revision INTEGER NOT NULL,
+            status TEXT NOT NULL
+                CHECK (status IN ('draft', 'confirmed', 'superseded', 'void')),
+            reason TEXT NOT NULL,
+            actor_user_id INTEGER REFERENCES users (id),
+            actor_username TEXT,
+            supersedes_id INTEGER REFERENCES opening_balance_revisions (id),
+            created_at TEXT NOT NULL,
+            UNIQUE (company_id_low, company_id_high, revision),
+            CHECK (company_id_low < company_id_high)
+        );
+
+        CREATE TABLE coverage_gaps (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            bank_account_id INTEGER NOT NULL REFERENCES bank_accounts (id),
+            gap_start TEXT NOT NULL,
+            gap_end TEXT NOT NULL,
+            gap_kind TEXT NOT NULL CHECK (gap_kind IN ('head', 'mid', 'tail')),
+            status TEXT NOT NULL DEFAULT 'open'
+                CHECK (status IN ('open', 'closed_attested')),
+            first_detected_at TEXT NOT NULL,
+            UNIQUE (bank_account_id, gap_start, gap_end)
+        );
+
+        CREATE TABLE no_business_attestations (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            bank_account_id INTEGER NOT NULL REFERENCES bank_accounts (id),
+            gap_start TEXT NOT NULL,
+            gap_end TEXT NOT NULL,
+            reason TEXT NOT NULL,
+            evidence TEXT,
+            submitted_by INTEGER REFERENCES users (id),
+            company_id INTEGER NOT NULL REFERENCES companies (id),
+            status TEXT NOT NULL DEFAULT 'pending'
+                CHECK (status IN ('pending', 'approved', 'rejected')),
+            reviewed_by INTEGER REFERENCES users (id),
+            reviewed_at TEXT,
+            review_reason TEXT,
+            created_at TEXT NOT NULL
+        );
+
+        CREATE INDEX idx_opening_balance_pair ON opening_balance_revisions (company_id_low, company_id_high);
+        CREATE INDEX idx_coverage_gaps_account ON coverage_gaps (bank_account_id);
+        CREATE INDEX idx_attestations_company ON no_business_attestations (company_id);
+
+        CREATE TABLE master_data_changes_new (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            entity_type TEXT NOT NULL
+                CHECK (entity_type IN (
+                    'company', 'user', 'bank_account', 'account_alias',
+                    'personal_transit_mapping', 'system_setting', 'opening_balance'
+                )),
+            entity_id INTEGER NOT NULL,
+            action TEXT NOT NULL,
+            before_json TEXT,
+            after_json TEXT,
+            reason TEXT,
+            actor_user_id INTEGER REFERENCES users (id),
+            actor_username TEXT,
+            created_at TEXT NOT NULL
+        );
+        INSERT INTO master_data_changes_new SELECT * FROM master_data_changes;
+        DROP TABLE master_data_changes;
+        ALTER TABLE master_data_changes_new RENAME TO master_data_changes;
+
+        DROP VIEW IF EXISTS eligible_intercompany_events;
+        CREATE VIEW eligible_intercompany_events AS
+        SELECT e.id AS event_id, d.id AS decision_id, d.revision AS revision,
+               d.effective_at AS effective_at, d.amount AS amount, d.currency AS currency,
+               payer.company_id AS payer_company_id,
+               payer.bank_account_id AS payer_account_id,
+               payee.company_id AS payee_company_id,
+               payee.bank_account_id AS payee_account_id,
+               d.pairing AS pairing, d.rule_version AS rule_version,
+               (SELECT COUNT(*) FROM transfer_decision_observations o
+                WHERE o.decision_id = d.id) AS evidence_count
+        FROM current_transfer_decisions c
+        JOIN canonical_transfer_events e ON e.id = c.event_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 = 'intercompany'
+          AND (d.pairing = 'paired' OR d.locked = 1)
+          AND (
+              (SELECT value FROM system_settings WHERE key = 'calculation_start_date') IS NULL
+              OR substr(d.effective_at, 1, 10) >= (
+                  SELECT value FROM system_settings WHERE key = 'calculation_start_date'
+              )
+          );
+        """,
+        down="""
+        DROP VIEW IF EXISTS eligible_intercompany_events;
+        CREATE VIEW eligible_intercompany_events AS
+        SELECT e.id AS event_id, d.id AS decision_id, d.revision AS revision,
+               d.effective_at AS effective_at, d.amount AS amount, d.currency AS currency,
+               payer.company_id AS payer_company_id,
+               payer.bank_account_id AS payer_account_id,
+               payee.company_id AS payee_company_id,
+               payee.bank_account_id AS payee_account_id,
+               d.pairing AS pairing, d.rule_version AS rule_version,
+               (SELECT COUNT(*) FROM transfer_decision_observations o
+                WHERE o.decision_id = d.id) AS evidence_count
+        FROM current_transfer_decisions c
+        JOIN canonical_transfer_events e ON e.id = c.event_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 = 'intercompany'
+          AND (d.pairing = 'paired' OR d.locked = 1);
+
+        CREATE TABLE master_data_changes_new (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            entity_type TEXT NOT NULL
+                CHECK (entity_type IN (
+                    'company', 'user', 'bank_account', 'account_alias',
+                    'personal_transit_mapping'
+                )),
+            entity_id INTEGER NOT NULL,
+            action TEXT NOT NULL,
+            before_json TEXT,
+            after_json TEXT,
+            reason TEXT,
+            actor_user_id INTEGER REFERENCES users (id),
+            actor_username TEXT,
+            created_at TEXT NOT NULL
+        );
+        INSERT INTO master_data_changes_new SELECT * FROM master_data_changes
+        WHERE entity_type NOT IN ('system_setting', 'opening_balance');
+        DROP TABLE master_data_changes;
+        ALTER TABLE master_data_changes_new RENAME TO master_data_changes;
+
+        DROP INDEX IF EXISTS idx_attestations_company;
+        DROP INDEX IF EXISTS idx_coverage_gaps_account;
+        DROP INDEX IF EXISTS idx_opening_balance_pair;
+        DROP TABLE IF EXISTS no_business_attestations;
+        DROP TABLE IF EXISTS coverage_gaps;
+        DROP TABLE IF EXISTS opening_balance_revisions;
+        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);
+        """,
+    ),
 )
 
 

src/bank_importer/matching.py

@@ -1523,7 +1523,7 @@ def unresolved_amounts(
     count as unresolved; paired intercompany, same-company and external events
     are resolved classifications and never appear here.
     """
-    cutoff_where = "AND d.effective_at <= ?" if cutoff else ""
+    cutoff_where = "AND substr(d.effective_at, 1, 10) <= ?" if cutoff else ""
     params: list[object] = []
     if cutoff:
         params.append(cutoff)

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_calculation.py

@@ -0,0 +1,593 @@
+"""Tests for calculation window: start date, opening balances, coverage gaps."""
+
+from __future__ import annotations
+
+from decimal import Decimal
+from pathlib import Path
+import json
+import tempfile
+import threading
+import unittest
+
+from bank_importer import auth, calculation, matching, master_data
+from bank_importer.db import connect, migrate, utc_now
+
+import server
+from test_server_auth import Client, as_json
+
+
+class CalculationBase(unittest.TestCase):
+    def setUp(self) -> None:
+        self.temp_dir = tempfile.TemporaryDirectory()
+        self.addCleanup(self.temp_dir.cleanup)
+        self.db_path = Path(self.temp_dir.name) / "app.db"
+        self.connection = connect(self.db_path)
+        self.addCleanup(self.connection.close)
+        migrate(self.connection)
+        self.admin = self._admin()
+        self.company_a = self._company("甲公司")
+        self.company_b = self._company("乙公司")
+        self.account_a = self._approved_account(self.company_a, "6222000000000001")
+        self.account_b = self._approved_account(self.company_b, "6222000000000002")
+
+    def _admin(self):
+        auth.create_user(self.connection, "admin-u", "AdminPass123", "admin")
+        return self.connection.execute(
+            "SELECT * FROM users WHERE username = 'admin-u'"
+        ).fetchone()
+
+    def _company(self, name: str) -> int:
+        with self.connection:
+            cursor = self.connection.execute(
+                "INSERT INTO companies (name, created_at, updated_at) VALUES (?, ?, ?)",
+                (name, utc_now(), utc_now()),
+            )
+        return int(cursor.lastrowid)
+
+    def _approved_account(self, company_id: int, number: str, start: str = "2026-01-01"):
+        account = master_data.submit_bank_account(
+            self.connection,
+            company_id=company_id,
+            bank_name="中信银行",
+            account_type="基本户",
+            account_number=number,
+            start_date=start,
+            actor=None,
+        )
+        return master_data.review_bank_account(
+            self.connection, account["id"], "approve", None, self.admin,
+            effective_from=start,
+        )
+
+    def add_confirmed_row(
+        self,
+        company_id: int,
+        *,
+        account_id: int,
+        own_account: str,
+        at: str,
+        income: str = "0",
+        expense: str = "0",
+        cp_account: str | None = None,
+        sheet: str = "流水",
+        source_row: int = 1,
+    ) -> int:
+        with self.connection:
+            cursor = self.connection.execute(
+                """
+                INSERT INTO source_files (sha256, original_filename, size_bytes, storage_path, created_at)
+                VALUES (?, '测试.xlsx', 1, 'data/files/测试.xlsx', ?)
+                """,
+                (f"sha-{at}-{own_account}-{source_row}", utc_now()),
+            )
+            source_file_id = int(cursor.lastrowid)
+            cursor = self.connection.execute(
+                """
+                INSERT INTO import_batches (
+                    source_file_id, status, company_id, upload_bank_account_id,
+                    created_at, updated_at
+                ) VALUES (?, 'parsed', ?, ?, ?, ?)
+                """,
+                (source_file_id, company_id, account_id, utc_now(), utc_now()),
+            )
+            batch_id = int(cursor.lastrowid)
+            cursor = self.connection.execute(
+                """
+                INSERT INTO sheet_batches (
+                    import_batch_id, sheet_name, bank_name, template_id, template_version,
+                    header_row, transaction_count, warnings, created_at
+                ) VALUES (?, ?, '测试银行', 'test-v1', 1, 1, 1, '[]', ?)
+                """,
+                (batch_id, sheet, utc_now()),
+            )
+            sheet_batch_id = int(cursor.lastrowid)
+            self.connection.execute(
+                """
+                INSERT INTO sheet_reviews (
+                    import_batch_id, sheet_name, outcome, sheet_batch_id,
+                    review_status, created_at
+                ) VALUES (?, ?, 'parsed', ?, 'confirmed', ?)
+                """,
+                (batch_id, sheet, sheet_batch_id, utc_now()),
+            )
+            cursor = self.connection.execute(
+                """
+                INSERT INTO source_rows (
+                    sheet_batch_id, source_row, transaction_at, income, expense,
+                    own_account, counterparty_account, created_at
+                ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+                """,
+                (sheet_batch_id, source_row, at, income, expense, own_account, cp_account, utc_now()),
+            )
+        return int(cursor.lastrowid)
+
+    def add_confirmed_batch_range(
+        self,
+        company_id: int,
+        *,
+        account_id: int,
+        own_account: str,
+        start: str,
+        end: str,
+        sheet: str,
+    ) -> None:
+        with self.connection:
+            cursor = self.connection.execute(
+                """
+                INSERT INTO source_files (sha256, original_filename, size_bytes, storage_path, created_at)
+                VALUES (?, '测试.xlsx', 1, 'data/files/测试.xlsx', ?)
+                """,
+                (f"sha-batch-{sheet}", utc_now()),
+            )
+            source_file_id = int(cursor.lastrowid)
+            cursor = self.connection.execute(
+                """
+                INSERT INTO import_batches (
+                    source_file_id, status, company_id, upload_bank_account_id,
+                    created_at, updated_at
+                ) VALUES (?, 'parsed', ?, ?, ?, ?)
+                """,
+                (source_file_id, company_id, account_id, utc_now(), utc_now()),
+            )
+            batch_id = int(cursor.lastrowid)
+            cursor = self.connection.execute(
+                """
+                INSERT INTO sheet_batches (
+                    import_batch_id, sheet_name, bank_name, template_id, template_version,
+                    header_row, transaction_count, warnings, created_at
+                ) VALUES (?, ?, '测试银行', 'test-v1', 1, 1, 2, '[]', ?)
+                """,
+                (batch_id, sheet, utc_now()),
+            )
+            sheet_batch_id = int(cursor.lastrowid)
+            self.connection.execute(
+                """
+                INSERT INTO sheet_reviews (
+                    import_batch_id, sheet_name, outcome, sheet_batch_id,
+                    review_status, created_at
+                ) VALUES (?, ?, 'parsed', ?, 'confirmed', ?)
+                """,
+                (batch_id, sheet, sheet_batch_id, utc_now()),
+            )
+            for source_row, day in ((1, start), (2, end)):
+                self.connection.execute(
+                    """
+                    INSERT INTO source_rows (
+                        sheet_batch_id, source_row, transaction_at, income, expense,
+                        own_account, created_at
+                    ) VALUES (?, ?, ?, '0', '0', ?, ?)
+                    """,
+                    (sheet_batch_id, source_row, f"{day}T10:00:00", own_account, utc_now()),
+                )
+
+
+class StartDateTests(CalculationBase):
+    def test_set_start_date_records_change(self) -> None:
+        result = calculation.set_calculation_start_date(
+            self.connection, "2026-01-01", "首次设定", self.admin
+        )
+        self.assertEqual("2026-01-01", result["calculation_start_date"])
+        row = self.connection.execute(
+            "SELECT 1 FROM master_data_changes WHERE entity_type = 'system_setting'"
+        ).fetchone()
+        self.assertIsNotNone(row)
+
+    def test_locked_after_closed_period(self) -> None:
+        calculation.set_calculation_start_date(
+            self.connection, "2026-01-01", "首次设定", self.admin
+        )
+        with self.connection:
+            self.connection.execute(
+                "INSERT INTO closed_periods (year_month, closed_at, closed_by) VALUES ('2026-01', ?, ?)",
+                (utc_now(), self.admin["id"]),
+            )
+        with self.assertRaises(calculation.LockedError):
+            calculation.set_calculation_start_date(
+                self.connection, "2026-02-01", "尝试修改", self.admin
+            )
+
+
+class OpeningBalanceTests(CalculationBase):
+    def setUp(self) -> None:
+        super().setUp()
+        calculation.set_calculation_start_date(
+            self.connection, "2026-01-01", "测试起算日", self.admin
+        )
+
+    def test_bilateral_conservation_on_storage(self) -> None:
+        item = calculation.create_opening_balance(
+            self.connection,
+            self.company_a,
+            self.company_b,
+            "100.00",
+            "期初录入",
+            self.admin,
+            viewer_company_id=self.company_a,
+        )
+        low, high = calculation.normalize_pair(self.company_a, self.company_b)
+        self.assertEqual(low, item["company_id_low"])
+        stored = calculation.confirmed_opening_amount(self.connection, low, high)
+        self.assertIsNone(stored)
+        calculation.confirm_opening_balance(
+            self.connection, item["id"], "确认期初", self.admin
+        )
+        stored = calculation.confirmed_opening_amount(self.connection, low, high)
+        self.assertEqual(Decimal("100.00"), stored)
+        from_b = calculation.signed_from_viewer(self.company_b, low, high, stored)
+        self.assertEqual(Decimal("-100.00"), from_b)
+
+    def test_confirmed_requires_revision_not_overwrite(self) -> None:
+        item = calculation.create_opening_balance(
+            self.connection, self.company_a, self.company_b, "50", "录入", self.admin
+        )
+        calculation.confirm_opening_balance(
+            self.connection, item["id"], "确认", self.admin
+        )
+        with self.assertRaises(calculation.ConflictError):
+            calculation.create_opening_balance(
+                self.connection, self.company_a, self.company_b, "80", "重复录入", self.admin
+            )
+        revised = calculation.revise_opening_balance(
+            self.connection, item["id"], "80", "修订", self.admin
+        )
+        self.assertEqual("draft", revised["status"])
+
+
+class CoverageGapTests(CalculationBase):
+    def setUp(self) -> None:
+        super().setUp()
+        calculation.set_calculation_start_date(
+            self.connection, "2026-06-01", "起算", self.admin
+        )
+
+    def test_adjacent_intervals_no_mid_gap(self) -> None:
+        self.add_confirmed_batch_range(
+            self.company_a,
+            account_id=self.account_a["id"],
+            own_account="6222000000000001",
+            start="2026-06-21",
+            end="2026-07-21",
+            sheet="批次A",
+        )
+        self.add_confirmed_batch_range(
+            self.company_a,
+            account_id=self.account_a["id"],
+            own_account="6222000000000001",
+            start="2026-07-22",
+            end="2026-08-21",
+            sheet="批次B",
+        )
+        calculation.recalculate_coverage_gaps(self.connection)
+        mids = self.connection.execute(
+            "SELECT * FROM coverage_gaps WHERE gap_kind = 'mid'"
+        ).fetchall()
+        self.assertEqual([], mids)
+
+    def test_missing_day_mid_gap(self) -> None:
+        self.add_confirmed_batch_range(
+            self.company_a,
+            account_id=self.account_a["id"],
+            own_account="6222000000000001",
+            start="2026-06-21",
+            end="2026-07-21",
+            sheet="批次A",
+        )
+        self.add_confirmed_batch_range(
+            self.company_a,
+            account_id=self.account_a["id"],
+            own_account="6222000000000001",
+            start="2026-07-23",
+            end="2026-08-21",
+            sheet="批次B",
+        )
+        calculation.recalculate_coverage_gaps(self.connection)
+        gap = self.connection.execute(
+            """
+            SELECT gap_start, gap_end FROM coverage_gaps
+            WHERE gap_kind = 'mid' AND gap_start = '2026-07-22'
+            """
+        ).fetchone()
+        self.assertIsNotNone(gap)
+        self.assertEqual("2026-07-22", gap["gap_end"])
+
+    def test_attestation_closes_gap_without_bank_row(self) -> None:
+        self.add_confirmed_row(
+            self.company_a,
+            account_id=self.account_a["id"],
+            own_account="6222000000000001",
+            at="2026-06-21T10:00:00",
+        )
+        calculation.recalculate_coverage_gaps(self.connection)
+        gap = self.connection.execute(
+            "SELECT * FROM coverage_gaps WHERE status = 'open'"
+        ).fetchone()
+        self.assertIsNotNone(gap)
+        before_rows = self.connection.execute("SELECT COUNT(*) AS n FROM source_rows").fetchone()["n"]
+        cashier_id = auth.create_user(
+            self.connection, "cashier-a", "CashierA123", "company", self.company_a
+        )
+        cashier = self.connection.execute(
+            "SELECT * FROM users WHERE id = ?", (cashier_id,)
+        ).fetchone()
+        att = calculation.submit_no_business_attestation(
+            self.connection,
+            company_id=self.company_a,
+            bank_account_id=self.account_a["id"],
+            gap_start=gap["gap_start"],
+            gap_end=gap["gap_end"],
+            reason="当日账户无资金往来",
+            evidence=None,
+            actor=cashier,
+        )
+        calculation.review_no_business_attestation(
+            self.connection, att["id"], "approve", "审核通过", self.admin
+        )
+        after_rows = self.connection.execute("SELECT COUNT(*) AS n FROM source_rows").fetchone()["n"]
+        self.assertEqual(before_rows, after_rows)
+        closed = self.connection.execute(
+            "SELECT status FROM coverage_gaps WHERE id = ?", (gap["id"],)
+        ).fetchone()
+        self.assertEqual("closed_attested", closed["status"])
+
+
+class BalanceBasisTests(CalculationBase):
+    def setUp(self) -> None:
+        super().setUp()
+        calculation.set_calculation_start_date(
+            self.connection, "2026-01-01", "起算", self.admin
+        )
+
+    def test_without_opening_returns_net_change(self) -> None:
+        row_a = self.add_confirmed_row(
+            self.company_a,
+            account_id=self.account_a["id"],
+            own_account="6222000000000001",
+            at="2026-01-05T10:00:00",
+            expense="100.00",
+            cp_account="6222000000000002",
+        )
+        row_b = self.add_confirmed_row(
+            self.company_b,
+            account_id=self.account_b["id"],
+            own_account="6222000000000002",
+            at="2026-01-05T11:00:00",
+            income="100.00",
+            cp_account="6222000000000001",
+        )
+        matching.reconcile_rows(self.connection, [row_a, row_b])
+        balance = calculation.compute_pair_balance(
+            self.connection, self.company_a, self.company_b, cutoff="2026-01-31"
+        )
+        self.assertEqual("net_change", balance["basis"])
+        self.assertNotIn("closing", balance)
+
+    def test_with_opening_returns_full_basis(self) -> None:
+        item = calculation.create_opening_balance(
+            self.connection, self.company_a, self.company_b, "200", "录入", self.admin
+        )
+        calculation.confirm_opening_balance(
+            self.connection, item["id"], "确认", self.admin
+        )
+        balance = calculation.compute_pair_balance(
+            self.connection, self.company_a, self.company_b, cutoff="2026-01-31"
+        )
+        self.assertEqual("full", balance["basis"])
+        self.assertEqual("200", balance["opening"])
+        self.assertEqual("200", balance["closing"])
+
+    def test_pre_start_events_excluded(self) -> None:
+        item = calculation.create_opening_balance(
+            self.connection, self.company_a, self.company_b, "0", "零期初", self.admin
+        )
+        calculation.confirm_opening_balance(
+            self.connection, item["id"], "确认", self.admin
+        )
+        row_a = self.add_confirmed_row(
+            self.company_a,
+            account_id=self.account_a["id"],
+            own_account="6222000000000001",
+            at="2025-12-31T10:00:00",
+            expense="50.00",
+            cp_account="6222000000000002",
+        )
+        row_b = self.add_confirmed_row(
+            self.company_b,
+            account_id=self.account_b["id"],
+            own_account="6222000000000002",
+            at="2025-12-31T11:00:00",
+            income="50.00",
+            cp_account="6222000000000001",
+        )
+        matching.reconcile_rows(self.connection, [row_a, row_b])
+        balance = calculation.compute_pair_balance(
+            self.connection, self.company_a, self.company_b, cutoff="2026-01-31"
+        )
+        self.assertEqual("0", balance["net_change"])
+
+    def test_cutoff_day_event_is_included(self) -> None:
+        """effective_at with time on the cutoff date must still count."""
+        from test_matching import MatchingBase
+
+        item = calculation.create_opening_balance(
+            self.connection, self.company_a, self.company_b, "0", "零期初", self.admin
+        )
+        calculation.confirm_opening_balance(
+            self.connection, item["id"], "确认", self.admin
+        )
+        helper = object.__new__(MatchingBase)
+        helper.connection = self.connection
+        row_a = helper.add_row(
+            self.company_a,
+            own_account="6222000000000001",
+            cp_account="6222000000000002",
+            expense="80.00",
+            at="2026-01-31T10:00:00",
+        )
+        matching.reconcile_rows(self.connection, [row_a])
+        row_b = helper.add_row(
+            self.company_b,
+            own_account="6222000000000002",
+            cp_account="6222000000000001",
+            income="80.00",
+            at="2026-01-31T11:00:00",
+        )
+        matching.reconcile_rows(self.connection, [row_b])
+        eligible = self.connection.execute(
+            "SELECT effective_at, amount FROM eligible_intercompany_events"
+        ).fetchall()
+        self.assertEqual(1, len(eligible))
+        self.assertEqual("2026-01-31T10:00:00", eligible[0]["effective_at"])
+        # Full-timestamp string compare wrongly excludes the cutoff day.
+        self.assertEqual(
+            [],
+            self.connection.execute(
+                """
+                SELECT 1 FROM eligible_intercompany_events
+                WHERE effective_at <= '2026-01-31'
+                """
+            ).fetchall(),
+        )
+        balance = calculation.compute_pair_balance(
+            self.connection, self.company_a, self.company_b, cutoff="2026-01-31"
+        )
+        # 甲转出 80 → 应收方向为正
+        self.assertEqual("80.00", balance["net_change"])
+        self.assertEqual("80.00", balance["closing"])
+
+    def test_opening_plus_outflow_increases_receivable(self) -> None:
+        """期初应收 200 + 本期转出垫付 100 → 期末应收 300；乙方对称为应付 300。"""
+        from test_matching import MatchingBase
+
+        item = calculation.create_opening_balance(
+            self.connection, self.company_a, self.company_b, "200", "期初应收", self.admin
+        )
+        calculation.confirm_opening_balance(
+            self.connection, item["id"], "确认", self.admin
+        )
+        helper = object.__new__(MatchingBase)
+        helper.connection = self.connection
+        row_a = helper.add_row(
+            self.company_a,
+            own_account="6222000000000001",
+            cp_account="6222000000000002",
+            expense="100.00",
+            at="2026-01-15T10:00:00",
+        )
+        matching.reconcile_rows(self.connection, [row_a])
+        row_b = helper.add_row(
+            self.company_b,
+            own_account="6222000000000002",
+            cp_account="6222000000000001",
+            income="100.00",
+            at="2026-01-15T11:00:00",
+        )
+        matching.reconcile_rows(self.connection, [row_b])
+
+        bal_a = calculation.compute_pair_balance(
+            self.connection, self.company_a, self.company_b, cutoff="2026-01-31"
+        )
+        self.assertEqual("full", bal_a["basis"])
+        self.assertEqual("200", bal_a["opening"])
+        self.assertEqual("100.00", bal_a["net_change"])
+        self.assertEqual("300.00", bal_a["closing"])
+
+        bal_b = calculation.compute_pair_balance(
+            self.connection, self.company_b, self.company_a, cutoff="2026-01-31"
+        )
+        self.assertEqual("full", bal_b["basis"])
+        self.assertEqual("-200", bal_b["opening"])
+        self.assertEqual("-100.00", bal_b["net_change"])
+        self.assertEqual("-300.00", bal_b["closing"])
+        # 双边守恒
+        self.assertEqual(
+            Decimal(bal_a["closing"]) + Decimal(bal_b["closing"]),
+            Decimal("0"),
+        )
+
+
+class CalculationApiTests(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls) -> None:
+        cls.temp_dir = tempfile.TemporaryDirectory()
+        cls.db_path = Path(cls.temp_dir.name) / "app.db"
+        cls.storage_dir = Path(cls.temp_dir.name) / "files"
+        cls.storage_dir.mkdir()
+        server.DB_PATH = cls.db_path
+        server.STORAGE_DIR = cls.storage_dir
+        connection = connect(cls.db_path)
+        migrate(connection)
+        auth.create_user(
+            connection, "group-admin", "AdminPass123", "admin",
+            must_change_password=False,
+        )
+        company_id = master_data.create_company(connection, "甲公司", None, None, None)
+        auth.create_user(
+            connection, "cashier-a", "CashierA123", "company", company_id,
+            must_change_password=False,
+        )
+        connection.close()
+        cls.httpd = server.ThreadingHTTPServer(("127.0.0.1", 0), server.AppHandler)
+        cls.port = cls.httpd.server_address[1]
+        cls.thread = threading.Thread(target=cls.httpd.serve_forever, daemon=True)
+        cls.thread.start()
+        cls.client = Client("127.0.0.1", cls.port)
+
+    @classmethod
+    def tearDownClass(cls) -> None:
+        cls.httpd.shutdown()
+        cls.temp_dir.cleanup()
+
+    def test_company_cannot_call_admin_start_date(self) -> None:
+        self.client.post_json("/api/login", {
+            "username": "cashier-a", "password": "CashierA123", "portal": "company",
+        })
+        status, _, _ = self.client.request(
+            "PUT",
+            "/api/admin/settings/calculation-start",
+            body=json.dumps(
+                {"calculation_start_date": "2026-01-01", "reason": "越权"}
+            ).encode("utf-8"),
+            headers={"Content-Type": "application/json"},
+        )
+        self.assertEqual(403, status)
+
+    def test_admin_can_set_start_date(self) -> None:
+        client = Client("127.0.0.1", self.port)
+        client.post_json("/api/login", {
+            "username": "group-admin", "password": "AdminPass123", "portal": "admin",
+        })
+        status, _, body = client.request(
+            "PUT",
+            "/api/admin/settings/calculation-start",
+            body=json.dumps(
+                {"calculation_start_date": "2026-01-01", "reason": "初始化"}
+            ).encode("utf-8"),
+            headers={"Content-Type": "application/json"},
+        )
+        self.assertEqual(200, status)
+        data = as_json(body)
+        self.assertEqual("2026-01-01", data["calculation_start_date"])
+
+
+if __name__ == "__main__":
+    unittest.main()

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=12", html)
+        self.assertIn("app.js?v=13", html)
         # 静态初值仍为进行中（黄），由 JS 在 pending=0 时切 done
         self.assertRegex(html, r'class="flow-step doing"[^>]*data-view-link="reconcile"')
 

tests/test_company_transfers_page.py

@@ -32,7 +32,7 @@ class TransfersPageSourceContractTests(unittest.TestCase):
         self.assertIn("期间净变动", html)
         self.assertNotIn("本公司往来合计", html)
         self.assertIn("design-system.css?v=6", html)
-        self.assertIn("app.js?v=12", html)
+        self.assertIn("app.js?v=13", html)
         # 侧栏顺序：流水管理 → 转账往来 → 往来确认
         flows = html.index('data-view="flows"')
         transfers = html.index('data-view="transfers"')
@@ -113,7 +113,7 @@ class TransfersPageLayoutSmokeTests(unittest.TestCase):
             for width in (360, 820, 1440):
                 page.set_viewport_size({"width": width, "height": 900})
                 page.set_content(
-                    html.replace('src="app.js?v=12"', 'src=""'),
+                    html.replace('src="app.js?v=13"', 'src=""'),
                     base_url=self.base,
                 )
                 page.evaluate(

tests/test_hel203_browser_smoke.py

@@ -0,0 +1,518 @@
+"""HEL-203: 真实浏览器冒烟——原因弹窗、首屏断档、表单 reset。"""
+
+from __future__ import annotations
+
+import os
+import re
+import tempfile
+import threading
+import unittest
+from pathlib import Path
+
+from bank_importer import auth, calculation, matching, master_data
+from bank_importer.db import connect, migrate, utc_now
+
+import server
+
+ROOT = Path(__file__).resolve().parents[1]
+WEB = ROOT / "web"
+ADMIN_PASSWORD = "AdminPass123"
+CASHIER_PASSWORD = "CashierA123"
+
+try:
+    from playwright.sync_api import sync_playwright
+except ImportError:  # pragma: no cover
+    sync_playwright = None
+
+
+def _prepare_chrome_libs() -> Path | None:
+    """本机缺系统 atk 时，复用仓库旁的本地 chromium 依赖目录。"""
+    candidates = [ROOT / ".chrome-libs" / "lib"]
+    for lib_dir in candidates:
+        if (lib_dir / "libatk-1.0.so.0").exists():
+            current = os.environ.get("LD_LIBRARY_PATH", "")
+            prefix = str(lib_dir)
+            if prefix not in current.split(":"):
+                os.environ["LD_LIBRARY_PATH"] = (
+                    f"{prefix}:{current}" if current else prefix
+                )
+            return lib_dir
+    return None
+
+
+def _chromium_available() -> bool:
+    if not sync_playwright:
+        return False
+    _prepare_chrome_libs()
+    try:
+        with sync_playwright() as p:
+            browser = p.chromium.launch(headless=True, args=["--no-sandbox"])
+            browser.close()
+        return True
+    except Exception:
+        return False
+
+
+class Hel203SourceContractTests(unittest.TestCase):
+    """不依赖浏览器：锁住 N1～N3 的源码契约。"""
+
+    def test_open_modal_is_single_top_level(self) -> None:
+        js = (WEB / "app.js").read_text(encoding="utf-8")
+        defs = list(re.finditer(r"(?m)^function openModal\(", js))
+        self.assertEqual(1, len(defs), "openModal 必须只有一处顶层定义")
+        # 不得再出现在 initAdmin / initCompany 函数体内的局部副本
+        self.assertNotRegex(
+            js,
+            r"function initAdmin\(\)[\s\S]*?function openModal\(",
+        )
+        self.assertNotRegex(
+            js,
+            r"function initCompany\(\)[\s\S]*?function openModal\(",
+        )
+        self.assertIn("function askReason(", js)
+        ask_pos = js.index("function askReason(")
+        open_pos = defs[0].start()
+        self.assertLess(open_pos, ask_pos, "openModal 须在 askReason 之前定义")
+
+    def test_init_company_boots_coverage_gaps(self) -> None:
+        js = (WEB / "app.js").read_text(encoding="utf-8")
+        company_fn = js[js.index("function initCompany(") :]
+        boot = company_fn[: company_fn.index("\nif (portal ===")]
+        self.assertIn("await loadCompanyWorkspace()", boot)
+        self.assertIn("await loadCompanyCoverageGaps()", boot)
+
+    def test_async_forms_capture_form_before_await(self) -> None:
+        js = (WEB / "app.js").read_text(encoding="utf-8")
+        self.assertNotIn("event.currentTarget.reset()", js)
+        for marker in ("#companyForm", "#openingForm", "#accountForm"):
+            idx = js.index(marker)
+            chunk = js[idx : idx + 2500]
+            self.assertIn("const form = event.currentTarget", chunk)
+            self.assertIn("form.reset()", chunk)
+
+
+@unittest.skipUnless(sync_playwright, "playwright 未安装，跳过浏览器冒烟")
+@unittest.skipUnless(_chromium_available(), "chromium 无法启动，跳过浏览器冒烟")
+class Hel203BrowserSmokeTests(unittest.TestCase):
+    """真实 Chromium：改起算日→期初→公司端期末；断档首屏→说明→审核。"""
+
+    @classmethod
+    def setUpClass(cls) -> None:
+        _prepare_chrome_libs()
+        cls.temp_dir = tempfile.TemporaryDirectory()
+        root = Path(cls.temp_dir.name)
+        cls.db_path = root / "app.db"
+        cls.storage = root / "files"
+        cls.storage.mkdir()
+
+        cls._old_db = server.DB_PATH
+        cls._old_storage = server.STORAGE_DIR
+        server.DB_PATH = cls.db_path
+        server.STORAGE_DIR = cls.storage
+
+        connection = connect(cls.db_path)
+        migrate(connection)
+        auth.create_user(
+            connection,
+            "group-admin",
+            ADMIN_PASSWORD,
+            "admin",
+            must_change_password=False,
+        )
+        cls.company_a = master_data.create_company(
+            connection, "甲公司", None, None, None
+        )
+        cls.company_b = master_data.create_company(
+            connection, "乙公司", None, None, None
+        )
+        auth.create_user(
+            connection,
+            "cashier-a",
+            CASHIER_PASSWORD,
+            "company",
+            cls.company_a,
+            must_change_password=False,
+        )
+        admin = connection.execute(
+            "SELECT * FROM users WHERE username = 'group-admin'"
+        ).fetchone()
+        account = master_data.submit_bank_account(
+            connection,
+            company_id=cls.company_a,
+            bank_name="中信银行",
+            account_type="基本户",
+            account_number="6222000000000001",
+            start_date="2026-06-01",
+            actor=None,
+        )
+        cls.account_a = master_data.review_bank_account(
+            connection,
+            account["id"],
+            "approve",
+            None,
+            admin,
+            effective_from="2026-06-01",
+        )
+        account_b = master_data.submit_bank_account(
+            connection,
+            company_id=cls.company_b,
+            bank_name="中信银行",
+            account_type="基本户",
+            account_number="6222000000000002",
+            start_date="2026-06-01",
+            actor=None,
+        )
+        master_data.review_bank_account(
+            connection,
+            account_b["id"],
+            "approve",
+            None,
+            admin,
+            effective_from="2026-06-01",
+        )
+        # 制造一处 mid 断档，供公司端首屏提醒
+        with connection:
+            cursor = connection.execute(
+                """
+                INSERT INTO source_files
+                  (sha256, original_filename, size_bytes, storage_path, created_at)
+                VALUES (?, 'gap.xlsx', 1, 'data/files/gap.xlsx', ?)
+                """,
+                ("sha-hel203-gap", utc_now()),
+            )
+            source_file_id = int(cursor.lastrowid)
+            cursor = connection.execute(
+                """
+                INSERT INTO import_batches (
+                    source_file_id, status, company_id, upload_bank_account_id,
+                    created_at, updated_at
+                ) VALUES (?, 'parsed', ?, ?, ?, ?)
+                """,
+                (
+                    source_file_id,
+                    cls.company_a,
+                    cls.account_a["id"],
+                    utc_now(),
+                    utc_now(),
+                ),
+            )
+            batch_id = int(cursor.lastrowid)
+            cursor = connection.execute(
+                """
+                INSERT INTO sheet_batches (
+                    import_batch_id, sheet_name, bank_name, template_id,
+                    template_version, header_row, transaction_count, warnings,
+                    created_at
+                ) VALUES (?, '流水', '测试银行', 'test-v1', 1, 1, 1, '[]', ?)
+                """,
+                (batch_id, utc_now()),
+            )
+            sheet_batch_id = int(cursor.lastrowid)
+            connection.execute(
+                """
+                INSERT INTO sheet_reviews (
+                    import_batch_id, sheet_name, outcome, sheet_batch_id,
+                    review_status, created_at
+                ) VALUES (?, '流水', 'parsed', ?, 'confirmed', ?)
+                """,
+                (batch_id, sheet_batch_id, utc_now()),
+            )
+            connection.execute(
+                """
+                INSERT INTO source_rows (
+                    sheet_batch_id, source_row, transaction_at, income, expense,
+                    own_account, created_at
+                ) VALUES (?, 1, '2026-06-21T10:00:00', '0', '0', ?, ?)
+                """,
+                (sheet_batch_id, "6222000000000001", utc_now()),
+            )
+        calculation.set_calculation_start_date(
+            connection, "2026-06-01", "初始化起算", admin
+        )
+        calculation.recalculate_coverage_gaps(connection)
+
+        # 种一笔已确认往来，确认期初后公司端才能进入完整期末口径
+        def _add_row(company_id, account_id, own, cp, *, income, expense, at, ref):
+            with connection:
+                cursor = connection.execute(
+                    """
+                    INSERT INTO source_files
+                      (sha256, original_filename, size_bytes, storage_path, created_at)
+                    VALUES (?, 'xfer.xlsx', 1, 'data/files/xfer.xlsx', ?)
+                    """,
+                    (ref, utc_now()),
+                )
+                source_file_id = int(cursor.lastrowid)
+                cursor = connection.execute(
+                    """
+                    INSERT INTO import_batches (
+                        source_file_id, status, company_id, upload_bank_account_id,
+                        created_at, updated_at
+                    ) VALUES (?, 'parsed', ?, ?, ?, ?)
+                    """,
+                    (source_file_id, company_id, account_id, utc_now(), utc_now()),
+                )
+                batch_id = int(cursor.lastrowid)
+                cursor = connection.execute(
+                    """
+                    INSERT INTO sheet_batches (
+                        import_batch_id, sheet_name, bank_name, template_id,
+                        template_version, header_row, transaction_count, warnings,
+                        created_at
+                    ) VALUES (?, '流水', '测试银行', 'test-v1', 1, 1, 1, '[]', ?)
+                    """,
+                    (batch_id, utc_now()),
+                )
+                sheet_batch_id = int(cursor.lastrowid)
+                connection.execute(
+                    """
+                    INSERT INTO sheet_reviews (
+                        import_batch_id, sheet_name, outcome, sheet_batch_id,
+                        review_status, created_at
+                    ) VALUES (?, '流水', 'parsed', ?, 'confirmed', ?)
+                    """,
+                    (batch_id, sheet_batch_id, utc_now()),
+                )
+                cursor = connection.execute(
+                    """
+                    INSERT INTO source_rows (
+                        sheet_batch_id, source_row, transaction_at, income, expense,
+                        own_account, own_name, counterparty_account, counterparty_name,
+                        summary, purpose, currency, created_at
+                    ) VALUES (?, 1, ?, ?, ?, ?, '测试', ?, '对方', '往来', '往来款', 'CNY', ?)
+                    """,
+                    (
+                        sheet_batch_id,
+                        at,
+                        income,
+                        expense,
+                        own,
+                        cp,
+                        utc_now(),
+                    ),
+                )
+            return int(cursor.lastrowid)
+
+        row_a = _add_row(
+            cls.company_a,
+            cls.account_a["id"],
+            "6222000000000001",
+            "6222000000000002",
+            income="0",
+            expense="100.00",
+            at="2026-06-20T10:00:00",
+            ref="sha-hel203-a",
+        )
+        row_b = _add_row(
+            cls.company_b,
+            account_b["id"],
+            "6222000000000002",
+            "6222000000000001",
+            income="100.00",
+            expense="0",
+            at="2026-06-20T11:00:00",
+            ref="sha-hel203-b",
+        )
+        matching.reconcile_rows(connection, [row_a, row_b])
+        connection.close()
+
+        class QuietHandler(server.AppHandler):
+            def log_message(self, *args) -> None:
+                pass
+
+        cls.httpd = server.ThreadingHTTPServer(("127.0.0.1", 0), QuietHandler)
+        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()
+        server.DB_PATH = cls._old_db
+        server.STORAGE_DIR = cls._old_storage
+        cls.temp_dir.cleanup()
+
+    def _new_page(self, playwright):
+        browser = playwright.chromium.launch(
+            headless=True, args=["--no-sandbox", "--disable-dev-shm-usage"]
+        )
+        context = browser.new_context(viewport={"width": 1440, "height": 900})
+        page = context.new_page()
+        errors: list[str] = []
+        page.on("pageerror", lambda err: errors.append(str(err)))
+        page.on(
+            "console",
+            lambda msg: errors.append(f"console.{msg.type}: {msg.text}")
+            if msg.type == "error"
+            else None,
+        )
+        return browser, page, errors
+
+    def _login(self, page, *, portal: str, username: str, password: str) -> None:
+        login_path = "login-admin.html" if portal == "admin" else "login-company.html"
+        page.goto(f"{self.base}/{login_path}", wait_until="domcontentloaded")
+        page.fill("#account", username)
+        page.fill("#password", password)
+        page.click('button[type="submit"]')
+        expect = "admin.html" if portal == "admin" else "company.html"
+        page.wait_for_url(f"**/{expect}", timeout=15000)
+
+    def test_02_admin_start_date_opening_company_ending(self) -> None:
+        with sync_playwright() as p:
+            browser, page, errors = self._new_page(p)
+            try:
+                self._login(
+                    page,
+                    portal="admin",
+                    username="group-admin",
+                    password=ADMIN_PASSWORD,
+                )
+                page.click('a[data-view="settings"]')
+                page.wait_for_selector("#cs-start", state="visible")
+
+                # 修改起算日 → 原因弹窗必须打开且发出 PUT
+                page.fill("#cs-start", "2026-06-15")
+                with page.expect_request(
+                    lambda req: req.method == "PUT"
+                    and "/api/admin/settings/calculation-start" in req.url
+                ) as start_req:
+                    page.click('#systemSettings button[type="submit"]')
+                    page.wait_for_selector("#reasonDialog.open", timeout=5000)
+                    page.fill("#reasonInput", "调整起算日供冒烟")
+                    page.click("#reasonSubmit")
+                self.assertTrue(start_req.value.post_data)
+                page.wait_for_function(
+                    "() => document.getElementById('cs-start')?.value === '2026-06-15'"
+                )
+
+                # 创建期初并确认
+                page.click("#openOpeningDialog")
+                page.wait_for_selector("#openingDialog.open")
+                page.select_option("#ob-from", label="甲公司")
+                page.select_option("#ob-to", label="乙公司")
+                page.fill("#ob-amount", "200")
+                page.fill("#ob-reason", "冒烟期初录入")
+                with page.expect_request(
+                    lambda req: req.method == "POST"
+                    and req.url.endswith("/api/admin/opening-balances")
+                ):
+                    page.click('#openingForm button[type="submit"]')
+                page.wait_for_selector(
+                    '#openingRows button[data-confirm-opening]',
+                    timeout=8000,
+                )
+
+                with page.expect_request(
+                    lambda req: req.method == "POST"
+                    and "/opening-balances/" in req.url
+                    and req.url.endswith("/confirm")
+                ):
+                    page.click('#openingRows button[data-confirm-opening]')
+                    page.wait_for_selector("#reasonDialog.open", timeout=5000)
+                    page.fill("#reasonInput", "确认期初冒烟")
+                    page.click("#reasonSubmit")
+                page.wait_for_selector(
+                    '#openingRows button[data-void-opening]',
+                    timeout=8000,
+                )
+
+                # 公司端看到完整期末口径
+                self._login(
+                    page,
+                    portal="company",
+                    username="cashier-a",
+                    password=CASHIER_PASSWORD,
+                )
+                page.click('a[data-view="transfers"]')
+                page.wait_for_function(
+                    """() => {
+                      const data = document.getElementById('transfersData');
+                      const empty = document.getElementById('transfersEmpty');
+                      const ready = (data && !data.hidden) || (empty && !empty.hidden);
+                      const card = document.getElementById('tfStatEndingCard');
+                      const title = document.getElementById('tfStatNetTitle');
+                      const emptyHtml = document.getElementById('transfersEmptyStats')?.innerHTML || '';
+                      return ready && (
+                        (card && !card.hidden) ||
+                        (title && title.textContent.includes('期末')) ||
+                        emptyHtml.includes('期末')
+                      );
+                    }""",
+                    timeout=15000,
+                )
+                fatal = [e for e in errors if "openModal is not defined" in e
+                         or "Cannot read properties of null" in e]
+                self.assertEqual([], fatal, fatal)
+            finally:
+                browser.close()
+
+    def test_01_company_gap_notice_then_admin_approve(self) -> None:
+        with sync_playwright() as p:
+            browser, page, errors = self._new_page(p)
+            try:
+                self._login(
+                    page,
+                    portal="company",
+                    username="cashier-a",
+                    password=CASHIER_PASSWORD,
+                )
+                # 首屏即可见断档提醒，无需手动刷新
+                page.wait_for_selector(
+                    "#companyCoverageNotice",
+                    state="visible",
+                    timeout=10000,
+                )
+                body = page.locator("#companyCoverageBody").inner_text()
+                self.assertTrue(body.strip())
+                self.assertNotIn("0002", body)
+
+                page.click("#openAttestationFromWorkspace")
+                page.wait_for_selector("#attestationDialog.open", timeout=5000)
+                page.fill("#att-reason", "节假日账户无资金往来")
+                with page.expect_request(
+                    lambda req: req.method == "POST"
+                    and req.url.endswith("/api/company/no-business-attestations")
+                ) as att_req:
+                    page.click('#attestationForm button[type="submit"]')
+                self.assertTrue(att_req.value.post_data)
+                page.wait_for_function(
+                    """() => !document.getElementById('attestationDialog')?.classList.contains('open')""",
+                    timeout=8000,
+                )
+
+                self._login(
+                    page,
+                    portal="admin",
+                    username="group-admin",
+                    password=ADMIN_PASSWORD,
+                )
+                page.click('a[data-view="audit"]')
+                page.wait_for_selector(
+                    'button[data-audit-action="approve-attestation"]',
+                    timeout=10000,
+                )
+                with page.expect_request(
+                    lambda req: req.method == "POST"
+                    and "/no-business-attestations/" in req.url
+                    and req.url.endswith("/review")
+                ):
+                    page.click('button[data-audit-action="approve-attestation"]')
+                    page.wait_for_selector("#reasonDialog.open", timeout=5000)
+                    page.fill("#reasonInput", "审核通过说明")
+                    page.click("#reasonSubmit")
+                page.wait_for_function(
+                    """() => !document.querySelector(
+                      'button[data-audit-action=\"approve-attestation\"]'
+                    )""",
+                    timeout=10000,
+                )
+                fatal = [e for e in errors if "openModal is not defined" in e]
+                self.assertEqual([], fatal, fatal)
+            finally:
+                browser.close()
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/test_hel206_balance_direction.py

@@ -0,0 +1,417 @@
+"""HEL-206: 公司间期末余额方向——期初应收 + 转出垫付 = 期末应收增加。"""
+
+from __future__ import annotations
+
+import os
+import tempfile
+import threading
+import unittest
+from decimal import Decimal
+from pathlib import Path
+
+from bank_importer import auth, calculation, matching, master_data
+from bank_importer.db import connect, migrate, utc_now
+
+import server
+
+ROOT = Path(__file__).resolve().parents[1]
+ADMIN_PASSWORD = "AdminPass123"
+CASHIER_A_PASSWORD = "CashierA123"
+CASHIER_B_PASSWORD = "CashierB123"
+
+try:
+    from playwright.sync_api import sync_playwright
+except ImportError:  # pragma: no cover
+    sync_playwright = None
+
+
+def _prepare_chrome_libs() -> Path | None:
+    candidates = [ROOT / ".chrome-libs" / "lib"]
+    for lib_dir in candidates:
+        if (lib_dir / "libatk-1.0.so.0").exists():
+            current = os.environ.get("LD_LIBRARY_PATH", "")
+            prefix = str(lib_dir)
+            if prefix not in current.split(":"):
+                os.environ["LD_LIBRARY_PATH"] = (
+                    f"{prefix}:{current}" if current else prefix
+                )
+            return lib_dir
+    return None
+
+
+def _chromium_available() -> bool:
+    if not sync_playwright:
+        return False
+    _prepare_chrome_libs()
+    try:
+        with sync_playwright() as p:
+            browser = p.chromium.launch(headless=True, args=["--no-sandbox"])
+            browser.close()
+        return True
+    except Exception:
+        return False
+
+
+class Hel206BalanceDirectionUnitTests(unittest.TestCase):
+    """不依赖浏览器：期初 200 + 转出 100 → 甲应收 300 / 乙应付 300。"""
+
+    def setUp(self) -> None:
+        self.temp_dir = tempfile.TemporaryDirectory()
+        self.addCleanup(self.temp_dir.cleanup)
+        self.db_path = Path(self.temp_dir.name) / "app.db"
+        self.connection = connect(self.db_path)
+        self.addCleanup(self.connection.close)
+        migrate(self.connection)
+        auth.create_user(self.connection, "admin-u", ADMIN_PASSWORD, "admin")
+        self.admin = self.connection.execute(
+            "SELECT * FROM users WHERE username = 'admin-u'"
+        ).fetchone()
+        self.company_a = master_data.create_company(
+            self.connection, "甲公司", None, None, None
+        )
+        self.company_b = master_data.create_company(
+            self.connection, "乙公司", None, None, None
+        )
+        self.account_a = self._approve("6222000000000001", self.company_a)
+        self.account_b = self._approve("6222000000000002", self.company_b)
+        calculation.set_calculation_start_date(
+            self.connection, "2026-01-01", "起算", self.admin
+        )
+
+    def _approve(self, number: str, company_id: int):
+        account = master_data.submit_bank_account(
+            self.connection,
+            company_id=company_id,
+            bank_name="中信银行",
+            account_type="基本户",
+            account_number=number,
+            start_date="2026-01-01",
+            actor=None,
+        )
+        return master_data.review_bank_account(
+            self.connection,
+            account["id"],
+            "approve",
+            None,
+            self.admin,
+            effective_from="2026-01-01",
+        )
+
+    def _add_row(self, company_id, account_id, own, cp, *, income, expense, at, ref):
+        with self.connection:
+            cursor = self.connection.execute(
+                """
+                INSERT INTO source_files
+                  (sha256, original_filename, size_bytes, storage_path, created_at)
+                VALUES (?, 'xfer.xlsx', 1, 'data/files/xfer.xlsx', ?)
+                """,
+                (ref, utc_now()),
+            )
+            source_file_id = int(cursor.lastrowid)
+            cursor = self.connection.execute(
+                """
+                INSERT INTO import_batches (
+                    source_file_id, status, company_id, upload_bank_account_id,
+                    created_at, updated_at
+                ) VALUES (?, 'parsed', ?, ?, ?, ?)
+                """,
+                (source_file_id, company_id, account_id, utc_now(), utc_now()),
+            )
+            batch_id = int(cursor.lastrowid)
+            cursor = self.connection.execute(
+                """
+                INSERT INTO sheet_batches (
+                    import_batch_id, sheet_name, bank_name, template_id,
+                    template_version, header_row, transaction_count, warnings,
+                    created_at
+                ) VALUES (?, '流水', '测试银行', 'test-v1', 1, 1, 1, '[]', ?)
+                """,
+                (batch_id, utc_now()),
+            )
+            sheet_batch_id = int(cursor.lastrowid)
+            self.connection.execute(
+                """
+                INSERT INTO sheet_reviews (
+                    import_batch_id, sheet_name, outcome, sheet_batch_id,
+                    review_status, created_at
+                ) VALUES (?, '流水', 'parsed', ?, 'confirmed', ?)
+                """,
+                (batch_id, sheet_batch_id, utc_now()),
+            )
+            cursor = self.connection.execute(
+                """
+                INSERT INTO source_rows (
+                    sheet_batch_id, source_row, transaction_at, income, expense,
+                    own_account, own_name, counterparty_account, counterparty_name,
+                    summary, purpose, currency, created_at
+                ) VALUES (?, 1, ?, ?, ?, ?, '测试', ?, '对方', '往来', '往来款', 'CNY', ?)
+                """,
+                (sheet_batch_id, at, income, expense, own, cp, utc_now()),
+            )
+        return int(cursor.lastrowid)
+
+    def test_opening_200_plus_outflow_100_equals_closing_300(self) -> None:
+        item = calculation.create_opening_balance(
+            self.connection, self.company_a, self.company_b, "200", "期初应收", self.admin
+        )
+        calculation.confirm_opening_balance(
+            self.connection, item["id"], "确认", self.admin
+        )
+        row_a = self._add_row(
+            self.company_a,
+            self.account_a["id"],
+            "6222000000000001",
+            "6222000000000002",
+            income="0",
+            expense="100.00",
+            at="2026-01-15T10:00:00",
+            ref="sha-hel206-a",
+        )
+        row_b = self._add_row(
+            self.company_b,
+            self.account_b["id"],
+            "6222000000000002",
+            "6222000000000001",
+            income="100.00",
+            expense="0",
+            at="2026-01-15T11:00:00",
+            ref="sha-hel206-b",
+        )
+        matching.reconcile_rows(self.connection, [row_a, row_b])
+
+        bal_a = calculation.compute_pair_balance(
+            self.connection, self.company_a, self.company_b, cutoff="2026-01-31"
+        )
+        bal_b = calculation.compute_pair_balance(
+            self.connection, self.company_b, self.company_a, cutoff="2026-01-31"
+        )
+        self.assertEqual("200", bal_a["opening"])
+        self.assertEqual("100.00", bal_a["net_change"])
+        self.assertEqual("300.00", bal_a["closing"])
+        self.assertEqual("-200", bal_b["opening"])
+        self.assertEqual("-100.00", bal_b["net_change"])
+        self.assertEqual("-300.00", bal_b["closing"])
+        self.assertEqual(
+            Decimal(bal_a["closing"]) + Decimal(bal_b["closing"]),
+            Decimal("0"),
+        )
+
+
+@unittest.skipUnless(sync_playwright, "playwright 未安装，跳过浏览器冒烟")
+@unittest.skipUnless(_chromium_available(), "chromium 无法启动，跳过浏览器冒烟")
+class Hel206BrowserDirectionTests(unittest.TestCase):
+    """真实 Chromium：公司端转账往来页期末方向与对手公司对称。"""
+
+    @classmethod
+    def setUpClass(cls) -> None:
+        _prepare_chrome_libs()
+        cls.temp_dir = tempfile.TemporaryDirectory()
+        root = Path(cls.temp_dir.name)
+        cls.db_path = root / "app.db"
+        cls.storage = root / "files"
+        cls.storage.mkdir()
+
+        cls._old_db = server.DB_PATH
+        cls._old_storage = server.STORAGE_DIR
+        server.DB_PATH = cls.db_path
+        server.STORAGE_DIR = cls.storage
+
+        connection = connect(cls.db_path)
+        migrate(connection)
+        auth.create_user(
+            connection, "group-admin", ADMIN_PASSWORD, "admin",
+            must_change_password=False,
+        )
+        cls.company_a = master_data.create_company(
+            connection, "甲公司", None, None, None
+        )
+        cls.company_b = master_data.create_company(
+            connection, "乙公司", None, None, None
+        )
+        auth.create_user(
+            connection, "cashier-a", CASHIER_A_PASSWORD, "company",
+            cls.company_a, must_change_password=False,
+        )
+        auth.create_user(
+            connection, "cashier-b", CASHIER_B_PASSWORD, "company",
+            cls.company_b, must_change_password=False,
+        )
+        admin = connection.execute(
+            "SELECT * FROM users WHERE username = 'group-admin'"
+        ).fetchone()
+
+        def approve(company_id, number):
+            account = master_data.submit_bank_account(
+                connection,
+                company_id=company_id,
+                bank_name="中信银行",
+                account_type="基本户",
+                account_number=number,
+                start_date="2026-01-01",
+                actor=None,
+            )
+            return master_data.review_bank_account(
+                connection, account["id"], "approve", None, admin,
+                effective_from="2026-01-01",
+            )
+
+        account_a = approve(cls.company_a, "6222000000000001")
+        account_b = approve(cls.company_b, "6222000000000002")
+        calculation.set_calculation_start_date(
+            connection, "2026-01-01", "初始化起算", admin
+        )
+        item = calculation.create_opening_balance(
+            connection, cls.company_a, cls.company_b, "200", "期初应收", admin
+        )
+        calculation.confirm_opening_balance(connection, item["id"], "确认", admin)
+
+        def add_row(company_id, account_id, own, cp, *, income, expense, at, ref):
+            with connection:
+                cursor = connection.execute(
+                    """
+                    INSERT INTO source_files
+                      (sha256, original_filename, size_bytes, storage_path, created_at)
+                    VALUES (?, 'xfer.xlsx', 1, 'data/files/xfer.xlsx', ?)
+                    """,
+                    (ref, utc_now()),
+                )
+                source_file_id = int(cursor.lastrowid)
+                cursor = connection.execute(
+                    """
+                    INSERT INTO import_batches (
+                        source_file_id, status, company_id, upload_bank_account_id,
+                        created_at, updated_at
+                    ) VALUES (?, 'parsed', ?, ?, ?, ?)
+                    """,
+                    (source_file_id, company_id, account_id, utc_now(), utc_now()),
+                )
+                batch_id = int(cursor.lastrowid)
+                cursor = connection.execute(
+                    """
+                    INSERT INTO sheet_batches (
+                        import_batch_id, sheet_name, bank_name, template_id,
+                        template_version, header_row, transaction_count, warnings,
+                        created_at
+                    ) VALUES (?, '流水', '测试银行', 'test-v1', 1, 1, 1, '[]', ?)
+                    """,
+                    (batch_id, utc_now()),
+                )
+                sheet_batch_id = int(cursor.lastrowid)
+                connection.execute(
+                    """
+                    INSERT INTO sheet_reviews (
+                        import_batch_id, sheet_name, outcome, sheet_batch_id,
+                        review_status, created_at
+                    ) VALUES (?, '流水', 'parsed', ?, 'confirmed', ?)
+                    """,
+                    (batch_id, sheet_batch_id, utc_now()),
+                )
+                cursor = connection.execute(
+                    """
+                    INSERT INTO source_rows (
+                        sheet_batch_id, source_row, transaction_at, income, expense,
+                        own_account, own_name, counterparty_account, counterparty_name,
+                        summary, purpose, currency, created_at
+                    ) VALUES (?, 1, ?, ?, ?, ?, '测试', ?, '对方', '往来', '往来款', 'CNY', ?)
+                    """,
+                    (sheet_batch_id, at, income, expense, own, cp, utc_now()),
+                )
+            return int(cursor.lastrowid)
+
+        row_a = add_row(
+            cls.company_a, account_a["id"], "6222000000000001", "6222000000000002",
+            income="0", expense="100.00", at="2026-01-15T10:00:00", ref="sha-hel206-br-a",
+        )
+        row_b = add_row(
+            cls.company_b, account_b["id"], "6222000000000002", "6222000000000001",
+            income="100.00", expense="0", at="2026-01-15T11:00:00", ref="sha-hel206-br-b",
+        )
+        matching.reconcile_rows(connection, [row_a, row_b])
+        connection.close()
+
+        class QuietHandler(server.AppHandler):
+            def log_message(self, *args) -> None:
+                pass
+
+        cls.httpd = server.ThreadingHTTPServer(("127.0.0.1", 0), QuietHandler)
+        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()
+        server.DB_PATH = cls._old_db
+        server.STORAGE_DIR = cls._old_storage
+        cls.temp_dir.cleanup()
+
+    def _login(self, page, *, username: str, password: str) -> None:
+        page.goto(f"{self.base}/login-company.html", wait_until="domcontentloaded")
+        page.fill("#account", username)
+        page.fill("#password", password)
+        page.click('button[type="submit"]')
+        page.wait_for_url("**/company.html", timeout=15000)
+
+    def test_company_ending_direction_in_browser(self) -> None:
+        with sync_playwright() as p:
+            browser = p.chromium.launch(
+                headless=True, args=["--no-sandbox", "--disable-dev-shm-usage"]
+            )
+            try:
+                context = browser.new_context(viewport={"width": 1440, "height": 900})
+                page = context.new_page()
+                errors: list[str] = []
+                page.on("pageerror", lambda err: errors.append(str(err)))
+
+                # 甲公司：期初 200 + 转出 100 → 期末应收 300
+                self._login(page, username="cashier-a", password=CASHIER_A_PASSWORD)
+                page.click('a[data-view="transfers"]')
+                page.wait_for_selector("#tfStatEndingCard:not([hidden])", timeout=15000)
+                bal_a = page.evaluate(
+                    """async () => {
+                      const res = await fetch('/api/company/balances?cutoff=2026-01-31');
+                      return await res.json();
+                    }"""
+                )
+                self.assertEqual("ok", bal_a.get("status"))
+                self.assertEqual("full", bal_a.get("basis"))
+                pair_a = next(
+                    p for p in bal_a["pairs"]
+                    if p["counterparty_company_id"] == self.company_b
+                )
+                self.assertEqual("200", pair_a["opening"])
+                self.assertEqual("100.00", pair_a["net_change"])
+                self.assertEqual("300.00", pair_a["closing"])
+                ending_text = page.locator("#tfStatEnding").inner_text()
+                self.assertIn("0.03", ending_text)  # 300 元 = 0.03 万元
+                self.assertEqual([], errors, errors)
+
+                # 乙公司：对称应付 300
+                self._login(page, username="cashier-b", password=CASHIER_B_PASSWORD)
+                page.click('a[data-view="transfers"]')
+                page.wait_for_selector("#tfStatEndingCard:not([hidden])", timeout=15000)
+                bal_b = page.evaluate(
+                    """async () => {
+                      const res = await fetch('/api/company/balances?cutoff=2026-01-31');
+                      return await res.json();
+                    }"""
+                )
+                pair_b = next(
+                    p for p in bal_b["pairs"]
+                    if p["counterparty_company_id"] == self.company_a
+                )
+                self.assertEqual("-200", pair_b["opening"])
+                self.assertEqual("-100.00", pair_b["net_change"])
+                self.assertEqual("-300.00", pair_b["closing"])
+                ending_b = page.locator("#tfStatEnding").inner_text()
+                self.assertIn("0.03", ending_b)
+                fatal = [e for e in errors if "is not defined" in e or "Cannot read" in e]
+                self.assertEqual([], fatal, fatal)
+            finally:
+                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], first)
+        self.assertEqual([1, 2, 3, 4, 5, 6, 7, 8, 9], first)
         self.assertEqual([], migrate(self.connection))
         self.assertEqual(first, applied_versions(self.connection))
         tables = {
@@ -84,20 +84,24 @@ 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",
             "schema_migrations",
         ):
             self.assertIn(table, tables)
 
     def test_rollback_removes_schema_and_forward_rebuilds_it(self) -> None:
-        self.assertEqual([7, 6, 5, 4, 3, 2, 1], rollback(self.connection, 0))
+        self.assertEqual([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], migrate(self.connection))
-        self.assertEqual([1, 2, 3, 4, 5, 6, 7], applied_versions(self.connection))
+        self.assertEqual([1, 2, 3, 4, 5, 6, 7, 8, 9], migrate(self.connection))
+        self.assertEqual([1, 2, 3, 4, 5, 6, 7, 8, 9], applied_versions(self.connection))
 
     def test_rollback_to_4_keeps_bank_evidence_and_drops_event_layer(self) -> None:
         self.import_sample()
@@ -105,7 +109,7 @@ class MigrationTests(PersistenceTestCase):
             "SELECT COUNT(*) AS n FROM source_rows"
         ).fetchone()["n"]
         self.assertGreater(row_count, 0)
-        self.assertEqual([7, 6, 5], rollback(self.connection, 4))
+        self.assertEqual([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(9, versions[-1]["version"])
+        connection.execute("DELETE FROM schema_migrations WHERE version = 9")
+        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_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

@@ -512,8 +512,9 @@
                   <form id="systemSettings" novalidate>
                     <div class="field" style="margin-bottom: 14px;">
                       <label for="cs-start">全局起算日</label>
-                      <input class="input num-input" type="date" name="startDate" id="cs-start" value="2026-01-01" />
-                      <span class="hint">期初余额以此日前一日的期末数为准</span>
+                      <input class="input num-input" type="date" name="startDate" id="cs-start" />
+                      <span class="hint" id="cs-start-hint">期初余额以此日前一日的期末数为准</span>
+                      <span class="pill pill-muted" id="cs-start-locked" style="display: none; margin-top: 8px;">已锁定</span>
                     </div>
                     <div class="field" style="margin-bottom: 14px;">
                       <label for="cs-day">每月结账日</label>
@@ -547,15 +548,30 @@
 
                 <div class="card">
                   <div class="card-head">
-                    <span class="card-title">期初余额管理<span class="sub" id="openingSub">2026-01-01 起算的公司间往来期初数</span></span>
+                    <span class="card-title">期初余额管理<span class="sub" id="openingSub">公司间往来期初数</span></span>
                     <button class="btn btn-sm" id="openOpeningDialog">新增</button>
                   </div>
+                  <div class="notice info" id="openingSummary" style="margin: 0 0 14px; display: none;"></div>
+                  <div class="table-wrap" style="border: 0;">
+                    <table class="ds-table">
+                      <thead>
+                        <tr><th>本方公司</th><th>对方公司</th><th>方向</th><th class="num-col">金额</th><th>录入人</th><th>录入时间</th><th>状态</th><th></th></tr>
+                      </thead>
+                      <tbody id="openingRows"></tbody>
+                    </table>
+                  </div>
+                </div>
+
+                <div class="card">
+                  <div class="card-head">
+                    <span class="card-title">变更记录<span class="sub">起算日与期初余额改动留痕</span></span>
+                  </div>
                   <div class="table-wrap" style="border: 0;">
                     <table class="ds-table">
                       <thead>
-                        <tr><th>本方公司</th><th>对方公司</th><th>科目</th><th>方向</th><th class="num-col">金额（万元）</th><th>生效日</th><th>状态</th></tr>
+                        <tr><th>时间</th><th>操作人</th><th>对象</th><th>变更</th><th>原因</th></tr>
                       </thead>
-                      <tbody id="openingRows"></tbody>
+                      <tbody id="calculationChangeRows"><tr><td colspan="5" class="empty">暂无变更记录</td></tr></tbody>
                     </table>
                   </div>
                 </div>
@@ -617,6 +633,22 @@
                 <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="card" id="pending-reminders-card" style="margin-bottom: 16px;">
+              <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>
+              </div>
+              <div id="pending-list">
+                <div class="empty" id="pending-empty">暂无需要提醒的事项 · 各公司流水与确认进度正常</div>
+              </div>
             </div>
 
             <div class="grid grid-1-2">
@@ -626,18 +658,30 @@
                 </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>
+                    <label>接收公司（可多选）</label>
+                    <div class="row" id="reminderCompanyList" style="flex-wrap: wrap; gap: 8px 16px;"></div>
+                    <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 class="field" style="margin-bottom: 14px;">
+                    <label for="reminder-type">提醒类型</label>
+                    <select class="select" id="reminder-type">
+                      <option selected>流水未提交</option>
+                      <option>单边待确认</option>
+                      <option>科目待确认</option>
+                      <option>账户登记</option>
+                      <option>其他</option>
+                    </select>
                   </div>
-                  <button type="submit" class="btn btn-primary" id="send-btn" style="width: 100%;" disabled>发送提醒</button>
+                  <div class="field" style="margin-bottom: 14px;">
+                    <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 class="field" style="margin-bottom: 18px;">
+                    <label for="reminder-deadline">截止日期</label>
+                    <input class="input" type="date" id="reminder-deadline" value="2026-08-29" min="2026-08-20" />
+                  </div>
+                  <button type="submit" class="btn btn-primary" id="send-btn" style="width: 100%;">发送提醒</button>
                   <p class="hint" id="send-hint" style="margin-top: 10px; display: none;"></p>
                 </form>
               </div>
@@ -656,6 +700,7 @@
                     <thead>
                       <tr>
                         <th>公司</th>
+                        <th>来源</th>
                         <th>类型</th>
                         <th class="wrap">内容摘要</th>
                         <th>发送时间</th>
@@ -762,31 +807,15 @@
               <select class="select" name="to" id="ob-to" required></select>
             </div>
             <div class="field">
-              <label for="ob-subject">科目</label>
-              <select class="select" name="subject" id="ob-subject" required>
-                <option>应收</option>
-                <option>应付</option>
-                <option>其他应收</option>
-                <option>其他应付</option>
-              </select>
+              <label for="ob-amount">金额</label>
+              <input class="input num-input" name="amount" id="ob-amount" type="number" step="0.01" required />
             </div>
             <div class="field">
-              <label for="ob-direction">方向</label>
-              <select class="select" name="direction" id="ob-direction" required>
-                <option>借方</option>
-                <option>贷方</option>
-              </select>
-            </div>
-            <div class="field">
-              <label for="ob-amount">金额（万元）</label>
-              <input class="input num-input" name="amount" id="ob-amount" type="number" min="0" step="0.01" required />
-            </div>
-            <div class="field">
-              <label for="ob-effective">生效日</label>
-              <input class="input" name="effectiveDate" id="ob-effective" type="date" value="2026-01-01" required />
+              <label for="ob-reason">录入原因</label>
+              <input class="input" name="reason" id="ob-reason" required placeholder="必填，将写入变更记录" />
             </div>
           </div>
-          <p class="hint" style="margin-top: 10px;">提交后进入复核，不能直接修改已确认期初。</p>
+          <p class="hint" style="margin-top: 10px;">正数表示本方对对方为应收；提交后进入待确认，确认后才计入公司端余额。</p>
           <div class="modal-actions">
             <button type="button" class="btn" data-close-opening>取消</button>
             <button type="submit" class="btn btn-primary">提交复核</button>
@@ -795,6 +824,26 @@
       </div>
     </div>
 
+    <div class="modal-backdrop" id="reasonDialog">
+      <div class="modal">
+        <div class="modal-head">
+          <span class="modal-title" id="reasonDialogTitle">填写原因</span>
+          <button type="button" class="modal-close" data-close-reason aria-label="关闭">×</button>
+        </div>
+        <p class="modal-sub" id="reasonDialogSub">该操作必须填写原因并留痕。</p>
+        <form id="reasonForm" novalidate>
+          <div class="field">
+            <label for="reasonInput">原因</label>
+            <textarea class="input" id="reasonInput" name="reason" rows="3" required placeholder="至少 2 个字"></textarea>
+          </div>
+          <div class="modal-actions">
+            <button type="button" class="btn" data-close-reason>取消</button>
+            <button type="submit" class="btn btn-primary" id="reasonSubmit">确认</button>
+          </div>
+        </form>
+      </div>
+    </div>
+
     <!-- 审核通过弹窗 -->
     <div class="modal-backdrop" id="modal-approve">
       <div class="modal">
@@ -927,6 +976,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">
@@ -942,6 +1011,6 @@
       </div>
     </div>
     <div class="toast-region" id="toastRegion" aria-live="polite"></div>
-    <script src="app.js?v=9"></script>
+    <script src="app.js?v=13"></script>
   </body>
 </html>

web/company.html

@@ -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">
@@ -98,6 +98,17 @@
 
             <div class="grid grid-3-2" style="margin-top: 14px;">
               <div class="stack">
+                <div class="notice danger" id="companyCoverageNotice" style="display: none; margin-bottom: 14px;">
+                  <div>
+                    <div class="n-title" id="companyCoverageTitle">流水断档提醒</div>
+                    <div class="n-body" id="companyCoverageBody"></div>
+                  </div>
+                  <div class="row" style="margin-top: 10px; gap: 8px; flex-wrap: wrap;">
+                    <button type="button" class="btn btn-sm btn-primary" data-view-link="upload">去上传</button>
+                    <button type="button" class="btn btn-sm" id="openAttestationFromWorkspace">提交无业务说明</button>
+                  </div>
+                </div>
+
                 <div class="card" id="workspaceTodos">
                   <div class="card-head">
                     <span class="card-title">本月待办<span class="sub" id="workspaceTodoSub">按权威待确认单边流水同步</span></span>
@@ -170,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>
@@ -357,6 +347,16 @@
           </section>
 
           <section class="app-view" data-page="flows">
+            <div class="notice danger" id="flowsCoverageNotice" style="display: none; margin-bottom: 14px;">
+              <div>
+                <div class="n-title">流水断档提醒</div>
+                <div class="n-body" id="flowsCoverageBody"></div>
+              </div>
+              <div class="row" style="margin-top: 10px; gap: 8px;">
+                <button type="button" class="btn btn-sm btn-primary" data-view-link="upload">去上传</button>
+                <button type="button" class="btn btn-sm" id="openAttestationFromFlows">提交无业务说明</button>
+              </div>
+            </div>
             <div class="page-head">
               <div>
                 <h1>流水管理</h1>
@@ -472,6 +472,11 @@
 
               <div id="transfersData" hidden>
                 <div class="grid grid-4" id="transfersStatGrid">
+                  <div class="card stat-card" id="tfStatOpeningCard" hidden>
+                    <div class="stat-label"><span class="stat-dot muted"></span>期初余额</div>
+                    <div class="stat-value" id="tfStatOpening">—</div>
+                    <div class="stat-foot">起算日前一日结转</div>
+                  </div>
                   <div class="card stat-card">
                     <div class="stat-label"><span class="stat-dot info"></span>往来公司数</div>
                     <div class="stat-value" id="tfStatCompanies">—<span class="unit">家</span></div>
@@ -492,6 +497,11 @@
                     <div class="stat-value" id="tfStatNet">—</div>
                     <div class="stat-foot" id="tfStatNetFoot">正数=应收方向 · 负数=应付方向</div>
                   </div>
+                  <div class="card stat-card" id="tfStatEndingCard" hidden>
+                    <div class="stat-label"><span class="stat-dot success"></span>期末余额</div>
+                    <div class="stat-value" id="tfStatEnding">—</div>
+                    <div class="stat-foot">期初 + 本期变动</div>
+                  </div>
                 </div>
 
                 <div class="xfer-split" id="transfersSplit" style="margin-top: 14px;">
@@ -773,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>
@@ -870,6 +802,37 @@
     </div>
 
     <!-- 导入批次详情弹窗 -->
+    <div class="modal-backdrop" id="attestationDialog">
+      <div class="modal">
+        <div class="modal-head">
+          <span class="modal-title">提交无业务说明</span>
+          <button type="button" class="modal-close" data-close-attestation aria-label="关闭">×</button>
+        </div>
+        <p class="modal-sub">说明经管理员审核通过后仅关闭断档提醒，不会生成银行流水。</p>
+        <form id="attestationForm" novalidate>
+          <input type="hidden" id="att-gap-start" name="gap_start" />
+          <input type="hidden" id="att-gap-end" name="gap_end" />
+          <input type="hidden" id="att-account-id" name="bank_account_id" />
+          <div class="field">
+            <label>断档区间</label>
+            <div class="meta num" id="att-gap-label">—</div>
+          </div>
+          <div class="field">
+            <label for="att-reason">说明（至少 5 个字）</label>
+            <textarea class="input" id="att-reason" name="reason" rows="3" required></textarea>
+          </div>
+          <div class="field">
+            <label for="att-evidence">佐证（可选）</label>
+            <input class="input" id="att-evidence" name="evidence" placeholder="如：节假日无业务、账户停用说明编号" />
+          </div>
+          <div class="modal-actions">
+            <button type="button" class="btn" data-close-attestation>取消</button>
+            <button type="submit" class="btn btn-primary">提交审核</button>
+          </div>
+        </form>
+      </div>
+    </div>
+
     <div class="modal-backdrop" id="modal-batch">
       <div class="modal">
         <div class="modal-head">
@@ -1046,6 +1009,6 @@
     </aside>
 
     <div class="toast-region" id="toastRegion" aria-live="polite"></div>
-    <script src="app.js?v=12"></script>
+    <script src="app.js?v=13"></script>
   </body>
 </html>