feat: Schlagwörter je Kategorie + auf-/zuklappbares Kategorie-Dropdown

- Manuelle Schlagwörter je Kategorie (Popup mit Chips, Doppelklick zum Bearbeiten)
- Treffer über Empfänger ODER Verwendungszweck; längstes Schlagwort gewinnt;
  Kind-Filter (Ausgabe/Einnahme); wirken nur bei künftigen Importen
- Lernende Korrektur-Erkennung: ab 5 Anwendungen und >= 1/3 Korrekturen
  erscheint eine Prüf-Meldung in den Einstellungen (Behalten/Entfernen)
- Neue CategorySelect-Komponente (Baum + Suche, per Portal) ersetzt die
  nativen optgroup-Selects in Buchungen und Import-Prüfansicht
- Migration 0006 (source/applied_count/overridden_count/confirmed, match_field any)
- Endpunkte, i18n DE/EN, Tests (test_keywords: 7 neu, gesamt 27 grün)

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

backend/app/models.py

@@ -94,6 +94,12 @@ class AmountMode(str, enum.Enum):
 class MatchField(str, enum.Enum):
     payee = "payee"
     purpose = "purpose"
+    any = "any"  # trifft, wenn das Muster im Empfänger ODER im Zweck vorkommt
+
+
+class RuleSource(str, enum.Enum):
+    learned = "learned"  # automatisch aus bestätigten Zuordnungen gelernt
+    manual = "manual"    # vom Nutzer als Schlagwort angelegt
 
 
 class ImportStatus(str, enum.Enum):
@@ -466,7 +472,13 @@ class ImportBatch(Base):
 
 
 class CategorizationRule(Base):
-    """Lernende Regel: Empfänger/Zweck enthält Muster -> Kategorie (oder Transfer)."""
+    """Regel: Empfänger/Zweck enthält Muster -> Kategorie.
+
+    Zwei Quellen (``source``): ``learned`` wird beim Import automatisch aus
+    bestätigten Zuordnungen gelernt; ``manual`` legt der Nutzer als Schlagwort je
+    Kategorie an. ``applied_count``/``overridden_count`` zählen, wie oft die Regel
+    zutraf und wie oft ihr Vorschlag wegkorrigiert wurde – daraus wird ein
+    manuelles Schlagwort ggf. als „stimmt vielleicht nicht" markiert."""
 
     __tablename__ = "categorization_rules"
 
@@ -479,8 +491,13 @@ class CategorizationRule(Base):
     category_id: Mapped[int | None] = mapped_column(
         ForeignKey("categories.id", ondelete="CASCADE"), nullable=True
     )
+    source: Mapped[RuleSource] = mapped_column(_enum(RuleSource), nullable=False, default=RuleSource.learned)
     priority: Mapped[int] = mapped_column(Integer, nullable=False, default=0)
     hits: Mapped[int] = mapped_column(Integer, nullable=False, default=0)
+    applied_count: Mapped[int] = mapped_column(Integer, nullable=False, default=0)
+    overridden_count: Mapped[int] = mapped_column(Integer, nullable=False, default=0)
+    # „Behalten, nicht mehr fragen" – unterdrückt das Flaggen trotz Korrekturen.
+    confirmed: Mapped[bool] = mapped_column(Boolean, nullable=False, default=False)
     created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), default=_now)
 
     __table_args__ = (

backend/app/routers/categories.py

@@ -3,12 +3,12 @@
 Eine Kategorie erbt ihre Art (Einnahme/Ausgabe) von ihrer Gruppe.
 """
 
-from fastapi import APIRouter, Depends, status
+from fastapi import APIRouter, Depends, HTTPException, status
 from sqlalchemy.orm import Session
 
 from ..database import get_db
 from ..deps import get_current_user, get_owned
-from ..models import Category, CategoryGroup, User
+from ..models import CategorizationRule, Category, CategoryGroup, MatchField, RuleSource, User
 from ..schemas import (
     CategoryCreate,
     CategoryGroupCreate,
@@ -16,10 +16,20 @@ from ..schemas import (
     CategoryGroupUpdate,
     CategoryOut,
     CategoryUpdate,
+    FlaggedKeywordOut,
+    KeywordCreate,
+    KeywordOut,
+    KeywordUpdate,
 )
+from ..services.csv_import import normalize_text
 
 router = APIRouter(prefix="/categories", tags=["categories"])
 
+# Ab wann ein manuelles Schlagwort als „stimmt vielleicht nicht" markiert wird:
+# mindestens so viele Anwendungen UND mindestens dieser Anteil wegkorrigiert.
+FLAG_MIN_APPLIED = 5
+FLAG_RATIO_DEN = 3  # >= 1/3 (jede dritte)
+
 
 def group_out(g: CategoryGroup) -> CategoryGroupOut:
     cats = sorted(g.categories, key=lambda c: (c.position, c.name.lower()))
@@ -152,3 +162,152 @@ def delete_category(
     cat = get_owned(db, Category, category_id, user)
     db.delete(cat)
     db.commit()
+
+
+# --- Schlagwörter je Kategorie (manuelle Regeln, Feld = Empfänger ODER Zweck) ---
+
+
+def _keyword_out(rule: CategorizationRule) -> KeywordOut:
+    return KeywordOut(id=rule.id, category_id=rule.category_id, word=rule.pattern)
+
+
+def _owned_manual_rule(db: Session, rule_id: int, user: User) -> CategorizationRule:
+    rule = db.get(CategorizationRule, rule_id)
+    if rule is None or rule.owner_id != user.id or rule.source != RuleSource.manual:
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Nicht gefunden")
+    return rule
+
+
+@router.get("/keywords/flagged", response_model=list[FlaggedKeywordOut])
+def list_flagged_keywords(db: Session = Depends(get_db), user: User = Depends(get_current_user)):
+    """Manuelle Schlagwörter, die auffällig oft wegkorrigiert werden."""
+    rules = (
+        db.query(CategorizationRule)
+        .filter(
+            CategorizationRule.owner_id == user.id,
+            CategorizationRule.source == RuleSource.manual,
+            CategorizationRule.confirmed.is_(False),
+            CategorizationRule.applied_count >= FLAG_MIN_APPLIED,
+            CategorizationRule.overridden_count * FLAG_RATIO_DEN >= CategorizationRule.applied_count,
+        )
+        .order_by(CategorizationRule.overridden_count.desc())
+        .all()
+    )
+    names = {c.id: c.name for c in db.query(Category).filter(Category.owner_id == user.id)}
+    return [
+        FlaggedKeywordOut(
+            id=r.id, category_id=r.category_id, category_name=names.get(r.category_id, "?"),
+            word=r.pattern, applied_count=r.applied_count, overridden_count=r.overridden_count,
+        )
+        for r in rules
+    ]
+
+
+@router.post("/keywords/{rule_id}/confirm", status_code=status.HTTP_204_NO_CONTENT)
+def confirm_keyword(rule_id: int, db: Session = Depends(get_db), user: User = Depends(get_current_user)):
+    """„Behalten" – nicht mehr nachfragen, obwohl korrigiert wird."""
+    rule = _owned_manual_rule(db, rule_id, user)
+    rule.confirmed = True
+    db.commit()
+
+
+@router.patch("/keywords/{rule_id}", response_model=KeywordOut)
+def update_keyword(
+    rule_id: int,
+    payload: KeywordUpdate,
+    db: Session = Depends(get_db),
+    user: User = Depends(get_current_user),
+):
+    """Wort eines Schlagworts ändern (Inline-Bearbeitung im Popup). Da sich das
+    Muster ändert, werden die Korrektur-Zähler zurückgesetzt."""
+    rule = _owned_manual_rule(db, rule_id, user)
+    pattern = normalize_text(payload.word)[:255]
+    if not pattern:
+        raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail="Leeres Schlagwort")
+    if pattern != rule.pattern:
+        clash = (
+            db.query(CategorizationRule)
+            .filter(
+                CategorizationRule.owner_id == user.id,
+                CategorizationRule.match_field == MatchField.any,
+                CategorizationRule.pattern == pattern,
+                CategorizationRule.id != rule.id,
+            )
+            .first()
+        )
+        if clash is not None:
+            other = db.get(Category, clash.category_id)
+            other_name = other.name if other else "?"
+            raise HTTPException(
+                status_code=status.HTTP_409_CONFLICT,
+                detail=f"Schlagwort ist bereits der Kategorie „{other_name}“ zugeordnet.",
+            )
+        rule.pattern = pattern
+        rule.applied_count = 0
+        rule.overridden_count = 0
+        rule.confirmed = False
+    db.commit()
+    db.refresh(rule)
+    return _keyword_out(rule)
+
+
+@router.delete("/keywords/{rule_id}", status_code=status.HTTP_204_NO_CONTENT)
+def delete_keyword(rule_id: int, db: Session = Depends(get_db), user: User = Depends(get_current_user)):
+    rule = _owned_manual_rule(db, rule_id, user)
+    db.delete(rule)
+    db.commit()
+
+
+@router.get("/{category_id}/keywords", response_model=list[KeywordOut])
+def list_keywords(category_id: int, db: Session = Depends(get_db), user: User = Depends(get_current_user)):
+    cat = get_owned(db, Category, category_id, user)
+    rules = (
+        db.query(CategorizationRule)
+        .filter(
+            CategorizationRule.owner_id == user.id,
+            CategorizationRule.source == RuleSource.manual,
+            CategorizationRule.category_id == cat.id,
+        )
+        .order_by(CategorizationRule.pattern)
+        .all()
+    )
+    return [_keyword_out(r) for r in rules]
+
+
+@router.post("/{category_id}/keywords", response_model=KeywordOut, status_code=status.HTTP_201_CREATED)
+def add_keyword(
+    category_id: int,
+    payload: KeywordCreate,
+    db: Session = Depends(get_db),
+    user: User = Depends(get_current_user),
+):
+    cat = get_owned(db, Category, category_id, user)
+    pattern = normalize_text(payload.word)[:255]
+    if not pattern:
+        raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail="Leeres Schlagwort")
+    existing = (
+        db.query(CategorizationRule)
+        .filter(
+            CategorizationRule.owner_id == user.id,
+            CategorizationRule.match_field == MatchField.any,
+            CategorizationRule.pattern == pattern,
+        )
+        .first()
+    )
+    if existing is not None:
+        if existing.category_id == cat.id:
+            return _keyword_out(existing)  # schon vorhanden – unverändert zurück
+        other = db.get(Category, existing.category_id)
+        other_name = other.name if other else "?"
+        raise HTTPException(
+            status_code=status.HTTP_409_CONFLICT,
+            detail=f"Schlagwort ist bereits der Kategorie „{other_name}“ zugeordnet.",
+        )
+    rule = CategorizationRule(
+        owner_id=user.id, match_field=MatchField.any, pattern=pattern,
+        category_id=cat.id, source=RuleSource.manual, priority=10,
+    )
+    db.add(rule)
+    db.commit()
+    db.refresh(rule)
+    return _keyword_out(rule)

