HEL-34: 登录页按「深海军蓝 × 账房金」方案改造

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

docs/decisions/006-intercompany-positions.md

@@ -1,87 +0,0 @@
-# 006: Intercompany positions, subject review and drill-down evidence (B-44)
-
-Status: accepted (2026-08-19)
-
-## Decision
-
-The intercompany ledger adds one canonical layer above B-43's eligible events:
-
-- **Append-only ledger events.** A canonical `ledger_event` carries an
-  append-only `ledger_event_revisions` chain. A B-43 eligible bank event first
-  becomes a `pending_subject` revision; an administrator confirms the subject
-  into a `confirmed` revision. Corrections are never in-place edits — a
-  reversal or adjustment is a *new* ledger event with its own effective date,
-  and the original event keeps its history so earlier cutoffs are not
-  rewritten.
-- **Manual records as immutable submitted facts.** Companies submit
-  `manual_records`; only an administrator-approved record becomes a confirmed
-  ledger event (`approve_new`) or joins one (`approve_link`). Returned,
-  exception and pending records never affect a balance and never leak to the
-  counterparty. Approved facts change only through `reverse` (a new opposite
-  event) — the original is never edited.
-- **One perspective, fixed mirror.** Subjects are stored from one participating
-  company's perspective (`receivable/payable/other_receivable/other_payable`);
-  the other side is the fixed mirror (应收<->应付, 其他应收<->其他应付), so the
-  two companies can never book conflicting subjects.
-- **Subjects are confirmed, never auto-posted.** Bank summary/purpose text only
-  feeds a deterministic *suggestion* dictionary (`subject-suggest-draft-v1`,
-  not group-approved). Without an approved trade dictionary every bank event
-  stays in subject review until an administrator confirms.
-- **Decimal-only aggregation.** All money is stored as TEXT decimal strings and
-  aggregated with Python `Decimal`. SQLite `SUM`, JavaScript `Number` and
-  Python `float` never touch financial math. Different currencies are
-  aggregated and displayed separately; nothing is converted to a group total.
-- **Conservation is asserted.** For every company pair and currency the two
-  perspectives must mirror exactly (`C_A == -C_B`); a violation raises a
-  calculation exception instead of rendering an unbalanced number.
-- **Unresolved is absolute gross.** Unresolved amounts are summed by absolute
-  value per currency (never netted), broken down by reason
-  (`subject_review`, `unmatched_single`, `manual_pending`), with count and
-  gross amount exposed on every balance response.
-- **B-45 boundary.** Until the B-45 opening balance exists, every response
-  returns `opening.status=unavailable`, `opening.amount=null` and
-  `result.kind=period_net_change`; the UI labels this "期间净变动", never
-  "期末余额".
-
-## Background
-
-B-43 produces `eligible_intercompany_events` as the only bank-event entry
-point. Before B-44 there was no canonical financial event, no statutory
-subject, no manual-record approval, and no server-side balance API. The
-revision-chain design is inherited from `transfer_match_decisions` in
-migration 5 and from the append-only audit posture of the rest of the system.
-
-## Consequences
-
-- **Positive:** balances are deterministic, conservable, auditable and
-  drillable from a group directory down to bank source rows; manual records
-  cannot double count; corrections never mutate evidence; company portals are
-  tenant-scoped on the server.
-- **Negative:** pending bank events and returned/exception manual records are
-  intentionally invisible to counterparties, which can surprise cashiers who
-  expect symmetric disclosure; subject confirmation is manual until a
-  group-approved dictionary exists.
-- **Operational:** migration 6 is forward-only for production once
-  approvals/revisions exist; pre-production it can be rolled back with
-  `--rollback-to 5`. Read aggregation runs against the rebuildable current
-  projection (no day snapshots yet); if B-45 monthly close needs them, immutable
-  monthly snapshots can be added behind the same API contract.
-
-## Files
-
-- `src/bank_importer/ledger_events.py` — event lifecycle, revision chain,
-  bank reconciliation, reversal/adjustment/reopen, projection rebuild.
-- `src/bank_importer/subjects.py` — subject constants/mirror, suggestion
-  dictionary, `confirm_subject`.
-- `src/bank_importer/manual_records.py` — submission, approval
-  (new/link), return/exception/reverse, candidate hints, idempotency.
-- `src/bank_importer/positions.py` — Decimal aggregation, directories, pairs,
-  events, evidence visibility, unresolved buckets, keyset pagination.
-- `server.py` — `/api/admin/intercompany/*` and `/api/company/intercompany/*`
-  plus `/api/admin/subject-reviews` and `/api/admin/manual-records`.
-- `db.py` migration 6 — `manual_records`, `manual_record_decisions`,
-  `ledger_events`, `ledger_event_revisions`, current-pointer projections,
-  source claim tables, `ledger_subject_suggestions`, `eligible_position_events`.
-- Tests: `test_ledger_events.py`, `test_manual_records.py`,
-  `test_positions.py`, `test_positions_api.py`, extended
-  `test_persistence.py`.

src/bank_importer/db.py

@@ -569,283 +569,6 @@ MIGRATIONS: tuple[Migration, ...] = (
         ALTER TABLE import_batches DROP COLUMN upload_bank_account_id;
         """,
     ),
-    Migration(
-        version=6,
-        name="0006_intercompany_ledger_events",
-        # B-44 canonical intercompany ledger layer. Manual records and the
-        # ledger event revision chain are append-only facts; current pointers
-        # (current revision per ledger event / manual decision, source claims)
-        # are rebuildable projections. Bank events enter only through
-        # ``eligible_intercompany_events``; nothing here rewrites bank rows.
-        up="""
-        CREATE TABLE manual_records (
-            id INTEGER PRIMARY KEY AUTOINCREMENT,
-            company_id INTEGER NOT NULL REFERENCES companies (id),
-            counterparty_company_id INTEGER NOT NULL REFERENCES companies (id),
-            occurred_at TEXT NOT NULL,
-            direction TEXT NOT NULL CHECK (direction IN ('outgoing', 'incoming')),
-            amount TEXT NOT NULL,
-            amount_scale INTEGER NOT NULL,
-            currency TEXT NOT NULL,
-            funding_source TEXT NOT NULL CHECK (funding_source IN (
-                'approved_bank_account', 'personal_transit', 'other'
-            )),
-            bank_account_id INTEGER REFERENCES bank_accounts (id),
-            personal_transit_mapping_id INTEGER REFERENCES personal_transit_mappings (id),
-            related_source_row_id INTEGER REFERENCES source_rows (id),
-            requested_subject TEXT NOT NULL CHECK (requested_subject IN (
-                'receivable', 'payable', 'other_receivable', 'other_payable'
-            )),
-            summary TEXT,
-            reason TEXT,
-            evidence_json TEXT,
-            request_key TEXT NOT NULL,
-            supersedes_record_id INTEGER REFERENCES manual_records (id),
-            submitted_by INTEGER REFERENCES users (id),
-            created_at TEXT NOT NULL,
-            UNIQUE (company_id, request_key),
-            CHECK (counterparty_company_id != company_id)
-        );
-
-        CREATE TABLE manual_record_decisions (
-            id INTEGER PRIMARY KEY AUTOINCREMENT,
-            record_id INTEGER NOT NULL REFERENCES manual_records (id),
-            revision INTEGER NOT NULL,
-            state TEXT NOT NULL CHECK (state IN (
-                'pending', 'approved', 'returned', 'exception', 'reversed'
-            )),
-            action TEXT NOT NULL,
-            reason TEXT,
-            actor_user_id INTEGER REFERENCES users (id),
-            actor_username TEXT,
-            idempotency_key TEXT,
-            supersedes_decision_id INTEGER REFERENCES manual_record_decisions (id),
-            created_at TEXT NOT NULL,
-            UNIQUE (record_id, revision)
-        );
-
-        CREATE TABLE current_manual_record_decisions (
-            record_id INTEGER PRIMARY KEY REFERENCES manual_records (id),
-            decision_id INTEGER NOT NULL UNIQUE REFERENCES manual_record_decisions (id)
-        );
-
-        CREATE TABLE ledger_events (
-            id INTEGER PRIMARY KEY AUTOINCREMENT,
-            lifecycle TEXT NOT NULL DEFAULT 'active'
-                CHECK (lifecycle IN ('active', 'superseded')),
-            created_at TEXT NOT NULL
-        );
-
-        CREATE TABLE ledger_event_revisions (
-            id INTEGER PRIMARY KEY AUTOINCREMENT,
-            ledger_event_id INTEGER NOT NULL REFERENCES ledger_events (id),
-            revision INTEGER NOT NULL,
-            state TEXT NOT NULL CHECK (state IN ('pending_subject', 'confirmed')),
-            effective_at TEXT NOT NULL,
-            amount TEXT NOT NULL,
-            amount_scale INTEGER NOT NULL,
-            currency TEXT NOT NULL,
-            payer_company_id INTEGER NOT NULL REFERENCES companies (id),
-            payee_company_id INTEGER NOT NULL REFERENCES companies (id),
-            perspective_company_id INTEGER REFERENCES companies (id),
-            subject_code TEXT CHECK (subject_code IN (
-                'receivable', 'payable', 'other_receivable', 'other_payable'
-            )),
-            source_kind TEXT NOT NULL CHECK (source_kind IN ('bank', 'manual', 'adjustment')),
-            source_revision_token TEXT,
-            posting_kind TEXT NOT NULL CHECK (posting_kind IN (
-                'normal', 'reversal', 'adjustment'
-            )),
-            reverses_ledger_event_id INTEGER REFERENCES ledger_events (id),
-            adjusts_ledger_event_id INTEGER REFERENCES ledger_events (id),
-            rule_version TEXT,
-            evidence_json TEXT,
-            idempotency_key TEXT,
-            actor_user_id INTEGER REFERENCES users (id),
-            actor_username TEXT,
-            reason TEXT,
-            supersedes_revision_id INTEGER REFERENCES ledger_event_revisions (id),
-            created_at TEXT NOT NULL,
-            UNIQUE (ledger_event_id, revision),
-            CHECK (payer_company_id != payee_company_id),
-            CHECK (state = 'confirmed' OR subject_code IS NULL),
-            CHECK (state = 'confirmed' OR perspective_company_id IS NULL),
-            CHECK (
-                state != 'confirmed'
-                OR (perspective_company_id IS NOT NULL AND subject_code IS NOT NULL)
-            )
-        );
-
-        CREATE TABLE current_ledger_event_revisions (
-            ledger_event_id INTEGER PRIMARY KEY REFERENCES ledger_events (id),
-            revision_id INTEGER NOT NULL UNIQUE REFERENCES ledger_event_revisions (id)
-        );
-
-        CREATE TABLE ledger_event_bank_sources (
-            bank_event_id INTEGER PRIMARY KEY REFERENCES canonical_transfer_events (id),
-            ledger_event_id INTEGER NOT NULL REFERENCES ledger_events (id),
-            UNIQUE (ledger_event_id, bank_event_id)
-        );
-
-        CREATE TABLE ledger_event_manual_sources (
-            manual_record_id INTEGER PRIMARY KEY REFERENCES manual_records (id),
-            ledger_event_id INTEGER NOT NULL REFERENCES ledger_events (id),
-            UNIQUE (ledger_event_id, manual_record_id)
-        );
-
-        CREATE TABLE ledger_subject_suggestions (
-            id INTEGER PRIMARY KEY AUTOINCREMENT,
-            ledger_event_id INTEGER NOT NULL REFERENCES ledger_events (id),
-            source_revision_id INTEGER NOT NULL REFERENCES ledger_event_revisions (id),
-            suggested_perspective_company_id INTEGER NOT NULL REFERENCES companies (id),
-            suggested_subject_code TEXT NOT NULL CHECK (suggested_subject_code IN (
-                'receivable', 'payable', 'other_receivable', 'other_payable'
-            )),
-            rule_version TEXT,
-            evidence_json TEXT,
-            created_at TEXT NOT NULL
-        );
-
-        CREATE INDEX idx_ledger_revisions_event ON ledger_event_revisions (ledger_event_id, revision);
-        CREATE INDEX idx_ledger_revisions_effective ON ledger_event_revisions (effective_at);
-        CREATE INDEX idx_ledger_revisions_pair_currency
-            ON ledger_event_revisions (payer_company_id, payee_company_id, currency);
-        CREATE INDEX idx_ledger_revisions_state
-            ON ledger_event_revisions (state, effective_at);
-        CREATE INDEX idx_manual_records_company ON manual_records (company_id, occurred_at);
-        CREATE INDEX idx_manual_decisions_record ON manual_record_decisions (record_id, revision);
-        CREATE INDEX idx_manual_decisions_state ON manual_record_decisions (state);
-        CREATE INDEX idx_subject_suggestions_event ON ledger_subject_suggestions (ledger_event_id);
-
-        CREATE VIEW eligible_position_events AS
-        SELECT le.id AS ledger_event_id,
-               cur.revision_id AS ledger_revision_id,
-               r.effective_at AS effective_at,
-               r.amount AS amount, r.amount_scale AS amount_scale,
-               r.currency AS currency,
-               r.payer_company_id AS payer_company_id,
-               r.payee_company_id AS payee_company_id,
-               r.perspective_company_id AS perspective_company_id,
-               r.subject_code AS subject_code,
-               r.source_kind AS source_kind, r.posting_kind AS posting_kind,
-               r.reverses_ledger_event_id AS reverses_ledger_event_id,
-               r.adjusts_ledger_event_id AS adjusts_ledger_event_id,
-               COALESCE(
-                   (SELECT bs.bank_event_id FROM ledger_event_bank_sources bs
-                    WHERE bs.ledger_event_id = le.id LIMIT 1),
-                   (SELECT ms.manual_record_id FROM ledger_event_manual_sources ms
-                    WHERE ms.ledger_event_id = le.id LIMIT 1)
-               ) AS source_id,
-               ((SELECT COUNT(*) FROM ledger_event_bank_sources bs
-                 WHERE bs.ledger_event_id = le.id)
-              + (SELECT COUNT(*) FROM ledger_event_manual_sources ms
-                 WHERE ms.ledger_event_id = le.id)) AS evidence_count
-        FROM ledger_events le
-        JOIN current_ledger_event_revisions cur ON cur.ledger_event_id = le.id
-        JOIN ledger_event_revisions r ON r.id = cur.revision_id
-        WHERE le.lifecycle = 'active' AND r.state = 'confirmed';
-
-        CREATE TRIGGER ledger_events_no_delete BEFORE DELETE ON ledger_events
-        BEGIN SELECT RAISE (ABORT, 'ledger_events rows are immutable'); END;
-        CREATE TRIGGER ledger_events_no_update BEFORE UPDATE ON ledger_events
-        BEGIN
-            SELECT RAISE (ABORT, 'ledger_events only allow lifecycle changes')
-            WHERE OLD.lifecycle = NEW.lifecycle
-               OR OLD.id IS NOT NEW.id
-               OR OLD.created_at IS NOT NEW.created_at;
-        END;
-
-        CREATE TRIGGER ledger_event_revisions_no_update BEFORE UPDATE ON ledger_event_revisions
-        BEGIN SELECT RAISE (ABORT, 'ledger_event_revisions rows are immutable'); END;
-        CREATE TRIGGER ledger_event_revisions_no_delete BEFORE DELETE ON ledger_event_revisions
-        BEGIN SELECT RAISE (ABORT, 'ledger_event_revisions rows are immutable'); END;
-
-        CREATE TRIGGER ledger_subject_suggestions_no_update BEFORE UPDATE ON ledger_subject_suggestions
-        BEGIN SELECT RAISE (ABORT, 'ledger_subject_suggestions rows are immutable'); END;
-        CREATE TRIGGER ledger_subject_suggestions_no_delete BEFORE DELETE ON ledger_subject_suggestions
-        BEGIN SELECT RAISE (ABORT, 'ledger_subject_suggestions rows are immutable'); END;
-
-        CREATE TRIGGER manual_records_no_update BEFORE UPDATE ON manual_records
-        BEGIN SELECT RAISE (ABORT, 'manual_records rows are immutable'); END;
-        CREATE TRIGGER manual_records_no_delete BEFORE DELETE ON manual_records
-        BEGIN SELECT RAISE (ABORT, 'manual_records rows are immutable'); END;
-
-        CREATE TRIGGER manual_record_decisions_no_update BEFORE UPDATE ON manual_record_decisions
-        BEGIN SELECT RAISE (ABORT, 'manual_record_decisions rows are immutable'); END;
-        CREATE TRIGGER manual_record_decisions_no_delete BEFORE DELETE ON manual_record_decisions
-        BEGIN SELECT RAISE (ABORT, 'manual_record_decisions rows are immutable'); END;
-        """,
-        down="""
-        DROP VIEW IF EXISTS eligible_position_events;
-        DROP TRIGGER IF EXISTS manual_record_decisions_no_delete;
-        DROP TRIGGER IF EXISTS manual_record_decisions_no_update;
-        DROP TRIGGER IF EXISTS manual_records_no_delete;
-        DROP TRIGGER IF EXISTS manual_records_no_update;
-        DROP TRIGGER IF EXISTS ledger_subject_suggestions_no_delete;
-        DROP TRIGGER IF EXISTS ledger_subject_suggestions_no_update;
-        DROP TRIGGER IF EXISTS ledger_event_revisions_no_delete;
-        DROP TRIGGER IF EXISTS ledger_event_revisions_no_update;
-        DROP TRIGGER IF EXISTS ledger_events_no_update;
-        DROP TRIGGER IF EXISTS ledger_events_no_delete;
-        DROP TABLE IF EXISTS ledger_subject_suggestions;
-        DROP TABLE IF EXISTS ledger_event_manual_sources;
-        DROP TABLE IF EXISTS ledger_event_bank_sources;
-        DROP TABLE IF EXISTS current_ledger_event_revisions;
-        DROP TABLE IF EXISTS ledger_event_revisions;
-        DROP TABLE IF EXISTS ledger_events;
-        DROP TABLE IF EXISTS current_manual_record_decisions;
-        DROP TABLE IF EXISTS manual_record_decisions;
-        DROP TABLE IF EXISTS manual_records;
-        """,
-    ),
-    Migration(
-        version=7,
-        name="0007_system_settings_and_reminders",
-        # System settings (closing day, global start date, auto-reminder) are
-        # persisted as a key/value table with an append-only change history
-        # (operator + before/after) for the audit requirement. Reminders are a
-        # separate append-only table so reminder history survives re-sends.
-        up="""
-        CREATE TABLE system_settings (
-            key TEXT PRIMARY KEY,
-            value TEXT NOT NULL,
-            updated_by INTEGER REFERENCES users (id),
-            updated_at TEXT NOT NULL
-        );
-
-        CREATE TABLE system_setting_changes (
-            id INTEGER PRIMARY KEY AUTOINCREMENT,
-            key TEXT NOT NULL,
-            before_value TEXT,
-            after_value TEXT NOT NULL,
-            actor_user_id INTEGER REFERENCES users (id),
-            actor_username TEXT,
-            created_at TEXT NOT NULL
-        );
-
-        CREATE TABLE reminders (
-            id INTEGER PRIMARY KEY AUTOINCREMENT,
-            company_id INTEGER NOT NULL REFERENCES companies (id),
-            kind TEXT NOT NULL,
-            content TEXT NOT NULL,
-            deadline TEXT,
-            source TEXT NOT NULL CHECK (source IN ('system', 'manual')),
-            status TEXT NOT NULL DEFAULT 'unread'
-                CHECK (status IN ('unread', 'done')),
-            actor_user_id INTEGER REFERENCES users (id),
-            actor_username TEXT,
-            created_at TEXT NOT NULL
-        );
-
-        CREATE INDEX idx_reminders_company ON reminders (company_id);
-        """,
-        down="""
-        DROP INDEX IF EXISTS idx_reminders_company;
-        DROP TABLE IF EXISTS reminders;
-        DROP TABLE IF EXISTS system_setting_changes;
-        DROP TABLE IF EXISTS system_settings;
-        """,
-    ),
 )
 
 

src/bank_importer/importing.py

@@ -25,7 +25,6 @@ import sqlite3
 import tempfile
 
 from . import auth
-from . import ledger_events
 from . import matching
 from .db import utc_now
 from .models import SheetResult, StatementBatch
@@ -649,7 +648,6 @@ def review_sheets(
                 [item["id"] for item in confirmed_rows],
                 actor=actor,
             )
-            ledger_events.reconcile_bank_events(connection, actor=actor)
         if began:
             connection.commit()
     except Exception:

src/bank_importer/ledger_events.py

@@ -1,684 +0,0 @@
-"""Canonical intercompany ledger events and the revision chain (B-44).
-
-Bank source rows and approved manual records are immutable evidence. This
-module turns them into one canonical ledger event each through ``reconcile_*``
-functions and an append-only revision chain. Corrections are never in-place
-edits: a reversal or adjustment is a new ledger event with its own effective
-date, and the original event keeps its history so no earlier cutoff is
-rewritten. Current revisions and source claims are rebuildable projections.
-
-Only B-43 ``eligible_intercompany_events`` feeds bank facts here; same-company
-transfers, external transactions, unresolved rows and unlocked single
-observations never reach the confirmed balance.
-"""
-
-from __future__ import annotations
-
-from decimal import Decimal, InvalidOperation
-import json
-import sqlite3
-
-from .db import utc_now
-from .subjects import MIRROR, SUBJECTS, mirror_subject
-
-
-class LedgerConflictError(ValueError):
-    """A revision/claim/idempotency conflict (mapped to HTTP 409)."""
-
-
-class LedgerInputError(ValueError):
-    """Invalid input for a ledger operation (mapped to HTTP 400/422)."""
-
-
-SUBJECT_RULE_VERSION = "subject-suggest-draft-v1"
-
-
-def amount_scale(amount: object) -> int:
-    """Decimal places of a decimal-string amount, never negative."""
-    try:
-        exponent = Decimal(str(amount)).as_tuple().exponent
-    except InvalidOperation:
-        return 0
-    return max(0, -int(exponent))
-
-
-def parse_amount(amount: object) -> Decimal:
-    """Parse a positive, valid decimal-string amount."""
-    try:
-        value = Decimal(str(amount))
-    except InvalidOperation:
-        raise LedgerInputError("金额不是有效的十进制数。") from None
-    if not value.is_finite() or value <= 0:
-        raise LedgerInputError("金额必须大于零。")
-    return value
-
-
-def _company_exists(connection: sqlite3.Connection, company_id: int, label: str) -> None:
-    row = connection.execute(
-        "SELECT id FROM companies WHERE id = ?", (company_id,)
-    ).fetchone()
-    if row is None:
-        raise LedgerInputError(f"{label}指向的公司不存在。")
-
-
-# ---------------------------------------------------------------------------
-# Revision helpers
-# ---------------------------------------------------------------------------
-
-
-def _ensure_transaction(connection: sqlite3.Connection) -> bool:
-    """Begin an immediate transaction unless one is already open.
-
-    Write helpers may run standalone (they own the transaction) or nested
-    inside a caller's transaction (e.g. the sheet-confirm flow); nested calls
-    never start their own commit.
-    """
-    began = False
-    if not connection.in_transaction:
-        connection.execute("BEGIN IMMEDIATE")
-        began = True
-    return began
-
-
-def current_revision(connection: sqlite3.Connection, ledger_event_id: int) -> sqlite3.Row | None:
-    return connection.execute(
-        """
-        SELECT r.* FROM current_ledger_event_revisions c
-        JOIN ledger_event_revisions r ON r.id = c.revision_id
-        WHERE c.ledger_event_id = ?
-        """,
-        (ledger_event_id,),
-    ).fetchone()
-
-
-def _event_lifecycle(connection: sqlite3.Connection, ledger_event_id: int) -> str | None:
-    row = connection.execute(
-        "SELECT lifecycle FROM ledger_events WHERE id = ?", (ledger_event_id,)
-    ).fetchone()
-    return row["lifecycle"] if row is not None else None
-
-
-def _next_revision_number(connection: sqlite3.Connection, ledger_event_id: int) -> int:
-    row = connection.execute(
-        "SELECT COALESCE(MAX(revision), 0) AS m FROM ledger_event_revisions WHERE ledger_event_id = ?",
-        (ledger_event_id,),
-    ).fetchone()
-    return int(row["m"]) + 1
-
-
-def create_event(
-    connection: sqlite3.Connection,
-    *,
-    state: str,
-    effective_at: str,
-    amount: str,
-    currency: str,
-    payer_company_id: int,
-    payee_company_id: int,
-    perspective_company_id: int | None,
-    subject_code: str | None,
-    source_kind: str,
-    source_revision_token: str | None,
-    posting_kind: str,
-    reverses_ledger_event_id: int | None = None,
-    adjusts_ledger_event_id: int | None = None,
-    rule_version: str | None = None,
-    evidence_json: str | None = None,
-    idempotency_key: str | None = None,
-    actor: sqlite3.Row | None = None,
-    reason: str | None = None,
-    supersedes_revision_id: int | None = None,
-) -> tuple[int, int]:
-    """Insert a new ledger event with one revision. Returns ``(event_id, revision_id)``."""
-    if state == "confirmed":
-        if perspective_company_id is None or subject_code is None:
-            raise LedgerInputError("已确认事件必须提供视角公司与科目。")
-        if subject_code not in SUBJECTS:
-            raise LedgerInputError("科目必须是应收/应付/其他应收/其他应付之一。")
-    if int(payer_company_id) == int(payee_company_id):
-        raise LedgerInputError("付款公司与收款公司不能相同。")
-    if perspective_company_id is not None and perspective_company_id not in (
-        int(payer_company_id), int(payee_company_id),
-    ):
-        raise LedgerInputError("视角公司必须是事件参与方。")
-    began = _ensure_transaction(connection)
-    try:
-        now = utc_now()
-        cursor = connection.execute(
-            "INSERT INTO ledger_events (lifecycle, created_at) VALUES ('active', ?)",
-            (now,),
-        )
-        event_id = int(cursor.lastrowid)
-        revision_id = append_revision(
-            connection,
-            event_id,
-            state=state,
-            effective_at=effective_at,
-            amount=amount,
-            currency=currency,
-            payer_company_id=payer_company_id,
-            payee_company_id=payee_company_id,
-            perspective_company_id=perspective_company_id,
-            subject_code=subject_code,
-            source_kind=source_kind,
-            source_revision_token=source_revision_token,
-            posting_kind=posting_kind,
-            reverses_ledger_event_id=reverses_ledger_event_id,
-            adjusts_ledger_event_id=adjusts_ledger_event_id,
-            rule_version=rule_version,
-            evidence_json=evidence_json,
-            idempotency_key=idempotency_key,
-            actor=actor,
-            reason=reason,
-            supersedes_revision_id=supersedes_revision_id,
-        )
-    except Exception:
-        if began:
-            connection.rollback()
-        raise
-    else:
-        if began:
-            connection.commit()
-        return event_id, revision_id
-
-
-def append_revision(
-    connection: sqlite3.Connection,
-    ledger_event_id: int,
-    *,
-    state: str,
-    effective_at: str,
-    amount: str,
-    currency: str,
-    payer_company_id: int,
-    payee_company_id: int,
-    perspective_company_id: int | None,
-    subject_code: str | None,
-    source_kind: str,
-    source_revision_token: str | None,
-    posting_kind: str,
-    reverses_ledger_event_id: int | None = None,
-    adjusts_ledger_event_id: int | None = None,
-    rule_version: str | None = None,
-    evidence_json: str | None = None,
-    idempotency_key: str | None = None,
-    actor: sqlite3.Row | None = None,
-    reason: str | None = None,
-    supersedes_revision_id: int | None = None,
-) -> int:
-    """Append one immutable revision and repoint the current projection."""
-    if _event_lifecycle(connection, ledger_event_id) != "active":
-        raise LedgerConflictError("该事件已停用，不能追加修订。")
-    if state == "confirmed":
-        if perspective_company_id is None or subject_code is None:
-            raise LedgerInputError("已确认事件必须提供视角公司与科目。")
-        if subject_code not in SUBJECTS:
-            raise LedgerInputError("科目必须是应收/应付/其他应收/其他应付之一。")
-        if perspective_company_id not in (int(payer_company_id), int(payee_company_id)):
-            raise LedgerInputError("视角公司必须是事件参与方。")
-    elif state != "pending_subject":
-        raise LedgerInputError("事件状态必须是 pending_subject 或 confirmed。")
-    revision = _next_revision_number(connection, ledger_event_id)
-    now = utc_now()
-    cursor = connection.execute(
-        """
-        INSERT INTO ledger_event_revisions (
-            ledger_event_id, revision, state, effective_at, amount,
-            amount_scale, currency, payer_company_id, payee_company_id,
-            perspective_company_id, subject_code, source_kind,
-            source_revision_token, posting_kind, reverses_ledger_event_id,
-            adjusts_ledger_event_id, rule_version, evidence_json,
-            idempotency_key, actor_user_id, actor_username, reason,
-            supersedes_revision_id, created_at
-        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-        """,
-        (
-            ledger_event_id, revision, state, effective_at, amount,
-            amount_scale(amount), currency, payer_company_id, payee_company_id,
-            perspective_company_id, subject_code, source_kind,
-            source_revision_token, posting_kind, reverses_ledger_event_id,
-            adjusts_ledger_event_id, rule_version, evidence_json,
-            idempotency_key,
-            actor["id"] if actor is not None else None,
-            actor["username"] if actor is not None else None,
-            reason, supersedes_revision_id, now,
-        ),
-    )
-    connection.execute(
-        """
-        INSERT OR REPLACE INTO current_ledger_event_revisions (ledger_event_id, revision_id)
-        VALUES (?, ?)
-        """,
-        (ledger_event_id, cursor.lastrowid),
-    )
-    return int(cursor.lastrowid)
-
-
-# ---------------------------------------------------------------------------
-# Source claims
-# ---------------------------------------------------------------------------
-
-
-def bank_source_claim(connection: sqlite3.Connection, bank_event_id: int) -> sqlite3.Row | None:
-    return connection.execute(
-        "SELECT * FROM ledger_event_bank_sources WHERE bank_event_id = ?",
-        (bank_event_id,),
-    ).fetchone()
-
-
-def manual_source_claim(connection: sqlite3.Connection, manual_record_id: int) -> sqlite3.Row | None:
-    return connection.execute(
-        "SELECT * FROM ledger_event_manual_sources WHERE manual_record_id = ?",
-        (manual_record_id,),
-    ).fetchone()
-
-
-def _facts_of(connection: sqlite3.Connection, ledger_event_id: int) -> dict[str, object]:
-    revision = current_revision(connection, ledger_event_id)
-    if revision is None:
-        return {}
-    return {
-        "amount": revision["amount"],
-        "currency": revision["currency"],
-        "effective_at": revision["effective_at"],
-        "payer_company_id": revision["payer_company_id"],
-        "payee_company_id": revision["payee_company_id"],
-    }
-
-
-def _eligible_facts(event: sqlite3.Row) -> dict[str, object]:
-    return {
-        "amount": event["amount"],
-        "currency": event["currency"],
-        "effective_at": event["effective_at"],
-        "payer_company_id": event["payer_company_id"],
-        "payee_company_id": event["payee_company_id"],
-    }
-
-
-def _has_reversal(connection: sqlite3.Connection, original_event_id: int) -> bool:
-    row = connection.execute(
-        """
-        SELECT 1 FROM ledger_event_revisions r
-        JOIN current_ledger_event_revisions c ON c.revision_id = r.id
-        WHERE r.reverses_ledger_event_id = ? AND r.posting_kind = 'reversal'
-        LIMIT 1
-        """,
-        (original_event_id,),
-    ).fetchone()
-    return row is not None
-
-
-def create_reversal(
-    connection: sqlite3.Connection,
-    original_event_id: int,
-    *,
-    source_kind: str,
-    source_revision_token: str | None = None,
-    effective_at: str | None = None,
-    reason: str,
-    actor: sqlite3.Row | None,
-    idempotency_key: str | None = None,
-    rule_version: str | None = None,
-) -> tuple[int, int]:
-    """Create an equal-amount, opposite-direction reversal as a new ledger event.
-
-    The subject mirrors the original (应收<->应付, 其他应收<->其他应付). ``effective_at``
-    defaults to the original event's effective date so an earlier cutoff keeps
-    the original impact and later cutoffs see the net zero. The original event
-    is never modified or deleted.
-    """
-    original = current_revision(connection, original_event_id)
-    if original is None:
-        raise LedgerConflictError("原事件不存在或没有当前修订。")
-    if original["state"] != "confirmed":
-        raise LedgerInputError("只有已确认事件才能生成冲销。")
-    perspective = mirror_perspective(original)
-    if effective_at is None:
-        effective_at = original["effective_at"]
-    return create_event(
-        connection,
-        state="confirmed",
-        effective_at=effective_at,
-        amount=original["amount"],
-        currency=original["currency"],
-        payer_company_id=original["payee_company_id"],
-        payee_company_id=original["payer_company_id"],
-        perspective_company_id=perspective,
-        subject_code=mirror_subject(original["subject_code"]),
-        source_kind=source_kind,
-        source_revision_token=source_revision_token,
-        posting_kind="reversal",
-        reverses_ledger_event_id=original_event_id,
-        rule_version=rule_version or original["rule_version"],
-        idempotency_key=idempotency_key,
-        actor=actor,
-        reason=reason,
-    )
-
-
-def mirror_perspective(revision: sqlite3.Row) -> int:
-    """The counterparty company from ``revision``'s perspective."""
-    perspective = int(revision["perspective_company_id"])
-    if perspective == int(revision["payer_company_id"]):
-        return int(revision["payee_company_id"])
-    return int(revision["payer_company_id"])
-
-
-def create_adjustment(
-    connection: sqlite3.Connection,
-    ledger_event_id: int,
-    *,
-    effective_at: str,
-    amount: str,
-    currency: str,
-    payer_company_id: int,
-    payee_company_id: int,
-    perspective_company_id: int,
-    subject_code: str,
-    reason: str,
-    actor: sqlite3.Row,
-    idempotency_key: str | None = None,
-    rule_version: str | None = None,
-) -> tuple[int, int]:
-    """Create an audit adjustment event; the original event stays unchanged."""
-    return create_event(
-        connection,
-        state="confirmed",
-        effective_at=effective_at,
-        amount=str(parse_amount(amount)),
-        currency=currency,
-        payer_company_id=payer_company_id,
-        payee_company_id=payee_company_id,
-        perspective_company_id=perspective_company_id,
-        subject_code=subject_code,
-        source_kind="adjustment",
-        source_revision_token=None,
-        posting_kind="adjustment",
-        adjusts_ledger_event_id=ledger_event_id,
-        rule_version=rule_version or SUBJECT_RULE_VERSION,
-        idempotency_key=idempotency_key,
-        actor=actor,
-        reason=reason,
-    )
-
-
-def reopen_subject(
-    connection: sqlite3.Connection,
-    ledger_event_id: int,
-    *,
-    reason: str,
-    actor: sqlite3.Row,
-    idempotency_key: str | None = None,
-) -> tuple[int, int]:
-    """Reverse a confirmed event and re-open it for subject re-review.
-
-    Creates an equal-amount reversal plus a fresh ``pending_subject`` event
-    that re-claims the original bank source, so the administrator can confirm
-    a corrected subject. The original event and its reversal keep history.
-    """
-    current = current_revision(connection, ledger_event_id)
-    if current is None or current["state"] != "confirmed":
-        raise LedgerConflictError("只有已确认事件可以重新进入科目审核。")
-    bank_claim = connection.execute(
-        "SELECT * FROM ledger_event_bank_sources WHERE ledger_event_id = ?",
-        (ledger_event_id,),
-    ).fetchone()
-    if bank_claim is None:
-        raise LedgerInputError(
-            "该事件没有银行来源，无法重新进入科目审核；请改用调整或冲销。"
-        )
-    if not _has_reversal(connection, ledger_event_id):
-        create_reversal(
-            connection, ledger_event_id,
-            source_kind=current["source_kind"],
-            source_revision_token=current["source_revision_token"],
-            reason="科目复核：原确认事件冲销",
-            actor=actor,
-            idempotency_key=(idempotency_key + ":rev" if idempotency_key else None),
-            rule_version=current["rule_version"],
-        )
-    ev = connection.execute(
-        "SELECT * FROM eligible_intercompany_events WHERE event_id = ?",
-        (bank_claim["bank_event_id"],),
-    ).fetchone()
-    if ev is None:
-        raise LedgerInputError("银行事件已不再纳入往来，无法重新入账。")
-    event_id, revision_id = _create_bank_event(
-        connection, ev, actor, reason="科目复核后重新入账，待确认科目",
-        replacing_claim=bank_claim,
-    )
-    return event_id, revision_id
-
-
-# ---------------------------------------------------------------------------
-# Bank event reconciliation
-# ---------------------------------------------------------------------------
-
-
-def reconcile_bank_events(
-    connection: sqlite3.Connection, actor: sqlite3.Row | None = None
-) -> dict[str, object]:
-    """Reconcile the current eligible intercompany events into ledger events.
-
-    Idempotent: first sight creates a ``pending_subject`` event; a changed B-43
-    decision updates a still-pending event's revision, or (for a confirmed
-    event) creates a reversal plus a fresh pending event. A source that left
-    the eligible set with a confirmed impact gets one reversal. Runs inside the
-    caller's transaction when one is open, otherwise in its own transaction.
-    """
-    began = _ensure_transaction(connection)
-    try:
-        eligible = {
-            row["event_id"]: row
-            for row in connection.execute(
-                "SELECT * FROM eligible_intercompany_events"
-            ).fetchall()
-        }
-        claims = {
-            row["bank_event_id"]: row
-            for row in connection.execute(
-                "SELECT * FROM ledger_event_bank_sources"
-            ).fetchall()
-        }
-        stats = {
-            "created": 0, "updated_pending": 0, "reversal": 0,
-            "reopened": 0, "unchanged": 0, "sources": len(eligible),
-        }
-        for bank_event_id, event in sorted(eligible.items()):
-            claim = claims.get(bank_event_id)
-            if claim is None:
-                _create_bank_event(
-                    connection, event, actor, reason="B-43 事件首次入账，待确认科目"
-                )
-                stats["created"] += 1
-                continue
-            current = current_revision(connection, claim["ledger_event_id"])
-            if current is None or _facts_of(connection, claim["ledger_event_id"]) != _eligible_facts(event):
-                if current is not None and current["state"] == "confirmed":
-                    if not _has_reversal(connection, claim["ledger_event_id"]):
-                        create_reversal(
-                            connection, claim["ledger_event_id"],
-                            source_kind="bank",
-                            source_revision_token=event["decision_id"],
-                            reason="B-43 事件事实变更，原确认事件冲销",
-                            actor=actor,
-                        )
-                        stats["reversal"] += 1
-                    _create_bank_event(
-                        connection, event, actor,
-                        reason="B-43 事件事实变更后重新入账，待确认科目",
-                        replacing_claim=claim,
-                    )
-                    stats["reopened"] += 1
-                elif current is None or current["state"] == "pending_subject":
-                    _append_bank_pending_revision(
-                        connection, claim["ledger_event_id"], event, actor
-                    )
-                    stats["updated_pending"] += 1
-                else:
-                    stats["unchanged"] += 1
-            else:
-                stats["unchanged"] += 1
-
-        for bank_event_id, claim in sorted(claims.items()):
-            if bank_event_id in eligible:
-                continue
-            current = current_revision(connection, claim["ledger_event_id"])
-            if current is not None and current["state"] == "confirmed":
-                if not _has_reversal(connection, claim["ledger_event_id"]):
-                    create_reversal(
-                        connection, claim["ledger_event_id"],
-                        source_kind="bank",
-                        source_revision_token=None,
-                        reason="B-43 事件不再纳入往来，原确认事件冲销",
-                        actor=actor,
-                    )
-                    stats["reversal"] += 1
-    except Exception:
-        if began:
-            connection.rollback()
-        raise
-    else:
-        if began:
-            connection.commit()
-        return stats
-
-
-def _create_bank_event(
-    connection: sqlite3.Connection,
-    event: sqlite3.Row,
-    actor: sqlite3.Row | None,
-    *,
-    reason: str,
-    replacing_claim: sqlite3.Row | None = None,
-) -> tuple[int, int]:
-    event_id, revision_id = create_event(
-        connection,
-        state="pending_subject",
-        effective_at=event["effective_at"],
-        amount=event["amount"],
-        currency=event["currency"],
-        payer_company_id=event["payer_company_id"],
-        payee_company_id=event["payee_company_id"],
-        perspective_company_id=None,
-        subject_code=None,
-        source_kind="bank",
-        source_revision_token=event["decision_id"],
-        posting_kind="normal",
-        rule_version=SUBJECT_RULE_VERSION,
-        evidence_json=json.dumps(
-            {
-                "bank_event_id": event["event_id"],
-                "decision_id": event["decision_id"],
-                "pairing": event["pairing"],
-                "evidence_count": event["evidence_count"],
-            },
-            ensure_ascii=False,
-        ),
-        actor=actor,
-        reason=reason,
-    )
-    if replacing_claim is not None:
-        connection.execute(
-            """
-            UPDATE ledger_event_bank_sources SET ledger_event_id = ?
-            WHERE bank_event_id = ?
-            """,
-            (event_id, event["event_id"]),
-        )
-    else:
-        connection.execute(
-            """
-            INSERT INTO ledger_event_bank_sources (bank_event_id, ledger_event_id)
-            VALUES (?, ?)
-            """,
-            (event["event_id"], event_id),
-        )
-    from .subjects import store_suggestions
-
-    store_suggestions(connection, event_id)
-    return event_id, revision_id
-
-
-def _append_bank_pending_revision(
-    connection: sqlite3.Connection,
-    ledger_event_id: int,
-    event: sqlite3.Row,
-    actor: sqlite3.Row | None,
-) -> int:
-    current = current_revision(connection, ledger_event_id)
-    revision_id = append_revision(
-        connection,
-        ledger_event_id,
-        state="pending_subject",
-        effective_at=event["effective_at"],
-        amount=event["amount"],
-        currency=event["currency"],
-        payer_company_id=event["payer_company_id"],
-        payee_company_id=event["payee_company_id"],
-        perspective_company_id=None,
-        subject_code=None,
-        source_kind="bank",
-        source_revision_token=event["decision_id"],
-        posting_kind="normal",
-        rule_version=SUBJECT_RULE_VERSION,
-        evidence_json=json.dumps(
-            {
-                "bank_event_id": event["event_id"],
-                "decision_id": event["decision_id"],
-                "pairing": event["pairing"],
-                "evidence_count": event["evidence_count"],
-            },
-            ensure_ascii=False,
-        ),
-        actor=actor,
-        reason="B-43 事件事实更新，追加待审修订",
-        supersedes_revision_id=current["id"] if current is not None else None,
-    )
-    from .subjects import store_suggestions
-
-    store_suggestions(connection, ledger_event_id)
-    return revision_id
-
-
-# ---------------------------------------------------------------------------
-# Projection rebuild
-# ---------------------------------------------------------------------------
-
-
-def rebuild_current_ledger_projection(connection: sqlite3.Connection) -> int:
-    """Rebuild current ledger revisions from the append-only log."""
-    began = _ensure_transaction(connection)
-    try:
-        connection.execute("DELETE FROM current_ledger_event_revisions")
-        rows = connection.execute(
-            """
-            SELECT e.id AS ledger_event_id,
-                   (SELECT r2.id FROM ledger_event_revisions r2
-                     WHERE r2.ledger_event_id = e.id
-                     ORDER BY r2.revision DESC LIMIT 1) AS latest_id
-            FROM ledger_events e
-            WHERE e.lifecycle = 'active'
-            """,
-        ).fetchall()
-        rebuilt = 0
-        for row in rows:
-            if row["latest_id"] is None:
-                continue
-            connection.execute(
-                """
-                INSERT OR REPLACE INTO current_ledger_event_revisions (ledger_event_id, revision_id)
-                VALUES (?, ?)
-                """,
-                (row["ledger_event_id"], row["latest_id"]),
-            )
-            rebuilt += 1
-    except Exception:
-        if began:
-            connection.rollback()
-        raise
-    else:
-        if began:
-            connection.commit()
-        return rebuilt

src/bank_importer/manual_records.py

@@ -1,818 +0,0 @@
-"""Manual evidence records, administrator approval and audit-safe reversal.
-
-Manual records are immutable submitted facts. Only an approved record becomes
-a canonical ledger event (``approve_new``) or joins one (``approve_link``);
-returned/exception/pending records never affect a balance and never leak to
-the counterparty. Approved facts change only through a ``reverse`` decision
-that creates an opposite new event (or detaches a linked claim) — the original
-is never edited. Idempotency keys and UNIQUE claims prevent double counting.
-"""
-
-from __future__ import annotations
-
-from datetime import datetime, timedelta, timezone
-from decimal import Decimal, InvalidOperation
-import json
-import sqlite3
-
-from .db import utc_now
-from .ledger_events import (
-    LedgerConflictError,
-    LedgerInputError,
-    create_event,
-    create_reversal,
-    current_revision,
-    manual_source_claim,
-)
-from .subjects import SUBJECTS
-
-MANUAL_STATES = ("pending", "approved", "returned", "exception", "reversed")
-FUNDING_SOURCES = ("approved_bank_account", "personal_transit", "other")
-DATE_KEYS = ("occurred_at",)
-
-
-class ManualConflictError(ValueError):
-    """A claim/idempotency/revision conflict (mapped to HTTP 409)."""
-
-
-class ManualInputError(ValueError):
-    """Invalid manual record input (mapped to HTTP 400/422)."""
-
-
-def _parse_amount(amount: object) -> Decimal:
-    try:
-        value = Decimal(str(amount))
-    except InvalidOperation:
-        raise ManualInputError("金额不是有效的十进制数。") from None
-    if not value.is_finite() or value <= 0:
-        raise ManualInputError("金额必须大于零。")
-    return value
-
-
-def _validate_date(value: object, field: str) -> str:
-    text = str(value or "").strip()
-    if len(text) < 10:
-        raise ManualInputError(f"{field}必须是 YYYY-MM-DD 或完整时间。")
-    try:
-        datetime.fromisoformat(text[:10])
-    except ValueError:
-        raise ManualInputError(f"{field}必须是 YYYY-MM-DD 或完整时间。") from None
-    return text
-
-
-def _business_today() -> str:
-    """Shanghai business date (the default reversal effective date)."""
-    return datetime.now(timezone(timedelta(hours=8))).date().isoformat()
-
-
-# ---------------------------------------------------------------------------
-# Submit
-# ---------------------------------------------------------------------------
-
-
-def submit(
-    connection: sqlite3.Connection,
-    *,
-    company_id: int,
-    counterparty_company_id: int,
-    occurred_at: str,
-    direction: str,
-    amount: str,
-    currency: str,
-    funding_source: str,
-    requested_subject: str,
-    request_key: str,
-    actor: sqlite3.Row,
-    bank_account_id: object = None,
-    personal_transit_mapping_id: object = None,
-    related_source_row_id: object = None,
-    summary: object = None,
-    reason: object = None,
-    evidence: object = None,
-    supersedes_record_id: object = None,
-) -> dict[str, object]:
-    """Submit one manual record for review. Idempotent on ``(company_id, request_key)``."""
-    request_key = str(request_key or "").strip()
-    if not request_key:
-        raise ManualInputError("必须提供提交幂等键 request_key。")
-    if int(company_id) == int(counterparty_company_id):
-        raise ManualInputError("对方公司不能与本公司相同。")
-    if direction not in ("outgoing", "incoming"):
-        raise ManualInputError("方向必须是 outgoing 或 incoming。")
-    if funding_source not in FUNDING_SOURCES:
-        raise ManualInputError(f"资金来源必须是：{'、'.join(FUNDING_SOURCES)}。")
-    if requested_subject not in SUBJECTS:
-        raise ManualInputError("科目必须是应收/应付/其他应收/其他应付之一。")
-    _validate_date(occurred_at, "业务日期")
-    currency = str(currency or "").strip()
-    if not currency:
-        raise ManualInputError("币种不能为空。")
-    amount = str(_parse_amount(amount))
-
-    for label, raw in (
-        ("company_id", company_id), ("counterparty_company_id", counterparty_company_id),
-    ):
-        row = connection.execute("SELECT id FROM companies WHERE id = ?", (int(raw),)).fetchone()
-        if row is None:
-            raise ManualInputError(f"{label} 指向的公司不存在。")
-
-    bank_account_id = _resolve_account_ref(
-        connection, bank_account_id, company_id, "银行账户"
-    )
-    mapping_id = _resolve_account_ref(
-        connection, personal_transit_mapping_id, company_id, "个人过账映射"
-    )
-    related_row = None
-    if related_source_row_id not in (None, ""):
-        related_row = connection.execute(
-            "SELECT r.id, b.company_id FROM source_rows r "
-            "JOIN sheet_batches s ON s.id = r.sheet_batch_id "
-            "JOIN import_batches b ON b.id = s.import_batch_id "
-            "WHERE r.id = ?",
-            (int(related_source_row_id),),
-        ).fetchone()
-        if related_row is None:
-            raise ManualInputError("关联银行源行不存在。")
-
-    if funding_source == "approved_bank_account" and bank_account_id is None:
-        raise ManualInputError("资金来源为已批准账户时必须指定银行账户。")
-    if funding_source == "personal_transit" and mapping_id is None:
-        raise ManualInputError("资金来源为个人过账时必须指定个人过账映射。")
-
-    supersedes_id = None
-    if supersedes_record_id not in (None, ""):
-        parent = connection.execute(
-            "SELECT id, company_id FROM manual_records WHERE id = ?",
-            (int(supersedes_record_id),),
-        ).fetchone()
-        if parent is None or parent["company_id"] != int(company_id):
-            raise ManualInputError("supersedes_record_id 无效。")
-        supersedes_id = int(supersedes_record_id)
-
-    now = utc_now()
-    began = False
-    if not connection.in_transaction:
-        connection.execute("BEGIN IMMEDIATE")
-        began = True
-    try:
-        # Re-check inside the write transaction: concurrent identical submits
-        # serialize here, so a replay is found before any INSERT.
-        existing = connection.execute(
-            "SELECT id FROM manual_records WHERE company_id = ? AND request_key = ?",
-            (int(company_id), request_key),
-        ).fetchone()
-        if existing is not None:
-            if began:
-                connection.commit()
-            return _record_payload(connection, existing["id"], idempotent_replay=True)
-        try:
-            cursor = connection.execute(
-                """
-                INSERT INTO manual_records (
-                    company_id, counterparty_company_id, occurred_at, direction,
-                    amount, amount_scale, currency, funding_source, bank_account_id,
-                    personal_transit_mapping_id, related_source_row_id,
-                    requested_subject, summary, reason, evidence_json, request_key,
-                    supersedes_record_id, submitted_by, created_at
-                ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-                """,
-                (
-                    int(company_id), int(counterparty_company_id), occurred_at, direction,
-                    amount, _scale_of(amount), currency, funding_source, bank_account_id,
-                    mapping_id, related_row["id"] if related_row is not None else None,
-                    requested_subject, str(summary or "") or None,
-                    str(reason or "") or None,
-                    json.dumps(evidence, ensure_ascii=False) if evidence else None,
-                    request_key, supersedes_id,
-                    actor["id"], now,
-                ),
-            )
-        except sqlite3.IntegrityError:
-            # A concurrent identical submit won the race and committed first;
-            # surface the existing record idempotently instead of a UNIQUE 500.
-            if began:
-                connection.rollback()
-            existing = connection.execute(
-                "SELECT id FROM manual_records WHERE company_id = ? AND request_key = ?",
-                (int(company_id), request_key),
-            ).fetchone()
-            if existing is not None:
-                return _record_payload(connection, existing["id"], idempotent_replay=True)
-            raise
-        record_id = int(cursor.lastrowid)
-        _append_decision(
-            connection, record_id, state="pending", action="submit",
-            reason=str(reason or "") or None, actor=actor,
-        )
-    except Exception:
-        if began:
-            connection.rollback()
-        raise
-    else:
-        if began:
-            connection.commit()
-        return _record_payload(connection, record_id)
-
-
-def _resolve_account_ref(connection, raw, company_id: int, label: str) -> int | None:
-    if raw in (None, ""):
-        return None
-    row = connection.execute(
-        "SELECT id, company_id FROM bank_accounts WHERE id = ?", (int(raw),)
-    ).fetchone()
-    if row is None:
-        raise ManualInputError(f"{label}不存在。")
-    if row["company_id"] != int(company_id):
-        raise ManualInputError(f"{label}必须属于提交公司。")
-    return int(raw)
-
-
-def _scale_of(amount: str) -> int:
-    exponent = Decimal(amount).as_tuple().exponent
-    return max(0, -int(exponent))
-
-
-# ---------------------------------------------------------------------------
-# Decisions
-# ---------------------------------------------------------------------------
-
-
-def _append_decision(
-    connection: sqlite3.Connection,
-    record_id: int,
-    *,
-    state: str,
-    action: str,
-    reason: str | None,
-    actor: sqlite3.Row,
-    idempotency_key: str | None = None,
-    supersedes_decision_id: int | None = None,
-) -> int:
-    row = connection.execute(
-        "SELECT COALESCE(MAX(revision), 0) AS m FROM manual_record_decisions WHERE record_id = ?",
-        (record_id,),
-    ).fetchone()
-    revision = int(row["m"]) + 1
-    now = utc_now()
-    cursor = connection.execute(
-        """
-        INSERT INTO manual_record_decisions (
-            record_id, revision, state, action, reason, actor_user_id,
-            actor_username, idempotency_key, supersedes_decision_id, created_at
-        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-        """,
-        (
-            record_id, revision, state, action, reason,
-            actor["id"], actor["username"], idempotency_key,
-            supersedes_decision_id, now,
-        ),
-    )
-    decision_id = int(cursor.lastrowid)
-    connection.execute(
-        """
-        INSERT OR REPLACE INTO current_manual_record_decisions (record_id, decision_id)
-        VALUES (?, ?)
-        """,
-        (record_id, decision_id),
-    )
-    return decision_id
-
-
-def _current_decision(connection: sqlite3.Connection, record_id: int) -> sqlite3.Row | None:
-    return connection.execute(
-        """
-        SELECT d.* FROM current_manual_record_decisions c
-        JOIN manual_record_decisions d ON d.id = c.decision_id
-        WHERE c.record_id = ?
-        """,
-        (record_id,),
-    ).fetchone()
-
-
-def decide(
-    connection: sqlite3.Connection,
-    record_id: int,
-    action: str,
-    *,
-    reason: str,
-    expected_decision_id: int | None,
-    request_key: str | None,
-    actor: sqlite3.Row,
-    subject_code: object = None,
-    target_ledger_event_id: object = None,
-    effective_at: object = None,
-) -> dict[str, object]:
-    """Apply an administrator decision to a manual record.
-
-    ``approve_new`` creates a confirmed ledger event; ``approve_link`` joins an
-    existing ledger event without adding a second economic impact; ``return``
-    and ``exception`` never produce a balance; ``reverse`` creates an opposite
-    reversal event (or detaches a linked claim) with an independent business
-    effective date — explicit ``effective_at`` or the approval business day.
-    Replays return the earlier outcome via ``idempotency_key``.
-    """
-    reason = (reason or "").strip()
-    if not reason:
-        raise ManualInputError("必须填写审核原因。")
-    if action not in ("approve_new", "approve_link", "return", "exception", "reverse"):
-        raise ManualInputError("未知的审核决定类型。")
-
-    began = False
-    if not connection.in_transaction:
-        connection.execute("BEGIN IMMEDIATE")
-        began = True
-    try:
-        record = connection.execute(
-            "SELECT * FROM manual_records WHERE id = ?", (record_id,)
-        ).fetchone()
-        if record is None:
-            raise ManualConflictError("手工记录不存在。")
-        if request_key:
-            existing = connection.execute(
-                "SELECT * FROM manual_record_decisions WHERE record_id = ? AND idempotency_key = ?",
-                (record_id, request_key),
-            ).fetchone()
-            if existing is not None:
-                if began:
-                    connection.commit()
-                return _decision_payload(connection, record_id, existing["id"])
-
-        current = _current_decision(connection, record_id)
-        if current is None:
-            raise ManualConflictError("该记录没有当前状态。")
-        if expected_decision_id is not None and int(expected_decision_id) != current["id"]:
-            raise ManualConflictError("记录已发生变更，请刷新后重试。")
-
-        if action == "approve_new":
-            outcome = _approve_new(
-                connection, record, current, actor, subject_code, reason, request_key
-            )
-        elif action == "approve_link":
-            outcome = _approve_link(
-                connection, record, current, actor, target_ledger_event_id, reason,
-                request_key,
-            )
-        elif action == "return":
-            if current["state"] != "pending":
-                raise ManualConflictError("只有待复核的记录可以退回。")
-            decision_id = _append_decision(
-                connection, record_id, state="returned", action=action,
-                reason=reason, actor=actor, idempotency_key=request_key,
-                supersedes_decision_id=current["id"],
-            )
-            outcome = {"decision_id": decision_id, "ledger_event_id": None}
-        elif action == "exception":
-            if current["state"] != "pending":
-                raise ManualConflictError("只有待复核的记录可以转为异常。")
-            decision_id = _append_decision(
-                connection, record_id, state="exception", action=action,
-                reason=reason, actor=actor, idempotency_key=request_key,
-                supersedes_decision_id=current["id"],
-            )
-            outcome = {"decision_id": decision_id, "ledger_event_id": None}
-        else:  # reverse
-            if current["state"] != "approved":
-                raise ManualConflictError("只有已批准记录可以冲销。")
-            outcome = _reverse(
-                connection, record, current, actor, request_key, reason,
-                effective_at=effective_at,
-            )
-
-        _store_audit(connection, record, current, action, outcome, reason, actor)
-    except Exception:
-        if began:
-            connection.rollback()
-        raise
-    else:
-        if began:
-            connection.commit()
-        return _decision_payload(connection, record_id, outcome["decision_id"])
-
-
-def _approve_new(
-    connection: sqlite3.Connection,
-    record: sqlite3.Row,
-    current: sqlite3.Row,
-    actor: sqlite3.Row,
-    subject_code: object,
-    reason: str,
-    idempotency_key: str | None,
-) -> dict[str, object]:
-    subject = str(subject_code or record["requested_subject"] or "")
-    if subject not in SUBJECTS:
-        raise ManualInputError("科目必须是应收/应付/其他应收/其他应付之一。")
-    if record["direction"] == "outgoing":
-        payer, payee = record["company_id"], record["counterparty_company_id"]
-    else:
-        payer, payee = record["counterparty_company_id"], record["company_id"]
-    event_id, _revision_id = create_event(
-        connection,
-        state="confirmed",
-        effective_at=record["occurred_at"],
-        amount=record["amount"],
-        currency=record["currency"],
-        payer_company_id=payer,
-        payee_company_id=payee,
-        perspective_company_id=record["company_id"],
-        subject_code=subject,
-        source_kind="manual",
-        source_revision_token=None,
-        posting_kind="normal",
-        rule_version="manual-record-v1",
-        evidence_json=json.dumps({"manual_record_id": record["id"]}, ensure_ascii=False),
-        actor=actor,
-        reason=reason,
-    )
-    decision_id = _append_decision(
-        connection, record["id"], state="approved", action="approve_new",
-        reason=reason, actor=actor,
-        idempotency_key=idempotency_key,
-        supersedes_decision_id=current["id"],
-    )
-    connection.execute(
-        """
-        INSERT INTO ledger_event_manual_sources (manual_record_id, ledger_event_id)
-        VALUES (?, ?)
-        """,
-        (record["id"], event_id),
-    )
-    return {"decision_id": decision_id, "ledger_event_id": event_id}
-
-
-def _approve_link(
-    connection: sqlite3.Connection,
-    record: sqlite3.Row,
-    current: sqlite3.Row,
-    actor: sqlite3.Row,
-    target_ledger_event_id: object,
-    reason: str,
-    idempotency_key: str | None,
-) -> dict[str, object]:
-    if target_ledger_event_id in (None, ""):
-        raise ManualInputError("approve_link 必须指定目标往来事件。")
-    target = connection.execute(
-        "SELECT id, lifecycle FROM ledger_events WHERE id = ?",
-        (int(target_ledger_event_id),),
-    ).fetchone()
-    if target is None or target["lifecycle"] != "active":
-        raise ManualConflictError("目标往来事件不存在。")
-    if manual_source_claim(connection, record["id"]) is not None:
-        raise ManualConflictError("该手工记录已关联往来事件。")
-    decision_id = _append_decision(
-        connection, record["id"], state="approved", action="approve_link",
-        reason=reason, actor=actor,
-        idempotency_key=idempotency_key,
-        supersedes_decision_id=current["id"],
-    )
-    connection.execute(
-        """
-        INSERT INTO ledger_event_manual_sources (manual_record_id, ledger_event_id)
-        VALUES (?, ?)
-        """,
-        (record["id"], int(target_ledger_event_id)),
-    )
-    return {"decision_id": decision_id, "ledger_event_id": int(target_ledger_event_id)}
-
-
-def _reverse(
-    connection: sqlite3.Connection,
-    record: sqlite3.Row,
-    current: sqlite3.Row,
-    actor: sqlite3.Row,
-    request_key: str | None,
-    reason: str,
-    effective_at: object = None,
-) -> dict[str, object]:
-    claim = manual_source_claim(connection, record["id"])
-    if claim is None:
-        raise ManualConflictError("该记录尚未关联往来事件，无法冲销。")
-    event_id = claim["ledger_event_id"]
-    revision = current_revision(connection, event_id)
-    if revision is None:
-        raise ManualConflictError("关联的往来事件没有当前修订。")
-
-    if _is_manual_creation_source(revision, record["id"]):
-        # This record created the event (approve_new): it added the economic
-        # impact, so reversing it must always produce an equal-amount reversal
-        # event — even when other manual evidence was later linked onto the
-        # same event. The original impact must not survive in balances.
-        if effective_at is not None and str(effective_at).strip():
-            effective_at = _validate_date(effective_at, "冲销生效日")
-        else:
-            effective_at = _business_today()
-        create_reversal(
-            connection,
-            event_id,
-            source_kind="manual",
-            source_revision_token=str(record["id"]),
-            effective_at=effective_at,
-            reason=reason,
-            actor=actor,
-            idempotency_key=request_key,
-            rule_version="manual-record-v1",
-        )
-    else:
-        # The manual was linked evidence (approve_link) on an event it never
-        # created: it added no second impact, so reversing detaches the claim
-        # and the underlying economic impact stays.
-        connection.execute(
-            "DELETE FROM ledger_event_manual_sources WHERE manual_record_id = ?",
-            (record["id"],),
-        )
-    decision_id = _append_decision(
-        connection, record["id"], state="reversed", action="reverse",
-        reason=reason, actor=actor, idempotency_key=request_key,
-        supersedes_decision_id=current["id"],
-    )
-    return {"decision_id": decision_id, "ledger_event_id": None}
-
-
-def _is_manual_creation_source(revision: sqlite3.Row, manual_record_id: int) -> bool:
-    """True when ``manual_record_id`` created the event via ``approve_new``.
-
-    The creation source is recorded in the event's immutable revision
-    ``evidence_json``; a linked evidence record is never the creation source
-    and carries no second economic impact.
-    """
-    if revision["source_kind"] != "manual":
-        return False
-    try:
-        evidence = json.loads(revision["evidence_json"] or "{}")
-    except (TypeError, ValueError):
-        return False
-    return evidence.get("manual_record_id") == manual_record_id
-
-
-def _store_audit(
-    connection, record, current, action, outcome, reason, actor
-) -> None:
-    from .auth import audit
-
-    audit(
-        connection,
-        f"manual_{action}",
-        actor=actor,
-        target=f"manual_record:{record['id']}",
-        detail=(
-            f"decision:{outcome['decision_id']};"
-            f"ledger_event:{outcome.get('ledger_event_id')};reason:{reason}"
-        ),
-    )
-
-
-# ---------------------------------------------------------------------------
-# Candidates and queries
-# ---------------------------------------------------------------------------
-
-
-def find_candidates(connection: sqlite3.Connection, record_id: int) -> list[dict[str, object]]:
-    """Deterministic hints shown before approval; never auto-merged."""
-    record = connection.execute(
-        "SELECT * FROM manual_records WHERE id = ?", (record_id,)
-    ).fetchone()
-    if record is None:
-        return []
-    wanted_direction = "incoming" if record["direction"] == "outgoing" else "outgoing"
-    date_prefix = str(record["occurred_at"])[:10]
-    candidates: list[dict[str, object]] = []
-
-    bank_rows = connection.execute(
-        """
-        SELECT e.event_id, e.amount, e.currency, e.effective_at, e.pairing,
-               e.payer_company_id, e.payee_company_id, e.decision_id
-        FROM eligible_intercompany_events e
-        WHERE (e.payer_company_id = ? AND e.payee_company_id = ?)
-           OR (e.payer_company_id = ? AND e.payee_company_id = ?)
-        ORDER BY e.event_id
-        """,
-        (
-            record["company_id"], record["counterparty_company_id"],
-            record["counterparty_company_id"], record["company_id"],
-        ),
-    ).fetchall()
-    for row in bank_rows:
-        if row["amount"] != record["amount"] or row["currency"] != record["currency"]:
-            continue
-        event_direction = (
-            "outgoing" if row["payer_company_id"] == record["company_id"] else "incoming"
-        )
-        if event_direction != wanted_direction:
-            continue
-        candidates.append(
-            {
-                "kind": "bank_event",
-                "ledger_event_id": _ledger_event_of_bank(connection, row["event_id"]),
-                "bank_event_id": row["event_id"],
-                "decision_id": row["decision_id"],
-                "amount": row["amount"],
-                "currency": row["currency"],
-                "effective_at": row["effective_at"],
-                "pairing": row["pairing"],
-                "hint": "已存在匹配的银行规范事件，建议关联",
-            }
-        )
-
-    manual_rows = connection.execute(
-        """
-        SELECT m.id, m.company_id, m.counterparty_company_id, m.direction,
-               m.amount, m.currency, m.occurred_at, d.state
-        FROM manual_records m
-        JOIN current_manual_record_decisions c ON c.record_id = m.id
-        JOIN manual_record_decisions d ON d.id = c.decision_id
-        WHERE m.id != ? AND m.amount = ? AND m.currency = ?
-          AND (
-            (m.company_id = ? AND m.counterparty_company_id = ?)
-            OR (m.company_id = ? AND m.counterparty_company_id = ?)
-          )
-        ORDER BY m.id
-        """,
-        (
-            record["id"], record["amount"], record["currency"],
-            record["company_id"], record["counterparty_company_id"],
-            record["counterparty_company_id"], record["company_id"],
-        ),
-    ).fetchall()
-    for row in manual_rows:
-        if row["direction"] != wanted_direction:
-            continue
-        if row["state"] not in ("approved", "pending"):
-            continue
-        candidates.append(
-            {
-                "kind": "manual_record",
-                "ledger_event_id": None,
-                "manual_record_id": row["id"],
-                "amount": row["amount"],
-                "currency": row["currency"],
-                "occurred_at": row["occurred_at"],
-                "state": row["state"],
-                "hint": "存在方向相反的同额手工记录，建议核对后关联",
-            }
-        )
-    return candidates
-
-
-def _ledger_event_of_bank(connection, bank_event_id: int) -> int | None:
-    claim = connection.execute(
-        "SELECT ledger_event_id FROM ledger_event_bank_sources WHERE bank_event_id = ?",
-        (bank_event_id,),
-    ).fetchone()
-    return claim["ledger_event_id"] if claim is not None else None
-
-
-def list_records(
-    connection: sqlite3.Connection,
-    *,
-    company_id: int | None = None,
-    state: str | None = None,
-    limit: int = 100,
-) -> list[sqlite3.Row]:
-    conditions: list[str] = []
-    params: list[object] = []
-    if company_id is not None:
-        conditions.append("(m.company_id = ? OR m.counterparty_company_id = ?)")
-        params.extend([company_id, company_id])
-    if state is not None:
-        if state not in MANUAL_STATES:
-            raise ManualInputError("无效的记录状态。")
-        conditions.append("d.state = ?")
-        params.append(state)
-    where = f"WHERE {' AND '.join(conditions)}" if conditions else ""
-    return connection.execute(
-        f"""
-        SELECT m.*, d.id AS decision_id, d.state AS state, d.revision AS decision_revision,
-               d.action AS action, d.reason AS decision_reason,
-               d.actor_username AS decision_actor, d.created_at AS decision_at,
-               c.name AS company_name, cc.name AS counterparty_company_name,
-               u.username AS submitted_by_username
-        FROM manual_records m
-        JOIN current_manual_record_decisions c ON c.record_id = m.id
-        JOIN manual_record_decisions d ON d.id = c.decision_id
-        LEFT JOIN companies c ON c.id = m.company_id
-        LEFT JOIN companies cc ON cc.id = m.counterparty_company_id
-        LEFT JOIN users u ON u.id = m.submitted_by
-        {where}
-        ORDER BY m.id DESC
-        LIMIT ?
-        """,
-        (*params, max(1, int(limit))),
-    ).fetchall()
-
-
-def rebuild_current_manual_projection(connection: sqlite3.Connection) -> int:
-    began = False
-    if not connection.in_transaction:
-        connection.execute("BEGIN IMMEDIATE")
-        began = True
-    try:
-        connection.execute("DELETE FROM current_manual_record_decisions")
-        rows = connection.execute(
-            """
-            SELECT m.id AS record_id,
-                   (SELECT d2.id FROM manual_record_decisions d2
-                     WHERE d2.record_id = m.id
-                     ORDER BY d2.revision DESC LIMIT 1) AS latest_id
-            FROM manual_records m
-            """
-        ).fetchall()
-        rebuilt = 0
-        for row in rows:
-            if row["latest_id"] is None:
-                continue
-            connection.execute(
-                """
-                INSERT OR REPLACE INTO current_manual_record_decisions (record_id, decision_id)
-                VALUES (?, ?)
-                """,
-                (row["record_id"], row["latest_id"]),
-            )
-            rebuilt += 1
-    except Exception:
-        if began:
-            connection.rollback()
-        raise
-    else:
-        if began:
-            connection.commit()
-        return rebuilt
-
-
-# ---------------------------------------------------------------------------
-# Payloads
-# ---------------------------------------------------------------------------
-
-
-def _record_payload(connection: sqlite3.Connection, record_id: int, *, idempotent_replay: bool = False) -> dict[str, object]:
-    rows = list_records(connection, limit=1000)
-    row = next((item for item in rows if item["id"] == record_id), None)
-    if row is None:
-        raise ManualInputError("手工记录不存在。")
-    payload = _row_payload(connection, row)
-    if idempotent_replay:
-        payload["idempotent_replay"] = True
-    return payload
-
-
-def _row_payload(connection: sqlite3.Connection, row: sqlite3.Row) -> dict[str, object]:
-    evidence = json.loads(row["evidence_json"] or "{}") if row["evidence_json"] else {}
-    return {
-        "id": row["id"],
-        "company_id": row["company_id"],
-        "company_name": row["company_name"],
-        "counterparty_company_id": row["counterparty_company_id"],
-        "counterparty_company_name": row["counterparty_company_name"],
-        "occurred_at": row["occurred_at"],
-        "direction": row["direction"],
-        "amount": row["amount"],
-        "currency": row["currency"],
-        "funding_source": row["funding_source"],
-        "bank_account_id": row["bank_account_id"],
-        "personal_transit_mapping_id": row["personal_transit_mapping_id"],
-        "related_source_row_id": row["related_source_row_id"],
-        "requested_subject": row["requested_subject"],
-        "summary": row["summary"],
-        "reason": row["reason"],
-        "request_key": row["request_key"],
-        "supersedes_record_id": row["supersedes_record_id"],
-        "submitted_by": row["submitted_by"],
-        "submitted_by_username": row["submitted_by_username"] if "submitted_by_username" in row.keys() else None,
-        "attachment_name": evidence.get("attachment_name"),
-        "created_at": row["created_at"],
-        "state": row["state"],
-        "decision_id": row["decision_id"],
-        "decision_revision": row["decision_revision"],
-        "decision_action": row["action"],
-        "decision_reason": row["decision_reason"],
-        "decision_actor": row["decision_actor"],
-        "decision_at": row["decision_at"],
-        "candidates": find_candidates(connection, row["id"]),
-    }
-
-
-def _decision_payload(connection: sqlite3.Connection, record_id: int, decision_id: int) -> dict[str, object]:
-    row = connection.execute(
-        """
-        SELECT d.* FROM manual_record_decisions d
-        WHERE d.id = ?
-        """,
-        (decision_id,),
-    ).fetchone()
-    record = connection.execute(
-        "SELECT * FROM manual_records WHERE id = ?", (record_id,)
-    ).fetchone()
-    claim = manual_source_claim(connection, record_id)
-    return {
-        "record_id": record_id,
-        "decision_id": decision_id,
-        "revision": row["revision"],
-        "state": row["state"],
-        "action": row["action"],
-        "reason": row["reason"],
-        "actor_username": row["actor_username"],
-        "created_at": row["created_at"],
-        "ledger_event_id": claim["ledger_event_id"] if claim is not None else None,
-        "requested_subject": record["requested_subject"],
-        "amount": record["amount"],
-        "currency": record["currency"],
-        "occurred_at": record["occurred_at"],
-    }

src/bank_importer/master_data.py

@@ -262,7 +262,7 @@ def submit_bank_account(
 
     if existing["company_id"] == company_id:
         raise ConflictError("该银行账号已登记，请等待现有申请处理。")
-    raise ConflictError("该银行账号已被其他公司登记，请联系管理员核对。")
+    raise ConflictError("该银行账号已被其他公司登记，请联系总账管理员核对。")
 
 
 def review_bank_account(

src/bank_importer/settings.py

@@ -1,309 +0,0 @@
-"""System settings and reminder item generation.
-
-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.
-"""
-
-from __future__ import annotations
-
-import re
-import sqlite3
-from datetime import datetime, timezone
-
-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",
-    "start_date": "2026-01-01",
-    "auto_remind": "1",
-    "remind_days": "3",
-}
-
-_SETTING_KEYS = frozenset({"closing_day", "start_date", "auto_remind", "remind_days"})
-
-_DATE_RE = re.compile(r"^\d{4}-\d{2}-\d{2}$")
-
-
-def _valid_date(value: str) -> bool:
-    if not _DATE_RE.match(value):
-        return False
-    try:
-        datetime.strptime(value, "%Y-%m-%d")
-    except ValueError:
-        return False
-    return True
-
-
-def get_settings(connection: sqlite3.Connection) -> dict[str, str]:
-    settings = dict(DEFAULT_SETTINGS)
-    rows = connection.execute(
-        "SELECT key, value FROM system_settings"
-    ).fetchall()
-    for row in rows:
-        settings[row["key"]] = row["value"]
-    return settings
-
-
-def validate_settings(values: dict[str, object]) -> tuple[dict[str, str], str | None]:
-    """Return ``(cleaned, error)``; ``cleaned`` holds only recognized keys."""
-    cleaned: dict[str, str] = {}
-    if "closing_day" in values:
-        raw = str(values["closing_day"]).strip()
-        try:
-            day = int(raw)
-        except ValueError:
-            return cleaned, "每月结账日须为 1-28 之间的整数。"
-        if day < 1 or day > 28:
-            return cleaned, "每月结账日须为 1-28 之间的整数。"
-        cleaned["closing_day"] = str(day)
-    if "start_date" in values:
-        raw = str(values["start_date"]).strip()
-        if not _valid_date(raw):
-            return cleaned, "全局起算日须为有效日期（YYYY-MM-DD）。"
-        cleaned["start_date"] = raw
-    if "auto_remind" in values:
-        raw = str(values["auto_remind"]).strip()
-        if raw not in {"0", "1"}:
-            return cleaned, "自动提醒开关须为 0 或 1。"
-        cleaned["auto_remind"] = raw
-    if "remind_days" in values:
-        raw = str(values["remind_days"]).strip()
-        try:
-            days = int(raw)
-        except ValueError:
-            return cleaned, "提前提醒天数须为不小于 1 的整数。"
-        if days < 1 or days > 30:
-            return cleaned, "提前提醒天数须为 1-30 之间的整数。"
-        cleaned["remind_days"] = str(days)
-    return cleaned, None
-
-
-def update_settings(
-    connection: sqlite3.Connection,
-    values: dict[str, object],
-    actor: sqlite3.Row,
-) -> dict[str, str]:
-    cleaned, error = validate_settings(values)
-    if error is not None:
-        raise ValueError(error)
-    if not cleaned:
-        raise ValueError("没有需要保存的设置项。")
-    current = get_settings(connection)
-    with connection:
-        for key, new_value in cleaned.items():
-            old_value = current.get(key)
-            if old_value == new_value:
-                continue
-            connection.execute(
-                """
-                INSERT INTO system_settings (key, value, updated_by, updated_at)
-                VALUES (?, ?, ?, ?)
-                ON CONFLICT(key) DO UPDATE SET
-                    value = excluded.value,
-                    updated_by = excluded.updated_by,
-                    updated_at = excluded.updated_at
-                """,
-                (key, new_value, actor["id"], utc_now()),
-            )
-            connection.execute(
-                """
-                INSERT INTO system_setting_changes (
-                    key, before_value, after_value,
-                    actor_user_id, actor_username, created_at
-                ) VALUES (?, ?, ?, ?, ?, ?)
-                """,
-                (
-                    key,
-                    old_value,
-                    new_value,
-                    actor["id"],
-                    actor["username"],
-                    utc_now(),
-                ),
-            )
-    return get_settings(connection)
-
-
-# ----------------------------------------------------------------------
-# 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

src/bank_importer/subjects.py

@@ -1,398 +0,0 @@
-"""Statutory subject suggestions, mirror mapping and confirmation (B-44).
-
-Subjects are stored from one participating company's perspective and the
-other side is the fixed mirror (应收<->应付, 其他应收<->其他应付), so the two
-companies can never record conflicting subjects. Bank summary/purpose text
-only ever produces a *suggestion*; nothing here confirms a subject
-automatically. Confirmation is an explicit administrator decision carrying
-``expected_revision`` and an idempotency key.
-"""
-
-from __future__ import annotations
-
-import json
-import re
-import sqlite3
-
-from . import matching
-
-SUBJECTS = ("receivable", "payable", "other_receivable", "other_payable")
-SUBJECT_RULE_VERSION = "subject-suggest-draft-v1"
-
-MIRROR = {
-    "receivable": "payable",
-    "payable": "receivable",
-    "other_receivable": "other_payable",
-    "other_payable": "other_receivable",
-}
-
-SUBJECT_LABELS = {
-    "receivable": "应收",
-    "payable": "应付",
-    "other_receivable": "其他应收",
-    "other_payable": "其他应付",
-}
-
-_FULL_WIDTH = str.maketrans(
-    "ＡＢＣＤＥＦＧＨＩＪＫＬＭＮＯＰＱＲＳＴＵＶＷＸＹＺ"
-    "ａｂｃｄｅｆｇｈｉｊｋｌｍｎｏｐｑｒｓｔｕｖｗｘｙｚ０１２３４５６７８９",
-    "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
-    "abcdefghijklmnopqrstuvwxyz0123456789",
-)
-
-# Draft v1 dictionary. Exact-keyword matching only; every hit is a suggestion
-# and never an automatic posting. Trade-type keywords are deliberately absent
-# until the group supplies an approved dictionary (they always go to review).
-_LOAN_LIKE = ("借款", "往来款", "资金往来", "临时借款", "资金调拨", "代垫", "垫付")
-_REPAY_LIKE = ("还款", "归还借款", "归还往来款")
-
-
-class SubjectConflictError(ValueError):
-    """A stale revision or idempotency conflict (mapped to HTTP 409)."""
-
-
-class SubjectInputError(ValueError):
-    """Invalid input for a subject decision (mapped to HTTP 400/422)."""
-
-
-def mirror_subject(subject_code: str) -> str:
-    if subject_code not in MIRROR:
-        raise SubjectInputError("科目必须是应收/应付/其他应收/其他应付之一。")
-    return MIRROR[subject_code]
-
-
-def subject_label(subject_code: str) -> str:
-    return SUBJECT_LABELS.get(subject_code, subject_code)
-
-
-def _normalize(text: object) -> str:
-    return re.sub(r"[\s\ufeff]+", "", str(text or "").translate(_FULL_WIDTH))
-
-
-def _bank_evidence_texts(connection: sqlite3.Connection, ledger_event_id: int) -> dict[str, str]:
-    """Purpose/summary text of the B-43 source rows behind a bank event."""
-    row = connection.execute(
-        """
-        SELECT bs.bank_event_id FROM ledger_event_bank_sources bs
-        WHERE bs.ledger_event_id = ?
-        """,
-        (ledger_event_id,),
-    ).fetchone()
-    if row is None:
-        return {"purpose": "", "summary": ""}
-    decision = matching._current_decision_for_event(connection, row["bank_event_id"])
-    if decision is None:
-        return {"purpose": "", "summary": ""}
-    observations = matching._decision_observations(connection, decision["id"])
-    texts: dict[str, list[str]] = {"purpose": [], "summary": []}
-    for observation in observations:
-        source = connection.execute(
-            "SELECT purpose, summary FROM source_rows WHERE id = ?",
-            (observation["source_row_id"],),
-        ).fetchone()
-        if source is None:
-            continue
-        for key in ("purpose", "summary"):
-            value = str(source[key] or "").strip()
-            if value:
-                texts[key].append(value)
-    return {
-        "purpose": " ".join(texts["purpose"]),
-        "summary": " ".join(texts["summary"]),
-    }
-
-
-def compute_suggestions(
-    connection: sqlite3.Connection, ledger_event_id: int
-) -> list[dict[str, object]]:
-    """    Deterministic draft suggestions for a pending event, never confirmation.
-
-    Purpose rules take precedence over summary rules. When both loan-like and
-    repay-like keywords match, both candidates are returned as a conflict for
-    the reviewer; no priority breaks the tie.
-    """
-    from .ledger_events import current_revision
-
-    revision = current_revision(connection, ledger_event_id)
-    if revision is None or revision["state"] != "pending_subject":
-        return []
-    texts = _bank_evidence_texts(connection, ledger_event_id)
-    purpose = _normalize(texts["purpose"])
-    summary = _normalize(texts["summary"])
-    search = purpose or summary
-    payer = revision["payer_company_id"]
-    payee = revision["payee_company_id"]
-
-    loan_hit = next((word for word in _LOAN_LIKE if word in search), None)
-    repay_hit = next((word for word in _REPAY_LIKE if word in search), None)
-
-    suggestions: list[dict[str, object]] = []
-    if loan_hit:
-        suggestions.append(
-            {
-                "suggested_perspective_company_id": payer,
-                "suggested_subject_code": "other_receivable",
-                "reason": f"匹配建议词典「{loan_hit}」，建议付款方其他应收",
-                "rule_version": SUBJECT_RULE_VERSION,
-                "evidence": {
-                    "keyword": loan_hit,
-                    "matched_text": search,
-                    "approved": False,
-                },
-            }
-        )
-    if repay_hit:
-        suggestions.append(
-            {
-                "suggested_perspective_company_id": payee,
-                "suggested_subject_code": "other_receivable",
-                "reason": f"匹配建议词典「{repay_hit}」，建议收款方其他应收",
-                "rule_version": SUBJECT_RULE_VERSION,
-                "evidence": {
-                    "keyword": repay_hit,
-                    "matched_text": search,
-                    "approved": False,
-                },
-            }
-        )
-    return suggestions
-
-
-def store_suggestions(connection: sqlite3.Connection, ledger_event_id: int) -> int:
-    """Compute and append suggestions for a pending event. Returns count stored."""
-    from .ledger_events import current_revision
-
-    revision = current_revision(connection, ledger_event_id)
-    if revision is None or revision["state"] != "pending_subject":
-        return 0
-    stored = 0
-    for suggestion in compute_suggestions(connection, ledger_event_id):
-        from .db import utc_now
-
-        connection.execute(
-            """
-            INSERT INTO ledger_subject_suggestions (
-                ledger_event_id, source_revision_id,
-                suggested_perspective_company_id, suggested_subject_code,
-                rule_version, evidence_json, created_at
-            ) VALUES (?, ?, ?, ?, ?, ?, ?)
-            """,
-            (
-                ledger_event_id, revision["id"],
-                suggestion["suggested_perspective_company_id"],
-                suggestion["suggested_subject_code"],
-                suggestion["rule_version"],
-                json.dumps(suggestion.get("evidence", {}), ensure_ascii=False),
-                utc_now(),
-            ),
-        )
-        stored += 1
-    return stored
-
-
-def confirm_subject(
-    connection: sqlite3.Connection,
-    ledger_event_id: int,
-    *,
-    perspective_company_id: int,
-    subject_code: str,
-    reason: str,
-    expected_revision: int | None,
-    request_key: str | None,
-    actor: sqlite3.Row,
-) -> dict[str, object]:
-    """Confirm a subject, turning a pending event into a confirmed revision."""
-    from .ledger_events import append_revision, current_revision
-
-    reason = (reason or "").strip()
-    if not reason:
-        raise SubjectInputError("必须填写科目确认依据。")
-    if subject_code not in SUBJECTS:
-        raise SubjectInputError("科目必须是应收/应付/其他应收/其他应付之一。")
-
-    began = False
-    if not connection.in_transaction:
-        connection.execute("BEGIN IMMEDIATE")
-        began = True
-    try:
-        if request_key:
-            existing = connection.execute(
-                """
-                SELECT * FROM ledger_event_revisions
-                WHERE ledger_event_id = ? AND idempotency_key = ?
-                ORDER BY id LIMIT 1
-                """,
-                (ledger_event_id, request_key),
-            ).fetchone()
-            if existing is not None:
-                if began:
-                    connection.commit()
-                return _revision_payload(connection, existing)
-
-        current = current_revision(connection, ledger_event_id)
-        if current is None:
-            raise SubjectConflictError("该事件不存在或没有当前修订。")
-        if current["state"] != "pending_subject":
-            raise SubjectConflictError("只有待确认科目的事件可以确认科目。")
-        # ``expected_revision`` may be the revision row id (what the API/UI
-        # sends as ``ledger_revision_id``) or the per-event sequence number;
-        # both identify the exact revision the client saw.
-        if expected_revision is not None and int(expected_revision) not in (
-            current["id"], current["revision"],
-        ):
-            raise SubjectConflictError("事件已发生变更，请刷新后重试。")
-        participants = {current["payer_company_id"], current["payee_company_id"]}
-        if perspective_company_id not in participants:
-            raise SubjectInputError("视角公司必须是事件参与方。")
-
-        revision_id = append_revision(
-            connection,
-            ledger_event_id,
-            state="confirmed",
-            effective_at=current["effective_at"],
-            amount=current["amount"],
-            currency=current["currency"],
-            payer_company_id=current["payer_company_id"],
-            payee_company_id=current["payee_company_id"],
-            perspective_company_id=perspective_company_id,
-            subject_code=subject_code,
-            source_kind=current["source_kind"],
-            source_revision_token=current["source_revision_token"],
-            posting_kind=current["posting_kind"],
-            reverses_ledger_event_id=current["reverses_ledger_event_id"],
-            adjusts_ledger_event_id=current["adjusts_ledger_event_id"],
-            rule_version=current["rule_version"] or SUBJECT_RULE_VERSION,
-            evidence_json=current["evidence_json"],
-            idempotency_key=request_key,
-            actor=actor,
-            reason=reason,
-            supersedes_revision_id=current["id"],
-        )
-        row = connection.execute(
-            "SELECT * FROM ledger_event_revisions WHERE id = ?", (revision_id,)
-        ).fetchone()
-    except Exception:
-        if began:
-            connection.rollback()
-        raise
-    else:
-        if began:
-            connection.commit()
-        return _revision_payload(connection, row)
-
-
-def park_subject(
-    connection: sqlite3.Connection,
-    ledger_event_id: int,
-    *,
-    disposition: str,
-    reason: str,
-    expected_revision: int | None,
-    request_key: str | None,
-    actor: sqlite3.Row,
-) -> dict[str, object]:
-    """Record 退回/转异常 without confirming a statutory subject.
-
-    The event stays ``pending_subject`` so it never enters confirmed balances.
-    ``exception`` is hidden from the active review queue; ``return`` remains
-    visible so the company can supplement materials.
-    """
-    from .ledger_events import append_revision, current_revision
-
-    if disposition not in ("return", "exception"):
-        raise SubjectInputError("科目处理只能是退回或转异常。")
-    reason = (reason or "").strip()
-    if not reason:
-        raise SubjectInputError("必须填写处理依据。")
-
-    began = False
-    if not connection.in_transaction:
-        connection.execute("BEGIN IMMEDIATE")
-        began = True
-    try:
-        if request_key:
-            existing = connection.execute(
-                """
-                SELECT * FROM ledger_event_revisions
-                WHERE ledger_event_id = ? AND idempotency_key = ?
-                ORDER BY id LIMIT 1
-                """,
-                (ledger_event_id, request_key),
-            ).fetchone()
-            if existing is not None:
-                if began:
-                    connection.commit()
-                return _revision_payload(connection, existing)
-
-        current = current_revision(connection, ledger_event_id)
-        if current is None:
-            raise SubjectConflictError("该事件不存在或没有当前修订。")
-        if current["state"] != "pending_subject":
-            raise SubjectConflictError("只有待确认科目的事件可以退回或转异常。")
-        if expected_revision is not None and int(expected_revision) not in (
-            current["id"], current["revision"],
-        ):
-            raise SubjectConflictError("事件已发生变更，请刷新后重试。")
-        evidence = json.loads(current["evidence_json"] or "{}") if current["evidence_json"] else {}
-        evidence["admin_disposition"] = disposition
-        revision_id = append_revision(
-            connection,
-            ledger_event_id,
-            state="pending_subject",
-            effective_at=current["effective_at"],
-            amount=current["amount"],
-            currency=current["currency"],
-            payer_company_id=current["payer_company_id"],
-            payee_company_id=current["payee_company_id"],
-            perspective_company_id=None,
-            subject_code=None,
-            source_kind=current["source_kind"],
-            source_revision_token=current["source_revision_token"],
-            posting_kind=current["posting_kind"],
-            reverses_ledger_event_id=current["reverses_ledger_event_id"],
-            adjusts_ledger_event_id=current["adjusts_ledger_event_id"],
-            rule_version=current["rule_version"] or SUBJECT_RULE_VERSION,
-            evidence_json=json.dumps(evidence, ensure_ascii=False),
-            idempotency_key=request_key,
-            actor=actor,
-            reason=reason,
-            supersedes_revision_id=current["id"],
-        )
-        row = connection.execute(
-            "SELECT * FROM ledger_event_revisions WHERE id = ?", (revision_id,)
-        ).fetchone()
-    except Exception:
-        if began:
-            connection.rollback()
-        raise
-    else:
-        if began:
-            connection.commit()
-        return _revision_payload(connection, row)
-
-
-def _revision_payload(connection: sqlite3.Connection, revision: sqlite3.Row) -> dict[str, object]:
-    company = connection.execute(
-        "SELECT name FROM companies WHERE id = ?", (revision["perspective_company_id"],)
-    ).fetchone()
-    return {
-        "ledger_event_id": revision["ledger_event_id"],
-        "revision_id": revision["id"],
-        "revision": revision["revision"],
-        "state": revision["state"],
-        "effective_at": revision["effective_at"],
-        "amount": revision["amount"],
-        "currency": revision["currency"],
-        "payer_company_id": revision["payer_company_id"],
-        "payee_company_id": revision["payee_company_id"],
-        "perspective_company_id": revision["perspective_company_id"],
-        "perspective_company_name": company["name"] if company else None,
-        "subject_code": revision["subject_code"],
-        "subject_label": subject_label(revision["subject_code"])
-        if revision["subject_code"]
-        else None,
-        "posting_kind": revision["posting_kind"],
-        "source_kind": revision["source_kind"],
-        "reason": revision["reason"],
-        "created_at": revision["created_at"],
-    }

tests/ledger_helpers.py

@@ -1,175 +0,0 @@
-"""Shared fixtures for B-44 ledger / manual / position tests."""
-
-from __future__ import annotations
-
-from pathlib import Path
-import sqlite3
-import tempfile
-import unittest
-
-from bank_importer import auth, matching, master_data
-from bank_importer.db import connect, migrate, utc_now
-
-
-class LedgerBase(unittest.TestCase):
-    def setUp(self) -> None:
-        self.temp_dir = tempfile.TemporaryDirectory()
-        self.addCleanup(self.temp_dir.cleanup)
-        root = Path(self.temp_dir.name)
-        self.db_path = root / "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.company_c = 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_row(
-        self,
-        company_id: int,
-        *,
-        own_account: str,
-        cp_account: str | None = None,
-        income: str = "0",
-        expense: str = "0",
-        at: str = "2026-01-05T10:00:00",
-        currency: str = "CNY",
-        reference: str | None = None,
-        summary: str | None = None,
-        purpose: str | None = None,
-    ) -> 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', ?)
-                """,
-                (utc_now(), utc_now()),
-            )
-            source_file_id = int(cursor.lastrowid)
-            cursor = self.connection.execute(
-                """
-                INSERT INTO import_batches (source_file_id, status, company_id, created_at, updated_at)
-                VALUES (?, 'parsing', ?, ?, ?)
-                """,
-                (source_file_id, company_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, own_account, own_name, period_start, period_end,
-                    transaction_count, warnings, created_at
-                ) VALUES (?, '流水', '测试银行', 'test-v1', 1, 1, NULL, NULL, NULL, NULL, 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, balance,
-                    own_account, own_name, counterparty_account, counterparty_name,
-                    counterparty_bank, summary, purpose, reference, currency, created_at
-                ) VALUES (?, 1, ?, ?, ?, NULL, ?, '测试', ?, '对方', NULL, ?, ?, ?, ?, ?)
-                """,
-                (
-                    sheet_batch_id, at, income, expense, own_account,
-                    cp_account, summary, purpose, reference, currency, utc_now(),
-                ),
-            )
-        return int(cursor.lastrowid)
-
-    def pair(
-        self,
-        payer: int,
-        payee: int,
-        amount: str,
-        at: str = "2026-01-05T10:00:00",
-        *,
-        currency: str = "CNY",
-        summary: str = "借款",
-        purpose: str = "往来款",
-    ) -> tuple[int, int]:
-        """Create a mirrored A/B pair and reconcile into an eligible event."""
-        payer_account = self._account_of(payer)
-        payee_account = self._account_of(payee)
-        row_payer = self.add_row(
-            payer, own_account=payer_account, cp_account=payee_account,
-            expense=amount, at=at, currency=currency, summary=summary, purpose=purpose,
-        )
-        row_payee = self.add_row(
-            payee, own_account=payee_account, cp_account=payer_account,
-            income=amount, at=at.replace("T10:", "T11:"), currency=currency,
-            summary=summary, purpose=purpose,
-        )
-        matching.reconcile_rows(self.connection, [row_payer, row_payee])
-        return row_payer, row_payee
-
-    def _account_of(self, company_id: int) -> str:
-        if company_id == self.company_a:
-            return self.account_a["account_number"]
-        if company_id == self.company_b:
-            return self.account_b["account_number"]
-        return "6222000000000005"
-
-    def eligible(self) -> list[sqlite3.Row]:
-        return matching.eligible_intercompany_events(self.connection)
-
-    def ledger_events(self) -> list[sqlite3.Row]:
-        return self.connection.execute(
-            "SELECT * FROM ledger_events ORDER BY id"
-        ).fetchall()
-
-    def current(self, ledger_event_id: int) -> sqlite3.Row | None:
-        return self.connection.execute(
-            """
-            SELECT r.* FROM current_ledger_event_revisions c
-            JOIN ledger_event_revisions r ON r.id = c.revision_id
-            WHERE c.ledger_event_id = ?
-            """,
-            (ledger_event_id,),
-        ).fetchone()
-
-    def position_events(self) -> list[sqlite3.Row]:
-        return self.connection.execute(
-            "SELECT * FROM eligible_position_events ORDER BY ledger_event_id"
-        ).fetchall()

tests/test_ledger_events.py

@@ -1,306 +0,0 @@
-"""B-44 ledger event layer tests: bank reconciliation, revision chain,
-reversal/adjustment, projection rebuild and immutability boundaries."""
-
-from __future__ import annotations
-
-from decimal import Decimal
-import sqlite3
-import unittest
-
-from bank_importer import ledger_events, matching, subjects
-from ledger_helpers import LedgerBase
-
-
-class BankReconcileTests(LedgerBase):
-    def test_paired_eligible_event_creates_pending_subject_only(self) -> None:
-        self.pair(self.company_a, self.company_b, "100.00")
-        self.assertEqual(1, len(self.eligible()))
-        stats = ledger_events.reconcile_bank_events(self.connection, actor=self.admin)
-        self.assertEqual(1, stats["created"])
-        events = self.ledger_events()
-        self.assertEqual(1, len(events))
-        revision = self.current(events[0]["id"])
-        self.assertEqual("pending_subject", revision["state"])
-        self.assertEqual(Decimal("100.00"), Decimal(revision["amount"]))
-        self.assertEqual("CNY", revision["currency"])
-        # Nothing confirmed yet -> no position event.
-        self.assertEqual([], self.position_events())
-        # The event is unresolved as subject_review.
-        from bank_importer import positions
-        unresolved = positions.unresolved_for_company(self.connection, self.company_a, "2026-12-31")
-        self.assertEqual("100.00", unresolved["by_reason"]["subject_review"]["gross_amount"])
-
-    def test_unlocked_single_never_enters_ledger(self) -> None:
-        self.add_row(
-            self.company_a, own_account="6222000000000001",
-            cp_account="6222000000000002", expense="100.00",
-        )
-        matching.reconcile_rows(self.connection, [1])
-        self.assertEqual([], self.eligible())
-        stats = ledger_events.reconcile_bank_events(self.connection, actor=self.admin)
-        self.assertEqual(0, stats["created"])
-        self.assertEqual([], self.ledger_events())
-
-    def test_same_company_transfer_never_enters_ledger(self) -> None:
-        self.add_row(
-            self.company_a, own_account="6222000000000001",
-            cp_account="6222000000000001", expense="100.00",
-        )
-        self.add_row(
-            self.company_a, own_account="6222000000000001",
-            cp_account="6222000000000001", income="100.00",
-        )
-        matching.reconcile_rows(self.connection, [1, 2])
-        eligible = self.eligible()
-        self.assertEqual(0, len([e for e in eligible if e["payer_company_id"] == e["payee_company_id"]]))
-        stats = ledger_events.reconcile_bank_events(self.connection, actor=self.admin)
-        self.assertEqual(0, stats["created"])
-
-    def test_reconcile_is_idempotent(self) -> None:
-        self.pair(self.company_a, self.company_b, "100.00")
-        ledger_events.reconcile_bank_events(self.connection, actor=self.admin)
-        events = self.ledger_events()
-        self.assertEqual(1, len(events))
-        before_revisions = self.connection.execute(
-            "SELECT COUNT(*) AS n FROM ledger_event_revisions"
-        ).fetchone()["n"]
-        stats = ledger_events.reconcile_bank_events(self.connection, actor=self.admin)
-        self.assertEqual(1, stats["unchanged"])
-        after_revisions = self.connection.execute(
-            "SELECT COUNT(*) AS n FROM ledger_event_revisions"
-        ).fetchone()["n"]
-        self.assertEqual(before_revisions, after_revisions)
-
-    def test_reconcile_picks_up_newly_linked_rows_as_new_pending_event(self) -> None:
-        # A single observation locked as intercompany -> pending ledger event.
-        row_a = self.add_row(
-            self.company_a, own_account="6222000000000001",
-            cp_account="6222000000000002", expense="100.00",
-        )
-        matching.reconcile_rows(self.connection, [row_a])
-        single = self.connection.execute(
-            "SELECT * FROM current_transfer_decisions"
-        ).fetchone()
-        event_id = single["event_id"]
-        decision = self.connection.execute(
-            "SELECT * FROM transfer_match_decisions WHERE id = ?",
-            (single["decision_id"],),
-        ).fetchone()
-        matching.apply_manual_decision(
-            self.connection, event_id, "assign_participant",
-            reason="函证确认对方",
-            expected_revision=decision["revision"], request_key="assign-1",
-            actor=self.admin,
-            participant={"role": "payee", "company_id": self.company_b},
-        )
-        self.assertEqual(1, len(self.eligible()))
-        ledger_events.reconcile_bank_events(self.connection, actor=self.admin)
-        self.assertEqual(1, len(self.ledger_events()))
-
-        # The administrator links two fresh rows with a different amount onto a
-        # new canonical event; reconcile creates a second pending event.
-        row_a2 = self.add_row(
-            self.company_a, own_account="6222000000000001",
-            cp_account="6222000000000002", expense="150.00",
-            at="2026-02-01T10:00:00",
-        )
-        row_b2 = self.add_row(
-            self.company_b, own_account="6222000000000002",
-            cp_account="6222000000000001", income="150.00",
-            at="2026-02-01T11:00:00",
-        )
-        current_row = self.connection.execute(
-            "SELECT d.* FROM current_transfer_decisions c "
-            "JOIN transfer_match_decisions d ON d.id = c.decision_id "
-            "WHERE c.event_id = ?",
-            (event_id,),
-        ).fetchone()
-        matching.apply_manual_decision(
-            self.connection, event_id, "link_rows",
-            reason="补录双边流水",
-            expected_revision=current_row["revision"], request_key="link-1",
-            actor=self.admin, source_row_ids=[row_a2, row_b2],
-        )
-        ledger_events.reconcile_bank_events(self.connection, actor=self.admin)
-        amounts = sorted(
-            row["amount"] for row in self.connection.execute(
-                "SELECT amount FROM ledger_event_revisions WHERE state = 'pending_subject'"
-            ).fetchall()
-        )
-        self.assertEqual(["100.00", "150.00"], amounts)
-
-    def test_confirm_subject_enters_position_view(self) -> None:
-        self.pair(self.company_a, self.company_b, "100.00")
-        ledger_events.reconcile_bank_events(self.connection, actor=self.admin)
-        event_id = self.ledger_events()[0]["id"]
-        subjects.confirm_subject(
-            self.connection, event_id,
-            perspective_company_id=self.company_a, subject_code="other_receivable",
-            reason="借款建议其他应收", expected_revision=1, request_key="k1",
-            actor=self.admin,
-        )
-        positions = self.position_events()
-        self.assertEqual(1, len(positions))
-        self.assertEqual("other_receivable", positions[0]["subject_code"])
-        self.assertEqual(self.company_a, positions[0]["perspective_company_id"])
-
-    def test_confirm_stale_revision_conflicts(self) -> None:
-        self.pair(self.company_a, self.company_b, "100.00")
-        ledger_events.reconcile_bank_events(self.connection, actor=self.admin)
-        event_id = self.ledger_events()[0]["id"]
-        subjects.confirm_subject(
-            self.connection, event_id,
-            perspective_company_id=self.company_a, subject_code="receivable",
-            reason="确认应收", expected_revision=1, request_key="k1",
-            actor=self.admin,
-        )
-        with self.assertRaises(subjects.SubjectConflictError):
-            subjects.confirm_subject(
-                self.connection, event_id,
-                perspective_company_id=self.company_a, subject_code="receivable",
-                reason="重复确认", expected_revision=1, request_key="k2",
-                actor=self.admin,
-            )
-
-    def test_reversal_mirrors_direction_and_subject(self) -> None:
-        self.pair(self.company_a, self.company_b, "100.00")
-        ledger_events.reconcile_bank_events(self.connection, actor=self.admin)
-        event_id = self.ledger_events()[0]["id"]
-        subjects.confirm_subject(
-            self.connection, event_id,
-            perspective_company_id=self.company_a, subject_code="other_receivable",
-            reason="借款", expected_revision=1, request_key="k1", actor=self.admin,
-        )
-        reversal_id, _ = ledger_events.create_reversal(
-            self.connection, event_id, source_kind="adjustment",
-            reason="冲销错误确认", actor=self.admin,
-        )
-        reversal = self.current(reversal_id)
-        self.assertEqual("reversal", reversal["posting_kind"])
-        self.assertEqual(self.company_b, reversal["payer_company_id"])
-        self.assertEqual(self.company_a, reversal["payee_company_id"])
-        self.assertEqual("other_payable", reversal["subject_code"])
-        self.assertEqual(self.company_b, reversal["perspective_company_id"])
-        # Original event stays confirmed and still in the position view.
-        self.assertEqual("confirmed", self.current(event_id)["state"])
-        positions = self.position_events()
-        self.assertEqual(2, len(positions))
-        signed = sum(
-            Decimal(position["amount"]) * (
-                1 if position["payer_company_id"] == self.company_a else -1
-            )
-            for position in positions
-        )
-        self.assertEqual(Decimal("0"), signed)
-
-    def test_evidence_rows_stay_immutable_under_reversal(self) -> None:
-        self.pair(self.company_a, self.company_b, "100.00")
-        ledger_events.reconcile_bank_events(self.connection, actor=self.admin)
-        event_id = self.ledger_events()[0]["id"]
-        subjects.confirm_subject(
-            self.connection, event_id,
-            perspective_company_id=self.company_a, subject_code="receivable",
-            reason="确认", expected_revision=1, request_key="k1", actor=self.admin,
-        )
-        before = self.connection.execute(
-            "SELECT income, expense FROM source_rows ORDER BY id"
-        ).fetchall()
-        ledger_events.create_reversal(
-            self.connection, event_id, source_kind="adjustment",
-            reason="冲销", actor=self.admin,
-        )
-        after = self.connection.execute(
-            "SELECT income, expense FROM source_rows ORDER BY id"
-        ).fetchall()
-        self.assertEqual(before, after)
-
-    def test_reversal_idempotent_guard(self) -> None:
-        self.pair(self.company_a, self.company_b, "100.00")
-        ledger_events.reconcile_bank_events(self.connection, actor=self.admin)
-        event_id = self.ledger_events()[0]["id"]
-        subjects.confirm_subject(
-            self.connection, event_id,
-            perspective_company_id=self.company_a, subject_code="receivable",
-            reason="确认", expected_revision=1, request_key="k1", actor=self.admin,
-        )
-        # Simulate the B-43 event leaving the eligible set.
-        with self.connection:
-            self.connection.execute(
-                "UPDATE canonical_transfer_events SET lifecycle = 'superseded' WHERE id = ?",
-                (self.eligible()[0]["event_id"],),
-            )
-        stats = ledger_events.reconcile_bank_events(self.connection, actor=self.admin)
-        self.assertEqual(1, stats["reversal"])
-        reversals = self.connection.execute(
-            "SELECT COUNT(*) AS n FROM ledger_event_revisions WHERE posting_kind = 'reversal'"
-        ).fetchone()["n"]
-        self.assertEqual(1, reversals)
-        # Re-run does not create a second reversal.
-        stats = ledger_events.reconcile_bank_events(self.connection, actor=self.admin)
-        self.assertEqual(0, stats["reversal"])
-
-
-class ProjectionTests(LedgerBase):
-    def test_rebuild_current_projection(self) -> None:
-        self.pair(self.company_a, self.company_b, "100.00")
-        ledger_events.reconcile_bank_events(self.connection, actor=self.admin)
-        event_id = self.ledger_events()[0]["id"]
-        subjects.confirm_subject(
-            self.connection, event_id,
-            perspective_company_id=self.company_a, subject_code="receivable",
-            reason="确认", expected_revision=1, request_key="k1", actor=self.admin,
-        )
-        self.connection.execute("DELETE FROM current_ledger_event_revisions")
-        rebuilt = ledger_events.rebuild_current_ledger_projection(self.connection)
-        self.assertGreaterEqual(rebuilt, 1)
-        revision = self.current(event_id)
-        self.assertEqual("confirmed", revision["state"])
-        self.assertEqual("receivable", revision["subject_code"])
-
-
-class SubjectSuggestionTests(LedgerBase):
-    def test_mirror_mapping_is_symmetric(self) -> None:
-        for subject, mirror in (
-            ("receivable", "payable"), ("payable", "receivable"),
-            ("other_receivable", "other_payable"), ("other_payable", "other_receivable"),
-        ):
-            self.assertEqual(mirror, subjects.mirror_subject(subject))
-            self.assertEqual(subject, subjects.mirror_subject(mirror))
-
-    def test_loan_keyword_suggests_payer_other_receivable(self) -> None:
-        self.pair(self.company_a, self.company_b, "100.00", summary="借款", purpose="往来款")
-        ledger_events.reconcile_bank_events(self.connection, actor=self.admin)
-        event_id = self.ledger_events()[0]["id"]
-        suggestions = subjects.compute_suggestions(self.connection, event_id)
-        self.assertEqual(1, len(suggestions))
-        self.assertEqual(self.company_a, suggestions[0]["suggested_perspective_company_id"])
-        self.assertEqual("other_receivable", suggestions[0]["suggested_subject_code"])
-        self.assertFalse(suggestions[0]["evidence"]["approved"])
-
-    def test_repay_keyword_suggests_payee(self) -> None:
-        self.pair(self.company_a, self.company_b, "100.00", summary="归还往来款", purpose="还款")
-        ledger_events.reconcile_bank_events(self.connection, actor=self.admin)
-        event_id = self.ledger_events()[0]["id"]
-        suggestions = subjects.compute_suggestions(self.connection, event_id)
-        self.assertEqual(1, len(suggestions))
-        self.assertEqual(self.company_b, suggestions[0]["suggested_perspective_company_id"])
-
-    def test_trade_keyword_never_suggests(self) -> None:
-        # Trade vocabulary needs group approval; no dictionary hit -> review.
-        self.pair(self.company_a, self.company_b, "100.00", summary="货款", purpose="采购货款")
-        ledger_events.reconcile_bank_events(self.connection, actor=self.admin)
-        event_id = self.ledger_events()[0]["id"]
-        self.assertEqual([], subjects.compute_suggestions(self.connection, event_id))
-
-    def test_name_alone_never_confirms(self) -> None:
-        # A name match on the counterparty cannot decide the subject.
-        self.pair(self.company_a, self.company_b, "100.00", summary="某客户往来", purpose=None)
-        ledger_events.reconcile_bank_events(self.connection, actor=self.admin)
-        event_id = self.ledger_events()[0]["id"]
-        current = self.current(event_id)
-        self.assertEqual("pending_subject", current["state"])
-        self.assertEqual([], subjects.compute_suggestions(self.connection, event_id))
-
-
-if __name__ == "__main__":
-    unittest.main()

tests/test_manual_records.py

@@ -1,607 +0,0 @@
-"""B-44 manual record tests: submit idempotency, approve new/link, return,
-exception, reverse, deduplication, idempotent replay and concurrency."""
-
-from __future__ import annotations
-
-from decimal import Decimal
-import threading
-import unittest
-
-from bank_importer import ledger_events, manual_records, matching, subjects
-from ledger_helpers import LedgerBase
-
-
-class SubmitTests(LedgerBase):
-    def submit(self, **overrides):
-        params = dict(
-            company_id=self.company_a,
-            counterparty_company_id=self.company_b,
-            occurred_at="2026-01-10T09:00:00",
-            direction="incoming",
-            amount="50.00",
-            currency="CNY",
-            funding_source="other",
-            requested_subject="other_receivable",
-            request_key="mr-key",
-            actor=self.admin,
-            summary="归还往来款",
-        )
-        params.update(overrides)
-        return manual_records.submit(self.connection, **params)
-
-    def test_submit_creates_pending_decision(self) -> None:
-        payload = self.submit()
-        self.assertEqual("pending", payload["state"])
-        self.assertEqual(Decimal("50.00"), Decimal(payload["amount"]))
-        self.assertEqual(1, payload["decision_revision"])
-        self.assertEqual([], payload["candidates"])
-
-    def test_submit_idempotent_on_request_key(self) -> None:
-        first = self.submit()
-        second = self.submit()
-        self.assertEqual(first["id"], second["id"])
-        self.assertTrue(second["idempotent_replay"])
-        decisions = self.connection.execute(
-            "SELECT COUNT(*) AS n FROM manual_record_decisions"
-        ).fetchone()["n"]
-        self.assertEqual(1, decisions)
-
-    def test_submit_validations(self) -> None:
-        cases = (
-            ({"counterparty_company_id": self.company_a}, "不能与本公司相同"),
-            ({"amount": "0"}, "必须大于零"),
-            ({"amount": "abc"}, "十进制"),
-            ({"funding_source": "credit_card"}, "资金来源"),
-            ({"requested_subject": "equity"}, "科目"),
-            ({"request_key": ""}, "request_key"),
-            ({"counterparty_company_id": 9999}, "公司不存在"),
-        )
-        for overrides, expected in cases:
-            with self.subTest(overrides=overrides):
-                with self.assertRaises(manual_records.ManualInputError) as ctx:
-                    self.submit(**overrides)
-                self.assertIn(expected, str(ctx.exception))
-
-    def test_bank_account_must_belong_to_submitting_company(self) -> None:
-        with self.assertRaises(manual_records.ManualInputError):
-            self.submit(
-                funding_source="approved_bank_account",
-                bank_account_id=self.account_b["id"],
-            )
-
-    def test_related_source_row_never_modified(self) -> None:
-        row_id = self.add_row(
-            self.company_a, own_account="6222000000000001",
-            cp_account="6222000000000002", expense="100.00",
-        )
-        payload = self.submit(related_source_row_id=row_id)
-        self.assertEqual(row_id, payload["related_source_row_id"])
-        with self.assertRaises(Exception):
-            self.connection.execute(
-                "UPDATE source_rows SET expense = '0' WHERE id = ?", (row_id,)
-            )
-        self.connection.rollback()
-
-
-class DecisionTests(LedgerBase):
-    def setUp(self) -> None:
-        super().setUp()
-        self.record = manual_records.submit(
-            self.connection,
-            company_id=self.company_a, counterparty_company_id=self.company_b,
-            occurred_at="2026-01-10T09:00:00", direction="incoming",
-            amount="50.00", currency="CNY", funding_source="other",
-            requested_subject="other_receivable", request_key="mr-1",
-            actor=self.admin, summary="归还往来款",
-        )
-
-    def decide(self, action, **overrides):
-        params = dict(
-            record_id=self.record["id"],
-            action=action,
-            reason="管理员审核",
-            expected_decision_id=self.record["decision_id"],
-            request_key="dec-key",
-            actor=self.admin,
-        )
-        params.update(overrides)
-        return manual_records.decide(self.connection, **params)
-
-    def test_approve_new_creates_confirmed_event_with_requested_subject(self) -> None:
-        outcome = self.decide("approve_new")
-        self.assertEqual("approved", outcome["state"])
-        event_id = outcome["ledger_event_id"]
-        revision = ledger_events.current_revision(self.connection, event_id)
-        self.assertEqual("confirmed", revision["state"])
-        # incoming 50 from A's perspective: B is the payer, A the payee.
-        self.assertEqual(self.company_b, revision["payer_company_id"])
-        self.assertEqual(self.company_a, revision["payee_company_id"])
-        self.assertEqual(self.company_a, revision["perspective_company_id"])
-        self.assertEqual("other_receivable", revision["subject_code"])
-        # Exactly one position impact.
-        positions = self.connection.execute(
-            "SELECT * FROM eligible_position_events"
-        ).fetchall()
-        self.assertEqual(1, len(positions))
-
-    def test_approve_new_replay_is_idempotent(self) -> None:
-        first = self.decide("approve_new")
-        second = self.decide("approve_new")
-        self.assertEqual(first["decision_id"], second["decision_id"])
-        events = self.connection.execute(
-            "SELECT COUNT(*) AS n FROM ledger_events"
-        ).fetchone()["n"]
-        self.assertEqual(1, events)
-
-    def test_return_and_exception_never_produce_balance(self) -> None:
-        for action in ("return", "exception"):
-            with self.subTest(action=action):
-                fresh = manual_records.submit(
-                    self.connection,
-                    company_id=self.company_a, counterparty_company_id=self.company_b,
-                    occurred_at="2026-01-11T09:00:00", direction="incoming",
-                    amount="10.00", currency="CNY", funding_source="other",
-                    requested_subject="receivable", request_key=f"mr-{action}",
-                    actor=self.admin,
-                )
-                outcome = manual_records.decide(
-                    self.connection, fresh["id"], action,
-                    reason="材料不足" if action == "return" else "转入异常",
-                    expected_decision_id=fresh["decision_id"],
-                    request_key=f"dec-{action}", actor=self.admin,
-                )
-                expected_state = "returned" if action == "return" else "exception"
-                self.assertEqual(expected_state, outcome["state"])
-        self.assertEqual(0, self.connection.execute(
-            "SELECT COUNT(*) AS n FROM eligible_position_events"
-        ).fetchone()["n"])
-
-    def test_reverse_of_approved_record_creates_reversal_event(self) -> None:
-        approved = self.decide("approve_new")
-        reversed_outcome = manual_records.decide(
-            self.connection, self.record["id"], "reverse",
-            reason="误录，冲销", expected_decision_id=approved["decision_id"],
-            request_key="dec-rev", actor=self.admin,
-        )
-        self.assertEqual("reversed", reversed_outcome["state"])
-        rows = self.connection.execute(
-            "SELECT * FROM eligible_position_events ORDER BY ledger_event_id"
-        ).fetchall()
-        self.assertEqual(2, len(rows))
-        original, reversal = rows
-        self.assertEqual("normal", original["posting_kind"])
-        self.assertEqual("reversal", reversal["posting_kind"])
-        self.assertEqual(original["payer_company_id"], reversal["payee_company_id"])
-        self.assertEqual(Decimal(original["amount"]), Decimal(reversal["amount"]))
-        # Net position is zero.
-        signed = Decimal(original["amount"]) * (
-            1 if original["payer_company_id"] == self.company_a else -1
-        ) + Decimal(reversal["amount"]) * (
-            1 if reversal["payer_company_id"] == self.company_a else -1
-        )
-        self.assertEqual(Decimal("0"), signed)
-
-    def test_approve_link_to_bank_event_adds_evidence_not_impact(self) -> None:
-        # Build an eligible bank event and confirm its subject.
-        self.pair(self.company_a, self.company_b, "100.00")
-        ledger_events.reconcile_bank_events(self.connection, actor=self.admin)
-        bank_ledger_id = self.ledger_events()[0]["id"]
-        subjects.confirm_subject(
-            self.connection, bank_ledger_id,
-            perspective_company_id=self.company_a, subject_code="other_receivable",
-            reason="借款", expected_revision=1, request_key="subj-1",
-            actor=self.admin,
-        )
-        before = len(self.position_events())
-        outcome = manual_records.decide(
-            self.connection, self.record["id"], "approve_link",
-            reason="与银行事件同源", expected_decision_id=self.record["decision_id"],
-            request_key="dec-link", actor=self.admin,
-            target_ledger_event_id=bank_ledger_id,
-        )
-        self.assertEqual("approved", outcome["state"])
-        self.assertEqual(bank_ledger_id, outcome["ledger_event_id"])
-        after = len(self.position_events())
-        self.assertEqual(before, after)
-        sources = self.connection.execute(
-            "SELECT * FROM ledger_event_manual_sources WHERE manual_record_id = ?",
-            (self.record["id"],),
-        ).fetchall()
-        self.assertEqual(1, len(sources))
-        self.assertEqual(bank_ledger_id, sources[0]["ledger_event_id"])
-
-    def test_approve_link_requires_target(self) -> None:
-        with self.assertRaises(manual_records.ManualInputError):
-            self.decide("approve_link")
-
-    def test_reverse_of_linked_record_detaches_claim_only(self) -> None:
-        self.pair(self.company_a, self.company_b, "100.00")
-        ledger_events.reconcile_bank_events(self.connection, actor=self.admin)
-        bank_ledger_id = self.ledger_events()[0]["id"]
-        subjects.confirm_subject(
-            self.connection, bank_ledger_id,
-            perspective_company_id=self.company_a, subject_code="other_receivable",
-            reason="借款", expected_revision=1, request_key="subj-1",
-            actor=self.admin,
-        )
-        approved = manual_records.decide(
-            self.connection, self.record["id"], "approve_link",
-            reason="同源", expected_decision_id=self.record["decision_id"],
-            request_key="dec-link", actor=self.admin,
-            target_ledger_event_id=bank_ledger_id,
-        )
-        reversed_outcome = manual_records.decide(
-            self.connection, self.record["id"], "reverse",
-            reason="撤销关联", expected_decision_id=approved["decision_id"],
-            request_key="dec-unlink", actor=self.admin,
-        )
-        self.assertEqual("reversed", reversed_outcome["state"])
-        # No reversal event is created for a linked claim.
-        reversals = self.connection.execute(
-            "SELECT COUNT(*) AS n FROM ledger_event_revisions WHERE posting_kind = 'reversal'"
-        ).fetchone()["n"]
-        self.assertEqual(0, reversals)
-        # The bank impact is untouched.
-        self.assertEqual(1, len(self.position_events()))
-
-    def test_stale_expected_decision_conflicts(self) -> None:
-        approved = self.decide("approve_new")
-        with self.assertRaises(manual_records.ManualConflictError):
-            manual_records.decide(
-                self.connection, self.record["id"], "reverse",
-                reason="冲销", expected_decision_id=self.record["decision_id"],
-                request_key="dec-stale", actor=self.admin,
-            )
-
-    def test_returned_record_cannot_be_reversed(self) -> None:
-        returned = self.decide("return", reason="材料不足")
-        with self.assertRaises(manual_records.ManualConflictError):
-            manual_records.decide(
-                self.connection, self.record["id"], "reverse",
-                reason="冲销", expected_decision_id=returned["decision_id"],
-                request_key="dec-x", actor=self.admin,
-            )
-
-    def test_reverse_uses_explicit_effective_date_across_cutoff(self) -> None:
-        # Reversing with an independent effective date must keep the original
-        # impact for cutoffs before it and net it to zero only on/after it —
-        # never rewrite the historical period retroactively.
-        from bank_importer import positions
-        approved = self.decide("approve_new")
-        event_id = approved["ledger_event_id"]
-        self.assertEqual("2026-01-10", self.current(event_id)["effective_at"][:10])
-
-        manual_records.decide(
-            self.connection, self.record["id"], "reverse",
-            reason="误录冲销", expected_decision_id=approved["decision_id"],
-            request_key="dec-rev-date", actor=self.admin,
-            effective_at="2026-06-15",
-        )
-        reversal = self.connection.execute(
-            "SELECT * FROM ledger_event_revisions WHERE posting_kind = 'reversal'"
-        ).fetchone()
-        self.assertEqual("2026-06-15", reversal["effective_at"][:10])
-
-        before = positions.company_balances(
-            self.connection, from_="2026-01-01", cutoff="2026-05-31"
-        )
-        after = positions.company_balances(
-            self.connection, from_="2026-01-01", cutoff="2026-07-31"
-        )
-        for item in before["items"]:
-            if item["company_id"] == self.company_a:
-                self.assertEqual("-50.00", item["result"]["signed_amount"])
-        for item in after["items"]:
-            if item["company_id"] == self.company_a:
-                self.assertEqual("0.00", item["result"]["signed_amount"])
-
-    def test_reverse_defaults_to_approval_business_day(self) -> None:
-        from datetime import datetime, timedelta, timezone
-        from bank_importer import positions
-        approved = self.decide("approve_new")
-        manual_records.decide(
-            self.connection, self.record["id"], "reverse",
-            reason="误录冲销", expected_decision_id=approved["decision_id"],
-            request_key="dec-rev-default", actor=self.admin,
-        )
-        today = datetime.now(timezone(timedelta(hours=8))).date().isoformat()
-        reversal = self.connection.execute(
-            "SELECT * FROM ledger_event_revisions WHERE posting_kind = 'reversal'"
-        ).fetchone()
-        self.assertEqual(today, reversal["effective_at"][:10])
-
-        # The day before the approval business day keeps the original impact.
-        before = positions.company_balances(
-            self.connection, from_="2026-01-01",
-            cutoff=(datetime.fromisoformat(today) - timedelta(days=1)).date().isoformat(),
-        )
-        for item in before["items"]:
-            if item["company_id"] == self.company_a:
-                self.assertEqual("-50.00", item["result"]["signed_amount"])
-
-    def test_reverse_of_creation_source_with_later_linked_evidence(self) -> None:
-        # approve_new created the event; a second manual record later links
-        # onto it. Reversing the creation source must still create an
-        # equal-amount reversal — the original economic impact must not survive
-        # just because other evidence was attached later.
-        approved = self.decide("approve_new")
-        event_id = approved["ledger_event_id"]
-
-        linked = manual_records.submit(
-            self.connection, company_id=self.company_a,
-            counterparty_company_id=self.company_b,
-            occurred_at="2026-01-12T09:00:00", direction="incoming",
-            amount="50.00", currency="CNY", funding_source="other",
-            requested_subject="receivable", request_key="mr-link-ev",
-            actor=self.admin,
-        )
-        manual_records.decide(
-            self.connection, linked["id"], "approve_link",
-            reason="同源补充证据", expected_decision_id=linked["decision_id"],
-            request_key="dec-link-ev", actor=self.admin,
-            target_ledger_event_id=event_id,
-        )
-        self.assertEqual(1, len(self.position_events()))
-
-        reversed_outcome = manual_records.decide(
-            self.connection, self.record["id"], "reverse",
-            reason="误录冲销", expected_decision_id=approved["decision_id"],
-            request_key="dec-rev-create", actor=self.admin,
-        )
-        self.assertEqual("reversed", reversed_outcome["state"])
-        rows = self.connection.execute(
-            "SELECT * FROM eligible_position_events ORDER BY ledger_event_id"
-        ).fetchall()
-        self.assertEqual(2, len(rows))
-        original, reversal = rows
-        self.assertEqual("normal", original["posting_kind"])
-        self.assertEqual("reversal", reversal["posting_kind"])
-        self.assertEqual(Decimal(original["amount"]), Decimal(reversal["amount"]))
-        # The later linked evidence stays attached to the event.
-        links = self.connection.execute(
-            "SELECT * FROM ledger_event_manual_sources ORDER BY manual_record_id"
-        ).fetchall()
-        self.assertEqual(2, len(links))
-
-    def test_reverse_of_linked_record_after_creation_reversal_detaches_only(self) -> None:
-        # M1 creates the event, M2 links; after M1's reversal created the
-        # offset, reversing the linked M2 must only detach, never add a second
-        # reversal event.
-        approved = self.decide("approve_new")
-        event_id = approved["ledger_event_id"]
-        linked = manual_records.submit(
-            self.connection, company_id=self.company_a,
-            counterparty_company_id=self.company_b,
-            occurred_at="2026-01-12T09:00:00", direction="incoming",
-            amount="50.00", currency="CNY", funding_source="other",
-            requested_subject="receivable", request_key="mr-link-ev2",
-            actor=self.admin,
-        )
-        linked_approved = manual_records.decide(
-            self.connection, linked["id"], "approve_link",
-            reason="同源补充证据", expected_decision_id=linked["decision_id"],
-            request_key="dec-link-ev2", actor=self.admin,
-            target_ledger_event_id=event_id,
-        )
-        manual_records.decide(
-            self.connection, self.record["id"], "reverse",
-            reason="误录冲销", expected_decision_id=approved["decision_id"],
-            request_key="dec-rev-create2", actor=self.admin,
-        )
-        manual_records.decide(
-            self.connection, linked["id"], "reverse",
-            reason="撤销关联证据", expected_decision_id=linked_approved["decision_id"],
-            request_key="dec-rev-link2", actor=self.admin,
-        )
-        reversals = self.connection.execute(
-            "SELECT COUNT(*) AS n FROM ledger_event_revisions WHERE posting_kind = 'reversal'"
-        ).fetchone()["n"]
-        self.assertEqual(1, reversals)
-        links = self.connection.execute(
-            "SELECT * FROM ledger_event_manual_sources"
-        ).fetchall()
-        self.assertEqual(1, len(links))
-
-
-class DedupAndConcurrencyTests(LedgerBase):
-    def test_duplicate_manual_record_pairing_candidate(self) -> None:
-        manual_records.submit(
-            self.connection, company_id=self.company_a,
-            counterparty_company_id=self.company_b,
-            occurred_at="2026-01-10T09:00:00", direction="outgoing",
-            amount="40.00", currency="CNY", funding_source="other",
-            requested_subject="other_receivable", request_key="mr-a",
-            actor=self.admin,
-        )
-        other = manual_records.submit(
-            self.connection, company_id=self.company_b,
-            counterparty_company_id=self.company_a,
-            occurred_at="2026-01-10T10:00:00", direction="incoming",
-            amount="40.00", currency="CNY", funding_source="other",
-            requested_subject="other_payable", request_key="mr-b",
-            actor=self.admin,
-        )
-        candidates = manual_records.find_candidates(self.connection, other["id"])
-        self.assertEqual(1, len(candidates))
-        self.assertEqual("manual_record", candidates[0]["kind"])
-
-    def test_duplicate_bank_event_candidate_hints_link(self) -> None:
-        self.pair(self.company_a, self.company_b, "100.00")
-        ledger_events.reconcile_bank_events(self.connection, actor=self.admin)
-        record = manual_records.submit(
-            self.connection, company_id=self.company_a,
-            counterparty_company_id=self.company_b,
-            occurred_at="2026-01-05T12:00:00", direction="incoming",
-            amount="100.00", currency="CNY", funding_source="other",
-            requested_subject="other_receivable", request_key="mr-c",
-            actor=self.admin,
-        )
-        candidates = manual_records.find_candidates(self.connection, record["id"])
-        self.assertTrue(any(c["kind"] == "bank_event" for c in candidates))
-
-    def test_concurrent_approve_new_counts_once(self) -> None:
-        record = manual_records.submit(
-            self.connection, company_id=self.company_a,
-            counterparty_company_id=self.company_b,
-            occurred_at="2026-01-10T09:00:00", direction="incoming",
-            amount="50.00", currency="CNY", funding_source="other",
-            requested_subject="receivable", request_key="mr-conc",
-            actor=self.admin,
-        )
-        errors: list[Exception] = []
-
-        def worker(thread_key: str) -> None:
-            import sqlite3
-
-            try:
-                connection = sqlite3.connect(self.db_path, timeout=30)
-                connection.row_factory = sqlite3.Row
-                try:
-                    manual_records.decide(
-                        connection, record["id"], "approve_new",
-                        reason="并发审批", expected_decision_id=record["decision_id"],
-                        request_key=f"dec-{thread_key}", actor=self.admin,
-                    )
-                finally:
-                    connection.close()
-            except Exception as exc:  # pragma: no cover
-                errors.append(exc)
-
-        threads = [
-            threading.Thread(target=worker, args=(f"t{i}",)) for i in range(4)
-        ]
-        for thread in threads:
-            thread.start()
-        for thread in threads:
-            thread.join()
-
-        # Two connections can still double-commit, so the UNIQUE manual source
-        # claim must make the second write fail or be a no-op; either way only
-        # one ledger event may exist.
-        events = self.connection.execute(
-            "SELECT COUNT(*) AS n FROM ledger_events"
-        ).fetchone()["n"]
-        self.assertEqual(1, events)
-
-    def test_concurrent_submit_same_request_key_is_idempotent(self) -> None:
-        import sqlite3
-
-        results: list[dict] = []
-        errors: list[Exception] = []
-
-        def worker(thread_key: str) -> None:
-            try:
-                connection = sqlite3.connect(self.db_path, timeout=30)
-                connection.row_factory = sqlite3.Row
-                try:
-                    payload = manual_records.submit(
-                        connection, company_id=self.company_a,
-                        counterparty_company_id=self.company_b,
-                        occurred_at="2026-01-10T09:00:00", direction="incoming",
-                        amount="50.00", currency="CNY", funding_source="other",
-                        requested_subject="receivable",
-                        request_key="mr-conc-submit", actor=self.admin,
-                    )
-                    results.append(payload)
-                finally:
-                    connection.close()
-            except Exception as exc:  # pragma: no cover
-                errors.append(exc)
-
-        threads = [
-            threading.Thread(target=worker, args=(f"t{i}",)) for i in range(4)
-        ]
-        for thread in threads:
-            thread.start()
-        for thread in threads:
-            thread.join()
-
-        self.assertEqual([], errors)
-        rows = self.connection.execute(
-            "SELECT COUNT(*) AS n FROM manual_records"
-        ).fetchone()["n"]
-        self.assertEqual(1, rows)
-        self.assertEqual(1, len({payload["id"] for payload in results}))
-        decisions = self.connection.execute(
-            "SELECT COUNT(*) AS n FROM manual_record_decisions"
-        ).fetchone()["n"]
-        self.assertEqual(1, decisions)
-
-    def test_concurrent_confirm_subject_same_key_creates_single_revision(self) -> None:
-        import sqlite3
-
-        self.pair(self.company_a, self.company_b, "100.00")
-        from bank_importer import ledger_events
-        ledger_events.reconcile_bank_events(self.connection, actor=self.admin)
-        event_id = self.ledger_events()[0]["id"]
-
-        outcomes: list[dict] = []
-        errors: list[Exception] = []
-
-        def worker(thread_key: str) -> None:
-            try:
-                connection = sqlite3.connect(self.db_path, timeout=30)
-                connection.row_factory = sqlite3.Row
-                try:
-                    payload = subjects.confirm_subject(
-                        connection, event_id,
-                        perspective_company_id=self.company_a,
-                        subject_code="other_receivable", reason="并发确认",
-                        expected_revision=1, request_key="conc-subj-key",
-                        actor=self.admin,
-                    )
-                    outcomes.append(payload)
-                finally:
-                    connection.close()
-            except Exception as exc:  # pragma: no cover
-                errors.append(exc)
-
-        threads = [
-            threading.Thread(target=worker, args=(f"t{i}",)) for i in range(4)
-        ]
-        for thread in threads:
-            thread.start()
-        for thread in threads:
-            thread.join()
-
-        self.assertEqual([], errors)
-        confirmed = self.connection.execute(
-            "SELECT COUNT(*) AS n FROM ledger_event_revisions WHERE state = 'confirmed'"
-        ).fetchone()["n"]
-        self.assertEqual(1, confirmed)
-        self.assertEqual(1, len({payload["revision_id"] for payload in outcomes}))
-
-    def test_repeated_confirm_same_key_appends_no_noise_revision(self) -> None:
-        self.pair(self.company_a, self.company_b, "100.00")
-        from bank_importer import ledger_events
-        ledger_events.reconcile_bank_events(self.connection, actor=self.admin)
-        event_id = self.ledger_events()[0]["id"]
-        first = subjects.confirm_subject(
-            self.connection, event_id,
-            perspective_company_id=self.company_a, subject_code="other_receivable",
-            reason="确认", expected_revision=1, request_key="noise-key",
-            actor=self.admin,
-        )
-        second = subjects.confirm_subject(
-            self.connection, event_id,
-            perspective_company_id=self.company_a, subject_code="other_receivable",
-            reason="重复确认", expected_revision=1, request_key="noise-key",
-            actor=self.admin,
-        )
-        self.assertEqual(first["revision_id"], second["revision_id"])
-        revisions = self.connection.execute(
-            "SELECT COUNT(*) AS n FROM ledger_event_revisions WHERE ledger_event_id = ?",
-            (event_id,),
-        ).fetchone()["n"]
-        # One pending_subject + one confirmed; the replay appended nothing.
-        self.assertEqual(2, revisions)
-        confirmed = self.connection.execute(
-            "SELECT COUNT(*) AS n FROM ledger_event_revisions "
-            "WHERE ledger_event_id = ? AND state = 'confirmed'",
-            (event_id,),
-        ).fetchone()["n"]
-        self.assertEqual(1, confirmed)
-
-
-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], first)
         self.assertEqual([], migrate(self.connection))
         self.assertEqual(first, applied_versions(self.connection))
         tables = {
@@ -73,31 +73,19 @@ class MigrationTests(PersistenceTestCase):
             "transfer_match_candidates",
             "current_transfer_decisions",
             "transfer_observation_claims",
-            "manual_records",
-            "manual_record_decisions",
-            "current_manual_record_decisions",
-            "ledger_events",
-            "ledger_event_revisions",
-            "current_ledger_event_revisions",
-            "ledger_event_bank_sources",
-            "ledger_event_manual_sources",
-            "ledger_subject_suggestions",
-            "system_settings",
-            "system_setting_changes",
-            "reminders",
             "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([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], migrate(self.connection))
+        self.assertEqual([1, 2, 3, 4, 5], applied_versions(self.connection))
 
     def test_rollback_to_4_keeps_bank_evidence_and_drops_event_layer(self) -> None:
         self.import_sample()
@@ -105,7 +93,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([5], rollback(self.connection, 4))
         # The pre-migration evidence and schema are untouched.
         self.assertEqual(
             row_count,
@@ -121,10 +109,6 @@ class MigrationTests(PersistenceTestCase):
             "SELECT name FROM sqlite_master WHERE type = 'table' AND name = 'transfer_match_decisions'"
         ).fetchone()
         self.assertIsNone(remaining)
-        ledger_remaining = self.connection.execute(
-            "SELECT name FROM sqlite_master WHERE type = 'table' AND name = 'ledger_event_revisions'"
-        ).fetchone()
-        self.assertIsNone(ledger_remaining)
 
     def test_event_layer_views_exist_after_migration(self) -> None:
         view = self.connection.execute(
@@ -132,93 +116,6 @@ class MigrationTests(PersistenceTestCase):
         ).fetchone()
         self.assertIsNotNone(view)
 
-    def test_ledger_layer_views_exist_after_migration(self) -> None:
-        view = self.connection.execute(
-            "SELECT name FROM sqlite_master WHERE type = 'view' AND name = 'eligible_position_events'"
-        ).fetchone()
-        self.assertIsNotNone(view)
-        table = self.connection.execute(
-            "SELECT name FROM sqlite_master WHERE type = 'table' AND name = 'ledger_event_revisions'"
-        ).fetchone()
-        self.assertIsNotNone(table)
-
-    def test_ledger_revision_log_is_immutable(self) -> None:
-        with self.connection:
-            self.connection.execute(
-                "INSERT INTO companies (name, created_at, updated_at) VALUES ('甲公司', ?, ?)",
-                (utc_now(), utc_now()),
-            )
-            self.connection.execute(
-                "INSERT INTO companies (name, created_at, updated_at) VALUES ('乙公司', ?, ?)",
-                (utc_now(), utc_now()),
-            )
-            company_a, company_b = [
-                row["id"]
-                for row in self.connection.execute("SELECT id FROM companies ORDER BY id")
-            ]
-            self.connection.execute(
-                "INSERT INTO ledger_events (lifecycle, created_at) VALUES ('active', ?)",
-                (utc_now(),),
-            )
-            event_id = self.connection.execute(
-                "SELECT id FROM ledger_events LIMIT 1"
-            ).fetchone()["id"]
-            self.connection.execute(
-                """
-                INSERT INTO ledger_event_revisions (
-                    ledger_event_id, revision, state, effective_at, amount,
-                    amount_scale, currency, payer_company_id, payee_company_id,
-                    source_kind, posting_kind, created_at
-                ) VALUES (?, 1, 'pending_subject', '2026-01-01T00:00:00', '1.00', 2,
-                          'CNY', ?, ?, 'bank', 'normal', ?)
-                """,
-                (event_id, company_a, company_b, utc_now()),
-            )
-        for statement in (
-            "UPDATE ledger_event_revisions SET amount = '9.99'",
-            "DELETE FROM ledger_event_revisions",
-            "UPDATE ledger_events SET created_at = '2020-01-01T00:00:00'",
-            "DELETE FROM ledger_events",
-        ):
-            with self.subTest(statement=statement):
-                with self.assertRaises(sqlite3.IntegrityError):
-                    self.connection.execute(statement)
-                self.connection.rollback()
-
-    def test_manual_record_facts_are_immutable(self) -> None:
-        with self.connection:
-            self.connection.execute(
-                "INSERT INTO companies (name, created_at, updated_at) VALUES ('甲公司', ?, ?)",
-                (utc_now(), utc_now()),
-            )
-            self.connection.execute(
-                "INSERT INTO companies (name, created_at, updated_at) VALUES ('乙公司', ?, ?)",
-                (utc_now(), utc_now()),
-            )
-            company_a, company_b = [
-                row["id"]
-                for row in self.connection.execute("SELECT id FROM companies ORDER BY id")
-            ]
-            self.connection.execute(
-                """
-                INSERT INTO manual_records (
-                    company_id, counterparty_company_id, occurred_at, direction,
-                    amount, amount_scale, currency, funding_source, requested_subject,
-                    request_key, created_at
-                ) VALUES (?, ?, '2026-01-01T00:00:00', 'incoming', '1.00', 2,
-                          'CNY', 'other', 'receivable', 'k1', ?)
-                """,
-                (company_a, company_b, utc_now()),
-            )
-        for statement in (
-            "UPDATE manual_records SET amount = '9.99'",
-            "DELETE FROM manual_records",
-        ):
-            with self.subTest(statement=statement):
-                with self.assertRaises(sqlite3.IntegrityError):
-                    self.connection.execute(statement)
-                self.connection.rollback()
-
     def test_decision_log_immutability_triggers(self) -> None:
         self.import_sample()
         source_row_id = self.connection.execute(

tests/test_positions.py

@@ -1,430 +0,0 @@
-"""B-44 position aggregation tests: conservation, repayments, reversals across
-cutoffs, currency isolation, Decimal precision, unresolved gross, normal
-balance exceptions and keyset pagination."""
-
-from __future__ import annotations
-
-from decimal import Decimal, getcontext
-import unittest
-
-from bank_importer import ledger_events, manual_records, positions, subjects
-from ledger_helpers import LedgerBase
-
-
-def confirm(connection, event_id: int, perspective: int, subject: str, key: str, actor):
-    return subjects.confirm_subject(
-        connection, event_id,
-        perspective_company_id=perspective, subject_code=subject,
-        reason="审核确认", expected_revision=1, request_key=key, actor=actor,
-    )
-
-
-class ConservationTests(LedgerBase):
-    def setUp(self) -> None:
-        super().setUp()
-        getcontext().prec = 50
-
-    def _confirm_all(self, subject: str = "other_receivable"):
-        ledger_events.reconcile_bank_events(self.connection, actor=self.admin)
-        for event in self.ledger_events():
-            revision = self.current(event["id"])
-            confirm(
-                self.connection, event["id"],
-                revision["payer_company_id"], subject, f"subj-{event['id']}",
-                self.admin,
-            )
-
-    def test_both_perspectives_mirror_exactly(self) -> None:
-        self.pair(self.company_a, self.company_b, "100.00")
-        self.pair(self.company_a, self.company_b, "30.00", at="2026-01-10T10:00:00")
-        self.pair(self.company_a, self.company_b, "70.00", at="2026-02-05T10:00:00")
-        self._confirm_all()
-        pair = positions.pair_detail(
-            self.connection, self.company_a, self.company_b,
-            from_="2026-01-01", cutoff="2026-07-31",
-        )
-        item = pair["items"][0]
-        self.assertTrue(item["conservation"]["opposite"])
-        self.assertTrue(item["conservation"]["abs_equal"])
-        self.assertEqual(Decimal("200.00"), Decimal(item["a"]["result"]["signed_amount"]))
-        self.assertEqual(Decimal("-200.00"), Decimal(item["b"]["result"]["signed_amount"]))
-
-    def test_repayment_reduces_the_original_balance(self) -> None:
-        # A lends B 100 (A pays) then B repays 40 (B pays).
-        self.pair(self.company_a, self.company_b, "100.00")
-        self.pair(self.company_b, self.company_a, "40.00", at="2026-03-01T10:00:00",
-                  summary="还款", purpose="归还借款")
-        self._confirm_all()
-        balances = positions.company_balances(
-            self.connection, from_="2026-01-01", cutoff="2026-07-31"
-        )
-        for item in balances["items"]:
-            if item["company_id"] == self.company_a:
-                self.assertEqual(Decimal("60.00"), Decimal(item["result"]["signed_amount"]))
-                self.assertEqual(Decimal("100.00"), Decimal(item["period"]["debit"]))
-                self.assertEqual(Decimal("40.00"), Decimal(item["period"]["credit"]))
-            else:
-                self.assertEqual(Decimal("-60.00"), Decimal(item["result"]["signed_amount"]))
-                self.assertEqual(Decimal("40.00"), Decimal(item["period"]["debit"]))
-                self.assertEqual(Decimal("100.00"), Decimal(item["period"]["credit"]))
-
-    def test_over_repayment_flags_normal_balance_exception(self) -> None:
-        # A lends B 100, then B repays 150 while A books the repayment against
-        # its receivable: A's receivable and B's payable both go negative.
-        self.pair(self.company_a, self.company_b, "100.00")
-        self.pair(self.company_b, self.company_a, "150.00", at="2026-03-01T10:00:00",
-                  summary="还款", purpose="归还借款")
-        ledger_events.reconcile_bank_events(self.connection, actor=self.admin)
-        for event in self.ledger_events():
-            revision = self.current(event["id"])
-            # Book every event from A's perspective on the receivable side so
-            # the over-repayment produces abnormal balances.
-            confirm(
-                self.connection, event["id"], self.company_a,
-                "other_receivable", f"k-{event['id']}", self.admin,
-            )
-        pair = positions.pair_detail(
-            self.connection, self.company_a, self.company_b,
-            from_="2026-01-01", cutoff="2026-07-31",
-        )
-        item = pair["items"][0]
-        self.assertTrue(item["normal_balance_exception"])
-        self.assertIn("other_receivable", item["normal_balance_exception"])
-        self.assertIn("other_payable", item["normal_balance_exception"])
-
-
-class CutoffAndReversalTests(LedgerBase):
-    def _loan(self) -> int:
-        self.pair(self.company_a, self.company_b, "100.00")
-        ledger_events.reconcile_bank_events(self.connection, actor=self.admin)
-        event_id = self.ledger_events()[0]["id"]
-        confirm(self.connection, event_id, self.company_a, "other_receivable", "k1", self.admin)
-        return event_id
-
-    def test_cutoff_before_reversal_keeps_original_impact(self) -> None:
-        event_id = self._loan()
-        # Reversal dated after the original event.
-        ledger_events.create_reversal(
-            self.connection, event_id, source_kind="adjustment",
-            effective_at="2026-06-15T00:00:00", reason="冲销", actor=self.admin,
-        )
-        before = positions.company_balances(
-            self.connection, from_="2026-01-01", cutoff="2026-05-31"
-        )
-        after = positions.company_balances(
-            self.connection, from_="2026-01-01", cutoff="2026-07-31"
-        )
-        for item in before["items"]:
-            if item["company_id"] == self.company_a:
-                self.assertEqual(Decimal("100.00"), Decimal(item["result"]["signed_amount"]))
-        for item in after["items"]:
-            if item["company_id"] == self.company_a:
-                self.assertEqual(Decimal("0"), Decimal(item["result"]["signed_amount"]))
-
-    def test_from_gt_cutoff_is_rejected(self) -> None:
-        with self.assertRaises(positions.PositionInputError):
-            positions.validate_window("2026-08-01", "2026-07-31")
-
-    def test_events_before_from_are_excluded_from_period(self) -> None:
-        self._loan()
-        balances = positions.company_balances(
-            self.connection, from_="2026-06-01", cutoff="2026-07-31"
-        )
-        self.assertEqual([], balances["items"])
-
-    def test_reversal_uses_approved_effective_date(self) -> None:
-        event_id = self._loan()
-        ledger_events.create_reversal(
-            self.connection, event_id, source_kind="adjustment",
-            effective_at="2026-08-01T00:00:00", reason="未来冲销", actor=self.admin,
-        )
-        balances = positions.company_balances(
-            self.connection, from_="2026-01-01", cutoff="2026-07-31"
-        )
-        for item in balances["items"]:
-            if item["company_id"] == self.company_a:
-                # The future reversal does not rewrite the earlier cutoff.
-                self.assertEqual(Decimal("100.00"), Decimal(item["result"]["signed_amount"]))
-
-
-class CurrencyAndPrecisionTests(LedgerBase):
-    def test_currencies_never_mix(self) -> None:
-        self.pair(self.company_a, self.company_b, "100.00", currency="CNY")
-        self.pair(self.company_a, self.company_b, "50.00", at="2026-01-20T10:00:00",
-                  currency="USD")
-        ledger_events.reconcile_bank_events(self.connection, actor=self.admin)
-        events = self.ledger_events()
-        for event in events:
-            revision = self.current(event["id"])
-            confirm(self.connection, event["id"], revision["payer_company_id"],
-                    "other_receivable", f"k-{event['id']}", self.admin)
-        balances = positions.company_balances(
-            self.connection, from_="2026-01-01", cutoff="2026-07-31"
-        )
-        by_company = {}
-        for item in balances["items"]:
-            by_company.setdefault(item["company_id"], {})[item["currency"]] = item["result"]
-        self.assertEqual(Decimal("100.00"), Decimal(by_company[self.company_a]["CNY"]["signed_amount"]))
-        self.assertEqual(Decimal("50.00"), Decimal(by_company[self.company_a]["USD"]["signed_amount"]))
-
-    def test_decimal_precision_is_preserved(self) -> None:
-        self.pair(self.company_a, self.company_b, "0.01")
-        self.pair(self.company_a, self.company_b, "12345.6789", at="2026-01-11T10:00:00")
-        ledger_events.reconcile_bank_events(self.connection, actor=self.admin)
-        for event in self.ledger_events():
-            revision = self.current(event["id"])
-            confirm(self.connection, event["id"], revision["payer_company_id"],
-                    "other_receivable", f"k-{event['id']}", self.admin)
-        balances = positions.company_balances(
-            self.connection, from_="2026-01-01", cutoff="2026-07-31"
-        )
-        for item in balances["items"]:
-            if item["company_id"] == self.company_a:
-                self.assertEqual(
-                    Decimal("12345.6889"), Decimal(item["result"]["signed_amount"])
-                )
-                # The stored string keeps every decimal place.
-                self.assertIn("12345.6889", item["result"]["signed_amount"])
-
-    def test_manual_record_preserves_amount_scale(self) -> None:
-        record = manual_records.submit(
-            self.connection, company_id=self.company_a,
-            counterparty_company_id=self.company_b,
-            occurred_at="2026-02-01T09:00:00", direction="incoming",
-            amount="12.3400", currency="CNY", funding_source="other",
-            requested_subject="receivable", request_key="mr-prec",
-            actor=self.admin,
-        )
-        manual_records.decide(
-            self.connection, record["id"], "approve_new",
-            reason="确认", expected_decision_id=record["decision_id"],
-            request_key="dec-prec", actor=self.admin,
-        )
-        stored = self.connection.execute(
-            "SELECT amount, amount_scale FROM eligible_position_events"
-        ).fetchone()
-        self.assertEqual("12.3400", stored["amount"])
-        self.assertEqual(4, stored["amount_scale"])
-
-
-class UnresolvedTests(LedgerBase):
-    def test_unresolved_gross_never_nets(self) -> None:
-        # Two pending_subject events of opposite economic signs must sum their
-        # absolute values, never cancel.
-        self.pair(self.company_a, self.company_b, "100.00")
-        self.pair(self.company_a, self.company_b, "40.00", at="2026-01-20T10:00:00",
-                  summary="还款", purpose="归还借款")
-        ledger_events.reconcile_bank_events(self.connection, actor=self.admin)
-        unresolved = positions.unresolved_for_company(
-            self.connection, self.company_a, "2026-07-31"
-        )
-        self.assertEqual(2, unresolved["count"])
-        self.assertEqual(
-            Decimal("140.00"), Decimal(unresolved["gross_amount"])
-        )
-        self.assertEqual(
-            Decimal("140.00"),
-            Decimal(unresolved["by_reason"]["subject_review"]["gross_amount"]),
-        )
-
-    def test_unmatched_single_reason_bucket(self) -> None:
-        self.add_row(
-            self.company_a, own_account="6222000000000001",
-            cp_account="6222000000000002", expense="88.00",
-        )
-        from bank_importer import matching
-        matching.reconcile_rows(self.connection, [1])
-        unresolved = positions.unresolved_for_company(
-            self.connection, self.company_a, "2026-07-31"
-        )
-        self.assertEqual(1, unresolved["count"])
-        self.assertEqual(
-            Decimal("88.00"),
-            Decimal(unresolved["by_reason"]["unmatched_single"]["gross_amount"]),
-        )
-
-    def test_pending_manual_only_counts_for_submitting_company(self) -> None:
-        manual_records.submit(
-            self.connection, company_id=self.company_a,
-            counterparty_company_id=self.company_b,
-            occurred_at="2026-01-10T09:00:00", direction="incoming",
-            amount="50.00", currency="CNY", funding_source="other",
-            requested_subject="receivable", request_key="mr-a",
-            actor=self.admin,
-        )
-        a_unresolved = positions.unresolved_for_company(
-            self.connection, self.company_a, "2026-07-31"
-        )
-        b_unresolved = positions.unresolved_for_company(
-            self.connection, self.company_b, "2026-07-31"
-        )
-        self.assertEqual(1, a_unresolved["count"])
-        self.assertEqual(
-            Decimal("50.00"), Decimal(a_unresolved["by_reason"]["manual_pending"]["gross_amount"])
-        )
-        # The counterparty never sees the unapproved declaration.
-        self.assertEqual(0, b_unresolved["count"])
-
-
-class PaginationTests(LedgerBase):
-    def test_subject_filter_matches_stored_and_mirror_subjects(self) -> None:
-        # A books "receivable" from its own perspective; B sees the mirror
-        # "payable". Filtering by B's mirror subject must still find the event.
-        self.pair(self.company_a, self.company_b, "100.00")
-        ledger_events.reconcile_bank_events(self.connection, actor=self.admin)
-        event_id = self.ledger_events()[0]["id"]
-        confirm(self.connection, event_id, self.company_a, "receivable", "k-mirror",
-                self.admin)
-
-        stored = positions.list_events(
-            self.connection, from_="2026-01-01", cutoff="2026-07-31",
-            subject="receivable",
-        )
-        self.assertTrue(any(
-            item["ledger_event_id"] == event_id for item in stored["items"]
-        ))
-        # Company B filters by its own perspective: the stored "receivable" is
-        # the mirror of "payable", so it must be included.
-        mirror = positions.list_events(
-            self.connection, from_="2026-01-01", cutoff="2026-07-31",
-            subject="payable", viewer_company_id=self.company_b,
-        )
-        self.assertTrue(any(
-            item["ledger_event_id"] == event_id for item in mirror["items"]
-        ), mirror)
-        for item in mirror["items"]:
-            if item["ledger_event_id"] == event_id:
-                self.assertEqual("payable", item["own_subject"])
-
-    def test_subject_filter_without_match_returns_empty(self) -> None:
-        self.pair(self.company_a, self.company_b, "100.00")
-        ledger_events.reconcile_bank_events(self.connection, actor=self.admin)
-        event_id = self.ledger_events()[0]["id"]
-        confirm(self.connection, event_id, self.company_a, "receivable", "k-none",
-                self.admin)
-        other = positions.list_events(
-            self.connection, from_="2026-01-01", cutoff="2026-07-31",
-            subject="other_receivable",
-        )
-        self.assertEqual([], other["items"])
-
-    def test_pagination_is_stable_and_complete(self) -> None:
-        for index in range(7):
-            at = f"2026-01-{(index % 28) + 1:02d}T10:00:00"
-            self.pair(self.company_a, self.company_b, f"{index + 1}.00", at=at)
-        ledger_events.reconcile_bank_events(self.connection, actor=self.admin)
-        for event in self.ledger_events():
-            revision = self.current(event["id"])
-            confirm(self.connection, event["id"], revision["payer_company_id"],
-                    "other_receivable", f"k-{event['id']}", self.admin)
-
-        seen: list[int] = []
-        cursor = None
-        pages = 0
-        while True:
-            page = positions.list_events(
-                self.connection, from_="2026-01-01", cutoff="2026-07-31",
-                limit=3, cursor=cursor,
-            )
-            pages += 1
-            seen.extend(item["ledger_event_id"] for item in page["items"])
-            cursor = page["next_cursor"]
-            if not page["has_more"]:
-                break
-        self.assertEqual(7, len(seen))
-        self.assertEqual(len(set(seen)), len(seen))
-        self.assertGreater(pages, 2)
-
-    def test_directory_pagination_complete(self) -> None:
-        for index in range(6):
-            at = f"2026-01-{(index % 28) + 1:02d}T10:00:00"
-            self.pair(self.company_a, self.company_b, f"{index + 1}.00", at=at)
-        ledger_events.reconcile_bank_events(self.connection, actor=self.admin)
-        for event in self.ledger_events():
-            revision = self.current(event["id"])
-            confirm(self.connection, event["id"], revision["payer_company_id"],
-                    "other_receivable", f"k-{event['id']}", self.admin)
-        seen: set[tuple[int, str]] = set()
-        cursor = None
-        while True:
-            page = positions.company_balances(
-                self.connection, from_="2026-01-01", cutoff="2026-07-31",
-                limit=1, cursor=cursor,
-            )
-            seen.update((item["company_id"], item["currency"]) for item in page["items"])
-            cursor = page["next_cursor"]
-            if not page["has_more"]:
-                break
-        self.assertEqual(
-            {(self.company_a, "CNY"), (self.company_b, "CNY")}, seen
-        )
-
-    def test_event_payload_account_chip_and_repayment_flag(self) -> None:
-        self.pair(
-            self.company_a, self.company_b, "40.00",
-            summary="归还往来款", purpose="还款",
-        )
-        ledger_events.reconcile_bank_events(self.connection, actor=self.admin)
-        event_id = int(self.ledger_events()[0]["id"])
-        detail = positions.event_detail(self.connection, event_id)
-        event = detail["event"]
-        self.assertEqual("visible", event["payer_account"]["visibility"])
-        self.assertEqual("测试 0001", event["payer_account"]["label"])
-        self.assertEqual("visible", event["payee_account"]["visibility"])
-        self.assertEqual("测试 0002", event["payee_account"]["label"])
-        self.assertEqual("归还往来款", event["summary"])
-        self.assertTrue(event["is_repayment"])
-
-        company_view = positions.event_payload(
-            self.connection,
-            self.connection.execute(
-                positions._DETAIL_SELECT + " WHERE p.ledger_event_id = ?",
-                (event_id,),
-            ).fetchone(),
-            viewer_company_id=self.company_a,
-        )
-        self.assertEqual("visible", company_view["payer_account"]["visibility"])
-        self.assertEqual("masked", company_view["payee_account"]["visibility"])
-        self.assertEqual("按对方授权不可见", company_view["payee_account"]["label"])
-
-    def test_park_subject_exception_hides_from_review_queue(self) -> None:
-        self.pair(self.company_a, self.company_b, "100.00")
-        ledger_events.reconcile_bank_events(self.connection, actor=self.admin)
-        event_id = int(self.ledger_events()[0]["id"])
-        current = self.current(event_id)
-        subjects.park_subject(
-            self.connection, event_id,
-            disposition="exception", reason="转异常核查",
-            expected_revision=current["id"], request_key="park-exc-1",
-            actor=self.admin,
-        )
-        queue = positions.subject_review_queue(
-            self.connection, from_="2026-01-01", cutoff="2026-07-31",
-        )
-        self.assertFalse(
-            any(item["ledger_event_id"] == event_id for item in queue["items"])
-        )
-        revision = self.current(event_id)
-        self.assertEqual("pending_subject", revision["state"])
-
-    def test_park_subject_return_stays_in_review_queue(self) -> None:
-        self.pair(self.company_a, self.company_b, "80.00")
-        ledger_events.reconcile_bank_events(self.connection, actor=self.admin)
-        event_id = int(self.ledger_events()[0]["id"])
-        current = self.current(event_id)
-        subjects.park_subject(
-            self.connection, event_id,
-            disposition="return", reason="退回补充摘要",
-            expected_revision=current["id"], request_key="park-ret-1",
-            actor=self.admin,
-        )
-        queue = positions.subject_review_queue(
-            self.connection, from_="2026-01-01", cutoff="2026-07-31",
-        )
-        self.assertTrue(
-            any(item["ledger_event_id"] == event_id for item in queue["items"])
-        )
-
-
-if __name__ == "__main__":
-    unittest.main()

tests/test_positions_api.py

@@ -1,594 +0,0 @@
-"""HTTP integration tests for the B-44 intercompany position APIs.
-
-Covers the admin balances/pair/events/evidence/subject-review/manual-record
-endpoints and the company-side scoped reads with masked evidence, plus
-cross-tenant 404s and company-forbidden admin writes. Every test method spins
-up its own server with a fresh database so subject confirmations and matched
-fixtures never leak across tests.
-"""
-
-from __future__ import annotations
-
-import io
-import json
-import os
-from pathlib import Path
-import tempfile
-import threading
-import unittest
-
-from openpyxl import Workbook
-
-from bank_importer.db import connect, migrate
-
-import server
-from test_server_auth import Client, as_json
-
-BOOTSTRAP_PASSWORD = "BootAdmin123"
-ADMIN_PASSWORD = "AdminPass123"
-CASHIER_PASSWORD = "Cashier123"
-
-CCB_HEADER = [
-    "客户账号", "账户名称", "交易时间", "借方发生额（支取）", "贷方发生额（收入）",
-    "余额", "币种", "对方户名", "对方账号", "对方开户机构", "摘要", "备注",
-]
-
-ACCOUNT_A = "6222000000000001"
-ACCOUNT_B = "6222000000000002"
-
-
-def workbook_bytes(rows) -> bytes:
-    workbook = Workbook()
-    sheet = workbook.active
-    sheet.title = "正常流水"
-    sheet.append(CCB_HEADER)
-    for row in rows:
-        sheet.append(row)
-    buffer = io.BytesIO()
-    workbook.save(buffer)
-    return buffer.getvalue()
-
-
-def outgoing(own: str, cp: str, amount: str, at: str = "2026-01-05 10:00:00",
-             currency: str = "RMB"):
-    return [own, "测试公司", at, amount, "", "50000.00", currency, "对方", cp, "某银行", "借款", ""]
-
-
-def incoming(own: str, cp: str, amount: str, at: str = "2026-01-05 11:00:00",
-             currency: str = "RMB"):
-    return [own, "测试公司", at, "", amount, "50000.00", currency, "对方", cp, "某银行", "借款", ""]
-
-
-class IntercompanyApiTests(unittest.TestCase):
-    def setUp(self) -> None:
-        self.temp_dir = tempfile.TemporaryDirectory()
-        self.addCleanup(self.temp_dir.cleanup)
-        root = Path(self.temp_dir.name)
-        self.db_path = root / "app.db"
-        self.storage = root / "files"
-        self.initial_passwords: dict[str, str] = {}
-
-        self._old_db_path = server.DB_PATH
-        self._old_storage = server.STORAGE_DIR
-        server.DB_PATH = self.db_path
-        server.STORAGE_DIR = self.storage
-
-        os.environ["APP_BOOTSTRAP_ADMIN_PASSWORD"] = BOOTSTRAP_PASSWORD
-        connection = connect(self.db_path)
-        migrate(connection)
-        assert server.ensure_bootstrap_admin(connection) is None
-        connection.close()
-
-        class QuietHandler(server.AppHandler):
-            def log_message(self, *args) -> None:
-                pass
-
-        self.httpd = server.ThreadingHTTPServer(("127.0.0.1", 0), QuietHandler)
-        self.port = self.httpd.server_address[1]
-        self.thread = threading.Thread(target=self.httpd.serve_forever, daemon=True)
-        self.thread.start()
-
-        self.admin = Client("127.0.0.1", self.port)
-        status, _, data = self.admin.post_json(
-            "/api/login",
-            {"username": "group-admin", "password": BOOTSTRAP_PASSWORD, "portal": "admin"},
-        )
-        assert status == 200, data
-        status, _, data = self.admin.post_json(
-            "/api/password/change",
-            {"old_password": BOOTSTRAP_PASSWORD, "new_password": ADMIN_PASSWORD},
-        )
-        assert status == 200, data
-
-        self.company_a = self._create_company("甲公司", "cashier-a")
-        self.company_b = self._create_company("乙公司", "cashier-b")
-        self.company_c = self._create_company("丙公司", "cashier-c")
-        self.cashier_a = self._login_company("cashier-a", self.company_a)
-        self.cashier_b = self._login_company("cashier-b", self.company_b)
-        self.cashier_c = self._login_company("cashier-c", self.company_c)
-
-        self._approve_account(self.company_a, ACCOUNT_A)
-        self._approve_account(self.company_b, ACCOUNT_B)
-
-    def tearDown(self) -> None:
-        self.httpd.shutdown()
-        self.httpd.server_close()
-        server.DB_PATH = self._old_db_path
-        server.STORAGE_DIR = self._old_storage
-        os.environ.pop("APP_BOOTSTRAP_ADMIN_PASSWORD", None)
-
-    def _create_company(self, name: str, username: str) -> int:
-        status, _, data = self.admin.post_json(
-            "/api/admin/companies", {"name": name, "username": username}
-        )
-        assert status == 200, data
-        self.initial_passwords.setdefault(username, as_json(data)["initial_password"])
-        return as_json(data)["company_id"]
-
-    def _login_company(self, username: str, company_id: int) -> Client:
-        client = Client("127.0.0.1", self.port)
-        initial = self.initial_passwords[username]
-        status, _, data = client.post_json(
-            "/api/login", {"username": username, "password": initial, "portal": "company"}
-        )
-        assert status == 200, data
-        status, _, data = client.post_json(
-            "/api/password/change",
-            {"old_password": initial, "new_password": CASHIER_PASSWORD},
-        )
-        assert status == 200, data
-        return client
-
-    def _approve_account(self, company_id: int, number: str) -> None:
-        client = {self.company_a: self.cashier_a, self.company_b: self.cashier_b}[company_id]
-        status, _, data = client.post_json(
-            "/api/company/accounts",
-            {"bank_name": "中信银行", "account_type": "基本户",
-             "account_number": number, "start_date": "2026-01-01"},
-        )
-        assert status == 200, data
-        account_id = as_json(data)["account"]["id"]
-        status, _, data = self.admin.post_json(
-            f"/api/admin/accounts/{account_id}/review",
-            {"decision": "approve", "reason": "测试启用", "effective_from": "2026-01-01"},
-        )
-        assert status == 200, data
-
-    def _upload_and_confirm(self, client, company_id: int, rows) -> int:
-        content = workbook_bytes(rows)
-        status, _, data = self.admin.post_multipart(
-            "/api/parse", {"company_id": str(company_id)}, "账单.xlsx", content
-        )
-        assert status == 200, data
-        batch_id = as_json(data)["batch_id"]
-        status, _, data = client.get(f"/api/batches/{batch_id}/sheets")
-        names = [s["sheet_name"] for s in as_json(data)["sheets"] if s["outcome"] == "parsed"]
-        status, _, data = client.post_json(
-            f"/api/batches/{batch_id}/confirm", {"sheets": names}
-        )
-        assert status == 200, data
-        return batch_id
-
-    def _fresh_pair(self, amount: str = "100.00", at: str = "2026-01-05 10:00:00",
-                    currency: str = "RMB") -> dict:
-        """Upload+confirm a new A<->B pair; returns the pending review item."""
-        self._upload_and_confirm(
-            self.cashier_a, self.company_a,
-            [outgoing(ACCOUNT_A, ACCOUNT_B, amount, at, currency)],
-        )
-        self._upload_and_confirm(
-            self.cashier_b, self.company_b,
-            [incoming(ACCOUNT_B, ACCOUNT_A, amount, at.replace("10:", "11:"), currency)],
-        )
-        status, _, data = self.admin.get(
-            "/api/admin/subject-reviews?from=2026-01-01&cutoff=2026-12-31"
-        )
-        self.assertEqual(200, status, data)
-        items = as_json(data)["items"]
-        pending = [item for item in items if item["amount"] == amount]
-        self.assertEqual(1, len(pending), data)
-        return pending[0]
-
-    def _confirm(self, ledger_event_id: int) -> dict:
-        status, _, data = self.admin.get(
-            f"/api/admin/intercompany/events/{ledger_event_id}"
-        )
-        self.assertEqual(200, status, data)
-        detail = as_json(data)
-        status, _, data = self.admin.post_json(
-            f"/api/admin/intercompany/events/{ledger_event_id}/subject-decisions",
-            {
-                "perspective_company_id": detail["event"]["payer_company_id"],
-                "subject_code": "other_receivable",
-                "reason": "借款确认其他应收",
-                "expected_revision": detail["event"]["ledger_revision_id"],
-                "request_key": f"subj-{ledger_event_id}",
-            },
-        )
-        self.assertEqual(200, status, data)
-        return as_json(data)["revision"]
-
-    def balances(self, client=None, path="/api/admin/intercompany/balances") -> dict:
-        client = client or self.admin
-        status, _, data = client.get(path + "?from=2026-01-01&cutoff=2026-12-31")
-        self.assertEqual(200, status, data)
-        return as_json(data)
-
-    def _by_company(self, payload: dict, company_id: int) -> dict:
-        return next(item for item in payload["items"] if item["company_id"] == company_id)
-
-    # ------------------------------------------------------------------
-    # Admin balances / pair / events
-    # ------------------------------------------------------------------
-
-    def test_admin_balances_directory(self) -> None:
-        self._fresh_pair("100.00")
-        payload = self.balances()
-        self.assertEqual("2026-12-31", payload["window"]["cutoff"])
-        companies = {item["company_id"] for item in payload["items"]}
-        self.assertIn(self.company_a, companies)
-        self.assertIn(self.company_b, companies)
-        for item in payload["items"]:
-            self.assertEqual("unavailable", item["opening"]["status"])
-            self.assertIsNone(item["opening"]["amount"])
-            self.assertEqual("period_net_change", item["result"]["kind"])
-            self.assertIn("gross_amount", item["unresolved"])
-            self.assertIn("count", item["unresolved"])
-            self.assertIn("by_reason", item["unresolved"])
-            self.assertEqual("RMB", item["currency"])
-
-    def test_admin_balances_pending_subject_shows_unresolved(self) -> None:
-        self._fresh_pair("100.00")
-        payload = self.balances()
-        item = self._by_company(payload, self.company_a)
-        self.assertEqual(1, item["unresolved"]["count"])
-        self.assertEqual(
-            "100.00", item["unresolved"]["by_reason"]["subject_review"]["gross_amount"]
-        )
-        self.assertEqual("0", item["period"]["debit"])
-        self.assertEqual("0", item["period"]["credit"])
-
-    def test_admin_pair_detail_conserves(self) -> None:
-        self._fresh_pair("100.00")
-        status, _, data = self.admin.get(
-            f"/api/admin/intercompany/pairs/{self.company_a}/{self.company_b}"
-            "?from=2026-01-01&cutoff=2026-12-31"
-        )
-        self.assertEqual(200, status, data)
-        payload = as_json(data)
-        item = payload["items"][0]
-        self.assertTrue(item["conservation"]["opposite"])
-        self.assertTrue(item["conservation"]["abs_equal"])
-        self.assertEqual("unavailable", item["opening"]["status"])
-        self.assertIn("subjects", item)
-        self.assertEqual(1, item["unresolved"]["count"])
-
-    def test_admin_subject_decision_flows_to_balances(self) -> None:
-        pending = self._fresh_pair("100.00")
-        revision = self._confirm(pending["ledger_event_id"])
-        self.assertEqual("confirmed", revision["state"])
-        self.assertEqual("other_receivable", revision["subject_code"])
-        payload = self.balances()
-        item = self._by_company(payload, self.company_a)
-        self.assertEqual(0, item["unresolved"]["count"])
-        self.assertEqual("100.00", item["period"]["debit"])
-        self.assertEqual("100.00", item["result"]["signed_amount"])
-
-    def test_admin_subject_decision_stale_revision_conflicts(self) -> None:
-        pending = self._fresh_pair("100.00")
-        status, _, data = self.admin.post_json(
-            f"/api/admin/intercompany/events/{pending['ledger_event_id']}/subject-decisions",
-            {
-                "perspective_company_id": pending["payer_company_id"],
-                "subject_code": "other_receivable", "reason": "确认",
-                "expected_revision": 999, "request_key": "stale-key",
-            },
-        )
-        self.assertEqual(409, status, data)
-
-    def test_admin_events_list_and_evidence(self) -> None:
-        pending = self._fresh_pair("100.00")
-        revision = self._confirm(pending["ledger_event_id"])
-        status, _, data = self.admin.get(
-            "/api/admin/intercompany/events?from=2026-01-01&cutoff=2026-12-31"
-        )
-        self.assertEqual(200, status, data)
-        items = as_json(data)["items"]
-        self.assertTrue(items)
-        event = next(
-            item for item in items
-            if item["ledger_event_id"] == revision["ledger_event_id"]
-        )
-        self.assertEqual("confirmed", event["state"])
-        self.assertEqual("other_receivable", event["subject_code"])
-        self.assertIn("payer_company_name", event)
-        self.assertIn("amount", event)
-
-        status, _, data = self.admin.get(
-            f"/api/admin/intercompany/events/{event['ledger_event_id']}"
-        )
-        self.assertEqual(200, status, data)
-        self.assertEqual("confirmed", as_json(data)["state"])
-
-        status, _, data = self.admin.get(
-            f"/api/admin/intercompany/events/{event['ledger_event_id']}/evidence"
-        )
-        self.assertEqual(200, status, data)
-        blocks = as_json(data)["blocks"]
-        self.assertTrue(blocks)
-        for block in blocks:
-            self.assertEqual("visible", block["visibility"])
-
-    def test_admin_events_list_includes_pending_subject(self) -> None:
-        pending = self._fresh_pair("100.00")
-        status, _, data = self.admin.get(
-            "/api/admin/intercompany/events?from=2026-01-01&cutoff=2026-12-31"
-        )
-        self.assertEqual(200, status, data)
-        items = as_json(data)["items"]
-        item = next(
-            item for item in items
-            if item["ledger_event_id"] == pending["ledger_event_id"]
-        )
-        self.assertEqual("pending_subject", item["state"])
-        self.assertIsNone(item["subject_code"])
-
-    def test_admin_manual_record_decision_via_api(self) -> None:
-        status, _, data = self.cashier_a.post_json(
-            "/api/company/manual-records",
-            {
-                "counterparty_company_id": self.company_b,
-                "occurred_at": "2026-02-01T09:00:00",
-                "direction": "incoming", "amount": "20.00", "currency": "CNY",
-                "funding_source": "other", "requested_subject": "other_receivable",
-                "request_key": "mr-api-1", "summary": "还款",
-            },
-        )
-        self.assertEqual(200, status, data)
-        record = as_json(data)["record"]
-        self.assertEqual("pending", record["state"])
-
-        status, _, data = self.admin.get("/api/admin/manual-records")
-        self.assertEqual(200, status, data)
-        records = as_json(data)["records"]
-        self.assertTrue(any(item["id"] == record["id"] for item in records))
-
-        status, _, data = self.admin.post_json(
-            f"/api/admin/manual-records/{record['id']}/decisions",
-            {"action": "approve_new", "reason": "银行流水中无此事实",
-             "expected_decision_id": record["decision_id"], "request_key": "dec-api-1"},
-        )
-        self.assertEqual(200, status, data)
-        self.assertEqual("approved", as_json(data)["decision"]["state"])
-
-        status, _, data = self.cashier_a.get("/api/company/manual-records")
-        self.assertEqual(200, status, data)
-        own = [item for item in as_json(data)["records"] if item["id"] == record["id"]]
-        self.assertEqual(1, len(own))
-        self.assertEqual("approved", own[0]["state"])
-
-        status, _, data = self.cashier_b.get("/api/company/manual-records")
-        self.assertEqual(200, status, data)
-        self.assertEqual([], [
-            item for item in as_json(data)["records"] if item["id"] == record["id"]
-        ])
-
-    def test_admin_adjustment_reverse_via_api(self) -> None:
-        pending = self._fresh_pair("100.00")
-        revision = self._confirm(pending["ledger_event_id"])
-        status, _, data = self.admin.post_json(
-            f"/api/admin/intercompany/events/{revision['ledger_event_id']}/adjustments",
-            {"action": "reverse", "reason": "科目误判，冲销"},
-        )
-        self.assertEqual(200, status, data)
-        self.assertEqual("reverse", as_json(data)["action"])
-
-    # ------------------------------------------------------------------
-    # Company scope and masking
-    # ------------------------------------------------------------------
-
-    def test_company_balances_scoped_to_own_company(self) -> None:
-        self._fresh_pair("100.00")
-        status, _, data = self.cashier_a.get(
-            "/api/company/intercompany/balances?from=2026-01-01&cutoff=2026-12-31"
-        )
-        self.assertEqual(200, status, data)
-        payload = as_json(data)
-        for item in payload["items"]:
-            self.assertEqual(self.company_a, item["company_id"])
-        self.assertIn("counterparties", payload)
-        self.assertTrue(payload["counterparties"])
-
-    def test_company_pair_and_events_are_own_scope(self) -> None:
-        self._fresh_pair("100.00")
-        status, _, data = self.cashier_a.get(
-            f"/api/company/intercompany/pairs/{self.company_b}"
-            "?from=2026-01-01&cutoff=2026-12-31"
-        )
-        self.assertEqual(200, status, data)
-        self.assertEqual(self.company_a, as_json(data)["companies"]["a"]["company_id"])
-
-        status, _, data = self.cashier_a.get(
-            "/api/company/intercompany/events?from=2026-01-01&cutoff=2026-12-31"
-        )
-        self.assertEqual(200, status, data)
-        items = as_json(data)["items"]
-        self.assertTrue(items)
-        for item in items:
-            self.assertIn("direction", item)
-            self.assertIn("own_subject_label", item)
-            self.assertIn(item["direction"], ("incoming", "outgoing"))
-
-    def test_company_evidence_masks_counterparty_side(self) -> None:
-        pending = self._fresh_pair("100.00")
-        self._confirm(pending["ledger_event_id"])
-        status, _, data = self.cashier_a.get(
-            f"/api/company/intercompany/events/{pending['ledger_event_id']}/evidence"
-        )
-        self.assertEqual(200, status, data)
-        blocks = as_json(data)["blocks"]
-        visibilities = {block["visibility"] for block in blocks}
-        self.assertTrue(visibilities & {"visible", "masked"})
-        for block in blocks:
-            if block["visibility"] == "masked":
-                self.assertEqual("按对方授权不可见", block["fields"].get("note"))
-            self.assertNotIn(ACCOUNT_B, json.dumps(block["fields"], ensure_ascii=False))
-
-    def test_company_cannot_read_or_write_admin_intercompany(self) -> None:
-        self._fresh_pair("100.00")
-        status, _, data = self.cashier_a.get("/api/admin/intercompany/balances")
-        self.assertEqual(403, status, data)
-        status, _, data = self.cashier_a.get("/api/admin/manual-records")
-        self.assertEqual(403, status, data)
-        status, _, data = self.cashier_a.post_json(
-            "/api/admin/manual-records/1/decisions", {"action": "approve_new", "reason": "x"}
-        )
-        self.assertEqual(403, status, data)
-        status, _, data = self.cashier_a.post_json(
-            "/api/admin/intercompany/events/1/adjustments",
-            {"action": "reverse", "reason": "越权"},
-        )
-        self.assertEqual(403, status, data)
-
-    def test_cross_company_reads_are_404(self) -> None:
-        pending = self._fresh_pair("100.00")
-        status, _, data = self.cashier_c.get(
-            f"/api/company/intercompany/events/{pending['ledger_event_id']}"
-        )
-        self.assertEqual(404, status, data)
-        status, _, data = self.cashier_c.get(
-            f"/api/company/intercompany/events/{pending['ledger_event_id']}/evidence"
-        )
-        self.assertEqual(404, status, data)
-
-    def test_company_counterparty_summary_splits_by_currency(self) -> None:
-        # A->B 100 CNY and A->B 50 USD must render two rows, never a mixed
-        # "CNY 150.00" bucket.
-        cny = self._fresh_pair("100.00", currency="CNY")
-        usd = self._fresh_pair("50.00", at="2026-01-20 10:00:00", currency="USD")
-        for pending in (cny, usd):
-            self._confirm(pending["ledger_event_id"])
-
-        status, _, data = self.cashier_a.get(
-            "/api/company/intercompany/balances?from=2026-01-01&cutoff=2026-12-31"
-        )
-        self.assertEqual(200, status, data)
-        counterparties = as_json(data)["counterparties"]
-        rows = [row for row in counterparties if row["counterparty_company_id"] == self.company_b]
-        self.assertEqual(2, len(rows), counterparties)
-        by_currency = {row["currency"]: row for row in rows}
-        self.assertEqual({"CNY", "USD"}, set(by_currency))
-        self.assertEqual("100.00", by_currency["CNY"]["result"]["signed_amount"])
-        self.assertEqual("50.00", by_currency["USD"]["result"]["signed_amount"])
-        for row in rows:
-            self.assertNotEqual("150.00", row["result"]["signed_amount"])
-            self.assertEqual(1, row["event_count"])
-
-    def test_company_events_subject_filter_matches_mirror(self) -> None:
-        # A confirms subject "receivable" (stored from A's perspective); B must
-        # still find the event when filtering by the mirror subject "payable".
-        pending = self._fresh_pair("100.00")
-        status, _, data = self.admin.post_json(
-            f"/api/admin/intercompany/events/{pending['ledger_event_id']}/subject-decisions",
-            {
-                "perspective_company_id": self.company_a,
-                "subject_code": "receivable", "reason": "确认应收",
-                "expected_revision": 1, "request_key": "mirror-subj",
-            },
-        )
-        self.assertEqual(200, status, data)
-
-        status, _, data = self.cashier_b.get(
-            "/api/company/intercompany/events?from=2026-01-01&cutoff=2026-12-31&subject=payable"
-        )
-        self.assertEqual(200, status, data)
-        items = as_json(data)["items"]
-        self.assertTrue(any(
-            item["ledger_event_id"] == pending["ledger_event_id"] for item in items
-        ), data)
-
-    def test_manual_reverse_via_api_uses_explicit_effective_date(self) -> None:
-        status, _, data = self.cashier_a.post_json(
-            "/api/company/manual-records",
-            {
-                "counterparty_company_id": self.company_b,
-                "occurred_at": "2026-02-01T09:00:00",
-                "direction": "incoming", "amount": "20.00", "currency": "CNY",
-                "funding_source": "other", "requested_subject": "other_receivable",
-                "request_key": "mr-rev-api", "summary": "还款",
-            },
-        )
-        self.assertEqual(200, status, data)
-        record = as_json(data)["record"]
-        status, _, data = self.admin.post_json(
-            f"/api/admin/manual-records/{record['id']}/decisions",
-            {"action": "approve_new", "reason": "确认入账",
-             "expected_decision_id": record["decision_id"], "request_key": "dec-rev-api"},
-        )
-        self.assertEqual(200, status, data)
-        event_id = as_json(data)["decision"]["ledger_event_id"]
-
-        status, _, data = self.admin.get(
-            f"/api/admin/intercompany/events/{event_id}"
-        )
-        self.assertEqual(200, status, data)
-        revision_id = as_json(data)["event"]["ledger_revision_id"]
-
-        status, _, data = self.admin.post_json(
-            f"/api/admin/manual-records/{record['id']}/decisions",
-            {"action": "reverse", "reason": "误录冲销", "effective_at": "2026-06-15",
-             "expected_decision_id": None, "request_key": "dec-rev-api-2"},
-        )
-        self.assertEqual(200, status, data)
-
-        status, _, data = self.admin.get(
-            "/api/admin/intercompany/events?from=2026-01-01&cutoff=2026-12-31"
-        )
-        self.assertEqual(200, status, data)
-        reversals = [item for item in as_json(data)["items"] if item["posting_kind"] == "reversal"]
-        self.assertEqual(1, len(reversals))
-        self.assertEqual("2026-06-15", reversals[0]["effective_at"][:10])
-        self.assertEqual(event_id, reversals[0]["reverses_ledger_event_id"])
-
-    def test_admin_events_include_account_chips(self) -> None:
-        pending = self._fresh_pair("100.00")
-        revision = self._confirm(pending["ledger_event_id"])
-        status, _, data = self.admin.get(
-            "/api/admin/intercompany/events?from=2026-01-01&cutoff=2026-12-31"
-        )
-        self.assertEqual(200, status, data)
-        event = next(
-            item for item in as_json(data)["items"]
-            if item["ledger_event_id"] == revision["ledger_event_id"]
-        )
-        self.assertIn("payer_account", event)
-        self.assertIn("payee_account", event)
-        self.assertEqual("visible", event["payer_account"]["visibility"])
-        self.assertTrue(event["payer_account"]["label"])
-        self.assertIn("summary", event)
-        self.assertIn("is_repayment", event)
-
-    def test_subject_exception_drops_from_review_queue(self) -> None:
-        pending = self._fresh_pair("77.00")
-        status, _, data = self.admin.post_json(
-            f"/api/admin/intercompany/events/{pending['ledger_event_id']}/subject-decisions",
-            {
-                "perspective_company_id": pending["payer_company_id"],
-                "action": "exception",
-                "reason": "转异常待核查",
-                "expected_revision": pending["revision_id"],
-                "request_key": "park-exc-api",
-            },
-        )
-        self.assertEqual(200, status, data)
-        self.assertEqual("pending_subject", as_json(data)["revision"]["state"])
-        status, _, data = self.admin.get(
-            "/api/admin/subject-reviews?from=2026-01-01&cutoff=2026-12-31"
-        )
-        self.assertEqual(200, status, data)
-        ids = [item["ledger_event_id"] for item in as_json(data)["items"]]
-        self.assertNotIn(pending["ledger_event_id"], ids)
-
-
-if __name__ == "__main__":
-    unittest.main()

tests/test_settings_reminders.py

@@ -1,258 +0,0 @@
-"""Integration tests for system settings persistence and reminder flow."""
-
-from __future__ import annotations
-
-from http.client import HTTPConnection
-from http.cookies import SimpleCookie
-import json
-import os
-from pathlib import Path
-import tempfile
-import threading
-import unittest
-
-from bank_importer.db import connect, migrate
-from bank_importer import auth, settings
-
-import server
-
-
-BOOTSTRAP_PASSWORD = "BootAdmin123"
-ADMIN_PASSWORD = "AdminPass123"
-
-
-class Client:
-    def __init__(self, host: str, port: int) -> None:
-        self.host = host
-        self.port = port
-        self.cookies: dict[str, str] = {}
-
-    def request(self, method, path, body=None, headers=None):
-        connection = HTTPConnection(self.host, self.port)
-        request_headers = dict(headers or {})
-        if self.cookies:
-            request_headers["Cookie"] = "; ".join(
-                f"{k}={v}" for k, v in self.cookies.items()
-            )
-        connection.request(method, path, body=body, headers=request_headers)
-        response = connection.getresponse()
-        data = response.read()
-        set_cookie = dict(response.getheaders()).get("Set-Cookie")
-        if set_cookie:
-            cookie = SimpleCookie()
-            cookie.load(set_cookie)
-            for key, morsel in cookie.items():
-                if morsel.value:
-                    self.cookies[key] = morsel.value
-                else:
-                    self.cookies.pop(key, None)
-        status = response.status
-        connection.close()
-        return status, data
-
-    def get(self, path):
-        return self.request("GET", path)
-
-    def post_json(self, path, payload):
-        return self.request(
-            "POST", path, body=json.dumps(payload).encode("utf-8"),
-            headers={"Content-Type": "application/json"},
-        )
-
-
-def as_json(data: bytes):
-    return json.loads(data.decode("utf-8"))
-
-
-class SettingsAndRemindersTests(unittest.TestCase):
-    @classmethod
-    def setUpClass(cls) -> None:
-        cls.temp_dir = tempfile.TemporaryDirectory()
-        root = Path(cls.temp_dir.name)
-        cls.db_path = root / "app.db"
-        cls.storage = root / "files"
-
-        cls._old_db_path = server.DB_PATH
-        cls._old_storage = server.STORAGE_DIR
-        server.DB_PATH = cls.db_path
-        server.STORAGE_DIR = cls.storage
-
-        os.environ["APP_BOOTSTRAP_ADMIN_PASSWORD"] = BOOTSTRAP_PASSWORD
-        connection = connect(cls.db_path)
-        migrate(connection)
-        server.ensure_bootstrap_admin(connection)
-        # One active account for company 1 so pending items are generated.
-        with connection:
-            connection.execute(
-                "INSERT INTO companies (name, credit_code, status, created_at, updated_at) "
-                "VALUES ('甲公司', NULL, 'active', 't', 't')"
-            )
-            company_id = connection.execute(
-                "SELECT id FROM companies WHERE name = '甲公司'"
-            ).fetchone()["id"]
-            connection.execute(
-                "INSERT INTO bank_accounts (company_id, account_number, bank_name, status, created_at, updated_at) "
-                "VALUES (?, '11112222', '工行', 'active', 't', 't')",
-                (company_id,),
-            )
-        cls.company_id = company_id
-        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.admin = Client("127.0.0.1", cls.port)
-        status, data = cls.admin.post_json(
-            "/api/login",
-            {"username": "group-admin", "password": BOOTSTRAP_PASSWORD, "portal": "admin"},
-        )
-        assert status == 200, data
-        status, data = cls.admin.post_json(
-            "/api/password/change",
-            {"old_password": BOOTSTRAP_PASSWORD, "new_password": ADMIN_PASSWORD},
-        )
-        assert status == 200, data
-
-    @classmethod
-    def tearDownClass(cls) -> None:
-        cls.httpd.shutdown()
-        cls.httpd.server_close()
-        server.DB_PATH = cls._old_db_path
-        server.STORAGE_DIR = cls._old_storage
-        os.environ.pop("APP_BOOTSTRAP_ADMIN_PASSWORD", None)
-        cls.temp_dir.cleanup()
-
-    def test_settings_roundtrip_persists(self) -> None:
-        status, data = self.admin.post_json(
-            "/api/admin/settings",
-            {"closing_day": "1", "start_date": "2026-01-05", "auto_remind": "0", "remind_days": "5"},
-        )
-        self.assertEqual(200, status, data)
-        updated = as_json(data)["settings"]
-        self.assertEqual("1", updated["closing_day"])
-        self.assertEqual("2026-01-05", updated["start_date"])
-        self.assertEqual("0", updated["auto_remind"])
-        self.assertEqual("5", updated["remind_days"])
-
-        status, data = self.admin.get("/api/admin/settings")
-        self.assertEqual(200, status)
-        self.assertEqual("1", as_json(data)["settings"]["closing_day"])
-
-    def test_invalid_closing_day_rejected(self) -> None:
-        for bad in ("0", "29", "abc"):
-            status, data = self.admin.post_json("/api/admin/settings", {"closing_day": bad})
-            self.assertEqual(400, status, (bad, data))
-
-    def test_setting_change_is_audited(self) -> None:
-        status, data = self.admin.post_json("/api/admin/settings", {"closing_day": "7"})
-        self.assertEqual(200, status)
-        connection = connect(self.db_path)
-        try:
-            rows = connection.execute(
-                "SELECT key, before_value, after_value, actor_username "
-                "FROM system_setting_changes WHERE key = 'closing_day' "
-                "ORDER BY id DESC LIMIT 1"
-            ).fetchall()
-        finally:
-            connection.close()
-        self.assertTrue(rows)
-        self.assertEqual("7", rows[0]["after_value"])
-        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(
-            "/api/admin/users", {"username": "cashier-x", "company_id": self.company_id}
-        )
-        self.assertEqual(200, status, data)
-        initial = as_json(data)["initial_password"]
-        cashier = Client("127.0.0.1", self.port)
-        status, data = cashier.post_json(
-            "/api/login",
-            {"username": "cashier-x", "password": initial, "portal": "company"},
-        )
-        self.assertEqual(200, status)
-        status, data = cashier.post_json(
-            "/api/password/change",
-            {"old_password": initial, "new_password": "Changed123"},
-        )
-        self.assertEqual(200, status)
-
-        for path in ("/api/admin/settings", "/api/admin/reminders"):
-            status, _ = cashier.get(path)
-            self.assertEqual(403, status, path)
-
-
-class SettingsModuleTests(unittest.TestCase):
-    """Unit tests for the settings module on a fresh in-memory database."""
-
-    def setUp(self) -> None:
-        self.connection = connect(":memory:")
-        self.addCleanup(self.connection.close)
-        migrate(self.connection)
-
-    def test_defaults_applied_when_no_row_exists(self) -> None:
-        values = settings.get_settings(self.connection)
-        self.assertEqual("5", values["closing_day"])
-        self.assertEqual("2026-01-01", values["start_date"])
-        self.assertEqual("1", values["auto_remind"])
-        self.assertEqual("3", values["remind_days"])
-
-    def test_validate_rejects_bad_values(self) -> None:
-        for bad in ({"closing_day": "0"}, {"closing_day": "29"}, {"closing_day": "abc"}):
-            _, error = settings.validate_settings(bad)
-            self.assertIsNotNone(error)
-        _, error = settings.validate_settings({"start_date": "2026-13-40"})
-        self.assertIsNotNone(error)
-        _, error = settings.validate_settings({"auto_remind": "2"})
-        self.assertIsNotNone(error)
-
-    def test_update_writes_value_and_trail(self) -> None:
-        user_id = auth.create_user(self.connection, "group-admin", "AdminPass123", "admin")
-        user = self.connection.execute(
-            "SELECT id, username FROM users WHERE id = ?", (user_id,)
-        ).fetchone()
-        updated = settings.update_settings(
-            self.connection, {"closing_day": "1", "auto_remind": "0"}, user
-        )
-        self.assertEqual("1", updated["closing_day"])
-        self.assertEqual("0", updated["auto_remind"])
-        changes = self.connection.execute(
-            "SELECT key, before_value, after_value FROM system_setting_changes ORDER BY id"
-        ).fetchall()
-        self.assertEqual(2, len(changes))
-        self.assertEqual("5", changes[0]["before_value"])
-        self.assertEqual("1", changes[0]["after_value"])
-
-
-if __name__ == "__main__":
-    unittest.main()

web/design-system.css

@@ -1,720 +0,0 @@
-/* ─── 金牛实业资金往来管理系统 · 共享样式 ─────────────────────────────
-   方向:tech-utility(数据密集型工具)。六枚基础 token 绑定设计方向,
-   状态色仅在此 :root 块内以 oklch 派生,组件一律引用变量。 */
-
-:root {
-  --bg:      oklch(98% 0.005 250);
-  --surface: oklch(100% 0 0);
-  --fg:      oklch(22% 0.02 240);
-  --muted:   oklch(50% 0.018 240);
-  --border:  oklch(90% 0.008 240);
-  --accent:  oklch(58% 0.16 145);
-
-  /* 状态色 — 仅此处定义 */
-  --success: oklch(55% 0.14 150);
-  --warn:    oklch(62% 0.14 70);
-  --danger:  oklch(55% 0.18 25);
-  --info:    oklch(52% 0.12 240);
-
-  --accent-soft:  color-mix(in oklch, var(--accent) 12%, transparent);
-  --success-soft: color-mix(in oklch, var(--success) 12%, transparent);
-  --warn-soft:    color-mix(in oklch, var(--warn) 14%, transparent);
-  --danger-soft:  color-mix(in oklch, var(--danger) 11%, transparent);
-  --info-soft:    color-mix(in oklch, var(--info) 10%, transparent);
-  --fg-soft:      color-mix(in oklch, var(--fg) 5%, transparent);
-
-  --font-body: -apple-system, BlinkMacSystemFont, "Segoe UI", "PingFang SC", "Hiragino Sans GB", "Microsoft YaHei", system-ui, sans-serif;
-  --font-mono: "JetBrains Mono", "IBM Plex Mono", ui-monospace, "SF Mono", Menlo, monospace;
-
-  --radius: 8px;
-  --radius-lg: 12px;
-  --side-w: 232px;
-}
-
-/* ─── reset ─────────────────────────────────────────────────────── */
-*, *::before, *::after { box-sizing: border-box; }
-body {
-  margin: 0;
-  background: var(--bg);
-  color: var(--fg);
-  font-family: var(--font-body);
-  font-size: 14px;
-  line-height: 1.55;
-  -webkit-font-smoothing: antialiased;
-}
-img, svg { display: block; }
-a { color: inherit; text-decoration: none; }
-button { font: inherit; cursor: pointer; }
-h1, h2, h3, h4 { margin: 0; line-height: 1.3; }
-p { margin: 0; }
-
-:focus-visible {
-  outline: 2px solid var(--accent);
-  outline-offset: 2px;
-  border-radius: 4px;
-}
-
-/* ─── 应用外壳 ──────────────────────────────────────────────────── */
-.shell { display: grid; grid-template-columns: var(--side-w) 1fr; min-height: 100vh; }
-
-.sidebar {
-  background: var(--surface);
-  border-right: 1px solid var(--border);
-  display: flex;
-  flex-direction: column;
-  position: sticky;
-  top: 0;
-  height: 100vh;
-}
-.side-brand {
-  padding: 18px 20px 16px;
-  border-bottom: 1px solid var(--border);
-}
-.side-brand .brand-name { font-size: 15px; font-weight: 650; letter-spacing: -0.01em; }
-.side-brand .brand-sub { font-family: var(--font-mono); font-size: 11px; color: var(--muted); margin-top: 3px; letter-spacing: 0.02em; }
-.side-role {
-  display: inline-flex; align-items: center; gap: 6px;
-  margin-top: 10px;
-  padding: 3px 9px;
-  border-radius: 999px;
-  background: var(--accent-soft);
-  color: var(--accent);
-  font-size: 11px; font-weight: 600;
-}
-.side-role.company { background: var(--info-soft); color: var(--info); }
-
-.side-nav { flex: 1; overflow-y: auto; padding: 12px 10px; }
-.side-nav .nav-group { font-family: var(--font-mono); font-size: 10.5px; letter-spacing: 0.08em; color: var(--muted); padding: 14px 10px 6px; }
-.side-nav a {
-  display: flex; align-items: center; gap: 10px;
-  padding: 8px 10px;
-  border-radius: var(--radius);
-  color: var(--muted);
-  font-size: 13.5px;
-  margin-bottom: 1px;
-}
-.side-nav a svg { width: 16px; height: 16px; flex: none; }
-.side-nav a:hover { color: var(--fg); background: var(--fg-soft); }
-.side-nav a.active {
-  color: var(--fg);
-  background: var(--accent-soft);
-  font-weight: 600;
-}
-.side-nav a.active svg { color: var(--accent); }
-.side-nav a .nav-badge {
-  margin-left: auto;
-  font-family: var(--font-mono);
-  font-size: 10.5px;
-  padding: 1px 7px;
-  border-radius: 999px;
-  background: var(--danger-soft);
-  color: var(--danger);
-  font-weight: 600;
-}
-.side-foot { border-top: 1px solid var(--border); padding: 12px 16px; }
-.side-foot .user-row { display: flex; align-items: center; gap: 10px; min-width: 0; }
-.side-foot .user-row > div { min-width: 0; }
-.side-foot .avatar {
-  width: 30px; height: 30px; border-radius: 50%;
-  background: var(--fg); color: var(--surface);
-  display: grid; place-items: center;
-  font-size: 12px; font-weight: 600;
-  flex: none;
-}
-.side-foot .user-name { font-size: 13px; font-weight: 600; white-space: nowrap; }
-.side-foot .user-meta { font-family: var(--font-mono); font-size: 11px; color: var(--muted); overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
-.side-foot .logout { margin-left: auto; color: var(--muted); font-size: 12px; padding: 4px 6px; border-radius: 6px; background: none; border: 0; flex: none; white-space: nowrap; }
-.side-foot .logout:hover { color: var(--danger); background: var(--danger-soft); }
-
-.main { min-width: 0; display: flex; flex-direction: column; }
-
-.topbar {
-  position: sticky; top: 0; z-index: 20;
-  background: color-mix(in oklch, var(--bg) 88%, transparent);
-  backdrop-filter: blur(10px);
-  border-bottom: 1px solid var(--border);
-  padding: 12px 28px;
-  display: flex; align-items: center; gap: 16px;
-  flex-wrap: wrap;
-}
-.topbar .crumb { font-family: var(--font-mono); font-size: 12px; color: var(--muted); }
-.topbar .crumb b { color: var(--fg); font-weight: 600; }
-.topbar .topbar-right { margin-left: auto; display: flex; align-items: center; gap: 10px; }
-
-.content { padding: 24px 28px 64px; max-width: 1440px; width: 100%; margin-inline: auto; }
-
-/* ─── 页头 ──────────────────────────────────────────────────────── */
-.page-head { display: flex; align-items: flex-end; justify-content: space-between; gap: 20px; margin-bottom: 20px; flex-wrap: wrap; }
-.page-head h1 { font-size: 22px; font-weight: 700; letter-spacing: -0.015em; }
-.page-head .page-sub { color: var(--muted); font-size: 13px; margin-top: 5px; max-width: 72ch; }
-.page-head .page-actions { display: flex; gap: 8px; flex-wrap: wrap; }
-
-/* ─── 按钮 ──────────────────────────────────────────────────────── */
-.btn {
-  display: inline-flex; align-items: center; justify-content: center; gap: 7px;
-  padding: 8px 14px;
-  min-height: 34px;
-  border-radius: var(--radius);
-  border: 1px solid var(--border);
-  background: var(--surface);
-  color: var(--fg);
-  font-size: 13px; font-weight: 550;
-  transition: background 0.12s ease, border-color 0.12s ease;
-}
-.btn:hover { border-color: color-mix(in oklch, var(--fg) 40%, var(--border)); background: var(--fg-soft); }
-.btn:active { transform: translateY(1px); }
-.btn-primary { background: var(--accent); border-color: var(--accent); color: var(--surface); }
-.btn-primary:hover { background: color-mix(in oklch, var(--accent) 88%, black); border-color: color-mix(in oklch, var(--accent) 88%, black); }
-.btn-ghost { background: transparent; border-color: transparent; color: var(--muted); }
-.btn-ghost:hover { color: var(--fg); background: var(--fg-soft); }
-.btn-danger { color: var(--danger); border-color: color-mix(in oklch, var(--danger) 35%, var(--border)); }
-.btn-danger:hover { background: var(--danger-soft); border-color: var(--danger); }
-.btn-sm { padding: 4px 10px; min-height: 26px; font-size: 12px; border-radius: 6px; }
-.btn[disabled] { opacity: 0.5; cursor: not-allowed; }
-.btn-primary[disabled] { opacity: 1; background: var(--fg-soft); border-color: var(--border); color: var(--muted); }
-
-/* ─── 卡片 ──────────────────────────────────────────────────────── */
-.card {
-  background: var(--surface);
-  border: 1px solid var(--border);
-  border-radius: var(--radius-lg);
-  padding: 18px 20px;
-}
-.card-head { display: flex; align-items: center; justify-content: space-between; gap: 12px; margin-bottom: 14px; }
-.card-title { font-size: 14px; font-weight: 650; letter-spacing: -0.005em; }
-.card-title .sub { display: block; font-size: 12px; font-weight: 400; color: var(--muted); margin-top: 2px; }
-
-/* ─── 指标卡 ────────────────────────────────────────────────────── */
-.stat-card { padding: 16px 18px; }
-.stat-card .stat-label { font-size: 12.5px; color: var(--muted); display: flex; align-items: center; gap: 6px; }
-.stat-card .stat-value {
-  font-family: var(--font-mono);
-  font-variant-numeric: tabular-nums;
-  font-size: 26px; font-weight: 650;
-  letter-spacing: -0.02em;
-  margin-top: 6px;
-}
-.stat-card .stat-value .unit { font-size: 13px; color: var(--muted); font-weight: 400; margin-left: 2px; }
-.stat-card .stat-foot { font-size: 12px; color: var(--muted); margin-top: 6px; }
-.stat-card.alert .stat-value { color: var(--danger); }
-.stat-card.warn .stat-value { color: var(--warn); }
-.stat-dot { width: 8px; height: 8px; border-radius: 50%; flex: none; }
-.stat-dot.danger { background: var(--danger); }
-.stat-dot.warn { background: var(--warn); }
-.stat-dot.success { background: var(--success); }
-.stat-dot.info { background: var(--info); }
-
-/* ─── 栅格与布局工具 ────────────────────────────────────────────── */
-.grid { display: grid; gap: 14px; }
-.grid-2 { grid-template-columns: repeat(2, minmax(0, 1fr)); }
-.grid-3 { grid-template-columns: repeat(3, minmax(0, 1fr)); }
-.grid-4 { grid-template-columns: repeat(4, minmax(0, 1fr)); }
-.grid-5 { grid-template-columns: repeat(5, minmax(0, 1fr)); }
-.grid-2-1 { grid-template-columns: minmax(0, 2fr) minmax(0, 1fr); align-items: start; }
-.grid-1-2 { grid-template-columns: minmax(0, 1fr) minmax(0, 2fr); align-items: start; }
-.grid-3-2 { grid-template-columns: minmax(0, 3fr) minmax(0, 2fr); align-items: start; }
-.row { display: flex; align-items: center; gap: 10px; }
-.row-between { display: flex; align-items: center; justify-content: space-between; gap: 12px; }
-.stack { display: flex; flex-direction: column; gap: 14px; }
-.muted { color: var(--muted); }
-.num { font-family: var(--font-mono); font-variant-numeric: tabular-nums; }
-.meta { font-family: var(--font-mono); font-size: 12px; color: var(--muted); }
-.mt-0 { margin-top: 0; }
-
-@media (max-width: 1100px) {
-  .grid-4, .grid-5 { grid-template-columns: repeat(2, minmax(0, 1fr)); }
-  .grid-3, .grid-2-1, .grid-1-2, .grid-3-2 { grid-template-columns: minmax(0, 1fr); }
-}
-@media (max-width: 860px) {
-  .shell { grid-template-columns: 1fr; }
-  .sidebar { position: static; height: auto; }
-  .grid-2 { grid-template-columns: 1fr; }
-  .content { padding: 16px 16px 48px; }
-}
-
-/* ─── 数据表 ────────────────────────────────────────────────────── */
-.table-wrap { overflow-x: auto; border: 1px solid var(--border); border-radius: var(--radius-lg); background: var(--surface); }
-.ds-table { width: 100%; border-collapse: collapse; font-size: 13px; min-width: 640px; }
-.ds-table th, .ds-table td { padding: 9px 14px; text-align: left; border-bottom: 1px solid var(--border); white-space: nowrap; }
-.ds-table th {
-  color: var(--muted); font-weight: 550;
-  font-family: var(--font-mono); font-size: 11px;
-  letter-spacing: 0.05em;
-  background: var(--bg);
-  position: sticky; top: 0;
-}
-.ds-table tbody tr:hover { background: var(--fg-soft); }
-.ds-table tbody tr:last-child td { border-bottom: 0; }
-.ds-table .num-col { font-family: var(--font-mono); font-variant-numeric: tabular-nums; text-align: right; }
-.ds-table td.wrap, .ds-table th.wrap { white-space: normal; min-width: 180px; }
-.ds-table .cell-main { font-weight: 550; }
-.ds-table .cell-sub { display: block; font-family: var(--font-mono); font-size: 11px; color: var(--muted); margin-top: 1px; }
-.ds-table tr.clickable { cursor: pointer; }
-.ds-table .amt-in { color: var(--success); }
-.ds-table .amt-out { color: var(--danger); }
-.table-foot { display: flex; align-items: center; justify-content: space-between; padding: 10px 14px; border-top: 1px solid var(--border); font-size: 12px; color: var(--muted); }
-
-/* ─── 徽章 / 状态 ───────────────────────────────────────────────── */
-.pill {
-  display: inline-flex; align-items: center; gap: 5px;
-  padding: 2px 9px;
-  border-radius: 999px;
-  font-size: 11.5px; font-weight: 600;
-  white-space: nowrap;
-}
-.pill::before { content: ""; width: 5px; height: 5px; border-radius: 50%; background: currentColor; }
-.pill-success { background: var(--success-soft); color: var(--success); }
-.pill-warn { background: var(--warn-soft); color: color-mix(in oklch, var(--warn) 80%, black); }
-.pill-danger { background: var(--danger-soft); color: var(--danger); }
-.pill-info { background: var(--info-soft); color: var(--info); }
-.pill-muted { background: var(--fg-soft); color: var(--muted); }
-.pill-accent { background: var(--accent-soft); color: var(--accent); }
-
-.tag {
-  display: inline-flex; align-items: center;
-  padding: 2px 8px;
-  border: 1px solid var(--border);
-  border-radius: 6px;
-  font-family: var(--font-mono);
-  font-size: 11px;
-  color: var(--muted);
-  white-space: nowrap;
-}
-
-/* ─── 筛选栏与表单 ──────────────────────────────────────────────── */
-.filters {
-  display: flex; align-items: flex-end; gap: 12px; flex-wrap: wrap;
-  padding: 14px 16px;
-  background: var(--surface);
-  border: 1px solid var(--border);
-  border-radius: var(--radius-lg);
-  margin-bottom: 14px;
-}
-.field { display: flex; flex-direction: column; gap: 5px; min-width: 0; }
-.field > label { font-size: 12px; color: var(--muted); font-weight: 550; }
-.input, .select, .textarea, .field .input, .field .select, .field .textarea {
-  padding: 7px 11px;
-  border: 1px solid var(--border);
-  border-radius: var(--radius);
-  background: var(--surface);
-  color: var(--fg);
-  font: inherit;
-  font-size: 13px;
-  min-height: 34px;
-}
-.input:focus, .select:focus, .textarea:focus, .field .input:focus, .field .select:focus, .field .textarea:focus {
-  outline: 2px solid var(--accent-soft);
-  border-color: var(--accent);
-}
-.input.num-input { font-family: var(--font-mono); font-variant-numeric: tabular-nums; }
-.textarea { min-height: 84px; resize: vertical; line-height: 1.55; }
-.field .hint { font-size: 11.5px; color: var(--muted); }
-.field .hint.error { color: var(--danger); }
-
-/* ─── Tabs ──────────────────────────────────────────────────────── */
-.tabs { display: flex; gap: 2px; border-bottom: 1px solid var(--border); margin-bottom: 16px; overflow-x: auto; }
-.tabs button {
-  background: none; border: 0;
-  padding: 9px 14px;
-  font-size: 13px; font-weight: 550;
-  color: var(--muted);
-  border-bottom: 2px solid transparent;
-  margin-bottom: -1px;
-  flex: none;
-  white-space: nowrap;
-}
-.tabs button:hover { color: var(--fg); }
-.tabs button.active { color: var(--fg); border-bottom-color: var(--accent); }
-.tabs button .tab-count {
-  font-family: var(--font-mono); font-size: 10.5px;
-  padding: 1px 6px; border-radius: 999px;
-  background: var(--fg-soft); color: var(--muted);
-  margin-left: 5px;
-}
-.tabs button.active .tab-count { background: var(--accent-soft); color: var(--accent); }
-
-/* ─── 时间轴(账期) ─────────────────────────────────────────────── */
-.timeline { display: flex; gap: 0; border: 1px solid var(--border); border-radius: var(--radius-lg); overflow: hidden; background: var(--surface); padding: 0; }
-.tl-cell { flex: 1; padding: 12px 10px; border-right: 1px solid var(--border); text-align: center; min-width: 0; }
-.tl-cell:last-child { border-right: 0; }
-.tl-cell .tl-month { font-family: var(--font-mono); font-size: 11px; color: var(--muted); letter-spacing: 0.04em; }
-.tl-cell .tl-state { font-size: 12px; font-weight: 600; margin-top: 4px; display: flex; align-items: center; justify-content: center; gap: 5px; }
-.tl-cell.closed { background: var(--fg-soft); }
-.tl-cell.closed .tl-state { color: var(--muted); }
-.tl-cell.current { background: var(--accent-soft); }
-.tl-cell.current .tl-state { color: var(--accent); }
-.tl-cell.open .tl-state { color: var(--fg); }
-
-/* ─── 进度条 ────────────────────────────────────────────────────── */
-.progress { height: 6px; border-radius: 999px; background: var(--fg-soft); overflow: hidden; }
-.progress > span { display: block; height: 100%; border-radius: 999px; background: var(--accent); }
-.progress.warn > span { background: var(--warn); }
-.progress.danger > span { background: var(--danger); }
-
-/* ─── 列表行(快查 / 待办 / 通知) ────────────────────────────────── */
-.list-row {
-  display: flex; align-items: center; gap: 12px;
-  padding: 10px 4px;
-  border-bottom: 1px solid var(--border);
-  font-size: 13px;
-}
-.list-row:last-child { border-bottom: 0; }
-.list-row .lr-main { min-width: 0; flex: 1; }
-.list-row .lr-title { font-weight: 550; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
-.list-row .lr-sub { font-size: 12px; color: var(--muted); margin-top: 1px; }
-.list-row .lr-side { text-align: right; flex: none; }
-[data-detail] { cursor: pointer; }
-.list-row[data-detail]:hover { background: var(--fg-soft); }
-.list-row[data-detail] { margin-inline: -4px; padding-inline: 4px; border-radius: var(--radius); }
-
-/* ─── 弹窗 ──────────────────────────────────────────────────────── */
-.modal-backdrop {
-  position: fixed; inset: 0; z-index: 50;
-  background: color-mix(in oklch, var(--fg) 45%, transparent);
-  display: none;
-  align-items: center; justify-content: center;
-  padding: 24px;
-}
-.modal-backdrop.open { display: flex; }
-.modal {
-  background: var(--surface);
-  border-radius: var(--radius-lg);
-  border: 1px solid var(--border);
-  width: 100%; max-width: 560px;
-  max-height: 86vh; overflow-y: auto;
-  padding: 22px 24px;
-  box-shadow: 0 18px 50px color-mix(in oklch, var(--fg) 25%, transparent);
-}
-.modal.wide { max-width: 760px; }
-.modal-head { display: flex; align-items: center; justify-content: space-between; margin-bottom: 4px; }
-.modal-title { font-size: 16px; font-weight: 700; }
-.modal-close { background: none; border: 0; color: var(--muted); font-size: 18px; padding: 4px 8px; border-radius: 6px; }
-.modal-close:hover { background: var(--fg-soft); color: var(--fg); }
-.modal-sub { font-size: 12.5px; color: var(--muted); margin-bottom: 16px; }
-.modal-actions { display: flex; justify-content: flex-end; gap: 8px; margin-top: 20px; }
-
-/* ─── 明细展开行 ────────────────────────────────────────────────── */
-.detail-box {
-  background: var(--bg);
-  border: 1px solid var(--border);
-  border-radius: var(--radius);
-  padding: 12px 14px;
-  font-size: 12.5px;
-}
-.kv { display: grid; grid-template-columns: auto 1fr; gap: 4px 18px; font-size: 12.5px; }
-.kv dt { color: var(--muted); }
-.kv dd { margin: 0; font-family: var(--font-mono); font-variant-numeric: tabular-nums; }
-
-/* ─── 提示条 ────────────────────────────────────────────────────── */
-.notice {
-  display: flex; gap: 10px; align-items: flex-start;
-  padding: 12px 14px;
-  border-radius: var(--radius-lg);
-  border: 1px solid var(--border);
-  font-size: 13px;
-  background: var(--surface);
-}
-.notice.warn { background: var(--warn-soft); border-color: color-mix(in oklch, var(--warn) 30%, transparent); }
-.notice.danger { background: var(--danger-soft); border-color: color-mix(in oklch, var(--danger) 30%, transparent); }
-.notice.info { background: var(--info-soft); border-color: color-mix(in oklch, var(--info) 25%, transparent); }
-.notice .n-title { font-weight: 650; }
-.notice .n-body { color: color-mix(in oklch, var(--fg) 80%, var(--muted)); margin-top: 2px; font-size: 12.5px; }
-
-/* ─── 登录页 ────────────────────────────────────────────────────── */
-.login-wrap {
-  min-height: 100vh;
-  display: grid;
-  grid-template-columns: 1fr 1fr;
-}
-.login-aside {
-  background: var(--fg);
-  color: var(--surface);
-  padding: 48px 56px;
-  display: flex; flex-direction: column;
-}
-.login-aside .brand-mark { font-family: var(--font-mono); font-size: 12px; letter-spacing: 0.1em; opacity: 0.65; }
-.login-aside h1 { font-size: 30px; font-weight: 700; letter-spacing: -0.02em; margin-top: 18px; line-height: 1.25; }
-.login-aside .aside-sub { opacity: 0.72; font-size: 14px; margin-top: 14px; max-width: 40ch; }
-.login-aside .aside-list { margin-top: auto; display: flex; flex-direction: column; gap: 12px; }
-.login-aside .aside-item { display: flex; gap: 10px; font-size: 13px; opacity: 0.85; align-items: baseline; }
-.login-aside .aside-item .tick { font-family: var(--font-mono); color: var(--accent); }
-.login-panel { display: grid; place-items: center; padding: 48px 32px; }
-.login-card { width: 100%; max-width: 400px; }
-.login-card h2 { font-size: 20px; font-weight: 700; letter-spacing: -0.01em; }
-.login-card .login-sub { color: var(--muted); font-size: 13px; margin: 6px 0 24px; }
-.role-switch { display: grid; grid-template-columns: 1fr 1fr; gap: 8px; margin-bottom: 18px; }
-.role-switch button {
-  border: 1px solid var(--border);
-  background: var(--surface);
-  border-radius: var(--radius);
-  padding: 12px 10px;
-  text-align: left;
-  transition: border-color 0.12s ease, background 0.12s ease;
-}
-.role-switch button .r-name { font-size: 13.5px; font-weight: 650; }
-.role-switch button .r-desc { font-size: 11.5px; color: var(--muted); margin-top: 2px; }
-.role-switch button.active { border-color: var(--accent); background: var(--accent-soft); }
-.role-switch button.active .r-name { color: var(--accent); }
-.login-card .field { margin-bottom: 14px; }
-.login-foot { margin-top: 16px; font-size: 12px; color: var(--muted); text-align: center; }
-.login-foot a { color: var(--accent); font-weight: 550; }
-.login-foot a:hover { text-decoration: underline; }
-
-/* 端标识：登录页顶部大字区分管理端 / 公司端 */
-.login-role-title {
-  font-size: 34px;
-  font-weight: 800;
-  letter-spacing: 0.02em;
-  line-height: 1.15;
-  margin-bottom: 6px;
-}
-.login-role-title.admin { color: var(--accent); }
-.login-role-title.company { color: var(--info); }
-.login-role-caption { color: var(--muted); font-size: 13px; margin-bottom: 22px; }
-/* 管理端青绿 / 公司端品蓝侧栏色块 */
-.login-aside.company { background: var(--info); }
-.login-aside.company .aside-item .tick { color: var(--surface); opacity: 0.85; }
-.login-back {
-  display: inline-flex; align-items: center; gap: 6px;
-  margin-bottom: 20px;
-  padding: 6px 12px;
-  border: 1px solid var(--border);
-  border-radius: 999px;
-  background: var(--surface);
-  color: var(--fg);
-  font-size: 12.5px; font-weight: 600;
-}
-.login-back:hover { border-color: var(--accent); color: var(--accent); }
-.login-back.company:hover { border-color: var(--info); color: var(--info); }
-@media (max-width: 900px) {
-  .login-wrap { grid-template-columns: 1fr; }
-  .login-aside { display: none; }
-}
-
-/* ─── 空状态 ────────────────────────────────────────────────────── */
-.empty {
-  padding: 40px 20px;
-  text-align: center;
-  color: var(--muted);
-  font-size: 13px;
-}
-.empty .e-title { font-weight: 600; color: var(--fg); margin-bottom: 4px; }
-
-/* ─── 账期流程条(公司端工作台) ─────────────────────────────────── */
-.flow { display: grid; grid-template-columns: repeat(5, 1fr); border: 1px solid var(--border); border-radius: var(--radius-lg); overflow: hidden; background: var(--surface); }
-.flow-step { padding: 14px 16px 13px; border-right: 1px solid var(--border); min-width: 0; }
-.flow-step:last-child { border-right: 0; }
-a.flow-step { cursor: pointer; transition: background 0.12s ease; }
-a.flow-step:hover { background: var(--fg-soft); }
-.flow-step .fs-top { display: flex; align-items: center; gap: 8px; }
-.flow-step .fs-idx { font-family: var(--font-mono); font-size: 11px; color: var(--muted); }
-.flow-step .fs-dot { width: 9px; height: 9px; border-radius: 50%; background: var(--border); flex: none; }
-.flow-step .fs-name { font-size: 13.5px; font-weight: 650; }
-.flow-step .fs-state { font-size: 12px; font-weight: 600; margin-top: 7px; color: var(--muted); }
-.flow-step .fs-meta { font-size: 12px; color: var(--muted); margin-top: 2px; }
-.flow-step.done .fs-dot { background: var(--success); }
-.flow-step.done .fs-state { color: var(--success); }
-.flow-step.part .fs-dot { background: var(--warn); }
-.flow-step.part .fs-state { color: color-mix(in oklch, var(--warn) 78%, black); }
-.flow-step.doing { background: var(--warn-soft); }
-.flow-step.doing .fs-dot { background: var(--warn); box-shadow: 0 0 0 3px color-mix(in oklch, var(--warn) 22%, transparent); }
-.flow-step.doing .fs-state { color: color-mix(in oklch, var(--warn) 78%, black); }
-a.flow-step.doing:hover { background: color-mix(in oklch, var(--warn) 16%, transparent); }
-@media (max-width: 860px) {
-  .flow { grid-template-columns: 1fr; }
-  .flow-step { border-right: 0; border-bottom: 1px solid var(--border); }
-  .flow-step:last-child { border-bottom: 0; }
-}
-
-/* ─── 迷你指标(2×2 数字块) ────────────────────────────────────── */
-.mini-stats { display: grid; grid-template-columns: 1fr 1fr; gap: 10px; }
-.mini-stat { background: var(--bg); border: 1px solid var(--border); border-radius: var(--radius); padding: 11px 13px; min-width: 0; }
-.mini-stat .ms-label { font-size: 11.5px; color: var(--muted); }
-.mini-stat .ms-value { font-family: var(--font-mono); font-variant-numeric: tabular-nums; font-size: 17px; font-weight: 650; letter-spacing: -0.01em; margin-top: 3px; }
-.mini-stat .ms-value .unit { font-size: 11px; font-weight: 400; color: var(--muted); margin-left: 2px; }
-.mini-stat .ms-value.pos { color: var(--success); }
-.mini-stat .ms-value.neg { color: var(--danger); }
-
-/* ─── 上传组件(拖放区 / 文件条 / 附件选择) ────────────────────── */
-.dropzone {
-  border: 1.5px dashed color-mix(in oklch, var(--fg) 28%, var(--border));
-  border-radius: var(--radius-lg);
-  background: var(--bg);
-  padding: 30px 20px;
-  text-align: center;
-  cursor: pointer;
-  transition: border-color 0.12s ease, background 0.12s ease;
-}
-.dropzone:hover, .dropzone:focus-visible { border-color: var(--accent); background: var(--accent-soft); }
-.dropzone.dragover { border-color: var(--accent); border-style: solid; background: var(--accent-soft); }
-.dropzone svg { width: 28px; height: 28px; margin: 0 auto 10px; color: var(--muted); }
-.dropzone .dz-title { font-size: 14px; font-weight: 650; }
-.dropzone .dz-sub { font-size: 12.5px; color: var(--muted); margin-top: 5px; }
-.dropzone .dz-sub .dz-browse { color: var(--accent); font-weight: 600; text-decoration: underline; text-underline-offset: 3px; }
-.dropzone .dz-formats { font-family: var(--font-mono); font-size: 11px; color: var(--muted); margin-top: 12px; letter-spacing: 0.02em; }
-
-.file-chip {
-  display: flex; align-items: center; gap: 10px;
-  margin-top: 12px;
-  padding: 10px 12px;
-  border: 1px solid var(--border);
-  border-radius: var(--radius);
-  background: var(--surface);
-}
-.file-chip svg { width: 18px; height: 18px; color: var(--muted); flex: none; }
-.file-chip .fc-info { min-width: 0; flex: 1; }
-.file-chip .fc-name { font-size: 13px; font-weight: 600; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
-.file-chip .fc-meta { font-family: var(--font-mono); font-size: 11px; color: var(--muted); margin-top: 1px; }
-.file-chip .fc-remove { background: none; border: 0; color: var(--muted); font-size: 16px; line-height: 1; padding: 4px 8px; border-radius: 6px; flex: none; }
-.file-chip .fc-remove:hover { color: var(--danger); background: var(--danger-soft); }
-
-.attach-pick {
-  display: inline-flex; align-items: center; gap: 7px;
-  padding: 7px 12px;
-  min-height: 34px;
-  border: 1.5px dashed color-mix(in oklch, var(--fg) 28%, var(--border));
-  border-radius: var(--radius);
-  color: var(--muted);
-  font-size: 13px;
-  cursor: pointer;
-  transition: border-color 0.12s ease, color 0.12s ease, background 0.12s ease;
-}
-.attach-pick svg { width: 15px; height: 15px; }
-.attach-pick:hover { border-color: var(--accent); color: var(--accent); background: var(--accent-soft); }
-
-/* ─── 数据表合计行 ─────────────────────────────────────────────── */
-.ds-table tfoot td { background: var(--bg); font-weight: 650; border-top: 1.5px solid color-mix(in oklch, var(--fg) 30%, var(--border)); border-bottom: 0; }
-
-/* ─── 入口页(index) ────────────────────────────────────────────── */
-.portal-wrap { min-height: 100vh; display: grid; place-items: center; padding: 40px 24px; }
-.portal-inner { width: 100%; max-width: 880px; }
-.portal-grid { display: grid; grid-template-columns: 1fr 1fr; gap: 16px; margin-top: 28px; }
-.portal-card {
-  display: block;
-  background: var(--surface);
-  border: 1px solid var(--border);
-  border-radius: var(--radius-lg);
-  padding: 24px;
-  transition: border-color 0.12s ease, transform 0.12s ease;
-}
-.portal-card:hover { border-color: var(--accent); transform: translateY(-2px); }
-.portal-card .pc-role { font-family: var(--font-mono); font-size: 11px; letter-spacing: 0.08em; color: var(--accent); }
-.portal-card h3 { font-size: 17px; font-weight: 700; margin-top: 8px; }
-.portal-card p { color: var(--muted); font-size: 13px; margin-top: 6px; }
-.portal-card .pc-go { font-size: 12.5px; font-weight: 600; color: var(--accent); margin-top: 14px; }
-@media (max-width: 720px) { .portal-grid { grid-template-columns: 1fr; } }
-
-/* ─── SPA 视图切换 / 无障碍结构类 ───────────────────────────────── */
-.app-view { display: none; }
-.app-view.is-active { display: block; }
-.sr-only { position: absolute !important; width: 1px; height: 1px; padding: 0; margin: -1px; overflow: hidden; clip: rect(0, 0, 0, 0); white-space: nowrap; border: 0; }
-.skip-link {
-  position: fixed; top: 8px; left: 50%; z-index: 500;
-  padding: 8px 14px;
-  border-radius: var(--radius);
-  background: var(--accent); color: var(--surface);
-  font-size: 13px; font-weight: 600;
-  transform: translate(-50%, -150%);
-  transition: transform 0.12s ease;
-}
-.skip-link:focus { transform: translate(-50%, 0); }
-
-/* ─── 图标按钮 / 窄屏侧栏折叠 ──────────────────────────────────── */
-.icon-button {
-  display: inline-grid; place-items: center;
-  width: 34px; height: 34px;
-  border: 1px solid var(--border);
-  border-radius: var(--radius);
-  background: var(--surface); color: var(--muted);
-  cursor: pointer;
-  transition: border-color 0.12s ease, background 0.12s ease, color 0.12s ease;
-}
-.icon-button:hover { color: var(--fg); border-color: color-mix(in oklch, var(--fg) 40%, var(--border)); background: var(--fg-soft); }
-.icon-button svg { width: 18px; height: 18px; }
-.menu-button { display: none; }
-@media (max-width: 860px) {
-  .menu-button { display: inline-grid; }
-  .shell { grid-template-columns: 1fr; }
-  .sidebar {
-    position: fixed; top: 0; left: 0; bottom: 0; z-index: 40;
-    width: var(--side-w); height: 100dvh;
-    transform: translateX(-100%);
-    transition: transform 0.2s ease;
-  }
-  .sidebar.is-open { transform: none; box-shadow: 0 0 48px color-mix(in oklch, var(--fg) 22%, transparent); }
-}
-
-/* ─── Toast 轻量提示 ───────────────────────────────────────────── */
-.toast-region { position: fixed; right: 16px; bottom: 16px; z-index: 300; display: grid; gap: 8px; }
-.toast {
-  display: flex; align-items: flex-start; gap: 9px;
-  min-width: 260px; max-width: 380px;
-  padding: 11px 14px;
-  border: 1px solid var(--border);
-  border-radius: var(--radius-lg);
-  background: var(--surface);
-  box-shadow: 0 12px 34px color-mix(in oklch, var(--fg) 18%, transparent);
-  font-size: 13px;
-}
-.toast .t-dot { width: 8px; height: 8px; border-radius: 50%; flex: none; margin-top: 5px; background: var(--muted); }
-.toast .t-body { min-width: 0; }
-.toast .t-title { font-weight: 650; }
-.toast .t-detail { color: var(--muted); font-size: 12px; margin-top: 1px; }
-.toast.success { border-color: color-mix(in oklch, var(--success) 35%, var(--border)); }
-.toast.success .t-dot { background: var(--success); }
-.toast.warn { border-color: color-mix(in oklch, var(--warn) 40%, var(--border)); }
-.toast.warn .t-dot { background: var(--warn); }
-.toast.danger { border-color: color-mix(in oklch, var(--danger) 35%, var(--border)); }
-.toast.danger .t-dot { background: var(--danger); }
-.toast.info { border-color: color-mix(in oklch, var(--info) 35%, var(--border)); }
-.toast.info .t-dot { background: var(--info); }
-@media (max-width: 720px) {
-  .toast-region { right: 12px; bottom: 12px; left: 12px; }
-  .toast { min-width: 0; max-width: none; }
-}
-
-/* ─── 侧滑详情抽屉（用 modal/card token 重画） ─────────────────── */
-.drawer {
-  position: fixed; top: 0; right: 0; bottom: 0; z-index: 60;
-  width: min(400px, calc(100vw - 24px));
-  display: flex; flex-direction: column;
-  background: var(--surface);
-  border-left: 1px solid var(--border);
-  box-shadow: -18px 0 50px color-mix(in oklch, var(--fg) 22%, transparent);
-  transform: translateX(100%);
-  visibility: hidden;
-  transition: transform 0.22s ease, visibility 0.22s;
-}
-.drawer.is-open { transform: none; visibility: visible; }
-.drawer-head { display: flex; align-items: flex-start; justify-content: space-between; gap: 12px; padding: 18px 20px 12px; border-bottom: 1px solid var(--border); }
-.drawer-head .d-title { font-size: 16px; font-weight: 700; margin-top: 6px; }
-.drawer-head .d-desc { color: var(--muted); font-size: 12.5px; margin-top: 4px; }
-.drawer-body { flex: 1; overflow-y: auto; padding: 16px 20px; }
-.drawer-body .kv { grid-template-columns: auto 1fr; gap: 8px 18px; }
-.drawer-body .kv dt { color: var(--muted); white-space: nowrap; }
-.drawer-body .kv dd { text-align: right; word-break: break-all; }
-.drawer-tip { margin: 0 20px 12px; padding: 12px 14px; border: 1px solid var(--border); border-radius: var(--radius); background: var(--bg); color: var(--muted); font-size: 12.5px; }
-.drawer-tip strong { display: block; color: var(--fg); margin-bottom: 4px; }
-.drawer-foot { display: flex; justify-content: flex-end; gap: 8px; padding: 14px 20px; border-top: 1px solid var(--border); }
-
-/* ─── 加载中骨架 / 表内加载行 ──────────────────────────────────── */
-.skeleton { display: block; border-radius: var(--radius); background: var(--fg-soft); position: relative; overflow: hidden; }
-.skeleton::after {
-  content: ""; position: absolute; inset: 0;
-  background: linear-gradient(90deg, transparent, color-mix(in oklch, var(--surface) 60%, transparent), transparent);
-  animation: skeleton-shimmer 1.3s ease-in-out infinite;
-}
-@keyframes skeleton-shimmer { from { transform: translateX(-100%); } to { transform: translateX(100%); } }
-.skeleton-line { height: 12px; margin-bottom: 10px; }
-.loading-row { padding: 40px 20px; text-align: center; color: var(--muted); font-family: var(--font-mono); font-size: 12.5px; letter-spacing: 0.04em; }
-.loading-inline { display: inline-flex; align-items: center; gap: 8px; color: var(--muted); font-family: var(--font-mono); font-size: 12.5px; }
-.loading-inline::before {
-  content: ""; width: 12px; height: 12px; border-radius: 50%;
-  border: 2px solid var(--border); border-top-color: var(--accent);
-  animation: loading-spin 0.7s linear infinite;
-}
-@keyframes loading-spin { to { transform: rotate(360deg); } }
-
-/* ─── 提示条补充：成功态 ───────────────────────────────────────── */
-.notice.success { background: var(--success-soft); border-color: color-mix(in oklch, var(--success) 30%, transparent); }
-.notice.success .n-title { color: color-mix(in oklch, var(--success) 82%, black); }

web/index.html

@@ -1,33 +1,75 @@
 <!doctype html>
 <html lang="zh-CN">
-<head>
-  <meta charset="utf-8" />
-  <meta name="viewport" content="width=device-width, initial-scale=1" />
-  <title>金牛实业资金往来管理系统 · 入口</title>
-  <link rel="stylesheet" href="design-system.css?v=5" />
-</head>
-<body>
-  <div class="portal-wrap">
-    <div class="portal-inner">
-      <p class="meta" style="letter-spacing: 0.1em;">JINNIU GROUP · INTERCOMPANY TREASURY</p>
-      <h1 style="font-size: 26px; font-weight: 700; letter-spacing: -0.015em; margin-top: 10px;">河南金牛实业集团有限公司 · 资金往来管理系统</h1>
-      <p class="muted" style="margin-top: 10px; max-width: 64ch;">集团内部公司间资金往来记账平台。银行流水导入后自动轧算往来余额，支持从集团汇总逐级穿透至银行原始流水。本系统包含管理端与公司业务端两套界面。</p>
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <meta name="description" content="河南金牛实业集团有限公司资金往来管理系统" />
+    <title>登录 · 河南金牛实业集团有限公司资金往来管理系统</title>
+    <link rel="stylesheet" href="styles.css?v=2" />
+  </head>
+  <body class="entry-page">
+    <main class="entry-shell">
+      <header class="entry-topbar">
+        <div class="entry-brand">
+          <span class="entry-seal" aria-hidden="true">金</span>
+          <span class="entry-system-name">河南金牛实业集团有限公司资金往来管理系统</span>
+        </div>
+      </header>
 
-      <div class="portal-grid">
-        <a class="portal-card" href="login-admin.html">
-          <span class="pc-role">管理端 · 7 个页面</span>
-          <h3>管理总览 / 往来查询 / 审核中心 / 流水管理 / 公司与账号 / 结账与期初 / 提醒管理</h3>
-          <p>面向管理员：全局监控各公司流水提交与往来余额，集中处理审核事项，执行月度结账。</p>
-          <span class="pc-go">去管理端登录 →</span>
-        </a>
-        <a class="portal-card" href="login-company.html">
-          <span class="pc-role">公司业务端 · 7 个页面</span>
-          <h3>工作台 / 流水导入 / 手工记录 / 流水管理 / 往来确认 / 银行账户 / 通知</h3>
-          <p>面向成员公司出纳：上传银行流水、登记手工往来、确认单边匹配与科目，跟踪本月完成进度。</p>
-          <span class="pc-go">去公司端登录 →</span>
-        </a>
-      </div>
-    </div>
-  </div>
-</body>
+      <section class="entry-context" aria-labelledby="entry-heading">
+        <div class="entry-statement">
+          <h1 id="entry-heading">集团资金往来管理</h1>
+          <p>集团内部资金往来登记、核对及台账查询入口</p>
+        </div>
+        <svg class="entry-figure" viewBox="0 0 520 300" aria-hidden="true" focusable="false" preserveAspectRatio="xMidYMax meet">
+          <path class="fig-arc" d="M 12 292 C 150 150, 370 150, 508 292" />
+          <rect class="fig-bar" x="96" y="150" width="34" height="140" rx="6" />
+          <rect class="fig-bar" x="172" y="120" width="34" height="170" rx="6" />
+          <rect class="fig-bar" x="248" y="178" width="34" height="112" rx="6" />
+          <rect class="fig-bar" x="324" y="100" width="34" height="190" rx="6" />
+          <rect class="fig-bar" x="400" y="60" width="34" height="230" rx="6" />
+          <polyline class="fig-line" points="113,138 189,108 265,166 341,88 417,48" />
+        </svg>
+      </section>
+
+      <section class="entry-form-wrap" aria-labelledby="login-title">
+        <form class="entry-form" id="loginForm">
+          <header>
+            <h2 id="login-title">欢迎登录</h2>
+            <p>请选择登录入口，使用账号和密码进入系统</p>
+          </header>
+
+          <p class="entry-note" id="loginError" role="alert" hidden></p>
+
+          <div class="role-switch" role="radiogroup" aria-label="登录入口">
+            <label><input type="radio" name="role" value="admin" checked /><span><svg><use href="icons.svg#shield-check"/></svg><b>总账管理端</b><small>集团管理员</small></span></label>
+            <label><input type="radio" name="role" value="company" /><span><svg><use href="icons.svg#building"/></svg><b>公司业务端</b><small>公司出纳</small></span></label>
+          </div>
+
+          <label class="field"><span>账号</span><input name="username" autocomplete="username" required /></label>
+          <label class="field"><span>密码</span><span class="password-field"><input name="password" type="password" autocomplete="current-password" required /><button type="button" class="inside-icon" id="togglePassword" aria-label="显示密码" title="显示密码"><svg><use href="icons.svg#eye"/></svg></button></span></label>
+
+          <div id="changePassword" hidden>
+            <p class="entry-note">首次登录须修改密码，请设置新密码后再进入工作台。</p>
+            <label class="field"><span>新密码</span><input name="new_password" type="password" autocomplete="new-password" /></label>
+            <label class="field"><span>确认新密码</span><input name="confirm_password" type="password" autocomplete="new-password" /></label>
+          </div>
+
+          <div class="entry-options">
+            <label class="check-field"><input type="checkbox" checked />记住登录入口</label>
+            <a class="entry-hint" href="#changePassword">首次登录需修改密码</a>
+          </div>
+
+          <button class="button primary wide" type="submit">
+            <span class="spinner" aria-hidden="true"></span>
+            <span id="loginAction">进入总账管理端</span>
+            <svg class="submit-arrow"><use href="icons.svg#chevron-right"/></svg>
+          </button>
+
+          <p class="entry-compliance">登录即表示你已阅读并遵守集团资金往来管理规范</p>
+        </form>
+      </section>
+    </main>
+    <script src="app.js?v=2"></script>
+  </body>
 </html>

web/login-admin.html

@@ -1,80 +0,0 @@
-<!doctype html>
-<html lang="zh-CN">
-<head>
-  <meta charset="utf-8" />
-  <meta name="viewport" content="width=device-width, initial-scale=1" />
-  <title>登录 · 金牛实业资金往来管理系统</title>
-  <link rel="stylesheet" href="design-system.css?v=5" />
-</head>
-<body data-role="admin">
-  <div class="login-wrap">
-    <aside class="login-aside">
-      <span class="brand-mark">JINNIU GROUP · TREASURY</span>
-      <h1>河南金牛实业集团有限公司<br />资金往来管理系统</h1>
-      <p class="aside-sub">集团内部各公司之间资金往来的统一记账平台。导入银行流水后自动轧算公司间往来余额，从集团汇总可层层下钻至银行原始流水。</p>
-      <div class="aside-list">
-        <div class="aside-item"><span class="tick">01</span><span>银行流水自动归集，公司间往来余额实时轧算</span></div>
-        <div class="aside-item"><span class="tick">02</span><span>单边匹配、流水断档、科目确认集中审核</span></div>
-        <div class="aside-item"><span class="tick">03</span><span>月度结账检查：流水提交、账户连续、审核完成</span></div>
-        <div class="aside-item"><span class="tick">04</span><span>汇总 → 公司 → 账户 → 原始流水，四级穿透追溯</span></div>
-      </div>
-    </aside>
-
-    <main class="login-panel">
-      <div class="login-card">
-        <a class="login-back" href="index.html">← 返回入口页</a>
-        <div class="login-role-title admin">管理端</div>
-        <p class="login-role-caption">管理员统一监控集团各公司资金往来，执行月度结账。</p>
-        <h2>登录系统</h2>
-        <p class="login-sub">请输入账号密码登录管理端。首次登录需修改初始密码。</p>
-
-        <form id="login-form" novalidate>
-          <div class="field">
-            <label for="account">账号</label>
-            <input class="input" id="account" placeholder="请输入账号" autocomplete="username" />
-            <span class="hint error" id="account-err" hidden>请输入账号</span>
-          </div>
-          <div class="field">
-            <label for="password">密码</label>
-            <input class="input" id="password" type="password" placeholder="请输入密码" autocomplete="current-password" />
-            <span class="hint error" id="password-err" hidden>请输入密码</span>
-          </div>
-          <div class="field">
-            <span class="hint error" id="login-err" role="alert" hidden></span>
-          </div>
-          <button class="btn btn-primary" type="submit" style="width: 100%; margin-top: 6px;">登 录</button>
-        </form>
-
-        <p class="login-foot">忘记密码请联系管理员重置 · <a href="index.html">返回入口页</a></p>
-      </div>
-    </main>
-  </div>
-
-  <div class="modal-backdrop" id="pwd-modal">
-    <div class="modal" role="dialog" aria-modal="true" aria-labelledby="pwd-title">
-      <div class="modal-head">
-        <span class="modal-title" id="pwd-title">首次登录 · 修改初始密码</span>
-      </div>
-      <p class="modal-sub">为保障资金安全，首次登录必须修改初始密码。新密码需 8 位以上，且包含字母与数字。</p>
-      <div class="field" style="margin-bottom: 12px;">
-        <label for="new-pwd">新密码</label>
-        <input class="input" id="new-pwd" type="password" placeholder="8 位以上，含字母与数字" autocomplete="new-password" />
-        <span class="hint error" id="new-pwd-err" hidden>密码需 8 位以上，且包含字母与数字</span>
-      </div>
-      <div class="field">
-        <label for="new-pwd2">确认新密码</label>
-        <input class="input" id="new-pwd2" type="password" placeholder="再次输入新密码" autocomplete="new-password" />
-        <span class="hint error" id="new-pwd2-err" hidden>两次输入的密码不一致</span>
-      </div>
-      <div class="field" style="margin-top: 12px;">
-        <span class="hint error" id="pwd-err" role="alert" hidden></span>
-      </div>
-      <div class="modal-actions">
-        <button class="btn btn-primary" id="pwd-confirm">确认修改并进入系统</button>
-      </div>
-    </div>
-  </div>
-
-  <script src="login.js?v=5"></script>
-</body>
-</html>

web/login-company.html

@@ -1,80 +0,0 @@
-<!doctype html>
-<html lang="zh-CN">
-<head>
-  <meta charset="utf-8" />
-  <meta name="viewport" content="width=device-width, initial-scale=1" />
-  <title>登录 · 金牛实业资金往来管理系统</title>
-  <link rel="stylesheet" href="design-system.css?v=5" />
-</head>
-<body data-role="company">
-  <div class="login-wrap">
-    <aside class="login-aside company">
-      <span class="brand-mark">JINNIU GROUP · TREASURY</span>
-      <h1>河南金牛实业集团有限公司<br />资金往来管理系统</h1>
-      <p class="aside-sub">集团内部各公司之间资金往来的统一记账平台。导入银行流水后自动轧算公司间往来余额，从集团汇总可层层下钻至银行原始流水。</p>
-      <div class="aside-list">
-        <div class="aside-item"><span class="tick">01</span><span>银行流水自动归集，公司间往来余额实时轧算</span></div>
-        <div class="aside-item"><span class="tick">02</span><span>单边匹配、流水断档、科目确认集中审核</span></div>
-        <div class="aside-item"><span class="tick">03</span><span>月度结账检查：流水提交、账户连续、审核完成</span></div>
-        <div class="aside-item"><span class="tick">04</span><span>汇总 → 公司 → 账户 → 原始流水，四级穿透追溯</span></div>
-      </div>
-    </aside>
-
-    <main class="login-panel">
-      <div class="login-card">
-        <a class="login-back company" href="index.html">← 返回入口页</a>
-        <div class="login-role-title company">公司端</div>
-        <p class="login-role-caption">成员公司出纳上传流水、登记手工往来、确认单边匹配。</p>
-        <h2>登录系统</h2>
-        <p class="login-sub">请输入账号密码登录公司业务端。首次登录需修改初始密码。</p>
-
-        <form id="login-form" novalidate>
-          <div class="field">
-            <label for="account">账号</label>
-            <input class="input" id="account" placeholder="请输入账号" autocomplete="username" />
-            <span class="hint error" id="account-err" hidden>请输入账号</span>
-          </div>
-          <div class="field">
-            <label for="password">密码</label>
-            <input class="input" id="password" type="password" placeholder="请输入密码" autocomplete="current-password" />
-            <span class="hint error" id="password-err" hidden>请输入密码</span>
-          </div>
-          <div class="field">
-            <span class="hint error" id="login-err" role="alert" hidden></span>
-          </div>
-          <button class="btn btn-primary" type="submit" style="width: 100%; margin-top: 6px;">登 录</button>
-        </form>
-
-        <p class="login-foot">忘记密码请联系管理员重置 · <a href="index.html">返回入口页</a></p>
-      </div>
-    </main>
-  </div>
-
-  <div class="modal-backdrop" id="pwd-modal">
-    <div class="modal" role="dialog" aria-modal="true" aria-labelledby="pwd-title">
-      <div class="modal-head">
-        <span class="modal-title" id="pwd-title">首次登录 · 修改初始密码</span>
-      </div>
-      <p class="modal-sub">为保障资金安全，首次登录必须修改初始密码。新密码需 8 位以上，且包含字母与数字。</p>
-      <div class="field" style="margin-bottom: 12px;">
-        <label for="new-pwd">新密码</label>
-        <input class="input" id="new-pwd" type="password" placeholder="8 位以上，含字母与数字" autocomplete="new-password" />
-        <span class="hint error" id="new-pwd-err" hidden>密码需 8 位以上，且包含字母与数字</span>
-      </div>
-      <div class="field">
-        <label for="new-pwd2">确认新密码</label>
-        <input class="input" id="new-pwd2" type="password" placeholder="再次输入新密码" autocomplete="new-password" />
-        <span class="hint error" id="new-pwd2-err" hidden>两次输入的密码不一致</span>
-      </div>
-      <div class="field" style="margin-top: 12px;">
-        <span class="hint error" id="pwd-err" role="alert" hidden></span>
-      </div>
-      <div class="modal-actions">
-        <button class="btn btn-primary" id="pwd-confirm">确认修改并进入系统</button>
-      </div>
-    </div>
-  </div>
-
-  <script src="login.js?v=5"></script>
-</body>
-</html>

web/login.js

@@ -1,96 +0,0 @@
-const ROLE = document.body.dataset.role || "admin";
-const REDIRECT = ROLE === "admin" ? "admin.html" : "company.html";
-
-const form = document.getElementById("login-form");
-const accountInput = document.getElementById("account");
-const passwordInput = document.getElementById("password");
-const accountErr = document.getElementById("account-err");
-const passwordErr = document.getElementById("password-err");
-const loginErr = document.getElementById("login-err");
-const submitButton = form.querySelector('button[type="submit"]');
-
-const modal = document.getElementById("pwd-modal");
-const newPwd = document.getElementById("new-pwd");
-const newPwd2 = document.getElementById("new-pwd2");
-const newPwdErr = document.getElementById("new-pwd-err");
-const newPwd2Err = document.getElementById("new-pwd2-err");
-const pwdErr = document.getElementById("pwd-err");
-const pwdConfirm = document.getElementById("pwd-confirm");
-
-const submitLabel = "登 录";
-
-function setLoading(loading) {
-  submitButton.disabled = loading;
-  submitButton.textContent = loading ? "登录中…" : submitLabel;
-  accountInput.disabled = loading;
-  passwordInput.disabled = loading;
-}
-
-function showLoginError(message) {
-  loginErr.textContent = message || "";
-  loginErr.hidden = !message;
-}
-
-function openPasswordModal() {
-  newPwd.value = "";
-  newPwd2.value = "";
-  newPwdErr.hidden = true;
-  newPwd2Err.hidden = true;
-  pwdErr.hidden = true;
-  modal.classList.add("open");
-  newPwd.focus();
-}
-
-form.addEventListener("submit", async (event) => {
-  event.preventDefault();
-  showLoginError("");
-  const account = accountInput.value.trim();
-  const password = passwordInput.value;
-  accountErr.hidden = Boolean(account);
-  passwordErr.hidden = Boolean(password);
-  if (!account || !password) return;
-
-  setLoading(true);
-  const response = await fetch("/api/login", {
-    method: "POST",
-    headers: { "Content-Type": "application/json" },
-    body: JSON.stringify({ username: account, password, portal: ROLE }),
-  }).catch(() => null);
-  const result = await response?.json().catch(() => ({}));
-  if (!response || !response.ok) {
-    showLoginError(result?.message || "登录服务暂时不可用，请稍后重试。");
-    setLoading(false);
-    return;
-  }
-  if (result.must_change_password) {
-    setLoading(false);
-    openPasswordModal();
-    return;
-  }
-  window.location.href = REDIRECT;
-});
-
-pwdConfirm.addEventListener("click", async () => {
-  const p1 = newPwd.value;
-  const p2 = newPwd2.value;
-  const valid = p1.length >= 8 && /[a-zA-Z]/.test(p1) && /\d/.test(p1);
-  newPwdErr.hidden = valid;
-  newPwd2Err.hidden = p1 === p2;
-  pwdErr.hidden = true;
-  if (!valid || p1 !== p2) return;
-
-  pwdConfirm.disabled = true;
-  const response = await fetch("/api/password/change", {
-    method: "POST",
-    headers: { "Content-Type": "application/json" },
-    body: JSON.stringify({ old_password: passwordInput.value, new_password: p1 }),
-  }).catch(() => null);
-  const result = await response?.json().catch(() => ({}));
-  if (!response || !response.ok) {
-    pwdErr.textContent = result?.message || "修改密码失败，请稍后重试。";
-    pwdErr.hidden = false;
-    pwdConfirm.disabled = false;
-    return;
-  }
-  window.location.href = REDIRECT;
-});

web/styles.css

@@ -0,0 +1,896 @@
+:root {
+  color-scheme: dark;
+  --font-ui: "Microsoft YaHei UI", "PingFang SC", "Noto Sans CJK SC", system-ui, sans-serif;
+  --font-data: "Segoe UI", "Microsoft YaHei UI", system-ui, sans-serif;
+  --color-bg: #050505;
+  --color-bg-soft: #0a0a0a;
+  --color-nav: #0a0a0a;
+  --color-surface: rgba(22, 22, 22, 0.82);
+  --color-surface-solid: #161616;
+  --color-surface-raised: #1c1c1c;
+  --color-surface-muted: rgba(255, 255, 255, 0.035);
+  --color-line: rgba(255, 255, 255, 0.09);
+  --color-line-strong: rgba(255, 255, 255, 0.16);
+  --color-ink: #f2f7f4;
+  --color-ink-soft: #a6b0aa;
+  --color-ink-muted: #89938d;
+  --color-primary: #37eb89;
+  --color-primary-strong: #70ffae;
+  --color-primary-dark: #08160e;
+  --color-primary-wash: rgba(55, 235, 137, 0.11);
+  --color-positive: #37eb89;
+  --color-positive-wash: rgba(55, 235, 137, 0.1);
+  --color-warning: #ffbc52;
+  --color-warning-wash: rgba(255, 188, 82, 0.11);
+  --color-danger: #ff626d;
+  --color-danger-wash: rgba(255, 98, 109, 0.11);
+  --color-info: #66a8ff;
+  --color-info-wash: rgba(102, 168, 255, 0.11);
+  --radius-sm: 10px;
+  --radius-md: 16px;
+  --radius-lg: 22px;
+  --radius-xl: 28px;
+  --shadow-panel: 0 24px 70px rgba(0, 0, 0, 0.34), inset 0 1px rgba(255, 255, 255, 0.035);
+  --shadow-low: 0 12px 32px rgba(0, 0, 0, 0.22), inset 0 1px rgba(255, 255, 255, 0.06), inset 0 -1px 0 rgba(0, 0, 0, 0.22);
+  --shadow-glow: 0 0 28px rgba(55, 235, 137, 0.12);
+  --duration-fast: 150ms;
+  --duration-standard: 260ms;
+  --ease-out: cubic-bezier(0.22, 1, 0.36, 1);
+  /* Login page — 深海军蓝 × 账房金 (HEL-32 已定稿) */
+  --jn-navy-900: #0B2740;
+  --jn-navy-800: #123A5C;
+  --jn-navy-700: #1B4F7A;
+  --jn-blue-600: #1D4ED8;
+  --jn-blue-700: #1E40AF;
+  --jn-blue-800: #1E3A8A;
+  --jn-blue-50: #EFF6FF;
+  --jn-gold-500: #C9A227;
+  --jn-gold-400: #D9B84A;
+  --jn-bg-page: #F5F7FA;
+  --jn-bg-panel: #FFFFFF;
+  --jn-text-1: #1F2937;
+  --jn-text-2: #6B7280;
+  --jn-text-3: #9CA3AF;
+  --jn-border: #E5E7EB;
+  --jn-border-strong: #D1D5DB;
+  --jn-error: #DC2626;
+  --jn-error-bg: #FEF2F2;
+  --jn-disabled-bg: #F3F4F6;
+}
+
+* { box-sizing: border-box; }
+html { min-width: 320px; background: var(--color-bg); scroll-behavior: smooth; }
+body { margin: 0; min-width: 320px; min-height: 100vh; background: var(--color-bg); color: var(--color-ink); font: 14px/1.6 var(--font-ui); -webkit-font-smoothing: antialiased; }
+button, input, select, textarea { font: inherit; }
+button, a, summary { -webkit-tap-highlight-color: transparent; }
+button { color: inherit; }
+a { color: inherit; text-decoration: none; }
+h1, h2, h3, p, dl, dd { margin: 0; }
+svg { width: 18px; height: 18px; fill: none; stroke: currentColor; stroke-width: 1.8; stroke-linecap: round; stroke-linejoin: round; }
+strong, .amount, .number, dd { font-variant-numeric: tabular-nums; }
+::selection { background: rgba(55, 235, 137, 0.26); color: #fff; }
+::-webkit-scrollbar { width: 9px; height: 9px; }
+::-webkit-scrollbar-track { background: transparent; }
+::-webkit-scrollbar-thumb { border: 2px solid transparent; border-radius: 10px; background: rgba(255, 255, 255, 0.15); background-clip: padding-box; }
+
+.sr-only { position: absolute !important; width: 1px; height: 1px; padding: 0; margin: -1px; overflow: hidden; clip: rect(0, 0, 0, 0); white-space: nowrap; border: 0; }
+.skip-link { position: fixed; top: 8px; left: 50%; z-index: 500; padding: 8px 12px; border-radius: var(--radius-sm); background: var(--color-primary); color: var(--color-primary-dark); transform: translate(-50%, -150%); }
+.skip-link:focus { transform: translate(-50%, 0); }
+:focus-visible { outline: 2px solid var(--color-primary-strong); outline-offset: 3px; }
+[hidden] { display: none !important; }
+
+/* Application frame */
+.app-shell { min-height: 100vh; display: grid; grid-template-columns: 266px minmax(0, 1fr); }
+.sidebar { position: fixed; inset: 18px auto 18px 18px; z-index: 120; width: 248px; display: flex; flex-direction: column; padding: 16px 12px; border: 1px solid var(--color-line); border-radius: var(--radius-xl); background: rgba(12, 12, 12, 0.9); box-shadow: var(--shadow-panel); backdrop-filter: blur(26px) saturate(125%); }
+.brand { min-height: 60px; display: flex; align-items: center; gap: 11px; padding: 7px 10px 20px; border-bottom: 1px solid var(--color-line); }
+.brand-mark { width: 36px; height: 36px; display: grid; place-items: center; flex: 0 0 auto; border: 1px solid rgba(112, 255, 174, 0.32); border-radius: 12px; background: var(--color-primary-wash); color: var(--color-primary-strong); box-shadow: var(--shadow-glow); font-size: 18px; font-weight: 800; }
+.brand-copy { display: flex; flex-direction: column; min-width: 0; }
+.brand-copy strong { font-size: 15px; }
+.brand-copy small, .user-block small, .company-context small { color: var(--color-ink-muted); font-size: 10px; }
+.company-context { min-height: 64px; display: flex; align-items: center; gap: 10px; margin: 12px 4px 2px; padding: 10px; border: 1px solid var(--color-line); border-radius: var(--radius-md); background: var(--color-surface-muted); }
+.company-context > span { width: 34px; height: 34px; display: grid; place-items: center; border-radius: 11px; background: var(--color-primary); color: var(--color-primary-dark); font-weight: 800; }
+.company-context div { display: flex; flex-direction: column; }
+.nav-list { display: grid; gap: 8px; padding: 14px 2px; overflow-y: auto; }
+.nav-item { position: relative; width: 100%; min-height: 46px; display: flex; align-items: center; gap: 11px; padding: 0 12px; border: 1px solid transparent; border-radius: 14px; background: transparent; color: var(--color-ink-soft); text-align: left; cursor: pointer; transition: color var(--duration-fast), background var(--duration-fast), border-color var(--duration-fast), transform var(--duration-fast); }
+.nav-item:hover { color: var(--color-ink); background: rgba(255, 255, 255, 0.045); transform: translateX(2px); }
+.nav-item.is-active { border-color: rgba(255, 255, 255, 0.1); background: rgba(255, 255, 255, 0.075); color: var(--color-ink); box-shadow: inset 0 1px rgba(255, 255, 255, 0.045), 0 8px 22px rgba(0, 0, 0, 0.2); }
+.nav-item.is-active svg { color: var(--color-primary); filter: drop-shadow(0 0 8px rgba(55, 235, 137, 0.42)); }
+.nav-item svg { width: 17px; flex: 0 0 auto; }
+.nav-item span { overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
+.nav-item b { min-width: 19px; height: 19px; display: grid; place-items: center; margin-left: auto; border-radius: 7px; background: var(--color-primary-wash); color: var(--color-primary); font-size: 10px; }
+.sidebar-footer { display: grid; gap: 8px; margin-top: auto; padding-top: 12px; border-top: 1px solid var(--color-line); }
+.user-block { min-height: 51px; display: flex; align-items: center; gap: 10px; padding: 7px 9px; }
+.user-block > span:last-child { display: flex; flex-direction: column; }
+.avatar { width: 34px; height: 34px; display: grid; place-items: center; flex: 0 0 auto; border-radius: 50%; background: #242c28; color: var(--color-primary-strong); font-weight: 700; }
+.workspace { min-width: 0; grid-column: 2; }
+.topbar { position: sticky; top: 0; z-index: 90; height: 56px; display: flex; align-items: center; gap: 13px; padding: 0 30px; border-bottom: 1px solid rgba(255, 255, 255, 0.055); background: rgba(5, 5, 5, 0.82); backdrop-filter: blur(22px); }
+.topbar-spacer { flex: 1; }
+.workspace-name { display: flex; flex-direction: column; min-width: 150px; }
+.workspace-name span { color: var(--color-ink-muted); font-size: 10px; }
+.workspace-name strong { font-size: 14px; }
+.demo-badge { padding: 3px 8px; border: 1px solid rgba(255, 188, 82, 0.22); border-radius: 8px; background: var(--color-warning-wash); color: var(--color-warning); font-size: 10px; }
+.topbar-actions { display: flex; align-items: center; gap: 9px; margin-left: auto; }
+.search-box { width: clamp(200px, 22vw, 340px); height: 40px; display: flex; align-items: center; gap: 9px; padding: 0 13px; border: 1px solid var(--color-line); border-radius: 14px; background: rgba(255, 255, 255, 0.035); color: var(--color-ink-muted); transition: border-color var(--duration-fast), background var(--duration-fast), box-shadow var(--duration-fast); }
+.search-box:focus-within { border-color: rgba(55, 235, 137, 0.4); background: rgba(255, 255, 255, 0.055); box-shadow: var(--shadow-glow); }
+.search-box input { width: 100%; border: 0; outline: 0; background: transparent; color: var(--color-ink); }
+.search-box input::placeholder, input::placeholder, textarea::placeholder { color: #626b66; }
+.period-button, .icon-button, .inside-icon, .swap-button { display: inline-grid; place-items: center; border: 1px solid var(--color-line); background: var(--color-surface-muted); color: var(--color-ink-soft); cursor: pointer; transition: border-color var(--duration-fast), color var(--duration-fast), background var(--duration-fast), transform var(--duration-fast); }
+.period-button { min-height: 40px; grid-auto-flow: column; gap: 8px; padding: 0 13px; border-radius: 14px; }
+.icon-button { position: relative; width: 40px; height: 40px; border-radius: 13px; }
+.inside-icon { width: 36px; height: 36px; border: 0; background: transparent; }
+.period-button:hover, .icon-button:hover, .inside-icon:hover, .swap-button:hover { border-color: var(--color-line-strong); background: rgba(255, 255, 255, 0.07); color: var(--color-ink); transform: translateY(-1px); }
+.notification-dot { position: absolute; top: -5px; right: -5px; min-width: 17px; height: 17px; display: grid; place-items: center; border: 2px solid var(--color-bg); border-radius: 9px; background: var(--color-danger); color: #fff; font: 9px var(--font-data); }
+.menu-button { display: none; }
+main { width: min(1560px, 100%); margin: 0 auto; padding: 12px 32px 58px; }
+.app-view { display: none; }
+.app-view.is-active { display: block; }
+.page-heading { min-height: 56px; display: flex; align-items: flex-start; justify-content: space-between; gap: 20px; margin-bottom: 18px; }
+.page-heading h1 { font-size: clamp(22px, 2.4vw, 30px); line-height: 1.2; letter-spacing: 0; }
+.page-heading p { margin-top: 5px; color: var(--color-ink-muted); }
+.content-toolbar { display: contents; }
+.content-toolbar > .search-box { margin-inline: auto; width: clamp(260px, 42vw, 520px); }
+.content-toolbar .toolbar-group { display: flex; align-items: center; gap: 10px; flex-shrink: 0; }
+.dashboard-head { align-items: center; gap: 20px; margin-bottom: 20px; }
+
+/* Commands and fields */
+.button { min-height: 40px; display: inline-flex; align-items: center; justify-content: center; gap: 8px; padding: 0 15px; border: 1px solid transparent; border-radius: 13px; font-weight: 700; cursor: pointer; transition: transform var(--duration-fast), box-shadow var(--duration-fast), background var(--duration-fast), border-color var(--duration-fast); }
+.button:hover { transform: translateY(-1px); }
+.button:active { transform: translateY(0) scale(0.985); }
+.button.primary { background: var(--color-primary); color: var(--color-primary-dark); box-shadow: 0 8px 24px rgba(55, 235, 137, 0.18); }
+.button.primary:hover { background: var(--color-primary-strong); box-shadow: 0 10px 30px rgba(55, 235, 137, 0.25); }
+.button.secondary { border-color: var(--color-line); background: rgba(255, 255, 255, 0.045); color: var(--color-ink); }
+.button.secondary:hover { border-color: var(--color-line-strong); background: rgba(255, 255, 255, 0.08); }
+.button.small { min-height: 34px; padding-inline: 11px; border-radius: 11px; font-size: 11px; }
+.button.wide { width: 100%; }
+.button:disabled { opacity: 0.42; cursor: not-allowed; transform: none; }
+.text-button { padding: 3px 0; border: 0; background: none; color: var(--color-primary); cursor: pointer; }
+.text-button:hover { color: var(--color-primary-strong); }
+.full-text-button { width: 100%; padding: 13px; border-top: 1px solid var(--color-line); }
+.field { min-width: 0; display: flex; flex-direction: column; gap: 6px; color: var(--color-ink-soft); }
+.field > span { color: var(--color-ink-muted); font-size: 11px; }
+.field input, .field select, .field textarea { width: 100%; min-height: 40px; padding: 9px 11px; border: 1px solid var(--color-line); border-radius: 11px; outline: 0; background: rgba(2, 5, 3, 0.48); color: var(--color-ink); transition: border-color var(--duration-fast), box-shadow var(--duration-fast), background var(--duration-fast); }
+.field textarea { resize: vertical; }
+.field input:focus, .field select:focus, .field textarea:focus { border-color: rgba(55, 235, 137, 0.5); background: rgba(2, 5, 3, 0.7); box-shadow: 0 0 0 3px rgba(55, 235, 137, 0.08); }
+.field select { color-scheme: dark; }
+.field.compact { min-width: 150px; }
+.password-field { display: grid; grid-template-columns: 1fr 38px; border: 1px solid var(--color-line); border-radius: 12px; background: rgba(2, 5, 3, 0.48); }
+.password-field input { border: 0; background: transparent; }
+.check-field { display: flex; align-items: center; gap: 8px; color: var(--color-ink-soft); }
+.check-field input { accent-color: var(--color-primary); }
+.swap-button { width: 38px; height: 38px; border-radius: 12px; align-self: end; }
+
+/* Glass surfaces */
+.panel, .period-ribbon, .query-band, .filter-bar, .filter-grid, .pair-report, .work-progress, .reconcile-summary { position: relative; border: 1px solid var(--color-line); border-radius: var(--radius-lg); background: linear-gradient(160deg, rgba(28, 28, 28, 0.82) 0%, rgba(16, 16, 16, 0.86) 50%, rgba(10, 10, 10, 0.88) 100%); box-shadow: var(--shadow-low); backdrop-filter: blur(22px) saturate(120%); transition: transform var(--duration-standard) var(--ease-out), box-shadow var(--duration-standard), border-color var(--duration-standard); }
+.panel::before, .period-ribbon::before, .reconcile-summary::before, .work-progress::before { content: ""; position: absolute; inset: 0; border-radius: inherit; background: linear-gradient(165deg, rgba(255, 255, 255, 0.1) 0%, rgba(255, 255, 255, 0.03) 40%, rgba(255, 255, 255, 0) 70%); pointer-events: none; }
+.panel:hover { box-shadow: 0 20px 48px rgba(0, 0, 0, 0.32), inset 0 1px rgba(255, 255, 255, 0.07); border-color: rgba(255, 255, 255, 0.14); }
+.panel { min-width: 0; overflow: hidden; }
+.panel > * { position: relative; }
+.panel-heading { min-height: 67px; display: flex; align-items: center; justify-content: space-between; gap: 15px; padding: 14px 17px; border-bottom: 1px solid var(--color-line); }
+.panel-heading h2 { font-size: 15px; }
+.panel-heading p { margin-top: 3px; color: var(--color-ink-muted); font-size: 11px; }
+.status { display: inline-flex; align-items: center; justify-content: center; gap: 5px; width: max-content; min-height: 23px; padding: 2px 8px; border: 1px solid transparent; border-radius: 8px; font-size: 10px; font-style: normal; white-space: nowrap; }
+.status.success { border-color: rgba(55, 235, 137, 0.18); background: var(--color-positive-wash); color: var(--color-positive); }
+.status.warning { border-color: rgba(255, 188, 82, 0.18); background: var(--color-warning-wash); color: var(--color-warning); }
+.status.danger { border-color: rgba(255, 98, 109, 0.18); background: var(--color-danger-wash); color: var(--color-danger); }
+.status.neutral { border-color: var(--color-line); background: rgba(255, 255, 255, 0.045); color: var(--color-ink-soft); }
+.task-level { width: 30px; height: 30px; display: grid; place-items: center; border-radius: 10px; font-size: 10px; font-style: normal; font-weight: 800; }
+.task-level.danger { background: var(--color-danger-wash); color: var(--color-danger); }
+.task-level.warning { background: var(--color-warning-wash); color: var(--color-warning); }
+.task-level.neutral { background: rgba(255, 255, 255, 0.055); color: var(--color-ink-soft); }
+
+/* Dashboard */
+.metric-grid { display: grid; grid-template-columns: repeat(4, minmax(0, 1fr)); gap: 18px; margin: 0 0 18px; }
+.metric-card { position: relative; min-height: 164px; display: grid; grid-template-columns: minmax(0, 1fr) 48px; align-content: space-between; gap: 14px; padding: 24px 22px; overflow: hidden; border: 1px solid var(--color-line); border-radius: var(--radius-lg); background: linear-gradient(160deg, rgba(28, 28, 28, 0.86) 0%, rgba(14, 14, 14, 0.88) 50%, rgba(8, 8, 8, 0.9) 100%); box-shadow: var(--shadow-low); backdrop-filter: blur(24px) saturate(125%); transform: perspective(900px) rotateX(0.6deg) rotateY(-0.8deg); transform-origin: center bottom; transition: transform var(--duration-standard) var(--ease-out), border-color var(--duration-standard), box-shadow var(--duration-standard); }
+.metric-card::before { content: ""; position: absolute; inset: 0; border-radius: inherit; background: linear-gradient(165deg, rgba(255, 255, 255, 0.12) 0%, rgba(255, 255, 255, 0.04) 42%, rgba(255, 255, 255, 0) 72%); pointer-events: none; }
+.metric-card::after { content: ""; position: absolute; inset: auto 15% -1px 15%; height: 1px; background: currentColor; opacity: 0.35; box-shadow: 0 -8px 24px currentColor; transition: opacity var(--duration-standard), box-shadow var(--duration-standard); }
+.metric-card:hover::after { opacity: 0.7; box-shadow: 0 -10px 34px currentColor; }
+.metric-card:hover { transform: perspective(900px) rotateX(3.5deg) rotateY(-4.5deg) translateY(-10px); border-color: rgba(255, 255, 255, 0.32); box-shadow: 0 36px 80px rgba(0, 0, 0, 0.5), 0 0 0 1px rgba(255, 255, 255, 0.06), inset 0 1px rgba(255, 255, 255, 0.14); }
+.metric-copy { align-self: start; }
+.metric-label { display: block; color: var(--color-ink-soft); font-size: 13px; }
+.metric-value { display: block; margin-top: 7px; font: 700 34px/1.05 var(--font-data); letter-spacing: 0; }
+.metric-value small { margin-left: 5px; color: var(--color-ink-muted); font: 11px var(--font-ui); }
+.metric-icon { position: relative; width: 48px; height: 48px; display: grid; place-items: center; border: 1px solid var(--color-line); border-radius: 50%; background: radial-gradient(circle at 50% 35%, rgba(255, 255, 255, 0.09), rgba(255, 255, 255, 0.02) 70%); color: var(--color-ink-soft); box-shadow: inset 0 1px rgba(255, 255, 255, 0.05); }
+.metric-icon::after { content: ""; position: absolute; inset: -3px; border-radius: 50%; border: 1px solid currentColor; opacity: 0.12; pointer-events: none; }
+.metric-foot { grid-column: 1 / -1; color: var(--color-ink-muted); font-size: 11px; }
+.metric-foot strong { color: var(--color-positive); }
+.metric-card.warning { color: var(--color-warning); }
+.metric-card.danger { color: var(--color-danger); }
+.metric-card.success { color: var(--color-positive); }
+.metric-card .metric-copy { color: var(--color-ink); }
+.metric-card .metric-icon { color: var(--color-ink-soft); }
+.metric-card .metric-foot { color: var(--color-ink-muted); }
+.metric-card[data-metric-link], .metric-card[data-metric-action] { cursor: pointer; }
+.metric-card.warning .metric-icon, .metric-card.warning .metric-foot strong { color: var(--color-warning); }
+.metric-card.warning .metric-icon::after { opacity: 0.28; }
+.metric-card.danger .metric-icon, .metric-card.danger .metric-foot strong { color: var(--color-danger); }
+.metric-card.danger .metric-icon::after { opacity: 0.32; }
+.metric-card.success .metric-icon { color: var(--color-positive); }
+.metric-card.success .metric-icon::after { opacity: 0.22; border-color: var(--color-positive); }
+.period-ribbon { display: grid; grid-template-columns: 1fr 1fr 1fr minmax(310px, 1.4fr); margin-bottom: 18px; overflow: hidden; }
+.period-ribbon > div { min-height: 72px; display: flex; flex-direction: column; justify-content: center; padding: 13px 17px; border-left: 1px solid var(--color-line); }
+.period-ribbon > div:first-child { border-left: 0; }
+.period-ribbon span, .period-ribbon small { color: var(--color-ink-muted); }
+.period-ribbon strong { margin-top: 3px; }
+.period-ribbon > .period-warning { display: grid; grid-template-columns: 24px minmax(0, 1fr) auto; align-items: center; gap: 10px; }
+.period-warning > svg { color: var(--color-warning); }
+.period-warning > span { display: flex; flex-direction: column; }
+.period-warning > span strong { color: var(--color-ink); }
+.admin-dashboard-grid { display: grid; grid-template-columns: minmax(0, 1.42fr) minmax(310px, 0.58fr); gap: 18px; margin-bottom: 18px; }
+.task-list button { width: 100%; min-height: 73px; display: grid; grid-template-columns: 32px minmax(0, 1fr) auto 18px; align-items: center; gap: 11px; padding: 12px 16px; border: 0; border-top: 1px solid var(--color-line); background: transparent; text-align: left; cursor: pointer; transition: background var(--duration-fast); }
+.task-list button:first-child { border-top: 0; }
+.task-list button:hover { background: rgba(255, 255, 255, 0.035); }
+.task-list button > span:nth-child(2) { display: flex; flex-direction: column; }
+.task-list small, .task-list button > b { color: var(--color-ink-muted); font-size: 11px; }
+.task-list button > svg { color: var(--color-ink-muted); }
+.quick-pair-form { display: grid; grid-template-columns: 1fr 38px 1fr; gap: 10px; padding: 16px; }
+.quick-pair-form .button { grid-column: 1 / -1; }
+.quick-result { margin: 0 16px 16px; padding: 14px; border: 1px solid rgba(55, 235, 137, 0.16); border-radius: var(--radius-md); background: var(--color-primary-wash); }
+.quick-result span, .quick-result p { color: var(--color-ink-muted); }
+.quick-result strong { display: block; margin: 4px 0; color: var(--color-primary-strong); font: 700 22px var(--font-data); }
+.quick-result small { margin-left: 4px; font: 10px var(--font-ui); }
+
+/* Key-company / account-coverage flat list (replaces the floating 3D card stack) */
+.company-list { display: grid; gap: 8px; padding: 10px 12px 14px; }
+.company-row { position: relative; display: grid; grid-template-columns: 34px minmax(0, 1fr) auto auto; align-items: center; gap: 12px; min-height: 62px; padding: 11px 13px; border: 1px solid var(--color-line); border-radius: var(--radius-md); background: linear-gradient(160deg, rgba(22, 22, 22, 0.7) 0%, rgba(12, 12, 12, 0.75) 100%); cursor: pointer; transition: background var(--duration-fast), border-color var(--duration-fast), transform var(--duration-standard) var(--ease-out), box-shadow var(--duration-standard); }
+.company-row:hover { background: linear-gradient(160deg, rgba(32, 32, 32, 0.8) 0%, rgba(18, 18, 18, 0.85) 100%); border-color: var(--color-line-strong); box-shadow: 0 12px 28px rgba(0, 0, 0, 0.25); }
+.company-row:focus-visible { outline: 2px solid var(--color-primary-strong); outline-offset: 2px; }
+.company-row-mark { width: 34px; height: 34px; display: grid; place-items: center; flex: 0 0 auto; border-radius: 10px; background: var(--color-primary-wash); color: var(--color-primary); font-weight: 800; font-size: 13px; }
+.company-row.is-warning .company-row-mark { background: var(--color-warning-wash); color: var(--color-warning); }
+.company-row.is-danger .company-row-mark { background: var(--color-danger-wash); color: var(--color-danger); }
+.company-row-body { display: flex; flex-direction: column; min-width: 0; }
+.company-row-body strong { font-size: 14px; }
+.company-row-body small { color: var(--color-ink-muted); font-size: 11px; }
+.company-row-figure { display: flex; flex-direction: column; align-items: flex-end; text-align: right; min-width: 92px; }
+.company-row-figure strong { font: 600 14px var(--font-data); color: var(--color-ink); }
+.company-row-figure small { color: var(--color-ink-muted); font-size: 11px; }
+.company-row .status { flex: 0 0 auto; }
+
+/* Timeline-strip: horizontal calculation window ribbon */
+.timeline-strip { display: grid; grid-template-columns: 96px minmax(0, 1fr); gap: 14px; align-items: stretch; padding: 16px 18px; border: 1px solid var(--color-line); border-radius: var(--radius-lg); background: linear-gradient(180deg, rgba(22, 22, 22, 0.86), rgba(10, 10, 10, 0.86)); box-shadow: var(--shadow-low); backdrop-filter: blur(22px) saturate(125%); }
+.timeline-strip::before { content: ""; position: absolute; }
+.timeline-legend { display: flex; flex-direction: column; justify-content: center; gap: 6px; }
+.timeline-legend strong { font-size: 13px; }
+.timeline-legend span { color: var(--color-ink-muted); font-size: 11px; }
+.timeline-body { position: relative; min-height: 88px; padding-top: 6px; }
+.timeline-axis { position: relative; height: 14px; display: grid; grid-template-columns: repeat(12, minmax(0, 1fr)); border-bottom: 1px solid var(--color-line); }
+.timeline-axis span { font: 600 10px var(--font-data); color: var(--color-ink-muted); align-self: end; padding-bottom: 4px; text-align: left; }
+.timeline-axis span + span { border-left: 1px solid var(--color-line); padding-left: 4px; }
+.timeline-rows { display: grid; gap: 8px; margin-top: 12px; }
+.timeline-row { position: relative; display: grid; grid-template-columns: 96px minmax(0, 1fr); align-items: center; gap: 10px; font-size: 11px; }
+.timeline-row > span { color: var(--color-ink-soft); }
+.timeline-track { position: relative; height: 14px; border-radius: 7px; background: rgba(255, 255, 255, 0.04); overflow: hidden; }
+.timeline-track i { position: absolute; top: 0; bottom: 0; border-radius: inherit; }
+.timeline-track i.coverage { background: linear-gradient(90deg, rgba(55, 235, 137, 0.35), rgba(55, 235, 137, 0.55)); box-shadow: inset 0 0 0 1px rgba(112, 255, 174, 0.32); }
+.timeline-track i.warning { background: linear-gradient(90deg, rgba(255, 188, 82, 0.32), rgba(255, 188, 82, 0.52)); box-shadow: inset 0 0 0 1px rgba(255, 188, 82, 0.32); }
+.timeline-track i.danger { background: linear-gradient(90deg, rgba(255, 98, 109, 0.32), rgba(255, 98, 109, 0.52)); box-shadow: inset 0 0 0 1px rgba(255, 98, 109, 0.32); }
+.timeline-today { position: absolute; top: -2px; bottom: -2px; width: 2px; background: var(--color-primary-strong); box-shadow: 0 0 12px rgba(112, 255, 174, 0.6); border-radius: 1px; }
+.timeline-today::after { content: ""; position: absolute; top: -6px; left: 50%; transform: translateX(-50%); width: 10px; height: 10px; border-radius: 50%; background: var(--color-primary-strong); box-shadow: 0 0 0 4px rgba(112, 255, 174, 0.18); }
+.timeline-strip-panel { position: relative; }
+
+/* Ledger and queries */
+.inline-search { width: min(240px, 38vw); height: 36px; display: flex; align-items: center; gap: 8px; padding: 0 11px; border: 1px solid var(--color-line); border-radius: 11px; background: rgba(0, 0, 0, 0.18); color: var(--color-ink-muted); }
+.inline-search input { width: 100%; border: 0; outline: 0; background: transparent; color: var(--color-ink); }
+.ledger-head, .company-ledger summary { display: grid; grid-template-columns: minmax(210px, 1.4fr) repeat(2, minmax(100px, 0.75fr)) minmax(150px, 0.9fr) 86px 24px; align-items: center; gap: 10px; }
+.ledger-head { min-height: 42px; padding: 0 16px; border-bottom: 1px solid var(--color-line); color: var(--color-ink-muted); font-size: 10px; }
+.company-ledger { border-top: 1px solid var(--color-line); }
+.company-ledger:first-child { border-top: 0; }
+.company-ledger summary { min-height: 72px; padding: 10px 16px; list-style: none; cursor: pointer; transition: background var(--duration-fast); }
+.company-ledger summary::-webkit-details-marker { display: none; }
+.company-ledger summary:hover { background: rgba(255, 255, 255, 0.035); }
+.company-ledger summary > svg { transition: transform var(--duration-standard) var(--ease-out); }
+.company-ledger[open] summary > svg { transform: rotate(180deg); }
+.company-name { display: grid; grid-template-columns: 38px minmax(0, 1fr); align-items: center; column-gap: 10px; }
+.company-name i { width: 36px; height: 36px; grid-row: 1 / 3; display: grid; place-items: center; border-radius: 12px; background: var(--color-primary-wash); color: var(--color-primary); font-style: normal; font-weight: 800; }
+.company-name small { color: var(--color-ink-muted); }
+.amount { font: 600 13px var(--font-data); }
+.amount.debit { color: var(--color-positive); }
+.amount.credit { color: var(--color-warning); }
+.ledger-breakdown { display: grid; grid-template-columns: 1fr 1fr; border-top: 1px solid var(--color-line); background: rgba(0, 0, 0, 0.13); }
+.ledger-breakdown section { padding: 14px 16px; }
+.ledger-breakdown section + section { border-left: 1px solid var(--color-line); }
+.ledger-breakdown header { display: flex; justify-content: space-between; margin-bottom: 8px; color: var(--color-ink-soft); }
+.subject-row { width: 100%; min-height: 48px; display: grid; grid-template-columns: minmax(0, 1fr) auto 18px; align-items: center; gap: 10px; padding: 8px 10px; border: 0; border-top: 1px solid var(--color-line); background: transparent; text-align: left; cursor: pointer; }
+.subject-row:hover { background: rgba(255, 255, 255, 0.035); }
+.subject-row span { display: flex; flex-direction: column; }
+.subject-row small { color: var(--color-ink-muted); }
+.query-band, .filter-grid { padding: 17px; margin-bottom: 18px; }
+.pair-query-form { display: grid; grid-template-columns: minmax(150px, 1fr) 38px minmax(150px, 1fr) minmax(150px, 0.8fr) auto; align-items: end; gap: 11px; }
+.pair-report { overflow: hidden; }
+.pair-report-heading { min-height: 84px; display: flex; align-items: center; justify-content: space-between; gap: 18px; padding: 16px 18px; border-bottom: 1px solid var(--color-line); }
+.pair-report-heading p { color: var(--color-ink-muted); }
+.pair-result { text-align: right; }
+.pair-result strong { display: block; color: var(--color-primary); font: 700 22px var(--font-data); }
+.pair-balance-line { display: grid; grid-template-columns: repeat(5, 1fr); border-bottom: 1px solid var(--color-line); }
+.pair-balance-line div { min-height: 76px; display: flex; flex-direction: column; justify-content: center; padding: 12px 16px; border-left: 1px solid var(--color-line); }
+.pair-balance-line div:first-child { border-left: 0; }
+.pair-balance-line span, .pair-balance-line small { color: var(--color-ink-muted); }
+.pair-balance-line strong { margin-top: 3px; font: 600 15px var(--font-data); }
+.pair-final strong { color: var(--color-primary); font-size: 19px; }
+.subject-strip { display: grid; grid-template-columns: repeat(5, 1fr); border-bottom: 1px solid var(--color-line); }
+.subject-strip button { min-height: 62px; display: flex; flex-direction: column; justify-content: center; padding: 9px 14px; border: 0; border-left: 1px solid var(--color-line); background: rgba(255, 255, 255, 0.018); text-align: left; cursor: pointer; }
+.subject-strip button:first-child { border-left: 0; }
+.subject-strip button.is-active { background: var(--color-primary-wash); color: var(--color-primary); box-shadow: inset 0 -2px var(--color-primary); }
+.subject-strip span { color: var(--color-ink-muted); font-size: 10px; }
+
+/* Filters and tables */
+.filter-bar { display: flex; align-items: center; justify-content: space-between; gap: 14px; padding: 12px; margin-bottom: 18px; }
+.segmented { display: flex; gap: 4px; padding: 4px; overflow-x: auto; border: 1px solid var(--color-line); border-radius: 13px; background: rgba(0, 0, 0, 0.18); }
+.segmented button { min-height: 32px; padding: 0 11px; border: 0; border-radius: 9px; background: transparent; color: var(--color-ink-muted); white-space: nowrap; cursor: pointer; }
+.segmented button.is-active { background: rgba(255, 255, 255, 0.09); color: var(--color-ink); }
+.flow-filters { display: grid; grid-template-columns: repeat(5, minmax(130px, 1fr)) minmax(200px, 1.4fr) auto; align-items: end; gap: 11px; }
+.flow-filters .grow { min-width: 0; }
+.table-summary { min-height: 51px; display: flex; align-items: center; justify-content: space-between; gap: 12px; padding: 0 16px; border-bottom: 1px solid var(--color-line); color: var(--color-ink-muted); font-size: 11px; }
+.table-scroll { max-width: 100%; overflow: auto; }
+.data-table { width: 100%; min-width: 860px; border-collapse: collapse; }
+.data-table th { height: 42px; padding: 8px 13px; border-bottom: 1px solid var(--color-line); background: rgba(255, 255, 255, 0.025); color: var(--color-ink-muted); font-size: 10px; font-weight: 500; text-align: left; white-space: nowrap; }
+.data-table td { height: 55px; padding: 9px 13px; border-bottom: 1px solid rgba(255, 255, 255, 0.055); color: var(--color-ink-soft); vertical-align: middle; }
+.data-table tbody tr { transition: background var(--duration-fast); }
+.data-table tbody tr:hover { background: rgba(55, 235, 137, 0.035); }
+.data-table tbody tr:last-child td { border-bottom: 0; }
+.data-table td strong, .data-table td small { display: block; }
+.data-table td strong { color: var(--color-ink); }
+.data-table td small { color: var(--color-ink-muted); }
+.data-table .number { color: var(--color-ink); text-align: right; font-family: var(--font-data); font-variant-numeric: tabular-nums; }
+
+/* Settings, reminders and company work */
+.settings-layout { display: grid; grid-template-columns: 340px minmax(0, 1fr); gap: 18px; }
+.form-body { display: grid; gap: 15px; padding: 17px; }
+.panel form footer, form.panel footer { display: flex; justify-content: flex-end; gap: 9px; padding: 13px 17px; border-top: 1px solid var(--color-line); }
+.closing-panel { grid-column: 1 / -1; }
+.closing-checks { display: grid; grid-template-columns: repeat(4, 1fr); }
+.closing-checks article { min-height: 75px; display: flex; align-items: center; gap: 10px; padding: 13px 16px; border-left: 1px solid var(--color-line); }
+.closing-checks article:first-child { border-left: 0; }
+.closing-checks svg { color: var(--color-positive); }
+.closing-checks .is-blocked svg { color: var(--color-danger); }
+.closing-checks span { display: flex; flex-direction: column; }
+.closing-checks small { color: var(--color-ink-muted); }
+.closing-footer { min-height: 62px; display: flex; align-items: center; justify-content: flex-end; gap: 10px; padding: 10px 16px; border-top: 1px solid var(--color-line); }
+.closing-footer > span { margin-right: auto; color: var(--color-ink-muted); }
+.reminder-layout { display: grid; grid-template-columns: 360px minmax(0, 1fr); gap: 18px; }
+.notification-list article { min-height: 76px; display: grid; grid-template-columns: 38px minmax(0, 1fr) auto; align-items: center; gap: 12px; padding: 12px 16px; border-top: 1px solid var(--color-line); }
+.notification-list article:first-child { border-top: 0; }
+.notification-list article.is-unread { background: rgba(102, 168, 255, 0.045); }
+.notification-list article > span:nth-child(2) { display: flex; flex-direction: column; }
+.notification-list small, .notification-list p { color: var(--color-ink-muted); }
+.notification-list p { margin-top: 4px; }
+.notification-icon { width: 35px; height: 35px; display: grid; place-items: center; border-radius: 12px; background: rgba(255, 255, 255, 0.055); color: var(--color-ink-soft); }
+.notification-icon.danger { background: var(--color-danger-wash); color: var(--color-danger); }
+.notification-icon.warning { background: var(--color-warning-wash); color: var(--color-warning); }
+.notification-icon.success { background: var(--color-positive-wash); color: var(--color-positive); }
+.company-alert { min-height: 78px; display: grid; grid-template-columns: 32px minmax(0, 1fr) auto; align-items: center; gap: 14px; margin-bottom: 18px; padding: 14px 16px; border: 1px solid rgba(255, 98, 109, 0.22); border-radius: var(--radius-lg); background: var(--color-danger-wash); box-shadow: var(--shadow-low); }
+.company-alert > svg { color: var(--color-danger); }
+.company-alert p { color: #c18e92; }
+.company-dashboard-grid { display: grid; grid-template-columns: minmax(0, 1.35fr) minmax(300px, 0.65fr); gap: 18px; }
+.cashier-tasks article { min-height: 92px; display: grid; grid-template-columns: 32px minmax(0, 1fr) auto; align-items: center; gap: 12px; padding: 13px 16px; border-top: 1px solid var(--color-line); }
+.cashier-tasks article:first-child { border-top: 0; }
+.cashier-tasks p, .cashier-tasks small { color: var(--color-ink-muted); }
+.coverage-list article { min-height: 62px; display: flex; align-items: center; justify-content: space-between; gap: 12px; padding: 10px 16px; border-top: 1px solid var(--color-line); }
+.coverage-list article:first-child { border-top: 0; }
+.coverage-list article > span { display: flex; flex-direction: column; }
+.coverage-list small { color: var(--color-ink-muted); }
+.work-progress { display: grid; grid-template-columns: minmax(130px, 1fr) 40px minmax(130px, 1fr) 40px minmax(130px, 1fr) 40px minmax(130px, 1fr); align-items: center; margin-top: 18px; padding: 18px; }
+.work-progress div { display: flex; align-items: center; gap: 10px; }
+.work-progress div > span { width: 31px; height: 31px; display: grid; place-items: center; border-radius: 11px; background: var(--color-positive); color: var(--color-primary-dark); font-weight: 800; }
+.work-progress p { display: flex; flex-direction: column; }
+.work-progress small { color: var(--color-ink-muted); }
+.work-progress i { height: 1px; background: var(--color-line-strong); }
+.work-progress .pending > span { background: rgba(255, 255, 255, 0.065); color: var(--color-ink-muted); }
+.reconcile-summary { display: grid; grid-template-columns: repeat(3, 1fr); margin-bottom: 18px; overflow: hidden; }
+.reconcile-summary div { min-height: 86px; display: flex; flex-direction: column; justify-content: center; padding: 14px 18px; border-left: 1px solid var(--color-line); }
+.reconcile-summary div:first-child { border-left: 0; }
+.reconcile-summary span, .reconcile-summary small { color: var(--color-ink-muted); }
+.reconcile-summary strong { font: 600 19px var(--font-data); }
+.review-list > article { padding: 16px; border-top: 1px solid var(--color-line); }
+.review-list > article:first-child { border-top: 0; }
+.review-main { display: grid; grid-template-columns: 38px 1fr; gap: 10px; }
+.review-main p { color: var(--color-ink-muted); }
+.candidate { display: flex; align-items: end; justify-content: space-between; gap: 16px; margin: 13px 0 0 48px; padding: 12px; border: 1px solid var(--color-line); border-radius: var(--radius-md); background: rgba(0, 0, 0, 0.15); }
+.candidate-options { display: grid; gap: 8px; margin: 13px 0 0 48px; padding: 12px; border: 1px solid var(--color-line); border-radius: var(--radius-md); }
+.candidate-options legend { padding: 0 5px; color: var(--color-ink-muted); }
+.candidate-options label { display: flex; align-items: center; gap: 9px; padding: 9px; border-radius: 11px; background: rgba(255, 255, 255, 0.035); }
+.candidate-options input { accent-color: var(--color-primary); }
+.candidate-options label span { display: flex; flex-direction: column; }
+.candidate-options small { color: var(--color-ink-muted); }
+.review-actions { display: flex; justify-content: flex-end; gap: 9px; margin-top: 10px; }
+.review-history { padding: 14px 16px; border-top: 1px solid var(--color-line); background: var(--color-positive-wash); }
+.evidence-block { padding: 12px; border: 1px solid var(--color-line); border-radius: var(--radius-md); background: rgba(0, 0, 0, 0.16); }
+.evidence-block strong, .evidence-block small { display: block; }
+.evidence-block small { color: var(--color-ink-muted); }
+.account-directory { display: grid; grid-template-columns: repeat(3, minmax(240px, 1fr)); gap: 16px; }
+.account-directory article { overflow: hidden; border: 1px solid var(--color-line); border-radius: var(--radius-lg); background: var(--color-surface); box-shadow: var(--shadow-low); }
+.account-directory header { display: grid; grid-template-columns: 38px minmax(0, 1fr) auto; align-items: center; gap: 10px; padding: 15px; border-bottom: 1px solid var(--color-line); }
+.account-directory header div { display: flex; flex-direction: column; }
+.account-directory header small { color: var(--color-ink-muted); }
+.bank-mark { width: 36px; height: 36px; display: grid; place-items: center; border-radius: 12px; background: var(--color-primary-wash); color: var(--color-primary); font-weight: 800; }
+.account-directory dl { display: grid; grid-template-columns: repeat(3, 1fr); }
+.account-directory dl div { padding: 12px; border-left: 1px solid var(--color-line); }
+.account-directory dl div:first-child { border-left: 0; }
+.account-directory dt { color: var(--color-ink-muted); font-size: 10px; }
+.account-directory dd { margin-top: 3px; font-size: 11px; }
+.manual-layout { display: grid; grid-template-columns: minmax(340px, 390px) minmax(0, 1fr); align-items: start; gap: 18px; }
+.manual-records-table { min-width: 900px; }
+
+/* Dialogs and feedback */
+.dialog { width: min(580px, calc(100% - 28px)); padding: 0; overflow: hidden; border: 1px solid var(--color-line-strong); border-radius: var(--radius-lg); background: rgba(17, 17, 17, 0.96); color: var(--color-ink); box-shadow: var(--shadow-panel); backdrop-filter: blur(28px); }
+.dialog::backdrop { background: rgba(0, 0, 0, 0.74); backdrop-filter: blur(6px); }
+.dialog > form > header { min-height: 72px; display: flex; align-items: center; justify-content: space-between; gap: 16px; padding: 14px 18px; border-bottom: 1px solid var(--color-line); }
+.dialog header p { color: var(--color-ink-muted); }
+.dialog-body { display: grid; gap: 15px; padding: 18px; }
+.dialog > form > footer { display: flex; justify-content: flex-end; gap: 9px; padding: 13px 18px; border-top: 1px solid var(--color-line); }
+.form-grid { display: grid; grid-template-columns: 1fr 1fr; gap: 12px; }
+.form-callout { display: flex; align-items: center; gap: 9px; padding: 10px; border: 1px solid rgba(102, 168, 255, 0.22); border-radius: 12px; background: var(--color-info-wash); color: #9ac6ff; }
+.dropzone { min-height: 168px; display: flex; flex-direction: column; align-items: center; justify-content: center; gap: 6px; border: 1px dashed rgba(255, 255, 255, 0.24); border-radius: var(--radius-md); background: rgba(0, 0, 0, 0.15); color: var(--color-ink-soft); text-align: center; transition: border-color var(--duration-fast), background var(--duration-fast); }
+.dropzone:hover, .dropzone.is-dragging { border-color: var(--color-primary); background: var(--color-primary-wash); }
+.dropzone input { position: absolute; width: 1px; height: 1px; opacity: 0; }
+.dropzone > svg { width: 30px; height: 30px; color: var(--color-primary); }
+.file-preview { display: grid; grid-template-columns: 40px minmax(0, 1fr) 40px; align-items: center; gap: 10px; padding: 10px; border: 1px solid var(--color-line); border-radius: var(--radius-md); }
+.file-preview > span:nth-child(2) { display: flex; flex-direction: column; min-width: 0; }
+.file-preview strong { overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
+.file-preview small { color: var(--color-ink-muted); }
+.file-type { width: 38px; height: 38px; display: grid; place-items: center; border-radius: 12px; background: var(--color-primary-wash); color: var(--color-primary); }
+.parse-result { display: grid; grid-template-columns: 38px 1fr; align-items: center; gap: 10px; padding: 11px; border: 1px solid rgba(55, 235, 137, 0.22); border-radius: var(--radius-md); background: var(--color-positive-wash); }
+.parse-result p { color: #9bd7b6; }
+.parse-result.is-exception { border-color: rgba(255, 188, 82, 0.25); background: var(--color-warning-wash); }
+.parse-result.is-exception p { color: #e7bd78; }
+.sheet-review { margin-top: 12px; padding-top: 12px; border-top: 1px solid var(--color-line); }
+.sheet-review h3 { font-size: 14px; }
+.sheet-review-hint { margin-top: 4px; color: var(--color-ink-muted); font-size: 12px; line-height: 1.5; }
+.sheet-list { display: grid; gap: 8px; margin-top: 10px; max-height: 220px; overflow-y: auto; }
+.sheet-item { display: grid; grid-template-columns: minmax(0, 1fr) auto; gap: 8px; padding: 10px; border: 1px solid var(--color-line); border-radius: var(--radius-md); background: var(--color-surface-muted); }
+.sheet-item.is-pending { border-color: rgba(255, 188, 82, 0.45); }
+.sheet-item-head { display: flex; align-items: center; gap: 8px; flex-wrap: wrap; }
+.sheet-item-head strong { font-size: 13px; }
+.sheet-item-head small { color: var(--color-ink-muted); }
+.sheet-item-meta { margin-top: 5px; color: var(--color-ink-muted); font-size: 12px; line-height: 1.5; }
+.sheet-item-actions { display: flex; align-items: center; gap: 6px; }
+.sheet-item-actions .text-button { font-size: 12px; padding: 4px 8px; }
+.sheet-item-reason { margin-top: 6px; padding: 6px 8px; border: 1px solid var(--color-line); border-radius: var(--radius-sm); color: var(--color-ink-muted); font-size: 12px; }
+.toast-region { position: fixed; right: 20px; bottom: 20px; z-index: 200; display: grid; gap: 8px; }
+.toast { min-width: 280px; max-width: 390px; padding: 13px 15px; border: 1px solid var(--color-line-strong); border-radius: var(--radius-md); background: rgba(20, 20, 20, 0.96); color: var(--color-ink); box-shadow: var(--shadow-panel); backdrop-filter: blur(20px); }
+.toast strong, .toast small { display: block; }
+.toast small { color: var(--color-ink-muted); }
+
+/* Login — 深海军蓝 × 账房金 (HEL-32) */
+.entry-page {
+  color-scheme: light;
+  background: var(--jn-bg-page);
+  color: var(--jn-text-1);
+  overflow-x: hidden;
+}
+.entry-page::before { display: none; }
+.entry-page :focus-visible { outline: 2px solid var(--jn-blue-600); outline-offset: 3px; }
+
+.entry-shell {
+  width: 100%;
+  margin: 0;
+  padding: 0;
+  min-height: 100vh;
+  min-height: 100dvh;
+  display: grid;
+  grid-template-columns: minmax(420px, 42%) minmax(0, 1fr);
+  grid-template-rows: 56px minmax(0, 1fr);
+  grid-template-areas: "topbar topbar" "context form";
+}
+
+.entry-topbar {
+  grid-area: topbar;
+  display: flex;
+  align-items: center;
+  padding: 0 24px;
+  background: var(--jn-bg-panel);
+  border-bottom: 1px solid var(--jn-border);
+}
+.entry-brand { display: flex; align-items: center; gap: 12px; min-width: 0; }
+.entry-seal {
+  width: 28px; height: 28px; flex: 0 0 auto;
+  display: grid; place-items: center;
+  border: 1.5px solid var(--jn-gold-500);
+  border-radius: 6px;
+  background: var(--jn-bg-panel);
+  color: var(--jn-gold-500);
+  font-size: 17px; line-height: 1; font-weight: 700;
+}
+.entry-system-name {
+  font-size: 17px; line-height: 26px; font-weight: 600;
+  color: var(--jn-text-1);
+  white-space: nowrap; overflow: hidden; text-overflow: ellipsis;
+}
+
+.entry-context {
+  grid-area: context;
+  position: relative;
+  display: flex; flex-direction: column; justify-content: center;
+  padding: 64px;
+  background: linear-gradient(160deg, var(--jn-navy-800), var(--jn-navy-900));
+  overflow: hidden;
+}
+.entry-statement { max-width: 520px; }
+.entry-statement h1 { font-size: 32px; line-height: 40px; font-weight: 700; color: #ffffff; letter-spacing: 0; }
+.entry-statement p { margin-top: 12px; max-width: 440px; font-size: 14px; line-height: 22px; color: #B9CBDD; }
+.entry-figure { width: 100%; height: auto; max-width: 520px; margin-top: 48px; display: block; }
+.entry-figure .fig-bar { fill: none; stroke: var(--jn-navy-700); stroke-width: 1.5; }
+.entry-figure .fig-arc { fill: none; stroke: var(--jn-navy-700); stroke-width: 80; opacity: 0.2; }
+.entry-figure .fig-line { fill: none; stroke: var(--jn-gold-500); stroke-width: 1.5; }
+
+.entry-form-wrap {
+  grid-area: form;
+  display: grid; place-items: center;
+  padding: 48px 40px;
+  background: var(--jn-bg-panel);
+}
+.entry-form { width: min(400px, 100%); display: grid; gap: 20px; }
+.entry-form header h2 { font-size: 24px; line-height: 32px; font-weight: 600; color: var(--jn-text-1); }
+.entry-form header p { margin-top: 6px; font-size: 14px; line-height: 22px; color: var(--jn-text-2); }
+
+#loginError {
+  padding: 10px 14px;
+  border-left: 3px solid var(--jn-error);
+  border-radius: 8px;
+  background: var(--jn-error-bg);
+  color: var(--jn-error);
+  font-size: 13px; line-height: 18px;
+}
+
+.role-switch { display: grid; grid-template-columns: 1fr 1fr; gap: 12px; }
+.role-switch label { cursor: pointer; }
+.role-switch input { position: absolute; opacity: 0; }
+.role-switch span {
+  min-height: 76px;
+  display: grid; grid-template-columns: 24px 1fr;
+  align-content: center; gap: 2px 10px;
+  padding: 12px 14px;
+  border: 1px solid var(--jn-border);
+  border-radius: 8px;
+  background: var(--jn-bg-panel);
+  transition: border-color 150ms ease-out, background 150ms ease-out;
+}
+.role-switch span:hover { border-color: var(--jn-border-strong); }
+.role-switch svg { grid-row: 1 / 3; align-self: center; color: var(--jn-text-3); }
+.role-switch b { font-size: 15px; line-height: 22px; font-weight: 600; color: var(--jn-text-2); }
+.role-switch small { font-size: 12px; line-height: 18px; color: var(--jn-text-3); }
+.role-switch input:focus-visible + span { border-color: var(--jn-blue-600); box-shadow: 0 0 0 3px rgba(29, 78, 216, 0.15); }
+.role-switch input:checked + span { border: 1.5px solid var(--jn-blue-600); background: var(--jn-blue-50); }
+.role-switch input:checked + span svg { color: var(--jn-blue-600); }
+.role-switch input:checked + span b { color: var(--jn-blue-600); }
+
+.entry-form .field { display: flex; flex-direction: column; gap: 8px; }
+.entry-form .field > span { font-size: 14px; line-height: 20px; font-weight: 500; color: var(--jn-text-1); }
+.entry-form .field input {
+  width: 100%; height: 44px;
+  padding: 0 14px;
+  border: 1px solid var(--jn-border);
+  border-radius: 8px;
+  outline: 0;
+  background: var(--jn-bg-panel);
+  color: var(--jn-text-1);
+  font-size: 15px; line-height: 22px;
+  transition: border-color 150ms ease-out, box-shadow 150ms ease-out;
+}
+.entry-form .field input::placeholder { color: var(--jn-text-3); }
+.entry-form .field input:hover { border-color: var(--jn-border-strong); }
+.entry-form .field input:focus { border-color: var(--jn-blue-600); box-shadow: 0 0 0 3px rgba(29, 78, 216, 0.15); }
+.entry-form .password-field {
+  display: grid; grid-template-columns: 1fr 44px;
+  border: 1px solid var(--jn-border);
+  border-radius: 8px;
+  background: var(--jn-bg-panel);
+  transition: border-color 150ms ease-out, box-shadow 150ms ease-out;
+}
+.entry-form .password-field:hover { border-color: var(--jn-border-strong); }
+.entry-form .password-field:focus-within { border-color: var(--jn-blue-600); box-shadow: 0 0 0 3px rgba(29, 78, 216, 0.15); }
+.entry-form .password-field input { border: 0; box-shadow: none; background: transparent; }
+.entry-form .password-field input:focus { border: 0; box-shadow: none; }
+.entry-form .inside-icon { width: 44px; height: 44px; color: var(--jn-text-3); border: 0; background: transparent; }
+.entry-form .inside-icon:hover { color: var(--jn-text-2); background: transparent; transform: none; }
+.entry-form .inside-icon svg { width: 20px; height: 20px; }
+
+.entry-options { display: flex; align-items: center; justify-content: space-between; }
+.entry-form .check-field { display: flex; align-items: center; gap: 8px; font-size: 13px; line-height: 18px; color: var(--jn-text-2); cursor: pointer; }
+.entry-form .check-field input { width: 16px; height: 16px; accent-color: var(--jn-blue-600); }
+.entry-hint { font-size: 13px; line-height: 18px; color: var(--jn-blue-600); }
+.entry-hint:hover { color: var(--jn-blue-700); }
+
+.entry-form .entry-note { font-size: 12px; line-height: 18px; color: var(--jn-text-2); }
+
+.entry-form .button.primary {
+  width: 100%; height: 44px;
+  border-radius: 8px;
+  background: var(--jn-blue-600);
+  color: #ffffff;
+  box-shadow: none;
+  font-size: 15px; line-height: 22px; font-weight: 600;
+}
+.entry-form .button.primary:hover { background: var(--jn-blue-700); box-shadow: none; transform: none; }
+.entry-form .button.primary:active { background: var(--jn-blue-800); transform: none; }
+.entry-form .button.primary:disabled { background: var(--jn-disabled-bg); color: var(--jn-text-3); opacity: 1; cursor: not-allowed; transform: none; }
+.entry-form .button.primary.is-loading:disabled { background: var(--jn-blue-600); color: #ffffff; opacity: 0.7; }
+.spinner {
+  width: 16px; height: 16px; flex: 0 0 auto;
+  display: none;
+  border: 2px solid rgba(255, 255, 255, 0.35);
+  border-top-color: #ffffff;
+  border-radius: 50%;
+  animation: jn-spin 1s linear infinite;
+}
+.button.is-loading .spinner { display: inline-block; }
+.button.is-loading .submit-arrow { display: none; }
+@keyframes jn-spin { to { transform: rotate(360deg); } }
+
+.entry-compliance { font-size: 12px; line-height: 18px; color: var(--jn-text-3); text-align: center; }
+
+@media (max-width: 1023px) {
+  .entry-shell { grid-template-columns: 1fr; grid-template-rows: 56px 180px minmax(0, 1fr); grid-template-areas: "topbar" "context" "form"; }
+  .entry-context { padding: 32px 40px; justify-content: center; }
+  .entry-statement h1 { font-size: 24px; line-height: 32px; }
+  .entry-figure { display: none; }
+  .entry-form-wrap { padding: 48px 40px; }
+  .entry-form { width: min(440px, 100%); }
+}
+
+@media (max-width: 767px) {
+  .entry-shell { grid-template-rows: 56px 96px minmax(0, 1fr); }
+  .entry-topbar { padding: 0 16px; }
+  .entry-seal { width: 24px; height: 24px; font-size: 14px; border-radius: 6px; }
+  .entry-system-name { font-size: 15px; line-height: 22px; }
+  .entry-context { padding: 24px; }
+  .entry-statement h1 { font-size: 18px; line-height: 26px; }
+  .entry-statement p { display: none; }
+  .entry-form-wrap { padding: 24px 16px; }
+  .entry-form { gap: 16px; }
+  .entry-form .field input { height: 48px; }
+  .entry-form .password-field { grid-template-columns: 1fr 48px; }
+  .entry-form .inside-icon { width: 48px; height: 48px; }
+  .entry-form .button.primary { height: 48px; }
+  .role-switch { grid-template-columns: 1fr; }
+}
+
+@media (max-width: 1180px) {
+  .app-shell { grid-template-columns: 88px minmax(0, 1fr); }
+  .sidebar { width: 70px; padding-inline: 9px; }
+  .workspace { grid-column: 2; }
+  .brand { justify-content: center; padding-inline: 0; }
+  .brand-copy, .nav-item span, .nav-item b, .user-block > span:last-child, .company-context div { display: none; }
+  .nav-item { justify-content: center; padding: 0; }
+  .user-block, .company-context { justify-content: center; padding-inline: 0; }
+  .metric-grid { grid-template-columns: repeat(2, 1fr); }
+  .period-ribbon { grid-template-columns: repeat(3, 1fr); }
+  .period-ribbon > .period-warning { grid-column: 1 / -1; border-top: 1px solid var(--color-line); border-left: 0; }
+  .admin-dashboard-grid, .company-dashboard-grid { grid-template-columns: 1fr; }
+  .flow-filters { grid-template-columns: repeat(3, 1fr); }
+  .flow-filters .button { min-height: 40px; }
+  .manual-layout { grid-template-columns: 1fr; }
+  .account-directory { grid-template-columns: repeat(2, 1fr); }
+}
+
+@media (max-width: 900px) {
+  main { padding-inline: 20px; }
+  .search-box { display: none; }
+  .settings-layout, .reminder-layout { grid-template-columns: 1fr; }
+  .pair-query-form { grid-template-columns: 1fr 40px 1fr; }
+  .pair-query-form .field:nth-of-type(3) { grid-column: 1 / 3; }
+  .pair-query-form .button { grid-column: 3; }
+  .ledger-head { display: none; }
+  .company-ledger summary { grid-template-columns: minmax(180px, 1.4fr) repeat(2, minmax(100px, 0.7fr)) 28px; }
+  .company-ledger summary > span:nth-child(4), .company-ledger summary > span:nth-child(5) { display: none; }
+  .ledger-breakdown { grid-template-columns: 1fr; }
+  .ledger-breakdown section + section { border-top: 1px solid var(--color-line); border-left: 0; }
+  .pair-balance-line { grid-template-columns: repeat(3, 1fr); }
+  .pair-balance-line .pair-final { grid-column: 1 / -1; border-top: 1px solid var(--color-line); border-left: 0; }
+  .subject-strip { grid-template-columns: repeat(3, 1fr); }
+  .work-progress { grid-template-columns: 1fr 24px 1fr; row-gap: 16px; }
+  .work-progress i:nth-of-type(2) { display: none; }
+}
+
+@media (max-width: 720px) {
+  .app-shell { display: block; }
+  .sidebar { inset: 10px auto 10px 10px; width: 242px; transform: translateX(calc(-100% - 20px)); transition: transform var(--duration-standard) var(--ease-out); }
+  .sidebar.is-open { transform: none; }
+  .sidebar.is-open .brand-copy, .sidebar.is-open .nav-item span, .sidebar.is-open .nav-item b, .sidebar.is-open .user-block > span:last-child, .sidebar.is-open .company-context div { display: flex; }
+  .sidebar.is-open .nav-item { justify-content: flex-start; padding: 0 12px; }
+  .sidebar.is-open .company-context { justify-content: flex-start; padding-inline: 10px; }
+  .workspace { display: block; }
+  .topbar { height: 64px; padding: 0 13px; gap: 9px; }
+  .menu-button { display: inline-grid; }
+  .workspace-name { min-width: 0; }
+  .workspace-name span { display: none; }
+  .demo-badge { padding: 2px 6px; }
+  .period-button { display: none; }
+  .topbar-actions .button { width: 40px; padding: 0; font-size: 0; }
+  main { padding: 12px 13px 42px; }
+  .page-heading { min-height: auto; flex-direction: column; margin-bottom: 18px; }
+  .page-heading h1 { font-size: 27px; }
+  .page-heading > .button { align-self: stretch; }
+  .metric-grid { grid-template-columns: 1fr 1fr; gap: 10px; }
+  .metric-card { min-height: 128px; grid-template-columns: minmax(0, 1fr) 38px; padding: 15px; }
+  .metric-icon { width: 38px; height: 38px; border-radius: 12px; }
+  .metric-value { font-size: 25px; }
+  .period-ribbon { grid-template-columns: 1fr 1fr; }
+  .period-ribbon > div { min-height: 64px; }
+  .period-ribbon > div:nth-child(3) { border-top: 1px solid var(--color-line); border-left: 0; }
+  .period-warning { grid-column: 1 / -1; }
+  .panel-heading { min-height: 60px; padding: 11px 13px; }
+  .inline-search { display: none; }
+  .task-list button { grid-template-columns: 30px minmax(0, 1fr) 18px; padding-inline: 12px; }
+  .task-list button > b { display: none; }
+  .quick-pair-form { grid-template-columns: 1fr 38px 1fr; padding-inline: 12px; }
+  .quick-result { margin-inline: 12px; }
+  .company-ledger summary { grid-template-columns: minmax(145px, 1fr) 100px 24px; padding-inline: 12px; }
+  .company-ledger summary > strong:nth-of-type(2), .company-ledger summary > span:nth-child(4), .company-ledger summary > span:nth-child(5) { display: none; }
+  .company-name { grid-template-columns: 30px minmax(0, 1fr); }
+  .company-name i { width: 28px; height: 28px; }
+  .filter-bar { align-items: stretch; flex-direction: column; }
+  .segmented { width: 100%; }
+  .flow-filters { grid-template-columns: 1fr 1fr; }
+  .flow-filters .grow, .flow-filters .button { grid-column: 1 / -1; }
+  .pair-query-form { grid-template-columns: 1fr 38px 1fr; }
+  .pair-query-form .field:nth-of-type(3), .pair-query-form .button { grid-column: 1 / -1; }
+  .pair-report-heading { align-items: flex-start; flex-direction: column; }
+  .pair-balance-line { grid-template-columns: 1fr 1fr; }
+  .pair-balance-line .pair-final { grid-column: auto; border-left: 1px solid var(--color-line); }
+  .subject-strip { grid-template-columns: 1fr 1fr; }
+  .company-alert { grid-template-columns: 28px 1fr; }
+  .company-alert .button { grid-column: 1 / -1; }
+  .cashier-tasks article { grid-template-columns: 30px minmax(0, 1fr); }
+  .cashier-tasks .button { grid-column: 2; justify-self: start; }
+  .work-progress { grid-template-columns: 1fr; }
+  .work-progress i { display: none; }
+  .reconcile-summary { grid-template-columns: 1fr; }
+  .reconcile-summary div { min-height: 70px; border-top: 1px solid var(--color-line); border-left: 0; }
+  .reconcile-summary div:first-child { border-top: 0; }
+  .candidate, .candidate-options { align-items: stretch; flex-direction: column; margin-left: 0; }
+  .account-directory { grid-template-columns: 1fr; }
+  .account-directory dl { grid-template-columns: 1fr 1fr; }
+  .closing-checks { grid-template-columns: 1fr; }
+  .closing-checks article { border-top: 1px solid var(--color-line); border-left: 0; }
+  .closing-footer { align-items: stretch; flex-direction: column; }
+  .notification-list article { grid-template-columns: 34px minmax(0, 1fr); }
+  .notification-list article > em { grid-column: 2; justify-self: start; }
+  .table-summary { align-items: flex-start; flex-direction: column; justify-content: center; padding-block: 9px; }
+  .dialog { width: 100%; max-width: none; height: 100%; max-height: none; border-radius: 0; }
+  .dialog > form { min-height: 100%; display: flex; flex-direction: column; }
+  .dialog-body { flex: 1; }
+  .form-grid { grid-template-columns: 1fr; }
+  .toast-region { right: 12px; bottom: 12px; left: 12px; }
+  .toast { min-width: 0; max-width: none; }
+}
+
+@media (max-width: 460px) {
+  .metric-card { min-height: 150px; padding: 13px; }
+  .metric-copy { min-height: 52px; }
+  .metric-label { font-size: 11px; }
+  .metric-value { font-size: 23px; }
+}
+
+@media (max-width: 1180px) {
+  .timeline-strip { grid-template-columns: 1fr; }
+  .timeline-legend { padding-bottom: 4px; }
+}
+
+@media (max-width: 900px) {
+  .company-row { grid-template-columns: 34px minmax(0, 1fr) auto; }
+  .company-row-figure { display: none; }
+}
+
+@media (max-width: 720px) {
+  .timeline-strip { padding: 14px; }
+  .timeline-rows { gap: 6px; }
+  .timeline-row { grid-template-columns: 80px minmax(0, 1fr); }
+  .timeline-axis span { font-size: 9px; }
+}
+
+/* ===== 参考图对齐：胶囊搜索条 / 账期时间轴 / 右侧详情面板 ===== */
+.content-toolbar > .search-box { border-radius: 999px; background: rgba(255, 255, 255, 0.045); backdrop-filter: blur(18px) saturate(120%); }
+
+.timeline-panel { margin-top: 18px; padding: 18px; }
+.timeline { padding: 10px 4px 0; }
+.timeline-bar { position: relative; height: 14px; border: 1px solid var(--color-line); border-radius: 999px; background: rgba(255, 255, 255, 0.05); }
+.timeline-seg, .timeline-gap { position: absolute; top: 2px; bottom: 2px; border-radius: 999px; }
+.timeline-seg.is-closed { background: linear-gradient(90deg, rgba(55, 235, 137, 0.5), rgba(55, 235, 137, 0.28)); }
+.timeline-seg.is-current { background: linear-gradient(90deg, rgba(255, 188, 82, 0.4), rgba(255, 188, 82, 0.18)); }
+.timeline-gap { background: repeating-linear-gradient(45deg, rgba(255, 98, 109, 0.75) 0 6px, rgba(255, 98, 109, 0.35) 6px 12px); box-shadow: 0 0 12px rgba(255, 98, 109, 0.25); }
+.timeline-today { position: absolute; top: -4px; bottom: -4px; width: 2px; background: var(--color-primary-strong); box-shadow: 0 0 10px rgba(55, 235, 137, 0.6); }
+.timeline-today::after { content: "今天"; position: absolute; top: -19px; right: 5px; font-size: 10px; font-style: normal; color: var(--color-primary-strong); white-space: nowrap; }
+.timeline-ticks { position: relative; height: 34px; margin-top: 8px; }
+.timeline-ticks span { position: absolute; display: flex; flex-direction: column; transform: translateX(-50%); font-size: 10px; color: var(--color-ink-muted); text-align: center; }
+.timeline-ticks span:first-child { transform: none; text-align: left; }
+.timeline-ticks span:last-child { transform: translateX(-100%); text-align: right; }
+.timeline-ticks small { color: var(--color-ink-soft); }
+.timeline-panel .timeline-legend { display: flex; flex-direction: row; flex-wrap: wrap; gap: 6px 18px; margin: 10px 0 0; padding: 0; list-style: none; font-size: 11px; color: var(--color-ink-soft); }
+.timeline-panel .timeline-legend li { display: flex; align-items: center; gap: 6px; }
+.timeline-panel .dot { width: 8px; height: 8px; border-radius: 50%; }
+.dot.success { background: var(--color-positive); }
+.dot.warning { background: var(--color-warning); }
+.dot.danger { background: var(--color-danger); }
+.dot.today { background: var(--color-primary-strong); box-shadow: 0 0 6px rgba(55, 235, 137, 0.7); }
+
+.detail-drawer { position: fixed; top: 16px; right: 16px; bottom: 16px; z-index: 80; width: min(380px, calc(100vw - 32px)); display: flex; flex-direction: column; border: 1px solid var(--color-line-strong); border-radius: var(--radius-lg); background: linear-gradient(160deg, rgba(28, 28, 28, 0.92), rgba(12, 12, 12, 0.94)); box-shadow: var(--shadow-panel); backdrop-filter: blur(26px) saturate(125%); transform: translateX(calc(100% + 32px)); visibility: hidden; transition: transform var(--duration-standard) var(--ease-out), visibility var(--duration-standard); }
+.detail-drawer.is-open { transform: none; visibility: visible; }
+.detail-drawer > header { display: flex; align-items: flex-start; justify-content: space-between; gap: 12px; padding: 18px 18px 12px; border-bottom: 1px solid var(--color-line); }
+.detail-drawer h2 { margin-top: 8px; font-size: 17px; }
+.detail-drawer .detail-desc { margin-top: 4px; color: var(--color-ink-muted); font-size: 12px; }
+.detail-fields { display: grid; gap: 10px; margin: 0; padding: 14px 18px; overflow-y: auto; }
+.detail-fields > div { display: flex; justify-content: space-between; gap: 14px; padding-bottom: 10px; border-bottom: 1px dashed var(--color-line); }
+.detail-fields dt { flex-shrink: 0; color: var(--color-ink-muted); font-size: 12px; }
+.detail-fields dd { margin: 0; text-align: right; font-size: 12px; }
+.detail-tip { margin: 0 18px 12px; padding: 12px; border: 1px solid var(--color-line); border-radius: var(--radius-md); background: var(--color-surface-muted); color: var(--color-ink-soft); font-size: 12px; }
+.detail-tip strong { display: block; margin-bottom: 4px; color: var(--color-ink); }
+.detail-drawer > footer { display: flex; gap: 10px; margin-top: auto; padding: 14px 18px; border-top: 1px solid var(--color-line); }
+.detail-drawer > footer .button { flex: 1; justify-content: center; }
+.detail-drawer .status { align-self: flex-start; }
+[data-detail] { cursor: pointer; }
+
+@media (max-width: 720px) {
+  .detail-drawer { top: 8px; right: 8px; bottom: 8px; width: calc(100vw - 16px); }
+  .timeline-panel { padding: 14px; }
+}
+
+/* ===== 质感打磨：玻璃光泽 / 氛围光 / 对比与呼吸感 ===== */
+:root {
+  --radius-lg: 24px;
+  --radius-xl: 30px;
+}
+
+body::before { content: ""; position: fixed; inset: 0; z-index: 0; pointer-events: none; background: radial-gradient(52vw 42vh at 62% 32%, rgba(55, 235, 137, 0.055), transparent 62%), radial-gradient(40vw 34vh at 90% 4%, rgba(102, 168, 255, 0.032), transparent 60%), radial-gradient(46vw 40vh at 28% 96%, rgba(55, 235, 137, 0.028), transparent 60%); }
+.app-shell { position: relative; z-index: 0; }
+
+.metric-card { border-color: rgba(255, 255, 255, 0.12); background: radial-gradient(120% 90% at 50% 108%, rgba(255, 255, 255, 0.09), rgba(255, 255, 255, 0.02) 42%, transparent 60%), linear-gradient(160deg, rgba(41, 41, 41, 0.86) 0%, rgba(23, 23, 23, 0.88) 50%, rgba(12, 12, 12, 0.9) 100%); }
+.metric-card::before { background: radial-gradient(130% 100% at 50% 112%, rgba(255, 255, 255, 0.1) 0%, rgba(255, 255, 255, 0.03) 45%, transparent 62%), linear-gradient(165deg, rgba(255, 255, 255, 0.14) 0%, rgba(255, 255, 255, 0.05) 42%, transparent 72%); }
+.panel::before, .period-ribbon::before, .reconcile-summary::before, .work-progress::before { background: radial-gradient(150% 110% at 50% 118%, rgba(255, 255, 255, 0.05), transparent 55%), linear-gradient(165deg, rgba(255, 255, 255, 0.1) 0%, rgba(255, 255, 255, 0.03) 40%, transparent 70%); }
+
+.nav-item.is-active { border-color: rgba(255, 255, 255, 0.16); background: linear-gradient(160deg, rgba(255, 255, 255, 0.14), rgba(255, 255, 255, 0.06)); box-shadow: inset 0 1px rgba(255, 255, 255, 0.14), 0 10px 26px rgba(0, 0, 0, 0.32), 0 0 18px rgba(55, 235, 137, 0.08); }
+.metric-value { font-size: clamp(28px, 2.6vw, 38px); font-weight: 800; color: #ffffff; white-space: nowrap; }
+
+.metric-grid { gap: 20px; margin-bottom: 20px; }
+.admin-dashboard-grid { gap: 20px; margin-bottom: 20px; }
+.company-dashboard-grid { gap: 20px; }
+.page-heading { margin-bottom: 22px; }
+
+@media (max-width: 720px) {
+  .metric-grid { gap: 10px; margin-bottom: 14px; }
+  .page-heading { margin-bottom: 18px; }
+}
+
+/* ===== 反馈修正：侧栏质感 + 模块间距统一 ===== */
+.sidebar { border-color: rgba(255, 255, 255, 0.13); background: linear-gradient(170deg, rgba(26, 26, 26, 0.92), rgba(10, 10, 10, 0.94)); box-shadow: var(--shadow-panel), 0 0 44px rgba(55, 235, 137, 0.05); }
+.sidebar::before { content: ""; position: absolute; inset: 0; border-radius: inherit; background: radial-gradient(150% 110% at 50% 118%, rgba(255, 255, 255, 0.06), transparent 55%), linear-gradient(170deg, rgba(255, 255, 255, 0.1), rgba(255, 255, 255, 0.02) 45%, transparent 70%); pointer-events: none; }
+.nav-list { gap: 10px; }
+.nav-item { min-height: 48px; border-radius: 16px; }
+.user-block { border: 1px solid var(--color-line); border-radius: 16px; background: var(--color-surface-muted); }
+
+.company-alert { margin-bottom: 20px; }
+.period-ribbon { margin-bottom: 20px; }
+.company-stack-panel { margin-bottom: 20px; }
+.work-progress { margin-top: 20px; }
+.timeline-panel { margin-top: 20px; }
+
+/* ===== 反馈修正：整体提亮 + 列表改为玻璃行（去掉线条隔断） ===== */
+:root {
+  --color-ink-soft: #b6c0ba;
+  --color-ink-muted: #99a39d;
+}
+
+.panel, .period-ribbon, .query-band, .filter-bar, .filter-grid, .pair-report, .work-progress, .reconcile-summary { border-color: rgba(255, 255, 255, 0.12); background: linear-gradient(160deg, rgba(37, 37, 37, 0.84) 0%, rgba(21, 21, 21, 0.87) 50%, rgba(12, 12, 12, 0.89) 100%); }
+.panel::before, .period-ribbon::before, .reconcile-summary::before, .work-progress::before { background: radial-gradient(150% 110% at 50% 118%, rgba(255, 255, 255, 0.06), transparent 55%), linear-gradient(165deg, rgba(255, 255, 255, 0.13) 0%, rgba(255, 255, 255, 0.04) 40%, transparent 70%); }
+
+.task-list, .cashier-tasks, .coverage-list, .notification-list, .review-list { display: grid; gap: 8px; padding: 12px 14px 14px; }
+.task-list button, .cashier-tasks article, .coverage-list article, .notification-list article, .review-list > article, .subject-row { border: 1px solid var(--color-line); border-radius: var(--radius-md); background: linear-gradient(160deg, rgba(32, 32, 32, 0.72) 0%, rgba(15, 15, 15, 0.78) 100%); transition: background var(--duration-fast), border-color var(--duration-fast), box-shadow var(--duration-fast), transform var(--duration-fast); }
+.task-list button:hover, .cashier-tasks article:hover, .coverage-list article:hover, .notification-list article:hover, .review-list > article:hover, .subject-row:hover { border-color: rgba(255, 255, 255, 0.2); background: linear-gradient(160deg, rgba(44, 44, 44, 0.82) 0%, rgba(22, 22, 22, 0.86) 100%); box-shadow: 0 10px 26px rgba(0, 0, 0, 0.28); }
+.notification-list article.is-unread { border-color: rgba(102, 168, 255, 0.3); background: linear-gradient(160deg, rgba(102, 168, 255, 0.1), rgba(102, 168, 255, 0.04)); }
+.company-ledger { margin: 8px 14px; border: 1px solid var(--color-line); border-radius: var(--radius-md); background: linear-gradient(160deg, rgba(32, 32, 32, 0.72) 0%, rgba(15, 15, 15, 0.78) 100%); overflow: hidden; }
+.company-ledger[open] { border-color: rgba(255, 255, 255, 0.18); }
+.company-ledger:last-child { margin-bottom: 14px; }
+
+.data-table { border-collapse: separate; border-spacing: 0 8px; }
+.data-table th { height: 28px; padding: 0 13px; border-bottom: 0; background: transparent; }
+.data-table td { border-bottom: 0; border-top: 1px solid var(--color-line); border-bottom: 1px solid var(--color-line); background: linear-gradient(160deg, rgba(32, 32, 32, 0.72) 0%, rgba(15, 15, 15, 0.78) 100%); }
+.data-table td:first-child { border-left: 1px solid var(--color-line); border-radius: 12px 0 0 12px; }
+.data-table td:last-child { border-right: 1px solid var(--color-line); border-radius: 0 12px 12px 0; }
+.data-table tbody tr:hover td { background: linear-gradient(160deg, rgba(44, 44, 44, 0.85) 0%, rgba(22, 22, 22, 0.88) 100%); }
+.data-table tbody tr:last-child td { border-bottom: 1px solid var(--color-line); }
+.table-scroll { padding: 2px 14px 8px; }
+.table-summary { margin: 0 14px; }
+
+@media (prefers-reduced-motion: reduce) {
+  *, *::before, *::after { scroll-behavior: auto !important; animation-duration: 0.01ms !important; animation-iteration-count: 1 !important; transition-duration: 0.01ms !important; }
+  .button.is-loading .spinner { animation-duration: 1s !important; animation-iteration-count: infinite !important; }
+}