Anlass, Dubletten, Rückseite, Teilen; Startseite und App-Anmutung

Vier Funktionen: - Anlass: ein Feld auf der Startseite gilt für alle folgenden Scans und wird im Browser gemerkt. Ordnet den Bestand verlässlicher als der Ortsname aus den Koordinaten. Durchsuchbar, nachträglich änderbar. - Dubletten: die Detailansicht zeigt Karten, die dieselbe Person meinen könnten - gleiche E-Mail, gleiche Telefonnummer (verglichen werden die letzten acht Ziffern, damit +49 511 123456 und 0511/123456 aufeinander passen) oder gleicher Nachname bei gleicher Firma. - Rückseite: nachträglich ein zweites Bild zur Karte. Es füllt nur Felder, die die Vorderseite offen gelassen hat. - Schnellwahl bei Erinnerungen: in 3 Tagen / 1 Woche / 2 Wochen / 1 Monat, jeweils 9 Uhr. Das Datumsfeld braucht man damit selten. Teilen als vCard über das System-Teilenblatt, mit Download als Rückfallebene, wo es kein Teilenblatt gibt. Oberfläche: - Startseite führt jetzt: Anlass, große Aufnahmefläche mit Symbol statt Textzeile, leise Alternative, darunter die zuletzt erfassten Karten. Vorher stand dort eine Überschrift mit Zahlen und man musste raten. - Weniger Webseite, mehr App: kein Seitenrahmen auf dem Telefon, Symbole in der Tableiste mit Zählerblasen, kein Tap-Highlight, keine Textmarkierung auf Bedienelementen, Safe-Area oben, Einblendung beim Ansichtswechsel, Mindesthöhe 54 px für Schaltflächen. - Die Marken "exportiert" / "nicht exportiert" sind aus der Liste raus; dafür gibt es den Filter. Neue Spalten occasion und back_image_file kommen per ALTER TABLE in bestehende Datenbanken - CREATE TABLE IF NOT EXISTS rührt eine vorhandene Tabelle nicht an. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Hintergrundverarbeitung, Bildaufbereitung, Sammelexport entfernt
2026-09-06 15:09:08 +02:00 · 2026-09-06 12:56:58 +02:00
16 changed files with 1004 additions and 215 deletions
--- a/README.md
+++ b/README.md
@@ -7,11 +7,23 @@ Kontakt aufs iPhone holen. Selbst gehostete PWA, ein Container.

 **Stapelscan.** Ein Foto von zwanzig Karten auf dem Tisch reicht. OpenCV findet
 die Kartenrechtecke, entzerrt sie perspektivisch und schneidet sie einzeln aus –
-ohne manuelle Nacharbeit. Jeder Zuschnitt geht als Bild an das Vision-Modell,
-das Name, Firma, Position und Kontaktdaten als strukturiertes JSON zurückgibt.
-Ein vorgeschalteter OCR-Schritt wäre kontraproduktiv: er würde Layout und
-Schriftgrößen wegwerfen, also genau die Information, aus der die Feldzuordnung
-entsteht.
+ohne manuelle Nacharbeit. Der Zuschnitt wird dabei leicht enger gesetzt als die
+erkannte Kante, damit kein Untergrund stehen bleibt, und die Beleuchtung wird
+ausgeglichen, damit das Papier weiß wird statt grau.
+
+Jeder Zuschnitt geht als Bild an das Vision-Modell, das Name, Firma, Position
+und Kontaktdaten als strukturiertes JSON zurückgibt. Ein vorgeschalteter
+OCR-Schritt wäre kontraproduktiv: er würde Layout und Schriftgrößen wegwerfen,
+also genau die Information, aus der die Feldzuordnung entsteht. Das Modell sagt
+außerdem, wie herum die Karte gehört – geometrisch ist das nicht bestimmbar –
+und das gespeicherte Bild wird entsprechend gedreht.
+
+**Die Antwort wartet nicht auf das Modell.** Der Scan liefert die freigestellten
+Karten sofort zurück, das Auslesen läuft danach im Hintergrund weiter; die
+Oberfläche lädt nach. Ein Zwanzigerstapel blockiert damit keine Minute im
+Upload. Wer eine Karte in der Zwischenzeit von Hand ergänzt, verliert die
+Eingabe nicht – das Modell füllt nur leere Felder. Bricht der Server mitten im
+Lauf ab, holt er die offenen Karten beim nächsten Start nach.

 **Metadaten.** Aufnahmezeit und GPS kommen aus den EXIF-Daten des Fotos, nicht
 aus dem Browser – Karten werden oft erst abends am Schreibtisch abfotografiert,
@@ -19,14 +31,32 @@ der Browserstandort wäre dann das Wohnzimmer statt der Messe. Die Koordinaten
 löst Nominatim in einen Ortsnamen auf. Fehlen EXIF-Daten, greift der
 Browserstandort als Rückfallebene.

-**Übersicht.** Alle Karten mit Volltextsuche über Name, Firma, Ort und Notiz.
-Filter für „nicht exportiert“, „unvollständig“ und „mit Erinnerung“.
+**Anlass.** Ein Feld auf der Startseite („Hannover Messe 2026“) gilt für alle
+folgenden Scans und wird im Browser gemerkt. Verlässlicher als der Ortsname aus
+den Koordinaten und die eigentliche Ordnung über den Bestand.

-**Export.** Ein Tippen auf *In Kontakte speichern* liefert eine vCard 3.0, die
-iOS direkt in die Kontakte-App übernimmt. Die Karte gilt danach als exportiert.
+**Dubletten.** Auf Messen trifft man Leute wieder. Die Detailansicht zeigt
+Karten, die dieselbe Person meinen könnten – gleiche E-Mail, gleiche
+Telefonnummer (Schreibweise egal, verglichen werden die letzten acht Ziffern)
+oder gleicher Nachname bei gleicher Firma.
+
+**Rückseite.** Nachträglich ein zweites Bild zur Karte aufnehmen. Es wird
+ausgelesen, füllt aber nur Felder, die die Vorderseite offen gelassen hat –
+dort steht oft nur die Mobilnummer.
+
+**Übersicht.** Alle Karten mit Volltextsuche über Name, Firma, Anlass, Ort und
+Notiz. Filter für „nicht exportiert“, „unvollständig“ und „mit Erinnerung“.
+
+**Export und Teilen.** *In Kontakte speichern* liefert eine vCard 3.0, die iOS
+direkt in die Kontakte-App übernimmt. *Als vCard teilen* geht über das
+System-Teilenblatt – per AirDrop, Mail oder Nachricht, ohne Umweg über den
+Download. Bewusst einzeln: ein Sammelexport schiebt zwanzig Kontakte ungeprüft
+ins Adressbuch.

 **Notizen und Erinnerungen.** Freitext pro Karte. Erinnerungen mit Termin gehen
 als Mail raus; verpasste Termine holt der Scheduler beim nächsten Start nach.
+Schnellwahl für die üblichen Abstände, damit das Datumsfeld selten gebraucht
+wird.

 ## Stack

@@ -95,6 +125,7 @@ app/        FastAPI-Anwendung
  segment.py    OpenCV-Pipeline: Karten finden und entzerren
  extract.py    Vision-Modell, strukturiertes JSON
  imaging.py    EXIF-Auswertung, Bildkonvertierung
+  duplicates.py Ähnliche Karten finden
  vcard.py      vCard 3.0
  reminders.py  Scheduler für die Erinnerungsmails
 static/     PWA: HTML, CSS, JavaScript, Service Worker
--- a/app/db.py
+++ b/app/db.py
@@ -15,7 +15,9 @@ CREATE TABLE IF NOT EXISTS cards (
    captured_at     TEXT,
    batch_id        TEXT,
    image_file      TEXT,
+    back_image_file TEXT,
    source          TEXT NOT NULL DEFAULT 'batch',
+    occasion        TEXT,
    full_name       TEXT,
    first_name      TEXT,
    last_name       TEXT,
@@ -71,10 +73,27 @@ def connect() -> sqlite3.Connection:
        _conn.execute("PRAGMA journal_mode=WAL")
        _conn.execute("PRAGMA foreign_keys=ON")
        _conn.executescript(SCHEMA)
+        _migrate(_conn)
        _conn.commit()
    return _conn


+# Spalten, die nach dem ersten Deploy dazugekommen sind. CREATE TABLE IF NOT
+# EXISTS ruehrt eine bestehende Tabelle nicht an - ohne das hier liefe die
+# App auf dem Server mit dem alten Schema weiter.
+LATER_COLUMNS = {
+    "back_image_file": "TEXT",
+    "occasion": "TEXT",
+}
+
+
+def _migrate(conn: sqlite3.Connection) -> None:
+    present = {row["name"] for row in conn.execute("PRAGMA table_info(cards)")}
+    for name, kind in LATER_COLUMNS.items():
+        if name not in present:
+            conn.execute(f"ALTER TABLE cards ADD COLUMN {name} {kind}")
+
+
 def query(sql: str, params: Iterable[Any] = ()) -> list[sqlite3.Row]:
    with _lock:
        return connect().execute(sql, tuple(params)).fetchall()
@@ -91,10 +110,3 @@ def execute(sql: str, params: Iterable[Any] = ()) -> None:
        conn.execute(sql, tuple(params))
        conn.commit()

-
-def execute_many(statements: list[tuple[str, Iterable[Any]]]) -> None:
-    with _lock:
-        conn = connect()
-        for sql, params in statements:
-            conn.execute(sql, tuple(params))
-        conn.commit()
--- a/app/duplicates.py
+++ b/app/duplicates.py
@@ -0,0 +1,55 @@
+"""Karten finden, die dieselbe Person meinen.
+
+Auf Messen trifft man Leute wieder, und dieselbe Karte landet ein zweites Mal
+im Stapel. Verglichen wird nicht der ganze Datensatz, sondern das, was eine
+Person eindeutig macht - in dieser Reihenfolge, weil die Aussagekraft faellt.
+"""
+from . import db
+
+
+def _phone_key(value) -> str:
+    """Nur die letzten acht Ziffern. Damit passen +49 511 123456,
+    0049511123456 und 0511/123456 aufeinander."""
+    digits = "".join(character for character in (value or "") if character.isdigit())
+    return digits[-8:] if len(digits) >= 8 else ""
+
+
+def _phone_keys(row) -> set:
+    return {_phone_key(row["phone"]), _phone_key(row["mobile"])} - {""}
+
+
+def _clean(value) -> str:
+    return (value or "").strip().lower()
+
+
+def _match(card, other) -> str:
+    email = _clean(card["email"])
+    if email and _clean(other["email"]) == email:
+        return "gleiche E-Mail"
+    if _phone_keys(card) & _phone_keys(other):
+        return "gleiche Telefonnummer"
+    last_name, company = _clean(card["last_name"]), _clean(card["company"])
+    if last_name and company:
+        if _clean(other["last_name"]) == last_name and _clean(other["company"]) == company:
+            return "gleicher Name und dieselbe Firma"
+    return ""
+
+
+def find(card) -> list:
+    """Aehnliche Karten, neueste zuerst."""
+    others = db.query(
+        """
+        SELECT id, full_name, first_name, last_name, company, email, phone, mobile,
+               occasion, captured_at, created_at
+        FROM cards
+        WHERE id <> ? AND extract_status <> 'offen'
+        ORDER BY COALESCE(captured_at, created_at) DESC
+        """,
+        (card["id"],),
+    )
+    hits = []
+    for other in others:
+        reason = _match(card, other)
+        if reason:
+            hits.append({**dict(other), "reason": reason})
+    return hits
--- a/app/extract.py
+++ b/app/extract.py
@@ -28,9 +28,17 @@ SCHEMA = {
            "type": "boolean",
            "description": "False, wenn der Ausschnitt keine Visitenkarte zeigt.",
        },
+        "rotation": {
+            "type": "integer",
+            "enum": [0, 90, 180, 270],
+            "description": (
+                "Grad im Uhrzeigersinn, um die das Bild gedreht werden muss, "
+                "damit die Schrift aufrecht steht."
+            ),
+        },
        **{name: {"type": ["string", "null"]} for name in FIELDS},
    },
