Update app.py

app.py

@@ -1,321 +1,458 @@
 import gradio as gr
 from openai import OpenAI
 import os
-import mlflow
-import dagshub
-import uuid
-
-# DagsHub Verbindung
-dagshub.init(repo_owner='homuhe', repo_name='PromptPlenum-Tracking', mlflow=True)
-
-# Das magische Autologging für alle OpenAI-kompatiblen Aufrufe!
-mlflow.openai.autolog()
+import json
 
 # ==========================================
-# 1. KONFIGURATION & PROMPTS
+# 1. KONFIGURATION & AUFGABEN-PROFILE
 # ==========================================
 
 MODERATOR_MODEL = "meta-llama/Llama-3.3-70B-Instruct"
 
-COUNCIL_MEMBERS = {
-    "🧠 Fachexperte für Struktur (GPT-OSS-120b)": {
+# Jedes Profil definiert, wie Experten denken und was am Ende rauskommt
+TASK_PROFILES = {
+    "CODE": {
+        "label": "💻 Code / Technisch",
+        "expert_focuses": [
+            "Architektur, Algorithmus & Gesamtstruktur des Codes",
+            "Edge-Cases, Fehlerbehandlung & Sicherheit",
+            "Saubere, idiomatische Implementierung & Lesbarkeit",
+        ],
+        "final_instruction": (
+            "Liefere AUSSCHLIESSLICH den fertigen, lauffähigen Code. "
+            "Inline-Kommentare nur wo nötig. Kein Fließtext drumherum. "
+            "Korrekter Code-Block für die jeweilige Sprache."
+        ),
+        "draft_label": "Aktueller Code-Entwurf",
+    },
+    "TEXT": {
+        "label": "✍️ Text / Content",
+        "expert_focuses": [
+            "Argumentationsstruktur, roter Faden & Aufbau",
+            "Ton, Zielgruppe, Fakten & fehlende Tiefe",
+            "Formulierung, Wirkung & plattformgerechtes Format",
+        ],
+        "final_instruction": (
+            "Liefere den fertigen, copy-paste-fähigen Text. "
+            "Passe Länge, Ton und Format EXAKT an die Plattform an "
+            "(z.B. LinkedIn: kurze Absätze, mobile-freundlich, sinnvolle Emojis). "
+            "Keine Platzhalter, keine KI-Floskeln, kein Meta-Kommentar."
+        ),
+        "draft_label": "Aktueller Text-Entwurf",
+    },
+    "PLAN": {
+        "label": "📋 Strategie / Plan",
+        "expert_focuses": [
+            "Gesamtstrategie, Phasen & logische Abfolge",
+            "Risiken, Abhängigkeiten, KPIs & blinde Flecken",
+            "Konkrete Maßnahmen, Verantwortlichkeiten & Zeitplan",
+        ],
+        "final_instruction": (
+            "Liefere einen klaren, strukturierten Aktionsplan. "
+            "Phasen, Meilensteine, Maßnahmen. Tabellen wo sinnvoll. "
+            "Direkt umsetzbar, keine abstrakten Worthülsen."
+        ),
+        "draft_label": "Aktueller Plan-Entwurf",
+    },
+    "ANALYSIS": {
+        "label": "🔍 Analyse / Konzept",
+        "expert_focuses": [
+            "Problemstruktur, Hypothesen & Analyserahmen",
+            "Daten, Belege, Gegenargumente & Lücken",
+            "Schlussfolgerungen, Empfehlungen & Priorisierung",
+        ],
+        "final_instruction": (
+            "Liefere eine strukturierte Analyse: Befunde → Bewertung → Empfehlung. "
+            "Faktenbasiert, präzise, keine leeren Phrasen."
+        ),
+        "draft_label": "Aktuelle Analyse",
+    },
+}
+
+COUNCIL_MEMBERS = [
+    {
+        "name": "🧠 Experte I",
         "model": "openai/gpt-oss-120b",
-        "role": """Du bist ein neutraler Fachexperte für Struktur und Architektur.
-REGELN:
-- Beginne mit: "[STRUKTUR] "
-- Liefere das logische Gerüst für die Lösung der Aufgabe.
-- Antworte in 2-4 Sätzen, professionell und bodenständig."""
+        "tag": "STRUKTUR",
+        "color": "#1a6b3c",
+        "role_hint": "Erstelle oder verbessere die Grundstruktur und das logische Gerüst.",
     },
-    "🧐 Fachexperte für Details (DeepSeek-V3)": {
+    {
+        "name": "🧐 Experte II",
         "model": "deepseek-ai/DeepSeek-V3.2",
-        "role": """Du bist ein neutraler Fachexperte für tiefe Details, Edge-Cases und Qualitätssicherung.
-REGELN:
-- Beginne mit: "[DETAILS] "
-- Finde Lücken im aktuellen Entwurf, korrigiere Fehler (technisch oder logisch) und füge fehlende Tiefe hinzu.
-- Antworte in 2-4 Sätzen, professionell und bodenständig."""
+        "tag": "KRITIK",
+        "color": "#7c3aed",
+        "role_hint": (
+            "Prüfe den Entwurf von [STRUKTUR] kritisch. "
+            "Finde konkrete Fehler, Lücken und Schwächen — und behebe sie direkt im Entwurf."
+        ),
     },
-    "🛠️ Fachexperte für Praxis (Llama-4-Maverick)": {
+    {
+        "name": "🛠️ Experte III",
         "model": "meta-llama/Llama-4-Maverick-17B-128E-Instruct",
-        "role": """Du bist der Fachexperte für die finale Umsetzung.
-REGELN:
-- Beginne mit: "[PRAXIS] "
-- Gieße die Erkenntnisse der anderen in greifbare Artefakte (z.B. konkrete Textentwürfe, Code-Snippets, Tabellen).
-- Antworte in 2-4 Sätzen, professionell und bodenständig."""
-    }
-}
+        "tag": "UMSETZUNG",
+        "color": "#b45309",
+        "role_hint": (
+            "Nimm den von [KRITIK] überarbeiteten Entwurf und bringe ihn zur Serienreife. "
+            "Schärfe die Formulierungen, vervollständige fehlende Teile, sorge für Konsistenz."
+        ),
+    },
+]
+
+
+# ==========================================
+# 2. PROMPT MANAGER
+# ==========================================
 
 class PromptManager:
-    """Verwaltet alle dynamischen Prompts (Universelles Meta-Prompting)"""
-    
+
     @staticmethod
-    def get_moderator_kickoff_sys():
+    def task_detection_sys():
         return (
-            "Du bist der Lead-Moderator eines Expertenrates. "
-            "Analysiere die User-Anfrage. Definiere in 2-3 Sätzen das Ziel und leite ab, "
-            "welches Format und welche Tonalität am Ende erwartet werden (z.B. IT-Code, Marketing-Text, strategischer Plan). "
-            "Briefe dein Team. WICHTIG: Schreibe direkt und professionell. ABSOLUTES VERBOT von Brief-Floskeln (kein 'Hallo Team', kein 'Mit freundlichen Grüßen')."
+            "Du bist ein präziser Aufgaben-Klassifikator. Analysiere die Anfrage und antworte NUR mit einem JSON-Objekt.\n"
+            "Gültige task_type-Werte: CODE, TEXT, PLAN, ANALYSIS\n"
+            "Format (keine weiteren Zeichen außerhalb):\n"
+            '{"task_type": "...", "core_goal": "Ein-Satz-Beschreibung des Ziels", '
+            '"key_constraints": ["Constraint 1", "Constraint 2"]}'
         )
-        
+
+    @staticmethod
+    def task_detection_user(user_prompt):
+        return f"Aufgabe: {user_prompt}"
+
     @staticmethod
-    def get_moderator_mid_sys():
+    def moderator_kickoff_sys(task_profile):
         return (
-            "Du bist der Lead-Moderator. Bewerte den Zwischenstand in einem Satz. "
-            "Gib danach exakt EINEN klaren Arbeitsauftrag für die nächste Runde, um Lücken zu schließen, die Lesbarkeit zu verbessern oder das Format zu schärfen."
+            f"Du bist Lead-Moderator eines Expertenrats. Aufgabentyp: {task_profile['label']}.\n"
+            "Brief das Team in genau 4 Punkten (je 1 Satz):\n"
+            "1. Konkretes Ziel\n"
+            "2. Wichtigste Qualitätskriterien für das Endprodukt\n"
+            "3. Größte Risiken / häufigste Fehler bei diesem Aufgabentyp\n"
+            "4. Erwartetes Format des Endprodukts\n"
+            "Kein Smalltalk. Direkt. Ohne Anrede."
         )
 
     @staticmethod
-    def get_expert_sys(role_focus):
+    def moderator_kickoff_user(user_prompt, task_info):
+        constraints = ", ".join(task_info.get("key_constraints", [])) or "keine"
         return (
-            f"{role_focus}\n\n"
-            "WICHTIG: Passt euren fachlichen Stil und euer Output-Format AUTOMATISCH an die Natur der Aufgabe an. "
-            "Schreibt keine Platzhalter für Bilder oder Grafiken in den Text. Arbeitet iterativ am Entwurf und setzt die Vorgaben des Moderators um."
+            f"Auftrag: '{user_prompt}'\n"
+            f"Kernziel: {task_info.get('core_goal', '')}\n"
+            f"Constraints: {constraints}"
         )
 
     @staticmethod
-    def get_expert_user_prompt(user_prompt, discussion_history, name):
-        if not discussion_history:
-            return f"Auftrag: '{user_prompt}'"
+    def moderator_steering_sys():
         return (
-            f"Auftrag: '{user_prompt}'.\n\n"
-            f"Bisheriges Protokoll:\n{discussion_history}\n\n"
-            f"ANWEISUNG FÜR DICH ({name}):\n"
-            "1. Richte dich nach der letzten Anweisung des Moderators.\n"
-            "2. Bringe das Endprodukt inhaltlich voran. Keine Zusammenfassungen der Vorredner.\n"
-            "3. Komm direkt zum Punkt."
+            "Du bist Lead-Moderator. Bewerte den aktuellen Entwurf knapp und gib dann "
+            "EINEN einzigen, konkreten Arbeitsauftrag für die nächste Runde.\n"
+            "Format:\n"
+            "STAND: [Was gut ist — 1 Satz]\n"
+            "AUFTRAG: [Was als nächstes konkret zu tun ist — 1-2 Sätze, so spezifisch wie möglich]"
         )
 
     @staticmethod
-    def get_analysis_sys():
-        return "Du bist der Chef-Analyst. Extrahiere alle Fakten, Code-Blöcke, Metriken und Strukturvorgaben verlustfrei aus dem Protokoll."
+    def moderator_steering_user(current_draft, round_num):
+        return (
+            f"Aktueller Entwurf nach Runde {round_num}:\n\n{current_draft}\n\n"
+            "Gib Steuerungsanweisung für Runde {next_round}.".replace(
+                "{next_round}", str(round_num + 1)
+            )
+        )
 
     @staticmethod
-    def get_analysis_user(discussion_history):
+    def expert_sys(expert, task_profile, focus_area, round_num):
+        tag = expert["tag"]
+        return (
+            f"Du bist Experte [{tag}] in einem iterativen Expertenrat.\n\n"
+            f"DEIN FOKUS in dieser Runde: {focus_area}\n"
+            f"DEINE ROLLE [{tag}]: {expert['role_hint']}\n\n"
+            f"REGELN:\n"
+            f"- Beginne mit '[{tag}] '\n"
+            f"- Du lieferst den {task_profile['draft_label']} — nicht einen Kommentar darüber.\n"
+            f"- Verbessere den Entwurf direkt. Kein 'Ich würde vorschlagen...'\n"
+            f"- Keine Wiederholung des Auftrags, kein Meta-Kommentar am Ende.\n"
+            f"- Runde {round_num}: {'Erstelle die erste Version.' if round_num == 1 and tag == 'STRUKTUR' else 'Baue auf dem bestehenden Entwurf auf.'}"
+        )
+
+    @staticmethod
+    def expert_user(user_prompt, current_draft, steering_instruction, expert_tag):
+        draft_block = (
+            f"\n\nAKTUELLER ENTWURF (verbessere diesen direkt):\n---\n{current_draft}\n---"
+            if current_draft
+            else "\n\nEs gibt noch keinen Entwurf. Erstelle die erste Version."
+        )
+        steering_block = (
+            f"\n\nMODERATOR-ANWEISUNG: {steering_instruction}"
+            if steering_instruction
+            else ""
+        )
         return (
-            f"Protokoll:\n{discussion_history}\n\n"
-            "Fasse den Konsens zusammen. Erhalte zwingend alle technischen Artefakte (Code, Tabellen, exakte Formulierungen). "
-            "Vermeide abstrakte Verallgemeinerungen!"
+            f"Auftrag: '{user_prompt}'"
+            f"{draft_block}"
+            f"{steering_block}\n\n"
+            f"Liefere jetzt den verbesserten {expert_tag}-Entwurf:"
         )
 
     @staticmethod
-    def get_final_sys():
+    def final_sys(task_profile):
         return (
-            "Du bist ein hochadaptiver Output-Generator. Du lieferst perfekte, industriestandard-konforme Endprodukte. "
-            "Liefere AUSSCHLIESSLICH das finale, sofort nutzbare Endprodukt ohne KI-Geschwafel."
+            f"Du bist ein Output-Finisher für {task_profile['label']}-Aufgaben.\n\n"
+            f"ANWEISUNG:\n{task_profile['final_instruction']}\n\n"
+            "Nutze den vorliegenden Entwurf als Basis und liefere das polierte Endprodukt. "
+            "Kein einleitender Satz, kein abschließender Kommentar — nur das Produkt."
         )
 
     @staticmethod
-    def get_final_user(user_prompt, consensus_res):
+    def final_user(user_prompt, best_draft, task_info):
         return (
-            f"Auftrag:\n'{user_prompt}'\n\nKonsens:\n{consensus_res}\n\n"
-            "ANWEISUNG:\n"
-            "1. Analysiere den ursprünglichen Auftrag und wähle AUTOMATISCH die perfekte Tonalität und das richtige Format.\n"
-            "2. Wenn es ein Text/Social-Media-Post ist: Nutze moderne Formatierung (kurze Absätze für mobile Leser, sinnvolle Emojis, knackige Aufzählungen).\n"
-            "3. Wenn es Code ist: Liefere sauberen Code ohne Marketing-Sprech.\n"
-            "4. ABSOLUTES VERBOT: Generiere NIEMALS Bild-Platzhalter (wie '[Bild von...]') in den Text. Der Text muss 1:1 copy-paste-fertig sein.\n"
-            "5. Verarbeite alle Fakten aus dem Konsens."
-   
+            f"Ursprünglicher Auftrag: '{user_prompt}'\n"
+            f"Kernziel: {task_info.get('core_goal', '')}\n\n"
+            f"Bester Entwurf aus der Diskussion:\n---\n{best_draft}\n---\n\n"
+            "Erstelle das finale, sofort nutzbare Endprodukt:"
         )
 
+
 # ==========================================
-# 2. CORE SERVICES
+# 3. LLM SERVICE & UI HELPER
 # ==========================================
+
 class LLMService:
-    """Kapselt die API-Kommunikation über das OpenAI SDK (verbunden mit HF Router)"""
     def __init__(self):
-        # Wir nutzen den OpenAI Client, leiten ihn aber an Hugging Face um!
         self.client = OpenAI(
-            base_url="https://router.huggingface.co/v1", 
-            api_key=os.getenv("HF_TOKEN")
+            base_url="https://router.huggingface.co/v1",
+            api_key=os.getenv("HF_TOKEN"),
         )
 
-    @mlflow.trace(name="Plenum_Turn", span_type="LLM")
-    def ask(self, model_id, system_prompt, user_input, session_id, role_name):
-        
-        # Fügt Meta-Daten zum Trace hinzu, damit du in DagsHub filtern kannst
-        mlflow.update_current_trace(tags={
-            "session_id": session_id,
-            "expert_role": role_name,
-            "model_name": model_id
-        })
-
+    def ask(self, model_id, system_prompt, user_input):
         messages = [
             {"role": "system", "content": system_prompt},
-            {"role": "user", "content": user_input}
+            {"role": "user", "content": user_input},
         ]
-        response = ""
         try:
-            # Der Aufruf im OpenAI SDK Format (stream=True für die UI)
-            stream = self.client.chat.completions.create(
-                model=model_id, 
-                messages=messages, 
-                max_tokens=4000, 
-                temperature=0.4, 
-                stream=True
+            response = self.client.chat.completions.create(
+                model=model_id,
+                messages=messages,
+                max_tokens=4000,
+                temperature=0.4,
+                stream=False,
             )
-            for chunk in stream:
-                if chunk.choices[0].delta.content is not None:
-                    response += chunk.choices[0].delta.content
-            return response
+            return response.choices[0].message.content or ""
         except Exception as e:
-            return f"🚨 System Error ({model_id}): {str(e)}"
+            return f"🚨 Fehler ({model_id}): {str(e)}"
+
+
 class UIHelper:
-    """Formatiert Ausgaben für die Gradio Chatbot-UI."""
     @staticmethod
     def header(title, color="#FF5A4D"):
-        return f"<h2 style='color: {color}; border-bottom: 2px solid #FFEBE8; padding-bottom: 5px; margin-top: 20px;'>{title}</h2>"
+        return (
+            f"<h2 style='color:{color}; border-bottom:2px solid #FFEBE8; "
+            f"padding-bottom:5px; margin-top:20px;'>{title}</h2>"
+        )
+
+    @staticmethod
+    def message(label, content, color="#4241A6"):
+        return f"**<span style='color:{color}; font-size:1.05em;'>{label}</span>**\n\n{content}"
 
     @staticmethod
-    def message(name, content, color="#4241A6"):
-        return f"**<span style='color: {color}; font-size: 1.1em;'>👤 {name}</span>**\n\n> {content}"
+    def info(content):
+        return f"> ℹ️ {content}"
+
 
 # ==========================================
-# 3. DER ORCHESTRATOR
+# 4. ORCHESTRATOR
 # ==========================================
+
 class PlenumOrchestrator:
-    """Steuert den gesamten Diskussions- und Generierungsprozess."""
     def __init__(self):
         self.llm = LLMService()
-        self.prompts = PromptManager()
+        self.pm = PromptManager()
         self.ui = UIHelper()
 
+    def _detect_task(self, user_prompt):
+        raw = self.llm.ask(
+            MODERATOR_MODEL,
+            self.pm.task_detection_sys(),
+            self.pm.task_detection_user(user_prompt),
+        )
+        try:
+            clean = raw.strip().removeprefix("```json").removeprefix("```").removesuffix("```").strip()
+            return json.loads(clean)
+        except Exception:
+            return {"task_type": "TEXT", "core_goal": user_prompt, "key_constraints": []}
+
     def run(self, user_prompt, rounds):
-        if not user_prompt:
-            yield [{"role": "assistant", "content": "Bitte gib ein Thema oder eine Frage ein."}]
+        if not user_prompt.strip():
+            yield [{"role": "assistant", "content": "Bitte gib einen Auftrag ein."}]
             return
-            
-        # Generiert die Session ID für das spätere Bündeln in MLflow!
-        current_session_id = str(uuid.uuid4())
 
         history = [{"role": "user", "content": user_prompt}]
         yield history
-        
-        discussion_history = "" 
-        
-        # --- KICK-OFF ---
-        history.append({"role": "assistant", "content": self.ui.header("🎤 MODERATOR ((Llama-3.3-70B)): SITZUNGSERÖFFNUNG")})
+
+        # Zustand: Das ist das Herzstück des neuen Ansatzes
+        current_draft = ""
+        steering_instruction = ""
+
+        # ── SCHRITT 0: AUFGABE ERKENNEN ──────────────────────────────
+        history.append({"role": "assistant", "content": self.ui.header("🔍 AUFGABENANALYSE", "#6b7280")})
+        yield history
+
+        task_info = self._detect_task(user_prompt)
+        task_type = task_info.get("task_type", "TEXT")
+        task_profile = TASK_PROFILES.get(task_type, TASK_PROFILES["TEXT"])
+
+        detection_text = (
+            f"**Erkannter Typ:** {task_profile['label']}  \n"
+            f"**Kernziel:** {task_info.get('core_goal', '—')}  \n"
+            f"**Constraints:** {', '.join(task_info.get('key_constraints', ['—'])) or '—'}"
+        )
+        history.append({"role": "assistant", "content": detection_text})
+        yield history
+
+        # ── SCHRITT 1: KICK-OFF ───────────────────────────────────────
+        history.append({"role": "assistant", "content": self.ui.header("🎤 MODERATOR: SITZUNGSERÖFFNUNG")})
         yield history
-        
-        kickoff_res = self.llm.ask(
-            MODERATOR_MODEL, 
-            self.prompts.get_moderator_kickoff_sys(), 
-            f"User-Anfrage: '{user_prompt}'\nBriefe das Team.",
-            current_session_id,    # <-- NEU hinzugefügt
-            "Moderator_Kickoff"    # <-- NEU hinzugefügt
+
+        kickoff = self.llm.ask(
+            MODERATOR_MODEL,
+            self.pm.moderator_kickoff_sys(task_profile),
+            self.pm.moderator_kickoff_user(user_prompt, task_info),
         )
-        discussion_history += f"Moderator - Kick-off (Llama-3.3-70B): {kickoff_res}\n\n"
-        history.append({"role": "assistant", "content": self.ui.message("🎤 Moderator", kickoff_res, "#FF5A4D")})
+        history.append({"role": "assistant", "content": self.ui.message("🎤 Moderator", kickoff, "#FF5A4D")})
         yield history
 
-        # --- ZYKLEN ---
+        # ── SCHRITT 2: ZYKLEN ─────────────────────────────────────────
         for r in range(int(rounds)):
-            history.append({"role": "assistant", "content": self.ui.header(f"🔄 ZYKLUS {r+1} - EXPERTENDEBATTE", "#4241A6")})
+            history.append({
+                "role": "assistant",
+                "content": self.ui.header(f"🔄 ZYKLUS {r + 1} — EXPERTENDEBATTE", "#4241A6"),
+            })
             yield history
-            
-            # Moderator Steuerung (ab Runde 2)
-            if r > 0:
-                mid_res = self.llm.ask(
-                    MODERATOR_MODEL, 
-                    self.prompts.get_moderator_mid_sys(), 
-                    f"Protokoll:\n{discussion_history}\n\nGib die Anweisung.",
-                    current_session_id,     # <-- NEU hinzugefügt
-                    "Moderator_Steuerung"   # <-- NEU hinzugefügt
+
+            # Moderator-Steuerung (ab Runde 2, basierend auf aktuellem Entwurf)
+            if r > 0 and current_draft:
+                steering_instruction = self.llm.ask(
+                    MODERATOR_MODEL,
+                    self.pm.moderator_steering_sys(),
+                    self.pm.moderator_steering_user(current_draft, r),
                 )
-                discussion_history += f"Moderator - Steuerung (Llama-3.3-70B): {mid_res}\n\n"
-                history.append({"role": "assistant", "content": self.ui.message("🎤 Moderator (Steuerung)", mid_res, "#FF5A4D")})
+                history.append({
+                    "role": "assistant",
+                    "content": self.ui.message("🎤 Moderator (Steuerung)", steering_instruction, "#FF5A4D"),
+                })
                 yield history
 
-            # Experten antworten
-            for name, config in COUNCIL_MEMBERS.items():
-                sys_msg = self.prompts.get_expert_sys(config["role"])
-                user_msg = self.prompts.get_expert_user_prompt(user_prompt, discussion_history, name)
-                
-                answer = self.llm.ask(
-                    config["model"], 
-                    sys_msg, 
-                    user_msg,
-                    current_session_id,
-                    name
-                )
-                discussion_history += f"{name}: {answer}\n\n"
-                
-                history.append({"role": "assistant", "content": self.ui.message(name, answer)})
-                yield history 
+            # Experten arbeiten SEQUENZIELL:
+            # Experte I sieht aktuellen Entwurf → produziert Draft A
+            # Experte II sieht Draft A → produziert Draft B (mit Korrekturen)
+            # Experte III sieht Draft B → produziert Draft C (serienreif)
+            # → Draft C wird zum current_draft für die nächste Runde
+            round_draft = current_draft
 
-        # --- ANALYSE ---
-        history.append({"role": "assistant", "content": self.ui.header("🧠 MODERATOR: ANALYSE DER DISKUSSION (Llama-3.3-70B)")})
-        yield history
-        
-        consensus_res = self.llm.ask(
-            MODERATOR_MODEL, 
-            self.prompts.get_analysis_sys(), 
-            self.prompts.get_analysis_user(discussion_history),
-            current_session_id,   # <-- NEU hinzugefügt
-            "Moderator_Analyse"   # <-- NEU hinzugefügt
-        )
-        history.append({"role": "assistant", "content": f"> {consensus_res}"})
-        yield history
+            for idx, expert in enumerate(COUNCIL_MEMBERS):
+                focus = task_profile["expert_focuses"][idx]
+
+                sys_msg = self.pm.expert_sys(expert, task_profile, focus, r + 1)
+                usr_msg = self.pm.expert_user(user_prompt, round_draft, steering_instruction if r > 0 else "", expert["tag"])
+
+                answer = self.llm.ask(expert["model"], sys_msg, usr_msg)
+
+                # Dieser Experte liefert den Entwurf für den Nächsten
+                round_draft = answer
+
+                label = f"{expert['name']} [{expert['tag']}] — {focus}"
+                history.append({"role": "assistant", "content": self.ui.message(label, answer, expert["color"])})
+                yield history
+
+            # Bester Stand dieser Runde = Output von Experte III
+            current_draft = round_draft
+            history.append({
+                "role": "assistant",
+                "content": self.ui.info(f"Zyklus {r + 1} abgeschlossen. Entwurf gesichert → Basis für nächste Runde."),
+            })
+            yield history
 
-        # --- FINALE AUSGABE ---
+        # ── SCHRITT 3: FINALE AUSGABE ─────────────────────────────────
         history.append({"role": "assistant", "content": self.ui.header("🏆 FINALE AUSGABE")})
         yield history
-        
-        final_res = self.llm.ask(
-            MODERATOR_MODEL, 
-            self.prompts.get_final_sys(), 
-            self.prompts.get_final_user(user_prompt, consensus_res),
-            current_session_id,   # <-- NEU hinzugefügt
-            "Moderator_Finale"    # <-- NEU hinzugefügt
+
+        final = self.llm.ask(
+            MODERATOR_MODEL,
+            self.pm.final_sys(task_profile),
+            self.pm.final_user(user_prompt, current_draft, task_info),
         )
-        history.append({"role": "assistant", "content": final_res})
+        history.append({"role": "assistant", "content": final})
         yield history
 
-# Instanziiere den Orchestrator
+
+# Orchestrator-Instanz
 orchestrator = PlenumOrchestrator()
 
+
 # ==========================================
-# 4. GRADIO UI
+# 5. GRADIO UI
 # ==========================================
+
 v_theme = gr.themes.Soft(
-    primary_hue="indigo",  
-    font=[gr.themes.GoogleFont("Inter"), "ui-sans-serif", "system-ui", "sans-serif"], 
+    primary_hue="indigo",
+    font=[gr.themes.GoogleFont("Inter"), "ui-sans-serif", "system-ui", "sans-serif"],
 ).set(
-    button_primary_background_fill="#4241A6", 
+    button_primary_background_fill="#4241A6",
     button_primary_background_fill_hover="#2D2C73",
     button_primary_text_color="white",
-    block_title_text_color="#FF5A4D", 
+    block_title_text_color="#FF5A4D",
     block_label_text_color="#4241A6",
     body_text_color="#1F2937",
-    color_accent_soft="#FFEBE8", 
+    color_accent_soft="#FFEBE8",
 )
 
 with gr.Blocks(theme=v_theme) as demo:
     gr.HTML("""
-    <div style="text-align: center; margin-bottom: 2rem; margin-top: 1rem;">
-        <h1 style="color: #FF5A4D; font-weight: 900; font-size: 2.8rem; margin-bottom: 0.2rem; font-family: 'Inter', sans-serif; letter-spacing: -0.02em;">PromptPlenum42</h1>
-        <p style="color: #4B5563; font-size: 1.1rem; font-family: 'Inter', sans-serif;">AI-Driven Multi-Agent Consensus System</p>
+    <div style="text-align:center; margin-bottom:2rem; margin-top:1rem;">
+        <h1 style="color:#FF5A4D; font-weight:900; font-size:2.8rem; margin-bottom:0.2rem;
+                   font-family:'Inter',sans-serif; letter-spacing:-0.02em;">PromptPlenum42</h1>
+        <p style="color:#4B5563; font-size:1.1rem; font-family:'Inter',sans-serif;">
+            AI-Driven Multi-Agent Consensus System
+        </p>
     </div>
     """)
 
     with gr.Row():
         with gr.Column(scale=4):
             input_text = gr.Textbox(
-                label="Plenumsauftrag", 
-                placeholder="z.B. 'Refaktorier dieses Python-Skript' oder 'Schreibe einen LinkedIn Post über KI'",
-                lines=2
+                label="Plenumsauftrag",
+                placeholder=(
+                    "z.B. 'Refaktoriere dieses Python-Skript' · "
+                    "'Schreibe einen LinkedIn-Post über KI' · "
+                    "'Erstelle einen Go-to-Market-Plan für ein SaaS-Produkt'"
+                ),
+                lines=3,
             )
         with gr.Column(scale=1):
-            rounds_slider = gr.Slider(minimum=1, maximum=5, value=1, step=1, label="Diskussionszyklen")
-            
+            rounds_slider = gr.Slider(
+                minimum=1, maximum=5, value=1, step=1, label="Diskussionszyklen"
+            )
+
     with gr.Row():
         start_btn = gr.Button("Sitzung starten", variant="primary", size="lg")
-        clear_btn = gr.ClearButton(components=[input_text], value="Protokoll leeren", size="lg")
-    
-    chatbot = gr.Chatbot(label="Sitzungsprotokoll", height=650)
+        clear_btn = gr.ClearButton(
+            components=[input_text], value="Protokoll leeren", size="lg"
+        )
+
+    chatbot = gr.Chatbot(
+        label="Sitzungsprotokoll",
+        height=700,
+        type="messages",
+        render_markdown=True,
+    )
     clear_btn.add(chatbot)
 
-    # UI Events an den Orchestrator binden
-    input_text.submit(orchestrator.run, inputs=[input_text, rounds_slider], outputs=[chatbot])
-    start_btn.click(orchestrator.run, inputs=[input_text, rounds_slider], outputs=[chatbot])
+    input_text.submit(
+        orchestrator.run, inputs=[input_text, rounds_slider], outputs=[chatbot]
+    )
+    start_btn.click(
+        orchestrator.run, inputs=[input_text, rounds_slider], outputs=[chatbot]
+    )
 
 if __name__ == "__main__":
     demo.launch()