diff --git a/article_server.py b/article_server.py
index 101d4bc..6900192 100644
--- a/article_server.py
+++ b/article_server.py
@@ -1,7 +1,8 @@
 #!/usr/bin/env python3
 """Article Index Server — with IDs, meta extraction, image upload, and multi-threading.
 v2: Added 'Markierte veröffentlichen' (Joomla API publish), article-image association,
-    and automatic VG-Wort tracking pixel injection."""
+    and automatic VG-Wort tracking pixel injection.
+v3: Added NanoBanana Image Generator (/nanobanana)."""
 
 import os
 import re
@@ -11,9 +12,12 @@ import base64
 import hashlib
 import socket
 import urllib.parse
+import urllib.request
 import io
 import email.parser
 import tempfile
+import subprocess
+import time
 from http.server import HTTPServer, BaseHTTPRequestHandler
 from datetime import datetime
 from socketserver import ThreadingMixIn
@@ -62,6 +66,87 @@ MONTHS = {
     "September": 9, "Oktober": 10, "November": 11, "Dezember": 12
 }
 
+# ── NanoBanana API Configuration ──────────────────────────────────────────
+NANOBANANA_API_URL = "https://api.nanobananaapi.ai"
+NANOBANANA_UPLOAD_DIR = "/tmp/nanobanana_uploads"
+os.makedirs(NANOBANANA_UPLOAD_DIR, exist_ok=True)
+
+def _get_nanobanana_key() -> str:
+    """NanoBanana API-Key aus bsn-secrets lesen."""
+    try:
+        r = subprocess.run(
+            ["/home/hermes/bin/bsn-secrets", "get", "bsn/nanobanana-key"],
+            capture_output=True, text=True, timeout=5
+        )
+        return r.stdout.strip()
+    except Exception:
+        return os.environ.get("NANOBANANA_API_KEY", "")
+
+def _nanobanana_generate(prompt: str, image_urls: list, aspect_ratio: str, resolution: str) -> dict:
+    """NanoBanana generate-2 API aufrufen."""
+    key = _get_nanobanana_key()
+    if not key:
+        return {"error": "Kein API-Key"}
+    
+    data = json.dumps({
+        "prompt": prompt,
+        "imageUrls": image_urls if image_urls else [],
+        "aspectRatio": aspect_ratio,
+        "resolution": resolution,
+        "outputFormat": "jpg",
+    }).encode()
+    
+    req = urllib.request.Request(
+        f"{NANOBANANA_API_URL}/api/v1/nanobanana/generate-2",
+        data=data, method="POST"
+    )
+    req.add_header("Authorization", "Bearer " + key)
+    req.add_header("Content-Type", "application/json")
+    req.add_header("User-Agent", "Mozilla/5.0")  # Cloudflare-Workaround
+    
+    try:
+        with urllib.request.urlopen(req, timeout=30) as resp:
+            return json.loads(resp.read())
+    except urllib.error.HTTPError as e:
+        return {"error": f"HTTP {e.code}: {e.read().decode()[:300]}"}
+
+def _nanobanana_status(task_id: str) -> dict:
+    """NanoBanana Task-Status abrufen."""
+    key = _get_nanobanana_key()
+    if not key:
+        return {"error": "Kein API-Key"}
+    
+    req = urllib.request.Request(
+        f"{NANOBANANA_API_URL}/api/v1/nanobanana/record-info?taskId={task_id}"
+    )
+    req.add_header("Authorization", "Bearer " + key)
+    req.add_header("User-Agent", "Mozilla/5.0")
+    
+    try:
+        with urllib.request.urlopen(req, timeout=15) as resp:
+            return json.loads(resp.read())
+    except urllib.error.HTTPError as e:
+        return {"error": f"HTTP {e.code}"}
+
+def _get_unpublished_articles() -> list[dict]:
+    """Liste aller unveröffentlichten Artikel (ohne joomla-id)."""
+    articles = []
+    for f in sorted(glob.glob(os.path.join(WORKSPACE, "*.html")), key=os.path.getmtime, reverse=True):
+        name = os.path.basename(f)
+        if any(re.search(p, name) for p in SKIP_PATTERNS):
+            continue
+        try:
+            with open(f, "r") as fh:
+                content = fh.read(5000)
+            has_joomla_id = '<meta name="joomla-id"' in content
+            if not has_joomla_id:
+                title_match = re.search(r'<title>(.*?)</title>', content)
+                title = title_match.group(1).strip() if title_match else name
+                articles.append({"filename": name, "title": title})
+        except Exception:
+            pass
+    return articles[:50]  # Max 50
+
 SKIP_PATTERNS = [
     r'^ddg\d*\.html', r'^google', r'^bgg_(search|thread|game|price)',
     r'^bk_', r'^backerkit', r'^brave_search', r'^fb_post', r'^reddit',
@@ -127,7 +212,7 @@ def extract_meta(filepath: str) -> dict | None:
         return None
     title = title_match.group(1)
 
-    date_match = re.search(r'<p class="meta">(\d{1,2}\.\s*\w+\s*\d{4})', content)
+    date_match = re.search(r'<p class="meta">[^<]*?(\d{1,2}\.\s*(?:Januar|Februar|März|April|Mai|Juni|Juli|August|September|Oktober|November|Dezember)\s*\d{4})', content)
     if not date_match:
         return None
     date_str = date_match.group(1)
@@ -152,7 +237,7 @@ def extract_meta(filepath: str) -> dict | None:
         meta_tags = tag_match.group(1)
 
     joomla_id = ""
-    jid_match = re.search(r'<meta\s+name="joomla-id"\s+content="(\d+)"', content, re.IGNORECASE)
+    jid_match = re.search(r'<meta\s+name="joomla-id"\s+content="(\d+|XXXXX)"', content, re.IGNORECASE)
     if jid_match:
         joomla_id = jid_match.group(1)
 
@@ -792,6 +877,16 @@ h1{color:#c0392b;}p{color:#888;}</style></head>
             self.send_header("Content-Type", "text/html; charset=utf-8")
             self.end_headers()
             self.wfile.write(html.encode("utf-8"))
+        elif path == "/nanobanana":
+            html = self._build_nanobanana_page()
+            self.send_response(200)
+            self.send_header("Content-Type", "text/html; charset=utf-8")
+            self.end_headers()
+            self.wfile.write(html.encode("utf-8"))
+        elif path == "/nanobanana/articles":
+            self._handle_nanobanana_articles()
+        elif path == "/nanobanana/status":
+            self._handle_nanobanana_status()
         elif path.startswith("/media/"):
             rel = path[len("/"):]
             filepath = os.path.normpath(os.path.join(WORKSPACE, rel))
@@ -857,6 +952,22 @@ h1{color:#c0392b;}p{color:#888;}</style></head>
             if not self._check_token():
                 return
             self._handle_assign_image()
+        elif path == "/nanobanana/generate":
+            if not self._check_token():
+                return
+            self._handle_nanobanana_generate()
+        elif path == "/nanobanana/status":
+            if not self._check_token():
+                return
+            self._handle_nanobanana_status()
+        elif path == "/nanobanana/articles":
+            if not self._check_token():
+                return
+            self._handle_nanobanana_articles()
+        elif path == "/nanobanana/assign":
+            if not self._check_token():
+                return
+            self._handle_nanobanana_assign()
         elif path == "/delete":
             if not self._check_auth():
                 return
@@ -869,6 +980,167 @@ h1{color:#c0392b;}p{color:#888;}</style></head>
             self.send_response(404)
             self.end_headers()
 
+    # ═══════════════════════════════════════════════════════════════════
+    # NanoBanana Handler
+    # ═══════════════════════════════════════════════════════════════════
+
+    def _handle_nanobanana_generate(self):
+        """NanoBanana Bildgenerierung starten."""
+        content_type = self.headers.get("Content-Type", "")
+        if "multipart/form-data" not in content_type:
+            self._json_reply(400, {"ok": False, "error": "Expected multipart/form-data"})
+            return
+        
+        boundary = content_type.split("boundary=")[-1].strip()
+        if not boundary:
+            self._json_reply(400, {"ok": False, "error": "Kein Boundary"})
+            return
+        
+        length = int(self.headers.get("Content-Length", 0))
+        raw = self.rfile.read(length)
+        
+        # Multipart manuell parsen (Python 3.13 hat kein cgi)
+        parts = raw.split(b"--" + boundary.encode())
+        prompt = ""
+        image_urls = []
+        aspect_ratio = "16:9"
+        resolution = "2K"
+        
+        for part in parts:
+            if b"Content-Disposition" not in part:
+                continue
+            headers_end = part.find(b"\r\n\r\n")
+            if headers_end == -1:
+                continue
+            headers_raw = part[:headers_end].decode("utf-8", errors="ignore")
+            content = part[headers_end + 4:]
+            content = content.rstrip(b"\r\n")
+            
+            if 'name="prompt"' in headers_raw:
+                prompt = content.decode("utf-8", errors="ignore")
+            elif 'name="aspectRatio"' in headers_raw:
+                aspect_ratio = content.decode("utf-8", errors="ignore")
+            elif 'name="resolution"' in headers_raw:
+                resolution = content.decode("utf-8", errors="ignore")
+            elif 'name="image"' in headers_raw and len(content) > 100:
+                # Bild als Data-URL für die NanoBanana API
+                import base64 as b64
+                b64_data = b64.b64encode(content).decode()
+                ct = "image/jpeg"
+                if b"Content-Type" in part:
+                    ct_line = [l for l in headers_raw.split("\r\n") if "Content-Type" in l]
+                    if ct_line:
+                        ct = ct_line[0].split(":")[-1].strip()
+                image_urls.append(f"data:{ct};base64,{b64_data}")
+        
+        if not prompt:
+            self._json_reply(400, {"ok": False, "error": "Prompt fehlt"})
+            return
+        
+        result = _nanobanana_generate(prompt, image_urls, aspect_ratio, resolution)
+        if "error" in result:
+            self._json_reply(500, {"ok": False, "error": result["error"]})
+            return
+        
+        task_id = result.get("data", {}).get("taskId", "")
+        self._json_reply(200, {"ok": True, "taskId": task_id})
+
+    def _handle_nanobanana_status(self):
+        """NanoBanana Task-Status abrufen."""
+        parsed = urllib.parse.urlparse(self.path)
+        params = urllib.parse.parse_qs(parsed.query)
+        task_id = params.get("taskId", [""])[0]
+        
+        if not task_id:
+            self._json_reply(400, {"ok": False, "error": "taskId fehlt"})
+            return
+        
+        result = _nanobanana_status(task_id)
+        if "error" in result:
+            self._json_reply(500, {"ok": False, "error": result["error"]})
+            return
+        
+        data = result.get("data", {})
+        self._json_reply(200, {
+            "ok": True,
+            "successFlag": data.get("successFlag"),
+            "resultImageUrl": data.get("response", {}).get("resultImageUrl"),
+            "completeTime": data.get("completeTime"),
+        })
+
+    def _handle_nanobanana_articles(self):
+        """Liste unveröffentlichter Artikel als JSON."""
+        articles = _get_unpublished_articles()
+        self._json_reply(200, {"ok": True, "articles": articles})
+
+    def _handle_nanobanana_assign(self):
+        """Bild einem Artikel zuordnen."""
+        content_type = self.headers.get("Content-Type", "")
+        if "application/json" not in content_type:
+            self._json_reply(400, {"ok": False, "error": "Expected JSON"})
+            return
+        
+        length = int(self.headers.get("Content-Length", 0))
+        raw = self.rfile.read(length)
+        try:
+            data = json.loads(raw)
+        except json.JSONDecodeError:
+            self._json_reply(400, {"ok": False, "error": "Invalid JSON"})
+            return
+        
+        article = data.get("article", "")
+        image_url = data.get("imageUrl", "")
+        
+        if not article or not image_url:
+            self._json_reply(400, {"ok": False, "error": "article und imageUrl erforderlich"})
+            return
+        
+        # Bild herunterladen
+        try:
+            req = urllib.request.Request(image_url)
+            req.add_header("User-Agent", "Mozilla/5.0")
+            with urllib.request.urlopen(req, timeout=30) as resp:
+                img_data = resp.read()
+        except Exception as e:
+            self._json_reply(500, {"ok": False, "error": f"Download fehlgeschlagen: {e}"})
+            return
+        
+        # In media/YYYY/MM/ speichern
+        now = datetime.now()
+        month_dir = os.path.join(MEDIA_DIR, now.strftime("%Y"), now.strftime("%m"))
+        os.makedirs(month_dir, exist_ok=True)
+        ts = now.strftime("%H%M%S")
+        fname = f"nanobanana_{ts}.jpg"
+        fpath = os.path.join(month_dir, fname)
+        
+        with open(fpath, "wb") as f:
+            f.write(img_data)
+        
+        # article_images.json updaten
+        img_map = get_image_map()
+        if article not in img_map:
+            img_map[article] = []
+        img_map[article].append(fpath)
+        save_image_map(img_map)
+        
+        self._json_reply(200, {"ok": True, "path": fpath, "filename": fname})
+
+    def _build_nanobanana_page(self) -> str:
+        """Baut die NanoBanana Editor HTML-Seite."""
+        articles = _get_unpublished_articles()
+        article_options = ""
+        for a in articles[:30]:
+            article_options += f'<option value="{a["filename"]}">{a["title"]}</option>\n'
+        
+        return NANOBANANA_HTML.format(
+            key=ACCESS_TOKEN,
+            article_options=article_options,
+        )
+
+    # ═══════════════════════════════════════════════════════════════════
+    # End NanoBanana Handler
+    # ═══════════════════════════════════════════════════════════════════
+
     def _handle_upload(self):
         """Handle multipart file upload — now accepts 'article' field for association."""
         content_type = self.headers.get("Content-Type", "")
@@ -1041,6 +1313,7 @@ h1{color:#c0392b;}p{color:#888;}</style></head>
             return
 
         published = 0
+        published_ids = []
         images_deleted_total = 0
         errors = []
         img_map = get_image_map()
@@ -1112,14 +1385,25 @@ h1{color:#c0392b;}p{color:#888;}</style></head>
                     body_match = re.search(r'(?:</header>|</head>)(.*?)(?:<footer|<div class="quellen"|</body)', html_content, re.DOTALL)
                 article_body = body_match.group(1) if body_match else html_content
 
-                # ── Strip H1 + Meta-Zeile aus dem Body ─────────────────
-                # Daniel 19.06.: Titel und Lesezeit-Zeile dürfen NICHT im
-                # Fließtext landen — sie werden von Joomla separat gerendert.
+                # ── Strip internal markers from article body ──────────────
+                # These are editorial metadata, not part of the published article.
+                # Applied AFTER extraction but BEFORE read-more split.
                 article_body = re.sub(r'<h1[^>]*>.*?</h1>\s*', '', article_body, flags=re.DOTALL)
                 article_body = re.sub(r'<p\s+class="meta"[^>]*>.*?</p>\s*', '', article_body, flags=re.DOTALL)
+                article_body = re.sub(r'<p\s+class="qc"[^>]*>.*?</p>\s*', '', article_body, flags=re.DOTALL)
+                # ── Umbruch vor Überschriften (Daniel 19.06.: bessere Lesbarkeit) ──
+                article_body = re.sub(r'(</(?:p|/div|/blockquote)>)\\s*(<h[234])', r'\\1\\n<br>\\n\\3', article_body)
+                # ── Remove <br> after read-more (muss NACH Umbruch-Insertion laufen!) ──
+                article_body = re.sub(
+                    r'(<hr\s+id="system-readmore"\s*/?>)\s*<br\s*/?>\s*',
+                    r'\1\n',
+                    article_body, flags=re.IGNORECASE
+                )
+                # ── Strip trailing whitespace/newlines before closing </article> ──
+                article_body = re.sub(r'\s*</article>', '</article>', article_body)
 
                 # Extract Joomla ID if present (for updates)
-                jid_match = re.search(r'<meta\s+name="joomla-id"\s+content="(\d+)"', html_content, re.IGNORECASE)
+                jid_match = re.search(r'<meta\s+name="joomla-id"\s+content="(\d+|XXXXX)"', html_content, re.IGNORECASE)
                 joomla_id = jid_match.group(1) if jid_match else None
 
                 # ── Kategorie: Rubrik vom Dropdown oder meta ──────────
@@ -1159,31 +1443,28 @@ h1{color:#c0392b;}p{color:#888;}</style></head>
                 # Generate alias from title
                 alias = re.sub(r'[^a-z0-9]+', '-', title.lower().strip())[:100]
 
-                # ── VG-Wort Zählmarke aus Pool holen & einbauen ─────────
-                # NUR bei LIVE-Artikeln (state=1)! Korrektur verbraucht keine Zählmarke.
+                # ── VG-Wort Zählmarke IMMER einbauen (auch bei Korrektur) ──
+                # Daniel 19.06.: Pixel muss bei JEDEM Publish rein, weil er
+                # später manuell live stellt und sonst kein Geld bekommt.
                 vgwort_pixel_html = ""
-                if state == 1:
-                    try:
-                        import subprocess
-                        result = subprocess.run(
-                            ["python3", os.path.expanduser("~/.hermes/vgwort_pool.py"), "get"],
-                            capture_output=True, text=True, timeout=30
-                        )
-                        if result.returncode == 0:
-                            pixel_data = json.loads(result.stdout)
-                            if pixel_data.get("ok"):
-                                vgwort_pixel_html = pixel_data.get("pixel_html", "")
-                                print(f"[VG-Wort] Zählmarke {pixel_data.get('public_id')} eingebaut, "
-                                      f"Pool: {pixel_data.get('pool_remaining')} übrig", flush=True)
-                            else:
-                                print(f"[VG-Wort] FEHLER: {pixel_data.get('error', 'unbekannt')}", flush=True)
+                try:
+                    import subprocess
+                    result = subprocess.run(
+                        ["python3", os.path.expanduser("~/.hermes/vgwort_pool.py"), "get"],
+                        capture_output=True, text=True, timeout=30
+                    )
+                    if result.returncode == 0:
+                        pixel_data = json.loads(result.stdout)
+                        if pixel_data.get("ok"):
+                            vgwort_pixel_html = pixel_data.get("pixel_html", "")
+                            print(f"[VG-Wort] Zählmarke {pixel_data.get('public_id')} eingebaut, "
+                                  f"Pool: {pixel_data.get('pool_remaining')} übrig", flush=True)
                         else:
-                            print(f"[VG-Wort] Pool-Script fehlgeschlagen: {result.stderr}", flush=True)
-                    except Exception as e:
-                        print(f"[VG-Wort] Ausnahme: {e}", flush=True)
-                else:
-                    print(f"[VG-Wort] Übersprungen — Artikel geht auf Korrektur (state=0), "
-                          f"Zählmarke erst bei Live-Gang", flush=True)
+                            print(f"[VG-Wort] FEHLER: {pixel_data.get('error', 'unbekannt')}", flush=True)
+                    else:
+                        print(f"[VG-Wort] Pool-Script fehlgeschlagen: {result.stderr}", flush=True)
+                except Exception as e:
+                    print(f"[VG-Wort] Ausnahme: {e}", flush=True)
 
                 if vgwort_pixel_html:
                     if '</article>' in article_body:
@@ -1198,10 +1479,20 @@ h1{color:#c0392b;}p{color:#888;}</style></head>
                     "X-Joomla-Token": JOOMLA_TOKEN,
                 }
 
+                # Joomla 5/6 PATCH-Fix: articletext wird ignoriert, muss in introtext + fulltext aufgeteilt werden
+                introtext = ""
+                fulltext = article_body.strip()
+                sr_match = re.search(r'<hr\s+id="system-readmore"\s*/?>', article_body, re.IGNORECASE)
+                if sr_match:
+                    split_idx = sr_match.end()
+                    introtext = article_body[:split_idx].strip()
+                    fulltext = article_body[split_idx:].strip()
+
                 article_payload = {
                     "title": title,
                     "alias": alias,
-                    "articletext": article_body.strip(),
+                    "introtext": introtext,
+                    "fulltext": fulltext,
                     "catid": catid,
                     "language": "*",
                     "state": state,
@@ -1214,44 +1505,60 @@ h1{color:#c0392b;}p{color:#888;}</style></head>
                     article_payload["metadesc"] = meta_desc_match.group(1).strip()
                 if meta_key_match and meta_key_match.group(1).strip():
                     article_payload["metakey"] = meta_key_match.group(1).strip()
-                # ── Image upload to Joomla ──────────────────────────────
+                # ── Image upload to Joomla (Joomla 5/6: Base64 + json, nicht multipart) ──
                 if fname in img_map and img_map[fname]:
                     image_path = img_map[fname][0]  # First image
                     if os.path.exists(image_path):
                         try:
+                            import base64 as b64
+                            from datetime import datetime as dt
                             img_filename = os.path.basename(image_path)
-                            ext = os.path.splitext(img_filename)[1].lower()
-                            mime_map = {".jpg": "image/jpeg", ".jpeg": "image/jpeg",
-                                       ".png": "image/png", ".webp": "image/webp",
-                                       ".gif": "image/gif"}
-                            mime_type = mime_map.get(ext, "image/jpeg")
+                            year = dt.now().strftime("%Y")
+                            j_img_path = f"Spiele/{year}/{img_filename}"  # OHNE images/ prefix (local-images root = images/)
+
                             with open(image_path, "rb") as img_f:
-                                from datetime import datetime as dt
-                                year = dt.now().strftime("%Y")
-                                img_resp = requests.post(
-                                    "https://www.brettspiel-news.de/api/index.php/v1/media",
-                                    headers={"X-Joomla-Token": JOOMLA_TOKEN},
-                                    data={"path": f"Spiele/{year}/"},
-                                    files={"file": (img_filename, img_f, mime_type)},
+                                img_content = b64.b64encode(img_f.read()).decode()
+
+                            img_resp = requests.post(
+                                "https://www.brettspiel-news.de/api/index.php/v1/media/files",
+                                headers={
+                                    "X-Joomla-Token": JOOMLA_TOKEN,
+                                    "Accept": "application/vnd.api+json",
+                                    "Content-Type": "application/json",
+                                },
+                                json={"path": j_img_path, "content": img_content},
+                                timeout=30
+                            )
+
+                            if img_resp.status_code == 400 and "exists" in img_resp.text:
+                                # Überschreiben existierender Datei
+                                print(f"[Image] {img_filename} existiert — überschreibe via PATCH", flush=True)
+                                img_resp = requests.patch(
+                                    f"https://www.brettspiel-news.de/api/index.php/v1/media/files/local-images:/{j_img_path}",
+                                    headers={
+                                        "X-Joomla-Token": JOOMLA_TOKEN,
+                                        "Accept": "application/vnd.api+json",
+                                        "Content-Type": "application/json",
+                                    },
+                                    json={"path": j_img_path, "content": img_content},
                                     timeout=30
                                 )
+
                             if img_resp.status_code in (200, 201):
-                                img_data = img_resp.json()
-                                # Joomla 4 returns the relative path
-                                j_img_path = None
-                                if "data" in img_data and "attributes" in img_data["data"]:
-                                    j_img_path = img_data["data"]["attributes"].get("path", "")
-                                if not j_img_path:
-                                    j_img_path = f"Spiele/{year}/{img_filename}"
+                                j_img_url = f"https://www.brettspiel-news.de/images/{j_img_path}"  # Web-URL braucht images/ Prefix
+                                # Joomla requires relative + joomlaImage pseudo-protocol
+                                # Format: images/Spiele/2026/file.jpg#joomlaImage://local-images/Spiele/2026/file.jpg
+                                # image_intro braucht images/ prefix, joomlaImage NICHT
+                                image_intro_value = f"images/{j_img_path}#joomlaImage://local-images/{j_img_path}"
                                 article_payload["images"] = {
-                                    "image_intro": j_img_path,
+                                    "image_intro": image_intro_value,
                                     "image_intro_alt": title,
-                                    "image_fulltext": j_img_path,
+                                    "image_fulltext": image_intro_value,
                                     "image_fulltext_alt": title,
                                 }
                                 print(f"[Image] Uploaded {img_filename} → {j_img_path}", flush=True)
                             else:
-                                print(f"[Image] Upload failed: HTTP {img_resp.status_code}", flush=True)
+                                print(f"[Image] Upload failed HTTP {img_resp.status_code}: {img_resp.text[:200]}", flush=True)
                         except Exception as e:
                             print(f"[Image] Upload error: {e}", flush=True)
                 if featured_up:
@@ -1284,8 +1591,11 @@ h1{color:#c0392b;}p{color:#888;}</style></head>
                         # Some responses nest the id differently
                         pass
 
-                    if new_jid and not joomla_id:
-                        # Inject <meta name="joomla-id"> into the HTML file
+                    if new_jid:
+                        published_ids.append(new_jid)
+
+                    if new_jid:
+                        # Immer Joomla-ID in die HTML-Datei schreiben (auch bei Updates)
                         if '<meta name="joomla-id"' not in html_content:
                             jid_meta = f'\n<meta name="joomla-id" content="{new_jid}">'
                             html_content = re.sub(
@@ -1296,7 +1606,7 @@ h1{color:#c0392b;}p{color:#888;}</style></head>
                             )
                         else:
                             html_content = re.sub(
-                                r'<meta\s+name="joomla-id"\s+content="(\d+)"',
+                                r'<meta\s+name="joomla-id"\s+content="([^"]*)"',
                                 f'<meta name="joomla-id" content="{new_jid}"',
                                 html_content
                             )
@@ -1326,6 +1636,7 @@ h1{color:#c0392b;}p{color:#888;}</style></head>
         self._json_reply(200 if published > 0 else 500, {
             "ok": published > 0,
             "published": published,
+            "published_ids": published_ids,
             "live_mode": allow_live,
             "images_deleted": images_deleted_total,
             "errors": errors,
@@ -1339,6 +1650,578 @@ h1{color:#c0392b;}p{color:#888;}</style></head>
         self.wfile.write(json.dumps(data).encode("utf-8"))
 
 
+# ═══════════════════════════════════════════════════════════════════════════
+# NanoBanana Editor HTML
+# ═══════════════════════════════════════════════════════════════════════════
+
+NANOBANANA_HTML = """<!DOCTYPE html>
+<html lang="de">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1.0">
+<title>BSN Bild-Generator — NanoBanana</title>
+<style>
+:root {{
+    --bsn-blue: #20228a;
+    --bsn-blue-light: #2d30b0;
+    --bg: #f5f6fa;
+    --card-bg: #fff;
+    --text: #1a1a2e;
+    --text-muted: #666;
+    --radius: 12px;
+    --shadow: 0 2px 12px rgba(0,0,0,0.08);
+}}
+* {{ box-sizing: border-box; margin: 0; padding: 0; }}
+body {{
+    font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', system-ui, sans-serif;
+    background: var(--bg);
+    color: var(--text);
+    min-height: 100vh;
+}}
+.header {{
+    background: var(--bsn-blue);
+    color: #fff;
+    padding: 16px 24px;
+    font-size: 1.3em;
+    font-weight: 700;
+    display: flex;
+    align-items: center;
+    gap: 10px;
+}}
+.header a {{
+    color: #fff;
+    font-size: 0.7em;
+    font-weight: 400;
+    opacity: 0.8;
+    text-decoration: none;
+    margin-left: auto;
+}}
+.container {{
+    max-width: 900px;
+    margin: 0 auto;
+    padding: 20px;
+}}
+.card {{
+    background: var(--card-bg);
+    border-radius: var(--radius);
+    box-shadow: var(--shadow);
+    padding: 24px;
+    margin-bottom: 20px;
+}}
+.card h2 {{
+    font-size: 1.1em;
+    margin-bottom: 16px;
+    color: var(--bsn-blue);
+}}
+/* Upload-Zone */
+.dropzone {{
+    border: 2px dashed #ccc;
+    border-radius: var(--radius);
+    padding: 40px 20px;
+    text-align: center;
+    cursor: pointer;
+    transition: all 0.3s;
+    background: #fafbfc;
+    min-height: 120px;
+    display: flex;
+    flex-direction: column;
+    align-items: center;
+    justify-content: center;
+    gap: 8px;
+}}
+.dropzone:hover, .dropzone.drag-over {{
+    border-color: var(--bsn-blue);
+    background: #eef0ff;
+}}
+.dropzone .icon {{ font-size: 2.5em; }}
+.dropzone .hint {{ color: var(--text-muted); font-size: 0.9em; }}
+.dropzone input[type=file] {{ display: none; }}
+.preview-box {{
+    position: relative;
+    display: inline-block;
+    margin-top: 12px;
+}}
+.preview-box img {{
+    max-height: 200px;
+    border-radius: 8px;
+    box-shadow: var(--shadow);
+}}
+.preview-box .remove-btn {{
+    position: absolute;
+    top: -8px;
+    right: -8px;
+    background: #e74c3c;
+    color: #fff;
+    border: none;
+    width: 28px;
+    height: 28px;
+    border-radius: 50%;
+    cursor: pointer;
+    font-size: 1.1em;
+    line-height: 1;
+}}
+/* Form */
+.form-row {{
+    display: flex;
+    gap: 12px;
+    margin-bottom: 12px;
+    flex-wrap: wrap;
+}}
+.form-row label {{
+    font-weight: 600;
+    font-size: 0.85em;
+    color: var(--text-muted);
+    display: block;
+    margin-bottom: 4px;
+}}
+.form-row > div {{ flex: 1; min-width: 140px; }}
+textarea, select, button {{
+    font-family: inherit;
+    font-size: 1em;
+    border-radius: 8px;
+    border: 1px solid #ddd;
+    padding: 10px 14px;
+    width: 100%;
+    background: #fff;
+    color: var(--text);
+}}
+textarea {{
+    min-height: 100px;
+    resize: vertical;
+    line-height: 1.5;
+}}
+textarea:focus, select:focus {{ border-color: var(--bsn-blue); outline: none; box-shadow: 0 0 0 3px rgba(32,34,138,0.1); }}
+.char-count {{ text-align: right; font-size: 0.8em; color: var(--text-muted); margin-top: 4px; }}
+/* Buttons */
+.btn {{
+    display: inline-flex;
+    align-items: center;
+    justify-content: center;
+    gap: 8px;
+    font-weight: 600;
+    cursor: pointer;
+    border: none;
+    border-radius: 8px;
+    padding: 12px 24px;
+    font-size: 1em;
+    transition: all 0.2s;
+    min-height: 48px;
+}}
+.btn-primary {{
+    background: var(--bsn-blue);
+    color: #fff;
+}}
+.btn-primary:hover {{ background: var(--bsn-blue-light); }}
+.btn-primary:disabled {{
+    background: #999;
+    cursor: not-allowed;
+}}
+.btn-secondary {{
+    background: #e0e0e0;
+    color: var(--text);
+}}
+.btn-download {{
+    background: #27ae60;
+    color: #fff;
+}}
+.btn-download:hover {{ background: #219a52; }}
+/* Ergebnis */
+.result-box {{
+    display: none;
+}}
+.result-box.visible {{
+    display: block;
+}}
+.result-box img {{
+    width: 100%;
+    max-height: 500px;
+    object-fit: contain;
+    border-radius: var(--radius);
+    box-shadow: var(--shadow);
+    margin-bottom: 16px;
+}}
+.result-actions {{
+    display: flex;
+    gap: 12px;
+    flex-wrap: wrap;
+}}
+/* Spinner */
+.spinner {{
+    display: none;
+    text-align: center;
+    padding: 40px 20px;
+}}
+.spinner.active {{
+    display: block;
+}}
+.spinner-icon {{
+    width: 48px;
+    height: 48px;
+    border: 4px solid #e0e0e0;
+    border-top-color: var(--bsn-blue);
+    border-radius: 50%;
+    animation: spin 0.8s linear infinite;
+    margin: 0 auto 16px;
+}}
+@keyframes spin {{ to {{ transform: rotate(360deg); }} }}
+.spinner-text {{ color: var(--text-muted); font-size: 0.95em; }}
+/* Toast */
+.toast {{
+    position: fixed;
+    bottom: 20px;
+    left: 50%;
+    transform: translateX(-50%);
+    background: #333;
+    color: #fff;
+    padding: 12px 24px;
+    border-radius: 8px;
+    font-size: 0.95em;
+    z-index: 1000;
+    opacity: 0;
+    transition: opacity 0.3s;
+    pointer-events: none;
+}}
+.toast.show {{ opacity: 1; }}
+.toast.success {{ background: #27ae60; }}
+.toast.error {{ background: #e74c3c; }}
+/* Mobile */
+@media (max-width: 600px) {{
+    .container {{ padding: 12px; }}
+    .card {{ padding: 16px; }}
+    .header {{ padding: 12px 16px; font-size: 1.1em; }}
+    .form-row {{ flex-direction: column; gap: 8px; }}
+    .result-actions {{ flex-direction: column; }}
+    .result-actions .btn {{ width: 100%; }}
+}}
+</style>
+</head>
+<body>
+<div class="header">
+    🎨 BSN Bild-Generator
+    <a href="/?key={key}">← Zurück zur Artikelübersicht</a>
+</div>
+
+<div class="container">
+
+    <!-- Foto-Upload -->
+    <div class="card">
+        <h2>📷 Referenzbild (optional)</h2>
+        <div class="dropzone" id="dropZone">
+            <span class="icon">🖼️</span>
+            <span class="hint">Foto hier ablegen oder klicken zum Auswählen</span>
+            <input type="file" id="fileInput" accept="image/*">
+        </div>
+        <div class="preview-box" id="previewBox" style="display:none">
+            <img id="previewImg" src="" alt="Vorschau">
+            <button class="remove-btn" id="removeBtn" title="Entfernen">✕</button>
+        </div>
+    </div>
+
+    <!-- Prompt -->
+    <div class="card">
+        <h2>✍️ Prompt</h2>
+        <textarea id="prompt" placeholder="Beschreibe das gewünschte Bild…&#10;&#10;Beispiele:&#10;• Professional board game photography of Catan, warm lighting, product shot&#10;• Transform this cover into a cinematic movie poster style, epic composition"></textarea>
+        <div class="char-count"><span id="charCount">0</span> Zeichen</div>
+        
+        <div class="form-row" style="margin-top:12px">
+            <div>
+                <label>📐 Seitenverhältnis</label>
+                <select id="aspectRatio">
+                    <option value="16:9">16:9 — Header (Standard)</option>
+                    <option value="1:1">1:1 — Quadrat</option>
+                    <option value="2:3">2:3 — Brettspiel-Box</option>
+                    <option value="9:16">9:16 — Instagram Story</option>
+                    <option value="21:9">21:9 — Breitformat</option>
+                </select>
+            </div>
+            <div>
+                <label>🔍 Auflösung</label>
+                <select id="resolution">
+                    <option value="2K">2K — 1920×1080 (Standard)</option>
+                    <option value="1K">1K — Schnell (geringere Qualität)</option>
+                    <option value="4K">4K — Höchste Qualität</option>
+                </select>
+            </div>
+        </div>
+    </div>
+
+    <!-- Start Button -->
+    <button class="btn btn-primary" id="startBtn" style="width:100%; font-size:1.1em; padding:16px">
+        🚀 Bild generieren
+    </button>
+
+    <!-- Spinner -->
+    <div class="spinner" id="spinner">
+        <div class="spinner-icon"></div>
+        <div class="spinner-text" id="spinnerText">Generiere Bild…</div>
+    </div>
+
+    <!-- Ergebnis -->
+    <div class="result-box card" id="resultBox">
+        <h2>✅ Ergebnis</h2>
+        <img id="resultImg" src="" alt="Generiertes Bild">
+        <div class="result-actions">
+            <button class="btn btn-download" id="downloadBtn">⬇ Download</button>
+            <button class="btn btn-secondary" id="retryBtn">🔄 Neues Bild</button>
+        </div>
+        <div style="margin-top:16px">
+            <label style="font-weight:600;font-size:0.85em;color:var(--text-muted)">📄 Artikel zuordnen</label>
+            <div class="form-row" style="margin-top:4px">
+                <select id="articleSelect">
+                    <option value="">-- Artikel wählen --</option>
+                    {article_options}
+                </select>
+                <button class="btn btn-primary" id="assignBtn" style="flex:0 0 auto;min-width:auto">Zuordnen</button>
+            </div>
+        </div>
+    </div>
+
+</div>
+
+<div class="toast" id="toast"></div>
+
+<script>
+const KEY = "{key}";
+const BASE = window.location.origin;
+let uploadedImageData = null;  // File object
+let currentResultUrl = null;
+let pollingTimer = null;
+
+// ── Upload-Zone ──
+const dropZone = document.getElementById('dropZone');
+const fileInput = document.getElementById('fileInput');
+const previewBox = document.getElementById('previewBox');
+const previewImg = document.getElementById('previewImg');
+const removeBtn = document.getElementById('removeBtn');
+
+dropZone.addEventListener('click', () => fileInput.click());
+fileInput.addEventListener('change', handleFile);
+
+dropZone.addEventListener('dragover', (e) => {{ e.preventDefault(); dropZone.classList.add('drag-over'); }});
+dropZone.addEventListener('dragleave', () => dropZone.classList.remove('drag-over'));
+dropZone.addEventListener('drop', (e) => {{
+    e.preventDefault();
+    dropZone.classList.remove('drag-over');
+    const files = e.dataTransfer.files;
+    if (files.length) handleFile({{ target: {{ files }} }});
+}});
+
+function handleFile(e) {{
+    const file = e.target.files[0];
+    if (!file) return;
+    uploadedImageData = file;
+    const reader = new FileReader();
+    reader.onload = (ev) => {{
+        previewImg.src = ev.target.result;
+        previewBox.style.display = 'inline-block';
+        dropZone.querySelector('.icon').textContent = '✅';
+        dropZone.querySelector('.hint').textContent = file.name + ' (' + (file.size/1024).toFixed(1) + ' KB)';
+    }};
+    reader.readAsDataURL(file);
+}}
+
+removeBtn.addEventListener('click', () => {{
+    uploadedImageData = null;
+    fileInput.value = '';
+    previewBox.style.display = 'none';
+    dropZone.querySelector('.icon').textContent = '🖼️';
+    dropZone.querySelector('.hint').textContent = 'Foto hier ablegen oder klicken zum Auswählen';
+}});
+
+// ── Char-Zähler ──
+const promptEl = document.getElementById('prompt');
+const charCount = document.getElementById('charCount');
+promptEl.addEventListener('input', () => charCount.textContent = promptEl.value.length);
+
+// ── Start ──
+document.getElementById('startBtn').addEventListener('click', startGeneration);
+
+async function startGeneration() {{
+    const prompt = promptEl.value.trim();
+    if (!prompt) {{
+        showToast('Bitte gib einen Prompt ein', 'error');
+        return;
+    }}
+    
+    const btn = document.getElementById('startBtn');
+    btn.disabled = true;
+    btn.textContent = '⏳ Sende…';
+    
+    document.getElementById('resultBox').classList.remove('visible');
+    document.getElementById('spinner').classList.add('active');
+    document.getElementById('spinnerText').textContent = 'Sende an NanoBanana…';
+    
+    try {{
+        const formData = new FormData();
+        formData.append('prompt', prompt);
+        formData.append('aspectRatio', document.getElementById('aspectRatio').value);
+        formData.append('resolution', document.getElementById('resolution').value);
+        if (uploadedImageData) {{
+            formData.append('image', uploadedImageData);
+        }}
+        
+        const resp = await fetch(BASE + '/nanobanana/generate?key=' + KEY, {{
+            method: 'POST',
+            body: formData
+        }});
+        const data = await resp.json();
+        
+        if (!data.ok) {{
+            throw new Error(data.error || 'Unbekannter Fehler');
+        }}
+        
+        document.getElementById('spinnerText').textContent = 'Warte auf Ergebnis…';
+        pollStatus(data.taskId);
+        
+    }} catch (err) {{
+        document.getElementById('spinner').classList.remove('active');
+        btn.disabled = false;
+        btn.textContent = '🚀 Bild generieren';
+        showToast('Fehler: ' + err.message, 'error');
+    }}
+}}
+
+async function pollStatus(taskId) {{
+    let attempts = 0;
+    
+    const poll = async () => {{
+        attempts++;
+        document.getElementById('spinnerText').textContent = 'Generiere Bild… (' + (attempts * 5) + 's)';
+        
+        try {{
+            const resp = await fetch(BASE + '/nanobanana/status?key=' + KEY + '&taskId=' + taskId);
+            const data = await resp.json();
+            
+            if (data.successFlag === 1) {{
+                // Fertig!
+                document.getElementById('spinner').classList.remove('active');
+                document.getElementById('startBtn').disabled = false;
+                document.getElementById('startBtn').textContent = '🚀 Bild generieren';
+                
+                currentResultUrl = data.resultImageUrl;
+                document.getElementById('resultImg').src = currentResultUrl;
+                document.getElementById('resultBox').classList.add('visible');
+                showToast('Bild fertig!', 'success');
+                
+                // Artikel-Dropdown laden
+                loadArticles();
+                return;
+            }}
+            
+            if (data.successFlag === 2) {{
+                throw new Error('Generation fehlgeschlagen');
+            }}
+            
+        }} catch (err) {{
+            if (err.message === 'Generation fehlgeschlagen') throw err;
+            // Netzwerkfehler ignorieren, weiter pollen
+        }}
+        
+        if (attempts < 60) {{
+            pollingTimer = setTimeout(poll, 5000);
+        }} else {{
+            throw new Error('Timeout nach 5 Minuten');
+        }}
+    }};
+    
+    poll().catch(err => {{
+        document.getElementById('spinner').classList.remove('active');
+        document.getElementById('startBtn').disabled = false;
+        document.getElementById('startBtn').textContent = '🚀 Bild generieren';
+        showToast('Fehler: ' + err.message, 'error');
+    }});
+}}
+
+// ── Artikel laden ──
+async function loadArticles() {{
+    try {{
+        const resp = await fetch(BASE + '/nanobanana/articles?key=' + KEY);
+        const data = await resp.json();
+        const sel = document.getElementById('articleSelect');
+        sel.innerHTML = '<option value="">-- Artikel wählen --</option>';
+        (data.articles || []).forEach(a => {{
+            sel.innerHTML += '<option value="' + a.filename + '">' + a.title + '</option>';
+        }});
+    }} catch (e) {{}}
+}}
+
+// ── Zuordnen ──
+document.getElementById('assignBtn').addEventListener('click', async () => {{
+    const article = document.getElementById('articleSelect').value;
+    if (!article) {{
+        showToast('Bitte Artikel auswählen', 'error');
+        return;
+    }}
+    if (!currentResultUrl) {{
+        showToast('Kein Bild zum Zuordnen', 'error');
+        return;
+    }}
+    
+    const btn = document.getElementById('assignBtn');
+    btn.disabled = true;
+    btn.textContent = '⏳…';
+    
+    try {{
+        const resp = await fetch(BASE + '/nanobanana/assign?key=' + KEY, {{
+            method: 'POST',
+            headers: {{ 'Content-Type': 'application/json' }},
+            body: JSON.stringify({{ article: article, imageUrl: currentResultUrl }})
+        }});
+        const data = await resp.json();
+        
+        if (data.ok) {{
+            showToast('✅ Bild zugeordnet: ' + data.filename, 'success');
+            btn.textContent = '✓ Zugeordnet';
+        }} else {{
+            throw new Error(data.error);
+        }}
+    }} catch (err) {{
+        showToast('Fehler: ' + err.message, 'error');
+        btn.disabled = false;
+        btn.textContent = 'Zuordnen';
+    }}
+}});
+
+// ── Download ──
+document.getElementById('downloadBtn').addEventListener('click', async () => {{
+    if (!currentResultUrl) return;
+    try {{
+        const resp = await fetch(currentResultUrl);
+        const blob = await resp.blob();
+        const url = URL.createObjectURL(blob);
+        const a = document.createElement('a');
+        a.href = url;
+        a.download = 'bsn-bild-' + Date.now() + '.jpg';
+        document.body.appendChild(a);
+        a.click();
+        document.body.removeChild(a);
+        URL.revokeObjectURL(url);
+    }} catch (err) {{
+        // Fallback: direkt öffnen
+        window.open(currentResultUrl, '_blank');
+    }}
+}});
+
+// ── Neues Bild ──
+document.getElementById('retryBtn').addEventListener('click', () => {{
+    document.getElementById('resultBox').classList.remove('visible');
+    currentResultUrl = null;
+    window.scrollTo({{ top: 0, behavior: 'smooth' }});
+}});
+
+// ── Toast ──
+function showToast(msg, type) {{
+    const t = document.getElementById('toast');
+    t.textContent = msg;
+    t.className = 'toast ' + type + ' show';
+    clearTimeout(t._timeout);
+    t._timeout = setTimeout(() => t.classList.remove('show'), 3000);
+}}
+</script>
+</body>
+</html>"""
+
+
 def main():
     import sys
     os.chdir(WORKSPACE)