-    "required": ["is_business_card", *FIELDS],
+    "required": ["is_business_card", "rotation", *FIELDS],
    "additionalProperties": False,
 }

@@ -48,7 +56,10 @@ Regeln:
  first_name und last_name ohne Titel.
 - website ohne Protokollpraefix.
 - Zeigt der Ausschnitt keine Visitenkarte (Tischkante, Notizzettel, leere
-  Flaeche), setze is_business_card auf false und alle Felder auf null."""
+  Flaeche), setze is_business_card auf false und alle Felder auf null.
+- rotation sagt, um wie viel Grad im Uhrzeigersinn das Bild gedreht werden
+  muss, damit die Schrift aufrecht steht. Steht sie schon richtig, ist der
+  Wert 0. Steht die Karte auf dem Kopf, ist er 180."""

 PROMPT = "Lies diese Visitenkarte aus."

@@ -80,7 +91,8 @@ def _get_client() -> anthropic.AsyncAnthropic:


 def _empty(reason: str) -> dict:
-    return {"is_business_card": False, "_error": reason, **{f: None for f in FIELDS}}
+    return {"is_business_card": False, "rotation": 0, "_error": reason,
+            **{f: None for f in FIELDS}}


 def _has_content(result: dict) -> bool:
@@ -154,10 +166,12 @@ async def extract(image_jpeg: bytes) -> dict:

    if not _has_content(result):
        try:
-            rotated = await asyncio.to_thread(imaging.rotate_jpeg_180, image_jpeg)
+            rotated = await asyncio.to_thread(imaging.rotate_jpeg, image_jpeg, 180)
            retry = await _ask(rotated)
            if _has_content(retry):
-                retry["_rotated"] = True
+                # Der zweite Anlauf sah das Bild gedreht - dann stimmt auch
+                # seine Rotationsangabe relativ zum gedrehten Bild.
+                retry["rotation"] = (int(retry.get("rotation") or 0) + 180) % 360
                return retry
        except Exception:
            log.exception("Zweiter Versuch (gedreht) fehlgeschlagen")
--- a/app/imaging.py
+++ b/app/imaging.py
@@ -80,10 +80,12 @@ def encode_jpeg(rgb_or_bgr: np.ndarray, quality: int = 88, bgr: bool = True) ->
    return buffer.getvalue()


-def rotate_jpeg_180(raw: bytes) -> bytes:
-    """Nur fuer den zweiten Anlauf einer leer gebliebenen Karte gedacht -
-    deshalb aus dem JPEG heraus statt aus dem grossen Rohbild."""
-    image = Image.open(io.BytesIO(raw)).transpose(Image.ROTATE_180)
+def rotate_jpeg(raw: bytes, degrees: int) -> bytes:
+    """Im Uhrzeigersinn drehen. Arbeitet auf dem fertigen JPEG, nicht auf dem
+    grossen Rohbild - gebraucht wird das nur fuer einzelne Karten."""
+    if degrees % 360 == 0:
+        return raw
+    image = Image.open(io.BytesIO(raw)).rotate(-degrees, expand=True)
    buffer = io.BytesIO()
    image.save(buffer, format="JPEG", quality=88, optimize=True)
    return buffer.getvalue()
--- a/app/main.py
+++ b/app/main.py
@@ -10,7 +10,10 @@ from fastapi import Depends, FastAPI, Form, HTTPException, Request, Response, Up
 from fastapi.responses import FileResponse, JSONResponse, PlainTextResponse
 from fastapi.staticfiles import StaticFiles

-from . import config, db, extract, geocode, imaging, reminders, security, segment, vcard
+from . import (
+    config, db, duplicates, extract, geocode, imaging, reminders, security,
+    segment, vcard,
+)

 logging.basicConfig(level=logging.INFO, format="%(asctime)s %(levelname)s %(name)s %(message)s")
 log = logging.getLogger("bcs")
@@ -21,7 +24,7 @@ MAX_UPLOAD_BYTES = 30 * 1024 * 1024
 EDITABLE = [
    "full_name", "first_name", "last_name", "job_title", "company", "department",
    "email", "phone", "mobile", "fax", "website",
-    "street", "postal_code", "city", "country", "notes",
+    "street", "postal_code", "city", "country", "notes", "occasion",
 ]


@@ -33,6 +36,14 @@ async def lifespan(app: FastAPI):
        log.warning("APP_PASSWORD ist leer - die App ist ohne Anmeldung erreichbar.")
    if not extract.available():
        log.warning("ANTHROPIC_API_KEY fehlt - Karten werden nur zugeschnitten, nicht ausgelesen.")
+
+    # Karten, die beim letzten Herunterfahren noch in der Warteschlange
+    # standen, wuerden sonst dauerhaft auf "wird gelesen" stehen bleiben.
+    unfinished = db.query("SELECT id FROM cards WHERE extract_status = 'offen'")
+    if unfinished:
+        log.info("%d Karte(n) aus dem letzten Lauf werden nachgeholt", len(unfinished))
+        start_reading([row["id"] for row in unfinished])
+
    task = asyncio.create_task(reminders.run_forever())
    try:
        yield
@@ -51,6 +62,9 @@ def now_iso() -> str:
 def card_dict(row) -> dict:
    card = dict(row)
    card["image_url"] = f"/api/cards/{card['id']}/image" if card.get("image_file") else None
+    card["back_image_url"] = (
+        f"/api/cards/{card['id']}/image?side=back" if card.get("back_image_file") else None
+    )
    card["has_contact"] = any(
        card.get(f) for f in ("full_name", "company", "email", "phone", "mobile")
    )
@@ -116,11 +130,60 @@ def _process_photo(raw: bytes) -> tuple:
    return meta, encoded, fallback


+# Laufende Lesevorgaenge festhalten, sonst raeumt die Garbage Collection sie
+# mitten im Lauf weg.
+_reading: set = set()
+
+
+def start_reading(card_ids: list, side: str = "front") -> None:
+    task = asyncio.create_task(_read_cards(card_ids, side))
+    _reading.add(task)
+    task.add_done_callback(_reading.discard)
+
+
+async def _read_cards(card_ids: list, side: str = "front") -> None:
+    """Das Auslesen laeuft nach der Antwort weiter - der Nutzer sieht seine
+    Karten sofort, die Felder tropfen nach."""
+    column = "back_image_file" if side == "back" else "image_file"
+    rows = [db.query_one("SELECT * FROM cards WHERE id = ?", (i,)) for i in card_ids]
+    rows = [row for row in rows if row is not None and row[column]]
+    images = [(config.IMAGE_DIR / row[column]).read_bytes() for row in rows]
+
+    results = await extract.extract_all(images)
+
+    for row, result in zip(rows, results):
+        rotation = int(result.get("rotation") or 0) % 360
+        if rotation:
+            # Die Lage der Karte auf dem Tisch ist geometrisch nicht
+            # bestimmbar - das Modell sagt uns, wie herum sie gehoert.
+            path = config.IMAGE_DIR / row[column]
+            path.write_bytes(
+                await asyncio.to_thread(imaging.rotate_jpeg, path.read_bytes(), rotation)
+            )
+        fields = {f: (result.get(f) or None) for f in extract.FIELDS}
+        # COALESCE, weil das Auslesen laeuft, waehrend die Karte schon
+        # sichtbar ist: was in der Zwischenzeit von Hand eingetragen wurde,
+        # darf das Modell nicht ueberschreiben.
+        assignments = ", ".join(f"{name} = COALESCE({name}, ?)" for name in fields)
+        db.execute(
+            f"UPDATE cards SET {assignments}, extract_status = ?, extract_error = ? "
+            "WHERE id = ? AND extract_status = 'offen'",
+            [
+                *fields.values(),
+                "fehler" if result.get("_error") else "ok",
+                result.get("_error"),
+                row["id"],
+            ],
+        )
+    log.info("%d Karte(n) ausgelesen", len(rows))
+
+
@app.post("/api/scan", dependencies=[auth])
 async def scan(
    file: UploadFile,
    lat: float = Form(None),
    lon: float = Form(None),
+    occasion: str = Form(""),
 ) -> JSONResponse:
    raw = await file.read()
    if not raw:
