commit 45424e6fd6102a698edd46f515e0fbd10853f682
Author: BlackMark <me@blackmark.me>
Date:   Mon Nov 2 16:52:27 2026 +0100

    Vermietungs-Tool
    
    A local web app for a small room-rental business in Austria: guest register,
    room ledger, occupancy plan, invoices, the monthly tourist-tax report and the
    quarterly VAT list. Application code only; it ships no data.
    
    Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

diff --git a/.gitattributes b/.gitattributes
new file mode 100644
index 0000000..6f6095b
--- /dev/null
+++ b/.gitattributes
@@ -0,0 +1,6 @@
+# Text is stored and checked out with LF on every machine
+* text=auto eol=lf
+
+*.png binary
+*.jpg binary
+*.jpeg binary
diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..d0753f1
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,11 @@
+# Local settings: database URLs
+.env
+
+# Python environment and caches
+.venv/
+__pycache__/
+*.pyc
+.pytest_cache/
+
+# Invoice logos and photos (app/static/invoice/) belong to whoever runs the app
+app/static/invoice/
diff --git a/README.md b/README.md
new file mode 100644
index 0000000..8fb3837
--- /dev/null
+++ b/README.md
@@ -0,0 +1,109 @@
+# Vermietungs-Tool
+
+A local web app for running a small room-rental business in Austria: the guest register, the room
+ledger, invoices, the monthly tourist-tax report and the quarterly VAT list, all from one database.
+It is built for one non-technical user — German UI, no training needed — and handles the bookkeeping
+rules that make this work tedious by hand.
+
+This repository presents the tool. It contains the application code only; it ships no data.
+
+![Belegungsplan — the occupancy timeline](docs/screenshots/plan.png)
+
+*All names, companies and addresses in the screenshots are fictitious.*
+
+## What it does
+
+| Page | Purpose |
+| --- | --- |
+| **Gästeblätter** | The guest register: one registration sheet per guest and stay (Meldegesetz), with room, employer, main residence and tourist-tax liability. A room change continues the same sheet in another room. |
+| **Zimmerbelegung** | The room ledger: what each room is billed for, per period and person — weeks, nights or months, Ortstaxe, payer, invoice number and payments (also in parts). |
+| **Belegungsplan** | A rooms × days timeline of who is in the house, today's free beds, and bookings ahead. |
+| **Rechnungen** | Invoices generated from ledger or register rows: per-person lines, VAT breakdown, cancellation fees as non-taxable damages, Ortstaxe, A4 layout for window envelopes, PDF download. |
+| **Firmen** | Companies with all their spellings and address versions; old invoices keep the address that was true at the time. |
+| **TVB-Meldung** | The monthly tourist-tax report (Sammelmeldung) per business, ready to type into Feratel: persons and nights by country or Austrian/German region, liable and exempt. |
+| **Umsatzsteuer** | The quarterly VAT list (cash basis): every receipt in the quarter it was paid, part payments split across quarters, non-taxable items kept out of the base. |
+| **Datenprüfung** | Data-quality checks — register and ledger disagreeing, departures never billed, recipients without an address, duplicate invoice numbers — and merge suggestions for near-duplicate companies and guests. |
+
+### Rules it applies so nobody has to
+
+- **Billing in weeks**: a stay of four nights or more is billed in whole weeks, rounded up; shorter stays
+  are billed by the night.
+- **Ortstaxe**: charged per person and night at the rate in force on the arrival date, and waived for
+  professional stays of more than ten nights — judged on the *whole* stay, across room changes and month-end
+  invoices, and never for a guest who is still in the house.
+- **The ledger follows the register**: a departure entered on a guest sheet closes that guest's ledger row
+  with quantity, amount and Ortstaxe; a guest leaving before the others gets a row of their own, and rows that
+  end up alike merge again. Month-end billing closes a row and continues the stay in a new one.
+- **The ledger follows the invoice**: when an invoice settles a price or period differently, the ledger rows it
+  was made from are corrected to match; when a ledger row changes after invoicing, the invoice is flagged and
+  can be regenerated in one click.
+- **Issued invoices never change as a side effect**: recording a payment touches only the payment fields, and
+  payment information from the ledger is offered, not applied.
+- **Invoice numbers follow the dates** within each business and year; saving an invoice out of order, or one
+  whose recipient has no postal address, asks first.
+- **Payments**: a date in "bezahlt am" marks a row paid, payments in parts keep it open until amount and
+  Ortstaxe are covered, and a paid invoice pays its ledger rows.
+
+## Screenshots
+
+| | |
+| --- | --- |
+| ![Zimmerbelegung](docs/screenshots/ledger.png) | ![Gästeblätter](docs/screenshots/register.png) |
+| **Zimmerbelegung** — the room ledger | **Gästeblätter** — the guest register |
+| ![TVB-Meldung](docs/screenshots/tvb.png) | ![Datenprüfung](docs/screenshots/quality.png) |
+| **TVB-Meldung** — the monthly tourist-tax report | **Datenprüfung** — data-quality checks |
+
+![Rechnung](docs/screenshots/invoice.png)
+
+## Under the hood
+
+- **Flask + Jinja2**, server-rendered pages; all UI text comes from [locales/de.json](locales/de.json).
+- **PostgreSQL** through psycopg, behind a thin adapter ([app/db.py](app/db.py)) that gives the code a
+  sqlite3-style interface (`?` placeholders, `lastrowid`, rows by name or index). Two roles: the app's role may
+  only read and write data; the owner applies migrations and takes snapshots.
+- **Single source of truth**: every value lives in one place; totals, nights, quantities and payment states are
+  computed at read time ([app/compute.py](app/compute.py), [app/repo.py](app/repo.py)). Money is summed at full
+  precision and rounded once.
+- **Audit log** ([migrations/002_audit_log.sql](migrations/002_audit_log.sql), [app/audit.py](app/audit.py)):
+  a trigger records every row change with before/after values and who made it; the app's role can read the log
+  but not alter it. `python -m app.audit revert` undoes chosen entries or a whole transaction, refusing if the
+  rows changed since.
+- **A grid engine in plain JavaScript** ([app/static/grids.js](app/static/grids.js)) for lists of thousands of
+  rows: rows ship in an inert `<template>` and only the visible window is attached, column widths are measured
+  once and cached per data version, multi-level sorting, live search and filters, pinned columns, live sums, and
+  print-to-one-page.
+- **Change detection by trigger**: every write bumps a `data_version` counter, which keys a server-side page
+  cache and the browser's cached column layouts.
+- **PDF invoices** rendered by a headless Chromium-family browser through Playwright
+  ([app/pdf.py](app/pdf.py)), from the same HTML the browser prints, placed to the millimetre for DIN 5008
+  window envelopes.
+
+```text
+app/
+  web.py        routes            repo.py      service layer (all reads and writes)
+  compute.py    money and stay rules            tvb.py, vat.py, plan.py, quality.py   reports and checks
+  db.py         database access, migrations     audit.py     audit log and revert
+  pdf.py        invoice PDFs                    templates/, static/
+locales/        UI text (German)
+migrations/     schema (numbered SQL)
+```
+
+## Running it
+
+Requirements: Python 3.13 or newer, a PostgreSQL database, and Microsoft Edge or Google Chrome for PDFs.
+
+```sh
+python -m venv .venv
+.venv/bin/pip install -r requirements.txt           # Windows: .venv\Scripts\pip
+export DATABASE_URL=postgresql://user:password@host:5432/dbname
+python -m app.db migrate                             # create the schema
+python -m app.web                                    # http://127.0.0.1:5000
+```
+
+- Settings come from the environment or from a `.env` file in the repository root (`KEY=VALUE` lines):
+  `DATABASE_URL`; optionally `DATABASE_OWNER_URL` for migrations when the app runs with a restricted role, and
+  `PDF_BROWSER` (`msedge`, `chrome`, or `chromium` after `playwright install chromium`).
+- The database starts empty. The businesses (`unit`: name, address, bank details, VAT and tourist-tax numbers,
+  invoice number prefix, colour theme) and their rooms (`room`) are set up directly in the database; everything
+  else is entered in the app. Logos and photos for the invoice header go into `app/static/invoice/`, named in
+  `unit.logo` / `unit.photo`.
diff --git a/app/__init__.py b/app/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/app/audit.py b/app/audit.py
new file mode 100644
index 0000000..73376f9
--- /dev/null
+++ b/app/audit.py
@@ -0,0 +1,116 @@
+"""The audit log (migration 002): every row a data table gains, loses or changes, with who wrote it — and
+undoing chosen entries.
+
+python -m app.audit [--table T] [--row ID] [--actor A] [--tx TX] [--limit N]    newest entries first
+python -m app.audit revert (ENTRY... | --tx TX) [--apply]                       a dry run without --apply
+"""
+import argparse
+import json
+
+from app import db
+
+KEYS = {"company_key": ("key",), "dismissed_finding": ("kind", "key")}   # every other table: id
+
+
+class Conflict(Exception):
+    """The row no longer looks as the entry left it: someone changed it since."""
+
+
+def entries(conn, table=None, row_id=None, actor=None, tx=None, ids=None, limit=50):
+    """Log entries, newest first."""
+    where, params = [], []
+    for sql, value in (("table_name = ?", table), ("row_id = ?", row_id), ("actor = ?", actor), ("tx = ?", tx)):
+        if value is not None:
+            where.append(sql)
+            params.append(value)
+    if ids:
+        where.append("id = ANY(?)")
+        params.append(list(ids))
+    sql = "SELECT * FROM audit_log" + (" WHERE " + " AND ".join(where) if where else "")
+    return [dict(r) for r in db.rows(conn, sql + " ORDER BY id DESC LIMIT ?", params + [limit])]
+
+
+def _where(table, row):
+    cols = KEYS.get(table, ("id",))
+    return " AND ".join(f'"{c}" = ?' for c in cols), [row[c] for c in cols]
+
+
+def revert(conn, chosen):
+    """Undo the chosen entries newest first, in the caller's transaction (commit or roll back after). Each
+    step first checks that the row still looks exactly as the entry left it — a later change by anyone else
+    raises Conflict, so the caller rolls everything back. Returns one line per step."""
+    conn.execute("SET CONSTRAINTS ALL DEFERRED")            # parents and children come back in any order
+    steps = []
+    for e in sorted(chosen, key=lambda e: e["id"], reverse=True):
+        table, op = e["table_name"], e["op"]
+        if table not in db.DATA_TABLES or op == "TRUNCATE":
+            raise Conflict(f"#{e['id']}: {op} on {table} cannot be undone row by row — restore a snapshot")
+        where, key = _where(table, e["new"] or e["old"])
+        now = db.row(conn, f"SELECT to_jsonb(x) FROM {table} x WHERE {where}", key)
+        if (now[0] if now else None) != e["new"]:
+            raise Conflict(f"#{e['id']} {table} {key}: changed since — now {now[0] if now else 'gone'}")
+        if op == "INSERT":
+            conn.execute(f"DELETE FROM {table} WHERE {where}", key)
+        elif op == "DELETE":
+            conn.execute(f"INSERT INTO {table} SELECT * FROM jsonb_populate_record(NULL::{table}, "
+                         f"(SELECT old FROM audit_log WHERE id = ?))", (e["id"],))
+        else:
+            cols = ", ".join(f'"{c}"' for c in e["old"] if e["old"][c] != e["new"].get(c))
+            conn.execute(f"UPDATE {table} SET ({cols}) = (SELECT {cols} FROM jsonb_populate_record("
+                         f"NULL::{table}, (SELECT old FROM audit_log WHERE id = ?))) WHERE {where}",
+                         [e["id"]] + key)
+        steps.append(f"#{e['id']} {op} {table} {key} undone")
+    return steps
+
+
+def describe(e):
+    if e["op"] == "UPDATE":
+        what = "; ".join(f"{c}: {e['old'][c]!r} -> {e['new'].get(c)!r}"
+                         for c in e["old"] if e["old"][c] != e["new"].get(c))
+    else:
+        what = json.dumps(e["new"] or e["old"], ensure_ascii=False)
+    return (f"#{e['id']} {e['at']:%Y-%m-%d %H:%M:%S} tx {e['tx']} {e['actor']} ({e['db_user']}) "
+            f"{e['op']} {e['table_name']} {e['row_id'] or ''}  {what[:300]}")
+
+
+def main():
+    p = argparse.ArgumentParser(prog="python -m app.audit")
+    p.add_argument("command", nargs="?", choices=["list", "revert"], default="list")
+    p.add_argument("ids", nargs="*", type=int, help="entries to revert")
+    p.add_argument("--table")
+    p.add_argument("--row", type=int)
+    p.add_argument("--actor")
+    p.add_argument("--tx", type=int)
+    p.add_argument("--limit", type=int, default=50)
+    p.add_argument("--apply", action="store_true", help="write the revert (default: dry run)")
+    a = p.parse_args()
+    if a.command == "list":
+        for e in entries(db.connect(), a.table, a.row, a.actor, a.tx, limit=a.limit):
+            print(describe(e))
+        return
+    if not (a.ids or a.tx):
+        p.error("revert needs entry ids or --tx")
+    if a.apply:
+        with db.connect(owner=True) as owner:
+            print("Snapshot saved:", db.snapshot(owner, "before revert"))
+    label = f"revert {'tx ' + str(a.tx) if a.tx else ' '.join(f'#{i}' for i in a.ids)}"
+    conn = db.connect(actor=label)
+    chosen = entries(conn, tx=a.tx, ids=a.ids, limit=100000)
+    if not chosen:
+        raise SystemExit("no such entries")
+    try:
+        for step in revert(conn, chosen):
+            print(step)
+    except Conflict as c:
+        conn.rollback()
+        raise SystemExit(f"NOTHING written — {c}")
+    if a.apply:
+        conn.commit()
+        print(f"reverted {len(chosen)} entries (logged as '{label}')")
+    else:
+        conn.rollback()
+        print("dry run — nothing written; add --apply")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/app/compute.py b/app/compute.py
new file mode 100644
index 0000000..bdcf029
--- /dev/null
+++ b/app/compute.py
@@ -0,0 +1,167 @@
+"""Money rules for invoice lines and totals, and the stay rules behind them — the single source for every
+page and report.
+
+A line's net is `quantity * gross_per_unit / (1 + vat_rate)` at full precision, unless an explicit
+`line_net_override` pins it. The standard accommodation rate is 10%. A storno line (kind='storno') is *nicht
+steuerbar* (vat_rate 0): a cancellation fee is damages, not a supply, so it carries no VAT and is kept OUT of
+the taxable Nettobetrag — it is a separate subtotal on the invoice. Totals sum the full-precision line values
+and round once.
+"""
+from decimal import Decimal, ROUND_HALF_UP
+
+VAT_STANDARD = Decimal("0.10")   # Beherbergung reduced rate
+
+
+def _d(x):
+    return Decimal(str(x))
+
+
+def _round2(value):
+    return float(Decimal(value).quantize(Decimal("0.01"), rounding=ROUND_HALF_UP))
+
+
+def _rate(vat_rate):
+    return VAT_STANDARD if vat_rate is None else _d(vat_rate)
+
+
+def _net_exact(quantity, gross_per_unit, line_net_override=None, vat_rate=None):
+    if line_net_override is not None:
+        return _d(line_net_override)
+    return _d(quantity) * _d(gross_per_unit) / (Decimal(1) + _rate(vat_rate))
+
+
+# --- per-line display values ---
+def net_per_unit(gross_per_unit, vat_rate=None):
+    return _round2(_d(gross_per_unit) / (Decimal(1) + _rate(vat_rate)))
+
+
+def line_net(quantity, gross_per_unit, line_net_override=None, vat_rate=None):
+    return _round2(_net_exact(quantity, gross_per_unit, line_net_override, vat_rate))
+
+
+def line_vat(quantity, gross_per_unit, line_net_override=None, vat_rate=None):
+    return _round2(_net_exact(quantity, gross_per_unit, line_net_override, vat_rate) * _rate(vat_rate))
+
+
+def line_gross(quantity, gross_per_unit, line_net_override=None, vat_rate=None):
+    return _round2(_net_exact(quantity, gross_per_unit, line_net_override, vat_rate) * (Decimal(1) + _rate(vat_rate)))
+
+
+# --- invoice totals over charge dicts (keys: quantity, gross_per_unit, line_net_override?, vat_rate?, kind?) ---
+def _is_storno(c):
+    return c.get("kind") == "storno"
+
+
+def _net_exact_c(c):
+    return _net_exact(c["quantity"], c["gross_per_unit"], c.get("line_net_override"), c.get("vat_rate"))
+
+
+def _storno_amount(c):
+    # nicht steuerbar: the whole amount, no VAT split (rate forced to 0)
+    return _net_exact(c["quantity"], c["gross_per_unit"], c.get("line_net_override"), 0)
+
+
+def invoice_net(charges):
+    """Steuerbarer Nettobetrag — taxable lines only (storno is nicht steuerbar and excluded from the base)."""
+    return _round2(sum((_net_exact_c(c) for c in charges if not _is_storno(c)), Decimal("0")))
+
+
+def invoice_vat(charges):
+    return _round2(sum((_net_exact_c(c) * _rate(c.get("vat_rate")) for c in charges if not _is_storno(c)), Decimal("0")))
+
+
+def invoice_vat_breakdown(charges):
+    """Per-rate (net, vat) for the taxable lines, so a mixed-rate invoice (e.g. a Betriebskosten settlement with
+    0/10/20 %) can print one 'USt X %' row per rate. A plain 10 % invoice yields a single row, unchanged.
+    0 % lines stay in the Nettobetrag but get no row — 'USt 0 %  0,00' must never be printed (§11 Abs 12)."""
+    buckets = {}
+    for c in charges:
+        if _is_storno(c):
+            continue
+        rate = _rate(c.get("vat_rate"))
+        b = buckets.setdefault(rate, [Decimal("0"), Decimal("0")])
+        net = _net_exact_c(c)
+        b[0] += net
+        b[1] += net * rate
+    out = []
+    for rate, (net, vat) in sorted(buckets.items()):
+        if not rate:
+            continue
+        p = float(rate) * 100
+        pct = str(int(round(p))) if abs(p - round(p)) < 0.005 else f"{p:.2f}".replace(".", ",")
+        out.append({"rate": float(rate), "pct": pct, "net": _round2(net), "vat": _round2(vat)})
+    return out
+
+
+def invoice_storno(charges):
+    """Sum of the nicht-steuerbare Storno lines (kept out of the VAT base, shown as its own subtotal)."""
+    return _round2(sum((_storno_amount(c) for c in charges if _is_storno(c)), Decimal("0")))
+
+
+def invoice_gross(charges, tourism_tax=0):
+    # Rounds the exact gross sum ONCE: the Rechnungsbetrag is the summed gross column, even where net + USt,
+    # each rounded on its own, differ from it by a cent.
+    taxable = sum((_net_exact_c(c) * (Decimal(1) + _rate(c.get("vat_rate"))) for c in charges if not _is_storno(c)),
+                  Decimal("0"))
+    storno = sum((_storno_amount(c) for c in charges if _is_storno(c)), Decimal("0"))
+    return _round2(taxable + storno + _d(tourism_tax))
+
+
+def days_between(arrival, departure):
+    """Whole days between two ISO dates (`bis - von`): the nights of a stay."""
+    from datetime import date
+    if not arrival or not departure:
+        return None
+    a = date.fromisoformat(arrival)
+    d = date.fromisoformat(departure)
+    return (d - a).days
+
+
+def weeks_for_period(period_from, period_to):
+    """The week rule: a stay of >= 4 nights is billed in WHOLE weeks, rounded up (5 nights -> 1 week,
+    10 nights -> 2). Shorter stays are not a week (billed per day/night) -> None."""
+    import math
+    nights = days_between(period_from, period_to)
+    if nights is None or nights < 4:
+        return None
+    return math.ceil(nights / 7)
+
+
+# Aufenthaltsabgabe (Ortstaxe) per person per night, by the date it applies from; newest first
+TOURISM_RATES = (("2026-05-01", 4.0), ("", 3.0))
+TOURISM_EXEMPT_OVER_NIGHTS = 10   # professional stays longer than this are exempt (T-AAG §4)
+
+
+def tourism_rate(day):
+    """The Aufenthaltsabgabe per person and night in force on an ISO date."""
+    return next(r for start, r in TOURISM_RATES if day >= start)
+
+
+def tourism_liable(arrival, departure):
+    """Does this stay owe the Aufenthaltsabgabe? (the guest sheet's 'Abg' column). >10 consecutive nights
+    on a professional stay are exempt (T-AAG §4) — the same rule the TVB filing counts by. None while the
+    departure is still open: nobody can know yet."""
+    nights = days_between(arrival, departure)
+    if nights is None:
+        return None
+    return 1 if nights <= TOURISM_EXEMPT_OVER_NIGHTS else 0
+
+
+def tourism_amount(period_from, period_to, total_nights=None):
+    """Ortstaxe for one invoice line: 0 when the guest's WHOLE continuous stay exceeds 10 nights (T-AAG §4
+    professional-stay exemption), otherwise this line's nights x the rate at the arrival date. Pass
+    `total_nights` = the continuous stay length so a slice billed in a later month stays exempt even though
+    the slice itself is short; it defaults to this line's own nights when the full length isn't known."""
+    line_nights = days_between(period_from, period_to)
+    if not line_nights or line_nights <= 0:
+        return 0
+    stay_nights = total_nights if total_nights is not None else line_nights
+    if stay_nights > TOURISM_EXEMPT_OVER_NIGHTS:
+        return 0
+    return round(line_nights * tourism_rate(period_from), 2)
+
+
+def tourism_for_period(period_from, period_to):
+    """Ortstaxe for a self-contained stay: the exemption is judged on this same period (see tourism_amount
+    for the continuation case where the stay started in an earlier, separately billed month)."""
+    return tourism_amount(period_from, period_to, days_between(period_from, period_to))
diff --git a/app/config.py b/app/config.py
new file mode 100644
index 0000000..be5949f
--- /dev/null
+++ b/app/config.py
@@ -0,0 +1,23 @@
+"""Settings that must not live in git — database URLs. Read from the environment first, else from the
+git-ignored `.env` at the repo root (KEY=VALUE lines, # comments)."""
+import os
+from functools import lru_cache
+from pathlib import Path
+
+ENV_FILE = Path(__file__).resolve().parents[1] / ".env"
+
+
+@lru_cache(maxsize=1)
+def _values():
+    values = {}
+    if ENV_FILE.exists():
+        for line in ENV_FILE.read_text(encoding="utf-8").splitlines():
+            line = line.strip()
+            if line and not line.startswith("#") and "=" in line:
+                key, value = line.split("=", 1)
+                values[key.strip()] = value.strip()
+    return values
+
+
+def get(key, default=None):
+    return os.environ.get(key) or _values().get(key, default)
diff --git a/app/db.py b/app/db.py
new file mode 100644
index 0000000..d0fa712
--- /dev/null
+++ b/app/db.py
@@ -0,0 +1,277 @@
+"""The only module that opens the database (PostgreSQL) and applies schema migrations.
+
+SQL in this code base uses `?` placeholders (DB-API qmark style); `_translate` turns each statement into
+psycopg's format once. Rows behave like sqlite3.Row (by name, by index, dict(row)), an INSERT reports
+`lastrowid`, and ints are sent untyped so Postgres reads them as the column needs. Two roles: the app's role
+reads and writes data only; the owner role applies migrations — `python -m app.db migrate` — and takes
+snapshots before risky writes. With a single role, DATABASE_URL serves both.
+"""
+import re
+import sys
+from datetime import date, datetime
+from decimal import Decimal
+from functools import lru_cache
+from pathlib import Path
+
+import psycopg
+from psycopg.adapt import Dumper, Loader
+from psycopg.conninfo import conninfo_to_dict
+from psycopg.sql import Identifier
+
+from app import config
+
+SYSTEM_DIR = Path(__file__).resolve().parent.parent
+MIGRATIONS_DIR = SYSTEM_DIR / "migrations"
+URL = config.get("DATABASE_URL")                       # the app's role: data only
+OWNER_URL = config.get("DATABASE_OWNER_URL") or URL     # migrations, snapshots
+SCHEMA = "public"                                # the tests give every test a schema of its own
+TIMEZONE = "Europe/Vienna"
+APP_ROLE = conninfo_to_dict(URL)["user"] if URL else None
+DATA_TABLES = ("unit", "room", "company", "client", "company_key", "dismissed_finding", "guest", "invoice",
+               "stay", "charge", "payment")
+TABLES_WITH_ID = {"unit", "room", "company", "client", "guest", "invoice", "stay", "charge", "payment"}
+IntegrityError = psycopg.IntegrityError
+INSERT = re.compile(r"\s*INSERT\s+INTO\s+(\w+)", re.I)
+
+
+class Row:
+    """A result row like sqlite3.Row: row["name"] (any case), row[0], dict(row), iteration over the values."""
+    __slots__ = ("_index", "_values")
+
+    def __init__(self, index, values):
+        self._index, self._values = index, values
+
+    def keys(self):
+        return [k for k in self._index if not k.startswith("\0")]
+
+    def __getitem__(self, key):
+        if isinstance(key, (int, slice)):
+            return self._values[key]
+        try:
+            return self._values[self._index[key]]
+        except KeyError:
+            return self._values[self._index["\0" + key.lower()]]
+
+    def __iter__(self):
+        return iter(self._values)
+
+    def __len__(self):
+        return len(self._values)
+
+    def __eq__(self, other):
+        return isinstance(other, Row) and self.keys() == other.keys() and self._values == other._values
+
+    def __hash__(self):
+        return hash(tuple(self._values))
+
+    def __repr__(self):
+        return f"Row({dict(self)!r})"
+
+
+def _row_factory(cursor):
+    names = [c.name for c in cursor.description or ()]
+    index = {n: i for i, n in enumerate(names)}
+    index.update({"\0" + n.lower(): i for i, n in enumerate(names)})    # case-insensitive, like sqlite3.Row
+    return lambda values: Row(index, values)
+
+
+class _Untyped(Dumper):
+    """Python ints and bools go to the server as untyped literals (bools as 1/0, the integer flag columns):
+    Postgres then reads `'22'` as the text room number or the integer id, whichever the context needs."""
+    oid = 0
+
+    def dump(self, obj):
+        return str(int(obj)).encode()
+
+
+class _IsoText(Dumper):
+    """Dates go as untyped ISO text: the date columns are text, and Postgres has no `text >= date`
+    operator."""
+    oid = 0
+
+    def dump(self, obj):
+        return (obj.isoformat(" ") if isinstance(obj, datetime) else obj.isoformat()).encode()
+
+
+class _Numeric(Loader):
+    """numeric -> int when integral, else float (charge.persons: 2, or 1.5)."""
+
+    def load(self, data):
+        d = Decimal(bytes(data).decode())
+        return int(d) if d == d.to_integral_value() else float(d)
+
+
+@lru_cache(maxsize=None)
+def _translate(sql):
+    """`?` -> `%s` and `%` -> `%%`. psycopg reads `%` everywhere — inside string literals and comments too —
+    so every `%` is doubled; a `?` inside a literal or comment stays a question mark."""
+    out, i, n = [], 0, len(sql)
+    while i < n:
+        ch = sql[i]
+        if ch in "'\"":
+            end = sql.find(ch, i + 1)
+            end = n - 1 if end < 0 else end
+            out.append(sql[i:end + 1].replace("%", "%%"))
+            i = end + 1
+            continue
+        if sql.startswith("--", i):
+            end = sql.find("\n", i)
+            end = n if end < 0 else end
+            out.append(sql[i:end].replace("%", "%%"))
+            i = end
+            continue
+        out.append("%s" if ch == "?" else "%%" if ch == "%" else ch)
+        i += 1
+    return "".join(out)
+
+
+class Cursor:
+    """A cursor as sqlite3 offers one: fetchone/fetchall/iteration, lastrowid after an INSERT, rowcount."""
+
+    def __init__(self, cur, returning):
+        self._cur, self.lastrowid, self.rowcount = cur, None, cur.rowcount
+        self._done = cur.description is None
+        if returning:
+            ids = cur.fetchall()
+            self.lastrowid = ids[-1][0] if ids else None
+            self._done = True
+
+    def fetchone(self):
+        return None if self._done else self._cur.fetchone()
+
+    def fetchall(self):
+        return [] if self._done else self._cur.fetchall()
+
+    def __iter__(self):
+        return iter(self.fetchall())
+
+
+class Connection:
+    """A psycopg connection with the sqlite3 interface this code is written against. `with conn:` commits
+    or rolls back and keeps the connection open, as sqlite3 does; `close()` closes it."""
+
+    def __init__(self, raw):
+        self.raw = raw
+
+    def execute(self, sql, params=()):
+        m = INSERT.match(sql)
+        returning = bool(m and m.group(1).lower() in TABLES_WITH_ID and not re.search(r"\bRETURNING\b", sql, re.I))
+        if returning:
+            sql = sql.rstrip().rstrip(";") + " RETURNING id"
+        return Cursor(self.raw.execute(_translate(sql), tuple(params)), returning)
+
+    def executescript(self, sql):
+        self.raw.execute(sql)            # no parameters: Postgres takes several statements at once
+
+    def commit(self):
+        self.raw.commit()
+
+    def rollback(self):
+        self.raw.rollback()
+
+    def close(self):
+        self.raw.close()
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, kind, exc, tb):
+        self.raw.rollback() if kind else self.raw.commit()
+
+
+def connect(owner=False, actor="cli"):
+    """A connection as the app's role — or as the owner, for migrations, snapshots and maintenance. `actor`
+    names whoever writes through it in the audit log (002): `web`, `cli`, ..."""
+    url = OWNER_URL if owner else URL
+    if not url:
+        raise RuntimeError("no database URL: set DATABASE_URL (environment or .env)")
+    actor = actor.replace("\\", "\\\\").replace(" ", "\\ ")      # libpq options split at unescaped spaces
+    raw = psycopg.connect(url, options=f"-c search_path={SCHEMA} -c TimeZone={TIMEZONE} -c app.actor={actor}",
+                          application_name="vermietungs-tool", row_factory=_row_factory)
+    raw.adapters.register_dumper(int, _Untyped)
+    raw.adapters.register_dumper(bool, _Untyped)
+    raw.adapters.register_dumper(date, _IsoText)
+    raw.adapters.register_dumper(datetime, _IsoText)
+    raw.adapters.register_loader("numeric", _Numeric)
+    return Connection(raw)
+
+
+def _migrations():
+    return {int(p.name[:3]): p for p in sorted(MIGRATIONS_DIR.glob("[0-9][0-9][0-9]_*.sql"))}
+
+
+def pending_migrations(conn):
+    exists = conn.execute("SELECT to_regclass('schema_version') IS NOT NULL").fetchone()[0]
+    applied = {r[0] for r in conn.execute("SELECT version FROM schema_version")} if exists else set()
+    return sorted(v for v in _migrations() if v not in applied)
+
+
+def migrate(conn):
+    """Apply every migration not yet recorded in schema_version, each in its own transaction (DDL is
+    transactional in Postgres), then grant the app's role its data rights. Needs the owner role."""
+    conn.execute("CREATE TABLE IF NOT EXISTS schema_version (version integer PRIMARY KEY, applied_at text "
+                 "COLLATE \"C\" DEFAULT to_char(now(), 'YYYY-MM-DD HH24:MI:SS'))")
+    conn.commit()
+    for version in pending_migrations(conn):
+        conn.executescript(_migrations()[version].read_text(encoding="utf-8"))
+        conn.execute("INSERT INTO schema_version (version) VALUES (?)", (version,))
+        conn.commit()
+    _grant(conn)
+
+
+def _grant(conn):
+    """The app's role may read and write the data tables — nothing else: no DDL, no TRUNCATE, and it cannot
+    rewrite the schema history or the audit log (its trigger writes as the owner)."""
+    me = conn.execute("SELECT current_user").fetchone()[0]
+    if not APP_ROLE or APP_ROLE == me:
+        return
+    schema, role = Identifier(SCHEMA).as_string(conn.raw), Identifier(APP_ROLE).as_string(conn.raw)
+    conn.executescript(f"GRANT USAGE ON SCHEMA {schema} TO {role};"
+                       f"GRANT SELECT, INSERT, UPDATE, DELETE ON ALL TABLES IN SCHEMA {schema} TO {role};"
+                       f"GRANT USAGE, SELECT, UPDATE ON ALL SEQUENCES IN SCHEMA {schema} TO {role};"
+                       f"REVOKE INSERT, UPDATE, DELETE ON {schema}.schema_version, {schema}.audit_log FROM {role};"
+                       f"REVOKE ALL ON SEQUENCE {schema}.audit_log_id_seq FROM {role};")
+    conn.commit()
+
+
+def snapshot(conn, label):
+    """Copy every data table into a new schema `snap_<YYYYMMDD_HHMMSS>_<label>` — the backup before a risky
+    write outside the app. Owner role. Returns the schema name."""
+    name = f"snap_{datetime.now():%Y%m%d_%H%M%S}_{re.sub(r'[^a-z0-9]+', '_', label.lower()).strip('_')}"[:63]
+    conn.execute(f'CREATE SCHEMA "{name}"')
+    for table in DATA_TABLES:
+        conn.execute(f'CREATE TABLE "{name}"."{table}" AS TABLE "{SCHEMA}"."{table}"')
+    conn.commit()
+    return name
+
+
+def rows(conn, sql, params=()):
+    return conn.execute(sql, params).fetchall()
+
+
+def row(conn, sql, params=()):
+    return conn.execute(sql, params).fetchone()
+
+
+def execute(conn, sql, params=()):
+    cur = conn.execute(sql, params)
+    conn.commit()
+    return cur.lastrowid
+
+
+def main():
+    """python -m app.db migrate | status | snapshot <label>"""
+    command = sys.argv[1] if len(sys.argv) > 1 else "status"
+    with connect(owner=True) as conn:
+        if command == "migrate":
+            migrate(conn)
+        elif command == "snapshot":
+            print(snapshot(conn, sys.argv[2] if len(sys.argv) > 2 else "manual"))
+            return
+        print("pending migrations:", pending_migrations(conn) or "none")
+        print("snapshots:", [r[0] for r in conn.execute(
+            "SELECT nspname FROM pg_namespace WHERE nspname LIKE 'snap\\_%' ORDER BY 1")])
+
+
+if __name__ == "__main__":
+    main()
diff --git a/app/i18n.py b/app/i18n.py
new file mode 100644
index 0000000..87cbfb7
--- /dev/null
+++ b/app/i18n.py
@@ -0,0 +1,11 @@
+"""Tiny localization lookup. All UI text comes from locales/de.json via t()."""
+import json
+from pathlib import Path
+
+_FILE = Path(__file__).resolve().parent.parent / "locales" / "de.json"
+_strings = json.loads(_FILE.read_text(encoding="utf-8"))
+
+
+def t(key, **kwargs):
+    text = _strings.get(key, key)
+    return text.format(**kwargs) if kwargs else text
diff --git a/app/money.py b/app/money.py
new file mode 100644
index 0000000..e361083
--- /dev/null
+++ b/app/money.py
@@ -0,0 +1,45 @@
+"""German number/currency formatting for display (1.234,56 €)."""
+from app import i18n
+
+
+def de_number(value, decimals=2):
+    if value is None or value == "":
+        return ""
+    formatted = f"{float(value):,.{decimals}f}"          # 1,234.56
+    return formatted.replace(",", "\x00").replace(".", ",").replace("\x00", ".")
+
+
+def euro(value):
+    if value is None or value == "":
+        return ""
+    return f"{de_number(value)} €"
+
+
+WEEKDAYS = i18n.t("weekdays_short")
+
+
+def de_date_wd(iso):
+    """'Mo 13.09.2026' — the weekday before the date, so the lists show at once which day an arrival or
+    departure falls on (weekly prices run from weekday to weekday)."""
+    import datetime
+    text = de_date(iso)
+    if not text:
+        return text
+    try:
+        day = datetime.date.fromisoformat(str(iso)[:10])
+    except ValueError:
+        return text                      # not a real date (a month name or the like) — leave it as it is
+    # a non-breaking space: on paper the table would otherwise break between weekday and date
+    # ("So" on one line, "13.09.2026" on the next)
+    return f"{WEEKDAYS[day.weekday()]} {text}"
+
+
+def de_date(iso):
+    """ISO yyyy-mm-dd -> German dd.mm.yyyy for display."""
+    if not iso:
+        return ""
+    try:
+        y, m, d = str(iso).split("-")
+        return f"{d}.{m}.{y}"
+    except ValueError:
+        return str(iso)
diff --git a/app/normalize.py b/app/normalize.py
new file mode 100644
index 0000000..74c1e65
--- /dev/null
+++ b/app/normalize.py
@@ -0,0 +1,53 @@
+"""Pure normalization rules: company-name spellings and invoice-number formats."""
+import re
+
+
+def company_key(name):
+    """Grouping key for company-name spellings: case/punctuation/whitespace-insensitive, the German
+    legal-form spellings unified (GmbH == Ges.m.b.H. == GesmbH, 'und' == '&'). Different legal forms
+    (GmbH vs AG) stay different — near-misses beyond this are only SUGGESTED for manual merge."""
+    n = (name or "").strip().lower()
+    n = n.replace(" und ", " & ").replace(" u. ", " & ")
+    n = re.sub(r"ges\.?\s*m\.?\s*b\.?\s*h\.?", "gmbh", n)
+    n = re.sub(r"[^a-z0-9äöüß&]+", "", n)
+    return n.replace("gbmh", "gmbh")   # 'GbmH' is a transposition typo, not a different legal form
+
+
+def invoice_seq(number, year):
+    """Canonical integer sequence of an invoice number for the given 4-digit year, whatever the format:
+        '202262' -> 62, '2022-62' -> 62, '22-62' -> 62, '62-2015' -> 62 (SEQ-YEAR), '2026-01' -> 1, '62' -> 62.
+    Combined / concatenated numbers ('41/46', '5556') return None so they never pass for a single invoice."""
+    toks = [t for t in re.split(r"\D+", str(number or "")) if t]
+    if not toks:
+        return None
+    if len(toks) == 1:                                               # bare '25' / glued 'YYYYNN' / 'YYNN'
+        s = toks[0]
+        if s == year:
+            return None                                              # a bare 4-digit year is not a sequence
+        if year and s.startswith(year) and len(s) > len(year):
+            s = s[len(year):]                                        # 'YYYYNN'
+        elif year and s.startswith(year[2:]) and len(s) > 2:
+            s = s[2:]                                                # 'YYNN'
+        # else keep s verbatim: a bare sequence ('25','62') even when it equals the 2-digit year (invoice #25 in 2025)
+    else:                                                            # PREFIX-SEQ / SEQ-YEAR: drop ONE year token
+        non_year = list(toks)
+        for yt in (year, year[2:]):
+            if yt in non_year:
+                non_year.remove(yt)
+                break
+        if len(non_year) != 1:
+            return None                                              # combined ('41','46') -> no single sequence
+        s = non_year[0]
+    s = s.lstrip("0") or s
+    return int(s) if s.isdigit() and len(s) <= 3 else None
+
+
+def invoice_year(number):
+    """The 4-digit year an invoice number encodes: '2025-46'->'2025', '25-46'/'26-01'->20YY, else None. A
+    New-Year invoice dated in January can still carry the old year's number; this is that year."""
+    s = str(number or "")
+    m = re.search(r"(?:19|20)\d\d", s)
+    if m:
+        return m.group(0)
+    m = re.match(r"\s*(\d{2})\D", s)                      # 'YY-NN' 2-digit prefix
+    return "20" + m.group(1) if m else None
diff --git a/app/pdf.py b/app/pdf.py
new file mode 100644
index 0000000..c1b63cf
--- /dev/null
+++ b/app/pdf.py
@@ -0,0 +1,25 @@
+"""Render invoice HTML to PDF with a headless Chromium-family browser through Playwright.
+
+PDF_BROWSER picks the browser: an installed `msedge` (default) or `chrome`, or `chromium` — Playwright's own
+build, after `playwright install chromium`."""
+from playwright.sync_api import sync_playwright
+
+from app import config
+
+BROWSER = config.get("PDF_BROWSER", "msedge")
+
+
+def render(html):
+    """The A4 PDF of a full-bleed HTML page, as bytes."""
+    with sync_playwright() as p:
+        browser = p.chromium.launch(channel=BROWSER)
+        try:
+            page = browser.new_page()
+            page.set_content(html, wait_until="load")
+            # Full-bleed: the template's @page/.sheet own every margin, so the sheet maps 1:1 to the A4 page
+            # and the address can be placed by physical millimetres (window-envelope position). Any margin
+            # here would re-inset (and scale) the 210mm sheet and throw those millimetres off.
+            return page.pdf(format="A4", print_background=True, prefer_css_page_size=True,
+                            margin={"top": "0", "bottom": "0", "left": "0", "right": "0"})
+        finally:
+            browser.close()
diff --git a/app/plan.py b/app/plan.py
new file mode 100644
index 0000000..1ab294b
--- /dev/null
+++ b/app/plan.py
@@ -0,0 +1,128 @@
+"""Belegungsplan: a rooms × days occupancy timeline built from the guest register (the house's
+who-is-present record; the ledger is billing and stays out of this).
+
+Date semantics are half-open [arrival, departure): the departure day itself is free — it is the
+'Von' of the follow-up row when a weekly renter is carried forward, so the bars tile without
+overlapping. An open departure means "still here" only while the arrival is recent; an open stay
+older than a year is a forgotten departure (same 365-day rule as the TVB Meldung) and is left to
+the Datenprüfung instead of blocking a room forever.
+"""
+import datetime
+
+from app import db, i18n
+
+FAR = "9999-12-31"
+STALE_AFTER_DAYS = 365   # keep in sync with tvb.STALE_AFTER_DAYS
+MONTHS = i18n.t("months")
+MONTHS_SHORT = i18n.t("months_short")
+WEEKDAYS = i18n.t("weekdays_short")
+
+
+def default_start(today=None):
+    """Monday of last week — a little context behind, most of the window ahead."""
+    today = today or datetime.date.today()
+    return today - datetime.timedelta(days=today.weekday() + 7)
+
+
+def _pack_lanes(stays):
+    """Greedy interval packing: each stay goes into the first lane free at its arrival, so
+    concurrent occupants of a room stack while back-to-back ones share a line."""
+    lane_ends, out = [], []
+    for st in stays:
+        dep = st["departure"] or FAR
+        for i, end in enumerate(lane_ends):
+            if end <= st["arrival"]:
+                lane_ends[i] = dep
+                out.append((st, i))
+                break
+        else:
+            lane_ends.append(dep)
+            out.append((st, len(lane_ends) - 1))
+    return out, max(len(lane_ends), 1)
+
+
+def build(conn, start, days, today=None):
+    today = today or datetime.date.today()
+    end = start + datetime.timedelta(days=days)
+    s_iso, e_iso, t_iso = start.isoformat(), end.isoformat(), today.isoformat()
+    fresh = (today - datetime.timedelta(days=STALE_AFTER_DAYS)).isoformat()
+
+    stays = db.rows(conn, """
+        SELECT s.id, s.room_id, s.arrival, s.departure, s.sheet_number,
+               COALESCE(TRIM(g.last_name || ' ' || COALESCE(g.first_name,'')), s.label) AS name,
+               cl.name AS employer
+        FROM stay s LEFT JOIN guest g ON g.id=s.guest_id
+        LEFT JOIN client cl ON cl.id=s.employer_client_id
+        WHERE s.source_sheet='guestsheet' AND s.arrival IS NOT NULL
+          AND s.arrival < ? AND COALESCE(s.departure, ?) > ?
+          AND (s.departure IS NOT NULL OR s.arrival >= ?)
+        ORDER BY s.arrival NULLS FIRST, COALESCE(s.departure, ?), s.id""",
+        (e_iso, FAR, s_iso, fresh, FAR))
+
+    per_room, unplaced = {}, []
+    for st in stays:
+        if st["room_id"] is None:
+            unplaced.append(dict(st))
+        else:
+            per_room.setdefault(st["room_id"], []).append(st)
+
+    # today's occupants per room, independent of the visible window
+    counts = {r[0]: r[1] for r in db.rows(conn, """
+        SELECT room_id, COUNT(*) FROM stay
+        WHERE source_sheet='guestsheet' AND room_id IS NOT NULL AND arrival IS NOT NULL
+          AND arrival <= ? AND COALESCE(departure, ?) > ?
+          AND (departure IS NOT NULL OR arrival >= ?)
+        GROUP BY room_id""", (t_iso, FAR, t_iso, fresh))}
+
+    rooms = []
+    for r in db.rows(conn, """SELECT r.id, r.number, r.category, r.capacity, r.long_term,
+                                     u.code AS unit FROM room r
+                              LEFT JOIN unit u ON u.id=r.unit_id ORDER BY r.number"""):
+        packed, lanes = _pack_lanes(per_room.get(r["id"], []))
+        bars = []
+        for st, lane in packed:
+            dep = st["departure"] or FAR
+            a, b = max(st["arrival"], s_iso), min(dep, e_iso)
+            c1 = (datetime.date.fromisoformat(a) - start).days + 1
+            c2 = max((datetime.date.fromisoformat(b) - start).days + 1, c1 + 1)
+            state = ("past" if st["departure"] and st["departure"] <= t_iso
+                     else "future" if st["arrival"] > t_iso else "current")
+            bars.append({
+                "stay_id": st["id"], "name": st["name"] or "?", "employer": st["employer"],
+                "sheet_number": st["sheet_number"], "arrival": st["arrival"],
+                "departure": st["departure"], "col": c1, "col_end": c2, "lane": lane + 1,
+                "state": state, "clip_start": st["arrival"] < s_iso, "clip_end": dep > e_iso,
+                "open_end": st["departure"] is None,
+            })
+        rooms.append({**dict(r), "bars": bars, "lanes": lanes,
+                      "today_count": counts.get(r["id"], 0), "floor": str(r["number"])[:1]})
+
+    day_list, months = [], []
+    for i in range(days):
+        d = start + datetime.timedelta(days=i)
+        day_list.append({"iso": d.isoformat(), "dom": d.day, "wd": WEEKDAYS[d.weekday()],
+                         "weekend": d.weekday() >= 5, "today": d == today,
+                         "monday": d.weekday() == 0, "month_start": d.day == 1,
+                         "label": f"{d.day:02d}.{d.month:02d}."})
+        m = f"{MONTHS[d.month - 1]} {d.year}"
+        if months and months[-1]["label"] == m:
+            months[-1]["span"] += 1
+        else:
+            months.append({"label": m, "short": MONTHS_SHORT[d.month - 1], "span": 1})
+    for m in months:
+        # pick a label that fits the span so it can't run into the next month's divider —
+        # 810px is the grid width at 200% display scaling, the narrowest supported case
+        est = m["span"] * 810 / days
+        m["text"] = m["label"] if est >= 95 else (m["short"] if est >= 40 else "")
+
+    live = [r for r in rooms if not r["long_term"]]
+    return {
+        "rooms": rooms, "days": day_list, "months": months, "n_days": days,
+        "start": start, "end": end, "today": today,
+        "last": (end - datetime.timedelta(days=1)).isoformat(),
+        "prev_start": (start - datetime.timedelta(days=7)).isoformat(),
+        "next_start": (start + datetime.timedelta(days=7)).isoformat(),
+        "guests_today": sum(r["today_count"] for r in rooms),
+        "free_beds": sum(max(0, (r["capacity"] or 0) - r["today_count"]) for r in live),
+        "unplaced": unplaced,
+    }
diff --git a/app/quality.py b/app/quality.py
new file mode 100644
index 0000000..43b0297
--- /dev/null
+++ b/app/quality.py
@@ -0,0 +1,309 @@
+"""Data-quality audit: surface what is missing or odd in the data, and suggest likely duplicates.
+
+Two kinds of findings, kept strictly apart:
+  * DATA GAPS — the data itself is incomplete or odd (missing dates, departure before arrival, money-less
+    rows, duplicate or year-mismatched invoice numbers, recipients without an address). These are
+    surfaced per row, never invented away; reviewed ones can be dismissed as correct-as-is.
+  * SUGGESTIONS — near-duplicate companies/guests (typo variants) offered for one-click manual merge;
+    only exact-normalized spellings are merged automatically.
+"""
+import re
+from difflib import SequenceMatcher
+
+from app import db, normalize
+
+# a company-name slice (legal form or personnel-industry activity word) has no business in a postal
+# address line — its presence means part of the NAME was typed into the ADDRESS. Deliberately narrow
+# (no 'OG'/'AG'/'KG' — those are Obergeschoss/real streets).
+_ADDR_NAME_RE = re.compile(
+    r"(g\.?m\.?b\.?h|gbmh|ges\.?m\.?b\.?h|gesmbh|e\.\s*u\.|personalmanagement|personalservice|"
+    r"personalbereitstellung|personaldienst|zeitarbeit|handelsges)", re.I)
+
+
+def _register_ledger_mismatches(conn):
+    """A guest's Gästeblatt An-/Abreise vs the ledger periods billed under exactly that name: where the
+    same name appears in both, the covered spans must agree — a mismatch means one of the two is wrong
+    (Gästeblatt 22.–23., Zimmerbelegung 22.–25.). Only exact name matches are compared, no fuzzy guessing;
+    room changes are bridged via the shared Gästeblatt number."""
+    ledger = db.rows(conn, """
+        SELECT s.label, c.period_from, c.period_to, rm.number AS room
+        FROM charge c JOIN stay s ON c.stay_id=s.id LEFT JOIN room rm ON s.room_id=rm.id
+        WHERE c.source_sheet='ledger' AND c.period_from IS NOT NULL AND c.period_to IS NOT NULL
+        ORDER BY c.id""")
+    by_name = {}                                    # 'muster max' -> segments (labels combine persons)
+    for r in ledger:
+        for token in (t.strip() for t in (r["label"] or "").split(",")):
+            if token:
+                by_name.setdefault(" ".join(token.lower().split()), []).append(r)
+
+    stays = db.rows(conn, """
+        SELECT s.guest_id, s.sheet_number, s.arrival, s.departure, rm.number AS room,
+               TRIM(g.last_name || ' ' || COALESCE(g.first_name, '')) AS name
+        FROM stay s JOIN guest g ON g.id=s.guest_id LEFT JOIN room rm ON s.room_id=rm.id
+        WHERE s.source_sheet='guestsheet' AND s.arrival IS NOT NULL
+        ORDER BY s.id""")
+    groups = {}                                     # one Gästeblatt = one registration span (room changes)
+    for s in stays:
+        key = (s["guest_id"], s["sheet_number"]) if s["sheet_number"] else ("stay", id(s))
+        groups.setdefault(key, []).append(s)
+
+    out = []
+    for rows_ in groups.values():
+        first = min(rows_, key=lambda r: r["arrival"])
+        arrival = first["arrival"]
+        deps = [r["departure"] for r in rows_]
+        if any(d is None for d in deps):            # still in the house — no final span to compare yet
+            continue
+        departure = max(deps)
+        segs = sorted((x for x in by_name.get(" ".join(first["name"].lower().split()), ())
+                       if x["period_from"] <= departure and x["period_to"] >= arrival),
+                      key=lambda x: x["period_from"])
+        if not segs:                                # name never billed in this window — nothing to compare
+            continue
+        led_from, led_to = min(x["period_from"] for x in segs), max(x["period_to"] for x in segs)
+        if (led_from, led_to) != (arrival, departure):
+            out.append({"sheet_number": first["sheet_number"], "room": first["room"], "name": first["name"],
+                        "arrival": arrival, "departure": departure,
+                        "ledger_from": led_from, "ledger_to": led_to})
+    out.sort(key=lambda r: r["arrival"], reverse=True)
+    return out
+
+
+def dismissed(conn, kind):
+    """Keys of findings reviewed and locked in as correct-as-is (natural keys, not row ids)."""
+    return {r[0] for r in db.rows(conn, "SELECT key FROM dismissed_finding WHERE kind=?", (kind,))}
+
+
+def dismiss(conn, kind, key, note=None):
+    db.execute(conn, "INSERT INTO dismissed_finding (kind, key, note) VALUES (?,?,?) ON CONFLICT DO NOTHING",
+               (kind, key, note))
+
+
+def _keyed(rows_, kind, keyfn, done):
+    """Attach the dismiss key to each finding and hide the already-reviewed ones."""
+    out = []
+    for r in rows_:
+        r["_kind"], r["_key"] = kind, keyfn(r)
+        if r["_key"] not in done:
+            out.append(r)
+    return out
+
+
+def data_gaps(conn):
+    """Oddities in the data, surfaced per row (the tool never invents data)."""
+    def rows(sql, params=()):
+        return [dict(r) for r in db.rows(conn, sql, params)]
+    gaps = {}
+    gaps["register_ledger_mismatch"] = _keyed(
+        _register_ledger_mismatches(conn), "register_ledger",
+        lambda r: f"{r['sheet_number']}|{r['name']}|{r['arrival']}",
+        dismissed(conn, "register_ledger"))
+    gaps["register_no_departure"] = rows("""
+        SELECT s.id AS stay_id, g.last_name || ' ' || COALESCE(g.first_name,'') AS name, s.arrival
+        FROM stay s LEFT JOIN guest g ON g.id=s.guest_id
+        WHERE s.source_sheet='guestsheet' AND s.departure IS NULL ORDER BY s.arrival DESC NULLS LAST, s.id""")
+    # an open guest-register stay older than a year is a forgotten departure; the TVB Sammelmeldung
+    # page skips such rows silently, so they must stay visible here until the date is filled in
+    gaps["tvb_stale_open"] = rows("""
+        SELECT s.id AS stay_id, rm.number AS room, COALESCE(TRIM(g.last_name || ' ' ||
+               COALESCE(g.first_name,'')), s.label) AS name, s.arrival, s.sheet_number
+        FROM stay s LEFT JOIN guest g ON g.id=s.guest_id LEFT JOIN room rm ON s.room_id=rm.id
+        WHERE s.source_sheet='guestsheet' AND s.departure IS NULL AND s.arrival < to_char(CURRENT_DATE - interval '1 year', 'YYYY-MM-DD')
+        ORDER BY s.arrival NULLS FIRST, s.id""")
+    # ledger rows keep their period on the charge only — the backwards-period check looks at stays for the
+    # register and at charges for the ledger. Dismissable: Storno/Korrektur rows legitimately carry
+    # reversed dates.
+    gaps["depart_before_arrival"] = _keyed(rows("""
+        SELECT s.id AS stay_id, s.source_sheet, COALESCE(g.last_name || ' ' || COALESCE(g.first_name,''),
+               s.label) AS name, s.arrival, s.departure
+        FROM stay s LEFT JOIN guest g ON g.id=s.guest_id
+        WHERE s.arrival IS NOT NULL AND s.departure IS NOT NULL AND s.departure < s.arrival
+        ORDER BY s.id""") + rows("""
+        SELECT c.id AS stay_id, 'ledger' AS source_sheet, s.label AS name,
+               c.period_from AS arrival, c.period_to AS departure
+        FROM charge c JOIN stay s ON s.id=c.stay_id
+        WHERE c.source_sheet='ledger' AND c.period_from IS NOT NULL AND c.period_to IS NOT NULL
+          AND c.period_to < c.period_from
+        ORDER BY c.id"""),
+        "backwards_period", lambda r: f"{r['name']}|{r['arrival']}|{r['departure']}",
+        dismissed(conn, "backwards_period"))
+    # the ledger's GB column must point at a Gästeblatt that actually exists. Multi-person rows write
+    # consecutive sheets in shorthand — '816, 827', '277f' (and following), '300-1', '304 305', and
+    # concatenated pairs ('23435' = 234+235, '1992' = 199+200) — a ref only counts as unknown if NO reading
+    # resolves to an existing sheet
+    gb_known = {str(r[0]).strip() for r in db.rows(conn,
+        "SELECT DISTINCT sheet_number FROM stay WHERE source_sheet='guestsheet' AND sheet_number IS NOT NULL")}
+
+    def gb_resolves(token):
+        t = token.strip().rstrip("fF")           # '277f'/'285ff' -> the base sheet starts the run
+        if not t or t in gb_known:
+            return True
+        if "-" in t:                             # '300-1' -> the range starts at 300
+            return t.split("-")[0].strip() in gb_known
+        if t.isdigit() and len(t) >= 4:          # concatenated consecutives: a known 2-3 digit prefix
+            return any(t[:n] in gb_known and len(t) - n <= n for n in (3, 2))
+        return False
+
+    gaps["gb_ref_unknown"] = _keyed([
+        {**r, "missing": ", ".join(t for t in re.split(r"[,.\s]+", str(r["gb_ref"])) if t and not gb_resolves(t))}
+        for r in rows("""SELECT c.id AS charge_id, rm.number AS room, s.label AS name, c.period_from, c.gb_ref
+                         FROM charge c JOIN stay s ON c.stay_id=s.id LEFT JOIN room rm ON s.room_id=rm.id
+                         WHERE c.source_sheet='ledger' AND c.gb_ref IS NOT NULL ORDER BY c.id""")
+        if any(t and not gb_resolves(t) for t in re.split(r"[,.\s]+", str(r["gb_ref"])))],
+        "gb_ref_unknown", lambda r: f"{r['room']}|{r['name']}|{r['period_from']}|{r['gb_ref']}",
+        dismissed(conn, "gb_ref_unknown"))
+    # a CLOSED register stay whose guest never shows up in any ledger billing: either the stay was
+    # never charged (lost revenue) or the two lists spell the name differently — both worth seeing
+    ledger_tokens = set()
+    for r in db.rows(conn, "SELECT DISTINCT lower(label) l FROM stay "
+                           "WHERE source_sheet='ledger' AND label IS NOT NULL"):
+        for tok in r["l"].split(","):
+            tok = " ".join(tok.split())
+            if len(tok) > 4:
+                ledger_tokens.add(tok)
+
+    def billed(name):
+        n = " ".join(name.lower().split())
+        if any(n in t or t in n for t in ledger_tokens):
+            return True
+        last = n.split()[0]
+        return len(last) > 3 and any(last in t for t in ledger_tokens)
+
+    gaps["register_never_billed"] = _keyed(
+        [r for r in rows("""SELECT s.id AS stay_id, s.sheet_number, rm.number AS room,
+                                   TRIM(g.last_name || ' ' || COALESCE(g.first_name,'')) AS name,
+                                   s.arrival, s.departure
+                            FROM stay s JOIN guest g ON g.id=s.guest_id
+                            LEFT JOIN room rm ON rm.id=s.room_id
+                            WHERE s.source_sheet='guestsheet' AND s.departure IS NOT NULL
+                            ORDER BY s.arrival DESC NULLS LAST, s.id""") if not billed(r["name"])],
+        "never_billed", lambda r: f"{r['sheet_number']}|{r['name']}|{r['arrival']}",
+        dismissed(conn, "never_billed"))
+    # Betrag matches NEITHER Anzahl x Satz NOR Anzahl x Satz x Personen: a possible typo in one of
+    # the three numbers (legitimate discounts exist — hence reviewable, not an error)
+    gaps["betrag_off_formula"] = _keyed(
+        [dict(r, calc=round(r["quantity"] * r["gross_per_unit"] * (r["persons"] or 1), 2))
+         for r in rows("""SELECT c.id AS charge_id, rm.number AS room, s.label AS name, c.period_from,
+                                 c.quantity, c.gross_per_unit, c.persons,
+                                 ROUND((c.line_net_override*1.1)::numeric, 2)::float8 AS betrag
+                          FROM charge c JOIN stay s ON s.id=c.stay_id LEFT JOIN room rm ON rm.id=s.room_id
+                          WHERE c.source_sheet='ledger' AND c.quantity IS NOT NULL
+                            AND c.gross_per_unit IS NOT NULL AND c.line_net_override IS NOT NULL
+                          ORDER BY c.period_from DESC NULLS LAST, c.id""")
+         if abs(r["quantity"] * r["gross_per_unit"] - r["betrag"]) > 1.0
+         and abs(r["quantity"] * r["gross_per_unit"] * (r["persons"] or 1) - r["betrag"]) > 1.0],
+        "betrag_formula", lambda r: f"{r['room']}|{r['name']}|{r['period_from']}|{r['betrag']}",
+        dismissed(conn, "betrag_formula"))
+    gaps["charges_without_money"] = rows("""
+        SELECT c.id AS charge_id, rm.number AS room, s.label AS name, c.period_from, c.period_to
+        FROM charge c JOIN stay s ON c.stay_id=s.id LEFT JOIN room rm ON s.room_id=rm.id
+        WHERE c.source_sheet='ledger' AND c.gross_per_unit IS NULL AND c.line_net_override IS NULL
+        ORDER BY c.id""")
+    # a company that is billed or worked for but has no postal address anywhere: an invoice to it would
+    # print half a recipient block (short 'Zlg. durch' spellings create such companies). Payment channels
+    # are not recipients and never count.
+    gaps["client_without_address"] = _keyed(rows("""
+        SELECT * FROM (
+            SELECT co.id AS company_id, co.name, COALESCE(paying.n, 0) AS as_payer,
+                   (SELECT COUNT(*) FROM stay s JOIN client c2 ON c2.id=s.employer_client_id
+                     WHERE c2.company_id=co.id) AS as_employer
+            FROM company co
+            -- payers counted once, not per company: one scan of charge instead of one per company
+            LEFT JOIN (SELECT lower(TRIM(payer)) AS payer, COUNT(*) AS n FROM charge GROUP BY 1) paying
+                   ON paying.payer = lower(co.name)
+            WHERE NOT EXISTS (SELECT 1 FROM client cl WHERE cl.company_id=co.id
+                              AND COALESCE(cl.address,'') <> '')
+              AND lower(co.name) NOT IN ('bar','bank')) counted
+        WHERE as_payer > 0 OR as_employer > 0
+        ORDER BY as_payer + as_employer DESC, company_id"""),
+        "client_without_address", lambda r: r["name"], dismissed(conn, "client_without_address"))
+    # a recipient whose ADDRESS line carries a slice of the company NAME — it would print wrong on every
+    # invoice to that client. Reviewable, not invented.
+    gaps["address_has_name"] = _keyed(
+        [dict(r) for r in rows("""SELECT cl.id AS client_id, co.name AS company, cl.name, cl.address,
+                                         cl.postcode, cl.city
+                                  FROM client cl LEFT JOIN company co ON cl.company_id=co.id
+                                  WHERE cl.address IS NOT NULL AND TRIM(cl.address) <> ''
+                                  ORDER BY cl.id""")
+         if _ADDR_NAME_RE.search(r["address"])],
+        "address_has_name", lambda r: f"{r['client_id']}|{r['address']}",
+        dismissed(conn, "address_has_name"))
+    # a negative or absurdly large quantity (a 'bis' before the 'von', a typo) poisons every sum in the grid
+    gaps["implausible_quantities"] = _keyed(rows("""
+        SELECT c.id AS charge_id, rm.number AS room, s.label AS name, c.period_from, c.period_to,
+               c.quantity, ROUND(COALESCE(c.line_net_override * 1.1,
+                                          c.quantity * c.gross_per_unit)::numeric, 2)::float8 AS amount
+        FROM charge c JOIN stay s ON c.stay_id=s.id LEFT JOIN room rm ON s.room_id=rm.id
+        WHERE c.source_sheet='ledger' AND (c.quantity < 0 OR c.quantity > 500
+           OR COALESCE(c.line_net_override * 1.1, c.quantity * c.gross_per_unit) < 0)
+        ORDER BY c.id"""),
+        "implausible_qty", lambda r: f"{r['room']}|{r['name']}|{r['period_from']}|{r['amount']}",
+        dismissed(conn, "implausible_qty"))
+    # an RNr typed into the ledger that no invoice answers to: a typo, or an invoice not entered yet
+    gaps["rnr_unlinked"] = rows("""
+        SELECT c.id AS charge_id, rm.number AS room, s.label AS name, c.period_from, c.rnr
+        FROM charge c JOIN stay s ON c.stay_id=s.id LEFT JOIN room rm ON s.room_id=rm.id
+        WHERE c.source_sheet='ledger' AND c.invoice_id IS NULL
+          AND c.rnr IS NOT NULL AND c.rnr <> '-----'
+        ORDER BY c.id""")
+    gaps["open_items"] = rows("""
+        SELECT c.id AS charge_id, rm.number AS room, s.label AS name, c.period_from,
+               ROUND((c.line_net_override * 1.1)::numeric, 2)::float8 AS amount
+        FROM charge c JOIN stay s ON c.stay_id=s.id LEFT JOIN room rm ON s.room_id=rm.id
+        WHERE c.paid_status='open' ORDER BY c.period_from NULLS FIRST, c.id""")
+    gaps["duplicate_invoice_numbers"] = _keyed(rows("""
+        SELECT u.code AS unit, i.number, COUNT(*) AS n, string_agg(i.id::text, ',' ORDER BY i.id) AS ids
+        FROM invoice i JOIN unit u ON u.id=i.unit_id
+        GROUP BY u.code, i.number HAVING COUNT(*) > 1 ORDER BY i.number NULLS FIRST, u.code"""),
+        "duplicate_number", lambda r: f"{r['unit']}|{r['number']}", dismissed(conn, "duplicate_number"))
+    # numbers can carry the year 4-digit ('7-2016'), or 2-digit-coded ('1803' = 2018 seq 03,
+    # '25-46') — only a number that matches NEITHER reading of its invoice date is a mismatch
+    gaps["number_year_mismatch"] = _keyed(rows("""
+        SELECT i.id, u.code AS unit, i.number, i.date FROM invoice i JOIN unit u ON u.id=i.unit_id
+        WHERE i.date IS NOT NULL AND i.number ~ '[0-9]{4}'
+          AND NOT i.number LIKE '%' || substr(i.date, 1, 4) || '%'
+          AND NOT i.number ~ ('^' || substr(i.date, 3, 2) || '[0-9][0-9]$')
+          AND NOT i.number ~ ('^' || substr(i.date, 3, 2) || '[- ]')
+        ORDER BY i.date, i.id"""),
+        "number_year", lambda r: f"{r['unit']}|{r['number']}|{r['date']}", dismissed(conn, "number_year"))
+    return gaps
+
+
+def _fuzzy_pairs(items, threshold=0.87, prefix=4):
+    """(id, key, label) triples -> near-duplicate pairs by key similarity. The shared-prefix guard keeps
+    the company comparison cheap (hundreds of names); tiny same-birthday guest groups compare unguarded."""
+    out = []
+    items = sorted(items, key=lambda x: x[1])
+    for i in range(len(items)):
+        for j in range(i + 1, len(items)):
+            a, b = items[i], items[j]
+            if prefix and a[1][:prefix] != b[1][:prefix]:
+                continue
+            if SequenceMatcher(None, a[1], b[1]).ratio() > threshold:
+                out.append({"a_id": a[0], "a": a[2], "b_id": b[0], "b": b[2]})
+    return out
+
+
+def suggestions(conn):
+    comps = [(r["id"], normalize.company_key(r["name"]), r["name"])
+             for r in db.rows(conn, "SELECT id, name FROM company ORDER BY id")]
+    companies = _fuzzy_pairs([c for c in comps if c[1]])
+
+    guests = []
+    by_birth = {}
+    for r in db.rows(conn, "SELECT id, last_name, first_name, birth_date FROM guest "
+                           "WHERE birth_date IS NOT NULL ORDER BY id"):
+        label = f"{r['last_name']} {r['first_name'] or ''}".strip()
+        by_birth.setdefault(r["birth_date"], []).append((r["id"], label.lower(), f"{label} ({r['birth_date']})"))
+    for birth, people in by_birth.items():
+        if len(people) > 1:
+            guests += _fuzzy_pairs(people, threshold=0.75, prefix=0)
+    # pairs reviewed as "genuinely different" stay dismissed (keyed by labels, not ids)
+    pair_key = lambda p: "|".join(sorted([p["a"].lower(), p["b"].lower()]))  # noqa: E731
+    companies = _keyed(companies, "company_pair", pair_key, dismissed(conn, "company_pair"))
+    guests = _keyed(guests, "guest_pair", pair_key, dismissed(conn, "guest_pair"))
+    return {"companies": companies, "guests": guests}
+
+
+def overview(conn):
+    return {"gaps": data_gaps(conn), "suggestions": suggestions(conn)}
diff --git a/app/repo.py b/app/repo.py
new file mode 100644
index 0000000..3840c8c
--- /dev/null
+++ b/app/repo.py
@@ -0,0 +1,1499 @@
+"""Service layer: all reads/writes for the app, callable by the web routes and by scripts alike.
+Keeps SQL in one place (with db.py). Returns plain dicts with a few computed display fields added.
+"""
+import re
+from collections import Counter
+
+from app import db, compute, normalize
+
+
+def _dicts(rows):
+    return [dict(r) for r in rows]
+
+
+# --- home ---
+def stats(conn):
+    n = lambda sql: db.row(conn, sql)[0]  # noqa: E731
+    return {
+        "guests": n("SELECT COUNT(*) FROM guest"),
+        "stays": n("SELECT COUNT(*) FROM stay"),
+        "invoices": n("SELECT COUNT(*) FROM invoice"),
+        "open": n("SELECT COUNT(*) FROM charge WHERE paid_status='open'"),
+    }
+
+
+# --- lookups for forms ---
+def units(conn):
+    return _dicts(db.rows(conn, "SELECT id, code, name FROM unit WHERE is_current=1 ORDER BY code"))
+
+
+def rooms(conn):
+    return _dicts(db.rows(conn, "SELECT id, number, category, unit_id FROM room ORDER BY number"))
+
+
+def field_suggestions(conn):
+    """Distinct past values for form autosuggest (rendered as <datalist> options)."""
+    def vals(sql):
+        return [r[0] for r in db.rows(conn, sql) if r[0]]
+    return {
+        "nationality": vals("SELECT DISTINCT nationality FROM guest WHERE nationality<>'' ORDER BY nationality"),
+        "doc_type": vals("SELECT DISTINCT doc_type FROM guest WHERE doc_type<>'' ORDER BY doc_type"),
+        "profession": vals("SELECT DISTINCT profession FROM guest WHERE profession<>'' ORDER BY profession"),
+        "city": vals("SELECT DISTINCT home_city FROM guest WHERE home_city<>'' ORDER BY home_city"),
+        "country": vals("SELECT DISTINCT home_country FROM guest WHERE home_country<>'' ORDER BY home_country"),
+        # canonical company names only — variants resolve to the same company anyway
+        "client": vals("SELECT name FROM company ORDER BY name"),
+    }
+
+
+def lines_from_stays(conn, stay_ids):
+    """Pre-fill invoice lines from selected guest-register rows: worker + period + unit + employer→client;
+    the rate/quantity are left blank (not derivable from the guest sheet)."""
+    if not stay_ids:
+        return {"lines": [], "unit_id": None, "client": None}
+    ph = ",".join("?" * len(stay_ids))
+    rows = db.rows(conn, f"""
+        SELECT s.unit_id, cl.name AS employer, s.sheet_number,
+               TRIM(COALESCE(g.last_name || ' ' || COALESCE(g.first_name,''), s.label)) AS worker,
+               s.arrival, s.departure
+        FROM stay s LEFT JOIN guest g ON s.guest_id = g.id LEFT JOIN client cl ON s.employer_client_id = cl.id
+        WHERE s.id IN ({ph}) ORDER BY s.arrival NULLS FIRST, s.id""", list(stay_ids))
+    lines = [{"worker": r["worker"], "period_from": r["arrival"], "period_to": r["departure"],
+              "quantity": compute.weeks_for_period(r["arrival"], r["departure"]) or "",
+              "unit_type": "week", "gross_per_unit": "",
+              "tourism_tax": compute.tourism_for_period(r["arrival"], r["departure"]) or "", "kind": "stay"}
+             for r in rows]
+    employer = next((r["employer"] for r in rows if r["employer"]), None)
+    return {"lines": lines, "unit_id": rows[0]["unit_id"] if rows else None,
+            "client": billing_client_name(conn, employer,
+                                          " ".join(r["sheet_number"] or "" for r in rows)) if employer else None}
+
+
+def _ledger_run(conn, worker, day):
+    """(nights, still_running) of the guest's UNBROKEN presence covering `day`, stitched across month and
+    room boundaries from the ledger's week-segments. Drives the >10-night Ortstaxe exemption: a stay that
+    began in an earlier (separately billed) month is already exempt, so its short current slice carries no
+    tax either. A segment WITHOUT a 'bis' continues the run — the guest is still in the house, so the stay
+    can never be judged as short (billing the first week must not charge Ortstaxe while the guest stays
+    on). (None, False) when no run covers the day."""
+    if not worker or not day:
+        return None, False
+    rows = db.rows(conn,
+        "SELECT c.period_from AS pf, c.period_to AS pt FROM charge c JOIN stay s ON s.id = c.stay_id "
+        "WHERE s.source_sheet = 'ledger' AND c.period_from IS NOT NULL "
+        "AND s.label ILIKE '%' || ? || '%' ORDER BY c.period_from NULLS FIRST, c.id", (worker,))
+    runs = []
+    for r in rows:
+        end = r["pt"] or r["pf"]                     # an open segment carries no end yet
+        if runs and r["pf"] <= runs[-1][1]:          # segment touches the open run → extend it
+            runs[-1][1] = max(runs[-1][1], end)
+            runs[-1][2] = runs[-1][2] or r["pt"] is None
+        else:
+            runs.append([r["pf"], end, r["pt"] is None])
+    for a, b, running in runs:
+        if a <= day <= b:
+            return compute.days_between(a, b), running
+    return None, False
+
+
+def billing_client_name(conn, payer, gb_ref=None):
+    """The recipient name to pre-fill an invoice with — one that carries a FULL address.
+
+    The ledger's 'Zlg. durch' is often a short form ('Muster Personal'), and a short form that matches no
+    known spelling becomes a bare company with no address at all: the invoice then prints half a recipient
+    block. So the
+    payer is only used as-is when it resolves to an address version that HAS an address; otherwise the
+    employer recorded on the linked Gästeblätter answers, since that is where the postal address lives.
+    Never creates anything — this runs while only previewing an invoice."""
+    def with_address(company_id):
+        r = db.row(conn, """SELECT cl.name FROM company co JOIN client cl ON cl.id = co.current_client_id
+                            WHERE co.id=? AND COALESCE(cl.address,'') <> ''""", (company_id,))
+        if not r:
+            r = db.row(conn, "SELECT name FROM client WHERE company_id=? AND COALESCE(address,'') <> '' "
+                             "ORDER BY id DESC LIMIT 1", (company_id,))
+        return r["name"] if r else None
+
+    key = normalize.company_key(payer or "")
+    comp = (_company_for_key(conn, key) or _alias_company(conn, key)) if key else None
+    if comp is not None:
+        name = with_address(comp)
+        if name:
+            return name
+    for num in re.findall(r"\d+", gb_ref or ""):
+        r = db.row(conn, """SELECT cl.name FROM stay s JOIN client cl ON cl.id = s.employer_client_id
+                            WHERE s.source_sheet='guestsheet' AND s.sheet_number=?
+                              AND COALESCE(cl.address,'') <> '' ORDER BY s.id DESC LIMIT 1""", (num,))
+        if r:
+            return r["name"]
+    return payer
+
+
+def lines_from_charges(conn, charge_ids):
+    """Pre-fill invoice lines from selected Zimmerbelegung rows. The ledger bills per room × week-segment
+    with the persons combined ('Muster, Beispiel, Probe' · 2 Wochen); an invoice bills per PERSON — so
+    the names are split, each person's contiguous segments merge into ONE line with a continuous period
+    (quantities added), and a gap in between starts a new line. A 'Storno' row comes in as a
+    nicht-steuerbare storno line, a lump row (Betrag but no per-unit rate) as one 'total' line at the
+    Betrag. Unit follows the rooms; the client is taken from the payer ('Zlg. Durch') when present."""
+    if not charge_ids:
+        return {"lines": [], "unit_id": None, "client": None}
+    ph = ",".join("?" * len(charge_ids))
+    rows = db.rows(conn, f"""
+        SELECT c.period_from, c.period_to, c.quantity, c.unit_type, c.gross_per_unit, c.line_net_override,
+               c.persons, c.art, c.gb_ref, s.label AS occupant, s.unit_id,
+               COALESCE(c.payer, iv.payment_method) AS payer
+        FROM charge c JOIN stay s ON c.stay_id = s.id LEFT JOIN invoice iv ON c.invoice_id = iv.id
+        WHERE c.id IN ({ph}) ORDER BY c.period_from NULLS FIRST, c.id""", list(charge_ids))
+
+    def line(worker, period_from, period_to, quantity, unit_type, gross_per_unit, kind="stay"):
+        if quantity is not None and abs(quantity - round(quantity)) < 1e-9:
+            quantity = int(round(quantity))             # 5.0 -> 5 in the form
+        return {"worker": worker, "period_from": period_from, "period_to": period_to,
+                "quantity": quantity if quantity is not None else "", "unit_type": unit_type,
+                "gross_per_unit": gross_per_unit if gross_per_unit is not None else "",
+                "tourism_tax": "", "kind": kind}
+
+    specials, segments = [], []
+    for r in rows:
+        storno = is_storno(r)
+        gpu, qty, utype = r["gross_per_unit"], r["quantity"], r["unit_type"] or "week"
+        if not gpu and r["line_net_override"] is not None:   # lump row: bill the exact Betrag as one 'total' line
+            specials.append(line(r["occupant"], r["period_from"], r["period_to"],
+                                 qty or 1, "total", round(r["line_net_override"] * 1.1, 2)))
+        elif storno:
+            # invoice bills per PERSON: split the names, one storno line each at the room Satz. So a half-week
+            # storno in a DZ (2 Pers.) prints as TWO lines of 0,5 Woche × Satz (= Anz × Satz per line, honest),
+            # summing to 0,5 × Satz × 2 — the same total the ledger row carries.
+            names = [n.strip() for n in (r["occupant"] or "").split(",")
+                     if n.strip() and "storno" not in n.lower()]
+            workers = names or ["Stornogebühr"] * int(r["persons"] or 1)
+            for w in workers:
+                specials.append(line(w, r["period_from"], r["period_to"], qty, utype, gpu, "storno"))
+        else:
+            names = [n.strip() for n in (r["occupant"] or "").split(",") if n.strip()] or [r["occupant"]]
+            for name in names:                               # the row's Anz/Satz apply per person
+                segments.append({"worker": name, "period_from": r["period_from"], "period_to": r["period_to"],
+                                 "quantity": qty, "unit_type": utype, "gross_per_unit": gpu})
+    merged = []
+    for seg in sorted(segments, key=lambda x: ((x["worker"] or "").lower(), str(x["gross_per_unit"]),
+                                               x["period_from"] or "")):
+        last = merged[-1] if merged else None
+        contiguous = (last and last["worker"] == seg["worker"] and last["gross_per_unit"] == seg["gross_per_unit"]
+                      and last["unit_type"] == seg["unit_type"] and last["period_to"] and seg["period_from"]
+                      and seg["period_from"] <= last["period_to"])
+        if contiguous:                                       # same man, no break -> one continuous line
+            last["period_to"] = max(last["period_to"], seg["period_to"] or last["period_to"])
+            last["quantity"] = (last["quantity"] or 0) + (seg["quantity"] or 0)
+        else:
+            merged.append(dict(seg))
+    lines = specials + [line(**m) for m in merged]
+    for ln in lines:                                         # the billing rules on the final periods:
+        if ln["kind"] != "stay":
+            continue
+        if ln["unit_type"] == "week":                        # >= 4 nights -> whole weeks, rounded up
+            weeks = compute.weeks_for_period(ln["period_from"], ln["period_to"])
+            if weeks:
+                ln["quantity"] = weeks
+        # Ortstaxe on the WHOLE continuous stay, not just this month's slice: a worker already here last
+        # month is past the >10-night exemption, so a short slice of the stay this month carries no tax
+        # either — and a guest who has not left yet is not a short stay at all.
+        nights, still_running = _ledger_run(conn, ln["worker"], ln["period_from"])
+        ln["tourism_tax"] = "" if still_running else             (compute.tourism_amount(ln["period_from"], ln["period_to"], nights) or "")
+    lines.sort(key=lambda x: (x["period_from"] or "", (x["worker"] or "").lower()))
+    # suggest the payer as the client — resolved to the canonical company; payment CHANNELS are no client
+    payer = next((r["payer"] for r in rows if r["payer"]), None)
+    if payer and payer.strip().lower().split()[0] in ("bar", "bank"):
+        payer = None
+    gb_refs = " ".join(r["gb_ref"] or "" for r in rows)
+    return {"lines": lines, "unit_id": rows[0]["unit_id"] if rows else None,
+            "client": billing_client_name(conn, payer, gb_refs) if payer else None}
+
+
+def _company_for_key(conn, key):
+    r = db.row(conn, "SELECT company_id FROM company_key WHERE key=?", (key,))
+    return r[0] if r else None
+
+
+def _alias_company(conn, key):
+    """A short alias ('Alpenbau', 'Muster Personal' — as the ledger's 'Zlg. durch' writes them) resolves
+    to the ONE company whose registered spelling starts with it. Ambiguous or very short prefixes resolve
+    to nothing (a new name must not silently attach to the wrong company)."""
+    if not key or len(key) < 5:
+        return None
+    rows = db.rows(conn, "SELECT DISTINCT company_id FROM company_key WHERE key ILIKE ? ORDER BY company_id", (key + "%",))
+    return rows[0][0] if len(rows) == 1 else None
+
+
+def recipient_choices(conn, name):
+    """Read-only, before an invoice is saved to `name`: None when the name resolves, as
+    `find_or_create_client` resolves it, to an address version that carries an address. Otherwise the
+    invoice would print no recipient address (§11 UStG) — an unknown name even creates an empty company,
+    and a short name may fit several companies of one group. Then the companies the name may mean come
+    back instead, with their current address — those whose spelling starts with the whole name, else with
+    its first word ('Muster Bau' → 'Muster Bau GmbH' and 'Muster Bau Holding', not every 'Muster…'); []
+    when none."""
+    key = normalize.company_key(name or "")
+    comp_id = (_company_for_key(conn, key) or _alias_company(conn, key)) if key else None
+    if comp_id is not None and db.row(conn, """
+            SELECT 1 FROM client WHERE COALESCE(address,'') <> '' AND id = COALESCE(
+                (SELECT current_client_id FROM company WHERE id=?), (SELECT max(id) FROM client WHERE company_id=?))""",
+            (comp_id, comp_id)):
+        return None
+    words = (name or "").split()
+    for stem in (key, normalize.company_key(words[0]) if words else ""):
+        if len(stem) < 3:
+            continue
+        choices = [dict(r) for r in db.rows(conn, """
+            SELECT co.name, cl.address, cl.postcode, cl.city
+            FROM company co JOIN client cl ON cl.id = co.current_client_id
+            WHERE COALESCE(cl.address,'') <> '' AND co.id IN (SELECT company_id FROM company_key WHERE key LIKE ?)
+            ORDER BY co.name""", (stem + "%",))]
+        if choices:
+            return choices
+    return []
+
+
+def _new_company(conn, name, kind, key):
+    comp_id = db.execute(conn, "INSERT INTO company (name, kind) VALUES (?,?)", (name, kind))
+    db.execute(conn, "INSERT INTO company_key (key, company_id) VALUES (?,?)", (key, comp_id))
+    return comp_id
+
+
+def _new_client_version(conn, comp_id, name, kind, address=None, postcode=None, city=None, phone=None,
+                        make_current=True):
+    cid = db.execute(conn, "INSERT INTO client (kind, name, address, postcode, city, company_id) "
+                     "VALUES (?,?,?,?,?,?)", (kind, name, address, postcode, city, comp_id))
+    if phone:   # phone is a COMPANY attribute (single source) — versions only carry name + address
+        db.execute(conn, "UPDATE company SET phone=COALESCE(phone,?) WHERE id=?", (phone, comp_id))
+    if make_current:
+        db.execute(conn, "UPDATE company SET current_client_id=? WHERE id=?", (cid, comp_id))
+    return cid
+
+
+def find_or_create_client(conn, name, kind="company"):
+    """Resolve a typed name to a client row via the company registry: ANY known spelling of a company maps
+    to its current address version, so typing a variant never creates a duplicate. A new name creates a
+    company + its first version."""
+    name = (name or "").strip()
+    if not name:
+        return None
+    key = normalize.company_key(name)
+    if not key:   # punctuation-only garbage — fall back to a bare client row
+        existing = db.row(conn, "SELECT id FROM client WHERE lower(name)=lower(?) ORDER BY id", (name,))
+        return existing[0] if existing else db.execute(conn,
+            "INSERT INTO client (kind, name) VALUES (?, ?)", (kind, name))
+    comp_id = _company_for_key(conn, key)
+    if comp_id is None:
+        comp_id = _alias_company(conn, key)
+        if comp_id is not None:   # learn the alias so it keeps resolving (and survives consolidation)
+            db.execute(conn, "INSERT INTO company_key (key, company_id) VALUES (?,?)", (key, comp_id))
+    if comp_id is None:
+        comp_id = _new_company(conn, name, kind, key)
+        return _new_client_version(conn, comp_id, name, kind)
+    cur = db.row(conn, "SELECT current_client_id FROM company WHERE id=?", (comp_id,))
+    if cur and cur[0]:
+        return cur[0]
+    cl = db.row(conn, "SELECT id FROM client WHERE company_id=? ORDER BY id DESC LIMIT 1", (comp_id,))
+    if cl:
+        db.execute(conn, "UPDATE company SET current_client_id=? WHERE id=?", (cl[0], comp_id))
+        return cl[0]
+    return _new_client_version(conn, comp_id, name, kind)
+
+
+# --- guest register view ---
+def register_rows(conn, search=None):
+    sql = """
+        SELECT s.id AS stay_id, g.id AS guest_id, g.last_name, g.first_name, g.birth_date,
+               g.nationality, g.doc_type, g.doc_number, g.profession,
+               g.home_street, g.home_postcode, g.home_city, g.home_country, g.phone,
+               r.number AS room, u.code AS unit, cl.name AS employer,
+               -- the address version this stay was registered under; if that one carries no address
+               -- (a sheet may name only the firm), fall back to the company's current one — as a
+               -- BLOCK, never mixing a street from one version with the town of another
+               CASE WHEN cl.address IS NOT NULL THEN cl.address   ELSE cur.address   END AS employer_street,
+               CASE WHEN cl.address IS NOT NULL THEN cl.postcode  ELSE cur.postcode  END AS employer_postcode,
+               CASE WHEN cl.address IS NOT NULL THEN cl.city      ELSE cur.city      END AS employer_city,
+               s.arrival, s.departure, s.sheet_number, s.hauptwohnsitz, s.tourism_liable, s.notes
+        FROM stay s
+        LEFT JOIN guest g ON s.guest_id = g.id
+        LEFT JOIN room r ON s.room_id = r.id
+        LEFT JOIN unit u ON s.unit_id = u.id
+        LEFT JOIN client cl ON s.employer_client_id = cl.id
+        LEFT JOIN company co ON cl.company_id = co.id
+        LEFT JOIN client cur ON co.current_client_id = cur.id
+        WHERE s.source_sheet = 'guestsheet'
+    """
+    params = []
+    if search:
+        like = f"%{search}%"
+        sql += (" AND (g.last_name ILIKE ? OR g.first_name ILIKE ? OR cl.name ILIKE ? OR r.number = ?)")
+        params = [like, like, like, search]
+    sql += " ORDER BY s.id"   # entry order breaks ties in the sort below
+    out = _dicts(db.rows(conn, sql, params))
+    for row in out:
+        row["days"] = compute.days_between(row["arrival"], row["departure"])
+        # the employer's postal address as ONE grid column, in the order it is written on an envelope
+        town = " ".join(x for x in (row["employer_postcode"], row["employer_city"]) if x)
+        row["employer_address"] = ", ".join(x for x in (row["employer_street"], town) if x)
+    return _grouped_by_sheet_number(out)
+
+
+def _grouped_by_sheet_number(rows):
+    """Order the register by ARRIVAL, chronologically — a guest entered late must land at the arrival
+    date, not at the end of the list where the sheet happened to be typed.
+
+    Every row of ONE Gästeblatt stays together, directly under the first of that group: a room change
+    continues the same GB number, and the group travels with its earliest arrival. The group is
+    (unit, GB number, person) — the same number is reused in later years for a different guest, and those
+    must NOT be pulled together; a row without a number is its own group. Within a group: by arrival, and
+    equal dates keep the entry order.
+
+    The same grouping answers 'Abg' where the sheet leaves it empty: the Abgabe exemption counts the guest's
+    WHOLE continuous stay (T-AAG §4), so the first segment of a room change must not read as a short stay."""
+    def group(r):
+        return (r["unit"], r["sheet_number"], r["guest_id"]) if r["sheet_number"] else ("", "", r["stay_id"])
+    first, span = {}, {}
+    for r in rows:
+        g = group(r)
+        # the group sorts by its earliest arrival; the row id only breaks ties (= the entry order)
+        stamp = (r["arrival"] or "", r["stay_id"])
+        first[g] = min(first[g], stamp) if g in first else stamp
+        arr, dep, open_end = span.get(g, (r["arrival"], r["departure"], False))
+        span[g] = (min(x for x in (arr, r["arrival"]) if x) if (arr or r["arrival"]) else None,
+                   max((x for x in (dep, r["departure"]) if x), default=None),
+                   open_end or r["departure"] is None)
+    for r in rows:
+        if r["tourism_liable"] is None:
+            arr, dep, open_end = span[group(r)]
+            liable = compute.tourism_liable(arr, dep)
+            # still running: certain only once the stay has already passed the exempt length
+            r["tourism_liable"] = None if open_end and liable != 0 else liable
+    return sorted(rows, key=lambda r: (first[group(r)], r["arrival"] or "", r["stay_id"]))
+
+
+# --- room ledger view ---
+def _payment(row):
+    """Is a Zimmerbelegung row paid ('paid' / 'cash' / 'open' / 'unknown'), and on which day?
+
+    The status picked in the row goes before its date: a part payment carries both (175,00 paid, the
+    16,00 Ortstaxe still open). A paid INVOICE pays its rows too — the payment is often recorded on the
+    invoice only — but only where the row itself says nothing, or a part payment would suddenly read as
+    settled. An empty cell on a billed row IS open; without an invoice number nothing is due yet."""
+    status = row["paid_status"]
+    payment = ("open" if status == "open"
+               else "paid" if status == "paid" or (not status and row["paid_date"])
+               else "cash" if status == "cash"
+               else "paid" if not status and row["invoice_paid_date"]
+               else "open" if row["invoice_no"] else "unknown")
+    return payment, row["paid_date"] or (row["invoice_paid_date"] if payment == "paid" else None)
+
+
+def is_storno(row):
+    """A Storno row says so in the name ('Stornogebühr Muster') or the Art. It is nicht steuerbarer
+    Schadenersatz: invoiced without USt, and outside the USt-Voranmeldung's base."""
+    return "storno" in ((row["occupant"] or "") + " " + (row["art"] or "")).lower()
+
+
+def ledger_rows(conn, room=None, search=None):
+    sql = """
+        SELECT c.id AS charge_id, s.id AS stay_id, r.number AS room, u.code AS unit,
+               COALESCE(g.last_name || ' ' || COALESCE(g.first_name,''), s.label) AS occupant,
+               c.period_from, c.period_to, c.gb_ref, c.persons, c.quantity, c.unit_type,
+               c.gross_per_unit, c.art, c.notes, c.tourism_tax, COALESCE(c.payer, i.payment_method) AS payer,
+               c.line_net_override, c.paid_status, c.paid_date,
+               COALESCE(c.rnr, i.number) AS invoice_no, i.id AS invoice_id, i.date AS invoice_date,
+               -- a paid invoice pays its rows too: a payment recorded on the invoice must show in the
+               -- Zimmerbelegung
+               i.paid_date AS invoice_paid_date
+        FROM charge c
+        JOIN stay s ON c.stay_id = s.id
+        LEFT JOIN room r ON s.room_id = r.id
+        LEFT JOIN unit u ON s.unit_id = u.id
+        LEFT JOIN guest g ON s.guest_id = g.id
+        LEFT JOIN invoice i ON c.invoice_id = i.id
+        WHERE s.source_sheet = 'ledger'
+    """
+    params = []
+    if room:
+        sql += " AND r.number = ?"
+        params.append(room)
+    if search:
+        like = f"%{search}%"
+        sql += " AND (COALESCE(g.last_name,'') ILIKE ? OR s.label ILIKE ? OR i.number ILIKE ?)"
+        params += [like, like, like]
+    sql += " ORDER BY c.id"   # entry order breaks ties in the sort below
+    out = _dicts(db.rows(conn, sql, params))
+    payments = {}
+    for p in db.rows(conn, "SELECT charge_id, paid_date, amount FROM payment ORDER BY paid_date, id"):
+        payments.setdefault(p["charge_id"], []).append((p["paid_date"], p["amount"]))
+    when, last = {}, {}
+    for row in out:
+        # the first date the row shows: its Von — but a long-term tenant's monthly rent may carry only a
+        # 'bis', or only the date the rent was paid
+        row["first_date"] = row["period_from"] or row["period_to"] or row["paid_date"]
+        # a row without any date stays behind the row entered before it in the same room
+        when[row["charge_id"]] = last[row["room"]] = row["first_date"] or last.get(row["room"], "")
+        # the ledger bills a row for EVERYONE in it: Betrag = Anz × Satz × Personen (2 Pers. × 1 Woche ×
+        # 161 = 322). A Betrag typed into the row always wins; only a row without one is computed, and then
+        # the person count belongs in it — otherwise the list shows half the money.
+        row["amount"] = compute.line_gross((row["quantity"] or 0) * (row["persons"] or 1),
+                                           row["gross_per_unit"] or 0, row["line_net_override"])
+        row["days"] = compute.days_between(row["period_from"], row["period_to"])
+        # part payment: what is still owed of Betrag + Ortstaxe (175 of 191 paid: 16 open)
+        row["payments"] = payments.get(row["charge_id"], [])
+        row["paid_amount"] = round(sum(a for _, a in row["payments"]), 2) if row["payments"] else None
+        row["total"] = round(row["amount"] + (row["tourism_tax"] or 0), 2)
+        row["open_amount"] = (round(row["total"] - row["paid_amount"], 2)
+                              if row["paid_amount"] is not None and row["paid_amount"] + 0.005 < row["total"]
+                              else None)
+        row["payment"], row["paid_on"] = _payment(row)
+    # Chronologically, earliest date first: in entry order a booking typed in advance would sit between
+    # unrelated months. One day's rows go by room, and within a room the entry order stands.
+    return sorted(out, key=lambda r: (when[r["charge_id"]], r["room"] or "", r["charge_id"]))
+
+
+# --- stay CRUD (guest register) ---
+def get_stay(conn, stay_id):
+    r = db.row(conn, "SELECT * FROM stay WHERE id=?", (stay_id,))
+    if not r:
+        return None
+    stay = dict(r)
+    stay["guest"] = {}
+    if stay["guest_id"]:
+        stay["guest"] = dict(db.row(conn, "SELECT * FROM guest WHERE id=?", (stay["guest_id"],)))
+    stay["employer_name"] = ""
+    if stay["employer_client_id"]:
+        c = db.row(conn, "SELECT name FROM client WHERE id=?", (stay["employer_client_id"],))
+        stay["employer_name"] = c[0] if c else ""
+    if stay["tourism_liable"] is None:      # pre-select the rule's answer, so saving the form records it
+        # over the guest's WHOLE stay under this Gästeblatt number, room changes included
+        sp = db.row(conn, "SELECT MIN(arrival) a, MAX(departure) d, SUM((departure IS NULL)::int) open_end "
+                          "FROM stay WHERE source_sheet='guestsheet' AND guest_id IS NOT DISTINCT FROM ? "
+                          "AND COALESCE(sheet_number,'')=COALESCE(?,'')",
+                    (stay["guest_id"], stay["sheet_number"]))
+        liable = compute.tourism_liable(sp["a"], sp["d"])
+        stay["tourism_liable"] = None if sp["open_end"] and liable != 0 else liable
+    return stay
+
+
+def find_or_create_guest(conn, last_name, first_name, **fields):
+    """Reuse a guest only on an exact person match (name + birth date); otherwise a distinct person with the
+    same name must not be merged. Never updates an existing guest — use update_guest for edits."""
+    existing = db.row(conn,
+        "SELECT id FROM guest WHERE lower(last_name)=lower(?) AND lower(COALESCE(first_name,''))=lower(?) "
+        "AND COALESCE(birth_date,'')=COALESCE(?,'') ORDER BY id",
+        (last_name, first_name or "", fields.get("birth_date")))
+    if existing:
+        return existing[0]
+    cols = ["last_name", "first_name"] + list(fields.keys())
+    vals = [last_name, first_name] + list(fields.values())
+    ph = ",".join("?" * len(cols))
+    return db.execute(conn, f"INSERT INTO guest ({','.join(cols)}) VALUES ({ph})", vals)
+
+
+def merge_guests(conn, keep_id, merge_id):
+    """Two guest rows that are the same person (typo variants): move the stays, drop the duplicate.
+    Master fields of the surviving guest win; missing ones are filled from the merged row."""
+    if keep_id == merge_id:
+        return
+    keep = db.row(conn, "SELECT * FROM guest WHERE id=?", (keep_id,))
+    merged = db.row(conn, "SELECT * FROM guest WHERE id=?", (merge_id,))
+    if not keep or not merged:
+        return
+    for col in keep.keys():
+        if col != "id" and keep[col] in (None, "") and merged[col] not in (None, ""):
+            db.execute(conn, f"UPDATE guest SET {col}=? WHERE id=?", (merged[col], keep_id))
+    db.execute(conn, "UPDATE stay SET guest_id=? WHERE guest_id=?", (keep_id, merge_id))
+    db.execute(conn, "DELETE FROM guest WHERE id=?", (merge_id,))
+
+
+def update_guest(conn, guest_id, **fields):
+    cols = ", ".join(f"{k}=?" for k in fields)
+    db.execute(conn, f"UPDATE guest SET {cols} WHERE id=?", list(fields.values()) + [guest_id])
+
+
+def save_stay(conn, stay_id, guest_id, room_id, unit_id, employer_client_id, arrival, departure, sheet_number,
+              hauptwohnsitz=None, tourism_liable=None, notes=None):
+    args = (guest_id, room_id, unit_id, employer_client_id, arrival, departure, sheet_number,
+            hauptwohnsitz, tourism_liable, notes)
+    if stay_id:
+        db.execute(conn, "UPDATE stay SET guest_id=?, room_id=?, unit_id=?, employer_client_id=?, arrival=?, "
+                   "departure=?, sheet_number=?, hauptwohnsitz=?, tourism_liable=?, notes=? WHERE id=?", args + (stay_id,))
+    else:
+        stay_id = db.execute(conn, "INSERT INTO stay (guest_id,room_id,unit_id,employer_client_id,arrival,"
+                             "departure,sheet_number,hauptwohnsitz,tourism_liable,notes,source_sheet) "
+                             "VALUES (?,?,?,?,?,?,?,?,?,?, 'guestsheet')", args)
+    close_ledger_on_departure(conn, sheet_number, room_id)
+    return stay_id
+
+
+PER_UNIT = {"week": 7, "day": 1, "night": 1}   # nights per Anz — month and lump rows derive nothing
+
+
+def _ledger_row(conn, charge_id):
+    return db.row(conn, """SELECT c.id, c.stay_id, s.label, s.room_id, c.gb_ref, c.period_from, c.period_to,
+                                  c.unit_type, c.gross_per_unit, c.persons, c.rnr, c.invoice_id, c.quantity,
+                                  c.line_net_override, c.tourism_tax, c.payer, c.art, c.notes,
+                                  c.paid_status, c.paid_date
+                           FROM charge c JOIN stay s ON s.id = c.stay_id WHERE c.id=?""", (charge_id,))
+
+
+def _gb_refs(gb_ref):
+    return [t for t in re.split(r"\D+", gb_ref or "") if t]
+
+
+def _departures(conn, refs, room_id, since):
+    """{Gästeblatt-Nr.: departure} for the people on a row who have left. Only stays overlapping the row
+    count: the numbers are reused years later, and an ancient namesake must not pass as departed."""
+    if not refs:
+        return {}
+    return {r["sheet_number"]: r["departure"] for r in db.rows(conn, """
+        SELECT sheet_number, departure FROM stay
+        WHERE source_sheet='guestsheet' AND sheet_number IN (%s) AND room_id IS NOT DISTINCT FROM ?
+          AND departure IS NOT NULL AND departure >= ? ORDER BY id""" % ",".join("?" * len(refs)),
+        refs + [room_id, since])}
+
+
+def _closing(conn, r, refs, bis, persons):
+    """Anz, Betrag (as line_net_override) and Ortstaxe of a row ending at `bis`, the way the form computes
+    them: Anz = Nächte / 7 for Wochen, Betrag = Anz x Satz x Personen. The Ortstaxe is nights x Satz x
+    Personen, and nothing at all once the WHOLE stay — the span of these Gästeblätter — passes 10 nights
+    (T-AAG §4). A room change keeps the number, so the span runs through the Betrieb's other rooms too — there
+    only for the row's own people, since an old number written on two guests' sheets must not lend one the
+    other's stay: the stays that reach this row and, without a break, those before them. A number reused
+    years earlier is not part of it."""
+    per = PER_UNIT.get(r["unit_type"])
+    nights = compute.days_between(r["period_from"], bis)
+    # a started week counts in full from 4 nights on, as on the invoice; shorter: the fraction
+    weeks = compute.weeks_for_period(r["period_from"], bis) if r["unit_type"] == "week" else None
+    qty = weeks or (round(nights / per, 6) if per and nights else r["quantity"])
+    override = (round(qty * (r["gross_per_unit"] or 0) * persons / 1.1, 6) if per and nights
+                else r["line_net_override"])
+    stays = db.rows(conn, """SELECT s.arrival, s.departure, s.room_id, g.last_name FROM stay s
+                             LEFT JOIN room rm ON rm.id = s.room_id LEFT JOIN guest g ON g.id = s.guest_id
+                             WHERE s.source_sheet='guestsheet' AND s.sheet_number IN (%s)
+                               AND s.arrival IS NOT NULL AND s.arrival <= ? AND s.departure IS NOT NULL
+                               AND rm.unit_id IS NOT DISTINCT FROM (SELECT unit_id FROM room WHERE id = ?)
+                             ORDER BY s.departure DESC""" % ",".join("?" * len(refs)), refs + [bis, r["room_id"]])
+    label = (r["label"] or "").lower()
+    stays = [s for s in stays if s["room_id"] == r["room_id"]
+             or any(w in label for w in re.findall(r"\w{3,}", (s["last_name"] or "").lower()))]
+    start = end = None
+    for s in stays:                                   # newest first; the run ends at the first gap
+        if end is None and s["departure"] < r["period_from"]:
+            break                                     # nothing reaches this row
+        if end is not None and s["departure"] < start:
+            break
+        start = min(start or s["arrival"], s["arrival"])
+        end = end or s["departure"]
+    taxe = round(compute.tourism_amount(r["period_from"], bis,
+                                        compute.days_between(start, end)) * persons, 2) or None
+    return qty, override, taxe
+
+
+def _name_match(guest, names):
+    """The one name on a row that is this register guest — 'Last First' first, else the last name alone;
+    None unless exactly one (father and son of the same name on one row: rather not guess)."""
+    full = f"{guest['last_name']} {guest['first_name'] or ''}".strip().lower()
+    hits = ([n for n in names if n.lower().startswith(full)]
+            or [n for n in names if guest["last_name"].lower() in n.lower()])
+    return hits[0] if len(hits) == 1 else None
+
+
+def _split_off(conn, r, gb, departure):
+    """Give the person behind Gästeblatt `gb` a row of their own that ends on their departure; the row
+    keeps the others. Only where the row says unambiguously who that is — one name and one Gästeblatt per
+    person — and the money derives from Anz x Satz; otherwise None and the row stays as it is."""
+    refs = _gb_refs(r["gb_ref"])
+    names = [n.strip() for n in (r["label"] or "").split(",") if n.strip()]
+    if (len(refs) < 2 or len(names) != len(refs) or (r["persons"] or 1) != len(refs)
+            or not PER_UNIT.get(r["unit_type"]) or r["gross_per_unit"] is None):
+        return None
+    g = db.row(conn, """SELECT g.last_name, g.first_name FROM stay s JOIN guest g ON g.id = s.guest_id
+                        WHERE s.source_sheet='guestsheet' AND s.sheet_number=? AND s.room_id IS NOT DISTINCT FROM ?
+                          AND s.departure=? ORDER BY s.id""", (gb, r["room_id"], departure))
+    name = _name_match(g, names) if g else None
+    if not name:
+        return None
+    qty, override, taxe = _closing(conn, r, [gb], departure, 1)
+    cid = create_ledger_row(conn, r["room_id"], name, r["period_from"], departure, 1, qty, r["unit_type"],
+                            r["gross_per_unit"], override * 1.1 if override is not None else None, None, None,
+                            r["art"], payer=r["payer"], gb_ref=gb, notes=r["notes"], tourism_tax=taxe)
+    names.remove(name)
+    refs.remove(gb)
+    db.execute(conn, "UPDATE stay SET label=? WHERE id=?", (", ".join(names), r["stay_id"]))
+    share = len(refs) / (len(refs) + 1)          # an already closed row keeps its price per person
+    db.execute(conn, "UPDATE charge SET gb_ref=?, persons=?, line_net_override=line_net_override*?, "
+                     "tourism_tax=tourism_tax*? WHERE id=?", (", ".join(refs), len(refs), share, share, r["id"]))
+    return cid
+
+
+def _rejoin(conn, charge_id):
+    """Rows that ended up alike — same room, same start and end, same terms, nothing billed — are ONE row
+    again: a group that leaves together is entered sheet by sheet, and the first sheet split its person
+    off. Returns the surviving row (the oldest), or None."""
+    r = _ledger_row(conn, charge_id)
+    if not r or not r["period_to"] or r["rnr"] or r["invoice_id"] or not r["gb_ref"]:
+        return None
+    twins = [t["id"] for t in db.rows(conn, """
+        SELECT c.id FROM charge c JOIN stay s ON s.id = c.stay_id
+        WHERE c.source_sheet='ledger' AND s.room_id IS NOT DISTINCT FROM ? AND c.id <> ? AND c.period_from = ?
+          AND c.period_to = ? AND c.gross_per_unit IS NOT DISTINCT FROM ? AND c.unit_type IS NOT DISTINCT FROM ?
+          AND c.payer IS NOT DISTINCT FROM ? AND c.art IS NOT DISTINCT FROM ?
+          AND c.rnr IS NULL AND c.invoice_id IS NULL AND c.gb_ref IS NOT NULL
+          AND (c.notes IS NOT DISTINCT FROM ? OR c.notes IS NULL OR CAST(? AS text) IS NULL)
+        ORDER BY c.id""",
+        (r["room_id"], r["id"], r["period_from"], r["period_to"], r["gross_per_unit"], r["unit_type"],
+         r["payer"], r["art"], r["notes"], r["notes"]))]
+    if not twins:
+        return None
+    rows = [_ledger_row(conn, i) for i in sorted([r["id"]] + twins)]
+    keep = rows[0]
+    names = [n.strip() for x in rows for n in (x["label"] or "").split(",") if n.strip()]
+    refs = [gb for x in rows for gb in _gb_refs(x["gb_ref"])]
+    persons = sum(x["persons"] or 1 for x in rows)
+    notes = next((x["notes"] for x in rows if x["notes"]), None)
+    qty, override, taxe = _closing(conn, keep, refs, keep["period_to"], persons)
+    db.execute(conn, "UPDATE stay SET label=? WHERE id=?", (", ".join(names), keep["stay_id"]))
+    db.execute(conn, "UPDATE charge SET gb_ref=?, persons=?, quantity=?, line_net_override=?, tourism_tax=?, "
+                     "notes=? WHERE id=?", (", ".join(refs), persons, qty, override, taxe, notes, keep["id"]))
+    for x in rows[1:]:
+        delete_charge(conn, x["id"])
+    return keep["id"]
+
+
+def close_ledger_on_departure(conn, sheet_number, room_id):
+    """A departure typed into a Gästeblatt writes itself into the room's Zimmerbelegung row — and a
+    CHANGED departure moves it again, which is the same job: the row's 'bis' is simply the last departure
+    of the people it bills. Rules the data forces:
+      * a row ends only when EVERY Gästeblatt on it has left, and gets Anz, Betrag and Ortstaxe with the
+        date, the way the form computes them — unless it already ends that day: then what was typed stands
+        (a guest may pay half a week for one night);
+      * whoever leaves while the others stay on — or leave later — gets a row of their own that ends on
+        their own departure, or the row bills that person for nights not stayed; rows that end up alike
+        are one row again (`_rejoin`), so a group leaving together stays one row;
+      * the departure belongs to the NEWEST row of that Gästeblatt in the room: an older one was closed at
+        a month end and continued, and its dates are that month's;
+      * Gästeblatt numbers are reused years later, so only stays overlapping the row count;
+      * a row that is already billed (RNr or invoice) is left untouched — its money sits on a document,
+        and correcting that is a deliberate act.
+    Returns the id of the row it last wrote, or None."""
+    if not sheet_number:
+        return None
+    rows = [r for r in db.rows(conn, """SELECT c.id, c.gb_ref FROM charge c JOIN stay s ON s.id = c.stay_id
+                                        WHERE c.source_sheet='ledger' AND s.room_id IS NOT DISTINCT FROM ? AND c.gb_ref IS NOT NULL
+                                          AND c.period_from IS NOT NULL
+                                        ORDER BY c.period_from DESC NULLS LAST, c.id DESC""", (room_id,))
+            if str(sheet_number) in _gb_refs(r["gb_ref"])]
+    if not rows:
+        return None
+    r = _ledger_row(conn, rows[0]["id"])
+    if r["rnr"] or r["invoice_id"]:
+        return None                           # already billed: dates and money belong to a document
+    written = None
+    refs = _gb_refs(r["gb_ref"])
+    done = _departures(conn, refs, room_id, r["period_from"])
+    last = max(done.values()) if set(done) == set(refs) else None    # None: somebody is still here
+    end = max((d for d in (r["period_to"], last) if d), default=None)
+    split = []
+    for gb in sorted(done):
+        if end and done[gb] >= end:
+            continue                          # leaves with the row's end, as it stands or as it moves
+        if last is None or done[gb] < last:
+            new = _split_off(conn, r, gb, done[gb])
+            if new:
+                split.append(new)
+                r = _ledger_row(conn, r["id"])   # its names, Gästeblätter and Personen just changed
+    refs = _gb_refs(r["gb_ref"])
+    if last is not None and set(refs) <= set(done):
+        bis = max(done[gb] for gb in refs)
+        if r["period_to"] != bis or r["quantity"] is None:   # it already ends that day: the typed Anz and Betrag stand
+            qty, override, taxe = _closing(conn, r, refs, bis, r["persons"] or 1)
+            if (r["period_to"], r["quantity"], r["line_net_override"], r["tourism_tax"]) != (bis, qty, override, taxe):
+                db.execute(conn, "UPDATE charge SET period_to=?, quantity=?, line_net_override=?, tourism_tax=? "
+                                 "WHERE id=?", (bis, qty, override, taxe, r["id"]))
+                written = r["id"]
+    # join alike rows only now: before the row moved on, a row split off it would look alike and join back
+    for new in split:
+        written = _rejoin(conn, new) or new
+    return _rejoin(conn, r["id"]) or written
+
+
+def carry_ledger_to_room(conn, sheet_number, old_room, new_room, day, guest):
+    """A room change moves the Zimmerbelegung along with the Gästeblatt: the guest's row in the old room
+    ends on `day` — the departure from it closed it — and a row in the new room starts there, like
+    'Speichern und weiterführen': same name, Einheit, Satz and Zahlung durch, nothing billed yet. A row
+    already continued in the old room from that day is moved instead of doubled. The ended row's Ortstaxe
+    is cleared as at a month end: the stay goes on, so its slice cannot be judged alone. Returns the new
+    room's row, or None when the ledger holds nothing to carry (it is entered as usual)."""
+    if not sheet_number or not day or not new_room or new_room == old_room:
+        return None
+    rows = [_ledger_row(conn, r["id"]) for r in db.rows(conn, """
+                SELECT c.id, c.gb_ref FROM charge c JOIN stay s ON s.id = c.stay_id
+                WHERE c.source_sheet='ledger' AND s.room_id IS NOT DISTINCT FROM ? AND c.gb_ref IS NOT NULL
+                  AND (c.period_from = ? OR c.period_to = ?) ORDER BY c.id""", (old_room, day, day))
+            if str(sheet_number) in _gb_refs(r["gb_ref"])]
+    ended = next((r for r in rows if r["period_to"] == day and r["period_from"] < day), None)
+    started = next((r for r in rows if r["period_from"] == day and _gb_refs(r["gb_ref"]) == [str(sheet_number)]
+                    and not (r["rnr"] or r["invoice_id"])), None)
+    if ended and not (ended["rnr"] or ended["invoice_id"]):
+        db.execute(conn, "UPDATE charge SET tourism_tax=NULL WHERE id=?", (ended["id"],))
+    if started:
+        db.execute(conn, "UPDATE stay SET room_id=?, unit_id=(SELECT unit_id FROM room WHERE id=?) WHERE id=?",
+                   (new_room, new_room, started["stay_id"]))
+        if started["period_to"] == day:                  # the departure closed it after no night at all
+            db.execute(conn, "UPDATE charge SET period_to=NULL, quantity=NULL, line_net_override=NULL, "
+                             "tourism_tax=NULL WHERE id=?", (started["id"],))
+        return started["id"]
+    if not ended:
+        return None
+    names = [n.strip() for n in (ended["label"] or "").split(",") if n.strip()]
+    alone = _gb_refs(ended["gb_ref"]) == [str(sheet_number)]
+    name = (ended["label"] if alone else _name_match(guest, names)
+            or f"{guest['last_name']} {guest['first_name'] or ''}".strip())
+    return create_ledger_row(conn, new_room, name, day, None, (ended["persons"] or 1) if alone else 1, None,
+                             ended["unit_type"], ended["gross_per_unit"], None, None, None, None,
+                             payer=ended["payer"], gb_ref=str(sheet_number))
+
+
+def delete_stay(conn, stay_id):
+    if db.row(conn, "SELECT 1 FROM charge WHERE stay_id=?", (stay_id,)):
+        raise ValueError("has_charges")
+    db.execute(conn, "DELETE FROM stay WHERE id=?", (stay_id,))
+
+
+# --- ledger row (charge) editing ---
+def get_charge(conn, charge_id):
+    r = db.row(conn, "SELECT c.*, s.label AS occupant, s.room_id, rm.number AS room "
+               "FROM charge c JOIN stay s ON c.stay_id=s.id LEFT JOIN room rm ON s.room_id=rm.id WHERE c.id=?",
+               (charge_id,))
+    if not r:
+        return None
+    d = dict(r)
+    d["betrag"] = round((d["line_net_override"] or 0) * 1.1, 2) if d.get("line_net_override") is not None else None
+    d["payments"] = charge_payments(conn, charge_id)
+    return d
+
+
+def charge_payments(conn, charge_id):
+    """The payments recorded on a Zimmerbelegung row, oldest first: [(paid_date, amount)]."""
+    return [(r["paid_date"], r["amount"]) for r in db.rows(
+        conn, "SELECT paid_date, amount FROM payment WHERE charge_id=? ORDER BY paid_date, id", (charge_id,))]
+
+
+def _save_payments(conn, charge_id, payments):
+    db.execute(conn, "DELETE FROM payment WHERE charge_id=?", (charge_id,))
+    for paid_date, amount in payments:
+        db.execute(conn, "INSERT INTO payment (charge_id, paid_date, amount) VALUES (?,?,?)",
+                   (charge_id, paid_date, amount))
+
+
+def _paid_status(paid_status, paid_date, paid=None, total=None):
+    """Writing a date into 'bezahlt' IS marking the row paid — a row with a payment date must not read
+    OFFEN just because the status dropdown stayed empty. The date decides — but only where nothing else
+    was said: a status picked by hand always wins.
+    Recorded PAYMENTS (`paid` = their sum) decide on their own: a part payment keeps the row OPEN (175,00
+    paid, 16,00 Ortstaxe open), and once they cover Betrag + Ortstaxe it is PAID (241,50 in May, the
+    remaining 174,50 in October)."""
+    if paid is not None and total is not None:
+        return "open" if paid + 0.005 < total else "paid"
+    return paid_status or ("paid" if paid_date else None)
+
+
+def _settle(paid_status, paid_date, payments, total):
+    """A row's 'Bezahlt' and 'bezahlt am'. With payments recorded, they decide both — bezahlt am is the
+    day of the last one; without, the dropdown and date stand (the usual single full payment)."""
+    if not payments:
+        return _paid_status(paid_status, paid_date), paid_date
+    return (_paid_status(paid_status, paid_date, sum(a for _, a in payments), total),
+            max(d for d, _ in payments))
+
+
+def charge_total(quantity, gross_per_unit, line_net_override, persons, tourism_tax):
+    """What this ledger row owes altogether: Betrag (Anz × Satz × Personen) plus the Ortstaxe — the figure
+    a part payment is measured against."""
+    amount = compute.line_gross((quantity or 0) * (persons or 1), gross_per_unit or 0, line_net_override)
+    return round(amount + (tourism_tax or 0), 2)
+
+
+def _link_typed_rnr(conn, charge_id, rnr):
+    """An RNr typed into a Zimmerbelegung row that names exactly one invoice of the row's own Betrieb LINKS
+    the row to it — the link is what fills 'Re vom' and makes the number clickable. Nothing on the invoice
+    changes; a number matching nothing leaves the row as is. Only a row WITHOUT a link, and only an invoice
+    dated within a year of the stay: bare numbers ('15') recur year after year — re-saving such a row must
+    never move its link."""
+    if not rnr:
+        return
+    hits = db.rows(conn, "SELECT i.id FROM invoice i JOIN stay s ON s.unit_id = i.unit_id "
+                         "JOIN charge c ON c.stay_id = s.id WHERE c.id=? AND i.number=? AND c.invoice_id IS NULL "
+                         "AND ABS(i.date::date - COALESCE(c.period_to, c.period_from)::date) <= 366 ORDER BY i.id",
+                   (charge_id, rnr))
+    if len(hits) == 1:
+        db.execute(conn, "UPDATE charge SET invoice_id=? WHERE id=?", (hits[0]["id"], charge_id))
+
+
+def update_charge(conn, charge_id, occupant, period_from, period_to, persons, quantity, unit_type,
+                  gross_per_unit, betrag, paid_status, paid_date, art, payer=None, rnr=None, gb_ref=None,
+                  notes=None, tourism_tax=None, payments=None):
+    """`payments`: [(paid_date, amount)] replaces the row's payments; None leaves them as they are — they
+    still decide 'Bezahlt' against the (possibly changed) Betrag."""
+    override = round(betrag / 1.1, 6) if betrag is not None else None   # pin the exact Betrag
+    if payments is None:
+        payments = charge_payments(conn, charge_id)
+    paid_status, paid_date = _settle(paid_status, paid_date, payments,
+                                     charge_total(quantity, gross_per_unit, override, persons, tourism_tax))
+    old = db.row(conn, "SELECT c.period_from, c.period_to, c.quantity, c.unit_type, c.gross_per_unit, "
+                 "c.line_net_override, c.art, c.invoice_id, c.source_sheet, c.stay_id, s.label AS occupant "
+                 "FROM charge c JOIN stay s ON c.stay_id=s.id WHERE c.id=?", (charge_id,))
+    db.execute(conn, "UPDATE charge SET period_from=?, period_to=?, persons=?, quantity=?, unit_type=?, "
+               "gross_per_unit=?, line_net_override=?, paid_status=?, paid_date=?, art=?, "
+               "payer=?, rnr=?, gb_ref=?, notes=?, tourism_tax=? WHERE id=?",
+               (period_from, period_to, persons, quantity, unit_type, gross_per_unit, override,
+                paid_status, paid_date, art, payer, rnr, gb_ref, notes, tourism_tax, charge_id))
+    _save_payments(conn, charge_id, payments)
+    db.execute(conn, "UPDATE stay SET label=? WHERE id=?", (occupant, old["stay_id"]))
+    _link_typed_rnr(conn, charge_id, rnr)
+    # a billing-relevant change on a linked ledger row marks its invoice for regeneration (payment fields don't).
+    # Of the Art only whether it makes the row a Storno counts: 'M' (mailed) flagged every sent invoice.
+    billing = (occupant, period_from, period_to, quantity, unit_type, gross_per_unit, override,
+               is_storno({"occupant": "", "art": art}))
+    was = tuple(old[k] for k in ("occupant", "period_from", "period_to", "quantity", "unit_type",
+                                 "gross_per_unit", "line_net_override")) + (is_storno({"occupant": "", "art": old["art"]}),)
+    if billing != was and old["invoice_id"] and old["source_sheet"] == "ledger":
+        db.execute(conn, "UPDATE invoice SET lines_stale=1 WHERE id=?", (old["invoice_id"],))
+
+
+def create_ledger_row(conn, room_id, occupant, period_from, period_to, persons, quantity, unit_type,
+                      gross_per_unit, betrag, paid_status, paid_date, art, payer=None, rnr=None, gb_ref=None,
+                      notes=None, tourism_tax=None, payments=None):
+    """Add a room-ledger occupancy: its own ledger-sourced stay + charge. The unit follows the chosen room;
+    Betrag is pinned via line_net_override. The stay carries NO dates — the charge's period is the single
+    source."""
+    unit_id = None
+    if room_id:
+        r = db.row(conn, "SELECT unit_id FROM room WHERE id=?", (room_id,))
+        unit_id = r[0] if r else None
+    override = round(betrag / 1.1, 6) if betrag is not None else None
+    payments = payments or []
+    paid_status, paid_date = _settle(paid_status, paid_date, payments,
+                                     charge_total(quantity, gross_per_unit, override, persons, tourism_tax))
+    sid = db.execute(conn, "INSERT INTO stay (room_id,unit_id,label,source_sheet) "
+                     "VALUES (?,?,?, 'ledger')", (room_id, unit_id, occupant))
+    cid = db.execute(conn, "INSERT INTO charge (stay_id,period_from,period_to,persons,quantity,unit_type,"
+                     "gross_per_unit,line_net_override,paid_status,paid_date,art,payer,rnr,"
+                     "gb_ref,notes,tourism_tax,source_sheet) "
+                     "VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?, 'ledger')",
+                     (sid, period_from, period_to, persons, quantity, unit_type, gross_per_unit, override,
+                      paid_status, paid_date, art, payer, rnr, gb_ref, notes, tourism_tax))
+    _save_payments(conn, cid, payments)
+    _link_typed_rnr(conn, cid, rnr)
+    return cid
+
+
+def continue_ledger_row(conn, charge_id):
+    """Month-end: the row is closed at the invoicing date, but the guest stays on. Continue the occupancy
+    in a NEW row that starts exactly where the closed one ends — same room, names, persons, Satz, Einheit,
+    Zahlung durch and Gästeblatt-Nr., with Anz/Betrag/Ortstaxe left open because nothing is billed yet.
+    The REGISTER stay is deliberately untouched: a month-end 'bis' is not a departure."""
+    r = db.row(conn, """SELECT c.period_to, c.persons, c.unit_type, c.gross_per_unit, c.art, c.payer,
+                               c.gb_ref, s.room_id, s.label
+                        FROM charge c JOIN stay s ON s.id = c.stay_id
+                        WHERE c.id=? AND c.source_sheet='ledger'""", (charge_id,))
+    if not r or not r["period_to"]:
+        return None
+    # the guest stays on, so this month's slice is part of a longer stay and its Ortstaxe cannot be judged
+    # from the slice alone (>10 nights over the WHOLE stay is exempt, T-AAG §4). Leave it to the invoice,
+    # which counts the continuous run — an auto-proposed figure here would simply be wrong.
+    db.execute(conn, "UPDATE charge SET tourism_tax=NULL WHERE id=?", (charge_id,))
+    return create_ledger_row(conn, r["room_id"], r["label"], r["period_to"], None, r["persons"], None,
+                             r["unit_type"], r["gross_per_unit"], None, None, None, r["art"],
+                             payer=r["payer"], gb_ref=r["gb_ref"])
+
+
+def delete_charge(conn, charge_id):
+    row = db.row(conn, "SELECT stay_id, invoice_id, source_sheet FROM charge WHERE id=?", (charge_id,))
+    if not row:
+        return
+    sid = row["stay_id"]
+    if row["invoice_id"] and row["source_sheet"] == "ledger":   # its invoice no longer matches the ledger
+        db.execute(conn, "UPDATE invoice SET lines_stale=1 WHERE id=?", (row["invoice_id"],))
+    db.execute(conn, "DELETE FROM charge WHERE id=?", (charge_id,))
+    if not db.row(conn, "SELECT 1 FROM charge WHERE stay_id=?", (sid,)):
+        db.execute(conn, "DELETE FROM stay WHERE id=? AND source_sheet='ledger'", (sid,))
+
+
+# --- invoices ---
+def invoices_list(conn, search=None):
+    sql = """
+        SELECT i.id, i.unit_id, i.number, i.date, i.paid_date, u.code AS unit, cl.name AS client,
+               led.n_led, led.n_paid, led.n_open, led.led_paid_date
+        FROM invoice i
+        LEFT JOIN unit u ON i.unit_id = u.id
+        LEFT JOIN client cl ON i.client_id = cl.id
+        LEFT JOIN (SELECT invoice_id AS iid, COUNT(*) AS n_led,
+                          -- a status picked by hand beats the date: a part payment carries BOTH
+                          -- (175,00 paid on 04.09., 16,00 Ortstaxe open) and stays open; cash is paid
+                          SUM((paid_status IN ('paid', 'cash')
+                               OR (paid_status IS NULL AND paid_date IS NOT NULL))::int) AS n_paid,
+                          SUM((paid_status = 'open')::int) AS n_open,
+                          MAX(paid_date) AS led_paid_date
+                   FROM charge WHERE source_sheet = 'ledger' AND invoice_id IS NOT NULL
+                   GROUP BY invoice_id) led ON led.iid = i.id
+    """
+    params = []
+    if search:
+        like = f"%{search}%"
+        sql += " WHERE i.number ILIKE ? OR cl.name ILIKE ?"
+        params = [like, like]
+    sql += " ORDER BY i.date DESC NULLS LAST, i.id DESC"   # no LIMIT: the grid is client-side sorted/filtered, show every year
+    out = _dicts(db.rows(conn, sql, params))
+    totals = _invoice_totals(conn)
+    for row in out:
+        row["gross"] = totals.get(row["id"], 0.0)
+        row.update(_payment_state(row))
+        row["number_key"] = invoice_number_key(row["number"], row["date"])
+    # Newest DATE first; within a date unit by unit, in the order they were set up, each with its own
+    # numbers in order: the units number independently, so sorting by the number alone would interleave
+    # 2026-35 with 26-35, and by id alone a month-end run would read 2026-49/51/50/48.
+    out.sort(key=lambda r: (r["date"] or "", -(r["unit_id"] or 0), r["number_key"][1], r["id"]), reverse=True)
+    return out
+
+
+def invoice_number_key(number, date):
+    """Sortable (year, sequence) behind an invoice number, whatever era spelled it: '2026-52', '26-31',
+    '49-2015' (SEQ-YEAR), '202201' (glued), '2018 -58'. The NUMBER's own year wins — a January invoice
+    still numbered with the old year belongs to that year — with the invoice date as the fallback. A
+    combined number ('41/46') has no single sequence, so its first group orders it."""
+    import datetime
+    num_year, date_year = normalize.invoice_year(number) or "", (date or "")[:4]
+    year = ""
+    if num_year.isdigit():
+        # the 2-digit-prefix rule reads a COMBINED number ('27 30', '69, 73') as a year — believe the
+        # number's year only next to the invoice's own date (a January invoice still numbered with last
+        # year is one apart; a decade apart means it was never a year)
+        if date_year.isdigit():
+            year = num_year if abs(int(num_year) - int(date_year)) <= 1 else ""
+        elif 1990 <= int(num_year) <= datetime.date.today().year + 1:
+            year = num_year
+    year = year or date_year
+    if not year.isdigit():
+        return (0, 0)
+    seq = normalize.invoice_seq(number, year)
+    if seq is None:
+        m = re.search(r"\d+", str(number or ""))
+        seq = int(m.group()) % 10000 if m else 0
+    return (int(year), seq)
+
+
+def _payment_state(row):
+    """Is this invoice settled? The invoice's own paid_date is the answer when it has one — most payments
+    are recorded in the ZIMMERBELEGUNG though ('bezahlt' per row), so the linked ledger rows answer for the
+    rest. An invoice nobody has said anything about (no paid_date, no linked row) is UNKNOWN, not open:
+    the receivables must not fill up with invoices nobody tracks. Read-only — writing the date onto an
+    issued invoice stays a deliberate act."""
+    if row["paid_date"]:
+        return {"payment_state": "paid", "paid_on": row["paid_date"]}
+    if row["n_open"]:
+        return {"payment_state": "open", "paid_on": None}
+    if row["n_paid"]:
+        return {"payment_state": "paid", "paid_on": row["led_paid_date"]}
+    if row["n_led"]:
+        return {"payment_state": "open", "paid_on": None}   # row exists, 'bezahlt' still empty = not yet
+    return {"payment_state": "unknown", "paid_on": None}
+
+
+def _invoice_totals(conn):
+    """Rechnungsbetrag per invoice for the list — the SAME number the invoice itself prints, so it comes
+    from the same computation over the same lines (see `get_invoice`): its invoice-sourced charges.
+    One query for all of them; hundreds of invoices must not become hundreds of round trips."""
+    lines = {}
+    for r in db.rows(conn, """SELECT c.invoice_id AS iid, c.quantity, c.gross_per_unit, c.line_net_override,
+                                     c.tourism_tax, c.vat_rate, c.kind
+                              FROM charge c JOIN stay s ON s.id = c.stay_id
+                              WHERE c.invoice_id IS NOT NULL AND s.source_sheet = 'invoice' ORDER BY c.id"""):
+        line = dict(r)
+        line["tourism_tax"] = line["tourism_tax"] or 0
+        line["kind"] = line["kind"] or "stay"
+        lines.setdefault(r["iid"], []).append(line)
+    return {iid: compute.invoice_gross(ls, sum(ln["tourism_tax"] for ln in ls)) for iid, ls in lines.items()}
+
+
+def next_invoice_number(conn, unit_id, today=None):
+    """Suggest the next per-unit number for the CURRENT year. Numbering restarts yearly, so scope by the
+    invoice date's year; ignore concatenated historical tokens (e.g. '5556', '303132') by taking only a
+    clean 1-3 digit trailing sequence. The seeded prefix carries a year ('2026-' / '26-') — swap it for
+    the current one so the suggestion survives New Year."""
+    import re
+    import datetime
+    row = db.row(conn, "SELECT invoice_prefix FROM unit WHERE id=?", (unit_id,))
+    prefix = (row["invoice_prefix"] if row else "") or ""
+    year = str((today or datetime.date.today()).year)
+    if re.match(r"\d{4}\D", prefix):
+        prefix = year + prefix[4:]
+    elif re.match(r"\d{2}\D", prefix):
+        prefix = year[2:] + prefix[2:]
+    biggest = 0
+    for r in db.rows(conn, "SELECT number FROM invoice WHERE unit_id=? AND date LIKE ? ORDER BY id", (unit_id, year + "%")):
+        m = re.search(r"(?<!\d)(\d{1,3})\s*$", (r["number"] or "").strip())
+        if m:
+            biggest = max(biggest, int(m.group(1)))
+    return f"{prefix}{biggest + 1}"
+
+
+def invoice_number_taken(conn, unit_id, number, exclude_id=None):
+    """True if this unit already has an invoice with this number (§11 fortlaufende Nummer). The forms
+    enforce it; the Datenprüfung lists duplicates that got in by any other way."""
+    number = (number or "").strip()
+    if not number:
+        return False
+    r = db.row(conn, "SELECT id FROM invoice WHERE unit_id=? AND number=? AND id<>COALESCE(?, -1)",
+               (unit_id, number, exclude_id))
+    return r is not None
+
+
+def invoice_out_of_order(conn, unit_id, number, date, exclude_id=None):
+    """Invoice dates follow the numbers: within a Betrieb and year, no smaller number may carry a later
+    date and no larger one an earlier date — said at once, before the invoice is saved. Returns the nearest
+    invoice that breaks the order as {number, date, smaller} — `smaller` when its number is below this
+    one — or None."""
+    key = invoice_number_key(number, date) if (unit_id and number and date) else (0, 0)
+    if key == (0, 0):
+        return None
+    clashes = []
+    for r in db.rows(conn, "SELECT number, date FROM invoice WHERE unit_id=? AND id<>COALESCE(?, -1) "
+                           "AND number IS NOT NULL AND date IS NOT NULL ORDER BY id", (unit_id, exclude_id)):
+        k = invoice_number_key(r["number"], r["date"])
+        if k[0] == key[0] and ((k < key and r["date"] > date) or (k > key and r["date"] < date)):
+            clashes.append((abs(k[1] - key[1]), {"number": r["number"], "date": r["date"], "smaller": k < key}))
+    return min(clashes, key=lambda c: c[0])[1] if clashes else None
+
+
+def create_invoice(conn, unit_id, client_id, number, date, lines, note=None,
+                   paid_date=None, payment_method=None, link_charge_ids=None):
+    """lines: {worker, period_from, period_to, quantity, unit_type, gross_per_unit, tourism_tax}.
+    Each line becomes a charge on a fresh invoice-sourced stay (kept out of the ledger/register views).
+    Tourism tax lives per line ONLY; invoice totals derive from the lines at read time.
+    `note` overrides the printed payment note (e.g. "already paid"); None keeps the default text.
+    `link_charge_ids`: the Zimmerbelegung rows this invoice was generated from — they get the invoice
+    number written back (the RNr column) and are linked, so the ledger shows the invoice."""
+    note = (note or "").strip() or None
+    inv_id = db.execute(conn,
+        "INSERT INTO invoice (unit_id,client_id,number,date,notes,paid_date,payment_method) "
+        "VALUES (?,?,?,?,?,?,?)",
+        (unit_id, client_id, number, date, note, paid_date, payment_method))
+    _insert_charge_lines(conn, inv_id, unit_id, lines)
+    if link_charge_ids:
+        ph = ",".join("?" * len(link_charge_ids))
+        db.execute(conn, f"UPDATE charge SET invoice_id=?, rnr=? WHERE id IN ({ph}) AND source_sheet='ledger'",
+                   [inv_id, number] + list(link_charge_ids))
+    return inv_id
+
+
+def _insert_charge_lines(conn, invoice_id, unit_id, lines):
+    """Each line → a fresh invoice-sourced stay + charge. A 'storno' line defaults to vat_rate 0 (nicht steuerbar)."""
+    for ln in lines:
+        kind = ln.get("kind") or "stay"
+        vat_rate = ln.get("vat_rate")
+        if vat_rate is None:
+            vat_rate = 0.0 if kind == "storno" else 0.10
+        label = ln.get("worker") or ln.get("description") or ""
+        sid = db.execute(conn, "INSERT INTO stay (unit_id,label,source_sheet) VALUES (?,?, 'invoice')",
+                         (unit_id, label))
+        db.execute(conn,
+            "INSERT INTO charge (stay_id,invoice_id,period_from,period_to,quantity,unit_type,gross_per_unit,"
+            "tourism_tax,vat_rate,kind,description) VALUES (?,?,?,?,?,?,?,?,?,?,?)",
+            (sid, invoice_id, ln["period_from"], ln["period_to"], ln["quantity"], ln["unit_type"],
+             ln["gross_per_unit"], ln.get("tourism_tax") or 0, vat_rate, kind, ln.get("description")))
+
+
+def _clear_invoice_lines(conn, invoice_id):
+    """Remove the invoice's OWN (app-created) charges + their stays. Linked ledger (Zimmerbelegung) rows are
+    LEFT in place and still linked — they belong to the ledger and keep this invoice's number so the ledger's
+    RNr stays a working link across an edit/regenerate. Only deleting the whole invoice unlinks them."""
+    inv_stays = [r[0] for r in db.rows(conn,
+        "SELECT s.id FROM stay s JOIN charge c ON c.stay_id=s.id "
+        "WHERE c.invoice_id=? AND s.source_sheet='invoice' ORDER BY s.id", (invoice_id,))]
+    db.execute(conn, "DELETE FROM charge WHERE invoice_id=? AND stay_id IN "
+               "(SELECT id FROM stay WHERE source_sheet='invoice')", (invoice_id,))
+    for sid in set(inv_stays):
+        db.execute(conn, "DELETE FROM stay WHERE id=?", (sid,))
+
+
+def update_invoice(conn, invoice_id, unit_id, client_id, number, date, lines, note=None,
+                   paid_date=None, payment_method=None):
+    """Edit an invoice header + lines. Its own lines are replaced; linked ledger rows stay in the ledger and stay
+    linked (`_clear_invoice_lines`)."""
+    note = (note or "").strip() or None
+    db.execute(conn, "UPDATE invoice SET unit_id=?, client_id=?, number=?, date=?, notes=?, "
+               "paid_date=?, payment_method=? WHERE id=?",
+               (unit_id, client_id, number, date, note, paid_date, payment_method, invoice_id))
+    _clear_invoice_lines(conn, invoice_id)
+    _insert_charge_lines(conn, invoice_id, unit_id, lines)
+    return invoice_id
+
+
+def linked_ledger_charges(conn, invoice_id):
+    """The Zimmerbelegung rows this invoice was generated from (linked via the RNr write-back)."""
+    return [r[0] for r in db.rows(conn, "SELECT id FROM charge WHERE invoice_id=? AND source_sheet='ledger' ORDER BY id",
+                                  (invoice_id,))]
+
+
+def invoice_payment_hint(conn, invoice_id):
+    """What the linked Zimmerbelegung rows say about the settlement — a PROPOSAL for the manual payment
+    action, nothing more. Nothing copies it onto an issued invoice by itself; taking it over is a deliberate
+    click. Values that disagree across the rows are offered as a list, not picked."""
+    rows = db.rows(conn, "SELECT paid_date, payer FROM charge "
+                         "WHERE invoice_id=? AND source_sheet='ledger' ORDER BY id", (invoice_id,))
+    def uniq(field):
+        return sorted({(r[field] or "").strip() for r in rows if (r[field] or "").strip()})
+    dates, payers = uniq("paid_date"), uniq("payer")
+    if not (dates or payers):
+        return None
+    return {"paid_date": dates[0] if len(dates) == 1 else None, "dates": dates,
+            "payment_method": payers[0] if len(payers) == 1 else None, "payers": payers}
+
+
+def set_invoice_payment(conn, invoice_id, paid_date=None, payment_method=None):
+    """Record how an invoice was settled. Touches ONLY the two settlement fields — never a line, a number,
+    a date or the recipient — so it is safe on an already issued document. Manual callers only."""
+    db.execute(conn, "UPDATE invoice SET paid_date=?, payment_method=? WHERE id=?",
+               (paid_date or None, (payment_method or "").strip() or None, invoice_id))
+
+
+def regenerate_invoice(conn, invoice_id):
+    """Rebuild the invoice's lines from its linked Zimmerbelegung rows at their CURRENT values — the one-click
+    path after a price/period fix in the ledger. The header (client, number, date, notes, payment) stays; the
+    ledger links (and their RNr as typed) survive; the stale flag clears."""
+    inv = db.row(conn, "SELECT unit_id FROM invoice WHERE id=?", (invoice_id,))
+    ids = linked_ledger_charges(conn, invoice_id)
+    if not inv or not ids:
+        return False
+    lines = lines_from_charges(conn, ids)["lines"]
+    for ln in lines:                                    # pre-fill lines use '' for empty form fields
+        ln["quantity"] = ln["quantity"] or None
+        ln["gross_per_unit"] = ln["gross_per_unit"] or None
+        ln["tourism_tax"] = ln["tourism_tax"] or 0
+    _clear_invoice_lines(conn, invoice_id)
+    _insert_charge_lines(conn, invoice_id, inv["unit_id"], lines)
+    ph = ",".join("?" * len(ids))
+    db.execute(conn, f"UPDATE charge SET invoice_id=? WHERE id IN ({ph})", [invoice_id] + ids)
+    db.execute(conn, "UPDATE invoice SET lines_stale=0 WHERE id=?", (invoice_id,))
+    return True
+
+
+def _gb_by_name(conn, r, names):
+    """{name: Gästeblatt-Nr.} for the people on a row, through the register — the stays of its Gästeblätter
+    in its room that overlap it (the numbers recur years later). {} for a row without Gästeblätter; None
+    unless every name and every Gästeblatt pair up exactly once."""
+    refs = _gb_refs(r["gb_ref"])
+    if not refs:
+        return {}
+    if len(refs) != len(names):
+        return None
+    pairs = {}
+    for gb in refs:
+        g = db.row(conn, """SELECT g.last_name, g.first_name FROM stay s JOIN guest g ON g.id = s.guest_id
+                            WHERE s.source_sheet='guestsheet' AND s.sheet_number=? AND s.room_id IS NOT DISTINCT FROM ?
+                              AND s.arrival <= ? AND COALESCE(s.departure, '9999') >= ? ORDER BY s.id""",
+                     (gb, r["room_id"], r["period_to"] or "9999", r["period_from"]))
+        name = _name_match(g, names) if g else None
+        if not name or name in pairs:
+            return None
+        pairs[name] = gb
+    return pairs
+
+
+def _row_says(r, t):
+    """Does ledger row `r` already bill what target `t` (one invoice line's worth) bills — same people,
+    same dates, same money? How the money is written does not count: the invoice may bill 11 Nächte x 23
+    where the row says 1,57 Wochen x 161, and the weekly Satz stays on the row."""
+    names = ", ".join(n.strip() for n in (r["label"] or "").split(",") if n.strip())
+    betrag = charge_total(r["quantity"], r["gross_per_unit"], r["line_net_override"], r["persons"], None)
+    return (names == t["label"] and (r["persons"] or 1) == t["persons"]
+            and (r["period_from"], r["period_to"]) == (t["period_from"], t["period_to"])
+            and abs(betrag - t["betrag"]) < 0.005 and abs((r["tourism_tax"] or 0) - (t["tourism_tax"] or 0)) < 0.005)
+
+
+def sync_rows_to_invoice(conn, invoice_id):
+    """Make the Zimmerbelegung rows an invoice was made from say what the invoice bills, so the ledger
+    corrects itself instead of drifting from the invoices. The price is settled on the
+    invoice — alone in a double room one company pays 175, the next stays at 161 — and the rows follow: a
+    changed period, Anz, Satz or Ortstaxe is corrected on the row, a second line for the same person
+    (another price or period) becomes a row of its own, and people billed apart get a row each. Only where
+    the lines are unambiguously that row's: every person on it billed by name and on no other linked row,
+    the money Anz x Satz, no part payment recorded yet. Not an invoice whose rows were changed AFTER it
+    (`lines_stale`): there the row is the newer word, and "Neu generieren" the way to bring them together.
+    Returns (corrected row ids, new row ids)."""
+    inv = db.row(conn, "SELECT lines_stale FROM invoice WHERE id=?", (invoice_id,))
+    if not inv or inv["lines_stale"]:
+        return [], []
+    lines = {}
+    for ln in db.rows(conn, """SELECT s.label AS worker, c.period_from, c.period_to, c.quantity, c.unit_type,
+                                      c.gross_per_unit, c.tourism_tax
+                               FROM charge c JOIN stay s ON s.id = c.stay_id
+                               WHERE c.invoice_id=? AND s.source_sheet='invoice' AND c.kind='stay'
+                               ORDER BY c.period_from NULLS FIRST, c.id""", (invoice_id,)):
+        lines.setdefault((ln["worker"] or "").strip(), []).append(ln)
+    rows = [_ledger_row(conn, i) for i in linked_ledger_charges(conn, invoice_id)]
+    names_of = {r["id"]: [n.strip() for n in (r["label"] or "").split(",") if n.strip()] for r in rows}
+    billed_on = Counter(n for names in names_of.values() for n in names)
+    fixed, new = [], []
+    for r in rows:
+        names = names_of[r["id"]]
+        if (not names or len(names) != (r["persons"] or 1) or r["gross_per_unit"] is None
+                or is_storno({"occupant": r["label"], "art": r["art"]}) or charge_payments(conn, r["id"])
+                or any(billed_on[n] > 1 or n not in lines for n in names)):
+            continue
+        groups = {}                                   # people billed alike stay together on one row
+        for n in names:
+            key = tuple((l["period_from"], l["period_to"], l["quantity"], l["unit_type"], l["gross_per_unit"])
+                        for l in lines[n])
+            groups.setdefault(key, []).append(n)
+        gbs = _gb_by_name(conn, r, names) if len(groups) > 1 else {}
+        if gbs is None:
+            continue
+        targets = [{"label": ", ".join(people), "persons": len(people), "period_from": frm, "period_to": to,
+                    "quantity": qty, "unit_type": unit_type, "gross_per_unit": rate,
+                    "betrag": round((qty or 0) * (rate or 0) * len(people), 2),
+                    "tourism_tax": round(sum(lines[n][i]["tourism_tax"] or 0 for n in people), 2) or None,
+                    "gb_ref": (", ".join(gbs[n] for n in people) if gbs
+                               else None if len(groups) > 1 else r["gb_ref"])}
+                   for key, people in groups.items() for i, (frm, to, qty, unit_type, rate) in enumerate(key)]
+        if len(targets) == 1 and _row_says(r, targets[0]):
+            continue
+        t = targets[0]
+        db.execute(conn, "UPDATE stay SET label=? WHERE id=?", (t["label"], r["stay_id"]))
+        db.execute(conn, "UPDATE charge SET period_from=?, period_to=?, persons=?, quantity=?, unit_type=?, "
+                         "gross_per_unit=?, line_net_override=?, tourism_tax=?, gb_ref=? WHERE id=?",
+                   (t["period_from"], t["period_to"], t["persons"], t["quantity"], t["unit_type"],
+                    t["gross_per_unit"], round(t["betrag"] / 1.1, 6), t["tourism_tax"], t["gb_ref"], r["id"]))
+        fixed.append(r["id"])
+        for t in targets[1:]:
+            cid = create_ledger_row(conn, r["room_id"], t["label"], t["period_from"], t["period_to"],
+                                    t["persons"], t["quantity"], t["unit_type"], t["gross_per_unit"], t["betrag"],
+                                    r["paid_status"], r["paid_date"], r["art"], payer=r["payer"], rnr=r["rnr"],
+                                    gb_ref=t["gb_ref"], notes=r["notes"], tourism_tax=t["tourism_tax"])
+            db.execute(conn, "UPDATE charge SET invoice_id=? WHERE id=?", (invoice_id, cid))
+            new.append(cid)
+    return fixed, new
+
+
+def get_invoice(conn, invoice_id):
+    r = db.row(conn, "SELECT * FROM invoice WHERE id=?", (invoice_id,))
+    if not r:
+        return None
+    inv = dict(r)
+    inv["unit"] = dict(db.row(conn, "SELECT * FROM unit WHERE id=?", (inv["unit_id"],))) if inv["unit_id"] else {}
+    inv["client"] = dict(db.row(conn, "SELECT * FROM client WHERE id=?", (inv["client_id"],))) \
+        if inv["client_id"] else {}
+    if inv["client"].get("company_id"):   # identity fields come from the company (kind decides Herrn/Firma)
+        comp = db.row(conn, "SELECT kind, uid FROM company WHERE id=?", (inv["client"]["company_id"],))
+        if comp:
+            inv["client"]["kind"] = comp["kind"]
+            inv["client"]["uid"] = comp["uid"]   # single source: uid lives on the company only
+    # the invoice's OWN lines are the invoice-sourced charges; linked ledger rows (RNr write-back) are
+    # bookkeeping, not lines
+    lines = db.rows(conn, """
+        SELECT c.quantity, c.unit_type, c.gross_per_unit, c.line_net_override, c.tourism_tax,
+               c.vat_rate, c.kind, c.period_from, c.period_to, COALESCE(c.description, s.label) AS worker
+        FROM charge c JOIN stay s ON c.stay_id = s.id
+        WHERE c.invoice_id = ? AND s.source_sheet = 'invoice' ORDER BY c.id""", (invoice_id,))
+    inv["lines"] = []
+    for ln in lines:
+        d = dict(ln)
+        d["tourism_tax"] = d.get("tourism_tax") or 0
+        d["kind"] = d.get("kind") or "stay"
+        r = 0 if d["kind"] == "storno" else d.get("vat_rate")   # storno is nicht steuerbar → display at rate 0
+        d["net_per_unit"] = compute.net_per_unit(d["gross_per_unit"] or 0, r)
+        d["line_net"] = compute.line_net(d["quantity"] or 0, d["gross_per_unit"] or 0, d["line_net_override"], r)
+        d["line_vat"] = compute.line_vat(d["quantity"] or 0, d["gross_per_unit"] or 0, d["line_net_override"], r)
+        d["line_gross"] = compute.line_gross(d["quantity"] or 0, d["gross_per_unit"] or 0, d["line_net_override"], r)
+        inv["lines"].append(d)
+    inv["tourism_tax"] = round(sum(d["tourism_tax"] for d in inv["lines"]), 2)  # sum of the per-line column
+    inv["net"] = compute.invoice_net(inv["lines"])          # steuerbarer Nettobetrag (storno excluded)
+    inv["vat"] = compute.invoice_vat(inv["lines"])
+    inv["vat_breakdown"] = compute.invoice_vat_breakdown(inv["lines"])   # one 'USt X %' row per rate present
+    inv["storno"] = compute.invoice_storno(inv["lines"])    # nicht steuerbar subtotal
+    inv["gross"] = compute.invoice_gross(inv["lines"], inv["tourism_tax"])
+    # short company form for the PDF filename: the payer ('Zlg. durch', e.g. 'Alpenbau') off the linked
+    # ledger rows — the invoice's own lines carry no payer. Most frequent non-null wins; None -> full name.
+    pr = db.row(conn, "SELECT payer FROM charge WHERE invoice_id=? AND payer IS NOT NULL "
+                      "GROUP BY payer ORDER BY COUNT(*) DESC, payer NULLS FIRST LIMIT 1", (invoice_id,))
+    inv["payer"] = pr[0] if pr else None
+    return inv
+
+
+def _period_de(a, b):
+    """'2026-05-25','2026-06-28' -> '25.05.-28.06.2026' (year once when equal, else on both)."""
+    def parts(iso):
+        y, m, d = iso.split("-")
+        return d, m, y
+    if a and b:
+        da, ma, ya = parts(a); db_, mb, yb = parts(b)
+        return f"{da}.{ma}.-{db_}.{mb}.{yb}" if ya == yb else f"{da}.{ma}.{ya}-{db_}.{mb}.{yb}"
+    one = a or b
+    if one:
+        d, m, y = parts(one); return f"{d}.{m}.{y}"
+    return ""
+
+
+def invoice_filename(inv):
+    """PDF name: '<Nr> <Firma-Kurz>, <Name1, Name2, …> <von.-bis.jahr>.pdf'. Number kept verbatim (units
+    may number '26-23' or '2026-…'); company is the payer short form with the full client name as fallback;
+    occupants are the invoice's stay lines, de-duplicated in order."""
+    number = (inv.get("number") or f"Rechnung_{inv.get('id')}").strip()
+    company = (inv.get("payer") or (inv.get("client") or {}).get("name") or "").strip()
+    seen, workers = set(), []
+    for ln in inv.get("lines", []):
+        w = (ln.get("worker") or "").strip()
+        if ln.get("kind") == "stay" and w and w not in seen:
+            seen.add(w); workers.append(w)
+    froms = [ln["period_from"] for ln in inv.get("lines", []) if ln.get("period_from")]
+    tos = [ln["period_to"] for ln in inv.get("lines", []) if ln.get("period_to")]
+    period = _period_de(min(froms) if froms else None, max(tos) if tos else None)
+    head = ", ".join(p for p in [company, *workers] if p)
+    name = " ".join(p for p in [number, head, period] if p)
+    name = re.sub(r"\s+", " ", re.sub(r'[\\/:*?"<>|\r\n\t]+', " ", name)).strip()
+    return (name or number) + ".pdf"
+
+
+def delete_invoice(conn, invoice_id):
+    """Delete an invoice; its own lines are removed, linked ledger rows only unlinked. An RNr this app wrote
+    into a ledger row (== the invoice number) is cleared; an RNr typed by hand that differs from the number
+    survives."""
+    inv = db.row(conn, "SELECT number FROM invoice WHERE id=?", (invoice_id,))
+    if inv and inv["number"]:
+        db.execute(conn, "UPDATE charge SET rnr=NULL WHERE invoice_id=? AND rnr=?", (invoice_id, inv["number"]))
+    _clear_invoice_lines(conn, invoice_id)
+    db.execute(conn, "UPDATE charge SET invoice_id=NULL WHERE invoice_id=?", (invoice_id,))  # unlink ledger rows
+    db.execute(conn, "DELETE FROM invoice WHERE id=?", (invoice_id,))
+
+
+# --- companies (canonical client identities; client rows are their address/spelling versions) ---
+def companies_list(conn, search=None):
+    sql = """
+        SELECT co.id, co.name, co.kind, co.uid,
+               cur.address AS cur_address, cur.postcode AS cur_postcode, cur.city AS cur_city,
+               (SELECT COUNT(*) FROM client c WHERE c.company_id = co.id) AS versions,
+               (SELECT COUNT(*) FROM stay s JOIN client c ON s.employer_client_id=c.id
+                WHERE c.company_id = co.id) AS stays,
+               (SELECT COUNT(*) FROM invoice i JOIN client c ON i.client_id=c.id
+                WHERE c.company_id = co.id) AS invoices
+        FROM company co LEFT JOIN client cur ON co.current_client_id = cur.id
+    """
+    params = []
+    if search:
+        sql += " WHERE co.name ILIKE ?"
+        params = [f"%{search}%"]
+    sql += " ORDER BY lower(co.name), co.id"
+    return _dicts(db.rows(conn, sql, params))
+
+
+def get_company(conn, company_id):
+    r = db.row(conn, "SELECT * FROM company WHERE id=?", (company_id,))
+    if not r:
+        return None
+    comp = dict(r)
+    comp["versions"] = _dicts(db.rows(conn, """
+        SELECT c.*,
+               (SELECT COUNT(*) FROM stay s WHERE s.employer_client_id=c.id) AS stays,
+               (SELECT COUNT(*) FROM invoice i WHERE i.client_id=c.id) AS invoices,
+               (SELECT MIN(i.date) FROM invoice i WHERE i.client_id=c.id) AS first_invoice,
+               (SELECT MAX(i.date) FROM invoice i WHERE i.client_id=c.id) AS last_invoice
+        FROM client c WHERE c.company_id=? ORDER BY c.id""", (company_id,)))
+    comp["aliases"] = [r[0] for r in db.rows(conn,
+        "SELECT DISTINCT c.name FROM client c WHERE c.company_id=? AND c.name<>? ORDER BY c.name",
+        (company_id, comp["name"]))]
+    return comp
+
+
+def save_company(conn, company_id, name, kind, uid, email, phone, notes, current_client_id=None):
+    db.execute(conn, "UPDATE company SET name=?, kind=?, uid=?, email=?, phone=?, notes=? WHERE id=?",
+               (name, kind, uid, email, phone, notes, company_id))
+    if current_client_id and db.row(conn, "SELECT 1 FROM client WHERE id=? AND company_id=?",
+                                    (current_client_id, company_id)):
+        db.execute(conn, "UPDATE company SET current_client_id=? WHERE id=?", (current_client_id, company_id))
+    key = normalize.company_key(name)   # a rename must keep resolving: register the new spelling too
+    if key and not db.row(conn, "SELECT 1 FROM company_key WHERE key=?", (key,)):
+        db.execute(conn, "INSERT INTO company_key (key, company_id) VALUES (?,?)", (key, company_id))
+
+
+def add_company_address(conn, company_id, address, postcode, city, make_current=True):
+    """A new address version for a company (it moved / has another location). New invoices use it when
+    make_current is set; old invoices keep their old version."""
+    comp = db.row(conn, "SELECT name, kind FROM company WHERE id=?", (company_id,))
+    if not comp:
+        return None
+    return _new_client_version(conn, company_id, comp["name"], comp["kind"],
+                               address or None, postcode or None, city or None, make_current=make_current)
+
+
+def update_client_address(conn, client_id, name, address, postcode, city):
+    """Edit one address version in place (fix a typo / a name-part that leaked into the street). Old invoices
+    on this version pick the correction up too — it's the same recipient, corrected."""
+    db.execute(conn, "UPDATE client SET name=?, address=?, postcode=?, city=? WHERE id=?",
+               (name.strip() or None, address.strip() or None, postcode.strip() or None,
+                city.strip() or None, client_id))
+
+
+def set_current_address(conn, company_id, client_id):
+    """Make this address version the one new invoices use."""
+    if db.row(conn, "SELECT 1 FROM client WHERE id=? AND company_id=?", (client_id, company_id)):
+        db.execute(conn, "UPDATE company SET current_client_id=? WHERE id=?", (client_id, company_id))
+
+
+def delete_client_address(conn, client_id):
+    """Delete one address version. Refuses if any stay/invoice still uses it ('has_refs') or if it's the
+    company's last version ('last_version'); a deleted current version hands off to another version."""
+    row = db.row(conn, "SELECT company_id FROM client WHERE id=?", (client_id,))
+    if not row:
+        return
+    company_id = row[0]
+    if (db.row(conn, "SELECT COUNT(*) FROM stay WHERE employer_client_id=?", (client_id,))[0]
+            or db.row(conn, "SELECT COUNT(*) FROM invoice WHERE client_id=?", (client_id,))[0]):
+        raise ValueError("has_refs")
+    other = db.row(conn, "SELECT id FROM client WHERE company_id=? AND id<>? ORDER BY id DESC LIMIT 1",
+                   (company_id, client_id))
+    if not other:
+        raise ValueError("last_version")
+    if db.row(conn, "SELECT current_client_id FROM company WHERE id=?", (company_id,))[0] == client_id:
+        db.execute(conn, "UPDATE company SET current_client_id=? WHERE id=?", (other[0], company_id))
+    db.execute(conn, "DELETE FROM client WHERE id=?", (client_id,))
+
+
+def merge_companies(conn, keep_id, merge_id):
+    """Fold company `merge_id` into `keep_id`: all spellings keep resolving (keys move over), every client
+    version survives under the surviving company, references never break."""
+    if keep_id == merge_id or not db.row(conn, "SELECT 1 FROM company WHERE id=?", (merge_id,)):
+        return
+    db.execute(conn, "UPDATE company_key SET company_id=? WHERE company_id=?", (keep_id, merge_id))
+    db.execute(conn, "UPDATE client SET company_id=? WHERE company_id=?", (keep_id, merge_id))
+    keep = db.row(conn, "SELECT * FROM company WHERE id=?", (keep_id,))
+    merged = db.row(conn, "SELECT * FROM company WHERE id=?", (merge_id,))
+    for col in ("uid", "email", "phone", "notes"):
+        if not keep[col] and merged[col]:
+            db.execute(conn, f"UPDATE company SET {col}=? WHERE id=?", (merged[col], keep_id))
+    if not keep["current_client_id"] and merged["current_client_id"]:
+        db.execute(conn, "UPDATE company SET current_client_id=? WHERE id=?",
+                   (merged["current_client_id"], keep_id))
+    db.execute(conn, "DELETE FROM company WHERE id=?", (merge_id,))
+
+
+def company_ref_counts(conn, company_id):
+    """How many stays / invoices still point at any address version of this company."""
+    sub = "SELECT id FROM client WHERE company_id=?"
+    stays = db.row(conn, f"SELECT COUNT(*) FROM stay WHERE employer_client_id IN ({sub})", (company_id,))[0]
+    invoices = db.row(conn, f"SELECT COUNT(*) FROM invoice WHERE client_id IN ({sub})", (company_id,))[0]
+    return stays, invoices
+
+
+def delete_company(conn, company_id):
+    """Delete a company and its address versions. Refuses when any stay or invoice still references it
+    (raise 'has_refs') so no register/billing row is orphaned — merge such a company instead."""
+    stays, invoices = company_ref_counts(conn, company_id)
+    if stays or invoices:
+        raise ValueError("has_refs")
+    db.execute(conn, "UPDATE company SET current_client_id=NULL WHERE id=?", (company_id,))  # break the self-ref
+    db.execute(conn, "DELETE FROM company_key WHERE company_id=?", (company_id,))
+    db.execute(conn, "DELETE FROM client WHERE company_id=?", (company_id,))
+    db.execute(conn, "DELETE FROM company WHERE id=?", (company_id,))
diff --git a/app/static/grids.js b/app/static/grids.js
new file mode 100644
index 0000000..be13e4c
--- /dev/null
+++ b/app/static/grids.js
@@ -0,0 +1,644 @@
+// Client-side grid engine for the spreadsheet-like tables: sorting, live search + dropdown filters.
+//
+// Built for LARGE tables (a ledger of thousands of rows) and for FIREFOX as well as Chromium. The server ships
+// every row inside an inert <template> (parsed, but the browser builds no layout boxes), and the grid
+// only ever ATTACHES the ~60 rows around the viewport — spacer rows keep the scrollbar honest, so it
+// still feels like one giant scrollable list. Sorting/filtering/searching work on an in-memory model
+// (each cell's text and sort key computed once), then just re-render the window: cost is O(visible),
+// not O(table), in every engine. Column widths are measured once (from the rows with the longest text
+// per column), frozen into generated CSS, and remembered in localStorage keyed by a db fingerprint —
+// the next visit re-applies them in <head> and never lays out the full table at all.
+//
+// Sorting: every column cycles ascending -> descending -> out; clicking more columns while one is
+// sorted adds sort levels (no modifier keys). Arrows + priority numbers live in the headers. The sort
+// survives navigating away and back (sessionStorage); the scroll offset does not — a chronological
+// grid always opens on its newest rows (data-scroll="end"). Columns can be PINNED
+// (Excel "Fenster fixieren", per column): the header's pin glyph toggles it, defaults come from the
+// table's data-pin attribute, overrides live in localStorage. Trade-off of windowed rendering: the
+// browser's own Ctrl+F / select-all only see the attached rows — the grid's search box covers the
+// full data instead.
+(function () {
+  var collator = new Intl.Collator("de");
+  var STORE_V = 5;                    // bump when the generated-CSS format changes (v5: per-column caps)
+  var MAX_COL = 200;                  // widest a single column may freeze to (px)
+  var OVERSCAN = 12;                  // extra rows rendered above/below the viewport
+  var TEXT = window.GRID_TEXT;        // UI labels, from de.json via base.html
+
+  // Typed sort key: a German date (dd.mm.yyyy) sorts chronologically, a German number sorts numerically,
+  // anything starting with digits sorts naturally by that number ('57*' lands at 57, not alphabetically),
+  // pure text sorts alphabetically. Decided per CELL, so one odd value can't degrade the whole column.
+  function makeKey(s) {
+    if (s === "") return { e: true };
+    var d = s.match(/^(\d{2})\.(\d{2})\.(\d{4})$/);
+    if (d) return { n: +(d[3] + d[2] + d[1]), s: "" };
+    var t = s.replace(/[\s€]/g, "").replace(/\./g, "").replace(",", ".");
+    if (/^-?\d+(\.\d+)?$/.test(t)) return { n: parseFloat(t), s: "" };
+    var m = s.match(/^(\d+)\s*(.*)$/);
+    if (m) return { n: parseInt(m[1], 10), s: m[2].toLowerCase() };
+    return { s: s.toLowerCase() };
+  }
+
+  // Which column does a filter/sum mean? A NAME (the header's own text) survives inserting a column;
+  // a hardcoded index does not — a filter would silently move to the neighbouring column when a column
+  // is added. Numbers still work for anything unnamed.
+  function colIndex(grid, spec) {
+    if (/^\d+$/.test(spec || "")) return parseInt(spec, 10);
+    var want = (spec || "").trim().toLowerCase();
+    for (var i = 0; i < grid.ths.length; i++) {
+      // the header's OWN text only: the pin glyph is a child element and would never match
+      var th = grid.ths[i], text = "";
+      for (var n = 0; n < th.childNodes.length; n++) {
+        if (th.childNodes[n].nodeType === 3) text += th.childNodes[n].nodeValue;
+      }
+      if (text.trim().toLowerCase() === want) return i;
+    }
+    return -1;
+  }
+
+  function cmpKeys(a, b) {
+    if (a.e || b.e) return (a.e ? 0 : 1) - (b.e ? 0 : 1);          // empty cells first
+    var na = a.n !== undefined, nb = b.n !== undefined;
+    if (na && nb && a.n !== b.n) return a.n - b.n;
+    if (na !== nb) return na ? -1 : 1;                             // numbers before text
+    return collator.compare(a.s, b.s);
+  }
+
+  function Grid(table) {
+    this.table = table;
+    this.tbody = table.tBodies[0];
+    this.wrap = table.closest(".tablewrap");
+    this.ths = table.tHead.rows[0].cells;
+    this.spec = [];                   // active sort: [{col, dir}], empty = the server's order
+    this.q = "";
+    this.filters = [];
+    this.rowH = 39;                   // refined from the stored layout or the first rendered row
+    this.a = -1;
+    this.b = -1;
+
+    var tpl = this.tbody.querySelector("template");
+    var els = tpl ? tpl.content.querySelectorAll("tr")
+                  : Array.prototype.slice.call(this.tbody.rows);   // fallback: server-attached rows
+    this.rows = [];
+    for (var i = 0; i < els.length; i++) {
+      if (els[i].dataset.empty) continue;
+      var texts = [], sortable = null, filterable = null, cells = els[i].cells;
+      for (var c = 0; c < cells.length; c++) {
+        texts.push(cells[c].textContent.trim());
+        // a cell may carry its own sort key (data-k) when the printed text does not sort sensibly —
+        // an invoice number spans four eras of spelling, so the server hands over year.sequence
+        if (cells[c].dataset.k) (sortable = sortable || {})[c] = cells[c].dataset.k;
+        // ... and its own FILTER value (data-f) when the question is not answerable from the text: an
+        // empty 'Bis' means "still here" only on a row that has a 'Von' at all
+        if (cells[c].dataset.f) (filterable = filterable || {})[c] = cells[c].dataset.f;
+      }
+      this.rows.push({ el: els[i], i: this.rows.length, texts: texts, sortable: sortable,
+                       filterable: filterable, keys: [], search: null });
+    }
+    if (tpl) tpl.remove();
+    this.view = this.rows.slice();
+    this.top = document.createElement("tr");
+    this.bot = document.createElement("tr");
+    this.top.className = this.bot.className = "vspace";
+  }
+
+  Grid.prototype.key = function (r, col) {
+    return r.keys[col] || (r.keys[col] = makeKey((r.sortable && r.sortable[col]) || r.texts[col] || ""));
+  };
+
+  // Recompute the visible/sorted row list from the current search, filters and sort spec, then render.
+  Grid.prototype.update = function () {
+    if (!this.rows.length) return 0;
+    var g = this, out = [];
+    for (var i = 0; i < this.rows.length; i++) {
+      var r = this.rows[i], show = true;
+      if (this.q) {
+        if (r.search === null) r.search = r.texts.join(" ").toLowerCase();
+        show = r.search.indexOf(this.q) !== -1;
+      }
+      for (var f = 0; show && f < this.filters.length; f++) {
+        // a dropdown normally matches the cell text exactly; two sentinels ask about the cell being
+        // EMPTY or filled at all — that is how "not departed yet" is a filter without a column
+        var col = this.filters[f].col, want = this.filters[f].value;
+        var txt = ((r.filterable && r.filterable[col]) || r.texts[col] || "").toLowerCase();
+        show = want === "__empty__" ? txt === "" : want === "__filled__" ? txt !== "" : txt === want;
+      }
+      if (show) out.push(r);
+    }
+    var spec = this.spec;
+    if (spec.length) out.sort(function (a, b) {
+      for (var s = 0; s < spec.length; s++) {
+        var d = cmpKeys(g.key(a, spec[s].col), g.key(b, spec[s].col));
+        if (d) return d * spec[s].dir;
+      }
+      return a.i - b.i;                                            // full tie -> keep server order
+    });
+    this.view = out;
+    this.a = -1;                                                   // force a re-render
+    this.render();
+    return out.length;
+  };
+
+  // Attach only the rows around the viewport; two spacer rows stand in for everything else.
+  Grid.prototype.render = function () {
+    if (!this.rows.length) return;
+    var win = Math.ceil(this.wrap.clientHeight / this.rowH) + 2 * OVERSCAN;
+    // clamp into the view: after a filter shrinks the list, the old scroll offset must not leave the
+    // window pointing past the last row (the browser only clamps scrollTop after we shrink the spacers)
+    var a = Math.max(0, Math.min(Math.floor(this.wrap.scrollTop / this.rowH) - OVERSCAN,
+                                 this.view.length - win));
+    var b = Math.min(this.view.length, a + win);
+    if (a === this.a && b === this.b) return;
+    var kids = [this.top];
+    for (var i = a; i < b; i++) {
+      var el = this.view[i].el;
+      el.classList.toggle("zeb", (i & 1) === 1);   // stripe by display position, not DOM position
+      kids.push(el);
+    }
+    kids.push(this.bot);
+    this.top.style.height = a * this.rowH + "px";
+    this.bot.style.height = (this.view.length - b) * this.rowH + "px";
+    this.tbody.replaceChildren.apply(this.tbody, kids);
+    this.a = a;
+    this.b = b;
+    if (!this.measured && b > a) {                                 // true row height once rows exist
+      this.measured = true;
+      var h = kids[1].getBoundingClientRect().height;
+      if (h > 5 && Math.abs(h - this.rowH) > 0.5) { this.rowH = h; this.a = -1; this.render(); }
+    }
+    this.placeAtNewest();
+  };
+
+  // Hold the pane at the very bottom while the list is still settling (see stickEnd).
+  Grid.prototype.placeAtNewest = function () {
+    if (this.stickEnd) this.wrap.scrollTop = this.wrap.scrollHeight;
+  };
+
+  // Every column cycles independently: ascending -> descending -> out. Clicking another column while
+  // one is sorted simply ADDS it as the next sort level (no modifier keys); when the last column cycles
+  // out, the grid is back in the server's order.
+  Grid.prototype.headerClick = function (col) {
+    var at = -1;
+    for (var i = 0; i < this.spec.length; i++) if (this.spec[i].col === col) at = i;
+    if (at < 0) this.spec.push({ col: col, dir: 1 });
+    else if (this.spec[at].dir === 1) this.spec[at].dir = -1;
+    else this.spec.splice(at, 1);
+    this.update();
+    this.markHeaders();
+    try {                                            // keep the sort while flipping between pages
+      sessionStorage.setItem("sort:" + this.table.id, JSON.stringify(this.spec));
+    } catch (e) { /* storage blocked: sorting still works, it just won't survive navigation */ }
+  };
+
+  Grid.prototype.restoreSort = function () {
+    var spec;
+    try { spec = JSON.parse(sessionStorage.getItem("sort:" + this.table.id)); } catch (e) { return; }
+    if (!Array.isArray(spec)) return;
+    var nCols = this.ths.length;
+    this.spec = spec.filter(function (s) {
+      return s && typeof s.col === "number" && s.col < nCols && (s.dir === 1 || s.dir === -1);
+    });
+    this.markHeaders();
+  };
+
+  Grid.prototype.markHeaders = function () {
+    for (var i = 0; i < this.ths.length; i++) {
+      this.ths[i].removeAttribute("data-sd");
+      this.ths[i].removeAttribute("data-prio");
+    }
+    for (var s = 0; s < this.spec.length; s++) {
+      var th = this.ths[this.spec[s].col];
+      if (!th) continue;
+      th.setAttribute("data-sd", this.spec[s].dir === 1 ? "a" : "d");
+      if (this.spec.length > 1) th.setAttribute("data-prio", s + 1);
+    }
+  };
+
+  Grid.prototype.sum = function (col) {
+    var total = 0;
+    for (var i = 0; i < this.view.length; i++) {
+      var k = this.key(this.view[i], col);
+      if (k.n !== undefined) total += k.n;
+    }
+    return total;
+  };
+
+  // --- pinned columns (Excel "Fenster fixieren", but per column) -----------------------------------
+  // A pinned column is position:sticky with left = the summed widths of the pinned columns BEFORE it:
+  // it scrolls normally until it reaches that offset, then docks flush against the pinned block while
+  // the unpinned columns slide underneath. Pure CSS — nothing runs on scroll. Column widths come from
+  // freezeLayout's measurement, so toggling never re-measures.
+  Grid.prototype.loadPins = function () {
+    var pins = null;
+    try { pins = JSON.parse(localStorage.getItem("pin:" + this.table.id)); } catch (e) { /* default */ }
+    if (!Array.isArray(pins)) {                    // no user override -> the template's default set
+      pins = (this.table.dataset.pin || "").split(/\s+/).filter(Boolean).map(Number);
+    }
+    var n = this.ths.length;
+    this.pins = pins.filter(function (c) { return c >= 1 && c <= n; });
+  };
+
+  Grid.prototype.togglePin = function (col) {
+    var at = this.pins.indexOf(col);
+    if (at < 0) this.pins.push(col); else this.pins.splice(at, 1);
+    try { localStorage.setItem("pin:" + this.table.id, JSON.stringify(this.pins)); }
+    catch (e) { /* storage blocked: the pin still applies, it just won't survive the session */ }
+    this.applyPins();
+  };
+
+  Grid.prototype.applyPins = function () {
+    if (!this.pinStyle) {
+      this.pinStyle = document.createElement("style");   // appended AFTER the layout css, so it wins ties
+      document.head.appendChild(this.pinStyle);
+    }
+    var id = "#" + this.table.id, g = this;
+    var sorted = this.pins.slice().sort(function (a, b) { return a - b; });
+    var active = [], left = 0;
+    // cap: at least ~240px of the pane must stay scrollable, or pinning could lock sideways scrolling
+    // up entirely; anything past the cap simply stays a normal column
+    var budget = Math.max(240, (this.wrap.clientWidth || 800) - 240);
+    for (var i = 0; i < sorted.length && this.widths; i++) {
+      var w = this.widths[sorted[i] - 1] || 0;
+      if (left + w > budget) break;
+      active.push({ col: sorted[i], left: left });
+      left += w;
+    }
+    this.markPins();
+    if (!active.length) { this.pinStyle.textContent = ""; return; }
+    var css = id + " thead{z-index:4}";                  // above the pinned cells on the vertical axis
+    var sel = function (part) {
+      return active.map(function (a) { return id + part.replace(/N/g, a.col); }).join(",");
+    };
+    for (var p = 0; p < active.length; p++) {
+      // th needs z 2: every header cell already carries z-index:1 (vertical stickiness), and a later
+      // unpinned sibling would otherwise paint OVER the docked one (equal z -> DOM order wins)
+      css += id + " th:nth-child(" + active[p].col + ")" +
+             "{position:sticky;left:" + active[p].left + "px;z-index:2}" +
+             id + " td:nth-child(" + active[p].col + ")" +
+             "{position:sticky;left:" + active[p].left + "px;z-index:1}";
+    }
+    // sticky cells float over the scrolled columns -> they need an opaque background per row state
+    css += sel(" thead th:nth-child(N)") + "{background:var(--accent-soft)}" +
+           sel(" tbody tr td:nth-child(N)") + "{background:var(--panel)}" +
+           sel(" tbody tr.zeb td:nth-child(N)") + "{background:#fafcfb}" +
+           sel(" tbody tr:hover td:nth-child(N)") + "{background:var(--accent-soft)}";
+    // shadows on the pinned edges, only once the table is actually scrolled sideways. A box-shadow
+    // per cell fades at every cell's corners (a scalloped edge), so each cell instead hangs a plain
+    // horizontal-gradient strip outside its right edge: the strips tile into ONE seamless shadow that
+    // only fades in over the header (the first cell) and out over the last row. EVERY pinned column
+    // carries it - a not-yet-docked pin has content sliding under its own right edge - and once
+    // columns dock, the inner strips are simply covered by the next pinned cell's opaque background.
+    // The layout css hides cell overflow -> lift that on pinned columns (safe: widths carry slack,
+    // nothing ever clips); th::after is the sort arrow, so the header strip rides on ::before.
+    var sth = sel(".xscrolled thead th:nth-child(N)");
+    var std = sel(".xscrolled tbody tr:not([data-empty]) td:nth-child(N)");
+    css += sth + "," + std + "{overflow:visible}" +
+           sel(".xscrolled thead th:nth-child(N)::before") + "," +
+           sel(".xscrolled tbody tr:not([data-empty]) td:nth-child(N)::after") +
+           "{content:'';position:absolute;top:0;bottom:0;right:-6px;width:6px;pointer-events:none;" +
+           "background:linear-gradient(to right,rgba(0,0,0,.22),rgba(0,0,0,0))}" +
+           sel(".xscrolled thead th:nth-child(N)::before") +
+           "{-webkit-mask-image:linear-gradient(rgba(0,0,0,0),#000);" +
+           "mask-image:linear-gradient(rgba(0,0,0,0),#000)}" +
+           // the bottom spacer is always the tbody's last child -> nth-last-child(2) is the last row
+           sel(".xscrolled tbody tr:nth-last-child(2) td:nth-child(N)::after") +
+           "{-webkit-mask-image:linear-gradient(#000,rgba(0,0,0,0));" +
+           "mask-image:linear-gradient(#000,rgba(0,0,0,0))}";
+    this.pinStyle.textContent = css;
+  };
+
+  Grid.prototype.markPins = function () {
+    var g = this;
+    Array.prototype.forEach.call(this.ths, function (th, i) {
+      var btn = th.querySelector(".pinbtn");
+      if (!btn) return;
+      var pinned = g.pins.indexOf(i + 1) >= 0;
+      th.classList.toggle("pinned", pinned);
+      btn.title = pinned ? TEXT.unpin : TEXT.pin;
+    });
+  };
+
+  Grid.prototype.initPinControls = function () {
+    var g = this;
+    Array.prototype.forEach.call(this.ths, function (th, i) {
+      if (th.classList.contains("actions")) return;      // pinning the trailing edit column is nonsense
+      var btn = document.createElement("span");
+      btn.className = "pinbtn";
+      btn.textContent = "📌";                  // 📌
+      btn.addEventListener("click", function (ev) {
+        ev.stopPropagation();                            // never trigger the header's sort click
+        g.togglePin(i + 1);
+      });
+      th.appendChild(btn);
+    });
+  };
+
+  // Freeze the column widths into generated CSS and switch the table to one flex row per <tr> — the
+  // windowed rows then always line up, whatever subset is attached. Widths are measured by attaching
+  // only the header plus the rows with the longest text per column (a full-table auto layout would cost
+  // seconds in Firefox). The result is remembered in localStorage, keyed by the db fingerprint, and
+  // re-applied by base.html BEFORE the table parses on the next visit.
+  function freezeLayout(table, grid) {
+    if (!table.id || !grid.rows.length) return;
+    var pre = window.__pregrids && window.__pregrids[table.id];
+    if (pre) {                                                     // stored layout already active
+      grid.rowH = +pre.rowH || grid.rowH;
+      grid.widths = pre.widths || null;
+      table.classList.add("flexgrid");
+      return;
+    }
+    var cols = grid.ths.length, candidates = {};
+    for (var c = 0; c < cols; c++) {
+      var top = grid.rows.slice().sort(function (x, y) {           // longest text per column
+        return (y.texts[c] || "").length - (x.texts[c] || "").length;
+      }).slice(0, 6);
+      for (var t = 0; t < top.length; t++) candidates[top[t].i] = top[t];
+    }
+    var att = Object.keys(candidates).map(function (k) { return candidates[k].el; });
+    grid.tbody.replaceChildren.apply(grid.tbody, att);             // measure with auto table layout
+    var id = "#" + table.id;
+    var rowH = att[0].getBoundingClientRect().height;
+    var css = id + "," + id + " thead," + id + " tbody{display:block}" +
+      id + " tr{display:flex;min-width:max-content}" +
+      id + " tr.vspace{display:block;min-width:0}" +
+      id + " th," + id + " td{flex:none;overflow:hidden;text-overflow:ellipsis;max-width:none}" +
+      id + " thead{position:sticky;top:0;z-index:1;background:var(--accent-soft)}" +
+      // striping follows the SORTED position (class set by render), not DOM position
+      id + " tbody tr:nth-child(even){background:transparent}" +
+      id + " tbody tr.zeb{background:#fafcfb}" +
+      id + " tbody tr:hover{background:var(--accent-soft)}";
+    var widths = [];
+    for (var i = 0; i < cols; i++) {
+      // slack so the widest cell never sprouts an ellipsis (widths come from longest-TEXT sampling)
+      var w = Math.ceil(grid.ths[i].getBoundingClientRect().width) + 6;
+      // ... but one very long Bemerkung must not push every other column off screen: cap the column and
+      // let it ellipsize, so more fits at a glance; hovering a cut-off cell shows its whole text (see
+      // showTip). A header may set its own, tighter cap (data-max): one long GB note or payer name
+      // otherwise decides how far right the RNr. sits on a small screen.
+      w = Math.min(w, +grid.ths[i].dataset.max || MAX_COL);
+      widths.push(w);
+      css += id + " th:nth-child(" + (i + 1) + ")," + id + " td:nth-child(" + (i + 1) + "){width:" + w + "px}";
+    }
+    var style = document.createElement("style");
+    style.textContent = css;
+    document.head.appendChild(style);
+    table.classList.remove("th-abbr");           // each column now abbreviates itself (ellipsis + showTip)
+    table.classList.add("flexgrid");
+    grid.rowH = rowH > 5 ? rowH : grid.rowH;
+    grid.widths = widths;                        // pinned-column offsets are computed from these
+    try {
+      if (window.__gridfp) localStorage.setItem("grid:" + table.id,
+        JSON.stringify({ v: STORE_V, fp: window.__gridfp, vw: window.innerWidth, css: css, rowH: grid.rowH,
+                         widths: widths }));
+    } catch (e) { /* storage full/blocked: just skip the head start next time */ }
+  }
+
+  // Headers carry FULL names; the tooltip always shows them. Non-grid tables (e.g. the quality page)
+  // additionally get the old shrink-to-fit abbreviation — grid columns ellipsize themselves.
+  function fitHeaders() {
+    document.querySelectorAll(".tablewrap table").forEach(function (table) {
+      if (!table.tHead || !table.tHead.rows.length) return;
+      Array.prototype.forEach.call(table.tHead.rows[0].cells, function (th) {
+        var full = th.textContent.trim();
+        if (full && !th.title) th.title = full;
+      });
+      if (table.classList.contains("grid")) return;
+      var wrap = table.closest(".tablewrap");
+      table.classList.remove("th-abbr");           // measure at full width first
+      if (table.scrollWidth > wrap.clientWidth + 1) table.classList.add("th-abbr");
+    });
+  }
+
+  // A cut-off cell's whole text, the moment the mouse is on it. The browser's own title tooltip is not
+  // good enough: it comes late, is tiny at 150 % display scaling, and Firefox drops it as soon as the
+  // mouse moves. So the grid shows its own box, at once, for every cell that is ACTUALLY cut off right
+  // now (measured live, whatever capped it), and for no other.
+  var tip = null;
+
+  function showTip(td) {
+    if (!tip) {
+      tip = document.createElement("div");
+      tip.className = "celltip";
+      document.body.appendChild(tip);
+    }
+    tip.textContent = td.textContent.trim();
+    tip.style.display = "block";
+    var r = td.getBoundingClientRect();
+    var top = r.bottom + 4;                                        // below the cell, above it near the bottom
+    if (top + tip.offsetHeight > window.innerHeight - 4) top = r.top - tip.offsetHeight - 4;
+    tip.style.left = Math.max(4, Math.min(r.left, window.innerWidth - tip.offsetWidth - 4)) + "px";
+    tip.style.top = top + "px";
+  }
+
+  function hideTip() {
+    if (tip) tip.style.display = "none";
+  }
+
+  function cutOff(td) {
+    return td.scrollWidth > td.clientWidth + 1;
+  }
+
+  var grids = {};
+  window.__grids = grids;             // for the Playwright checks — the model is otherwise unreachable
+
+  // The selected checkboxes of a grid — read from the MODEL, because windowed rendering keeps most
+  // rows detached (a plain querySelectorAll would only see the attached window).
+  // Printing. Two things stand in the way: the table only ever holds the visible ~30 rows in the DOM
+  // (the rest are two spacers), and 20 columns are wider than a sheet. So: attach all filtered rows,
+  // shrink the page until it fits ONE landscape sheet (never below MIN_ZOOM — below that it may take
+  // several pages), print, put everything back.
+  var PX_MM = 96 / 25.4, PAGE_W = (297 - 20) * PX_MM, PAGE_H = (210 - 20) * PX_MM, MIN_ZOOM = 0.45;
+
+  var printing = false, printedGrids = [];
+
+  // Preparing means: attach all filtered rows (normally the table holds only the visible ~30), switch
+  // the page to its paper view and shrink it until it fits one landscape sheet. Hooked on beforeprint,
+  // so Ctrl+P works exactly like the Drucken button.
+  function preparePrint() {
+    if (printing) return;
+    printing = true;
+    document.body.classList.add("printing");
+    printedGrids = [];
+    for (var id in grids) {
+      var g = grids[id];
+      if (!g.rows.length) continue;
+      var kids = [];
+      for (var i = 0; i < g.view.length; i++) {
+        g.view[i].el.classList.toggle("zeb", (i & 1) === 1);
+        kids.push(g.view[i].el);
+      }
+      g.tbody.replaceChildren.apply(g.tbody, kids);
+      var info = document.querySelector(".printinfo[data-grid='" + id + "']");
+      if (info) info.textContent = printLabel(id, g.view.length);
+      printedGrids.push(g);
+    }
+    if (printedGrids.length) {
+      var g0 = printedGrids[0];
+      fitToSheet(g0.table.closest("main") || document.body);
+    }
+  }
+
+  function restoreAfterPrint() {
+    if (!printing) return;
+    printing = false;
+    document.body.classList.remove("printing");
+    printedGrids.forEach(function (g) {
+      var main = g.table.closest("main");
+      if (main) main.style.zoom = "";
+      g.a = -1;
+      g.render();
+    });
+    printedGrids = [];
+  }
+
+  window.addEventListener("beforeprint", preparePrint);
+  window.addEventListener("afterprint", restoreAfterPrint);
+
+  window.gridPrint = function () {
+    preparePrint();
+    window.print();
+    setTimeout(restoreAfterPrint, 0);  // in case afterprint never comes (Safari/Firefox)
+  };
+
+  // On paper the sheet itself settles the WIDTH: in the print view the list is a real table again with
+  // width:100%, the columns shrink and text wraps. What is left is the HEIGHT. So the page is briefly set
+  // to the sheet's width on screen — text then wraps exactly as it will on paper — and the shrink factor
+  // comes from the measured height. Never below MIN_ZOOM: rather a second sheet than a magnifying glass.
+  // (zoom does not affect getBoundingClientRect in this engine, so measuring again after shrinking
+  // measures nothing.)
+  function fitToSheet(main) {
+    var before = main.style.width;
+    main.style.width = PAGE_W + "px";
+    var height = main.getBoundingClientRect().height;
+    main.style.width = before;
+    var zoom = PAGE_H / Math.max(1, height);
+    main.style.zoom = zoom < 0.999 ? Math.max(MIN_ZOOM, zoom) : "";
+    return zoom;
+  }
+
+  // What is on the sheet? Search and filters belong on it, or nobody knows any more what the list shows.
+  // (The German words here are UI text hardcoded in JS — to move into de.json: docs/plan.md.)
+  function printLabel(id, n) {
+    var parts = [];
+    var search = document.querySelector('.live-search[data-grid="' + id + '"]');
+    if (search && search.value.trim()) parts.push(TEXT.search.replace("{q}", search.value.trim()));
+    document.querySelectorAll('.live-filter[data-grid="' + id + '"]').forEach(function (sel) {
+      if (sel.value) parts.push(sel.dataset.col + ": " + sel.value);
+    });
+    parts.push(n === 1 ? TEXT.rows_one : TEXT.rows.replace("{n}", n));
+    parts.push(TEXT.date.replace("{date}", new Date().toLocaleDateString("de-AT")));
+    return parts.join("  •  ");
+  }
+
+  window.gridChecked = function (id) {
+    var g = grids[id], out = [];
+    if (!g) return out;
+    for (var i = 0; i < g.rows.length; i++) {
+      var cb = g.rows[i].el.querySelector(".rowsel");
+      if (cb && cb.checked) out.push(cb.value);
+    }
+    return out;
+  };
+
+  document.addEventListener("DOMContentLoaded", function () {
+    function refresh(name) {
+      var g = grids[name];
+      if (!g) return;
+      var search = document.querySelector('.live-search[data-grid="' + name + '"]');
+      // searching or filtering means looking for something specific — stop holding the bottom
+      if (g.ready && (search && search.value.trim())) g.stickEnd = false;
+      g.q = search ? search.value.trim().toLowerCase() : "";
+      g.filters = [];
+      document.querySelectorAll('.live-filter[data-grid="' + name + '"]').forEach(function (sel) {
+        var col = colIndex(g, sel.dataset.col);
+        if (sel.value && col >= 0) g.filters.push({ col: col, value: sel.value.toLowerCase() });
+      });
+      var shown = g.update();
+      var count = document.querySelector('.grid-count[data-grid="' + name + '"]');
+      if (count) count.textContent = shown;
+      // live sum over the VISIBLE rows of a marked money column (Excel's bottom SUM row equivalent)
+      document.querySelectorAll('.grid-sum[data-grid="' + name + '"]').forEach(function (el) {
+        el.textContent = g.sum(colIndex(g, el.dataset.col))
+          .toLocaleString("de-AT", { minimumFractionDigits: 2, maximumFractionDigits: 2 });
+      });
+    }
+
+    document.querySelectorAll("table.grid").forEach(function (table) {
+      if (!table.tHead || !table.tBodies.length || !table.id) return;
+      var g = grids[table.id] = new Grid(table);
+      Array.prototype.forEach.call(table.tHead.rows[0].cells, function (th, i) {
+        if (th.classList.contains("nosort")) return;
+        th.addEventListener("click", function () { g.headerClick(i); });
+      });
+      g.restoreSort();                             // the sort chosen on the last visit still applies
+    });
+
+    fitHeaders();
+    window.addEventListener("resize", fitHeaders);
+
+    // the dropdown filters chosen on the last visit still apply (per tab, like the sort) —
+    // restored BEFORE the first render below so counts, sums and rows come up already filtered
+    document.querySelectorAll(".live-filter[data-grid]").forEach(function (el) {
+      var key = "filter:" + el.dataset.grid + ":" + el.dataset.col;
+      try {
+        var saved = sessionStorage.getItem(key);
+        if (saved !== null) el.value = saved;      // a vanished option leaves the select unfiltered
+      } catch (e) { /* fine */ }
+      el.addEventListener("change", function () {
+        try {
+          if (el.value) sessionStorage.setItem(key, el.value);
+          else sessionStorage.removeItem(key);
+        } catch (e) { /* fine */ }
+      });
+    });
+
+    Object.keys(grids).forEach(function (name) {
+      var g = grids[name];
+      freezeLayout(g.table, g);
+      g.loadPins();                                // stored override, else the template's data-pin set
+      g.initPinControls();
+      g.applyPins();
+      refresh(name);                               // first window render (+ counts and sums)
+
+      // These grids ALWAYS open on their newest entries, the bottom row visible first, so nobody has to
+      // scroll down every time. Placing the pane once is not
+      // enough: the first rendered rows correct the row height, the spacers are resized from it, and the
+      // bottom moves away underneath us. So the grid STAYS glued to the end across those re-renders until
+      // the user actually touches it — wheel, drag, key, or a search/filter/sort. (No remembered scroll
+      // offset: it would reopen a long list anywhere; sorting is remembered, under its own key.)
+      g.stickEnd = g.table.dataset.scroll === "end";
+      g.ready = true;
+      g.placeAtNewest();
+      ["wheel", "mousedown", "touchstart", "keydown"].forEach(function (ev) {
+        g.wrap.addEventListener(ev, function () { g.stickEnd = false; }, { passive: true });
+      });
+      g.table.classList.toggle("xscrolled", g.wrap.scrollLeft > 0);
+      var pending = null;
+      g.wrap.addEventListener("mouseover", function (e) {
+        var td = e.target.closest ? e.target.closest("td") : null;
+        if (td && g.tbody.contains(td) && cutOff(td)) showTip(td);
+        else hideTip();
+      });
+      g.wrap.addEventListener("mouseleave", hideTip);
+      g.wrap.addEventListener("scroll", function () {
+        hideTip();                                 // the row under it is about to move or be detached
+        if (pending) return;
+        pending = requestAnimationFrame(function () {
+          pending = null;
+          g.render();
+          g.table.classList.toggle("xscrolled", g.wrap.scrollLeft > 0);
+        });
+      }, { passive: true });
+    });
+
+    var timer = null;
+    document.querySelectorAll(".live-search[data-grid]").forEach(function (el) {
+      el.addEventListener("input", function () {                   // debounced: not on every keystroke
+        clearTimeout(timer);
+        timer = setTimeout(function () { refresh(el.dataset.grid); }, 120);
+      });
+    });
+    document.querySelectorAll(".live-filter[data-grid]").forEach(function (el) {
+      el.addEventListener("change", function () { refresh(el.dataset.grid); });
+    });
+  });
+})();
diff --git a/app/static/style.css b/app/static/style.css
new file mode 100644
index 0000000..d538864
--- /dev/null
+++ b/app/static/style.css
@@ -0,0 +1,288 @@
+:root{
+  --ink:#1f2a24; --muted:#6b756e; --line:#d9e0da; --bg:#f4f6f3; --panel:#ffffff;
+  --accent:#2f6d5b; --accent-dark:#245645; --accent-soft:#e5efea;
+  --warn:#b4531a; --open:#b23a3a; --paid:#2e7d5b; --cash:#7a6a2e;
+}
+*{box-sizing:border-box}
+html,body{height:100%}
+body{margin:0;background:var(--bg);color:var(--ink);
+  font-family:"Segoe UI",system-ui,Arial,sans-serif;font-size:15px;line-height:1.45;
+  display:flex;flex-direction:column;height:100vh;overflow:hidden}
+a{color:var(--accent);text-decoration:none}
+a:hover{text-decoration:underline}
+
+.topbar{display:flex;flex-shrink:0;align-items:center;gap:28px;background:var(--accent);color:#fff;
+  padding:0 26px;height:56px;box-shadow:0 2px 6px rgba(0,0,0,.12)}
+.topbar .brand{font-size:20px;font-weight:700;letter-spacing:.2px}
+.topbar nav{display:flex;gap:6px;height:100%}
+.topbar nav a{color:#e8f2ee;padding:0 18px;display:flex;align-items:center;height:100%;
+  font-size:17px;border-bottom:4px solid transparent}
+.topbar nav a:hover{background:var(--accent-dark);text-decoration:none}
+.topbar nav a.active{color:#fff;border-bottom-color:#fff;font-weight:600}
+
+main{flex:1;min-height:0;overflow:auto;width:100%;max-width:1200px;margin:0 auto;padding:20px 26px 40px}
+/* grid pages fill the viewport so only the table scrolls (no second page scrollbar) */
+main.grid-page{max-width:none;overflow:hidden;display:flex;flex-direction:column;padding:12px 20px}
+.grid-page h1{margin:2px 0 10px;font-size:22px}
+
+.flash{background:#fff6e6;border:1px solid #e6c98a;color:#8a5a12;border-radius:8px;
+  padding:12px 16px;margin-bottom:18px;font-size:16px}
+
+h1{font-size:28px;margin:4px 0 20px}
+.toolbar{display:flex;align-items:center;gap:12px;margin-bottom:16px;flex-wrap:wrap}
+.toolbar .spacer{flex:1}
+.count{color:var(--muted);font-size:15px}
+
+.btn{display:inline-flex;align-items:center;gap:7px;background:var(--accent);color:#fff;
+  border:none;border-radius:8px;padding:10px 18px;font-size:16px;cursor:pointer;text-decoration:none}
+.btn:hover{background:var(--accent-dark);text-decoration:none}
+.btn.secondary{background:#eef2ef;color:var(--ink);border:1px solid var(--line)}
+.btn.secondary:hover{background:#e3e9e4}
+.btn.danger{background:#fff;color:var(--open);border:1px solid #e3b7b7}
+.btn.danger:hover{background:#fbeeee}
+.btn.small{padding:6px 12px;font-size:14px}
+.btn:disabled{opacity:.4;cursor:not-allowed}
+
+input[type=text],input[type=date],input[type=number],select{
+  font-size:16px;padding:9px 11px;border:1px solid var(--line);border-radius:8px;background:#fff;color:var(--ink)}
+input:focus,select:focus{outline:2px solid var(--accent-soft);border-color:var(--accent)}
+.search{min-width:280px}
+
+/* overflow-anchor off: the grids swap windowed rows in and out while scrolling — the browser's scroll
+   anchoring would fight that and make the list jump */
+.tablewrap{background:var(--panel);border:1px solid var(--line);border-radius:10px;overflow:auto;
+  overflow-anchor:none}
+.grid-page .tablewrap{flex:1;min-height:0}
+table{border-collapse:collapse;width:100%;font-size:13px}
+thead th{position:sticky;top:0;z-index:1;background:var(--accent-soft);color:var(--accent-dark);text-align:left;
+  padding:6px 9px;font-weight:600;white-space:nowrap;border-bottom:1px solid var(--line);
+  cursor:pointer;user-select:none}
+/* headers carry full names; th-abbr (set by grids.js when the table overflows its container)
+   abbreviates them with an ellipsis — the tooltip keeps the full name */
+table.th-abbr thead th{max-width:78px;overflow:hidden;text-overflow:ellipsis}
+/* pin toggle (Spalte fixieren): revealed on header hover at the LEFT edge — the sort arrows own the
+   right edge. Grid headers reserve room for it so the glyph never covers the title. */
+table.grid thead th{padding-left:20px}
+thead th .pinbtn{position:absolute;left:2px;top:50%;transform:translateY(-50%);
+  font-size:10px;line-height:1;padding:2px;cursor:pointer;opacity:0}
+thead th:hover .pinbtn{opacity:.45}
+thead th .pinbtn:hover,thead th.pinned .pinbtn{opacity:1}
+thead th:hover{background:#d7e6df}
+/* sort indicator, pinned to the header's right edge so an abbreviated title can't swallow it;
+   with several sort levels (shift-click) the priority number follows the arrow */
+thead th[data-sd]{padding-right:24px}
+thead th[data-sd]::after{position:absolute;right:6px;font-size:10px}
+thead th[data-sd="a"]::after{content:"\25B2" attr(data-prio)}
+thead th[data-sd="d"]::after{content:"\25BC" attr(data-prio)}
+tbody td{padding:2px 9px;border-bottom:1px solid #eef1ee;white-space:nowrap}
+/* the ledger has 20 columns — give its cells less air so more of them fit on screen */
+table.grid tbody td{padding-left:7px;padding-right:7px}
+table.grid thead th{padding-left:14px;padding-right:7px}
+table.grid td.actions .btn.small{padding:4px 9px}
+/* a right-aligned number needs no room on its LEFT, and the pin glyph can't collide with it either —
+   so Satz/Anz/Pers/Betrag and the checkbox column give that space back */
+table.grid thead th.num,table.grid tbody td.num{padding-left:4px}
+table.grid thead th:first-child,table.grid tbody td:first-child{padding-left:5px;padding-right:5px}
+tbody tr:nth-child(even){background:#fafcfb}
+tbody tr:hover{background:var(--accent-soft)}
+td.num,th.num{text-align:right;font-variant-numeric:tabular-nums}
+td.actions{text-align:right}
+.empty{padding:40px;text-align:center;color:var(--muted)}
+
+.pill{display:inline-block;padding:2px 10px;border-radius:999px;font-size:13px;font-weight:600}
+.pill.paid{background:#e4f0ea;color:var(--paid)}
+.pill.open{background:#f7e3e3;color:var(--open)}
+.pill.cash{background:#f2eed9;color:var(--cash)}
+.pill.unit{background:#e9edf5;color:#3a4a6b}
+.pill.have{background:#eef1ef;color:#5a6b62}
+/* the whole text of a cut-off list cell, on hover (grids.js showTip) */
+.celltip{position:fixed;z-index:50;display:none;max-width:480px;padding:6px 11px;background:var(--panel);
+  color:var(--ink);border:1px solid var(--line);border-radius:8px;box-shadow:0 4px 14px rgba(0,0,0,.15);
+  font-size:15px;line-height:1.35;white-space:normal;pointer-events:none}
+
+/* Umsatzsteuer-Voranmeldung: one table with its sum per room, the summary at the end */
+.vat-room h2,.vat-total h2{font-size:19px;margin:22px 0 6px}
+.vat-room tfoot td{padding:4px 9px;font-weight:700;border-top:2px solid var(--line)}
+.vat-total table{width:auto;min-width:420px;font-size:16px;background:var(--panel);
+  border:1px solid var(--line);border-radius:10px}
+.vat-total td{padding:5px 14px;border-bottom:1px solid #eef1ee}
+.vat-total td.num{padding-left:40px}
+.vat-total tr.key td{font-weight:700}
+
+/* home */
+.cards{display:grid;grid-template-columns:repeat(auto-fit,minmax(200px,1fr));gap:16px;margin:20px 0 30px}
+.card{background:var(--panel);border:1px solid var(--line);border-radius:12px;padding:20px 22px}
+.card .n{font-size:34px;font-weight:700;color:var(--accent-dark)}
+.card .l{color:var(--muted);margin-top:4px}
+.lead{font-size:18px;color:var(--muted);max-width:60ch}
+.quicklinks{display:flex;gap:14px;flex-wrap:wrap;margin-top:10px}
+
+/* forms */
+form.card{max-width:720px;margin:0 auto}
+.field{display:flex;flex-direction:column;gap:6px;margin-bottom:16px}
+.field label{font-weight:600;font-size:15px}
+.grid2{display:grid;grid-template-columns:1fr 1fr;gap:16px}
+/* an invoice dated against the number order: the deliberate exception (invoice_form) */
+.confirm-order{display:flex;align-items:center;gap:8px;margin:2px 0 14px;padding:8px 12px;font-size:15px;
+  background:#fff6e6;border:1px solid #e6c98a;border-radius:8px;color:#8a5a12}
+.client-choices{flex-direction:column;align-items:flex-start}
+.client-choices .btn.picked{background:var(--accent);color:#fff}
+/* payments in parts: one line of date + amount each (ledger_form) */
+.pay-line{display:grid;grid-template-columns:1fr 1fr;gap:16px;margin-bottom:8px}
+#addPayment{align-self:flex-start;margin-bottom:6px}
+.formactions{display:flex;gap:12px;margin-top:24px}
+
+/* Belegungsplan: rooms × days timeline. The day columns are fractional (1fr), so the plan always
+   fills the viewport width exactly — no horizontal scrolling at any display scaling (up to 200%).
+   Only the room rows scroll vertically; the date header sticks. */
+.planwrap{overflow-y:auto;overflow-x:hidden}
+.plan{--labelw:112px;--laneh:26px;min-width:600px}
+.plan-hrow,.plan-row{display:flex}
+.plan-row{border-bottom:1px solid var(--line)}
+.plan-row.newfloor{border-top:2px solid var(--line)}
+.plan-label{flex:0 0 var(--labelw);padding:4px 10px;border-right:1px solid var(--line);min-width:0}
+.plan-cells{flex:1;display:grid;grid-template-columns:repeat(var(--days),1fr);min-width:0}
+.plan-head{position:sticky;top:0;z-index:3;background:var(--panel);box-shadow:0 2px 4px rgba(0,0,0,.07)}
+/* the month row closes with a full-width line */
+.plan-head .plan-hrow:first-child{border-bottom:1px solid var(--line)}
+.plan-head .plan-hrow + .plan-hrow .plan-label{border-bottom:1px solid var(--line)}
+.pm{font-size:12px;font-weight:600;color:var(--accent-dark);padding:3px 5px 1px 8px;
+  border-left:1px solid #b9c4bb;white-space:nowrap;overflow:hidden;text-overflow:ellipsis}
+/* the label column already draws the divider — no doubled line on the first day column */
+.pm:first-child,.pd:first-child{border-left:none}
+.pd{border-left:1px solid #eef1ee;border-bottom:1px solid var(--line);text-align:center;
+  padding:1px 0 3px;overflow:visible;min-width:0}
+.pd b{display:block;font-size:12px;line-height:1.25;white-space:nowrap}
+.pd span{display:block;font-size:10px;color:var(--muted);line-height:1.2}
+.pd.we{background:#f2f4f0}
+.pd.mon{border-left-color:var(--line)}
+/* weekend and today columns are bounded on BOTH sides ('x + y' colors the following cell's left
+   border = this column's end line), at normal 1px line thickness. Precedence weekend < month <
+   today is enforced by DOUBLED classes (today is often also .we — a Sunday — and the '+' selectors
+   carry an extra element of specificity that a single class cannot beat). */
+.pd.we,.pd.we + .pd{border-left-color:#c9d2ca}
+.pd.m1.m1{border-left-color:#b9c4bb}   /* month boundary: continuous from the month row down */
+.pd.today{background:#fff3d6}
+.pd.today.today,.pd.today.today + .pd{border-left-color:var(--warn)}
+.pd.today b{color:var(--warn)}
+.plan-lanes{grid-template-rows:repeat(var(--lanes),var(--laneh));position:relative;
+  align-content:center}
+/* room rows carry only neutral day grid lines — the weekend/today accents live in the header
+   alone. The lines are a full-height absolute overlay so they span the whole row even when the
+   room label makes the row taller than the lane stack. */
+.daylines{position:absolute;inset:0;display:grid;grid-template-columns:repeat(var(--days),1fr);
+  pointer-events:none}
+.daylines i{border-left:1px solid #f0f3ef}
+.daylines i.mon{border-left-color:var(--line)}
+.daylines i.we,.daylines i.we + i{border-left-color:#c9d2ca}
+.daylines i.m1.m1{border-left-color:#b9c4bb}
+.daylines i.today.today,.daylines i.today.today + i{border-left-color:var(--warn)}
+.daylines i:first-child{border-left:none}
+/* weekend/today column tints, same hues as the header */
+.daylines i.we{background:#f2f4f0}
+.daylines i.today{background:#fff3d6}
+.plan-lanes.longterm{background:repeating-linear-gradient(45deg,#f3f5f2 0 8px,#eaeeea 8px 16px)}
+/* ALL grid lines (month boundaries included) sit BEHIND cell content — the opaque
+   Dauervermietung filling covers its whole row, so these rows draw no lines or tints */
+.plan-lanes.longterm .daylines{display:none}
+.lt-note{grid-column:1/-1;grid-row:1/-1;align-self:center;padding:0 10px;color:var(--muted);
+  font-size:12px;z-index:1;white-space:nowrap;overflow:hidden;text-overflow:ellipsis}
+.rl-top{display:flex;align-items:center;gap:6px;white-space:nowrap}
+.rl-top b{font-size:14px}
+.rl-top .pill{font-size:11px;padding:1px 7px}
+.rl-sub{font-size:11px;color:var(--muted);white-space:nowrap}
+.bar{z-index:1;margin:2px 1px;border-radius:5px;font-size:12.5px;line-height:calc(var(--laneh) - 5px);
+  padding:0 7px;overflow:hidden;text-overflow:ellipsis;white-space:nowrap;min-width:0;color:#fff}
+.bar:hover{text-decoration:none;filter:brightness(1.08)}
+.bar.current{background:var(--accent)}
+.bar.past{background:#b9c9c0;color:#2c3a32}
+.bar.future{background:var(--accent-soft);color:var(--accent-dark);box-shadow:inset 0 0 0 1px var(--accent)}
+/* a stay running past the window edge (or an open departure) gets a pointed end */
+.bar.clipend{clip-path:polygon(0 0,calc(100% - 8px) 0,100% 50%,calc(100% - 8px) 100%,0 100%);padding-right:13px}
+.bar.clipstart{clip-path:polygon(8px 0,100% 0,100% 100%,8px 100%,0 50%);padding-left:13px}
+.bar.clipstart.clipend{clip-path:polygon(8px 0,calc(100% - 8px) 0,100% 50%,calc(100% - 8px) 100%,8px 100%,0 50%)}
+.plan-foot{flex-shrink:0;display:flex;gap:16px;align-items:center;flex-wrap:wrap;
+  padding:8px 2px 0;color:var(--muted);font-size:13px}
+.plan-foot .key{display:inline-block;width:14px;height:14px;border-radius:4px;
+  vertical-align:-2px;margin-right:5px}
+.plan-unplaced a{margin-left:2px}
+.seg{display:inline-flex;border:1px solid var(--line);border-radius:8px;overflow:hidden;background:#fff}
+.seg a{padding:7px 13px;font-size:14px;color:var(--ink)}
+.seg a:hover{background:#eef2ef;text-decoration:none}
+.seg a.on{background:var(--accent);color:#fff}
+
+/* at 150–200% display scaling (≈960–1280 CSS px on a 24" monitor) the chrome steps down so no page
+   ever grows a horizontal scrollbar */
+@media (max-width:1280px){
+  .topbar{gap:16px;padding:0 14px}
+  .topbar .brand{font-size:17px}
+  .topbar nav a{padding:0 11px;font-size:15px}
+}
+@media (max-width:1020px){
+  .topbar .brand{display:none}
+  main{padding-left:14px;padding-right:14px}
+  main.grid-page{padding:10px 12px}
+}
+
+/* printing an app page (e.g. the TVB Meldung for the folder): the app shell scrolls inside a fixed
+   viewport, which would clip everything to one page — undo that and drop chrome/warnings.
+   MUST stay at the END of the file: several rules here tie on specificity with base rules above
+   (tbody td, body) and win only by source order. */
+.printinfo{display:none}
+
+/* Print view. Two roads lead here: Ctrl+P (media print) and the Drucken button, which measures the page
+   BEFORE printing to shrink it onto one sheet — for that it must already look on screen as it will on
+   paper, or the toolbar is measured too. Hence the same rules under body.printing (measuring) and
+   @media print (paper). */
+body.printing .topbar,body.printing .toolbar,body.printing .flash{display:none}
+body.printing{background:#fff;height:auto;overflow:visible;display:block}
+body.printing main{overflow:visible;height:auto;max-width:none;padding:0;background:#fff}
+body.printing .tablewrap{max-height:none;overflow:visible;box-shadow:none;border:0;background:#fff}
+body.printing .printinfo{display:block;margin:0 0 8px;font-size:12px;color:#333}
+body.printing .grid th,body.printing .grid td{position:static}
+body.printing tbody td{white-space:normal}
+/* Umsatzsteuer list: only the name may wrap — otherwise every cell breaks on paper ("2026-/49") */
+.vat-room td,body.printing .vat-room td{white-space:nowrap}
+.vat-room tbody td:nth-child(2),body.printing .vat-room tbody td:nth-child(2){white-space:normal}
+/* On screen the columns are frozen to fixed pixel widths (freezeLayout, flex rows). On paper the table
+   must be a real table again: then the columns shrink to their content and long texts wrap instead of
+   pushing the list past the sheet's edge. */
+body.printing .grid,body.printing .grid thead,body.printing .grid tbody,body.printing .grid tr,
+body.printing .grid th,body.printing .grid td{display:revert!important;min-width:0!important}
+body.printing .grid{width:100%!important;table-layout:auto!important;border-collapse:collapse}
+body.printing .grid thead{display:table-header-group!important;position:static!important}
+body.printing .grid th,body.printing .grid td{width:auto!important;max-width:none!important;
+  overflow:visible!important;text-overflow:clip!important;white-space:normal!important;
+  padding:2px 5px!important;font-size:12px!important;line-height:1.25!important}
+body.printing .grid tr{break-inside:avoid}
+body.printing .grid td.num,body.printing .grid .nowrap{white-space:nowrap!important}
+/* after the display:revert rules, or revert wins over the hiding */
+body.printing .grid .selcol,body.printing .grid .actions,body.printing .pinbtn{display:none!important}
+body.printing .grid .pill{border:0;padding:0;background:none!important;color:inherit!important;font-weight:600}
+
+@media print {
+  /* Landscape for the wide lists (the named page "list"); everything else portrait — the TVB report sets
+     its landscape itself (tvb.html). Printed duplex in landscape, the printer must flip "on the short
+     edge", or the back side stands on its head — no page can set that itself. */
+  @page{size:A4 portrait;margin:10mm}
+  @page list{size:A4 landscape;margin:10mm}
+  main.grid-page{page:list}
+  body{display:block;height:auto;overflow:visible;background:#fff}
+  .topbar,.noprint,.flash,.toolbar,.celltip{display:none!important}
+  main{overflow:visible;height:auto;max-width:none;padding:0;background:#fff}
+  .tablewrap{max-height:none!important;overflow:visible;box-shadow:none;border:0;background:#fff}
+  tbody td{white-space:normal}      /* long Hinweis texts wrap instead of running off the sheet */
+  td.note div{max-width:240px}      /* cells ignore max-width in auto layout — cap the inner block */
+  .tvb-unit + .tvb-unit{page-break-before:always}
+  .tvb-summary,.tvb-summary .tablewrap{break-inside:avoid}   /* Feratel tables never split over pages */
+  .tvb-feratel{break-inside:avoid}   /* ... and their heading and total travel WITH them */
+  .vat-room,.vat-total{break-inside:avoid}   /* a room with its sum on one sheet */
+  /* the list on paper: checkboxes, the edit button and the pin say nothing there, pinned columns must
+     not stick over the others, the header row repeats on every sheet */
+  .grid .selcol,.grid .actions,.pinbtn{display:none}
+  .grid th,.grid td{position:static!important}
+  .grid thead{display:table-header-group}
+  .grid tr{break-inside:avoid}
+  .printinfo{display:block;margin:0 0 8px;font-size:12px;color:#333}
+}
+
diff --git a/app/templates/base.html b/app/templates/base.html
new file mode 100644
index 0000000..78a730f
--- /dev/null
+++ b/app/templates/base.html
@@ -0,0 +1,62 @@
+<!doctype html>
+<html lang="de">
+<head>
+  <meta charset="utf-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1">
+  <title>{{ t('app_title') }}</title>
+  {# a house emoji as favicon: kills the browser's /favicon.ico 404 on every page load #}
+  <link rel="icon" href="data:image/svg+xml,<svg xmlns=%22http://www.w3.org/2000/svg%22 viewBox=%220 0 100 100%22><text y=%22.9em%22 font-size=%2290%22>🏠</text></svg>">
+  <link rel="stylesheet" href="{{ url_for('static', filename='style.css') }}">
+  <script data-fp="{{ db_fp }}">
+    // Re-apply the grid layouts measured on an earlier visit BEFORE the tables parse, so the browser
+    // never has to lay out thousands of rows at once (grids.js stores them, keyed by a db fingerprint —
+    // any data change re-measures). See freezeLayout() in grids.js.
+    (function () {
+      try {
+        var fp = document.currentScript.dataset.fp;
+        window.__gridfp = fp;
+        window.__pregrids = {};
+        for (var i = localStorage.length - 1; i >= 0; i--) {
+          var k = localStorage.key(i);
+          if (k.indexOf("grid:") !== 0) continue;
+          var v = JSON.parse(localStorage.getItem(k));
+          if (v.v !== 5) { localStorage.removeItem(k); continue; }   // older stored format: re-measure
+          if (v.fp === fp && v.vw === window.innerWidth) {
+            var s = document.createElement("style");
+            s.textContent = v.css;
+            document.head.appendChild(s);
+            window.__pregrids[k.slice(5)] = { rowH: v.rowH || 1, widths: v.widths || null };
+          } else if (v.fp !== fp) {
+            localStorage.removeItem(k);
+          }
+        }
+      } catch (e) { /* no stored layout -> the table measures itself after load */ }
+    })();
+  </script>
+  <script>window.GRID_TEXT = {{ {'search': t('print_search'), 'rows': t('print_rows'), 'rows_one': t('print_rows_one'),
+                                'date': t('print_date'), 'pin': t('pin_tip'), 'unpin': t('unpin_tip')}|tojson }};</script>
+  <script src="{{ url_for('static', filename='grids.js') }}" defer></script>
+</head>
+<body>
+  <header class="topbar">
+    <div class="brand">{{ t('app_title') }}</div>
+    <nav>
+      <a href="{{ url_for('home') }}" class="{{ 'active' if request.endpoint == 'home' }}">{{ t('nav_home') }}</a>
+      <a href="{{ url_for('register') }}" class="{{ 'active' if request.endpoint in ('register','stay_form') }}">{{ t('nav_register') }}</a>
+      <a href="{{ url_for('ledger') }}" class="{{ 'active' if request.endpoint == 'ledger' }}">{{ t('nav_ledger') }}</a>
+      <a href="{{ url_for('plan_page') }}" class="{{ 'active' if request.endpoint == 'plan_page' }}">{{ t('nav_plan') }}</a>
+      <a href="{{ url_for('invoices') }}" class="{{ 'active' if request.endpoint and request.endpoint.startswith('invoice') }}">{{ t('nav_invoices') }}</a>
+      <a href="{{ url_for('clients') }}" class="{{ 'active' if request.endpoint and request.endpoint.startswith('client') }}">{{ t('nav_clients') }}</a>
+      <a href="{{ url_for('tvb_page') }}" class="{{ 'active' if request.endpoint == 'tvb_page' }}">{{ t('nav_tvb') }}</a>
+      <a href="{{ url_for('vat_page') }}" class="{{ 'active' if request.endpoint == 'vat_page' }}">{{ t('nav_vat') }}</a>
+      <a href="{{ url_for('quality_page') }}" class="{{ 'active' if request.endpoint and request.endpoint.startswith('quality') }}">{{ t('nav_quality') }}</a>
+    </nav>
+  </header>
+  <main class="{% block main_class %}{% endblock %}">
+    {% with msgs = get_flashed_messages() %}
+      {% if msgs %}<div class="flash">{% for m in msgs %}<div>{{ m }}</div>{% endfor %}</div>{% endif %}
+    {% endwith %}
+    {% block content %}{% endblock %}
+  </main>
+</body>
+</html>
diff --git a/app/templates/client_form.html b/app/templates/client_form.html
new file mode 100644
index 0000000..a909f6f
--- /dev/null
+++ b/app/templates/client_form.html
@@ -0,0 +1,126 @@
+{% extends "base.html" %}
+{% block content %}
+  <h1>{{ t('form_edit_client') }} – {{ comp.name }}</h1>
+
+  <form class="card" method="post" style="max-width:900px">
+    <div class="grid2">
+      <div class="field"><label>{{ t('col_name') }} *</label>
+        <input type="text" name="name" value="{{ comp.name }}" required></div>
+      <div class="field"><label>{{ t('col_kind') }}</label>
+        <select name="kind">
+          <option value="company" {{ 'selected' if comp.kind != 'private' }}>{{ t('kind_company') }}</option>
+          <option value="private" {{ 'selected' if comp.kind == 'private' }}>{{ t('kind_private') }}</option>
+        </select></div>
+    </div>
+    <div class="grid2">
+      <div class="field"><label>{{ t('col_uid') }}</label>
+        <input type="text" name="uid" value="{{ comp.uid or '' }}"></div>
+      <div class="field"><label>{{ t('col_email') }}</label>
+        <input type="text" name="email" value="{{ comp.email or '' }}"></div>
+    </div>
+    <div class="grid2">
+      <div class="field"><label>{{ t('col_phone') }}</label>
+        <input type="text" name="phone" value="{{ comp.phone or '' }}"></div>
+      <div class="field"><label>{{ t('col_notes') }}</label>
+        <input type="text" name="notes" value="{{ comp.notes or '' }}"></div>
+    </div>
+
+    {% if comp.aliases %}
+    <div class="field"><label>{{ t('lbl_known_spellings') }}</label>
+      <div style="color:#6b756e; font-size:13px">{{ comp.aliases|join(' · ') }}</div></div>
+    {% endif %}
+
+    <div class="formactions">
+      <button class="btn" type="submit">{{ t('btn_save') }}</button>
+      <a class="btn secondary" href="{{ url_for('clients') }}">{{ t('btn_cancel') }}</a>
+    </div>
+  </form>
+
+  <div class="card" style="max-width:900px; margin:16px auto 0">
+    <h3 style="margin:0 0 8px">{{ t('lbl_addresses') }}</h3>
+    <div class="tablewrap" style="max-height:none">
+      <table>
+        <thead><tr><th>{{ t('lbl_address_current') }}</th><th>{{ t('col_name') }}</th><th>{{ t('col_address') }}</th><th>{{ t('col_postcode') }}</th>
+          <th>{{ t('col_city') }}</th><th></th></tr></thead>
+        <tbody>
+          {% for v in comp.versions %}
+          <tr>
+            <td style="text-align:center">{% if v.id == comp.current_client_id %}<span style="color:var(--accent); font-weight:700" title="{{ t('lbl_current_address_short') }}">✓</span>{% endif %}</td>
+            <td>{{ v.name }}</td><td>{{ v.address or '' }}</td><td>{{ v.postcode or '' }}</td><td>{{ v.city or '' }}</td>
+            <td style="white-space:nowrap; text-align:right">
+              <button type="button" class="btn secondary small" onclick="document.getElementById('addr-{{ v.id }}').showModal()">{{ t('btn_edit') }}</button>
+              <form method="post" style="display:inline" onsubmit="return confirm('{{ t('confirm_delete_address') }}')">
+                <input type="hidden" name="client_id" value="{{ v.id }}">
+                <button class="btn danger small" name="action" value="delete_address"
+                        title="{{ v.stays }} {{ t('home_stays') }} · {{ v.invoices }} {{ t('nav_invoices') }}"
+                        {{ 'disabled' if (v.stays + v.invoices) or comp.versions|length < 2 }}>{{ t('btn_delete') }}</button>
+              </form>
+            </td>
+          </tr>
+          {% endfor %}
+        </tbody>
+      </table>
+    </div>
+  </div>
+
+  {% for v in comp.versions %}
+  <dialog id="addr-{{ v.id }}" style="border:1px solid var(--line); border-radius:12px; padding:22px; max-width:520px; width:92%">
+    <form method="post">
+      <input type="hidden" name="client_id" value="{{ v.id }}">
+      <h3 style="margin:0 0 14px">{{ t('lbl_edit_address') }}</h3>
+      <div class="field"><label>{{ t('col_name') }}</label><input type="text" name="name" value="{{ v.name }}"></div>
+      <div class="field"><label>{{ t('col_address') }}</label><input type="text" name="address" value="{{ v.address or '' }}"></div>
+      <div class="grid2">
+        <div class="field"><label>{{ t('col_postcode') }}</label><input type="text" name="postcode" value="{{ v.postcode or '' }}"></div>
+        <div class="field"><label>{{ t('col_city') }}</label><input type="text" name="city" value="{{ v.city or '' }}"></div>
+      </div>
+      <div class="formactions" style="margin-top:16px; flex-wrap:wrap">
+        <button class="btn" type="submit" name="action" value="edit_address">{{ t('btn_save') }}</button>
+        {% if v.id != comp.current_client_id %}
+        <button class="btn secondary" type="submit" name="action" value="make_current">{{ t('btn_make_current') }}</button>
+        {% endif %}
+        <button class="btn secondary" type="button" onclick="this.closest('dialog').close()">{{ t('btn_cancel') }}</button>
+      </div>
+    </form>
+  </dialog>
+  {% endfor %}
+
+  <form class="card" method="post" style="max-width:900px; margin-top:16px">
+    <input type="hidden" name="action" value="add_address">
+    <h3 style="margin:0 0 8px">{{ t('lbl_new_address') }}</h3>
+    <div class="field"><label>{{ t('col_address') }}</label><input type="text" name="address"></div>
+    <div class="grid2">
+      <div class="field"><label>{{ t('col_postcode') }}</label><input type="text" name="postcode"></div>
+      <div class="field"><label>{{ t('col_city') }}</label><input type="text" name="city"></div>
+    </div>
+    <div class="field"><label><input type="checkbox" name="make_current" checked> {{ t('lbl_use_from_now') }}</label></div>
+    <div class="formactions"><button class="btn secondary" type="submit">{{ t('btn_add_address') }}</button></div>
+  </form>
+
+  <form class="card" method="post" style="max-width:900px; margin-top:16px"
+        onsubmit="return confirm('{{ t('confirm_merge') }}')">
+    <input type="hidden" name="action" value="merge">
+    <h3 style="margin:0 0 8px">{{ t('lbl_merge') }}</h3>
+    <p style="color:#6b756e; font-size:13px; margin:0 0 10px">{{ t('merge_hint') }}</p>
+    <div class="field"><label>{{ t('lbl_merge_into') }}</label>
+      <select name="merge_into">
+        <option value="">—</option>
+        {% for o in others %}<option value="{{ o.id }}">{{ o.name }}</option>{% endfor %}
+      </select></div>
+    <div class="formactions"><button class="btn danger" type="submit">{{ t('btn_merge') }}</button></div>
+  </form>
+
+  {% set refs = (comp.versions|sum(attribute='stays')) + (comp.versions|sum(attribute='invoices')) %}
+  <form class="card" method="post" style="max-width:900px; margin-top:16px"
+        action="{{ url_for('client_delete', company_id=comp.id) }}"
+        onsubmit="return confirm('{{ t('confirm_delete_company') }}')">
+    <h3 style="margin:0 0 8px">{{ t('lbl_delete_company') }}</h3>
+    <p style="color:#6b756e; font-size:13px; margin:0 0 10px">{{ t('delete_company_hint') }}</p>
+    <div class="formactions">
+      <button class="btn danger" type="submit" {{ 'disabled' if refs }}>{{ t('btn_delete_company') }}</button>
+      {% if refs %}<span style="color:#6b756e; font-size:13px">
+        {{ comp.versions|sum(attribute='stays') }} {{ t('home_stays') }} ·
+        {{ comp.versions|sum(attribute='invoices') }} {{ t('nav_invoices') }}</span>{% endif %}
+    </div>
+  </form>
+{% endblock %}
diff --git a/app/templates/clients.html b/app/templates/clients.html
new file mode 100644
index 0000000..1e40b90
--- /dev/null
+++ b/app/templates/clients.html
@@ -0,0 +1,39 @@
+{% extends "base.html" %}
+{% block main_class %}grid-page{% endblock %}
+{% block content %}
+  <h1>{{ t('clients_title') }}</h1>
+  <div class="toolbar">
+    <input class="search live-search" data-grid="cli" type="text" placeholder="{{ t('search_placeholder') }}">
+    <span class="count"><span class="grid-count" data-grid="cli">{{ rows|length }}</span> {{ t('showing_count', count='')|trim }}</span>
+    <span class="spacer"></span>
+  </div>
+  <div class="tablewrap">
+    <table id="cli" class="grid">
+      <thead><tr>
+        <th>{{ t('col_name') }}</th><th>{{ t('col_kind') }}</th><th>{{ t('col_address_current') }}</th>
+        <th class="num">{{ t('col_versions') }}</th><th class="num">{{ t('home_stays') }}</th>
+        <th class="num">{{ t('nav_invoices') }}</th><th>{{ t('col_uid') }}</th><th class="nosort actions"></th>
+      </tr></thead>
+      <tbody>
+        {# rows ship inside an inert <template>: grids.js renders only the visible window (see freezeLayout) #}
+        <template>
+        {% for r in rows %}
+        <tr>
+          <td>{{ r.name }}</td>
+          <td>{{ t('kind_private') if r.kind == 'private' else t('kind_company') }}</td>
+          <td>{{ r.cur_address or '' }}{% if r.cur_postcode or r.cur_city %}, {{ r.cur_postcode or '' }} {{ r.cur_city or '' }}{% endif %}</td>
+          <td class="num">{{ r.versions }}</td>
+          <td class="num">{{ r.stays }}</td>
+          <td class="num">{{ r.invoices }}</td>
+          <td>{{ r.uid or '' }}</td>
+          <td class="actions"><a class="btn secondary small" href="{{ url_for('client_edit', company_id=r.id) }}">{{ t('btn_edit') }}</a></td>
+        </tr>
+        {% endfor %}
+        </template>
+        {% if not rows %}
+        <tr data-empty="1"><td class="empty" colspan="8">{{ t('no_results') }}</td></tr>
+        {% endif %}
+      </tbody>
+    </table>
+  </div>
+{% endblock %}
diff --git a/app/templates/error.html b/app/templates/error.html
new file mode 100644
index 0000000..9b79190
--- /dev/null
+++ b/app/templates/error.html
@@ -0,0 +1,5 @@
+{% extends "base.html" %}
+{% block content %}
+  <h1>{{ t('err_generic') if not message else message }}</h1>
+  <p><a class="btn" href="{{ url_for('home') }}">{{ t('nav_home') }}</a></p>
+{% endblock %}
diff --git a/app/templates/home.html b/app/templates/home.html
new file mode 100644
index 0000000..675f4e3
--- /dev/null
+++ b/app/templates/home.html
@@ -0,0 +1,17 @@
+{% extends "base.html" %}
+{% block content %}
+  <h1>{{ t('home_welcome') }}</h1>
+  <p class="lead">{{ t('home_intro') }}</p>
+  <div class="cards">
+    <div class="card"><div class="n">{{ stats.guests|num(0) }}</div><div class="l">{{ t('home_guests') }}</div></div>
+    <div class="card"><div class="n">{{ stats.stays|num(0) }}</div><div class="l">{{ t('home_stays') }}</div></div>
+    <div class="card"><div class="n">{{ stats.invoices|num(0) }}</div><div class="l">{{ t('home_invoices') }}</div></div>
+    <div class="card"><div class="n">{{ stats.open|num(0) }}</div><div class="l">{{ t('home_open') }}</div></div>
+  </div>
+  <div class="quicklinks">
+    <a class="btn" href="{{ url_for('plan_page') }}">{{ t('nav_plan') }}</a>
+    <a class="btn" href="{{ url_for('register') }}">{{ t('nav_register') }}</a>
+    <a class="btn" href="{{ url_for('ledger') }}">{{ t('nav_ledger') }}</a>
+    <a class="btn" href="{{ url_for('invoices') }}">{{ t('nav_invoices') }}</a>
+  </div>
+{% endblock %}
diff --git a/app/templates/invoice_form.html b/app/templates/invoice_form.html
new file mode 100644
index 0000000..1566b01
--- /dev/null
+++ b/app/templates/invoice_form.html
@@ -0,0 +1,123 @@
+{% extends "base.html" %}
+{% block content %}
+  <style>
+    /* keep all 9 line columns visible without horizontal scrolling */
+    #lines input[type=date] { width: 132px; }
+    #lines td, #lines th { padding: 6px 4px; }
+  </style>
+  <h1>{{ t('form_edit_invoice') if editing else t('form_new_invoice') }}</h1>
+  <datalist id="dl_client">{% for v in (suggest|default({})).client|default([]) %}<option value="{{ v }}">{% endfor %}</datalist>
+  <form class="card" method="post" style="max-width:1240px">
+    <div class="grid2">
+      <div class="field"><label>{{ t('lbl_unit') }} *</label>
+        <select name="unit_id" onchange="setNumber(true)">
+          {% for u in units %}
+            <option value="{{ u.id }}" {{ 'selected' if form.get('unit_id')|string == u.id|string }}>{{ u.code }} – {{ u.name }}</option>
+          {% endfor %}
+        </select></div>
+      <div class="field"><label>{{ t('lbl_client') }} *</label>
+        <input type="text" name="client" required value="{{ form.get('client','') }}" list="dl_client"></div>
+    </div>
+    {# a recipient without an address: the companies the name may mean, or the deliberate exception #}
+    {% if client_choices is not none or form.get('confirm_client') %}
+    <div class="confirm-order client-choices">
+      <div>{{ t('lbl_client_choices' if client_choices else 'lbl_client_unknown', name=form.get('client','')) }}</div>
+      {% for c in client_choices or [] %}
+      <button type="button" class="btn secondary small" onclick="pickClient(this)" data-name="{{ c.name }}">
+        {{ c.name }} – {{ c.address }}, {{ c.postcode }} {{ c.city }}</button>
+      {% endfor %}
+      <label><input type="checkbox" name="confirm_client" value="1" {{ 'checked' if form.get('confirm_client') }}>
+        {{ t('lbl_confirm_client') }}</label>
+    </div>
+    {% endif %}
+    <div class="grid2">
+      <div class="field"><label>{{ t('lbl_invoice_no') }}</label>
+        <input type="text" name="number" value="{{ form.get('number','') }}"></div>
+      <div class="field"><label>{{ t('lbl_invoice_date') }}</label>
+        <input type="date" name="date" value="{{ form.get('date') or today|default('') }}"></div>
+    </div>
+    {# a date against the number order: the warning stands at the top, here only the deliberate exception #}
+    {# kept while ticked, so answering the other warning does not bring this one back #}
+    {% if order_warning or form.get('confirm_order') %}
+    <label class="confirm-order"><input type="checkbox" name="confirm_order" value="1" {{ 'checked' if form.get('confirm_order') }}> {{ t('lbl_confirm_order') }}</label>
+    {% endif %}
+    <div class="grid2">
+      <div class="field"><label>{{ t('lbl_paid_date') }}</label>
+        <input type="date" name="paid_date" value="{{ form.get('paid_date') or '' }}"></div>
+      <div class="field"><label>{{ t('lbl_payment_method') }}</label>
+        <input type="text" name="payment_method" value="{{ form.get('payment_method') or '' }}"></div>
+    </div>
+    <div class="field"><label>{{ t('lbl_invoice_note') }}</label>
+      <textarea name="note" rows="2" style="width:100%">{{ form.get('note') if form.get('note') is not none else t('invoice_note_default') }}</textarea></div>
+    {% if form.get('link_charges') %}<input type="hidden" name="link_charges" value="{{ form.get('link_charges') }}">{% endif %}
+
+    <h3 style="margin:18px 0 8px">{{ t('lbl_select_charges') }}</h3>
+    <div class="tablewrap" style="max-height:none">
+      <table id="lines">
+        <thead><tr>
+          <th style="min-width:200px">{{ t('col_name') }} *</th><th>{{ t('col_from') }}</th>
+          <th>{{ t('col_to') }}</th><th class="num">{{ t('col_qty') }}</th><th>{{ t('col_unit_type') }}</th>
+          <th>{{ t('col_art') }}</th><th class="num">{{ t('col_gross_per_unit') }} *</th>
+          <th class="num">{{ t('col_tourism') }}</th><th></th>
+        </tr></thead>
+        <tbody>
+          {% for ln in (lines or [none]) %}
+          <tr class="linerow">
+            {# 'or ""': '{{ x if ln }}' renders the STRING 'None' for an empty field and it would be
+               saved back as literal text (the number/date inputs just drop it, the text input keeps it) #}
+            <td><input type="text" name="worker" style="width:100%" value="{{ ln.worker or '' if ln else '' }}"></td>
+            <td><input type="date" name="period_from" value="{{ ln.period_from or '' if ln else '' }}"></td>
+            <td><input type="date" name="period_to" value="{{ ln.period_to or '' if ln else '' }}"></td>
+            <td><input type="number" name="quantity" step="any" min="0" style="width:70px" class="num" value="{{ ln.quantity if ln and ln.quantity is not none else '' }}"></td>
+            <td><select name="unit_type">
+              <option value="week" {{ 'selected' if ln and ln.unit_type=='week' }}>{{ t('unit_types').week }}</option>
+              <option value="day" {{ 'selected' if ln and ln.unit_type=='day' }}>{{ t('unit_types').day }}</option>
+              <option value="night" {{ 'selected' if ln and ln.unit_type=='night' }}>{{ t('unit_types').night }}</option>
+              <option value="month" {{ 'selected' if ln and ln.unit_type=='month' }}>{{ t('unit_types').month }}</option>
+              <option value="total" {{ 'selected' if ln and ln.unit_type=='total' }}>{{ t('unit_types').total }}</option></select></td>
+            <td><select name="kind">
+              <option value="stay" {{ 'selected' if not ln or ln.kind!='storno' }}>{{ t('line_kinds').stay }}</option>
+              <option value="storno" {{ 'selected' if ln and ln.kind=='storno' }}>{{ t('line_kinds').storno }}</option></select></td>
+            <td><input type="number" name="gross_per_unit" step="0.01" min="0" style="width:90px" class="num" value="{{ ln.gross_per_unit if ln and ln.gross_per_unit is not none else '' }}"></td>
+            <td><input type="number" name="tourism" step="0.01" min="0" style="width:80px" class="num" value="{{ ln.tourism_tax if ln and ln.tourism_tax is not none else '' }}"></td>
+            <td><button type="button" class="btn secondary small" onclick="removeLine(this)" title="{{ t('btn_remove_line') }}">✕</button></td>
+          </tr>
+          {% endfor %}
+        </tbody>
+      </table>
+    </div>
+    <p><button class="btn secondary small" type="button" onclick="addLine()">{{ t('btn_add_line') }}</button>
+       &nbsp;<small style="color:#6b756e">{{ t('hint_invoice_tourism') }}</small></p>
+
+    <div class="formactions">
+      <button class="btn" type="submit">{{ t('btn_save') }}</button>
+      <a class="btn secondary" href="{{ url_for('invoices') }}">{{ t('btn_cancel') }}</a>
+    </div>
+  </form>
+
+  <script>
+    const SUGG = {{ suggestions|tojson }};
+    function setNumber(force) {
+      const nr = document.querySelector('[name=number]');
+      const v = SUGG[document.querySelector('[name=unit_id]').value];
+      if (v && (force || !nr.value)) nr.value = v;   // don't wipe an existing number on edit (no suggestions there)
+    }
+    function addLine() {
+      const row = document.querySelector('#lines tbody .linerow');
+      const copy = row.cloneNode(true);
+      copy.querySelectorAll('input').forEach(i => i.value = '');
+      copy.querySelectorAll('select').forEach(s => s.selectedIndex = 0);
+      document.querySelector('#lines tbody').appendChild(copy);
+    }
+    function pickClient(btn) {
+      btn.form.client.value = btn.dataset.name;
+      btn.parentNode.querySelectorAll('button').forEach(b => b.classList.toggle('picked', b === btn));
+    }
+    function removeLine(btn) {
+      const rows = document.querySelectorAll('#lines tbody .linerow');
+      if (rows.length > 1) btn.closest('tr').remove();
+      else btn.closest('tr').querySelectorAll('input').forEach(i => i.value = '');
+    }
+    setNumber(false);
+  </script>
+{% endblock %}
diff --git a/app/templates/invoice_payment.html b/app/templates/invoice_payment.html
new file mode 100644
index 0000000..9f24132
--- /dev/null
+++ b/app/templates/invoice_payment.html
@@ -0,0 +1,37 @@
+{% extends "base.html" %}
+{% block content %}
+  <h1>{{ t('form_payment', number=inv.number) }}</h1>
+  <form class="card" method="post">
+    {% if hint %}
+    {# The linked Zimmerbelegung rows may already say how it was paid. Offer it, never apply it by
+       itself: an issued invoice only changes by a deliberate click. #}
+    <div class="field">
+      <label>{{ t('lbl_payment_from_ledger') }}</label>
+      <div>
+        {% if hint.dates %}{{ t('col_paid_date') }}: {{ hint.dates|map('date')|join(', ') }}{% endif %}
+        {% if hint.payers %} · {{ t('col_payer') }}: {{ hint.payers|join(', ') }}{% endif %}
+        <button class="btn secondary" type="button" id="takeover"
+                data-date="{{ hint.paid_date or '' }}" data-method="{{ hint.payment_method or '' }}"
+        >{{ t('btn_take_over') }}</button>
+      </div>
+    </div>
+    {% endif %}
+    <div class="grid2">
+      <div class="field"><label>{{ t('lbl_paid_date') }}</label>
+        <input type="date" name="paid_date" value="{{ inv.paid_date or '' }}" autofocus></div>
+      <div class="field"><label>{{ t('lbl_payment_method') }}</label>
+        <input type="text" name="payment_method" value="{{ inv.payment_method or '' }}"></div>
+    </div>
+    <div class="formactions">
+      <button class="btn" type="submit">{{ t('btn_save') }}</button>
+      <a class="btn secondary" href="{{ url_for('invoice_view', invoice_id=inv.id) }}">{{ t('btn_cancel') }}</a>
+    </div>
+  </form>
+  <script>
+    const t = document.getElementById("takeover");
+    if (t) t.addEventListener("click", function () {
+      if (t.dataset.date) document.querySelector("[name=paid_date]").value = t.dataset.date;
+      if (t.dataset.method) document.querySelector("[name=payment_method]").value = t.dataset.method;
+    });
+  </script>
+{% endblock %}
diff --git a/app/templates/invoice_print.html b/app/templates/invoice_print.html
new file mode 100644
index 0000000..2d1073d
--- /dev/null
+++ b/app/templates/invoice_print.html
@@ -0,0 +1,174 @@
+<!doctype html>
+<html lang="de">
+{% set accent = '#26588c' if inv.unit.theme == 'blue' else '#2f6d5b' %}
+{% set units_de = {'week':'Wochen','day':'Tage','night':'Nächte','month':'Monate','total':''} %}
+<head>
+  <meta charset="utf-8">
+  <title>Rechnung {{ inv.number }}</title>
+  <style>
+    /* Full-bleed A4: the sheet maps 1:1 to the page so the recipient block hits the DIN window and the totals
+       block anchors at a constant Y. Up to 10 line rows fit one page. */
+    @page { size: A4; margin: 0; }
+    * { box-sizing: border-box; }
+    html, body { margin: 0; }
+    body { font-family: Arial, "Segoe UI", sans-serif; color:#1b1b1b; font-size:13px; background:#e9e9e9; }
+
+    .toolbar { display:flex; gap:10px; width:210mm; max-width:100%; margin:14px auto 10px; }
+    .toolbar a, .toolbar button { font-size:14px; padding:8px 16px; border-radius:8px; border:1px solid #ccc;
+      background:#f3f3f3; color:#222; cursor:pointer; text-decoration:none; }
+    .toolbar .primary { background:{{ accent }}; color:#fff; border-color:{{ accent }}; }
+    .flash { width:210mm; max-width:100%; margin:0 auto 10px; box-sizing:border-box; padding:8px 14px; font-size:14px;
+      background:#fff6e6; border:1px solid #e6c98a; color:#8a5a12; border-radius:8px; }
+
+    .sheet { position:relative; width:210mm; min-height:296mm; margin:0 auto; background:#fff;
+      display:flex; flex-direction:column; box-shadow:0 1px 8px rgba(0,0,0,.18); }
+
+    /* Recipient — DIN 5008 form B address field (20mm left, 45mm top) → shows in a window envelope. */
+    .recipient { position:absolute; left:20mm; top:45mm; width:85mm; height:45mm; }
+    .recipient .return { font-size:8px; color:#555; border-bottom:1px solid #999;
+      padding-bottom:2px; margin-bottom:9px; white-space:nowrap; }
+    .recipient .to { line-height:1.4; }
+    .recipient .to b { font-size:15px; }
+    .recipient .uid { font-size:10px; color:#333; margin-top:3px; }
+
+    /* .main grows to push the bottom block (totals+notice+footer) to a fixed position → totals at a constant Y. */
+    .main { flex:1 0 auto; display:flex; flex-direction:column; padding:9mm 14mm 0; }
+    /* 82mm clears both the address window (bottom 90mm) and the branding stack for every unit. */
+    .masthead { position:relative; min-height:82mm; }
+    .masthead .brand .name { color:{{ accent }}; font-size:25px; font-weight:700; letter-spacing:1px; line-height:1.1; }
+    .masthead .brand .sub { color:{{ accent }}; font-style:italic; margin:2px 0 0; }
+    /* Branding column, top-right, spanning the masthead. Each image gets an explicit size from
+       masthead_art(): all images of a unit share ONE width, solved so the stack fills the box height
+       (capped at the box width) — logo and house always render equally wide, with no dead letterbox
+       space. Box is 64 x 80 mm, gap 4mm — keep in sync with ART_BOX_* in web.py. */
+    .masthead .art { position:absolute; top:0; right:0; bottom:2mm; width:64mm;
+      display:flex; flex-direction:column; align-items:flex-end; justify-content:center; gap:4mm; }
+    .masthead .art img { border-radius:2px; }
+
+    .title { font-weight:700; font-size:16px; margin:0 0 3px; }
+    .date { font-size:12px; margin-bottom:8px; }
+
+    table.lines { width:100%; border-collapse:collapse; font-size:10.5px; }
+    table.lines th, table.lines td { border:1px solid #9a9a9a; }          /* full gridlines */
+    table.lines th { background:{{ accent }}; color:#fff; font-weight:600; text-align:left; padding:4px 6px; font-size:9.5px; }
+    table.lines td { padding:2px 6px; vertical-align:bottom; line-height:1.25; }
+    table.lines td.nm { vertical-align:top; } table.lines td.nm .wn { font-weight:700; }
+    table.lines td.n, table.lines th.n { text-align:right; font-variant-numeric:tabular-nums; white-space:nowrap; }
+
+    /* Anchored bottom block. */
+    .bottom { flex-shrink:0; padding:0 14mm; }
+    table.totals { margin-left:auto; border-collapse:collapse; font-size:13px; margin-top:5mm; }
+    table.totals td { padding:3px 10px; }
+    table.totals td.l { text-align:right; font-weight:700; color:#333; white-space:nowrap; }
+    table.totals td.v { text-align:right; font-variant-numeric:tabular-nums; min-width:120px; }
+    table.totals tr.grand td { font-size:15px; font-weight:700; border-top:2px solid {{ accent }}; color:{{ accent }}; padding-top:5px; }
+    .note { text-align:center; white-space:pre-line; min-height:12mm; margin:6mm 0 0; font-size:12px; }
+    .thanks { text-align:center; font-weight:600; margin:4mm 0 0; }
+
+    footer { flex-shrink:0; display:flex; justify-content:center; gap:40px; margin:5mm 14mm 10mm;
+      border-top:1px solid #ddd; padding-top:8px; font-size:11px; color:#444; }
+    footer .col b { color:{{ accent }}; display:block; margin-bottom:3px; }
+
+    @media print { body { background:#fff; } .toolbar, .flash { display:none; } .sheet { box-shadow:none; margin:0; } }
+  </style>
+</head>
+<body>
+  <div class="toolbar">
+    <button class="primary" onclick="window.print()">{{ t('btn_print') }}</button>
+    <a href="{{ url_for('invoice_pdf', invoice_id=inv.id) }}">{{ t('btn_pdf') }}</a>
+    <a href="{{ url_for('invoice_edit', invoice_id=inv.id) }}">{{ t('btn_edit') }}</a>
+    <a href="{{ url_for('invoice_payment', invoice_id=inv.id) }}">{{ t('btn_payment') }}{% if inv.paid_date %} ✓{% endif %}</a>
+    <a href="{{ url_for('invoices') }}">{{ t('btn_back') }}</a>
+    {% if can_regen %}
+    <form method="post" action="{{ url_for('invoice_regenerate', invoice_id=inv.id) }}" style="display:inline"
+          onsubmit="return confirm('{{ t('confirm_regenerate') }}')">
+      <button type="submit" class="primary">{{ t('btn_regenerate') }}</button>
+    </form>
+    {% endif %}
+    <form method="post" action="{{ url_for('invoice_delete', invoice_id=inv.id) }}" style="display:inline;margin-left:auto"
+          onsubmit="return confirm('{{ t('confirm_delete') }}')">
+      <button type="submit" style="background:#fff;color:#b23a3a;border:1px solid #e3b7b7;padding:8px 16px;border-radius:8px;cursor:pointer">{{ t('btn_delete') }}</button>
+    </form>
+  </div>
+  {% with msgs = get_flashed_messages() %}
+    {% if msgs %}<div class="flash">{% for m in msgs %}<div>{{ m }}</div>{% endfor %}</div>{% endif %}
+  {% endwith %}
+
+  <div class="sheet">
+    <div class="recipient">
+      <div class="return">{{ inv.unit.name }}, {{ (inv.unit.address or '')|replace('\n', ', ') }}</div>
+      <div class="to">
+        {% if inv.client and inv.client.name %}
+          {% if inv.client.kind == 'private' %}Herrn{% else %}Firma{% endif %}<br>
+          <b>{{ inv.client.name }}</b><br>
+          {{ inv.client.address or '' }}{% if inv.client.postcode or inv.client.city %}<br>{{ inv.client.postcode or '' }} {{ inv.client.city or '' }}{% endif %}
+          {% if inv.gross and inv.gross > 10000 and inv.client.uid %}<div class="uid">UID: {{ inv.client.uid }}</div>{% endif %}
+        {% endif %}
+      </div>
+    </div>
+
+    <div class="main">
+      <div class="masthead">
+        <div class="brand">
+          <div class="name">{{ inv.unit.name }}</div>
+          <div class="sub">{{ inv.unit.subtitle }}</div>
+        </div>
+        <div class="art">
+          {% for a in masthead_art(inv.unit) %}
+          <img class="{{ a.cls }}" src="{{ asset_uri(a.src) }}" alt="" style="width:{{ a.w }}mm; height:{{ a.h }}mm">
+          {% endfor %}
+        </div>
+      </div>
+
+      <div class="title">RECHNUNG für Unterkunft&nbsp;&nbsp;&nbsp;{{ inv.number }}</div>
+      <div class="date">{{ inv.unit.place ~ ', am' if inv.unit.place else 'Datum:' }} {{ inv.date|date }}</div>
+
+      <table class="lines">
+        <thead><tr>
+          <th>Name / Zeitraum</th><th class="n">Anz</th><th>Einheit</th><th class="n">Brutto/Einh.</th>
+          <th class="n">Netto/Einh.</th><th class="n">Summe Netto</th><th class="n">USt</th>
+          <th class="n">Summe Brutto</th><th class="n">Ortstaxe</th>
+        </tr></thead>
+        <tbody>
+          {% for ln in inv.lines %}
+          <tr>
+            {% if ln.kind == 'storno' %}
+            <td class="nm"><div class="wn">{{ ln.worker }}</div>Stornogebühr – nicht steuerbarer Schadenersatz{% if ln.period_from %} · {{ ln.period_from|date }}{% endif %}</td>
+            <td class="n">{{ ln.quantity|num(0) if (ln.quantity or 0) % 1 == 0 else ln.quantity|num(1) }}</td><td>{{ units_de.get(ln.unit_type, ln.unit_type) }}</td>
+            <td class="n">{{ ln.gross_per_unit|euro }}</td><td class="n">—</td>
+            <td class="n">—</td><td class="n">—</td>
+            <td class="n">{{ ln.line_gross|euro }}</td><td class="n"></td>
+            {% else %}
+            <td class="nm"><div class="wn">{{ ln.worker }}</div>{{ ln.period_from|date }}{% if ln.period_to %} – {{ ln.period_to|date }}{% endif %}</td>
+            <td class="n">{{ ln.quantity|num(0) if (ln.quantity or 0) % 1 == 0 else ln.quantity|num(1) }}</td><td>{{ units_de.get(ln.unit_type, ln.unit_type) }}</td>
+            <td class="n">{{ ln.gross_per_unit|euro }}</td><td class="n">{{ ln.net_per_unit|num }}</td>
+            <td class="n">{{ ln.line_net|num }}</td><td class="n">{{ ln.line_vat|num }}</td>
+            <td class="n">{{ ln.line_gross|euro }}</td>
+            <td class="n">{% if ln.tourism_tax %}{{ ln.tourism_tax|euro }}{% endif %}</td>
+            {% endif %}
+          </tr>
+          {% endfor %}
+        </tbody>
+      </table>
+    </div>
+
+    <div class="bottom">
+      <table class="totals">
+        <tr><td class="l">{% if inv.storno %}Steuerbarer Nettobetrag{% else %}Nettobetrag{% endif %}</td><td class="v">{{ inv.net|euro }}</td></tr>
+        {% for b in inv.vat_breakdown %}<tr><td class="l">USt {{ b.pct }} %</td><td class="v">{{ b.vat|euro }}</td></tr>{% endfor %}
+        {% if inv.storno %}<tr><td class="l">Stornogebühr (nicht steuerbar)</td><td class="v">{{ inv.storno|euro }}</td></tr>{% endif %}
+        {% if inv.tourism_tax %}<tr><td class="l">Tourismusabgabe</td><td class="v">{{ inv.tourism_tax|euro }}</td></tr>{% endif %}
+        <tr class="grand"><td class="l">Rechnungsbetrag</td><td class="v">{{ inv.gross|euro }}</td></tr>
+      </table>
+      <div class="note">{{ inv.notes or t('invoice_note_default') }}</div>
+      <div class="thanks">Vielen Dank!</div>
+    </div>
+
+    <footer>
+      <div class="col"><b>Anschrift:</b>{{ inv.unit.name }}<br>{{ inv.unit.subtitle }}<br>{{ (inv.unit.address or '')|e|replace('\n', '<br>'|safe) }}</div>
+      <div class="col"><b>Bankverbindung:</b>{{ inv.unit.bank }}<br>IBAN: {{ inv.unit.iban }}<br><br>UID: {{ inv.unit.uid }}</div>
+      {% if inv.unit.contact %}<div class="col"><b>Kontakt:</b>{{ inv.unit.contact|e|replace('\n', '<br>'|safe) }}</div>{% endif %}
+    </footer>
+  </div>
+</body>
+</html>
diff --git a/app/templates/invoices.html b/app/templates/invoices.html
new file mode 100644
index 0000000..fbbdfef
--- /dev/null
+++ b/app/templates/invoices.html
@@ -0,0 +1,54 @@
+{% extends "base.html" %}
+{% block main_class %}grid-page{% endblock %}
+{% block content %}
+  {% set unit_opts = rows|map(attribute='unit')|select|unique|sort %}
+  <h1>{{ t('invoices_title') }}</h1>
+  <div class="toolbar">
+    <input class="search live-search" data-grid="inv" type="text" placeholder="{{ t('search_placeholder') }}">
+    <select class="live-filter" data-grid="inv" data-col="{{ t('col_unit') }}"><option value="">{{ t('filter_all', col=t('col_unit')) }}</option>
+      {% for u in unit_opts %}<option>{{ u }}</option>{% endfor %}</select>
+    <select class="live-filter" data-grid="inv" data-col="{{ t('col_payment') }}"><option value="">{{ t('filter_all', col=t('col_payment')) }}</option>
+      <option>{{ t('payment_paid') }}</option><option>{{ t('payment_open') }}</option>
+      <option value="{{ t('payment_unknown') }}">{{ t('payment_unknown_label') }}</option></select>
+    <span class="count"><span class="grid-count" data-grid="inv">{{ rows|length }}</span> {{ t('showing_count', count='')|trim }}</span>
+    <span class="count">{{ t('sum_label') }}: <span class="grid-sum" data-grid="inv" data-col="{{ t('col_invoice_total') }}"></span> €</span>
+    <span class="spacer"></span>
+    <button class="btn secondary" type="button" onclick="gridPrint('inv')">{{ t('btn_print') }}</button>
+    <a class="btn" href="{{ url_for('invoice_new') }}">+ {{ t('btn_new_invoice') }}</a>
+  </div>
+  <p class="printinfo" data-grid="inv"></p>
+  <div class="tablewrap">
+    <table id="inv" class="grid">
+      <thead><tr>
+        <th>{{ t('col_invoice') }}</th><th>{{ t('col_date') }}</th><th>{{ t('col_unit') }}</th>
+        <th>{{ t('col_client') }}</th><th class="num">{{ t('col_invoice_total') }}</th>
+        <th>{{ t('col_payment') }}</th><th>{{ t('col_paid_date') }}</th>
+        <th class="nosort actions"></th>
+      </tr></thead>
+      <tbody>
+        {# rows ship inside an inert <template>: grids.js renders only the visible window (see freezeLayout) #}
+        <template>
+        {% for r in rows %}
+        <tr>
+          <td data-k="{{ '%04d.%04d'|format(r.number_key[0], r.number_key[1]) }}">{{ r.number }}</td><td>{{ r.date|date }}</td>
+          <td>{% if r.unit %}<span class="pill unit">{{ r.unit }}</span>{% endif %}</td>
+          <td>{{ r.client or '' }}</td>
+          <td class="num">{{ r.gross|euro if r.gross else '' }}</td>
+          <td>{% if r.payment_state == 'paid' %}<span class="pill paid">{{ t('payment_paid') }}</span>
+              {% elif r.payment_state == 'open' %}<span class="pill open">{{ t('payment_open') }}</span>
+              {% else %}{{ t('payment_unknown') }}{% endif %}</td>
+          <td>{{ r.paid_on|date }}</td>
+          <td class="actions">
+            <a class="btn secondary small" href="{{ url_for('invoice_view', invoice_id=r.id) }}">{{ t('btn_open') }}</a>
+            <a class="btn secondary small" href="{{ url_for('invoice_edit', invoice_id=r.id) }}">{{ t('btn_edit') }}</a>
+          </td>
+        </tr>
+        {% endfor %}
+        </template>
+        {% if not rows %}
+        <tr data-empty="1"><td class="empty" colspan="8">{{ t('no_results') }}</td></tr>
+        {% endif %}
+      </tbody>
+    </table>
+  </div>
+{% endblock %}
diff --git a/app/templates/ledger.html b/app/templates/ledger.html
new file mode 100644
index 0000000..770ec51
--- /dev/null
+++ b/app/templates/ledger.html
@@ -0,0 +1,96 @@
+{% extends "base.html" %}
+{% block main_class %}grid-page{% endblock %}
+{% block content %}
+  <h1>{{ t('ledger_title') }}</h1>
+  <div class="toolbar">
+    <input class="search live-search" data-grid="led" type="text" placeholder="{{ t('search_placeholder') }}">
+    {# Jahr first: the list spans many years, and picking one is the most common filter #}
+    <select class="live-filter" data-grid="led" data-col="{{ t('col_from') }}">
+      <option value="">{{ t('filter_all', col=t('filter_year')) }}</option>
+      {% for y in years %}<option>{{ y }}</option>{% endfor %}</select>
+    <select class="live-filter" data-grid="led" data-col="{{ t('hd_room') }}"><option value="">{{ t('filter_all', col=t('col_room')) }}</option>
+      {% for r in rooms %}<option>{{ r.number }}</option>{% endfor %}</select>
+    {# between Zimmer and Bezahlt: who is still here? A row without 'Bis' is still running. #}
+    <select class="live-filter" data-grid="led" data-col="{{ t('col_to') }}">
+      <option value="">{{ t('filter_all', col=t('filter_persons')) }}</option>
+      <option>{{ t('filter_still_here') }}</option></select>
+    <select class="live-filter" data-grid="led" data-col="{{ t('col_payment') }}"><option value="">{{ t('filter_all', col=t('col_payment')) }}</option>
+      <option>{{ t('payment_paid') }}</option><option>{{ t('payment_open') }}</option><option>{{ t('payment_cash') }}</option>
+      <option value="{{ t('payment_unknown') }}">{{ t('payment_unknown_label') }}</option></select>
+    <span class="count"><span class="grid-count" data-grid="led">{{ rows|length }}</span> {{ t('showing_count', count='')|trim }}</span>
+    <span class="count">{{ t('sum_label') }}: <span class="grid-sum" data-grid="led" data-col="{{ t('col_amount') }}"></span> €</span>
+    <span class="spacer"></span>
+    <button class="btn secondary" type="button" onclick="invoiceFromSelection()">{{ t('btn_invoice_from_selection') }}</button>
+    <button class="btn secondary" type="button" onclick="gridPrint('led')">{{ t('btn_print') }}</button>
+    <a class="btn" href="{{ url_for('ledger_new') }}">+ {{ t('btn_add_ledger') }}</a>
+  </div>
+  <p class="printinfo" data-grid="led"></p>
+
+  <div class="tablewrap">
+    {# data-pin: Zimmer + Name stay on screen while scrolling to the payment columns.
+       data-max: tighter maximum widths, so RNr. and Re vom can be read on a small screen (1280 px at 150 %)
+       without scrolling — anything longer is cut off and shows in full on hover #}
+    <table id="led" class="grid" data-scroll="end" data-pin="1 2 6">
+      <thead><tr>
+        <th class="nosort selcol"></th><th title="{{ t('col_room') }}">{{ t('hd_room') }}</th><th>{{ t('col_from') }}</th><th>{{ t('col_to') }}</th>
+        <th title="{{ t('col_gb') }}" data-max="70">{{ t('hd_gb') }}</th><th data-max="135">{{ t('col_occupant') }}</th><th class="num">{{ t('col_days') }}</th>
+        <th class="num">{{ t('col_rate') }}</th><th class="num" title="{{ t('col_qty') }}">{{ t('hd_qty') }}</th>
+        <th class="num" title="{{ t('col_persons') }}">{{ t('hd_persons') }}</th><th class="num">{{ t('col_amount') }}</th>
+        <th class="num">{{ t('col_tourism_tax') }}</th>
+        <th title="{{ t('col_payer') }}" data-max="90">{{ t('hd_payer') }}</th><th data-max="40">{{ t('col_art') }}</th><th title="{{ t('col_invoice') }}" data-max="72">{{ t('hd_invoice') }}</th>
+        <th title="{{ t('col_invoice_date') }}">{{ t('hd_invoice_date') }}</th><th data-max="105">{{ t('col_payment') }}</th>
+        <th title="{{ t('col_paid_date') }}">{{ t('hd_paid_date') }}</th><th>{{ t('col_notes') }}</th><th class="nosort actions"></th>
+      </tr></thead>
+      <tbody>
+        {# rows ship inside an inert <template>: grids.js renders only the visible window (see freezeLayout) #}
+        <template>
+        {% for r in rows %}
+        <tr>
+          <td class="selcol"><input type="checkbox" class="rowsel" value="{{ r.charge_id }}"></td>
+          <td>{{ r.room or '' }}</td>
+          {%- set year = (r.first_date or '')[:4] %}
+          {#- the weekday before the date, to be seen at a glance. data-k keeps the sort:
+              makeKey only recognises a bare DD.MM.YYYY; with "Mo " in front it would sort alphabetically -#}
+          <td{% if year %} data-f="{{ year }}"{% endif %}{% if r.period_from %} data-k="{{ r.period_from|replace('-', '') }}"{% endif %}>{{ r.period_from|datewd }}</td>
+          {#- 'noch da' = a running occupancy: Von set, no Bis, and either a Gästeblatt number or not billed
+              yet. 'Bereitstellung'/'Storno' rows without Bis are settled items, not people in the house. -#}
+          <td{% if r.period_from and not r.period_to and (r.gb_ref or not r.line_net_override) %} data-f="{{ t('filter_still_here') }}"{% endif %}{% if r.period_to %} data-k="{{ r.period_to|replace('-', '') }}"{% endif %}>{{ r.period_to|datewd }}</td><td>{{ r.gb_ref or '' }}</td><td>{{ r.occupant or '' }}</td>
+          <td class="num">{{ r.days if r.days is not none else '' }}</td>
+          <td class="num">{{ r.gross_per_unit|num if r.gross_per_unit else '' }}</td>
+          <td class="num">{{ (r.quantity|num(0) if r.quantity % 1 == 0 else r.quantity|num(1)) if r.quantity is not none else '' }}</td>
+          <td class="num">{{ r.persons|num(0) if r.persons }}</td>
+          <td class="num">{{ r.amount|euro }}</td>
+          <td class="num">{{ r.tourism_tax|euro if r.tourism_tax else '' }}</td>
+          <td>{{ r.payer or '' }}</td><td>{{ r.art or '' }}</td>
+          <td>{% if r.invoice_id %}<a href="{{ url_for('invoice_view', invoice_id=r.invoice_id) }}">{{ r.invoice_no }}</a>
+              {% else %}{{ r.invoice_no or '' }}{% endif %}</td>
+          <td>{{ r.invoice_date|date }}</td>
+          {#- paid or open: repo._payment — the Umsatzsteuer list reads the same rule -#}
+          {%- set payment = r.payment %}
+          {#- data-f: the filter asks for the STATE, even when text stands beside it (the part payment)
+              — without it "OFFEN" would miss exactly these rows -#}
+          <td data-f="{{ t('payment_' + payment) }}">
+              {%- if payment == 'unknown' %}{{ t('payment_unknown') }}
+              {%- else %}<span class="pill {{ payment }}">{{ t('payment_' + payment) }}</span>{% endif %}
+              {%- if r.open_amount %} {{ t('payment_part', paid=r.paid_amount|euro, open=r.open_amount|euro) }}{% endif %}</td>
+          {#- without a date of the row's own, this shows when the INVOICE was paid -#}
+          <td>{{ r.paid_on|date }}</td>
+          <td>{{ r.notes or '' }}</td>
+          <td class="actions"><a class="btn secondary small" href="{{ url_for('ledger_edit', charge_id=r.charge_id) }}">{{ t('btn_edit') }}</a></td>
+        </tr>
+        {% endfor %}
+        </template>
+        {% if not rows %}
+        <tr data-empty="1"><td class="empty" colspan="20">{{ t('no_results') }}</td></tr>
+        {% endif %}
+      </tbody>
+    </table>
+  </div>
+  <script>
+    function invoiceFromSelection() {
+      var ids = window.gridChecked('led');   // from the grid model — most rows are not in the DOM
+      if (!ids.length) { alert('Bitte zuerst Zeilen auswählen.'); return; }
+      window.location = '{{ url_for("invoice_new") }}?charges=' + ids.join(',');
+    }
+  </script>
+{% endblock %}
diff --git a/app/templates/ledger_form.html b/app/templates/ledger_form.html
new file mode 100644
index 0000000..fc2d468
--- /dev/null
+++ b/app/templates/ledger_form.html
@@ -0,0 +1,167 @@
+{% extends "base.html" %}
+{% block content %}
+  <h1>{% if is_new %}{{ t('form_new_ledger') }}{% else %}{{ t('form_edit_ledger') }}{% if ch.room %} – {{ t('form_room', room=ch.room) }}{% endif %}{% endif %}</h1>
+  <form class="card" method="post"{% if is_new %} action="{{ url_for('ledger_new') }}"{% endif %}>
+    {% if is_new %}
+    <div class="field"><label>{{ t('col_room') }}</label>
+      <select name="room_id"><option value="">—</option>
+        {% for r in rooms %}<option value="{{ r.id }}">{{ r.number }}</option>{% endfor %}</select></div>
+    {% endif %}
+    <div class="grid2">
+      <div class="field"><label>{{ t('col_occupant') }}</label>
+        <input type="text" name="occupant" value="{{ ch.occupant or '' }}" autofocus></div>
+      <div class="field"><label>{{ t('col_gb_number') }}</label>
+        <input type="text" name="gb_ref" value="{{ ch.gb_ref or '' }}"></div>
+    </div>
+    <div class="grid2">
+      <div class="field"><label>{{ t('col_from') }}</label>
+        <input type="date" name="period_from" value="{{ ch.period_from or '' }}"></div>
+      <div class="field"><label>{{ t('col_to') }}</label>
+        <input type="date" name="period_to" value="{{ ch.period_to or '' }}"></div>
+    </div>
+    <div class="grid2">
+      <div class="field"><label>{{ t('col_persons') }}</label>
+        <input type="number" name="persons" step="1" min="0" value="{{ ch.persons if ch.persons is not none else '' }}"></div>
+      <div class="field"><label>{{ t('col_qty') }}</label>
+        <input type="number" name="quantity" step="any" min="0" value="{{ ch.quantity if ch.quantity is not none else '' }}"></div>
+    </div>
+    <div class="grid2">
+      <div class="field"><label>{{ t('col_unit_type') }}</label>
+        <select name="unit_type">
+          {% for v, lbl in t('unit_types').items() %}
+            <option value="{{ v }}" {{ 'selected' if ch.unit_type==v }}>{{ lbl }}</option>{% endfor %}</select></div>
+      <div class="field"><label>{{ t('col_rate_per_unit') }}</label>
+        <input type="number" name="gross_per_unit" step="0.01" min="0" value="{{ ch.gross_per_unit if ch.gross_per_unit is not none else '' }}"></div>
+    </div>
+    <div class="grid2">
+      <div class="field"><label>{{ t('col_amount_eur') }}</label>
+        <input type="number" name="betrag" step="0.01" min="0" value="{{ ch.betrag if ch.betrag is not none else '' }}"></div>
+      <div class="field"><label>{{ t('col_tourism_tax') }} (€)</label>
+        <input type="number" name="tourism_tax" step="0.01" min="0" data-rate="{{ tourism_rate }}"
+               value="{{ ch.tourism_tax if ch.tourism_tax is not none else '' }}"></div>
+    </div>
+    <div class="grid2">
+      <div class="field"><label>{{ t('col_art') }}</label>
+        <input type="text" name="art" value="{{ ch.art or '' }}"></div>
+      <div class="field"></div>
+    </div>
+    <div class="grid2">
+      <div class="field"><label>{{ t('col_payer') }}</label>
+        <input type="text" name="payer" value="{{ ch.payer or '' }}"></div>
+      <div class="field"><label>{{ t('col_invoice') }}</label>
+        <input type="text" name="rnr" value="{{ ch.rnr or '' }}"></div>
+    </div>
+    <div class="field"><label>{{ t('col_notes') }}</label>
+      <input type="text" name="notes" value="{{ ch.notes or '' }}"></div>
+    <div class="grid2">
+      <div class="field"><label>{{ t('col_payment') }}</label>
+        <select name="paid_status">
+          <option value="" {{ 'selected' if not ch.paid_status }}>—</option>
+          <option value="paid" {{ 'selected' if ch.paid_status=='paid' }}>{{ t('payment_paid') }}</option>
+          <option value="open" {{ 'selected' if ch.paid_status=='open' }}>{{ t('payment_open') }}</option>
+          <option value="cash" {{ 'selected' if ch.paid_status=='cash' }}>{{ t('payment_cash') }}</option></select></div>
+      <div class="field"><label>{{ t('lbl_paid_date') }}</label>
+        <input type="date" name="paid_date" value="{{ ch.paid_date or '' }}"></div>
+    </div>
+    {# Payments in parts, each with date and amount (paid without the Ortstaxe, or in two instalments).
+       For the usual ONE full payment "bezahlt am" above is enough. #}
+    <div class="field"><label>{{ t('lbl_payments') }}</label>
+      <div id="payLines">
+        {% for d, a in (ch.payments or []) %}
+        <div class="pay-line"><input type="date" name="pay_date" value="{{ d }}" required>
+          <input type="number" name="pay_amount" step="0.01" min="0" value="{{ '%.2f'|format(a) }}"></div>
+        {% endfor %}
+        <div class="pay-line"><input type="date" name="pay_date">
+          <input type="number" name="pay_amount" step="0.01" min="0" placeholder="€"></div>
+      </div>
+      <button type="button" class="btn secondary small" id="addPayment">{{ t('btn_add_payment') }}</button>
+      <small>{{ t('hint_payments') }}</small></div>
+    <div class="formactions">
+      <button class="btn" type="submit">{{ t('btn_save') }}</button>
+      {% if not is_new %}
+      {# month end: bill up to the invoice date and let the occupancy run on from that day #}
+      <button class="btn secondary" type="submit" name="action" value="continue"
+              title="{{ t('hint_continue') }}">{{ t('btn_continue') }}</button>
+      {% endif %}
+      <a class="btn secondary" href="{{ url_for('ledger') }}">{{ t('btn_cancel') }}</a>
+    </div>
+  </form>
+  {% if ch.id %}
+  <form class="formactions" method="post" action="{{ url_for('ledger_delete', charge_id=ch.id) }}"
+        onsubmit="return confirm('{{ t('confirm_delete') }}')">
+    <button class="btn danger" type="submit">{{ t('btn_delete') }}</button>
+  </form>
+  {% endif %}
+  <script>
+    // Editing Satz, Anzahl or Personen recomputes the Betrag the way the ledger counts it:
+    // Anzahl x Satz x PERSONEN (2 Pers. x 1 Woche x 161 = 322, not 161). Betrag stays a normal input,
+    // so a negotiated amount typed by hand sticks until one of the three changes again.
+    const rate = document.querySelector('[name=gross_per_unit]'),
+          qty = document.querySelector('[name=quantity]'),
+          betrag = document.querySelector('[name=betrag]'),
+          taxe = document.querySelector('[name=tourism_tax]'),
+          persons = document.querySelector('[name=persons]'),
+          from = document.querySelector('[name=period_from]'),
+          to = document.querySelector('[name=period_to]'),
+          unit = document.querySelector('[name=unit_type]');
+    function recalc() {
+      const r = parseFloat(rate.value), q = parseFloat(qty.value), p = parseFloat(persons.value) || 1;
+      if (!isNaN(r) && !isNaN(q)) betrag.value = (q * r * p).toFixed(2);
+    }
+    // Changing Von/Bis fills the Anzahl: for Wochen a started week counts in full from 4 nights on, like the
+    // invoice (compute.weeks_for_period: 12 nights are 2 weeks), a shorter stay the fraction priced by
+    // hand; the plain day count for Tag/Nacht. Anzahl stays an ordinary input, so a value typed by hand
+    // stands until a date moves again. Monat/gesamt derive nothing.
+    const PER_UNIT = { week: 7, day: 1, night: 1 };
+    function recalcQty() {
+      const a = Date.parse(from.value), b = Date.parse(to.value), per = PER_UNIT[unit.value];
+      if (isNaN(a) || isNaN(b) || !per) return;
+      const nights = (b - a) / 86400000;                    // both dates parse as UTC -> exact day count
+      qty.value = unit.value === 'week' && nights >= 4 ? Math.ceil(nights / 7) : +(nights / per).toFixed(6);
+      recalc();
+      recalcTaxe(nights);
+    }
+    // Ortstaxe = Nächte x Satz x Personen, but only for a stay of at most 10 nights: longer professional
+    // stays are exempt (T-AAG §4). A hand-typed amount is left alone, like the Betrag.
+    function recalcTaxe(nights) {
+      const rate = parseFloat(taxe.dataset.rate), p = parseFloat(persons.value) || 1;
+      if (isNaN(rate) || nights <= 0) return;
+      taxe.value = nights > 10 ? '' : (nights * rate * p).toFixed(2);
+    }
+    // entering a payment date means paid — set the dropdown with it instead of asking for it twice
+    const paidStatus = document.querySelector('[name=paid_status]'),
+          paidDate = document.querySelector('[name=paid_date]'),
+          payLines = document.getElementById('payLines');
+    paidDate.addEventListener('change', function () {
+      if (paidDate.value && !paidStatus.value) paidStatus.value = 'paid';
+    });
+    // Payments in parts decide by themselves, like the server (repo._settle): once they cover Betrag +
+    // Ortstaxe the row is paid — on the day of the last one —, otherwise it stays open. Typing an amount
+    // requires a date with it: a payment without a date belongs to no quarter.
+    function checkPayments() {
+      let sum = 0, last = '';
+      payLines.querySelectorAll('.pay-line').forEach(function (z) {
+        const d = z.querySelector('[name=pay_date]'), a = parseFloat(z.querySelector('[name=pay_amount]').value);
+        d.required = !isNaN(a);
+        if (!isNaN(a) && d.value) { sum += a; if (d.value > last) last = d.value; }
+      });
+      if (!last) return;
+      paidStatus.value = sum + 0.005 >= total() ? 'paid' : 'open';
+      paidDate.value = last;
+    }
+    payLines.addEventListener('input', checkPayments);
+    document.getElementById('addPayment').addEventListener('click', function () {
+      const line = payLines.lastElementChild.cloneNode(true);
+      line.querySelectorAll('input').forEach(function (i) { i.value = ''; i.required = false; });
+      payLines.appendChild(line);
+      line.querySelector('input').focus();
+    });
+    function total() {
+      return (parseFloat(betrag.value) || 0) + (parseFloat(taxe.value) || 0);
+    }
+    rate.addEventListener('input', recalc);
+    qty.addEventListener('input', recalc);
+    persons.addEventListener('input', recalc);
+    [from, to, unit, persons].forEach(el => el.addEventListener('change', recalcQty));
+  </script>
+{% endblock %}
diff --git a/app/templates/plan.html b/app/templates/plan.html
new file mode 100644
index 0000000..92fd2e1
--- /dev/null
+++ b/app/templates/plan.html
@@ -0,0 +1,87 @@
+{% extends "base.html" %}
+{% block main_class %}grid-page{% endblock %}
+{% block content %}
+  <h1>{{ t('plan_title') }}</h1>
+  <div class="toolbar">
+    <a class="btn secondary small" href="{{ url_for('plan_page', start=p.prev_start, weeks=weeks) }}"
+       title="{{ t('plan_prev_week') }}">&#9664;</a>
+    <a class="btn secondary small" href="{{ url_for('plan_page', weeks=weeks) }}">{{ t('plan_today') }}</a>
+    <a class="btn secondary small" href="{{ url_for('plan_page', start=p.next_start, weeks=weeks) }}"
+       title="{{ t('plan_next_week') }}">&#9654;</a>
+    <span class="count">{{ p.start.isoformat()|date }} &ndash; {{ p.last|date }}</span>
+    <span class="seg">
+      <a class="{{ 'on' if weeks == 4 }}" href="{{ url_for('plan_page', start=p.start.isoformat(), weeks=4) }}">{{ t('plan_weeks_4') }}</a>
+      <a class="{{ 'on' if weeks == 8 }}" href="{{ url_for('plan_page', start=p.start.isoformat(), weeks=8) }}">{{ t('plan_weeks_8') }}</a>
+    </span>
+    <span class="spacer"></span>
+    <span class="count">{{ t('plan_guests_one') if p.guests_today == 1 else t('plan_guests', guests=p.guests_today) }} &middot; {{ t('plan_free_one') if p.free_beds == 1 else t('plan_free', free=p.free_beds) }}</span>
+  </div>
+
+  <div class="tablewrap planwrap">
+    <div class="plan" style="--days:{{ p.n_days }}">
+      <div class="plan-head">
+        <div class="plan-hrow">
+          <div class="plan-label"></div>
+          <div class="plan-cells">
+            {% for m in p.months %}<div class="pm" style="grid-column:span {{ m.span }}">{{ m.text }}</div>{% endfor %}
+          </div>
+        </div>
+        <div class="plan-hrow">
+          <div class="plan-label"></div>
+          <div class="plan-cells plan-daysrow">
+            {% for d in p.days %}
+            <div class="pd{{ ' we' if d.weekend }}{{ ' today' if d.today }}{{ ' mon' if d.monday }}{{ ' m1' if d.month_start }}">
+              {% if p.n_days <= 35 %}<b>{{ d.dom }}</b><span>{{ d.wd }}</span>
+              {% elif d.monday %}<b>{{ d.label }}</b>{% endif %}
+            </div>
+            {% endfor %}
+          </div>
+        </div>
+      </div>
+      {% for r in p.rooms %}
+      <div class="plan-row{{ ' newfloor' if loop.index0 and r.floor != p.rooms[loop.index0 - 1].floor }}">
+        <div class="plan-label">
+          <div class="rl-top"><b>{{ t('plan_room', number=r.number) }}</b>
+            {% if r.long_term %}
+            <span class="pill unit" title="{{ t('plan_longterm') }}">{{ t('plan_longterm_short') }}</span>
+            {% else %}
+            <span class="pill {{ 'open' if r.today_count > r.capacity else ('have' if r.today_count >= r.capacity else 'paid') }}"
+                  title="{{ t('plan_pill_tip') }}">{{ r.today_count }}/{{ r.capacity }}</span>
+            {% endif %}
+          </div>
+          <div class="rl-sub">{{ r.category }} &middot; {{ r.unit }}</div>
+        </div>
+        <div class="plan-cells plan-lanes{{ ' longterm' if r.long_term }}" style="--lanes:{{ r.lanes }}">
+          {# day lines live in their own full-height overlay: as grid items they could neither
+             overlap the bars (auto-placement) nor reach below the last lane when the room label
+             makes the row taller than the lane stack #}
+          <div class="daylines">
+            {% for d in p.days %}<i class="{{ 'we' if d.weekend }}{{ ' today' if d.today }}{{ ' mon' if d.monday }}{{ ' m1' if d.month_start }}"></i>{% endfor %}
+          </div>
+          {% if r.long_term and not r.bars %}<div class="lt-note">{{ t('plan_longterm') }}</div>{% endif %}
+          {% for b in r.bars %}
+          <a class="bar {{ b.state }}{{ ' clipstart' if b.clip_start }}{{ ' clipend' if b.clip_end }}"
+             style="grid-column:{{ b.col }}/{{ b.col_end }};grid-row:{{ b.lane }}"
+             href="{{ url_for('stay_form', stay_id=b.stay_id) }}"
+             title="{{ b.name }} &middot; {{ b.arrival|date }} &ndash; {{ b.departure|date if b.departure else t('plan_open') }}{% if b.sheet_number %} &middot; {{ t('plan_sheet', number=b.sheet_number) }}{% endif %}{% if b.employer %} &middot; {{ b.employer }}{% endif %}">{{ b.name }}</a>
+          {% endfor %}
+        </div>
+      </div>
+      {% endfor %}
+    </div>
+  </div>
+
+  <div class="plan-foot">
+    <span><span class="key" style="background:var(--accent)"></span>{{ t('plan_legend_current') }}</span>
+    <span><span class="key" style="background:#b9c9c0"></span>{{ t('plan_legend_past') }}</span>
+    <span><span class="key" style="background:var(--accent-soft);box-shadow:inset 0 0 0 1px var(--accent)"></span>{{ t('plan_legend_future') }}</span>
+    <span><span class="key" style="background:#fff3d6;box-shadow:inset 0 0 0 1px var(--warn)"></span>{{ t('plan_legend_today') }}</span>
+    {% if p.unplaced %}
+    <span class="plan-unplaced">{{ t('plan_no_room') }}
+      {% for u in p.unplaced %}
+      <a href="{{ url_for('stay_form', stay_id=u.id) }}">{{ u.name }} ({{ u.arrival|date }} &ndash; {{ u.departure|date if u.departure else t('plan_open') }})</a>{{ ', ' if not loop.last }}
+      {% endfor %}
+    </span>
+    {% endif %}
+  </div>
+{% endblock %}
diff --git a/app/templates/quality.html b/app/templates/quality.html
new file mode 100644
index 0000000..9ba2982
--- /dev/null
+++ b/app/templates/quality.html
@@ -0,0 +1,85 @@
+{% extends "base.html" %}
+{% block content %}
+  <h1>{{ t('quality_title') }}</h1>
+  <p class="lead">{{ t('quality_intro') }}</p>
+
+  <h2 style="margin:26px 0 6px">{{ t('quality_gaps') }}</h2>
+  {% macro gaptable(title, rows, cols) %}
+    {# rows carrying _kind/_key (set in quality.py) get a per-row "Passt so" button: the finding is
+       reviewed-as-correct and stays hidden — keyed by natural key, not by row id #}
+    {% set dismissable = rows and rows[0]._kind is defined %}
+    <details style="margin:8px 0" {% if rows|length and rows|length <= 12 %}open{% endif %}>
+      <summary style="cursor:pointer; font-weight:600">{{ title }}
+        <span class="pill {{ 'open' if rows|length else 'paid' }}">{{ rows|length }}</span></summary>
+      {% if rows %}
+      <div class="tablewrap" style="max-height:280px; margin-top:6px">
+        <table>
+          <thead><tr>{% for c in cols %}<th>{{ c }}</th>{% endfor %}{% if dismissable %}<th></th>{% endif %}</tr></thead>
+          <tbody>
+            {% for r in rows[:80] %}
+            <tr>{% for c in cols %}<td>{{ r[c] if r[c] is not none else '' }}</td>{% endfor %}
+              {% if dismissable %}
+              <td><form method="post" action="{{ url_for('quality_dismiss') }}" style="margin:0">
+                <input type="hidden" name="kind" value="{{ r._kind }}"><input type="hidden" name="key" value="{{ r._key }}">
+                <button class="btn secondary small" type="submit">{{ t('btn_dismiss') }}</button></form></td>
+              {% endif %}</tr>
+            {% endfor %}
+            {% if rows|length > 80 %}<tr><td colspan="{{ cols|length + (1 if dismissable else 0) }}">{{ t('quality_more', n=rows|length - 80) }}</td></tr>{% endif %}
+          </tbody>
+        </table>
+      </div>
+      {% endif %}
+    </details>
+  {% endmacro %}
+  {{ gaptable(t('gap_depart_before_arrival'), q.gaps.depart_before_arrival,
+              ['stay_id','source_sheet','name','arrival','departure']) }}
+  {{ gaptable(t('gap_charges_without_money'), q.gaps.charges_without_money,
+              ['charge_id','room','name','period_from','period_to']) }}
+  {{ gaptable(t('gap_client_without_address'), q.gaps.client_without_address,
+              ['name','as_payer','as_employer']) }}
+  {{ gaptable(t('gap_address_has_name'), q.gaps.address_has_name,
+              ['client_id','company','name','address','postcode','city']) }}
+  {{ gaptable(t('gap_implausible_qty'), q.gaps.implausible_quantities,
+              ['charge_id','room','name','period_from','period_to','quantity','amount']) }}
+  {{ gaptable(t('gap_rnr_unlinked'), q.gaps.rnr_unlinked, ['charge_id','room','name','period_from','rnr']) }}
+  {{ gaptable(t('gap_duplicate_numbers'), q.gaps.duplicate_invoice_numbers, ['unit','number','n','ids']) }}
+  {{ gaptable(t('gap_number_year'), q.gaps.number_year_mismatch, ['unit','number','date']) }}
+  {{ gaptable(t('gap_open_items'), q.gaps.open_items, ['room','name','period_from','amount']) }}
+  {{ gaptable(t('gap_register_ledger'), q.gaps.register_ledger_mismatch,
+              ['room','name','sheet_number','arrival','departure','ledger_from','ledger_to']) }}
+  {{ gaptable(t('gap_gb_ref_unknown'), q.gaps.gb_ref_unknown,
+              ['charge_id','room','name','period_from','gb_ref','missing']) }}
+  {{ gaptable(t('gap_never_billed'), q.gaps.register_never_billed,
+              ['sheet_number','room','name','arrival','departure']) }}
+  {{ gaptable(t('gap_betrag_formula'), q.gaps.betrag_off_formula,
+              ['room','name','period_from','quantity','gross_per_unit','persons','betrag','calc']) }}
+  {{ gaptable(t('gap_tvb_stale_open'), q.gaps.tvb_stale_open, ['room','name','sheet_number','arrival']) }}
+  {{ gaptable(t('gap_no_departure'), q.gaps.register_no_departure, ['name','arrival']) }}
+
+  <h2 style="margin:26px 0 6px">{{ t('quality_suggestions') }}</h2>
+  <p style="color:#6b756e; font-size:13px">{{ t('quality_suggestions_hint') }}</p>
+  {% for s in q.suggestions.companies %}
+  <form method="post" action="{{ url_for('quality_merge_companies') }}" style="margin:4px 0; display:flex; gap:8px; align-items:center"
+        onsubmit="return confirm('{{ t('confirm_merge') }}')">
+    <input type="hidden" name="keep" value="{{ s.a_id }}"><input type="hidden" name="drop" value="{{ s.b_id }}">
+    <span><b>{{ s.a }}</b> ~ <b>{{ s.b }}</b></span>
+    <button class="btn secondary small" type="submit">{{ t('btn_merge') }} → {{ s.a }}</button>
+    <a class="btn secondary small" href="{{ url_for('client_edit', company_id=s.a_id) }}">{{ t('btn_open') }}</a>
+    <button class="btn secondary small" type="submit" form="dp-c{{ loop.index }}">{{ t('btn_dismiss') }}</button>
+  </form>
+  <form id="dp-c{{ loop.index }}" method="post" action="{{ url_for('quality_dismiss') }}" style="display:none">
+    <input type="hidden" name="kind" value="{{ s._kind }}"><input type="hidden" name="key" value="{{ s._key }}"></form>
+  {% else %}<p>{{ t('quality_no_company_suggestions') }}</p>{% endfor %}
+
+  {% for s in q.suggestions.guests %}
+  <form method="post" action="{{ url_for('quality_merge_guests') }}" style="margin:4px 0; display:flex; gap:8px; align-items:center"
+        onsubmit="return confirm('{{ t('confirm_merge') }}')">
+    <input type="hidden" name="keep" value="{{ s.a_id }}"><input type="hidden" name="drop" value="{{ s.b_id }}">
+    <span>{{ t('quality_guest') }}: <b>{{ s.a }}</b> ~ <b>{{ s.b }}</b></span>
+    <button class="btn secondary small" type="submit">{{ t('btn_merge') }} → {{ s.a }}</button>
+    <button class="btn secondary small" type="submit" form="dp-g{{ loop.index }}">{{ t('btn_dismiss') }}</button>
+  </form>
+  <form id="dp-g{{ loop.index }}" method="post" action="{{ url_for('quality_dismiss') }}" style="display:none">
+    <input type="hidden" name="kind" value="{{ s._kind }}"><input type="hidden" name="key" value="{{ s._key }}"></form>
+  {% endfor %}
+{% endblock %}
diff --git a/app/templates/register.html b/app/templates/register.html
new file mode 100644
index 0000000..52bb092
--- /dev/null
+++ b/app/templates/register.html
@@ -0,0 +1,77 @@
+{% extends "base.html" %}
+{% block main_class %}grid-page{% endblock %}
+{% block content %}
+  {% set unit_opts = rows|map(attribute='unit')|select|unique|sort %}
+  {% set nat_opts = rows|map(attribute='nationality')|select|unique|sort %}
+  <h1>{{ t('register_title') }}</h1>
+  <div class="toolbar">
+    <input class="search live-search" data-grid="reg" type="text" placeholder="{{ t('search_placeholder') }}">
+    <select class="live-filter" data-grid="reg" data-col="{{ t('col_unit') }}"><option value="">{{ t('filter_all', col=t('col_unit')) }}</option>
+      {% for u in unit_opts %}<option>{{ u }}</option>{% endfor %}</select>
+    <select class="live-filter" data-grid="reg" data-col="{{ t('col_departure') }}"><option value="">{{ t('filter_all', col=t('filter_stay')) }}</option>
+      <option value="__empty__">{{ t('filter_still_here') }}</option>
+      <option value="__filled__">{{ t('filter_departed') }}</option></select>
+    <select class="live-filter" data-grid="reg" data-col="{{ t('col_nationality') }}"><option value="">{{ t('filter_all', col=t('col_nationality')) }}</option>
+      {% for nat in nat_opts %}<option>{{ nat }}</option>{% endfor %}</select>
+    <span class="count"><span class="grid-count" data-grid="reg">{{ rows|length }}</span> {{ t('showing_count', count='')|trim }}</span>
+    <span class="spacer"></span>
+    <button class="btn secondary" type="button" onclick="invoiceFromSelection()">{{ t('btn_invoice_from_selection') }}</button>
+    <button class="btn secondary" type="button" onclick="gridPrint('reg')">{{ t('btn_print') }}</button>
+    <a class="btn" href="{{ url_for('stay_form') }}">+ {{ t('btn_add_stay') }}</a>
+  </div>
+  <p class="printinfo" data-grid="reg"></p>
+
+  <div class="tablewrap">
+    {# data-pin: checkbox, Einheit, G-Blatt, Name and Vorname stay on screen while scrolling #}
+    <table id="reg" class="grid" data-scroll="end" data-pin="1 2 3 4 5">
+      <thead><tr>
+        <th class="nosort selcol"></th><th>{{ t('col_unit') }}</th><th>{{ t('col_sheetno') }}</th>
+        <th>{{ t('col_lastname') }}</th><th>{{ t('col_firstname') }}</th><th>{{ t('col_birth') }}</th>
+        <th>{{ t('col_residence') }}</th><th>{{ t('col_room') }}</th>
+        <th>{{ t('col_arrival') }}</th><th>{{ t('col_departure') }}</th><th class="num">{{ t('col_days') }}</th>
+        <th>{{ t('col_tourism_liable') }}</th><th>{{ t('col_nationality') }}</th><th>{{ t('col_document') }}</th>
+        <th>{{ t('col_docnr') }}</th><th>{{ t('col_profession') }}</th><th>{{ t('col_address') }}</th>
+        <th>{{ t('col_postcode') }}</th><th>{{ t('col_city') }}</th><th>{{ t('col_country') }}</th>
+        <th>{{ t('col_phone') }}</th><th>{{ t('col_employer') }}</th><th>{{ t('col_employer_address') }}</th>
+        <th>{{ t('col_notes_long') }}</th>
+        <th class="nosort actions"></th>
+      </tr></thead>
+      <tbody>
+        {# rows ship inside an inert <template>: grids.js renders only the visible window (see freezeLayout) #}
+        <template>
+        {% for r in rows %}
+        <tr>
+          <td class="selcol"><input type="checkbox" class="rowsel" value="{{ r.stay_id }}"></td>
+          <td>{% if r.unit %}<span class="pill unit">{{ r.unit }}</span>{% endif %}</td>
+          <td>{{ r.sheet_number or '' }}</td><td>{{ r.last_name or '' }}</td><td>{{ r.first_name or '' }}</td>
+          <td>{{ r.birth_date|date }}</td>
+          <td>{{ 'HWS' if r.hauptwohnsitz == 1 else ('NWS' if r.hauptwohnsitz == 0 else '') }}</td>
+          <td>{{ r.room or '' }}</td>
+          {#- the weekday before the date; data-k = the ISO date, or the column would sort by "Mo/Di/Mi" -#}
+          <td{% if r.arrival %} data-k="{{ r.arrival|replace('-', '') }}"{% endif %}>{{ r.arrival|datewd }}</td><td{% if r.departure %} data-k="{{ r.departure|replace('-', '') }}"{% endif %}>{{ r.departure|datewd }}</td>
+          <td class="num">{{ r.days if r.days is not none else '' }}</td>
+          <td>{{ 'Ja' if r.tourism_liable == 1 else ('-' if r.tourism_liable == 0 else '') }}</td>
+          <td>{{ r.nationality or '' }}</td><td>{{ r.doc_type or '' }}</td>
+          <td>{{ r.doc_number or '' }}</td><td>{{ r.profession or '' }}</td><td>{{ r.home_street or '' }}</td>
+          <td>{{ r.home_postcode or '' }}</td><td>{{ r.home_city or '' }}</td><td>{{ r.home_country or '' }}</td>
+          <td>{{ r.phone or '' }}</td><td>{{ r.employer or '' }}</td>
+          <td>{{ r.employer_address or '' }}</td>
+          <td>{{ r.notes or '' }}</td>
+          <td class="actions"><a class="btn secondary small" href="{{ url_for('stay_form', stay_id=r.stay_id) }}">{{ t('btn_edit') }}</a></td>
+        </tr>
+        {% endfor %}
+        </template>
+        {% if not rows %}
+        <tr data-empty="1"><td class="empty" colspan="25">{{ t('no_results') }}</td></tr>
+        {% endif %}
+      </tbody>
+    </table>
+  </div>
+  <script>
+    function invoiceFromSelection() {
+      var ids = window.gridChecked('reg');   // from the grid model — most rows are not in the DOM
+      if (!ids.length) { alert('Bitte zuerst Zeilen auswählen.'); return; }
+      window.location = '{{ url_for("invoice_new") }}?stays=' + ids.join(',');
+    }
+  </script>
+{% endblock %}
diff --git a/app/templates/stay_form.html b/app/templates/stay_form.html
new file mode 100644
index 0000000..691240e
--- /dev/null
+++ b/app/templates/stay_form.html
@@ -0,0 +1,114 @@
+{% extends "base.html" %}
+{% block content %}
+  {% set g = (stay.guest if stay else {}) or {} %}
+  {% set sg = suggest|default({}) %}
+  <h1>{{ t('form_room_change') if room_change else t('form_edit_stay') if stay else t('form_new_stay') }}</h1>
+
+  <datalist id="dl_nationality">{% for v in sg.nationality|default([]) %}<option value="{{ v }}">{% endfor %}</datalist>
+  <datalist id="dl_doc_type">{% for v in sg.doc_type|default([]) %}<option value="{{ v }}">{% endfor %}</datalist>
+  <datalist id="dl_profession">{% for v in sg.profession|default([]) %}<option value="{{ v }}">{% endfor %}</datalist>
+  <datalist id="dl_city">{% for v in sg.city|default([]) %}<option value="{{ v }}">{% endfor %}</datalist>
+  <datalist id="dl_country">{% for v in sg.country|default([]) %}<option value="{{ v }}">{% endfor %}</datalist>
+  <datalist id="dl_client">{% for v in sg.client|default([]) %}<option value="{{ v }}">{% endfor %}</datalist>
+
+  <form class="card" method="post">
+    <div class="grid2">
+      <div class="field"><label>{{ t('col_name') }} *</label>
+        <input type="text" name="last_name" value="{{ g.last_name or '' }}" autofocus required></div>
+      <div class="field"><label>{{ t('col_firstname') }}</label>
+        <input type="text" name="first_name" value="{{ g.first_name or '' }}"></div>
+    </div>
+    <div class="grid2">
+      <div class="field"><label>{{ t('col_birth') }}</label>
+        <input type="date" name="birth_date" value="{{ g.birth_date or '' }}"></div>
+      <div class="field"><label>{{ t('col_nationality') }}</label>
+        <input type="text" name="nationality" value="{{ g.nationality or '' }}" list="dl_nationality"></div>
+    </div>
+    <div class="grid2">
+      <div class="field"><label>{{ t('col_document') }}</label>
+        <input type="text" name="doc_type" value="{{ g.doc_type or '' }}" list="dl_doc_type"></div>
+      <div class="field"><label>{{ t('col_docnr') }}</label>
+        <input type="text" name="doc_number" value="{{ g.doc_number or '' }}"></div>
+    </div>
+    <div class="field"><label>{{ t('col_profession') }}</label>
+      <input type="text" name="profession" value="{{ g.profession or '' }}" list="dl_profession"></div>
+
+    <div class="grid2">
+      <div class="field"><label>{{ t('lbl_room') }}</label>
+        <select name="room_id">
+          <option value="">—</option>
+          {% for r in rooms %}
+            <option value="{{ r.id }}" {{ 'selected' if stay and stay.room_id == r.id }}>{{ r.number }} ({{ r.category }})</option>
+          {% endfor %}
+        </select></div>
+      <div class="field"><label>{{ t('lbl_unit') }}</label>
+        <select name="unit_id">
+          <option value="">—</option>
+          {% for u in units %}
+            <option value="{{ u.id }}" {{ 'selected' if stay and stay.unit_id == u.id }}>{{ u.code }}</option>
+          {% endfor %}
+        </select></div>
+    </div>
+    <div class="field"><label>{{ t('col_employer') }}</label>
+      <input type="text" name="employer" value="{{ stay.employer_name or '' if stay else '' }}" list="dl_client"></div>
+
+    <div class="grid2">
+      <div class="field"><label>{{ t('col_arrival') }}</label>
+        <input type="date" name="arrival" value="{{ stay.arrival or '' if stay else '' }}"></div>
+      <div class="field"><label>{{ t('col_departure') }}</label>
+        <input type="date" name="departure" value="{{ stay.departure or '' if stay else '' }}"></div>
+    </div>
+    <div class="field"><label>{{ t('col_sheetno') }}</label>
+      <input type="text" name="sheet_number" value="{{ stay.sheet_number or '' if stay else '' }}" style="max-width:160px"></div>
+
+    <div class="grid2">
+      <div class="field"><label>{{ t('col_address_private') }}</label>
+        <input type="text" name="home_street" value="{{ g.home_street or '' }}"></div>
+      <div class="field"><label>{{ t('col_country') }}</label>
+        <input type="text" name="home_country" value="{{ g.home_country or '' }}" list="dl_country"></div>
+    </div>
+    <div class="grid2">
+      <div class="field"><label>{{ t('col_postcode') }}</label>
+        <input type="text" name="home_postcode" value="{{ g.home_postcode or '' }}"></div>
+      <div class="field"><label>{{ t('col_city') }}</label>
+        <input type="text" name="home_city" value="{{ g.home_city or '' }}" list="dl_city"></div>
+    </div>
+    <div class="field"><label>{{ t('col_phone') }}</label>
+      <input type="text" name="phone" value="{{ g.phone or '' }}"></div>
+    <div class="grid2">
+      <div class="field"><label>{{ t('col_residence') }}</label>
+        <select name="hauptwohnsitz">
+          <option value="" {{ 'selected' if not stay or stay.hauptwohnsitz is none }}>—</option>
+          <option value="1" {{ 'selected' if stay and stay.hauptwohnsitz == 1 }}>{{ t('hws_full') }}</option>
+          <option value="0" {{ 'selected' if stay and stay.hauptwohnsitz == 0 }}>{{ t('hws_none') }}</option>
+        </select></div>
+      <div class="field"><label>{{ t('col_tourism_liable') }}</label>
+        <select name="tourism_liable">
+          <option value="" {{ 'selected' if not stay or stay.tourism_liable is none }}>—</option>
+          <option value="1" {{ 'selected' if stay and stay.tourism_liable == 1 }}>{{ t('yes') }}</option>
+          <option value="0" {{ 'selected' if stay and stay.tourism_liable == 0 }}>{{ t('no') }}</option>
+        </select></div>
+    </div>
+    <div class="field"><label>{{ t('col_notes') }}</label>
+      {# 'or ""' matters: '{{ x if stay }}' renders the STRING 'None' for an empty field, which then
+         gets saved back as literal text on the next submit #}
+      <textarea name="notes" rows="2">{{ stay.notes or '' if stay else '' }}</textarea></div>
+
+    <div class="formactions">
+      <button class="btn" type="submit">{{ t('btn_save') }}</button>
+      {% if stay and stay.id %}
+      {# a room change: same person and number, a new sheet in another room from the departure day #}
+      <button class="btn secondary" type="submit" name="action" value="room_change"
+              title="{{ t('hint_room_change') }}">{{ t('btn_room_change') }}</button>
+      {% endif %}
+      <a class="btn secondary" href="{{ url_for('register') }}">{{ t('btn_cancel') }}</a>
+    </div>
+  </form>
+
+  {% if stay and stay.id %}
+  <form class="formactions" method="post" action="{{ url_for('stay_delete', stay_id=stay.id) }}"
+        onsubmit="return confirm('{{ t('confirm_delete') }}')">
+    <button class="btn danger" type="submit">{{ t('btn_delete') }}</button>
+  </form>
+  {% endif %}
+{% endblock %}
diff --git a/app/templates/tvb.html b/app/templates/tvb.html
new file mode 100644
index 0000000..e5ffb3a
--- /dev/null
+++ b/app/templates/tvb.html
@@ -0,0 +1,89 @@
+{% extends "base.html" %}
+{% block content %}
+  {# Landscape when printed — the wide detail table reads better that way. As THIS document's default
+     page, not a named page: with mixed page sizes a printer may still print a later unit's part portrait.
+     This way there is only one size. #}
+  <style>@media print { @page { size: A4 landscape; margin: 10mm; } }</style>
+  <h1>{{ t('tvb_title') }} – {{ r.month_name }}</h1>
+  <p class="lead noprint">{{ t('tvb_intro') }}</p>
+
+  <form method="get" style="margin:10px 0 18px" class="noprint">
+    <label style="font-weight:600; margin-right:8px">{{ t('tvb_month') }}</label>
+    <input type="month" name="month" value="{{ month_value }}" onchange="this.form.submit()">
+    <button type="button" class="btn" style="margin-left:14px" onclick="window.print()">{{ t('btn_print') }}</button>
+  </form>
+
+  {% for u in r.units %}
+  <section class="tvb-unit" style="margin:0 0 34px">
+    <h2 style="margin:18px 0 4px">{{ u.name }}
+      <small style="font-weight:400; color:#6b756e">— {{ t('tvb_number') }} {{ u.tvb_number or '?' }}</small></h2>
+
+    {% if u.warnings %}
+    <div class="flash" style="margin:8px 0">
+      <b>{{ t('tvb_warnings') }}:</b>
+      {% for w in u.warnings %}<div>{{ w }}</div>{% endfor %}
+    </div>
+    {% endif %}
+
+    {% if not u.rows %}
+    <p>{{ t('tvb_empty') }}</p>
+    {% else %}
+    <h3 style="margin:12px 0 6px">{{ t('tvb_detail') }}</h3>
+    <div class="tablewrap" style="max-height:420px">
+      <table>
+        <thead><tr>
+          <th>{{ t('col_room') }}</th><th>{{ t('col_name') }}</th><th>{{ t('tvb_col_land') }}</th>
+          <th>{{ t('col_sheetno') }}</th><th class="num">{{ t('tvb_col_gb_new') }}</th>
+          <th>{{ t('tvb_col_stay') }}</th><th class="num">{{ t('tvb_col_nights_month') }}</th>
+          <th></th><th>{{ t('tvb_col_note') }}</th>
+        </tr></thead>
+        <tbody>
+          {% for row in u.rows %}
+          <tr>
+            <td>{{ row.room or '' }}</td><td>{{ row.name }}</td><td>{{ row.land }}</td>
+            <td>{{ row.sheet or '' }}</td><td class="num">{{ row.person }}</td>
+            <td>{{ row.arrival|date }}–{{ row.departure|date }}{% if row.total_nights %} ({{ row.total_nights }}){% endif %}</td>
+            <td class="num">{{ row.nights }}</td>
+            <td><span class="pill {{ 'paid' if row.exempt else 'open' }}">
+              {{ t('tvb_status_frei') if row.exempt else t('tvb_status_pflichtig') }}</span></td>
+            <td class="note"><div>{{ row.note or '' }}</div></td>
+          </tr>
+          {% endfor %}
+        </tbody>
+      </table>
+    </div>
+
+    {# heading and tables stay on ONE sheet: otherwise "Für Feratel" can slide alone to the bottom of a
+       page and the figures onto the next #}
+    <div class="tvb-feratel">
+    <h3 style="margin:16px 0 6px">{{ t('tvb_feratel') }}</h3>
+    <div class="tvb-summary" style="display:flex; gap:26px; flex-wrap:wrap; align-items:flex-start">
+      {% for part, label in (('pflichtig', t('tvb_pflichtig')), ('frei', t('tvb_frei'))) %}
+      <div class="tablewrap" style="flex:0 1 340px">
+        <table>
+          <thead><tr><th>{{ label }}</th><th class="num">{{ t('tvb_col_pn') }}</th></tr></thead>
+          <tbody>
+            {% for v in u[part] %}
+            <tr><td>{{ v.land }}</td><td class="num">{{ v.persons }}/{{ v.nights }}</td></tr>
+            {% endfor %}
+            <tr style="font-weight:700; border-top:2px solid #9a9a9a">
+              <td>{{ t('sum_label') }}</td>
+              <td class="num">{{ u[part + '_sum'].persons }}/{{ u[part + '_sum'].nights }}</td></tr>
+          </tbody>
+        </table>
+      </div>
+      {% endfor %}
+    </div>
+    <p style="margin:10px 0 0">
+      <b>{{ t('tvb_total') }}:</b>
+      {{ t('tvb_pflichtig') }} {{ u.pflichtig_sum.persons }}/{{ u.pflichtig_sum.nights }} ·
+      {{ t('tvb_frei') }} {{ u.frei_sum.persons }}/{{ u.frei_sum.nights }}
+      &nbsp;·&nbsp; <b>{{ t('tvb_betrag') }}:</b> {{ u.betrag|euro }}
+      ({{ u.pflichtig_sum.nights }} × {{ r.rate|euro }})
+      &nbsp;·&nbsp; {{ t('tvb_new_sheets') }}: <b>{{ u.new_sheets }}</b>
+    </p>
+    </div>
+    {% endif %}
+  </section>
+  {% endfor %}
+{% endblock %}
diff --git a/app/templates/vat.html b/app/templates/vat.html
new file mode 100644
index 0000000..43716fe
--- /dev/null
+++ b/app/templates/vat.html
@@ -0,0 +1,65 @@
+{% extends "base.html" %}
+{% block content %}
+  <h1>{{ t('vat_title') }} – {{ t('vat_quarter_n', n=quarter) }} {{ year }}</h1>
+  <p class="lead">{{ unit_name }} · {{ r.first|date }} – {{ r.last|date }}</p>
+  <p class="noprint">{{ t('vat_intro') }}</p>
+
+  <form method="get" class="toolbar">
+    <select name="unit" onchange="this.form.submit()">
+      {% for u in units %}<option value="{{ u.code }}"{% if u.code == unit %} selected{% endif %}>{{ u.name }}</option>{% endfor %}
+    </select>
+    <select name="q" onchange="this.form.submit()">
+      {% for n in range(1, 5) %}<option value="{{ n }}"{% if n == quarter %} selected{% endif %}>{{ t('vat_quarter_n', n=n) }}</option>{% endfor %}
+    </select>
+    <select name="year" onchange="this.form.submit()">
+      {% for y in years %}<option{% if y == year %} selected{% endif %}>{{ y }}</option>{% endfor %}
+    </select>
+    <button type="button" class="btn secondary" onclick="window.print()">{{ t('btn_print') }}</button>
+  </form>
+
+  {% for s in r.sections %}
+  <section class="vat-room">
+    <h2>{{ t('col_room') }} {{ s.room }}</h2>
+    <div class="tablewrap">
+      <table>
+        <thead><tr>
+          <th>{{ t('col_paid_date') }}</th><th>{{ t('col_occupant') }}</th><th>{{ t('col_period') }}</th>
+          <th>{{ t('hd_invoice') }}</th><th>{{ t('col_payer') }}</th><th class="num">{{ t('col_amount') }}</th>
+        </tr></thead>
+        <tbody>
+          {% for x in s.rows %}
+          <tr>
+            <td>{{ x.received_on|date }}</td>
+            <td>{{ x.occupant or '' }}
+              {%- if x.storno %} <span class="pill cash">{{ t('vat_storno') }}</span>{% endif %}
+              {%- if x.received < x.amount %} <span class="pill open">{{ t('vat_part') }}</span>{% endif %}</td>
+            {#- a monthly rent may carry only a 'bis' #}
+            <td>{% if x.period_from and x.period_to %}{{ x.period_from|date }}–{{ x.period_to|date }}
+                {%- elif x.period_to %}{{ t('period_until', date=x.period_to|date) }}
+                {%- elif x.period_from %}{{ t('period_since', date=x.period_from|date) }}{% endif %}</td>
+            <td>{{ x.invoice_no or '' }}</td><td>{{ x.payer or '' }}</td>
+            <td class="num">{{ x.received|euro }}</td>
+          </tr>
+          {% endfor %}
+        </tbody>
+        <tfoot><tr><td colspan="5">{{ t('vat_room_sum', room=s.room) }}</td><td class="num">{{ s.sum|euro }}</td></tr></tfoot>
+      </table>
+    </div>
+  </section>
+  {% else %}
+  <p class="empty">{{ t('vat_empty') }}</p>
+  {% endfor %}
+
+  {% if r.sections %}
+  <section class="vat-total">
+    <h2>{{ t('vat_total_title') }}</h2>
+    <table>
+      <tr><td>{{ t('vat_total') }}</td><td class="num">{{ r.total|euro }}</td></tr>
+      {% if r.storno %}<tr><td>{{ t('vat_storno_sum') }}</td><td class="num">− {{ r.storno|euro }}</td></tr>{% endif %}
+      <tr class="key"><td>{{ t('vat_gross') }}</td><td class="num">{{ r.gross|euro }}</td></tr>
+      <tr class="key"><td>{{ t('vat_tax') }}</td><td class="num">{{ r.vat|euro }}</td></tr>
+      <tr class="key"><td>{{ t('vat_net') }}</td><td class="num">{{ r.net|euro }}</td></tr>
+    </table>
+  </section>
+  {% endif %}
+{% endblock %}
diff --git a/app/tvb.py b/app/tvb.py
new file mode 100644
index 0000000..20d1f2c
--- /dev/null
+++ b/app/tvb.py
@@ -0,0 +1,218 @@
+"""Monthly TVB Sammelmeldung (Aufenthaltsabgabe) figures, computed from the guest register.
+
+The rules of the report:
+- a night belongs to the month its evening falls in (the night onto the 1st counts to the previous month);
+- "Personen" = NEW Gästeblätter that month — a guest already present counts 0 persons, only nights;
+  a room change keeps the sheet number (no new person), a vacation gap issues a new sheet (counts again);
+- the Land is the HAUPTWOHNSITZ: the register's HWS flag set means the main residence is the house itself
+  (→ Ö-Tirol); Austria splits by Bundesland (postcode), Germany reports per postcode region;
+- stays of more than 10 nights in total are exempt ("Freie"), shorter ones owe the levy ("Pflichtige");
+  a still-open stay at the month border is assumed to run long (frei) but flagged for a human decision.
+"""
+import datetime
+import re
+
+from app import compute, db, i18n
+
+EXEMPT_OVER_NIGHTS = compute.TOURISM_EXEMPT_OVER_NIGHTS   # > 10 nights total → exempt from the levy
+STALE_AFTER_DAYS = 365   # an open stay this much older than the month is a missing departure, not a guest
+
+AT_STATES = ((1000, 1999, "Wien"), (2000, 3999, "Niederösterreich"), (4000, 4999, "Oberösterreich"),
+             (5000, 5999, "Salzburg"), (6000, 6699, "Tirol"), (6700, 6999, "Vorarlberg"),
+             (7000, 7999, "Burgenland"), (8000, 8999, "Steiermark"), (9000, 9999, "Kärnten"))
+
+# Feratel's German "Stat. Land" dropdown offers 7 regions (the Statistik-Austria grouping), spelled
+# exactly as below. The Bundesland is resolved from the PLZ first, then folded into its region.
+DE_REGIONS = {"Bayern": "Bayern", "Baden-Württemberg": "Baden Württemberg",
+              "Nordrhein-Westfalen": "Nordrhein-Westfalen", "Berlin": "Berlin",
+              "Niedersachsen": "Norddeutschland", "Hamburg": "Norddeutschland",
+              "Bremen": "Norddeutschland", "Schleswig-Holstein": "Norddeutschland",
+              "Hessen": "Mitteldeutschland", "Rheinland-Pfalz": "Mitteldeutschland",
+              "Saarland": "Mitteldeutschland",
+              "Brandenburg": "Ostdeutschland", "Mecklenburg-Vorpommern": "Ostdeutschland",
+              "Sachsen": "Ostdeutschland", "Sachsen-Anhalt": "Ostdeutschland",
+              "Thüringen": "Ostdeutschland"}
+
+# German Leitregion -> predominant Bundesland. A few border regions genuinely cross states
+# (e.g. Aschaffenburg 637xx is Bayern inside the Hessen block), so every German row carries its PLZ
+# as a note to check — at a few German guests a year that is the honest cut.
+DE_STATES = (
+    (1000, 2999, "Sachsen"), (3000, 3999, "Brandenburg"), (4000, 5999, "Sachsen"),
+    (6000, 6999, "Sachsen-Anhalt"), (7000, 7999, "Thüringen"), (8000, 9999, "Sachsen"),
+    (10000, 14330, "Berlin"), (14400, 16999, "Brandenburg"), (17000, 19999, "Mecklenburg-Vorpommern"),
+    (20000, 22999, "Hamburg"), (23000, 25999, "Schleswig-Holstein"),
+    (26000, 27499, "Niedersachsen"), (27500, 27599, "Bremen"), (27600, 27999, "Niedersachsen"),
+    (28000, 28999, "Bremen"), (29000, 31999, "Niedersachsen"), (32000, 33999, "Nordrhein-Westfalen"),
+    (34000, 36999, "Hessen"), (37000, 38999, "Niedersachsen"), (39000, 39999, "Sachsen-Anhalt"),
+    (40000, 48999, "Nordrhein-Westfalen"), (49000, 49999, "Niedersachsen"),
+    (50000, 53999, "Nordrhein-Westfalen"), (54000, 56999, "Rheinland-Pfalz"),
+    (57000, 59999, "Nordrhein-Westfalen"), (60000, 65999, "Hessen"), (66000, 66999, "Saarland"),
+    (67000, 67999, "Rheinland-Pfalz"), (68000, 79999, "Baden-Württemberg"),
+    (80000, 87999, "Bayern"), (88000, 89999, "Baden-Württemberg"),
+    (90000, 97999, "Bayern"), (98000, 99999, "Thüringen"),
+)
+
+
+def _date(s):
+    return datetime.date.fromisoformat(s[:10]) if s else None
+
+
+def _at_state(postcode):
+    digits = "".join(ch for ch in str(postcode or "") if ch.isdigit())[:4]
+    if len(digits) == 4:
+        n = int(digits)
+        for lo, hi, name in AT_STATES:
+            if lo <= n <= hi:
+                return name
+    return None
+
+
+def _de_state(postcode):
+    digits = "".join(ch for ch in str(postcode or "") if ch.isdigit())
+    if len(digits) == 4:                                # a lost leading zero (02763 -> 2763)
+        digits = "0" + digits
+    if len(digits) == 5:
+        n = int(digits)
+        for lo, hi, name in DE_STATES:
+            if lo <= n <= hi:
+                return name
+    return None
+
+
+def _land(row):
+    """The reporting Land for a guest, in the report's shorthand ('Ö-Wien'). Returns (land, warning?)."""
+    if row["hauptwohnsitz"] == 1:                       # main residence IS the house → Tirol
+        return "Ö-Tirol", None
+    country = (row["home_country"] or "").strip()
+    if not country:
+        nat = (row["nationality"] or "").strip()
+        if nat:
+            return nat, i18n.t("tvb_warn_nationality_used")
+        return "Unbekannt", i18n.t("tvb_warn_no_country")
+    if country == "Österreich":
+        state = _at_state(row["home_postcode"])
+        if state:
+            return f"Ö-{state}", None
+        return "Ö-?", i18n.t("tvb_warn_at_postcode")
+    if country == "Deutschland":
+        state = _de_state(row["home_postcode"])
+        if state:                                       # grouped exactly like Feratel's dropdown
+            return f"{DE_REGIONS[state]} (DE)", \
+                i18n.t("tvb_warn_de_border", postcode=row["home_postcode"], state=state)
+        return "Deutschland (?)", i18n.t("tvb_warn_de_postcode")
+    return country, None
+
+
+def _sheet_order(sheet):
+    """Gästeblatt numbers in numeric order ('98' before '613'), a row without one last — the order the
+    paper sheets are filed in."""
+    m = re.match(r"\d+", sheet or "")
+    return (0, int(m.group())) if m else (1, 0)
+
+
+def _nights_in(arrival, departure, month_start, month_end):
+    """Nights whose evening falls inside the month; the departure day itself is no night."""
+    a = max(arrival, month_start)
+    b = min(departure - datetime.timedelta(days=1), month_end) if departure else month_end
+    return max(0, (b - a).days + 1)
+
+
+def monthly_report(conn, year, month):
+    """The Sammelmeldung for one month: per current unit the room-by-room detail rows (to check against
+    the paper sheets) and the per-Land Pflichtige/Freie summary exactly as it is typed into Feratel."""
+    month_start = datetime.date(year, month, 1)
+    rate = compute.tourism_rate(month_start.isoformat())
+    month_end = (month_start + datetime.timedelta(days=45)).replace(day=1) - datetime.timedelta(days=1)
+    stale_before = month_start - datetime.timedelta(days=STALE_AFTER_DAYS)
+
+    stays = db.rows(conn, """
+        SELECT s.id, s.arrival, s.departure, s.sheet_number, s.hauptwohnsitz, s.guest_id,
+               COALESCE(s.unit_id, rm.unit_id) AS unit_id, rm.number AS room,
+               TRIM(g.last_name || ' ' || COALESCE(g.first_name, '')) AS name,
+               g.home_country, g.home_postcode, g.nationality
+        FROM stay s JOIN guest g ON s.guest_id = g.id LEFT JOIN room rm ON s.room_id = rm.id
+        WHERE s.source_sheet = 'guestsheet' AND s.arrival IS NOT NULL
+          AND s.arrival <= ? AND (s.departure IS NULL OR s.departure > ?)
+        ORDER BY rm.number NULLS FIRST, s.arrival NULLS FIRST, s.id""", (month_end.isoformat(), month_start.isoformat()))
+
+    # current units; predecessors report under their successor
+    units = {u["id"]: dict(u) for u in db.rows(conn, "SELECT * FROM unit ORDER BY id")}
+    def current_unit(uid):
+        seen = set()
+        while uid in units and units[uid]["succeeded_by_id"] and uid not in seen:
+            seen.add(uid)
+            uid = units[uid]["succeeded_by_id"]
+        return uid
+
+    # group rows by Gästeblatt (room changes share the number); a sheetless row is its own group
+    groups = {}
+    for s in stays:
+        key = (s["guest_id"], s["sheet_number"]) if s["sheet_number"] else ("stay", s["id"])
+        groups.setdefault(key, []).append(s)
+
+    report = {u["code"]: {"code": u["code"], "name": u["name"], "tvb_number": u["tvb_number"],
+                          "rows": [], "warnings": [], "summary": {}}
+              for u in units.values() if u.get("is_current")}
+
+    for rows in groups.values():
+        first = min(rows, key=lambda r: r["arrival"])
+        arrival = _date(first["arrival"])
+        is_open = any(r["departure"] is None for r in rows)
+        unit = units.get(current_unit(rows[0]["unit_id"]))
+        target = report.get(unit["code"]) if unit else None
+        if target is None:                                # no unit resolvable — surface, never guess a Betrieb
+            for u in report.values():
+                u["warnings"].append(i18n.t("tvb_warn_no_unit", name=first["name"], arrival=f"{arrival:%d.%m.%Y}"))
+            continue
+        if is_open and arrival < stale_before:            # forgotten departure years ago, not a guest —
+            continue                                      # surfaced on the Datenprüfung page, not here
+
+        land, land_warn = _land(first)
+        month_nights = sum(_nights_in(_date(r["arrival"]), _date(r["departure"]), month_start, month_end)
+                           for r in rows)
+        if month_nights == 0:
+            continue
+        total_nights = sum((( _date(r["departure"]) or month_end + datetime.timedelta(days=1))
+                            - _date(r["arrival"])).days for r in rows)
+        person = 1 if arrival >= month_start else 0
+        exempt = total_nights > EXEMPT_OVER_NIGHTS
+        note = None
+        if not exempt and is_open:                        # foreseeably long stays are frei
+            exempt, note = True, i18n.t("tvb_note_still_here", nights=total_nights)
+        if land_warn:
+            note = (note + "; " if note else "") + land_warn
+
+        for r in sorted(rows, key=lambda r: r["arrival"]):
+            n = _nights_in(_date(r["arrival"]), _date(r["departure"]), month_start, month_end)
+            if n == 0:
+                continue
+            target["rows"].append({
+                "room": r["room"], "name": r["name"], "land": land,
+                "person": person if r is first else 0, "nights": n,
+                # the whole stay next to the month's share: a stay across a month boundary looks like a
+                # mismatch against the Gästeblatt otherwise (24.08.-02.09. = 9 Nächte, 8 of them in
+                # August, 1 in September)
+                "arrival": r["arrival"], "departure": r["departure"], "total_nights": total_nights,
+                "sheet": r["sheet_number"], "exempt": exempt, "note": note})
+            note = None                                   # print group notes once
+        key = (land, exempt)
+        agg = target["summary"].setdefault(key, {"land": land, "exempt": exempt, "persons": 0, "nights": 0})
+        agg["persons"] += person
+        agg["nights"] += month_nights
+
+    month_names = i18n.t("months")
+    out = []
+    for code in sorted(report):
+        u = report[code]
+        u["rows"].sort(key=lambda r: (str(r["room"] or "~"), _sheet_order(r["sheet"]), r["arrival"], r["name"]))
+        u["pflichtig"] = sorted((v for v in u["summary"].values() if not v["exempt"]), key=lambda v: v["land"])
+        u["frei"] = sorted((v for v in u["summary"].values() if v["exempt"]), key=lambda v: v["land"])
+        for part in ("pflichtig", "frei"):
+            u[part + "_sum"] = {"persons": sum(v["persons"] for v in u[part]),
+                                "nights": sum(v["nights"] for v in u[part])}
+        u["betrag"] = round(u["pflichtig_sum"]["nights"] * rate, 2)
+        u["new_sheets"] = u["pflichtig_sum"]["persons"] + u["frei_sum"]["persons"]
+        del u["summary"]
+        out.append(u)
+    return {"year": year, "month": month, "month_start": month_start, "rate": rate,
+            "month_name": f"{month_names[month - 1]} {year}", "units": out}
diff --git a/app/vat.py b/app/vat.py
new file mode 100644
index 0000000..e695a33
--- /dev/null
+++ b/app/vat.py
@@ -0,0 +1,75 @@
+"""Quarterly Umsatzsteuer-Voranmeldung list, computed from the Zimmerbelegung.
+
+- A receipt belongs to the quarter it was PAID in (Ist-Besteuerung), not the one it was lived or invoiced
+  in. A row paid in several goes counts each payment on its own day; otherwise paid = the same rule the
+  Zimmerbelegung shows (`repo._payment`): the row's own date, else the date its invoice was paid.
+- Only the Betrag counts. The Ortstaxe is a durchlaufender Posten and never appears; payments cover the
+  Betrag first (175,00 paid of 175,00 Betrag + 16,00 Ortstaxe: the Betrag is in, the Ortstaxe open).
+- One Betrieb at a time — each unit files separately. A Betrieb includes its predecessors.
+- Everything is 10 % USt: Beherbergung, and the Garçonnières' residential rent alike. A Storno is nicht
+  steuerbar (`repo.is_storno`): listed, because the money came in, but kept out of the base.
+"""
+import datetime
+
+from app import db, repo
+
+VAT_RATE = 0.10
+
+
+def previous_quarter(today):
+    """The UVA is filed for the quarter that has just ended."""
+    q = (today.month - 1) // 3          # 0 = we are in the 1st quarter → last year's 4th
+    return (today.year, q) if q else (today.year - 1, 4)
+
+
+def _bounds(year, quarter):
+    first = datetime.date(year, 3 * quarter - 2, 1)
+    after = datetime.date(year + 1, 1, 1) if quarter == 4 else datetime.date(year, 3 * quarter + 1, 1)
+    return first.isoformat(), (after - datetime.timedelta(days=1)).isoformat()
+
+
+def receipts(row):
+    """When this row's money came in: [(date, part of the Betrag, part of the Ortstaxe)].
+
+    Recorded payments count one by one, each on its own day — an invoice paid half in May and half in
+    October belongs to two quarters. They cover the Betrag first and the Ortstaxe last. Without payments, a
+    paid row came in whole on its 'bezahlt am'."""
+    if row["payments"]:
+        out, left, taxe = [], row["amount"] or 0, row["tourism_tax"] or 0
+        for on, amount in row["payments"]:
+            part = round(min(amount, left), 2)
+            tax = round(min(amount - part, taxe), 2)
+            left, taxe = left - part, taxe - tax
+            if part > 0 or tax > 0:
+                out.append((on, part, tax))
+        return out
+    if row["payment"] in ("paid", "cash") and row["paid_on"]:
+        return [(row["paid_on"], row["amount"] or 0, row["tourism_tax"] or 0)]
+    return []
+
+
+def units(conn):
+    return db.rows(conn, "SELECT code, name FROM unit WHERE is_current=1 ORDER BY id")
+
+
+def quarterly_report(conn, unit_code, year, quarter):
+    first, last = _bounds(year, quarter)
+    codes = {r["code"] for r in db.rows(conn, "SELECT code FROM unit WHERE code=? OR succeeded_by_id="
+                                        "(SELECT id FROM unit WHERE code=?)", (unit_code, unit_code))}
+    rooms = {}
+    for r in repo.ledger_rows(conn):
+        if r["unit"] not in codes:
+            continue
+        for on, amount, _ in receipts(r):
+            if amount and first <= on <= last:
+                rooms.setdefault(r["room"] or "", []).append(
+                    dict(r, received_on=on, received=amount, storno=repo.is_storno(r)))
+    sections = [{"room": room, "rows": sorted(rows, key=lambda x: (x["received_on"], x["charge_id"])),
+                 "sum": round(sum(x["received"] for x in rows), 2)}
+                for room, rows in sorted(rooms.items())]
+    total = round(sum(s["sum"] for s in sections), 2)
+    storno = round(sum(x["received"] for s in sections for x in s["rows"] if x["storno"]), 2)
+    gross = round(total - storno, 2)
+    net = round(gross / (1 + VAT_RATE), 2)
+    return {"first": first, "last": last, "sections": sections, "total": total, "storno": storno,
+            "gross": gross, "net": net, "vat": round(gross - net, 2)}
diff --git a/app/web.py b/app/web.py
new file mode 100644
index 0000000..f6552fb
--- /dev/null
+++ b/app/web.py
@@ -0,0 +1,737 @@
+"""Flask app: the web UI. Refuses to start while a migration is pending. All data access goes through
+repo.py, so scripts get the same operations as the pages.
+"""
+import base64
+import io
+import mimetypes
+import secrets
+import struct
+from functools import lru_cache
+from pathlib import Path
+
+from flask import (Flask, render_template, request, redirect, url_for, g, flash, abort, send_file)
+
+from app import compute, db, i18n, money, pdf, plan, repo, quality, tvb, vat
+
+APP_DIR = Path(__file__).resolve().parent
+INVOICE_ASSETS = APP_DIR / "static" / "invoice"
+
+
+def get_db():
+    if "conn" not in g:
+        g.conn = db.connect(actor="web")
+    return g.conn
+
+
+_page_cache = {}
+
+
+def assets_fingerprint():
+    """Newest mtime of the grid's own code — static files AND templates. It belongs in the fingerprint that
+    keys the FROZEN column layouts in the browser's localStorage: without it a change is invisible after a
+    reload, because the browser re-applies the widths it measured against the old code. The templates count
+    too: a template change can widen a column without touching a single static file."""
+    files = [APP_DIR / "static" / f for f in ("grids.js", "style.css")]
+    files += sorted((APP_DIR / "templates").glob("*.html"))
+    return str(max(int(f.stat().st_mtime) for f in files))
+
+
+def _ledger_year(row):
+    """Which year does a Zimmerbelegung row belong to? That of the first date it actually has —
+    `repo.ledger_rows` says which."""
+    return (row["first_date"] or "")[:4] or None
+
+
+def page_fingerprint():
+    """What a rendered list page depends on: the data AND the grid code. Keys both the server-side page
+    cache and the frozen column layouts in the browser — a cached page carrying the old fingerprint would
+    keep the stale layout alive just as effectively as the layout itself."""
+    return db_fingerprint() + "-" + assets_fingerprint()
+
+
+def db_fingerprint():
+    """The schema and its write counter (`data_version`, counted up by every statement that writes a data
+    table — this app or any script; migration 001). Keys the server-side page cache and the
+    browser's stored grid layouts. The schema belongs in it: the tests run each in a schema of their own."""
+    return f"{db.SCHEMA}.{db.row(get_db(), 'SELECT version FROM data_version')[0]}"
+
+
+def cached_page(view):
+    """Serve the big read-only list pages from memory while the database is unchanged.
+    Pages carrying flash messages are rendered fresh and never stored."""
+    from functools import wraps
+
+    @wraps(view)
+    def wrapped(**kwargs):
+        from flask import session
+        if "_flashes" in session:
+            return view(**kwargs)
+        key = (request.full_path, page_fingerprint())
+        if _page_cache.get(view.__name__, (None,))[0] != key:
+            _page_cache[view.__name__] = (key, view(**kwargs))
+        return _page_cache[view.__name__][1]
+    return wrapped
+
+
+def asset_uri(filename):
+    """Inline an invoice image as a data URI so it renders in both browser-print and the headless PDF."""
+    if not filename:
+        return ""
+    path = INVOICE_ASSETS / filename
+    if not path.exists():
+        return ""
+    mime = mimetypes.guess_type(str(path))[0] or "image/png"
+    return f"data:{mime};base64," + base64.b64encode(path.read_bytes()).decode()
+
+
+ART_BOX_W, ART_BOX_H, ART_GAP = 64, 80, 4  # masthead art box (mm) — keep in sync with .masthead .art CSS
+
+
+@lru_cache(maxsize=None)
+def _image_size(path_str):
+    """Pixel (w, h) of a PNG or JPEG read from the file header — avoids an imaging dependency."""
+    data = Path(path_str).read_bytes()
+    if data[:8] == b"\x89PNG\r\n\x1a\n":
+        w, h = struct.unpack(">II", data[16:24])
+        return w, h
+    if data[:2] == b"\xff\xd8":
+        i = 2
+        while i + 9 < len(data):
+            if data[i] != 0xFF:
+                i += 1
+            elif data[i + 1] == 0x01 or 0xD0 <= data[i + 1] <= 0xD9:  # marker without a length field
+                i += 2
+            elif 0xC0 <= data[i + 1] <= 0xCF and data[i + 1] not in (0xC4, 0xC8, 0xCC):  # SOFn
+                h, w = struct.unpack(">HH", data[i + 5:i + 9])
+                return w, h
+            else:
+                i += 2 + struct.unpack(">H", data[i + 2:i + 4])[0]
+    raise ValueError(f"cannot read image size: {path_str}")
+
+
+def masthead_art(unit):
+    """Explicit print sizes for the branding images. All images of a unit share ONE width, solved so the
+    stack exactly fills the art box height (capped at the box width) — a wide logo can never render bigger
+    than the house photo, and a lone image grows to fill the whole box."""
+    imgs = [{"src": name, "cls": cls} for name, cls in ((unit.get("logo"), "logo"), (unit.get("photo"), "photo"))
+            if name and (INVOICE_ASSETS / name).exists()]
+    for a in imgs:
+        w_px, h_px = _image_size(str(INVOICE_ASSETS / a["src"]))
+        a["ratio"] = h_px / w_px
+    if not imgs:
+        return []
+    usable_h = ART_BOX_H - ART_GAP * (len(imgs) - 1)
+    width = min(ART_BOX_W, usable_h / sum(a["ratio"] for a in imgs))
+    for a in imgs:
+        a["w"] = round(width, 2)
+        a["h"] = round(width * a.pop("ratio"), 2)
+    return imgs
+
+
+def _tourism_rate(on_date=None):
+    """The Aufenthaltsabgabe per person and night in force on that date — handed to the ledger form so the
+    browser can propose the amount without a second copy of the rate table."""
+    import datetime
+    return compute.tourism_rate(on_date or datetime.date.today().isoformat())
+
+
+def create_app():
+    app = Flask(__name__)
+    app.secret_key = secrets.token_hex(32)   # the session only carries flash messages across a redirect
+
+    # Static assets: version the URL by file mtime and cache hard. Without this the browser's heuristic
+    # cache kept serving OLD grids.js/style.css after updates (no revalidation for hours/days).
+    app.config["SEND_FILE_MAX_AGE_DEFAULT"] = 60 * 60 * 24 * 365
+
+    @app.url_defaults
+    def bust_static_cache(endpoint, values):
+        if endpoint == "static" and "filename" in values:
+            f = APP_DIR / "static" / values["filename"]
+            if f.exists():
+                values["v"] = int(f.stat().st_mtime)
+
+    conn = db.connect()
+    pending = db.pending_migrations(conn)
+    conn.close()
+    if pending:      # the app's role may not change the schema — the owner does, before the app starts
+        raise RuntimeError(f"database schema is behind the code (migrations {pending}) — "
+                           f"run first: python -m app.db migrate")
+
+    # the grid pages render thousands of rows — don't ship template indentation as page weight
+    app.jinja_env.trim_blocks = True
+    app.jinja_env.lstrip_blocks = True
+    app.context_processor(lambda: {"db_fp": page_fingerprint()})
+    app.jinja_env.globals["t"] = i18n.t
+    app.jinja_env.globals["asset_uri"] = asset_uri
+    app.jinja_env.globals["masthead_art"] = masthead_art
+    app.jinja_env.filters["euro"] = money.euro
+    app.jinja_env.filters["num"] = money.de_number
+    app.jinja_env.filters["date"] = money.de_date
+    app.jinja_env.filters["datewd"] = money.de_date_wd   # with the weekday, for the two lists
+
+    @app.after_request
+    def never_cache_pages(resp):
+        # dynamic pages must always re-render — without this, the browser's back button (bfcache /
+        # heuristic caching) shows a STALE copy after an edit. Versioned static assets keep their year.
+        if request.endpoint != "static":
+            resp.headers["Cache-Control"] = "no-store"
+        return resp
+
+    @app.teardown_appcontext
+    def close_db(exc):
+        conn = g.pop("conn", None)
+        if conn is not None:
+            conn.close()
+
+    @app.route("/")
+    def home():
+        return render_template("home.html", stats=repo.stats(get_db()))
+
+    # --- guest register ---
+    @app.route("/register")
+    @cached_page
+    def register():
+        search = request.args.get("q", "").strip()
+        return render_template("register.html", rows=repo.register_rows(get_db(), search), q=search)
+
+    @app.route("/register/new", methods=["GET", "POST"])
+    @app.route("/register/<int:stay_id>/edit", methods=["GET", "POST"])
+    def stay_form(stay_id=None):
+        conn = get_db()
+        stay = repo.get_stay(conn, stay_id) if stay_id else None
+        # a room change: the new sheet continues the old one — same person, same number
+        from_id = None if stay_id else request.args.get("from", type=int)
+        moved_from = repo.get_stay(conn, from_id) if from_id else None
+        if request.method == "POST":
+            f = request.form
+            if not f.get("last_name", "").strip():
+                flash(i18n.t("err_required", field=i18n.t("col_name")))
+            elif f.get("arrival") and f.get("departure") and f["departure"] < f["arrival"]:
+                flash(i18n.t("err_departure_before_arrival"))   # reject at the door, not on Datenprüfung
+            else:
+                last = f["last_name"].strip()
+                first = f.get("first_name", "").strip() or None
+                gfields = dict(birth_date=f.get("birth_date") or None, nationality=f.get("nationality") or None,
+                               doc_type=f.get("doc_type") or None, doc_number=f.get("doc_number") or None,
+                               profession=f.get("profession") or None, home_street=f.get("home_street") or None,
+                               home_postcode=f.get("home_postcode") or None, home_city=f.get("home_city") or None,
+                               home_country=f.get("home_country") or None, phone=f.get("phone") or None)
+                person = stay or moved_from                  # edit, or the same person in another room
+                if person and person.get("guest_id"):        # update this exact person
+                    repo.update_guest(conn, person["guest_id"], last_name=last, first_name=first, **gfields)
+                    guest_id = person["guest_id"]
+                else:                                        # new: reuse only on exact person match
+                    guest_id = repo.find_or_create_guest(conn, last, first, **gfields)
+                room_id = int(f["room_id"]) if f.get("room_id") else None
+                saved = repo.save_stay(conn, stay_id, guest_id, room_id,
+                                       int(f["unit_id"]) if f.get("unit_id") else None,
+                                       repo.find_or_create_client(conn, f.get("employer")),
+                                       f.get("arrival") or None, f.get("departure") or None,
+                                       f.get("sheet_number") or None,
+                                       int(f["hauptwohnsitz"]) if f.get("hauptwohnsitz") in ("0", "1") else None,
+                                       int(f["tourism_liable"]) if f.get("tourism_liable") in ("0", "1") else None,
+                                       f.get("notes") or None)
+                if f.get("action") == "room_change":
+                    if not f.get("departure"):                # the departure IS the day of the change
+                        flash(i18n.t("err_room_change_needs_date"))
+                        return redirect(url_for("stay_form", stay_id=saved))
+                    return redirect(url_for("stay_form", **{"from": saved}))
+                if moved_from and repo.carry_ledger_to_room(conn, f.get("sheet_number") or None,
+                                                            moved_from["room_id"], room_id, f.get("arrival"),
+                                                            {"last_name": last, "first_name": first}):
+                    flash(i18n.t("msg_room_changed", date=money.de_date(f["arrival"]),
+                                 room=_room_number(conn, room_id)))
+                return redirect(url_for("register"))
+        if moved_from:                                       # the old sheet, as the new one starts
+            stay = dict(moved_from, id=None, room_id=None, arrival=moved_from["departure"], departure=None,
+                        notes=i18n.t("note_room_change", room=_room_number(conn, moved_from["room_id"])))
+        return render_template("stay_form.html", stay=stay, room_change=bool(moved_from), rooms=repo.rooms(conn),
+                               units=repo.units(conn), suggest=repo.field_suggestions(conn))
+
+    @app.route("/register/<int:stay_id>/delete", methods=["POST"])
+    def stay_delete(stay_id):
+        try:
+            repo.delete_stay(get_db(), stay_id)
+        except ValueError:
+            flash(i18n.t("err_delete_blocked"))
+        return redirect(url_for("register"))
+
+    # --- room ledger ---
+    @app.route("/ledger")
+    @cached_page
+    def ledger():
+        conn = get_db()
+        room = request.args.get("room", "").strip()
+        search = request.args.get("q", "").strip()
+        rows = repo.ledger_rows(conn, room or None, search)
+        years = sorted({y for y in (_ledger_year(r) for r in rows) if y}, reverse=True)
+        return render_template("ledger.html", rows=rows, years=years,
+                               rooms=repo.rooms(conn), room=room, q=search)
+
+    @app.route("/ledger/new", methods=["GET", "POST"])
+    def ledger_new():
+        conn = get_db()
+        if request.method == "POST":
+            f = request.form
+            room = f.get("room_id", "").strip()
+            repo.create_ledger_row(conn, int(room) if room.isdigit() else None,
+                                   f.get("occupant", "").strip() or None,
+                                   f.get("period_from") or None, f.get("period_to") or None,
+                                   parse_number(f.get("persons")), parse_number(f.get("quantity")),
+                                   f.get("unit_type") or None, parse_number(f.get("gross_per_unit")),
+                                   parse_number(f.get("betrag")), f.get("paid_status") or None,
+                                   f.get("paid_date") or None, f.get("art") or None,
+                                   f.get("payer", "").strip() or None, f.get("rnr", "").strip() or None,
+                                   f.get("gb_ref", "").strip() or None, f.get("notes", "").strip() or None,
+                                   tourism_tax=parse_number(f.get("tourism_tax")),
+                                   payments=_payments(f) or [])
+            return redirect(url_for("ledger"))
+        return render_template("ledger_form.html", ch={}, rooms=repo.rooms(conn), is_new=True,
+                               tourism_rate=_tourism_rate(None))
+
+    @app.route("/ledger/<int:charge_id>/edit", methods=["GET", "POST"])
+    def ledger_edit(charge_id):
+        conn = get_db()
+        ch = repo.get_charge(conn, charge_id)
+        if not ch:
+            abort(404)
+        if request.method == "POST":
+            f = request.form
+            repo.update_charge(conn, charge_id, f.get("occupant", "").strip() or None,
+                               f.get("period_from") or None, f.get("period_to") or None,
+                               parse_number(f.get("persons")), parse_number(f.get("quantity")),
+                               f.get("unit_type") or None, parse_number(f.get("gross_per_unit")),
+                               parse_number(f.get("betrag")), f.get("paid_status") or None,
+                               f.get("paid_date") or None, f.get("art") or None,
+                               f.get("payer", "").strip() or None, f.get("rnr", "").strip() or None,
+                               f.get("gb_ref", "").strip() or None, f.get("notes", "").strip() or None,
+                               tourism_tax=parse_number(f.get("tourism_tax")),
+                               payments=_payments(f))
+            if f.get("action") == "continue":
+                # month-end billing: bill up to this date, then carry the occupancy on from it
+                if not f.get("period_to"):
+                    flash(i18n.t("err_continue_needs_date"))
+                    return redirect(url_for("ledger_edit", charge_id=charge_id))
+                repo.continue_ledger_row(conn, charge_id)
+                flash(i18n.t("msg_continued", date=money.de_date(f["period_to"])))
+            return redirect(url_for("ledger"))
+        return render_template("ledger_form.html", ch=ch, tourism_rate=_tourism_rate(ch.get("period_from")))
+
+    @app.route("/ledger/<int:charge_id>/delete", methods=["POST"])
+    def ledger_delete(charge_id):
+        repo.delete_charge(get_db(), charge_id)
+        return redirect(url_for("ledger"))
+
+    # --- Belegungsplan (occupancy timeline) ---
+    @app.route("/plan")
+    def plan_page():
+        # not @cached_page: the view depends on today's date (today marker, occupancy pills),
+        # and the cache key only sees URL + db fingerprint — it would survive midnight.
+        import datetime
+        weeks = 8 if request.args.get("weeks") == "8" else 4
+        try:
+            start = datetime.date.fromisoformat(request.args.get("start", ""))
+        except ValueError:
+            start = plan.default_start()
+        return render_template("plan.html", p=plan.build(get_db(), start, weeks * 7), weeks=weeks)
+
+    # --- invoices ---
+    @app.route("/invoices")
+    @cached_page
+    def invoices():
+        q = request.args.get("q", "").strip()
+        return render_template("invoices.html", rows=repo.invoices_list(get_db(), q), q=q)
+
+    def _rows_follow(conn, invoice_id):
+        """The Zimmerbelegung takes over what the saved invoice bills — and the user is told it did."""
+        fixed, new = repo.sync_rows_to_invoice(conn, invoice_id)
+        if fixed or new:
+            flash(i18n.t("msg_rows_follow_invoice", fixed=len(fixed), new=len(new)))
+
+    @app.route("/invoices/new", methods=["GET", "POST"])
+    def invoice_new():
+        conn = get_db()
+        units = repo.units(conn)
+        f = request.form
+        lines = []
+        order_warning = False
+        client_choices = None
+        if request.method == "POST":
+            lines, incomplete = _parse_lines(f)
+            unit_id = int(f["unit_id"]) if f.get("unit_id") else None
+            number = f.get("number", "").strip()
+            if incomplete:
+                flash(i18n.t("err_number", field=", ".join(incomplete)))
+            elif not unit_id or not f.get("client", "").strip() or not lines:
+                flash(i18n.t("err_required", field="Einheit, Kunde, mind. 1 Zeile"))
+            elif number and repo.invoice_number_taken(conn, unit_id, number):
+                flash(i18n.t("err_number_taken", number=number))
+            elif _order_warning(conn, f, unit_id, number):
+                order_warning = True
+            elif (client_choices := _recipient_warning(conn, f)) is None:
+                links = [int(x) for x in f.get("link_charges", "").split(",") if x.strip().isdecimal()]
+                inv_id = repo.create_invoice(
+                    conn, unit_id, repo.find_or_create_client(conn, f["client"]),
+                    number, f.get("date") or None, lines, note=f.get("note"),
+                    paid_date=f.get("paid_date") or None, payment_method=f.get("payment_method") or None,
+                    link_charge_ids=links)
+                _rows_follow(conn, inv_id)
+                return redirect(url_for("invoice_view", invoice_id=inv_id))
+            lines = _raw_lines(f)   # re-render exactly what was typed, incl. the rejected rows
+        elif request.args.get("stays") or request.args.get("charges"):
+            # generate a pre-filled invoice from selected Gästeblätter rows or Zimmerbelegung rows
+            if request.args.get("charges"):
+                ids = [int(x) for x in request.args["charges"].split(",") if x.strip().isdecimal()]
+                pre = repo.lines_from_charges(conn, ids)
+            else:
+                ids = [int(x) for x in request.args["stays"].split(",") if x.strip().isdecimal()]
+                pre = repo.lines_from_stays(conn, ids)
+            lines = pre["lines"]
+            f = {"unit_id": pre["unit_id"], "client": pre["client"] or "",
+                 # remember the ledger rows so saving writes the invoice number back into them
+                 "link_charges": ",".join(map(str, ids)) if request.args.get("charges") else ""}
+            if pre["client"]:   # a payer without an address asks at once, not only on saving
+                client_choices = repo.recipient_choices(conn, pre["client"])
+        import datetime
+        suggestions = {u["id"]: repo.next_invoice_number(conn, u["id"]) for u in units}
+        return render_template("invoice_form.html", units=units, suggestions=suggestions, form=f, lines=lines,
+                               suggest=repo.field_suggestions(conn), order_warning=order_warning,
+                               client_choices=client_choices, today=datetime.date.today().isoformat())
+
+    @app.route("/invoices/<int:invoice_id>/edit", methods=["GET", "POST"])
+    def invoice_edit(invoice_id):
+        conn = get_db()
+        inv = repo.get_invoice(conn, invoice_id)
+        if not inv:
+            abort(404)
+        units = repo.units(conn)
+        order_warning = False
+        client_choices = None
+        if request.method == "POST":
+            f = request.form
+            lines, incomplete = _parse_lines(f)
+            unit_id = int(f["unit_id"]) if f.get("unit_id") else None
+            number = f.get("number", "").strip()
+            if incomplete:
+                flash(i18n.t("err_number", field=", ".join(incomplete)))
+            elif not unit_id or not f.get("client", "").strip() or not lines:
+                flash(i18n.t("err_required", field="Einheit, Kunde, mind. 1 Zeile"))
+            elif number and repo.invoice_number_taken(conn, unit_id, number, exclude_id=invoice_id):
+                flash(i18n.t("err_number_taken", number=number))
+            elif _order_warning(conn, f, unit_id, number, invoice_id):
+                order_warning = True
+            elif (client_choices := _recipient_warning(conn, f)) is None:
+                repo.update_invoice(conn, invoice_id, unit_id,
+                    repo.find_or_create_client(conn, f["client"]), number,
+                    f.get("date") or None, lines, note=f.get("note"),
+                    paid_date=f.get("paid_date") or None, payment_method=f.get("payment_method") or None)
+                _rows_follow(conn, invoice_id)
+                return redirect(url_for("invoice_view", invoice_id=invoice_id))
+            return render_template("invoice_form.html", units=units, suggestions={}, form=f,
+                                   lines=_raw_lines(f), editing=inv, suggest=repo.field_suggestions(conn),
+                                   order_warning=order_warning, client_choices=client_choices)
+        form = {"unit_id": inv["unit_id"], "client": (inv["client"] or {}).get("name", ""),
+                "number": inv["number"], "date": inv["date"], "note": inv.get("notes"),
+                "paid_date": inv.get("paid_date"), "payment_method": inv.get("payment_method")}
+        return render_template("invoice_form.html", units=units, suggestions={}, form=form, lines=inv["lines"],
+                               editing=inv, suggest=repo.field_suggestions(conn),
+                               client_choices=repo.recipient_choices(conn, form["client"]))
+
+    @app.route("/invoices/<int:invoice_id>/delete", methods=["POST"])
+    def invoice_delete(invoice_id):
+        repo.delete_invoice(get_db(), invoice_id)
+        return redirect(url_for("invoices"))
+
+    @app.route("/invoices/<int:invoice_id>")
+    def invoice_view(invoice_id):
+        conn = get_db()
+        inv = repo.get_invoice(conn, invoice_id)
+        if not inv:
+            abort(404)
+        # offer "Neu generieren" only when a linked ledger row changed since the invoice was (re)generated
+        can_regen = bool(inv.get("lines_stale")) and bool(repo.linked_ledger_charges(conn, invoice_id))
+        return render_template("invoice_print.html", inv=inv, can_regen=can_regen)
+
+    @app.route("/invoices/<int:invoice_id>/regenerate", methods=["POST"])
+    def invoice_regenerate(invoice_id):
+        if not repo.regenerate_invoice(get_db(), invoice_id):
+            abort(404)
+        return redirect(url_for("invoice_view", invoice_id=invoice_id))
+
+    @app.route("/invoices/<int:invoice_id>/payment", methods=["GET", "POST"])
+    def invoice_payment(invoice_id):
+        """Record the settlement of an already issued invoice — the ONLY writing path onto one that is not
+        a full edit. Deliberate and manual by design: an issued invoice never changes as a side effect."""
+        conn = get_db()
+        inv = repo.get_invoice(conn, invoice_id)
+        if not inv:
+            abort(404)
+        if request.method == "POST":
+            repo.set_invoice_payment(conn, invoice_id, request.form.get("paid_date"),
+                                     request.form.get("payment_method"))
+            return redirect(url_for("invoice_view", invoice_id=invoice_id))
+        return render_template("invoice_payment.html", inv=inv,
+                               hint=repo.invoice_payment_hint(conn, invoice_id))
+
+    @app.route("/invoices/<int:invoice_id>/pdf")
+    def invoice_pdf(invoice_id):
+        inv = repo.get_invoice(get_db(), invoice_id)
+        if not inv:
+            abort(404)
+        html = render_template("invoice_print.html", inv=inv, standalone=True)
+        return send_file(io.BytesIO(pdf.render(html)), mimetype="application/pdf", as_attachment=True,
+                         download_name=repo.invoice_filename(inv))
+
+    # --- companies (canonical clients + their address versions) ---
+    @app.route("/clients")
+    @cached_page
+    def clients():
+        q = request.args.get("q", "").strip()
+        return render_template("clients.html", rows=repo.companies_list(get_db(), q or None), q=q)
+
+    @app.route("/clients/<int:company_id>", methods=["GET", "POST"])
+    def client_edit(company_id):
+        conn = get_db()
+        comp = repo.get_company(conn, company_id)
+        if not comp:
+            abort(404)
+        if request.method == "POST":
+            f = request.form
+            if f.get("action") == "add_address":
+                repo.add_company_address(conn, company_id, f.get("address", "").strip(),
+                                         f.get("postcode", "").strip(), f.get("city", "").strip(),
+                                         make_current=bool(f.get("make_current")))
+            elif f.get("action") == "edit_address":
+                repo.update_client_address(conn, int(f["client_id"]), f.get("name", ""),
+                                           f.get("address", ""), f.get("postcode", ""), f.get("city", ""))
+            elif f.get("action") == "make_current":
+                repo.set_current_address(conn, company_id, int(f["client_id"]))
+            elif f.get("action") == "delete_address":
+                try:
+                    repo.delete_client_address(conn, int(f["client_id"]))
+                except ValueError as e:
+                    flash(i18n.t("err_address_last" if str(e) == "last_version" else "err_address_has_refs"))
+            elif f.get("action") == "merge":
+                target = f.get("merge_into", "").strip()
+                if target.isdigit() and int(target) != company_id:
+                    repo.merge_companies(conn, int(target), company_id)
+                    return redirect(url_for("client_edit", company_id=int(target)))
+            elif not f.get("name", "").strip():
+                flash(i18n.t("err_required", field=i18n.t("col_name")))
+            else:
+                repo.save_company(conn, company_id, f["name"].strip(), f.get("kind") or "company",
+                                  f.get("uid", "").strip() or None, f.get("email", "").strip() or None,
+                                  f.get("phone", "").strip() or None, f.get("notes", "").strip() or None,
+                                  int(f["current_client_id"]) if f.get("current_client_id", "").isdigit() else None)
+                return redirect(url_for("clients"))
+            return redirect(url_for("client_edit", company_id=company_id))
+        others = [c for c in repo.companies_list(conn) if c["id"] != company_id]
+        return render_template("client_form.html", comp=comp, others=others)
+
+    @app.route("/clients/<int:company_id>/delete", methods=["POST"])
+    def client_delete(company_id):
+        try:
+            repo.delete_company(get_db(), company_id)
+        except ValueError:
+            flash(i18n.t("err_company_has_refs"))
+            return redirect(url_for("client_edit", company_id=company_id))
+        return redirect(url_for("clients"))
+
+    # --- data-quality audit ---
+    @app.route("/quality")
+    @cached_page
+    def quality_page():
+        return render_template("quality.html", q=quality.overview(get_db()))
+
+    # --- monthly TVB Sammelmeldung (Aufenthaltsabgabe) ---
+    @app.route("/tvb")
+    def tvb_page():
+        import datetime
+        m = request.args.get("month", "")
+        try:
+            year, month = int(m[:4]), int(m[5:7])
+            datetime.date(year, month, 1)
+        except ValueError:                                # default: the month that is due now
+            prev = datetime.date.today().replace(day=1) - datetime.timedelta(days=1)
+            year, month = prev.year, prev.month
+        return render_template("tvb.html", r=tvb.monthly_report(get_db(), year, month),
+                               month_value=f"{year:04d}-{month:02d}")
+
+    # --- quarterly Umsatzsteuer-Voranmeldung ---
+    @app.route("/vat")
+    def vat_page():
+        import datetime
+        conn = get_db()
+        today = datetime.date.today()
+        year, quarter = vat.previous_quarter(today)          # default: the quarter that is due now
+        try:
+            year = int(request.args.get("year", year))
+            quarter = min(max(int(request.args.get("q", quarter)), 1), 4)
+        except ValueError:
+            pass
+        units = vat.units(conn)
+        names = {u["code"]: u["name"] for u in units}
+        unit = request.args.get("unit") if request.args.get("unit") in names else next(iter(names), None)
+        return render_template("vat.html", r=vat.quarterly_report(conn, unit, year, quarter), units=units,
+                               unit=unit, unit_name=names.get(unit, unit), year=year, quarter=quarter,
+                               years=range(today.year, today.year - 8, -1))
+
+    @app.route("/quality/companies/merge", methods=["POST"])
+    def quality_merge_companies():
+        f = request.form
+        if f.get("keep", "").isdigit() and f.get("drop", "").isdigit():
+            repo.merge_companies(get_db(), int(f["keep"]), int(f["drop"]))
+        return redirect(url_for("quality_page"))
+
+    @app.route("/quality/guests/merge", methods=["POST"])
+    def quality_merge_guests():
+        f = request.form
+        if f.get("keep", "").isdigit() and f.get("drop", "").isdigit():
+            repo.merge_guests(get_db(), int(f["keep"]), int(f["drop"]))
+        return redirect(url_for("quality_page"))
+
+    @app.route("/quality/dismiss", methods=["POST"])
+    def quality_dismiss():
+        f = request.form
+        if f.get("kind") and f.get("key"):
+            quality.dismiss(get_db(), f["kind"], f["key"], f.get("note", "").strip() or None)
+        return redirect(url_for("quality_page"))
+
+    @app.errorhandler(404)
+    def not_found(e):
+        return render_template("error.html", message=i18n.t("err_not_found")), 404
+
+    @app.errorhandler(500)
+    def server_error(e):
+        return render_template("error.html", message=i18n.t("err_generic")), 500
+
+    return app
+
+
+def _payments(f):
+    """The ledger form's payment lines as [(date, amount)] — None when the form carries no payment lines at
+    all, which leaves the row's payments untouched. A line without an amount is the spare empty one; the
+    form makes the date required as soon as an amount is typed."""
+    if "pay_amount" not in f:
+        return None
+    lines = zip(f.getlist("pay_date"), (parse_number(a) for a in f.getlist("pay_amount")))
+    return [(d, a) for d, a in lines if d and a]
+
+
+def _room_number(conn, room_id):
+    return next((r["number"] for r in repo.rooms(conn) if r["id"] == room_id), "")
+
+
+def parse_number(value):
+    """Accept German decimals ('161,50', '1.234,56') and plain numbers; None if not parseable."""
+    if value is None:
+        return None
+    s = str(value).strip().replace(" ", "")
+    if not s:
+        return None
+    if "," in s:                       # German: comma = decimal, dot = thousands separator
+        s = s.replace(".", "").replace(",", ".")
+    try:
+        return float(s)
+    except ValueError:
+        return None
+
+
+def _raw_lines(form):
+    """The submitted line rows verbatim, for re-rendering a form that failed validation — a rejected row
+    must come back filled in, not vanish."""
+    keys = ("worker", "period_from", "period_to", "quantity", "unit_type", "gross_per_unit", "tourism", "kind")
+    lists = {k: form.getlist(k) for k in keys}
+    n = max((len(v) for v in lists.values()), default=0)
+    rows = []
+    for i in range(n):
+        row = {k: (lists[k][i] if i < len(lists[k]) else "") for k in keys}
+        row["tourism_tax"] = row.pop("tourism")
+        rows.append(row)
+    return rows
+
+
+def _order_warning(conn, f, unit_id, number, exclude_id=None):
+    """Stop the save and say which invoice is in the way when the date breaks the number order
+    (`repo.invoice_out_of_order`) — unless the user has ticked that the date is right on purpose."""
+    clash = repo.invoice_out_of_order(conn, unit_id, number, f.get("date") or None, exclude_id)
+    if not clash or f.get("confirm_order"):
+        return False
+    flash(i18n.t("warn_order_smaller" if clash["smaller"] else "warn_order_larger", number=number,
+                 date=money.de_date(f.get("date")), other=clash["number"], other_date=money.de_date(clash["date"])))
+    return True
+
+
+def _recipient_warning(conn, f):
+    """None when the recipient prints an address; otherwise stop the save and return the companies the
+    name may mean (`repo.recipient_choices`) — unless the user has ticked that it is right without one."""
+    if f.get("confirm_client"):
+        return None
+    name = f.get("client", "").strip()
+    choices = repo.recipient_choices(conn, name)
+    if choices is not None:
+        flash(i18n.t("warn_client_no_address", name=name))
+    return choices
+
+
+def _parse_lines(form):
+    """Return (valid_lines, incomplete). A row with a name but no valid rate/quantity (or vice versa) is
+    reported as incomplete rather than silently dropped, so an invoice can't be undercharged unnoticed."""
+    workers = form.getlist("worker")
+    gross, qtys = form.getlist("gross_per_unit"), form.getlist("quantity")
+    pfrom, pto, utype = form.getlist("period_from"), form.getlist("period_to"), form.getlist("unit_type")
+    tourism, kinds = form.getlist("tourism"), form.getlist("kind")
+
+    def at(lst, i):
+        return lst[i] if i < len(lst) else None
+
+    lines, incomplete = [], []
+    for i, worker in enumerate(workers):
+        worker = worker.strip()
+        rate = parse_number(at(gross, i))
+        qty = parse_number(at(qtys, i))
+        if not worker and rate is None:
+            continue                                    # empty row
+        if not worker or rate is None or not qty or qty <= 0:   # a blank/zero Anz is a mistake, not a free line
+            incomplete.append(worker or "Zeile {}".format(i + 1))
+            continue
+        lines.append({
+            "worker": worker,
+            "period_from": at(pfrom, i) or None,
+            "period_to": at(pto, i) or None,
+            "quantity": qty,
+            "unit_type": at(utype, i) or "week",
+            "gross_per_unit": rate,
+            "tourism_tax": parse_number(at(tourism, i)) or 0,
+            "kind": at(kinds, i) or "stay",
+        })
+    return lines, incomplete
+
+
+HOST, PORT = "127.0.0.1", 5000
+
+
+def server_answers(host=HOST, port=PORT, timeout=0.4):
+    """Is a server already listening? Windows lets a SECOND server bind the same port instead of refusing
+    it (SO_REUSEADDR), so every extra start left another instance running and Windows decided which one
+    answered — after an update often the OLD one, still serving the previous code."""
+    import socket
+    with socket.socket() as s:
+        s.settimeout(timeout)
+        return s.connect_ex((host, port)) == 0
+
+
+def main():
+    import threading
+    import webbrowser
+    url = f"http://{HOST}:{PORT}"
+    if server_answers():                      # already running: just open the window, never start twice
+        webbrowser.open(url)
+        return
+    app = create_app()
+    threading.Timer(1.0, lambda: webbrowser.open(url)).start()
+    app.run(host=HOST, port=PORT, debug=False)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/docs/screenshots/invoice.png b/docs/screenshots/invoice.png
new file mode 100644
index 0000000..85c6b10
Binary files /dev/null and b/docs/screenshots/invoice.png differ
diff --git a/docs/screenshots/ledger.png b/docs/screenshots/ledger.png
new file mode 100644
index 0000000..021296c
Binary files /dev/null and b/docs/screenshots/ledger.png differ
diff --git a/docs/screenshots/plan.png b/docs/screenshots/plan.png
new file mode 100644
index 0000000..1b634fd
Binary files /dev/null and b/docs/screenshots/plan.png differ
diff --git a/docs/screenshots/quality.png b/docs/screenshots/quality.png
new file mode 100644
index 0000000..94a1fba
Binary files /dev/null and b/docs/screenshots/quality.png differ
diff --git a/docs/screenshots/register.png b/docs/screenshots/register.png
new file mode 100644
index 0000000..3b35fb9
Binary files /dev/null and b/docs/screenshots/register.png differ
diff --git a/docs/screenshots/tvb.png b/docs/screenshots/tvb.png
new file mode 100644
index 0000000..23106a4
Binary files /dev/null and b/docs/screenshots/tvb.png differ
diff --git a/locales/de.json b/locales/de.json
new file mode 100644
index 0000000..8259511
--- /dev/null
+++ b/locales/de.json
@@ -0,0 +1,311 @@
+{
+  "app_title": "Zimmervermietung",
+  "nav_home": "Start",
+  "nav_register": "Gästeblätter",
+  "nav_ledger": "Zimmerbelegung",
+  "nav_invoices": "Rechnungen",
+  "nav_plan": "Belegungsplan",
+
+  "plan_title": "Belegungsplan",
+  "plan_today": "Heute",
+  "plan_prev_week": "Eine Woche zurück",
+  "plan_next_week": "Eine Woche weiter",
+  "plan_weeks_4": "4 Wochen",
+  "plan_weeks_8": "8 Wochen",
+  "plan_guests": "Heute: {guests} Gäste im Haus",
+  "plan_guests_one": "Heute: 1 Gast im Haus",
+  "plan_free": "{free} Betten frei",
+  "plan_free_one": "1 Bett frei",
+  "plan_pill_tip": "Belegte Betten heute / Betten gesamt",
+  "plan_longterm": "Dauervermietung",
+  "plan_longterm_short": "Dauer",
+  "plan_open": "offen",
+  "plan_legend_current": "wohnt gerade hier",
+  "plan_legend_past": "abgereist",
+  "plan_legend_future": "kommt noch",
+  "plan_legend_today": "heute",
+  "plan_no_room": "Ohne Zimmer eingetragen:",
+
+  "home_welcome": "Willkommen",
+  "home_intro": "Verwaltung der Gästeblätter, Zimmerbelegung und Rechnungen an einem Ort.",
+  "home_guests": "Gäste",
+  "home_stays": "Aufenthalte",
+  "home_invoices": "Rechnungen",
+  "home_open": "Offene Posten",
+
+  "register_title": "Gästeblätter",
+  "ledger_title": "Zimmerbelegung",
+  "invoices_title": "Rechnungen",
+  "clients_title": "Firmen & Kunden",
+  "nav_clients": "Firmen",
+  "nav_quality": "Datenprüfung",
+  "nav_tvb": "TVB-Meldung",
+  "nav_vat": "Umsatzsteuer",
+  "tvb_title": "Meldung Tourismusverband (Aufenthaltsabgabe)",
+  "tvb_intro": "Für den gewählten Monat, getrennt nach Betrieb: die Zimmerliste zur Kontrolle und darunter die fertigen Zahlen zum Eintippen in Feratel (Sammelmeldung, jeweils Personen/Nächte). Personen = neue Gästeblätter in diesem Monat.",
+  "tvb_month": "Monat",
+  "tvb_number": "Betriebsnummer",
+  "tvb_detail": "Zimmerliste (zur Kontrolle)",
+  "tvb_feratel": "Für Feratel",
+  "tvb_pflichtig": "Pflichtige",
+  "tvb_frei": "Freie",
+  "tvb_col_land": "Land",
+  "tvb_col_gb_new": "GB neu",
+  "tvb_col_stay": "Aufenthalt (Nächte gesamt)",
+  "tvb_col_nights_month": "Nächte im Monat",
+  "tvb_col_pn": "Personen/Nächte",
+  "tvb_col_note": "Hinweis",
+  "tvb_status_frei": "frei",
+  "tvb_status_pflichtig": "pflichtig",
+  "tvb_total": "Monat Gesamt",
+  "tvb_betrag": "Zu erwartende Abgabe",
+  "tvb_new_sheets": "Kontrolle: neue Gästeblätter in diesem Monat",
+  "tvb_warnings": "Bitte prüfen",
+  "tvb_empty": "Keine Nächtigungen in diesem Monat.",
+  "quality_title": "Datenprüfung",
+  "quality_intro": "Hinweise auf Lücken, Unstimmigkeiten und Doppeleinträge in den Daten.",
+  "quality_gaps": "Auffälligkeiten in den Daten",
+  "gap_depart_before_arrival": "Abreise liegt vor der Anreise",
+  "gap_charges_without_money": "Belegungen ohne Betrag",
+  "gap_client_without_address": "Firma ohne Adresse — eine Rechnung an sie würde unvollständig gedruckt",
+  "gap_address_has_name": "Adresse enthält Firmennamen-Teil (Adresszeile prüfen)",
+  "gap_implausible_qty": "Unmögliche Anzahl/Betrag (Tippfehler?)",
+  "gap_rnr_unlinked": "Rechnungs-Nr. ohne zugeordnete Rechnung",
+  "gap_duplicate_numbers": "Doppelte Rechnungsnummern",
+  "gap_number_year": "Rechnungsnummer passt nicht zum Datum",
+  "gap_open_items": "Offene Posten (alt)",
+  "gap_no_departure": "Gäste ohne Abreisedatum",
+  "gap_tvb_stale_open": "Gästeblatt seit über 1 Jahr ohne Abreise (zählt in der TVB-Meldung nicht mit)",
+  "gap_register_ledger": "Gästeblatt-Dauer passt nicht zur Zimmerbelegung (gleicher Name, andere Zeiten)",
+  "gap_gb_ref_unknown": "Gästeblatt-Nr. in der Zimmerbelegung, die es in der Gästeblätter-Liste nicht gibt",
+  "btn_dismiss": "Passt so",
+  "gap_never_billed": "Abgereister Gast ohne Verrechnung in der Zimmerbelegung (vergessen oder anders geschrieben?)",
+  "gap_betrag_formula": "Betrag passt weder zu Anzahl × Satz noch zu Anzahl × Satz × Personen (Tippfehler oder Rabatt?)",
+  "err_departure_before_arrival": "Abreise liegt vor der Anreise — bitte Datum prüfen.",
+  "quality_suggestions": "Mögliche Doppeleinträge (zusammenführen?)",
+  "quality_suggestions_hint": "Diese Einträge sehen sehr ähnlich aus. Zusammenführen nur, wenn es wirklich dasselbe ist – nichts geht dabei verloren.",
+  "quality_no_company_suggestions": "Keine ähnlichen Firmennamen gefunden.",
+  "quality_guest": "Gast",
+  "form_edit_client": "Firma bearbeiten",
+  "col_kind": "Typ",
+  "kind_company": "Firma",
+  "kind_private": "Privat",
+  "col_address_current": "Aktuelle Adresse",
+  "col_versions": "Adressen",
+  "lbl_known_spellings": "Bekannte Schreibweisen",
+  "lbl_addresses": "Adressen im Zeitverlauf (alte Rechnungen behalten ihre alte Adresse)",
+  "lbl_address_current": "Aktuell",
+  "lbl_new_address": "Neue Adresse (Umzug / weiterer Standort)",
+  "lbl_use_from_now": "Ab jetzt für neue Rechnungen verwenden",
+  "btn_add_address": "Adresse hinzufügen",
+  "lbl_merge": "Mit anderer Firma zusammenführen",
+  "lbl_merge_into": "Diese Firma ist dasselbe wie",
+  "merge_hint": "Alle Einträge und Schreibweisen wandern zur ausgewählten Firma. Nichts geht verloren.",
+  "btn_merge": "Zusammenführen",
+  "confirm_merge": "Wirklich zusammenführen?",
+  "lbl_edit_address": "Adresse bearbeiten",
+  "btn_make_current": "Als aktuelle Adresse",
+  "confirm_delete_address": "Diese Adresse wirklich löschen?",
+  "lbl_current_address_short": "aktuelle Adresse",
+  "err_address_has_refs": "Adresse kann nicht gelöscht werden: Es hängen noch Aufenthalte oder Rechnungen daran.",
+  "err_address_last": "Die letzte Adresse einer Firma kann nicht gelöscht werden — dann lieber die ganze Firma löschen.",
+  "lbl_delete_company": "Firma löschen",
+  "delete_company_hint": "Nur möglich, wenn keine Aufenthalte oder Rechnungen an dieser Firma hängen. Gibt es welche, führe sie stattdessen mit der richtigen Firma zusammen.",
+  "btn_delete_company": "Firma löschen",
+  "confirm_delete_company": "Diese Firma wirklich löschen?",
+  "err_company_has_refs": "Firma kann nicht gelöscht werden: Es hängen noch Aufenthalte oder Rechnungen daran. Bitte stattdessen zusammenführen.",
+  "hws_full": "Hauptwohnsitz",
+  "hws_none": "Nebenwohnsitz",
+
+  "search": "Suchen",
+  "search_placeholder": "Name, Firma, Zimmer …",
+  "no_results": "Keine Einträge gefunden.",
+  "showing_count": "{count} Einträge",
+
+  "col_name": "Name",
+  "col_lastname": "Nachname",
+  "col_firstname": "Vorname",
+  "col_birth": "Geburtsdatum",
+  "col_nationality": "Staatsbürgerschaft",
+  "col_room": "Zimmer",
+  "col_unit": "Einheit",
+  "col_arrival": "Anreise",
+  "col_departure": "Abreise",
+  "filter_stay": "Aufenthalt",
+  "filter_persons": "Personen",
+  "filter_year": "Jahr",
+  "filter_still_here": "noch da",
+  "filter_departed": "abgereist",
+  "col_days": "Tage",
+  "col_residence": "Wohnsitz",
+  "col_tourism_liable": "Abgabe",
+  "col_employer_address": "Firmenadresse",
+  "col_employer": "Arbeitgeber",
+  "col_document": "Dokument",
+  "col_docnr": "Dokument-Nr.",
+  "col_profession": "Beruf",
+  "col_sheetno": "Gästeblatt-Nr.",
+  "col_address": "Adresse",
+  "col_postcode": "PLZ",
+  "col_city": "Ort",
+  "col_country": "Land",
+  "col_phone": "Telefon",
+  "col_notes_long": "Bemerkung",
+  "hd_room": "Zi",
+  "hd_gb": "GB",
+  "hd_qty": "Anz",
+  "hd_persons": "Pers",
+  "hd_payer": "Zlg. durch",
+  "hd_invoice": "RNr.",
+  "hd_invoice_date": "Re vom",
+  "hd_paid_date": "bez. am",
+  "col_period": "Zeitraum",
+  "col_from": "Von",
+  "col_to": "Bis",
+  "col_gb": "Gästeblatt",
+  "col_occupant": "Name",
+  "col_persons": "Personen",
+  "col_qty": "Anzahl",
+  "col_rate": "Satz",
+  "col_amount": "Betrag",
+  "col_invoice_total": "Rechnungssumme",
+  "col_tourism_tax": "Ortstaxe",
+  "col_payer": "Zahlung durch",
+  "col_art": "Art",
+  "col_invoice": "Rechnungs-Nr.",
+  "col_invoice_date": "Rechnungsdatum",
+  "col_paid_date": "Bezahlt am",
+  "col_notes": "Bemerkung",
+  "col_payment": "Bezahlt",
+  "col_client": "Kunde",
+  "col_date": "Datum",
+  "col_unit_type": "Einheit (Woche/Tag)",
+  "col_gross_per_unit": "Brutto pro Einheit",
+  "col_tourism": "Ortstaxe",
+
+  "payment_paid": "Bezahlt",
+  "payment_open": "OFFEN",
+  "payment_cash": "Bar/direkt",
+  "payment_part": "({paid} bezahlt, {open} offen)",
+  "lbl_payments": "Zahlungen in Teilen (Datum und Betrag)",
+  "hint_payments": "Nur wenn in Teilen bezahlt wurde. Decken die Zahlungen zusammen Betrag + Ortstaxe, ist die Zeile bezahlt (am Tag der letzten Zahlung) — sonst bleibt sie OFFEN.",
+  "btn_add_payment": "+ weitere Zahlung",
+  "payment_unknown": "—",
+  "payment_unknown_label": "keine Angabe",
+
+  "btn_remove_line": "Zeile entfernen",
+  "btn_add_stay": "Neuer Gast",
+  "btn_add_ledger": "Neue Belegung",
+  "btn_new_invoice": "Neue Rechnung",
+  "btn_edit": "Bearbeiten",
+  "btn_save": "Speichern",
+  "btn_cancel": "Abbrechen",
+  "btn_delete": "Löschen",
+  "btn_back": "Zurück",
+  "btn_print": "Drucken",
+  "btn_open": "Öffnen",
+  "btn_regenerate": "Neu generieren",
+  "btn_continue": "Speichern und weiterführen",
+  "hint_continue": "Rechnet bis zum Datum bei 'Bis' ab und legt eine neue Zeile ab diesem Tag an — für Gäste, die bleiben.",
+  "msg_continued": "Neue Zeile ab {date} angelegt — der Gast bleibt.",
+  "msg_rows_follow_invoice": "Die Zimmerbelegung wurde an die Rechnung angepasst: {fixed} Zeile(n) ausgebessert, {new} neue Zeile(n).",
+  "err_continue_needs_date": "Bitte zuerst bei 'Bis' das Datum eintragen, bis zu dem abgerechnet wird.",
+  "btn_room_change": "Speichern und Zimmerwechsel",
+  "hint_room_change": "Die Abreise ist der Tag des Wechsels. Danach öffnet sich ein neues Gästeblatt mit derselben Nummer, schon ausgefüllt — nur das neue Zimmer wählen.",
+  "err_room_change_needs_date": "Bitte zuerst bei 'Abreise' den Tag des Zimmerwechsels eintragen.",
+  "form_room_change": "Zimmerwechsel – neues Gästeblatt mit derselben Nummer",
+  "note_room_change": "Zimmerwechsel von Zimmer {room}",
+  "msg_room_changed": "Zimmerwechsel eingetragen — die Zimmerbelegung läuft ab {date} in Zimmer {room} weiter, zum bisherigen Preis.",
+  "btn_payment": "Zahlung",
+  "btn_take_over": "Übernehmen",
+  "pin_tip": "Spalte fixieren (bleibt beim Blättern links stehen)",
+  "unpin_tip": "Fixierung aufheben",
+
+  "form_new_stay": "Neuer Gast / Aufenthalt",
+  "form_edit_stay": "Aufenthalt bearbeiten",
+  "form_new_ledger": "Neue Belegung",
+  "form_edit_ledger": "Belegung bearbeiten",
+  "form_new_invoice": "Neue Rechnung",
+  "form_edit_invoice": "Rechnung bearbeiten",
+  "form_payment": "Zahlung eintragen – Rechnung {number}",
+
+  "lbl_unit": "Einheit",
+  "lbl_room": "Zimmer",
+  "lbl_client": "Kunde / Firma",
+  "lbl_invoice_no": "Rechnungsnummer",
+  "lbl_invoice_date": "Rechnungsdatum",
+  "lbl_paid_date": "Bezahlt am",
+  "lbl_payment_method": "Zahlung durch (Bank / bar / Firma)",
+  "lbl_payment_from_ledger": "Laut Zimmerbelegung",
+  "lbl_invoice_note": "Rechnungstext (Zahlungshinweis / Vermerk)",
+  "invoice_note_default": "Bitte überweisen Sie den Rechnungsbetrag innerhalb von 8 Tagen auf das u.a. Konto.",
+  "lbl_select_charges": "Zu verrechnende Belegungen auswählen",
+
+  "err_required": "Bitte ausfüllen: {field}",
+  "err_number": "Bitte eine Zahl eingeben: {field}",
+  "err_number_taken": "Rechnungsnummer {number} ist bereits vergeben.",
+  "warn_order_smaller": "Achtung, nicht gespeichert: Die Rechnung {other} hat eine kleinere Nummer, ist aber vom {other_date} – also später als {date}. Die Rechnungen müssen der Reihe nach datiert sein. Bitte Datum oder Nummer prüfen.",
+  "warn_order_larger": "Achtung, nicht gespeichert: Die Rechnung {other} hat eine höhere Nummer, ist aber schon vom {other_date} – also früher als {date}. Die Rechnungen müssen der Reihe nach datiert sein. Bitte Datum oder Nummer prüfen.",
+  "lbl_confirm_order": "Das Datum stimmt trotzdem – so speichern",
+  "warn_client_no_address": "Achtung, nicht gespeichert: Für den Kunden „{name}“ gibt es keine Adresse – die Rechnung hätte keine Anschrift. Bitte den richtigen Kunden wählen.",
+  "lbl_client_choices": "Für „{name}“ gibt es keine Adresse. Welche Firma ist gemeint? Anklicken, dann speichern:",
+  "lbl_client_unknown": "Für „{name}“ gibt es keine Adresse. Bitte die Firma zuerst unter Firmen mit Adresse anlegen – oder:",
+  "lbl_confirm_client": "Der Kunde stimmt trotzdem – ohne Adresse speichern",
+  "sum_label": "Summe",
+  "vat_title": "Umsatzsteuer-Voranmeldung",
+  "vat_intro": "Alle Eingänge des Quartals nach dem Tag, an dem bezahlt wurde – nach Zimmer geordnet, ohne Ortstaxe.",
+  "vat_quarter_n": "{n}. Quartal",
+  "vat_room_sum": "Summe Zimmer {room}",
+  "vat_empty": "Keine Eingänge in diesem Quartal.",
+  "vat_storno": "Storno – nicht steuerbar",
+  "vat_part": "Teilzahlung",
+  "period_until": "bis {date}",
+  "period_since": "ab {date}",
+  "vat_total_title": "Zusammenfassung",
+  "vat_total": "Eingänge gesamt",
+  "vat_storno_sum": "davon Stornogebühren (nicht steuerbar, ohne Umsatzsteuer)",
+  "vat_gross": "Brutto (10 %)",
+  "vat_tax": "Umsatzsteuer 10 %",
+  "vat_net": "Netto (10 %)",
+  "err_delete_blocked": "Kann nicht gelöscht werden – es hängen noch Buchungen daran.",
+  "err_not_found": "Eintrag nicht gefunden.",
+  "err_generic": "Etwas ist schiefgelaufen. Bitte nochmal versuchen.",
+
+  "confirm_delete": "Diesen Eintrag wirklich löschen?",
+  "confirm_regenerate": "Rechnung aus der Zimmerbelegung neu erstellen? Die bisherigen Rechnungszeilen werden ersetzt.",
+  "none": "—",
+
+  "col_uid": "UID",
+  "col_email": "E-Mail",
+  "col_address_private": "Adresse (privat)",
+  "col_gb_number": "Gästeblatt-Nr.",
+  "col_rate_per_unit": "Satz (€ pro Einheit)",
+  "col_amount_eur": "Betrag (€)",
+  "form_room": "Zimmer {room}",
+  "filter_all": "{col}: alle",
+  "yes": "Ja",
+  "no": "Nein",
+  "unit_types": {"week": "Woche", "day": "Tag", "night": "Nacht", "month": "Monat", "total": "gesamt"},
+  "line_kinds": {"stay": "Übernachtung", "storno": "Storno"},
+  "btn_add_line": "+ Zeile",
+  "btn_pdf": "Als PDF",
+  "btn_invoice_from_selection": "Rechnung aus Auswahl",
+  "hint_invoice_tourism": "Ortstaxe nur bei Aufenthalten ≤ 10 Nächten (sonst befreit).",
+  "plan_room": "Zi {number}",
+  "plan_sheet": "GB {number}",
+  "quality_more": "… {n} weitere",
+  "tvb_warn_nationality_used": "Kein Wohnsitz-Land eingetragen – Staatsbürgerschaft verwendet",
+  "tvb_warn_no_country": "Weder Wohnsitz-Land noch Staatsbürgerschaft eingetragen",
+  "tvb_warn_at_postcode": "Österreich ohne erkennbare PLZ – Bundesland unklar",
+  "tvb_warn_de_border": "PLZ {postcode} → {state} (Grenzgebiete bitte prüfen)",
+  "tvb_warn_de_postcode": "Deutsche PLZ fehlt oder unbekannt – Region unklar",
+  "tvb_warn_no_unit": "{name} (angereist {arrival}): kein Betrieb zuordenbar – NICHT mitgezählt. Bitte Zimmer im Gästeblatt eintragen.",
+  "tvb_note_still_here": "noch im Haus, erst {nights} Nächte – als frei angenommen (bleibt er ≤ 10 Nächte: Abreise eintragen → pflichtig)",
+  "months": ["Jänner", "Februar", "März", "April", "Mai", "Juni", "Juli", "August", "September", "Oktober", "November", "Dezember"],
+  "months_short": ["Jän.", "Feb.", "März", "Apr.", "Mai", "Juni", "Juli", "Aug.", "Sep.", "Okt.", "Nov.", "Dez."],
+  "weekdays_short": ["Mo", "Di", "Mi", "Do", "Fr", "Sa", "So"],
+  "print_search": "Suche: {q}",
+  "print_rows": "{n} Zeilen",
+  "print_rows_one": "1 Zeile",
+  "print_date": "gedruckt am {date}"
+}
diff --git a/migrations/001_schema.sql b/migrations/001_schema.sql
new file mode 100644
index 0000000..c84329a
--- /dev/null
+++ b/migrations/001_schema.sql
@@ -0,0 +1,180 @@
+-- 001 schema.
+--   * text is COLLATE "C" (byte order), dates are ISO text, money is double precision
+--   * every foreign key is DEFERRABLE (INITIALLY IMMEDIATE): company and client point at each other
+
+CREATE TABLE unit (
+    id              bigint GENERATED BY DEFAULT AS IDENTITY PRIMARY KEY,
+    code            text COLLATE "C" NOT NULL UNIQUE,     -- short code shown in the lists
+    name            text COLLATE "C" NOT NULL,
+    subtitle        text COLLATE "C",
+    address         text COLLATE "C",                     -- multi-line issuer address block
+    place           text COLLATE "C",                     -- where invoices are issued ('<place>, am <date>')
+    contact         text COLLATE "C",                     -- multi-line contact block of the invoice footer
+    bank            text COLLATE "C",
+    iban            text COLLATE "C",
+    uid             text COLLATE "C",
+    tvb_number      text COLLATE "C",                     -- Betriebsnummer for the tourist-tax report
+    invoice_prefix  text COLLATE "C",                     -- '2026-' | '26-': the year is kept current
+    logo            text COLLATE "C",                     -- file in app/static/invoice/, nullable
+    photo           text COLLATE "C",
+    theme           text COLLATE "C",                     -- 'green' | 'blue'
+    is_current      integer NOT NULL DEFAULT 1,
+    succeeded_by_id bigint REFERENCES unit(id) DEFERRABLE  -- a former operator reports under its successor
+);
+
+CREATE TABLE room (
+    id        bigint GENERATED BY DEFAULT AS IDENTITY PRIMARY KEY,
+    number    text COLLATE "C" NOT NULL UNIQUE,           -- floor-coded, e.g. '21'
+    category  text COLLATE "C",                           -- EZ | DZ | 3BZ | 4BZ | Garconniere
+    capacity  integer,
+    unit_id   bigint REFERENCES unit(id) DEFERRABLE,      -- current owner
+    long_term integer NOT NULL DEFAULT 0,                 -- let long-term, left out of the free-bed count
+    floor     text COLLATE "C"
+);
+
+CREATE TABLE company (
+    id                bigint GENERATED BY DEFAULT AS IDENTITY PRIMARY KEY,
+    name              text COLLATE "C" NOT NULL,          -- canonical display name
+    kind              text COLLATE "C" NOT NULL DEFAULT 'company',   -- company | private
+    uid               text COLLATE "C",
+    email             text COLLATE "C",
+    phone             text COLLATE "C",
+    notes             text COLLATE "C",
+    current_client_id bigint                              -- the address version used for NEW invoices
+);
+
+CREATE TABLE client (
+    id         bigint GENERATED BY DEFAULT AS IDENTITY PRIMARY KEY,
+    kind       text COLLATE "C" NOT NULL DEFAULT 'company',   -- company | private
+    name       text COLLATE "C" NOT NULL,
+    address    text COLLATE "C",
+    postcode   text COLLATE "C",
+    city       text COLLATE "C",
+    country    text COLLATE "C",
+    company_id bigint REFERENCES company(id) DEFERRABLE
+);
+ALTER TABLE company ADD FOREIGN KEY (current_client_id) REFERENCES client(id) DEFERRABLE;
+
+CREATE TABLE company_key (
+    key        text COLLATE "C" PRIMARY KEY,              -- normalize.company_key(spelling)
+    company_id bigint NOT NULL REFERENCES company(id) DEFERRABLE
+);
+
+CREATE TABLE dismissed_finding (
+    kind text COLLATE "C" NOT NULL,
+    key  text COLLATE "C" NOT NULL,
+    note text COLLATE "C",
+    PRIMARY KEY (kind, key)
+);
+
+CREATE TABLE guest (
+    id            bigint GENERATED BY DEFAULT AS IDENTITY PRIMARY KEY,
+    last_name     text COLLATE "C",
+    first_name    text COLLATE "C",
+    birth_date    text COLLATE "C",                       -- ISO yyyy-mm-dd
+    nationality   text COLLATE "C",
+    doc_type      text COLLATE "C",
+    doc_number    text COLLATE "C",
+    profession    text COLLATE "C",
+    home_street   text COLLATE "C",
+    home_postcode text COLLATE "C",
+    home_city     text COLLATE "C",
+    home_country  text COLLATE "C",
+    phone         text COLLATE "C"
+);
+
+CREATE TABLE invoice (
+    id             bigint GENERATED BY DEFAULT AS IDENTITY PRIMARY KEY,
+    unit_id        bigint REFERENCES unit(id) DEFERRABLE,
+    client_id      bigint REFERENCES client(id) DEFERRABLE,
+    number         text COLLATE "C",                      -- '2026-01'
+    date           text COLLATE "C",
+    paid_date      text COLLATE "C",
+    payment_method text COLLATE "C",
+    notes          text COLLATE "C",
+    lines_stale    integer NOT NULL DEFAULT 0
+);
+
+-- One table for three kinds of rows, told apart by source_sheet: 'guestsheet' (a Gästeblatt in the guest
+-- register), 'ledger' (a Zimmerbelegung row; its dates live on the charge) and 'invoice' (an invoice line).
+CREATE TABLE stay (
+    id                 bigint GENERATED BY DEFAULT AS IDENTITY PRIMARY KEY,
+    guest_id           bigint REFERENCES guest(id) DEFERRABLE,    -- null for ledger and invoice rows
+    room_id            bigint REFERENCES room(id) DEFERRABLE,
+    unit_id            bigint REFERENCES unit(id) DEFERRABLE,     -- the operator at the time
+    employer_client_id bigint REFERENCES client(id) DEFERRABLE,
+    arrival            text COLLATE "C",
+    departure          text COLLATE "C",
+    sheet_number       text COLLATE "C",
+    label              text COLLATE "C",                  -- occupant text when guest_id is null
+    notes              text COLLATE "C",
+    source_sheet       text COLLATE "C",                  -- guestsheet | ledger | invoice
+    hauptwohnsitz      integer,
+    tourism_liable     integer
+);
+
+CREATE TABLE charge (
+    id                bigint GENERATED BY DEFAULT AS IDENTITY PRIMARY KEY,
+    stay_id           bigint REFERENCES stay(id) DEFERRABLE,
+    invoice_id        bigint REFERENCES invoice(id) DEFERRABLE,
+    period_from       text COLLATE "C",
+    period_to         text COLLATE "C",
+    quantity          double precision,
+    unit_type         text COLLATE "C",                   -- week | day | night | month
+    gross_per_unit    double precision,
+    line_net_override double precision,                   -- null => computed
+    source_sheet      text COLLATE "C",
+    persons           numeric,
+    paid_date         text COLLATE "C",
+    paid_status       text COLLATE "C",
+    tourism_tax       double precision,
+    art               text COLLATE "C",
+    gb_ref            text COLLATE "C",
+    vat_rate          double precision NOT NULL DEFAULT 0.10,
+    kind              text COLLATE "C" NOT NULL DEFAULT 'stay',
+    description       text COLLATE "C",
+    rnr               text COLLATE "C",
+    payer             text COLLATE "C",
+    notes             text COLLATE "C"
+);
+
+CREATE TABLE payment (
+    id        bigint GENERATED BY DEFAULT AS IDENTITY PRIMARY KEY,
+    charge_id bigint NOT NULL REFERENCES charge(id) ON DELETE CASCADE DEFERRABLE,
+    paid_date text COLLATE "C" NOT NULL,
+    amount    double precision NOT NULL
+);
+
+CREATE INDEX idx_charge_invoice ON charge(invoice_id);
+CREATE INDEX idx_charge_stay ON charge(stay_id);
+CREATE INDEX idx_client_company ON client(company_id);
+CREATE INDEX idx_stay_guest ON stay(guest_id);
+CREATE INDEX idx_stay_room ON stay(room_id);
+-- the company pages count stays and invoices per company in correlated subqueries
+CREATE INDEX idx_stay_employer ON stay(employer_client_id);
+CREATE INDEX idx_invoice_client ON invoice(client_id);
+CREATE INDEX payment_charge ON payment(charge_id);
+
+-- "Has anything changed?" for the page cache and the browser's frozen column widths: every statement that
+-- writes a data table counts it up.
+CREATE TABLE data_version (
+    id      integer PRIMARY KEY DEFAULT 1 CHECK (id = 1),
+    version bigint NOT NULL DEFAULT 0
+);
+INSERT INTO data_version (id, version) VALUES (1, 0);
+
+CREATE FUNCTION bump_data_version() RETURNS trigger LANGUAGE plpgsql AS $$
+BEGIN
+    EXECUTE format('UPDATE %I.data_version SET version = version + 1', TG_TABLE_SCHEMA);
+    RETURN NULL;
+END $$;
+
+DO $$
+DECLARE t text;
+BEGIN
+    FOREACH t IN ARRAY ARRAY['unit', 'room', 'company', 'client', 'company_key', 'dismissed_finding', 'guest',
+                             'invoice', 'stay', 'charge', 'payment'] LOOP
+        EXECUTE format('CREATE TRIGGER %I AFTER INSERT OR UPDATE OR DELETE OR TRUNCATE ON %I '
+                       'FOR EACH STATEMENT EXECUTE FUNCTION bump_data_version()', t || '_data_version', t);
+    END LOOP;
+END $$;
diff --git a/migrations/002_audit_log.sql b/migrations/002_audit_log.sql
new file mode 100644
index 0000000..dbdfdd6
--- /dev/null
+++ b/migrations/002_audit_log.sql
@@ -0,0 +1,49 @@
+-- 002 audit log: every row a data table gains, loses or changes — before, after, and who wrote it.
+-- Backups protect against losing the database, not against it being wrong; this shows which rows changed,
+-- when and by whom, and `python -m app.audit revert` undoes just those. It is also the registration history
+-- the Meldegesetz asks for: corrections through history, not by overwriting.
+-- The trigger function runs as the owner (SECURITY DEFINER): the app's role may read the log but neither
+-- write nor change it (db._grant), and only a table's owner can switch its triggers off.
+
+CREATE TABLE audit_log (
+    id         bigint GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
+    at         timestamptz NOT NULL DEFAULT now(),          -- when the writing transaction began
+    tx         bigint NOT NULL DEFAULT pg_current_xact_id()::text::bigint,   -- revert one transaction whole
+    actor      text COLLATE "C" NOT NULL,   -- the connection's app.actor: web | cli | ...
+    db_user    text COLLATE "C" NOT NULL DEFAULT session_user,                -- the login role, unspoofable
+    table_name text COLLATE "C" NOT NULL,
+    op         text COLLATE "C" NOT NULL,   -- INSERT | UPDATE | DELETE | TRUNCATE
+    row_id     bigint,                      -- null for company_key / dismissed_finding: their key is in the JSON
+    old        jsonb,
+    new        jsonb
+);
+CREATE INDEX audit_log_row ON audit_log (table_name, row_id);
+CREATE INDEX audit_log_tx ON audit_log (tx);
+
+CREATE FUNCTION audit_row() RETURNS trigger LANGUAGE plpgsql SECURITY DEFINER SET search_path = pg_catalog AS $$
+DECLARE
+    o jsonb := CASE WHEN TG_OP IN ('UPDATE', 'DELETE') THEN to_jsonb(OLD) END;
+    n jsonb := CASE WHEN TG_OP IN ('INSERT', 'UPDATE') THEN to_jsonb(NEW) END;
+BEGIN
+    IF TG_OP = 'UPDATE' AND o = n THEN
+        RETURN NULL;                                  -- a save that changed nothing is no history
+    END IF;
+    EXECUTE format('INSERT INTO %I.audit_log (actor, table_name, op, row_id, old, new) '
+                   'VALUES ($1, $2, $3, $4, $5, $6)', TG_TABLE_SCHEMA)
+        USING COALESCE(NULLIF(current_setting('app.actor', true), ''), 'unknown'), TG_TABLE_NAME, TG_OP,
+              (COALESCE(n, o) ->> 'id')::bigint, o, n;
+    RETURN NULL;
+END $$;
+REVOKE EXECUTE ON FUNCTION audit_row() FROM PUBLIC;
+
+DO $$
+DECLARE t text;
+BEGIN
+    FOREACH t IN ARRAY ARRAY['unit', 'room', 'company', 'client', 'company_key', 'dismissed_finding', 'guest',
+                             'invoice', 'stay', 'charge', 'payment'] LOOP
+        EXECUTE format('CREATE TRIGGER %I AFTER INSERT OR UPDATE OR DELETE ON %I '
+                       'FOR EACH ROW EXECUTE FUNCTION audit_row()', t || '_audit', t);
+        EXECUTE format('CREATE TRIGGER %I AFTER TRUNCATE ON %I '
+                       'FOR EACH STATEMENT EXECUTE FUNCTION audit_row()', t || '_audit_truncate', t);
+    END LOOP;
+END $$;
diff --git a/requirements.txt b/requirements.txt
new file mode 100644
index 0000000..f25cb38
--- /dev/null
+++ b/requirements.txt
@@ -0,0 +1,3 @@
+Flask==3.1.3
+playwright==1.61.0
+psycopg[binary]==3.3.6