refactor(klassifikation): Klassifikation aus Monitor entfernt — Pflege jetzt in der Verwaltung

Endpoints unter /api/sources/classification/* weg, Service-Module (source_classifier, external_reputation) gelöscht. Quellen-Modal verliert Tab Klassifikations-Review, Klassifikations-Section in der Edit-Form, alle Bulk-Buttons (Sync, Klassifikation starten, Bulk-Approve). API-Methoden in api.js entfernt, alignment-Helper raus, saveSource entschlackt. Read-Only bleibt: Filter-Dropdowns über der Quellenliste (Politik, Medientyp, Reliability, Externe Reputation, Alignment) und Inline-Badges (_renderClassificationBadges + Label-Maps in components.js). Kunde sieht nur freigegebene Werte. GET /api/sources liefert weiter Klassifikations-Felder + alignments für die Anzeige; SourceCreate/SourceUpdate akzeptieren keine Klassifikations-Felder mehr. Bulk-Klassifikations-Skripte entfernt — Pflege läuft über Verwaltungs-UI.
2026-05-09 22:01:20 +00:00
Commit b90e47ff3f
--- a/scripts/migrate_sources_classification.py
+++ b/scripts/migrate_sources_classification.py
@@ -1,64 +0,0 @@
 """Einmalige LLM-Klassifikation aller noch unklassifizierten Quellen.
 Verwendung:
    python3 scripts/migrate_sources_classification.py --limit 50
    python3 scripts/migrate_sources_classification.py --limit 500     # Alle
    python3 scripts/migrate_sources_classification.py --recheck-pending  # bereits Pending neu
 Schreibt Vorschlaege in proposed_*-Spalten. Approval erfolgt anschliessend
 ueber das Verwaltungs-UI / API (POST /api/sources/{id}/classification/approve).
 """
 import argparse
 import asyncio
 import logging
 import sys
 from pathlib import Path
 # src/ in PYTHONPATH aufnehmen, wenn Skript direkt aufgerufen wird
 HERE = Path(__file__).resolve().parent
 SRC = HERE.parent / "src"
 if str(SRC) not in sys.path:
    sys.path.insert(0, str(SRC))
 from database import get_db  # noqa: E402
 from services.source_classifier import bulk_classify  # noqa: E402
 logging.basicConfig(
    level=logging.INFO,
    format="%(asctime)s [%(name)s] %(levelname)s: %(message)s",
 )
 logger = logging.getLogger("migrate_sources")
 async def main():
    parser = argparse.ArgumentParser(description="LLM-Klassifikation aller Quellen.")
    parser.add_argument("--limit", type=int, default=50, help="Max. Quellen pro Lauf")
    parser.add_argument(
        "--recheck-pending",
        action="store_true",
        help="Auch Quellen mit classification_source='llm_pending' neu klassifizieren",
    )
    args = parser.parse_args()
    db = await get_db()
    try:
        result = await bulk_classify(
            db,
            limit=args.limit,
            only_unclassified=not args.recheck_pending,
        )
    finally:
        await db.close()
    print(f"Verarbeitet: {result['processed']}")
    print(f"Erfolgreich: {result['success']}")
    print(f"Fehler:      {len(result['errors'])}")
    print(f"Kosten:      ${result['total_cost_usd']:.4f}")
    if result["errors"]:
        print("\nFehler-Details:")
        for e in result["errors"][:10]:
            print(f"  source_id={e['source_id']}: {e['error']}")
 if __name__ == "__main__":
    asyncio.run(main())
--- a/src/models.py
+++ b/src/models.py
@@ -142,14 +142,6 @@ class IncidentListItem(BaseModel):
 SOURCE_TYPE_PATTERN = "^(rss_feed|web_source|excluded|telegram_channel|podcast_feed)$"
 SOURCE_CATEGORY_PATTERN = "^(nachrichtenagentur|oeffentlich-rechtlich|qualitaetszeitung|behoerde|fachmedien|think-tank|international|regional|boulevard|sonstige)$"
 SOURCE_STATUS_PATTERN = "^(active|inactive)$"
 POLITICAL_ORIENTATION_PATTERN = "^(links_extrem|links|mitte_links|liberal|mitte|konservativ|mitte_rechts|rechts|rechts_extrem|na)$"
 MEDIA_TYPE_PATTERN = "^(tageszeitung|wochenzeitung|magazin|tv_sender|radio|oeffentlich_rechtlich|nachrichtenagentur|online_only|blog|telegram_kanal|telegram_bot|podcast|social_media|imageboard|think_tank|ngo|behoerde|staatsmedium|fachmedium|sonstige)$"
 RELIABILITY_PATTERN = "^(sehr_hoch|hoch|gemischt|niedrig|sehr_niedrig|na)$"
 ALIGNMENT_PATTERN = "^(prorussisch|proiranisch|prowestlich|proukrainisch|prochinesisch|projapanisch|proisraelisch|propalaestinensisch|protuerkisch|panarabisch|neutral|sonstige)$"
 COUNTRY_CODE_PATTERN = "^[A-Z]{2}$"
 CLASSIFICATION_SOURCE_PATTERN = "^(manual|llm_approved|llm_pending|legacy)$"
 class SourceCreate(BaseModel):
    name: str = Field(min_length=1, max_length=200)
    url: Optional[str] = None
@@ -160,12 +152,6 @@ class SourceCreate(BaseModel):
    notes: Optional[str] = None
    language: Optional[str] = None
    bias: Optional[str] = None
    political_orientation: Optional[str] = Field(default=None, pattern=POLITICAL_ORIENTATION_PATTERN)
    media_type: Optional[str] = Field(default=None, pattern=MEDIA_TYPE_PATTERN)
    reliability: Optional[str] = Field(default=None, pattern=RELIABILITY_PATTERN)
    state_affiliated: Optional[bool] = None
    country_code: Optional[str] = Field(default=None, pattern=COUNTRY_CODE_PATTERN)
    alignments: Optional[list[str]] = None
 class SourceUpdate(BaseModel):
@@ -178,12 +164,6 @@ class SourceUpdate(BaseModel):
    notes: Optional[str] = None
    language: Optional[str] = None
    bias: Optional[str] = None
    political_orientation: Optional[str] = Field(default=None, pattern=POLITICAL_ORIENTATION_PATTERN)
    media_type: Optional[str] = Field(default=None, pattern=MEDIA_TYPE_PATTERN)
    reliability: Optional[str] = Field(default=None, pattern=RELIABILITY_PATTERN)
    state_affiliated: Optional[bool] = None
    country_code: Optional[str] = Field(default=None, pattern=COUNTRY_CODE_PATTERN)
    alignments: Optional[list[str]] = None
 class SourceResponse(BaseModel):
--- a/src/routers/sources.py
+++ b/src/routers/sources.py
@@ -1,13 +1,11 @@
-"""Sources-Router: Quellenverwaltung (Multi-Tenant)."""
+"""Sources-Router: Quellenverwaltung (Multi-Tenant). Klassifikation: Read-Only — Pflege in der Verwaltung."""
 import json
 import logging
 from collections import defaultdict
-from fastapi import APIRouter, BackgroundTasks, Depends, HTTPException, status
+from fastapi import APIRouter, Depends, HTTPException, status
 from models import SourceCreate, SourceUpdate, SourceResponse, DiscoverRequest, DiscoverResponse, DiscoverMultiResponse, DomainActionRequest
 from auth import get_current_user
-from database import db_dependency, get_db, refresh_source_counts
+from database import db_dependency, refresh_source_counts
 from services.external_reputation import apply_reputation_overrides, sync_all as sync_external_reputation
 from services.source_classifier import bulk_classify, classify_source
 from source_rules import discover_source, discover_all_feeds, evaluate_feeds_with_claude, _extract_domain, _detect_category, domain_to_display_name, _DOMAIN_ALIASES
 import aiosqlite
@@ -18,22 +16,11 @@ router = APIRouter(prefix="/api/sources", tags=["sources"])
 SOURCE_UPDATE_COLUMNS = {
    "name", "url", "domain", "source_type", "category", "status", "notes",
    "language", "bias",
    "political_orientation", "media_type", "reliability",
    "state_affiliated", "country_code",
 }
 SOURCE_CLASSIFICATION_FIELDS = {
    "political_orientation", "media_type", "reliability",
    "state_affiliated", "country_code",
 }
 ALLOWED_ALIGNMENTS = {
    "prorussisch", "proiranisch", "prowestlich", "proukrainisch",
    "prochinesisch", "projapanisch", "proisraelisch", "propalaestinensisch",
    "protuerkisch", "panarabisch", "neutral", "sonstige",
 }
 async def _load_alignments_for(db: aiosqlite.Connection, source_ids: list[int]) -> dict[int, list[str]]:
-    """Lädt alignments fuer mehrere Quellen in einer Query und gibt {source_id: [alignment, ...]} zurück."""
+    """Lädt alignments fuer mehrere Quellen — Read-Only fuer Anzeige (Pflege in Verwaltung)."""
    if not source_ids:
        return {}
    placeholders = ",".join("?" for _ in source_ids)
@@ -47,26 +34,6 @@ async def _load_alignments_for(db: aiosqlite.Connection, source_ids: list[int])
    return out
 async def _replace_alignments(db: aiosqlite.Connection, source_id: int, alignments: list[str]):
    """Ersetzt die alignments-Liste einer Quelle (DELETE + INSERT) — Aufrufer muss commit() machen."""
    await db.execute("DELETE FROM source_alignments WHERE source_id = ?", (source_id,))
    seen: set[str] = set()
    for raw in alignments:
        a = (raw or "").strip().lower()
        if not a or a in seen:
            continue
        if a not in ALLOWED_ALIGNMENTS:
            raise HTTPException(
                status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
                detail=f"Ungueltiger alignment-Wert: '{a}'",
            )
        seen.add(a)
        await db.execute(
            "INSERT INTO source_alignments (source_id, alignment) VALUES (?, ?)",
            (source_id, a),
        )
 def _check_source_ownership(source: dict, username: str):
    """Prueft ob der Nutzer die Quelle bearbeiten/loeschen darf.
@@ -538,14 +505,9 @@ async def create_source(
                )
    payload = data.model_dump(exclude_unset=True)
    alignments = payload.pop("alignments", None)
    classification_touched = bool(SOURCE_CLASSIFICATION_FIELDS & payload.keys()) or alignments is not None
    cols = ["name", "url", "domain", "source_type", "category", "status", "notes",
-            "language", "bias",
+            "language", "bias", "added_by", "tenant_id"]
            "political_orientation", "media_type", "reliability",
            "state_affiliated", "country_code",
            "added_by", "tenant_id"]
    vals = [
        data.name,
        data.url,
@@ -556,31 +518,16 @@ async def create_source(
        data.notes,
        payload.get("language"),
        payload.get("bias"),
        payload.get("political_orientation"),
        payload.get("media_type"),
        payload.get("reliability"),
        1 if payload.get("state_affiliated") else 0,
        payload.get("country_code"),
        current_user["username"],
        tenant_id,
    ]
    if classification_touched:
        cols += ["classification_source", "classified_at"]
        vals += ["manual"]
        ts_marker = True
    else:
        ts_marker = False
-    placeholders = ", ".join(["?"] * len(vals) + (["CURRENT_TIMESTAMP"] if ts_marker else []))
+    placeholders = ", ".join(["?"] * len(vals))
    cursor = await db.execute(
        f"INSERT INTO sources ({', '.join(cols)}) VALUES ({placeholders})",
        vals,
    )
    new_id = cursor.lastrowid
    if alignments:
        await _replace_alignments(db, new_id, alignments)
    await db.commit()
    cursor = await db.execute("SELECT * FROM sources WHERE id = ?", (new_id,))
@@ -612,40 +559,19 @@ async def update_source(
    _check_source_ownership(dict(row), current_user["username"])
    payload = data.model_dump(exclude_unset=True)
    alignments = payload.pop("alignments", None)
    updates = {}
    for field, value in payload.items():
        if field not in SOURCE_UPDATE_COLUMNS:
            continue
        # Domain normalisieren
        if field == "domain" and value:
            value = _DOMAIN_ALIASES.get(value.lower(), value.lower())
        if field == "state_affiliated":
            value = 1 if value else 0
        updates[field] = value
    classification_touched = bool(SOURCE_CLASSIFICATION_FIELDS & updates.keys()) or alignments is not None
    if classification_touched:
        updates["classification_source"] = "manual"
        updates["classified_at"] = "CURRENT_TIMESTAMP_MARKER"
    if updates:
-        set_parts = []
+        set_clause = ", ".join(f"{k} = ?" for k in updates)
-        values = []
+        values = list(updates.values()) + [source_id]
-        for k, v in updates.items():
+        await db.execute(f"UPDATE sources SET {set_clause} WHERE id = ?", values)
            if v == "CURRENT_TIMESTAMP_MARKER":
                set_parts.append(f"{k} = CURRENT_TIMESTAMP")
            else:
                set_parts.append(f"{k} = ?")
                values.append(v)
        values.append(source_id)
        await db.execute(f"UPDATE sources SET {', '.join(set_parts)} WHERE id = ?", values)
    if alignments is not None:
        await _replace_alignments(db, source_id, alignments)
    if updates or alignments is not None:
        await db.commit()
    cursor = await db.execute("SELECT * FROM sources WHERE id = ?", (source_id,))
@@ -714,327 +640,3 @@ async def trigger_refresh_counts(
    await refresh_source_counts(db)
    return {"status": "ok"}
 # === Klassifikations-Review (LLM-Vorschlaege approve/reject/reclassify) ===
 def _require_admin_for_global(row: dict, current_user: dict):
    """Globale Quellen (tenant_id IS NULL) duerfen nur org_admins approve-en/reclassify-en."""
    if row.get("tenant_id") is None and current_user.get("role") != "org_admin":
        raise HTTPException(
            status_code=status.HTTP_403_FORBIDDEN,
            detail="Globale Quellen koennen nur von Admins klassifiziert werden",
        )
@router.get("/classification/stats")
 async def classification_stats(
    current_user: dict = Depends(get_current_user),
    db: aiosqlite.Connection = Depends(db_dependency),
 ):
    """Counts pro classification_source-Wert (global + eigene Org)."""
    tenant_id = current_user.get("tenant_id")
    cursor = await db.execute(
        """SELECT classification_source, COUNT(*) as cnt
           FROM sources
           WHERE (tenant_id IS NULL OR tenant_id = ?) AND status = 'active'
           GROUP BY classification_source""",
        (tenant_id,),
    )
    by_source = {row["classification_source"] or "legacy": row["cnt"] for row in await cursor.fetchall()}
    cursor = await db.execute(
        """SELECT COUNT(*) as cnt FROM sources
           WHERE (tenant_id IS NULL OR tenant_id = ?) AND status = 'active'
           AND proposed_political_orientation IS NOT NULL""",
        (tenant_id,),
    )
    pending = (await cursor.fetchone())["cnt"]
    return {
        "by_classification_source": by_source,
        "pending_review": pending,
        "total": sum(by_source.values()),
    }
@router.get("/classification/queue")
 async def classification_queue(
    limit: int = 50,
    min_confidence: float = 0.0,
    current_user: dict = Depends(get_current_user),
    db: aiosqlite.Connection = Depends(db_dependency),
 ):
    """Liefert Quellen mit nicht-leeren proposed_*-Spalten (Review-Queue)."""
    tenant_id = current_user.get("tenant_id")
    cursor = await db.execute(
        """SELECT s.* FROM sources s
           WHERE (s.tenant_id IS NULL OR s.tenant_id = ?)
             AND s.proposed_political_orientation IS NOT NULL
             AND COALESCE(s.proposed_confidence, 0) >= ?
           ORDER BY s.proposed_confidence DESC, s.proposed_at DESC
           LIMIT ?""",
        (tenant_id, min_confidence, limit),
    )
    rows = [dict(r) for r in await cursor.fetchall()]
    alignments_map = await _load_alignments_for(db, [r["id"] for r in rows])
    out = []
    for d in rows:
        try:
            proposed_aligns = json.loads(d.get("proposed_alignments_json") or "[]")
        except (json.JSONDecodeError, TypeError):
            proposed_aligns = []
        out.append({
            "id": d["id"],
            "name": d["name"],
            "url": d.get("url"),
            "domain": d.get("domain"),
            "source_type": d.get("source_type"),
            "category": d.get("category"),
            "is_global": d.get("tenant_id") is None,
            "current": {
                "political_orientation": d.get("political_orientation"),
                "media_type": d.get("media_type"),
                "reliability": d.get("reliability"),
                "state_affiliated": bool(d.get("state_affiliated")),
                "country_code": d.get("country_code"),
                "alignments": alignments_map.get(d["id"], []),
                "classification_source": d.get("classification_source"),
            },
            "proposed": {
                "political_orientation": d.get("proposed_political_orientation"),
                "media_type": d.get("proposed_media_type"),
                "reliability": d.get("proposed_reliability"),
                "state_affiliated": bool(d.get("proposed_state_affiliated")),
                "country_code": d.get("proposed_country_code"),
                "alignments": proposed_aligns,
                "confidence": d.get("proposed_confidence"),
                "reasoning": d.get("proposed_reasoning"),
                "proposed_at": d.get("proposed_at"),
            },
        })
    return out
 async def _clear_proposed(db: aiosqlite.Connection, source_id: int):
    """Loescht die proposed_*-Felder einer Quelle (ohne commit)."""
    await db.execute(
        """UPDATE sources SET
            proposed_political_orientation = NULL,
            proposed_media_type = NULL,
            proposed_reliability = NULL,
            proposed_state_affiliated = NULL,
            proposed_country_code = NULL,
            proposed_alignments_json = NULL,
            proposed_confidence = NULL,
            proposed_reasoning = NULL,
            proposed_at = NULL
        WHERE id = ?""",
        (source_id,),
    )
@router.post("/{source_id}/classification/approve")
 async def approve_classification(
    source_id: int,
    current_user: dict = Depends(get_current_user),
    db: aiosqlite.Connection = Depends(db_dependency),
 ):
    """Uebernimmt proposed_* in echte Felder, setzt classification_source='llm_approved'."""
    cursor = await db.execute("SELECT * FROM sources WHERE id = ?", (source_id,))
    row = await cursor.fetchone()
    if not row:
        raise HTTPException(status_code=404, detail="Quelle nicht gefunden")
    src = dict(row)
    _require_admin_for_global(src, current_user)
    if src.get("proposed_political_orientation") is None:
        raise HTTPException(status_code=400, detail="Keine LLM-Vorschlaege fuer diese Quelle vorhanden")
    try:
        proposed_aligns = json.loads(src.get("proposed_alignments_json") or "[]")
    except (json.JSONDecodeError, TypeError):
        proposed_aligns = []
    await db.execute(
        """UPDATE sources SET
            political_orientation = ?,
            media_type = ?,
            reliability = ?,
            state_affiliated = ?,
            country_code = ?,
            classification_source = 'llm_approved',
            classified_at = CURRENT_TIMESTAMP
        WHERE id = ?""",
        (
            src["proposed_political_orientation"],
            src["proposed_media_type"],
            src["proposed_reliability"],
            1 if src.get("proposed_state_affiliated") else 0,
            src.get("proposed_country_code"),
            source_id,
        ),
    )
    await _replace_alignments(db, source_id, [a for a in proposed_aligns if a in ALLOWED_ALIGNMENTS])
    await _clear_proposed(db, source_id)
    await db.commit()
    # Reliability-Override anwenden (IFCN/EUvsDisinfo)
    try:
        await apply_reputation_overrides(db, source_id)
    except Exception as e:
        logger.warning("Reputation-Override fuer source_id=%s fehlgeschlagen: %s", source_id, e)
    return {"source_id": source_id, "status": "approved"}
@router.post("/{source_id}/classification/reject")
 async def reject_classification(
    source_id: int,
    current_user: dict = Depends(get_current_user),
    db: aiosqlite.Connection = Depends(db_dependency),
 ):
    """Verwirft die LLM-Vorschlaege ohne Uebernahme. classification_source bleibt unveraendert."""
    cursor = await db.execute("SELECT * FROM sources WHERE id = ?", (source_id,))
    row = await cursor.fetchone()
    if not row:
        raise HTTPException(status_code=404, detail="Quelle nicht gefunden")
    src = dict(row)
    _require_admin_for_global(src, current_user)
    await _clear_proposed(db, source_id)
    # Wenn classification_source noch 'llm_pending' war, zurueck auf 'legacy'
    if src.get("classification_source") == "llm_pending":
        await db.execute(
            "UPDATE sources SET classification_source = 'legacy' WHERE id = ?",
            (source_id,),
        )
    await db.commit()
    return {"source_id": source_id, "status": "rejected"}
@router.post("/{source_id}/classification/reclassify")
 async def reclassify_source(
    source_id: int,
    current_user: dict = Depends(get_current_user),
    db: aiosqlite.Connection = Depends(db_dependency),
 ):
    """Triggert eine LLM-Klassifikation einer einzelnen Quelle (synchron, ~3-5s)."""
    cursor = await db.execute("SELECT * FROM sources WHERE id = ?", (source_id,))
    row = await cursor.fetchone()
    if not row:
        raise HTTPException(status_code=404, detail="Quelle nicht gefunden")
    src = dict(row)
    _require_admin_for_global(src, current_user)
    try:
        result = await classify_source(db, source_id)
    except Exception as e:
        logger.error("Reclassify source_id=%s fehlgeschlagen: %s", source_id, e, exc_info=True)
        raise HTTPException(status_code=500, detail=f"Klassifikation fehlgeschlagen: {e}")
    return result
 async def _bulk_classify_background(limit: int, only_unclassified: bool):
    """Hintergrund-Task: oeffnet eigene DB-Connection."""
    db = await get_db()
    try:
        await bulk_classify(db, limit=limit, only_unclassified=only_unclassified)
    finally:
        await db.close()
@router.post("/classification/bulk-classify")
 async def trigger_bulk_classify(
    background_tasks: BackgroundTasks,
    limit: int = 50,
    only_unclassified: bool = True,
    current_user: dict = Depends(get_current_user),
 ):
    """Startet eine Bulk-Klassifikation im Hintergrund (nur Admins)."""
    if current_user.get("role") != "org_admin":
        raise HTTPException(status_code=403, detail="Nur Admins koennen Bulk-Klassifikation starten")
    if limit < 1 or limit > 500:
        raise HTTPException(status_code=400, detail="limit muss zwischen 1 und 500 liegen")
    background_tasks.add_task(_bulk_classify_background, limit, only_unclassified)
    return {"status": "started", "limit": limit, "only_unclassified": only_unclassified}
@router.post("/external-reputation/sync")
 async def trigger_external_reputation_sync(
    background_tasks: BackgroundTasks,
    current_user: dict = Depends(get_current_user),
 ):
    """Startet Sync von IFCN- und EUvsDisinfo-Daten (Admin, Hintergrund)."""
    if current_user.get("role") != "org_admin":
        raise HTTPException(status_code=403, detail="Nur Admins koennen den externen Sync starten")
    async def _bg():
        db = await get_db()
        try:
            await sync_external_reputation(db)
        finally:
            await db.close()
    background_tasks.add_task(_bg)
    return {"status": "started"}
@router.post("/classification/bulk-approve")
 async def bulk_approve_classifications(
    min_confidence: float = 0.85,
    current_user: dict = Depends(get_current_user),
    db: aiosqlite.Connection = Depends(db_dependency),
 ):
    """Genehmigt alle Pending-Vorschlaege ueber dem confidence-Schwellwert (nur Admins).
    Globale Quellen werden nur bearbeitet, wenn der Aufrufer org_admin ist;
    Tenant-eigene Quellen sowieso.
    """
    if current_user.get("role") != "org_admin":
        raise HTTPException(status_code=403, detail="Nur Admins koennen Bulk-Approve nutzen")
    tenant_id = current_user.get("tenant_id")
    cursor = await db.execute(
        """SELECT id, proposed_political_orientation, proposed_media_type,
                  proposed_reliability, proposed_state_affiliated,
                  proposed_country_code, proposed_alignments_json, tenant_id
           FROM sources
           WHERE proposed_political_orientation IS NOT NULL
             AND COALESCE(proposed_confidence, 0) >= ?
             AND (tenant_id IS NULL OR tenant_id = ?)""",
        (min_confidence, tenant_id),
    )
    rows = [dict(r) for r in await cursor.fetchall()]
    approved_ids: list[int] = []
    for src in rows:
        try:
            proposed_aligns = json.loads(src.get("proposed_alignments_json") or "[]")
        except (json.JSONDecodeError, TypeError):
            proposed_aligns = []
        await db.execute(
            """UPDATE sources SET
                political_orientation = ?,
                media_type = ?,
                reliability = ?,
                state_affiliated = ?,
                country_code = ?,
                classification_source = 'llm_approved',
                classified_at = CURRENT_TIMESTAMP
            WHERE id = ?""",
            (
                src["proposed_political_orientation"],
                src["proposed_media_type"],
                src["proposed_reliability"],
                1 if src.get("proposed_state_affiliated") else 0,
                src.get("proposed_country_code"),
                src["id"],
            ),
        )
        await _replace_alignments(
            db, src["id"], [a for a in proposed_aligns if a in ALLOWED_ALIGNMENTS]
        )
        await _clear_proposed(db, src["id"])
        approved_ids.append(src["id"])
    await db.commit()
    # Reliability-Override fuer alle gerade Approved
    try:
        for sid in approved_ids:
            await apply_reputation_overrides(db, sid)
    except Exception as e:
        logger.warning("Bulk Reputation-Override fehlgeschlagen: %s", e)
    return {"approved_count": len(approved_ids), "min_confidence": min_confidence}
--- a/src/services/external_reputation.py
+++ b/src/services/external_reputation.py
@@ -1,282 +0,0 @@
 """Externe Reputations-Daten fuer Quellen.
 Synchronisiert Domain-Listen von oeffentlichen Reputations-/Faktencheck-Datenbanken
 und schreibt die Treffer in die sources-Spalten:
 - IFCN-Signatories (anerkannte Faktenchecker) -> ifcn_signatory
 - EUvsDisinfo (pro-Kreml-Desinformation, Zenodo-CSV) -> eu_disinfo_listed,
  eu_disinfo_case_count, eu_disinfo_last_seen
 Anschliessend wendet apply_reputation_overrides() Override-Regeln auf die
 reliability-Spalte an:
 - ifcn_signatory=1 -> reliability='sehr_hoch'
 - eu_disinfo_case_count >= 5 -> reliability='sehr_niedrig'
 - eu_disinfo_case_count >= 1 -> reliability eine Stufe runter (max bis 'niedrig')
 """
 import csv
 import io
 import logging
 from collections import defaultdict
 from urllib.parse import urlparse
 import aiosqlite
 import httpx
 logger = logging.getLogger("osint.external_reputation")
 IFCN_LIST_URL = "https://raw.githubusercontent.com/IFCN/verified-signatories/main/list"
 EU_DISINFO_CSV_URL = "https://zenodo.org/records/10514307/files/euvsdisinfo_base.csv?download=1"
 HTTP_TIMEOUT = httpx.Timeout(60.0, connect=10.0)
 # Generische Plattform-Domains, die NICHT als Quelle markiert werden duerfen
 # (EUvsDisinfo aggregiert anonyme Telegram-/Twitter-Posts unter Plattform-Domains).
 PLATFORM_DOMAINS = {
    "t.me", "telegram.me", "telegram.org",
    "twitter.com", "x.com", "mobile.twitter.com",
    "youtube.com", "youtu.be", "m.youtube.com",
    "facebook.com", "fb.com", "m.facebook.com",
    "instagram.com", "tiktok.com", "vk.com", "ok.ru",
    "rumble.com", "bitchute.com", "odysee.com",
    "reddit.com", "old.reddit.com",
    "wordpress.com", "blogspot.com", "medium.com",
    "substack.com", "wixsite.com",
 }
 # Reliability-Skala in Stufenfolge (schlecht -> gut)
 RELIABILITY_ORDER = ["sehr_niedrig", "niedrig", "gemischt", "hoch", "sehr_hoch"]
 def _normalize_domain(raw: str | None) -> str | None:
    """Normalisiert eine Domain: lowercase, ohne www., ohne Schema/Pfad."""
    if not raw:
        return None
    raw = raw.strip().lower()
    if not raw:
        return None
    # Falls eine vollstaendige URL uebergeben wurde
    if "://" in raw:
        try:
            raw = urlparse(raw).netloc or raw
        except ValueError:
            pass
    # Pfad/Query strippen
    raw = raw.split("/")[0].split("?")[0].split("#")[0]
    if raw.startswith("www."):
        raw = raw[4:]
    return raw or None
 async def _fetch_text(url: str) -> str:
    """Laedt Text von einer URL. Wirft HTTPException bei Fehler."""
    async with httpx.AsyncClient(timeout=HTTP_TIMEOUT, follow_redirects=True) as client:
        resp = await client.get(url)
        resp.raise_for_status()
        return resp.text
 async def sync_ifcn_signatories(db: aiosqlite.Connection) -> dict:
    """Laedt IFCN-Domain-Liste und matcht gegen sources.domain.
    Setzt ifcn_signatory=1 wo die Domain in der Liste vorkommt, sonst 0.
    """
    text = await _fetch_text(IFCN_LIST_URL)
    domains: set[str] = set()
    for line in text.splitlines():
        d = _normalize_domain(line)
        if d:
            domains.add(d)
    logger.info("IFCN-Liste geladen: %d Domains", len(domains))
    # Aktuelle Quellen mit Domain laden
    cursor = await db.execute(
        "SELECT id, domain FROM sources WHERE domain IS NOT NULL AND domain != ''"
    )
    sources = [dict(r) for r in await cursor.fetchall()]
    matched_ids: list[int] = []
    unmatched_ids: list[int] = []
    for s in sources:
        nd = _normalize_domain(s["domain"])
        if nd and nd not in PLATFORM_DOMAINS and nd in domains:
            matched_ids.append(s["id"])
        else:
            unmatched_ids.append(s["id"])
    # Bulk-Update in zwei Statements
    if matched_ids:
        placeholders = ",".join("?" for _ in matched_ids)
        await db.execute(
            f"UPDATE sources SET ifcn_signatory = 1 WHERE id IN ({placeholders})",
            matched_ids,
        )
    if unmatched_ids:
        placeholders = ",".join("?" for _ in unmatched_ids)
        await db.execute(
            f"UPDATE sources SET ifcn_signatory = 0 WHERE id IN ({placeholders})",
            unmatched_ids,
        )
    await db.commit()
    logger.info("IFCN-Sync: %d Quellen als Faktenchecker markiert (von %d)",
                len(matched_ids), len(sources))
    return {
        "list_size": len(domains),
        "sources_checked": len(sources),
        "matched": len(matched_ids),
    }
 async def sync_eu_disinfo(db: aiosqlite.Connection) -> dict:
    """Laedt EUvsDisinfo-CSV von Zenodo, aggregiert pro Domain, schreibt sources.
    - eu_disinfo_listed: 1 wenn Domain mindestens 1x als 'disinformation' debunkt
    - eu_disinfo_case_count: Anzahl Disinformation-Faelle
    - eu_disinfo_last_seen: spaetestes debunk_date
    """
    text = await _fetch_text(EU_DISINFO_CSV_URL)
    reader = csv.DictReader(io.StringIO(text))
    # Per-Domain aggregieren (nur class='disinformation')
    counts: dict[str, int] = defaultdict(int)
    last_seen: dict[str, str] = {}
    total_rows = 0
    for row in reader:
        total_rows += 1
        if (row.get("class") or "").strip().lower() != "disinformation":
            continue
        d = _normalize_domain(row.get("article_domain"))
        if not d:
            continue
        counts[d] += 1
        debunk_date = (row.get("debunk_date") or "").strip()
        if debunk_date:
            prev = last_seen.get(d)
            if not prev or debunk_date > prev:
                last_seen[d] = debunk_date
    logger.info("EUvsDisinfo-CSV: %d Zeilen, %d Domains mit Desinformation",
                total_rows, len(counts))
    # Quellen laden + matchen
    cursor = await db.execute(
        "SELECT id, domain FROM sources WHERE domain IS NOT NULL AND domain != ''"
    )
    sources = [dict(r) for r in await cursor.fetchall()]
    matched = 0
    for s in sources:
        nd = _normalize_domain(s["domain"])
        if nd and nd not in PLATFORM_DOMAINS and nd in counts:
            await db.execute(
                """UPDATE sources SET
                    eu_disinfo_listed = 1,
                    eu_disinfo_case_count = ?,
                    eu_disinfo_last_seen = ?
                WHERE id = ?""",
                (counts[nd], last_seen.get(nd), s["id"]),
            )
            matched += 1
        else:
            await db.execute(
                """UPDATE sources SET
                    eu_disinfo_listed = 0,
                    eu_disinfo_case_count = 0,
                    eu_disinfo_last_seen = NULL
                WHERE id = ?""",
                (s["id"],),
            )
    await db.commit()
    logger.info("EUvsDisinfo-Sync: %d Quellen als Desinformations-Quelle markiert (von %d)",
                matched, len(sources))
    return {
        "rows_in_csv": total_rows,
        "domains_with_disinfo_in_csv": len(counts),
        "sources_checked": len(sources),
        "matched": matched,
    }
 def _override_reliability(current: str | None, ifcn: bool, eu_count: int) -> str | None:
    """Wendet Override-Regeln auf eine reliability-Stufe an.
    Rueckgabe: neue Stufe (oder None, wenn unveraendert).
    """
    cur = current or "na"
    # IFCN gewinnt: zertifizierter Faktenchecker -> sehr_hoch (immer)
    if ifcn:
        return "sehr_hoch" if cur != "sehr_hoch" else None
    # EUvsDisinfo: Downgrade
    if eu_count >= 5:
        return "sehr_niedrig" if cur != "sehr_niedrig" else None
    if eu_count >= 1:
        # Eine Stufe runter, mindestens bis 'niedrig'
        if cur == "na":
            return "niedrig"
        if cur in RELIABILITY_ORDER:
            idx = RELIABILITY_ORDER.index(cur)
            new_idx = max(0, idx - 1)
            new = RELIABILITY_ORDER[new_idx]
            # Mindeststufe 'niedrig' bei eu_count >= 1
            if RELIABILITY_ORDER.index(new) > RELIABILITY_ORDER.index("niedrig"):
                new = "niedrig"
            return new if new != cur else None
    return None
 async def apply_reputation_overrides(db: aiosqlite.Connection, source_id: int | None = None) -> dict:
    """Wendet Reliability-Override-Regeln an.
    Wenn source_id angegeben ist, nur fuer diese Quelle. Sonst fuer alle Quellen.
    """
    if source_id is not None:
        cursor = await db.execute(
            "SELECT id, reliability, ifcn_signatory, eu_disinfo_case_count "
            "FROM sources WHERE id = ?",
            (source_id,),
        )
    else:
        cursor = await db.execute(
            "SELECT id, reliability, ifcn_signatory, eu_disinfo_case_count FROM sources"
        )
    sources = [dict(r) for r in await cursor.fetchall()]
    changed = 0
    for s in sources:
        new = _override_reliability(
            s.get("reliability"),
            bool(s.get("ifcn_signatory")),
            int(s.get("eu_disinfo_case_count") or 0),
        )
        if new is not None:
            await db.execute(
                "UPDATE sources SET reliability = ? WHERE id = ?",
                (new, s["id"]),
            )
            changed += 1
    await db.commit()
    logger.info("Reliability-Override: %d Quellen angepasst (von %d gepruefte)",
                changed, len(sources))
    return {"checked": len(sources), "changed": changed}
 async def sync_all(db: aiosqlite.Connection) -> dict:
    """Vollstaendiger Sync: IFCN + EUvsDisinfo + Reliability-Override.
    Setzt external_data_synced_at fuer alle Quellen.
    """
    ifcn_result = await sync_ifcn_signatories(db)
    eu_result = await sync_eu_disinfo(db)
    override_result = await apply_reputation_overrides(db)
    await db.execute(
        "UPDATE sources SET external_data_synced_at = CURRENT_TIMESTAMP "
        "WHERE domain IS NOT NULL AND domain != ''"
    )
    await db.commit()
    return {
        "ifcn": ifcn_result,
        "eu_disinfo": eu_result,
        "override": override_result,
    }
--- a/src/services/source_classifier.py
+++ b/src/services/source_classifier.py
@@ -1,295 +0,0 @@
 """Klassifiziert Quellen via Claude (Haiku) nach 4 Achsen + state_affiliated + country.
 Schreibt Vorschlaege in die proposed_*-Spalten von sources und setzt
 classification_source='llm_pending'. Approval erfolgt ueber separate Endpoints,
 die proposed_* in die echten Spalten kopieren.
 """
 import asyncio
 import json
 import logging
 import re
 import aiosqlite
 from agents.claude_client import call_claude
 from config import CLAUDE_MODEL_FAST
 logger = logging.getLogger("osint.source_classifier")
 POLITICAL_VALUES = {
    "links_extrem", "links", "mitte_links", "liberal", "mitte",
    "konservativ", "mitte_rechts", "rechts", "rechts_extrem", "na",
 }
 MEDIA_TYPE_VALUES = {
    "tageszeitung", "wochenzeitung", "magazin", "tv_sender", "radio",
    "oeffentlich_rechtlich", "nachrichtenagentur", "online_only", "blog",
    "telegram_kanal", "telegram_bot", "podcast", "social_media", "imageboard",
    "think_tank", "ngo", "behoerde", "staatsmedium", "fachmedium", "sonstige",
 }
 RELIABILITY_VALUES = {"sehr_hoch", "hoch", "gemischt", "niedrig", "sehr_niedrig", "na"}
 ALIGNMENT_VALUES = {
    "prorussisch", "proiranisch", "prowestlich", "proukrainisch",
    "prochinesisch", "projapanisch", "proisraelisch", "propalaestinensisch",
    "protuerkisch", "panarabisch", "neutral", "sonstige",
 }
 def _build_prompt(src: dict, sample_articles: list[dict]) -> str:
    sample_text = ""
    if sample_articles:
        lines = []
        for i, art in enumerate(sample_articles[:5], 1):
            headline = (art.get("headline") or art.get("headline_de") or "").strip()
            if headline:
                lines.append(f"{i}. {headline[:200]}")
        if lines:
            sample_text = "\nLetzte Artikel/Headlines:\n" + "\n".join(lines)
    return f"""Du bist ein OSINT-Analyst und klassifizierst Nachrichten- und Medienquellen fuer ein Lagebild-Monitoring-System (DACH-Raum).
 QUELLE:
 Name: {src.get('name')}
 URL: {src.get('url') or '-'}
 Domain: {src.get('domain') or '-'}
 Quellentyp: {src.get('source_type')}
 Bisherige Kategorie: {src.get('category')}
 Sprache: {src.get('language') or 'unbekannt'}
 Bisherige Notiz (Freitext): {src.get('bias') or '-'}{sample_text}
 AUFGABE: Klassifiziere die Quelle nach folgenden Achsen.
 1. political_orientation:
   - links_extrem (z.B. linksunten.indymedia)
   - links (klar links, z.B. junge Welt, taz)
   - mitte_links (linksliberal/sozialdemokratisch, z.B. SZ, Spiegel)
   - liberal (wirtschafts-/grünliberal, z.B. NZZ, Zeit)
   - mitte (politisch neutral, Agentur, z.B. dpa, Reuters, tagesschau)
   - konservativ (buergerlich-konservativ, z.B. FAZ, Welt)
   - mitte_rechts (rechts-buergerlich, z.B. Tichys Einblick, Achgut)
   - rechts (klar rechts, z.B. Junge Freiheit, EpochTimes)
   - rechts_extrem (z.B. Compact, PI-News)
   - na (nicht klassifizierbar: Behoerde, Fachmedium, Think Tank ohne klare politische Linie)
 2. media_type (genau einer):
   tageszeitung, wochenzeitung, magazin, tv_sender, radio, oeffentlich_rechtlich,
   nachrichtenagentur, online_only, blog, telegram_kanal, telegram_bot, podcast,
   social_media, imageboard, think_tank, ngo, behoerde, staatsmedium, fachmedium, sonstige
 3. reliability:
   - sehr_hoch (etablierte Qualitaet, Faktencheck: tagesschau, dpa, FAZ, Reuters)
   - hoch (serioes mit gelegentlichen Schwaechen: taz, Welt, BILD bei harten News)
   - gemischt (Mix Meinung/Einseitigkeit: Tichys Einblick, Achgut, Boulevard)
   - niedrig (haeufig irrefuehrend, schwache Quellenarbeit: Junge Freiheit, EpochTimes)
   - sehr_niedrig (bekannt fuer Desinformation/Verschwoerung: Compact, RT, Sputnik, PI-News)
   - na (nicht bewertbar)
 4. alignments (Mehrfach, leeres Array wenn keine ausgepraegte Naehe):
   prorussisch, proiranisch, prowestlich, proukrainisch, prochinesisch, projapanisch,
   proisraelisch, propalaestinensisch, protuerkisch, panarabisch, neutral, sonstige
 5. state_affiliated (true/false): true wenn vom Staat finanziert/kontrolliert
   (RT, Sputnik, CGTN, PressTV, Xinhua, TRT). Public Service Broadcaster
   wie ARD/ZDF/BBC sind NICHT state_affiliated.
 6. country_code (ISO 3166-1 alpha-2): Heimatland (DE, AT, CH, RU, US, ...). null wenn unklar.
 7. confidence (0.0-1.0): 0.85+ fuer bekannte Outlets, 0.5-0.85 fuer mittelbekannt, <0.5 fuer unsicher.
 8. reasoning (1-2 Saetze): Kurze Begruendung der Hauptklassifikationen.
 WICHTIG:
 - Antworte AUSSCHLIESSLICH mit einem JSON-Objekt, kein Text drumherum.
 - Nutze ausschliesslich die genannten enum-Werte (snake_case).
 - Bei Unklarheit lieber `na` und niedrige confidence.
 JSON-Schema:
 {{
  "political_orientation": "...",
  "media_type": "...",
  "reliability": "...",
  "alignments": ["..."],
  "state_affiliated": false,
  "country_code": "DE",
  "confidence": 0.9,
  "reasoning": "..."
 }}"""
 async def _load_sample_articles(db: aiosqlite.Connection, name: str, domain: str | None, limit: int = 5) -> list[dict]:
    """Laedt die letzten Headlines einer Quelle (per name oder Domain-Match)."""
    rows: list = []
    if name:
        cursor = await db.execute(
            "SELECT headline, headline_de FROM articles WHERE source = ? ORDER BY collected_at DESC LIMIT ?",
            (name, limit),
        )
        rows = await cursor.fetchall()
    if not rows and domain:
        cursor = await db.execute(
            "SELECT headline, headline_de FROM articles WHERE source_url LIKE ? ORDER BY collected_at DESC LIMIT ?",
            (f"%{domain}%", limit),
        )
        rows = await cursor.fetchall()
    return [dict(r) for r in rows]
 def _validate(parsed: dict) -> dict:
    """Validiert + normalisiert eine LLM-Antwort gegen die Enums."""
    pol = parsed.get("political_orientation", "na")
    if pol not in POLITICAL_VALUES:
        pol = "na"
    mt = parsed.get("media_type", "sonstige")
    if mt not in MEDIA_TYPE_VALUES:
        mt = "sonstige"
    rel = parsed.get("reliability", "na")
    if rel not in RELIABILITY_VALUES:
        rel = "na"
    aligns_raw = parsed.get("alignments") or []
    if not isinstance(aligns_raw, list):
        aligns_raw = []
    aligns = sorted({a for a in aligns_raw if isinstance(a, str) and a in ALIGNMENT_VALUES})
    sa = bool(parsed.get("state_affiliated", False))
    cc = parsed.get("country_code")
    if isinstance(cc, str) and len(cc) == 2 and cc.isalpha():
        cc = cc.upper()
    else:
        cc = None
    try:
        confidence = float(parsed.get("confidence", 0.5))
        confidence = max(0.0, min(1.0, confidence))
    except (TypeError, ValueError):
        confidence = 0.5
    reasoning = str(parsed.get("reasoning", ""))[:1000]
    return {
        "political_orientation": pol,
        "media_type": mt,
        "reliability": rel,
        "alignments": aligns,
        "state_affiliated": sa,
        "country_code": cc,
        "confidence": confidence,
        "reasoning": reasoning,
    }
 async def classify_source(
    db: aiosqlite.Connection,
    source_id: int,
    sample_limit: int = 5,
    model: str = CLAUDE_MODEL_FAST,
 ) -> dict:
    """Klassifiziert eine einzelne Quelle und schreibt die Vorschlaege in proposed_*-Spalten."""
    cursor = await db.execute(
        "SELECT id, name, url, domain, source_type, category, language, bias, "
        "classification_source FROM sources WHERE id = ?",
        (source_id,),
    )
    row = await cursor.fetchone()
    if not row:
        raise ValueError(f"Quelle {source_id} nicht gefunden")
    src = dict(row)
    sample = await _load_sample_articles(db, src["name"], src.get("domain"), sample_limit)
    prompt = _build_prompt(src, sample)
    response, usage = await call_claude(prompt, tools=None, model=model)
    json_match = re.search(r"\{.*\}", response, re.DOTALL)
    if not json_match:
        raise ValueError(f"Keine JSON-Antwort von Claude fuer source_id={source_id}: {response[:200]}")
    parsed = json.loads(json_match.group(0))
    result = _validate(parsed)
    # Nur classification_source auf 'llm_pending' setzen, wenn nicht bereits manuell/approved
    new_src = "CASE WHEN classification_source IN ('manual','llm_approved') THEN classification_source ELSE 'llm_pending' END"
    await db.execute(
        f"""UPDATE sources SET
            proposed_political_orientation = ?,
            proposed_media_type = ?,
            proposed_reliability = ?,
            proposed_state_affiliated = ?,
            proposed_country_code = ?,
            proposed_alignments_json = ?,
            proposed_confidence = ?,
            proposed_reasoning = ?,
            proposed_at = CURRENT_TIMESTAMP,
            classification_source = {new_src}
        WHERE id = ?""",
        (
            result["political_orientation"],
            result["media_type"],
            result["reliability"],
            1 if result["state_affiliated"] else 0,
            result["country_code"],
            json.dumps(result["alignments"], ensure_ascii=False),
            result["confidence"],
            result["reasoning"],
            source_id,
        ),
    )
    await db.commit()
    logger.info(
        "Klassifiziert source_id=%s '%s' -> %s/%s/%s conf=%.2f ($%.4f)",
        source_id, src["name"], result["political_orientation"],
        result["media_type"], result["reliability"], result["confidence"],
        usage.cost_usd,
    )
    result["source_id"] = source_id
    result["usage"] = {
        "cost_usd": usage.cost_usd,
        "input_tokens": usage.input_tokens,
        "output_tokens": usage.output_tokens,
    }
    return result
 async def bulk_classify(
    db: aiosqlite.Connection,
    limit: int = 50,
    only_unclassified: bool = True,
    model: str = CLAUDE_MODEL_FAST,
 ) -> dict:
    """Klassifiziert noch unklassifizierte Quellen (sequenziell).
    Args:
        limit: Maximale Anzahl Quellen pro Aufruf
        only_unclassified: Wenn True, nur classification_source='legacy'.
                           Wenn False, auch 'llm_pending' neu klassifizieren.
    """
    if only_unclassified:
        where = "classification_source = 'legacy'"
    else:
        where = "classification_source IN ('legacy', 'llm_pending')"
    cursor = await db.execute(
        f"SELECT id FROM sources WHERE {where} AND status = 'active' "
        f"AND source_type != 'excluded' ORDER BY id LIMIT ?",
        (limit,),
    )
    ids = [row["id"] for row in await cursor.fetchall()]
    total_cost = 0.0
    success = 0
    errors: list[dict] = []
    for sid in ids:
        try:
            r = await classify_source(db, sid, model=model)
            total_cost += r["usage"]["cost_usd"]
            success += 1
        except asyncio.CancelledError:
            raise
        except Exception as e:
            logger.error("Klassifikation source_id=%s fehlgeschlagen: %s", sid, e, exc_info=True)
            errors.append({"source_id": sid, "error": str(e)})
    logger.info(
        "Bulk-Klassifikation fertig: %d/%d erfolgreich, $%.4f Kosten, %d Fehler",
        success, len(ids), total_cost, len(errors),
    )
    return {
        "processed": len(ids),
        "success": success,
        "errors": errors,
        "total_cost_usd": total_cost,
    }
--- a/src/static/css/style.css
+++ b/src/static/css/style.css
@@ -3503,203 +3503,6 @@ a.dev-source-pill:hover {
    color: var(--info);
 }
 /* Sources-Modal: Tabs */
 .sources-tabs {
    display: flex;
    gap: 2px;
    border-bottom: 1px solid var(--border-color, rgba(0,0,0,0.1));
    margin-bottom: 12px;
 }
 .sources-tab {
    background: transparent;
    border: none;
    padding: 8px 16px;
    font-size: 13px;
    font-weight: 500;
    color: var(--text-secondary, #555);
    cursor: pointer;
    border-bottom: 2px solid transparent;
    margin-bottom: -1px;
    display: inline-flex;
    align-items: center;
    gap: 8px;
 }
 .sources-tab:hover {
    color: var(--text-primary, #222);
 }
 .sources-tab.active {
    color: var(--primary, #2a81cb);
    border-bottom-color: var(--primary, #2a81cb);
 }
 .sources-tab-badge {
    display: inline-flex;
    align-items: center;
    justify-content: center;
    min-width: 20px;
    padding: 0 6px;
    height: 18px;
    border-radius: 9px;
    background: var(--primary, #2a81cb);
    color: #fff;
    font-size: 10px;
    font-weight: 700;
 }
 /* Review-Queue */
 .review-toolbar {
    display: flex;
    align-items: center;
    justify-content: space-between;
    padding: 8px 12px;
    background: var(--cat-sonstige-bg, #f6f6fa);
    border-radius: var(--radius);
    margin-bottom: 12px;
    flex-wrap: wrap;
    gap: 12px;
 }
 .review-toolbar-info {
    display: flex;
    align-items: center;
    gap: 16px;
    font-size: 13px;
 }
 .review-conf-filter {
    display: inline-flex;
    align-items: center;
    gap: 6px;
    font-size: 12px;
    color: var(--text-secondary, #555);
 }
 .review-conf-filter select {
    padding: 2px 6px;
    font-size: 12px;
    border-radius: var(--radius);
    border: 1px solid var(--border-color, rgba(0,0,0,0.15));
 }
 .review-toolbar-actions {
    display: flex;
    gap: 6px;
 }
 .review-list {
    display: flex;
    flex-direction: column;
    gap: 8px;
 }
 .review-card {
    background: var(--surface, #fff);
    border: 1px solid var(--border-color, rgba(0,0,0,0.08));
    border-radius: var(--radius);
    padding: 12px 14px;
 }
 .review-card-header {
    display: flex;
    justify-content: space-between;
    align-items: flex-start;
    gap: 12px;
    margin-bottom: 10px;
 }
 .review-card-title {
    display: flex;
    flex-wrap: wrap;
    align-items: center;
    gap: 8px;
 }
 .review-card-name {
    font-weight: 600;
    font-size: 14px;
 }
 .review-card-domain {
    font-size: 11px;
    color: var(--text-disabled, #888);
 }
 .review-global-badge {
    display: inline-flex;
    align-items: center;
    padding: 1px 6px;
    border-radius: var(--radius);
    background: #5e35b1;
    color: #fff;
    font-size: 9px;
    font-weight: 600;
    letter-spacing: 0.3px;
    text-transform: uppercase;
 }
 .review-card-confidence {
    display: inline-flex;
    flex-direction: column;
    align-items: center;
    padding: 4px 10px;
    border-radius: var(--radius);
    min-width: 60px;
 }
 .review-card-confidence .conf-value {
    font-size: 14px;
    font-weight: 700;
 }
 .review-card-confidence .conf-label {
    font-size: 9px;
    text-transform: uppercase;
    letter-spacing: 0.3px;
    opacity: 0.8;
 }
 .review-card-confidence.conf-high { background: #e8f5e9; color: #2e7d32; }
 .review-card-confidence.conf-medium { background: #fff8e1; color: #ef6c00; }
 .review-card-confidence.conf-low { background: #ffebee; color: #c62828; }
 .review-card-diff {
    display: grid;
    grid-template-columns: 1fr;
    gap: 4px;
    font-size: 12px;
    margin-bottom: 10px;
 }
 .review-diff-row {
    display: grid;
    grid-template-columns: 110px 1fr 24px 1fr;
    align-items: center;
    gap: 8px;
    padding: 3px 6px;
    border-radius: 3px;
 }
 .review-diff-row.changed {
    background: #fff8e1;
 }
 .review-diff-label {
    color: var(--text-secondary, #555);
    font-weight: 500;
 }
 .review-diff-current {
    color: var(--text-disabled, #888);
 }
 .review-diff-arrow {
    text-align: center;
    color: var(--text-disabled, #888);
    font-weight: 600;
 }
 .review-diff-proposed {
    color: var(--text-primary, #222);
    font-weight: 500;
 }
 .review-diff-row.changed .review-diff-proposed {
    color: #ef6c00;
    font-weight: 600;
 }
 .review-card-reasoning {
    font-size: 12px;
    color: var(--text-secondary, #555);
    background: var(--cat-sonstige-bg, #f6f6fa);
    padding: 8px 10px;
    border-radius: var(--radius);
    margin-bottom: 10px;
    line-height: 1.5;
 }
 .review-card-actions {
    display: flex;
    gap: 6px;
    flex-wrap: wrap;
 }
 /* Klassifikations-Badges (politisch / reliability / alignments / state) */
 .source-classification-badges {
@@ -3797,46 +3600,6 @@ a.dev-source-pill:hover {
    border: 1px solid rgba(0, 0, 0, 0.08);
 }
 /* Edit-Form: Klassifikations-Sektion */
 .sources-classification-section {
    margin-top: 12px;
    padding-top: 12px;
    border-top: 1px solid var(--border-color, rgba(0,0,0,0.08));
 }
 .sources-classification-header {
    font-size: 12px;
    font-weight: 600;
    color: var(--text-secondary, #555);
    margin-bottom: 8px;
    letter-spacing: 0.3px;
    text-transform: uppercase;
 }
 .alignment-chips {
    display: flex;
    flex-wrap: wrap;
    gap: 6px;
 }
 .alignment-chip {
    display: inline-flex;
    align-items: center;
    padding: 4px 10px;
    border-radius: 999px;
    font-size: 11px;
    font-weight: 500;
    background: transparent;
    color: var(--text-secondary, #555);
    border: 1px solid var(--border-color, rgba(0,0,0,0.15));
    cursor: pointer;
    transition: all 0.12s ease;
 }
 .alignment-chip:hover {
    background: var(--cat-sonstige-bg, #eef);
 }
 .alignment-chip.active {
    background: var(--primary, #2a81cb);
    color: #fff;
    border-color: var(--primary, #2a81cb);
 }
 /* Typ-Badges */
 .source-type-badge {
--- a/src/static/dashboard.html
+++ b/src/static/dashboard.html
@@ -456,15 +456,6 @@
                <!-- Stats-Leiste -->
                <div class="sources-stats-bar" id="sources-stats-bar"></div>
                <!-- Tabs: Liste vs. Klassifikations-Review -->
                <div class="sources-tabs" role="tablist">
                    <button type="button" class="sources-tab active" id="sources-tab-list" role="tab" aria-selected="true" onclick="App.switchSourcesTab('list')">Quellenliste</button>
                    <button type="button" class="sources-tab" id="sources-tab-review" role="tab" aria-selected="false" onclick="App.switchSourcesTab('review')" style="display:none;">Klassifikations-Review <span id="sources-review-count" class="sources-tab-badge">0</span></button>
                </div>
                <!-- View: Quellenliste -->
                <div id="sources-list-view">
                <!-- Toolbar -->
                <div class="sources-toolbar">
                    <div class="sources-filters">
@@ -627,89 +618,6 @@
                                <input type="text" id="src-notes" placeholder="Optional">
                            </div>
                        </div>
                        <div class="sources-classification-section">
                            <div class="sources-classification-header">Einordnung</div>
                            <div class="sources-add-form-grid">
                                <div class="form-group">
                                    <label for="src-political">Politische Ausrichtung</label>
                                    <select id="src-political">
                                        <option value="na">Nicht eingeordnet</option>
                                        <option value="links_extrem">Links (extrem)</option>
                                        <option value="links">Links</option>
                                        <option value="mitte_links">Mitte-Links</option>
                                        <option value="liberal">Liberal</option>
                                        <option value="mitte">Mitte</option>
                                        <option value="konservativ">Konservativ</option>
                                        <option value="mitte_rechts">Mitte-Rechts</option>
                                        <option value="rechts">Rechts</option>
                                        <option value="rechts_extrem">Rechts (extrem)</option>
                                    </select>
                                </div>
                                <div class="form-group">
                                    <label for="src-mediatype">Medientyp</label>
                                    <select id="src-mediatype">
                                        <option value="sonstige">Sonstige</option>
                                        <option value="tageszeitung">Tageszeitung</option>
                                        <option value="wochenzeitung">Wochenzeitung</option>
                                        <option value="magazin">Magazin</option>
                                        <option value="tv_sender">TV-Sender</option>
                                        <option value="radio">Radio</option>
                                        <option value="oeffentlich_rechtlich">Öffentlich-Rechtlich</option>
                                        <option value="nachrichtenagentur">Nachrichtenagentur</option>
                                        <option value="online_only">Online-only</option>
                                        <option value="blog">Blog</option>
                                        <option value="telegram_kanal">Telegram-Kanal</option>
                                        <option value="telegram_bot">Telegram-Bot</option>
                                        <option value="podcast">Podcast</option>
                                        <option value="social_media">Social Media</option>
                                        <option value="imageboard">Imageboard</option>
                                        <option value="think_tank">Think Tank</option>
                                        <option value="ngo">NGO</option>
                                        <option value="behoerde">Behörde</option>
                                        <option value="staatsmedium">Staatsmedium</option>
                                        <option value="fachmedium">Fachmedium</option>
                                    </select>
                                </div>
                                <div class="form-group">
                                    <label for="src-reliability">Glaubwürdigkeit</label>
                                    <select id="src-reliability">
                                        <option value="na">Nicht eingeordnet</option>
                                        <option value="sehr_hoch">Sehr hoch</option>
                                        <option value="hoch">Hoch</option>
                                        <option value="gemischt">Gemischt</option>
                                        <option value="niedrig">Niedrig</option>
                                        <option value="sehr_niedrig">Sehr niedrig</option>
                                    </select>
                                </div>
                                <div class="form-group">
                                    <label for="src-country">Land (ISO 3166)</label>
                                    <input type="text" id="src-country" maxlength="2" placeholder="z.B. DE, RU, US" style="text-transform:uppercase;">
                                </div>
                                <div class="form-group">
                                    <label class="checkbox-label" style="display:flex;align-items:center;gap:8px;">
                                        <input type="checkbox" id="src-state-affiliated">
                                        <span>Staatsnah/-kontrolliert</span>
                                    </label>
                                </div>
                            </div>
                            <div class="form-group" style="margin-top:8px;">
                                <label>Geopolitische Nähe (Mehrfachauswahl)</label>
                                <div id="src-alignments-chips" class="alignment-chips" onclick="App.handleAlignmentChipClick(event)">
                                    <button type="button" class="alignment-chip" data-alignment="prorussisch">prorussisch</button>
                                    <button type="button" class="alignment-chip" data-alignment="proiranisch">proiranisch</button>
                                    <button type="button" class="alignment-chip" data-alignment="prowestlich">prowestlich</button>
                                    <button type="button" class="alignment-chip" data-alignment="proukrainisch">proukrainisch</button>
                                    <button type="button" class="alignment-chip" data-alignment="prochinesisch">prochinesisch</button>
                                    <button type="button" class="alignment-chip" data-alignment="projapanisch">projapanisch</button>
                                    <button type="button" class="alignment-chip" data-alignment="proisraelisch">proisraelisch</button>
                                    <button type="button" class="alignment-chip" data-alignment="propalaestinensisch">propalästinensisch</button>
                                    <button type="button" class="alignment-chip" data-alignment="protuerkisch">protürkisch</button>
                                    <button type="button" class="alignment-chip" data-alignment="panarabisch">panarabisch</button>
                                    <button type="button" class="alignment-chip" data-alignment="neutral">neutral</button>
                                    <button type="button" class="alignment-chip" data-alignment="sonstige">sonstige</button>
                                </div>
                            </div>
                        </div>
                        <div class="sources-discovery-actions">
                            <button class="btn btn-primary btn-small" onclick="App.saveSource()">Speichern</button>
                            <button class="btn btn-secondary btn-small" onclick="App.toggleSourceForm(false)">Abbrechen</button>
@@ -721,36 +629,6 @@
                <div class="sources-list" id="sources-list">
                    <div class="empty-state-text" style="padding:var(--sp-3xl);text-align:center;">Lade Quellen...</div>
                </div>
                </div>
                <!-- /sources-list-view -->
                <!-- View: Klassifikations-Review (Admin-only) -->
                <div id="sources-review-view" style="display:none;">
                    <div class="review-toolbar">
                        <div class="review-toolbar-info">
                            <span><strong id="review-pending-count">0</strong> Vorschlaege ausstehend</span>
                            <label class="review-conf-filter">
                                Mindest-Konfidenz:
                                <select id="review-min-confidence" onchange="App.loadClassificationQueue()">
                                    <option value="0">alle</option>
                                    <option value="0.5">0.5+</option>
                                    <option value="0.7">0.7+</option>
                                    <option value="0.85">0.85+</option>
                                    <option value="0.9">0.9+</option>
                                </select>
                            </label>
                        </div>
                        <div class="review-toolbar-actions">
                            <button class="btn btn-small btn-secondary" onclick="App.triggerExternalReputationSync()" title="IFCN-Faktenchecker-Liste und EUvsDisinfo-Daten synchronisieren">Externe Daten syncen</button>
                            <button class="btn btn-small btn-secondary" onclick="App.triggerBulkClassify()" title="LLM-Klassifikation fuer noch unklassifizierte Quellen starten">+ Klassifikation starten</button>
                            <button class="btn btn-small btn-primary" onclick="App.bulkApproveHighConfidence()" title="Alle Vorschlaege ueber dem Konfidenz-Schwellwert genehmigen">Alle &ge; 0.85 genehmigen</button>
                        </div>
                    </div>
                    <div class="review-list" id="sources-review-list">
                        <div class="empty-state-text" style="padding:var(--sp-3xl);text-align:center;">Lade Review-Queue...</div>
                    </div>
                </div>
            </div>
        </div>
    </div>
--- a/src/static/js/api.js
+++ b/src/static/js/api.js
@@ -209,35 +209,6 @@ const API = {
        return this._request('GET', `/sources${qs ? '?' + qs : ''}`);
    },
    // Sources: Klassifikations-Review (LLM)
    getClassificationStats() {
        return this._request('GET', '/sources/classification/stats');
    },
    getClassificationQueue(limit = 50, minConfidence = 0.0) {
        const qs = new URLSearchParams({ limit: String(limit), min_confidence: String(minConfidence) }).toString();
        return this._request('GET', `/sources/classification/queue?${qs}`);
    },
    approveClassification(id) {
        return this._request('POST', `/sources/${id}/classification/approve`);
    },
    rejectClassification(id) {
        return this._request('POST', `/sources/${id}/classification/reject`);
    },
    reclassifySource(id) {
        return this._request('POST', `/sources/${id}/classification/reclassify`);
    },
    triggerBulkClassify(limit = 50, onlyUnclassified = true) {
        const qs = new URLSearchParams({ limit: String(limit), only_unclassified: String(onlyUnclassified) }).toString();
        return this._request('POST', `/sources/classification/bulk-classify?${qs}`);
    },
    bulkApproveClassifications(minConfidence = 0.85) {
        const qs = new URLSearchParams({ min_confidence: String(minConfidence) }).toString();
        return this._request('POST', `/sources/classification/bulk-approve?${qs}`);
    },
    triggerExternalReputationSync() {
        return this._request('POST', '/sources/external-reputation/sync');
    },
    createSource(data) {
        return this._request('POST', '/sources', data);
    },
--- a/src/static/js/app.js
+++ b/src/static/js/app.js
@@ -2702,12 +2702,6 @@ async handleRefresh() {
    async openSourceManagement() {
        openModal('modal-sources');
        await this.loadSources();
        // Admin sieht den Review-Tab
        const reviewTab = document.getElementById('sources-tab-review');
        if (reviewTab && this.user && this.user.role === 'org_admin') {
            reviewTab.style.display = '';
            this._refreshReviewBadge().catch(() => {});
        }
    },
    async loadSources() {
@@ -2728,122 +2722,6 @@ async handleRefresh() {
        }
    },
    async _refreshReviewBadge() {
        try {
            const stats = await API.getClassificationStats();
            const badge = document.getElementById('sources-review-count');
            if (badge) badge.textContent = String(stats.pending_review || 0);
        } catch (_) { /* still ok */ }
    },
    switchSourcesTab(tab) {
        const listView = document.getElementById('sources-list-view');
        const reviewView = document.getElementById('sources-review-view');
        const tabList = document.getElementById('sources-tab-list');
        const tabReview = document.getElementById('sources-tab-review');
        if (!listView || !reviewView) return;
        if (tab === 'review') {
            listView.style.display = 'none';
            reviewView.style.display = '';
            if (tabList) { tabList.classList.remove('active'); tabList.setAttribute('aria-selected', 'false'); }
            if (tabReview) { tabReview.classList.add('active'); tabReview.setAttribute('aria-selected', 'true'); }
            this.loadClassificationQueue();
        } else {
            listView.style.display = '';
            reviewView.style.display = 'none';
            if (tabList) { tabList.classList.add('active'); tabList.setAttribute('aria-selected', 'true'); }
            if (tabReview) { tabReview.classList.remove('active'); tabReview.setAttribute('aria-selected', 'false'); }
        }
    },
    async loadClassificationQueue() {
        const list = document.getElementById('sources-review-list');
        if (!list) return;
        const minConf = parseFloat(document.getElementById('review-min-confidence')?.value || '0');
        list.innerHTML = '<div class="empty-state-text" style="padding:var(--sp-3xl);text-align:center;">Lade...</div>';
        try {
            const items = await API.getClassificationQueue(200, minConf);
            this._reviewItems = items;
            const countEl = document.getElementById('review-pending-count');
            if (countEl) countEl.textContent = String(items.length);
            if (items.length === 0) {
                list.innerHTML = '<div class="empty-state-text" style="padding:var(--sp-3xl);text-align:center;">Keine ausstehenden Vorschlaege.</div>';
                return;
            }
            list.innerHTML = items.map(item => UI.renderClassificationQueueItem(item)).join('');
        } catch (err) {
            list.innerHTML = `<div class="empty-state-text" style="padding:var(--sp-3xl);text-align:center;color:var(--danger);">Fehler: ${err.message}</div>`;
        }
    },
    async approveClassification(id) {
        try {
            await API.approveClassification(id);
            UI.showToast('Klassifikation uebernommen.', 'success');
            await this.loadClassificationQueue();
            this._refreshReviewBadge();
        } catch (err) {
            UI.showToast('Approve fehlgeschlagen: ' + err.message, 'error');
        }
    },
    async rejectClassification(id) {
        try {
            await API.rejectClassification(id);
            UI.showToast('Vorschlag verworfen.', 'success');
            await this.loadClassificationQueue();
            this._refreshReviewBadge();
        } catch (err) {
            UI.showToast('Reject fehlgeschlagen: ' + err.message, 'error');
        }
    },
    async reclassifySource(id) {
        const btn = document.querySelector(`[data-reclassify-id="${id}"]`);
        if (btn) { btn.disabled = true; btn.textContent = '...'; }
        try {
            await API.reclassifySource(id);
            UI.showToast('Neu klassifiziert.', 'success');
            await this.loadClassificationQueue();
        } catch (err) {
            UI.showToast('Reclassify fehlgeschlagen: ' + err.message, 'error');
        } finally {
            if (btn) { btn.disabled = false; btn.textContent = 'Neu klassifizieren'; }
        }
    },
    async triggerBulkClassify() {
        if (!confirm('Bulk-Klassifikation aller noch nicht klassifizierten Quellen starten? Lauft im Hintergrund (~3-5 Sek pro Quelle, ~0.02 USD pro Quelle).')) return;
        try {
            const r = await API.triggerBulkClassify(500, true);
            UI.showToast(`Bulk-Klassifikation gestartet (limit=${r.limit}). Nachschauen mit Reload.`, 'info');
        } catch (err) {
            UI.showToast('Start fehlgeschlagen: ' + err.message, 'error');
        }
    },
    async bulkApproveHighConfidence() {
        if (!confirm('Alle Vorschlaege mit Konfidenz >= 0.85 genehmigen?')) return;
        try {
            const r = await API.bulkApproveClassifications(0.85);
            UI.showToast(`${r.approved_count} Vorschlaege uebernommen.`, 'success');
            await this.loadClassificationQueue();
            this._refreshReviewBadge();
        } catch (err) {
            UI.showToast('Bulk-Approve fehlgeschlagen: ' + err.message, 'error');
        }
    },
    async triggerExternalReputationSync() {
        if (!confirm('IFCN- und EUvsDisinfo-Datenbanken jetzt syncen? Lauft im Hintergrund (~30 Sek).')) return;
        try {
            await API.triggerExternalReputationSync();
            UI.showToast('Externer Sync gestartet. Quellenliste in 30 Sek neu laden.', 'info');
        } catch (err) {
            UI.showToast('Sync fehlgeschlagen: ' + err.message, 'error');
        }
    },
    renderSourceStats(stats) {
        const bar = document.getElementById('sources-stats-bar');
        if (!bar) return;
@@ -3200,13 +3078,6 @@ async handleRefresh() {
            document.getElementById('src-discover-btn').disabled = false;
            document.getElementById('src-discover-btn').textContent = 'Erkennen';
            document.getElementById('src-type-select').value = 'rss_feed';
            // Klassifikations-Felder auf Default zurücksetzen
            const polEl = document.getElementById('src-political'); if (polEl) polEl.value = 'na';
            const mtEl = document.getElementById('src-mediatype'); if (mtEl) mtEl.value = 'sonstige';
            const relEl = document.getElementById('src-reliability'); if (relEl) relEl.value = 'na';
            const ccEl = document.getElementById('src-country'); if (ccEl) ccEl.value = '';
            const saEl = document.getElementById('src-state-affiliated'); if (saEl) saEl.checked = false;
            this._setAlignmentChips([]);
            // Save-Button Text zurücksetzen
            const saveBtn = document.querySelector('#src-discovery-result .sources-discovery-actions .btn-primary');
            if (saveBtn) saveBtn.textContent = 'Speichern';
@@ -3388,19 +3259,6 @@ async handleRefresh() {
            rss_url: source.url,
        };
        // Klassifikations-Felder setzen
        const polEl = document.getElementById('src-political');
        if (polEl) polEl.value = source.political_orientation || 'na';
        const mtEl = document.getElementById('src-mediatype');
        if (mtEl) mtEl.value = source.media_type || 'sonstige';
        const relEl = document.getElementById('src-reliability');
        if (relEl) relEl.value = source.reliability || 'na';
        const ccEl = document.getElementById('src-country');
        if (ccEl) ccEl.value = source.country_code || '';
        const saEl = document.getElementById('src-state-affiliated');
        if (saEl) saEl.checked = !!source.state_affiliated;
        this._setAlignmentChips(source.alignments || []);
        // Submit-Button-Text ändern
        const saveBtn = document.querySelector('#src-discovery-result .sources-discovery-actions .btn-primary');
        if (saveBtn) saveBtn.textContent = 'Quelle speichern';
@@ -3409,27 +3267,6 @@ async handleRefresh() {
        if (form) form.scrollIntoView({ behavior: 'smooth', block: 'start' });
    },
    _setAlignmentChips(active) {
        const chips = document.querySelectorAll('#src-alignments-chips .alignment-chip');
        const set = new Set((active || []).map(a => (a || '').toLowerCase()));
        chips.forEach(chip => {
            if (set.has(chip.dataset.alignment)) chip.classList.add('active');
            else chip.classList.remove('active');
        });
    },
    _getAlignmentChips() {
        return Array.from(document.querySelectorAll('#src-alignments-chips .alignment-chip.active'))
            .map(chip => chip.dataset.alignment);
    },
    handleAlignmentChipClick(e) {
        const chip = e.target.closest('.alignment-chip');
        if (!chip) return;
        e.preventDefault();
        chip.classList.toggle('active');
    },
    async saveSource() {
        const name = document.getElementById('src-name').value.trim();
        if (!name) {
@@ -3445,12 +3282,6 @@ async handleRefresh() {
            url: discovered.rss_url || (discovered.source_type === 'telegram_channel' ? (document.getElementById('src-domain').value || null) : null),
            domain: document.getElementById('src-domain').value.trim() || discovered.domain || null,
            notes: document.getElementById('src-notes').value.trim() || null,
            political_orientation: document.getElementById('src-political')?.value || 'na',
            media_type: document.getElementById('src-mediatype')?.value || 'sonstige',
            reliability: document.getElementById('src-reliability')?.value || 'na',
            country_code: (document.getElementById('src-country')?.value || '').trim().toUpperCase() || null,
            state_affiliated: !!document.getElementById('src-state-affiliated')?.checked,
            alignments: this._getAlignmentChips(),
        };
        if (!data.domain && discovered.domain) {
--- a/src/static/js/components.js
+++ b/src/static/js/components.js
@@ -1119,71 +1119,6 @@ const UI = {
        sonstige: 'sonstige',
    },
    /**
     * Eintrag in der Klassifikations-Review-Queue.
     * Zeigt Diff zwischen aktuellem Wert und LLM-Vorschlag.
     */
    renderClassificationQueueItem(item) {
        const cur = item.current || {};
        const prop = item.proposed || {};
        const conf = prop.confidence || 0;
        const confPct = Math.round(conf * 100);
        const confClass = conf >= 0.85 ? 'high' : (conf >= 0.7 ? 'medium' : 'low');
        const diffRow = (label, currentVal, proposedVal, formatter) => {
            const fmt = formatter || (v => v == null || v === '' ? '–' : String(v));
            const c = fmt(currentVal);
            const p = fmt(proposedVal);
            const changed = c !== p;
            return `<div class="review-diff-row${changed ? ' changed' : ''}">
                <span class="review-diff-label">${this.escape(label)}</span>
                <span class="review-diff-current">${this.escape(c)}</span>
                <span class="review-diff-arrow">→</span>
                <span class="review-diff-proposed">${this.escape(p)}</span>
            </div>`;
        };
        const polFmt = v => (v && v !== 'na') ? (this._politicalLabels[v]?.full || v) : '–';
        const mtFmt = v => (v && v !== 'sonstige') ? (this._mediaTypeLabels[v] || v) : (v === 'sonstige' ? 'Sonstige' : '–');
        const relFmt = v => (v && v !== 'na') ? (this._reliabilityLabels[v] || v) : '–';
        const stateFmt = v => v ? 'ja' : 'nein';
        const ccFmt = v => v || '–';
        const alignFmt = v => (Array.isArray(v) && v.length > 0)
            ? v.map(a => this._alignmentLabels[a] || a).join(', ')
            : '–';
        const globalBadge = item.is_global ? '<span class="review-global-badge">Grundquelle</span>' : '';
        const reasoning = prop.reasoning ? this.escape(prop.reasoning) : '';
        return `<div class="review-card" data-source-id="${item.id}">
            <div class="review-card-header">
                <div class="review-card-title">
                    <span class="review-card-name">${this.escape(item.name)}</span>
                    ${globalBadge}
                    <span class="review-card-domain">${this.escape(item.domain || '')}</span>
                </div>
                <div class="review-card-confidence conf-${confClass}" title="LLM-Konfidenz">
                    <span class="conf-value">${confPct}%</span>
                    <span class="conf-label">Konfidenz</span>
                </div>
            </div>
            <div class="review-card-diff">
                ${diffRow('Politik', cur.political_orientation, prop.political_orientation, polFmt)}
                ${diffRow('Medientyp', cur.media_type, prop.media_type, mtFmt)}
                ${diffRow('Glaubwürdigkeit', cur.reliability, prop.reliability, relFmt)}
                ${diffRow('Staatsnah', cur.state_affiliated, prop.state_affiliated, stateFmt)}
                ${diffRow('Land', cur.country_code, prop.country_code, ccFmt)}
                ${diffRow('Geopol. Nähe', cur.alignments, prop.alignments, alignFmt)}
            </div>
            ${reasoning ? `<div class="review-card-reasoning"><strong>Begründung:</strong> ${reasoning}</div>` : ''}
            <div class="review-card-actions">
                <button class="btn btn-small btn-primary" onclick="App.approveClassification(${item.id})">Übernehmen</button>
                <button class="btn btn-small btn-secondary" onclick="App.rejectClassification(${item.id})">Verwerfen</button>
                <button class="btn btn-small btn-secondary" data-reclassify-id="${item.id}" onclick="App.reclassifySource(${item.id})">Neu klassifizieren</button>
            </div>
        </div>`;
    },
    _renderClassificationBadges(feed) {
        const parts = [];
        const pol = feed.political_orientation;