@@ -144,13 +207,11 @@ async def scan(
        geo_source = None
    place = await asyncio.to_thread(geocode.reverse, meta["lat"], meta["lon"])

-    results = await extract.extract_all(encoded)
-
    batch_id = uuid.uuid4().hex
    created = now_iso()
    source = "einzel" if fallback else "stapel"
    cards = []
-    for upright, result in zip(encoded, results):
+    for upright in encoded:
        card_id = uuid.uuid4().hex
        image_file = f"{card_id}.jpg"
        (config.IMAGE_DIR / image_file).write_bytes(upright)
@@ -166,11 +227,9 @@ async def scan(
            "lon": meta["lon"],
            "place": place,
            "geo_source": geo_source,
-            "extract_status": "fehler" if result.get("_error") else "ok",
-            "extract_error": result.get("_error"),
+            "occasion": occasion.strip() or None,
+            "extract_status": "offen",
        }
-        for field in extract.FIELDS:
-            columns[field] = (result.get(field) or None)
        names = ", ".join(columns)
        placeholders = ", ".join("?" for _ in columns)
        db.execute(
@@ -178,6 +237,9 @@ async def scan(
        )
        cards.append(card_dict(db.query_one("SELECT * FROM cards WHERE id = ?", (card_id,))))

+    # Antwort geht sofort raus, das Auslesen laeuft danach weiter.
+    start_reading([card["id"] for card in cards])
+
    log.info("Scan %s: %d Karte(n), Fallback=%s", batch_id, len(cards), fallback)
    return JSONResponse(
        {"batch_id": batch_id, "count": len(cards), "fallback": fallback, "cards": cards}
@@ -194,7 +256,7 @@ def list_cards(q: str = "", filter: str = "alle") -> dict:
        needle = f"%{q.strip()}%"
        searchable = [
            "full_name", "company", "job_title", "email", "phone", "mobile",
-            "website", "city", "place", "notes", "department", "street",
+            "website", "city", "place", "notes", "department", "street", "occasion",
        ]
        where.append("(" + " OR ".join(f"{c} LIKE ?" for c in searchable) + ")")
        params += [needle] * len(searchable)
@@ -202,7 +264,8 @@ def list_cards(q: str = "", filter: str = "alle") -> dict:
        where.append("exported_at IS NULL")
    elif filter == "unvollstaendig":
        where.append(
-            "(extract_status <> 'ok' OR (full_name IS NULL AND company IS NULL))"
+            "(extract_status = 'fehler' "
+            "OR (extract_status = 'ok' AND full_name IS NULL AND company IS NULL))"
        )
    elif filter == "erinnerung":
        where.append(
@@ -216,7 +279,8 @@ def list_cards(q: str = "", filter: str = "alle") -> dict:
    totals = db.query_one(
        """
        SELECT COUNT(*) AS total,
-               SUM(CASE WHEN exported_at IS NULL THEN 1 ELSE 0 END) AS offen
+               SUM(CASE WHEN exported_at IS NULL THEN 1 ELSE 0 END) AS offen,
+               SUM(CASE WHEN extract_status = 'offen' THEN 1 ELSE 0 END) AS laeuft
        FROM cards
        """
    )
@@ -229,6 +293,7 @@ def list_cards(q: str = "", filter: str = "alle") -> dict:
            "total": totals["total"] or 0,
            "offen": totals["offen"] or 0,
            "erinnerungen": pending["n"] or 0,
+            "laeuft": totals["laeuft"] or 0,
        },
    }

@@ -249,6 +314,7 @@ def get_card(card_id: str) -> dict:
            "SELECT * FROM reminders WHERE card_id = ? ORDER BY due_at", (card_id,)
        )
    ]
+    card["duplicates"] = duplicates.find(card)
    return card


@@ -271,34 +337,58 @@ async def update_card(card_id: str, request: Request) -> dict:
@app.delete("/api/cards/{card_id}", dependencies=[auth])
 def delete_card(card_id: str) -> dict:
    row = _card_or_404(card_id)
-    if row["image_file"]:
-        (config.IMAGE_DIR / row["image_file"]).unlink(missing_ok=True)
+    for name in (row["image_file"], row["back_image_file"]):
+        if name:
+            (config.IMAGE_DIR / name).unlink(missing_ok=True)
    db.execute("DELETE FROM cards WHERE id = ?", (card_id,))
    return {"ok": True}


@app.get("/api/cards/{card_id}/image", dependencies=[auth])
-def card_image(card_id: str) -> FileResponse:
+def card_image(card_id: str, side: str = "front") -> FileResponse:
    row = _card_or_404(card_id)
-    path = config.IMAGE_DIR / (row["image_file"] or "")
-    if not row["image_file"] or not path.exists():
+    name = row["back_image_file"] if side == "back" else row["image_file"]
+    path = config.IMAGE_DIR / (name or "")
+    if not name or not path.exists():
        raise HTTPException(status_code=404, detail="Kein Bild gespeichert")
    return FileResponse(path, media_type="image/jpeg")


-# ---------------------------------------------------------------------------- Export
+@app.post("/api/cards/{card_id}/back", dependencies=[auth])
+async def add_back(card_id: str, file: UploadFile) -> dict:
+    """Rueckseite nachtragen. Sie wird ausgelesen, fuellt aber nur Felder, die
+    die Vorderseite offen gelassen hat - dort steht oft nur die Mobilnummer."""
+    row = _card_or_404(card_id)
+    raw = await file.read()
+    if not raw:
+        raise HTTPException(status_code=400, detail="Leere Datei")
+    if len(raw) > MAX_UPLOAD_BYTES:
+        raise HTTPException(status_code=413, detail="Foto ist groesser als 30 MB")