backend/app/schemas.py

@@ -345,3 +345,29 @@ class ImportCommitIn(BaseModel):
     template_id: int | None = None
     filename: str = ""
     rows: list[dict] = Field(default_factory=list)
+
+
+# --- Schlagwörter (manuelle Kategorisierungs-Regeln) -----------------------
+
+
+class KeywordCreate(BaseModel):
+    word: str = Field(min_length=1, max_length=255)
+
+
+class KeywordUpdate(BaseModel):
+    word: str = Field(min_length=1, max_length=255)
+
+
+class KeywordOut(BaseModel):
+    id: int
+    category_id: int
+    word: str
+
+
+class FlaggedKeywordOut(BaseModel):
+    id: int
+    category_id: int
+    category_name: str
+    word: str
+    applied_count: int
+    overridden_count: int

backend/app/services/csv_import.py

@@ -18,10 +18,12 @@ from ..models import (
     BudgetTreatment,
     CategorizationRule,
     Category,
+    CategoryKind,
     ImportBatch,
     ImportStatus,
     ImportTemplate,
     MatchField,
+    RuleSource,
     SAVINGS_ACCOUNT_TYPES,
     Transaction,
     TxnType,
@@ -143,14 +145,43 @@ def import_hash(account_id: int, d: date | None, amount_cents: int | None, payee
 # --- Vorschau --------------------------------------------------------------
 
 
-def _apply_rules(rules: list[CategorizationRule], payee: str, purpose: str) -> int | None:
+def _rule_sort_key(rule: CategorizationRule) -> tuple:
+    """Reihenfolge der Regelanwendung: längstes Schlagwort zuerst, dann manuelle
+    vor gelernten, dann höhere Priorität/mehr Treffer."""
+    return (
+        len(rule.pattern or ""),
+        1 if rule.source == RuleSource.manual else 0,
+        rule.priority,
+        rule.hits,
+    )
+
+
+def _apply_rules(
+    rules: list[CategorizationRule],
+    payee: str,
+    purpose: str,
+    allowed_kind: CategoryKind | None,
+    cat_kind: dict[int, CategoryKind],
+) -> tuple[int | None, int | None]:
+    """Erste passende Regel -> (category_id, rule_id). Nur Kategorien, deren Art
+    (Einnahme/Ausgabe) zur Buchung passt, damit ein Ausgabe-Schlagwort keine
+    Einnahme falsch einordnet."""
     p = normalize_text(payee)
     z = normalize_text(purpose)
-    for rule in rules:  # bereits nach Priorität sortiert
+    for rule in rules:  # bereits sortiert (längstes/​manuell zuerst)
-        hay = p if rule.match_field == MatchField.payee else z
+        if not rule.pattern or not rule.category_id:
-        if rule.pattern and rule.pattern in hay and rule.category_id:
+            continue
-            return rule.category_id
+        if allowed_kind is not None and cat_kind.get(rule.category_id) != allowed_kind:
-    return None
+            continue
+        if rule.match_field == MatchField.payee:
+            hit = rule.pattern in p
+        elif rule.match_field == MatchField.purpose:
+            hit = rule.pattern in z
+        else:  # any: Empfänger ODER Zweck
+            hit = rule.pattern in p or rule.pattern in z
+        if hit:
+            return rule.category_id, rule.id
+    return None, None
 
 
 def parse_file_to_candidates(data: bytes, template: ImportTemplate) -> list[dict]:
@@ -200,12 +231,12 @@ def detect_rows(db: Session, user: User, account: Account, candidates: list[dict
     ):
         idents[value_norm] = acc_id
 
-    rules = (
+    rules = db.query(CategorizationRule).filter(CategorizationRule.owner_id == user.id).all()
-        db.query(CategorizationRule)
+    rules.sort(key=_rule_sort_key, reverse=True)  # längstes/​manuell zuerst
-        .filter(CategorizationRule.owner_id == user.id)
+    cat_kind: dict[int, CategoryKind] = {
-        .order_by(CategorizationRule.priority.desc(), CategorizationRule.hits.desc())
+        cid: kind
-        .all()
+        for cid, kind in db.query(Category.id, Category.type).filter(Category.owner_id == user.id)
-    )
+    }
     existing = {
         h[0]
         for h in db.query(Transaction.import_hash).filter(
@@ -226,6 +257,7 @@ def detect_rows(db: Session, user: User, account: Account, candidates: list[dict
         valid = d is not None and amount is not None and amount != 0
         ttype = "expense" if (amount or 0) < 0 else "income"
         category_id: int | None = None
+        matched_rule_id: int | None = None
         to_account_id: int | None = None
 
         other = idents.get(iban) if iban else None
@@ -233,7 +265,10 @@ def detect_rows(db: Session, user: User, account: Account, candidates: list[dict
             ttype = "transfer"
             to_account_id = other
         else:
-            category_id = _apply_rules(rules, payee or "", purpose or "")
+            kind = CategoryKind.expense if ttype == "expense" else CategoryKind.income
+            category_id, matched_rule_id = _apply_rules(
+                rules, payee or "", purpose or "", kind, cat_kind
+            )
 
         h = import_hash(account.id, d, amount, payee)
         is_dup = h in existing or h in seen
@@ -249,6 +284,7 @@ def detect_rows(db: Session, user: User, account: Account, candidates: list[dict
             "valid": valid,
             "type": ttype,
             "category_id": category_id,
+            "matched_rule_id": matched_rule_id,
             "to_account_id": to_account_id,
             "import_hash": h,
             "is_duplicate": is_dup,
@@ -347,13 +383,34 @@ def _learn_rule(db: Session, user: User, row: dict) -> None:
     if existing is None:
         db.add(CategorizationRule(
             owner_id=user.id, match_field=MatchField.payee, pattern=pattern,
-            category_id=cat, priority=1, hits=1,
+            category_id=cat, source=RuleSource.learned, priority=1, hits=1,
         ))
+        # Sichtbar machen (Session ist autoflush=False), damit dasselbe Muster ein
+        # zweites Mal im selben Import die vorhandene Regel findet statt zu doppeln.
+        db.flush()
     else:
         existing.category_id = cat
         existing.hits += 1
 
 
+def _track_and_learn(db: Session, user: User, row: dict) -> None:
+    """Zählt für die zutreffende Regel Anwendung/Korrektur (Basis fürs Flaggen von
+    Schlagwörtern) und lernt anschließend Empfänger -> Kategorie weiter."""
+    rid = row.get("matched_rule_id")
+    final_cat = row.get("category_id")
+    matched_manual_kept = False
+    if rid:
+        rule = db.get(CategorizationRule, rid)
+        if rule is not None and rule.owner_id == user.id:
+            rule.applied_count = (rule.applied_count or 0) + 1
+            if final_cat != rule.category_id:
+                rule.overridden_count = (rule.overridden_count or 0) + 1
+            elif rule.source == RuleSource.manual:
+                matched_manual_kept = True  # Schlagwort greift schon – nicht doppelt lernen
+    if not matched_manual_kept:
+        _learn_rule(db, user, row)
+
+
 def commit_import(db: Session, user: User, account: Account, template_id: int | None, filename: str, rows: list[dict]) -> ImportBatch:
     accounts = {a.id: a for a in db.query(Account).filter(Account.owner_id == user.id)}
     batch = ImportBatch(
@@ -372,7 +429,7 @@ def commit_import(db: Session, user: User, account: Account, template_id: int |
         if txn is None:
             continue
         db.add(txn)
-        _learn_rule(db, user, row)
+        _track_and_learn(db, user, row)
         imported += 1
 
     batch.imported_count = imported

backend/migrations/versions/0006_keyword_rules.py

@@ -0,0 +1,32 @@
+"""Schlagwörter/Regeln erweitern: Quelle + Korrektur-Zähler + „behalten".
+
+Manuelle Schlagwörter je Kategorie und die lernende Korrektur-Erkennung nutzen
+dieselbe Tabelle ``categorization_rules`` wie die automatisch gelernten Regeln.
+
+Revision ID: 0006
+Revises: 0005
+Create Date: 2026-08-19
+"""
+from alembic import op
+import sqlalchemy as sa
+
+revision = "0006"
+down_revision = "0005"
+branch_labels = None
+depends_on = None
+
+
+def upgrade() -> None:
+    with op.batch_alter_table("categorization_rules") as batch:
+        batch.add_column(sa.Column("source", sa.String(length=32), nullable=False, server_default="learned"))
+        batch.add_column(sa.Column("applied_count", sa.Integer(), nullable=False, server_default=sa.text("0")))
+        batch.add_column(sa.Column("overridden_count", sa.Integer(), nullable=False, server_default=sa.text("0")))
+        batch.add_column(sa.Column("confirmed", sa.Boolean(), nullable=False, server_default=sa.text("0")))
+
+
+def downgrade() -> None:
+    with op.batch_alter_table("categorization_rules") as batch:
+        batch.drop_column("confirmed")
+        batch.drop_column("overridden_count")
+        batch.drop_column("applied_count")
+        batch.drop_column("source")

backend/tests/test_keywords.py

@@ -0,0 +1,162 @@
+"""Schlagwörter je Kategorie: Anlegen/Konflikt, Treffer (Empfänger ODER Zweck),
+längstes gewinnt, Kind-Filter, Korrektur-Erkennung/Flagging, keine Rückwirkung."""
+
+import io
+import json
+
+
+def _account(admin, **kw):
+    body = {"name": "Giro", "type": "girokonto", "currency": "EUR", "opening_balance_cents": 0}
+    body.update(kw)
+    r = admin.post("/api/accounts", json=body)
+    assert r.status_code == 201, r.text
+    return r.json()
+
+
+def _expense_cats(admin, n=2):
+    out = []
+    for g in admin.get("/api/categories").json():
+        if g["kind"] == "expense":
+            out += g["categories"]
+    assert len(out) >= n, "zu wenige Ausgabe-Kategorien im Seed"
+    return out[:n]
+
+
+def _income_cat(admin):
+    for g in admin.get("/api/categories").json():
+        if g["kind"] == "income" and g["categories"]:
+            return g["categories"][0]
+    raise AssertionError("keine Einnahme-Kategorie im Seed")
+
+
+def _preview_csv(admin, account_id, csv, colmap):
+    r = admin.post(
+        "/api/imports/preview",
+        files={"file": ("k.csv", io.BytesIO(csv.encode("utf-8")), "text/csv")},
+        data={
+            "account_id": str(account_id), "delimiter": ";", "decimal_sep": ",",
+            "date_format": "%d.%m.%Y", "encoding": "utf-8", "has_header": "true",
+            "skip_rows": "0", "amount_mode": "signed", "column_map": colmap,
+        },
+    )
+    assert r.status_code == 200, r.text
+    return r.json()["rows"]
+
+
+COLMAP = json.dumps({"date": 0, "amount": 1, "payee": 2, "purpose": 3})
+
+
+def test_keyword_crud_and_conflict(admin):
+    a, b = _expense_cats(admin, 2)
+    r = admin.post(f"/api/categories/{a['id']}/keywords", json={"word": "  REWE  "})
+    assert r.status_code == 201, r.text
+    assert r.json()["word"] == "rewe"  # getrimmt + kleingeschrieben
+    kid = r.json()["id"]
+
+    assert [k["word"] for k in admin.get(f"/api/categories/{a['id']}/keywords").json()] == ["rewe"]
+
+    # Gleiches Wort, gleiche Kategorie -> idempotent, keine Dublette.
+    assert admin.post(f"/api/categories/{a['id']}/keywords", json={"word": "rewe"}).status_code == 201
+    assert len(admin.get(f"/api/categories/{a['id']}/keywords").json()) == 1
+
+    # Gleiches Wort, andere Kategorie -> Konflikt.
+    assert admin.post(f"/api/categories/{b['id']}/keywords", json={"word": "rewe"}).status_code == 409
+
+    assert admin.delete(f"/api/categories/keywords/{kid}").status_code == 204
+    assert admin.get(f"/api/categories/{a['id']}/keywords").json() == []
+
+
+def test_matching_payee_purpose_and_kind_filter(admin):
+    giro = _account(admin, name="Giro KW")
+    a, _ = _expense_cats(admin, 2)
+    admin.post(f"/api/categories/{a['id']}/keywords", json={"word": "netflix"})
+
+    csv = (
+        "Datum;Betrag;Empfaenger;Zweck\n"
+        "01.03.2026;-9,99;NETFLIX;Abo\n"                    # Empfänger-Treffer
+        "02.03.2026;-9,99;Kartenzahlung;NETFLIX Monatsabo\n"  # Zweck-Treffer (any)
+        "03.03.2026;9,99;NETFLIX;Erstattung\n"             # Einnahme -> darf NICHT greifen
+    )
+    rows = _preview_csv(admin, giro["id"], csv, COLMAP)
+    assert rows[0]["category_id"] == a["id"]
+    assert rows[0]["matched_rule_id"] is not None
+    assert rows[1]["category_id"] == a["id"]      # über den Zweck getroffen
+    assert rows[2]["category_id"] is None          # Ausgabe-Schlagwort, Einnahme -> gefiltert
+
+
+def test_longest_keyword_wins(admin):
+    giro = _account(admin, name="Giro LW")
+    a, b = _expense_cats(admin, 2)
+    admin.post(f"/api/categories/{a['id']}/keywords", json={"word": "rewe"})
+    admin.post(f"/api/categories/{b['id']}/keywords", json={"word": "rewe getraenke"})
+
+    csv = "Datum;Betrag;Empfaenger;Zweck\n01.03.2026;-20,00;REWE Getraenke Markt;Wasser\n"
+    rows = _preview_csv(admin, giro["id"], csv, COLMAP)
+    assert rows[0]["category_id"] == b["id"]  # spezifischeres (längeres) Schlagwort gewinnt
+
+
+def test_correction_flagging_confirm(admin):
+    giro = _account(admin, name="Giro Flag")
+    a, b = _expense_cats(admin, 2)
+    kw = admin.post(f"/api/categories/{a['id']}/keywords", json={"word": "spotify"}).json()
+
+    lines = "".join(f"0{i}.03.2026;-9,99;SPOTIFY;Abo\n" for i in range(1, 7))  # 6 Zeilen
+    rows = _preview_csv(admin, giro["id"], "Datum;Betrag;Empfaenger;Zweck\n" + lines, COLMAP)
+    assert len(rows) == 6 and all(r["category_id"] == a["id"] for r in rows)
+
+    for r in rows[:2]:  # zwei wegkorrigieren
+        r["category_id"] = b["id"]
+    res = admin.post("/api/imports/commit", json={"account_id": giro["id"], "filename": "s.csv", "rows": rows})
+    assert res.status_code == 200, res.text
+
+    flagged = admin.get("/api/categories/keywords/flagged").json()
+    hit = next((f for f in flagged if f["id"] == kw["id"]), None)
+    assert hit is not None, flagged
+    assert hit["applied_count"] == 6 and hit["overridden_count"] == 2
+
+    # „Behalten" unterdrückt die Meldung künftig.
+    assert admin.post(f"/api/categories/keywords/{kw['id']}/confirm").status_code == 204
+    assert kw["id"] not in [f["id"] for f in admin.get("/api/categories/keywords/flagged").json()]
+
+
+def test_keyword_update_and_conflict(admin):
+    a, b = _expense_cats(admin, 2)
+    kw = admin.post(f"/api/categories/{a['id']}/keywords", json={"word": "lidil"}).json()
+
+    r = admin.patch(f"/api/categories/keywords/{kw['id']}", json={"word": "  LIDL  "})
+    assert r.status_code == 200, r.text
+    assert r.json()["word"] == "lidl"  # getrimmt + kleingeschrieben
+    words = admin.get(f"/api/categories/{a['id']}/keywords").json()
+    assert next(k for k in words if k["id"] == kw["id"])["word"] == "lidl"
+    assert "lidil" not in [k["word"] for k in words]  # altes Wort ist weg
+
+    # Umbenennen auf ein Wort, das schon einer anderen Kategorie gehört -> Konflikt.
+    admin.post(f"/api/categories/{b['id']}/keywords", json={"word": "coop"})
+    assert admin.patch(f"/api/categories/keywords/{kw['id']}", json={"word": "coop"}).status_code == 409
+
+
+def test_below_threshold_not_flagged(admin):
+    giro = _account(admin, name="Giro NoFlag")
+    a, b = _expense_cats(admin, 2)
+    kw = admin.post(f"/api/categories/{a['id']}/keywords", json={"word": "denner"}).json()
+
+    lines = "".join(f"0{i}.03.2026;-4,00;DENNER;Einkauf\n" for i in range(1, 7))  # 6 Zeilen
+    rows = _preview_csv(admin, giro["id"], "Datum;Betrag;Empfaenger;Zweck\n" + lines, COLMAP)
+    rows[0]["category_id"] = b["id"]  # nur 1 von 6 korrigiert (< 1/3)
+    admin.post("/api/imports/commit", json={"account_id": giro["id"], "filename": "d.csv", "rows": rows})
+
+    assert kw["id"] not in [f["id"] for f in admin.get("/api/categories/keywords/flagged").json()]
+
+
+def test_no_retroactive_apply(admin):
+    giro = _account(admin, name="Giro Retro")
+    a, _ = _expense_cats(admin, 2)
+    rows = _preview_csv(admin, giro["id"], "Datum;Betrag;Empfaenger;Zweck\n01.03.2026;-5,00;ALDI;Einkauf\n", COLMAP)
+    assert rows[0]["category_id"] is None
+    admin.post("/api/imports/commit", json={"account_id": giro["id"], "filename": "aldi.csv", "rows": rows})
+
+    admin.post(f"/api/categories/{a['id']}/keywords", json={"word": "aldi"})  # erst danach angelegt
+
+    txns = admin.get("/api/transactions").json()
+    aldi = [t for t in txns if (t.get("payee") or "").upper() == "ALDI"]
+    assert aldi and aldi[0]["category_id"] is None  # bestehende Buchung bleibt unkategorisiert

docs/ROADMAP.md

@@ -35,3 +35,11 @@ Zeilen-Parser (Datum + Betrag), speist dieselbe Prüfansicht. Best-Effort.
 ## Querschnitt – Backup/Export  ✅
 DB-Backup-Download (Admin) + Export je Entität (CSV/JSON); dokumentierte
 LXC-Sicherung (docs/BACKUP.md).
+
+## Querschnitt – Schlagwörter & Kategorie-Auswahl  ✅
+Manuelle Schlagwörter je Kategorie (Popup, Doppelklick zum Bearbeiten); Treffer
+über Empfänger ODER Verwendungszweck, längstes Schlagwort gewinnt, nur bei
+künftigen Importen. Korrektur-Erkennung: ab 5 Anwendungen und ≥ 1/3 Korrekturen
+Prüf-Meldung in den Einstellungen (Behalten/Entfernen). Auf-/zuklappbares
+Kategorie-Dropdown mit Suche (ersetzt das native optgroup-Select) in Buchungen
+und Import-Prüfansicht.

web/src/api.js

@@ -141,6 +141,14 @@ export const api = {
   updateCategory: (id, body) => request(`/categories/${id}`, { method: "PATCH", body }),
   deleteCategory: (id) => request(`/categories/${id}`, { method: "DELETE" }),
 
+  // Schlagwörter je Kategorie (manuelle Auto-Zuordnung) + Prüfmeldungen
+  listKeywords: (categoryId) => request(`/categories/${categoryId}/keywords`),
+  addKeyword: (categoryId, word) => request(`/categories/${categoryId}/keywords`, { method: "POST", body: { word } }),
+  updateKeyword: (ruleId, word) => request(`/categories/keywords/${ruleId}`, { method: "PATCH", body: { word } }),
+  deleteKeyword: (ruleId) => request(`/categories/keywords/${ruleId}`, { method: "DELETE" }),
+  flaggedKeywords: () => request("/categories/keywords/flagged"),
+  confirmKeyword: (ruleId) => request(`/categories/keywords/${ruleId}/confirm`, { method: "POST" }),
+
   // Transaktionen
   listTransactions: (params = {}) => {
     const qs = new URLSearchParams();

web/src/components/CategorySelect.jsx

@@ -0,0 +1,198 @@
+import { useEffect, useMemo, useRef, useState } from "react";
+import { createPortal } from "react-dom";
+import { useTranslation } from "react-i18next";
+import Icon from "./Icon";
+import IconChip from "./IconChip";
+
+// Auf-/zuklappbares Kategorie-Dropdown (Gruppe -> Kategorien als Baum) mit
+// Suchfeld. Ersetzt das native <select> mit optgroup, das die oberste Gruppe
+// abgesetzt wirken ließ. Das Panel wird per Portal mit fester Position gerendert,
+// damit es in scrollbaren Tabellen (Import-Prüfansicht) nicht abgeschnitten wird.
+export default function CategorySelect({
+  groups = [],
+  value,
+  onChange,
+  allowNone = false,
+  noneLabel = "—",
+  placeholder = "—",
+  minWidth = 0,
+  disabled = false,
+}) {
+  const { t } = useTranslation();
+  const selectedId = value === "" || value == null ? null : Number(value);
+
+  const [open, setOpen] = useState(false);
+  const [q, setQ] = useState("");
+  const [collapsed, setCollapsed] = useState(() => new Set());
+  const [pos, setPos] = useState(null);
+
+  const btnRef = useRef(null);
+  const panelRef = useRef(null);
+  const searchRef = useRef(null);
+
+  const byId = useMemo(() => {
+    const m = {};
+    for (const g of groups) for (const c of g.categories) m[c.id] = c;
+    return m;
+  }, [groups]);
+  const sel = selectedId != null ? byId[selectedId] : null;
+
+  function computePos() {
+    const el = btnRef.current;
+    if (!el) return;
+    const r = el.getBoundingClientRect();
+    const width = Math.max(r.width, 260);
+    const spaceBelow = window.innerHeight - r.bottom;
+    const spaceAbove = r.top;
+    const desired = 340;
+    let top;
+    let maxHeight;
+    if (spaceBelow >= 220 || spaceBelow >= spaceAbove) {
+      maxHeight = Math.min(desired, spaceBelow - 10);
+      top = r.bottom + 4;
+    } else {
+      maxHeight = Math.min(desired, spaceAbove - 10);
+      top = r.top - 4 - maxHeight;
+    }
+    let left = r.left;
+    if (left + width > window.innerWidth - 8) left = window.innerWidth - 8 - width;
+    if (left < 8) left = 8;
+    setPos({ left, top, width, maxHeight });
+  }
+
+  function openPanel() {
+    if (disabled) return;
+    computePos();
+    setQ("");
+    setOpen(true);
+  }
+
+  useEffect(() => {
+    if (!open) return undefined;
+    searchRef.current?.focus();
+    const onDown = (e) => {
+      if (panelRef.current?.contains(e.target) || btnRef.current?.contains(e.target)) return;
+      setOpen(false);
+    };
+    const onKey = (e) => e.key === "Escape" && setOpen(false);
+    const onScrollResize = () => setOpen(false);
+    document.addEventListener("mousedown", onDown);
+    document.addEventListener("keydown", onKey);
+    // capture=true: fängt auch das Scrollen innerhalb der Tabelle ab.
+    window.addEventListener("scroll", onScrollResize, true);
+    window.addEventListener("resize", onScrollResize);
+    return () => {
+      document.removeEventListener("mousedown", onDown);
+      document.removeEventListener("keydown", onKey);
+      window.removeEventListener("scroll", onScrollResize, true);
+      window.removeEventListener("resize", onScrollResize);
+    };
+  }, [open]);
+
+  function choose(id) {
+    onChange(id);
+    setOpen(false);
+  }
+  function toggleGroup(id) {
+    setCollapsed((prev) => {
+      const next = new Set(prev);
+      next.has(id) ? next.delete(id) : next.add(id);
+      return next;
+    });
+  }
+
+  const ql = q.trim().toLowerCase();
+
+  return (
+    <div className="catsel" style={{ minWidth }}>
+      <button
+        type="button"
+        ref={btnRef}
+        className={`catsel-btn${open ? " open" : ""}`}
+        onClick={() => (open ? setOpen(false) : openPanel())}
+        disabled={disabled}
+      >
+        {sel ? (
+          <span className="catsel-value">
+            <IconChip name={sel.icon} color={sel.color} size={22} />
+            <span className="ellipsis">{sel.name}</span>
+          </span>
+        ) : (
+          <span className="catsel-value muted ellipsis">{placeholder}</span>
+        )}
+        <Icon name="chevron-down" size={15} className="catsel-caret" />
+      </button>
+
+      {open &&
+        pos &&
+        createPortal(
+          <div
+            ref={panelRef}
+            className="catsel-panel"
+            style={{ left: pos.left, top: pos.top, width: pos.width, maxHeight: pos.maxHeight }}
+          >
+            <div className="catsel-search">
+              <Icon name="search" size={14} />
+              <input
+                ref={searchRef}
+                value={q}
+                onChange={(e) => setQ(e.target.value)}
+                placeholder={t("categories.searchPlaceholder")}
+              />
+            </div>
+            <div className="catsel-list">
+              {allowNone && (
+                <button
+                  type="button"
+                  className={`catsel-opt${selectedId == null ? " selected" : ""}`}
+                  onClick={() => choose(null)}
+                >
+                  <span className="muted ellipsis">{noneLabel}</span>
+                  {selectedId == null && <Icon name="check" size={15} className="catsel-check" />}
+                </button>
+              )}
+              {groups.map((g) => {
+                const cats = ql
+                  ? g.categories.filter((c) => c.name.toLowerCase().includes(ql))
+                  : g.categories;
+                if (ql && cats.length === 0) return null;
+                const isCollapsed = !ql && collapsed.has(g.id);
+                return (
+                  <div className="catsel-group" key={g.id}>
+                    <button
+                      type="button"
+                      className="catsel-group-head"
+                      onClick={() => toggleGroup(g.id)}
+                    >
+                      <Icon
+                        name="chevron-down"
+                        size={14}
+                        className={`catsel-gchev${isCollapsed ? " collapsed" : ""}`}
+                      />
+                      <IconChip name={g.icon} color={g.color} size={18} />
+                      <span className="ellipsis">{g.name}</span>
+                    </button>
+                    {!isCollapsed &&
+                      cats.map((c) => (
+                        <button
+                          type="button"
+                          key={c.id}
+                          className={`catsel-opt${selectedId === c.id ? " selected" : ""}`}
+                          onClick={() => choose(c.id)}
+                        >
+                          <IconChip name={c.icon} color={c.color} size={20} />
+                          <span className="ellipsis">{c.name}</span>
+                          {selectedId === c.id && <Icon name="check" size={15} className="catsel-check" />}
+                        </button>
+                      ))}
+                  </div>
+                );
+              })}
+              {groups.length === 0 && <div className="catsel-empty muted small">{t("categories.emptyGroup")}</div>}
+            </div>
+          </div>,
+          document.body
+        )}
+    </div>
+  );
+}

web/src/components/Icon.jsx

@@ -71,6 +71,14 @@ const PATHS = {
     </>
   ),
   "chevron-right": <path d="m9 18 6-6-6-6" />,
+  "chevron-down": <path d="m6 9 6 6 6-6" />,
+  tags: (
+    <>
+      <path d="M9 5H2v7l6.29 6.29c.94.94 2.48.94 3.42 0l3.58-3.58c.94-.94.94-2.48 0-3.42L9 5Z" />
+      <path d="M6 9.01V9" />
+      <path d="m15 5 6.3 6.3a2.4 2.4 0 0 1 0 3.4L17 19" />
+    </>
+  ),
   "refresh-ccw": (
     <>
       <path d="M21 12a9 9 0 0 0-9-9 9.75 9.75 0 0 0-6.74 2.74L3 8" />

web/src/finance.css

@@ -571,3 +571,219 @@ tr.row-dup {
   border-radius: var(--radius-sm);
   margin-top: var(--sp-2);
 }
+
+/* ---------- Kategorie-Auswahl (auf-/zuklappbarer Baum, Ersatz für <select>) ---------- */
+.catsel {
+  width: 100%;
+}
+.catsel-btn {
+  width: 100%;
+  margin-top: 5px;
+  display: flex;
+  align-items: center;
+  gap: var(--sp-2);
+  padding: 7px 10px;
+  border: 1px solid var(--border-strong);
+  border-radius: var(--radius-sm);
+  background: var(--surface);
+  color: var(--text);
+  font: inherit;
+  text-align: left;
+  cursor: pointer;
+  transition: border-color .12s, box-shadow .12s;
+}
+.catsel-btn:hover:not(:disabled) {
+  border-color: var(--accent);
+}
+.catsel-btn:disabled {
+  opacity: 0.6;
+  cursor: default;
+}
+.catsel-btn.open {
+  border-color: var(--accent);
+  box-shadow: 0 0 0 3px var(--accent-soft);
+}
+.catsel-value {
+  flex: 1 1 auto;
+  min-width: 0;
+  display: flex;
+  align-items: center;
+  gap: var(--sp-2);
+}
+.catsel-caret {
+  flex: 0 0 auto;
+  color: var(--muted);
+}
+
+.catsel-panel {
+  position: fixed;
+  z-index: 1000;
+  display: flex;
+  flex-direction: column;
+  background: var(--surface);
+  border: 1px solid var(--border-strong);
+  border-radius: var(--radius);
+  box-shadow: 0 8px 24px rgba(0, 0, 0, 0.18);
+  overflow: hidden;
+}
+.catsel-search {
+  display: flex;
+  align-items: center;
+  gap: var(--sp-2);
+  padding: 8px 10px;
+  border-bottom: 1px solid var(--border);
+  color: var(--muted);
+  flex: 0 0 auto;
+}
+.catsel-search input {
+  width: 100%;
+  border: none;
+  background: none;
+  outline: none;
+  margin: 0;
+  padding: 0;
+  color: var(--text);
+  font: inherit;
+}
+.catsel-list {
+  overflow-y: auto;
+  padding: 5px;
+}
+.catsel-group + .catsel-group {
+  margin-top: 2px;
+}
+.catsel-group-head {
+  display: flex;
+  align-items: center;
+  gap: 6px;
+  width: 100%;
+  padding: 6px;
+  border: none;
+  background: none;
+  cursor: pointer;
+  color: var(--muted);
+  font-weight: 650;
+  font-size: 0.72rem;
+  text-transform: uppercase;
+  letter-spacing: 0.03em;
+}
+.catsel-group-head:hover {
+  color: var(--text);
+}
+.catsel-gchev {
+  flex: 0 0 auto;
+  transition: transform .12s ease;
+}
+.catsel-gchev.collapsed {
+  transform: rotate(-90deg);
+}
+.catsel-opt {
+  display: flex;
+  align-items: center;
+  gap: var(--sp-2);
+  width: 100%;
+  padding: 6px 8px 6px 22px;
+  border: none;
+  border-radius: var(--radius-sm);
+  background: none;
+  color: var(--text);
+  font: inherit;
+  text-align: left;
+  cursor: pointer;
+}
+.catsel-opt:hover {
+  background: var(--surface-2);
+}
+.catsel-opt.selected {
+  background: var(--accent-soft);
+  color: var(--accent);
+  font-weight: 600;
+}
+.catsel-check {
+  margin-left: auto;
+  flex: 0 0 auto;
+  color: var(--accent);
+}
+.catsel-empty {
+  padding: 10px;
+}
+
+/* ---------- Schlagwörter (Kategorie-Popup + Prüfmeldungen) ---------- */
+.kw-add {
+  display: flex;
+  gap: var(--sp-2);
+  margin-bottom: var(--sp-3);
+}
+.kw-add input {
+  flex: 1 1 auto;
+  min-width: 0;
+  margin-top: 0;
+}
+.kw-chips {
+  display: flex;
+  flex-wrap: wrap;
+  gap: var(--sp-2);
+}
+.kw-chip {
+  display: inline-flex;
+  align-items: center;
+  gap: 6px;
+  padding: 4px 6px 4px 11px;
+  border-radius: 20px;
+  background: var(--surface-2);
+  border: 1px solid var(--border);
+  font-size: 0.85rem;
+}
+.kw-chip button {
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  width: 18px;
+  height: 18px;
+  padding: 0;
+  margin: 0;
+  border: none;
+  border-radius: 50%;
+  background: none;
+  color: var(--muted);
+  cursor: pointer;
+}
+.kw-chip button:hover {
+  background: var(--danger);
+  color: #fff;
+}
+.kw-chip.editing {
+  padding: 2px 6px;
+  border-color: var(--accent);
+  box-shadow: 0 0 0 2px var(--accent-soft);
+}
+.kw-chip.editing input {
+  width: 12ch;
+  min-width: 70px;
+  margin: 0;
+  padding: 2px 2px;
+  border: none;
+  background: none;
+  outline: none;
+  font: inherit;
+  font-size: 0.85rem;
+  color: var(--text);
+}
+
+.kw-flag {
+  display: flex;
+  align-items: center;
+  gap: var(--sp-3);
+  padding: var(--sp-3) 0;
+  border-bottom: 1px solid var(--border);
+}
+.kw-flag:last-child {
+  border-bottom: none;
+}
+.kw-flag-main {
+  flex: 1;
+  min-width: 0;
+}
+.kw-flag-word {
+  font-weight: 600;
+}

web/src/locales/de.json

@@ -79,7 +79,12 @@
     "exportTxnJson": "Buchungen (JSON)",
     "exportAll": "Alle Daten (JSON)",
     "dbBackup": "Komplettes DB-Backup herunterladen",
-    "dbBackupHint": "Vollständige Datenbank aller Nutzer (nur Admin) – zum Wiederherstellen sichern."
+    "dbBackupHint": "Vollständige Datenbank aller Nutzer (nur Admin) – zum Wiederherstellen sichern.",
+    "keywordReview": "Schlagwörter prüfen",
+    "keywordReviewHint": "Diese Schlagwörter werden auffällig oft wieder wegkorrigiert – stimmen sie vielleicht nicht mehr?",
+    "keywordCorrected": "{{overridden}} von {{applied}} Buchungen korrigiert",
+    "keep": "Behalten",
+    "remove": "Entfernen"
   },
   "dashboard": {
     "title": "Übersicht",
@@ -153,7 +158,14 @@
     "expense": "Ausgabe",
     "emptyGroup": "Keine Kategorien in dieser Gruppe.",
     "deleteConfirm": "Diese Kategorie löschen?",
-    "deleteGroupConfirm": "Diese Gruppe samt aller Kategorien löschen?"
+    "deleteGroupConfirm": "Diese Gruppe samt aller Kategorien löschen?",
+    "keywordsBtn": "Schlagwörter",
+    "keywordsTitle": "Schlagwörter – {{name}}",
+    "keywordsHint": "Buchungen, die eines dieser Wörter im Empfänger oder Verwendungszweck enthalten, werden bei künftigen Importen automatisch dieser Kategorie zugeordnet.",
+    "keywordAdd": "Wort eingeben und Enter",
+    "keywordEmpty": "Noch keine Schlagwörter.",
+    "keywordEditHint": "Doppelklick auf ein Schlagwort, um es zu bearbeiten.",
+    "searchPlaceholder": "Kategorie suchen …"
   },
   "transactions": {
     "title": "Buchungen",

web/src/locales/en.json

@@ -79,7 +79,12 @@
     "exportTxnJson": "Transactions (JSON)",
     "exportAll": "All data (JSON)",
     "dbBackup": "Download full DB backup",
-    "dbBackupHint": "Complete database of all users (admin only) — keep it for restore."
+    "dbBackupHint": "Complete database of all users (admin only) — keep it for restore.",
+    "keywordReview": "Review keywords",
+    "keywordReviewHint": "These keywords keep getting corrected away — maybe they no longer fit?",
+    "keywordCorrected": "{{overridden}} of {{applied}} transactions corrected",
+    "keep": "Keep",
+    "remove": "Remove"
   },
   "dashboard": {
     "title": "Overview",
@@ -153,7 +158,14 @@
     "expense": "Expense",
     "emptyGroup": "No categories in this group.",
     "deleteConfirm": "Delete this category?",
-    "deleteGroupConfirm": "Delete this group and all its categories?"
+    "deleteGroupConfirm": "Delete this group and all its categories?",
+    "keywordsBtn": "Keywords",
+    "keywordsTitle": "Keywords – {{name}}",
+    "keywordsHint": "Transactions whose payee or description contains one of these words are automatically assigned to this category on future imports.",
+    "keywordAdd": "Type a word and press Enter",
+    "keywordEmpty": "No keywords yet.",
+    "keywordEditHint": "Double-click a keyword to edit it.",
+    "searchPlaceholder": "Search category …"
   },
   "transactions": {
     "title": "Transactions",

web/src/pages/Categories.jsx

@@ -8,12 +8,141 @@ import IconChip from "../components/IconChip";
 import Modal from "../components/Modal";
 import IconPicker, { CATEGORY_ICONS } from "../components/IconPicker";
 
+// Popup zum Pflegen der Schlagwörter einer Kategorie. Wörter werden beim Import
+// gegen Empfänger/Verwendungszweck geprüft und ordnen Buchungen automatisch zu.
+function KeywordModal({ category, onClose }) {
+  const { t } = useTranslation();
+  const toast = useToast();
+  const [words, setWords] = useState([]);
+  const [input, setInput] = useState("");
+  const [busy, setBusy] = useState(false);
+  const [editId, setEditId] = useState(null);
+  const [editVal, setEditVal] = useState("");
+
+  async function laden() {
+    try { setWords(await api.listKeywords(category.id)); }
+    catch (err) { toast(err.message, "error"); }
+  }
+  useEffect(() => { laden(); }, [category.id]);
+
+  async function hinzufuegen() {
+    const w = input.trim();
+    if (!w) return;
+    setBusy(true);
+    try {
+      await api.addKeyword(category.id, w);
+      setInput("");
+      await laden();
+    } catch (err) {
+      toast(err.message, "error");
+    } finally {
+      setBusy(false);
+    }
+  }
+  async function entfernen(id) {
+    try {
+      await api.deleteKeyword(id);
+      setWords((ws) => ws.filter((x) => x.id !== id));
+    } catch (err) {
+      toast(err.message, "error");
+    }
+  }
+
+  function starteBearbeiten(w) {
+    setEditId(w.id);
+    setEditVal(w.word);
+  }
+  function abbrechenBearbeiten() {
+    setEditId(null);
+    setEditVal("");
+  }
+  async function speichernBearbeiten(id) {
+    const val = editVal.trim();
+    const orig = words.find((x) => x.id === id);
+    if (!val || (orig && val === orig.word)) { abbrechenBearbeiten(); return; }
+    try {
+      await api.updateKeyword(id, val);
+      abbrechenBearbeiten();
+      await laden();
+    } catch (err) {
+      toast(err.message, "error");
+      abbrechenBearbeiten();
+      await laden();
+    }
+  }
+
+  return (
+    <Modal
+      title={t("categories.keywordsTitle", { name: category.name })}
+      onClose={onClose}
+      footer={<button className="btn primary" onClick={onClose}>{t("common.close")}</button>}
+    >
+      <p className="muted small" style={{ marginTop: 0 }}>{t("categories.keywordsHint")}</p>
+      <div className="kw-add">
+        {/* eslint-disable-next-line jsx-a11y/no-autofocus */}
+        <input
+          autoFocus
+          value={input}
+          placeholder={t("categories.keywordAdd")}
+          onChange={(e) => setInput(e.target.value)}
+          onKeyDown={(e) => { if (e.key === "Enter") { e.preventDefault(); hinzufuegen(); } }}
+        />
+        <button className="btn" onClick={hinzufuegen} disabled={busy || !input.trim()}>
+          <Icon name="plus" size={15} />
+        </button>
+      </div>
+      {words.length === 0 ? (
+        <div className="muted small">{t("categories.keywordEmpty")}</div>
+      ) : (
+        <>
+          <div className="kw-chips">
+            {words.map((w) =>
+              editId === w.id ? (
+                <span className="kw-chip editing" key={w.id}>
+                  {/* eslint-disable-next-line jsx-a11y/no-autofocus */}
+                  <input
+                    autoFocus
+                    value={editVal}
+                    onFocus={(e) => e.target.select()}
+                    onChange={(e) => setEditVal(e.target.value)}
+                    onKeyDown={(e) => {
+                      if (e.key === "Enter") { e.preventDefault(); speichernBearbeiten(w.id); }
+                      else if (e.key === "Escape") { e.preventDefault(); abbrechenBearbeiten(); }
+                    }}
+                    onBlur={() => speichernBearbeiten(w.id)}
+                  />
+                </span>
+              ) : (
+                <span
+                  className="kw-chip"
+                  key={w.id}
+                  title={t("categories.keywordEditHint")}
+                  onDoubleClick={() => starteBearbeiten(w)}
+                >
+                  {w.word}
+                  <button type="button" title={t("common.delete")} onClick={() => entfernen(w.id)}>
+                    <Icon name="close" size={13} />
+                  </button>
+                </span>
+              )
+            )}
+          </div>
+          <p className="muted small" style={{ marginTop: "var(--sp-2)", marginBottom: 0 }}>
+            {t("categories.keywordEditHint")}
+          </p>
+        </>
+      )}
+    </Modal>
+  );
+}
+
 export default function Categories() {
   const { t } = useTranslation();
   const confirm = useConfirm();
   const toast = useToast();
   const [groups, setGroups] = useState([]);
   const [modal, setModal] = useState(null); // {type:'group'|'category', editing, groupId, form}
+  const [keywordCat, setKeywordCat] = useState(null); // Kategorie fürs Schlagwort-Popup
 
   async function laden() {
     try {
@@ -103,6 +232,9 @@ export default function Categories() {
               <div className="cat-row" key={c.id}>
                 <IconChip name={c.icon} color={c.color} size={28} />
                 <span className="grow">{c.name}</span>
+                <button className="btn sm ghost" title={t("categories.keywordsBtn")} onClick={() => setKeywordCat(c)}>
+                  <Icon name="tags" size={14} />
+                </button>
                 <button className="btn sm ghost" title={t("common.edit")} onClick={() => openCategory(g.id, c)}>
                   <Icon name="edit" size={14} />
                 </button>
@@ -164,6 +296,8 @@ export default function Categories() {
           </form>
         </Modal>
       )}
+
+      {keywordCat && <KeywordModal category={keywordCat} onClose={() => setKeywordCat(null)} />}
     </div>
   );
 }

web/src/pages/Import.jsx

@@ -5,6 +5,7 @@ import { useSettings } from "../settings";
 import { useConfirm } from "../confirm";
 import { useToast } from "../toast";
 import Icon from "../components/Icon";
+import CategorySelect from "../components/CategorySelect";
 import { formatMoney } from "../format";
 
 const DATE_FORMATS = [
@@ -421,14 +422,15 @@ export default function Import() {
                           {accounts.filter((a) => a.id !== Number(accountId)).map((a) => <option key={a.id} value={a.id}>{a.name}</option>)}
                         </select>
                       ) : (
-                        <select value={r.category_id || ""} onChange={(e) => updateRow(idx, { category_id: e.target.value ? Number(e.target.value) : null })} style={{ minWidth: 150 }}>
+                        <CategorySelect
-                          <option value="">{t("transactions.uncategorized")}</option>
+                          groups={r.type === "income" ? incomeGroups : expenseGroups}
-                          {(r.type === "income" ? incomeGroups : expenseGroups).map((g) => (
+                          value={r.category_id || ""}
-                            <optgroup key={g.id} label={g.name}>
+                          onChange={(id) => updateRow(idx, { category_id: id != null ? Number(id) : null })}
-                              {g.categories.map((c) => <option key={c.id} value={c.id}>{c.name}</option>)}
+                          allowNone
-                            </optgroup>
+                          noneLabel={t("transactions.uncategorized")}
-                          ))}
+                          placeholder={t("transactions.uncategorized")}
-                        </select>
+                          minWidth={180}
+                        />
                       )}
                     </td>
                   </tr>

web/src/pages/Settings.jsx

@@ -1,3 +1,4 @@
+import { useEffect, useState } from "react";
 import { useTranslation } from "react-i18next";
 import { useSettings } from "../settings";
 import { useAuth } from "../auth";
@@ -10,6 +11,22 @@ export default function Settings() {
   const s = useSettings();
   const { isAdmin } = useAuth();
   const toast = useToast();
+  const [flagged, setFlagged] = useState([]);
+
+  async function ladenFlagged() {
+    try { setFlagged(await api.flaggedKeywords()); }
+    catch { /* still ignorieren – nicht kritisch für die Einstellungen */ }
+  }
+  useEffect(() => { ladenFlagged(); }, []);
+
+  async function keywordBehalten(id) {
+    try { await api.confirmKeyword(id); setFlagged((f) => f.filter((x) => x.id !== id)); }
+    catch (err) { toast(err.message, "error"); }
+  }
+  async function keywordEntfernen(id) {
+    try { await api.deleteKeyword(id); setFlagged((f) => f.filter((x) => x.id !== id)); }
+    catch (err) { toast(err.message, "error"); }
+  }
 
   async function set(key, value) {
     try {
@@ -32,6 +49,30 @@ export default function Settings() {
     <div>
       <h1>{t("settings.title")}</h1>
 
+      {flagged.length > 0 && (
+        <div className="card" style={{ maxWidth: 520, marginBottom: "var(--sp-4)", borderColor: "var(--danger)" }}>
+          <h2 style={{ display: "flex", alignItems: "center", gap: "var(--sp-2)", marginTop: 0 }}>
+            <Icon name="alert" size={18} /> {t("settings.keywordReview")}
+          </h2>
+          <p className="muted small">{t("settings.keywordReviewHint")}</p>
+          {flagged.map((f) => (
+            <div className="kw-flag" key={f.id}>
+              <div className="kw-flag-main">
+                <div className="ellipsis">
+                  <span className="kw-flag-word">{f.word}</span>
+                  <Icon name="chevron-right" size={12} /> {f.category_name}
+                </div>
+                <div className="muted small">
+                  {t("settings.keywordCorrected", { overridden: f.overridden_count, applied: f.applied_count })}
+                </div>
+              </div>
+              <button className="btn sm" onClick={() => keywordBehalten(f.id)}>{t("settings.keep")}</button>
+              <button className="btn sm danger" onClick={() => keywordEntfernen(f.id)}>{t("settings.remove")}</button>
+            </div>
+          ))}
+        </div>
+      )}
+
       <div className="card" style={{ maxWidth: 520 }}>
         <label>
           <span>{t("settings.baseCurrency")}</span>

web/src/pages/Transactions.jsx

@@ -8,6 +8,7 @@ import Icon from "../components/Icon";
 import IconChip from "../components/IconChip";
 import Money from "../components/Money";
 import Modal from "../components/Modal";
+import CategorySelect from "../components/CategorySelect";
 import { centsToInput, parseAmountToCents, todayIso } from "../format";
 
 const TYPES = ["expense", "income", "transfer"];
@@ -321,14 +322,14 @@ export default function Transactions() {
             ) : (
               <label>
                 <span>{t("transactions.category")}</span>
-                <select value={form.category_id} onChange={(e) => setForm({ ...form, category_id: e.target.value })}>
+                <CategorySelect
-                  <option value="">{t("transactions.uncategorized")}</option>
+                  groups={catOptions}
-                  {catOptions.map((g) => (
+                  value={form.category_id}
-                    <optgroup key={g.id} label={g.name}>
+                  onChange={(id) => setForm({ ...form, category_id: id != null ? String(id) : "" })}
-                      {g.categories.map((c) => <option key={c.id} value={c.id}>{c.name}</option>)}
+                  allowNone
-                    </optgroup>
+                  noneLabel={t("transactions.uncategorized")}
-                  ))}
+                  placeholder={t("transactions.uncategorized")}
-                </select>
+                />
               </label>
             )}
 
@@ -357,13 +358,12 @@ export default function Transactions() {
                 {form.budget_as_expense && (
                   <label>
                     <span>{t("transactions.budgetCategory")}</span>
-                    <select value={form.budget_category_id} onChange={(e) => setForm({ ...form, budget_category_id: e.target.value })}>
+                    <CategorySelect
-                      {expenseGroups.map((g) => (
+                      groups={expenseGroups}
-                        <optgroup key={g.id} label={g.name}>
+                      value={form.budget_category_id}
-                          {g.categories.map((c) => <option key={c.id} value={c.id}>{c.name}</option>)}
+                      onChange={(id) => setForm({ ...form, budget_category_id: id != null ? String(id) : "" })}
-                        </optgroup>
+                      placeholder={t("transactions.budgetCategory")}
-                      ))}
+                    />
-                    </select>
                   </label>
                 )}
               </div>