-def _mark_exported(ids: list) -> None:
-    stamp = now_iso()
-    db.execute_many(
-        [("UPDATE cards SET exported_at = ? WHERE id = ?", (stamp, i)) for i in ids]
+    try:
+        _, encoded, _ = await asyncio.to_thread(_process_photo, raw)
+    except Exception as exc:
+        log.exception("Rueckseite konnte nicht verarbeitet werden")
+        raise HTTPException(status_code=400, detail=f"Bild nicht lesbar: {exc}") from exc
+    if not encoded:
+        raise HTTPException(status_code=400, detail="Keine Karte im Bild gefunden")
+
+    name = f"{card_id}-back.jpg"
+    (config.IMAGE_DIR / name).write_bytes(encoded[0])
+    db.execute(
+        "UPDATE cards SET back_image_file = ?, extract_status = 'offen' WHERE id = ?",
+        (name, card_id),
    )
+    start_reading([card_id], side="back")
+    return card_dict(_card_or_404(card_id))


+# ---------------------------------------------------------------------------- Export
+
@app.get("/vcf/{card_id}", dependencies=[auth])
 def download_vcard(card_id: str) -> Response:
    card = dict(_card_or_404(card_id))
-    _mark_exported([card_id])
+    db.execute("UPDATE cards SET exported_at = ? WHERE id = ?", (now_iso(), card_id))
    return Response(
        content=vcard.build(card),
        media_type="text/vcard; charset=utf-8",
@@ -306,23 +396,6 @@ def download_vcard(card_id: str) -> Response:
    )


-@app.get("/vcf", dependencies=[auth])
-def download_vcards(ids: str = "") -> Response:
-    wanted = [i for i in ids.split(",") if i.strip()]
-    if not wanted:
-        raise HTTPException(status_code=400, detail="Keine Karten ausgewaehlt")
-    placeholders = ", ".join("?" for _ in wanted)
-    rows = db.query(f"SELECT * FROM cards WHERE id IN ({placeholders})", wanted)
-    if not rows:
-        raise HTTPException(status_code=404, detail="Karten nicht gefunden")
-    _mark_exported([r["id"] for r in rows])
-    return Response(
-        content=vcard.build_many([dict(r) for r in rows]),
-        media_type="text/vcard; charset=utf-8",
-        headers={"Content-Disposition": 'attachment; filename="kontakte.vcf"'},
-    )
-
-
 # ----------------------------------------------------------------------- Erinnerungen

@app.get("/api/reminders", dependencies=[auth])
--- a/app/segment.py
+++ b/app/segment.py
@@ -15,6 +15,10 @@ OUT_WIDTH = 1400   # Obergrenze; kleinere Karten werden nicht hochskaliert
 MIN_WIDTH = 600
 OUT_HEIGHT = round(OUT_WIDTH / CARD_RATIO)

+# Das gefundene Rechteck liegt auf der Kartenkante. Ein schmaler Streifen
+# davon ist noch Tisch - der faellt weg, bevor zugeschnitten wird.
+INSET = 0.015
+
 DETECT_EDGE = 1600          # Aufloesung, auf der gesucht wird
 MIN_AREA_FRACTION = 0.004   # kleiner ist Rauschen, kein Kartenfund
 MAX_AREA_FRACTION = 0.60    # groesser ist der Tisch, nicht die Karte
@@ -130,17 +134,41 @@ def segment(image: np.ndarray) -> tuple[list[np.ndarray], bool]:
    crops = []
    for rect in _reading_order(rects):
        quad = _order_quad(cv2.boxPoints(rect)) / scale  # zurueck auf volle Aufloesung
+        quad = _shrink(quad)
        width, height = _target_size(quad)
        target = np.array(
            [[0, 0], [width, 0], [width, height], [0, height]], dtype="float32"
        )
        matrix = cv2.getPerspectiveTransform(quad, target)
-        crops.append(
-            cv2.warpPerspective(image, matrix, (width, height), flags=cv2.INTER_CUBIC)
-        )
+        crop = cv2.warpPerspective(image, matrix, (width, height), flags=cv2.INTER_CUBIC)
+        crops.append(flatten(crop))
    return crops, False


+def _shrink(quad: np.ndarray, factor: float = INSET) -> np.ndarray:
+    """Ecken zur Mitte ziehen, damit kein Untergrund im Zuschnitt bleibt."""
+    center = quad.mean(axis=0)
+    return (center + (quad - center) * (1.0 - factor)).astype("float32")
+
+
+def flatten(card: np.ndarray) -> np.ndarray:
+    """Beleuchtung ausgleichen, damit das Papier weiss wird statt grau.
+
+    Geteilt wird durch eine stark weichgezeichnete Fassung des Bildes - das
+    ist die Beleuchtung. Uebrig bleibt der Aufdruck. Dunkle Karten bleiben
+    unangetastet: bei ihnen ist das Dunkle das Papier, kein Schatten.
+    """
+    gray = cv2.cvtColor(card, cv2.COLOR_BGR2GRAY)
+    if np.median(gray) < 120:
+        return card
+
+    sigma = max(card.shape[1] / 16.0, 3.0)
+    illumination = cv2.GaussianBlur(gray, (0, 0), sigma).astype(np.float32)
+    gain = np.clip(250.0 / np.maximum(illumination, 1.0), 1.0, 2.2)
+    lifted = card.astype(np.float32) * gain[:, :, None]
+    return np.clip(lifted, 0, 255).astype(np.uint8)
+
+
 def _target_size(quad: np.ndarray) -> tuple:
    """Zuschnitt so gross wie die Vorlage, hoechstens OUT_WIDTH.

--- a/app/vcard.py
+++ b/app/vcard.py
@@ -80,10 +80,6 @@ def build(card: dict) -> str:
    return "\r\n".join(lines) + "\r\n"


-def build_many(cards: list) -> str:
-    return "".join(build(card) for card in cards)
-
-
 def filename(card: dict) -> str:
    base = _display_name(card).replace(" ", "-")
    safe = "".join(c for c in base if c.isalnum() or c in "-_")
--- a/static/app.js
+++ b/static/app.js
@@ -18,6 +18,7 @@
    postal_code: "PLZ",
    city: "Ort",
    country: "Land",
+    occasion: "Anlass",
  };
  const FIELD_ORDER = Object.keys(FIELD_LABELS);

@@ -27,7 +28,7 @@
    query: "",
    filter: "alle",
    cards: [],
-    stats: { total: 0, offen: 0, erinnerungen: 0 },
+    stats: { total: 0, offen: 0, erinnerungen: 0, laeuft: 0 },
    editing: false,
  };

@@ -44,6 +45,15 @@
      "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;",
    })[c]);

+  const store = {
+    get(key) {
+      try { return localStorage.getItem(key) || ""; } catch (_) { return ""; }
+    },
+    set(key, value) {
+      try { localStorage.setItem(key, value); } catch (_) { /* privater Modus */ }
+    },
+  };
+
  // ------------------------------------------------------------------ Helfer

  function toast(message) {
@@ -55,7 +65,7 @@
  }

  function busy(on, text) {
-    $("busy-text").textContent = text || "Karten werden gelesen";
+    $("busy-text").textContent = text || "Karten werden freigestellt";
    $("busy-overlay").hidden = !on;
  }

@@ -98,6 +108,9 @@
    card.company ||
    "Ohne Namen";

+  const subtitle = (card) =>
+    [card.job_title, card.company].filter(Boolean).join(" · ") || "Keine Firma erkannt";
+
  /** Position des Browsers als Rückfallebene. Die EXIF-Daten des Fotos sind
   *  genauer, deshalb blockiert das hier nichts und scheitert leise. */
  function browserPosition() {
@@ -111,20 +124,31 @@
    });
  }

-  /** Zustand einer Karte als abgestufte Pillen: schwarz, was erledigt ist,
-   *  grau umrandet, was noch offen oder auffaellig ist. */
+  /** Zustand einer Karte als Pillen. Ob sie schon exportiert wurde, steht
+   *  bewusst nicht dabei - dafür gibt es den Filter. */
  function cardTags(card) {
    const tags = [];
-    if (card.place) tags.push(["", card.place]);
-    tags.push(
-      card.exported_at ? ["pill-solid", "exportiert"] : ["", "nicht exportiert"]
-    );
-    if (card.extract_status !== "ok") tags.push(["", "Lesefehler"]);
+    if (card.occasion) tags.push(["pill-solid", card.occasion]);
+    else if (card.place) tags.push(["", card.place]);
+    if (card.extract_status === "offen") tags.push(["", "wird gelesen"]);
+    if (card.extract_status === "fehler") tags.push(["", "Lesefehler"]);
    return tags
      .map(([extra, text]) => `<span class="pill ${extra}">${esc(text)}</span>`)
      .join("");
  }

+  function cardRow(card) {
+    return `
+      <button class="row" data-card="${esc(card.id)}">
+        <span class="row-head">
+          <span class="row-title">${esc(displayName(card))}</span>
+          <span class="row-meta">${esc(formatDate(card.captured_at || card.created_at))}</span>
+        </span>
+        <span class="row-sub">${esc(subtitle(card))}</span>
+        <span class="row-tags">${cardTags(card)}</span>
+      </button>`;
+  }
+
  // ----------------------------------------------------------------- Routing

  function go(route, cardId) {
@@ -139,11 +163,13 @@

    Object.entries(screens).forEach(([name, node]) => { node.hidden = name !== route; });
    document.querySelectorAll(".tab").forEach((tab) => {
-      const active = tab.dataset.route === route || (route === "karte" && tab.dataset.route === "karten");
+      const active =
+        tab.dataset.route === route || (route === "karte" && tab.dataset.route === "karten");
      tab.setAttribute("aria-selected", active ? "true" : "false");
    });
    window.scrollTo(0, 0);

+    if (route === "scan") loadRecent();
    if (route === "karten") loadCards();
    if (route === "karte") loadCard(state.cardId);
    if (route === "erinnerungen") loadReminders();
@@ -156,17 +182,18 @@
    busy(true, "Karten werden freigestellt");
    const body = new FormData();
    body.append("file", file);
+    body.append("occasion", $("occasion-input").value.trim());
    const coords = await browserPosition();
    if (coords) {
      body.append("lat", coords.latitude);
      body.append("lon", coords.longitude);
    }
-    busy(true, "Karten werden gelesen");
    try {
      const result = await api("/api/scan", { method: "POST", body });
      renderScanResult(result);
      await refreshStats();
-      toast(`${result.count} Karte${result.count === 1 ? "" : "n"} erfasst`);
+      loadRecent();
+      toast(`${result.count} Karte${result.count === 1 ? "" : "n"} erfasst, wird gelesen`);
    } catch (error) {
      toast(error.message);
    } finally {
@@ -175,31 +202,43 @@
  }

  function renderScanResult(result) {
-    const rows = result.cards
-      .map(
-        (card) => `
-        <button class="row" data-card="${esc(card.id)}">
-          <span class="row-head">
-            <span class="row-title">${esc(displayName(card))}</span>
-            <span class="row-meta">${card.has_contact ? "Gelesen" : "Leer"}</span>
-          </span>
-          <span class="row-sub">${esc(card.company || card.email || "Keine Daten erkannt")}</span>
-        </button>`
-      )
-      .join("");
-
    $("scan-result").innerHTML = `
      <div class="section-label"><span class="label">Ergebnis</span></div>
-      <div class="strip" style="border-top:3px solid #000">
-        <span class="label">Gefundene Karten</span>
-        <span class="display d-lg mono-num">${result.count}</span>
+      <div class="strip">
+        <span class="label">${result.count} Karte${result.count === 1 ? "" : "n"} gefunden</span>
+        <span class="pill">wird gelesen</span>
      </div>
      ${result.fallback
        ? `<p class="hint" style="margin-top:10px">Kein Kartenrechteck erkannt – das ganze Foto
           wurde als eine Karte behandelt. Für einen Stapel hilft ein dunkler, einfarbiger
           Untergrund mit Abstand zwischen den Karten.</p>`
        : ""}
-      <div class="rows" style="margin-top:14px">${rows}</div>`;
+      <div class="rows" style="margin-top:12px">
+        ${result.cards.map(cardRow).join("")}
+      </div>`;
+  }
+
+  async function loadRecent() {
+    try {
+      const data = await api("/api/cards?filter=alle");
+      state.stats = data.stats;
+      updateCounters();
+      const recent = data.cards.slice(0, 3);
+      $("recent-list").innerHTML = recent.length
+        ? `<div class="rows">${recent.map(cardRow).join("")}</div>
+           ${data.cards.length > 3
+             ? `<button class="btn btn-quiet" data-goto="karten" style="margin-top:12px">
+                  Alle ${data.stats.total} Karten <span class="arrow">→</span>
+                </button>`
+             : ""}`
+        : `<div class="empty">
+             <p class="label">Noch nichts erfasst</p>
+             <p class="hint" style="margin:8px 0 0">Mach oben ein Foto – der Rest passiert von allein.</p>
+           </div>`;
+      schedulePoll();
+    } catch (error) {
+      toast(error.message);
+    }
  }

  // ------------------------------------------------------------- Kartenliste
@@ -212,11 +251,25 @@
      state.stats = data.stats;
      updateCounters();
      renderCards();
+      schedulePoll();
    } catch (error) {
      toast(error.message);
    }
  }

+  /** Das Auslesen läuft auf dem Server weiter, nachdem der Scan geantwortet
+   *  hat. Solange noch etwas offen ist, holen wir den Stand nach. */
+  function schedulePoll() {
+    clearTimeout(schedulePoll.timer);
+    if (!state.stats.laeuft) return;
+    schedulePoll.timer = setTimeout(() => {
+      if (state.route === "karten") loadCards();
+      else if (state.route === "karte") loadCard(state.cardId);
+      else if (state.route === "scan") loadRecent();
+      else refreshStats();
+    }, 3000);
+  }
+
  function renderCards() {
    const list = $("cards-list");
    if (!state.cards.length) {
@@ -230,29 +283,12 @@
      return;
    }

-    const selectable = state.cards.map((c) => c.id).join(",");
    list.innerHTML = `
-      <div class="strip" style="border-top:3px solid #000">
+      <div class="strip">
        <span class="label">${state.cards.length} Karte${state.cards.length === 1 ? "" : "n"}</span>
-        <a class="badge" href="/vcf?ids=${esc(selectable)}" download>Alle als vCard</a>
+        ${state.stats.laeuft ? `<span class="pill">${state.stats.laeuft} werden gelesen</span>` : ""}
      </div>
-      <div class="rows">
-        ${state.cards
-          .map(
-            (card) => `
-          <button class="row" data-card="${esc(card.id)}">
-            <span class="row-head">
-              <span class="row-title">${esc(displayName(card))}</span>
-              <span class="row-meta">${esc(formatDate(card.captured_at || card.created_at))}</span>
-            </span>
-            <span class="row-sub">
-              ${esc([card.job_title, card.company].filter(Boolean).join(" · ") || "Keine Firma erkannt")}
-            </span>
-            <span class="row-tags">${cardTags(card)}</span>
-          </button>`
-          )
-          .join("")}
-      </div>`;
+      <div class="rows">${state.cards.map(cardRow).join("")}</div>`;
  }

  // ----------------------------------------------------------- Kartendetail
@@ -261,6 +297,10 @@
    try {
      const card = await api(`/api/cards/${cardId}`);
      renderCard(card);
+      if (card.extract_status === "offen") {
+        state.stats = { ...state.stats, laeuft: Math.max(1, state.stats.laeuft) };
+        schedulePoll();
+      }
    } catch (error) {
      screens.karte.innerHTML = `<div class="empty"><p class="label">${esc(error.message)}</p></div>`;
    }
@@ -268,10 +308,7 @@

  function dataTable(card) {
    const rows = FIELD_ORDER.filter((field) => card[field])
-      .map(
-        (field) =>
-          `<tr><th>${FIELD_LABELS[field]}</th><td>${esc(card[field])}</td></tr>`
-      )
+      .map((field) => `<tr><th>${FIELD_LABELS[field]}</th><td>${esc(card[field])}</td></tr>`)
      .join("");
    return rows
      ? `<table class="data">${rows}</table>`
@@ -288,18 +325,47 @@
    ).join("")}</div>`;
  }

-  function renderCard(card) {
-    const meta = [];
-    if (card.place) meta.push(esc(card.place));
-    if (card.lat != null) meta.push(`${card.lat.toFixed(4)}, ${card.lon.toFixed(4)}`);
+  function duplicateBlock(card) {
+    if (!card.duplicates || !card.duplicates.length) return "";
+    return `
+      <div class="section-label"><span class="label">Schon einmal erfasst?</span></div>
+      <div class="rows">
+        ${card.duplicates
+          .map(
+            (other) => `
+          <button class="row" data-card="${esc(other.id)}">
+            <span class="row-head">
+              <span class="row-title">${esc(displayName(other))}</span>
+              <span class="row-meta">${esc(formatDate(other.captured_at || other.created_at))}</span>
+            </span>
+            <span class="row-sub">${esc(other.reason)}${other.occasion ? " · " + esc(other.occasion) : ""}</span>
+          </button>`
+          )
+          .join("")}
+      </div>`;
+  }

+  const QUICK_DATES = [
+    ["In 3 Tagen", 3],
+    ["In 1 Woche", 7],
+    ["In 2 Wochen", 14],
+    ["In 1 Monat", 30],
+  ];
+
+  function localInputValue(date) {
+    const pad = (n) => String(n).padStart(2, "0");
+    return `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())}` +
+      `T${pad(date.getHours())}:${pad(date.getMinutes())}`;
+  }
+
+  function renderCard(card) {
    const reminders = card.reminders.length
      ? `<div class="rows">${card.reminders
          .map(
            (reminder) => `
          <div class="row" style="cursor:default">
            <span class="row-head">
-              <span class="row-title" style="font-size:14px">${esc(reminder.text)}</span>
+              <span class="row-title" style="font-size:15px">${esc(reminder.text)}</span>
              <button class="badge" data-delete-reminder="${esc(reminder.id)}">Löschen</button>
            </span>
            <span class="row-sub">
@@ -313,14 +379,12 @@
      : `<p class="hint">Keine Erinnerung gesetzt.</p>`;

    screens.karte.innerHTML = `
-      <button class="chip" data-back>← Zurück</button>
+      <button class="chip" data-back>← Karten</button>

      <div class="block-invert">
-        <p class="label">${card.source === "stapel" ? "Aus Stapelscan" : "Einzelscan"}</p>
+        <p class="label">${esc(card.occasion || (card.source === "stapel" ? "Aus Stapelscan" : "Einzelscan"))}</p>
        <h1 class="display d-lg" style="margin-top:8px">${esc(displayName(card))}</h1>
-        <p class="muted" style="margin:6px 0 0">
-          ${esc([card.job_title, card.company].filter(Boolean).join(" · ") || "Keine Firma erkannt")}
-        </p>
+        <p class="muted" style="margin:6px 0 0">${esc(subtitle(card))}</p>
        <div class="figures">
          <span class="figure">
            <span class="label">Erfasst</span>
@@ -328,26 +392,38 @@
          </span>
          <span class="figure">
            <span class="label">Ort</span>
-            <span class="display d-md">${meta.length ? esc(meta[0]) : "Unbekannt"}</span>
+            <span class="display d-md">${esc(card.place || "Unbekannt")}</span>
          </span>
        </div>
      </div>

      ${card.image_url
-        ? `<img class="card-image" src="${esc(card.image_url)}" alt="Visitenkarte">`
+        ? `<img class="card-image" src="${esc(card.image_url)}" alt="Vorderseite">`
        : ""}
+      ${card.back_image_url
+        ? `<img class="card-image" src="${esc(card.back_image_url)}" alt="Rückseite">`
+        : `<label class="btn btn-quiet" for="input-back">
+             Rückseite hinzufügen <span class="arrow">+</span>
+             <input id="input-back" type="file" accept="image/*" capture="environment" hidden>
+           </label>`}

      <a class="btn btn-primary" href="/vcf/${esc(card.id)}" download>
        In Kontakte speichern <span class="arrow">→</span>
      </a>
+      <button class="btn" data-share="${esc(card.id)}">
+        Als vCard teilen <span class="arrow">↗</span>
+      </button>

-      ${card.extract_status !== "ok"
+      ${card.extract_status === "offen"
+        ? `<p class="hint">Die Karte wird gerade ausgelesen – die Felder erscheinen gleich.</p>`
+        : ""}
+      ${card.extract_status === "fehler"
        ? `<p class="hint">Lesefehler: ${esc(card.extract_error || "unbekannt")}</p>`
        : ""}

-      <div class="section-label">
-        <span class="label">Daten</span>
-      </div>
+      ${duplicateBlock(card)}
+
+      <div class="section-label"><span class="label">Daten</span></div>
      <button class="chip" data-toggle-edit style="margin-bottom:10px">
        ${state.editing ? "Fertig" : "Bearbeiten"}
      </button>
@@ -365,7 +441,12 @@
          <span class="label">Text</span>
          <input name="text" placeholder="Angebot nachfassen" required>
        </label>
-        <label class="field">
+        <div class="chips" style="margin-top:12px">
+          ${QUICK_DATES.map(
+            ([text, days]) => `<button class="chip" type="button" data-quick="${days}">${text}</button>`
+          ).join("")}
+        </div>
+        <label class="field" style="margin-top:12px">
          <span class="label">Termin</span>
          <input name="due" type="datetime-local" required>
        </label>
@@ -392,9 +473,39 @@
      });
    });

-    $("reminder-form").addEventListener("submit", async (event) => {
+    const backInput = $("input-back");
+    if (backInput) {
+      backInput.addEventListener("change", async (event) => {
+        const file = event.target.files[0];
+        event.target.value = "";
+        if (!file) return;
+        busy(true, "Rückseite wird gelesen");
+        try {
+          const body = new FormData();
+          body.append("file", file);
+          await api(`/api/cards/${card.id}/back`, { method: "POST", body });
+          toast("Rückseite hinzugefügt");
+          loadCard(card.id);
+        } catch (error) {
+          toast(error.message);
+        } finally {
+          busy(false);
+        }
+      });
+    }
+
+    const form = $("reminder-form");
+    form.querySelectorAll("[data-quick]").forEach((button) => {
+      button.addEventListener("click", () => {
+        const date = new Date();
+        date.setDate(date.getDate() + Number(button.dataset.quick));
+        date.setHours(9, 0, 0, 0);
+        form.elements.due.value = localInputValue(date);
+      });
+    });
+
+    form.addEventListener("submit", async (event) => {
      event.preventDefault();
-      const form = event.currentTarget;
      const due = form.elements.due.value;
      if (!due) return;
      try {
@@ -415,6 +526,34 @@
    });
  }

+  /** Teilen über das System-Teilenblatt. Damit landet die vCard per AirDrop,
+   *  Mail oder Nachricht beim Gegenüber, ohne Umweg über den Download. */
+  async function shareCard(cardId) {
+    try {
+      const response = await fetch(`/vcf/${cardId}`, { credentials: "same-origin" });
+      if (!response.ok) throw new Error("vCard konnte nicht geladen werden");
+      const disposition = response.headers.get("content-disposition") || "";
+      const match = disposition.match(/filename="([^"]+)"/);
+      const blob = await response.blob();
+      const file = new File([blob], match ? match[1] : "kontakt.vcf", {
+        type: "text/vcard",
+      });
+      if (navigator.canShare && navigator.canShare({ files: [file] })) {
+        await navigator.share({ files: [file] });
+        return;
+      }
+      // Kein Teilenblatt (Desktop, ältere Browser): dann eben herunterladen.
+      const url = URL.createObjectURL(blob);
+      const link = document.createElement("a");
+      link.href = url;
+      link.download = file.name;
+      link.click();
+      URL.revokeObjectURL(url);
+    } catch (error) {
+      if (error.name !== "AbortError") toast(error.message);
+    }
+  }
+
  // ------------------------------------------------------------ Erinnerungen

  async function loadReminders() {
@@ -448,11 +587,15 @@

  // -------------------------------------------------------------- Zähler

+  function badge(id, value) {
+    const node = $(id);
+    node.textContent = value;
+    node.hidden = !value;
+  }
+
  function updateCounters() {
-    $("figure-total").textContent = state.stats.total;
-    $("figure-open").textContent = state.stats.offen;
-    $("tab-count-cards").textContent = state.stats.total;
-    $("tab-count-reminders").textContent = state.stats.erinnerungen;
+    badge("tab-count-cards", state.stats.total);
+    badge("tab-count-reminders", state.stats.erinnerungen);
  }

  async function refreshStats() {
@@ -460,15 +603,22 @@
      const data = await api("/api/cards?filter=alle");
      state.stats = data.stats;
      updateCounters();
+      schedulePoll();
    } catch (_) { /* Zähler sind nicht kritisch */ }
  }

  // ------------------------------------------------------------- Ereignisse

  document.addEventListener("click", (event) => {
+    const shareButton = event.target.closest("[data-share]");
+    if (shareButton) return shareCard(shareButton.dataset.share);
+
    const cardButton = event.target.closest("[data-card]");
    if (cardButton) return go("karte", cardButton.dataset.card);

+    const goto = event.target.closest("[data-goto]");
+    if (goto) return go(goto.dataset.goto);
+
    if (event.target.closest("[data-back]")) {
      state.editing = false;
      return go("karten");
@@ -521,6 +671,12 @@
    loadCards();
  });

+  // Der Anlass gilt für eine ganze Messe, nicht für einen Scan.
+  $("occasion-input").value = store.get("occasion");
+  $("occasion-input").addEventListener("change", (event) => {
+    store.set("occasion", event.target.value.trim());
+  });
+
  ["input-camera", "input-library"].forEach((id) => {
    $(id).addEventListener("change", (event) => {
      const file = event.target.files[0];
@@ -534,10 +690,10 @@
    const body = new FormData();
    body.append("password", $("login-password").value);
    try {
-      await fetch("/api/login", { method: "POST", body, credentials: "same-origin" })
-        .then((response) => {
-          if (!response.ok) throw new Error("Passwort stimmt nicht");
-        });
+      const response = await fetch("/api/login", {
+        method: "POST", body, credentials: "same-origin",
+      });
+      if (!response.ok) throw new Error("Passwort stimmt nicht");
      $("login-overlay").hidden = true;
      $("login-error").hidden = true;
      boot();
@@ -567,7 +723,6 @@
      if (!session.extraction_available) {
        toast("Kein API-Schlüssel gesetzt – Karten werden nur zugeschnitten.");
      }
-      await refreshStats();
      applyRoute();
    } catch (error) {
      toast("Server nicht erreichbar");
--- a/static/index.html
+++ b/static/index.html
@@ -34,46 +34,44 @@
  <main>
    <!-- ------------------------------------------------------------- Scan -->
    <section class="screen stack" id="screen-scan">
-      <div class="block-invert">
-        <p class="label">Stapel oder Einzelkarte</p>
-        <h1 class="display d-xl" style="margin-top:8px">Karten<br>erfassen</h1>
-        <p class="muted" style="margin:12px 0 0">
-          Karten nebeneinander auf einen dunklen, einfarbigen Untergrund legen,
-          Handy parallel darüber halten. Ein Foto genügt für den ganzen Tisch.
-        </p>
-        <div class="figures">
-          <span class="figure">
-            <span class="label">Erfasst</span>
-            <span class="display d-lg mono-num" id="figure-total">0</span>
-          </span>
-          <span class="figure">
-            <span class="label">Nicht exportiert</span>
-            <span class="display d-lg mono-num" id="figure-open">0</span>
-          </span>
-        </div>
-      </div>
+      <label class="field">
+        <span class="label">Anlass · gilt für die nächsten Scans</span>
+        <input id="occasion-input" placeholder="z. B. Hannover Messe 2026"
+               autocomplete="off" enterkeyhint="done">
+      </label>

-      <label class="btn btn-primary" for="input-camera">
-        Foto aufnehmen <span class="arrow">→</span>
+      <label class="action" for="input-camera">
+        <span class="action-icon" aria-hidden="true">
+          <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.8">
+            <path d="M3 7h3l1.5-2h9L18 7h3v12H3z"></path>
+            <circle cx="12" cy="13" r="3.6"></circle>
+          </svg>
+        </span>
+        <span class="action-body">
+          <span class="display d-lg">Foto aufnehmen</span>
+          <span class="action-hint">
+            Karten nebeneinander auf einen dunklen Untergrund legen.
+            Ein Foto reicht für den ganzen Tisch.
+          </span>
+        </span>
        <input id="input-camera" type="file" accept="image/*" capture="environment" hidden>
      </label>
+
      <label class="btn btn-quiet" for="input-library">
        Aus Fotos wählen <span class="arrow">↗</span>
        <input id="input-library" type="file" accept="image/*" hidden>
      </label>

-      <p class="hint">
-        Die Kamera liefert die volle Auflösung – bei zwanzig Karten auf einem Foto
-        ist das der Unterschied zwischen lesbar und nicht lesbar.
-      </p>
-
      <div id="scan-result"></div>
+
+      <div class="section-label"><span class="label">Zuletzt erfasst</span></div>
+      <div id="recent-list"></div>
    </section>

    <!-- ------------------------------------------------------------ Karten -->
    <section class="screen stack" id="screen-cards" hidden>
      <div class="search">
-        <input id="search-input" type="search" placeholder="Name, Firma, Ort, Notiz …"
+        <input id="search-input" type="search" placeholder="Name, Firma, Anlass, Notiz …"
               autocomplete="off" enterkeyhint="search">
        <button id="search-clear" type="button" aria-label="Suche leeren">×</button>
      </div>
@@ -97,12 +95,34 @@
  </main>

  <nav class="tabs" role="tablist">
-    <button class="tab" role="tab" data-route="scan" aria-selected="true">Scan</button>
+    <button class="tab" role="tab" data-route="scan" aria-selected="true">
+      <span class="tab-icon" aria-hidden="true">
+        <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.9">
+          <path d="M3 7h3l1.5-2h9L18 7h3v12H3z"></path>
+          <circle cx="12" cy="13" r="3.4"></circle>
+        </svg>
+      </span>
+      <span class="tab-label">Scannen</span>
+    </button>
    <button class="tab" role="tab" data-route="karten" aria-selected="false">
-      <span class="count mono-num" id="tab-count-cards">0</span>Karten
+      <span class="tab-icon" aria-hidden="true">
+        <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.9">
+          <rect x="3" y="6" width="18" height="13"></rect>
+          <path d="M7 11h5M7 15h8"></path>
+        </svg>
+      </span>
+      <span class="tab-label">Karten</span>
+      <span class="tab-badge mono-num" id="tab-count-cards" hidden>0</span>
    </button>
    <button class="tab" role="tab" data-route="erinnerungen" aria-selected="false">
-      <span class="count mono-num" id="tab-count-reminders">0</span>Termine
+      <span class="tab-icon" aria-hidden="true">
+        <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.9">
+          <circle cx="12" cy="12" r="8.5"></circle>
+          <path d="M12 7v5.2l3.4 2"></path>
+        </svg>
+      </span>
+      <span class="tab-label">Termine</span>
+      <span class="tab-badge mono-num" id="tab-count-reminders" hidden>0</span>
    </button>
  </nav>
 </div>
@@ -125,7 +145,7 @@
 <div class="overlay" id="busy-overlay" hidden>
  <div class="block-invert stack" style="text-align:center">
    <div class="spinner" style="margin:0 auto"></div>
-    <p class="label" id="busy-text">Karten werden gelesen</p>
+    <p class="label" id="busy-text">Karten werden freigestellt</p>
  </div>
 </div>

--- a/static/style.css
+++ b/static/style.css
@@ -27,7 +27,7 @@
 html, body {
  margin: 0;
  padding: 0;
-  background: var(--page);
+  background: var(--bg);
  color: var(--ink);
  font-family: var(--sans);
  font-size: 15px;
@@ -35,7 +35,17 @@ html, body {
  -webkit-text-size-adjust: 100%;
 }

-body { overflow-x: hidden; }
+body {
+  overflow-x: hidden;
+  overscroll-behavior-y: none;
+  -webkit-tap-highlight-color: transparent;
+}
+
+/* Bedienelemente verhalten sich wie in einer App, nicht wie Fliesstext. */
+.btn, .chip, .tab, .row, .badge, .pill, .action, .label, .topbar {
+  -webkit-user-select: none;
+  user-select: none;
+}

 button, input, textarea, select {
  font: inherit;
@@ -81,8 +91,6 @@ a { color: inherit; }
  margin: 0 auto;
  min-height: 100vh;
  background: var(--bg);
-  border-left: 1px solid var(--ink);
-  border-right: 1px solid var(--ink);
  display: flex;
  flex-direction: column;
 }
@@ -95,6 +103,7 @@ a { color: inherit; }
  align-items: center;
  gap: 12px;
  padding: 13px var(--pad);
+  padding-top: calc(13px + env(safe-area-inset-top));
  background: var(--bg);
  border-bottom: 3px solid var(--ink);
 }
@@ -117,7 +126,12 @@ a { color: inherit; }
 .topbar .spacer { margin-left: auto; }

 main { flex: 1; display: flex; flex-direction: column; }
-.screen { flex: 1; padding: var(--pad) var(--pad) 30px; }
+.screen { flex: 1; padding: var(--pad) var(--pad) 30px; animation: rise 0.18s ease-out; }
+
+@keyframes rise {
+  from { opacity: 0; transform: translateY(7px); }
+  to { opacity: 1; transform: none; }
+}
 .screen[hidden] { display: none; }

 .stack > * + * { margin-top: 12px; }
@@ -191,6 +205,7 @@ main { flex: 1; display: flex; flex-direction: column; }
  justify-content: space-between;
  gap: 10px;
  width: 100%;
+  min-height: 54px;
  padding: 16px;
  background: var(--bg);
  border: 2px solid var(--ink);
@@ -203,6 +218,24 @@ main { flex: 1; display: flex; flex-direction: column; }
  text-align: left;
 }

+/* Die eine Sache, die man auf der Startseite tut. Grosse Flaeche statt
+   Textzeile - auf dem Telefon zaehlt die Trefferflaeche, nicht die Kante. */
+.action {
+  display: flex;
+  align-items: center;
+  gap: 16px;
+  padding: 22px 18px;
+  background: var(--ink);
+  color: var(--bg);
+  cursor: pointer;
+}
+
+.action:active { background: #1f1f1f; }
+.action-icon { flex: 0 0 42px; color: var(--bg); }
+.action-icon svg { width: 42px; height: 42px; display: block; }
+.action-body { display: flex; flex-direction: column; gap: 7px; }
+.action-hint { font-size: 12.5px; line-height: 1.45; color: #a9a9a9; }
+
 /* Was man hier tun soll. */
 .btn-primary { background: var(--ink); color: var(--bg); border-color: var(--ink); }

@@ -274,7 +307,7 @@ main { flex: 1; display: flex; flex-direction: column; }

 /* Ungewaehlt zurueckgenommen, damit die Auswahl ueberhaupt auffaellt. */
 .chip {
-  padding: 7px 11px;
+  padding: 9px 12px;
  border: 1px solid var(--rule);
  background: var(--bg);
  color: var(--ink-3);
@@ -402,15 +435,16 @@ main { flex: 1; display: flex; flex-direction: column; }
 }

 .tab {
+  position: relative;
  flex: 1;
-  padding: 12px 4px calc(12px + env(safe-area-inset-bottom));
+  padding: 10px 4px calc(10px + env(safe-area-inset-bottom));
  background: var(--bg);
  border: none;
  border-left: 1px solid var(--rule);
  color: var(--ink-3);
  font-size: 10px;
  font-weight: 700;
-  letter-spacing: 0.12em;
+  letter-spacing: 0.1em;
  text-transform: uppercase;
  cursor: pointer;
 }
@@ -418,15 +452,27 @@ main { flex: 1; display: flex; flex-direction: column; }
 .tab:first-child { border-left: none; }
 .tab[aria-selected="true"] { background: var(--ink); color: var(--bg); }

-.tab .count {
-  display: block;
-  font-size: 17px;
+.tab-icon { display: block; width: 24px; height: 24px; margin: 0 auto 4px; }
+.tab-icon svg { width: 24px; height: 24px; display: block; }
+.tab-label { display: block; }
+
+.tab-badge {
+  position: absolute;
+  top: 6px;
+  right: 50%;
+  transform: translateX(26px);
+  min-width: 18px;
+  padding: 1px 4px;
+  background: var(--ink);
+  color: var(--bg);
+  border: 1px solid var(--bg);
+  font-size: 10px;
  font-weight: 800;
-  color: var(--ink);
-  margin-bottom: 1px;
+  letter-spacing: 0;
 }

-.tab[aria-selected="true"] .count { color: var(--bg); }
+.tab-badge[hidden] { display: none; }
+.tab[aria-selected="true"] .tab-badge { background: var(--bg); color: var(--ink); border-color: var(--ink); }

 /* ------------------------------------------------------------------- Zustaende */

@@ -484,8 +530,11 @@ main { flex: 1; display: flex; flex-direction: column; }

 .toast[hidden] { display: none; }

+/* Nur am grossen Bildschirm ein Rahmen - auf dem Telefon fuellt die App
+   den Schirm, wie eine App das tut. */
@media (min-width: 600px) {
  :root { --pad: 26px; }
+  body { background: var(--page); }
  .app { border: 1px solid var(--ink); margin: 26px auto; min-height: calc(100vh - 52px); }
  .d-xl { font-size: 52px; }
 }
--- a/tests/test_api.py
+++ b/tests/test_api.py
@@ -3,16 +3,31 @@
 Ohne ANTHROPIC_API_KEY laeuft die Extraktion in den Leerlauf - Freistellen,
 Speichern, Suchen, Bearbeiten und Export werden trotzdem vollstaendig gepruft.
 """
+import asyncio
+import time
 from datetime import datetime, timedelta, timezone

 import pytest
 from fastapi.testclient import TestClient

-from app import db, mailer, reminders
+from app import db, extract, mailer, reminders
 from app.main import app
 from tests.helpers import photo_bytes


+def warte_bis_gelesen(client, card_ids, timeout=15.0):
+    """Das Auslesen laeuft im Hintergrund - hier auf das Ende warten."""
+    frist = time.monotonic() + timeout
+    while time.monotonic() < frist:
+        stati = [
+            client.get(f"/api/cards/{i}").json()["extract_status"] for i in card_ids
+        ]
+        if all(status != "offen" for status in stati):
+            return stati
+        time.sleep(0.1)
+    raise AssertionError("Karten wurden nicht fertig gelesen")
+
+
@pytest.fixture(scope="module")
 def client():
    with TestClient(app) as test_client:
@@ -25,7 +40,9 @@ def scanned(client):
        "/api/scan", files={"file": ("tisch.jpg", photo_bytes(4), "image/jpeg")}
    )
    assert response.status_code == 200
-    return response.json()
+    data = response.json()
+    warte_bis_gelesen(client, [c["id"] for c in data["cards"]])
+    return data


 def test_healthz(client):
@@ -97,14 +114,6 @@ def test_filter_offen_blendet_exportierte_karten_aus(client, scanned):
    assert all(card["exported_at"] is None for card in offen)


-def test_sammelexport_mehrerer_karten(client, scanned):
-    ids = ",".join(card["id"] for card in scanned["cards"][:3])
-
-    response = client.get("/vcf", params={"ids": ids})
-
-    assert response.text.count("BEGIN:VCARD") == 3
-
-
 def test_erinnerung_anlegen_und_filtern(client, scanned):
    card_id = scanned["cards"][2]["id"]
    due = datetime.now(timezone.utc) + timedelta(days=3)
@@ -181,3 +190,168 @@ def test_pwa_dateien_werden_ausgeliefert(client):
    assert client.get("/sw.js").status_code == 200
    assert client.get("/manifest.webmanifest").status_code == 200
    assert client.get("/static/app.js").status_code == 200
+
+
+def test_scan_antwortet_bevor_das_auslesen_fertig_ist(client, monkeypatch):
+    """Der Kern der Hintergrundverarbeitung: die Antwort wartet nicht auf das
+    Modell. Ohne das haengt ein Zwanzigerstapel eine Minute im Upload."""
+    original = extract.extract_all
+
+    async def langsam(images):
+        await asyncio.sleep(1.5)
+        return await original(images)
+
+    monkeypatch.setattr(extract, "extract_all", langsam)
+
+    start = time.monotonic()
+    response = client.post(
+        "/api/scan", files={"file": ("einzel.jpg", photo_bytes(1), "image/jpeg")}
+    )
+    dauer = time.monotonic() - start
+    card_id = response.json()["cards"][0]["id"]
+
+    assert dauer < 1.2, f"Antwort brauchte {dauer:.2f}s, hat also gewartet"
+    assert client.get(f"/api/cards/{card_id}").json()["extract_status"] == "offen"
+
+    monkeypatch.undo()
+    warte_bis_gelesen(client, [card_id])
+
+
+def test_offene_karten_zaehlen_nicht_als_unvollstaendig(client):
+    """Waehrend des Lesens sind Felder naturgemaess leer - das ist kein Mangel."""
+    created = client.post(
+        "/api/scan", files={"file": ("einzel.jpg", photo_bytes(1), "image/jpeg")}
+    ).json()
+    card_id = created["cards"][0]["id"]
+    warte_bis_gelesen(client, [card_id])  # sonst ueberschreibt der Hintergrundlauf
+    db.execute("UPDATE cards SET extract_status = 'offen' WHERE id = ?", (card_id,))
+
+    unvollstaendig = client.get(
+        "/api/cards", params={"filter": "unvollstaendig"}
+    ).json()["cards"]
+
+    assert card_id not in [c["id"] for c in unvollstaendig]
+    assert client.get("/api/cards").json()["stats"]["laeuft"] >= 1
+
+    db.execute("UPDATE cards SET extract_status = 'ok' WHERE id = ?", (card_id,))
+
+
+def test_sammelexport_ist_entfernt(client):
+    assert client.get("/vcf", params={"ids": "egal"}).status_code == 404
+
+
+def test_handeintrag_ueberlebt_den_hintergrundlauf(client, monkeypatch):
+    """Die Karte ist sichtbar, bevor sie gelesen ist. Wer in der Zwischenzeit
+    etwas eintraegt, darf es nicht wieder verlieren."""
+    original = extract.extract_all
+
+    async def langsam(images):
+        await asyncio.sleep(1.0)
+        return await original(images)
+
+    monkeypatch.setattr(extract, "extract_all", langsam)
+    card_id = client.post(
+        "/api/scan", files={"file": ("einzel.jpg", photo_bytes(1), "image/jpeg")}
+    ).json()["cards"][0]["id"]
+
+    client.patch(f"/api/cards/{card_id}", json={"full_name": "Von Hand", "notes": "Messe"})
+
+    monkeypatch.undo()
+    warte_bis_gelesen(client, [card_id])
+
+    card = client.get(f"/api/cards/{card_id}").json()
+    assert card["full_name"] == "Von Hand"
+    assert card["notes"] == "Messe"
+
+
+def test_anlass_wird_gespeichert_und_ist_durchsuchbar(client):
+    created = client.post(
+        "/api/scan",
+        files={"file": ("tisch.jpg", photo_bytes(2), "image/jpeg")},
+        data={"occasion": "Hannover Messe 2026"},
+    ).json()
+    ids = [c["id"] for c in created["cards"]]
+    warte_bis_gelesen(client, ids)
+
+    assert all(c["occasion"] == "Hannover Messe 2026" for c in created["cards"])
+
+    gefunden = client.get("/api/cards", params={"q": "hannover messe"}).json()["cards"]
+    assert set(ids) <= {c["id"] for c in gefunden}
+
+
+def test_anlass_ist_nachtraeglich_aenderbar(client):
+    card_id = client.post(
+        "/api/scan", files={"file": ("einzel.jpg", photo_bytes(1), "image/jpeg")}
+    ).json()["cards"][0]["id"]
+    warte_bis_gelesen(client, [card_id])
+
+    patched = client.patch(f"/api/cards/{card_id}", json={"occasion": "Kundentermin"})
+
+    assert patched.json()["occasion"] == "Kundentermin"
+
+
+def test_dubletten_stehen_in_der_detailansicht(client):
+    erste = client.post(
+        "/api/scan", files={"file": ("a.jpg", photo_bytes(1), "image/jpeg")}
+    ).json()["cards"][0]["id"]
+    zweite = client.post(
+        "/api/scan", files={"file": ("b.jpg", photo_bytes(1), "image/jpeg")}
+    ).json()["cards"][0]["id"]
+    warte_bis_gelesen(client, [erste, zweite])
+    for card_id in (erste, zweite):
+        client.patch(f"/api/cards/{card_id}", json={"email": "doppelt@firma.de"})
+
+    detail = client.get(f"/api/cards/{zweite}").json()
+
+    assert erste in [d["id"] for d in detail["duplicates"]]
+    assert detail["duplicates"][0]["reason"] == "gleiche E-Mail"
+
+
+def test_rueckseite_nachtragen(client):
+    card_id = client.post(
+        "/api/scan", files={"file": ("vorne.jpg", photo_bytes(1), "image/jpeg")}
+    ).json()["cards"][0]["id"]
+    warte_bis_gelesen(client, [card_id])
+
+    response = client.post(
+        f"/api/cards/{card_id}/back",
+        files={"file": ("hinten.jpg", photo_bytes(1), "image/jpeg")},
+    )
+    assert response.status_code == 200
+    assert response.json()["back_image_url"].endswith("side=back")
+    warte_bis_gelesen(client, [card_id])
+
+    bild = client.get(f"/api/cards/{card_id}/image", params={"side": "back"})
+    assert bild.status_code == 200
+    assert bild.headers["content-type"] == "image/jpeg"
+
+
+def test_ohne_rueckseite_gibt_es_kein_rueckseitenbild(client):
+    card_id = client.post(
+        "/api/scan", files={"file": ("vorne.jpg", photo_bytes(1), "image/jpeg")}
+    ).json()["cards"][0]["id"]
+    warte_bis_gelesen(client, [card_id])
+
+    assert client.get(
+        f"/api/cards/{card_id}/image", params={"side": "back"}
+    ).status_code == 404
+
+
+def test_loeschen_entfernt_auch_die_rueckseite(client):
+    from app import config
+
+    card_id = client.post(
+        "/api/scan", files={"file": ("vorne.jpg", photo_bytes(1), "image/jpeg")}
+    ).json()["cards"][0]["id"]
+    warte_bis_gelesen(client, [card_id])
+    client.post(
+        f"/api/cards/{card_id}/back",
+        files={"file": ("hinten.jpg", photo_bytes(1), "image/jpeg")},
+    )
+    warte_bis_gelesen(client, [card_id])
+    row = db.query_one("SELECT * FROM cards WHERE id = ?", (card_id,))
+
+    client.delete(f"/api/cards/{card_id}")
+
+    assert not (config.IMAGE_DIR / row["image_file"]).exists()
+    assert not (config.IMAGE_DIR / row["back_image_file"]).exists()
--- a/tests/test_bildaufbereitung.py
+++ b/tests/test_bildaufbereitung.py
@@ -0,0 +1,89 @@
+"""Zuschnitt aufhellen, Untergrund abschneiden, richtig herum drehen."""
+import io
+
+import numpy as np
+from PIL import Image
+
+from app import imaging, segment
+from tests.helpers import photo_with_cards
+
+
+def _jpeg(width: int, height: int, color=(255, 255, 255)) -> bytes:
+    buffer = io.BytesIO()
+    Image.new("RGB", (width, height), color).save(buffer, format="JPEG")
+    return buffer.getvalue()
+
+
+def _size(raw: bytes) -> tuple:
+    return Image.open(io.BytesIO(raw)).size
+
+
+def test_drehung_um_null_grad_laesst_die_datei_unangetastet():
+    raw = _jpeg(40, 20)
+
+    assert imaging.rotate_jpeg(raw, 0) is raw
+    assert imaging.rotate_jpeg(raw, 360) is raw
+
+
+def test_drehung_um_180_grad_behaelt_das_format():
+    assert _size(imaging.rotate_jpeg(_jpeg(40, 20), 180)) == (40, 20)
+
+
+def test_drehung_um_90_grad_tauscht_die_seiten():
+    assert _size(imaging.rotate_jpeg(_jpeg(40, 20), 90)) == (20, 40)
+    assert _size(imaging.rotate_jpeg(_jpeg(40, 20), 270)) == (20, 40)
+
+
+def test_drehrichtung_ist_im_uhrzeigersinn():
+    # Oben links schwarz: nach 90 Grad im Uhrzeigersinn liegt es oben rechts.
+    image = np.full((20, 40, 3), 255, dtype=np.uint8)
+    image[:10, :20] = 0
+    buffer = io.BytesIO()
+    Image.fromarray(image).save(buffer, format="PNG")
+    gedreht = np.asarray(
+        Image.open(io.BytesIO(imaging.rotate_jpeg(buffer.getvalue(), 90)))
+    )
+
+    assert gedreht[:10, -10:].mean() < 60   # oben rechts jetzt dunkel
+    assert gedreht[:10, :10].mean() > 195   # oben links jetzt hell
+
+
+def test_helle_karte_wird_aufgehellt():
+    # Karte mit Helligkeitsverlauf, wie ihn schraeges Licht erzeugt.
+    verlauf = np.linspace(150, 225, 400, dtype=np.float32)
+    karte = np.repeat(verlauf[None, :, None], 250, axis=0).repeat(3, axis=2)
+    karte = karte.astype(np.uint8)
+
+    aufgehellt = segment.flatten(karte)
+
+    assert aufgehellt.mean() > karte.mean() + 20
+    # Der Verlauf ist danach deutlich flacher als vorher.
+    vorher = float(karte[:, -1].mean() - karte[:, 0].mean())
+    nachher = float(aufgehellt[:, -1].mean() - aufgehellt[:, 0].mean())
+    assert nachher < vorher / 2
+
+
+def test_dunkle_karte_bleibt_dunkel():
+    dunkel = np.full((250, 400, 3), 40, dtype=np.uint8)
+
+    assert np.array_equal(segment.flatten(dunkel), dunkel)
+
+
+def test_zuschnitt_laesst_den_untergrund_draussen():
+    # Der Untergrund im Testfoto ist dunkel. Bleibt ein Streifen davon im
+    # Zuschnitt, waeren die Randspalten deutlich dunkler als die Mitte.
+    crops, _ = segment.segment(photo_with_cards(count=4))
+
+    for crop in crops:
+        rand = np.concatenate([crop[:, :3], crop[:, -3:]], axis=1)
+        assert rand.mean() > 170
+
+
+def test_einzug_zieht_die_ecken_zur_mitte():
+    quad = np.array([[0, 0], [100, 0], [100, 100], [0, 100]], dtype="float32")
+
+    kleiner = segment._shrink(quad, factor=0.1)
+
+    assert kleiner[0][0] > quad[0][0]
+    assert kleiner[2][0] < quad[2][0]
+    assert np.allclose(kleiner.mean(axis=0), quad.mean(axis=0))
--- a/tests/test_duplicates.py
+++ b/tests/test_duplicates.py
@@ -0,0 +1,88 @@
+"""Dublettenerkennung. Auf Messen trifft man Leute wieder."""
+import uuid
+
+import pytest
+
+from app import db, duplicates
+
+
+def _card(**felder):
+    columns = {
+        "id": uuid.uuid4().hex,
+        "created_at": "2026-09-01T10:00:00+00:00",
+        "extract_status": "ok",
+        **felder,
+    }
+    names = ", ".join(columns)
+    db.execute(
+        f"INSERT INTO cards ({names}) VALUES ({', '.join('?' for _ in columns)})",
+        list(columns.values()),
+    )
+    return db.query_one("SELECT * FROM cards WHERE id = ?", (columns["id"],))
+
+
+@pytest.fixture(autouse=True)
+def leere_tabelle():
+    db.execute("DELETE FROM cards")
+    yield
+    db.execute("DELETE FROM cards")
+
+
+def test_gleiche_email_wird_gefunden():
+    _card(full_name="Anna Berg", email="A.Berg@Firma.de")
+    neu = _card(full_name="A. Berg", email="a.berg@firma.de")
+
+    treffer = duplicates.find(neu)
+
+    assert [t["reason"] for t in treffer] == ["gleiche E-Mail"]
+
+
+def test_telefonnummer_in_anderer_schreibweise():
+    _card(full_name="Anna Berg", phone="+49 511 1234560")
+    neu = _card(full_name="Anna B.", mobile="0511/1234560")
+
+    treffer = duplicates.find(neu)
+
+    assert [t["reason"] for t in treffer] == ["gleiche Telefonnummer"]
+
+
+def test_name_und_firma_zusammen():
+    _card(last_name="Berg", company="Berg & Partner GmbH")
+    neu = _card(last_name="berg", company="berg & partner gmbh")
+
+    assert [t["reason"] for t in duplicates.find(neu)] == ["gleicher Name und dieselbe Firma"]
+
+
+def test_gleicher_nachname_allein_reicht_nicht():
+    _card(last_name="Berg", company="Andere GmbH")
+    neu = _card(last_name="Berg", company="Berg & Partner GmbH")
+
+    assert duplicates.find(neu) == []
+
+
+def test_kurze_nummern_werden_nicht_verglichen():
+    # Eine dreistellige Durchwahl darf keine Dublette erzeugen.
+    _card(full_name="Anna Berg", phone="123")
+    neu = _card(full_name="Bea Kurz", phone="123")
+
+    assert duplicates.find(neu) == []
+
+
+def test_leere_felder_erzeugen_keine_treffer():
+    _card(full_name="Anna Berg")
+    neu = _card(full_name="Bea Kurz")
+
+    assert duplicates.find(neu) == []
+
+
+def test_die_karte_selbst_ist_keine_dublette():
+    karte = _card(full_name="Anna Berg", email="a@b.de")
+
+    assert duplicates.find(karte) == []
+
+
+def test_noch_nicht_gelesene_karten_bleiben_aussen_vor():
+    _card(full_name="Anna Berg", email="a@b.de", extract_status="offen")
+    neu = _card(full_name="Anna Berg", email="a@b.de")
+
+    assert duplicates.find(neu) == []
--- a/tests/test_extract.py
+++ b/tests/test_extract.py
@@ -30,6 +30,16 @@ def test_output_config_ohne_effort_bleibt_gueltig():

 def test_schema_verlangt_alle_felder_und_verbietet_zusaetze():
    assert extract.SCHEMA["additionalProperties"] is False
-    assert set(extract.SCHEMA["required"]) == {"is_business_card", *extract.FIELDS}
+    assert set(extract.SCHEMA["required"]) == {
+        "is_business_card",
+        "rotation",
+        *extract.FIELDS,
+    }
    for field in extract.FIELDS:
        assert extract.SCHEMA["properties"][field]["type"] == ["string", "null"]
+
+
+def test_rotation_ist_auf_vier_werte_beschraenkt():
+    """Das Modell sagt uns, wie herum die Karte gehoert - geometrisch ist das
+    nicht bestimmbar."""
+    assert extract.SCHEMA["properties"]["rotation"]["enum"] == [0, 90, 180, 270]
--- a/tests/test_vcard.py
+++ b/tests/test_vcard.py
@@ -58,13 +58,6 @@ def test_firma_ersetzt_den_namen_wenn_keiner_erkannt_wurde():
    assert "FN:Berg & Partner GmbH" in output


-def test_mehrere_karten_in_einer_datei():
-    output = vcard.build_many([BASE, {"full_name": "Bea Kurz"}])
-
-    assert output.count("BEGIN:VCARD") == 2
-    assert output.count("END:VCARD") == 2
-
-
 def test_dateiname_ist_dateisystemtauglich():
    assert vcard.filename(BASE) == "Dr-Anna-Berg.vcf"
    assert vcard.filename({}) == "Unbenannt.vcf"