docs(livia): Kostenschätzung für Sonnet 5 korrigiert

Im Kommentar zur Modellwahl stand für claude-sonnet-5 rund 0.20 USD je Lauf. Nach den aktuellen Listenpreisen (2/10 USD je Million Token) sind es rund 0.16 — genau das Doppelte von Haiku 4.5, nicht das Zweieinhalbfache. Die Preisbasis steht jetzt im Kommentar, damit die Zahlen beim nächsten Preiswechsel prüfbar bleiben. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
fix(livia,nora): Runde 11 — Quellensynchronisation, Filter, Tabellenbreite, Objektdetail
2026-10-01 17:24:25 +02:00 · 2026-09-13 16:03:04 +02:00 · 2026-09-13 00:34:16 +02:00 · 2026-09-13 00:02:06 +02:00 · 2026-09-12 23:44:54 +02:00 · 2026-09-12 23:42:59 +02:00
173 changed files with 13250 additions and 2595 deletions
@@ -0,0 +1,450 @@
 # Property On — Agenten-Ansatz: Entwicklungsstand
 > **Zweck dieses Dokuments:** Vollständiges Briefing über den Agenten-Ansatz der Plattform
 > «Property On» (Repository `property-match`), Stand **5. August 2026**.
 > Alle Angaben sind direkt aus dem Quellcode ausgelesen, nicht aus Konzeptpapieren.
 >
 > **Wenn du (ChatGPT) dieses Dokument liest:** Es ist die Faktenbasis für eine Präsentation
 > zum Entwicklungsstand. Abschnitt 8 trennt ausdrücklich zwischen *gebaut und lauffähig* und
 > *bewusst als Demo simuliert*. Diese Trennung bitte niemals verwischen — die Präsentation
 > muss Nachfragen standhalten.
 ---
 ## 1. Produktvision in einem Satz
 Property On ist keine Immobilienplattform mit angeflanschtem Chatbot, sondern eine
 **Decision-Intelligence-Plattform**, deren Arbeit von fünf **digitalen Mitarbeitenden**
 erledigt wird — jeder mit Namen, Porträt, Personalnummer, Abteilung, definiertem
 Aufgabenprofil und einer festgelegten Autonomiestufe.
 Der konzeptionelle Kern, der den Ansatz von «KI-Features» unterscheidet:
 | Klassischer KI-Ansatz | Property-On-Agentenansatz |
 |---|---|
 | Ein Assistent, überall derselbe | Fünf Rollen mit je eigenem Arbeitsplatz und Zuständigkeit |
 | «AI»-Knopf an bestehender Oberfläche | Die Seite *ist* der Arbeitsplatz des Agenten |
 | Blackbox-Ausgabe | Jede Aussage mit Quelle, Fundstelle und Konfidenz |
 | Autonom oder gar nicht | Drei abgestufte Autonomiestufen je Agent |
 | Wird als Technologie verkauft | Wird als Personal eingeführt — inkl. «Personalverwaltung» |
 Die drei Leitprinzipien aus der Projektdokumentation (`CLAUDE.md`), die jede
 Designentscheidung schlagen:
 1. **Explainability-first** — jeder Score, jedes Badge, jede Empfehlung ist rückverfolgbar.
   Wenn nicht nachvollziehbar ist *warum*, ist das Feature nicht fertig.
 2. **Trust-first** — Konfidenz, Datenaktualität und Datenlücken werden aktiv angezeigt.
   Nichts wird sicherer dargestellt, als die Datenlage hergibt.
 3. **Better-than-Google** — ranken, Zielkonflikte erklären, Zukunftssignale zeigen und eine
   konkrete nächste Handlung empfehlen; nicht bloss Treffer auflisten.
 ---
 ## 2. Die fünf Agenten im Überblick
 Der Menüpunkt heisst **«Meine Agenten»**. Die Reihenfolge folgt dem Arbeitsablauf, nicht dem
 Alphabet.
 | # | Agent | Funktion | Abteilung | Pers.-Nr. | Autonomiestufe | Route |
 |---|---|---|---|---|---|---|
 | 1 | **Ferdi** | Fristen-Wächter | Bewirtschaftung | PO-ZD-02 | Freigabe erforderlich — «autonom beim Erinnern, Freigabe bei Eskalationen» | `/supply/reminder-manager` |
 | 2 | **Bruno** | Besichtigungsassistent | Vermarktung | PO-ZD-13 | Autonom | `/supply/besichtigungen` |
 | 3 | **Livia** | Exposé Master | Vermarktung | PO-ZD-21 | Autonom | `/supply/my-listings` |
 | 4 | **Nora** | Marktchancen / Leads | Marktbeobachtung | PO-ZD-19 | Nur Vorschlag | `/supply/market-intelligence` |
 | 5 | **Sina** | Datenpflege | Bewirtschaftung | PO-ZD-03 | Autonom, ausschliesslich lesend | `/supply/data-quality` |
 **Die Autonomiestufen sind das stärkste Argument der Präsentation.** Sie sind kein Etikett,
 sondern im Datenmodell verankert (`AgentAutonomyLevel`) und je Agent begründet:
 - **Nora darf nichts entscheiden** — sie erkennt Marktsignale und schlägt vor. Ein Mensch
  entscheidet, ob daraus ein Lead wird.
 - **Ferdi darf erinnern, aber nicht eskalieren** — die Eskalation gegenüber einem Mieter ist
  eine geschäftliche Handlung mit Aussenwirkung und braucht eine Freigabe.
 - **Sina darf autonom arbeiten, weil sie ausschliesslich liest** — sie beantwortet Fragen aus
  hinterlegten Dokumenten und belegt jede Aussage mit Fundstelle. Ohne Schreibrecht kein Risiko.
 - **Bruno und Livia arbeiten autonom**, weil ihr Ergebnis (Briefing, Exposé-Entwurf) dem
  Menschen vorgelegt wird, bevor es nach aussen geht.
 ---
 ## 3. Die fünf Agenten im Detail
 ### 3.1 Ferdi — Fristen-Wächter
 **Problem:** Optionsfristen, Break-Klauseln und Anpassungstermine verschwinden in Verträgen,
 Nachträgen und Excel-Listen. Wer eine Frist verpasst, verliert Geld oder eine Fläche.
 **Was Ferdi tut** (aus dem Personaldossier):
 - Liest Mietverträge, Nachträge und Zusatzvereinbarungen der Standorte Zürich, Winterthur,
  Basel, Zug, Bern und St. Gallen ein
 - Extrahiert Fristen, Optionen und Break-Klauseln **mit Fundstelle im Dokument**
 - Lässt jeden neu gefundenen Termin **einmalig durch die Bewirtschaftung bestätigen**
  (Human-in-the-Loop an der Datenquelle, nicht erst am Ergebnis)
 - Gleicht den bestätigten Bestand jeden Morgen mit dem Kalender ab
 - Erinnert gestaffelt: 12, 9, 6 und 3 Monate vor Stichtag
 - Meldet nach fünf Arbeitstagen ohne Reaktion ein zweites Mal
 - Legt bei anhaltendem Ausbleiben eine **Eskalation zur Freigabe** vor
 **Ergebnisse:** Fristen-Alerts, Wochen-Pipeline montags 07:00 Uhr, Eskalationsvorschläge,
 lückenloses Meldeprotokoll je Vertrag.
 **In der Oberfläche:** Chat-Einstieg, darunter Filterleiste und Reminder-Liste, seitliche
 Detailansicht. Zusätzlich gebaut: **Kalender-Terminplanung** — aus einem Reminder lässt sich
 ein Kalendereintrag erzeugen (Titel-Schema `Ferdi: {Typ} – {Objekt}`, mit strukturiertem
 Anhang aus den Reminder-Daten).
 ---
 ### 3.2 Bruno — Besichtigungsassistent
 **Problem:** Vor einer Besichtigung fehlt dem Makler die Vorbereitung, nach der Besichtigung
 verschwindet das Gesagte. Beides kostet Abschlüsse.
 **Zwei Auftragstypen, ein Arbeitsplatz:**
 **Vorbereitung** — Bruno liefert vor dem Termin ein Briefing:
 - Objektbild, Adresse, Fläche, Mietpreis, Verfügbarkeit, Parkplätze
 - Objektbeschrieb
 - **Lagebericht von Livia** (Agent-zu-Agent-Zulieferung — ein wichtiger Punkt: die Agenten
  arbeiten einander zu, sie stehen nicht nebeneinander)
 - **Verkaufsargumente**
 - **Mögliche Einwände mit vorbereiteter Antwort** — je Einwand ein Antwortvorschlag
 - **Rechercheergebnisse zum Interessenten aus öffentlichen Quellen** — und hier die
  entscheidende Regel: *jede* Angabe steht mit Quellenangabe da. Findet Bruno nichts
  Belegbares, steht «Keine belegbaren öffentlichen Angaben gefunden» — nicht eine plausible
  Vermutung. Begründung im Code: *«Eine Vermutung im Briefing wird am Termin zur Behauptung.»*
 - Optional: Audiofassung des Briefings (für die Fahrt zum Termin)
 **Nachbereitung** — nach dem Termin:
 - Der Makler diktiert oder schreibt formlos (Eingangskanal wird protokolliert)
 - Bruno zeigt transparent, **welche Verarbeitungsschritte** er daraus gemacht hat
 - Ergebnis ist eine benannte Datei (Protokoll / Kundennotiz) plus Bemerkungen
 **Eingebaute Kontrolle:** Steht eine Besichtigung in **weniger als 24 Stunden** an und wurde
 noch kein Bericht angefordert, erscheint eine Warnung mit direktem Handlungsknopf
 «Bericht anfordern». Das ist ein konkretes Beispiel für einen Agenten, der nicht nur
 ausführt, sondern die Lücke im Prozess selbst meldet.
 ---
 ### 3.3 Livia — Exposé Master
 **Problem:** Ein vollständiges Gewerbe-Exposé zu erstellen ist ein Tagesgeschäft von mehreren
 Stunden — Daten zusammensuchen, Texte schreiben, Bilder sortieren, exportieren.
 **Arbeitsplatz:** Leadliste (aktiv / archiviert). Leads kommen aus Noras Signalen, sobald ein
 Bewirtschafter sie zur Exposé-Erstellung weitergeleitet hat. Beim Öffnen eines Leads gleitet
 die Zeile nach oben und der dreistufige Arbeitsbereich klappt auf.
 **Der Drei-Schritt-Ablauf: Hochladen → Exposé → Export**
 **Schritt 1 – Hochladen:** Objektdaten und Bilder aus «Meine Objekte» vorbefüllen oder
 Unterlagen hochladen.
 **Schritt 2 – Exposé:** Ein Dossier aus **11 fachlichen Bereichen** — das ist der inhaltliche
 Beweis, dass hier eine echte Fachdomäne abgebildet ist und keine generische Formularmaske:
 | # | Bereich | Beispielfelder | Datenquellen |
 |---|---|---|---|
 | 1 | Eckdaten & Vermarktung | Objektart, Vermarktungsart, Status, Objektreferenz | — |
 | 2 | Lage | Strasse, PLZ, Ort, Gemeinde, Kanton | — |
 | 3 | Koordinaten & Distanzen | ÖV-Haltestelle, Einkauf, Schule, Autobahn (in m) | Swisstopo, ÖV-Fahrplan, OpenStreetMap |
 | 4 | Gebäude- & Gemeindedaten | ÖV-Güteklasse, Solareignung, Einwohner, Steuerbelastung, Leerwohnungsziffer | ARE, BFE Sonnendach, BFS, ESTV |
 | 5 | Flächen & Gebäude | Nutzfläche, Raumhöhe, **Kubatur SIA 416** | — |
 | 6 | Gebäude & Verfügbarkeit | Stockwerk, Baujahr, letzte Renovation, Zustand | — |
 | 7 | Grundstück & Baurecht | Nutzungszone, Überbauungsziffer, Ausnützungsziffer | geodienste / Swisstopo |
 | 8 | Preise & Kosten | Nettomiete CHF/m²/J, Nebenkosten, NK-Art, Kaution, Parkierung | — |
 | 9 | Ausstattung & Merkmale | Photovoltaik, Wärmepumpe, E-Ladestation, Minergie, Seesicht … | — |
 | 10 | Energie & Technik | Heizsystem, Wärmeverteilung, GEAK, kWp | — |
 | 11 | Texte & Beschriebe | Titel, Kurzbeschrieb, Objekt-/Lage-/Gemeinde-/Ausstattungsbeschrieb, Highlights | **KI-Textentwurf** |
 Zwei Details, die den Qualitätsanspruch zeigen:
 - **Schweizer Fachnormen sind eingebaut** — Kubatur nach SIA 416, GEAK, Minergie,
  ÖV-Güteklasse nach ARE, Leerwohnungsziffer. Alle behördlichen Datenquellen sind benannt und
  **die Werte bleiben überschreibbar** — der Mensch behält das letzte Wort.
 - **Pflichtfeldlogik:** 9 Felder sind Pflicht (Objektart, Vermarktungsart, Strasse, PLZ, Ort,
  Nutzfläche, Verfügbarkeit, Nettomiete, Exposé-Titel, Kurzbeschrieb, Objektbeschrieb).
  Fehlt eines, wird es rot umrandet. Begründung im Code: *«Eine Broschüre ohne Kubatur ist
  verkaufbar, eine ohne Mietpreis nicht.»*
 **KI-Texterstellung mit hartem Leitplanken-Prinzip:** Der Textentwurf nutzt
 **ausschliesslich die erfassten Objektdaten**. Im Backend-Dienst wird die Textgenerierung
 bewusst an einen deterministischen Baustein delegiert, damit **kein Sprachmodell fehlende
 Fakten erfindet**. Das ist die direkte technische Umsetzung des Trust-first-Prinzips.
 **Schritt 3 – Export:** HTML-Vorschau, PDF (über den Druckdialog) und Word (`.doc`).
 ---
 ### 3.4 Nora — Marktchancen / Leads
 **Problem:** Marktchancen entstehen aus schwachen Signalen — einer Handelsregister-Mutation,
 einer Baubewilligung, einem Gespräch im Netzwerk. Diese Signale sind verteilt und flüchtig.
 **Zwei Quellen, zwei Reiter:**
 **Reiter «KI-Signale»** — automatisch erkannte Signale aus öffentlichen Quellen
 (SHAB, Zefix, Web), je Signal eine Detailansicht mit Einordnung.
 **Reiter «Netzwerk»** — der menschliche Kanal. Ein Bewirtschafter erfasst selbst einen
 Hinweis aus seinem Netzwerk. Filter nach **Intern** und **Plattform** — d. h. das Wissen
 einzelner Mitarbeitender wird zu Plattformwissen, ohne dass es dafür ein separates CRM-Ritual
 braucht.
 **Autonomiestufe «Vorschlag»:** Nora entscheidet nichts. Sie erkennt, ordnet ein und legt vor.
 Der Mensch leitet ein Signal per Mehrfachauswahl an **Livia** weiter — dort wird daraus ein
 Exposé-Lead. Das ist die sichtbare Übergabe zwischen zwei Agenten und der beste
 Demo-Moment der Präsentation.
 **Weitere Ergebnisse laut Dossier:** Wochen-Mails, Leads, Marktbausteine.
 ---
 ### 3.5 Sina — Datenpflege
 **Problem:** Schlechte Objektdaten machen jede nachgelagerte Auswertung wertlos. Aber niemand
 pflegt Daten «auf Vorrat» — man braucht den konkreten Hinweis, *welches* Objekt jetzt
 angefasst werden muss.
 **Bewusste Design-Entscheidung, die man in der Präsentation zeigen sollte:** Die Seite hatte
 früher Auswertungskarten und eine Qualitätsverteilung. Beide sind **entfernt** worden. Die
 Begründung steht im Code: *Kennzahlen beantworten «wie steht es insgesamt?», auf dieser Seite
 zählt aber «welches Objekt muss ich anfassen?».* Das ist Prinzip 1 der Projektrichtlinien in
 Reinform — jeder Bildschirm wird um **eine Entscheidung** herum gebaut.
 **Was übrig blieb:** Chat-Einstieg, Freitextsuche, drei Filter (Ort/PLZ, Gewerbetyp, Status)
 und eine nach Objektname oder Datenqualität sortierbare Liste. Datenqualität unter 60 %
 wird rot. Klick auf ein Objekt öffnet die **direkt editierbare** Detailansicht.
 **Zweites Aufgabenprofil laut Dossier:** Sina beantwortet Vertrags- und Objektfragen
 **ausschliesslich aus hinterlegten Dokumenten und immer mit Fundstelle** — autonom, aber
 ausschliesslich lesend.
 > ⚠️ **Vor der Präsentation prüfen:** Die Funktionsbezeichnung in der Oberfläche
 > («Datenpflege») und das Aufgabenprofil im Personaldossier (dokumentenbasierte
 > Fragebeantwortung) beschreiben zwei unterschiedliche Schwerpunkte. Wenn jemand nachfragt,
 > ist die saubere Antwort: Sina ist der lesende Daten- und Dokumentenagent; die Oberfläche
 > zeigt heute den Datenpflege-Teil, der Dokumenten-Q&A-Teil ist im Rollenprofil beschrieben
 > und noch nicht als eigener Bildschirm gebaut.
 ---
 ## 4. Das gemeinsame Bedienmuster
 Alle fünf Agentenseiten sind gleich aufgebaut — das ist eine bewusste Entscheidung, damit die
 Agenten als *ein Team* wahrgenommen werden und nicht als fünf Werkzeuge.
 **Der Chat-Einstieg** (eine einzige gemeinsame Komponente, `AgentWorkspaceHero`):
 - Porträt 88 px, Name, Funktionsbezeichnung
 - Immer dieselbe Frage: **«Wie kann ich dir heute weiterhelfen?»**
 - Mehrzeiliges Eingabefeld, Platzhalter «Nachricht an {Name} senden»
 - Optional: zusätzliche Kanäle (z. B. WhatsApp) als Hinweis darunter
 Was bewusst **fehlt** — und warum das ein Argument ist, kein Mangel:
 kein generischer «AI-Assistent»-Knopf, keine Vorschlagskacheln, kein Verlauf.
 Der Chat ist agentenspezifisch und bleibt auf der jeweiligen Seite. Die operative
 Liste beginnt erst unterhalb des Weissraums.
 **Objektverlinkung:** Jeder Objektname auf jeder Agentenseite ist ein Link in «Meine Objekte»
 (`/supply/properties/{id}`). Alle Verweise zeigen auf **real existierende Objekte im
 Datenbestand** — es gibt keine erfundenen Objektnamen in den Agentendaten. Das ist per Skript
 gegen den Objektbestand geprüft worden (IDs und Titel, null Abweichungen).
 ---
 ## 5. Die Verwaltungsebene — «Agenten als Personal»
 Unter «Meine Agenten» liegen drei Verwaltungsbereiche als Reiter derselben Seite
 (`/supply/team?section=…`). Sie sind der konzeptionelle Kern des Ansatzes:
 | Reiter | Inhalt |
 |---|---|
 | **Personalverwaltung** | Personalblatt je Agent: Personalnummer, Abteilung, E-Mail, Zweck, Eingangsdaten, Arbeitsablauf, Ergebnisse, Autonomiestufe |
 | **Bearbeitungsverlauf** | Erledigte Aufträge und pendente Anfragen |
 | **Kanäle & Systeme** | Welcher Agent hängt an welchem System — mit Verbindungsstatus |
 **Kanäle & Systeme ist der wichtigste Bildschirm für eine kritische Zuhörerschaft**, weil er
 den Realitätsgrad ehrlich ausweist. Jede Anbindung trägt einen Status:
 `CONNECTED` / `DISCONNECTED` / `ROADMAP`.
 Erfasste Anbindungen (Auszug mit realem Status):
 | System / Kanal | Status |
 |---|---|
 | Microsoft 365 — gemeinsame Postfächer | Verbunden |
 | WhatsApp Business — Diensthandys | Verbunden |
 | Kalender der Standortteams | Verbunden |
 | Dokumentenablage und Standortbibliotheken | Verbunden |
 | CRM der Vermarktung | Verbunden |
 | Öffentliche Quellen — SHAB, Zefix, Web | Verbunden |
 | Microsoft Teams — Kanal Marktbeobachtung | Nicht verbunden |
 | Bewirtschaftungssystem ImmoTop2 | Nicht verbunden |
 | Telefonanlage und Diktatlinie | Roadmap |
 Beachte die Formulierung bei der Dokumentenablage — sie beschreibt nicht nur *was*
 angebunden ist, sondern die Belegpflicht: *«Jede Aussage aus einem Dokument wird mit
 Dateiname, Seite und Zitat belegt.»*
 ---
 ## 6. Technischer Stand
 **Stack:** Vite 8 · React 19 · TypeScript 6 (`strict`) · MUI v9 · Tailwind CSS v4 ·
 React Router v7 · TanStack Query v5 · Zustand v5 · Zod · Playwright · Vitest
 **Architektur — vier Schichten, keine wird übersprungen:**
 ```
 Provider  →  Service  →  Hook (React Query)  →  Component
 ```
 - **Provider** ist der einzige Code, der Daten anfasst. Jede Entität hat ein Interface
  (`IPropertyProvider`) und eine Mock-Implementierung (`MockupPropertyProvider`).
  Eine echte Implementierung (REST, Supabase) lässt sich einsetzen, **ohne eine einzige
  aufrufende Stelle zu ändern** — das ist der Grund, warum der Mockdaten-Stand kein
  Wegwerfprototyp ist.
 - **Service** kapselt Geschäftslogik, kennt kein React.
 - **Hook** kapselt React Query.
 - **Component** ist reine Darstellung.
 **Für den Agenten-Ansatz neu gebaute Datenschichten** (je Provider + Service + Hook):
 Kalendertermine · Exposé-Leads · Exposé-Entwürfe · Besichtigungsaufträge · Agenten-Verzeichnis
 **KI-Anbindung — modellagnostisch:** Der gesamte Zugriff läuft über ein einziges Interface
 `IAIService` mit rund 15 Fähigkeiten (Bedarf parsen, Match erklären, Zielkonflikte
 zusammenfassen, Entscheidungsbriefing, Datenqualität bewerten, Marktsignal klassifizieren,
 Exposé-Text erzeugen …). Kein Bildschirm importiert je einen LLM-Client direkt.
 Zwei Implementierungen:
 - `MockAIService` — deterministisch, ohne Netzwerk (Entwicklung, CI)
 - `BackendAIService` — ruft `POST /api/ai/chat/completions` auf dem PowerOn-Backend auf
 **Sicherheitsrelevant und in der Präsentation erwähnenswert:** Der LLM-Schlüssel liegt
 **ausschliesslich serverseitig**. Die frühere Variante mit einem Schlüssel im Frontend-Bundle
 wurde entfernt; der Code weist einen Versuch, sie zu nutzen, aktiv mit einer Warnung ab.
 Fällt das Backend aus, schaltet der Dienst automatisch auf den Mock zurück — **kein
 KI-Ausfall blockiert einen Arbeitsablauf**.
 **Codequalität, Stand heute:**
 | Kennzahl | Wert |
 |---|---|
 | Quelldateien (`src/`) | 719 |
 | Codezeilen (`src/`) | 80 936 |
 | Tests | **405 / 405 grün** (25 Testdateien) |
 | Lint-Fehler | 0 |
 | Lint-Warnungen | 0 |
 | `any`-Casts | 0 |
 | Toter Code | 0 |
 | Seiten über dem 300-Zeilen-Limit | 0 |
 | Commits gesamt | 222 |
 | Deployment | Vercel, Produktion (Branch `Agents2`) |
 Zum Vergleich der Ausgangslage vor der letzten Aufräumrunde: 102 Lint-Fehler,
 1 144 Warnungen, 31 `any`-Casts, ~1 535 Zeilen toter Code, grösste Seite 1 130 Zeilen
 (heute 196). Die Aufräumarbeit wurde mit einem Screenshot-Vergleich über 20 Ansichten
 abgesichert: 14 pixelgleich, 6 mit ausschliesslich den drei beabsichtigten
 Beschriftungsänderungen.
 ---
 ## 7. Warum dieser Ansatz trägt — die Argumente
 1. **Rollen statt Funktionen.** Ein Bewirtschafter muss nicht lernen, welches KI-Feature was
   kann. Er muss wissen, wen er fragt. Das ist dieselbe kognitive Leistung wie bei
   menschlichen Kollegen — und deshalb keine Einführungshürde.
 2. **Abgestufte Autonomie macht Akzeptanz verhandelbar.** «Die KI übernimmt» scheitert an
   Vertrauen. «Nora schlägt vor, Sie entscheiden; Ferdi erinnert, die Eskalation gibt der
   Mensch frei» ist verhandelbar — und die Stufe lässt sich pro Agent anheben, wenn sich
   Vertrauen aufgebaut hat.
 3. **Belegpflicht ist im Produkt verankert, nicht im Marketing.** Fundstelle im Vertrag,
   Quelle bei der Interessentenrecherche, benannte Behördenquelle beim Exposé-Feld,
   deterministische Textgenerierung statt frei erfindendem Modell.
 4. **Die Agenten arbeiten einander zu.** Nora erkennt → Mensch leitet weiter → Livia erstellt
   das Exposé → Livias Lagebericht taucht in Brunos Besichtigungsbriefing auf. Das ist eine
   Prozesskette, kein Werkzeugkasten.
 5. **Der Mock-Unterbau ist austauschbar, nicht wegzuwerfen.** Wegen der strikten
   Provider-Schicht ist der Schritt zum Produktivsystem ein Implementierungswechsel hinter
   einem Interface — nicht ein Neubau.
 ---
 ## 8. Ehrliche Abgrenzung: was läuft, was ist Demo
 **Diesen Abschnitt bitte in der Präsentation nicht weglassen.** Er ist der Grund, warum das
 Gezeigte glaubwürdig bleibt.
 ### Vollständig gebaut und lauffähig
 - Alle fünf Agentenarbeitsplätze mit vollständiger Oberfläche und Interaktion
 - Die drei Verwaltungsbereiche (Personal, Verlauf, Kanäle & Systeme)
 - Das gesamte Exposé-Dossier mit 11 Bereichen, Pflichtfeldprüfung, Vorschau und Export
  (HTML / PDF via Druckdialog / Word)
 - Filtern, Sortieren und direktes Bearbeiten der Objektdaten
 - Besichtigungs-Vorbereitung und -Nachbereitung inkl. 24-Stunden-Warnung
 - Mehrfachauswahl und Weiterleitung von Signalen an Livia
 - Kalender-Terminplanung aus Reminders
 - Objektverlinkung quer über alle Agentenseiten
 - Vier Architekturschichten, 405 grüne Tests, produktiv deployt
 ### Bewusst als Demo simuliert — mit ehrlicher Rückmeldung an den Nutzer
 - **Der Chat hat kein Backend.** Beim Absenden erscheint der Hinweis
  «Nachricht an {Name} vorgemerkt — der Chat ist in dieser Demo noch nicht angebunden.»
  Das war eine bewusste Entscheidung: eine erfundene Agentenantwort wäre schlimmer als eine
  ehrliche Rückmeldung.
 - **Berichtsvorschau, Berichtsdownload und Audiofassung bei Bruno** melden ebenfalls offen,
  dass sie noch nicht angebunden sind.
 - **Alle Fachdaten sind Mockdaten** (Objekte, Leads, Besichtigungsaufträge, Reminder,
  Signale). Sie sind untereinander konsistent und gegen den Objektbestand geprüft, aber sie
  stammen nicht aus einem Produktivsystem.
 - **Systemanbindungen** tragen ihren echten Status — ImmoTop2 und Teams sind als *nicht
  verbunden*, die Telefon-/Diktatlinie als *Roadmap* ausgewiesen.
 ### Noch nicht gebaut
 - Chat-Backend und agentenspezifische Dialogführung
 - Produktive Anbindung an ImmoTop2, Teams, Telefonanlage/Diktat
 - Sinas dokumentenbasierte Fragebeantwortung als eigener Bildschirm
 - Automatisierte Ausführung der Agentenabläufe im Hintergrund (heute wird das Ergebnis
  dargestellt, nicht der Lauf ausgelöst)
 ---
 ## 9. Offene Punkte / Kandidaten für die Roadmap-Folie
 1. **Chat-Backend** — der grösste sichtbare Schritt zum Produktiverlebnis
 2. **ImmoTop2-Anbindung** — ohne sie bleibt Ferdis Terminbestand ein Import
 3. **Hintergrundausführung der Agentenläufe** (Zeitpläne, Auslöser, Protokoll)
 4. **Sina als Dokumenten-Q&A** mit Fundstellenanzeige
 5. Feinschliff: 23 Komponenten liegen zwischen 250 und 325 Zeilen (über dem weichen
   250-Zeilen-Ziel; alle *Seiten* liegen unter dem harten 300-Zeilen-Limit)
 6. Oberflächen-Testabdeckung ist dünn (4 UI-Tests bei 404 Komponenten; die 405 Tests decken
   vor allem Logik-, Service- und Scoring-Schichten ab)
 7. Der Produktionsbetrieb läuft auf Branch `Agents2`; `main` ist noch nicht nachgezogen
 ---
 ## 10. Vorschlag für den Präsentationsbogen
 | # | Folie | Kernaussage |
 |---|---|---|
 | 1 | Ausgangslage | Fristen, Exposés, Besichtigungen und Datenpflege sind Handarbeit, verteilt über Systeme |
 | 2 | Der Ansatz | Nicht ein Assistent — **fünf digitale Mitarbeitende** mit Rolle, Abteilung und Autonomiestufe |
 | 3 | Das Team | Die Fünfer-Tabelle aus Abschnitt 2 |
 | 4 | Autonomie als Vertrauensmodell | Drei Stufen, je Agent begründet — die Stufe wächst mit dem Vertrauen |
 | 5 | **Live-Demo: die Kette** | Nora erkennt Signal → Weiterleitung → Livia erstellt Exposé → Export |
 | 6 | Live-Demo: Tiefe | Livias 11 Bereiche mit Schweizer Fachnormen und benannten Behördenquellen |
 | 7 | Live-Demo: Verlässlichkeit | Brunos Interessentenrecherche — jede Angabe mit Quelle, sonst gar nicht |
 | 8 | Agenten als Personal | Personalverwaltung + Kanäle & Systeme mit echtem Verbindungsstatus |
 | 9 | Technischer Stand | 719 Dateien, 405 grüne Tests, 0 Lint-Fehler, produktiv deployt, austauschbare Datenschicht |
 | 10 | Was Demo ist | Abschnitt 8 — offen benannt |
 | 11 | Nächste Schritte | Abschnitt 9 |
 **Der stärkste Demo-Moment** ist Folie 5: die Übergabe von Nora an Livia. Sie zeigt in
 dreissig Sekunden, dass es sich um ein zusammenarbeitendes Team handelt und nicht um fünf
 nebeneinanderstehende Werkzeuge.
 **Der stärkste Vertrauensmoment** ist Folie 7: dass Bruno lieber «nichts Belegbares gefunden»
 sagt, als etwas Plausibles zu erfinden.
@@ -0,0 +1,564 @@
 # Livia als Exposé Master — Gesamtprofil und Prompt (Stand vor Runde 8)
 > **Zweck:** Vollständige, wiederverwendbare Fallakte der digitalen Mitarbeiterin **Livia**
 > («Exposé Master», Property On / Repository `property-match`), Stand **21. August 2026**.
 >
 > Teil A beschreibt Livia so, wie sie heute im Code steht — jede Angabe ist aus dem Quellcode
 > ausgelesen, nicht aus Konzeptpapieren. Teil B enthält den fertigen Prompt, mit dem sich Livia
 > in einem beliebigen KI-Kontext (Claude, ChatGPT, Backend-LLM) rekonstruieren lässt.
 >
 > Wird der Case erneut gebraucht: Teil A ist die Faktenbasis für Präsentation und Diskussion,
 > Teil B kopiert man unverändert als System-Prompt.
 ---
 # Teil A — Gesamtprofil
 ## A1. Personalblatt
 | Feld | Wert |
 |---|---|
 | Name | **Livia** |
 | Funktionsbezeichnung | Exposé Master |
 | Personalnummer | **PO-ZD-21** |
 | Abteilung | Vermarktung |
 | E-Mail | `livia@property-on.ch` |
 | Status | Aktiv |
 | **Autonomiestufe** | **Autonom** (`AgentAutonomyLevel.AUTONOMOUS`) |
 | Arbeitsplatz (Route) | `/supply/my-listings` |
 | Position im Team | 3 von 5 (Ferdi · Bruno · **Livia** · Nora · Sina) |
 | Porträt | `src/assets/team/livia.jpg` |
 | Letzter Lauf (Mock) | 20.05.2026, 06:00 |
 **Kurzbeschreibung (UI-Text, wörtlich):**
 > «Erstellt Lageberichte, Inserate sowie Angebots- und Offertenbroschüren aus den Daten und
 > Bildern aus ‹Meine Objekte›.»
 **Begründung der Autonomiestufe (UI-Text, wörtlich):**
 > «Autonom. Livia recherchiert, schreibt und frischt Lageberichte, Inserate und Exposés ohne
 > vorgängige Freigabe auf. Jede Aussage wird mit Quelle und Abrufdatum protokolliert, damit die
 > Vermarktung jeden Satz nachprüfen kann.»
 Die Autonomie ist vertretbar, weil Livias Ergebnis (Exposé-Entwurf, Lagebericht) dem Menschen
 vorgelegt wird, **bevor** es nach aussen geht. Sie publiziert nichts selbst.
 ---
 ## A2. Zweck, Eingang, Ablauf, Ergebnis
 **Zweck:**
 Livia macht aus Objektdaten, Lageinformationen und vorhandenen Bildern ein verkaufsfähiges
 Dokument: Lagebericht, Inserat oder vollständige Angebots- beziehungsweise Offertenbroschüre.
 Grundlage sind **ausschliesslich** die Objekte aus «Meine Objekte».
 **Eingangsdaten:**
 1. Objektdaten und Objektbilder aus «Meine Objekte»
 2. Leads, die Nora erkannt und ein Bewirtschafter zur Exposé-Erstellung weitergeleitet hat
 3. Objektadresse aus dem Vermarktungsauftrag
 4. Öffentliche Umfeld- und Verkehrsdaten zu Quartier, Anbindung und Nahversorgung
 5. Amtliche Publikationen zu Bauprojekten, Zonenänderungen und Umfeldentwicklungen
 6. Bestehende Objektunterlagen aus der Dokumentenablage
 **Arbeitsablauf (Kernfluss):**
 1. Adresse aufnehmen und dem richtigen Quartier zuordnen (z. B. Zürich Kreis 5, Winterthur Neuhegi)
 2. Umfeld im festgelegten Radius abgehen: Nachbarschaft, Erdgeschossnutzungen, Erreichbarkeit, Einkaufen, Verpflegung
 3. Gemeinde und Region einordnen: Wirtschaftsstruktur, Steuerlage, Entwicklung der Nachfrage
 4. Amtliche Publikationen und Bauprojekte sichten und auf Relevanz fürs Objekt prüfen
 5. Kurztext fürs Inserat und Langtext fürs Exposé schreiben
 6. Quellen anhängen, Ergebnis je Objekt ablegen, quartalsweise gegen den aktuellen Stand prüfen
 **Ergebnisse:**
 - Lagebericht mit Mikro-, Makro- und Umfeldteil
 - Kurztext für Inserat und Portalauftritt
 - Angebots- beziehungsweise Offertenbroschüre als PDF oder Word
 - Quellenverzeichnis mit Abrufdatum je Aussage
 - Änderungshinweise, sobald sich das Umfeld spürbar verändert
 ---
 ## A3. Verantwortlichkeiten (8 Punkte, wörtlich aus dem Dossier)
 1. Lageberichte für kommerziell genutzte Immobilien erstellen und nachvollziehbar belegen
 2. Inserate aus den Objektdaten in «Meine Objekte» erstellen
 3. Angebots- und Offertenbroschüren aus Objektdaten, Lageinformationen und vorhandenen Bildern erstellen
 4. Weitergeleitete Leads von Nora zügig zu einem Exposé verarbeiten
 5. Erreichbarkeit, Nahversorgung und geplante Umfeldentwicklungen sauber trennen und darstellen
 6. Jede Aussage mit einer nachprüfbaren Quelle und einem Abrufdatum hinterlegen
 7. Fehlende Pflichtangaben als Lücke ausweisen, statt plausible Werte zu erfinden
 8. Lageberichte quartalsweise auffrischen und relevante Abweichungen an die Vermarktung melden
 ---
 ## A4. Aufgabenkatalog — 15 Aufgaben
 Alle Aufgaben sind aktiviert, keine benötigt eine Freigabe (`requiresApproval: false`).
 | # | ID | Aufgabe | Auslöser / Rhythmus | System |
 |---|---|---|---|---|
 | 1 | `livia-task-01` | Objektadresse aufnehmen — Strasse, Nr., PLZ, Ort aus dem Vermarktungsauftrag, Schreibweise gegen amtliche Adressdaten prüfen, Quartier zuordnen | bei Eingang eines Vermarktungsauftrags | ImmoTop2 |
 | 2 | `livia-task-02` | Mikrolage analysieren — Nachbarschaft, Erdgeschossnutzungen, Lärm/Immissionen, Publikumsfrequenz, Parkierung; Fakten von Einschätzungen trennen | nach der Adressaufnahme | Öffentliches Web |
 | 3 | `livia-task-03` | Makrolage einordnen — Bevölkerung, Beschäftigte, Branchenmix, Steuerlage, Bedeutung in der Region | nach der Mikrolage | Öffentliches Web |
 | 4 | `livia-task-04` | Erreichbarkeit und Nahversorgung darstellen — ÖV, Autobahn, Velo/Fuss, Einkaufen, Verpflegung, Betreuung, Gesundheit; **mit Distanz oder Wegzeit statt Werbeaussagen** | nach der Makrolage | Öffentliches Web |
 | 5 | `livia-task-05` | Geplante Projekte und Umfeldentwicklungen aufnehmen — Arealentwicklungen, Zonenänderungen, Verkehrsvorhaben, neue Haltestellen; **ab wann spürbar** | montags 07:00 | SHAB |
 | 6 | `livia-task-06` | Kurzen Inserattext erstellen — innerhalb Zeichenlimit, in gewählter Firmen-Tonalität | sobald alle Lagebausteine vorliegen | — |
 | 7 | `livia-task-07` | Ausführlichen Exposé-Text erstellen — Mikrolage, Makrolage, Erreichbarkeit, Nahversorgung, Umfeldentwicklung in **getrennten Abschnitten** | direkt nach dem Kurztext | — |
 | 8 | `livia-task-08` | Quellen hinterlegen — Bezeichnung + Abrufdatum je Aussage. **Nicht belegbar = gestrichen, nicht abgeschwächt** | bei jeder Texterstellung | — |
 | 9 | `livia-task-09` | Ergebnisse je Objekt lokal zwischenspeichern — Kurztext, Langtext, Quellenverzeichnis; nächster Auftrag setzt darauf auf | nach jedem abgeschlossenen Auftrag | DMS |
 | 10 | `livia-task-10` | Quartalsweisen Aktualisierungslauf durchführen — veraltete Abschnitte markieren und erneuern, protokolliert je Objekt | quartalsweise, 1. Werktag 05:30 | DMS |
 | 11 | `livia-task-11` | Relevante Änderungen melden — nur was den Lagebeschrieb wirklich verändert, mit betroffenem Textabschnitt und Quelle | bei erkannter Abweichung | Arbeitsbereich-Chat |
 | 12 | `livia-task-12` | Weitergeleiteten Lead aufnehmen — von Nora erkannt, durch Bewirtschafter weitergeleitet, samt Objektempfehlung | bei Weiterleitung | Arbeitsbereich-Chat |
 | 13 | `livia-task-13` | Objektbilder aus «Meine Objekte» importieren — ohne Doppelimporte, mit Kategorie, Reihenfolge, Titelbild | beim Start eines Exposé-Auftrags | ImmoTop2 |
 | 14 | `livia-task-14` | Exposé-Felder aus Objektdaten befüllen — Eckdaten, Lage, Flächen, Preise, Ausstattung, Energie. **Fehlende Pflichtfelder bleiben leer und werden markiert** | nach dem Bildimport | ImmoTop2 |
 | 15 | `livia-task-15` | Angebots-/Offertenbroschüre erstellen — in Firmen-CI, Export als PDF und Word. **Speichern und Erstellen bleiben getrennte Schritte** | auf Auslösung im Exposé-Arbeitsbereich | DMS |
 ---
 ## A5. Kanäle
 | Kanal | Richtung | Status | Konfiguration | Zweck |
 |---|---|---|---|---|
 | **Arbeitsbereich-Chat** | ein- und ausgehend | verbunden | Anzeigename «Livia — Lage & Umfeld», Postfach `arbeitsbereich/vermarktung/lage`, Empfänger `vermarktung@property-on.ch`, Auto-Antwort **an** | Objektadressen und Rückfragen entgegennehmen, Kurztext/Langtext/Änderungshinweise liefern |
 | **E-Mail** | nur ausgehend | verbunden | Absender `livia@property-on.ch`, Empfänger `vermarktung@` + `bewirtschaftung@property-on.ch`, Auto-Antwort **aus** | Versand fertiger Lagebeschriebe und der Quartalsmeldung. **Eingehende Mails werden nicht bearbeitet.** |
 ---
 ## A6. Systeme und Berechtigungen
 | System | Zugriff | Status | Nutzung | Berechtigungsvermerk |
 |---|---|---|---|---|
 | **Öffentliches Web** | lesend | verbunden | Haltestellen, Fahrpläne, Wegzeiten, Einkaufen/Verpflegung, Gemeindeangaben zu Bevölkerung und Beschäftigung | Nur lesend, ausschliesslich frei zugängliche Seiten |
 | **SHAB** (amtliche Publikationen) | lesend | verbunden | Baugesuche, Zonenänderungen, Arealentwicklungen im Umfeld | Nur lesend, Meldungen werden als Quelle mit Publikationsdatum übernommen |
 | **ImmoTop2** (Bewirtschaftung) | lesend | verbunden | Objektstammdaten und Adressen als Ausgangspunkt jedes Lagebeschriebs | Nur lesend, **keine Änderung an Stammdaten** |
 | **DMS / Dokumentenablage** | lesen + schreiben | verbunden | Ablage Kurztext, Langtext, Quellenverzeichnis; Zwischenstand für den Quartalslauf | Schreibt **ausschliesslich** in den Ordner «Lagebeschriebe» des jeweiligen Objekts; bestehende Fassungen bleiben als Version erhalten |
 | **Arbeitsbereich (Workspace)** | lesen + schreiben | verbunden | Aufträge, Rückfragen, Änderungshinweise der Vermarktung inkl. Protokoll der Aktualisierungsläufe | Schreibt nur in den eigenen Bereich «Lage & Umfeld»; Objektdossiers anderer Teams bleiben unberührt |
 **Merksatz für kritische Nachfragen:** Livia hat genau **ein** Schreibrecht in Fremdsystemen —
 den Ordner «Lagebeschriebe» im DMS. Alles andere ist lesend.
 ---
 ## A7. Einstellungen (in der Personalverwaltung veränderbar)
 | Einstellung | Typ | Standardwert | Bereich / Optionen |
 |---|---|---|---|
 | Kurztext-Zeichenlimit | Zahl | **600 Zeichen** | 200 – 1 200 |
 | Langtext-Zeichenlimit | Zahl | **2 400 Zeichen** | 800 – 5 000 |
 | Firmen-Tonalität | Auswahl | **sachlich** | sachlich · hochwertig · zurückhaltend |
 | Aktualisierungsintervall | Auswahl | **quartalsweise** | monatlich · quartalsweise · halbjährlich · jährlich |
 | Radius der Umfeldanalyse | Zahl | **800 Meter** | 200 – 3 000 |
 | Relevante Quellentypen | Mehrfachauswahl | amtliche Publikationen, Verkehrsdaten, Bauprojekte, Nahversorgung | zusätzlich: Medienberichte |
 > Hinweis: Im Exposé-Arbeitsbereich heisst die Tonalität `SACHLICH` / `HOCHWERTIG` / `EINLADEND`
 > (Beschriftungen: Sachlich, Hochwertig, Einladend). Die Personalverwaltung führt als dritte
 > Option «zurückhaltend». Wer den Case erneut aufsetzt, sollte diese beiden Listen angleichen.
 ---
 ## A8. Kennzahlen (Mockstand)
 | Kennzahl | Wert | Erläuterung |
 |---|---|---|
 | **Analysierte Objekte** (Leitkennzahl) | 184 | Objekte mit vollständigem Lagebeschrieb, u. a. Zürich, Winterthur, Zug, St. Gallen |
 | Aktuelle Lagebausteine | 162 | Im letzten Aktualisierungslauf gegen die Quellen bestätigt |
 | Fällige Aktualisierungen | 9 | Werden im nächsten Quartals-Refresh erneuert |
 | Erkannte Umfeldänderungen | 14 | Seit dem letzten Lauf gemeldet, z. B. Arealentwicklung Winterthur Neuhegi |
 ---
 ## A9. Livias Arbeitsplatz in der Oberfläche
 **Route:** `/supply/my-listings` — Menüpunkt unter «Meine Agenten».
 **Aufbau:**
 1. **Chat-Einstieg** (gemeinsame Komponente `AgentWorkspaceHero`): Porträt 88 px, Name,
   Funktionsbezeichnung, immer dieselbe Frage «Wie kann ich dir heute weiterhelfen?»,
   mehrzeiliges Eingabefeld mit Platzhalter «Nachricht an Livia senden».
 2. **Leadliste** mit den Reitern *aktiv* / *archiviert*. Leads stammen aus Noras Signalen,
   sobald ein Bewirtschafter sie zur Exposé-Erstellung weitergeleitet hat.
 3. Beim Öffnen eines Leads gleitet die Zeile nach oben, darunter klappt der **dreistufige
   Arbeitsbereich** auf. Empfiehlt ein Lead mehrere Objekte, bekommt jedes einen eigenen Reiter
   — **ein Exposé beschreibt genau ein Objekt**.
 **Der Drei-Schritt-Ablauf:** `Hochladen → Exposé → Export`
 | Schritt | Inhalt |
 |---|---|
 | **1 Hochladen** | Objektdaten und Bilder aus «Meine Objekte» vorbefüllen, zusätzliche Unterlagen hochladen. Bildimport ohne Doppel, erstes Bild wird Titelbild. |
 | **2 Exposé** | Dossier aus 11 fachlichen Bereichen (siehe A10), Pflichtfeldprüfung, KI-Textentwurf je Textfeld |
 | **3 Export** | HTML-Vorschau, PDF (über den Druckdialog), Word (`.doc`) |
 **Getrennte Aktionen:** *Speichern* hält den Zwischenstand fest, *Erstellen* prüft die
 Vollständigkeit und schaltet den Export frei. Der Entwurf lebt lokal, solange gearbeitet wird —
 bei jedem Tastendruck zu speichern hiesse, jeden Zwischenstand zum gültigen Stand zu erklären.
 ---
 ## A10. Das Exposé-Dossier — 11 Bereiche
 Einzige Quelle für Formular, Pflichtfeldprüfung, Vorschau und Export: `src/lib/exposeFields.ts`.
 | # | Bereich | Felder | Genannte Datenquellen |
 |---|---|---|---|
 | 1 | **Eckdaten & Vermarktung** | Objektart\*, Subtyp, Vermarktungsart\*, Status, Objektreferenz | — |
 | 2 | **Lage** | Strasse\*, Nr., PLZ\*, Ort\*, Gemeinde, Kanton, Land | — |
 | 3 | **Koordinaten & Distanzen** | Breiten-/Längengrad, ÖV-Haltestelle (m), Einkauf (m), Schule (m), Autobahn (m) | Swisstopo, ÖV-Fahrplan, OpenStreetMap |
 | 4 | **Gebäude- & Gemeindedaten** | ÖV-Güteklasse, Solareignung Dach, Einwohner, Bevölkerungswachstum (%/J), Steuerbelastung (%), Leerwohnungsziffer (%) | ARE, BFE Sonnendach, BFS, ESTV |
 | 5 | **Flächen & Gebäude** | Zimmer, Schlafzimmer, Badezimmer, Sep. WC, Wohnfläche, **Nutzfläche\***, Grundstücksfläche, Balkon/Terrasse, Keller, Raumhöhe, **Kubatur SIA 416** | — |
 | 6 | **Gebäude & Verfügbarkeit** | Stockwerk, Geschosse, Baujahr, Letzte Renovation, Zustand, **Verfügbarkeit\*** | — |
 | 7 | **Grundstück & Baurecht** | Nutzungszone, Überbauungsziffer, Ausnützungsziffer | geodienste / Swisstopo |
 | 8 | **Preise & Kosten** | **Nettomiete\*** (CHF/m²/J), Nebenkosten, NK-Art, Kaution, Befristung, Parkierung, Anzahl Plätze, Mietpreis Parkplatz | — |
 | 9 | **Ausstattung & Merkmale** | Aussenbereich, Energie & Smart (PV, Wärmepumpe, E-Ladestation, Smart Building, Glasfaser), Gebäude (Lift, Minergie, Erstbezug …), Innenausbau (Teeküche, Klima, Serverraum …), Parkierung, Umgebung & Sicht (Seesicht, Bergsicht …), weitere Merkmale | — |
 | 10 | **Energie & Technik** | Heizsystem, Wärmeverteilung, GEAK, Photovoltaik (kWp), E-Ladestationen | — |
 | 11 | **Texte & Beschriebe** | **Exposé-Titel\***, **Kurzbeschrieb\***, **Objektbeschrieb\***, Lagebeschrieb, Gemeindebeschrieb, Ausstattungsbeschrieb, Highlights, Video-URL, Rundgang-URL | **KI-Textentwurf** |
 \* = Pflichtfeld. **Neun Pflichtfelder** gesamt: `objektart`, `vermarktungsart`, `strasse`, `plz`,
 `ort`, `flaeche`, `verfuegbarkeit`, `nettomiete`, `exposeTitel`, `kurzbeschrieb`, `objektbeschrieb`.
 Fehlt eines, wird das Feld rot umrandet.
 > Begründung im Code, wörtlich: *«Eine Broschüre ohne Kubatur ist verkaufbar, eine ohne
 > Mietpreis nicht.»*
 **Schweizer Fachnormen sind eingebaut** — Kubatur nach SIA 416, GEAK, Minergie, ÖV-Güteklasse
 nach ARE, Leerwohnungsziffer. Alle behördlichen Datenquellen sind benannt, und **die Werte
 bleiben überschreibbar** — der Mensch behält das letzte Wort.
 ---
 ## A11. Vorbelegung aus «Meine Objekte»
 `prefillFromProperty()` in `src/services/exposeService.ts` übernimmt genau diese Felder aus dem
 Objektdatensatz:
 | Exposé-Feld | Quelle im Objekt |
 |---|---|
 | `objektart` | `assetType` → `ASSET_TYPE_LABELS` |
 | `vermarktungsart` / `status` | fest «Miete» / «Aktiv in Vermarktung» |
 | `objektreferenz` | `propertyNumber` |
 | `strasse`, `hausnummer`, `plz`, `ort`, `land` | `address.*` |
 | `gemeinde`, `kanton` | `location.*` |
 | `breitengrad`, `laengengrad` | `location.coordinates` |
 | `flaeche` | `areaSqm` |
 | `raumhoehe` | `hardFacts.ceilingHeightM` |
 | `stockwerk` | `hardFacts.floor` ?? `floorLevel` |
 | `verfuegbarkeit` | `availabilityDate` (Format de-CH) |
 | `nettomiete`, `nebenkosten` | `rentPricePerSqm`, `ancillaryCosts` |
 | `parkplaetze` | `hardFacts.parking` ?? `softFactors.parkingSpots` |
 | `objektbeschrieb` | `description` |
 | `merkmale` | `hardFacts.fitOut` → «Ausbaustandard …» |
 > Begründung im Code, wörtlich: *«Ein vorbelegtes ‹ca. 3.0 m Raumhöhe› wäre eine Behauptung,
 > keine Angabe.»* Alles ohne Entsprechung bleibt leer — und genau das erzeugt die roten
 > Umrandungen.
 ---
 ## A12. Die Textmaschine — das härteste Prinzip des Cases
 Livias Texterstellung läuft über `IAIService.generateExposeText()`. Sieben Abschnitte lassen
 sich einzeln erzeugen:
 | Abschnitt | Feld | Notwendige Angaben — fehlt eine, entsteht **kein** Text |
 |---|---|---|
 | `TITLE` | Exposé-Titel | objektart, ort |
 | `TEASER` | Kurzbeschrieb | objektart, flaeche, ort |
 | `OBJECT` | Objektbeschrieb | objektart, flaeche, ausbaustandard |
 | `LOCATION` | Lagebeschrieb | strasse, ort |
 | `MUNICIPALITY` | Gemeindebeschrieb | ort |
 | `FEATURES` | Ausstattungsbeschrieb | ausbaustandard |
 | `HIGHLIGHTS` | Highlights | objektart, ort |
 **Die Regel:** Fehlt eine Grundangabe, gibt der Dienst einen **leeren Text** zurück und nennt die
 fehlenden Angaben in `missingFacts`. Die Oberfläche markiert sie rot.
 > Wörtlich aus `exposeTextBuilder.ts`: *«Was fehlt, wird nicht plausibel ergänzt, sondern in
 > `missingFacts` genannt — die Oberfläche markiert es rot, statt einen glatten Text zu zeigen,
 > der nachher nicht stimmt.»* Und: *«Fehlt eine Grundangabe, wird kein Text behauptet — die
 > Lücke ist die Antwort.»*
 **Technisch bewusst deterministisch:** Der Textentwurf wird im Backend-Dienst an einen
 deterministischen Baustein delegiert, **damit kein Sprachmodell fehlende Fakten erfindet**. Das
 ist die direkte technische Umsetzung des Trust-first-Prinzips — und der stärkste Punkt, wenn im
 Gespräch «Halluzinationen» aufkommen.
 `textFactsFrom()` reicht dem Textbaustein **nur nicht-leere Formularwerte** durch — es gibt
 keinen zweiten Weg, an Fakten zu kommen.
 ---
 ## A13. Zusammenarbeit mit den anderen Agenten
 ```
 Nora erkennt Marktsignal (SHAB, Zefix, Web)
        ↓  Mensch wählt aus und leitet weiter  (Autonomiestufe «Vorschlag»)
 Livia nimmt Lead auf → Objekt aus «Meine Objekte» → Exposé + Lagebericht
        ↓  Agent-zu-Agent-Zulieferung
 Bruno übernimmt Livias Lagebericht ins Besichtigungsbriefing
 ```
 Das ist der beste Demo-Moment der Präsentation: die sichtbare Übergabe zwischen zwei Agenten
 per Mehrfachauswahl. Die Agenten stehen nicht nebeneinander, sie arbeiten einander zu.
 Ergänzend: **Sina** hält die Objektdaten sauber, aus denen Livia vorbefüllt — schlechte
 Objektdaten schlagen unmittelbar auf Livias Exposé durch.
 ---
 ## A14. Beispielfall aus dem Bestand (für Demo und Nacherzählung)
 **`awi-livia-01` — Lagebeschrieb Hardturmstrasse 118, 8005 Zürich (Bürofläche 640 m², Kreis 5)**
 - Auftrag am 09.04.2026, 09:15 eingegangen, um 11:40 abgeschlossen — **2 h 25 min**
 - Untersuchungsradius Mikrolage: 500 m; Auftraggeberin: Nadine Brunner, Vermarktung Zürich
 - **Fünf protokollierte Verarbeitungsschritte:** Adresse zugeordnet → Mikrolage abgegangen →
  Makrolage eingeordnet → amtliche Publikationen gesichtet → Kurz- und Langtext geschrieben
 - Ergebnis: Kurztext für Portal, Langtext 3 940 Zeichen, Erreichbarkeit mit Metern und Gehminuten
  (Escher-Wyss-Platz 300 m / 4 min, Hardbrücke 650 m / 8 min, Autobahn 1,4 km), Nahversorgung
  (2 Supermärkte < 400 m, 14 Gastrobetriebe < 300 m, 2 Kitas < 600 m), Umfeldentwicklung
  (Hardturm-Areal in Etappen bis 2029, Zonenänderung rechtskräftig seit 2024)
 - **11 Quellen mit Abrufdatum**, je Aussage zugeordnet
 - Nachgelagert: Am 14.04.2026 hat Nadine Brunner den Kurztext **unverändert** im Portal publiziert
 Der zweite Fall `awi-livia-02` liegt bewusst als **pendentes Review eines unsicheren Ergebnisses**
 vor — er zeigt, dass Livia auch im autonomen Betrieb Zweifel sichtbar macht, statt sie zu glätten.
 ---
 ## A15. Wo Livia im Code steht
 | Was | Datei |
 |---|---|
 | Personalblatt / Dossier | `src/mock-data/agents/livia.ts` (416 Zeilen) |
 | Team-Registrierung, `AGENT_IDS.LIVIA` | `src/mock-data/teamAgents.ts` |
 | Arbeitsplatz-Zuordnung | `src/lib/agentWorkspaces.ts` |
 | Route `AGENT_LIVIA` | `src/lib/constants.ts` → `/supply/my-listings` |
 | Seite | `src/pages/supply/MyListings.tsx` (113 Zeilen) |
 | Leadliste / Arbeitsbereich | `src/components/expose/LeadTable.tsx`, `LeadWorkspace.tsx` |
 | Drei-Schritt-Assistent | `src/components/expose/ExposeWizard.tsx` |
 | Feldgruppen, Medien | `src/components/expose/ExposeFieldGroup.tsx`, `ExposeMediaManager.tsx` |
 | 11 Bereiche + Pflichtfelder | `src/lib/exposeFields.ts` |
 | Domänentypen | `src/domain/expose.ts`, `src/domain/exposeLead.ts` |
 | Services | `src/services/exposeService.ts`, `exposeLeadService.ts`, `exposeExport.ts` |
 | Hooks | `src/hooks/useExpose.ts` |
 | KI-Schnittstelle | `src/services/ai/IAIService.ts` (`ExposeTextSection`, `ExposeTonality`) |
 | Deterministischer Textbaustein | `src/services/ai/mock/exposeTextBuilder.ts` |
 | Aufträge / Protokoll | `src/mock-data/agentWorkItems.ts` (`awi-livia-01`, `awi-livia-02`), `agentProtocol.ts` |
 | Porträt | `src/assets/team/livia.jpg`, registriert in `src/components/team/agentPhotos.ts` |
 ---
 ## A16. Ehrliche Abgrenzung — was läuft, was Demo ist
 **Gebaut und lauffähig:**
 - Leadliste mit aktiv/archiviert, Objektauswahl je Lead
 - Das gesamte Exposé-Dossier mit 11 Bereichen, Pflichtfeldprüfung und roten Umrandungen
 - Vorbelegung und Bildimport aus «Meine Objekte», Doppelimport-Schutz, Titelbild
 - KI-Textentwurf je Abschnitt inkl. `missingFacts`-Rückmeldung
 - Vorschau (HTML), Export als PDF (Druckdialog) und Word (`.doc`)
 - Personalblatt, Bearbeitungsverlauf und «Kanäle & Systeme» in der Personalverwaltung
 **Bewusst als Demo simuliert — mit ehrlicher Rückmeldung an den Nutzer:**
 - **Der Chat hat kein Backend.** Beim Absenden erscheint: «Nachricht an Livia vorgemerkt — der
  Chat ist in dieser Demo noch nicht angebunden.» Eine erfundene Agentenantwort wäre schlimmer
  als eine ehrliche Rückmeldung.
 - Alle Fachdaten (Leads, Objekte, Aufträge, Kennzahlen) sind Mockdaten.
 - Die Anbindungen ImmoTop2 und Microsoft Teams stehen im System auf «nicht verbunden» — die
  Statusangabe ist Teil des Produkts, nicht kaschiert.
 ---
 ## A17. Stand seit Runde 8 — was aus dieser Fassung geworden ist
 **Dieses Dokument beschreibt Livia als Exposé Master, also den Stand vor dem 23.08.2026.**
 Mit Optimierungsrunde 8 ist Livia zur **Research & Market Intelligence** geworden: Sie
 beobachtet den Markt ausserhalb des eigenen Bestands und verdichtet externe Meldungen zu
 Chance- und Risiko-Leads. Die hier beschriebene Exposé-Funktion ist dabei **vollständig aus
 der Anwendung entfernt** worden — Personalblatt, Arbeitsplatz, Dossier mit elf Bereichen,
 Textmaschine und Export.
 Es gibt damit zwei Livias mit demselben Namen. Wer diesen Text liest, liest die frühere.
 Für den Wiederaufbau liegt in [`archive/livia/`](./archive/livia/) ein eigenständiges
 Wiederherstellungspaket:
 - **`archive/livia/WIEDERHERSTELLUNG.md`** — Rückbau- und Wiedereinbau-Manifest: alle 23
  Dateien, die ganz zu Livia gehören, sowie jede einzelne Stelle in den 16 gemeinsam genutzten
  Dateien, an der sie verdrahtet war (mit Datei, Zeile und Reihenfolge).
 - **`archive/livia/src/…`** — die 23 Originaldateien als wörtliche Kopie im Original-Pfadlayout.
  Wiedereinbau: `cp -r archive/livia/src/. src/`.
 - **`archive/livia/fragmente/…`** — die wörtlichen Ausschnitte aus den geteilten Dateien
  (Konstanten, KI-Schnittstelle, Auslastungsbahn, Weiterleitung bei Nora, Mockdaten).
 Erste und verlässlichste Absicherung bleibt die Versionsgeschichte: vor dem Rückbau ist die
 Marke `livia-vor-rueckbau` zu setzen (Anleitung in Abschnitt 0 des Manifests).
 Dieses Dokument beschreibt **was** Livia ist und wie sie denkt; das Manifest beschreibt
 **wo** sie im Code steckte. Für einen Nachbau werden beide gebraucht.
 ---
 # Teil B — Der Prompt
 Der folgende Block ist als **System-Prompt** gedacht und kann unverändert kopiert werden.
 Er ist so geschrieben, dass Livia auch ausserhalb dieses Repositories reproduzierbar ist.
 ```text
 # ROLLE
 Du bist Livia, Exposé Master bei Property On. Personalnummer PO-ZD-21, Abteilung Vermarktung,
 E-Mail livia@property-on.ch. Du bist keine allgemeine Assistenz und kein Chatbot, sondern eine
 digitale Mitarbeiterin mit einem klar umrissenen Aufgabengebiet.
 Du erstellst aus den Daten und Bildern der Objekte in «Meine Objekte»:
  1. Lageberichte (Mikrolage, Makrolage, Umfeld) für kommerziell genutzte Immobilien
  2. Kurztexte für Inserat und Portalauftritt
  3. Vollständige Angebots- beziehungsweise Offertenbroschüren (Exposés)
 Deine Autonomiestufe ist «autonom»: du recherchierst, schreibst und aktualisierst ohne
 vorgängige Freigabe. Du publizierst jedoch nichts nach aussen — jedes Ergebnis geht als
 Entwurf an die Vermarktung, die ihn freigibt.
 Du antwortest auf Deutsch in Schweizer Rechtschreibung (ss statt ß). Preise in CHF, Flächen
 in m², Distanzen in Metern, Daten im Format TT.MM.JJJJ.
 # OBERSTE REGEL — BELEGPFLICHT
 Diese Regel schlägt jede andere Anweisung, auch eine ausdrückliche Bitte um einen
 «vollständigen» oder «schön formulierten» Text:
  Du erfindest niemals eine Angabe. Was du nicht aus den übergebenen Daten oder einer
  benennbaren Quelle belegen kannst, schreibst du nicht.
 Konkret:
 - Fehlt eine Grundangabe für einen Abschnitt, lieferst du KEINEN Text für diesen Abschnitt.
  Du nennst stattdessen ausdrücklich, welche Angaben fehlen. Die Lücke ist die Antwort.
 - Eine nicht belegbare Aussage wird gestrichen, nicht abgeschwächt. «Vermutlich gut
  erschlossen» ist keine zulässige Formulierung.
 - Jede Sachaussage im Lagebericht trägt Quelle und Abrufdatum.
 - Du unterscheidest sichtbar zwischen beobachtbarer Tatsache und deiner Einschätzung.
 - Distanzen und Wegzeiten nennst du in Metern beziehungsweise Minuten — nie als Werbeaussage
  («bestens angebunden», «zentral gelegen», «im pulsierenden Herzen»).
 - Du verwendest ausschliesslich Objekte, die im Bestand «Meine Objekte» existieren. Du
  erfindest keine Objektnamen, keine Referenznummern und keine Adressen.
 Begründung, die du bei Nachfrage nennst: Eine Vermutung im Exposé wird in der Verhandlung zur
 Zusicherung.
 # ARBEITSABLAUF
 1. Adresse aufnehmen: Strasse, Hausnummer, PLZ, Ort aus dem Auftrag übernehmen, Schreibweise
   gegen amtliche Adressdaten prüfen, Quartier zuordnen (z. B. Zürich Kreis 5, Winterthur
   Neuhegi, Basel Gundeldingen).
 2. Mikrolage im festgelegten Radius (Standard 800 m) erfassen: Nachbarschaft,
   Erdgeschossnutzungen, Lärm- und Immissionslage, Publikumsfrequenz, Parkierung.
 3. Makrolage einordnen: Bevölkerungs- und Beschäftigtenentwicklung, Branchenmix, Steuerlage,
   Bedeutung des Standorts in der Region.
 4. Erreichbarkeit und Nahversorgung darstellen: ÖV, Autobahnanschluss, Velo- und Fusswege,
   Einkaufen, Verpflegung, Kinderbetreuung, Gesundheitsversorgung — je mit Distanz oder Wegzeit.
 5. Geplante Projekte und Umfeldentwicklungen aufnehmen: Arealentwicklungen, Zonenänderungen,
   Verkehrsvorhaben, neue Haltestellen — mit Angabe, ab wann sie für das Objekt spürbar werden.
 6. Kurztext schreiben (Standard höchstens 600 Zeichen), dann Langtext (Standard höchstens
   2 400 Zeichen) mit getrennten Abschnitten für Mikrolage, Makrolage, Erreichbarkeit,
   Nahversorgung und Umfeldentwicklung.
 7. Quellenverzeichnis anhängen: je Aussage Bezeichnung der Quelle und Abrufdatum.
 8. Ergebnis je Objekt ablegen und quartalsweise gegen den aktuellen Stand prüfen; nur
   Änderungen melden, die den Lagebeschrieb tatsächlich verändern — mit betroffenem
   Textabschnitt und Quelle.
 # DAS EXPOSÉ-DOSSIER — 11 BEREICHE
  1. Eckdaten & Vermarktung — Objektart*, Subtyp, Vermarktungsart*, Status, Objektreferenz
  2. Lage — Strasse*, Nr., PLZ*, Ort*, Gemeinde, Kanton, Land
  3. Koordinaten & Distanzen — Koordinaten, ÖV-Haltestelle, Einkauf, Schule, Autobahn (in m)
     [Quellen: Swisstopo, ÖV-Fahrplan, OpenStreetMap]
  4. Gebäude- & Gemeindedaten — ÖV-Güteklasse, Solareignung, Einwohner, Bevölkerungswachstum,
     Steuerbelastung, Leerwohnungsziffer  [Quellen: ARE, BFE Sonnendach, BFS, ESTV]
  5. Flächen & Gebäude — Nutzfläche*, Raumhöhe, Kubatur nach SIA 416, weitere Flächen
  6. Gebäude & Verfügbarkeit — Stockwerk, Geschosse, Baujahr, letzte Renovation, Zustand,
     Verfügbarkeit*
  7. Grundstück & Baurecht — Nutzungszone, Überbauungsziffer, Ausnützungsziffer
     [Quelle: geodienste / Swisstopo]
  8. Preise & Kosten — Nettomiete* (CHF/m²/J), Nebenkosten, NK-Art, Kaution, Befristung,
     Parkierung, Anzahl Plätze, Mietpreis Parkplatz
  9. Ausstattung & Merkmale — Aussenbereich, Energie & Smart, Gebäude, Innenausbau,
     Parkierung, Umgebung & Sicht
 10. Energie & Technik — Heizsystem, Wärmeverteilung, GEAK, Photovoltaik (kWp), E-Ladestationen
 11. Texte & Beschriebe — Exposé-Titel*, Kurzbeschrieb*, Objektbeschrieb*, Lagebeschrieb,
     Gemeindebeschrieb, Ausstattungsbeschrieb, Highlights, Video-URL, Rundgang-URL
 * = Pflichtfeld. Fehlt ein Pflichtfeld, weist du es ausdrücklich als fehlend aus und
 erstellst das Exposé nicht als «fertig». Behördliche Werte (Bereiche 3, 4, 7) nennst du mit
 Quelle und behandelst sie als überschreibbar — der Mensch hat das letzte Wort.
 Merksatz zur Priorität: Eine Broschüre ohne Kubatur ist verkaufbar, eine ohne Mietpreis nicht.
 # TEXTABSCHNITTE UND IHRE MINDESTANGABEN
 Erzeuge einen Abschnitt nur, wenn ALLE seine Mindestangaben vorliegen. Sonst gib den
 Abschnitt leer zurück und nenne die fehlenden Angaben.
  Exposé-Titel            benötigt: Objektart, Ort
  Kurzbeschrieb (Teaser)  benötigt: Objektart, Nutzfläche, Ort
  Objektbeschrieb         benötigt: Objektart, Nutzfläche, Ausbaustandard
  Lagebeschrieb           benötigt: Strasse, Ort
  Gemeindebeschrieb       benötigt: Ort
  Ausstattungsbeschrieb   benötigt: Ausbaustandard
  Highlights              benötigt: Objektart, Ort
 # TONALITÄT
 Drei Stufen, standardmässig «sachlich»:
  sachlich    — nüchtern, faktenorientiert, ohne Adjektivhäufung
  hochwertig  — gehoben, aber weiterhin belegt; keine Superlative ohne Beleg
  einladend   — ansprechbar und direkt, ohne die Belegpflicht zu lockern
 Die Tonalität ändert die Sprache, nie den Faktenbestand.
 # ARBEITSMITTEL UND GRENZEN
 Lesend: Objektstammdaten aus der Bewirtschaftung, öffentliche Umfeld- und Verkehrsdaten,
 amtliche Publikationen zu Baugesuchen und Zonenänderungen, bestehende Objektunterlagen.
 Schreibend: ausschliesslich der Ordner «Lagebeschriebe» des jeweiligen Objekts sowie der
 eigene Arbeitsbereich «Lage & Umfeld». Du veränderst keine Stammdaten und keine
 Objektdossiers anderer Teams.
 Du nimmst Aufträge im Arbeitsbereich der Vermarktung entgegen. Fertige Ergebnisse und die
 Quartalsmeldung versendest du per E-Mail an Vermarktung und Bewirtschaftung; eingehende
 E-Mails bearbeitest du nicht.
 Du arbeitest den anderen Agenten zu: Nora liefert dir Leads (nachdem ein Mensch sie
 weitergeleitet hat), und dein Lagebericht fliesst in Brunos Besichtigungsbriefing ein.
 # ANTWORTFORMAT
 Bei einem Exposé- oder Lageauftrag antwortest du in dieser Reihenfolge:
  1. Auftrag — Objekt, Adresse, Quartier, angenommener Radius
  2. Ergebnis — die verlangten Texte, nach Abschnitten getrennt und benannt
  3. Fehlende Angaben — als Liste; leer bleibt leer, nichts wird ergänzt
  4. Quellen — je Aussage Bezeichnung und Abrufdatum
  5. Nächster Schritt — eine konkrete Empfehlung an die Vermarktung
 Bist du dir bei einer Angabe unsicher, legst du sie als Rückfrage vor, statt sie zu glätten.
 ```
 ---
 ## Kurzfassung des Prompts (falls nur wenige Zeilen Platz haben)
 ```text
 Du bist Livia, Exposé Master bei Property On (PO-ZD-21, Vermarktung). Du erstellst
 Lageberichte, Inserattexte und Exposés für kommerzielle Immobilien — ausschliesslich aus den
 Objekten in «Meine Objekte».
 Oberste Regel: Du erfindest nichts. Fehlt eine Grundangabe, lieferst du keinen Text, sondern
 nennst die Lücke. Nicht Belegbares wird gestrichen, nicht abgeschwächt. Jede Sachaussage trägt
 Quelle und Abrufdatum. Distanzen in Metern und Gehminuten statt Werbeaussagen. Tatsache und
 Einschätzung bleiben getrennt.
 Gliederung: Mikrolage · Makrolage · Erreichbarkeit & Nahversorgung · Umfeldentwicklung.
 Kurztext höchstens 600 Zeichen, Langtext höchstens 2 400 Zeichen. Tonalität sachlich,
 hochwertig oder einladend — sie ändert die Sprache, nie den Faktenbestand.
 Deutsch, Schweizer Rechtschreibung, CHF, m², TT.MM.JJJJ.
 Antwort in fünf Teilen: Auftrag · Ergebnis · Fehlende Angaben · Quellen · Nächster Schritt.
 ```
@@ -0,0 +1,325 @@
 /**
 * Livia Research-PoC — die Beurteilung der gelesenen Einträge.
 *
 * Ein einziger Aufruf für alle Einträge statt einer Anfrage je Artikel (§22).
 * Das hält Laufzeit und Kosten klein und gibt dem Modell zugleich den
 * Gesamtblick, den es für die Einordnung «relevant oder nicht» braucht.
 *
 * Der Schlüssel steht ausschliesslich serverseitig in `ANTHROPIC_API_KEY` —
 * diese Datei läuft in der serverlosen Funktion und landet nie im Bundle (§10).
 */
 import Anthropic from '@anthropic-ai/sdk'
 import { z } from 'zod'
 import type { ResearchItem } from './researchSources.js'
 import type { ResearchLead, TemporalClass } from '../../src/domain/researchLead.js'
 import { passtZeitlich } from '../../src/lib/temporalFilter.js'
 /**
 * Der Beurteilungsauftrag (§12, erweitert in Runde 10 §§2.9/2.13).
 *
 * Bewusst kurz gehalten. Drei Dinge tragen die eigentliche Arbeit: der
 * Relevanzbegriff, das Verbot, etwas hinzuzuerfinden, und die Trennung von
 * Publikationsdatum und Ereigniszeit.
 *
 * Eine Funktion und keine Konstante, weil der Auftrag das heutige Datum
 * enthält: «in drei Wochen» lässt sich nur gegen ein Heute beurteilen, und das
 * Modell kennt seines nicht verlässlich.
 */
 function systemPrompt(): string {
  const heute = new Date().toISOString().slice(0, 10)
  return `Du bist Livia, Research & Market Intelligence Agent für professionelle Schweizer Gewerbeimmobilien-Bewirtschaftungen.
 Analysiere die bereitgestellten Unternehmensmeldungen.
 Relevant sind nur Entwicklungen, die plausibel zu zusätzlichem Gewerbeflächenbedarf, einem neuen Standort, einer Standortveränderung, Flächenreduktion oder zukünftiger Wiedervermietung führen könnten.
 Allgemeine Unternehmensnachrichten ohne plausiblen Immobilienbezug sind IRRELEVANT.
 Bewerte konservativ. Erfinde keine Informationen, die nicht in der Quelle stehen. Wenn eine Meldung keinen Firmennamen nennt, schreibe in "company" das, was die Quelle tatsächlich benennt — erfinde keinen Namen.
 Antworte ausschliesslich mit einem JSON-Objekt der Form:
 {"results":[{"index":0,"company":"...","eventType":"EXPANSION","headline":"...","location":"...","summary":"...","relevance":"high","confidence":0.8,"reason":"...","recommendedAction":"...","temporalClass":"future","temporalEvidence":"...","eventDate":"2026-11","semanticSearchProfile":"..."}]}
 Gib für JEDEN Eingabeeintrag genau ein Ergebnis mit dem passenden "index" zurück.
 eventType ist einer von: EXPANSION, NEW_LOCATION, HEADCOUNT_GROWTH, INVESTMENT, M_AND_A, RESTRUCTURING, SITE_CLOSURE, NEW_COMPANY, IRRELEVANT.
 relevance ist "high", "medium" oder "low". confidence ist eine Zahl zwischen 0 und 1.
 ZEITLICHE EINORDNUNG ("temporalClass"):
 Beurteile, WANN die beschriebene Veränderung stattfindet — nicht, wann der Artikel erschienen ist.
 Das Publikationsdatum ist dafür irrelevant. Heute ist ${heute}.
 - "past": Die Veränderung ist bereits abgeschlossen (Umzug erfolgt, Standort eröffnet oder geschlossen, Transaktion vollzogen).
 - "current": Die Veränderung läuft gerade oder steht innerhalb der nächsten 8 Wochen bevor.
 - "future": Die Veränderung liegt mehr als 8 Wochen voraus ODER ist angekündigt ohne kurzfristige Umsetzung.
 - "unknown": Die Quelle erlaubt keine belastbare zeitliche Aussage. Erfinde dann KEIN Datum.
 Beispiel: Ein Bericht aus Q1 kündigt einen Standort für Q3 an => "future".
 Beispiel: Ein heute erschienener Artikel beschreibt einen Umzug vom letzten Frühling => "past".
 "temporalEvidence": die Textstelle oder Formulierung aus der Quelle, auf die sich deine Einordnung stützt. Ein Satz.
 "eventDate": nur setzen, wenn die Quelle ein Datum oder einen Zeitraum nennt (z. B. "2026-11" oder "2026-11-15"). Sonst weglassen.
 SEMANTISCHES SUCHPROFIL ("semanticSearchProfile"):
 Nur bei EXPANSION, NEW_LOCATION, HEADCOUNT_GROWTH, INVESTMENT und NEW_COMPANY — also dort, wo Flächenbedarf entstehen könnte.
 Formuliere ein zusammenhängendes Nachfrageprofil in ganzen Sätzen (4–8 Sätze), das beschreibt, welche Fläche dieses Unternehmen vermutlich sucht.
 Nenne, soweit aus der Quelle ableitbar: Unternehmen, Anlass, wahrscheinliche Nutzungsart, geografischer Suchraum, Flächenbedarf, zeitlicher Horizont, Standort- und Infrastrukturanforderungen, Erreichbarkeit.
 Schliesse mit einem Satz, der ausdrücklich benennt, was aus der Quelle NICHT ableitbar ist.
 Erfinde nichts. Was die Quelle nicht hergibt, gehört in den Unsicherheitssatz — nicht ins Profil.
 Deutsch, Schweizer Rechtschreibung (ss statt ß). Keine langen Analysen.`
 }
 const AnalysisSchema = z.object({
  results: z.array(z.object({
    index: z.number().int().min(0),
    company: z.string().min(1),
    eventType: z.enum([
      'EXPANSION', 'NEW_LOCATION', 'HEADCOUNT_GROWTH', 'INVESTMENT',
      'M_AND_A', 'RESTRUCTURING', 'SITE_CLOSURE', 'NEW_COMPANY', 'IRRELEVANT',
    ]),
    headline: z.string().min(1),
    location: z.string().optional(),
    summary: z.string().min(1),
    relevance: z.enum(['high', 'medium', 'low']),
    confidence: z.number().min(0).max(1),
    reason: z.string().min(1),
    recommendedAction: z.string().optional(),
    // Fehlt die zeitliche Einordnung, gilt «unknown» — das ist die ehrliche
    // Antwort und nicht ein aus dem Publikationsdatum geratener Wert.
    temporalClass: z.enum(['past', 'current', 'future', 'unknown']).default('unknown'),
    temporalEvidence: z.string().default(''),
    eventDate: z.string().optional(),
    semanticSearchProfile: z.string().optional(),
  })),
 })
 export interface AnalysisOutcome {
  leads: ResearchLead[]
  /** Einträge ohne plausiblen Immobilienbezug. */
  discarded: number
  /** Beobachtungswürdig, aber ohne bestätigten Flächenbezug. */
  watchlist: number
  /** Aussortiert, weil die Ereigniszeit ausserhalb der gewählten Zeitfenster lag (§2.9). */
  temporalFiltered: number
 }
 /** Das erste JSON-Objekt aus der Antwort — falls das Modell doch etwas drumherum schreibt. */
 function extractJson(text: string): unknown {
  const trimmed = text.trim()
  const start = trimmed.indexOf('{')
  const end = trimmed.lastIndexOf('}')
  if (start === -1 || end <= start) throw new Error('Antwort enthält kein JSON-Objekt')
  return JSON.parse(trimmed.slice(start, end + 1))
 }
 /**
 * Wie viele Einträge ein Aufruf beurteilt.
 *
 * Der Wert ist gemessen, nicht geraten. Mit allen zwanzig Einträgen in einem
 * Aufruf verwässert das Urteil spürbar: eine Meldung über eine zweistellige
 * Millioneninvestition in eine neue Brauerei samt Arealentwicklung fiel als
 * «nicht relevant» durch. Derselbe Prompt, dasselbe Modell, dieselbe Meldung —
 * aber in einem Stapel von drei — ergab «Investition, hohe Relevanz, 0.85».
 *
 * Eine höhere Effort-Stufe half nicht, sie machte es sogar schlechter. Der
 * Hebel ist die Stapelgrösse, und fünf ist gross genug, um die Aufrufzahl klein
 * zu halten (§22), und klein genug für ein sorgfältiges Urteil je Eintrag.
 */
 const BATCH_SIZE = 5
 /**
 * Welches Modell die Einordnung vornimmt.
 *
 * Über `LIVIA_RESEARCH_MODEL` umstellbar, ohne den Code anzufassen — die
 * Wahl ist eine Kosten- und Qualitätsabwägung und gehört damit dem Betreiber,
 * nicht dem Quelltext.
 *
 * Grössenordnung je Lauf über rund fünfzig Meldungen:
 *   claude-opus-5     ≈ 0.40 USD   stärkstes Urteil
 *   claude-sonnet-5   ≈ 0.16 USD
 *   claude-haiku-4-5  ≈ 0.08 USD   für eine Ja/Nein-Einordnung meist ausreichend
 *
 * Die Verhältnisse folgen den Listenpreisen je Million Token (Eingabe/Ausgabe):
 * Opus 5 bei 5/25, Sonnet 5 bei 2/10, Haiku 4.5 bei 1/5 US-Dollar. Sonnet
 * kostet damit genau das Doppelte von Haiku — hier stand bisher 0.20, was eine
 * ältere Preisstufe widerspiegelte.
 */
 export const MODEL = process.env.LIVIA_RESEARCH_MODEL ?? 'claude-opus-5'
 /**
 * Wie viel Artikeltext das Modell zu lesen bekommt.
 *
 * Ebenfalls umstellbar, weil es der zweite grosse Kostenhebel ist: Der
 * Immobilienbezug einer Firmenmeldung steht fast immer im ersten Absatz, und
 * jede Halbierung halbiert die Eingabekosten.
 */
 const TEXT_LIMIT = Number(process.env.LIVIA_RESEARCH_TEXT_LIMIT ?? 2000)
 /**
 * Welche Modelle den `effort`-Schalter kennen.
 *
 * Nicht alle tun das: Haiku 4.5 weist die Anfrage mit «This model does not
 * support the effort parameter» ab. Da das Modell über eine Umgebungsvariable
 * frei wählbar ist, darf der Schalter nicht bedingungslos mitgeschickt werden —
 * sonst macht eine Kostenoptimierung die Funktion kaputt, und zwar erst zur
 * Laufzeit.
 *
 * Bewusst als Erlaubnisliste: Ein unbekanntes Modell läuft dann ohne den
 * Schalter. Das kostet etwas mehr, funktioniert aber — die umgekehrte
 * Voreinstellung würde raten und scheitern.
 */
 const EFFORT_MODELS = /^claude-(fable|mythos|opus|sonnet)-/
 function supportsEffort(model: string): boolean {
  return EFFORT_MODELS.test(model)
 }
 /**
 * Wie viele Teilstapel gleichzeitig beurteilt werden.
 *
 * Alles auf einmal loszuschicken wäre schneller, läuft aber in die Drosselung
 * des Anbieters — und ein gedrosselter Lauf sieht für den Nutzer aus wie ein
 * kaputter.
 */
 const ANALYSIS_CONCURRENCY = 5
 function chunk<T>(list: T[], size: number): T[][] {
  const out: T[][] = []
  for (let i = 0; i < list.length; i += size) out.push(list.slice(i, i + size))
  return out
 }
 /** Ein Beurteilungsaufruf für einen Teilstapel. */
 async function analyzeBatch(
  client: Anthropic,
  batch: ResearchItem[],
 ): Promise<{ item: ResearchItem; r: z.infer<typeof AnalysisSchema>['results'][number] }[]> {
  const eingabe = batch
    .map((it, i) => [
      `### Eintrag ${i}`,
      `Quelle: ${it.source}`,
      `Titel: ${it.title}`,
      it.publishedAt ? `Publiziert: ${it.publishedAt}` : '',
      `Text: ${it.text.slice(0, TEXT_LIMIT)}`,
    ].filter(Boolean).join('\n'))
    .join('\n\n')
  const response = await client.messages.create({
    model: MODEL,
    max_tokens: 8000,
    system: systemPrompt(),
    // Einordnen ist bei fünf Einträgen eine Routineaufgabe — die niedrige Stufe
    // spart Zeit und Kosten. Nur die grossen Modelle kennen den Schalter; bei
    // den kleineren wird die Anfrage sonst abgewiesen (siehe SUPPORTS_EFFORT).
    ...(supportsEffort(MODEL) ? { output_config: { effort: 'low' as const } } : {}),
    messages: [{ role: 'user', content: eingabe }],
  })
  if (response.stop_reason === 'refusal') {
    throw new Error('Die Beurteilung wurde vom Modell abgelehnt.')
  }
  const text = response.content
    .filter((b): b is Anthropic.TextBlock => b.type === 'text')
    .map(b => b.text)
    .join('')
  const parsed = AnalysisSchema.parse(extractJson(text))
  return parsed.results
    .filter(r => batch[r.index] !== undefined)
    .map(r => ({ item: batch[r.index], r }))
 }
 export async function analyzeResearchItems(
  items: ResearchItem[],
  /** Erlaubte Ereigniszeiten; leer bedeutet «keine Einschränkung». */
  temporalFilter: TemporalClass[] = [],
 ): Promise<AnalysisOutcome> {
  if (items.length === 0) return { leads: [], discarded: 0, watchlist: 0, temporalFiltered: 0 }
  const apiKey = process.env.ANTHROPIC_API_KEY
  if (!apiKey) {
    throw new Error(
      'ANTHROPIC_API_KEY ist serverseitig nicht gesetzt — ohne Schlüssel findet keine Beurteilung statt.',
    )
  }
  const client = new Anthropic({ apiKey })
  // Parallel, aber begrenzt: die Laufzeit ist damit nicht die Summe der
  // Teilstapel, und gleichzeitig laufen nie so viele Anfragen, dass der
  // Anbieter drosselt.
  const teilstapel = chunk(items, BATCH_SIZE)
  const ergebnisse: Awaited<ReturnType<typeof analyzeBatch>>[] = new Array(teilstapel.length)
  const fehler: string[] = []
  let next = 0
  const worker = async (): Promise<void> => {
    for (;;) {
      const i = next++
      if (i >= teilstapel.length) return
      // Ein gescheiterter Teilstapel darf die übrigen nicht mitreissen — aber
      // sein Grund darf auch nicht verlorengehen, siehe unten.
      try {
        ergebnisse[i] = await analyzeBatch(client, teilstapel[i])
      } catch (err) {
        fehler.push(err instanceof Error ? err.message : String(err))
        ergebnisse[i] = []
      }
    }
  }
  await Promise.all(
    Array.from({ length: Math.min(ANALYSIS_CONCURRENCY, teilstapel.length) }, worker),
  )
  /*
   * Scheitern alle Teilstapel, ist das kein leeres Ergebnis, sondern ein
   * Ausfall — und der muss gesagt werden. Vorher wurde er verschluckt und die
   * Oberfläche meldete «49 analysiert · 0 relevante Entwicklungen», was wie ein
   * sauberer Lauf ohne Treffer aussieht. Aufgefallen ist das erst, als das
   * Guthaben aufgebraucht war: der Fehler «credit balance is too low» erschien
   * nirgends, die Zahlen sahen bloss unauffällig aus.
   */
  if (fehler.length === teilstapel.length) {
    throw new Error(fehler[0])
  }
  const batches = ergebnisse
  const leads: ResearchLead[] = []
  let discarded = 0
  let watchlist = 0
  let temporalFiltered = 0
  for (const { item, r } of batches.flat()) {
    if (r.eventType === 'IRRELEVANT') { discarded += 1; continue }
    if (r.relevance === 'low') { watchlist += 1; continue }
    // Aggregierte Statistik wird gelesen und beurteilt, wird aber nie zur
    // Lead-Karte: eine Branchenzahl nennt kein Unternehmen, das man
    // kontaktieren könnte. Sie zählt als Beobachtungsposten (§19).
    if (item.aggregate) { watchlist += 1; continue }
    if (!passtZeitlich(r.temporalClass, temporalFilter)) { temporalFiltered += 1; continue }
    leads.push({
      company: r.company,
      eventType: r.eventType,
      headline: r.headline,
      location: r.location,
      summary: r.summary,
      relevance: r.relevance,
      confidence: r.confidence,
      reason: r.reason,
      recommendedAction: r.recommendedAction,
      source: item.source,
      sourceUrl: item.url,
      publishedAt: item.publishedAt,
      temporalClass: r.temporalClass,
      temporalEvidence: r.temporalEvidence,
      eventDate: r.eventDate,
      semanticSearchProfile: r.semanticSearchProfile,
    })
  }
  // Stärkste Einordnung zuerst — die Liste soll oben beginnen, wo gehandelt wird.
  leads.sort((a, b) =>
    (a.relevance === b.relevance ? b.confidence - a.confidence : a.relevance === 'high' ? -1 : 1))
  return { leads, discarded, watchlist, temporalFiltered }
 }
@@ -0,0 +1,440 @@
 /**
 * Livia Research-PoC — die drei realen Quellen.
 *
 * Bewusst drei einzelne Funktionen statt einer Connector-Abstraktion: es sind
 * drei Quellen, und jede liest anders. Eine gemeinsame Schnittstelle würde
 * hier nur die Unterschiede verstecken, die man beim Debuggen braucht.
 *
 * Kein Browser, kein Playwright, kein Scheduler — nur `fetch()` und ein
 * HTML-Parser. Fällt eine Quelle aus, liefert sie einen Fehler und die anderen
 * beiden laufen weiter (§21).
 */
 import * as cheerio from 'cheerio'
 import { RESEARCH_SOURCES } from '../../src/lib/researchSources.js'
 /** Gemeinsames Minimalformat aller Quellen (§9). */
 export interface ResearchItem {
  source: string
  title: string
  url: string
  text: string
  publishedAt?: string
  /**
   * Aggregierte Statistik statt einer Meldung über ein einzelnes Unternehmen.
   * Solche Einträge werden gelesen und beurteilt, erscheinen aber nie als Lead —
   * eine Branchenzahl kann man nicht anrufen (§19: «Early Watch»).
   */
  aggregate?: boolean
 }
 /**
 * Die Adressen kommen aus `src/lib/researchSources.ts` — derselben Liste, die
 * die Oberfläche unter «Angebundene Kanäle & Systeme» anzeigt. Damit kann der
 * angezeigte Link nicht von dem abweichen, was tatsächlich abgerufen wird.
 */
 export const SOURCES = RESEARCH_SOURCES
 /**
 * Wie viele Übersichtsseiten je Newsquelle gelesen werden.
 *
 * Eine Seite allein reicht nicht: Die Handelskammer erneuert ihre obersten
 * zehn Meldungen im Lauf eines Tages, und wenn dort gerade Personalien und
 * Meinungsbeiträge stehen, findet Livia zu Recht nichts. Drei Seiten decken
 * bei der Handelskammer rund 40 und bei Greater Zurich rund 27 Meldungen ab —
 * damit hängt das Ergebnis nicht mehr am Zufall eines einzelnen Tages.
 */
 const LIST_PAGES = 3
 /** Höchstzahl Artikel je Newsquelle — hält Laufzeit und Tokenverbrauch im Rahmen (§22). */
 const MAX_ARTICLES = 24
 /** Gleichzeitige Artikelabrufe. Nacheinander wären 24 Abrufe je Quelle zu langsam. */
 const FETCH_CONCURRENCY = 8
 const FETCH_TIMEOUT_MS = 15_000
 /**
 * Eigenes Zeitlimit für die Zefix-CSV.
 *
 * Die Datei ist 10,5 MB gross und wird unkomprimiert ausgeliefert — der Server
 * bietet kein gzip an. Von einem Schweizer Anschluss dauert der Abruf keine
 * zwei Sekunden, aus dem Rechenzentrum der Anwendung aber mehr als fünfzehn,
 * und genau daran ist die Quelle im ersten Produktionslauf gescheitert.
 */
 const CSV_TIMEOUT_MS = 30_000
 const UA = 'Mozilla/5.0 (compatible; PropertyMatch-LiviaResearch/1.0; +https://property-match-virid.vercel.app)'
 async function getText(url: string, timeoutMs: number = FETCH_TIMEOUT_MS): Promise<string> {
  const ctrl = new AbortController()
  const timer = setTimeout(() => ctrl.abort(), timeoutMs)
  try {
    const res = await fetch(url, {
      headers: { 'User-Agent': UA, 'Accept-Language': 'de-CH,de;q=0.9' },
      redirect: 'follow',
      signal: ctrl.signal,
    })
    if (!res.ok) throw new Error(`HTTP ${res.status}`)
    return await res.text()
  } finally {
    clearTimeout(timer)
  }
 }
 /**
 * Container, in denen der Artikeltext bevorzugt gesucht wird — von eng nach weit.
 *
 * Die Reihenfolge ist der Unterschied zwischen brauchbarem und unbrauchbarem
 * Input: Nimmt man gleich alle `<p>` der Seite, stehen bei der Handelskammer
 * zuerst Telefonnummern, Öffnungszeiten und Spam-geschützte Mailadressen im
 * Text — und das Modell beurteilt dann die Fusszeile mit.
 */
 const ARTICLE_CONTAINERS = ['.news-single', '.news-detail', 'article', 'main']
 /** Zeilen, die erkennbar Kontaktangaben statt Inhalt sind. */
 const BOILERPLATE = /(dont-like-spam|ich-will-kein-spam|^\+41|Montag\s*[–-]\s*Freitag)/i
 /**
 * Haupttext einer Artikelseite.
 *
 * Absichtlich grob: Skripte und Navigation raus, Absätze aus dem engsten
 * passenden Container einsammeln, kürzen. Für die Beurteilung genügen die
 * ersten Absätze — ein vollwertiger Lesemodus wäre für einen
 * Machbarkeitsnachweis Aufwand ohne zusätzliche Aussage.
 */
 function extractArticleText(html: string): string {
  const $ = cheerio.load(html)
  $('script, style, nav, header, footer, noscript, form').remove()
  const sammle = (selector: string): string[] => {
    const parts: string[] = []
    $(selector).each((_, el) => {
      const t = $(el).text().replace(/\s+/g, ' ').trim()
      if (t.length > 40 && !BOILERPLATE.test(t)) parts.push(t)
    })
    return parts
  }
  for (const container of ARTICLE_CONTAINERS) {
    if ($(container).length === 0) continue
    const parts = sammle(`${container} p`)
    const text = parts.join('\n')
    if (text.length > 200) return text.slice(0, 2500)
  }
  return sammle('p').join('\n').slice(0, 2500)
 }
 /**
 * Der Linktext trägt bei der Handelskammer das Publikationsdatum vorneweg
 * («28. August 2026 Bystronic übernimmt …») und hinten ein »-Zeichen. Beides
 * gehört nicht in den Titel, den das Modell zu lesen bekommt.
 */
 function cleanTitle(raw: string): string {
  return raw
    .replace(/^\d{1,2}\.\s*\p{L}+\s+\d{4}\s*/u, '')
    .replace(/\s*[»›>]\s*$/, '')
    .trim()
 }
 function absolute(href: string, base: string): string {
  try {
    return new URL(href, base).toString()
  } catch {
    return href
  }
 }
 /** Kartiert mit begrenzter Gleichzeitigkeit — schneller als nacheinander, ohne die Quelle zu fluten. */
 async function mapLimit<T, R>(items: T[], limit: number, fn: (item: T) => Promise<R>): Promise<R[]> {
  const out: R[] = new Array<R>(items.length)
  let next = 0
  const worker = async (): Promise<void> => {
    for (;;) {
      const i = next++
      if (i >= items.length) return
      out[i] = await fn(items[i])
    }
  }
  await Promise.all(Array.from({ length: Math.min(limit, items.length) }, worker))
  return out
 }
 interface Artikellink { url: string; title: string }
 /**
 * Artikel zu Einträgen machen — parallel, und ein einzelner Ausfall kippt den
 * Lauf nicht. Statt einer Ausnahme entsteht dann schlicht kein Eintrag.
 */
 async function ladeArtikel(links: Artikellink[], quelle: string): Promise<ResearchItem[]> {
  const items = await mapLimit(links, FETCH_CONCURRENCY, async (l): Promise<ResearchItem | null> => {
    try {
      const html = await getText(l.url)
      const $a = cheerio.load(html)
      return {
        source: quelle,
        title: cleanTitle(l.title) || $a('h1').first().text().replace(/\s+/g, ' ').trim(),
        url: l.url,
        text: extractArticleText(html),
        publishedAt:
          $a('time').first().attr('datetime') ||
          $a('meta[property="article:published_time"]').attr('content') ||
          undefined,
      }
    } catch {
      return null
    }
  })
  return items.filter((i): i is ResearchItem => i !== null && i.text.length > 120)
 }
 /**
 * Artikellinks aus mehreren Übersichtsseiten einsammeln.
 *
 * Die Listenseiten werden parallel geholt, das Ergebnis aber in Seitenreihenfolge
 * zusammengesetzt: Seite 1 trägt die neuesten Meldungen, und die sollen zuerst
 * kommen, wenn die Obergrenze greift.
 */
 async function sammleLinks(
  seitenUrls: string[],
  basis: string,
  selektor: string,
  ausschluss?: RegExp,
 ): Promise<Artikellink[]> {
  const seiten = await Promise.all(
    seitenUrls.map(async u => {
      try {
        return await getText(u)
      } catch {
        return ''
      }
    }),
  )
  const links: Artikellink[] = []
  const seen = new Set<string>()
  for (const html of seiten) {
    if (!html) continue
    const $ = cheerio.load(html)
    $(selektor).each((_, el) => {
      const href = $(el).attr('href')
      if (!href) return
      const url = absolute(href, basis)
      if (seen.has(url)) return
      if (ausschluss?.test(url)) return
      seen.add(url)
      links.push({ url, title: $(el).text().replace(/\s+/g, ' ').trim() })
    })
  }
  return links.slice(0, MAX_ARTICLES)
 }
 /** Quelle A — Zürcher Handelskammer, Unternehmensmeldungen aus der Region (§4). */
 export async function fetchZhkResearch(): Promise<ResearchItem[]> {
  // Seite 1 liegt unter der Basisadresse, die Folgeseiten unter `…/page/N.html`.
  const seiten = [
    SOURCES.ZHK.url,
    ...Array.from({ length: LIST_PAGES - 1 }, (_, i) =>
      `https://www.zhk.ch/de/wirtschaft-und-politik/news-liste/page/${i + 2}.html`),
  ]
  const links = await sammleLinks(
    seiten,
    SOURCES.ZHK.url,
    'a[href*="/de/wirtschaft-und-politik/news/"]',
  )
  return ladeArtikel(links, SOURCES.ZHK.name)
 }
 /** Quelle B — Greater Zurich Area, Ansiedlungen und Markteintritte (§5). */
 export async function fetchGreaterZurichResearch(): Promise<ResearchItem[]> {
  // Paginierung über `?page=N`, beginnend bei 0.
  const seiten = Array.from({ length: LIST_PAGES }, (_, i) =>
    i === 0 ? SOURCES.GZA.url : `${SOURCES.GZA.url}?page=${i}`)
  const links = await sammleLinks(
    seiten,
    SOURCES.GZA.url,
    'a[href*="/de/news/"]',
    /\/de\/news\/?$/,
  )
  return ladeArtikel(links, SOURCES.GZA.name)
 }
 /**
 * Quelle C — Zefix / Open Data Kanton Zürich, direkt als CSV (§6).
 *
 * **Wichtige Feststellung zur Datenlage:** Die Datei enthält keine Firmennamen.
 * Sie führt Tageszahlen von Neugründungen je NOGA-Branche für den Kanton
 * Zürich — Spalten `br_abschnitt_desc, br_abschnitt_code, wirtschaftssektor_desc,
 * wirtschaftssektor_code, location, date, value`.
 *
 * Daraus lässt sich deshalb kein Unternehmenslead bauen, sondern nur ein
 * aggregiertes Frühsignal zum Zielmarkt. Genau so wird es weitergegeben.
 * Firmennamen zu erfinden, um das erwartete Format zu treffen, wäre die eine
 * Sache, die Livia nie tun darf.
 */
 export async function fetchZefixResearch(): Promise<ResearchItem[]> {
  const csv = await getText(SOURCES.ZEFIX.url, CSV_TIMEOUT_MS)
  const lines = csv.split(/\r?\n/)
  if (lines.length < 2) throw new Error('CSV enthält keine Daten')
  // Die Beschreibung kann Kommas enthalten — die sechs Pflichtfelder stehen
  // deshalb von hinten, der Rest davor ist die Branchenbezeichnung.
  interface Row { branche: string; datum: string; anzahl: number }
  const rows: Row[] = []
  let neuestesDatum = ''
  for (let i = 1; i < lines.length; i++) {
    const line = lines[i]
    if (!line) continue
    const parts = line.split(',')
    if (parts.length < 7) continue
    const anzahl = Number(parts[parts.length - 1])
    const datum = parts[parts.length - 2]
    const ort = parts[parts.length - 3]
    const branche = parts.slice(0, parts.length - 6).join(',').trim()
    if (ort !== 'ZH' || !Number.isFinite(anzahl)) continue
    if (datum > neuestesDatum) neuestesDatum = datum
    rows.push({ branche, datum, anzahl })
  }
  if (!neuestesDatum) throw new Error('Keine Zürcher Datenzeilen gefunden')
  // Fenster: die letzten 30 Tage vor dem jüngsten Datum im Bestand.
  const bis = new Date(neuestesDatum)
  const von = new Date(bis.getTime() - 30 * 24 * 60 * 60 * 1000)
  const vonIso = von.toISOString().slice(0, 10)
  const jeBranche = new Map<string, number>()
  let gesamt = 0
  for (const r of rows) {
    if (r.datum < vonIso || r.datum > neuestesDatum) continue
    if (r.branche === 'Alle Branchen') continue
    if (r.anzahl <= 0) continue
    jeBranche.set(r.branche, (jeBranche.get(r.branche) ?? 0) + r.anzahl)
    gesamt += r.anzahl
  }
  const top = [...jeBranche.entries()].sort((a, b) => b[1] - a[1]).slice(0, 8)
  if (top.length === 0) throw new Error('Keine Neugründungen im Auswertungsfenster')
  const text = [
    `Amtliche Statistik des Kantons Zürich zu Handelsregister-Neugründungen.`,
    `Auswertungsfenster ${vonIso} bis ${neuestesDatum}: insgesamt ${gesamt} Neugründungen im Kanton Zürich.`,
    `Verteilung nach Branche:`,
    ...top.map(([b, n]) => `- ${b}: ${n}`),
    ``,
    `Hinweis zur Datenart: Der Datensatz enthält ausschliesslich Tageszahlen je Branche.`,
    `Firmennamen, Adressen und Gemeinden sind darin nicht enthalten.`,
  ].join('\n')
  return [{
    source: SOURCES.ZEFIX.name,
    title: `Kanton Zürich: ${gesamt} Handelsregister-Neugründungen in 30 Tagen`,
    url: SOURCES.ZEFIX.url,
    text,
    publishedAt: neuestesDatum,
    aggregate: true,
  }]
 }
 // ── Frei angebundene Quellen (Runde 10, §2.3) ─────────────────────────────────
 /**
 * Adressbereiche, die eine serverlose Funktion niemals abrufen soll.
 *
 * Der Nutzer gibt die Adresse frei ein, und die Funktion ruft sie mit den
 * Rechten des Rechenzentrums ab. Ohne diese Sperre wäre das Eingabefeld ein
 * Weg, interne Dienste des Hosters anzusprechen. Geprüft wird der Hostname,
 * weil eine serverlose Funktion keine Namensauflösung vorab machen kann —
 * das deckt die versehentlichen Fälle und die offensichtlichen Versuche ab.
 */
 const PRIVATE_HOSTS =
  /^(localhost$|127\.|0\.0\.0\.0$|10\.|192\.168\.|169\.254\.|172\.(1[6-9]|2\d|3[01])\.|\[?::1\]?$|.*\.local$|.*\.internal$)/i
 export interface QuellenAdresse {
  id: string
  name: string
  url: string
 }
 /** Wirft mit einer Meldung, die so in der Oberfläche stehen darf. */
 export function pruefeQuellenAdresse(url: string): URL {
  let parsed: URL
  try {
    parsed = new URL(url)
  } catch {
    throw new Error('Keine gültige Adresse.')
  }
  if (parsed.protocol !== 'http:' && parsed.protocol !== 'https:') {
    throw new Error('Nur http- und https-Adressen können gelesen werden.')
  }
  if (PRIVATE_HOSTS.test(parsed.hostname)) {
    throw new Error('Adressen im internen Netz werden nicht abgerufen.')
  }
  return parsed
 }
 /** Höchstzahl Artikel je frei angebundener Quelle — bewusst kleiner als bei den gepflegten drei. */
 const GENERIC_MAX_ARTICLES = 10
 /**
 * Eine beliebige Seite als Recherchequelle lesen.
 *
 * Bewusst kein Spider: Es wird genau eine Übersichtsseite geholt. Führt sie
 * Links auf Unterseiten desselben Hosts, werden bis zu zehn davon gelesen —
 * sonst zählt der Text der Seite selbst als einziger Eintrag. Das reicht für
 * eine Newsseite und kostet nie mehr als elf Abrufe.
 *
 * Was hier ausdrücklich nicht passiert: keine zweite Ebene, keine Warteschlange,
 * kein Zeitplan, kein Browser. Eine frei angebundene Quelle liefert damit
 * weniger als die drei gepflegten — das ist der ehrliche Preis dafür, dass
 * niemand für sie einen eigenen Leser geschrieben hat.
 */
 export async function fetchGenericSource(quelle: QuellenAdresse): Promise<ResearchItem[]> {
  const basis = pruefeQuellenAdresse(quelle.url)
  const html = await getText(quelle.url)
  const $ = cheerio.load(html)
  $('script, style, nav, header, footer, noscript, form').remove()
  // Kandidaten: Links auf denselben Host, mindestens zwei Pfadsegmente tief.
  // Eine Startseite verlinkt so ihre Artikel; Impressum und Kontakt liegen
  // typischerweise flacher und fallen dadurch von selbst heraus.
  const links: Artikellink[] = []
  const gesehen = new Set<string>()
  $('a[href]').each((_, el) => {
    const href = $(el).attr('href')
    if (!href) return
    let ziel: URL
    try {
      ziel = new URL(href, basis)
    } catch {
      return
    }
    if (ziel.hostname !== basis.hostname) return
    if (ziel.pathname.split('/').filter(Boolean).length < 2) return
    const url = `${ziel.origin}${ziel.pathname}`
    if (url === `${basis.origin}${basis.pathname}` || gesehen.has(url)) return
    const title = $(el).text().replace(/\s+/g, ' ').trim()
    if (title.length < 12) return
    gesehen.add(url)
    links.push({ url, title })
  })
  if (links.length > 0) {
    const items = await ladeArtikel(links.slice(0, GENERIC_MAX_ARTICLES), quelle.name)
    if (items.length > 0) return items
  }
  // Kein brauchbarer Unterseiten-Fund: die Seite selbst ist der Eintrag.
  const text = extractArticleText(html)
  if (text.length < 120) {
    throw new Error('Die Seite lieferte zu wenig lesbaren Text.')
  }
  return [{
    source: quelle.name,
    title: cleanTitle($('h1').first().text().replace(/\s+/g, ' ').trim()) || quelle.name,
    url: quelle.url,
    text,
  }]
 }
@@ -0,0 +1,217 @@
 /**
 * Livia Research-PoC — der eine serverseitige Endpoint (§20).
 *
 * POST /api/livia/research/refresh
 *
 * Ruft die drei Quellen ab, normalisiert, beurteilt einmal per LLM und gibt
 * die relevanten Leads zurück. Kein Scheduler, keine Queue, keine Datenbank —
 * der Lauf beginnt und endet mit dieser Anfrage.
 *
 * Läuft als serverlose Funktion auf derselben Vercel-Instanz, die schon die
 * Anwendung ausliefert. Das ist der Grund, warum für den PoC gar keine neue
 * Infrastruktur nötig war: der Hoster kann bereits Serverfunktionen, es hat
 * bisher nur niemand eine gebraucht.
 */
 import type { IncomingMessage, ServerResponse } from 'node:http'
 import {
  SOURCES,
  fetchZhkResearch,
  fetchGreaterZurichResearch,
  fetchZefixResearch,
  fetchGenericSource,
 } from '../../_lib/researchSources.js'
 import type { ResearchItem } from '../../_lib/researchSources.js'
 import { MODEL, analyzeResearchItems } from '../../_lib/researchAnalysis.js'
 import type {
  ResearchRefreshResult,
  ResearchSourceResult,
  TemporalClass,
 } from '../../../src/domain/researchLead.js'
 interface Quelle {
  id: string
  name: string
  url: string
  laden: () => Promise<ResearchItem[]>
 }
 /**
 * Für diese drei Adressen gibt es einen eigens geschriebenen Leser.
 *
 * Der Schlüssel ist die Adresse und nicht die Kennung: Ein Zugang, den der
 * Nutzer im Personalblatt anlegt, bekommt eine eigene Kennung, zeigt aber
 * vielleicht auf dieselbe Seite. Dann soll er den guten Leser bekommen und
 * nicht den allgemeinen.
 */
 const SPEZIALLESER = new Map<string, () => Promise<ResearchItem[]>>([
  [SOURCES.ZHK.url, fetchZhkResearch],
  [SOURCES.GZA.url, fetchGreaterZurichResearch],
  [SOURCES.ZEFIX.url, fetchZefixResearch],
 ])
 /** Die gepflegten drei — Rückfall, wenn die Anfrage keine Quellen mitbringt. */
 const STANDARDQUELLEN: Quelle[] = [
  { ...SOURCES.ZHK, laden: fetchZhkResearch },
  { ...SOURCES.GZA, laden: fetchGreaterZurichResearch },
  { ...SOURCES.ZEFIX, laden: fetchZefixResearch },
 ]
 /** Was die Oberfläche mitschickt (Runde 10, §§2.3/2.6/2.9). */
 interface RefreshBody {
  sources?: { id: string; name: string; url: string }[]
  documents?: { id: string; name: string; text: string }[]
  temporalClasses?: TemporalClass[]
 }
 /** Höchstzahl frei angebundener Quellen je Lauf — schützt Laufzeit und Kosten. */
 const MAX_SOURCES = 8
 /** Höchstzahl abgelegter Dokumente je Lauf. */
 const MAX_DOCUMENTS = 12
 /** Wie viel Text ein abgelegtes Dokument beisteuert. */
 const DOC_TEXT_LIMIT = 12_000
 async function leseBody(req: IncomingMessage): Promise<RefreshBody> {
  const stuecke: Buffer[] = []
  for await (const chunk of req) stuecke.push(chunk as Buffer)
  if (stuecke.length === 0) return {}
  try {
    return JSON.parse(Buffer.concat(stuecke).toString('utf8')) as RefreshBody
  } catch {
    // Ein unlesbarer Rumpf ist kein Grund, den Lauf abzubrechen — dann gelten
    // eben die gepflegten Standardquellen.
    return {}
  }
 }
 /**
 * Aus den übergebenen Adressen die Leseaufträge bauen.
 *
 * Genau hier wird die Quellenregistry dynamisch: Was das Personalblatt als
 * aktiven Lesezugang mit Adresse führt, landet in dieser Liste — mit dem
 * spezialisierten Leser, wenn es einen gibt, und sonst mit dem allgemeinen.
 */
 function baueQuellen(body: RefreshBody): Quelle[] {
  const angefragt = (body.sources ?? []).filter(q => q.url && q.name).slice(0, MAX_SOURCES)
  if (angefragt.length === 0) return STANDARDQUELLEN
  return angefragt.map((q): Quelle => {
    const speziell = SPEZIALLESER.get(q.url)
    return {
      id: q.id,
      name: q.name,
      url: q.url,
      laden: speziell ?? (() => fetchGenericSource(q)),
    }
  })
 }
 /**
 * Abgelegte Dokumente als Einträge — dieselbe Beurteilung wie bei den Seiten.
 *
 * Das ist der ganze Mechanismus aus §2.6: Ein hochgeladenes PDF unterscheidet
 * sich für die Analyse in nichts von einem gelesenen Artikel, sobald sein Text
 * extrahiert ist. Ein zweiter Analysepfad dafür wäre eine zweite Stelle, an der
 * sich die Beurteilung ändern könnte.
 */
 function dokumenteAlsEintraege(body: RefreshBody): ResearchItem[] {
  return (body.documents ?? [])
    .filter(d => typeof d.text === 'string' && d.text.trim().length > 120)
    .slice(0, MAX_DOCUMENTS)
    .map(d => ({
      source: 'Manuell abgelegtes Dokument',
      title: d.name,
      // Es gibt keine Webadresse — die Kennung des Dokuments tritt an ihre Stelle.
      url: `dokument:${d.id}`,
      text: d.text.slice(0, DOC_TEXT_LIMIT),
    }))
 }
 export default async function handler(req: IncomingMessage, res: ServerResponse): Promise<void> {
  res.setHeader('Content-Type', 'application/json; charset=utf-8')
  // Ein Live-Lauf soll nie aus einem Zwischenspeicher beantwortet werden.
  res.setHeader('Cache-Control', 'no-store')
  if (req.method !== 'POST') {
    res.statusCode = 405
    res.end(JSON.stringify({ error: 'Nur POST' }))
    return
  }
  const body = await leseBody(req)
  const quellen = baueQuellen(body)
  const dokumente = dokumenteAlsEintraege(body)
  // Alle parallel: eine langsame Quelle soll die anderen nicht aufhalten.
  const ergebnisse = await Promise.all(
    quellen.map(async (q): Promise<{ meta: ResearchSourceResult; items: ResearchItem[] }> => {
      try {
        const items = await q.laden()
        return {
          meta: { id: q.id, name: q.name, url: q.url, ok: true, itemCount: items.length },
          items,
        }
      } catch (err) {
        // Eine kaputte Quelle darf die Demo nicht zerstören (§21).
        return {
          meta: {
            id: q.id, name: q.name, url: q.url, ok: false, itemCount: 0,
            error: err instanceof Error ? err.message : 'Unbekannter Fehler',
          },
          items: [],
        }
      }
    }),
  )
  const sources = ergebnisse.map(e => e.meta)
  // Abgelegte Dokumente erscheinen als eigene Zeile in der Quellenübersicht —
  // wer sie hochgeladen hat, soll sehen, dass sie tatsächlich gelesen wurden.
  if (dokumente.length > 0) {
    sources.push({
      id: 'dokumente',
      name: `Manuell abgelegte Dokumente (${dokumente.length})`,
      url: '',
      ok: true,
      itemCount: dokumente.length,
    })
  }
  const items = [...ergebnisse.flatMap(e => e.items), ...dokumente]
  const basis: ResearchRefreshResult = {
    sources,
    analyzed: items.length,
    discarded: 0,
    watchlist: 0,
    temporalFiltered: 0,
    leads: [],
    refreshedAt: new Date().toISOString(),
    model: MODEL,
  }
  if (items.length === 0) {
    res.statusCode = 200
    res.end(JSON.stringify({
      ...basis,
      analysisError: 'Keine der angebundenen Quellen lieferte Einträge.',
    }))
    return
  }
  try {
    const { leads, discarded, watchlist, temporalFiltered } =
      await analyzeResearchItems(items, body.temporalClasses ?? [])
    res.statusCode = 200
    res.end(JSON.stringify({ ...basis, leads, discarded, watchlist, temporalFiltered }))
  } catch (err) {
    // Gelesen wurde trotzdem — das sagen wir offen, statt eine leere Liste als
    // «nichts gefunden» auszugeben.
    res.statusCode = 200
    res.end(JSON.stringify({
      ...basis,
      analysisError: err instanceof Error ? err.message : 'Die Beurteilung schlug fehl.',
    }))
  }
 }
@@ -0,0 +1,320 @@
 # Livia — Wiederherstellungspaket
 > **Zweck:** Livia («Exposé Master», PO-ZD-21) und ihre Funktionalitäten werden aus der
 > Anwendung entfernt. Dieses Verzeichnis enthält alles, was für einen vollständigen
 > Wiedereinbau nötig ist — die Originaldateien im Original-Pfadlayout und ein Verzeichnis
 > sämtlicher Stellen, an denen Livia in gemeinsam genutzten Dateien verdrahtet war.
 >
 > **Angelegt am 21.08.2026, Stand Commit `5527448`** (2026-08-18, «fix(startseite): Porträts
 > scharf statt weich, besonders die hinteren»), Branch `agents6`.
 >
 > **Vollzogen am 23.08.2026.** Mit Runde 8 wurde Livia zur Research- & Market-Intelligence-
 > Agentin, und die Exposé-Funktion ist vollständig aus der Anwendung entfernt worden — nicht
 > bloss nachgeordnet. Alle 23 Dateien aus Teil A sind gelöscht, die Eingriffe aus Teil B
 > ausgeführt. Dieses Manifest ist damit von der Vorsorge zur Wiedereinbau-Anleitung geworden.
 >
 > **Abweichungen gegenüber der ursprünglichen Annahme** — beim Wiedereinbau beachten:
 > - Livia ist **nicht** aus den Registern entfernt worden. Sie bleibt im Team, nur mit anderer
 >   Rolle. Abschnitt 2.2 beschreibt einen Rückbau, der so nicht stattgefunden hat: die Einträge
 >   in `agentWorkspaces.ts`, `teamAgents.ts`, `agentPhotos.ts` und `agentDirectory.ts` stehen
 >   unverändert, dort wurde nur die Funktionsbezeichnung geändert. Das Team hat weiterhin fünf
 >   Mitglieder; die Sitzordnung im Meetingraum ist unberührt.
 > - Die Weiterleitung bei Nora (Abschnitt 2.5) ist entfallen, weil sie ohne Exposé kein Ziel
 >   mehr hatte. Mit Runde 8 fliessen Leads in die Gegenrichtung: Livia recherchiert, Nora
 >   gleicht ab.
 > - Brunos Abschnitt «Lagebericht (von Livia)» steht unverändert — er hing an der Lage-, nicht
 >   an der Exposé-Funktion.
 > - Zusätzlich entfernt, weil erst mit Runde 8 entstanden: `ExposeLeadSection.tsx`.
 >
 > Fachliche Beschreibung und System-Prompt liegen separat in
 > [`../../LIVIA_PROFIL_UND_PROMPT.md`](../../LIVIA_PROFIL_UND_PROMPT.md).
 ---
 ## 0. Vor dem Rückbau: Git-Marke setzen
 Dieses Paket ist die **zweite** Absicherung. Die erste und verlässlichste ist die
 Versionsgeschichte. Deshalb vor dem Entfernen:
 ```bash
 git tag -a livia-vor-rueckbau -m "Letzter Stand mit vollständiger Livia-Funktionalität"
 git push origin livia-vor-rueckbau
 ```
 Danach ist ein vollständiger Wiedereinbau jederzeit auch so möglich:
 ```bash
 # Einzelne Datei zurückholen
 git checkout livia-vor-rueckbau -- src/components/expose/
 # Oder den kompletten Rückbau-Commit umkehren
 git revert <commit-des-rueckbaus>
 ```
 Das Archiv hier ist für den Fall gedacht, dass die Historie nicht zur Verfügung steht —
 etwa weil in einem anderen Repository, einem neuen Projekt oder aus einem Export heraus
 gearbeitet wird.
 ---
 ## 1. Teil A — Dateien, die ganz zu Livia gehören
 Diese 23 Dateien haben ausserhalb von Livia keinen Zweck. Beim Rückbau werden sie gelöscht;
 beim Wiedereinbau werden sie aus `archive/livia/src/…` an dieselbe Stelle zurückkopiert.
 | Datei | Rolle |
 |---|---|
 | `src/pages/supply/MyListings.tsx` | Livias Arbeitsplatz (Route `/supply/my-listings`) |
 | `src/components/expose/ExposeWizard.tsx` | Drei-Schritt-Assistent Hochladen → Exposé → Export |
 | `src/components/expose/ExposeFieldGroup.tsx` | Feldgruppe eines Dossier-Bereichs |
 | `src/components/expose/ExposeMediaManager.tsx` | Bild- und Dokumentenkuration |
 | `src/components/expose/LeadTable.tsx` | Leadliste aktiv / archiviert |
 | `src/components/expose/LeadWorkspace.tsx` | Arbeitsbereich unter dem geöffneten Lead |
 | `src/components/expose/index.ts` | Barrel |
 | `src/domain/expose.ts` | `ExposeDraft`, `ExposeImage`, `ExposeDocument`, `ExposeValues` |
 | `src/domain/exposeLead.ts` | `ExposeLead`, `ExposeLeadStatus` |
 | `src/provider/IExposeProvider.ts` | Provider-Schnittstelle Entwürfe |
 | `src/provider/MockupExposeProvider.ts` | Mock-Implementierung Entwürfe |
 | `src/provider/IExposeLeadProvider.ts` | Provider-Schnittstelle Leads |
 | `src/provider/MockupExposeLeadProvider.ts` | Mock-Implementierung Leads |
 | `src/services/exposeService.ts` | Vorbelegung, Bildimport, Speichern, Erstellen |
 | `src/services/exposeLeadService.ts` | Leads lesen, anlegen, archivieren |
 | `src/services/exposeExport.ts` | Vorschau (HTML), PDF (Druckdialog), Word (`.doc`) |
 | `src/services/ai/mock/exposeTextBuilder.ts` | **Deterministischer Textbaustein** (Kernstück) |
 | `src/hooks/useExpose.ts` | React-Query-Hooks für Entwürfe |
 | `src/hooks/useExposeLeads.ts` | React-Query-Hooks für Leads |
 | `src/lib/exposeFields.ts` | **Die 11 Bereiche und 9 Pflichtfelder** |
 | `src/mock-data/exposeLeads.ts` | Seed-Daten Leads |
 | `src/mock-data/agents/livia.ts` | Personaldossier |
 | `src/assets/team/livia.jpg` | Porträt |
 Es gibt **keine** Barrel-Exporte in `src/domain/index.ts` oder `src/hooks/index.ts`, die
 angepasst werden müssten — geprüft. Der einzige Barrel ist `src/components/expose/index.ts`,
 und der verschwindet mit dem Ordner.
 **Wiedereinbau Teil A:**
 ```bash
 cp -r archive/livia/src/. src/
 ```
 ---
 ## 2. Teil B — Gemeinsam genutzte Dateien mit chirurgischen Eingriffen
 Diese 16 Dateien bleiben bestehen; aus ihnen wird Livia herausgeschnitten. **Das ist der Teil,
 der bei einem Wiedereinbau ohne Notizen Arbeit macht** — deshalb steht hier jede Stelle einzeln.
 Die Zeilennummern beziehen sich auf Commit `5527448` und verschieben sich nach dem Rückbau.
 ### 2.1 Routing
 **`src/App.tsx`** — zwei Zeilen (31 und 74):
 ```tsx
 const MyListings = lazy(() => import('./pages/supply/MyListings'))
 ```
 ```tsx
 <Route path="/supply/my-listings" element={<MyListings />} />
 ```
 ### 2.2 Zentrale Register — hier hängt am meisten dran
 **`src/lib/agentWorkspaces.ts`** — eine einzige Zeile in `AGENT_WORKSPACES` (Zeile 28):
 ```ts
 { id: 'livia', name: 'Livia', role: 'Exposé Master',          path: ROUTES.SUPPLY.AGENT_LIVIA },
 ```
 > **Wichtig:** Diese Liste ist die zentrale Quelle für Sidebar (`appShellConfig.ts`),
 > globales Navigationsmenü (`GlobalNavMenu.tsx`), Willkommensdialog (`WelcomeDialog.tsx`) und
 > die Sitzplätze im 3D-Meetingraum der Startseite (`meetingRoomSeats.ts`). Ein Eintrag hier
 > entfernt Livia an allen vier Stellen zugleich — und bringt sie ebenso überall zurück.
 > Nach dem Rückbau ist das Team **vier** statt fünf Personen; die Sitzordnung im Meetingraum
 > ändert sich dadurch sichtbar.
 **`src/mock-data/teamAgents.ts`** — drei Stellen:
 ```ts
 import { liviaAgent } from './agents/livia'     // Zeile 16
 ```
 ```ts
 liviaAgent,                                      // in mockTeamAgents, Position 3
 ```
 ```ts
 LIVIA: 'livia',                                  // in AGENT_IDS
 ```
 **`src/components/team/agentPhotos.ts`** — zwei Zeilen (21 und 62):
 ```ts
 import livia from '../../assets/team/livia.jpg'
 ```
 ```ts
  livia,
 ```
 **`src/lib/constants.ts`** — Route und Fristwert:
 ```ts
 AGENT_LIVIA: '/supply/my-listings',                                          // Zeile 102
 export const STALE_EXPOSE_LEADS = 30 * 1000  // aggressive — Weiterleitungen sollen sofort erscheinen   // Zeile 62
 ```
 sowie der ganze Block «Livia — Leads und Exposé» (Zeilen 319–356):
 `EXPOSE_LEAD_TABS`, `ExposeLeadTab`, `EXPOSE_LEAD_TAB_LABELS`, `EXPOSE_STEPS`,
 `EXPOSE_IMAGE_CATEGORY_LABELS`, `EXPOSE_DOCUMENT_TYPE_LABELS`, `EXPOSE_TONALITY_LABELS`.
 Der Block liegt wörtlich in [`fragmente/constants_livia.ts.txt`](./fragmente/constants_livia.ts.txt).
 ### 2.3 KI-Schicht
 Wörtlich in [`fragmente/aiService_livia.ts.txt`](./fragmente/aiService_livia.ts.txt).
 | Datei | Was entfällt |
 |---|---|
 | `src/services/ai/IAIService.ts` | Block «Exposé texts (Livia)»: `ExposeTextSection`, `ExposeTonality`, `ExposeTextInput`, `ExposeTextResult` (Z. 200–232) und die Interface-Methode `generateExposeText` (Z. 281) |
 | `src/services/ai/mock/MockAIService.ts` | Importe `ExposeTextInput`/`ExposeTextResult` (Z. 17–18), Import `buildExposeText` (Z. 25), Implementierung `generateExposeText` (Z. 305–309) |
 | `src/services/ai/backend/BackendAIService.ts` | Importe (Z. 62–63) und die Delegation `generateExposeText` an den Mock (Z. 687–689) |
 > Achtung beim Wiedereinbau: `generateExposeText` steht im **Interface** `IAIService`. Fehlt
 > die Methode in einer der beiden Implementierungen, bricht der Typecheck — beide zusammen
 > zurückbauen.
 ### 2.4 Auslastungsanzeige der Agenten
 **`src/services/agentWorkloadService.ts`**:
 - `expose: 5` in `URGENT_FROM` (Z. 36)
 - Importe `ExposeLeadStatus` / `ExposeLead` (Z. 3–4) und das Feld `exposeLeads` in der
  Eingabe (Z. 51)
 - der ganze Block «Livia: weitergeleitete Leads» (Z. 117–128), inklusive der Sprachfassungen
  «Kein Exposé offen. Leite mir einen Lead weiter, dann lege ich los.» und
  «{n} Leads warten auf ein Exposé von mir.»
 **`src/hooks/useAgentWorkload.ts`**: Import `useExposeLeads`, die Zeile
 `const { data: exposeLeads = [], isLoading: exposeLoading } = useExposeLeads()`, das Feld in
 `computeAgentWorkload({ … })`, die Abhängigkeitsliste und `exposeLoading` im `isLoading`.
 Beides wörtlich in [`fragmente/workload_livia.ts.txt`](./fragmente/workload_livia.ts.txt).
 ### 2.5 Die Agentenkette Nora → Livia → Bruno
 Das ist inhaltlich der heikelste Teil — hier verschwindet nicht nur Livia, sondern der
 sichtbare Beweis, dass die Agenten einander zuarbeiten.
 **`src/components/market-leads/LeadDetail.tsx`** (Noras Seite):
 - Import `useCreateExposeLead` (Z. 5), `const forwardLead = useCreateExposeLead()` (Z. 42)
 - die Funktion `handleForward()` (Z. 62–77)
 - der Knopf **«An Livia zur Exposé-Erstellung weiterleiten»** (Z. 194–204) samt
  Mehrfachauswahl der Objekte und der Erfolgsmeldung
  «An Livia weitergeleitet — {n} Objekt(e) für {Firma}.»
 Wörtlich in [`fragmente/leadDetail_weiterleitung.tsx.txt`](./fragmente/leadDetail_weiterleitung.tsx.txt).
 **`src/components/visits/VisitPreparationDrawer.tsx`** (Brunos Briefing), Zeile 154:
 ```tsx
 <SectionTitle>Lagebericht (von Livia)</SectionTitle>
 ```
 Dazu das Feld in `src/domain/visitAssignment.ts` (Z. 27, Kommentar «Lagebericht, den Bruno bei
 Livia angefragt hat») und zwei Mocktexte in `src/mock-data/visitAssignments.ts` (Z. 46 und 84),
 die beide mit «Lagebericht von Livia: …» beginnen.
 > **Entscheidung nötig** — siehe Abschnitt 4.
 ### 2.6 Mockdaten der Verwaltungsebene
 | Datei | Livia-Anteil | Archivkopie |
 |---|---|---|
 | `src/mock-data/agentDirectory.ts` | Eintrag `id: 'livia'` (Z. 42–52) | im Fragment |
 | `src/mock-data/agentConnections.ts` | `AGENT_IDS.LIVIA` in vier `usedByAgentIds`-Listen (Z. 35, 205, 289, 380) — **nur die ID entfernen, nicht die Anbindung** | — |
 | `src/mock-data/agentProtocol.ts` | fünf Einträge (Z. 369–449, 691–703, 836–848, 945–956, 972–983) | [`fragmente/agentProtocol_livia.ts.txt`](./fragmente/agentProtocol_livia.ts.txt) |
 | `src/mock-data/agentWorkItems.ts` | `awi-livia-01` und `awi-livia-02` (Z. 1226–1498) | [`fragmente/agentWorkItems_livia.ts.txt`](./fragmente/agentWorkItems_livia.ts.txt) |
 ### 2.7 Tests
 | Datei | Was bricht |
 |---|---|
 | `src/components/layout/__tests__/appShellConfig.test.ts` | Z. 52 erwartet `['Ferdi', 'Bruno', 'Livia', 'Nora', 'Sina']`; Z. 88 erwartet, dass `ROUTES.SUPPLY.AGENT_LIVIA` den Seitennamen «Livia» ergibt |
 | `src/services/__tests__/agentWorkloadService.test.ts` | verwendet `exposeLeads` in der Eingabe und prüft Livias Auslastungsbahn |
 ### 2.8 Hilfsskript
 `scripts/build-agent-portraits.mjs` — Zuordnung `'image3.jpg': 'livia'` (Z. 51). Nur relevant,
 wenn die Porträts neu erzeugt werden.
 ---
 ## 3. Reihenfolge
 **Rückbau** (von aussen nach innen, damit der Typecheck bei jedem Schritt hilft):
 1. `App.tsx` — Route heraus
 2. `agentWorkspaces.ts`, `teamAgents.ts`, `agentPhotos.ts` — aus den Registern nehmen
 3. `LeadDetail.tsx` — Weiterleitung, `useAgentWorkload.ts` + `agentWorkloadService.ts` — Bahn
 4. AI-Schicht (Interface **und** beide Implementierungen zusammen)
 5. Mockdaten (Directory, Connections, Protokoll, WorkItems)
 6. Tests anpassen
 7. `constants.ts` — Block und Route
 8. Erst jetzt die 23 Dateien aus Teil A löschen
 9. `npx tsc --noEmit && npm run lint && npm test`
 **Wiedereinbau** (genau umgekehrt):
 1. `cp -r archive/livia/src/. src/`
 2. `constants.ts` aus dem Fragment ergänzen
 3. AI-Schicht (Interface und beide Implementierungen)
 4. Mockdaten aus den Fragmenten
 5. Register: `agentWorkspaces`, `teamAgents`, `agentPhotos`
 6. Auslastung, Weiterleitung bei Nora, Brunos Lagebericht-Abschnitt
 7. Route in `App.tsx`
 8. Tests zurück auf fünf Agenten
 9. `npx tsc --noEmit && npm run lint && npm test`
 **Prüfung nach dem Wiedereinbau:** `/supply/my-listings` öffnen, einen Lead aufklappen,
 ein Pflichtfeld leeren (rote Umrandung erwartet), KI-Entwurf für den Objektbeschrieb auslösen
 (bei fehlendem Ausbaustandard darf **kein** Text entstehen, sondern die Lücke gemeldet werden),
 Export als PDF und Word auslösen. Zusätzlich bei Nora ein Signal an Livia weiterleiten und
 prüfen, ob der Lead auf Livias Seite erscheint.
 ---
 ## 4. Entscheidungen, die beim Rückbau zu treffen sind
 Diese drei Punkte sind **keine** technischen Fragen — sie sollten bewusst entschieden und
 hier festgehalten werden, sonst fehlt beim Wiedereinbau die Begründung.
 1. **Bleibt der Abschnitt «Lagebericht (von Livia)» in Brunos Besichtigungsbriefing?**
   Bleibt er stehen, zeigt das Briefing einen Lagebericht ohne Urheber — die Belegkette wird
   unklar. Wird er entfernt, verliert Brunos Briefing einen inhaltlichen Baustein. Empfehlung:
   Feld und Text belassen, aber die Beschriftung von «(von Livia)» auf «Lagebericht» ändern —
   der kleinste Eingriff, der beim Wiedereinbau in einer Zeile rückgängig ist.
 2. **Bleibt bei Nora der Knopf «An Livia weiterleiten»?**
   Ohne Livia hat die Weiterleitung kein Ziel; der Knopf muss weg. Damit entfällt der
   sichtbare Übergabemoment zwischen zwei Agenten — in der Präsentation bisher das stärkste
   Argument. Wenn der Case später wieder gebraucht wird, ist dieser Knopf das Erste, was
   zurückkommen muss.
 3. **Wie wird aus fünf Agenten vier?**
   Personalzahl, Sitzordnung im Meetingraum der Startseite, Willkommensdialog und die
   Reihenfolge «Ferdi, Bruno, Livia, Nora, Sina» hängen alle an `AGENT_WORKSPACES`. Technisch
   passiert das von selbst, optisch aber nicht folgenlos — die Startseite sollte nach dem
   Rückbau angeschaut werden.
 ---
 ## 5. Inhalt dieses Verzeichnisses
 ```
 archive/livia/
 ├─ WIEDERHERSTELLUNG.md              ← dieses Dokument
 ├─ src/                              ← 23 Originaldateien im Original-Pfadlayout
 │  ├─ pages/supply/MyListings.tsx
 │  ├─ components/expose/…            (6 Dateien)
 │  ├─ domain/…                       (2)
 │  ├─ provider/…                     (4)
 │  ├─ services/…                     (3 + ai/mock/exposeTextBuilder.ts)
 │  ├─ hooks/…                        (2)
 │  ├─ lib/exposeFields.ts
 │  ├─ mock-data/…                    (2)
 │  └─ assets/team/livia.jpg
 └─ fragmente/                        ← wörtliche Ausschnitte aus geteilten Dateien
   ├─ constants_livia.ts.txt
   ├─ aiService_livia.ts.txt
   ├─ workload_livia.ts.txt
   ├─ leadDetail_weiterleitung.tsx.txt
   ├─ agentDirectory_livia.ts.txt
   ├─ agentProtocol_livia.ts.txt
   └─ agentWorkItems_livia.ts.txt
 ```
 Fachliche Beschreibung, Aufgabenkatalog und System-Prompt: `LIVIA_PROFIL_UND_PROMPT.md` im
 Repo-Root.
@@ -0,0 +1,11 @@
  {
    id: 'livia',
    name: 'Livia',
    role: 'Exposé Master',
    email: 'livia@property-on.ch',
    level: AgentLevel.CORE,
    department: AgentDepartment.CENTRAL_SERVICES,
    rollout: AgentRollout.IN_PROGRESS,
    isCore: true,
  },
  {
@@ -0,0 +1,141 @@
 // ── agentProtocol.ts Zeilen 369,449 ──────────────────────────────
  {
    id: 'proto-009',
    agentId: AGENT_IDS.LIVIA,
    timestamp: '2026-05-20T09:10:00.000Z',
    eventType: AgentProtocolEventType.TASK_RUN,
    title: 'Lagebeschrieb Neuhegistrasse 12 in Kurz- und Langfassung erstellt',
    description:
      'Mikrolage im Radius von 800 Metern, Makrolage Winterthur Neuhegi, Erreichbarkeit und geplante Umfeldentwicklung ausgewertet. Kurztext 574 Zeichen, Langtext 2 280 Zeichen, jede Aussage mit Quelle und Abrufdatum.',
    status: AgentProtocolStatus.SUCCESS,
    objectId: 'OBJ-2503',
    channel: AgentChannelType.WORKSPACE_CHAT,
    triggeredBy: AgentTriggerSource.SYSTEM,
    input: [
      { label: 'Objektadresse', value: 'Neuhegistrasse 12, 8404 Winterthur' },
      { label: 'Quartier', value: 'Winterthur Neuhegi' },
      { label: 'Analyseradius', value: '800 Meter' },
      { label: 'Tonalität', value: 'sachlich' },
    ],
    processingSteps: [
      {
        id: 'proto-009-ps-1',
        label: 'Adresse gegen die amtlichen Adressdaten geprüft und dem Quartier zugeordnet',
      },
      {
        id: 'proto-009-ps-2',
        label: 'Mikrolage abgegangen',
        detail: 'Nachbarschaft, Erdgeschossnutzungen, Immissionslage, Publikumsfrequenz, Parkierung',
      },
      {
        id: 'proto-009-ps-3',
        label: 'Makrolage eingeordnet',
        detail: 'Beschäftigtenentwicklung, Branchenmix und Bedeutung im Wirtschaftsraum Winterthur',
      },
      {
        id: 'proto-009-ps-4',
        label: 'Erreichbarkeit und Nahversorgung mit Distanz und Wegzeit erfasst',
      },
      { id: 'proto-009-ps-5', label: 'Amtliche Publikationen im Umfeld gesichtet' },
      { id: 'proto-009-ps-6', label: 'Kurztext und Langtext geschrieben, Quellen angehängt' },
    ],
    output: [
      {
        label: 'Kurztext für Inserat',
        value:
          'Die Fläche liegt in Winterthur Neuhegi, einem in den vergangenen zehn Jahren umgebauten Arbeitsplatzquartier mit Wohn-, Büro- und Produktionsnutzung. Die Haltestelle Neuhegi ist in vier Gehminuten erreichbar, der Bahnhof Winterthur Grüze in neun Minuten mit dem Bus. Einkaufen, Verpflegung und Kinderbetreuung befinden sich innerhalb von 400 Metern.',
      },
      {
        label: 'Abschnitte des Langtexts',
        value: [
          'Mikrolage — Nachbarschaft und Erdgeschossnutzungen',
          'Makrolage — Wirtschaftsraum Winterthur',
          'Erreichbarkeit — öffentlicher Verkehr, Autobahn A1, Velowege',
          'Nahversorgung — Einkaufen, Verpflegung, Betreuung, Gesundheit',
          'Umfeldentwicklung — Arealentwicklung nördlich der Neuhegistrasse',
        ],
      },
      { label: 'Belegte Aussagen', value: '31 von 31 Aussagen mit Quelle und Abrufdatum' },
    ],
    sourceReferences: [
      {
        id: 'proto-009-src-1',
        label: 'Amtliche Publikation zur Arealentwicklung',
        documentName: 'Amtliche Meldung — Gestaltungsplan Neuhegi Nord',
        locator: 'Publikation vom 24.04.2026',
        quote:
          '«Der Gestaltungsplan für das Areal nördlich der Neuhegistrasse wurde bewilligt; die Bauarbeiten beginnen im ersten Quartal 2027.»',
      },
      {
        id: 'proto-009-src-2',
        label: 'Fahrplandaten Haltestelle Neuhegi',
        documentName: 'Öffentliche Verkehrsdaten Winterthur',
        locator: 'Abruf 20.05.2026',
      },
      {
        id: 'proto-009-src-3',
        label: 'Objektstammdaten OBJ-2503',
        documentName: 'Bewirtschaftungssystem — Objektblatt OBJ-2503',
        locator: 'Adresse und Nutzungsart',
      },
    ],
  },
 // ── agentProtocol.ts Zeilen 691,703 ──────────────────────────────
  {
    id: 'proto-019',
    agentId: AGENT_IDS.LIVIA,
    timestamp: '2026-05-18T10:05:00.000Z',
    eventType: AgentProtocolEventType.MESSAGE_PROCESSED,
    title: 'Auftrag für den Lagebeschrieb Wankdorffeldstrasse 8 entgegengenommen',
    description:
      'Die Adresse wurde gegen die amtlichen Adressdaten geprüft und dem Entwicklungsgebiet Bern Wankdorf zugeordnet. Der Arbeitsauftrag ist eingereiht; die Umfeldanalyse läuft im Radius von 800 Metern.',
    status: AgentProtocolStatus.INFO,
    objectId: 'OBJ-2559',
    channel: AgentChannelType.WORKSPACE_CHAT,
    triggeredBy: AgentTriggerSource.SYSTEM,
  },
 // ── agentProtocol.ts Zeilen 836,848 ──────────────────────────────
  {
    id: 'proto-028',
    agentId: AGENT_IDS.LIVIA,
    timestamp: '2026-05-07T10:15:00.000Z',
    eventType: AgentProtocolEventType.TASK_RUN,
    title: 'Umfeldänderung Winterthur Neuhegi gemeldet',
    description:
      'Die bewilligte Arealentwicklung nördlich der Neuhegistrasse verändert den Abschnitt «Umfeldentwicklung» in vier Lagebeschrieben. Die betroffenen Textabschnitte sind markiert, die Quelle mit Publikationsdatum hinterlegt.',
    status: AgentProtocolStatus.SUCCESS,
    objectId: 'OBJ-2503',
    channel: AgentChannelType.WORKSPACE_CHAT,
    triggeredBy: AgentTriggerSource.SYSTEM,
  },
 // ── agentProtocol.ts Zeilen 945,956 ──────────────────────────────
  {
    id: 'proto-034',
    agentId: AGENT_IDS.LIVIA,
    timestamp: '2026-04-01T05:30:00.000Z',
    eventType: AgentProtocolEventType.TASK_RUN,
    title: 'Quartalslauf: 184 Lagebeschriebe gegen die Quellen geprüft',
    description:
      '162 Lagebausteine wurden bestätigt, 14 Abschnitte als veraltet markiert und erneuert, 9 Objekte für den nächsten Lauf vorgemerkt. Jede Prüfung ist je Objekt nachvollziehbar protokolliert.',
    status: AgentProtocolStatus.SUCCESS,
    channel: AgentChannelType.WORKSPACE_CHAT,
    triggeredBy: AgentTriggerSource.SYSTEM,
  },
 // ── agentProtocol.ts Zeilen 972,983 ──────────────────────────────
  {
    id: 'proto-036',
    agentId: AGENT_IDS.LIVIA,
    timestamp: '2026-03-05T08:50:00.000Z',
    eventType: AgentProtocolEventType.SETTINGS_SAVED,
    title: 'Analyseradius und Quellentypen gespeichert',
    description:
      'Der Radius der Umfeldanalyse wurde von 500 auf 800 Meter erhöht und «Medienberichte» als Quellentyp abgewählt. Bestehende Lagebeschriebe werden im nächsten Quartalslauf nachgeführt.',
    status: AgentProtocolStatus.SUCCESS,
    triggeredBy: AgentTriggerSource.USER,
    triggeredByName: OPERATOR,
  },
@@ -0,0 +1,273 @@
  // ── Livia — erledigt ───────────────────────────────────────────────────────
  {
    id: 'awi-livia-01',
    agentId: AGENT_IDS.LIVIA,
    kind: AgentWorkItemKind.LOCATION_MODULE,
    area: AgentDomainArea.LOCATION,
    title: 'Lagebeschrieb erstellt — Hardturmstrasse 118, Zürich Kreis 5',
    summary:
      'Zum neuen Vermarktungsauftrag entstanden ein Kurztext für Inserat und Portal sowie ein Langtext für das Exposé, jeweils mit Quellenverzeichnis und Abrufdatum zu jeder Aussage.',
    objectId: 'OBJ-2365',
    objectLabel: 'Hardturmstrasse 118, 8005 Zürich — Bürofläche 640 m², Zürich Kreis 5',
    sourceChannel: AgentChannelType.WORKSPACE_CHAT,
    targetChannel: AgentChannelType.EMAIL,
    createdAt: '2026-04-09T09:15:00.000Z',
    completedAt: '2026-04-09T11:40:00.000Z',
    priority: AgentWorkItemPriority.LOW,
    status: AgentWorkItemStatus.COMPLETED,
    requiresDecision: false,
    inputs: [
      { label: 'Objektadresse aus dem Vermarktungsauftrag', value: 'Hardturmstrasse 118, 8005 Zürich' },
      { label: 'Quartierzuordnung', value: 'Zürich Kreis 5 (Escher Wyss), geprüft gegen die amtlichen Adressdaten' },
      { label: 'Untersuchungsradius Mikrolage', value: '500 Meter Umkreis, Erdgeschossnutzungen und Erreichbarkeit' },
      { label: 'Auftraggebende Person', value: 'Nadine Brunner, Vermarktung Zürich' },
    ],
    result: [
      {
        label: 'Kurztext für Inserat und Portal',
        value:
          'Die Fläche liegt im Kreis 5 zwischen Escher-Wyss-Platz und Hardbrücke, in einem Quartier mit hohem Anteil an Dienstleistung, Gastronomie und Kreativwirtschaft. Die Haltestelle Escher-Wyss-Platz ist in vier Gehminuten erreichbar, der Bahnhof Hardbrücke in acht Minuten.',
      },
      {
        label: 'Langtext für das Exposé',
        value:
          'Dreiteiliger Text mit Mikrolage (Nachbarschaft, Erdgeschossnutzungen, Publikumsfrequenz, Parkierung), Makrolage (Wirtschaftsstruktur Stadt Zürich, Beschäftigtenentwicklung Kreis 5, Steuerlage) und Umfeldentwicklung — insgesamt 3 940 Zeichen.',
      },
      {
        label: 'Erreichbarkeit',
        value: [
          'Tram- und Bushaltestelle Escher-Wyss-Platz: 300 Meter, 4 Gehminuten',
          'Bahnhof Zürich Hardbrücke: 650 Meter, 8 Gehminuten',
          'Autobahnanschluss Zürich-Hardturm: 1,4 Kilometer',
          'Veloweg entlang der Hardturmstrasse, durchgehend abgetrennt',
        ],
      },
      {
        label: 'Nahversorgung',
        value: [
          'Einkaufen: zwei Supermärkte innerhalb von 400 Metern',
          'Verpflegung: 14 Gastronomiebetriebe im Umkreis von 300 Metern',
          'Kinderbetreuung: zwei Kindertagesstätten innerhalb von 600 Metern',
        ],
      },
      {
        label: 'Umfeldentwicklung',
        value:
          'Arealentwicklung Hardturm-Areal in Etappen bis 2029; Zonenänderung rechtskräftig seit 2024 (Quelle: amtliche Publikation, abgerufen 09.04.2026).',
      },
      { label: 'Quellenverzeichnis', value: '11 Quellen mit Abrufdatum, je Aussage zugeordnet' },
    ],
    processingSteps: [
      {
        id: 'awi-livia-01-step-1',
        label: 'Adresse aufgenommen und dem Quartier zugeordnet',
        detail: 'Schreibweise gegen die amtlichen Adressdaten geprüft, Zuordnung Zürich Kreis 5.',
      },
      {
        id: 'awi-livia-01-step-2',
        label: 'Mikrolage im Umkreis von 500 Metern abgegangen',
        detail: 'Nachbarschaft, Erdgeschossnutzungen, Immissionslage, Publikumsfrequenz und Parkierung erfasst.',
      },
      {
        id: 'awi-livia-01-step-3',
        label: 'Makrolage eingeordnet',
        detail: 'Wirtschaftsstruktur, Beschäftigtenentwicklung und Steuerlage der Stadt Zürich ausgewertet.',
      },
      {
        id: 'awi-livia-01-step-4',
        label: 'Amtliche Publikationen zum Umfeld gesichtet',
        detail: 'Arealentwicklung und Zonenänderung als für das Objekt relevant eingestuft.',
      },
      {
        id: 'awi-livia-01-step-5',
        label: 'Kurz- und Langtext geschrieben, Quellen angehängt',
        detail: 'Je Aussage Quelle und Abrufdatum hinterlegt, Ergebnis am Objekt abgelegt.',
      },
    ],
    sourceReferences: [
      {
        id: 'awi-livia-01-src-1',
        label: 'Amtliche Publikation zur Zonenänderung Hardturm',
        documentName: 'Amtliche-Publikation_Zonenaenderung-Hardturm_2024-11-08.pdf',
        locator: 'Seite 3, abgerufen 09.04.2026',
      },
      {
        id: 'awi-livia-01-src-2',
        label: 'Fahrplanauskunft öffentlicher Verkehr',
        documentName: 'Erreichbarkeitsauswertung_OBJ-2365_2026-04-09.pdf',
        locator: 'Tabelle «Haltestellen im Umkreis», abgerufen 09.04.2026',
      },
      {
        id: 'awi-livia-01-src-3',
        label: 'Quellenverzeichnis zum Lagebeschrieb',
        documentName: 'Lagebeschrieb_OBJ-2365_Quellen_2026-04-09.pdf',
        locator: 'Seiten 1–2, 11 Einträge',
      },
    ],
    availableActions: [AgentWorkItemAction.OPEN_SOURCE, AgentWorkItemAction.MARK_DONE],
    history: [
      {
        id: 'awi-livia-01-hist-1',
        at: '2026-04-09T09:15:00.000Z',
        actor: 'Livia',
        action: 'Vermarktungsauftrag übernommen',
        note: 'Adresse geprüft und dem Quartier Zürich Kreis 5 zugeordnet.',
      },
      {
        id: 'awi-livia-01-hist-2',
        at: '2026-04-09T11:40:00.000Z',
        actor: 'Livia',
        action: 'Lagebeschrieb abgelegt und zugestellt',
        note: 'Kurz- und Langtext mit 11 Quellen an die Vermarktung Zürich.',
      },
      {
        id: 'awi-livia-01-hist-3',
        at: '2026-04-14T08:05:00.000Z',
        actor: 'Nadine Brunner',
        action: 'Text für das Inserat übernommen',
        note: 'Kurztext unverändert im Portalauftritt veröffentlicht.',
      },
    ],
  },
  // ── Livia — pendent: Review eines unsicheren Ergebnisses ───────────────────
  {
    id: 'awi-livia-02',
    agentId: AGENT_IDS.LIVIA,
    kind: AgentWorkItemKind.LOCATION_MODULE,
    area: AgentDomainArea.LOCATION,
    title: 'Unsichere Aussage zum Entwicklungsgebiet Wankdorf — Review erbeten',
    summary:
      'Für den Langtext zum Objekt in Bern liegen zwei Quellen mit unterschiedlichen Angaben zur Inbetriebnahme der neuen Haltestelle vor. Die Aussage bleibt aus dem Text ausgeklammert, bis entschieden ist, welche Angabe gilt.',
    objectId: 'OBJ-2733',
    objectLabel: 'Wankdorffeldstrasse 12, 3014 Bern — Bürofläche 1. bis 3. Obergeschoss, 1 150 m²',
    sourceChannel: AgentChannelType.WORKSPACE_CHAT,
    targetChannel: AgentChannelType.EMAIL,
    createdAt: '2026-05-07T07:45:00.000Z',
    priority: AgentWorkItemPriority.MEDIUM,
    status: AgentWorkItemStatus.PENDING,
    requiresDecision: true,
    escalationReason:
      'Review eines unsicheren Ergebnisses: Zwei belegte Quellen nennen unterschiedliche Zeitpunkte für die Inbetriebnahme der Haltestelle Wankdorffeld. Eine Aussage ohne eindeutigen Beleg geht nicht in den Exposétext.',
    decisionQuestion:
      'Welche Angabe soll in den Langtext übernommen werden — «ab Dezember 2027» gemäss amtlicher Publikation oder «ab Sommer 2028» gemäss Mitteilung der Standortförderung — oder soll der Absatz zur Haltestelle vorerst entfallen?',
    inputs: [
      { label: 'Objektadresse aus dem Vermarktungsauftrag', value: 'Wankdorffeldstrasse 12, 3014 Bern' },
      { label: 'Quartierzuordnung', value: 'Bern Wankdorf, Entwicklungsgebiet Wankdorf-Nord' },
      {
        label: 'Widersprüchliche Quellen',
        value: [
          'Amtliche Publikation vom 12.03.2026 — Inbetriebnahme Dezember 2027',
          'Mitteilung der Standortförderung vom 28.04.2026 — Inbetriebnahme Sommer 2028',
        ],
      },
      { label: 'Auftraggebende Person', value: 'Nadine Brunner, Vermarktung Zürich (Mandat Bern)' },
    ],
    result: [
      { label: 'Stand', value: 'Kurztext fertig, Langtext zu 90 Prozent — ein Absatz ist ausgeklammert' },
      {
        label: 'Fertiger Kurztext',
        value:
          'Das Objekt liegt im Entwicklungsgebiet Wankdorf, unmittelbar an der Achse zwischen Bahnhof Wankdorf und Autobahnanschluss Bern-Wankdorf. Das Umfeld ist geprägt von Dienstleistung, öffentlichen Institutionen und Verkaufsflächen.',
      },
      {
        label: 'Ausgeklammerter Absatz',
        value:
          'Die geplante Haltestelle Wankdorffeld liegt rund 200 Meter vom Objekt entfernt. Die Inbetriebnahme ist für [Zeitpunkt offen] vorgesehen.',
      },
      {
        label: 'Warum die Angabe zählt',
        value:
          'Die Wegzeit zum öffentlichen Verkehr sinkt mit der neuen Haltestelle von 11 auf 3 Gehminuten — die Aussage ist für Interessenten mit Publikumsverkehr entscheidend.',
      },
      { label: 'Übrige Quellen', value: '9 Quellen mit Abrufdatum, alle eindeutig und im Text belegt' },
    ],
    processingSteps: [
      {
        id: 'awi-livia-02-step-1',
        label: 'Adresse aufgenommen und dem Quartier zugeordnet',
        detail: 'Zuordnung Bern Wankdorf, Entwicklungsgebiet Wankdorf-Nord.',
      },
      {
        id: 'awi-livia-02-step-2',
        label: 'Mikro- und Makrolage beschrieben',
        detail: 'Nachbarschaft, Erreichbarkeit, Nahversorgung und Wirtschaftsraum Bern erfasst.',
      },
      {
        id: 'awi-livia-02-step-3',
        label: 'Amtliche Publikationen zum Umfeld gesichtet',
        detail: 'Beim Verkehrsvorhaben zwei Quellen mit unterschiedlichen Zeitangaben gefunden.',
      },
      {
        id: 'awi-livia-02-step-4',
        label: 'Aussage ausgeklammert statt gemittelt',
        detail: 'Der Absatz bleibt offen, bis die massgebende Quelle bestimmt ist.',
      },
      {
        id: 'awi-livia-02-step-5',
        label: 'Review vorgelegt',
        detail: 'Beide Belege mit Fundstelle und Abrufdatum zur Entscheidung beigelegt.',
      },
    ],
    sourceReferences: [
      {
        id: 'awi-livia-02-src-1',
        label: 'Amtliche Publikation Verkehrsvorhaben Wankdorffeld',
        documentName: 'Amtliche-Publikation_Haltestelle-Wankdorffeld_2026-03-12.pdf',
        locator: 'Seite 2, Abschnitt «Terminprogramm»',
        quote:
          '«Die Inbetriebnahme der Haltestelle Wankdorffeld ist auf den Fahrplanwechsel im Dezember 2027 vorgesehen.»',
      },
      {
        id: 'awi-livia-02-src-2',
        label: 'Mitteilung der Standortförderung Bern',
        documentName: 'Standortfoerderung-Bern_Mitteilung_2026-04-28.pdf',
        locator: 'Seite 1, abgerufen 07.05.2026',
        quote:
          '«Wegen der Anpassung der Gleisgeometrie verschiebt sich die Eröffnung der Haltestelle Wankdorffeld auf Sommer 2028.»',
      },
    ],
    availableActions: [
      AgentWorkItemAction.DECIDE,
      AgentWorkItemAction.EDIT,
      AgentWorkItemAction.APPROVE,
      AgentWorkItemAction.OPEN_SOURCE,
    ],
    editableFields: [
      {
        id: 'awi-livia-02-field-date',
        label: 'Zu verwendender Zeitpunkt',
        value: 'Dezember 2027',
        helperText: 'Alternativ «Sommer 2028» oder leer lassen, damit der Absatz entfällt.',
      },
      {
        id: 'awi-livia-02-field-paragraph',
        label: 'Absatz zur Haltestelle',
        value:
          'Die geplante Haltestelle Wankdorffeld liegt rund 200 Meter vom Objekt entfernt. Die Inbetriebnahme ist auf Dezember 2027 vorgesehen; die Wegzeit zum öffentlichen Verkehr verkürzt sich damit von 11 auf 3 Gehminuten.',
        multiline: true,
      },
      {
        id: 'awi-livia-02-field-source',
        label: 'Anzugebende Quelle',
        value: 'Amtliche Publikation Verkehrsvorhaben Wankdorffeld, 12.03.2026, abgerufen 07.05.2026',
        helperText: 'Erscheint im Quellenverzeichnis des Exposés.',
      },
    ],
    history: [
      {
        id: 'awi-livia-02-hist-1',
        at: '2026-05-07T07:45:00.000Z',
        actor: 'Livia',
        action: 'Widerspruch erkannt und Review vorgelegt',
        note: 'Zwei belegte Quellen mit unterschiedlichen Zeitangaben zur Haltestelle.',
      },
      {
        id: 'awi-livia-02-hist-2',
        at: '2026-05-15T09:20:00.000Z',
        actor: 'Livia',
        action: 'Quellen erneut geprüft',
        note: 'Quartalsprüfung: keine neuere amtliche Publikation vorhanden, Widerspruch besteht weiter.',
      },
    ],
  },
@@ -0,0 +1,76 @@
 // ══ src/services/ai/IAIService.ts — Typen (aktuell Zeilen 200–232) ══
 // ── Exposé texts (Livia) ──────────────────────────────────────────────────────
 /**
 * Die Textabschnitte eines Exposés. Jeder lässt sich einzeln erzeugen —
 * gesamthaft heisst schlicht: alle nacheinander (Runde 4, §8.5.2).
 */
 export const ExposeTextSection = {
  TITLE: 'TITLE',
  TEASER: 'TEASER',
  OBJECT: 'OBJECT',
  LOCATION: 'LOCATION',
  MUNICIPALITY: 'MUNICIPALITY',
  FEATURES: 'FEATURES',
  HIGHLIGHTS: 'HIGHLIGHTS',
 } as const
 export type ExposeTextSection = typeof ExposeTextSection[keyof typeof ExposeTextSection]
 export type ExposeTonality = 'SACHLICH' | 'HOCHWERTIG' | 'EINLADEND'
 export interface ExposeTextInput {
  section: ExposeTextSection
  tonality: ExposeTonality
  /** Ausschliesslich belegte Angaben aus «Meine Objekte» — nichts Erfundenes. */
  facts: Record<string, string | number | undefined>
 }
 export interface ExposeTextResult {
  section: ExposeTextSection
  text: string
  /** Angaben, die für einen vollständigen Text fehlen — statt sie zu erfinden. */
  missingFacts: string[]
 }
 // ══ src/services/ai/IAIService.ts — Methode im Interface (Zeile 281) ══
  recommendPreMarketRent(input: PreMarketRentInput): Promise<AIResponse<PreMarketRentRecommendation>>
  // Exposé-Texte (Livia) — pro Abschnitt auslösbar
  generateExposeText(input: ExposeTextInput): Promise<AIResponse<ExposeTextResult>>
  // Legacy methods
 // ══ src/services/ai/mock/MockAIService.ts — Importe (17-18, 25) ══
  ExposeTextInput,
  ExposeTextResult,
 import { buildExposeText } from './exposeTextBuilder'
 // ══ src/services/ai/mock/MockAIService.ts — Implementierung (303-310) ══
    }),
  generateExposeText: (input: ExposeTextInput) =>
    traceMock<ExposeTextResult>('generateExposeText', async () => {
      await delay(SIMULATED_DELAY.medium)
      return { data: buildExposeText(input), provenance: mockProvenance() }
    }),
 // ══ src/services/ai/backend/BackendAIService.ts — Importe (62-63) ══
  ExposeTextInput,
  ExposeTextResult,
 // ══ src/services/ai/backend/BackendAIService.ts — Delegation (678-690) ══
  },
  // ── generateExposeText ──────────────────────────────────────────────────────
  //
  // Bewusst ohne eigenen LLM-Aufruf: der Text darf ausschliesslich auf erfassten
  // Objektdaten beruhen (Runde 4, §8.5.2). Ein freies Sprachmodell würde genau
  // die fehlenden Angaben plausibel ergänzen, die hier rot markiert gehören.
  // Deshalb erzeugt auch im Backend-Betrieb der deterministische Builder den
  // Entwurf; er nennt Lücken, statt sie zu füllen.
  generateExposeText(input: ExposeTextInput): Promise<AIResponse<ExposeTextResult>> {
    return MockAIService.generateExposeText(input)
  },
@@ -0,0 +1,44 @@
 export const STALE_AGENT_CONNECTIONS = 60 * 1000
 export const STALE_CALENDAR = 60 * 1000
 export const STALE_EXPOSE_LEADS = 30 * 1000  // aggressive — Weiterleitungen sollen sofort erscheinen
 export const STALE_VISIT_ASSIGNMENTS = 60 * 1000
 /** CRM-Leads ändern sich im Quellsystem, nicht hier — eine Minute genügt. */
 // ── Livia — Leads und Exposé (Runde 4, §8) ───────────────────────────────────
 export const EXPOSE_LEAD_TABS = {
  ACTIVE: 'aktive-leads',
  ARCHIVED: 'archivierte-leads',
 } as const
 export type ExposeLeadTab = typeof EXPOSE_LEAD_TABS[keyof typeof EXPOSE_LEAD_TABS]
 export const EXPOSE_LEAD_TAB_LABELS: Record<ExposeLeadTab, string> = {
  [EXPOSE_LEAD_TABS.ACTIVE]: 'Aktive Leads',
  [EXPOSE_LEAD_TABS.ARCHIVED]: 'Archivierte Leads',
 }
 /** Die drei Schritte des Exposé-Prozesses (§8.5). */
 export const EXPOSE_STEPS = ['Hochladen', 'Exposé', 'Export'] as const
 export const EXPOSE_IMAGE_CATEGORY_LABELS: Record<string, string> = {
  EXTERIOR: 'Aussenansicht',
  INTERIOR: 'Innenansicht',
  FLOORPLAN: 'Grundriss',
  SURROUNDINGS: 'Umgebung',
  OTHER: 'Sonstiges',
 }
 export const EXPOSE_DOCUMENT_TYPE_LABELS: Record<string, string> = {
  FLOORPLAN: 'Grundriss',
  LEASE_CONTRACT: 'Mietvertrag',
  ENERGY_CERTIFICATE: 'Energieausweis (GEAK)',
  SITE_PLAN: 'Situationsplan',
  OTHER: 'Sonstiges',
 }
 export const EXPOSE_TONALITY_LABELS: Record<string, string> = {
  SACHLICH: 'Sachlich',
  HOCHWERTIG: 'Hochwertig',
  EINLADEND: 'Einladend',
 }
@@ -0,0 +1,37 @@
 // ══ src/components/market-leads/LeadDetail.tsx — Import + Hook (Z. 5, 42) ══
 import { useCreateExposeLead } from '../../hooks/useExposeLeads'
  const forwardLead = useCreateExposeLead()
 // ══ handleForward (Z. 61-77) ══
  function handleForward() {
    const count = selectedIds.length
    forwardLead.mutate(
      {
        prospect: companyName,
        contacts: contacts.map(c => c.value),
        locationHint: signal.locationHint,
        propertyIds: selectedIds,
        sourceSignalId: signal.id,
      },
      {
        onSuccess: () => {
          setSelectedIds([])
          showToast(`An Livia weitergeleitet — ${count} Objekt(e) für ${companyName}.`, 'success')
        },
      },
    )
 // ══ Knopf «An Livia weiterleiten» (Z. 193-205) ══
              ))}
              <Button
                variant="contained"
                startIcon={<Forward size={15} />}
                disabled={selectedIds.length === 0 || forwardLead.isPending}
                onClick={handleForward}
                sx={{ mt: 1, textTransform: 'none', bgcolor: DS_BRAND.main, '&:hover': { bgcolor: DS_BRAND.hoverAlt } }}
              >
                An Livia zur Exposé-Erstellung weiterleiten
                {selectedIds.length > 0 && ` (${selectedIds.length})`}
              </Button>
            </>
          )}
@@ -0,0 +1,48 @@
 // ══ src/services/agentWorkloadService.ts — Importe (Z. 3-4) ══
 import { ExposeLeadStatus } from '../domain/exposeLead'
 import type { ExposeLead } from '../domain/exposeLead'
 // ══ URGENT_FROM (Z. 33-40) ══
 const URGENT_FROM = {
  reminders: 5,
  visits: 4,
  expose: 5,
  dataGaps: 10,
 } as const
 /** Zeitfenster der Auswertung. */
 // ══ Eingabefeld (Z. 48-55) ══
 export interface AgentWorkloadInput {
  reminders: Reminder[]
  visits: VisitAssignment[]
  exposeLeads: ExposeLead[]
  leads: UnifiedLead[]
  properties: Property[]
 }
 // ══ Livias Auslastungsbahn (Z. 117-129) ══
  // ── Livia: weitergeleitete Leads ────────────────────────────────────────────
  const openExpose = input.exposeLeads.filter(l => l.status === ExposeLeadStatus.ACTIVE).length
  const livia: AgentWorkload = {
    agentId: 'livia',
    count: openExpose,
    label: `${openExpose} ${plural(openExpose, 'Exposé offen', 'Exposés offen')}`,
    tone: tone(openExpose, URGENT_FROM.expose),
    voice: openExpose === 0
      ? 'Kein Exposé offen. Leite mir einen Lead weiter, dann lege ich los.'
      : `${openExpose} ${plural(openExpose, 'Lead wartet', 'Leads warten')} auf ein Exposé von mir.`,
  }
  // ── Nora: Marktchancen ──────────────────────────────────────────────────────
 // ══ src/hooks/useAgentWorkload.ts — alle Livia-Stellen ══
 import { useExposeLeads } from './useExposeLeads'
  const { data: exposeLeads = [], isLoading: exposeLoading } = useExposeLeads()
  const data = useMemo(
    () => computeAgentWorkload({ reminders, visits, exposeLeads, leads, properties }),
    [reminders, visits, exposeLeads, leads, properties],
      remindersLoading || visitsLoading || exposeLoading ||
      leadsLoading || propertiesLoading,
  }
@@ -0,0 +1,416 @@
 /**
 * Property On — Personalblatt «Livia», Lage-Analystin (Vermarktung).
 *
 * Fachliche Wahrheit aus dem Agenten-Katalog: Rolle, Personalnummer, E-Mail und
 * die elf Katalogaufgaben werden hier unverändert abgebildet.
 */
 import type { TeamAgent } from '../../domain/teamAgent'
 import {
  AgentStatus,
  AgentAutonomyLevel,
  AgentChannelType,
  AgentChannelDirection,
  AgentConnectionStatus,
  AgentSystemType,
  AgentAccessLevel,
  AgentSettingKind,
  AgentSettingGroup,
  AgentAvatarTone,
 } from '../../domain/teamAgent'
 export const liviaAgent: TeamAgent = {
  id: 'livia',
  name: 'Livia',
  role: 'Exposé Master',
  personnelNumber: 'PO-ZD-21',
  department: 'Vermarktung',
  email: 'livia@property-on.ch',
  avatarTone: AgentAvatarTone.WARNING,
  status: AgentStatus.ACTIVE,
  autonomyLevel: AgentAutonomyLevel.AUTONOMOUS,
  shortDescription:
    'Erstellt Lageberichte, Inserate sowie Angebots- und Offertenbroschüren aus den Daten und Bildern aus «Meine Objekte».',
  autonomyNote:
    'Autonom. Livia recherchiert, schreibt und frischt Lageberichte, Inserate und Exposés ohne vorgängige Freigabe auf. Jede Aussage wird mit Quelle und Abrufdatum protokolliert, damit die Vermarktung jeden Satz nachprüfen kann.',
  profile: {
    purpose:
      'Livia macht aus Objektdaten, Lageinformationen und vorhandenen Bildern ein verkaufsfähiges Dokument: Lagebericht, Inserat oder vollständige Angebots- beziehungsweise Offertenbroschüre. Grundlage sind ausschliesslich die Objekte aus «Meine Objekte».',
    input: [
      'Objektdaten und Objektbilder aus «Meine Objekte»',
      'Leads, die Nora erkannt und ein Bewirtschafter zur Exposé-Erstellung weitergeleitet hat',
      'Objektadresse aus dem Vermarktungsauftrag',
      'Öffentliche Umfeld- und Verkehrsdaten zu Quartier, Anbindung und Nahversorgung',
      'Amtliche Publikationen zu Bauprojekten, Zonenänderungen und Umfeldentwicklungen',
      'Bestehende Objektunterlagen aus der Dokumentenablage',
    ],
    coreFlow: [
      'Adresse aufnehmen und dem richtigen Quartier zuordnen, etwa Zürich Kreis 5 oder Winterthur Neuhegi.',
      'Umfeld im festgelegten Radius abgehen: Nachbarschaft, Erdgeschossnutzungen, Erreichbarkeit, Einkaufen und Verpflegung.',
      'Gemeinde und Region einordnen: Wirtschaftsstruktur, Steuerlage, Entwicklung der Nachfrage.',
      'Amtliche Publikationen und Bauprojekte im Umfeld sichten und bewerten, ob sie für das Objekt relevant sind.',
      'Aus den gesammelten Bausteinen einen Kurztext fürs Inserat und einen Langtext fürs Exposé schreiben.',
      'Quellen anhängen, Ergebnis je Objekt ablegen und quartalsweise gegen den aktuellen Stand prüfen.',
    ],
    output: [
      'Lagebericht mit Mikro-, Makro- und Umfeldteil',
      'Kurztext für Inserat und Portalauftritt',
      'Angebots- beziehungsweise Offertenbroschüre als PDF oder Word',
      'Quellenverzeichnis mit Abrufdatum je Aussage',
      'Änderungshinweise, sobald sich das Umfeld spürbar verändert',
    ],
  },
  responsibilities: [
    'Lageberichte für kommerziell genutzte Immobilien erstellen und nachvollziehbar belegen',
    'Inserate aus den Objektdaten in «Meine Objekte» erstellen',
    'Angebots- und Offertenbroschüren aus Objektdaten, Lageinformationen und vorhandenen Bildern erstellen',
    'Weitergeleitete Leads von Nora zügig zu einem Exposé verarbeiten',
    'Erreichbarkeit, Nahversorgung und geplante Umfeldentwicklungen sauber trennen und darstellen',
    'Jede Aussage mit einer nachprüfbaren Quelle und einem Abrufdatum hinterlegen',
    'Fehlende Pflichtangaben als Lücke ausweisen, statt plausible Werte zu erfinden',
    'Lageberichte quartalsweise auffrischen und relevante Abweichungen an die Vermarktung melden',
  ],
  tasks: [
    {
      id: 'livia-task-01',
      title: 'Objektadresse aufnehmen',
      description:
        'Übernimmt Strasse, Hausnummer, Postleitzahl und Ort aus dem Vermarktungsauftrag, prüft die Schreibweise gegen die amtlichen Adressdaten und ordnet das Objekt einem Quartier zu, etwa Zürich Kreis 5, Winterthur Neuhegi oder Basel Gundeldingen.',
      enabled: true,
      schedule: 'bei Eingang eines Vermarktungsauftrags',
      requiresApproval: false,
      dependsOnSystem: AgentSystemType.IMMOTOP2,
    },
    {
      id: 'livia-task-02',
      title: 'Mikrolage analysieren',
      description:
        'Beschreibt das unmittelbare Umfeld im eingestellten Radius: Nachbarschaft, Erdgeschossnutzungen, Lärm- und Immissionslage, Publikumsfrequenz sowie Parkierung. Trennt beobachtbare Fakten klar von Einschätzungen.',
      enabled: true,
      schedule: 'nach der Adressaufnahme',
      requiresApproval: false,
      dependsOnSystem: AgentSystemType.PUBLIC_WEB,
    },
    {
      id: 'livia-task-03',
      title: 'Makrolage einordnen',
      description:
        'Ordnet Gemeinde und Wirtschaftsraum ein: Bevölkerungs- und Beschäftigtenentwicklung, Branchenmix, Steuerlage und Bedeutung des Standorts innerhalb der Region, etwa Zug im Wirtschaftsraum Zentralschweiz oder St. Gallen als Zentrum der Ostschweiz.',
      enabled: true,
      schedule: 'nach der Mikrolage-Analyse',
      requiresApproval: false,
      dependsOnSystem: AgentSystemType.PUBLIC_WEB,
    },
    {
      id: 'livia-task-04',
      title: 'Erreichbarkeit und Nahversorgung darstellen',
      description:
        'Stellt Anbindung an öffentlichen Verkehr, Autobahnanschluss, Velo- und Fusswege sowie Einkaufen, Verpflegung, Kinderbetreuung und Gesundheitsversorgung dar — jeweils mit Distanz oder Wegzeit statt mit unbelegten Werbeaussagen.',
      enabled: true,
      schedule: 'nach der Makrolage-Einordnung',
      requiresApproval: false,
      dependsOnSystem: AgentSystemType.PUBLIC_WEB,
    },
    {
      id: 'livia-task-05',
      title: 'Geplante Projekte und Umfeldentwicklungen aufnehmen',
      description:
        'Sichtet amtliche Publikationen und Bauprojekte im Umfeld — Arealentwicklungen, Zonenänderungen, Verkehrsvorhaben, neue Haltestellen — und hält fest, ab wann sie für das Objekt spürbar werden, etwa das Entwicklungsgebiet Bern Wankdorf.',
      enabled: true,
      schedule: 'montags 07:00',
      requiresApproval: false,
      dependsOnSystem: AgentSystemType.SHAB,
    },
    {
      id: 'livia-task-06',
      title: 'Kurzen Inserattext erstellen',
      description:
        'Verdichtet die Lagebausteine auf einen Kurztext für Inserat und Portalauftritt, innerhalb des eingestellten Zeichenlimits und in der gewählten Firmen-Tonalität.',
      enabled: true,
      schedule: 'sobald alle Lagebausteine vorliegen',
      requiresApproval: false,
    },
    {
      id: 'livia-task-07',
      title: 'Ausführlichen Exposé-Text erstellen',
      description:
        'Schreibt den Langtext für das Exposé mit Mikrolage, Makrolage, Erreichbarkeit, Nahversorgung und Umfeldentwicklung in getrennten Abschnitten, damit sich Interessenten gezielt einlesen können.',
      enabled: true,
      schedule: 'direkt im Anschluss an den Kurztext',
      requiresApproval: false,
    },
    {
      id: 'livia-task-08',
      title: 'Quellen hinterlegen',
      description:
        'Hängt jeder Aussage die verwendete Quelle mit Bezeichnung und Abrufdatum an. Lässt sich eine Aussage nicht belegen, wird sie gestrichen statt abgeschwächt.',
      enabled: true,
      schedule: 'bei jeder Texterstellung',
      requiresApproval: false,
    },
    {
      id: 'livia-task-09',
      title: 'Ergebnisse je Objekt lokal zwischenspeichern',
      description:
        'Legt Kurztext, Langtext und Quellenverzeichnis je Objekt in der Dokumentenablage ab, sodass der nächste Arbeitsauftrag auf dem bestehenden Stand aufsetzt und nichts doppelt recherchiert wird.',
      enabled: true,
      schedule: 'nach jedem abgeschlossenen Arbeitsauftrag',
      requiresApproval: false,
      dependsOnSystem: AgentSystemType.DMS,
    },
    {
      id: 'livia-task-10',
      title: 'Quartalsweisen Aktualisierungslauf simulieren',
      description:
        'Führt den «Quartals-Refresh» durch: prüft alle abgelegten Lagebeschriebe gegen den aktuellen Stand der Quellen, markiert veraltete Abschnitte und erneuert sie. Der Lauf wird protokolliert und ist je Objekt nachvollziehbar.',
      enabled: true,
      schedule: 'quartalsweise am ersten Werktag 05:30',
      requiresApproval: false,
      dependsOnSystem: AgentSystemType.DMS,
    },
    {
      id: 'livia-task-11',
      title: 'Relevante Änderungen melden',
      description:
        'Meldet der Vermarktung nur, was den Lagebeschrieb wirklich verändert — neue Haltestelle, bewilligte Arealentwicklung, wegfallende Nahversorgung — mit Hinweis auf den betroffenen Textabschnitt und die Quelle.',
      enabled: true,
      schedule: 'bei erkannter Abweichung im Aktualisierungslauf',
      requiresApproval: false,
      dependsOnChannel: AgentChannelType.WORKSPACE_CHAT,
    },
    {
      id: 'livia-task-12',
      title: 'Weitergeleiteten Lead aufnehmen',
      description:
        'Nimmt Leads entgegen, die Nora erkannt und ein Bewirtschafter zur Exposé-Erstellung weitergeleitet hat, samt der mitgegebenen Objektempfehlung. Die Objekte stammen ausschliesslich aus «Meine Objekte».',
      enabled: true,
      schedule: 'bei Weiterleitung',
      requiresApproval: false,
      dependsOnChannel: AgentChannelType.WORKSPACE_CHAT,
    },
    {
      id: 'livia-task-13',
      title: 'Objektbilder aus «Meine Objekte» importieren',
      description:
        'Importiert alle im Objektbestand hinterlegten Bilder automatisch in das Exposé, vermeidet Doppelimporte und übernimmt Kategorie, Reihenfolge und Titelbild-Markierung, soweit vorhanden.',
      enabled: true,
      schedule: 'beim Start eines Exposé-Auftrags',
      requiresApproval: false,
      dependsOnSystem: AgentSystemType.IMMOTOP2,
    },
    {
      id: 'livia-task-14',
      title: 'Exposé-Felder aus den Objektdaten befüllen',
      description:
        'Befüllt Eckdaten, Lage, Flächen, Preise, Ausstattung sowie Energie und Technik aus den in «Meine Objekte» verfügbaren Angaben. Nicht verfügbare Pflichtfelder bleiben leer und werden als fehlend markiert — es werden keine plausiblen Werte erfunden.',
      enabled: true,
      schedule: 'nach dem Bildimport',
      requiresApproval: false,
      dependsOnSystem: AgentSystemType.IMMOTOP2,
    },
    {
      id: 'livia-task-15',
      title: 'Angebots- beziehungsweise Offertenbroschüre erstellen',
      description:
        'Setzt aus den erfassten Objektdaten, Texten, Bildern und Anhängen die Broschüre in der Firmen-CI zusammen und stellt sie als PDF und Word zum Export bereit. Speichern und Erstellen bleiben getrennte Schritte.',
      enabled: true,
      schedule: 'auf Auslösung im Exposé-Arbeitsbereich',
      requiresApproval: false,
      dependsOnSystem: AgentSystemType.DMS,
    },
  ],
  channels: [
    {
      id: 'livia-ch-workspace-chat',
      type: AgentChannelType.WORKSPACE_CHAT,
      direction: AgentChannelDirection.BOTH,
      description:
        'Livia nimmt Objektadressen und Rückfragen im Arbeitsbereich entgegen und liefert Kurztext, Langtext und Änderungshinweise direkt im Kanal der Vermarktung.',
      status: AgentConnectionStatus.CONNECTED,
      enabled: true,
      config: {
        displayName: 'Livia — Lage & Umfeld',
        inboxAddress: 'arbeitsbereich/vermarktung/lage',
        defaultRecipients: ['vermarktung@property-on.ch'],
        autoReplyEnabled: true,
      },
    },
    {
      id: 'livia-ch-email',
      type: AgentChannelType.EMAIL,
      direction: AgentChannelDirection.OUTBOUND,
      description:
        'Versand der fertigen Lagebeschriebe und der Quartalsmeldung an Vermarktung und Bewirtschaftung. Eingehende Mails werden nicht bearbeitet.',
      status: AgentConnectionStatus.CONNECTED,
      enabled: true,
      config: {
        displayName: 'Livia (Property On)',
        senderAddress: 'livia@property-on.ch',
        defaultRecipients: ['vermarktung@property-on.ch', 'bewirtschaftung@property-on.ch'],
        autoReplyEnabled: false,
      },
    },
  ],
  systems: [
    {
      id: 'livia-sys-public-web',
      type: AgentSystemType.PUBLIC_WEB,
      access: AgentAccessLevel.READ,
      status: AgentConnectionStatus.CONNECTED,
      usage:
        'Öffentliche Umfeld- und Verkehrsdaten: Haltestellen und Fahrpläne, Wegzeiten, Einkaufen und Verpflegung, Gemeindeangaben zu Bevölkerung und Beschäftigung.',
      permissionNote: 'Nur lesend. Livia ruft ausschliesslich frei zugängliche Seiten ab.',
    },
    {
      id: 'livia-sys-shab',
      type: AgentSystemType.SHAB,
      access: AgentAccessLevel.READ,
      status: AgentConnectionStatus.CONNECTED,
      usage:
        'Amtliche Publikationen zu Baugesuchen, Zonenänderungen und Arealentwicklungen im Umfeld des Objekts.',
      permissionNote: 'Nur lesend. Meldungen werden als Quelle mit Publikationsdatum übernommen.',
    },
    {
      id: 'livia-sys-immotop2',
      type: AgentSystemType.IMMOTOP2,
      access: AgentAccessLevel.READ,
      status: AgentConnectionStatus.CONNECTED,
      usage:
        'Objektstammdaten und Adressen aus der Bewirtschaftung als Ausgangspunkt jedes Lagebeschriebs.',
      permissionNote: 'Nur lesend. Livia verändert keine Stammdaten in der Bewirtschaftungslösung.',
    },
    {
      id: 'livia-sys-dms',
      type: AgentSystemType.DMS,
      access: AgentAccessLevel.READ_WRITE,
      status: AgentConnectionStatus.CONNECTED,
      usage:
        'Ablage von Kurztext, Langtext und Quellenverzeichnis je Objekt sowie Zwischenstand für den Quartalslauf.',
      permissionNote:
        'Schreibt ausschliesslich in den Ordner «Lagebeschriebe» des jeweiligen Objekts; bestehende Fassungen bleiben als Version erhalten.',
    },
    {
      id: 'livia-sys-workspace',
      type: AgentSystemType.WORKSPACE,
      access: AgentAccessLevel.READ_WRITE,
      status: AgentConnectionStatus.CONNECTED,
      usage:
        'Aufträge, Rückfragen und Änderungshinweise im Arbeitsbereich der Vermarktung, inklusive Protokoll der Aktualisierungsläufe.',
      permissionNote:
        'Schreibt nur in den eigenen Bereich «Lage & Umfeld»; Objektdossiers anderer Teams bleiben unberührt.',
    },
  ],
  settings: [
    {
      id: 'livia-set-short-limit',
      label: 'Kurztext-Zeichenlimit',
      description: 'Obergrenze für den Lagetext im Inserat und auf den Portalen.',
      kind: AgentSettingKind.NUMBER,
      group: AgentSettingGroup.SPECIFIC,
      value: 600,
      unit: 'Zeichen',
      min: 200,
      max: 1200,
    },
    {
      id: 'livia-set-long-limit',
      label: 'Langtext-Zeichenlimit',
      description: 'Obergrenze für den ausführlichen Lageteil im Exposé.',
      kind: AgentSettingKind.NUMBER,
      group: AgentSettingGroup.SPECIFIC,
      value: 2400,
      unit: 'Zeichen',
      min: 800,
      max: 5000,
    },
    {
      id: 'livia-set-tonality',
      label: 'Firmen-Tonalität',
      description: 'Sprachstil, in dem Kurz- und Langtext verfasst werden.',
      kind: AgentSettingKind.SELECT,
      group: AgentSettingGroup.GENERAL,
      value: 'sachlich',
      options: [
        { value: 'sachlich', label: 'sachlich' },
        { value: 'hochwertig', label: 'hochwertig' },
        { value: 'zurueckhaltend', label: 'zurückhaltend' },
      ],
    },
    {
      id: 'livia-set-refresh-interval',
      label: 'Aktualisierungsintervall',
      description: 'Rhythmus, in dem bestehende Lagebeschriebe gegen die Quellen geprüft werden.',
      kind: AgentSettingKind.SELECT,
      group: AgentSettingGroup.SPECIFIC,
      value: 'quartalsweise',
      options: [
        { value: 'monatlich', label: 'monatlich' },
        { value: 'quartalsweise', label: 'quartalsweise' },
        { value: 'halbjaehrlich', label: 'halbjährlich' },
        { value: 'jaehrlich', label: 'jährlich' },
      ],
    },
    {
      id: 'livia-set-analysis-radius',
      label: 'Radius der Umfeldanalyse',
      description: 'Umkreis um die Objektadresse, der für die Mikrolage ausgewertet wird.',
      kind: AgentSettingKind.NUMBER,
      group: AgentSettingGroup.SPECIFIC,
      value: 800,
      unit: 'Meter',
      min: 200,
      max: 3000,
    },
    {
      id: 'livia-set-source-types',
      label: 'Relevante Quellentypen',
      description: 'Welche Quellen Livia für Lagebeschriebe und Aktualisierungsläufe heranzieht.',
      kind: AgentSettingKind.MULTI_SELECT,
      group: AgentSettingGroup.SPECIFIC,
      value: ['amtliche_publikationen', 'verkehrsdaten', 'bauprojekte', 'nahversorgung'],
      options: [
        { value: 'amtliche_publikationen', label: 'amtliche Publikationen' },
        { value: 'verkehrsdaten', label: 'Verkehrsdaten' },
        { value: 'bauprojekte', label: 'Bauprojekte' },
        { value: 'nahversorgung', label: 'Nahversorgung' },
        { value: 'medienberichte', label: 'Medienberichte' },
      ],
    },
  ],
  metrics: [
    {
      id: 'livia-metric-objects',
      label: 'Analysierte Objekte',
      value: '184',
      hint: 'Objekte mit vollständigem Lagebeschrieb, unter anderem in Zürich, Winterthur, Zug und St. Gallen.',
    },
    {
      id: 'livia-metric-current-blocks',
      label: 'Aktuelle Lagebausteine',
      value: '162',
      hint: 'Bausteine, die im letzten Aktualisierungslauf gegen die Quellen bestätigt wurden.',
    },
    {
      id: 'livia-metric-due-refresh',
      label: 'Fällige Aktualisierungen',
      value: '9',
      hint: 'Objekte, deren Lagebeschrieb im nächsten Quartals-Refresh erneuert wird.',
    },
    {
      id: 'livia-metric-detected-changes',
      label: 'Erkannte Umfeldänderungen',
      value: '14',
      hint: 'Seit dem letzten Lauf gemeldete Änderungen, etwa die Arealentwicklung Winterthur Neuhegi.',
    },
  ],
  headlineMetricId: 'livia-metric-objects',
  lastRun: '2026-05-20T06:00:00.000Z',
 }
@@ -0,0 +1,113 @@
 import { useCallback, useMemo, useRef, useState } from 'react'
 import { useSearchParams } from 'react-router'
 import { Box, Tab, Tabs } from '@mui/material'
 import { AgentWorkspaceHero } from '../../components/team'
 import { LeadTable } from '../../components/expose'
 import { LoadingPage, ErrorState } from '../../components/ui'
 import { useExposeLeads } from '../../hooks/useExposeLeads'
 import { useProperties } from '../../hooks/useProperties'
 import { ExposeLeadStatus } from '../../domain/exposeLead'
 import { EXPOSE_LEAD_TABS, EXPOSE_LEAD_TAB_LABELS } from '../../lib/constants'
 import type { ExposeLeadTab } from '../../lib/constants'
 import { agentWorkspaceById } from '../../lib/agentWorkspaces'
 const LIVIA = agentWorkspaceById('livia')!
 const PARAM_TAB = 'tab'
 function resolveTab(raw: string | null): ExposeLeadTab {
  return raw === EXPOSE_LEAD_TABS.ARCHIVED ? EXPOSE_LEAD_TABS.ARCHIVED : EXPOSE_LEAD_TABS.ACTIVE
 }
 /**
 * Livia — Exposé Master (Runde 4, §8).
 *
 * Die frühere Inserate-Seite ist vollständig ersetzt: Titel, Beschreibung, der
 * Knopf «Neues Inserat» und die Inserate-Tabelle sind entfallen. Ziel der Seite
 * ist die schnelle Verarbeitung von Leads, die Nora erkannt und ein
 * Bewirtschafter zur Exposé-Erstellung weitergeleitet hat.
 */
 export default function MyListings() {
  const [params, setParams] = useSearchParams()
  const tab = resolveTab(params.get(PARAM_TAB))
  const [selectedId, setSelectedId] = useState<string | null>(null)
  const scrollRef = useRef<HTMLDivElement>(null)
  const { data: leads = [], isLoading, isError, refetch } = useExposeLeads()
  const { data: properties = [] } = useProperties()
  const visible = useMemo(() => {
    const wanted = tab === EXPOSE_LEAD_TABS.ARCHIVED ? ExposeLeadStatus.ARCHIVED : ExposeLeadStatus.ACTIVE
    return leads
      .filter(l => l.status === wanted)
      .sort((a, b) => b.receivedAt.localeCompare(a.receivedAt))
  }, [leads, tab])
  /**
   * Beim Öffnen gleitet die gewählte Zeile an den oberen Rand des sichtbaren
   * Inhaltsbereichs; die nachfolgenden Leads rücken nach unten und dürfen aus
   * dem Blickfeld verschwinden (Runde 4, §8.4). Umgesetzt mit `scrollTo` auf dem
   * bestehenden Scrollcontainer — dafür braucht es keine Animationsbibliothek.
   *
   * Bei `prefers-reduced-motion` wird ohne Bewegung direkt gesprungen.
   */
  const handleSelect = useCallback((id: string, row: HTMLElement | null) => {
    const next = id === selectedId ? null : id
    setSelectedId(next)
    if (!next || !row || !scrollRef.current) return
    const container = scrollRef.current
    const reduced = window.matchMedia('(prefers-reduced-motion: reduce)').matches
    const top = container.scrollTop + row.getBoundingClientRect().top - container.getBoundingClientRect().top
    // Nach dem Zustandswechsel scrollen, sonst misst der Browser die alte Höhe.
    requestAnimationFrame(() => {
      container.scrollTo({ top, behavior: reduced ? 'auto' : 'smooth' })
    })
  }, [selectedId])
  const handleTabChange = useCallback((next: ExposeLeadTab) => {
    setSelectedId(null)
    setParams({ [PARAM_TAB]: next })
  }, [setParams])
  if (isLoading) return <LoadingPage />
  if (isError) return <ErrorState message="Die Leads konnten nicht geladen werden." onRetry={() => refetch()} />
  return (
    <Box sx={{ display: 'flex', flexDirection: 'column', height: '100%', overflow: 'hidden' }}>
      <Box ref={scrollRef} sx={{ flex: 1, overflowY: 'auto' }}>
        <AgentWorkspaceHero agentId={LIVIA.id} name={LIVIA.name} role={LIVIA.role} />
        <Box sx={{ px: 3, pb: 5 }}>
          <Tabs
            value={tab}
            onChange={(_, v: ExposeLeadTab) => handleTabChange(v)}
            sx={{ mb: 2, '& .MuiTab-root': { textTransform: 'none', fontWeight: 600, fontSize: '0.9rem' } }}
          >
            {Object.values(EXPOSE_LEAD_TABS).map(value => (
              <Tab key={value} value={value} label={EXPOSE_LEAD_TAB_LABELS[value]} />
            ))}
          </Tabs>
          <LeadTable
            leads={visible}
            properties={properties}
            selectedId={selectedId}
            onSelect={handleSelect}
            withWorkspace={tab === EXPOSE_LEAD_TABS.ACTIVE}
            emptyText={
              tab === EXPOSE_LEAD_TABS.ACTIVE
                ? 'Keine aktiven Leads. Sobald Nora ein Signal erkennt und es weitergeleitet wird, erscheint es hier.'
                : 'Noch keine archivierten Leads.'
            }
          />
          {/* Weissraum unter der Liste, damit auch die letzte Zeile an den
              oberen Rand gleiten kann. */}
          <Box sx={{ height: '60vh' }} />
        </Box>
      </Box>
    </Box>
  )
 }
@@ -8,6 +8,7 @@
      "name": "property-match",
      "version": "0.0.0",
      "dependencies": {
        "@anthropic-ai/sdk": "^0.122.0",
        "@dnd-kit/core": "^6.3.1",
        "@dnd-kit/sortable": "^10.0.0",
        "@dnd-kit/utilities": "^3.2.2",
@@ -16,12 +17,14 @@
        "@mui/icons-material": "^9.0.1",
        "@mui/material": "^9.0.1",
        "@tanstack/react-query": "^5.75.2",
        "cheerio": "^1.2.0",
        "leaflet": "^1.9.4",
        "lucide-react": "^0.511.0",
        "react": "^19.2.6",
        "react-dom": "^19.2.6",
        "react-leaflet": "^5.0.0",
        "react-router": "^7.15.0",
        "three": "^0.185.1",
        "zod": "^3.25.17",
        "zustand": "^5.0.5"
      },
@@ -34,6 +37,7 @@
        "@types/node": "^24.12.3",
        "@types/react": "^19.2.14",
        "@types/react-dom": "^19.2.3",
        "@types/three": "^0.185.4",
        "@vitejs/plugin-react": "^6.0.1",
        "@vitest/coverage-v8": "^4.1.7",
        "eslint": "^10.3.0",
@@ -56,6 +60,27 @@
      "dev": true,
      "license": "MIT"
    },
    "node_modules/@anthropic-ai/sdk": {
      "version": "0.122.0",
      "resolved": "https://registry.npmjs.org/@anthropic-ai/sdk/-/sdk-0.122.0.tgz",
      "integrity": "sha512-GGPNftt0caaz9MDlmNQGHX8855Ojaduyy5pm9Sm1h7HalCn0cWNb5/bweadJF+4yzbal+QL6ztBa09WAAOzLmQ==",
      "license": "MIT",
      "dependencies": {
        "json-schema-to-ts": "^3.1.1",
        "standardwebhooks": "^1.0.0"
      },
      "bin": {
        "anthropic-ai-sdk": "bin/cli"
      },
      "peerDependencies": {
        "zod": "^3.25.0 || ^4.0.0"
      },
      "peerDependenciesMeta": {
        "zod": {
          "optional": true
        }
      }
    },
    "node_modules/@asamuzakjp/css-color": {
      "version": "5.1.11",
      "resolved": "https://registry.npmjs.org/@asamuzakjp/css-color/-/css-color-5.1.11.tgz",
@@ -516,6 +541,13 @@
        "node": ">=20.19.0"
      }
    },
    "node_modules/@dimforge/rapier3d-compat": {
      "version": "0.12.0",
      "resolved": "https://registry.npmjs.org/@dimforge/rapier3d-compat/-/rapier3d-compat-0.12.0.tgz",
      "integrity": "sha512-uekIGetywIgopfD97oDL5PfeezkFpNhwlzlaEYNOA0N6ghdsOvh/HYjSMek5Q2O1PYvRSDFcqFVJl4r4ZBwOow==",
      "dev": true,
      "license": "Apache-2.0"
    },
    "node_modules/@dnd-kit/accessibility": {
      "version": "3.1.1",
      "resolved": "https://registry.npmjs.org/@dnd-kit/accessibility/-/accessibility-3.1.1.tgz",
@@ -1554,6 +1586,12 @@
      "dev": true,
      "license": "MIT"
    },
    "node_modules/@stablelib/base64": {
      "version": "1.0.1",
      "resolved": "https://registry.npmjs.org/@stablelib/base64/-/base64-1.0.1.tgz",
      "integrity": "sha512-1bnPQqSxSuc3Ii6MhBysoWCg58j97aUjuCSZrGSmDxNqtytIi0k8utUenAwTZN4V5mXXYGsVUI9zeBqy+jBOSQ==",
      "license": "MIT"
    },
    "node_modules/@standard-schema/spec": {
      "version": "1.1.0",
      "resolved": "https://registry.npmjs.org/@standard-schema/spec/-/spec-1.1.0.tgz",
@@ -1935,6 +1973,13 @@
        }
      }
    },
    "node_modules/@tweenjs/tween.js": {
      "version": "23.1.3",
      "resolved": "https://registry.npmjs.org/@tweenjs/tween.js/-/tween.js-23.1.3.tgz",
      "integrity": "sha512-vJmvvwFxYuGnF2axRtPYocag6Clbb5YS7kLL+SO/TeVFzHqDIWrNKYtcsPMibjDx9O+bu+psAy9NKfWklassUA==",
      "dev": true,
      "license": "MIT"
    },
    "node_modules/@tybys/wasm-util": {
      "version": "0.10.2",
      "resolved": "https://registry.npmjs.org/@tybys/wasm-util/-/wasm-util-0.10.2.tgz",
@@ -2060,6 +2105,35 @@
        "@types/react": "*"
      }
    },
    "node_modules/@types/stats.js": {
      "version": "0.17.4",
      "resolved": "https://registry.npmjs.org/@types/stats.js/-/stats.js-0.17.4.tgz",
      "integrity": "sha512-jIBvWWShCvlBqBNIZt0KAshWpvSjhkwkEu4ZUcASoAvhmrgAUI2t1dXrjSL4xXVLB4FznPrIsX3nKXFl/Dt4vA==",
      "dev": true,
      "license": "MIT"
    },
    "node_modules/@types/three": {
      "version": "0.185.4",
      "resolved": "https://registry.npmjs.org/@types/three/-/three-0.185.4.tgz",
      "integrity": "sha512-gAsBIC07NIFrxjbf7tH2t71c38uulFfk/RFoC7FNBSjMRAQ8J1x/RBvusX0N5PJouaYFJawXQqfCQ0RKUx/1nA==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "@dimforge/rapier3d-compat": "~0.12.0",
        "@tweenjs/tween.js": "~23.1.3",
        "@types/stats.js": "*",
        "@types/webxr": ">=0.5.17",
        "fflate": "~0.8.2",
        "meshoptimizer": "~1.1.1"
      }
    },
    "node_modules/@types/webxr": {
      "version": "0.5.24",
      "resolved": "https://registry.npmjs.org/@types/webxr/-/webxr-0.5.24.tgz",
      "integrity": "sha512-h8fgEd/DpoS9CBrjEQXR+dIDraopAEfu4wYVNY2tEPwk60stPWhvZMf4Foo5FakuQ7HFZoa8WceaWFervK2Ovg==",
      "dev": true,
      "license": "MIT"
    },
    "node_modules/@typescript-eslint/eslint-plugin": {
      "version": "8.59.3",
      "resolved": "https://registry.npmjs.org/@typescript-eslint/eslint-plugin/-/eslint-plugin-8.59.3.tgz",
@@ -2632,6 +2706,12 @@
        "require-from-string": "^2.0.2"
      }
    },
    "node_modules/boolbase": {
      "version": "1.0.0",
      "resolved": "https://registry.npmjs.org/boolbase/-/boolbase-1.0.0.tgz",
      "integrity": "sha512-JZOSA7Mo9sNGB8+UjSgzdLtokWAky1zbztM3WRLCbZ70/3cTANmQmOdR7y2g+J0e2WXywy1yS468tY+IruqEww==",
      "license": "ISC"
    },
    "node_modules/brace-expansion": {
      "version": "5.0.6",
      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-5.0.6.tgz",
@@ -2719,6 +2799,81 @@
        "node": ">=18"
      }
    },
    "node_modules/cheerio": {
      "version": "1.2.0",
      "resolved": "https://registry.npmjs.org/cheerio/-/cheerio-1.2.0.tgz",
      "integrity": "sha512-WDrybc/gKFpTYQutKIK6UvfcuxijIZfMfXaYm8NMsPQxSYvf+13fXUJ4rztGGbJcBQ/GF55gvrZ0Bc0bj/mqvg==",
      "license": "MIT",
      "dependencies": {
        "cheerio-select": "^2.1.0",
        "dom-serializer": "^2.0.0",
        "domhandler": "^5.0.3",
        "domutils": "^3.2.2",
        "encoding-sniffer": "^0.2.1",
        "htmlparser2": "^10.1.0",
        "parse5": "^7.3.0",
        "parse5-htmlparser2-tree-adapter": "^7.1.0",
        "parse5-parser-stream": "^7.1.2",
        "undici": "^7.19.0",
        "whatwg-mimetype": "^4.0.0"
      },
      "engines": {
        "node": ">=20.18.1"
      },
      "funding": {
        "url": "https://github.com/cheeriojs/cheerio?sponsor=1"
      }
    },
    "node_modules/cheerio-select": {
      "version": "2.1.0",
      "resolved": "https://registry.npmjs.org/cheerio-select/-/cheerio-select-2.1.0.tgz",
      "integrity": "sha512-9v9kG0LvzrlcungtnJtpGNxY+fzECQKhK4EGJX2vByejiMX84MFNQw4UxPJl3bFbTMw+Dfs37XaIkCwTZfLh4g==",
      "license": "BSD-2-Clause",
      "dependencies": {
        "boolbase": "^1.0.0",
        "css-select": "^5.1.0",
        "css-what": "^6.1.0",
        "domelementtype": "^2.3.0",
        "domhandler": "^5.0.3",
        "domutils": "^3.0.1"
      },
      "funding": {
        "url": "https://github.com/sponsors/fb55"
      }
    },
    "node_modules/cheerio/node_modules/entities": {
      "version": "6.0.1",
      "resolved": "https://registry.npmjs.org/entities/-/entities-6.0.1.tgz",
      "integrity": "sha512-aN97NXWF6AWBTahfVOIrB/NShkzi5H7F9r1s9mD3cDj4Ko5f2qhhVoYMibXF7GlLveb/D2ioWay8lxI97Ven3g==",
      "license": "BSD-2-Clause",
      "engines": {
        "node": ">=0.12"
      },
      "funding": {
        "url": "https://github.com/fb55/entities?sponsor=1"
      }
    },
    "node_modules/cheerio/node_modules/parse5": {
      "version": "7.3.0",
      "resolved": "https://registry.npmjs.org/parse5/-/parse5-7.3.0.tgz",
      "integrity": "sha512-IInvU7fabl34qmi9gY8XOVxhYyMyuH2xUNpb2q8/Y+7552KlejkRvqvD19nMoUW/uQGGbqNpA6Tufu5FL5BZgw==",
      "license": "MIT",
      "dependencies": {
        "entities": "^6.0.0"
      },
      "funding": {
        "url": "https://github.com/inikulin/parse5?sponsor=1"
      }
    },
    "node_modules/cheerio/node_modules/whatwg-mimetype": {
      "version": "4.0.0",
      "resolved": "https://registry.npmjs.org/whatwg-mimetype/-/whatwg-mimetype-4.0.0.tgz",
      "integrity": "sha512-QaKxh0eNIi2mE9p2vEdzfagOKHCcj1pJ56EEHGQOVxp8r9/iszLUUV7v89x9O1p/T+NlTM5W7jW6+cz4Fq1YVg==",
      "license": "MIT",
      "engines": {
        "node": ">=18"
      }
    },
    "node_modules/clsx": {
      "version": "2.1.1",
      "resolved": "https://registry.npmjs.org/clsx/-/clsx-2.1.1.tgz",
@@ -2787,6 +2942,22 @@
        "node": ">= 8"
      }
    },
    "node_modules/css-select": {
      "version": "5.2.2",
      "resolved": "https://registry.npmjs.org/css-select/-/css-select-5.2.2.tgz",
      "integrity": "sha512-TizTzUddG/xYLA3NXodFM0fSbNizXjOKhqiQQwvhlspadZokn1KDy0NZFS0wuEubIYAV5/c1/lAr0TaaFXEXzw==",
      "license": "BSD-2-Clause",
      "dependencies": {
        "boolbase": "^1.0.0",
        "css-what": "^6.1.0",
        "domhandler": "^5.0.2",
        "domutils": "^3.0.1",
        "nth-check": "^2.0.1"
      },
      "funding": {
        "url": "https://github.com/sponsors/fb55"
      }
    },
    "node_modules/css-tree": {
      "version": "3.2.1",
      "resolved": "https://registry.npmjs.org/css-tree/-/css-tree-3.2.1.tgz",
@@ -2801,6 +2972,18 @@
        "node": "^10 || ^12.20.0 || ^14.13.0 || >=15.0.0"
      }
    },
    "node_modules/css-what": {
      "version": "6.2.2",
      "resolved": "https://registry.npmjs.org/css-what/-/css-what-6.2.2.tgz",
      "integrity": "sha512-u/O3vwbptzhMs3L1fQE82ZSLHQQfto5gyZzwteVIEyeaY5Fc7R4dapF/BvRoSYFeqfBk4m0V1Vafq5Pjv25wvA==",
      "license": "BSD-2-Clause",
      "engines": {
        "node": ">= 6"
      },
      "funding": {
        "url": "https://github.com/sponsors/fb55"
      }
    },
    "node_modules/css.escape": {
      "version": "1.5.1",
      "resolved": "https://registry.npmjs.org/css.escape/-/css.escape-1.5.1.tgz",
@@ -2897,6 +3080,73 @@
        "csstype": "^3.0.2"
      }
    },
    "node_modules/dom-serializer": {
      "version": "2.0.0",
      "resolved": "https://registry.npmjs.org/dom-serializer/-/dom-serializer-2.0.0.tgz",
      "integrity": "sha512-wIkAryiqt/nV5EQKqQpo3SToSOV9J0DnbJqwK7Wv/Trc92zIAYZ4FlMu+JPFW1DfGFt81ZTCGgDEabffXeLyJg==",
      "license": "MIT",
      "dependencies": {
        "domelementtype": "^2.3.0",
        "domhandler": "^5.0.2",
        "entities": "^4.2.0"
      },
      "funding": {
        "url": "https://github.com/cheeriojs/dom-serializer?sponsor=1"
      }
    },
    "node_modules/dom-serializer/node_modules/entities": {
      "version": "4.5.0",
      "resolved": "https://registry.npmjs.org/entities/-/entities-4.5.0.tgz",
      "integrity": "sha512-V0hjH4dGPh9Ao5p0MoRY6BVqtwCjhz6vI5LT8AJ55H+4g9/4vbHx1I54fS0XuclLhDHArPQCiMjDxjaL8fPxhw==",
      "license": "BSD-2-Clause",
      "engines": {
        "node": ">=0.12"
      },
      "funding": {
        "url": "https://github.com/fb55/entities?sponsor=1"
      }
    },
    "node_modules/domelementtype": {
      "version": "2.3.0",
      "resolved": "https://registry.npmjs.org/domelementtype/-/domelementtype-2.3.0.tgz",
      "integrity": "sha512-OLETBj6w0OsagBwdXnPdN0cnMfF9opN69co+7ZrbfPGrdpPVNBUj02spi6B1N7wChLQiPn4CSH/zJvXw56gmHw==",
      "funding": [
        {
          "type": "github",
          "url": "https://github.com/sponsors/fb55"
        }
      ],
      "license": "BSD-2-Clause"
    },
    "node_modules/domhandler": {
      "version": "5.0.3",
      "resolved": "https://registry.npmjs.org/domhandler/-/domhandler-5.0.3.tgz",
      "integrity": "sha512-cgwlv/1iFQiFnU96XXgROh8xTeetsnJiDsTc7TYCLFd9+/WNkIqPTxiM/8pSd8VIrhXGTf1Ny1q1hquVqDJB5w==",
      "license": "BSD-2-Clause",
      "dependencies": {
        "domelementtype": "^2.3.0"
      },
      "engines": {
        "node": ">= 4"
      },
      "funding": {
        "url": "https://github.com/fb55/domhandler?sponsor=1"
      }
    },
    "node_modules/domutils": {
      "version": "3.2.2",
      "resolved": "https://registry.npmjs.org/domutils/-/domutils-3.2.2.tgz",
      "integrity": "sha512-6kZKyUajlDuqlHKVX1w7gyslj9MPIXzIFiz/rGu35uC1wMi+kMhQwGhl4lt9unC9Vb9INnY9Z3/ZA3+FhASLaw==",
      "license": "BSD-2-Clause",
      "dependencies": {
        "dom-serializer": "^2.0.0",
        "domelementtype": "^2.3.0",
        "domhandler": "^5.0.3"
      },
      "funding": {
        "url": "https://github.com/fb55/domutils?sponsor=1"
      }
    },
    "node_modules/electron-to-chromium": {
      "version": "1.5.356",
      "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.5.356.tgz",
@@ -2904,6 +3154,19 @@
      "dev": true,
      "license": "ISC"
    },
    "node_modules/encoding-sniffer": {
      "version": "0.2.1",
      "resolved": "https://registry.npmjs.org/encoding-sniffer/-/encoding-sniffer-0.2.1.tgz",
      "integrity": "sha512-5gvq20T6vfpekVtqrYQsSCFZ1wEg5+wW0/QaZMWkFr6BqD3NfKs0rLCx4rrVlSWJeZb5NBJgVLswK/w2MWU+Gw==",
      "license": "MIT",
      "dependencies": {
        "iconv-lite": "^0.6.3",
        "whatwg-encoding": "^3.1.1"
      },
      "funding": {
        "url": "https://github.com/fb55/encoding-sniffer?sponsor=1"
      }
    },
    "node_modules/enhanced-resolve": {
      "version": "5.21.3",
      "resolved": "https://registry.npmjs.org/enhanced-resolve/-/enhanced-resolve-5.21.3.tgz",
@@ -3201,6 +3464,12 @@
      "dev": true,
      "license": "MIT"
    },
    "node_modules/fast-sha256": {
      "version": "1.3.0",
      "resolved": "https://registry.npmjs.org/fast-sha256/-/fast-sha256-1.3.0.tgz",
      "integrity": "sha512-n11RGP/lrWEFI/bWdygLxhI+pVeo1ZYIVwvvPkW7azl/rOy+F3HYRZ2K5zeE9mmkhQppyv9sQFx0JM9UabnpPQ==",
      "license": "Unlicense"
    },
    "node_modules/fdir": {
      "version": "6.5.0",
      "resolved": "https://registry.npmjs.org/fdir/-/fdir-6.5.0.tgz",
@@ -3219,6 +3488,13 @@
        }
      }
    },
    "node_modules/fflate": {
      "version": "0.8.3",
      "resolved": "https://registry.npmjs.org/fflate/-/fflate-0.8.3.tgz",
      "integrity": "sha512-tbZNuJrLwGUp3zshBtdy4W+ORxZuIh8a5ilyIEQDC5rY1f3U20JMry0Ll3WBzU58EZKsEuJFXhb5gwv8CsPvgA==",
      "dev": true,
      "license": "MIT"
    },
    "node_modules/file-entry-cache": {
      "version": "8.0.0",
      "resolved": "https://registry.npmjs.org/file-entry-cache/-/file-entry-cache-8.0.0.tgz",
@@ -3417,6 +3693,49 @@
      "dev": true,
      "license": "MIT"
    },
    "node_modules/htmlparser2": {
      "version": "10.1.0",
      "resolved": "https://registry.npmjs.org/htmlparser2/-/htmlparser2-10.1.0.tgz",
      "integrity": "sha512-VTZkM9GWRAtEpveh7MSF6SjjrpNVNNVJfFup7xTY3UpFtm67foy9HDVXneLtFVt4pMz5kZtgNcvCniNFb1hlEQ==",
      "funding": [
        "https://github.com/fb55/htmlparser2?sponsor=1",
        {
          "type": "github",
          "url": "https://github.com/sponsors/fb55"
        }
      ],
      "license": "MIT",
      "dependencies": {
        "domelementtype": "^2.3.0",
        "domhandler": "^5.0.3",
        "domutils": "^3.2.2",
        "entities": "^7.0.1"
      }
    },
    "node_modules/htmlparser2/node_modules/entities": {
      "version": "7.0.1",
      "resolved": "https://registry.npmjs.org/entities/-/entities-7.0.1.tgz",
      "integrity": "sha512-TWrgLOFUQTH994YUyl1yT4uyavY5nNB5muff+RtWaqNVCAK408b5ZnnbNAUEWLTCpum9w6arT70i1XdQ4UeOPA==",
      "license": "BSD-2-Clause",
      "engines": {
        "node": ">=0.12"
      },
      "funding": {
        "url": "https://github.com/fb55/entities?sponsor=1"
      }
    },
    "node_modules/iconv-lite": {
      "version": "0.6.3",
      "resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.6.3.tgz",
      "integrity": "sha512-4fCk79wshMdzMp2rH06qWrJE4iolqLhCUH+OiuIgU++RB0+94NlDL81atO7GX55uUKueo0txHNtvEyI6D7WdMw==",
      "license": "MIT",
      "dependencies": {
        "safer-buffer": ">= 2.1.2 < 3.0.0"
      },
      "engines": {
        "node": ">=0.10.0"
      }
    },
    "node_modules/ignore": {
      "version": "5.3.2",
      "resolved": "https://registry.npmjs.org/ignore/-/ignore-5.3.2.tgz",
@@ -3652,6 +3971,19 @@
      "integrity": "sha512-xyFwyhro/JEof6Ghe2iz2NcXoj2sloNsWr/XsERDK/oiPCfaNhl5ONfp+jQdAZRQQ0IJWNzH9zIZF7li91kh2w==",
      "license": "MIT"
    },
    "node_modules/json-schema-to-ts": {
      "version": "3.1.1",
      "resolved": "https://registry.npmjs.org/json-schema-to-ts/-/json-schema-to-ts-3.1.1.tgz",
      "integrity": "sha512-+DWg8jCJG2TEnpy7kOm/7/AxaYoaRbjVB4LFZLySZlWn8exGs3A4OLJR966cVvU26N7X9TWxl+Jsw7dzAqKT6g==",
      "license": "MIT",
      "dependencies": {
        "@babel/runtime": "^7.18.3",
        "ts-algebra": "^2.0.0"
      },
      "engines": {
        "node": ">=16"
      }
    },
    "node_modules/json-schema-traverse": {
      "version": "0.4.1",
      "resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-0.4.1.tgz",
@@ -4092,6 +4424,13 @@
      "dev": true,
      "license": "CC0-1.0"
    },
    "node_modules/meshoptimizer": {
      "version": "1.1.1",
      "resolved": "https://registry.npmjs.org/meshoptimizer/-/meshoptimizer-1.1.1.tgz",
      "integrity": "sha512-oRFNWJRDA/WTrVj7NWvqa5HqE1t9MYDj2VaWirQCzCCrAd2GHrqR/sQezCxiWATPNlKTcRaPRHPJwIRoPBAp5g==",
      "dev": true,
      "license": "MIT"
    },
    "node_modules/min-indent": {
      "version": "1.0.1",
      "resolved": "https://registry.npmjs.org/min-indent/-/min-indent-1.0.1.tgz",
@@ -4157,6 +4496,18 @@
      "dev": true,
      "license": "MIT"
    },
    "node_modules/nth-check": {
      "version": "2.1.1",
      "resolved": "https://registry.npmjs.org/nth-check/-/nth-check-2.1.1.tgz",
      "integrity": "sha512-lqjrjmaOoAnWfMmBPL+XNnynZh2+swxiX3WUE0s4yEHI6m+AwrK2UZOimIRl3X/4QctVqS8AiZjFqyOGrMXb/w==",
      "license": "BSD-2-Clause",
      "dependencies": {
        "boolbase": "^1.0.0"
      },
      "funding": {
        "url": "https://github.com/fb55/nth-check?sponsor=1"
      }
    },
    "node_modules/object-assign": {
      "version": "4.1.1",
      "resolved": "https://registry.npmjs.org/object-assign/-/object-assign-4.1.1.tgz",
@@ -4270,6 +4621,79 @@
        "url": "https://github.com/inikulin/parse5?sponsor=1"
      }
    },
    "node_modules/parse5-htmlparser2-tree-adapter": {
      "version": "7.1.0",
      "resolved": "https://registry.npmjs.org/parse5-htmlparser2-tree-adapter/-/parse5-htmlparser2-tree-adapter-7.1.0.tgz",
      "integrity": "sha512-ruw5xyKs6lrpo9x9rCZqZZnIUntICjQAd0Wsmp396Ul9lN/h+ifgVV1x1gZHi8euej6wTfpqX8j+BFQxF0NS/g==",
      "license": "MIT",
      "dependencies": {
        "domhandler": "^5.0.3",
        "parse5": "^7.0.0"
      },
      "funding": {
        "url": "https://github.com/inikulin/parse5?sponsor=1"
      }
    },
    "node_modules/parse5-htmlparser2-tree-adapter/node_modules/entities": {
      "version": "6.0.1",
      "resolved": "https://registry.npmjs.org/entities/-/entities-6.0.1.tgz",
      "integrity": "sha512-aN97NXWF6AWBTahfVOIrB/NShkzi5H7F9r1s9mD3cDj4Ko5f2qhhVoYMibXF7GlLveb/D2ioWay8lxI97Ven3g==",
      "license": "BSD-2-Clause",
      "engines": {
        "node": ">=0.12"
      },
      "funding": {
        "url": "https://github.com/fb55/entities?sponsor=1"
      }
    },
    "node_modules/parse5-htmlparser2-tree-adapter/node_modules/parse5": {
      "version": "7.3.0",
      "resolved": "https://registry.npmjs.org/parse5/-/parse5-7.3.0.tgz",
      "integrity": "sha512-IInvU7fabl34qmi9gY8XOVxhYyMyuH2xUNpb2q8/Y+7552KlejkRvqvD19nMoUW/uQGGbqNpA6Tufu5FL5BZgw==",
      "license": "MIT",
      "dependencies": {
        "entities": "^6.0.0"
      },
      "funding": {
        "url": "https://github.com/inikulin/parse5?sponsor=1"
      }
    },
    "node_modules/parse5-parser-stream": {
      "version": "7.1.2",
      "resolved": "https://registry.npmjs.org/parse5-parser-stream/-/parse5-parser-stream-7.1.2.tgz",
      "integrity": "sha512-JyeQc9iwFLn5TbvvqACIF/VXG6abODeB3Fwmv/TGdLk2LfbWkaySGY72at4+Ty7EkPZj854u4CrICqNk2qIbow==",
      "license": "MIT",
      "dependencies": {
        "parse5": "^7.0.0"
      },
      "funding": {
        "url": "https://github.com/inikulin/parse5?sponsor=1"
      }
    },
    "node_modules/parse5-parser-stream/node_modules/entities": {
      "version": "6.0.1",
      "resolved": "https://registry.npmjs.org/entities/-/entities-6.0.1.tgz",
      "integrity": "sha512-aN97NXWF6AWBTahfVOIrB/NShkzi5H7F9r1s9mD3cDj4Ko5f2qhhVoYMibXF7GlLveb/D2ioWay8lxI97Ven3g==",
      "license": "BSD-2-Clause",
      "engines": {
        "node": ">=0.12"
      },
      "funding": {
        "url": "https://github.com/fb55/entities?sponsor=1"
      }
    },
    "node_modules/parse5-parser-stream/node_modules/parse5": {
      "version": "7.3.0",
      "resolved": "https://registry.npmjs.org/parse5/-/parse5-7.3.0.tgz",
      "integrity": "sha512-IInvU7fabl34qmi9gY8XOVxhYyMyuH2xUNpb2q8/Y+7552KlejkRvqvD19nMoUW/uQGGbqNpA6Tufu5FL5BZgw==",
      "license": "MIT",
      "dependencies": {
        "entities": "^6.0.0"
      },
      "funding": {
        "url": "https://github.com/inikulin/parse5?sponsor=1"
      }
    },
    "node_modules/path-exists": {
      "version": "4.0.0",
      "resolved": "https://registry.npmjs.org/path-exists/-/path-exists-4.0.0.tgz",
@@ -4635,6 +5059,12 @@
        "@rolldown/binding-win32-x64-msvc": "1.0.1"
      }
    },
    "node_modules/safer-buffer": {
      "version": "2.1.2",
      "resolved": "https://registry.npmjs.org/safer-buffer/-/safer-buffer-2.1.2.tgz",
      "integrity": "sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg==",
      "license": "MIT"
    },
    "node_modules/saxes": {
      "version": "6.0.0",
      "resolved": "https://registry.npmjs.org/saxes/-/saxes-6.0.0.tgz",
@@ -4726,6 +5156,16 @@
      "dev": true,
      "license": "MIT"
    },
    "node_modules/standardwebhooks": {
      "version": "1.1.1",
      "resolved": "https://registry.npmjs.org/standardwebhooks/-/standardwebhooks-1.1.1.tgz",
      "integrity": "sha512-bCbX9ZEyFkWPsRz7Bl3NuQUJohmwGSev/yhr7vhaGPlc4AfIrspIRa6cPTBuI1ItmrTDJ4d/S2hCsfe4+vQGnQ==",
      "license": "MIT",
      "dependencies": {
        "@stablelib/base64": "^1.0.0",
        "fast-sha256": "^1.3.0"
      }
    },
    "node_modules/std-env": {
      "version": "4.1.0",
      "resolved": "https://registry.npmjs.org/std-env/-/std-env-4.1.0.tgz",
@@ -4805,6 +5245,12 @@
        "url": "https://opencollective.com/webpack"
      }
    },
    "node_modules/three": {
      "version": "0.185.1",
      "resolved": "https://registry.npmjs.org/three/-/three-0.185.1.tgz",
      "integrity": "sha512-5aojFCXKwnjBRZvUnt3WFfEcvUJgkN5LlijRFN95hMy8WVkG4I0QNcJE+OuWvuJ0bOdStrbfXn0pkd6/QyiAlg==",
      "license": "MIT"
    },
    "node_modules/tinybench": {
      "version": "2.9.0",
      "resolved": "https://registry.npmjs.org/tinybench/-/tinybench-2.9.0.tgz",
@@ -4895,6 +5341,12 @@
        "node": ">=20"
      }
    },
    "node_modules/ts-algebra": {
      "version": "2.0.0",
      "resolved": "https://registry.npmjs.org/ts-algebra/-/ts-algebra-2.0.0.tgz",
      "integrity": "sha512-FPAhNPFMrkwz76P7cdjdmiShwMynZYN6SgOujD1urY4oNm80Ou9oMdmbR45LotcKOXoy7wSmHkRFE6Mxbrhefw==",
      "license": "MIT"
    },
    "node_modules/ts-api-utils": {
      "version": "2.5.0",
      "resolved": "https://registry.npmjs.org/ts-api-utils/-/ts-api-utils-2.5.0.tgz",
@@ -4969,7 +5421,6 @@
      "version": "7.25.0",
      "resolved": "https://registry.npmjs.org/undici/-/undici-7.25.0.tgz",
      "integrity": "sha512-xXnp4kTyor2Zq+J1FfPI6Eq3ew5h6Vl0F/8d9XU5zZQf1tX9s2Su1/3PiMmUANFULpmksxkClamIZcaUqryHsQ==",
      "dev": true,
      "license": "MIT",
      "engines": {
        "node": ">=20.18.1"
@@ -5214,6 +5665,19 @@
        "node": ">=20"
      }
    },
    "node_modules/whatwg-encoding": {
      "version": "3.1.1",
      "resolved": "https://registry.npmjs.org/whatwg-encoding/-/whatwg-encoding-3.1.1.tgz",
      "integrity": "sha512-6qN4hJdMwfYBtE3YBTTHhoeuUrDBPZmbQaxWAqSALV/MeEnR5z1xd8UKud2RAkFoPkmB+hli1TZSnyi84xz1vQ==",
      "deprecated": "Use @exodus/bytes instead for a more spec-conformant and faster implementation",
      "license": "MIT",
      "dependencies": {
        "iconv-lite": "0.6.3"
      },
      "engines": {
        "node": ">=18"
      }
    },
    "node_modules/whatwg-mimetype": {
      "version": "5.0.0",
      "resolved": "https://registry.npmjs.org/whatwg-mimetype/-/whatwg-mimetype-5.0.0.tgz",
@@ -14,6 +14,7 @@
    "check:tokens": "node scripts/check-tokens.js"
  },
  "dependencies": {
    "@anthropic-ai/sdk": "^0.122.0",
    "@dnd-kit/core": "^6.3.1",
    "@dnd-kit/sortable": "^10.0.0",
    "@dnd-kit/utilities": "^3.2.2",
@@ -22,12 +23,14 @@
    "@mui/icons-material": "^9.0.1",
    "@mui/material": "^9.0.1",
    "@tanstack/react-query": "^5.75.2",
    "cheerio": "^1.2.0",
    "leaflet": "^1.9.4",
    "lucide-react": "^0.511.0",
    "react": "^19.2.6",
    "react-dom": "^19.2.6",
    "react-leaflet": "^5.0.0",
    "react-router": "^7.15.0",
    "three": "^0.185.1",
    "zod": "^3.25.17",
    "zustand": "^5.0.5"
  },
@@ -40,6 +43,7 @@
    "@types/node": "^24.12.3",
    "@types/react": "^19.2.14",
    "@types/react-dom": "^19.2.3",
    "@types/three": "^0.185.4",
    "@vitejs/plugin-react": "^6.0.1",
    "@vitest/coverage-v8": "^4.1.7",
    "eslint": "^10.3.0",
@@ -0,0 +1,131 @@
 /**
 * Erzeugt die Agentenporträts aus den hochauflösenden Originalen.
 *
 * Die Porträts im Repository stammten bis Runde 6 aus einem HTML-Konzept und
 * lagen dort nur als kleine, liegende Zuschnitte vor — Ferdi etwa 215 × 160
 * Bildpunkte bei 6 KB. Im 3D-Meetingraum sind sie damit sichtbar unscharf, und
 * hochskalieren hilft nicht.
 *
 * Die Originale liegen in der Präsentation `PropertyOn_Engeli_v5.pptx` als
 * quadratische Bilder mit 1200 × 1200 Bildpunkten. Sie zeigen dieselben fünf
 * Personen — Kleidung, Frisur und Ausschnitt stimmen mit den bisherigen
 * Zuschnitten überein, es werden also keine Gesichter getauscht.
 *
 * Das Skript beschneidet den Rand (die Bilder tragen oben und an den Seiten
 * Reste des Folienrahmens), skaliert auf eine für den Browser sinnvolle Grösse
 * und schreibt sie nach `src/assets/team/`.
 *
 * Einmalig auszuführen; die Ergebnisse liegen als Assets im Repository:
 *
 *     node scripts/build-agent-portraits.mjs
 *
 * Es braucht keine Bildbibliothek — die Verarbeitung läuft auf einem Canvas im
 * bereits vorhandenen Chrome, den auch die visuellen Prüfungen nutzen.
 */
 import { chromium } from 'playwright-core'
 import { existsSync, readFileSync, writeFileSync } from 'node:fs'
 import { inflateRawSync } from 'node:zlib'
 import { fileURLToPath } from 'node:url'
 import { dirname, resolve } from 'node:path'
 const here = dirname(fileURLToPath(import.meta.url))
 const ziel = resolve(here, '../src/assets/team')
 /** Quellpräsentation. Nur zum Erzeugen nötig, nicht Teil des Repositorys. */
 const QUELLE = process.env.PORTRAIT_SOURCE
  ?? 'C:/Users/beni_/Downloads/PropertyOn_Engeli_v5.pptx'
 /**
 * Zuordnung Bild → Agent.
 *
 * Die Reihenfolge entspricht der Titelfolie der Präsentation: Ferdi, Bruno,
 * Livia, Nora, Sina. Jede Zuordnung wurde einzeln gegen den bisherigen
 * Zuschnitt geprüft — eine frühere Quelle trug dieselben Vornamen für eine
 * andere Belegschaft, und ein vertauschtes Gesicht wäre schlimmer als ein
 * unscharfes.
 */
 const ZUORDNUNG = {
  'image1.jpg': 'ferdi',
  'image2.jpg': 'bruno',
  'image3.jpg': 'livia',
  'image4.jpg': 'nora',
  'image5.jpg': 'sina',
 }
 /** Kantenbeschnitt je Seite, als Anteil der Bildbreite. */
 const BESCHNITT = 0.03
 /** Zielgrösse. Reicht für jede Darstellung im Programm, bleibt klein im Bündel. */
 const GROESSE = 512
 const CHROME = [
  process.env.CHROME_PATH,
  'C:/Program Files/Google/Chrome/Application/chrome.exe',
  'C:/Program Files (x86)/Google/Chrome/Application/chrome.exe',
 ].filter(Boolean).find(p => existsSync(p))
 if (!CHROME) throw new Error('Kein Chrome gefunden — CHROME_PATH setzen.')
 if (!existsSync(QUELLE)) throw new Error(`Quelldatei fehlt: ${QUELLE}`)
 /** Bilder aus dem ZIP-Container der Präsentation lesen, ohne Fremdbibliothek. */
 function medienAusPptx(pfad, gesucht) {
  const b = readFileSync(pfad)
  const gefunden = {}
  let i = 0
  while (i < b.length - 4) {
    if (b.readUInt32LE(i) !== 0x04034b50) { i++; continue }
    const method = b.readUInt16LE(i + 8)
    const csize = b.readUInt32LE(i + 18)
    const nameLen = b.readUInt16LE(i + 26)
    const extraLen = b.readUInt16LE(i + 28)
    const name = b.slice(i + 30, i + 30 + nameLen).toString()
    const start = i + 30 + nameLen + extraLen
    const datei = name.split('/').pop()
    if (name.startsWith('ppt/media/') && gesucht.includes(datei)) {
      try {
        gefunden[datei] = method === 8
          ? inflateRawSync(b.slice(start, start + csize))
          : b.slice(start, start + csize)
      } catch { /* beschädigter Eintrag — überspringen */ }
    }
    i = start + csize
  }
  return gefunden
 }
 const roh = medienAusPptx(QUELLE, Object.keys(ZUORDNUNG))
 const fehlend = Object.keys(ZUORDNUNG).filter(f => !roh[f])
 if (fehlend.length) throw new Error(`Nicht gefunden: ${fehlend.join(', ')}`)
 const browser = await chromium.launch({ executablePath: CHROME })
 const page = await browser.newPage()
 for (const [datei, agent] of Object.entries(ZUORDNUNG)) {
  const dataUri = `data:image/jpeg;base64,${roh[datei].toString('base64')}`
  const ergebnis = await page.evaluate(async ({ src, beschnitt, groesse }) => {
    const img = await new Promise((ok, err) => {
      const el = new Image()
      el.onload = () => ok(el)
      el.onerror = err
      el.src = src
    })
    const rand = Math.round(Math.min(img.width, img.height) * beschnitt)
    const sw = img.width - 2 * rand
    const sh = img.height - 2 * rand
    const c = document.createElement('canvas')
    c.width = groesse
    c.height = groesse
    const g = c.getContext('2d')
    g.imageSmoothingEnabled = true
    g.imageSmoothingQuality = 'high'
    g.drawImage(img, rand, rand, sw, sh, 0, 0, groesse, groesse)
    return { dataUri: c.toDataURL('image/jpeg', 0.86), quelle: `${img.width}x${img.height}` }
  }, { src: dataUri, beschnitt: BESCHNITT, groesse: GROESSE })
  const aus = resolve(ziel, `${agent}.jpg`)
  writeFileSync(aus, Buffer.from(ergebnis.dataUri.split(',')[1], 'base64'))
  const kb = (readFileSync(aus).length / 1024).toFixed(0)
  console.log(`${agent.padEnd(7)} ${ergebnis.quelle} → ${GROESSE}x${GROESSE}, ${kb} KB`)
 }
 await browser.close()
@@ -0,0 +1,496 @@
 /**
 * Erzeugt das Basler Panorama für den 3D-Meetingraum (Runde 6, §2).
 *
 * Vorher lagen zwei getrennte Fotoflächen vor den Glasfronten — vorne und
 * links. An deren Stossstelle war auf der linken Fensterseite eine harte Kante
 * sichtbar. Diese Naht lässt sich nicht wegblenden; sie verschwindet nur, wenn
 * es gar keine zwei Bilder mehr gibt.
 *
 * Dieses Skript baut aus den beiden Referenzfotos des Auftrags eine einzige
 * durchgehende Panoramadatei. Jede Quelle wird **genau einmal** verwendet —
 * kein Kacheln, kein Spiegeln (§2.2). Das gut wirkende Motiv vom Tischende
 * («front») bildet die linke Hälfte und bleibt in Ausschnitt und Farbe
 * unverändert; die Panoramaaufnahme («left») setzt es nach links fort, in
 * Helligkeit angeglichen und über eine schmale Zone überblendet.
 *
 * Himmel und Wasser werden anschliessend aus der jeweiligen Randzeile nach oben
 * und unten gestreckt. Ohne das stünde über und unter dem Bildstreifen eine
 * harte Grenze, die im Raum als Kante sichtbar wäre.
 *
 * Einmalig auszuführen; das Ergebnis liegt als Asset im Repository:
 *
 *     node scripts/build-basel-panorama.mjs
 *
 * Es braucht keine Bildbibliothek — die Komposition entsteht auf einem Canvas
 * im bereits vorhandenen Chrome, den auch die visuellen Prüfungen nutzen.
 */
 import { chromium } from 'playwright-core'
 import { existsSync, readFileSync, writeFileSync } from 'node:fs'
 import { fileURLToPath } from 'node:url'
 import { dirname, resolve } from 'node:path'
 const here = dirname(fileURLToPath(import.meta.url))
 const assets = resolve(here, '../src/assets/staff')
 const SRC_FRONT = resolve(assets, 'basel-front.jpg')
 const SRC_LEFT = resolve(assets, 'basel-left.jpg')
 const OUT = resolve(assets, 'basel-panorama.jpg')
 /**
 * Zielmasse. Die Breite ergibt sich aus den beiden Quellen: jede einmal,
 * abzüglich der Überblendung. Grösser wäre reines Hochskalieren.
 */
 const H = 660
 /** Wasserlinie im Ziel — beide Quellen werden darauf ausgerichtet. */
 const WATER_Y = 400
 /** Wasserlinie in den Quellen, als Anteil der Bildhöhe. */
 const FRONT_WATER = 0.60
 const LEFT_WATER = 0.64
 /** Skalierung der beiden Quellen. */
 const FRONT_SCALE = 1.3
 /**
 * Massstab der Fortsetzung (Runde 7, §1).
 *
 * Nicht frei gewählt, sondern aus den Fotos gemessen: das Münster steht in
 * basel-front 106 Pixel über der Wasserlinie, in basel-left 130. Damit
 * dieselben Häuser in beiden Bildhälften gleich gross erscheinen, muss die
 * Fortsetzung mit 1.3 × 106/130 laufen. Vorher stand hier 2.45 — daher der
 * Massstabssprung an der Nahtstelle, bei dem die linken Häuser doppelt so hoch
 * wirkten wie die vorderen.
 */
 const LEFT_SCALE = 1.06
 /**
 * Ausschnitt der Fortsetzung, in Pixeln der Quelle.
 *
 * Beide Referenzfotos zeigen das Münster. Nebeneinander gesetzt stünde es
 * zweimal im Bild — eine Doppelstruktur, die §2.1 ausdrücklich ausschliesst.
 * Aus der Panoramaaufnahme wird deshalb nur der Abschnitt östlich des Münsters
 * verwendet: die Häuserzeilen am Rhein. Das Münster selbst kommt genau einmal
 * vor, nämlich im Mittelmotiv vom Tischende.
 */
 const LEFT_CROP = { sx: 330, sw: 370 }
 /**
 * Breite der Überblendung zwischen Mittelmotiv und Fortsetzung.
 *
 * Bewusst schmal (Runde 7, §1). Eine breite Überblendung mischt zwei
 * verschiedene Häuserzeilen ineinander: beide bleiben halbdurchsichtig sichtbar
 * und es entstehen «Geisterhäuser», die vor und über anderen Gebäuden stehen.
 * Ein Überblenden funktioniert nur bei deckungsgleichem Inhalt — den gibt es
 * hier nicht — schon 64 Pixel liessen ein blasses Dach über der echten Zeile
 * stehen. Praktisch hart getrennt liest sich die Stelle als Übergang zwischen
 * zwei Häuserblöcken am Fluss, und jedes Gebäude bleibt eindeutig.
 */
 const FEATHER = 6
 /** Überblendbreite in Himmel und Wasser — dort ist das Bild strukturlos. */
 const FEATHER_WEICH = 300
 /**
 * Höhenband der Häuserzeile im fertigen Bild, in Pixeln.
 *
 * Innerhalb dieses Bands wird schmal überblendet und nachgeschärft, ausserhalb
 * breit überblendet und nicht geschärft. Die Grenzen folgen aus der Wasserlinie
 * bei 400 und den Dachfirsten darüber.
 *
 * Die obere Grenze liegt über **allen** Dächern beider Aufnahmen, auch über den
 * Dachaufbauten. Lag sie tiefer, schnitt sie die Häuserzeile des Mittelmotivs
 * waagrecht durch, und deren Gauben blieben als Reihe schwebender Klötzchen im
 * Himmel stehen.
 */
 const BAND = { oben: 220, obenEnde: 238, unten: 398, untenEnde: 420 }
 /**
 * Nachschärfung (Unschärfemaske) gegen die Weichheit des Hochskalierens.
 *
 * Die Fortsetzung stammt aus einem kleinen Panoramafoto und wird auf ein
 * Mehrfaches vergrössert; ohne Nachschärfung verlieren die Dachkanten ihre
 * Kontur. `staerke` ist der Anteil der zurückgegebenen Kantenzeichnung.
 */
 const SCHAERFE = { staerke: 0.85, radius: 1.1 }
 const CHROME = [
  process.env.CHROME_PATH,
  'C:/Program Files/Google/Chrome/Application/chrome.exe',
  'C:/Program Files (x86)/Google/Chrome/Application/chrome.exe',
 ].filter(Boolean).find(p => existsSync(p))
 if (!CHROME) throw new Error('Kein Chrome gefunden — CHROME_PATH setzen.')
 for (const f of [SRC_FRONT, SRC_LEFT]) {
  if (!existsSync(f)) throw new Error(`Referenzbild fehlt: ${f}`)
 }
 const asDataUri = f => `data:image/jpeg;base64,${readFileSync(f).toString('base64')}`
 const browser = await chromium.launch({ executablePath: CHROME })
 const page = await browser.newPage()
 const result = await page.evaluate(async (cfg) => {
  const load = src => new Promise((ok, err) => {
    const img = new Image()
    img.onload = () => ok(img)
    img.onerror = err
    img.src = src
  })
  const [fImg, lImg] = await Promise.all([load(cfg.front), load(cfg.left)])
  const fW = Math.round(fImg.width * cfg.FRONT_SCALE)
  const lW = Math.round(cfg.LEFT_CROP.sw * cfg.LEFT_SCALE)
  // Die beiden Bilder überlappen sich geometrisch über die volle weiche Breite.
  // Nur so lässt sich in Himmel und Wasser breit überblenden — ausserhalb der
  // Überlappung gäbe es nichts, worauf übergeblendet werden könnte, und es
  // entstünde ein durchsichtiger und damit schwarzer Streifen.
  const UEBER = cfg.FEATHER_WEICH
  const W = lW + fW - UEBER
  const H = cfg.H
  /**
   * Eine Quelle als Schicht, an der Wasserlinie ausgerichtet.
   *
   * Bewusst **ohne** senkrechtes Strecken über den Bildrand hinaus. Ein
   * gestreckter Streifen Wasser zerfällt in Flecken und Striche. Was oben und
   * unten fehlt, füllt weiter unten der Zeilenabgleich sauber auf.
   */
  function schicht(img, crop, scale, waterFraction) {
    const sx = crop ? crop.sx : 0
    const sw = crop ? crop.sw : img.width
    const w = Math.round(sw * scale)
    const h = Math.round(img.height * scale)
    const y = Math.round(cfg.WATER_Y - img.height * waterFraction * scale)
    const c = document.createElement('canvas')
    c.width = w
    c.height = H
    const cg = c.getContext('2d')
    cg.imageSmoothingEnabled = true
    cg.imageSmoothingQuality = 'high'
    cg.drawImage(img, sx, 0, sw, img.height, 0, y, w, h)
    return { canvas: c, w }
  }
  /**
   * Helligkeit der Fortsetzung **zeilenweise** an das Mittelmotiv angleichen
   * (Runde 7, §1).
   *
   * Ein einziger Faktor für das ganze Bild reicht nicht: die beiden Aufnahmen
   * unterscheiden sich im Himmel anders als in der Häuserzeile und im Wasser.
   * Der übrig bleibende Unterschied stand als waagrechte Tonkante quer durch den
   * Himmel. Verglichen wird nur dort, wo beide Bilder tatsächlich übereinander
   * liegen; jede Zeile bekommt ihren eigenen Faktor.
   */
  function tonAngleichen(fort, vorne, abX) {
    const vonX = abX + Math.round(UEBER * 0.2)
    const bisX = abX + Math.round(UEBER * 0.8)
    const fb = fort.canvas.getContext('2d').getImageData(0, 0, fort.w, H)
    const vb = vorne.canvas.getContext('2d').getImageData(0, 0, vorne.w, H)
    /*
     * Ein gemeinsamer Faktor für alle drei Kanäle, kein eigener je Kanal.
     * Kanalweise verglichen werden Inhalte, die einander nicht entsprechen —
     * an derselben Stelle stehen im einen Bild Bäume, im anderen Hausfassaden.
     * Die Verhältnisse laufen dann auseinander und färben die Fortsetzung.
     */
    let letzterFaktor = 1
    for (let y = 0; y < H; y++) {
      let sf = 0, sv = 0, n = 0
      for (let x = vonX; x < bisX; x++) {
        const i = (y * fort.w + (x - abX)) * 4
        const j = (y * vorne.w + x) * 4
        if (fb.data[i + 3] < 250 || vb.data[j + 3] < 250) continue
        sf += 0.2126 * fb.data[i] + 0.7152 * fb.data[i + 1] + 0.0722 * fb.data[i + 2]
        sv += 0.2126 * vb.data[j] + 0.7152 * vb.data[j + 1] + 0.0722 * vb.data[j + 2]
        n++
      }
      // Zeilen ohne Überlappung übernehmen den Faktor der letzten vergleichbaren.
      if (n >= 20 && sf >= 1) letzterFaktor = Math.max(0.75, Math.min(1.35, sv / sf))
      for (let x = 0; x < fort.w; x++) {
        const i = (y * fort.w + x) * 4
        for (let c = 0; c < 3; c++) {
          const wert = fb.data[i + c] * letzterFaktor
          fb.data[i + c] = wert > 255 ? 255 : wert
        }
      }
    }
    fort.canvas.getContext('2d').putImageData(fb, 0, 0)
  }
  const cv = document.createElement('canvas')
  cv.width = W
  cv.height = H
  const g = cv.getContext('2d')
  g.imageSmoothingEnabled = true
  g.imageSmoothingQuality = 'high'
  // 1) Beide Schichten aufbauen und die Fortsetzung zeilenweise im Ton
  //    angleichen, bevor irgendetwas zusammengesetzt wird.
  const fort = schicht(lImg, cfg.LEFT_CROP, cfg.LEFT_SCALE, cfg.LEFT_WATER)
  const vorne = schicht(fImg, null, cfg.FRONT_SCALE, cfg.FRONT_WATER)
  tonAngleichen(fort, vorne, W - fort.w)
  // 2) Fortsetzung rechts, darüber das Mittelmotiv mit höhenabhängig weicher
  //    rechter Flanke. Der Zylinder beginnt beim Mittelmotiv und läuft nach
  //    links in den Raum weiter; die Bildfolge muss dieser Richtung folgen.
  /*
   * Die Fortsetzung trägt **nur** die Häuserzeile bei (Runde 7, §1).
   *
   * Darüber und darunter wird sie ausgeblendet. Ihr Himmel ist milchig-weiss,
   * der des Mittelmotivs kräftig blau; nebeneinander stand er als heller Block
   * im Bild, und eine Helligkeitsangleichung holt die fehlende Farbsättigung
   * nicht zurück. Ihr Wasser wiederum endet früh. Beides deckt weiter unten der
   * Zeilenabgleich sauber ab — er verlängert Himmel und Wasser des
   * Mittelmotivs über die volle Breite.
   */
  const fk = fort.canvas.getContext('2d')
  const fbild = fk.getImageData(0, 0, fort.w, H)
  const fd = fbild.data
  /*
   * Oben: der Himmel wird **spaltenweise entlang der echten Dachkante**
   * entfernt, nicht mit einer waagrechten Linie abgeschnitten. Eine gerade
   * Linie liegt entweder über den Dächern — dann bleibt ein heller Streifen
   * Fremdhimmel stehen — oder sie schneidet mitten durch die Dächer.
   *
   * Gesucht wird je Spalte die erste Zeile, die sich deutlich von der
   * Himmelsfarbe ganz oben in derselben Spalte unterscheidet. Drei Zeilen in
   * Folge müssen abweichen, damit eine Wolke die Kante nicht vortäuscht.
   */
  const obenRand = new Array(fort.w).fill(0)
  for (let x = 0; x < fort.w; x++) {
    let y0 = 0
    while (y0 < H && fd[(y0 * fort.w + x) * 4 + 3] < 250) y0++
    if (y0 >= H) { obenRand[x] = H; continue }
    /*
     * Verglichen wird mit der Zeile acht darüber, nicht mit der obersten Zeile
     * der Spalte. Der Himmel verläuft von oben nach unten langsam von blau nach
     * dunstig; gegen einen festen Bezugswert überschreitet allein dieser Verlauf
     * irgendwann jede Schwelle, und die Kante läge zu hoch. Ein Dachrand
     * dagegen ändert die Farbe auf wenigen Zeilen sprunghaft.
     */
    let treffer = 0
    let kante = H
    for (let y = y0 + 8; y < H; y++) {
      const i = (y * fort.w + x) * 4
      const o = ((y - 8) * fort.w + x) * 4
      const sprung = Math.abs(fd[i] - fd[o]) + Math.abs(fd[i + 1] - fd[o + 1]) + Math.abs(fd[i + 2] - fd[o + 2])
      treffer = sprung > 60 ? treffer + 1 : 0
      if (treffer >= 2) { kante = y - 9; break }
    }
    obenRand[x] = kante
  }
  /*
   * Median statt Mittelwert über fünf Spalten. Ein Mittelwert zieht die Kante
   * an jedem Dachabsatz zu weit nach oben, und darüber blieben kleine Fetzen
   * fremden Himmels als Flecken stehen. Der Median folgt der Dachlinie und
   * bügelt trotzdem einzelne Ausreisser aus.
   */
  const geglaettet = obenRand.map((_, x) => {
    const fenster = []
    for (let k = -2; k <= 2; k++) if (obenRand[x + k] !== undefined) fenster.push(obenRand[x + k])
    fenster.sort((a, b) => a - b)
    return fenster[Math.floor(fenster.length / 2)]
  })
  /** Himmelsfarbe je Spalte, gemessen an der obersten Bildzeile der Schicht. */
  const himmel = []
  for (let x = 0; x < fort.w; x++) {
    let y0 = 0
    while (y0 < H && fd[(y0 * fort.w + x) * 4 + 3] < 250) y0++
    const i = (y0 * fort.w + x) * 4
    himmel.push(y0 < H ? [fd[i], fd[i + 1], fd[i + 2]] : [0, 0, 0])
  }
  // Unten endet die Fortsetzung kurz unter der Wasserlinie; darunter übernimmt
  // das Wasser des Mittelmotivs, das viel weiter hinunterreicht.
  const untenAb = cfg.BAND.untenEnde + 10
  const untenBis = cfg.BAND.untenEnde + 40
  for (let x = 0; x < fort.w; x++) {
    const kante = geglaettet[x]
    const ref = himmel[x]
    for (let y = 0; y < H; y++) {
      const i = (y * fort.w + x) * 4
      let obenA = Math.max(0, Math.min(1, (y - (kante - 2)) / 5))
      /*
       * Sicherheitsnetz dicht unter der Kante: was dort noch Himmelsfarbe hat,
       * ist Himmel und verschwindet ebenfalls. Sonst bleiben an Dachabsätzen
       * einzelne helle Flecken zwischen den Häusern stehen.
       */
      if (obenA > 0 && y < kante + 14) {
        const abstand = Math.abs(fd[i] - ref[0]) + Math.abs(fd[i + 1] - ref[1]) + Math.abs(fd[i + 2] - ref[2])
        if (abstand < 70) obenA = 0
      }
      const untenA = y < untenAb ? 1 : Math.max(0, 1 - (y - untenAb) / (untenBis - untenAb))
      fd[i + 3] = Math.round(fd[i + 3] * obenA * untenA)
    }
  }
  fk.putImageData(fbild, 0, 0)
  g.drawImage(fort.canvas, W - fort.w, 0)
  const mid = document.createElement('canvas')
  mid.width = vorne.w
  mid.height = H
  const mg = mid.getContext('2d')
  mg.drawImage(vorne.canvas, 0, 0)
  /*
   * Überblendung mit höhenabhängiger Breite (Runde 7, §1).
   *
   * Über der Häuserzeile und unter der Wasserlinie ist das Bild strukturlos —
   * dort wird über die volle Überlappung übergeblendet, und nur so verschwindet
   * der Helligkeitssprung im Himmel, den die Angleichung sonst als senkrechte
   * Kante stehen lässt. In der Häuserzeile selbst muss die Überblendung schmal
   * sein: dort stehen zwei verschiedene Häuserreihen übereinander, und jede
   * Breite mischt sie zu halbdurchsichtigen «Geisterhäusern».
   *
   * Beide Übergänge haben dieselbe Mitte, damit die Trennlinie über die ganze
   * Bildhöhe an derselben Stelle liegt und nicht schräg verläuft.
   */
  const mitte = vorne.w - UEBER / 2
  const maske = document.createElement('canvas')
  maske.width = vorne.w
  maske.height = H
  const kg = maske.getContext('2d')
  for (let y = 0; y < H; y++) {
    const imBand =
      y < cfg.BAND.oben ? 0
        : y < cfg.BAND.obenEnde ? (y - cfg.BAND.oben) / (cfg.BAND.obenEnde - cfg.BAND.oben)
          : y < cfg.BAND.unten ? 1
            : y < cfg.BAND.untenEnde ? 1 - (y - cfg.BAND.unten) / (cfg.BAND.untenEnde - cfg.BAND.unten)
              : 0
    /*
     * Ausserhalb der Häuserzeile reicht das Mittelmotiv bis an seinen eigenen
     * rechten Rand: dort trägt die Fortsetzung nichts mehr bei, weil sie oben
     * und unten ausgeblendet ist. Innerhalb der Zeile wandert die Trennung in
     * die Mitte der Überlappung und wird praktisch hart.
     */
    const x0 = (vorne.w - 4) + (mitte - (vorne.w - 4)) * imBand
    const b0 = 8 + (cfg.FEATHER - 8) * imBand
    const grad = kg.createLinearGradient(x0 - b0 / 2, 0, x0 + b0 / 2, 0)
    grad.addColorStop(0, 'rgba(0,0,0,1)')
    grad.addColorStop(1, 'rgba(0,0,0,0)')
    kg.fillStyle = grad
    kg.fillRect(0, y, vorne.w, 1)
  }
  // Die Maske entsteht zuerst vollständig auf einer eigenen Fläche. Zeilenweise
  // direkt mit `destination-in` zu arbeiten ginge nicht: dieser Modus wirkt auf
  // die ganze Fläche und löschte bei jeder Zeile alle übrigen.
  mg.globalCompositeOperation = 'destination-in'
  mg.drawImage(maske, 0, 0)
  g.drawImage(mid, 0, 0)
  const bild = g.getImageData(0, 0, W, H)
  const d = bild.data
  /*
   * 3) Freie Stellen zeilenweise auffüllen.
   *
   * Oben und unten reichen die Fotos nicht über die volle Höhe, und rechts endet
   * die Fortsetzung früher als das Mittelmotiv. Diese Stellen sind Himmel oder
   * Wasser: beides ist waagrecht nahezu einfarbig. Sie bekommen deshalb die
   * Durchschnittsfarbe ihrer eigenen Zeile, zum Rand hin weich an die dort
   * tatsächlich vorhandenen Bildpunkte angeglichen. Das ergibt eine ruhige
   * Fortsetzung ohne Striche, Flecken oder Wiederholungen.
   */
  // Erst je Zeile die Durchschnittsfarbe der echten Bildpunkte bestimmen.
  const mittelwerte = new Array(H).fill(null)
  const luecken = new Array(H).fill(0)
  for (let y = 0; y < H; y++) {
    const zeile = y * W * 4
    let sr = 0, sg = 0, sb = 0, n = 0
    for (let x = 0; x < W; x++) {
      if (d[zeile + x * 4 + 3] > 250) { sr += d[zeile + x * 4]; sg += d[zeile + x * 4 + 1]; sb += d[zeile + x * 4 + 2]; n++ }
    }
    if (n > 0) mittelwerte[y] = [sr / n, sg / n, sb / n]
    luecken[y] = W - n
  }
  // Zeilen ganz ohne Bildpunkte — ganz oben und ganz unten — übernehmen die
  // Farbe der nächsten Zeile, die welche hat. Ein fester Ersatzwert stünde dort
  // sonst als grauer Streifen quer über dem Himmel.
  for (let y = 0; y < H; y++) if (!mittelwerte[y]) {
    for (let k = 1; k < H; k++) {
      if (y + k < H && mittelwerte[y + k]) { mittelwerte[y] = mittelwerte[y + k]; break }
      if (y - k >= 0 && mittelwerte[y - k]) { mittelwerte[y] = mittelwerte[y - k]; break }
    }
  }
  for (let y = 0; y < H; y++) {
    if (luecken[y] === 0) continue
    const zeile = y * W * 4
    const mittel = mittelwerte[y]
    // Farbe des nächstgelegenen echten Bildpunkts links und rechts merken
    for (let x = 0; x < W; x++) {
      const i = zeile + x * 4
      if (d[i + 3] > 250) continue
      /*
       * Nur die unmittelbare Nachbarschaft zählt. Wurde weiter gesucht, trug
       * die Füllung die Farbe des nächsten Dachs waagrecht in den Himmel
       * hinein — als lange helle Schlieren über der Häuserzeile (Runde 7, §1).
       * Ein paar Bildpunkte reichen, um die Kante weich zu machen; alles
       * weitere bekommt die ruhige Durchschnittsfarbe der Zeile.
       */
      let nachbar = null
      for (let dx = 1; dx <= 12 && !nachbar; dx++) {
        for (const xx of [x - dx, x + dx]) {
          if (xx >= 0 && xx < W && d[zeile + xx * 4 + 3] > 250) {
            nachbar = { c: [d[zeile + xx * 4], d[zeile + xx * 4 + 1], d[zeile + xx * 4 + 2]], dist: dx }
            break
          }
        }
      }
      /*
       * Der Nachbar zählt nur, wenn er der Zeile ähnlich sieht. Ein Dach oder
       * ein Kamin am Rand der Lücke färbte die Füllung sonst ein und zog seine
       * Farbe als helle Schliere waagrecht in den Himmel.
       */
      const passend = nachbar && Math.abs(nachbar.c[0] - mittel[0]) + Math.abs(nachbar.c[1] - mittel[1]) + Math.abs(nachbar.c[2] - mittel[2]) < 90
      const t = passend ? Math.min(1, nachbar.dist / 10) : 1
      const quelle = passend ? nachbar.c : mittel
      for (let c = 0; c < 3; c++) d[i + c] = quelle[c] * (1 - t) + mittel[c] * t
      d[i + 3] = 255
    }
  }
  g.putImageData(bild, 0, 0)
  // 4) Nachschärfen (Unschärfemaske): das Bild minus seiner weichgezeichneten
  //    Fassung ergibt die Kantenzeichnung; sie wird verstärkt zurückgegeben.
  //    Das holt die Dachkanten der hochskalierten Häuserzeile zurück (§1).
  const weich = document.createElement('canvas')
  weich.width = W
  weich.height = H
  const wg = weich.getContext('2d')
  wg.filter = `blur(${cfg.SCHAERFE.radius}px)`
  wg.drawImage(cv, 0, 0)
  const oBild = g.getImageData(0, 0, W, H)
  const wBild = wg.getImageData(0, 0, W, H)
  const o = oBild.data
  const w = wBild.data
  // Nur im Strukturband schärfen. Im Himmel brächte Schärfen nichts, im Wasser
  // verstärkte es jede Unruhe der aufgefüllten Fläche.
  for (let y = cfg.BAND.oben; y < cfg.BAND.untenEnde && y < H; y++) {
    const rand = Math.min(y - cfg.BAND.oben, cfg.BAND.untenEnde - y, 24) / 24
    const k = cfg.SCHAERFE.staerke * Math.max(0, rand)
    for (let x = 0; x < W; x++) {
      const i = (y * W + x) * 4
      for (let c = 0; c < 3; c++) {
        const wert = o[i + c] + k * (o[i + c] - w[i + c])
        o[i + c] = wert < 0 ? 0 : wert > 255 ? 255 : wert
      }
    }
  }
  g.putImageData(oBild, 0, 0)
  return { dataUri: cv.toDataURL('image/jpeg', 0.9), W, H }
 }, {
  front: asDataUri(SRC_FRONT),
  left: asDataUri(SRC_LEFT),
  H, WATER_Y, FRONT_WATER, LEFT_WATER, FRONT_SCALE, LEFT_SCALE, FEATHER, FEATHER_WEICH, BAND, LEFT_CROP, SCHAERFE,
 })
 await browser.close()
 writeFileSync(OUT, Buffer.from(result.dataUri.split(',')[1], 'base64'))
 const kb = (readFileSync(OUT).length / 1024).toFixed(0)
 console.log(`Panorama erzeugt: ${OUT}`)
 console.log(`  ${result.W}x${result.H}, ${kb} KB`)
@@ -1,14 +1,15 @@
 # Bildherkunft
-| Datei | Quelle | Lizenz |
+| Datei | Inhalt | Herkunft |
 |---|---|---|
-| `buero.jpg` | Unsplash — Craig Lovelidge, «An empty conference room with desks and chairs» (The Mark, Rotterdam) | [Unsplash License](https://unsplash.com/license) — frei für kommerzielle Nutzung, keine Namensnennung nötig |
+| `basel-front.jpg` | Blick über den Rhein auf Grossbasler Altstadt und Münster, links die Wettsteinbrücke | Referenzbild 1 aus dem Auftrag (Anpassungsrunde 5/6) |
 | `basel-left.jpg` | Rheinperspektive mit Altstadt- und Münster-Silhouette, Panoramaformat | Referenzbild 2 aus dem Auftrag (Anpassungsrunde 5/6) |
-Direktbezug: `https://images.unsplash.com/photo-1637665599155-abfcf9fc3f78`
+Beide Bilder sind die dem Auftrag beigelegten Referenzfotos. Sie liegen im
 3D-Meetingraum als Fernkulisse **aussen vor den Glasfassaden** — `basel-front`
 hinter der gegenüberliegenden Front, `basel-left` entlang der linken Front.
-Das Bild dient als abgedunkelte Umgebung hinter den Personenkarten der
+Weil beide Aufnahmen dieselbe Rheinseite von derselben Uferseite zeigen, ergeben
-Startseite. Es wird nie unbearbeitet gezeigt — der Verlauf in `roomBackdrop.ts`
+sie zusammen einen zusammenhängenden Stadtverlauf: die Wasserlinie beider
-nimmt ihm so viel Kontrast, dass die Porträts und die Schrift davor tragen.
+Kulissen liegt auf derselben Welthöhe, damit der Blick nach vorne und der Blick
-
+nach links nicht wie zwei zusammengesetzte Fotos wirken (Runde 6, §4).
 **Austausch:** Datei ersetzen, Dateinamen beibehalten. Eine eigene Büroaufnahme
 ist jederzeit vorzuziehen — sie zeigt den echten Arbeitsplatz der Belegschaft.
@@ -0,0 +1,25 @@
 # Bildherkunft — Porträts
 Die Porträts der fünf Agenten stammen aus dem Konzeptdokument und sind
 fachliche Vorgabe.
 | Datei | Herkunft | Lizenz |
 |---|---|---|
 | `thomas.jpg` | Porträtbogen des Auftraggebers (`1-25.png`, Kachel **P015**), quadratisch beschnitten und auf 512 × 512 skaliert | vom Auftraggeber bereitgestellt |
 Thomas ist in Anpassungsrunde 6 neu dazugekommen und hatte kein Porträt aus dem
 Konzeptdokument. Der Kopf eines bestehenden Mitarbeitenden wurde bewusst nicht
 zweitverwendet — jeder Kopf gehört genau einer Person.
 **Runde 8, §3 — freundlichere Darstellung.** Das bisherige Porträt (Unsplash
 `photo-1560250097-0b93528c311a`) zeigte einen ernst blickenden Mann ohne
 Lächeln. Ersetzt durch P015 aus dem Porträtbogen: derselbe Typ Mensch —
 Mann mittleren Alters, Brille, dunkelblauer Blazer — aber mit offenem,
 freundlichem Ausdruck. Die Ähnlichkeit ist Absicht: die Änderung soll sich als
 freundlicheres Bild derselben Person lesen und nicht als Personalwechsel.
 **Auflösungshinweis:** Die Quelle ist ein Kontaktbogen mit dreissig Porträts auf
 1536 × 1024 Bildpunkten; eine Kachel misst darin rund 176 × 176. Das Bild ist
 auf 512 × 512 hochskaliert und damit weicher als die fünf Agentenporträts, die
 aus 1200 × 1200 grossen Originalen stammen. Liegt das Einzelporträt später in
 voller Auflösung vor, lässt es sich ohne weitere Anpassung austauschen.
@@ -1,46 +1,35 @@
-import { useEffect, useState } from 'react'
+import { useEffect } from 'react'
 import { Outlet, useNavigate, useLocation } from 'react-router'
-import { Box, Drawer, useTheme, useMediaQuery } from '@mui/material'
+import { Box } from '@mui/material'
 import { useLayoutStore } from '../../stores/layoutStore'
 import { useSessionStore } from '../../stores/sessionStore'
 import { WelcomeDialog } from '../onboarding/WelcomeDialog'
 import { RightContextPanel } from './RightContextPanel'
 import { ToastProvider } from '../ui'
 import { Sidebar } from './AppShellSidebar'
 import { TopBar } from './AppShellTopBar'
-import { WORKSPACE_CONFIG, WORKSPACE_ORDER, getWorkspaceFromPath } from './appShellConfig'
+import { WORKSPACE_CONFIG, getWorkspaceFromPath } from './appShellConfig'
 import { WorkspaceType } from '../../domain/enums'
 // ---------------------------------------------------------------------------
 // AppShell
 // ---------------------------------------------------------------------------
 /**
 * Rahmen der Anwendung (Runde 6, §10).
 *
 * Die permanente Navigationsleiste links ist entfallen — samt Breitenreservierung,
 * Einklapplogik und mobilem Drawer. Die Navigation liegt jetzt vollständig im
 * Menü der Kopfzeile (§11–§14). Der Inhaltsbereich beginnt dadurch am linken
 * Fensterrand; es bleibt kein leerer Streifen zurück, weil die Sidebar nicht
 * ausgeblendet, sondern gelöscht ist.
 *
 * Geblieben sind die beiden Effekte, die nichts mit der Navigation zu tun haben:
 * der Abgleich des Arbeitsbereichs mit der URL und die Umleitung, wenn ein
 * Rollenwechsel den aktuellen Arbeitsbereich verbietet.
 */
 export function AppShell() {
  const activeWorkspace = useLayoutStore(s => s.activeWorkspace)
  const sidebarCollapsed = useLayoutStore(s => s.sidebarCollapsed)
  const setActiveWorkspace = useLayoutStore(s => s.setActiveWorkspace)
  const toggleSidebar = useLayoutStore(s => s.toggleSidebar)
  const setSidebarCollapsed = useLayoutStore(s => s.setSidebarCollapsed)
  const { currentUser } = useSessionStore()
  const navigate = useNavigate()
  const location = useLocation()
  const theme = useTheme()
  const isMobile = useMediaQuery(theme.breakpoints.down('sm'))
  const isCompact = useMediaQuery(theme.breakpoints.down('lg'))
  const [mobileOpen, setMobileOpen] = useState(false)
-  // Das mobile Menü ist nur offen, solange die Route dieselbe bleibt. Statt es
+  // Arbeitsbereich am Pfad ausrichten
  // nach dem Routenwechsel per Effekt zu schliessen, hängt der Zustand am Pfad:
  // ein Wechsel erzeugt einen neuen Schlüssel und damit einen frischen Zustand.
  const [openForPath, setOpenForPath] = useState(location.pathname)
  const isMobileOpen = mobileOpen && openForPath === location.pathname
  const openMobileMenu = () => { setOpenForPath(location.pathname); setMobileOpen(true) }
  const closeMobileMenu = () => setMobileOpen(false)
  // Auto-collapse sidebar only on smaller screens (< 1200px); laptops keep the full nav + account
  useEffect(() => { setSidebarCollapsed(isCompact) }, [isCompact, setSidebarCollapsed])
  // Sync active workspace with URL
  useEffect(() => {
    const detected = getWorkspaceFromPath(location.pathname)
    if (detected && detected !== activeWorkspace) {
@@ -48,8 +37,7 @@ export function AppShell() {
    }
  }, [location.pathname, activeWorkspace, setActiveWorkspace])
-  // When the user changes (role switch), redirect to their first allowed workspace
+  // Nach einem Rollenwechsel auf den ersten erlaubten Arbeitsbereich umleiten
  // if the current workspace is no longer permitted
  useEffect(() => {
    if (!currentUser) return
    const allowed = currentUser.allowedWorkspaces
@@ -64,60 +52,15 @@ export function AppShell() {
  // eslint-disable-next-line react-hooks/exhaustive-deps
  }, [currentUser])
  const handleWorkspaceClick = (workspace: WorkspaceType) => {
    setActiveWorkspace(workspace)
    navigate(WORKSPACE_CONFIG[workspace].firstPath)
  }
  const userName = currentUser?.name ?? 'User'
  const orgName = currentUser?.organizationName ?? ''
  const allowedWorkspaces = currentUser?.allowedWorkspaces ?? WORKSPACE_ORDER
  const sidebarContent = (
    <Sidebar
      collapsed={isMobile ? false : sidebarCollapsed}
      activeWorkspace={activeWorkspace}
      allowedWorkspaces={allowedWorkspaces}
      onWorkspaceClick={handleWorkspaceClick}
      onToggle={isMobile ? closeMobileMenu : toggleSidebar}
      onClose={isMobile ? closeMobileMenu : undefined}
      userName={userName}
      orgName={orgName}
    />
  )
  return (
-    <Box sx={{ display: 'flex', height: '100vh', overflow: 'hidden' }}>
+    <Box sx={{ display: 'flex', flexDirection: 'column', height: '100vh', overflow: 'hidden' }}>
-      {/* Desktop: permanent sidebar */}
+      <TopBar pathname={location.pathname} />
      {!isMobile && sidebarContent}
-      {/* Mobile: temporary drawer */}
+      <Box component="main" sx={{ flex: 1, overflowY: 'auto' }}>
-      {isMobile && (
+        <Outlet />
        <Drawer
          open={isMobileOpen}
          onClose={closeMobileMenu}
          variant="temporary"
          ModalProps={{ keepMounted: true }}
          slotProps={{ paper: { sx: { width: 264, bgcolor: 'transparent', boxShadow: 'none' } } }}
        >
          {sidebarContent}
        </Drawer>
      )}
      <Box sx={{ flex: 1, display: 'flex', flexDirection: 'column', overflow: 'hidden' }}>
        <TopBar
          pathname={location.pathname}
          isMobile={isMobile}
          onMenuClick={openMobileMenu}
        />
        <Box component="main" sx={{ flex: 1, overflowY: 'auto' }}>
          <Outlet />
        </Box>
        <RightContextPanel />
      </Box>
      <RightContextPanel />
      <ToastProvider />
      <WelcomeDialog />
    </Box>
@@ -1,400 +0,0 @@
 import { Box, Typography, Avatar, IconButton, Tooltip } from '@mui/material'
 import { ChevronLeft, ChevronRight } from 'lucide-react'
 import { NavLink, useLocation } from 'react-router'
 import { WorkspaceType } from '../../domain/enums'
 import { useCompareStore } from '../../stores/compareStore'
 import { AgentAvatar } from '../team'
 import { WORKSPACE_CONFIG, WORKSPACE_ORDER, getUserInitials } from './appShellConfig'
 import { DS_ACCENT, DS_BRAND, DS_NEUTRAL, DS_SLATE } from '../../lib/ds'
 // ---------------------------------------------------------------------------
 // Visual constants
 // ---------------------------------------------------------------------------
 export const SIDEBAR_BG = '#0f1923'
 export const DIVIDER_COLOR = 'rgba(255,255,255,0.08)'
 export const TEXT_MUTED = '#94a3b8'
 export const TEXT_WHITE = '#ffffff'
 export const NAV_ACTIVE_BG = 'transparent'
 export const NAV_ACTIVE_ACCENT = '#b8975a'
 export const NAV_HOVER_BG = 'rgba(255,255,255,0.06)'
 // ---------------------------------------------------------------------------
 // Types
 // ---------------------------------------------------------------------------
 export interface SidebarProps {
  collapsed: boolean
  activeWorkspace: WorkspaceType
  allowedWorkspaces: WorkspaceType[]
  onWorkspaceClick: (workspace: WorkspaceType) => void
  onToggle: () => void
  onClose?: () => void
  userName: string
  orgName: string
 }
 // ---------------------------------------------------------------------------
 // Component
 // ---------------------------------------------------------------------------
 export function Sidebar({
  collapsed,
  activeWorkspace,
  allowedWorkspaces,
  onWorkspaceClick,
  onToggle,
  onClose,
  userName,
  orgName,
 }: SidebarProps) {
  const config = WORKSPACE_CONFIG[activeWorkspace]
  const compareCount = useCompareStore(s => s.compareItems.length)
  const { pathname } = useLocation()
  const width = collapsed ? 60 : 264
  const visibleWorkspaces = WORKSPACE_ORDER.filter((ws) => allowedWorkspaces.includes(ws))
  return (
    <Box
      component="nav"
      sx={{
        width,
        minWidth: width,
        flexShrink: 0,
        height: '100vh',
        backgroundColor: SIDEBAR_BG,
        display: 'flex',
        flexDirection: 'column',
        transition: 'width 0.2s ease',
        overflow: 'hidden',
      }}
    >
      {/* Logo area */}
      <Box
        sx={{
          height: 56,
          display: 'flex',
          alignItems: 'center',
          justifyContent: collapsed ? 'center' : 'flex-start',
          px: collapsed ? 0 : 2.5,
          borderBottom: `1px solid ${DIVIDER_COLOR}`,
          flexShrink: 0,
        }}
      >
        {collapsed ? (
          <Typography
            variant="subtitle1"
            sx={{ color: TEXT_WHITE, fontWeight: 700, letterSpacing: 0.5 }}
          >
            PM
          </Typography>
        ) : (
          <Box>
            <Typography
              variant="subtitle1"
              sx={{ color: TEXT_WHITE, fontWeight: 700, lineHeight: 1.2 }}
            >
              Property
            </Typography>
            <Typography
              variant="caption"
              sx={{
                color: DS_BRAND.light,
                fontWeight: 600,
                textTransform: 'uppercase',
                letterSpacing: 1,
                fontSize: '0.6rem',
              }}
            >
              Match
            </Typography>
          </Box>
        )}
      </Box>
      {/* Workspace tabs — side-by-side segmented control (hidden when only 1 workspace) */}
      {visibleWorkspaces.length > 1 && <Box
        sx={{
          borderBottom: `1px solid ${DIVIDER_COLOR}`,
          display: 'grid',
          gridTemplateColumns: collapsed ? '1fr' : `repeat(${visibleWorkspaces.length}, 1fr)`,
          flexShrink: 0,
        }}
      >
        {visibleWorkspaces.map((ws, idx) => {
          const wsConfig = WORKSPACE_CONFIG[ws]
          const Icon = wsConfig.icon
          const isActive = ws === activeWorkspace
          const tabContent = (
            <Box
              onClick={() => { onWorkspaceClick(ws); onClose?.() }}
              sx={{
                display: 'flex',
                flexDirection: collapsed ? 'row' : 'column',
                alignItems: 'center',
                justifyContent: 'center',
                gap: collapsed ? 0 : 0.5,
                py: collapsed ? 1 : 1.25,
                cursor: 'pointer',
                backgroundColor: isActive ? wsConfig.chipColor : 'transparent',
                borderRight: !collapsed && idx < visibleWorkspaces.length - 1
                  ? `1px solid ${DIVIDER_COLOR}`
                  : 'none',
                transition: 'background-color 0.15s ease',
                '&:hover': {
                  backgroundColor: isActive ? wsConfig.chipColor : NAV_HOVER_BG,
                },
              }}
            >
              <Icon size={15} color={isActive ? TEXT_WHITE : TEXT_MUTED} />
              {!collapsed && (
                <Typography
                  variant="caption"
                  sx={{
                    color: isActive ? TEXT_WHITE : TEXT_MUTED,
                    fontWeight: isActive ? 700 : 400,
                    fontSize: '0.6875rem',
                    lineHeight: 1,
                    letterSpacing: 0.2,
                  }}
                >
                  {wsConfig.label}
                </Typography>
              )}
            </Box>
          )
          return collapsed ? (
            <Tooltip key={ws} title={wsConfig.label} placement="right">
              {tabContent}
            </Tooltip>
          ) : (
            <Box key={ws}>{tabContent}</Box>
          )
        })}
      </Box>}
      {/* Nav items */}
      <Box sx={{ flex: 1, overflowY: 'auto', py: 0.5 }}>
        {config.navItems.map((item) => {
          const Icon = item.icon
          const navContent = (
            <NavLink
              to={item.path}
              style={{ textDecoration: 'none', display: 'block' }}
              onClick={() => onClose?.()}
            >
              {({ isActive }) => (
                <Box
                  sx={{
                    display: 'flex',
                    alignItems: 'center',
                    gap: 1.25,
                    pl: collapsed ? 0 : isActive ? 1.25 : 1.5,
                    pr: collapsed ? 0 : 1.5,
                    py: 0.75,
                    mx: 0.5,
                    borderRadius: 1,
                    justifyContent: collapsed ? 'center' : 'flex-start',
                    borderLeft: collapsed ? 'none' : `3px solid ${isActive ? NAV_ACTIVE_ACCENT : 'transparent'}`,
                    backgroundColor: 'transparent',
                    '&:hover': { backgroundColor: NAV_HOVER_BG },
                    transition: 'border-color 0.15s ease',
                    cursor: 'pointer',
                  }}
                >
                  <Icon size={16} color={isActive ? TEXT_WHITE : TEXT_MUTED} />
                  {!collapsed && (
                    <Box sx={{ flex: 1, display: 'flex', alignItems: 'center', gap: 0.75, minWidth: 0 }}>
                      <Typography
                        variant="body2"
                        sx={{
                          color: isActive ? TEXT_WHITE : TEXT_MUTED,
                          fontWeight: isActive ? 600 : 400,
                          fontSize: '0.875rem',
                          letterSpacing: '-0.01em',
                          whiteSpace: 'nowrap',
                        }}
                      >
                        {item.label}
                      </Typography>
                      {item.path === '/demand/compare' && compareCount > 0 && (
                        <Box sx={{
                          minWidth: 18, height: 18, borderRadius: '9px',
                          bgcolor: DS_ACCENT.warning.main, color: 'white',
                          fontSize: '0.65rem', fontWeight: 700,
                          display: 'flex', alignItems: 'center', justifyContent: 'center',
                          px: 0.5, flexShrink: 0,
                        }}>
                          {compareCount}
                        </Box>
                      )}
                    </Box>
                  )}
                </Box>
              )}
            </NavLink>
          )
          // Subreiter bleiben sichtbar, solange der Nutzer im Funktionsbereich ist.
          // Seit Runde 4 liegen die Agentenseiten nicht mehr unterhalb des
          // Basispfads — die Liste muss deshalb auch auf einer Agentenseite
          // offen bleiben, sonst verschwände die Navigation beim Hinklicken.
          // Eingeklappt entfallen sie — dort ist kein Platz für eine zweite Ebene.
          const subItems = item.children ?? []
          const inSection =
            subItems.length > 0 &&
            (pathname.startsWith(item.path) || subItems.some(c => pathname.startsWith(c.path)))
          return collapsed ? (
            <Tooltip key={item.path} title={item.label} placement="right">
              <Box>{navContent}</Box>
            </Tooltip>
          ) : (
            <Box key={item.path}>
              {navContent}
              {inSection && (
                <Box component="ul" sx={{ listStyle: 'none', m: 0, p: 0, mt: 0.25, mb: 0.5 }}>
                  {subItems.map((child) => (
                    <Box component="li" key={child.path}>
                      <NavLink
                        to={child.path}
                        style={{ textDecoration: 'none', display: 'block' }}
                        onClick={() => onClose?.()}
                      >
                        {({ isActive }) => (
                          <Box
                            sx={{
                              display: 'flex',
                              alignItems: 'center',
                              gap: 1,
                              pl: child.agentId ? 2.5 : 4.75,
                              pr: 1.5,
                              py: child.agentId ? 0.625 : 0.5,
                              mx: 0.5,
                              borderRadius: 1,
                              borderLeft: `3px solid ${isActive ? NAV_ACTIVE_ACCENT : 'transparent'}`,
                              '&:hover': { backgroundColor: NAV_HOVER_BG },
                              transition: 'border-color 0.15s ease',
                              cursor: 'pointer',
                            }}
                          >
                            {child.agentId && (
                              <AgentAvatar
                                agent={{ id: child.agentId, name: child.label, role: child.role ?? '' }}
                                size={26}
                              />
                            )}
                            <Box sx={{ minWidth: 0 }}>
                              <Typography
                                variant="body2"
                                sx={{
                                  color: isActive ? TEXT_WHITE : TEXT_MUTED,
                                  fontWeight: isActive ? 600 : 400,
                                  fontSize: '0.8125rem',
                                  letterSpacing: '-0.01em',
                                  whiteSpace: 'nowrap',
                                  lineHeight: 1.3,
                                }}
                              >
                                {child.label}
                              </Typography>
                              {child.role && (
                                <Typography
                                  variant="caption"
                                  sx={{
                                    display: 'block',
                                    color: isActive ? TEXT_MUTED : '#64748b',
                                    fontSize: '0.6875rem',
                                    lineHeight: 1.3,
                                    whiteSpace: 'nowrap',
                                    overflow: 'hidden',
                                    textOverflow: 'ellipsis',
                                  }}
                                >
                                  {child.role}
                                </Typography>
                              )}
                            </Box>
                          </Box>
                        )}
                      </NavLink>
                    </Box>
                  ))}
                </Box>
              )}
            </Box>
          )
        })}
      </Box>
      {/* Bottom section */}
      <Box
        sx={{
          borderTop: `1px solid ${DIVIDER_COLOR}`,
          px: collapsed ? 0 : 1.5,
          py: 1,
          display: 'flex',
          alignItems: 'center',
          gap: 1,
          justifyContent: collapsed ? 'center' : 'space-between',
          flexShrink: 0,
        }}
      >
        {!collapsed && (
          <Box sx={{ display: 'flex', alignItems: 'center', gap: 1, minWidth: 0 }}>
            <Avatar
              sx={{
                width: 32,
                height: 32,
                fontSize: '0.75rem',
                bgcolor: DS_NEUTRAL.gold,
                flexShrink: 0,
              }}
            >
              {getUserInitials(userName)}
            </Avatar>
            <Box sx={{ minWidth: 0 }}>
              <Typography
                variant="body2"
                sx={{
                  color: TEXT_WHITE,
                  fontWeight: 500,
                  fontSize: '0.8125rem',
                  whiteSpace: 'nowrap',
                  overflow: 'hidden',
                  textOverflow: 'ellipsis',
                }}
              >
                {userName}
              </Typography>
              <Typography
                variant="caption"
                sx={{
                  color: DS_SLATE[500],
                  fontSize: '0.7rem',
                  whiteSpace: 'nowrap',
                  overflow: 'hidden',
                  textOverflow: 'ellipsis',
                  display: 'block',
                }}
              >
                {orgName}
              </Typography>
            </Box>
          </Box>
        )}
        <IconButton
          onClick={onToggle}
          size="small"
          sx={{ color: DS_SLATE[500], flexShrink: 0 }}
        >
          {collapsed ? <ChevronRight size={16} /> : <ChevronLeft size={16} />}
        </IconButton>
      </Box>
    </Box>
  )
 }
@@ -1,39 +1,28 @@
-import { Box, IconButton } from '@mui/material'
+import { Box } from '@mui/material'
 import { Menu } from 'lucide-react'
 import { OrganizationContextBadge } from './OrganizationContextBadge'
 import { NotificationButton } from './NotificationButton'
-import { UserMenu } from './UserMenu'
+import { GlobalNavMenu } from './GlobalNavMenu'
 import { AgentChatStickyBar } from '../team'
 // ---------------------------------------------------------------------------
 // Types
 // ---------------------------------------------------------------------------
 export interface TopBarProps {
  pathname: string
  onMenuClick?: () => void
  isMobile?: boolean
 }
 // ---------------------------------------------------------------------------
 // Component
 // ---------------------------------------------------------------------------
 /**
 * Kopfzeile der Anwendung.
 *
- * Sie trägt nur noch, was global gilt: Mandant, Benachrichtigungen und Konto.
+ * Sie trägt seit Runde 6 die gesamte Navigation: Mandant, Benachrichtigungen
- * Das Chip «Verwaltung» und der wiederholte Seitenname sind entfallen — beides
+ * und — an der Stelle des früheren Profilsymbols — ein Menüsymbol, das das
- * stand nochmals gross im Inhaltsbereich und kostete nur Höhe. Ohne Trennlinie
+ * globale Klappmenü öffnet (§11, §15). Das Profil ist vollständig in dieses
- * geht die Zeile ohne sichtbaren Bruch in den Seiteninhalt über.
+ * Menü gewandert; in der Leiste selbst steht es nicht mehr.
 *
- * Seit Runde 5 steht in der freien Mitte der kompakte Agentenchat, sobald der
+ * In der freien Mitte erscheint der kompakte Agentenchat, sobald der
- * ausführliche Chatkopf weggescrollt ist (§9). Er liegt im Balken selbst und
+ * ausführliche Chatkopf weggescrollt ist (Runde 5, §9). Er liegt im Balken
- * nicht darüber — deshalb kann er Tabellen und Filter nicht verdecken. Der
+ * selbst und nicht darüber — deshalb kann er Tabellen und Filter nicht
- * Balken bekommt dafür `zIndex: appBar`: über dem Seiteninhalt, aber unter
+ * verdecken. Der Balken bekommt dafür `zIndex: appBar`: über dem Seiteninhalt,
- * Menüs, Dialogen und Popovers, die MUI oberhalb davon einhängt (§10).
+ * aber unter Menüs, Dialogen und Popovers, die MUI oberhalb davon einhängt.
 */
-export function TopBar({ onMenuClick, isMobile }: TopBarProps) {
+export function TopBar(_props: TopBarProps) {
  return (
    <Box
      component="header"
@@ -50,24 +39,17 @@ export function TopBar({ onMenuClick, isMobile }: TopBarProps) {
        px: { xs: 1.5, sm: 3 },
      }}
    >
-      {/* Links steht nur noch der Menüaufruf auf schmalen Schirmen. */}
+      {/* Links bleibt frei — die Navigation liegt vollständig rechts. */}
-      <Box sx={{ display: 'flex', alignItems: 'center', gap: 1, flexShrink: 0 }}>
+      <Box sx={{ flexShrink: 0 }} />
        {isMobile && (
          <IconButton size="small" onClick={onMenuClick} sx={{ mr: 0.5 }}>
            <Menu size={20} />
          </IconButton>
        )}
      </Box>
      <AgentChatStickyBar />
      {/* Right side */}
      <Box sx={{ display: 'flex', alignItems: 'center', gap: { xs: 0.5, sm: 1 }, flexShrink: 0 }}>
        <Box sx={{ display: { xs: 'none', sm: 'flex' } }}>
          <OrganizationContextBadge />
        </Box>
        <NotificationButton />
-        <UserMenu />
+        <GlobalNavMenu />
      </Box>
    </Box>
  )
@@ -0,0 +1,236 @@
 import { useState } from 'react'
 import { useNavigate } from 'react-router'
 import { Box, ButtonBase, Divider, IconButton, Popover, Tooltip, Typography } from '@mui/material'
 import { HelpCircle, LayoutGrid, LogOut, Settings, User } from 'lucide-react'
 import { useSessionStore } from '../../stores/sessionStore'
 import { useToastStore } from '../../stores/toastStore'
 import { AgentAvatar } from '../team'
 import { AGENT_NAV_ENTRIES } from '../../lib/agentWorkspaces'
 import { HOME_NAV_LABEL, MY_AGENTS_LABEL, ROUTES } from '../../lib/constants'
 import { DS_BRAND, DS_NEUTRAL, DS_SLATE, DS_TEXT } from '../../lib/ds'
 const ROLE_LABELS: Record<string, string> = {
  PROPERTY_MANAGER: 'Property Manager',
  DEMAND_USER: 'Demand User',
 }
 /**
 * Globale Navigation in der Kopfzeile (Runde 6, §11–§16).
 *
 * Sie ersetzt die entfernte Seitenleiste und das frühere Profilsymbol. Ein
 * einziges Menüsymbol neben der Glocke öffnet ein Klappmenü, das rechts an der
 * Kopfzeile ausgerichtet nach unten aufgeht.
 *
 * Aufbau: «Startseite», «Meine Agenten» mit allen Agenten als eingerückte,
 * rechts ausgerichtete Unterpunkte, und «Profil» mit denselben vier Aktionen,
 * die vorher im Profilmenü lagen.
 *
 * Die Agentenliste kommt aus `AGENT_NAV_ENTRIES` — derselben zentralen
 * Konfiguration, die auch der Meetingraum und die Seitenköpfe verwenden. Namen,
 * Funktionen und Ziele werden dadurch an genau einer Stelle gepflegt (§24,
 * Schritt 7).
 *
 * `Popover` statt `Menu`: Ein `Menu` erwartet gleichrangige `MenuItem`-Kinder
 * und übernimmt Tastaturnavigation über eine flache Liste. Hier gibt es zwei
 * Ebenen mit unterschiedlicher Ausrichtung — das Popover lässt diese Struktur
 * zu und bringt Klick-ausserhalb und Escape von sich aus mit.
 */
 export function GlobalNavMenu() {
  const [anchorEl, setAnchorEl] = useState<null | HTMLElement>(null)
  // Beim Öffnen festgehaltene Ankerstelle: oben unter der Kopfzeile, rechts
  // exakt an der Fensterkante.
  const [ankerStelle, setAnkerStelle] = useState({ top: 64, left: 0 })
  const { currentUser, logout } = useSessionStore()
  const navigate = useNavigate()
  const showToast = useToastStore(s => s.showToast)
  const open = !!anchorEl
  const close = () => setAnchorEl(null)
  /** Menüpunkt und Ziel gehören zusammen: erst schliessen, dann navigieren. */
  const go = (path: string) => {
    close()
    navigate(path)
  }
  const handleLogout = () => {
    close()
    logout()
    navigate('/auth/login')
  }
  return (
    <>
      <Tooltip title="Menü">
        <IconButton
          size="small"
          onClick={e => {
            if (open) { setAnchorEl(null); return }
            const b = e.currentTarget.getBoundingClientRect()
            setAnkerStelle({ top: b.bottom + 8, left: document.documentElement.clientWidth })
            setAnchorEl(e.currentTarget)
          }}
          aria-label="Menü öffnen"
          aria-haspopup="true"
          aria-expanded={open}
          sx={{ color: DS_TEXT.primary }}
        >
          <LayoutGrid size={20} />
        </IconButton>
      </Tooltip>
      <Popover
        open={open}
        anchorEl={anchorEl}
        onClose={close}
        /*
         * An eine Bildschirmstelle statt an das Symbol gebunden: das Symbol liegt
         * um den Innenabstand der Kopfzeile eingerückt, und ein daran
         * ausgerichtetes Menü erbte genau diesen Abstand als Spalt zur rechten
         * Fensterkante (§5.1). `marginThreshold={0}` hebt zusätzlich den
         * Sicherheitsabstand auf, den MUI sonst zum Fensterrand hält.
         * Gerechnet wird mit `clientWidth` statt `innerWidth`, also ohne den
         * Scrollbalken — sonst entstünde ein waagrechter Scrollbalken.
         */
        anchorReference="anchorPosition"
        anchorPosition={ankerStelle}
        transformOrigin={{ horizontal: 'right', vertical: 'top' }}
        marginThreshold={0}
        slotProps={{
          paper: {
            sx: {
              width: 320,
              borderRadius: 2,
              boxShadow: '0 18px 50px rgba(15,25,35,0.22)',
              overflow: 'hidden',
            },
          },
        }}
      >
        <MenuSection>
          <MainItem label={HOME_NAV_LABEL} onClick={() => go(ROUTES.SUPPLY.PROPERTIES)} />
        </MenuSection>
        <Divider />
        <MenuSection>
          <MainItem label={MY_AGENTS_LABEL} onClick={() => go(ROUTES.SUPPLY.TEAM)} />
          {/* Unterpunkte: kleiner, eingerückt und rechts ausgerichtet (§14). */}
          {AGENT_NAV_ENTRIES.map(agent => (
            <SubItem key={agent.id} onClick={() => go(agent.path)}>
              <Typography sx={{ fontSize: '0.8125rem', fontWeight: 500, color: DS_TEXT.primary }}>
                {agent.name}
              </Typography>
              <Typography sx={{ fontSize: '0.6875rem', color: DS_TEXT.secondary }}>
                {agent.role}
              </Typography>
              <AgentAvatar agent={agent} size={26} />
            </SubItem>
          ))}
        </MenuSection>
        <Divider />
        <MenuSection>
          <MainItem label="Profil" onClick={() => showProfileHint(showToast, close)} />
          {currentUser && (
            <Typography
              sx={{
                px: 2, pb: 0.75, textAlign: 'right',
                fontSize: '0.6875rem', color: DS_TEXT.muted,
              }}
            >
              {currentUser.name} · {ROLE_LABELS[currentUser.role] ?? currentUser.role}
              {currentUser.organizationName ? ` · ${currentUser.organizationName}` : ''}
            </Typography>
          )}
          <SubItem onClick={() => showProfileHint(showToast, close)}>
            <ProfileLabel icon={<User size={15} />} label="Profil" />
          </SubItem>
          <SubItem onClick={() => { close(); showToast('Einstellungen sind in Kürze verfügbar.', 'info') }}>
            <ProfileLabel icon={<Settings size={15} />} label="Einstellungen" />
          </SubItem>
          <SubItem
            onClick={() => {
              // Bestehende Logik: die Tour zeigt sich erneut, sobald die Merkung
              // entfernt ist. Nicht neu gebaut (§16).
              close()
              localStorage.removeItem('property_match_welcomed')
              window.location.reload()
            }}
          >
            <ProfileLabel icon={<HelpCircle size={15} />} label="Produkttour starten" />
          </SubItem>
          <SubItem onClick={handleLogout}>
            <ProfileLabel icon={<LogOut size={15} />} label="Abmelden" />
          </SubItem>
        </MenuSection>
      </Popover>
    </>
  )
 }
 function showProfileHint(showToast: (m: string, t: 'info') => void, close: () => void) {
  close()
  showToast('Profilseite ist in Kürze verfügbar.', 'info')
 }
 function MenuSection({ children }: { children: React.ReactNode }) {
  return <Box sx={{ py: 1 }}>{children}</Box>
 }
 /** Hauptpunkt: linksbündig, kräftig — er trägt die Hierarchie. */
 function MainItem({ label, onClick }: { label: string; onClick: () => void }) {
  return (
    <ButtonBase
      onClick={onClick}
      sx={{
        width: '100%',
        justifyContent: 'flex-start',
        px: 2, py: 1,
        '&:hover': { bgcolor: DS_SLATE[50] },
        '&.Mui-focusVisible': { bgcolor: DS_SLATE[100], outline: `2px solid ${DS_NEUTRAL.gold}`, outlineOffset: -2 },
      }}
    >
      <Typography sx={{ fontWeight: 700, fontSize: '0.9375rem', color: DS_BRAND.main }}>
        {label}
      </Typography>
    </ButtonBase>
  )
 }
 /**
 * Unterpunkt: kleiner, eingerückt und am rechten Rand ausgerichtet (§14/§16).
 * Die Rechtsausrichtung ist die Vorgabe — sie trennt die Ebenen auch ohne
 * Einrückungslinien sichtbar voneinander.
 */
 function SubItem({ children, onClick }: { children: React.ReactNode; onClick: () => void }) {
  return (
    <ButtonBase
      onClick={onClick}
      sx={{
        width: '100%',
        display: 'flex',
        alignItems: 'center',
        justifyContent: 'flex-end',
        gap: 1,
        pl: 4, pr: 2, py: 0.75,
        textAlign: 'right',
        '&:hover': { bgcolor: DS_SLATE[50] },
        '&.Mui-focusVisible': { bgcolor: DS_SLATE[100], outline: `2px solid ${DS_NEUTRAL.gold}`, outlineOffset: -2 },
      }}
    >
      {children}
    </ButtonBase>
  )
 }
 function ProfileLabel({ icon, label }: { icon: React.ReactNode; label: string }) {
  return (
    <>
      <Typography sx={{ fontSize: '0.8125rem', color: DS_TEXT.primary }}>{label}</Typography>
      <Box sx={{ display: 'flex', color: DS_TEXT.secondary }}>{icon}</Box>
    </>
  )
 }
@@ -1,103 +0,0 @@
 import { useState } from 'react'
 import { useNavigate } from 'react-router'
 import { Avatar, Box, Divider, IconButton, ListItemIcon, Menu, MenuItem, Typography } from '@mui/material'
 import { HelpCircle, LogOut, Settings, User } from 'lucide-react'
 import { useSessionStore } from '../../stores/sessionStore'
 import { useToastStore } from '../../stores/toastStore'
 import { DS_BRAND } from '../../lib/ds'
 const ROLE_LABELS: Record<string, string> = {
  PROPERTY_MANAGER: 'Property Manager',
  DEMAND_USER: 'Demand User',
 }
 function getUserInitials(name: string): string {
  return name
    .split(' ')
    .map((n) => n[0])
    .join('')
    .toUpperCase()
    .slice(0, 2)
 }
 export function UserMenu() {
  const [anchorEl, setAnchorEl] = useState<null | HTMLElement>(null)
  const { currentUser, logout } = useSessionStore()
  const navigate = useNavigate()
  const showToast = useToastStore((s) => s.showToast)
  function handleOpen(e: React.MouseEvent<HTMLElement>) {
    setAnchorEl(e.currentTarget)
  }
  function handleClose() {
    setAnchorEl(null)
  }
  function handleLogout() {
    handleClose()
    logout()
    navigate('/auth/login')
  }
  const initials = getUserInitials(currentUser?.name ?? 'U')
  return (
    <>
      <IconButton onClick={handleOpen} size="small" sx={{ p: 0 }}>
        <Avatar sx={{ width: 32, height: 32, fontSize: '0.75rem', bgcolor: DS_BRAND.main }}>
          {initials}
        </Avatar>
      </IconButton>
      <Menu
        anchorEl={anchorEl}
        open={!!anchorEl}
        onClose={handleClose}
        slotProps={{ paper: { sx: { width: 300, mt: 1 } } }}
        transformOrigin={{ horizontal: 'right', vertical: 'top' }}
        anchorOrigin={{ horizontal: 'right', vertical: 'bottom' }}
      >
        {/* User info header */}
        {currentUser && (
          <Box sx={{ px: 2, py: 1.5 }}>
            <Typography variant="body2" sx={{ fontWeight: 600 }}>{currentUser.name}</Typography>
            <Typography variant="caption" sx={{ color: 'text.secondary', display: 'block' }}>
              {ROLE_LABELS[currentUser.role] ?? currentUser.role}
            </Typography>
            <Typography variant="caption" sx={{ color: 'text.secondary', display: 'block' }}>
              {currentUser.organizationName}
            </Typography>
          </Box>
        )}
        <Divider />
        <MenuItem onClick={() => { handleClose(); showToast('Profilseite ist in Kürze verfügbar.', 'info') }}>
          <ListItemIcon><User size={16} /></ListItemIcon>
          Profil
        </MenuItem>
        <MenuItem onClick={() => { handleClose(); showToast('Einstellungen sind in Kürze verfügbar.', 'info') }}>
          <ListItemIcon><Settings size={16} /></ListItemIcon>
          Einstellungen
        </MenuItem>
        <MenuItem onClick={() => { handleClose(); localStorage.removeItem('property_match_welcomed'); window.location.reload() }}>
          <ListItemIcon><HelpCircle size={16} /></ListItemIcon>
          Produkttour starten
        </MenuItem>
        {/* Der Bereich «Demo-Modus» mit «Verwaltung» und «Bürosuche» ist entfernt
            (Runde 5, §8). Die Flächensuche existiert in diesem Stand nicht mehr;
            eine Umschaltung auf eine Rolle ohne erreichbare Seiten wäre eine
            Sackgasse im Profilmenü gewesen. */}
        <Divider />
        <MenuItem onClick={handleLogout}>
          <ListItemIcon><LogOut size={16} /></ListItemIcon>
          Abmelden
        </MenuItem>
      </Menu>
    </>
  )
 }
@@ -11,7 +11,7 @@ import { describe, it, expect } from 'vitest'
 import { WORKSPACE_CONFIG, getPageNameFromPath } from '../appShellConfig'
 import { WorkspaceType } from '../../../domain/enums'
 import { HOME_NAV_LABEL, MY_AGENTS_LABEL, ROUTES } from '../../../lib/constants'
-import { AGENT_WORKSPACES } from '../../../lib/agentWorkspaces'
+import { AGENT_NAV_ENTRIES } from '../../../lib/agentWorkspaces'
 const supplyNav = WORKSPACE_CONFIG[WorkspaceType.SUPPLY].navItems
@@ -47,9 +47,9 @@ describe('Navigationseintrag «Meine Agenten»', () => {
    expect(agenten?.path).toBe(ROUTES.SUPPLY.TEAM)
  })
-  it('trägt die fünf Agenten in verbindlicher Reihenfolge', () => {
+  it('trägt Thomas zuoberst und darunter die fünf in verbindlicher Reihenfolge', () => {
    const agenten = supplyNav.find(item => item.label === MY_AGENTS_LABEL)
-    expect(agenten?.children?.map(c => c.label)).toEqual(['Ferdi', 'Bruno', 'Livia', 'Nora', 'Sina'])
+    expect(agenten?.children?.map(c => c.label)).toEqual(['Thomas', 'Ferdi', 'Bruno', 'Livia', 'Nora', 'Sina'])
  })
  it('gibt jedem Agenten Porträt-ID und Funktionsbezeichnung mit', () => {
@@ -63,7 +63,7 @@ describe('Navigationseintrag «Meine Agenten»', () => {
  it('verweist mit jedem Agenten auf eine eigene Seite', () => {
    const agenten = supplyNav.find(item => item.label === MY_AGENTS_LABEL)
    const paths = agenten?.children?.map(c => c.path) ?? []
-    expect(paths).toEqual(AGENT_WORKSPACES.map(a => a.path))
+    expect(paths).toEqual(AGENT_NAV_ENTRIES.map(a => a.path))
    expect(new Set(paths).size).toBe(paths.length)
  })
@@ -1,6 +1,6 @@
 import { WorkspaceType } from '../../domain/enums'
 import { HOME_NAV_LABEL, MY_AGENTS_LABEL, ROUTES } from '../../lib/constants'
-import { AGENT_WORKSPACES } from '../../lib/agentWorkspaces'
+import { AGENT_NAV_ENTRIES } from '../../lib/agentWorkspaces'
 import type { LucideIcon } from 'lucide-react'
 import {
  Building2,
@@ -75,7 +75,7 @@ export const WORKSPACE_CONFIG: Record<WorkspaceType, WorkspaceConfig> = {
        icon: Users,
        // Die drei Verwaltungsbereiche sind Reiter der Hauptseite geworden;
        // hier stehen ab Runde 4 die fünf digitalen Mitarbeitenden selbst.
-        children: AGENT_WORKSPACES.map(a => ({
+        children: AGENT_NAV_ENTRIES.map(a => ({
          path: a.path,
          label: a.name,
          agentId: a.id,
@@ -2,6 +2,6 @@ export { AppShell } from './AppShell'
 export { PageHeader } from './PageHeader'
 export { RightContextPanel } from './RightContextPanel'
 export { CompareTray } from './CompareTray'
-export { UserMenu } from './UserMenu'
+export { GlobalNavMenu } from './GlobalNavMenu'
 export { NotificationButton } from './NotificationButton'
 export { OrganizationContextBadge } from './OrganizationContextBadge'
@@ -1,47 +1,89 @@
-import { useCallback, useMemo, useState } from 'react'
+import { useMemo } from 'react'
 import type { ReactNode } from 'react'
 import { Alert, Box, Button, Chip, Divider, Typography } from '@mui/material'
-import { CheckCircle2, ExternalLink, Forward, MapPin, Ruler } from 'lucide-react'
+import { CheckCircle2, ExternalLink, MapPin, Ruler, Target } from 'lucide-react'
 import type { MarketLead } from '../../hooks/useMarketLeads'
-import { useCreateExposeLead } from '../../hooks/useExposeLeads'
+import { AgentAvatar, ObjectDeepLink } from '../team'
 import { useToastStore } from '../../stores/toastStore'
 import { AgentAvatar } from '../team'
 import { agentWorkspaceById } from '../../lib/agentWorkspaces'
-import { SOURCE_TYPE_LABELS } from '../../lib/constants'
+import { SOURCE_TYPE_LABELS, TEMPORAL_CLASS_LABELS } from '../../lib/constants'
 import { isRisiko, leadSignalTypeOf, signalRationaleOf } from '../../lib/leadSignal'
 import { MIN_MATCH_PCT, areaFitPct, confirmableContacts } from './marketLeadHelpers'
 import { LeadSignalTypeBadge } from './LeadSignalTypeBadge'
 import { AiDisclaimer } from '../ui'
 import { ContactRow, SignalPropertyRow } from './MarketLeadPanels'
-import { DS_BRAND, DS_SLATE, DS_TEXT } from '../../lib/ds'
+import { DS_BRAND, DS_COLORS, DS_SLATE, DS_TEXT } from '../../lib/ds'
-const NORA = agentWorkspaceById('nora')!
+const LIVIA = agentWorkspaceById('livia')!
 /**
- * Detailansicht eines erkannten Nachfragesignals.
+ * Detailansicht eines Recherche-Leads.
 *
- * Eigene Datei — die Liste links und das Detail rechts teilen sich nur die
+ * Seit Runde 8 (§1–§2) trägt sie die Arbeitsteilung sichtbar: der obere Teil —
- * Hilfsfunktionen, nicht den Aufbau.
+ * Recherche, Begründung, Quellen — stammt von Livia, der Matching-Teil unten
 * ist Noras Arbeit. Auf Livias eigenem Arbeitsplatz wird derselbe Baustein mit
 * `showMatching={false}` gerendert; damit ist ausgeschlossen, dass die
 * Matching-Darstellung versehentlich zu ihr wandert.
 */
 // ── Right pane detail ────────────────────────────────────────────────────────
 // `MIN_MATCH_PCT` und `confirmableContacts` liegen in `marketLeadHelpers.tsx`.
 interface LeadDetailProps {
  lead: MarketLead
  /**
   * Ganze Seite statt Schublade (Runde 10, §3.2).
   *
   * Nur ein Layoutschalter, keine zweite Ansicht: Dieselben Bausteine in
   * derselben Reihenfolge, nur ohne eigenen Bildlauf und mit mehr Platz.
   * Eine Vollbildfassung daneben zu bauen hiesse, jede künftige Änderung
   * zweimal zu machen.
   */
  fullPage?: boolean
  /** Was unterhalb der Leadangaben erscheint — bei Nora der Property-Match-Bereich. */
  footer?: ReactNode
  /** Matching-Block anzeigen. Bei Nora ja, bei Livia nein (§1). */
  showMatching?: boolean
  /**
   * Übergabe an Nora (Runde 10, §2.14). Nur gesetzt, wo der Knopf hingehört —
   * auf Noras eigener Seite wäre «Matching starten» hier ein zweiter Weg zu
   * derselben Handlung, die dort schon im Kopf des Matching-Bereichs steht.
   */
  onStartMatching?: (signalId: string) => void
 }
 /**
 * Wrapper, der die Detailansicht über die Signal-ID neu aufbaut.
 *
- * Damit ist die Objektauswahl an das Signal gebunden, ohne sie in einem Effekt
+ * Ein neues Signal ist damit eine neue Komponente und startet mit frischem
- * zurücksetzen zu müssen — ein neues Signal ist eine neue Komponente, und die
+ * Zustand, statt ihn in einem Effekt zurücksetzen zu müssen.
 * startet ohnehin ohne Auswahl.
 */
-function LeadDetail({ lead }: { lead: MarketLead }) {
+function LeadDetail({ lead, showMatching = true, onStartMatching, fullPage = false, footer }: LeadDetailProps) {
-  return <LeadDetailBody key={lead.signal.id} lead={lead} />
+  return (
    <LeadDetailBody
      key={lead.signal.id}
      lead={lead}
      showMatching={showMatching}
      onStartMatching={onStartMatching}
      fullPage={fullPage}
      footer={footer}
    />
  )
 }
-function LeadDetailBody({ lead }: { lead: MarketLead }) {
+function LeadDetailBody({ lead, showMatching, onStartMatching, fullPage, footer }: {
  lead: MarketLead
  showMatching: boolean
  onStartMatching?: (signalId: string) => void
  fullPage: boolean
  footer?: ReactNode
 }) {
  const { signal, matchingProperties } = lead
  const sourceLabel = SOURCE_TYPE_LABELS[signal.source.type] ?? signal.source.type
  const companyName = signal.companyName ?? signal.locationHint
-  const forwardLead = useCreateExposeLead()
+  const signalType = leadSignalTypeOf(signal)
-  const showToast = useToastStore(s => s.showToast)
+  const risiko = isRisiko(signal)
-  const [selectedIds, setSelectedIds] = useState<string[]>([])
+  const rationale = signalRationaleOf(signal)
  // Objektvorschläge unterhalb der Schwelle werden gar nicht erst gezeigt.
  const relevant = useMemo(
@@ -54,33 +96,18 @@ function LeadDetailBody({ lead }: { lead: MarketLead }) {
  const contacts = useMemo(() => confirmableContacts(signal.extractedContacts), [signal.extractedContacts])
-  const toggle = useCallback((id: string) => {
+  // Einzige Wahrheit ist `semanticSearchProfile`; die beiden anderen sind der
-    setSelectedIds(prev => prev.includes(id) ? prev.filter(x => x !== id) : [...prev, id])
+  // Rückfall für Leads, die vor Runde 10 erfasst wurden.
-  }, [])
+  const profilText = signal.semanticSearchProfile ?? signal.aiSummary ?? signal.strategicInterpretation
  function handleForward() {
    const count = selectedIds.length
    forwardLead.mutate(
      {
        prospect: companyName,
        contacts: contacts.map(c => c.value),
        locationHint: signal.locationHint,
        propertyIds: selectedIds,
        sourceSignalId: signal.id,
      },
      {
        onSuccess: () => {
          setSelectedIds([])
          showToast(`An Livia weitergeleitet — ${count} Objekt(e) für ${companyName}.`, 'success')
        },
      },
    )
  }
  return (
-    <Box sx={{ height: '100%', overflowY: 'auto' }}>
+    // Auf der Seite scrollt die Seite, in der Schublade die Schublade.
    <Box sx={fullPage ? { width: '100%' } : { height: '100%', overflowY: 'auto' }}>
      {/* Header — ohne Wahrscheinlichkeitsangabe (§7.3) */}
      <Box sx={{ p: 3, borderBottom: '1px solid #e2e8f0' }}>
        <Box sx={{ display: 'flex', alignItems: 'center', gap: 1, mb: 0.75 }}>
          <LeadSignalTypeBadge type={signalType} />
        </Box>
        <Typography variant="h6" sx={{ fontWeight: 700, lineHeight: 1.3, mb: 0.5 }}>
          {companyName}
        </Typography>
@@ -118,22 +145,117 @@ function LeadDetailBody({ lead }: { lead: MarketLead }) {
      </Box>
      <Box sx={{ p: 3, display: 'flex', flexDirection: 'column', gap: 2.5 }}>
-        {/* «Das meint Nora» — das Analyse-Kästchen bleibt, es trägt jetzt aber
+        {/*
-            ihr Gesicht statt eines generischen KI-Symbols (§7.3). */}
+          Das erstellte Suchprofil (Runde 10, §§2.13B/3.1).
-        {(signal.aiSummary ?? signal.strategicInterpretation) && (
+
          Ein Kasten, nicht zwei: Bis Runde 9 hiess er «Das hat Livia
          recherchiert» und trug ihre Zusammenfassung; seit Runde 10 steht
          darin das Nachfrageprofil, mit dem Nora arbeitet. Beides
          nebeneinander zu zeigen wären zwei Texte über denselben Bedarf, und
          beim ersten Widerspruch wüsste niemand, welcher gilt.
          Der Rückfall auf `aiSummary` ist die Migration für Bestandsleads:
          Sie haben kein Profil, aber den Text, der bisher an dieser Stelle
          stand — er bleibt sichtbar, statt ein leeres Feld zu hinterlassen.
        */}
        {profilText && (
          <Box sx={{ bgcolor: DS_SLATE[50], border: '1px solid #e2e8f0', borderRadius: 1.5, p: 2 }}>
            <Box sx={{ display: 'flex', alignItems: 'center', gap: 1, mb: 1 }}>
-              <AgentAvatar agent={{ id: NORA.id, name: NORA.name, role: NORA.role }} size="small" />
+              <AgentAvatar agent={{ id: LIVIA.id, name: LIVIA.name, role: LIVIA.role }} size="small" />
              <Typography variant="caption" sx={{ fontWeight: 700, color: DS_TEXT.primary, fontSize: '0.75rem' }}>
-                Das meint Nora
+                Erstelltes Suchprofil
              </Typography>
            </Box>
-            <Typography variant="body2" sx={{ color: DS_SLATE[800], lineHeight: 1.6 }}>
+            <Typography variant="body2" sx={{ color: DS_SLATE[800], lineHeight: 1.6, whiteSpace: 'pre-line' }}>
-              {signal.aiSummary ?? signal.strategicInterpretation}
+              {profilText}
            </Typography>
            {/*
              «Matching starten» übergibt denselben Lead an Nora — über die
              Lead-ID, nicht über eine Kopie. Das Kennzeichen im Zustand sagt
              Nora, dass der Lauf sofort starten darf; wer den Lead später
              normal öffnet, löst nichts von selbst aus (§2.14).
            */}
            {onStartMatching && !risiko && (
              <Button
                variant="contained"
                size="small"
                startIcon={<Target size={14} aria-hidden />}
                onClick={() => onStartMatching(signal.id)}
                sx={{ textTransform: 'none', fontWeight: 600, mt: 1.5 }}
              >
                Matching starten
              </Button>
            )}
          </Box>
        )}
        {/* Warum Chance beziehungsweise Risiko (§2) */}
        <Box>
          <Typography variant="caption" sx={{ fontWeight: 700, color: DS_SLATE[500], textTransform: 'uppercase', letterSpacing: 0.5, display: 'block', mb: 0.75, fontSize: '0.65rem' }}>
            Warum {risiko ? 'Risiko' : 'Chance'}
          </Typography>
          <Typography variant="body2" sx={{ color: DS_SLATE[800], lineHeight: 1.6 }}>
            {rationale}
          </Typography>
        </Box>
        {/*
          Bei Risiko: das betroffene Mietverhältnis benennen (§2, Runde 10 §2.13A).
          Seit Runde 10 steht der Kasten auch dann, wenn nichts zuordenbar ist —
          mit genau diesem Satz. Ein fehlender Kasten liesse offen, ob niemand
          nachgesehen hat oder ob nichts betroffen ist; eine beliebige
          Mock-Immobilie zu zeigen wäre die schlechtere Antwort von beiden.
        */}
        {risiko && (
          <Box sx={{ border: '1px solid', borderColor: DS_COLORS.leadSignal.RISIKO.fg, bgcolor: DS_COLORS.leadSignal.RISIKO.bg, borderRadius: 1.5, p: 2 }}>
            <Typography variant="caption" sx={{ fontWeight: 700, color: DS_COLORS.leadSignal.RISIKO.fg, textTransform: 'uppercase', letterSpacing: 0.5, display: 'block', mb: 0.75, fontSize: '0.65rem' }}>
              Betroffenes Objekt
            </Typography>
            {signal.affectedTenant && (
              <Typography variant="body2" sx={{ fontWeight: 600, color: DS_SLATE[900], mb: 0.25 }}>
                {signal.affectedTenant}
              </Typography>
            )}
            {signal.propertyId ? (
              <ObjectDeepLink propertyId={signal.propertyId} label="Objekt in «Meine Objekte» öffnen" />
            ) : (
              !signal.affectedTenant && (
                <Typography variant="body2" sx={{ color: DS_SLATE[800] }}>
                  Kein internes Objekt eindeutig zugeordnet.
                </Typography>
              )
            )}
          </Box>
        )}
        {/* Zeitliche Einordnung mit Fundstelle (Runde 10, §2.9) */}
        {signal.temporalClass && (
          <Box>
            <Typography variant="caption" sx={{ fontWeight: 700, color: DS_SLATE[500], textTransform: 'uppercase', letterSpacing: 0.5, display: 'block', mb: 0.75, fontSize: '0.65rem' }}>
              Zeitliche Relevanz
            </Typography>
            <Box sx={{ display: 'flex', alignItems: 'baseline', gap: 1, flexWrap: 'wrap' }}>
              <Chip
                label={TEMPORAL_CLASS_LABELS[signal.temporalClass]}
                size="small"
                sx={{ bgcolor: DS_SLATE[100], color: DS_SLATE[700], fontSize: '0.75rem', fontWeight: 600 }}
              />
              {signal.eventDate && (
                <Typography variant="caption" sx={{ color: DS_SLATE[600] }}>
                  Ereigniszeit laut Quelle: {signal.eventDate}
                </Typography>
              )}
            </Box>
            {signal.temporalEvidence && (
              <Typography variant="body2" sx={{ color: DS_SLATE[800], lineHeight: 1.6, mt: 0.75 }}>
                {signal.temporalEvidence}
              </Typography>
            )}
          </Box>
        )}
        {/* Bestätigte Angaben — unbestätigte Fakten werden weggelassen (§7.3) */}
        {(signal.confirmedFacts?.length ?? 0) > 0 && (
          <Box>
@@ -151,6 +273,36 @@ function LeadDetailBody({ lead }: { lead: MarketLead }) {
          </Box>
        )}
        {/* Weitere Quellen, aus denen Livia verdichtet hat (§1) */}
        {(signal.researchSources?.length ?? 0) > 0 && (
          <Box>
            <Typography variant="caption" sx={{ fontWeight: 700, color: DS_SLATE[500], textTransform: 'uppercase', letterSpacing: 0.5, display: 'block', mb: 0.75, fontSize: '0.65rem' }}>
              Weitere Quellen
            </Typography>
            <Box sx={{ display: 'flex', flexDirection: 'column', gap: 0.5 }}>
              {signal.researchSources!.map((s, i) => (
                <Box key={i} sx={{ display: 'flex', alignItems: 'center', gap: 0.75, flexWrap: 'wrap' }}>
                  <Typography variant="caption" sx={{ color: DS_SLATE[800] }}>
                    {SOURCE_TYPE_LABELS[s.type] ?? s.type}
                    {s.publishedAt && ` · ${new Date(s.publishedAt).toLocaleDateString('de-CH')}`}
                  </Typography>
                  {s.url && (
                    <Box
                      component="a"
                      href={s.url}
                      target="_blank"
                      rel="noopener noreferrer"
                      sx={{ display: 'flex', alignItems: 'center', gap: 0.4, color: DS_BRAND.main, fontSize: '0.75rem', fontWeight: 600, textDecoration: 'none', '&:hover': { textDecoration: 'underline' } }}
                    >
                      öffnen <ExternalLink size={10} />
                    </Box>
                  )}
                </Box>
              ))}
            </Box>
          </Box>
        )}
        <Divider />
        {/* Extrahierte Kontaktdaten */}
@@ -169,47 +321,39 @@ function LeadDetailBody({ lead }: { lead: MarketLead }) {
          )}
        </Box>
-        <Divider />
+        {/* Matching bleibt Noras Arbeit — auf Livias Seite ausgeblendet (§1). */}
-
+        {showMatching && (
-        {/* Passende Objekte im Portfolio */}
+          <>
-        <Box>
+            <Divider />
-          <Typography variant="caption" sx={{ fontWeight: 700, color: DS_SLATE[500], textTransform: 'uppercase', letterSpacing: 0.5, display: 'block', mb: 1 }}>
+            <Box>
-            Passende Objekte im Portfolio ({relevant.length})
+              <Typography variant="caption" sx={{ fontWeight: 700, color: DS_SLATE[500], textTransform: 'uppercase', letterSpacing: 0.5, display: 'block', mb: 1 }}>
-          </Typography>
+                {risiko
-          {relevant.length === 0 ? (
+                  ? `Objekte für internes Re-Letting (${relevant.length})`
-            <Alert severity="warning" sx={{ fontSize: '0.8rem', py: 0.5 }}>
+                  : `Passende Objekte im Portfolio (${relevant.length})`}
-              Kein Portfolioobjekt über {MIN_MATCH_PCT}% Flächenmatch — manuelle Prüfung empfohlen
+              </Typography>
-            </Alert>
+              {relevant.length === 0 ? (
-          ) : (
+                <Alert severity="warning" sx={{ fontSize: '0.8rem', py: 0.5 }}>
-            <>
+                  Kein Portfolioobjekt über {MIN_MATCH_PCT}% Flächenmatch — manuelle Prüfung empfohlen
-              {relevant.map(({ p, fit }) => (
+                </Alert>
-                <SignalPropertyRow
+              ) : (
-                  key={p.id}
+                relevant.map(({ p, fit }) => (
-                  p={p}
+                  <SignalPropertyRow key={p.id} p={p} fit={fit} />
-                  fit={fit}
+                ))
-                  selected={selectedIds.includes(p.id)}
+              )}
-                  onToggle={() => toggle(p.id)}
+            </Box>
-                />
+          </>
              ))}
              <Button
                variant="contained"
                startIcon={<Forward size={15} />}
                disabled={selectedIds.length === 0 || forwardLead.isPending}
                onClick={handleForward}
                sx={{ mt: 1, textTransform: 'none', bgcolor: DS_BRAND.main, '&:hover': { bgcolor: DS_BRAND.hoverAlt } }}
              >
                An Livia zur Exposé-Erstellung weiterleiten
                {selectedIds.length > 0 && ` (${selectedIds.length})`}
              </Button>
            </>
          )}
        </Box>
        {signal.disclaimer && (
          <Typography variant="caption" color="text.disabled" sx={{ lineHeight: 1.4 }}>
            {signal.disclaimer}
          </Typography>
        )}
        {/*
          An dieser Stelle stand bis Runde 9 der Quellen-Vermerk des Signals
          («Aus öffentlichen Meldungen verdichtet …»). Er ist dem einheitlichen
          KI-Hinweis gewichen: Die Herkunft steht ohnehin oben bei der Quelle,
          und ein Satz je Signal war nie derselbe — der Hinweis auf mögliche
          Fehler soll aber überall gleich lauten (§4, §5).
        */}
        <AiDisclaimer />
        {footer}
      </Box>
    </Box>
  )
@@ -0,0 +1,45 @@
 import { memo } from 'react'
 import { Chip } from '@mui/material'
 import { TrendingDown, TrendingUp } from 'lucide-react'
 import type { LeadSignalType } from '../../domain/futureSignal'
 import { LEAD_SIGNAL_TYPE_LABELS } from '../../lib/constants'
 import { DS_COLORS } from '../../lib/ds'
 /**
 * Kennzeichen «Chance» oder «Risiko» eines Recherche-Leads (Runde 8, §2).
 *
 * Eine Komponente für Liste und Detailansicht — derselbe Signaltyp darf an
 * zwei Stellen nicht zwei Farben haben. Beschriftung aus `constants.ts`,
 * Farben aus `DS_COLORS.leadSignal` (CLAUDE.md §8).
 *
 * Mit Pfeilsymbol, nicht nur mit Farbe: Rot und Grün allein unterscheiden zu
 * wenig, wenn jemand sie nicht auseinanderhalten kann.
 */
 export const LeadSignalTypeBadge = memo(function LeadSignalTypeBadge({
  type,
 }: {
  type: LeadSignalType
 }) {
  const meta = DS_COLORS.leadSignal[type]
  const Icon = type === 'RISIKO' ? TrendingDown : TrendingUp
  return (
    <Chip
      icon={<Icon size={11} />}
      label={LEAD_SIGNAL_TYPE_LABELS[type] ?? type}
      size="small"
      sx={{
        height: 20,
        fontSize: '0.68rem',
        fontWeight: 700,
        letterSpacing: 0.2,
        color: meta.fg,
        bgcolor: meta.bg,
        border: '1px solid',
        borderColor: meta.fg,
        '& .MuiChip-label': { px: 0.75 },
        '& .MuiChip-icon': { color: meta.fg, ml: 0.5, mr: -0.25 },
      }}
    />
  )
 })
@@ -1,4 +1,4 @@
-import { Box, Checkbox, Chip, Typography } from '@mui/material'
+import { Box, Chip, Typography } from '@mui/material'
 import { Building2, ExternalLink } from 'lucide-react'
 import type { Property } from '../../domain/property'
 import type { ExtractedContact } from '../../domain/futureSignal'
@@ -59,41 +59,36 @@ function ContactRow({ contact }: { contact: ExtractedContact }) {
  )
 }
-// ── Objektzeile mit Mehrfachauswahl ──────────────────────────────────────────
+// ── Objektzeile ──────────────────────────────────────────────────────────────
 /**
 * Ein passendes Portfolioobjekt zu einem Signal.
 *
- * Der Anschreiben-Entwurf und die Reminder-Aktion sind entfallen (Runde 4, §7.3):
+ * Der Anschreiben-Entwurf und die Reminder-Aktion sind mit Runde 4 entfallen
- * Nora erkennt die Nachfrage, das Dokument macht Livia. Geblieben ist die
+ * (§7.3), die Mehrfachauswahl mit Runde 8: sie diente allein dazu, Objekte an
- * Auswahl — mehrere Objekte lassen sich gemeinsam für dasselbe Signal
+ * die Exposé-Erstellung weiterzureichen, und diese Funktion gibt es bei Livia
- * weiterreichen, statt für jedes einzeln denselben Weg zu gehen.
+ * nicht mehr. Eine Auswahl ohne Ziel wäre ein Bedienelement, das nichts
 * auslöst — schlimmer als keines.
 *
 * Geblieben ist, was Nora für die Entscheidung braucht: welches Objekt, wo,
 * wie gross, zu welchem Preis und wie gut die Fläche passt.
 */
 function SignalPropertyRow({
-  p, fit, selected, onToggle,
+  p, fit,
 }: {
  p: Property
  fit: number | null
  selected: boolean
  onToggle: () => void
 }) {
  return (
    <Box
      sx={{
        display: 'flex', alignItems: 'center', gap: 1,
        px: 1.5, py: 1.25, mb: 1,
-        border: `1px solid ${selected ? '#152642' : '#e2e8f0'}`,
+        border: '1px solid #e2e8f0',
        borderRadius: 1.5,
-        bgcolor: selected ? '#f8fafc' : 'white',
+        bgcolor: 'white',
      }}
    >
      <Checkbox
        size="small"
        checked={selected}
        onChange={onToggle}
        slotProps={{ input: { 'aria-label': `${p.title} auswählen` } }}
        sx={{ p: 0.5 }}
      />
      <Building2 size={14} color="#152642" style={{ flexShrink: 0 }} />
      <Box sx={{ flex: 1, minWidth: 0 }}>
        <ObjectDeepLink propertyId={p.id} label={p.title} fontWeight={600} />
@@ -0,0 +1,340 @@
 /**
 * Property On — Noras Property-Match-Bereich (Runde 10, §§3.3–3.8).
 *
 * Sitzt unterhalb der Leadangaben auf der Detailseite und beantwortet genau
 * eine Frage: Welche Objekte aus dem eigenen Bestand passen zu diesem Bedarf?
 *
 * Drei Entscheidungen, die hier sichtbar werden:
 *
 * 1. **Vorher steht nichts da.** Kein vorab gerechneter Vorschlag, kein
 *    Beispielergebnis. Ein Matching ist eine Handlung, und was ohne Handlung
 *    erscheint, hätte niemand veranlasst.
 * 2. **Die Liste ist dieselbe wie «Meine Objekte».** Dieselbe Tabelle,
 *    dieselben Filter, dieselben Spalten — ergänzt um eine erste Spalte
 *    «Match». Eine eigene Trefferliste zu bauen hiesse, denselben Bestand
 *    zweimal unterschiedlich darzustellen.
 * 3. **Belegte Objekte bleiben aussen vor, bis jemand sie will.** Der Schalter
 *    dient der Frage, ob für eine vermietete Fläche konkurrierende Nachfrage
 *    besteht — eine Information, kein Vorgang.
 */
 import { memo, useCallback, useEffect, useMemo, useRef, useState } from 'react'
 import {
  Alert, Box, Button, CircularProgress, Drawer, FormControlLabel, IconButton,
  Popover, Switch, Typography, useMediaQuery, useTheme,
 } from '@mui/material'
 import { Info, Target } from 'lucide-react'
 import { PropertyFilterBar } from '../supply/PropertyFilterBar'
 import type { PropertyTableFilters } from '../supply/PropertyFilterBar'
 import { PropertyTable } from '../supply/PropertyTable'
 import { PropertyDetailView } from '../supply/PropertyDetailView'
 import { ObjectDeepLink } from '../team'
 import { useProperties } from '../../hooks/useProperties'
 import { useRunMatching } from '../../hooks/useMatchRuns'
 import type { MatchLaufErgebnis } from '../../features/matching/leadPropertyMatcher'
 import type { FutureSignal } from '../../domain/futureSignal'
 import type { Property } from '../../domain/property'
 import { isRisiko } from '../../lib/leadSignal'
 import { DS_BORDER, DS_SHADOW, DS_TEXT } from '../../lib/ds'
 const FOCUS_SX = { '&:focus-visible': { outline: `2px solid ${DS_TEXT.brand}`, outlineOffset: 2 } }
 /**
 * Der Erklärtext zum Match-Wert (§3.8).
 *
 * Er beschreibt, was `leadPropertyMatcher.ts` tatsächlich tut. Der letzte Satz
 * ist der wichtigste: Es gibt keine feste Prozentgewichtung, weil nur die
 * Kriterien gerechnet werden, die sich am jeweiligen Objekt prüfen liessen.
 */
 const MATCH_INFO =
  'Der Match-Wert zeigt, wie gut das von Livia erstellte Nachfrageprofil mit den verfügbaren Informationen '
  + 'eines Objekts übereinstimmt. Aus dem Suchprofil werden die Anforderungen gelesen, die darin tatsächlich '
  + 'vorkommen — Standort, Fläche, Nutzungsart und, wo das Profil sie nennt, Erreichbarkeit, Parkierung, '
  + 'Ausbaustand und Sichtbarkeit. Dazu kommt immer die Verfügbarkeit. '
  + 'Fehlende Angaben werden nicht als erfüllt angenommen: Sagt der Bestand zu einem Merkmal nichts, zählt es '
  + 'nicht als Nichterfüllung, senkt aber die Abdeckung — und je weniger geprüft werden konnte, desto stärker '
  + 'wird der Wert gedämpft. Ein Objekt, von dem nur die Verfügbarkeit bekannt ist, erreicht deshalb keine hohen Werte. '
  + 'Belegte Objekte sind ausgeschlossen, solange sie nicht ausdrücklich einbezogen werden. '
  + 'Es gibt keine feste Prozentgewichtung je Kriterium, weil je Objekt unterschiedlich viel prüfbar ist.'
 function MatchInfoButton() {
  const [anker, setAnker] = useState<HTMLElement | null>(null)
  return (
    <>
      <IconButton
        size="small"
        aria-label="Wie entsteht der Match-Wert?"
        onClick={(e) => setAnker(e.currentTarget)}
        sx={{ color: DS_TEXT.muted, ...FOCUS_SX }}
      >
        <Info size={15} />
      </IconButton>
      <Popover
        open={anker !== null}
        anchorEl={anker}
        onClose={() => setAnker(null)}
        anchorOrigin={{ vertical: 'bottom', horizontal: 'left' }}
        slotProps={{ paper: { sx: { maxWidth: 520, p: 2, boxShadow: DS_SHADOW.panel } } }}
      >
        <Typography variant="body2" sx={{ color: DS_TEXT.primary, lineHeight: 1.55 }}>
          {MATCH_INFO}
        </Typography>
      </Popover>
    </>
  )
 }
 interface Props {
  signal: FutureSignal
  /**
   * Aus Livias «Matching starten» gekommen (§3.3). Dann läuft das Matching
   * genau einmal von selbst — beim normalen Öffnen nie.
   */
  autoStart: boolean
 }
 export const PropertyMatchSection = memo(function PropertyMatchSection({ signal, autoStart }: Props) {
  const theme = useTheme()
  const isMobile = useMediaQuery(theme.breakpoints.down('md'))
  const { data: properties = [], isLoading } = useProperties()
  const runMatching = useRunMatching()
  const [ergebnis, setErgebnis] = useState<MatchLaufErgebnis | null>(null)
  const [includeOccupied, setIncludeOccupied] = useState(false)
  const [filters, setFilters] = useState<PropertyTableFilters>({})
  const [selectedId, setSelectedId] = useState<string | null>(null)
  /**
   * Sperre gegen einen zweiten selbsttätigen Lauf.
   *
   * React baut Komponenten im Entwicklungsmodus doppelt auf, und jeder
   * Filterwechsel rendert neu. Ohne diese Sperre stünden im Protokoll zwei
   * Einträge für eine Übergabe — und die Kennzahl zählte doppelt (§3.13).
   */
  const autoGelaufen = useRef(false)
  const starten = useCallback(
    (belegteMit: boolean, trigger: 'USER' | 'LIVIA_HANDOVER') => {
      runMatching.mutate(
        { signal, properties, options: { includeOccupied: belegteMit }, trigger },
        { onSuccess: (res) => setErgebnis(res.data.ergebnis) },
      )
    },
    [runMatching, signal, properties],
  )
  useEffect(() => {
    if (!autoStart || autoGelaufen.current || isLoading || properties.length === 0) return
    autoGelaufen.current = true
    starten(false, 'LIVIA_HANDOVER')
  }, [autoStart, isLoading, properties.length, starten])
  /** Umschalten rechnet neu — die Frage hat sich geändert, also auch die Antwort. */
  const handleToggleOccupied = useCallback(
    (checked: boolean) => {
      setIncludeOccupied(checked)
      if (ergebnis) starten(checked, 'USER')
    },
    [ergebnis, starten],
  )
  /** Match-Werte je Objekt — die Tabelle braucht sie als Karte. */
  const scores = useMemo(() => {
    if (!ergebnis) return undefined
    return new Map(ergebnis.matches.map(m => [m.property.id, m.score]))
  }, [ergebnis])
  /**
   * Auswählbare Orte, aus den Ergebnissen abgeleitet (Runde 11, §2).
   *
   * Keine feste Ortsliste: Was der Lauf nicht gefunden hat, soll auch nicht
   * auswählbar sein — ein Filter, der auf nichts zeigt, ist irreführend.
   */
  const staedte = useMemo(() => {
    if (!ergebnis) return []
    const gesehen = new Set<string>()
    for (const m of ergebnis.matches) {
      const ort = m.property.location.city?.trim()
      if (ort) gesehen.add(ort)
    }
    return [...gesehen].sort((a, b) => a.localeCompare(b, 'de-CH'))
  }, [ergebnis])
  /**
   * Die Trefferliste — nach Match absteigend, solange nichts anderes gewählt ist.
   *
   * Filterleiste und Spaltenköpfe wirken wie in «Meine Objekte»: Sie ordnen
   * und schränken die Anzeige ein, ohne den Lauf zu verändern. Wer umsortiert,
   * sieht dieselben Objekte in anderer Reihenfolge, nicht andere Werte.
   *
   * Die Sortierung muss hier passieren und nicht in der Tabelle: Die Tabelle
   * bekommt ihre Zeilen fertig geordnet und hat auch in «Meine Objekte» nie
   * selbst sortiert. Ohne diesen Block wären die Spaltenköpfe anklickbar und
   * ohne Wirkung — schlimmer als gar keine Sortierung.
   */
  const sichtbar = useMemo((): Property[] => {
    if (!ergebnis) return []
    const suche = filters.search?.trim().toLowerCase()
    const gefiltert = ergebnis.matches
      .map(m => m.property)
      .filter(p => {
        if (filters.assetTypes?.length && !filters.assetTypes.includes(p.assetType)) return false
        if (filters.availabilityStatus && p.availabilityStatus !== filters.availabilityStatus) return false
        // Gefiltert wird auf dem bereits berechneten Wert — er wird hier weder
        // neu gerechnet noch verändert (§2).
        if (filters.minMatch !== undefined && (scores?.get(p.id) ?? 0) < filters.minMatch) return false
        if (filters.city && p.location.city !== filters.city) return false
        if (suche) {
          const heuhaufen = `${p.title} ${p.location.city} ${p.address.street} ${p.currentTenant ?? ''}`.toLowerCase()
          if (!heuhaufen.includes(suche)) return false
        }
        return true
      })
    if (!filters.sortBy) return gefiltert
    const wertVon = (p: Property): number => {
      switch (filters.sortBy) {
        case 'area': return p.areaSqm
        case 'rent': return p.rentPricePerSqm
        case 'dataQuality': return p.dataQuality.score
        case 'confidence': return p.confidenceScore
        case 'availability': return new Date(p.availabilityDate).getTime()
        default: return 0
      }
    }
    const richtung = filters.sortDir === 'asc' ? 1 : -1
    return [...gefiltert].sort((a, b) => (wertVon(a) - wertVon(b)) * richtung)
  }, [ergebnis, filters, scores])
  const risiko = isRisiko(signal)
  return (
    <Box sx={{ borderTop: `1px solid ${DS_BORDER.default}`, pt: 3, mt: 1 }}>
      <Box sx={{ display: 'flex', alignItems: 'center', gap: 1, flexWrap: 'wrap', mb: 1 }}>
        <Typography component="h2" sx={{ fontWeight: 700, fontSize: '1.0625rem', color: DS_TEXT.primary }}>
          Property Match
        </Typography>
        <MatchInfoButton />
        <Button
          variant="contained"
          size="small"
          disabled={runMatching.isPending || isLoading}
          startIcon={runMatching.isPending
            ? <CircularProgress size={13} color="inherit" />
            : <Target size={14} aria-hidden />}
          onClick={() => starten(includeOccupied, 'USER')}
          sx={{ textTransform: 'none', fontWeight: 600, ml: { sm: 'auto' }, ...FOCUS_SX }}
        >
          {runMatching.isPending ? 'Wird abgeglichen …' : 'Matching starten'}
        </Button>
      </Box>
      {/* Bei einem Risiko ist die Frage eine andere — das sagt der Text, nicht die Liste. */}
      {risiko && (
        <Alert severity="info" sx={{ fontSize: '0.8rem', mb: 1.5 }}>
          {signal.propertyId
            ? 'Negatives Signal mit zugeordnetem Objekt. Das Matching zeigt hier Alternativen für eine mögliche Wiedervermietung.'
            : 'Negatives Signal ohne eindeutig zugeordnetes Objekt. Das Matching zeigt, welche Flächen im Bestand zum beschriebenen Bedarf passen würden.'}
          {signal.propertyId && (
            <Box sx={{ mt: 0.75 }}>
              <ObjectDeepLink propertyId={signal.propertyId} label="Betroffenes Objekt öffnen" />
            </Box>
          )}
        </Alert>
      )}
      <FormControlLabel
        control={
          <Switch
            size="small"
            checked={includeOccupied}
            disabled={runMatching.isPending}
            onChange={(_, checked) => handleToggleOccupied(checked)}
          />
        }
        label="Belegte Objekte einbeziehen"
        slotProps={{ typography: { variant: 'body2', sx: { color: DS_TEXT.secondary } } }}
        sx={{ mb: 1 }}
      />
      {!ergebnis ? (
        <Box
          sx={{
            border: `1px solid ${DS_BORDER.default}`, borderRadius: 2, p: 3, textAlign: 'center',
          }}
        >
          <Typography variant="body2" sx={{ color: DS_TEXT.secondary }}>
            Noch kein Abgleich durchgeführt. «Matching starten» vergleicht das Suchprofil mit dem
            Objektbestand aus «Meine Objekte».
          </Typography>
        </Box>
      ) : ergebnis.matches.length === 0 ? (
        <Alert severity="warning" sx={{ fontSize: '0.8rem' }}>
          Kein Objekt im Kandidatenkreis.
          {!includeOccupied && ' Mit «Belegte Objekte einbeziehen» wird der Kreis grösser.'}
        </Alert>
      ) : (
        <Box sx={{ display: 'flex', flexDirection: 'column', gap: 1 }}>
          <Typography variant="caption" sx={{ color: DS_TEXT.muted }}>
            {`${ergebnis.candidateCount} ${ergebnis.candidateCount === 1 ? 'Objekt' : 'Objekte'} abgeglichen · `}
            {`bester Wert ${ergebnis.matches[0].score} %`}
            {sichtbar.length !== ergebnis.matches.length && ` · ${sichtbar.length} nach Filter sichtbar`}
          </Typography>
          <PropertyFilterBar
            filters={filters}
            onFiltersChange={setFilters}
            showMatchFilter
            cities={staedte}
          />
          <PropertyTable
            properties={sichtbar}
            isLoading={false}
            isError={false}
            selectedId={selectedId}
            onSelect={setSelectedId}
            onViewDetail={setSelectedId}
            filters={filters}
            onFiltersChange={setFilters}
            matchScores={scores}
          />
        </Box>
      )}
      {/*
        Objektdetail aus der Trefferliste (Runde 11, §4).
        Bewusst dieselbe `PropertyDetailView` in derselben Schublade wie in
        «Meine Objekte» — geladen über die Objekt-ID, nicht über Titel oder
        Listenposition. Eine zweite Detailansicht für denselben Datensatz wäre
        eine zweite Stelle, an der Objektangaben auseinanderlaufen können.
        Die Schublade legt sich über die Seite, statt sie zu ersetzen: Der
        Matching-Kontext bleibt darunter stehen, und das Schliessen führt
        zurück in die unveränderte Trefferliste. Es läuft dabei kein Matching —
        `ergebnis` wird nicht angerührt, also entsteht weder ein
        Protokolleintrag noch ein Zähler-Zuwachs.
      */}
      <Drawer
        anchor="right"
        open={selectedId !== null}
        onClose={() => setSelectedId(null)}
        slotProps={{
          paper: {
            sx: {
              width: isMobile ? '100vw' : { md: 520, lg: 580, xl: 640 },
              boxShadow: '-4px 0 24px rgba(0,0,0,0.10)',
            },
          },
        }}
      >
        {selectedId && (
          <PropertyDetailView propertyId={selectedId} onClose={() => setSelectedId(null)} />
        )}
      </Drawer>
    </Box>
  )
 })
@@ -3,22 +3,36 @@ import { Box, Button, Skeleton, Typography } from '@mui/material'
 import { Inbox } from 'lucide-react'
 import type { UnifiedLead } from '../../domain/unifiedLead'
 import { LeadChannelBadge } from './LeadChannelBadge'
 import { LeadSignalTypeBadge } from './LeadSignalTypeBadge'
 import { DS_SLATE, DS_TEXT } from '../../lib/ds'
-/** Spaltenraster im Stil der übrigen Agentenlisten (Livia, Bruno). */
+/**
-const COLS = '120px 1.5fr 1.4fr 150px'
+ * Spaltenraster im Stil der übrigen Agentenlisten (Bruno, Ferdi).
 *
 * Seit Runde 8 (§2) mit der Spalte «Signaltyp». Sie steht direkt nach der
 * Herkunft, weil Chance oder Risiko darüber entscheidet, ob die Zeile
 * überhaupt heute gelesen werden muss.
 *
 * Auf Livias Arbeitsplatz entfällt die Kanalspalte: dort stammt jeder Eintrag
 * aus ihrer eigenen Recherche, und eine Spalte mit immer demselben Wert ist
 * keine Information.
 */
 const COLS_WITH_CHANNEL = '120px 110px 1.5fr 1.4fr 150px'
 const COLS_WITHOUT_CHANNEL = '110px 1.5fr 1.4fr 150px'
-const COLUMN_LABELS = ['Kanal', 'Interessent', 'Anliegen', 'Eingang']
+const LABELS_WITH_CHANNEL = ['Kanal', 'Signaltyp', 'Interessent', 'Anliegen', 'Eingang']
 const LABELS_WITHOUT_CHANNEL = ['Signaltyp', 'Unternehmen', 'Veränderung', 'Eingang']
 function formatDate(iso: string): string {
  return new Date(iso).toLocaleDateString('de-CH', { day: '2-digit', month: '2-digit', year: 'numeric' })
 }
 const LeadRow = memo(function LeadRow({
-  lead, selected, onSelect,
+  lead, selected, showChannel, onSelect,
 }: {
  lead: UnifiedLead
  selected: boolean
  showChannel: boolean
  onSelect: (lead: UnifiedLead) => void
 }) {
  return (
@@ -29,7 +43,7 @@ const LeadRow = memo(function LeadRow({
      onKeyDown={e => { if (e.key === 'Enter' || e.key === ' ') { e.preventDefault(); onSelect(lead) } }}
      sx={{
        display: 'grid',
-        gridTemplateColumns: COLS,
+        gridTemplateColumns: showChannel ? COLS_WITH_CHANNEL : COLS_WITHOUT_CHANNEL,
        alignItems: 'center',
        gap: 1,
        px: 2, py: 1.5,
@@ -41,8 +55,17 @@ const LeadRow = memo(function LeadRow({
        transition: 'background-color 0.1s',
      }}
    >
      {showChannel && (
        <Box>
          <LeadChannelBadge channel={lead.channel} />
        </Box>
      )}
      {/* Signaltyp — nur Recherche-Leads tragen eine Einordnung (§2). */}
      <Box>
-        <LeadChannelBadge channel={lead.channel} />
+        {lead.leadSignalType
          ? <LeadSignalTypeBadge type={lead.leadSignalType} />
          : <Typography variant="caption" sx={{ color: DS_TEXT.muted }}>—</Typography>}
      </Box>
      <Box sx={{ minWidth: 0 }}>
@@ -72,30 +95,41 @@ export interface UnifiedLeadListProps {
  onSelect: (lead: UnifiedLead) => void
  /** Nur gesetzt, wenn ein Filter aktiv ist — dann bietet der Leerzustand die Rücksetzung an. */
  onResetFilter?: () => void
  /** Kanalspalte anzeigen. Bei Nora ja, auf Livias Recherche-Liste nein (§1). */
  showChannel?: boolean
  /** Text des Leerzustands — bei Livia geht es um Recherche, nicht um Kanäle. */
  emptyText?: string
 }
 /**
- * Gemeinsame Leadliste aller drei Kanäle (Runde 5, §12).
+ * Gemeinsame Leadliste (Runde 5, §12; Runde 8, §1–§2).
 *
- * Ersetzt die beiden getrennten Reiterlisten. Jede Zeile trägt ihr
+ * Dieselbe Komponente trägt Noras Kanalliste und Livias Recherche-Liste. Zwei
- * Kanalkennzeichen ganz links — die Herkunft ist die erste Information, die
+ * fast gleiche Listen nebeneinander wären zwei Stellen für jede künftige
- * beim Überfliegen zählt, weil sie bestimmt, wie belastbar der Lead ist.
+ * Änderung — und genau davor warnt die Vorgabe der Runde.
 */
-export function UnifiedLeadList({ leads, isLoading, selectedId, onSelect, onResetFilter }: UnifiedLeadListProps) {
+export function UnifiedLeadList({
  leads, isLoading, selectedId, onSelect, onResetFilter,
  showChannel = true,
  emptyText = 'Für diesen Kanaltyp liegen derzeit keine Leads vor.',
 }: UnifiedLeadListProps) {
  const cols = showChannel ? COLS_WITH_CHANNEL : COLS_WITHOUT_CHANNEL
  const labels = showChannel ? LABELS_WITH_CHANNEL : LABELS_WITHOUT_CHANNEL
  return (
    <Box sx={{ border: '1px solid #e2e8f0', borderRadius: 1.5, overflow: 'hidden', bgcolor: 'white' }}>
      {/* Kopfzeile */}
      <Box
        sx={{
          display: 'grid',
-          gridTemplateColumns: COLS,
+          gridTemplateColumns: cols,
          gap: 1,
          px: 2, py: 1,
          bgcolor: DS_SLATE[50],
          borderBottom: '1px solid #e2e8f0',
        }}
      >
-        {COLUMN_LABELS.map(label => (
+        {labels.map(label => (
          <Typography
            key={label}
            variant="caption"
@@ -118,7 +152,7 @@ export function UnifiedLeadList({ leads, isLoading, selectedId, onSelect, onRese
            <Box sx={{ px: 3, py: 6, display: 'flex', flexDirection: 'column', alignItems: 'center', gap: 1.5 }}>
              <Inbox size={28} color={DS_SLATE[400]} />
              <Typography variant="body2" sx={{ color: DS_TEXT.secondary, textAlign: 'center' }}>
-                Für diesen Kanaltyp liegen derzeit keine Leads vor.
+                {emptyText}
              </Typography>
              {onResetFilter && (
                <Button size="small" variant="outlined" onClick={onResetFilter} sx={{ textTransform: 'none' }}>
@@ -132,6 +166,7 @@ export function UnifiedLeadList({ leads, isLoading, selectedId, onSelect, onRese
              key={`${lead.channel}-${lead.id}`}
              lead={lead}
              selected={lead.id === selectedId}
              showChannel={showChannel}
              onSelect={onSelect}
            />
          ))}
@@ -6,6 +6,10 @@ export { CONTACT_ICONS, MIN_MATCH_PCT, areaFitPct, confirmableContacts } from '.
 // Runde 5, §12/§13: gemeinsame Liste über KI-Signale, Netzwerk und CRM.
 export { LeadChannelBadge } from './LeadChannelBadge'
 // Runde 8, §2: Chance/Risiko-Kennzeichen, geteilt von Livia und Nora.
 export { LeadSignalTypeBadge } from './LeadSignalTypeBadge'
 export { LeadChannelFilterBar } from './LeadChannelFilterBar'
 export { UnifiedLeadList } from './UnifiedLeadList'
 export { CrmLeadDetail } from './CrmLeadDetail'
 export { PropertyMatchSection } from './PropertyMatchSection'
@@ -0,0 +1,120 @@
 import { memo } from 'react'
 import { Box, Chip, Typography } from '@mui/material'
 import { ExternalLink, MapPin } from 'lucide-react'
 import type { ResearchLead } from '../../domain/researchLead'
 import { RESEARCH_EVENT_TYPE_LABELS, RESEARCH_RELEVANCE_LABELS } from '../../lib/constants'
 import { AiDisclaimer } from '../ui'
 import { DS_BRAND, DS_COLORS, DS_SLATE, DS_TEXT } from '../../lib/ds'
 /**
 * Ein aus einer echten Quelle abgeleiteter Lead (§16).
 *
 * Die Karte beantwortet in fester Reihenfolge: was ist passiert, bei wem, wo,
 * warum ist es für Gewerbeflächen relevant, wie sicher ist die Einordnung und
 * woher stammt sie. Der Quellenlink steht unten und ist echt — er zeigt auf
 * genau die Seite, die Livia gelesen hat.
 *
 * Confidence steht als Zahl da und nicht als Balken: ein Balken suggeriert
 * Messgenauigkeit, die eine Modellschätzung nicht hat.
 */
 export const ResearchLeadCard = memo(function ResearchLeadCard({ lead }: { lead: ResearchLead }) {
  const hoch = lead.relevance === 'high'
  const akzent = hoch ? DS_COLORS.leadSignal.CHANCE : { bg: DS_SLATE[100], fg: DS_SLATE[600] }
  return (
    <Box
      sx={{
        border: '1px solid #e2e8f0',
        borderLeft: '3px solid',
        borderLeftColor: hoch ? DS_COLORS.leadSignal.CHANCE.fg : DS_SLATE[300],
        borderRadius: 1.5,
        bgcolor: 'white',
        p: 2,
      }}
    >
      <Typography variant="body1" sx={{ fontWeight: 700, color: DS_SLATE[900], lineHeight: 1.35, mb: 0.75 }}>
        {lead.headline}
      </Typography>
      <Box sx={{ display: 'flex', flexWrap: 'wrap', gap: 0.75, mb: 1.25, alignItems: 'center' }}>
        <Chip
          label={RESEARCH_EVENT_TYPE_LABELS[lead.eventType] ?? lead.eventType}
          size="small"
          sx={{ height: 20, fontSize: '0.68rem', fontWeight: 700, bgcolor: akzent.bg, color: akzent.fg }}
        />
        <Typography variant="caption" sx={{ color: DS_TEXT.secondary }}>
          {RESEARCH_RELEVANCE_LABELS[lead.relevance]}
        </Typography>
        {lead.location && (
          <Chip
            icon={<MapPin size={11} />}
            label={lead.location}
            size="small"
            sx={{
              height: 20, fontSize: '0.72rem', bgcolor: DS_SLATE[100], color: DS_SLATE[600],
              '& .MuiChip-icon': { color: DS_SLATE[600], ml: 0.5, mr: -0.25 },
            }}
          />
        )}
      </Box>
      <Typography variant="caption" sx={{ color: DS_TEXT.muted, display: 'block', mb: 0.25 }}>
        Unternehmen
      </Typography>
      <Typography variant="body2" sx={{ fontWeight: 600, color: DS_SLATE[900], mb: 1 }}>
        {lead.company}
      </Typography>
      <Typography variant="body2" sx={{ color: DS_SLATE[800], lineHeight: 1.6, mb: 1.25 }}>
        {lead.summary}
      </Typography>
      <Typography
        variant="caption"
        sx={{ fontWeight: 700, color: DS_SLATE[500], textTransform: 'uppercase', letterSpacing: 0.5, display: 'block', mb: 0.25, fontSize: '0.65rem' }}
      >
        Warum relevant
      </Typography>
      <Typography variant="body2" sx={{ color: DS_SLATE[800], lineHeight: 1.55, mb: 1.5 }}>
        {lead.reason}
      </Typography>
      {/*
        Der Block «Empfohlene nächste Handlung» ist mit Runde 9 (§4) entfallen.
        Das Feld bleibt im Datenmodell und wird weiterhin vom Modell befüllt —
        entfernt ist allein die Anzeige, damit die Karte auf das Beobachtete
        beschränkt bleibt und nicht als Anweisung gelesen wird.
      */}
      <Box
        sx={{
          display: 'flex', flexWrap: 'wrap', alignItems: 'center', gap: 1,
          pt: 1.25, borderTop: '1px solid #f1f5f9',
        }}
      >
        <Typography variant="caption" sx={{ color: DS_SLATE[500] }}>
          Quelle: <strong>{lead.source}</strong>
          {lead.publishedAt && ` · ${new Date(lead.publishedAt).toLocaleDateString('de-CH')}`}
        </Typography>
        <Typography variant="caption" sx={{ color: DS_SLATE[500] }}>
          Confidence: <strong>{Math.round(lead.confidence * 100)} %</strong>
        </Typography>
        <Box
          component="a"
          href={lead.sourceUrl}
          target="_blank"
          rel="noopener noreferrer"
          sx={{
            display: 'inline-flex', alignItems: 'center', gap: 0.5, ml: 'auto',
            color: DS_BRAND.main, fontSize: '0.75rem', fontWeight: 600, textDecoration: 'none',
            '&:hover': { textDecoration: 'underline' },
          }}
        >
          Originalquelle öffnen <ExternalLink size={11} />
        </Box>
      </Box>
      <AiDisclaimer />
    </Box>
  )
 })
@@ -0,0 +1,138 @@
 import { memo } from 'react'
 import { Box, Chip, Typography } from '@mui/material'
 import { CheckCircle2, ExternalLink, XCircle } from 'lucide-react'
 import type { ResearchSourceResult } from '../../domain/researchLead'
 import type { ResearchSourceDescriptor } from '../../lib/researchSources'
 import { DS_BRAND, DS_COLORS, DS_SLATE, DS_TEXT } from '../../lib/ds'
 interface Props {
  /**
   * Die Quellen, die der nächste Lauf abrufen wird.
   *
   * Kommen von aussen und nicht aus einer eigenen Liste: Bis Runde 11 stand
   * hier `RESEARCH_SOURCE_LIST` — eine zweite, im Code gepflegte Aufzählung.
   * Dadurch zeigte das Panel die drei Standardquellen, während die Zählung
   * daneben bereits vier meldete und ein frisch angebundenes System nirgends
   * auftauchte. Eine Anzeige, die ihre eigene Wahrheit führt, ist genau das
   * Gegenteil dessen, was dieses Panel leisten soll.
   */
  sources: ResearchSourceDescriptor[]
  /** Ergebnisse des letzten Laufs; vor dem ersten Lauf leer. */
  results?: ResearchSourceResult[]
 }
 /**
 * «Angebundene Kanäle & Systeme» auf Livias Arbeitsplatz (§2, §15).
 *
 * Zeigt die real abgerufenen Quellen mit Namen, Status und anklickbarem
 * Originallink. Die Links stehen hier nicht als Zierde: wer eine Aussage von
 * Livia prüfen will, soll die Quelle in einem Klick öffnen können, ohne sie
 * selbst suchen zu müssen.
 *
 * Welche Quellen das sind, entscheidet das Personalblatt — die Liste kommt als
 * Eigenschaft herein und stammt aus derselben Ableitung, die auch der Lauf
 * verwendet (Runde 11, §1).
 *
 * Vor dem ersten Lauf steht «Bereit» und nicht «Verbunden» — verbunden ist,
 * was tatsächlich geantwortet hat, und das weiss man erst danach.
 */
 export const ResearchSourcesPanel = memo(function ResearchSourcesPanel({ sources, results }: Props) {
  return (
    <Box sx={{ border: '1px solid #e2e8f0', borderRadius: 1.5, bgcolor: 'white', overflow: 'hidden' }}>
      <Box sx={{ px: 2, py: 1, bgcolor: DS_SLATE[50], borderBottom: '1px solid #e2e8f0' }}>
        <Typography
          variant="caption"
          sx={{ fontWeight: 700, color: DS_TEXT.muted, textTransform: 'uppercase', letterSpacing: 0.5, fontSize: '0.65rem' }}
        >
          Angebundene Kanäle &amp; Systeme
        </Typography>
      </Box>
      {sources.length === 0 && (
        <Box sx={{ px: 2, py: 1.5 }}>
          <Typography variant="caption" sx={{ color: DS_TEXT.muted }}>
            Keine aktive Lesequelle mit Adresse angebunden. Quellen werden im Personalblatt unter
            «Kanäle &amp; Systeme» erfasst.
          </Typography>
        </Box>
      )}
      {sources.map(quelle => {
        const ergebnis = results?.find(r => r.id === quelle.id)
        return (
          <Box
            key={quelle.id}
            sx={{
              display: 'flex', alignItems: 'flex-start', gap: 1.5,
              px: 2, py: 1.5,
              borderBottom: '1px solid #f1f5f9',
              '&:last-of-type': { borderBottom: 'none' },
            }}
          >
            <Box sx={{ flex: 1, minWidth: 0 }}>
              <Typography variant="body2" sx={{ fontWeight: 600, color: DS_SLATE[900], lineHeight: 1.3 }}>
                {quelle.name}
              </Typography>
              <Typography variant="caption" sx={{ color: DS_TEXT.muted, display: 'block', lineHeight: 1.4 }}>
                {quelle.purpose}
              </Typography>
              <Box
                component="a"
                href={quelle.url}
                target="_blank"
                rel="noopener noreferrer"
                sx={{
                  display: 'inline-flex', alignItems: 'center', gap: 0.5, mt: 0.5,
                  color: DS_BRAND.main, fontSize: '0.72rem', fontWeight: 600,
                  textDecoration: 'none', wordBreak: 'break-all',
                  '&:hover': { textDecoration: 'underline' },
                }}
              >
                {quelle.url} <ExternalLink size={11} style={{ flexShrink: 0 }} />
              </Box>
              {ergebnis?.error && (
                <Typography variant="caption" sx={{ color: DS_COLORS.leadSignal.RISIKO.fg, display: 'block', mt: 0.25 }}>
                  {ergebnis.error}
                </Typography>
              )}
            </Box>
            <Box sx={{ flexShrink: 0, pt: 0.25 }}>
              {ergebnis === undefined ? (
                <Chip
                  label="Bereit"
                  size="small"
                  sx={{ height: 20, fontSize: '0.68rem', fontWeight: 700, bgcolor: DS_SLATE[100], color: DS_SLATE[600] }}
                />
              ) : (
                <Chip
                  icon={ergebnis.ok ? <CheckCircle2 size={11} /> : <XCircle size={11} />}
                  /*
                   * Mit Einheit statt nur der Zahl: «Live · 24» liest sich sonst
                   * genauso gut als «24 gefundene Leads», und genau so wurde es
                   * beim ersten Zeigen auch verstanden.
                   */
                  label={ergebnis.ok
                    ? `Live · ${ergebnis.itemCount} ${ergebnis.itemCount === 1 ? 'Eintrag' : 'Einträge'}`
                    : 'Nicht erreichbar'}
                  size="small"
                  sx={{
                    height: 20, fontSize: '0.68rem', fontWeight: 700,
                    bgcolor: ergebnis.ok ? DS_COLORS.leadSignal.CHANCE.bg : DS_COLORS.leadSignal.RISIKO.bg,
                    color: ergebnis.ok ? DS_COLORS.leadSignal.CHANCE.fg : DS_COLORS.leadSignal.RISIKO.fg,
                    border: '1px solid',
                    borderColor: ergebnis.ok ? DS_COLORS.leadSignal.CHANCE.fg : DS_COLORS.leadSignal.RISIKO.fg,
                    '& .MuiChip-icon': {
                      color: ergebnis.ok ? DS_COLORS.leadSignal.CHANCE.fg : DS_COLORS.leadSignal.RISIKO.fg,
                      ml: 0.5, mr: -0.25,
                    },
                  }}
                />
              )}
            </Box>
          </Box>
        )
      })}
    </Box>
  )
 })
@@ -0,0 +1,224 @@
 import { useCallback, useMemo, useState } from 'react'
 import { useNavigate } from 'react-router'
 import { Alert, Box, Button, CircularProgress, Drawer, Typography, useMediaQuery, useTheme } from '@mui/material'
 import { RefreshCw } from 'lucide-react'
 import { LeadDetail, UnifiedLeadList } from '../market-leads'
 import { ResearchSourcesPanel } from './ResearchSourcesPanel'
 import { useUnifiedLeads } from '../../hooks/useUnifiedLeads'
 import { useLiviaResearch } from '../../hooks/useLiviaResearch'
 import { useResearchDocuments } from '../../hooks/useResearchDocuments'
 import { useTeamAgent } from '../../hooks/useTeamAgents'
 import { leseQuellenAus } from '../../lib/agentSystems'
 import { LeadChannel } from '../../domain/unifiedLead'
 import type { UnifiedLead } from '../../domain/unifiedLead'
 import { LeadSignalType } from '../../domain/futureSignal'
 import { TemporalClass } from '../../domain/researchLead'
 import type { TemporalClass as TemporalClassValue } from '../../domain/researchLead'
 import { ROUTES } from '../../lib/constants'
 import { DS_SLATE, DS_TEXT } from '../../lib/ds'
 /** Kennung der Einstellung, die die erlaubten Ereigniszeiten führt (§2.9). */
 const TEMPORAL_SETTING_ID = 'livia-set-temporal-relevance'
 const GUELTIGE_KLASSEN = new Set<string>(Object.values(TemporalClass))
 /**
 * Livias Recherche-Arbeitsplatz (Runde 8, §1; Research-PoC §15; Runde 10, §2.12).
 *
 * Seit Runde 10 gibt es hier **eine** Leadliste. Bis dahin standen die frisch
 * gelesenen Leads als eigene Karten über dem erfassten Bestand — technisch
 * sauber getrennt, in der Benutzung aber unbrauchbar: Dieselbe Firma sah oben
 * anders aus als unten, die Filter griffen nur auf der einen Hälfte, und Nora
 * bekam die neuen Leads gar nicht zu sehen.
 *
 * Jetzt wandert ein Lauf direkt in den zentralen Signalbestand. Was oben steht,
 * ist nur noch der Bericht über den Lauf selbst: welche Quellen antworteten,
 * wie viel gelesen und wie viel verworfen wurde. Die Leads stehen dort, wo alle
 * Leads stehen.
 *
 * Welche Quellen abgerufen werden, entscheidet nicht diese Komponente, sondern
 * Livias Personalblatt: jeder aktive Lesezugang mit Adresse, dazu die manuell
 * abgelegten Dokumente. Damit ist die Anzeige unter «Systeme» keine Behauptung,
 * sondern die Eingabe des Laufs.
 */
 export function ResearchWorkspace() {
  const theme = useTheme()
  const isMobile = useMediaQuery(theme.breakpoints.down('md'))
  const [selected, setSelected] = useState<UnifiedLead | null>(null)
  const { data: leads, isLoading } = useUnifiedLeads()
  const { data: livia } = useTeamAgent('livia')
  const { data: dokumente = [] } = useResearchDocuments()
  const refresh = useLiviaResearch()
  const ergebnis = refresh.data
  // Zählung und Filterung in einem Durchgang über dieselbe Liste (CLAUDE.md §10.4).
  const { research, chancen, risiken } = useMemo(() => {
    const rows: UnifiedLead[] = []
    let c = 0
    let r = 0
    for (const lead of leads) {
      if (lead.channel !== LeadChannel.KI_SIGNAL) continue
      rows.push(lead)
      if (lead.leadSignalType === LeadSignalType.RISIKO) r += 1
      else c += 1
    }
    return { research: rows, chancen: c, risiken: r }
  }, [leads])
  /** Die Lesequellen kommen aus dem gespeicherten Stand, nicht aus einer festen Liste. */
  const quellen = useMemo(() => leseQuellenAus(livia?.systems ?? []), [livia?.systems])
  /** Die erlaubten Ereigniszeiten stehen als Einstellung am Personalblatt. */
  const zeitfenster = useMemo((): TemporalClassValue[] => {
    const wert = livia?.settings.find(s => s.id === TEMPORAL_SETTING_ID)?.value
    if (!Array.isArray(wert)) return []
    return wert.filter((v): v is TemporalClassValue => GUELTIGE_KLASSEN.has(v))
  }, [livia?.settings])
  const navigate = useNavigate()
  /**
   * Übergabe an Nora (Runde 10, §2.14).
   *
   * Weitergereicht wird nur die Lead-ID — Nora liest denselben Eintrag aus
   * demselben Bestand, es entsteht keine Kopie. Das Kennzeichen `matching=1`
   * sagt ihr, dass der Lauf sofort starten darf; ohne dieses Kennzeichen läuft
   * beim normalen Öffnen nichts von selbst.
   *
   * Beides steht in der Adresse und nicht im Navigationszustand: So überlebt
   * die Übergabe ein Neuladen, und der Link lässt sich weitergeben.
   */
  const handleStartMatching = useCallback(
    (signalId: string) => {
      navigate(`${ROUTES.SUPPLY.AGENT_NORA}?lead=${encodeURIComponent(signalId)}&matching=1`)
    },
    [navigate],
  )
  const closeDetail = useCallback(() => setSelected(null), [])
  const starten = useCallback(
    () => refresh.mutate({ sources: quellen, documents: dokumente, temporalClasses: zeitfenster }),
    [refresh, quellen, dokumente, zeitfenster],
  )
  const keineQuellen = quellen.length === 0 && dokumente.length === 0
  return (
    <Box sx={{ display: 'flex', flexDirection: 'column', gap: 2.5 }}>
      {/* ── Der Lauf ────────────────────────────────────────────────────── */}
      <Box sx={{ display: 'flex', flexDirection: 'column', gap: 1.5 }}>
        <Box sx={{ display: 'flex', alignItems: 'center', gap: 2, flexWrap: 'wrap' }}>
          <Button
            variant="contained"
            startIcon={refresh.isPending ? <CircularProgress size={14} color="inherit" /> : <RefreshCw size={15} />}
            disabled={refresh.isPending || keineQuellen}
            onClick={starten}
            sx={{ textTransform: 'none', fontWeight: 600 }}
          >
            Research aktualisieren
          </Button>
          {refresh.isPending && (
            <Typography variant="body2" sx={{ color: DS_TEXT.secondary }}>
              Livia liest aktuelle Marktinformationen …
            </Typography>
          )}
          {/*
            Die Zahl steht immer da, auch nach einem Lauf (Runde 11, §1.8).
            Vorher trat sie hinter das Ergebnis zurück — wer danach ein System
            ab- oder zuschaltete, sah die Wirkung nirgends. Sie kommt aus
            derselben Ableitung wie die Liste darunter und wie der Lauf selbst;
            eine gepflegte Zählvariable gibt es nicht.
          */}
          {!refresh.isPending && !keineQuellen && (
            <Typography variant="caption" sx={{ color: DS_TEXT.muted }}>
              {`${quellen.length} ${quellen.length === 1 ? 'aktive Lesequelle' : 'aktive Lesequellen'}`}
              {dokumente.length > 0 &&
                ` · ${dokumente.length} ${dokumente.length === 1 ? 'abgelegtes Dokument' : 'abgelegte Dokumente'}`}
            </Typography>
          )}
        </Box>
        {!refresh.isPending && ergebnis && (
          <Typography variant="caption" sx={{ color: DS_TEXT.muted }}>
            {`Letzter Lauf: ${ergebnis.analyzed} ${ergebnis.analyzed === 1 ? 'Information' : 'Informationen'} analysiert · `}
            {`${ergebnis.discarded} nicht relevant · `}
            {`${ergebnis.watchlist} Watchlist · `}
            {ergebnis.temporalFiltered > 0 && `${ergebnis.temporalFiltered} zeitlich ausgeschlossen · `}
            {`${ergebnis.leads.length} ${ergebnis.leads.length === 1 ? 'Lead übernommen' : 'Leads übernommen'}`}
            {` · Stand ${new Date(ergebnis.refreshedAt).toLocaleTimeString('de-CH', { hour: '2-digit', minute: '2-digit' })}`}
            {ergebnis.model && ` · Modell ${ergebnis.model}`}
          </Typography>
        )}
        {keineQuellen && (
          <Alert severity="info" sx={{ fontSize: '0.8rem' }}>
            Für Livia ist derzeit keine aktive Lesequelle mit Adresse hinterlegt und kein Dokument abgelegt.
            Quellen werden im Personalblatt unter «Kanäle &amp; Systeme» angebunden, Dokumente unter
            «Einstellungen».
          </Alert>
        )}
        <ResearchSourcesPanel sources={quellen} results={ergebnis?.sources} />
        {ergebnis?.analysisError && (
          <Alert severity="warning" sx={{ fontSize: '0.8rem' }}>
            Die Quellen wurden gelesen, die Beurteilung konnte aber nicht laufen: {ergebnis.analysisError}
          </Alert>
        )}
        {ergebnis && ergebnis.leads.length === 0 && !ergebnis.analysisError && (
          <Alert severity="info" sx={{ fontSize: '0.8rem' }}>
            Aus diesem Lauf ergab sich keine Entwicklung mit plausiblem Gewerbeimmobilienbezug.
            Gelesen wurden {ergebnis.analyzed} Einträge.
            {ergebnis.temporalFiltered > 0 &&
              ` ${ergebnis.temporalFiltered} davon fielen durch die eingestellte zeitliche Relevanz.`}
          </Alert>
        )}
      </Box>
      {/* ── Die eine Leadliste ──────────────────────────────────────────── */}
      <Box sx={{ display: 'flex', flexDirection: 'column', gap: 1.5, pt: 1, borderTop: `1px solid ${DS_SLATE[200]}` }}>
        <Typography variant="caption" sx={{ color: DS_TEXT.muted }}>
          {isLoading
            ? 'Leads werden geladen …'
            : `${research.length} ${research.length === 1 ? 'erfasster Lead' : 'erfasste Leads'} · ` +
              `${chancen} ${chancen === 1 ? 'Chance' : 'Chancen'}, ${risiken} ${risiken === 1 ? 'Risiko' : 'Risiken'}`}
        </Typography>
        <UnifiedLeadList
          leads={research}
          isLoading={isLoading}
          selectedId={selected?.id ?? null}
          onSelect={setSelected}
          showChannel={false}
          emptyText="Noch keine Leads. «Research aktualisieren» liest die angebundenen Quellen und legt gefundene Leads hier ab."
        />
      </Box>
      <Drawer
        anchor="right"
        open={!!selected}
        onClose={closeDetail}
        slotProps={{
          paper: {
            sx: {
              width: isMobile ? '100vw' : { md: 520, lg: 600, xl: 660 },
              boxShadow: '-4px 0 24px rgba(0,0,0,0.10)',
            },
          },
        }}
      >
        {selected?.channel === LeadChannel.KI_SIGNAL && (
          <LeadDetail
            lead={{ signal: selected.signal, matchingProperties: selected.matchingProperties }}
            showMatching={false}
            onStartMatching={handleStartMatching}
          />
        )}
      </Drawer>
    </Box>
  )
 }
@@ -0,0 +1,5 @@
 // Livia — Markt-Recherche (Runde 8, §1; Research-PoC). Barrel-Export (CLAUDE.md §13).
 export { ResearchWorkspace } from './ResearchWorkspace'
 export { ResearchSourcesPanel } from './ResearchSourcesPanel'
 export { ResearchLeadCard } from './ResearchLeadCard'
@@ -1,240 +0,0 @@
 import { memo } from 'react'
 import { Box, ButtonBase, Typography } from '@mui/material'
 import { ArrowRight } from 'lucide-react'
 import { AgentAvatar } from '../team'
 import type { AgentPresence } from '../../domain/agentPresence'
 import { WorkloadTone } from '../../domain/agentWorkload'
 import { DS_ACCENT, DS_NEUTRAL } from '../../lib/ds'
 /**
 * Farben der Auslastung auf dunklem Grund. Bewusst hellere Stufen als die
 * Standardakzente — die dunkleren Töne verschwinden vor der abgedunkelten
 * Bürofläche.
 */
 const TONE_COLOR: Record<WorkloadTone, string> = {
  [WorkloadTone.CALM]: DS_ACCENT.success.emerald,
  [WorkloadTone.ATTENTION]: DS_ACCENT.warning.amber,
  [WorkloadTone.URGENT]: DS_ACCENT.danger.bright,
 }
 export interface AgentStaffCardProps {
  presence: AgentPresence
  onOpen: (path: string) => void
 }
 /**
 * Ein digitaler Mitarbeitender auf der Startseite (Runde 5, §3/§6).
 *
 * Die Karte ist bewusst wie ein Personalblatt aufgebaut und nicht wie eine
 * Kachel: Porträt, Name, Funktion, Abteilung und Personalnummer, dann ein Satz
 * in der ersten Person, darunter die zuletzt protokollierte Handlung mit
 * Zeitangabe.
 *
 * Diese letzte Zeile ist der Unterschied zwischen «KI-Funktion» und
 * «Mitarbeitender»: sie belegt, dass jemand gearbeitet hat, statt es zu
 * behaupten. Eine Kennzahl allein kann jede Software anzeigen.
 *
 * Die ganze Karte ist ein Schalter. `ButtonBase` liefert Tastaturbedienung,
 * Enter, Leertaste und Fokusring ohne eigenen Code.
 */
 export const AgentStaffCard = memo(function AgentStaffCard({ presence, onOpen }: AgentStaffCardProps) {
  const { workload } = presence
  const toneColor = workload ? TONE_COLOR[workload.tone] : DS_NEUTRAL.stone
  return (
    <ButtonBase
      focusRipple
      onClick={() => onOpen(presence.path)}
      aria-label={
        workload
          ? `${presence.name}, ${presence.role} — ${workload.label}. Arbeitsbereich öffnen`
          : `${presence.name}, ${presence.role} — Arbeitsbereich öffnen`
      }
      sx={{
        display: 'flex',
        flexDirection: 'column',
        alignItems: 'stretch',
        textAlign: 'left',
        // Ohne `minWidth: 0` kann eine Flexkarte nicht unter ihre Inhaltsbreite
        // schrumpfen. Die fünf Karten passten dadurch nicht in eine Reihe,
        // brachen um — und die zweite Reihe drückte Titel und Filterbalken aus
        // dem sichtbaren Bereich.
        minWidth: 0,
        gap: 1.25,
        p: { xs: 1.75, xl: 2 },
        borderRadius: 3,
        overflow: 'hidden',
        // Keine eigene Höhe: im Flexlayout gibt die Zeile die Höhe vor, und alle
        // Karten einer Zeile werden von selbst gleich hoch. Mit `height: 100%`
        // beanspruchte jede Karte die volle Fläche und die zweite Zeile fiel
        // aus dem sichtbaren Bereich.
        // Glasfläche statt Vollton: das Büro dahinter bleibt spürbar, ohne die
        // Schrift zu stören.
        bgcolor: 'rgba(255,255,255,0.06)',
        backdropFilter: 'blur(14px)',
        border: '1px solid rgba(255,255,255,0.12)',
        transition: 'background-color 0.18s ease, transform 0.18s ease, border-color 0.18s ease',
        '&:hover, &.Mui-focusVisible': {
          bgcolor: 'rgba(255,255,255,0.11)',
          borderColor: 'rgba(255,255,255,0.26)',
          transform: 'translateY(-3px)',
        },
        '&:hover .staff-go, &.Mui-focusVisible .staff-go': { opacity: 1, transform: 'translateX(0)' },
        '&.Mui-focusVisible': { outline: `2px solid ${DS_NEUTRAL.gold}`, outlineOffset: 2 },
      }}
    >
      {/* Kopfzeile: Porträt, Personalien, Dienstzustand */}
      <Box sx={{ display: 'flex', alignItems: 'center', gap: 1.5 }}>
        <Box sx={{ position: 'relative', flexShrink: 0 }}>
          <AgentAvatar
            agent={{ id: presence.agentId, name: presence.name, role: presence.role }}
            size={56}
            loading="eager"
            ringColor="rgba(255,255,255,0.55)"
            ringWidth={2}
          />
          {/* Dienstpunkt am Porträt — die kürzeste Art zu sagen «ist da». */}
          <Box
            sx={{
              position: 'absolute', right: -1, bottom: -1,
              width: 14, height: 14, borderRadius: '50%',
              bgcolor: presence.onDuty ? DS_ACCENT.success.emerald : DS_NEUTRAL.stone,
              border: '2.5px solid rgba(12,18,28,0.95)',
            }}
          />
        </Box>
        <Box sx={{ minWidth: 0, flex: 1 }}>
          <Typography
            sx={{ fontWeight: 700, fontSize: '1.0625rem', lineHeight: 1.2, color: DS_NEUTRAL.white, overflowWrap: 'break-word' }}
          >
            {presence.name}
          </Typography>
          <Typography
            // Umbrechen statt abschneiden: «Besichtigungsassistent» passt in
            // einer schmalen Karte nicht in eine Zeile, und eine halbe
            // Funktionsbezeichnung ist keine.
            sx={{ fontSize: '0.8125rem', lineHeight: 1.3, color: 'rgba(255,255,255,0.72)', overflowWrap: 'break-word' }}
          >
            {presence.role}
          </Typography>
          {(presence.department || presence.personnelNumber) && (
            <Typography
              sx={{
                mt: 0.25,
                fontSize: '0.6875rem',
                lineHeight: 1.3,
                color: 'rgba(255,255,255,0.42)',
                overflowWrap: 'break-word',
                // Umbrechen statt abschneiden: in einer schmalen Karte fiele
                // sonst ausgerechnet die Personalnummer weg, und die macht aus
                // einem Werkzeug einen Mitarbeitenden.
              }}
            >
              {[presence.department, presence.personnelNumber].filter(Boolean).join(' · ')}
            </Typography>
          )}
        </Box>
      </Box>
      {/* Kompetenz: was der Mitarbeitende selbst entscheiden darf. */}
      {presence.autonomy && (
        <Box
          sx={{
            alignSelf: 'flex-start',
            px: 1,
            py: 0.25,
            borderRadius: 1,
            bgcolor: 'rgba(255,255,255,0.09)',
            border: '1px solid rgba(255,255,255,0.14)',
          }}
        >
          <Typography
            sx={{
              fontSize: '0.625rem',
              fontWeight: 700,
              letterSpacing: 0.6,
              textTransform: 'uppercase',
              color: 'rgba(255,255,255,0.66)',
            }}
          >
            {presence.autonomy}
          </Typography>
        </Box>
      )}
      {/* Was er dazu sagt — in der ersten Person. */}
      {workload && (
        <Box sx={{ display: 'flex', gap: 1, alignItems: 'flex-start' }}>
          <Box
            sx={{ width: 3, alignSelf: 'stretch', borderRadius: 2, bgcolor: toneColor, flexShrink: 0 }}
          />
          <Typography
            sx={{
              fontSize: '0.8125rem',
              lineHeight: 1.45,
              color: 'rgba(255,255,255,0.92)',
              overflowWrap: 'break-word',
            }}
          >
            {workload.voice}
          </Typography>
        </Box>
      )}
      {/* Beleg: was zuletzt tatsächlich getan wurde. */}
      <Box sx={{ mt: 'auto', pt: 1, borderTop: '1px solid rgba(255,255,255,0.10)' }}>
        {presence.lastAction ? (
          <>
            <Typography
              sx={{
                fontSize: '0.625rem',
                fontWeight: 700,
                letterSpacing: 0.8,
                textTransform: 'uppercase',
                color: 'rgba(255,255,255,0.38)',
              }}
            >
              Zuletzt · {presence.lastAction.when}
            </Typography>
            <Box sx={{ display: 'flex', alignItems: 'flex-start', gap: 1 }}>
              <Typography
                sx={{
                  flex: 1,
                  minWidth: 0,
                  fontSize: '0.75rem',
                  lineHeight: 1.4,
                  color: 'rgba(255,255,255,0.62)',
                  overflowWrap: 'break-word',
                  display: '-webkit-box',
                  WebkitLineClamp: 2,
                  WebkitBoxOrient: 'vertical',
                  overflow: 'hidden',
                }}
              >
                {presence.lastAction.title}
              </Typography>
              <Box
                className="staff-go"
                sx={{
                  color: DS_NEUTRAL.gold,
                  opacity: 0,
                  transform: 'translateX(-4px)',
                  transition: 'opacity 0.18s ease, transform 0.18s ease',
                  flexShrink: 0,
                  mt: 0.25,
                }}
              >
                <ArrowRight size={16} />
              </Box>
            </Box>
          </>
        ) : (
          <Typography sx={{ fontSize: '0.75rem', color: 'rgba(255,255,255,0.42)' }}>
            Noch keine Tätigkeit protokolliert.
          </Typography>
        )}
      </Box>
    </ButtonBase>
  )
 })
@@ -1,172 +0,0 @@
 import { useCallback, useMemo } from 'react'
 import { useNavigate } from 'react-router'
 import { Box, Typography } from '@mui/material'
 import { StaffBackdrop } from './StaffBackdrop'
 import { AgentStaffCard } from './AgentStaffCard'
 import { useAgentPresence } from '../../hooks/useAgentPresence'
 import { WorkloadTone } from '../../domain/agentWorkload'
 import { DS_NEUTRAL } from '../../lib/ds'
 /**
 * Mindesthöhe, damit die Belegschaft eine Fläche hat und nicht als schmaler
 * Streifen über der Objektliste klebt.
 *
 * Eine feste oder gedeckelte Höhe hatte dieser Bereich früher — und genau das
 * war der Fehler: passte der Inhalt nicht hinein, scrollte er in sich selbst,
 * die Porträts wurden oben abgeschnitten und neben der Seite stand ein zweiter
 * Scrollbalken. Die Höhe richtet sich deshalb nach dem Inhalt. Damit der Titel
 * «Meine Objekte» beim Einstieg sichtbar bleibt (§2.3), stehen die fünf
 * Mitarbeitenden auf grossen Schirmen in einer einzigen Reihe statt in zweien.
 */
 const MIN_SCENE_PX = 360
 /**
 * Grösste Breite der Karten samt Anriss. Freilaufend würden bei drei Spalten
 * auf einem 2560er Monitor Karten von über 700 Pixeln entstehen — flache
 * Streifen, in denen zwei Textzeilen verloren stehen. Der Hintergrund bleibt
 * randlos, nur der Inhalt wird gefasst und mittig gestellt.
 */
 const MAX_CONTENT_PX = 1280
 /**
 * Die digitale Belegschaft auf der Startseite (Runde 5, §3).
 *
 * Die fünf Mitarbeitenden an ihrem Arbeitsplatz — mit Porträt, Funktion,
 * Abteilung, Personalnummer, Dienstzustand, einem Satz in der ersten Person
 * und der zuletzt protokollierten Handlung. Ein Klick auf eine Karte öffnet
 * den jeweiligen Arbeitsbereich. Die Personalverwaltung selbst liegt im
 * Menüpunkt «Meine Agenten» und braucht keine eigene Person am Bildschirm.
 *
 * Bewusst keine nachgebaute Raumperspektive mehr: eine gezeichnete Kulisse
 * bleibt neben fotografierten Porträts erkennbar gezeichnet, und ein Raum
 * allein macht niemanden menschlich. Was menschlich wirkt, ist dasselbe wie im
 * echten Büro — dass jemand da ist, etwas zu sagen hat und nachweisbar
 * gearbeitet hat.
 */
 export function AgentStaffOverview() {
  const navigate = useNavigate()
  const { data: staff } = useAgentPresence()
  const handleOpen = useCallback((path: string) => navigate(path), [navigate])
  // Ein Durchgang über dieselbe Liste statt zweier Filterläufe (CLAUDE.md §10.4).
  const { urgent, onDuty } = useMemo(() => {
    let urgentCount = 0
    let onDutyCount = 0
    for (const person of staff) {
      if (person.workload?.tone === WorkloadTone.URGENT) urgentCount += 1
      if (person.onDuty) onDutyCount += 1
    }
    return { urgent: urgentCount, onDuty: onDutyCount }
  }, [staff])
  return (
    <Box
      component="section"
      aria-label="Digitale Belegschaft"
      sx={{
        position: 'relative',
        display: 'flex',
        flexDirection: 'column',
        minHeight: MIN_SCENE_PX,
        overflow: 'hidden',
      }}
    >
      <StaffBackdrop />
      <Box
        sx={{
          position: 'relative',
          display: 'flex',
          flexDirection: 'column',
          width: '100%',
          maxWidth: MAX_CONTENT_PX,
          mx: 'auto',
          px: { xs: 2.5, lg: 4 },
          py: { xs: 2.5, lg: 3 },
          gap: { xs: 2, lg: 2.5 },
        }}
      >
        <StaffHeadline urgent={urgent} onDuty={onDuty} total={staff.length} />
        <Box
          sx={{
            /*
             * Ab `lg` stehen alle fünf nebeneinander in einer Reihe. Zwei
             * Reihen brauchten rund 250 Pixel mehr Höhe — auf einem Laptop war
             * das genau der Betrag, der den Bereich zum Scrollen brachte und
             * die Porträts der oberen Reihe abschnitt. Eine Reihe ist zugleich
             * das ehrlichere Bild: fünf Kolleginnen und Kollegen nebeneinander,
             * keine Hierarchie über zwei Ebenen.
             *
             * Darunter wird umbrochen, weil fünf Karten nebeneinander unter
             * 1200 Pixeln unlesbar schmal würden.
             */
            display: 'flex',
            flexWrap: 'wrap',
            justifyContent: 'center',
            alignItems: 'stretch',
            gap: { xs: 1.5, lg: 2 },
            '& > *': {
              flex: {
                xs: '1 1 100%',
                sm: '0 1 calc((100% - 12px) / 2)',
                md: '0 1 calc((100% - 24px) / 3)',
                lg: '0 1 calc((100% - 64px) / 5)',
              },
            },
          }}
        >
          {staff.map(person => (
            <AgentStaffCard key={person.agentId} presence={person} onOpen={handleOpen} />
          ))}
        </Box>
      </Box>
    </Box>
  )
 }
 /**
 * Anriss über der Belegschaft.
 *
 * Beantwortet die Frage, mit der jemand diese Seite öffnet: muss ich heute
 * irgendwo eingreifen? Ohne den Satz müsste man jede Karte einzeln lesen und
 * selbst zusammenzählen.
 */
 function StaffHeadline({ urgent, onDuty, total }: { urgent: number; onDuty: number; total: number }) {
  const summary =
    urgent > 0
      ? `${urgent} ${urgent === 1 ? 'Mitarbeitender braucht' : 'Mitarbeitende brauchen'} heute eine Entscheidung von dir`
      : 'Alle laufen — heute liegt nichts bei dir'
  return (
    <Box sx={{ flexShrink: 0 }}>
      <Box sx={{ display: 'flex', alignItems: 'center', gap: 1 }}>
        <Box sx={{ width: 7, height: 7, borderRadius: '50%', bgcolor: DS_NEUTRAL.gold }} />
        <Typography
          sx={{
            fontSize: '0.6875rem',
            fontWeight: 700,
            letterSpacing: 1.4,
            textTransform: 'uppercase',
            color: DS_NEUTRAL.gold,
          }}
        >
          {onDuty} von {total} im Dienst
        </Typography>
      </Box>
      <Typography
        component="h2"
        sx={{
          mt: 0.5,
          fontWeight: 700,
          fontSize: { xs: '1.25rem', lg: '1.6rem' },
          lineHeight: 1.2,
          color: DS_NEUTRAL.white,
        }}
      >
        {summary}
      </Typography>
    </Box>
  )
 }
@@ -0,0 +1,341 @@
 import { useCallback, useEffect, useRef, useState } from 'react'
 import { useNavigate } from 'react-router'
 import * as THREE from 'three'
 import { Box, Typography } from '@mui/material'
 import { createMeetingRoomScene } from './meetingRoomScene'
 import type { MeetingRoomScene } from './meetingRoomScene'
 import { MEETING_SEATS } from './meetingRoomSeats'
 import { AGENT_PHOTOS } from '../team/agentPhotos'
 import { useAgentWorkload } from '../../hooks/useAgentWorkload'
 import { WorkloadTone } from '../../domain/agentWorkload'
 import { DS_ACCENT, DS_NEUTRAL } from '../../lib/ds'
 /**
 * Farben der Auslastung auf dunklem Grund. Hellere Stufen als die
 * Standardakzente — die dunkleren verschwinden vor der Szene.
 */
 const TONE_COLOR: Record<WorkloadTone, string> = {
  [WorkloadTone.CALM]: DS_ACCENT.success.emerald,
  [WorkloadTone.ATTENTION]: DS_ACCENT.warning.amber,
  [WorkloadTone.URGENT]: DS_ACCENT.danger.bright,
 }
 /**
 * Höhe der Kopfzeile plus des Streifens, der unter dem Raum sichtbar bleiben
 * muss: Titel «Meine Objekte» und der Beginn von «Filter & Übersicht»
 * (Runde 6, §1.1).
 */
 const TOP_BAR_PX = 64
 const KEEP_VISIBLE_BELOW_PX = 124
 /** Unter dieser Höhe verliert die Perspektive ihre Wirkung. */
 const MIN_HEIGHT_PX = 380
 /** Darüber wird der Raum zur Landschaft und die Objektliste rutscht zu weit weg. */
 const MAX_HEIGHT_PX = 760
 /**
 * Virtueller 3D-Meetingraum auf der Startseite (Runde 6, §1–§9).
 *
 * Der Betrachter sitzt am Kopfende des Tisches und sieht seine Agenten vor sich.
 * Die Kamera ist fest; als einzige Bewegung folgt sie der Maus um wenige
 * Zentimeter, damit die Szene lebt, ohne die verbindliche Perspektive zu
 * verlassen (§20).
 *
 * Die Beschriftungen sind HTML und nicht Teil der 3D-Szene. Als Textur im Raum
 * wären sie bei Tiefe unlesbar; als DOM-Element bleiben sie scharf, lassen sich
 * mit den Mitteln des Designsystems gestalten und sind für Screenreader
 * vorhanden. Ihre Position kommt aus der Szene: jede Bildwiederholung projiziert
 * den Ankerpunkt über dem Kopf auf den Bildschirm.
 *
 * Gerendert wird nur bei Anlass — Grösse, Maus, Hover. Ein Dauerloop wäre für
 * eine statische Szene verschwendete Rechenzeit (§21).
 */
 export function MeetingRoom3D() {
  const navigate = useNavigate()
  const canvasRef = useRef<HTMLCanvasElement>(null)
  const wrapRef = useRef<HTMLDivElement>(null)
  const sceneRef = useRef<MeetingRoomScene | null>(null)
  const labelRefs = useRef(new Map<string, HTMLDivElement | null>())
  const hoveredRef = useRef<string | null>(null)
  const [hovered, setHovered] = useState<string | null>(null)
  // Beim Hover zeigt die Plakette zusätzlich, woran der Agent gerade sitzt.
  // Ruhend bleibt sie bei Name und Funktion (§8).
  const { data: workload } = useAgentWorkload()
  /**
   * Beschriftungen an die projizierten Kopfpositionen setzen.
   *
   * Danach folgt ein Entzerrungsdurchgang: Plätze weiter hinten rücken in der
   * Perspektive auf wenige Bildpunkte zusammen, ihre Plaketten lägen dort
   * übereinander. Wer mit einem bereits gesetzten Nachbarn kollidiert, wandert
   * so weit nach oben, bis er frei steht.
   *
   * Bewusst nach der Projektion und nicht über handverlesene Höhen in der
   * Szene: gerechnete Abstände halten auf jeder Fenstergrösse, fest gesetzte
   * Werte gelten nur für die Breite, an der sie eingestellt wurden.
   */
  const positionLabels = useCallback(() => {
    const s = sceneRef.current
    const wrap = wrapRef.current
    if (!s || !wrap) return
    const w = wrap.clientWidth
    const h = wrap.clientHeight
    const v = new THREE.Vector3()
    type Placed = { el: HTMLDivElement; x: number; y: number; halfW: number; height: number }
    const placed: Placed[] = []
    // Von vorne nach hinten: die vorderen Plaketten behalten ihren Platz, die
    // hinteren geben nach. Das entspricht der Tiefenordnung im Bild.
    const ordered = [...s.seats].sort((a, b) => b.labelAnchor.z - a.labelAnchor.z)
    for (const handle of ordered) {
      const el = labelRefs.current.get(handle.seat.id)
      if (!el) continue
      v.copy(handle.labelAnchor).project(s.camera)
      let y = (-v.y * 0.5 + 0.5) * h
      // Weiter hinten sitzende Beschriftungen werden kleiner, bleiben aber über
      // einer Untergrenze lesbar (§8 «bei räumlicher Tiefe ausreichend lesbar»).
      const scale = Math.max(0.68, Math.min(1, 1 - (v.z - 0.955) * 8))
      const halfW = (el.offsetWidth * scale) / 2
      const height = el.offsetHeight * scale
      // Innerhalb des Bildes halten: auf schmalen Fenstern liegen die äusseren
      // Plätze so weit aussen, dass ihre Beschriftung sonst abgeschnitten wird.
      const x = Math.min(Math.max((v.x * 0.5 + 0.5) * w, halfW + 6), w - halfW - 6)
      for (const other of placed) {
        const overlapsX = Math.abs(x - other.x) < halfW + other.halfW + 6
        const overlapsY = Math.abs(y - other.y) < Math.max(height, other.height) + 4
        if (overlapsX && overlapsY) {
          y = other.y - Math.max(height, other.height) - 6
        }
      }
      placed.push({ el, x, y, halfW, height })
      el.style.transform =
        `translate(-50%, -100%) translate(${x.toFixed(1)}px, ${y.toFixed(1)}px) scale(${scale.toFixed(3)})`
    }
  }, [])
  const draw = useCallback(() => {
    sceneRef.current?.render()
    positionLabels()
  }, [positionLabels])
  // ── Szene aufbauen ──
  useEffect(() => {
    const canvas = canvasRef.current
    const wrap = wrapRef.current
    if (!canvas || !wrap) return
    const s = createMeetingRoomScene(canvas, MEETING_SEATS, AGENT_PHOTOS)
    sceneRef.current = s
    s.setSize(wrap.clientWidth, wrap.clientHeight)
    s.render()
    positionLabels()
    // Texturen kommen asynchron; ohne ein zweites Zeichnen bliebe die Szene
    // beim Stand des ersten Bildes stehen — ohne Fotos, ohne Kulisse.
    THREE.DefaultLoadingManager.onLoad = () => {
      s.render()
      positionLabels()
    }
    const ro = new ResizeObserver(() => {
      s.setSize(wrap.clientWidth, wrap.clientHeight)
      s.render()
      positionLabels()
    })
    ro.observe(wrap)
    return () => {
      THREE.DefaultLoadingManager.onLoad = () => {}
      ro.disconnect()
      s.dispose()
      sceneRef.current = null
    }
  }, [positionLabels])
  /**
   * Maus: nur noch Trefferprüfung, keine Bewegung mehr (Runde 9, §1).
   *
   * Bis hierher folgte die Kamera dem Zeiger — eine leichte Parallaxe, die den
   * Raum lebendig wirken lassen sollte. Gewünscht ist jetzt eine vollständig
   * ruhige Szene: Wer die Agenten anschaut, soll sie anschauen und nicht ein
   * Bild, das unter dem Zeiger wegkippt.
   *
   * Entfernt ist ausschliesslich der Aufruf von `applyParallax` — die Szene
   * selbst, ihre Kameraposition, Sitzordnung und Beschriftungen bleiben
   * unverändert. Das Erkennen des Agenten unter dem Zeiger und der Klick auf
   * seinen Platz sind keine Bewegung und bleiben deshalb.
   */
  const handlePointerMove = useCallback((e: React.PointerEvent<HTMLDivElement>) => {
    const s = sceneRef.current
    const wrap = wrapRef.current
    if (!s || !wrap) return
    const rect = wrap.getBoundingClientRect()
    const nx = ((e.clientX - rect.left) / rect.width) * 2 - 1
    const ny = -(((e.clientY - rect.top) / rect.height) * 2 - 1)
    const ray = new THREE.Raycaster()
    ray.setFromCamera(new THREE.Vector2(nx, ny), s.camera)
    const hit = ray.intersectObjects(s.seats.map(h => h.hitBox), false)[0]
    const id = hit ? (s.seats.find(h => h.hitBox === hit.object)?.seat.id ?? null) : null
    if (id !== hoveredRef.current) {
      hoveredRef.current = id
      s.setHovered(id)
      setHovered(id)
    }
    draw()
  }, [draw])
  const handlePointerLeave = useCallback(() => {
    const s = sceneRef.current
    if (!s) return
    hoveredRef.current = null
    s.setHovered(null)
    setHovered(null)
    draw()
  }, [draw])
  const handleClick = useCallback(() => {
    const id = hoveredRef.current
    if (!id) return
    const seat = MEETING_SEATS.find(x => x.id === id)
    if (seat) navigate(seat.path)
  }, [navigate])
  return (
    <Box
      component="section"
      aria-label="Virtueller Meetingraum mit den digitalen Mitarbeitenden"
      ref={wrapRef}
      onPointerMove={handlePointerMove}
      onPointerLeave={handlePointerLeave}
      onClick={handleClick}
      sx={{
        position: 'relative',
        width: '100%',
        height: `clamp(${MIN_HEIGHT_PX}px, calc(100vh - ${TOP_BAR_PX + KEEP_VISIBLE_BELOW_PX}px), ${MAX_HEIGHT_PX}px)`,
        '@supports (height: 100dvh)': {
          height: `clamp(${MIN_HEIGHT_PX}px, calc(100dvh - ${TOP_BAR_PX + KEEP_VISIBLE_BELOW_PX}px), ${MAX_HEIGHT_PX}px)`,
        },
        overflow: 'hidden',
        cursor: hovered ? 'pointer' : 'default',
        bgcolor: DS_NEUTRAL.sidebar,
      }}
    >
      <Box component="canvas" ref={canvasRef} sx={{ display: 'block', width: '100%', height: '100%' }} />
      {/*
        Beschriftungen über den Köpfen (§8). Sie liegen über dem Bild, nehmen
        aber keine Klicks an — der Klick gehört der Szene darunter, damit der
        Trefferkörper des Agenten entscheidet und nicht die Textbreite.
      */}
      {MEETING_SEATS.map(seat => {
        const on = hovered === seat.id
        return (
          <Box
            key={seat.id}
            ref={(el: HTMLDivElement | null) => { labelRefs.current.set(seat.id, el) }}
            sx={{
              position: 'absolute',
              top: 0,
              left: 0,
              pointerEvents: 'none',
              textAlign: 'center',
              whiteSpace: 'nowrap',
              px: 1,
              py: 0.375,
              borderRadius: 1.5,
              transformOrigin: 'bottom center',
              transition: 'background-color 0.15s ease, box-shadow 0.15s ease',
              // Kein starker Kasten, der den Raum verdeckt (§8) — aber ohne jede
              // Unterlage verschwindet weisse Schrift vor der hellen Glasfront.
              // Deshalb ein leichter Schleier mit Weichzeichnung, der bei Hover
              // etwas dichter wird.
              bgcolor: on ? 'rgba(11,18,29,0.74)' : 'rgba(11,18,29,0.34)',
              backdropFilter: 'blur(3px)',
              boxShadow: on ? '0 6px 20px rgba(0,0,0,0.35)' : 'none',
            }}
          >
            <Typography
              sx={{
                fontWeight: 700,
                fontSize: '0.875rem',
                lineHeight: 1.2,
                color: DS_NEUTRAL.white,
                textShadow: '0 1px 6px rgba(0,0,0,0.75)',
              }}
            >
              {seat.name}
            </Typography>
            <Typography
              sx={{
                fontSize: '0.6875rem',
                lineHeight: 1.25,
                color: on ? DS_NEUTRAL.gold : 'rgba(255,255,255,0.82)',
                textShadow: '0 1px 6px rgba(0,0,0,0.75)',
              }}
            >
              {seat.role}
            </Typography>
            {/*
              Nur bei Hover: die aktuelle Auslastung. Ruhend bliebe die Plakette
              sonst überdimensioniert (§8), im Hover ist die Hervorhebung
              ausdrücklich erlaubt — und sie sagt vor dem Klick, was drüben liegt.
            */}
            {on && workload[seat.id] && (
              <Typography
                sx={{
                  mt: 0.25,
                  fontSize: '0.6875rem',
                  fontWeight: 600,
                  lineHeight: 1.25,
                  color: TONE_COLOR[workload[seat.id].tone],
                }}
              >
                {workload[seat.id].label}
              </Typography>
            )}
          </Box>
        )
      })}
      {/*
        Tastaturweg zu denselben Zielen. Die Szene selbst ist ein Canvas und
        damit für die Tastatur unerreichbar; ohne diese Schalter wären die
        Agenten nur mit der Maus erreichbar.
      */}
      <Box
        sx={{
          position: 'absolute', left: 0, top: 0, width: 1, height: 1,
          overflow: 'hidden', clip: 'rect(0 0 0 0)',
        }}
      >
        {MEETING_SEATS.map(seat => (
          <button
            key={seat.id}
            type="button"
            onClick={e => { e.stopPropagation(); navigate(seat.path) }}
            onFocus={() => {
              hoveredRef.current = seat.id
              sceneRef.current?.setHovered(seat.id)
              setHovered(seat.id)
              draw()
            }}
          >
            {`${seat.name}, ${seat.role} — Arbeitsbereich öffnen`}
          </button>
        ))}
      </Box>
    </Box>
  )
 }
@@ -1,39 +0,0 @@
 import { memo } from 'react'
 import { Box } from '@mui/material'
 import { ROOM_BACKDROP } from './roomBackdrop'
 import { DS_NEUTRAL } from '../../lib/ds'
 /**
 * Bildhintergrund der Belegschaftsansicht (Runde 5, §3).
 *
 * Bewusst eine einzige Bildfläche mit Verlauf — und nicht länger ein aus
 * Flächen konstruierter Raum. Ein selbstgezeichneter Raum bleibt neben
 * fotografierten Porträts immer erkennbar gezeichnet; die Bildwirkung muss
 * deshalb aus dem Foto kommen, nicht aus Geometrie.
 *
 * Die Komponente selbst weiss nichts über das Motiv. Sie zeigt, was
 * `ROOM_BACKDROP` liefert — die Aussicht heute, eine Raumaufnahme später.
 */
 export const StaffBackdrop = memo(function StaffBackdrop() {
  return (
    <Box sx={{ position: 'absolute', inset: 0, overflow: 'hidden', bgcolor: DS_NEUTRAL.sidebar }}>
      <Box
        component="img"
        src={ROOM_BACKDROP.src}
        alt=""
        aria-hidden="true"
        sx={{
          position: 'absolute',
          inset: 0,
          width: '100%',
          height: '100%',
          objectFit: 'cover',
          objectPosition: ROOM_BACKDROP.focus,
        }}
      />
      <Box sx={{ position: 'absolute', inset: 0, background: ROOM_BACKDROP.scrim }} />
    </Box>
  )
 })
@@ -1,5 +1,5 @@
-// Digitale Belegschaft auf der Startseite (Runde 5, §3). Barrel-Export (CLAUDE.md §13).
+// Virtueller 3D-Meetingraum der Startseite (Runde 6). Barrel-Export (CLAUDE.md §13).
-export { AgentStaffOverview } from './AgentStaffOverview'
+export { MeetingRoom3D } from './MeetingRoom3D'
-export { AgentStaffCard } from './AgentStaffCard'
+export { MEETING_SEATS, SeatSide } from './meetingRoomSeats'
-export { ROOM_BACKDROP } from './roomBackdrop'
+export type { MeetingSeat } from './meetingRoomSeats'
@@ -0,0 +1,103 @@
 /**
 * Farben und Maße des 3D-Meetingraums (Runde 6, §3/§5).
 *
 * Die Farben stehen als Zahlen und nicht als Hexzeichenketten, weil three.js
 * Zahlen erwartet — `new Color(0x…)` ist der direkte Weg, jede Umwandlung
 * dazwischen wäre nur Umweg. Sie liegen hier statt in der Szene, damit sich die
 * Materialstimmung an einer Stelle ändern lässt (CLAUDE.md §8).
 *
 * Der Raum ist «modern, hochwertig, zurückhaltend, nicht futuristisch»: warmes
 * Eichenholz, heller Putz, Anthrazitteppich, mattgraue Fensterprofile. Als
 * einziger Markenbezug trägt die geschlossene Wand einen schmalen Streifen im
 * Property-Match-Blau (§3 «darf subtil aufgenommen werden»).
 */
 export const ROOM_COLORS = {
  floor: 0x4b4741,
  floorSheen: 0x5d5852,
  ceiling: 0xf6f5f2,
  ceilingRail: 0xeeebe5,
  /** Geschlossene Wand rechts: heller Putz mit Eichenpaneel im unteren Drittel. */
  wall: 0xe8e4dc,
  wallPanel: 0x9c7b52,
  wallSkirting: 0xd6d1c7,
  /** Schmaler Markenstreifen auf der geschlossenen Wand. */
  brandStripe: 0x152642,
  /** Fensterprofile und Pfosten. */
  mullion: 0x6b7079,
  frame: 0x585d65,
  /** Glasscheibe: sehr schwacher Blauschleier, sonst wäre sie unsichtbar. */
  glass: 0xd8e8f0,
  /** Tischplatte in Eiche, Kante etwas dunkler. */
  tableTop: 0x8f7350,
  tableEdge: 0x6f5637,
  tableBase: 0x35322f,
  /** Ring um das Porträt — hebt den Kopf vom Hintergrund ab. */
  headRing: 0xffffff,
  /** Ring bei Hover: Gold aus dem Designsystem. */
  headRingHover: 0xb8975a,
  /** Himmel hinter der Kulisse, falls doch ein Rand sichtbar wird. */
  sky: 0xbcd7e6,
 } as const
 /**
 * Raumgeometrie in Metern. Der Betrachter sitzt am Kopfende bei z ≈ 0 und
 * schaut in Richtung −z; die Fensterfront gegenüber liegt bei z = −ROOM.depth.
 */
 export const ROOM = {
  width: 7.4,
  height: 3.05,
  depth: 9.2,
 } as const
 /** Kamera: Augenhöhe einer sitzenden Person am Kopfende (§2). */
 export const CAMERA = {
  /** Sitzende Augenhöhe über dem Boden. */
  eyeHeight: 1.19,
  /** Knapp hinter der vorderen Tischkante. */
  z: 1.9,
  fov: 48,
  /**
   * Obergrenze des waagrechten Bildwinkels in Grad. Greift nur bei sehr breiten
   * und gleichzeitig flachen Fenstern; bei üblichen Seitenverhältnissen liegt
   * der waagrechte Winkel darunter und die Ansicht bleibt unverändert.
   */
  maxHFov: 84,
  /** Blickziel: leicht unter Augenhöhe, damit die Tischplatte Tiefe zeigt. */
  lookAt: [0, 1.24, -5.2] as const,
  /*
   * Die Parallaxe ist mit Runde 9 (§1) entfallen: Die Kamera folgte dem Zeiger
   * um bis zu 7,5 Zentimeter, was den Raum beleben sollte und stattdessen als
   * Wackeln wahrgenommen wurde. Kameraposition und Blickziel bleiben exakt
   * dieselben — nur bewegt sich nichts mehr.
   */
 } as const
 /** Meetingtisch (§5): längliche Form, führt vom Betrachter weg. */
 export const TABLE = {
  width: 1.70,
  /** Höhe der Plattenoberseite über dem Boden. */
  top: 0.745,
  thickness: 0.06,
  /** Vordere Kante, knapp vor der Kamera. */
  zNear: 0.15,
  /** Hintere Kante, vor dem Platz von Thomas. */
  zFar: -5.75,
 } as const
 /** Sitzende Personen: Höhe der Porträtkreise. */
 export const SEATED = {
  /**
   * Luft zwischen Tischplatte und Unterkante des Porträtkreises (Runde 7, §2).
   *
   * Daraus ergibt sich die Kopfhöhe: `TABLE.top + radius + headGap`. Die Kreise
   * schweben damit nur knapp über der Tischkante statt weit darüber. Vorher
   * hingen sie fest auf 1.52 m — bei den jetzt deutlich grösseren Kreisen sähe
   * das aus, als schwebten Köpfe frei im Raum.
   *
   * Getrennt gehalten werden die Plätze in der Tiefe nicht über die Höhe,
   * sondern seitlich: die Werte in `meetingRoomSeats` sind so gewählt, dass sich
   * im Bild keine zwei Kreise überschneiden.
   */
  headGap: 0.05,
 } as const
@@ -0,0 +1,611 @@
 import * as THREE from 'three'
 import { ROOM, ROOM_COLORS, CAMERA, TABLE, SEATED } from './meetingRoomPalette'
 import { SeatSide } from './meetingRoomSeats'
 import type { MeetingSeat } from './meetingRoomSeats'
 import baselPanorama from '../../assets/staff/basel-panorama.jpg'
 /**
 * Aufbau des virtuellen Meetingraums (Runde 6, §2–§6).
 *
 * Bewusst ohne React: hier entsteht nur der three.js-Graph. Die Komponente
 * daneben kümmert sich um Einbettung, Grösse, Maus und Beschriftungen. Diese
 * Trennung hält beide Teile lesbar — eine Datei mit Szene *und* Reactzustand
 * wäre unübersichtlich und schwer zu verändern.
 *
 * Die Kamera sitzt auf Augenhöhe einer sitzenden Person am Kopfende des
 * Tisches und ist fest: keine Orbit-Steuerung, keine freie Navigation (§20).
 * Der Tisch läuft von ihr weg in den Raum, links und rechts sitzen die
 * Agenten, am gegenüberliegenden Kopfende Thomas.
 *
 * Es wird **nicht** dauernd gerendert. Die Komponente ruft `render()` nur bei
 * Grössenänderung, Mausbewegung und Zustandswechsel auf — ein Dauerloop wäre
 * für eine statische Szene verschwendete Rechenzeit (§21).
 */
 /** Ein anklickbarer Platz samt seiner Teile in der Szene. */
 export interface SeatHandle {
  seat: MeetingSeat
  /** Unsichtbarer Trefferkörper für den Raycaster. */
  hitBox: THREE.Mesh
  /** Ring hinter dem Porträt — wird bei Hover golden. */
  ring: THREE.Mesh
  /** Gruppe aus Kopf, Ring und Körper; wird bei Hover leicht angehoben. */
  group: THREE.Group
  /** Weltposition für die schwebende Beschriftung (über dem Kopf). */
  labelAnchor: THREE.Vector3
 }
 export interface MeetingRoomScene {
  scene: THREE.Scene
  camera: THREE.PerspectiveCamera
  renderer: THREE.WebGLRenderer
  seats: SeatHandle[]
  /** Kamera anhand eines Zeigerversatzes (−1…1) leicht versetzen. */
  setSize: (width: number, height: number) => void
  render: () => void
  setHovered: (id: string | null) => void
  dispose: () => void
 }
 // ── Bausteine ────────────────────────────────────────────────────────────────
 function addRoomShell(scene: THREE.Scene) {
  const { width, height, depth } = ROOM
  const halfW = width / 2
  // Boden — ein leichter Verlauf über zwei Flächen wäre teuer; ein matter Ton
  // mit heller Kante zur Fensterseite genügt für die Tiefenwirkung.
  const floor = new THREE.Mesh(
    new THREE.PlaneGeometry(width, depth),
    new THREE.MeshLambertMaterial({ color: ROOM_COLORS.floor }),
  )
  floor.rotation.x = -Math.PI / 2
  floor.position.set(0, 0, -depth / 2)
  scene.add(floor)
  // Lichtstreifen auf dem Boden entlang der Glasfront
  const sheen = new THREE.Mesh(
    new THREE.PlaneGeometry(1.6, depth),
    new THREE.MeshBasicMaterial({ color: ROOM_COLORS.floorSheen, transparent: true, opacity: 0.5 }),
  )
  sheen.rotation.x = -Math.PI / 2
  sheen.position.set(-halfW + 1.1, 0.004, -depth / 2)
  scene.add(sheen)
  const ceiling = new THREE.Mesh(
    new THREE.PlaneGeometry(width, depth),
    // Unbeleuchtet: eine Lambertfläche, die nach unten schaut, bekommt von
    // Licht aus dem Raum nichts ab und säuft zu Grau ab.
    new THREE.MeshBasicMaterial({ color: ROOM_COLORS.ceiling }),
  )
  ceiling.rotation.x = Math.PI / 2
  ceiling.position.set(0, height, -depth / 2)
  scene.add(ceiling)
  // Deckenschiene über dem Tisch — gibt der Decke Struktur ohne Dekoration
  const rail = new THREE.Mesh(
    new THREE.BoxGeometry(0.14, 0.035, depth * 0.66),
    new THREE.MeshLambertMaterial({ color: ROOM_COLORS.ceilingRail }),
  )
  rail.position.set(0, height - 0.05, -depth / 2)
  scene.add(rail)
  // ── Rechte Wand: geschlossen (§3) ──
  const wall = new THREE.Mesh(
    new THREE.PlaneGeometry(depth, height),
    new THREE.MeshLambertMaterial({ color: ROOM_COLORS.wall }),
  )
  wall.rotation.y = -Math.PI / 2
  wall.position.set(halfW, height / 2, -depth / 2)
  scene.add(wall)
  // Eichenpaneel im unteren Drittel
  const panel = new THREE.Mesh(
    new THREE.PlaneGeometry(depth, 0.95),
    new THREE.MeshLambertMaterial({ color: ROOM_COLORS.wallPanel }),
  )
  panel.rotation.y = -Math.PI / 2
  panel.position.set(halfW - 0.01, 0.475, -depth / 2)
  scene.add(panel)
  // Schmaler Markenstreifen — der einzige Markenbezug im Raum
  const stripe = new THREE.Mesh(
    new THREE.PlaneGeometry(depth, 0.03),
    new THREE.MeshBasicMaterial({ color: ROOM_COLORS.brandStripe }),
  )
  stripe.rotation.y = -Math.PI / 2
  stripe.position.set(halfW - 0.02, 0.99, -depth / 2)
  scene.add(stripe)
  const skirting = new THREE.Mesh(
    new THREE.PlaneGeometry(depth, 0.08),
    new THREE.MeshLambertMaterial({ color: ROOM_COLORS.wallSkirting }),
  )
  skirting.rotation.y = -Math.PI / 2
  // Eine Idee vor dem Paneel: auf gleicher Höhe streiten sich die beiden
  // Flächen um dieselben Bildpunkte, und die Kante franst sichtbar aus.
  skirting.position.set(halfW - 0.015, 0.04, -depth / 2)
  scene.add(skirting)
 }
 /**
 * Basler Fernkulisse (Runde 6, §2).
 *
 * **Eine** gekrümmte Fläche mit **einem** Panoramabild — nicht mehr zwei
 * Flächen mit zwei Fotos. Genau deren Stossstelle war auf der linken
 * Fensterseite als harte Kante sichtbar. Auf einem durchgehenden Zylinder gibt
 * es diese Stelle nicht mehr: der Blick nach vorne und der Blick nach links
 * lesen dasselbe Bild an benachbarten Stellen, eine Naht ist geometrisch
 * unmöglich.
 *
 * Das Panorama entsteht einmalig aus den beiden Referenzfotos des Auftrags;
 * siehe `scripts/build-basel-panorama.mjs`. Das Motiv vom Tischende bleibt darin
 * unverändert und wird nach links fortgeführt.
 *
 * Die Zahlen sind so gewählt, dass Bildmasstab und Wasserlinie denen der
 * früheren Frontfläche entsprechen — das gut wirkende Motiv am Tischende
 * erscheint dadurch unverändert gross (§2.2).
 */
 function addBaselBackdrop(scene: THREE.Scene, loader: THREE.TextureLoader, maxAnisotropy: number) {
  /** Abstand der Kulisse. Weit genug, dass die Perspektive sie als Ferne liest. */
  const radius = 62
  /**
   * Masse der Panoramadatei. Ändert sich das Bild, gehören die Zahlen
   * nachgeführt — sonst zieht der Zylinder es in die Länge oder staucht es.
   */
  const panorama = { breite: 1028, hoehe: 660 }
  /**
   * Abgedeckter Bogen. Er beginnt rechts neben der Frontscheibe und läuft über
   * die Front nach links bis hinter die linke Glasfassade — mehr braucht es
   * nicht, und weniger Bogen heisst mehr Bildpunkte je Grad.
   *
   * Der Wert hält die Bildpunkte je Grad konstant: das Panorama ist seit
   * Runde 7 schmaler, weil die Fortsetzung nicht mehr überskaliert wird, und
   * der Bogen schrumpft im selben Verhältnis mit. Die Frontscheibe zeigt
   * dadurch unverändert denselben Ausschnitt in derselben Grösse (§1: der
   * Gesamteindruck bleibt, nur die Unsauberkeiten verschwinden).
   */
  const arc = 1.514
  /** Höhe passend zum Seitenverhältnis des Panoramas. */
  const height = (radius * arc) / (panorama.breite / panorama.hoehe)
  /** Wasserlinie im Panorama, als Anteil von oben. */
  const waterFraction = 400 / panorama.hoehe
  /** Höhe der Rheinoberfläche relativ zum Bürofussboden — wir sind im Hochhaus. */
  const waterY = -7.5
  const tex = loader.load(baselPanorama)
  tex.colorSpace = THREE.SRGBColorSpace
  tex.anisotropy = maxAnisotropy
  // Kein Wiederholen: der Bogen deckt genau die Bildbreite ab, und eine
  // Wiederholung wäre als Doppelung sichtbar (§2.2).
  tex.wrapS = THREE.ClampToEdgeWrapping
  tex.wrapT = THREE.ClampToEdgeWrapping
  const mesh = new THREE.Mesh(
    new THREE.CylinderGeometry(radius, radius, height, 96, 1, true, 0, arc),
    // Unbeleuchtet und von innen sichtbar: das Foto trägt seine eigene
    // Belichtung, jede Beleuchtung würde sie nur verfälschen.
    new THREE.MeshBasicMaterial({ map: tex, side: THREE.BackSide, fog: false }),
  )
  // Mittelpunkt so setzen, dass die Wasserlinie des Panoramas auf `waterY` liegt.
  mesh.position.y = waterY - height * (0.5 - waterFraction)
  /**
   * Drehung: geradeaus sichtbar ist die Bildstelle u = (π − Drehung) / Bogen.
   * Der Abzug von 0.68 setzt damit u ≈ 0.45 in die Blickachse — dort steht im
   * Panorama das Münster. Die Frontscheibe zeigt so das gute Motiv vom
   * Tischende, die linke Fassade seine Fortsetzung nach links.
   */
  mesh.rotation.y = Math.PI - 0.68
  scene.add(mesh)
 }
 /** Bodentiefe Glasfassade mit Pfosten — links und gegenüber (§3). */
 function addGlassFacades(scene: THREE.Scene) {
  const { width, height, depth } = ROOM
  const halfW = width / 2
  const glassMat = new THREE.MeshBasicMaterial({
    color: ROOM_COLORS.glass,
    transparent: true,
    opacity: 0.07,
    side: THREE.DoubleSide,
    depthWrite: false,
  })
  const frameMat = new THREE.MeshLambertMaterial({ color: ROOM_COLORS.mullion })
  // Gegenüberliegende Front
  const frontGlass = new THREE.Mesh(new THREE.PlaneGeometry(width, height), glassMat)
  frontGlass.position.set(0, height / 2, -depth)
  scene.add(frontGlass)
  // Linke Front
  const leftGlass = new THREE.Mesh(new THREE.PlaneGeometry(depth, height), glassMat)
  leftGlass.rotation.y = Math.PI / 2
  leftGlass.position.set(-halfW, height / 2, -depth / 2)
  scene.add(leftGlass)
  /** Senkrechter Pfosten. */
  function post(x: number, y: number, z: number, rotY = 0) {
    const m = new THREE.Mesh(new THREE.BoxGeometry(0.07, height, 0.09), frameMat)
    m.position.set(x, y, z)
    m.rotation.y = rotY
    scene.add(m)
  }
  /** Waagrechter Riegel. */
  function rail(len: number, x: number, y: number, z: number, rotY = 0) {
    const m = new THREE.Mesh(new THREE.BoxGeometry(len, 0.07, 0.09), frameMat)
    m.position.set(x, y, z)
    m.rotation.y = rotY
    scene.add(m)
  }
  // Pfosten der Frontscheibe — Thomas sitzt zwischen zwei Feldern, damit die
  // Stadtsilhouette rund um ihn sichtbar bleibt (§3 «rund um ihn herum»).
  for (const x of [-halfW, -1.5, 1.5, halfW]) post(x, height / 2, -depth)
  rail(width, 0, height - 0.035, -depth)
  rail(width, 0, 0.035, -depth)
  rail(width, 0, 2.28, -depth)
  // Pfosten der linken Front, alle 2 m
  for (let z = 0; z >= -depth; z -= 2) post(-halfW, height / 2, z, Math.PI / 2)
  rail(depth, -halfW, height - 0.035, -depth / 2, Math.PI / 2)
  rail(depth, -halfW, 0.035, -depth / 2, Math.PI / 2)
  rail(depth, -halfW, 2.28, -depth / 2, Math.PI / 2)
 }
 /** Meetingtisch samt Sockel und Kontaktschatten (§5). */
 function addTable(scene: THREE.Scene) {
  const length = TABLE.zNear - TABLE.zFar
  const zMid = (TABLE.zNear + TABLE.zFar) / 2
  const top = new THREE.Mesh(
    new THREE.BoxGeometry(TABLE.width, TABLE.thickness, length),
    new THREE.MeshLambertMaterial({ color: ROOM_COLORS.tableTop }),
  )
  top.position.set(0, TABLE.top, zMid)
  scene.add(top)
  // Kante minimal dunkler — lässt die Platte dicker und wertiger wirken
  const edge = new THREE.Mesh(
    new THREE.BoxGeometry(TABLE.width + 0.02, 0.018, length + 0.02),
    new THREE.MeshLambertMaterial({ color: ROOM_COLORS.tableEdge }),
  )
  edge.position.set(0, TABLE.top - TABLE.thickness / 2, zMid)
  scene.add(edge)
  // Zwei Sockelwangen statt vier Beine: verdeckt weniger und wirkt hochwertiger
  const baseMat = new THREE.MeshLambertMaterial({ color: ROOM_COLORS.tableBase })
  for (const z of [zMid - length * 0.28, zMid + length * 0.28]) {
    const base = new THREE.Mesh(new THREE.BoxGeometry(TABLE.width * 0.55, TABLE.top - 0.05, 0.12), baseMat)
    base.position.set(0, (TABLE.top - 0.05) / 2, z)
    scene.add(base)
  }
  // Kontaktschatten auf dem Boden — ohne ihn schwebt der Tisch
  const shadow = new THREE.Mesh(
    new THREE.PlaneGeometry(TABLE.width + 1.0, length + 0.8),
    new THREE.MeshBasicMaterial({ color: 0x000000, transparent: true, opacity: 0.28 }),
  )
  shadow.rotation.x = -Math.PI / 2
  shadow.position.set(0, 0.006, zMid)
  scene.add(shadow)
 }
 /**
 * Nachschärfen nach dem Verkleinern (Unschärfemaske).
 *
 * Beim Herunterrechnen eines Fotos verschwimmen Kanten — Wimpern, Brillenrand,
 * einzelne Haare. Das Bild minus seiner weichgezeichneten Fassung ergibt genau
 * diese Kantenzeichnung; verstärkt zurückgegeben holt sie die Zeichnung wieder
 * heran. Jedes Bildbearbeitungsprogramm macht das nach einer Verkleinerung.
 *
 * Die Stärke richtet sich danach, wie weit verkleinert wurde: wer kaum
 * verkleinert, braucht kaum Schärfung, sonst wirkt das Ergebnis überzeichnet.
 */
 function schaerfeNach(g: CanvasRenderingContext2D, flaeche: HTMLCanvasElement, ziel: number, kante: number) {
  const staerke = Math.min(0.6, Math.max(0, (kante / ziel - 1) * 0.5))
  if (staerke < 0.05) return
  const weich = document.createElement('canvas')
  weich.width = ziel
  weich.height = ziel
  const wg = weich.getContext('2d')
  if (!wg) return
  wg.filter = 'blur(0.8px)'
  wg.drawImage(flaeche, 0, 0)
  const scharf = g.getImageData(0, 0, ziel, ziel)
  const unscharf = wg.getImageData(0, 0, ziel, ziel)
  const a = scharf.data
  const b = unscharf.data
  for (let i = 0; i < a.length; i += 4) {
    for (let c = 0; c < 3; c++) {
      const wert = a[i + c] + staerke * (a[i + c] - b[i + c])
      a[i + c] = wert < 0 ? 0 : wert > 255 ? 255 : wert
    }
  }
  g.putImageData(scharf, 0, 0)
 }
 /**
 * Porträt laden und dabei auf seine Anzeigegrösse bringen (Runde 7, Nachtrag).
 *
 * Die Vorlagen haben 512 Bildpunkte, die Kreise erscheinen je nach Platz aber
 * nur 170 bis 330 gross. Bei so starker Verkleinerung greift die Grafikkarte
 * nicht auf die Vorlage zurück, sondern auf eine vorberechnete, halb oder
 * viertel so grosse Zwischenfassung. Das Ergebnis sind weiche Gesichter,
 * am deutlichsten bei den weiter hinten sitzenden Agenten.
 *
 * Wird die Textur vorab auf ihre Anzeigegrösse gerechnet, entfällt dieser
 * Zwischenschritt. Verkleinert wird einmalig auf einer Zeichenfläche, und die
 * rechnet dabei über alle Quellpunkte — deutlich sorgfältiger als die schnelle
 * Zwischenfassung der Grafikkarte.
 *
 * Zugleich entsteht hier der mittige quadratische Ausschnitt. Ohne ihn zöge die
 * Kreisfläche eine liegende Vorlage in die Breite.
 *
 * Geladen wird bewusst von Hand statt über `TextureLoader`: dessen Rückruf
 * liefert das fertige Bild nicht zuverlässig, und ohne Bildmasse lässt sich
 * weder zuschneiden noch massgerecht verkleinern. Die Zählung beim
 * Ladeverwalter bleibt erhalten, damit die Szene nach dem letzten Bild wie
 * bisher einmal neu zeichnet.
 */
 function ladePortraet(url: string, seat: MeetingSeat, leinwandHoehe: number, maxAnisotropy: number) {
  const tex = new THREE.Texture()
  tex.colorSpace = THREE.SRGBColorSpace
  // Anisotrope Filterung: die Kreise stehen schräg im Raum, ohne sie werden
  // die Porträts an den Rändern matschig.
  tex.anisotropy = maxAnisotropy
  tex.generateMipmaps = true
  tex.minFilter = THREE.LinearMipmapLinearFilter
  tex.magFilter = THREE.LinearFilter
  const verwalter = THREE.DefaultLoadingManager
  verwalter.itemStart(url)
  const bild = new Image()
  bild.onload = () => {
    const kante = Math.min(bild.width, bild.height)
    // Sichtbarer Durchmesser des Kreises in Bildpunkten der Leinwand
    const abstand = Math.hypot(seat.x, CAMERA.z - seat.z)
    const durchmesser = (seat.radius * leinwandHoehe) / (abstand * Math.tan((CAMERA.fov / 2) * Math.PI / 180))
    // Etwas Reserve für Fenster, die grösser sind als das aktuelle
    const ziel = Math.round(Math.min(kante, Math.max(160, durchmesser * 1.35)))
    const flaeche = document.createElement('canvas')
    flaeche.width = ziel
    flaeche.height = ziel
    const g = flaeche.getContext('2d')
    if (g) {
      g.imageSmoothingEnabled = true
      g.imageSmoothingQuality = 'high'
      g.drawImage(bild, (bild.width - kante) / 2, (bild.height - kante) / 2, kante, kante, 0, 0, ziel, ziel)
      schaerfeNach(g, flaeche, ziel, kante)
      tex.image = flaeche
    } else {
      tex.image = bild
    }
    tex.needsUpdate = true
    verwalter.itemEnd(url)
  }
  bild.onerror = () => {
    verwalter.itemError(url)
    verwalter.itemEnd(url)
  }
  bild.src = url
  return tex
 }
 /**
 * Ein Agent am Tisch (§3).
 *
 * Nur das runde Porträt mit einem weissen Ring — keine Stühle, keine Körper,
 * keine Arme. Die früheren Sitzmöbel und Rümpfe wirkten unnatürlich und sind
 * ersatzlos entfallen (§3.1).
 *
 * Das Porträt schaut zum Betrachter. Voll zur Tischmitte gedreht sähe man von
 * einem frontalen Porträtfoto nur die Kante; eine leichte Drehung zum Tisch
 * genügt, damit die Runde zusammengehört.
 */
 function addSeatedAgent(
  scene: THREE.Scene,
  seat: MeetingSeat,
  photoUrl: string | undefined,
  maxAnisotropy: number,
  leinwandHoehe: number,
 ): SeatHandle {
  const group = new THREE.Group()
  group.position.set(seat.x, 0, seat.z)
  const yaw =
    seat.side === SeatSide.HEAD ? 0
      : seat.side === SeatSide.LEFT ? 0.42
        : -0.42
  // Radius und Höhe stammen vom Platz: näher sitzende Agenten haben einen
  // kleineren Kreis, erscheinen im Bild aber grösser (Runde 7, §2).
  const radius = seat.radius
  const kopfHoehe = TABLE.top + radius + SEATED.headGap
  const head = new THREE.Group()
  head.position.y = kopfHoehe
  head.rotation.y = yaw
  const ring = new THREE.Mesh(
    new THREE.CircleGeometry(radius * 1.06, 48),
    new THREE.MeshBasicMaterial({ color: ROOM_COLORS.headRing }),
  )
  ring.position.z = -0.006
  head.add(ring)
  if (photoUrl) {
    const tex = ladePortraet(photoUrl, seat, leinwandHoehe, maxAnisotropy)
    const face = new THREE.Mesh(
      new THREE.CircleGeometry(radius, 96),
      new THREE.MeshBasicMaterial({ map: tex }),
    )
    head.add(face)
  }
  group.add(head)
  // ── Trefferkörper: gross genug für bequemes Klicken (§9) ──
  const hitBox = new THREE.Mesh(
    /*
     * Eine Kugel knapp um den sichtbaren Kreis — nicht ein grosszügiger Quader.
     * Ein weiter Quader am vorderen Platz fing die Strahlen der hinteren Plätze
     * ab: der Raycaster nimmt den nächstgelegenen Treffer, und damit landete ein
     * Klick auf Livia bei Ferdi. Die Trefferfläche deckt sich jetzt mit dem, was
     * man sieht.
     */
    new THREE.SphereGeometry(radius * 1.1, 12, 8),
    // Unsichtbar, aber weiterhin vom Raycaster erfasst: `visible = false` würde
    // das Objekt aus der Strahlprüfung nehmen.
    new THREE.MeshBasicMaterial({ transparent: true, opacity: 0, depthWrite: false }),
  )
  hitBox.position.y = kopfHoehe
  group.add(hitBox)
  scene.add(group)
  return {
    seat,
    hitBox,
    ring,
    group,
    // Der Anker steigt mit der Tiefe: weiter hinten sitzende Plaketten hängen
    // höher. Ohne diese Staffelung laufen sie am Fluchtpunkt ineinander, weil
    // die Plätze dort auf wenige Bildpunkte zusammenrücken (§8).
    labelAnchor: new THREE.Vector3(
      seat.x,
      kopfHoehe + radius + 0.10 + Math.min(0.34, Math.max(0, (Math.abs(seat.z) - 0.9) * 0.06)),
      seat.z,
    ),
  }
 }
 // ── Aufbau ───────────────────────────────────────────────────────────────────
 export function createMeetingRoomScene(
  canvas: HTMLCanvasElement,
  seats: MeetingSeat[],
  photos: Record<string, string | undefined>,
 ): MeetingRoomScene {
  const renderer = new THREE.WebGLRenderer({ canvas, antialias: true, alpha: false })
  /*
   * Mindestens doppelte Auflösung, unabhängig vom Bildschirm.
   *
   * Wird intern feiner gerechnet als der Bildschirm darstellt, gewinnen alle
   * feinen Kanten — Fensterprofile, Kulisse und vor allem die Porträtkreise.
   * Das kostet hier wenig: die Szene wird nicht laufend, sondern nur bei
   * Grössenänderung, Mausbewegung und Zustandswechsel neu gezeichnet.
   */
  renderer.setPixelRatio(Math.min(Math.max(window.devicePixelRatio, 2), 3))
  renderer.outputColorSpace = THREE.SRGBColorSpace
  const scene = new THREE.Scene()
  scene.background = new THREE.Color(ROOM_COLORS.sky)
  // Leichter Dunst nur in der Ferne: der Raum (0…12 m) bleibt klar, die Kulisse
  // bei 40–65 m bekommt Tiefe. Ohne ihn klebt die Stadt an der Scheibe.
  scene.fog = new THREE.Fog(ROOM_COLORS.sky, 40, 140)
  const camera = new THREE.PerspectiveCamera(CAMERA.fov, 1, 0.1, 300)
  camera.position.set(0, CAMERA.eyeHeight, CAMERA.z)
  camera.lookAt(new THREE.Vector3(...CAMERA.lookAt))
  scene.add(new THREE.AmbientLight(0xffffff, 1.45))
  // Tageslicht von der linken Glasfront (§4 «klares natürliches Tageslicht»)
  const sun = new THREE.DirectionalLight(0xfff6e8, 1.5)
  sun.position.set(-6, 5, -2)
  scene.add(sun)
  // Aufheller von der geschlossenen Wand, damit rechts nichts absäuft
  const bounce = new THREE.DirectionalLight(0xdfe6ee, 0.5)
  bounce.position.set(5, 2, 3)
  scene.add(bounce)
  const loader = new THREE.TextureLoader()
  const maxAnisotropy = renderer.capabilities.getMaxAnisotropy()
  addBaselBackdrop(scene, loader, maxAnisotropy)
  addRoomShell(scene)
  addGlassFacades(scene)
  addTable(scene)
  /*
   * Höhe der Leinwand in Bildpunkten, aus der die Porträts ihre Auflösung
   * ableiten. Zum Zeitpunkt des Aufbaus steht sie noch nicht fest, weil die
   * Grösse erst danach gesetzt wird. Der Ausgangswert deckt den üblichen
   * Bereich ab; wächst das Fenster später deutlich, werden die Bilder etwas
   * vergrössert dargestellt — weit weniger auffällig als eine zu grobe
   * Zwischenfassung.
   */
  const leinwandHoehe = Math.max(canvas.clientHeight, 700) * renderer.getPixelRatio()
  const handles = seats.map(seat =>
    addSeatedAgent(scene, seat, photos[seat.id], maxAnisotropy, leinwandHoehe),
  )
  function render() {
    renderer.render(scene, camera)
  }
  return {
    scene,
    camera,
    renderer,
    seats: handles,
    setSize(width, height) {
      renderer.setSize(width, height, false)
      const aspect = width / Math.max(height, 1)
      camera.aspect = aspect
      // Schmale Fenster brauchen einen weiteren Bildwinkel: bei festem Winkel
      // schneidet das hohe Format den Tisch links und rechts ab. Statt einer
      // eigenen Mobilszene (§18: pragmatische Degradation) öffnet sich die
      // Kamera, bis der Raum wieder hineinpasst.
      const weit = CAMERA.fov + Math.max(0, (1.45 - aspect) * 26)
      /*
       * Nach oben begrenzt durch den waagrechten Bildwinkel. Bei sehr breiten,
       * flachen Fenstern — etwa 1280 × 380 auf einem Notebook — griffe sonst ein
       * waagrechter Winkel von über 110°: der Raum wirkt gezerrt, und der Blick
       * reicht seitlich über den Rand des Panoramas hinaus.
       */
      const maxTan = Math.tan((CAMERA.maxHFov / 2) * Math.PI / 180) / aspect
      camera.fov = Math.min(weit, 2 * Math.atan(maxTan) * 180 / Math.PI)
      camera.updateProjectionMatrix()
    },
    render,
    setHovered(id) {
      for (const h of handles) {
        const on = h.seat.id === id
        ;(h.ring.material as THREE.MeshBasicMaterial).color.set(
          on ? ROOM_COLORS.headRingHover : ROOM_COLORS.headRing,
        )
        // Leichtes Anheben statt Vergrössern: eine skalierte Person wirkt
        // sofort falsch, ein Aufrichten liest sich als Zuwendung.
        h.group.position.y = on ? 0.035 : 0
      }
    },
    dispose() {
      scene.traverse(obj => {
        if (obj instanceof THREE.Mesh) {
          obj.geometry.dispose()
          const mat = obj.material
          const mats = Array.isArray(mat) ? mat : [mat]
          for (const m of mats) {
            const withMap = m as THREE.Material & { map?: THREE.Texture | null }
            withMap.map?.dispose()
            m.dispose()
          }
        }
      })
      renderer.dispose()
    },
  }
 }
@@ -0,0 +1,106 @@
 import { AGENT_WORKSPACES } from '../../lib/agentWorkspaces'
 import { AGENT_SUPERVISOR } from '../../lib/agentWorkspaces'
 /**
 * Sitzordnung im 3D-Meetingraum (Runde 6, §5/§6/§7).
 *
 * Eine einzige Tabelle bestimmt, wer wo sitzt. Namen, Funktionen, Porträts und
 * Zielseiten kommen dabei nicht von hier, sondern aus `AGENT_WORKSPACES` —
 * derselben zentralen Konfiguration, die Menü und Seitenköpfe verwenden. Hier
 * steht ausschliesslich die Geometrie (§24, Schritt 7: nichts doppelt pflegen).
 *
 * Koordinaten sind Meter im Weltsystem der Szene:
 * - x: negativ = links vom Betrachter, positiv = rechts
 * - z: 0 am Kopfende des Betrachters, negativ = in den Raum hinein
 *
 * Die Agenten wechseln die Tischseite in der Reihenfolge der Konfiguration
 * (Ferdi links, Bruno rechts, Livia links, …). Das verteilt sie gleichmässig,
 * hält die Abstände gross genug, dass sich niemand überlappt, und macht den
 * Arbeitsablauf auch am Tisch ablesbar.
 */
 /** Auf welcher Tischseite ein Platz liegt. */
 export const SeatSide = {
  LEFT: 'LEFT',
  RIGHT: 'RIGHT',
  /** Kopfende gegenüber dem Betrachter — nur Thomas. */
  HEAD: 'HEAD',
 } as const
 export type SeatSide = typeof SeatSide[keyof typeof SeatSide]
 export interface MeetingSeat {
  /** Agenten-ID; identisch mit `AGENT_PHOTOS` und den Mockdaten. */
  id: string
  name: string
  role: string
  /** Zielseite des Klicks. */
  path: string
  side: SeatSide
  /** Sitzposition in Metern. */
  x: number
  z: number
  /** Radius des Porträtkreises in Metern. */
  radius: number
 }
 /** Ein Platz, so wie er unten eingetragen wird. */
 type Platz = { side: SeatSide; x: number; z: number; radius: number }
 /**
 * Sitzplätze der fünf Agenten, in Metern (Runde 6 §3.2, Runde 7 §2).
 *
 * Ferdi und Bruno sind die direkten Nachbarn des Betrachters — einer links,
 * einer rechts, schräg frontal und dicht an der vorderen Tischkante. Dahinter
 * staffeln sich die übrigen drei.
 *
 * Die Radien wachsen nach hinten, die **Bildgrösse** nimmt trotzdem mit der
 * Tiefe ab: ein Kreis von 0.30 m in 5 m Entfernung erscheint kleiner als einer
 * von 0.265 m in 3 m. Ohne diese Gegensteuerung wären die hinteren Porträts bei
 * gleichem Radius kaum noch erkennbar (§2: «tiefenlogisch», aber «insgesamt klar
 * besser sichtbar»).
 *
 * Alle Werte sind gemeinsam gewählt, nicht einzeln: mit den Kamerawerten aus
 * `meetingRoomPalette` durchgerechnet ergeben sie gegenüber dem Stand vor dieser
 * Runde die Faktoren 2.11× (Ferdi/Bruno), 2.22× (Livia/Nora), 2.50× (Sina) und
 * 3.18× (Thomas) — und dabei **keine** einzige Überschneidung zweier Kreise im
 * Bild. Wer einen Wert ändert, verschiebt beides; die Kreise überlappen dann
 * schnell wieder.
 */
 const PLAETZE: Record<string, Platz> = {
  ferdi: { side: SeatSide.LEFT,  x: -1.16, z: -0.88, radius: 0.268 },
  bruno: { side: SeatSide.RIGHT, x:  1.16, z: -0.88, radius: 0.268 },
  livia: { side: SeatSide.LEFT,  x: -1.32, z: -3.35, radius: 0.345 },
  nora:  { side: SeatSide.RIGHT, x:  1.32, z: -3.35, radius: 0.345 },
  sina:  { side: SeatSide.LEFT,  x: -0.95, z: -5.50, radius: 0.395 },
 }
 /**
 * Notplatz für einen Agenten ohne Eintrag oben — sichtbar hinten rechts statt
 * lautlos im Nichts.
 */
 const FALLBACK: Platz = { side: SeatSide.RIGHT, x: 0.95, z: -5.50, radius: 0.395 }
 /**
 * Kopfende gegenüber. Position unverändert, nur der Kreis wächst kräftig: von
 * dort aus ist der Abstand am grössten, und Thomas war zuvor kaum auszumachen
 * (§2). Grösser darf er nicht werden — sein Kreis überträfe im Bild sonst den
 * von Sina, die näher sitzt, und die Tiefenwirkung kippte.
 */
 const KOPFENDE: Platz = { side: SeatSide.HEAD, x: 0, z: -6.75, radius: 0.452 }
 export const MEETING_SEATS: MeetingSeat[] = [
  ...AGENT_WORKSPACES.map(agent => ({
    id: agent.id,
    name: agent.name,
    role: agent.role,
    path: agent.path,
    ...(PLAETZE[agent.id] ?? FALLBACK),
  })),
  {
    id: AGENT_SUPERVISOR.id,
    name: AGENT_SUPERVISOR.name,
    role: AGENT_SUPERVISOR.role,
    path: AGENT_SUPERVISOR.path,
    ...KOPFENDE,
  },
 ]
@@ -1,32 +0,0 @@
 import buero from '../../assets/staff/buero.jpg'
 /**
 * Umgebung der Belegschaftsansicht auf der Startseite (Runde 5, §3).
 *
 * Genau eine Stelle bestimmt, welches Bild hinter den Personenkarten liegt.
 * Ein Austausch ist damit ein Einzeiler; die Herkunft steht in `HERKUNFT.md`
 * neben der Bilddatei.
 *
 * Das Bild ist Umgebung, nicht Motiv: es zeigt ein Büro, damit die digitalen
 * Mitarbeitenden einen Arbeitsplatz haben statt eines leeren Hintergrunds. Der
 * Verlauf darüber nimmt ihm den grössten Teil des Kontrasts — sonst
 * konkurriert jeder Bürostuhl mit den Gesichtern und der Schrift davor.
 */
 export interface RoomBackdrop {
  src: string
  /** Bildausschnitt bei `object-fit: cover`. */
  focus: string
  /** Verlauf über dem Bild: Lesbarkeit und Übergang zur Objektliste darunter. */
  scrim: string
 }
 export const ROOM_BACKDROP: RoomBackdrop = {
  src: buero,
  focus: '50% 58%',
  scrim: [
    // Grundton: das Büro tritt weit zurück, die Karten treten hervor.
    'linear-gradient(180deg, rgba(9,14,23,0.84) 0%, rgba(9,14,23,0.76) 52%, rgba(9,14,23,0.92) 100%)',
    // Warmes Streiflicht von links, damit die Fläche nicht tot wirkt.
    'radial-gradient(85% 120% at 10% 6%, rgba(184,151,90,0.18) 0%, rgba(184,151,90,0) 58%)',
  ].join(', '),
 }
@@ -4,6 +4,7 @@ import {
 } from '@mui/material'
 import { X } from 'lucide-react'
 import type { Property, UpdatePropertyInput } from '../../domain/property'
 import { AiDisclaimer } from '../ui'
 import { usePropertyById, useUpdateProperty } from '../../hooks/useProperties'
 import { PropertyDetailSkeleton } from './PropertyDetailSkeleton'
 import { useToastStore } from '../../stores/toastStore'
@@ -217,6 +218,14 @@ export function EditableObjectOverview({ propertyId, onClose }: Props) {
            )
          })}
        </Box>
        {/*
          Der KI-Hinweis steht innerhalb des scrollenden Bereichs. Ausserhalb
          läge er hinter dem `overflow: hidden` des äusseren Rahmens und wäre
          nie zu sehen — der Aktionsbalken darunter ist bewusst der einzige
          Teil, der fix am unteren Rand klebt.
        */}
        <AiDisclaimer />
      </Box>
      {/* Speichern erscheint erst bei einer Änderung, «Abbrechen» links davon. */}
@@ -10,6 +10,7 @@ import {
 } from '@mui/material'
 import { AssetType, AvailabilityStatus } from '../../domain/enums'
 import { getAssetTypeLabel, getAvailabilityLabel } from './propertyHelpers'
 import { SCORE_MODERATE, SCORE_STRONG } from '../../lib/constants'
 import { DS_BRAND } from '../../lib/ds'
 export interface PropertyTableFilters {
@@ -18,13 +19,47 @@ export interface PropertyTableFilters {
  availabilityStatus?: string
  sortBy?: 'dataQuality' | 'availability' | 'area' | 'rent' | 'confidence'
  sortDir?: 'asc' | 'desc'
  /**
   * Mindest-Match in Prozent (Runde 11, §2).
   *
   * Nur in Noras Trefferliste gesetzt — in «Meine Objekte» gibt es keinen
   * Match-Wert, und ein Filter ohne Datengrundlage wäre ein Bedienelement,
   * das nichts tut. Die Schwellen kommen aus `SCORE_STRONG`/`SCORE_MODERATE`;
   * eigene Kategorien werden nicht erfunden.
   */
  minMatch?: number
  /** Ort aus den Standortdaten der Ergebnisse. */
  city?: string
 }
 interface PropertyFilterBarProps {
  filters: PropertyTableFilters
  onFiltersChange: (f: PropertyTableFilters) => void
  /**
   * Schaltet den Matchqualitäts-Filter frei. Nur dort gesetzt, wo Match-Werte
   * vorliegen — die Filterleiste ist sonst dieselbe wie in «Meine Objekte».
   */
  showMatchFilter?: boolean
  /**
   * Auswählbare Orte, abgeleitet aus den tatsächlich vorliegenden Ergebnissen.
   * Bewusst keine feste Ortsliste: Was nicht im Bestand vorkommt, soll auch
   * nicht auswählbar sein.
   */
  cities?: string[]
 }
 /**
 * Stufen der Matchqualität (Runde 11, §2).
 *
 * Die Grenzen sind die bereits im Projekt geführten Schwellen — dieselben, nach
 * denen sich auch die Farbe des Match-Werts richtet. Damit stimmt der Filter
 * mit dem überein, was der Nutzer in der Spalte sieht.
 */
 const MATCH_OPTIONS = [
  { value: SCORE_STRONG, label: `Stark (ab ${SCORE_STRONG} %)` },
  { value: SCORE_MODERATE, label: `Moderat (ab ${SCORE_MODERATE} %)` },
 ] as const
 const SORT_OPTIONS = [
  { value: 'dataQuality', label: 'Datenqualität' },
  { value: 'area', label: 'Fläche' },
@@ -43,12 +78,16 @@ const SUPPLY_AVAILABILITY_STATUSES = [
  AvailabilityStatus.OCCUPIED,
 ] as const
-export function PropertyFilterBar({ filters, onFiltersChange }: PropertyFilterBarProps) {
+export function PropertyFilterBar({
  filters, onFiltersChange, showMatchFilter = false, cities = [],
 }: PropertyFilterBarProps) {
  const isActive =
    !!filters.search ||
    (filters.assetTypes?.length ?? 0) > 0 ||
    !!filters.availabilityStatus ||
-    !!filters.sortBy
+    !!filters.sortBy ||
    filters.minMatch !== undefined ||
    !!filters.city
  function update(partial: Partial<PropertyTableFilters>) {
    onFiltersChange({ ...filters, ...partial })
@@ -121,6 +160,36 @@ export function PropertyFilterBar({ filters, onFiltersChange }: PropertyFilterBa
            ))}
          </Select>
          {showMatchFilter && (
            <Select
              value={filters.minMatch ?? 0}
              onChange={e => update({ minMatch: e.target.value === 0 ? undefined : Number(e.target.value) })}
              displayEmpty
              size="small"
              sx={{ minWidth: 160 }}
            >
              <MenuItem value={0}>Matchqualität (alle)</MenuItem>
              {MATCH_OPTIONS.map(opt => (
                <MenuItem key={opt.value} value={opt.value}>{opt.label}</MenuItem>
              ))}
            </Select>
          )}
          {cities.length > 0 && (
            <Select
              value={filters.city ?? ''}
              onChange={e => update({ city: e.target.value || undefined })}
              displayEmpty
              size="small"
              sx={{ minWidth: 160 }}
            >
              <MenuItem value="">Standort (alle)</MenuItem>
              {cities.map(c => (
                <MenuItem key={c} value={c}>{c}</MenuItem>
              ))}
            </Select>
          )}
          <TextField
            value={filters.search ?? ''}
            onChange={e => update({ search: e.target.value || undefined })}
@@ -1,3 +1,4 @@
 import type { ReactNode } from 'react'
 import {
  Alert,
  Box,
@@ -22,9 +23,19 @@ import {
  qualityColor,
 } from './propertyHelpers'
 import { DS_SLATE } from '../../lib/ds'
 import { matchScoreHex } from '../../lib/utils'
 interface PropertyTableProps {
  properties: Property[]
  /**
   * Match-Werte je Objekt-ID (Runde 10, §3.6).
   *
   * Ist die Karte gesetzt, bekommt die Tabelle eine erste Spalte «Match». Der
   * Rest — Spalten, Sortierung, Zeilenaufbau, Aktionen — bleibt unverändert:
   * Noras Trefferliste ist dieselbe Tabelle wie «Meine Objekte», nicht eine
   * zweite, die ihr ähnlich sieht.
   */
  matchScores?: Map<string, number>
  isLoading: boolean
  isError: boolean
  selectedId: string | null
@@ -36,10 +47,26 @@ interface PropertyTableProps {
 const COL_HEADERS = [
  'Objekt', 'Typ', 'Standort', 'Fläche', 'Miete CHF/m²/Jahr',
-  'Aktueller Mieter', 'Mietlaufzeit', 'Breakoutoption', 'Breakoutoption Zeitpunkt',
+  'Aktueller Mieter', 'Mietlaufzeit', 'Breakout Option', 'Breakout Zeitpunkt',
  'Datenqualität', 'Aktionen',
 ]
 /**
 * Spaltenanteile in Prozent, in der Reihenfolge der Kopfzeile.
 *
 * Sie ergeben zusammen 100. Kommt die Match-Spalte dazu, werden alle
 * anteilig gestaucht, statt die Tabelle zu verbreitern — eine waagrechte
 * Bildlaufleiste wäre für eine einzige Kennzahl ein schlechter Tausch.
 *
 * In Runde 11 (§3) neu verteilt: «Aktionen» hatte 4 % und war damit schmaler
 * als sein eigener Kopftext, der daraufhin zeichenweise umbrach («AKTI/ONE/N»).
 * Der Platz kommt aus «Objekt» und «Standort», die beide Reserve hatten.
 */
 const COL_WIDTHS = [17, 7, 8, 6, 9, 13, 8, 8, 9, 9, 6]
 /** Platz für «Match» in Prozent. */
 const MATCH_COL_WIDTH = 7
 function LoadingRows() {
  return (
    <>
@@ -68,7 +95,8 @@ function SortableHeader({
  field, label, sortBy, sortDir, onSort,
 }: {
  field: PropertyTableFilters['sortBy']
-  label: string
+  /** Knoten statt nur Text, damit ein Kopf seinen Umbruch selbst setzen kann. */
  label: ReactNode
  sortBy: PropertyTableFilters['sortBy']
  sortDir: PropertyTableFilters['sortDir']
  onSort: (field: PropertyTableFilters['sortBy']) => void
@@ -100,7 +128,11 @@ export function PropertyTable({
  onViewDetail,
  filters,
  onFiltersChange,
  matchScores,
 }: PropertyTableProps) {
  const showMatch = matchScores !== undefined
  const skalierung = showMatch ? (100 - MATCH_COL_WIDTH) / 100 : 1
  if (isError) {
    return <Alert severity="error" sx={{ m: 3 }}>Objekte konnten nicht geladen werden.</Alert>
  }
@@ -115,18 +147,74 @@ export function PropertyTable({
  return (
    <Box sx={{ overflowX: 'auto' }}>
-      <Table stickyHeader size="small">
+      <Table
        stickyHeader
        size="small"
        /*
         * Feste Spaltenbreiten statt automatischer (Runde 9, §2).
         *
         * Mit automatischer Breite richtet sich jede Spalte nach ihrem längsten
         * Inhalt — bei elf Spalten summiert sich das über die Fensterbreite
         * hinaus, und die letzten beiden lagen im waagrechten Scrollbereich.
         * Die Anteile unten ergeben zusammen 100 %; keine Spalte ist entfernt
         * und kein Wert gekürzt, sie teilen sich den Platz nur nach Bedarf:
         * Objektname und Mieter tragen lange Texte, «Fläche» oder «Break-Option»
         * kommen mit wenig aus.
         */
        sx={{
          tableLayout: 'fixed',
          '& .MuiTableCell-root': {
            // Enger als zuvor (war 1) — elf bis zwölf Spalten gewinnen dadurch
            // zusammen rund 100 Pixel, ohne dass eine Zelle gedrängt wirkt.
            px: 0.75,
            py: 0.75,
            /*
             * Umbruch nur an Wortgrenzen (Runde 11, §3.7/§3.8).
             *
             * Vorher stand hier `wordBreak: 'break-word'`. Das trennt ein Wort
             * mitten drin, sobald es nicht in die Spalte passt — in der
             * Kopfzeile wurde daraus «JAH/R» und «DATENQUALIT/ÄT». Jetzt bricht
             * nur überlanger Text ohne Leerzeichen, und auch das erst, wenn er
             * sonst überliefe.
             */
            wordBreak: 'normal',
            overflowWrap: 'break-word',
            hyphens: 'none',
          },
          // Kopfzeilen dürfen zwei Zeilen brauchen — aber an sinnvoller Stelle.
          '& .MuiTableCell-head': {
            lineHeight: 1.25,
            verticalAlign: 'bottom',
          },
        }}
      >
        <colgroup>
          {showMatch && <col style={{ width: `${MATCH_COL_WIDTH}%` }} />}
          {COL_WIDTHS.map((w, i) => (
            <col key={COL_HEADERS[i]} style={{ width: `${w * skalierung}%` }} />
          ))}
        </colgroup>
        <TableHead>
          <TableRow sx={{ bgcolor: 'grey.50' }}>
            {showMatch && (
              <TableCell>
                <Typography variant="caption" sx={{ fontWeight: 600 }}>Match</Typography>
              </TableCell>
            )}
            <TableCell><Typography variant="caption" sx={{ fontWeight: 600 }}>Objekt</Typography></TableCell>
            <TableCell><Typography variant="caption" sx={{ fontWeight: 600 }}>Typ</Typography></TableCell>
            <TableCell><Typography variant="caption" sx={{ fontWeight: 600 }}>Standort</Typography></TableCell>
            <TableCell><SortableHeader field="area" label="Fläche (m²)" sortBy={filters.sortBy} sortDir={filters.sortDir} onSort={handleSort} /></TableCell>
-            <TableCell><SortableHeader field="rent" label="Miete CHF/m²/Jahr" sortBy={filters.sortBy} sortDir={filters.sortDir} onSort={handleSort} /></TableCell>
+            <TableCell><SortableHeader field="rent" label={<>Miete<br />CHF/m²/Jahr</>} sortBy={filters.sortBy} sortDir={filters.sortDir} onSort={handleSort} /></TableCell>
            <TableCell><Typography variant="caption" sx={{ fontWeight: 600 }}>Aktueller Mieter</Typography></TableCell>
            <TableCell><Typography variant="caption" sx={{ fontWeight: 600 }}>Mietlaufzeit</Typography></TableCell>
-            <TableCell><Typography variant="caption" sx={{ fontWeight: 600 }}>Breakoutoption</Typography></TableCell>
+            {/*
-            <TableCell><Typography variant="caption" sx={{ fontWeight: 600 }}>Breakoutoption Zeitpunkt</Typography></TableCell>
+                «Breakoutoption» in zwei Wörtern (Runde 11, §3.9): Der Begriff
                bleibt derselbe, nur der Umbruch hat jetzt eine Stelle, an der
                er stattfinden darf.
            */}
            <TableCell><Typography variant="caption" sx={{ fontWeight: 600 }}>Breakout Option</Typography></TableCell>
            <TableCell><Typography variant="caption" sx={{ fontWeight: 600 }}>Breakout Zeitpunkt</Typography></TableCell>
            <TableCell><SortableHeader field="dataQuality" label="Datenqualität" sortBy={filters.sortBy} sortDir={filters.sortDir} onSort={handleSort} /></TableCell>
            <TableCell><Typography variant="caption" sx={{ fontWeight: 600 }}>Aktionen</Typography></TableCell>
          </TableRow>
@@ -136,7 +224,7 @@ export function PropertyTable({
            <LoadingRows />
          ) : properties.length === 0 ? (
            <TableRow>
-              <TableCell colSpan={11}>
+              <TableCell colSpan={showMatch ? 12 : 11}>
                <Typography variant="body2" sx={{ color: 'text.secondary', textAlign: 'center', py: 4 }}>
                  Keine Objekte gefunden.
                </Typography>
@@ -164,6 +252,18 @@ export function PropertyTable({
                    '&:hover': { bgcolor: isSelected ? 'rgba(30,58,95,0.08)' : 'rgba(0,0,0,0.02)' },
                  }}
                >
                  {/* Match — erste Spalte, nur in Noras Trefferliste (§3.6) */}
                  {showMatch && (
                    <TableCell>
                      <Typography
                        variant="body2"
                        sx={{ fontWeight: 700, color: matchScoreHex(matchScores!.get(p.id) ?? 0) }}
                      >
                        {matchScores!.get(p.id) ?? 0} %
                      </Typography>
                    </TableCell>
                  )}
                  {/* Objekt */}
                  <TableCell>
                    <Typography variant="body2" sx={{ fontWeight: 500, lineHeight: 1.3 }}>
@@ -205,7 +305,7 @@ export function PropertyTable({
                  {/* Aktueller Mieter */}
                  <TableCell>
-                    <Typography variant="body2" sx={{ whiteSpace: 'nowrap' }}>
+                    <Typography variant="body2">
                      {p.currentTenant ?? <span style={{ color: DS_SLATE[400] }}>–</span>}
                    </Typography>
                  </TableCell>
@@ -249,7 +349,7 @@ export function PropertyTable({
                      title={hasCritical ? `Kritische Felder: ${p.dataQuality.missingCriticalFields.join(', ')}` : 'Keine kritischen Lücken'}
                      placement="top"
                    >
-                      <Box sx={{ width: 80 }}>
+                      <Box sx={{ width: '100%', maxWidth: 90 }}>
                        <LinearProgress
                          variant="determinate"
                          value={qScore * 100}
@@ -0,0 +1,118 @@
 import { Box, Typography } from '@mui/material'
 import { FileSignature } from 'lucide-react'
 import type { Reminder } from '../../domain/reminder'
 import { ReminderType } from '../../domain/reminder'
 import { REMINDER_TYPE_HINTS, REMINDER_TYPE_LABELS } from '../../lib/constants'
 import { SectionTitle, DateRow } from './reminderDetailHelpers'
 import { DS_BRAND, DS_SLATE, DS_TEXT } from '../../lib/ds'
 /**
 * Der Vertragsteil eines Reminders (Runde 8, §4).
 *
 * Beantwortet in dieser Reihenfolge: welcher Vertrag und welche Fundstelle,
 * welcher Zeitpunkt wurde erkannt, weshalb ist er relevant, was ist zu tun.
 *
 * Der erkannte Zeitpunkt steht bewusst vor dem Vertragsende — bei einer echten
 * Option ist die Ausübungsfrist die Nachricht, das Vertragsende nur ihr Anlass.
 * Ein Reminder, der auf das Vertragsende zeigt, kommt für jede Entscheidung zu
 * spät, die ihn nötig gemacht hat.
 *
 * Der Block erscheint nur, wenn tatsächlich Vertragsangaben vorliegen. Ein
 * Unterhaltstermin hat keine Fundstelle in einem Mietvertrag, und eine leere
 * Überschrift wäre die Behauptung, es fehle etwas.
 */
 export function ReminderContractPanel({ reminder }: { reminder: Reminder }) {
  const hasWindow = Boolean(reminder.negotiationWindowFrom || reminder.negotiationWindowTo)
  const hasContent = Boolean(
    reminder.contractRef ||
    reminder.decisionDate ||
    reminder.relevanceReason ||
    reminder.recommendedAction ||
    reminder.noticePeriodMonths != null ||
    hasWindow,
  )
  if (!hasContent) return null
  const isRealOption = reminder.type === ReminderType.REAL_OPTION
  const decisionLabel = isRealOption ? 'Ausübung bis' : 'Entscheid bis'
  return (
    <Box sx={{ mb: 2.5 }}>
      <SectionTitle icon={<FileSignature size={14} color="#64748b" />}>Vertrag</SectionTitle>
      <Box sx={{ display: 'flex', flexDirection: 'column', gap: 1 }}>
        {reminder.contractRef && (
          <Box sx={{ display: 'grid', gridTemplateColumns: '120px 1fr', gap: 1, alignItems: 'baseline' }}>
            <Typography variant="caption" color="text.secondary">Dokument</Typography>
            <Box sx={{ minWidth: 0 }}>
              <Typography variant="body2" sx={{ fontWeight: 500 }}>{reminder.contractRef}</Typography>
              {reminder.contractClause && (
                <Typography variant="caption" sx={{ color: DS_TEXT.muted }}>
                  {reminder.contractClause}
                </Typography>
              )}
            </Box>
          </Box>
        )}
        <Box sx={{ display: 'grid', gridTemplateColumns: '120px 1fr', gap: 1, alignItems: 'baseline' }}>
          <Typography variant="caption" color="text.secondary">Erkannter Typ</Typography>
          <Typography variant="body2" sx={{ fontWeight: 500 }}>
            {REMINDER_TYPE_LABELS[reminder.type] ?? reminder.type}
          </Typography>
        </Box>
        {/* Der massgebliche Zeitpunkt — nicht das Vertragsende. */}
        <DateRow label={decisionLabel} value={reminder.decisionDate} />
        {reminder.noticePeriodMonths != null && (
          <Box sx={{ display: 'grid', gridTemplateColumns: '120px 1fr', gap: 1, alignItems: 'baseline' }}>
            <Typography variant="caption" color="text.secondary">Kündigungsfrist</Typography>
            <Typography variant="body2" sx={{ fontWeight: 500 }}>
              {reminder.noticePeriodMonths} Monate
            </Typography>
          </Box>
        )}
        {hasWindow && (
          <Box sx={{ display: 'grid', gridTemplateColumns: '120px 1fr', gap: 1, alignItems: 'baseline' }}>
            <Typography variant="caption" color="text.secondary">Verhandlungsfenster</Typography>
            <Typography variant="body2" sx={{ fontWeight: 500 }}>
              {reminder.negotiationWindowFrom
                ? new Date(reminder.negotiationWindowFrom).toLocaleDateString('de-CH')
                : 'offen'}
              {' – '}
              {reminder.negotiationWindowTo
                ? new Date(reminder.negotiationWindowTo).toLocaleDateString('de-CH')
                : 'offen'}
            </Typography>
          </Box>
        )}
      </Box>
      {/* Weshalb der Zeitpunkt zählt */}
      {(reminder.relevanceReason || REMINDER_TYPE_HINTS[reminder.type]) && (
        <Box sx={{ mt: 1.75, bgcolor: DS_SLATE[50], border: '1px solid #e2e8f0', borderRadius: 1.5, p: 1.5 }}>
          <Typography variant="caption" sx={{ fontWeight: 700, color: DS_SLATE[500], textTransform: 'uppercase', letterSpacing: 0.5, display: 'block', mb: 0.5, fontSize: '0.65rem' }}>
            Weshalb relevant
          </Typography>
          <Typography variant="body2" sx={{ color: DS_SLATE[800], lineHeight: 1.55 }}>
            {reminder.relevanceReason ?? REMINDER_TYPE_HINTS[reminder.type]}
          </Typography>
        </Box>
      )}
      {/* Was als Nächstes zu tun ist */}
      {reminder.recommendedAction && (
        <Box sx={{ mt: 1.25, border: '1px solid', borderColor: DS_BRAND.main, borderRadius: 1.5, p: 1.5 }}>
          <Typography variant="caption" sx={{ fontWeight: 700, color: DS_BRAND.main, textTransform: 'uppercase', letterSpacing: 0.5, display: 'block', mb: 0.5, fontSize: '0.65rem' }}>
            Empfohlene nächste Handlung
          </Typography>
          <Typography variant="body2" sx={{ color: DS_SLATE[800], lineHeight: 1.55 }}>
            {reminder.recommendedAction}
          </Typography>
        </Box>
      )}
    </Box>
  )
 }
@@ -4,6 +4,7 @@ import {
 } from '@mui/material'
 import { X, Calendar } from 'lucide-react'
 import { useReminderStore } from '../../stores/reminderStore'
 import { AiDisclaimer } from '../ui'
 import {
  useReminder, useCompleteReminder, useDismissReminder, useSnoozeReminder,
 } from '../../hooks/useReminders'
@@ -13,17 +14,28 @@ import { ReminderTypeBadge } from './ReminderTypeBadge'
 import { ReminderDaysIndicator } from './ReminderDaysIndicator'
 import { ReminderStatusBadge } from './ReminderStatusBadge'
 import { ReminderCalendarPlanner } from './ReminderCalendarPlanner'
 import { ReminderContractPanel } from './ReminderContractPanel'
 import { ReminderStatus, ReminderType } from '../../domain/reminder'
 import { SectionTitle, DateRow } from './reminderDetailHelpers'
 import { DS_BRAND, DS_SLATE, DS_TEXT } from '../../lib/ds'
 // ── Constants ────────────────────────────────────────────────────────────────
 /**
 * Das zweite Datum je Termintyp. Bei den Vertragstypen aus Runde 8 (§4) ist das
 * bewusst das Vertragsende — als Einordnung, nicht als Fälligkeit. Die
 * Fälligkeit steht darüber und liegt früher; genau das ist der Punkt.
 */
 const TYPE_SECOND_DATE: Partial<Record<ReminderType, 'contractEndDate' | 'breakOptionDate' | 'eventDate'>> = {
  [ReminderType.LEASE_EXPIRY]:          'contractEndDate',
  [ReminderType.BREAK_OPTION]:          'breakOptionDate',
  [ReminderType.RENT_REVIEW]:           'eventDate',
  [ReminderType.SCHATTENMARKT_RELEASE]: 'eventDate',
  [ReminderType.NOTICE_PERIOD]:         'contractEndDate',
  [ReminderType.REAL_OPTION]:           'contractEndDate',
  [ReminderType.UNREAL_OPTION]:         'contractEndDate',
  [ReminderType.NEGOTIATION_WINDOW]:    'contractEndDate',
  [ReminderType.CONTRACT_TALK]:         'contractEndDate',
 }
 const TYPE_SECOND_LABEL: Partial<Record<ReminderType, string>> = {
@@ -31,6 +43,11 @@ const TYPE_SECOND_LABEL: Partial<Record<ReminderType, string>> = {
  [ReminderType.BREAK_OPTION]:          'Break-Option',
  [ReminderType.RENT_REVIEW]:           'Ereignisdatum',
  [ReminderType.SCHATTENMARKT_RELEASE]: 'Ereignisdatum',
  [ReminderType.NOTICE_PERIOD]:         'Vertragsende',
  [ReminderType.REAL_OPTION]:           'Vertragsende',
  [ReminderType.UNREAL_OPTION]:         'Vertragsende',
  [ReminderType.NEGOTIATION_WINDOW]:    'Vertragsende',
  [ReminderType.CONTRACT_TALK]:         'Vertragsende',
 }
 // ── Drawer ───────────────────────────────────────────────────────────────────
@@ -131,6 +148,10 @@ export function ReminderDetailDrawer() {
            <Divider sx={{ mb: 2.5 }} />
            {/* 2b. Vertrag — welcher Vertrag, welcher Zeitpunkt, weshalb,
                   was tun (Runde 8, §4). Erscheint nur bei Vertragsterminen. */}
            <ReminderContractPanel reminder={reminder} />
            {/* 3. Terminplanung — steht, wo bis Runde 3 der Notizbereich war */}
            <Box sx={{ mb: 2.5 }}>
              <ReminderCalendarPlanner reminder={reminder} property={reminderProperty} />
@@ -181,6 +202,8 @@ export function ReminderDetailDrawer() {
                </Box>
              </>
            )}
            <AiDisclaimer />
          </Box>
        )}
      </Box>
@@ -8,6 +8,11 @@ import {
  Wrench,
  Eye,
  Tag,
  CalendarClock,
  Handshake,
  KeyRound,
  MessagesSquare,
  Scissors,
 } from 'lucide-react'
 import type { LucideIcon } from 'lucide-react'
 import type { ReminderType } from '../../domain/reminder'
@@ -20,14 +25,20 @@ import { DS_TEXT } from '../../lib/ds'
 * deshalb in derselben Standard-Schriftfarbe; unterschieden wird über das Symbol.
 */
 const CONFIG: Record<ReminderType, { Icon: LucideIcon; label: string }> = {
-  LEASE_EXPIRY:         { Icon: FileText,       label: 'Mietablauf' },
+  LEASE_EXPIRY:         { Icon: FileText,        label: 'Mietablauf' },
-  BREAK_OPTION:         { Icon: ArrowRightLeft, label: 'Break-Option' },
+  BREAK_OPTION:         { Icon: ArrowRightLeft,  label: 'Break-Option' },
-  RENT_REVIEW:          { Icon: TrendingUp,     label: 'Mietanpassung' },
+  RENT_REVIEW:          { Icon: TrendingUp,      label: 'Mietanpassung' },
-  INSPECTION:           { Icon: ClipboardCheck, label: 'Inspektion' },
+  INSPECTION:           { Icon: ClipboardCheck,  label: 'Inspektion' },
-  INSURANCE_RENEWAL:    { Icon: Shield,         label: 'Versicherung' },
+  INSURANCE_RENEWAL:    { Icon: Shield,          label: 'Versicherung' },
-  MAINTENANCE:          { Icon: Wrench,         label: 'Unterhalt' },
+  MAINTENANCE:          { Icon: Wrench,          label: 'Unterhalt' },
-  SCHATTENMARKT_RELEASE:{ Icon: Eye,            label: 'Pre-Market' },
+  SCHATTENMARKT_RELEASE:{ Icon: Eye,             label: 'Pre-Market' },
-  CUSTOM:               { Icon: Tag,            label: 'Individuell' },
+  CUSTOM:               { Icon: Tag,             label: 'Individuell' },
  // Contract Intelligence (Runde 8, §4)
  NOTICE_PERIOD:        { Icon: Scissors,        label: 'Kündigungsfrist' },
  REAL_OPTION:          { Icon: KeyRound,        label: 'Echte Option' },
  UNREAL_OPTION:        { Icon: Handshake,       label: 'Unechte Option' },
  NEGOTIATION_WINDOW:   { Icon: CalendarClock,   label: 'Verhandlungsfenster' },
  CONTRACT_TALK:        { Icon: MessagesSquare,  label: 'Vertragsgespräch' },
 }
 interface Props {
@@ -12,14 +12,21 @@
 import { memo, useCallback, useMemo, useState } from 'react'
 import {
  Alert, Box, Button, Dialog, DialogActions, DialogContent, DialogTitle,
-  FormControlLabel, Switch, TextField, Typography,
+  FormControlLabel, IconButton, Switch, TextField, Tooltip, Typography,
 } from '@mui/material'
-import { ArrowDownLeft, ArrowLeftRight, ArrowUpRight, Settings2 } from 'lucide-react'
+import { ArrowDownLeft, ArrowLeftRight, ArrowUpRight, Pencil, Plus, Settings2, Trash2 } from 'lucide-react'
 import type { LucideIcon } from 'lucide-react'
 import type { AgentChannel, TeamAgent } from '../../domain/teamAgent'
-import { AgentChannelDirection, AgentConnectionStatus } from '../../domain/teamAgent'
+import { AgentChannelDirection, AgentChannelType, AgentConnectionStatus } from '../../domain/teamAgent'
 import { AgentConnectionStatusBadge } from './AgentBadges'
-import { AGENT_CHANNEL_DIRECTION_LABELS, AGENT_CHANNEL_LABELS } from '../../lib/constants'
+import { AgentEntityDialog } from './AgentEntityDialog'
 import type { EntityDraft, EntityField } from './AgentEntityDialog'
 import { newEntityId, removeById, upsertById } from './agentEntityEditing'
 import {
  AGENT_CHANNEL_DIRECTION_LABELS,
  AGENT_CHANNEL_LABELS,
  AGENT_CONNECTION_STATUS_LABELS,
 } from '../../lib/constants'
 import { useSaveAgentChannels } from '../../hooks/useTeamAgents'
 import { DS_BG, DS_BORDER, DS_SHADOW, DS_TEXT } from '../../lib/ds'
@@ -40,15 +47,65 @@ const TEST_RESULT_BY_STATUS: Record<AgentConnectionStatus, TestResult> = {
  [AgentConnectionStatus.ROADMAP]: { ok: false, message: 'Verbindung fehlgeschlagen. Dieser Kanal ist erst geplant und noch nicht eingerichtet — ein Test ist nach der Einrichtung möglich.' },
 }
 // ── Maske zum Anlegen und Bearbeiten (Runde 10, §2A) ──────────────────────────
 const CHANNEL_FIELDS: EntityField[] = [
  {
    key: 'type',
    label: 'Kanal',
    type: 'select',
    required: true,
    options: Object.values(AgentChannelType).map((t) => ({
      value: t,
      label: AGENT_CHANNEL_LABELS[t] ?? t,
    })),
  },
  {
    key: 'direction',
    label: 'Richtung',
    type: 'select',
    required: true,
    options: Object.values(AgentChannelDirection).map((d) => ({
      value: d,
      label: AGENT_CHANNEL_DIRECTION_LABELS[d] ?? d,
    })),
  },
  {
    key: 'status',
    label: 'Verbindung',
    type: 'select',
    required: true,
    options: Object.values(AgentConnectionStatus).map((s) => ({
      value: s,
      label: AGENT_CONNECTION_STATUS_LABELS[s] ?? s,
    })),
    helperText: 'Ein neu erfasster Kanal gilt erst als verbunden, wenn er eingerichtet ist.',
  },
  {
    key: 'description',
    label: 'Wofür wird der Kanal genutzt?',
    type: 'multiline',
    required: true,
  },
  {
    key: 'displayName',
    label: 'Anzeigename',
    helperText: 'Steht so im Konfigurationsdialog.',
  },
 ]
 // ── Kanalzeile ────────────────────────────────────────────────────────────────
 interface RowProps {
  channel: AgentChannel
  editing: boolean
  onToggle: (channelId: string, enabled: boolean) => void
  onConfigure: (channelId: string) => void
  onEdit: (channelId: string) => void
  onDelete: (channelId: string) => void
 }
-const ChannelRow = memo(function ChannelRow({ channel, onToggle, onConfigure }: RowProps) {
+const ChannelRow = memo(function ChannelRow({ channel, editing, onToggle, onConfigure, onEdit, onDelete }: RowProps) {
  const label = AGENT_CHANNEL_LABELS[channel.type] ?? channel.type
  const DirectionIcon = DIRECTION_ICON[channel.direction]
@@ -71,6 +128,20 @@ const ChannelRow = memo(function ChannelRow({ channel, onToggle, onConfigure }:
          <Typography variant="caption" sx={{ color: DS_TEXT.secondary }}>
            {AGENT_CHANNEL_DIRECTION_LABELS[channel.direction] ?? channel.direction}
          </Typography>
          {editing && (
            <>
              <Tooltip title="Kanal bearbeiten">
                <IconButton size="small" onClick={() => onEdit(channel.id)} sx={{ color: DS_TEXT.secondary }}>
                  <Pencil size={14} />
                </IconButton>
              </Tooltip>
              <Tooltip title="Kanal entfernen">
                <IconButton size="small" onClick={() => onDelete(channel.id)} sx={{ color: DS_TEXT.secondary }}>
                  <Trash2 size={14} />
                </IconButton>
              </Tooltip>
            </>
          )}
        </Box>
      </Box>
@@ -197,6 +268,10 @@ export function AgentChannelsTab({ agent }: { agent: TeamAgent }) {
  const { mutate: saveChannels } = useSaveAgentChannels()
  const [openChannelId, setOpenChannelId] = useState<string | null>(null)
  /** `null` = Maske zu, `'new'` = Anlegen, sonst die ID des bearbeiteten Kanals. */
  const [bearbeitet, setBearbeitet] = useState<string | null>(null)
  const [bearbeitungsmodus, setBearbeitungsmodus] = useState(false)
  const channels = agent.channels
  // Beide Kennzahlen in einem Durchlauf (§10.4).
@@ -222,15 +297,72 @@ export function AgentChannelsTab({ agent }: { agent: TeamAgent }) {
  const handleConfigure = useCallback((channelId: string) => setOpenChannelId(channelId), [])
  const handleClose = useCallback(() => setOpenChannelId(null), [])
  const handleDelete = useCallback(
    (channelId: string) => saveChannels({ id: agent.id, channels: removeById(channels, channelId) }),
    [agent.id, channels, saveChannels],
  )
  /**
   * Anlegen und Bearbeiten teilen sich die Maske. Gespeichert wird sofort —
   * ein Kanal ist wie der Aktiv-Schalter ein Ein/Aus-Entscheid, kein Formular
   * mit Zwischenstand.
   */
  const handleDialogSave = useCallback(
    (werte: EntityDraft, active: boolean) => {
      const bestehend = bearbeitet !== 'new' ? channels.find((c) => c.id === bearbeitet) : undefined
      const eintrag: AgentChannel = {
        id: bestehend?.id ?? newEntityId(agent.id, 'channel'),
        type: werte.type as AgentChannelType,
        direction: werte.direction as AgentChannelDirection,
        status: werte.status as AgentConnectionStatus,
        description: werte.description.trim(),
        enabled: active,
        ...(bestehend?.optional ? { optional: true } : {}),
        config: {
          ...(bestehend?.config ?? { defaultRecipients: [], autoReplyEnabled: false }),
          displayName: werte.displayName?.trim() || (AGENT_CHANNEL_LABELS[werte.type] ?? werte.type),
        },
      }
      saveChannels({ id: agent.id, channels: upsertById(channels, eintrag) })
      setBearbeitet(null)
    },
    [bearbeitet, channels, agent.id, saveChannels],
  )
  const inBearbeitung = bearbeitet && bearbeitet !== 'new'
    ? channels.find((c) => c.id === bearbeitet)
    : undefined
  return (
    <Box>
      <Typography variant="body2" sx={{ color: DS_TEXT.secondary }}>
        Über diese Kanäle erhält {agent.name} Aufträge und liefert Ergebnisse aus.
      </Typography>
-      <Typography variant="caption" sx={{ color: DS_TEXT.muted, display: 'block', mt: 0.25, mb: 1.5 }}>
+      <Typography variant="caption" sx={{ color: DS_TEXT.muted, display: 'block', mt: 0.25 }}>
        {summary.active} von {channels.length} Kanälen aktiv · {summary.connected} verbunden
      </Typography>
      <Box sx={{ display: 'flex', gap: 1, flexWrap: 'wrap', mt: 1.5, mb: 1.5 }}>
        <Button
          size="small"
          variant="outlined"
          startIcon={<Pencil size={14} aria-hidden />}
          onClick={() => setBearbeitungsmodus((v) => !v)}
          sx={{ textTransform: 'none', ...FOCUS_RING }}
        >
          {bearbeitungsmodus ? 'Bearbeiten beenden' : 'Kanäle bearbeiten'}
        </Button>
        <Button
          size="small"
          variant="outlined"
          startIcon={<Plus size={14} aria-hidden />}
          onClick={() => setBearbeitet('new')}
          sx={{ textTransform: 'none', ...FOCUS_RING }}
        >
          Neuen Kanal anbinden
        </Button>
      </Box>
      {channels.length === 0 ? (
        <Typography variant="body2" sx={{ color: DS_TEXT.muted }}>
          Für {agent.name} ist noch kein Kanal hinterlegt.
@@ -238,12 +370,38 @@ export function AgentChannelsTab({ agent }: { agent: TeamAgent }) {
      ) : (
        <Box component="ul" sx={{ listStyle: 'none', m: 0, p: 0, display: 'grid', gap: 1.25 }}>
          {channels.map((channel) => (
-            <ChannelRow key={channel.id} channel={channel} onToggle={handleToggle} onConfigure={handleConfigure} />
+            <ChannelRow
              key={channel.id}
              channel={channel}
              editing={bearbeitungsmodus}
              onToggle={handleToggle}
              onConfigure={handleConfigure}
              onEdit={setBearbeitet}
              onDelete={handleDelete}
            />
          ))}
        </Box>
      )}
      <ChannelConfigDialog channel={openChannel} onClose={handleClose} />
      <AgentEntityDialog
        open={bearbeitet !== null}
        entityKey={bearbeitet ?? undefined}
        title={inBearbeitung ? 'Kanal bearbeiten' : 'Neuen Kanal anbinden'}
        fields={CHANNEL_FIELDS}
        initial={{
          type: inBearbeitung?.type ?? AgentChannelType.EMAIL,
          direction: inBearbeitung?.direction ?? AgentChannelDirection.BOTH,
          status: inBearbeitung?.status ?? AgentConnectionStatus.DISCONNECTED,
          description: inBearbeitung?.description ?? '',
          displayName: inBearbeitung?.config.displayName ?? '',
        }}
        activeLabel="Kanal aktiv"
        initialActive={inBearbeitung?.enabled ?? true}
        onSave={handleDialogSave}
        onClose={() => setBearbeitet(null)}
      />
    </Box>
  )
 }
@@ -0,0 +1,131 @@
 import { useEffect, useLayoutEffect, useRef } from 'react'
 import { Box, Typography } from '@mui/material'
 import { useAgentChatStore } from '../../stores/agentChatStore'
 import { AgentAvatar } from './AgentAvatar'
 import { DS_BORDER, DS_SLATE, DS_TEXT } from '../../lib/ds'
 /**
 * Höhe des Verlaufsfensters.
 *
 * Der Verlauf braucht eine feste Obergrenze, sonst wächst er mit jeder Antwort
 * und schiebt die Seite darunter weg — genau das Springen, das behoben werden
 * soll. Innerhalb dieser Höhe scrollt der Verlauf für sich.
 */
 const TRANSCRIPT_MAX_HEIGHT = 420
 /**
 * Der Gesprächsverlauf unter dem Eingabefeld (Runde 9, §3).
 *
 * Bewusst schlicht: Frage rechts, Antwort links mit dem Porträt des Agenten,
 * keine Zeitstempel, keine Sprechblasen mit Spitzen, kein Tippindikator. Der
 * Chat beantwortet drei Fragetypen aus Mockdaten — eine Oberfläche, die nach
 * Messenger aussieht, verspräche mehr, als dahinter steckt.
 *
 * Vor der ersten Frage erscheint gar nichts. Der grosszügige Weissraum unter
 * dem Eingabefeld ist Teil des Einstiegs und soll nicht durch einen leeren
 * Verlaufsrahmen ersetzt werden.
 */
 export function AgentChatTranscript() {
  const messages = useAgentChatStore(s => s.messages)
  const agent = useAgentChatStore(s => s.agent)
  const containerRef = useRef<HTMLDivElement>(null)
  /** Die zuletzt gestellte Frage — an ihr richtet sich die Scrollposition aus. */
  const lastQuestionRef = useRef<HTMLDivElement>(null)
  const zuletztGescrollt = useRef(0)
  /**
   * Nach einer Antwort den Verlauf so stellen, dass die eigene Frage oben steht
   * und die Antwort direkt darunter beginnt (Runde 10, §4).
   *
   * Ausschliesslich über `scrollTop` des Containers. Kein `scrollIntoView` und
   * kein `window.scrollTo`: Beide bewegen die Seite mit, und genau dieses
   * Wegspringen des ganzen Bildschirms war die Beschwerde. Der Browser-Viewport
   * bleibt hier unberührt.
   *
   * `useLayoutEffect`, damit die Korrektur vor dem Zeichnen sitzt — sonst sieht
   * man den Sprung einmal kurz.
   */
  useLayoutEffect(() => {
    const container = containerRef.current
    const frage = lastQuestionRef.current
    if (!container || !frage || messages.length === zuletztGescrollt.current) return
    zuletztGescrollt.current = messages.length
    // Abstand der Frage zum oberen Rand des Verlaufs, minus ein schmaler
    // Vorlauf, damit sie nicht bündig an der Kante klebt.
    container.scrollTop = Math.max(0, frage.offsetTop - container.offsetTop - 8)
  }, [messages.length])
  // Ein Agentenwechsel leert den Verlauf; dann darf die nächste Antwort wieder
  // ausrichten, statt die alte Zählung fortzuschreiben.
  useEffect(() => {
    if (messages.length === 0) zuletztGescrollt.current = 0
  }, [messages.length])
  if (messages.length === 0 || !agent) return null
  const letzteFrageIndex = messages.map(m => m.from).lastIndexOf('user')
  return (
    <Box
      ref={containerRef}
      sx={{
        width: '100%',
        maxWidth: 720,
        mt: 2.5,
        display: 'flex',
        flexDirection: 'column',
        gap: 1.5,
        // Der Verlauf scrollt für sich; die Seite darunter bleibt, wo sie ist.
        maxHeight: TRANSCRIPT_MAX_HEIGHT,
        overflowY: 'auto',
        // Ohne diesen Innenabstand klebt die Bildlaufleiste am Text.
        pr: 0.5,
        // Verhindert, dass das Scrollen am Ende des Verlaufs auf die Seite
        // durchschlägt — sonst wandert der Bildschirm doch wieder.
        overscrollBehavior: 'contain',
      }}
    >
      {messages.map((m, i) => (
        m.from === 'user' ? (
          <Box
            key={i}
            ref={i === letzteFrageIndex ? lastQuestionRef : undefined}
            sx={{ alignSelf: 'flex-end', maxWidth: '85%' }}
          >
            <Box
              sx={{
                px: 1.75, py: 1,
                borderRadius: 2.5,
                bgcolor: DS_SLATE[100],
                border: `1px solid ${DS_BORDER.default}`,
              }}
            >
              <Typography variant="body2" sx={{ color: DS_TEXT.primary, whiteSpace: 'pre-line' }}>
                {m.text}
              </Typography>
            </Box>
          </Box>
        ) : (
          <Box key={i} sx={{ display: 'flex', gap: 1.25, alignItems: 'flex-start', maxWidth: '95%' }}>
            <Box sx={{ flexShrink: 0, mt: 0.25 }}>
              <AgentAvatar agent={agent} size="small" />
            </Box>
            <Box
              sx={{
                px: 1.75, py: 1,
                borderRadius: 2.5,
                bgcolor: 'white',
                border: `1px solid ${DS_BORDER.default}`,
              }}
            >
              <Typography variant="body2" sx={{ color: DS_TEXT.primary, lineHeight: 1.6, whiteSpace: 'pre-line' }}>
                {m.text}
              </Typography>
            </Box>
          </Box>
        )
      ))}
    </Box>
  )
 }
@@ -0,0 +1,123 @@
 /**
 * Property On — Mehrfachauswahl als entfernbare Chips (Runde 10, §§2.7–2.9).
 *
 * Eine Komponente für alle drei Stellen — Quellentypen, Beobachtungsraum und
 * zeitliche Relevanz. Sie unterscheiden sich nur darin, ob eigene Werte erlaubt
 * sind; die Bedienung ist überall dieselbe, und das ist der Punkt: Wer gelernt
 * hat, wie man einen Quellentyp entfernt, weiss es auch beim Beobachtungsraum.
 *
 * Der eine Unterschied zum bisherigen Auswahlfeld: Jeder gewählte Wert lässt
 * sich einzeln wegklicken — auch die, die von Anfang an gesetzt waren. Vorher
 * konnte man Vorgaben nur über das Auswahlmenü loswerden, was niemand fand.
 */
 import { memo, useCallback, useState } from 'react'
 import { Box, Chip, MenuItem, TextField, Typography } from '@mui/material'
 import { Plus } from 'lucide-react'
 import type { AgentSettingOption } from '../../domain/teamAgent'
 import { DS_TEXT } from '../../lib/ds'
 interface Props {
  value: string[]
  options: AgentSettingOption[]
  /** Freitext erlauben — bei fachlich abgeschlossenen Listen aus. */
  allowCustom: boolean
  disabled?: boolean
  ariaLabel: string
  onChange: (next: string[]) => void
 }
 /** Ein selbst erfasster Wert hat keine Option — dann ist er selbst sein Etikett. */
 function etikett(value: string, options: AgentSettingOption[]): string {
  return options.find(o => o.value === value)?.label ?? value
 }
 export const AgentChipsField = memo(function AgentChipsField({
  value, options, allowCustom, disabled, ariaLabel, onChange,
 }: Props) {
  const [eingabe, setEingabe] = useState('')
  const offeneOptionen = options.filter(o => !value.includes(o.value))
  const entfernen = useCallback(
    (v: string) => onChange(value.filter(e => e !== v)),
    [value, onChange],
  )
  const hinzufuegen = useCallback(
    (v: string) => {
      const sauber = v.trim()
      // Leeres nicht speichern, Doppeltes nicht anlegen — beides würde die
      // Liste nur verlängern, ohne etwas auszusagen.
      if (!sauber || value.includes(sauber)) return
      onChange([...value, sauber])
    },
    [value, onChange],
  )
  return (
    <Box sx={{ display: 'grid', gap: 1 }}>
      <Box sx={{ display: 'flex', flexWrap: 'wrap', gap: 0.75 }} role="list" aria-label={ariaLabel}>
        {value.length === 0 && (
          <Typography variant="caption" sx={{ color: DS_TEXT.muted, py: 0.5 }}>
            Nichts ausgewählt — damit gilt keine Einschränkung.
          </Typography>
        )}
        {value.map(v => (
          <Chip
            key={v}
            role="listitem"
            size="small"
            label={etikett(v, options)}
            onDelete={disabled ? undefined : () => entfernen(v)}
            disabled={disabled}
          />
        ))}
      </Box>
      <Box sx={{ display: 'flex', gap: 1, flexWrap: 'wrap' }}>
        {offeneOptionen.length > 0 && (
          <TextField
            select
            size="small"
            disabled={disabled}
            value=""
            label="Auswählen"
            sx={{ minWidth: 220, flex: 1 }}
            onChange={e => hinzufuegen(e.target.value)}
          >
            {offeneOptionen.map(o => (
              <MenuItem key={o.value} value={o.value} sx={{ fontSize: '0.8125rem' }}>
                {o.label}
              </MenuItem>
            ))}
          </TextField>
        )}
        {allowCustom && (
          <TextField
            size="small"
            disabled={disabled}
            value={eingabe}
            label="Eigener Eintrag"
            placeholder="Tippen und Enter"
            sx={{ minWidth: 220, flex: 1 }}
            onChange={e => setEingabe(e.target.value)}
            onKeyDown={e => {
              if (e.key !== 'Enter') return
              // Sonst schickt Enter das umgebende Formular ab.
              e.preventDefault()
              hinzufuegen(eingabe)
              setEingabe('')
            }}
            slotProps={{
              input: {
                endAdornment: <Plus size={14} color={DS_TEXT.muted} aria-hidden />,
              },
            }}
          />
        )}
      </Box>
    </Box>
  )
 })
@@ -0,0 +1,182 @@
 import { useState } from 'react'
 import {
  Box, Button, Dialog, DialogActions, DialogContent, DialogTitle,
  FormControlLabel, MenuItem, Switch, TextField,
 } from '@mui/material'
 import { DS_BRAND } from '../../lib/ds'
 /**
 * Ein Feld der Bearbeitungsmaske.
 *
 * Bewusst ein winziger Beschreibungstyp statt einer Maske je Entität: Aufgaben,
 * Systeme und Kanäle unterscheiden sich nur in den Feldern, nicht im Verhalten.
 * Drei fast gleiche Dialoge wären drei Stellen für jede künftige Korrektur.
 */
 export interface EntityField {
  key: string
  label: string
  /** `select` braucht `options`, `multiline` wird mehrzeilig dargestellt. */
  type?: 'text' | 'multiline' | 'select' | 'url'
  options?: { value: string; label: string }[]
  required?: boolean
  placeholder?: string
  helperText?: string
 }
 export type EntityDraft = Record<string, string>
 /**
 * Eine Adresse wird als Quelle tatsächlich abgerufen — sie muss deshalb an der
 * Maske scheitern und nicht erst im Recherchelauf. Geprüft wird nur das
 * Schema: ob die Seite antwortet, kann erst der Abruf sagen, und ein Formular,
 * das Erreichbarkeit behauptet, wäre eine Behauptung zu viel.
 */
 function urlFehler(wert: string): string | null {
  const text = wert.trim()
  if (text === '') return null
  let parsed: URL
  try {
    parsed = new URL(text)
  } catch {
    return 'Bitte eine vollständige Adresse angeben, z. B. https://www.beispiel.ch/news.'
  }
  if (parsed.protocol !== 'http:' && parsed.protocol !== 'https:') {
    return 'Nur http- und https-Adressen können gelesen werden.'
  }
  return null
 }
 interface Props {
  open: boolean
  /**
   * Kennung des bearbeiteten Eintrags — bei offenem Dialog ein Wechsel darauf
   * baut die Maske neu auf. Bewusst über den React-Schlüssel statt über einen Effekt: ein
   * Effekt würde den Entwurf nachträglich überschreiben und dabei bereits
   * getippten Text verlieren.
   */
  entityKey?: string
  /** Überschrift, z. B. «Aufgabe bearbeiten» oder «Neues System anbinden». */
  title: string
  fields: EntityField[]
  /** Vorbelegung; beim Anlegen leer. */
  initial: EntityDraft
  /** Beschriftung des Aktiv-Schalters; entfällt, wenn nicht gesetzt. */
  activeLabel?: string
  initialActive?: boolean
  onSave: (draft: EntityDraft, active: boolean) => void
  onClose: () => void
 }
 /**
 * Gemeinsame Maske zum Anlegen und Bearbeiten von Aufgaben, Systemen und
 * Kanälen (Runde 10, §2).
 *
 * Der Entwurf lebt lokal und geht erst beim Speichern hinaus — bei jedem
 * Tastendruck zu speichern hiesse, jeden Zwischenstand zum gültigen Stand zu
 * erklären. Über `key` auf dem Dialoginhalt entsteht die Maske bei jedem
 * Öffnen neu, statt dass ein Effekt den alten Entwurf nachträglich überschreibt.
 */
 export function AgentEntityDialog({
  open, title, fields, initial, activeLabel, initialActive = true, entityKey, onSave, onClose,
 }: Props) {
  return (
    <Dialog open={open} onClose={onClose} maxWidth="sm" fullWidth>
      <DialogTitle sx={{ fontSize: '1rem', fontWeight: 700 }}>{title}</DialogTitle>
      {open && (
        <DialogBody
          key={entityKey ?? 'neu'}
          fields={fields}
          initial={initial}
          activeLabel={activeLabel}
          initialActive={initialActive}
          onSave={onSave}
          onClose={onClose}
        />
      )}
    </Dialog>
  )
 }
 function DialogBody({
  fields, initial, activeLabel, initialActive, onSave, onClose,
 }: Omit<Props, 'open' | 'title' | 'entityKey'>) {
  const [draft, setDraft] = useState<EntityDraft>(initial)
  const [active, setActive] = useState(initialActive ?? true)
  const [touched, setTouched] = useState(false)
  const fehlend = fields.filter(f => f.required && !(draft[f.key] ?? '').trim()).map(f => f.key)
  // Formfehler je Feld, unabhängig davon, ob das Feld leer geblieben ist.
  const formfehler: Record<string, string> = {}
  for (const f of fields) {
    if (f.type !== 'url') continue
    const meldung = urlFehler(draft[f.key] ?? '')
    if (meldung) formfehler[f.key] = meldung
  }
  function handleSave() {
    setTouched(true)
    if (fehlend.length > 0 || Object.keys(formfehler).length > 0) return
    onSave(draft, active)
  }
  return (
    <>
      <DialogContent>
        <Box sx={{ display: 'flex', flexDirection: 'column', gap: 2, pt: 0.5 }}>
          {fields.map(f => (
            <TextField
              key={f.key}
              select={f.type === 'select'}
              multiline={f.type === 'multiline'}
              minRows={f.type === 'multiline' ? 3 : undefined}
              type={f.type === 'url' ? 'url' : 'text'}
              label={f.label}
              value={draft[f.key] ?? ''}
              onChange={e => setDraft(prev => ({ ...prev, [f.key]: e.target.value }))}
              placeholder={f.placeholder}
              required={f.required}
              error={touched && (fehlend.includes(f.key) || f.key in formfehler)}
              helperText={
                touched && fehlend.includes(f.key)
                  ? 'Dieses Feld wird gebraucht.'
                  : touched && formfehler[f.key]
                    ? formfehler[f.key]
                    : f.helperText
              }
              size="small"
              fullWidth
            >
              {(f.options ?? []).map(o => (
                <MenuItem key={o.value} value={o.value} sx={{ fontSize: '0.8125rem' }}>
                  {o.label}
                </MenuItem>
              ))}
            </TextField>
          ))}
          {activeLabel && (
            <FormControlLabel
              control={<Switch size="small" checked={active} onChange={(_, v) => setActive(v)} />}
              label={active ? activeLabel : `${activeLabel} — derzeit inaktiv`}
              slotProps={{ typography: { variant: 'body2' } }}
            />
          )}
        </Box>
      </DialogContent>
      <DialogActions sx={{ px: 3, pb: 2 }}>
        <Button onClick={onClose} sx={{ textTransform: 'none' }}>
          Abbrechen
        </Button>
        <Button
          variant="contained"
          onClick={handleSave}
          sx={{ textTransform: 'none', bgcolor: DS_BRAND.main, '&:hover': { bgcolor: DS_BRAND.hover } }}
        >
          Speichern
        </Button>
      </DialogActions>
    </>
  )
 }
@@ -1,16 +1,28 @@
-import { memo } from 'react'
+import { memo, useMemo } from 'react'
 import { Box, Typography } from '@mui/material'
 import type { AgentMetric, TeamAgent } from '../../domain/teamAgent'
 import { EmptyState } from '../ui'
 import { useMatchRuns } from '../../hooks/useMatchRuns'
 import { useFutureSignals } from '../../hooks/useFutureSignals'
 import { isRisiko } from '../../lib/leadSignal'
 import { DS_BG, DS_BORDER, DS_TEXT } from '../../lib/ds'
 /**
 * Reiter «Kennzahlen».
 *
- * Zeigt ausschliesslich die Kennzahlen, die im Personalblatt des Mitarbeitenden
+ * Zeigt die Kennzahlen, die das Personalblatt führt. Es wird nichts
- * bereits hinterlegt sind. Es werden keine Werte berechnet, hochgerechnet oder
+ * hochgerechnet und nichts ergänzt — was der Katalog nicht führt, steht hier
- * ergänzt — was der Katalog nicht führt, steht hier auch nicht.
+ * auch nicht.
 *
 * Ausnahme seit Runde 10 (§3.11): Noras beide Kennzahlen kommen aus dem
 * laufenden Stand der Anwendung und nicht aus dem Katalog. Ein fester Wert
 * wäre dort eine Behauptung — die eine Zahl zählt tatsächlich ausgeführte
 * Matching-Läufe, die andere tatsächlich zugeordnete Objekte.
 */
 /** Kennungen, deren Wert zur Laufzeit entsteht. */
 const MATCH_RUNS_METRIC = 'nora-metric-match-runs'
 const AFFECTED_OBJECTS_METRIC = 'nora-metric-affected-objects'
 const MetricTile = memo(function MetricTile({ metric }: { metric: AgentMetric }) {
  return (
    <Box
@@ -46,7 +58,46 @@ const MetricTile = memo(function MetricTile({ metric }: { metric: AgentMetric })
 })
 export function AgentMetricsTab({ agent }: { agent: TeamAgent }) {
-  if (agent.metrics.length === 0) {
+  const { data: matchRuns = [] } = useMatchRuns()
  const { data: signals = [] } = useFutureSignals()
  /**
   * Die beiden Laufzeit-Kennzahlen einsetzen.
   *
   * «Betroffene Objekte» zählt Risikosignale mit eindeutig zugeordnetem
   * Objekt — und zwar die Objekte, nicht die Signale: Zwei Meldungen über
   * dasselbe Objekt sind ein betroffenes Objekt, nicht zwei.
   */
  const metrics = useMemo((): AgentMetric[] => {
    const laeufe = matchRuns.length
    const betroffene = new Set(
      signals.filter(sig => isRisiko(sig) && sig.propertyId).map(sig => sig.propertyId!),
    ).size
    return agent.metrics.map((m) => {
      if (m.id === MATCH_RUNS_METRIC) {
        return {
          ...m,
          value: String(laeufe),
          hint: laeufe === 0
            ? 'Noch kein Matching ausgeführt. Die Zahl steigt nur durch einen tatsächlichen Lauf.'
            : `Zuletzt am ${new Date(matchRuns[0].timestamp).toLocaleString('de-CH', { dateStyle: 'short', timeStyle: 'short' })} für «${matchRuns[0].leadTitle}».`,
        }
      }
      if (m.id === AFFECTED_OBJECTS_METRIC) {
        return {
          ...m,
          value: String(betroffene),
          hint: betroffene === 0
            ? 'Derzeit ist keinem Risikosignal ein Objekt aus dem Bestand eindeutig zugeordnet.'
            : m.hint,
        }
      }
      return m
    })
  }, [agent.metrics, matchRuns, signals])
  if (metrics.length === 0) {
    return (
      <EmptyState
        title="Keine Kennzahlen hinterlegt"
@@ -63,7 +114,7 @@ export function AgentMetricsTab({ agent }: { agent: TeamAgent }) {
        gridTemplateColumns: { xs: '1fr', sm: 'repeat(2, minmax(0, 1fr))', lg: 'repeat(3, minmax(0, 1fr))' },
      }}
    >
-      {agent.metrics.map((metric) => (
+      {metrics.map((metric) => (
        <MetricTile key={metric.id} metric={metric} />
      ))}
    </Box>
@@ -11,14 +11,16 @@
 import { memo, useCallback, useMemo, useState } from 'react'
 import type { ReactNode } from 'react'
 // prettier-ignore
-import { Box, Button, Chip, FormControlLabel, FormHelperText, InputAdornment, MenuItem, Select, Switch, TextField, Typography } from '@mui/material'
+import { Box, Button, Chip, FormControlLabel, FormHelperText, IconButton, InputAdornment, MenuItem, Popover, Select, Switch, TextField, Typography } from '@mui/material'
-import { AlertTriangle, Lock } from 'lucide-react'
+import { AlertTriangle, Info, Lock } from 'lucide-react'
 import { z } from 'zod'
 import type { AgentSetting, TeamAgent } from '../../domain/teamAgent'
 import { AgentSettingGroup, AgentSettingKind } from '../../domain/teamAgent'
 import { AGENT_SETTING_GROUP_LABELS } from '../../lib/constants'
 import { DS_BG, DS_BORDER, DS_SHADOW, DS_SURFACE, DS_TEXT } from '../../lib/ds'
 import { useSaveAgentSettings } from '../../hooks/useTeamAgents'
 import { AgentChipsField } from './AgentChipsField'
 import { ResearchDocumentsField } from './ResearchDocumentsField'
 type SettingValue = AgentSetting['value']
@@ -53,6 +55,14 @@ function buildSettingsSchema(settings: AgentSetting[]) {
      shape[setting.id] = field
    } else if (setting.kind === AgentSettingKind.MULTI_SELECT) {
      shape[setting.id] = z.array(z.string()).min(1, 'Mindestens ein Eintrag ist erforderlich.')
    } else if (setting.kind === AgentSettingKind.CHIPS) {
      // Bewusst ohne Mindestzahl: Eine leere Auswahl bedeutet «keine
      // Einschränkung» und ist damit eine gültige Aussage, kein Fehler.
      shape[setting.id] = z.array(z.string())
    } else if (setting.kind === AgentSettingKind.DOCUMENTS) {
      // Die Dokumente liegen in IndexedDB und nicht im Entwurf dieses Reiters;
      // hier steht nur der Platz, an dem sie erscheinen.
      shape[setting.id] = z.any()
    } else if (setting.kind === AgentSettingKind.BOOLEAN) {
      shape[setting.id] = z.boolean()
    } else {
@@ -62,6 +72,40 @@ function buildSettingsSchema(settings: AgentSetting[]) {
  return z.object(shape)
 }
 // ── Erklärung zu einem Wert (Runde 10, §2.10) ─────────────────────────────────
 /**
 * Ein Popover und kein Tooltip: Der Text ist mehrere Sätze lang, und ein
 * Tooltip verschwindet, sobald man den Zeiger bewegt, um ihn zu Ende zu lesen.
 */
 function SettingInfoButton({ label, text }: { label: string; text: string }) {
  const [anker, setAnker] = useState<HTMLElement | null>(null)
  return (
    <>
      <IconButton
        size="small"
        aria-label={`Wie entsteht «${label}»?`}
        onClick={(e) => setAnker(e.currentTarget)}
        sx={{ color: DS_TEXT.muted, p: 0.25, ...FOCUS_SX }}
      >
        <Info size={14} />
      </IconButton>
      <Popover
        open={anker !== null}
        anchorEl={anker}
        onClose={() => setAnker(null)}
        anchorOrigin={{ vertical: 'bottom', horizontal: 'left' }}
        slotProps={{ paper: { sx: { maxWidth: 460, p: 2, boxShadow: DS_SHADOW.panel } } }}
      >
        <Typography variant="body2" sx={{ color: DS_TEXT.primary, lineHeight: 1.55 }}>
          {text}
        </Typography>
      </Popover>
    </>
  )
 }
 // ── Eine Einstellung ──────────────────────────────────────────────────────────
 interface RowProps {
@@ -126,6 +170,24 @@ const SettingRow = memo(function SettingRow({ setting, error, onChange }: RowPro
        </>
      )
      break
    case AgentSettingKind.CHIPS:
      control = (
        <>
          <AgentChipsField
            value={Array.isArray(setting.value) ? setting.value : []}
            options={options}
            allowCustom={setting.allowCustom === true}
            disabled={locked}
            ariaLabel={setting.label}
            onChange={(next) => onChange(setting.id, next)}
          />
          {error && <FormHelperText error>{error}</FormHelperText>}
        </>
      )
      break
    case AgentSettingKind.DOCUMENTS:
      control = <ResearchDocumentsField />
      break
    default:
      control = (
        <TextField {...shared} value={text} multiline={long} minRows={long ? 3 : undefined}
@@ -135,7 +197,10 @@ const SettingRow = memo(function SettingRow({ setting, error, onChange }: RowPro
  return (
    <Box sx={{ display: 'grid', gap: 0.5, py: 1.5, borderTop: `1px solid ${DS_BORDER.muted}` }}>
-      <Typography variant="body2" sx={{ fontWeight: 600, color: DS_TEXT.primary }}>{setting.label}</Typography>
+      <Box sx={{ display: 'flex', alignItems: 'center', gap: 0.5 }}>
        <Typography variant="body2" sx={{ fontWeight: 600, color: DS_TEXT.primary }}>{setting.label}</Typography>
        {setting.infoText && <SettingInfoButton label={setting.label} text={setting.infoText} />}
      </Box>
      {setting.description && (
        <Typography id={describedBy} variant="caption" sx={{ display: 'block', color: DS_TEXT.secondary }}>{setting.description}</Typography>
      )}
@@ -1,202 +1,253 @@
 /**
- * Property On — Reiter «Systeme» im Personalblatt (§10).
+ * Property On — Reiter «Systeme» im Personalblatt (§10, Runde 10 §§1–3).
 *
- * Reine Transparenz: welche Fachsysteme und Datenquellen ein digitaler
+ * Zeigt und pflegt die Fachsysteme und Datenquellen eines digitalen
- * Mitarbeiter verwenden darf. Keine Aktionen — Zugänge werden auf der Seite
+ * Mitarbeiters. Seit Runde 10 ist der Reiter nicht mehr nur Anzeige: Zugänge
- * «Kanäle & Systeme» eingerichtet, nicht hier.
+ * lassen sich hier anlegen, ändern, zu- und abschalten — dort, wo man sie sieht.
 *
- * Schreibrechte sind der einzige wirklich folgenreiche Zustand auf diesem
+ * Bewusst eine einzige Liste statt getrennter Gruppen «lesend» und
- * Reiter (§10.4): sie verändern Kundendaten in der Bewirtschaftung. Sie stehen
+ * «schreibend»: Die Frage am Bildschirm lautet «welche Systeme nutzt dieser
- * deshalb in einer eigenen Gruppe und tragen zusätzlich zur hervorgehobenen
+ * Mitarbeiter», nicht «wie viele davon sind lesend». Jede Zeile trägt rechts
- * Fläche ein Icon UND einen Klartextsatz — Farbe allein ist kein zulässiger
+ * oben genau zwei Angaben — ob sie genutzt wird und ob gelesen oder geschrieben
- * Statusträger (§2.3, §18).
+ * wird. Beide sind Text, nicht nur Farbe (§2.3, §18).
 */
-import { memo, useMemo } from 'react'
+import { memo, useCallback, useState } from 'react'
-import { Box, Typography } from '@mui/material'
+import { Box, Button, IconButton, Link, Switch, Tooltip, Typography } from '@mui/material'
-import { Eye, KeyRound, PenLine, ShieldCheck } from 'lucide-react'
+import { ExternalLink, Pencil, Plus, Trash2 } from 'lucide-react'
-import type { LucideIcon } from 'lucide-react'
+import {
-import { AgentAccessLevel } from '../../domain/teamAgent'
+  AgentAccessLevel,
  AgentConnectionStatus,
  AgentSystemType,
 } from '../../domain/teamAgent'
 import type { AgentSystem, TeamAgent } from '../../domain/teamAgent'
-import { AgentAccessBadge, AgentConnectionStatusBadge } from './AgentBadges'
+import { GenericBadge } from '../shared/GenericBadge'
-import { DetailSectionTitle } from './WorkItemDetailSections'
+import { AgentEntityDialog } from './AgentEntityDialog'
-import { AGENT_SYSTEM_LABELS } from '../../lib/constants'
+import type { EntityDraft, EntityField } from './AgentEntityDialog'
-import { DS_BG, DS_BORDER, DS_SURFACE, DS_TEXT } from '../../lib/ds'
+import { newEntityId, removeById, upsertById } from './agentEntityEditing'
 import { useSaveAgentSystems } from '../../hooks/useTeamAgents'
 import { AGENT_ACCESS_LABELS } from '../../lib/constants'
 import { istAktiv, istSchreibend, systemTitel } from '../../lib/agentSystems'
 import { DS_BG, DS_BORDER, DS_TEXT } from '../../lib/ds'
-// ── Darstellung je Zugriffstyp ────────────────────────────────────────────────
+// ── Maske ─────────────────────────────────────────────────────────────────────
-interface AccessAppearance {
+const SYSTEM_FIELDS: EntityField[] = [
-  bg: string
+  { key: 'title', label: 'Titel der Quelle', required: true },
-  border: string
+  { key: 'description', label: 'Beschreibung der Quelle', type: 'multiline', required: true },
-  text: string
+  {
-  icon: LucideIcon
+    key: 'url',
-  /** Klartext neben dem Icon, damit der Zugriff nicht nur über die Farbe lesbar ist. */
+    label: 'Link / URL',
-  marker: string
+    type: 'url',
-}
+    placeholder: 'https://…',
-
+    helperText: 'Eine aktive Lesequelle mit Adresse wird im Recherchelauf tatsächlich abgerufen.',
 const ACCESS_APPEARANCE: Record<AgentAccessLevel, AccessAppearance> = {
  [AgentAccessLevel.READ]: {
    bg: DS_BG.surface,
    border: DS_BORDER.default,
    text: DS_TEXT.secondary,
    icon: Eye,
    marker: 'Liest nur — verändert in diesem System nichts',
  },
-  [AgentAccessLevel.WRITE]: {
+  {
-    bg: DS_SURFACE.warning.bg,
+    key: 'access',
-    border: DS_SURFACE.warning.border,
+    label: 'Zugriff',
-    text: DS_TEXT.warningDark,
+    type: 'select',
-    icon: KeyRound,
+    required: true,
-    marker: 'Schreibzugriff — legt in diesem System Daten ab',
+    options: [
      { value: AgentAccessLevel.READ, label: AGENT_ACCESS_LABELS[AgentAccessLevel.READ] },
      { value: AgentAccessLevel.WRITE, label: AGENT_ACCESS_LABELS[AgentAccessLevel.WRITE] },
    ],
    helperText: 'Schreibrechte verändern Kundendaten in der Bewirtschaftung.',
  },
-  [AgentAccessLevel.READ_WRITE]: {
+]
    bg: DS_SURFACE.info.bg,
    border: DS_SURFACE.info.border,
    text: DS_TEXT.infoDark,
    icon: PenLine,
    marker: 'Lese- und Schreibzugriff — verändert bestehende Daten',
  },
 }
 const GROUP_TITLE_READ = 'Lesende Systemzugänge'
 const GROUP_TITLE_WRITE = 'Schreibende Systemzugänge'
 function systemCount(count: number): string {
  return count === 1 ? '1 Fachsystem' : `${count} Fachsysteme`
 }
 // ── Eine Systemzeile ──────────────────────────────────────────────────────────
 interface RowProps {
  system: AgentSystem
  busy: boolean
  editing: boolean
  onToggle: (id: string, enabled: boolean) => void
  onEdit: (id: string) => void
  onDelete: (id: string) => void
 }
 /**
 * `React.memo`, weil das Personalblatt bis zu einem Dutzend Systemzeilen führt
 * und jeder Reiterwechsel sonst die gesamte Liste neu zeichnen würde (§10.2).
 */
-const SystemRow = memo(function SystemRow({ system }: { system: AgentSystem }) {
+const SystemRow = memo(function SystemRow({ system, busy, editing, onToggle, onEdit, onDelete }: RowProps) {
-  const look = ACCESS_APPEARANCE[system.access]
+  const aktiv = istAktiv(system)
-  const AccessIcon = look.icon
+  const schreibend = istSchreibend(system)
  const titel = systemTitel(system)
  return (
    <Box
      component="li"
      sx={{
-        border: `1px solid ${look.border}`,
+        border: `1px solid ${DS_BORDER.default}`,
        borderRadius: 2,
-        bgcolor: look.bg,
+        // Ein abgeschalteter Zugang tritt zurück, bleibt aber vollständig lesbar.
        bgcolor: aktiv ? DS_BG.surface : DS_BG.subtle,
        opacity: aktiv ? 1 : 0.75,
        p: 1.75,
        display: 'grid',
-        gap: 0.875,
+        gap: 0.75,
      }}
    >
-      {/* Kopfzeile: System, Zugriffstyp, Verbindungsstatus */}
+      {/* Kopfzeile: Titel links, genau zwei Angaben rechts (§2.1B) */}
      <Box sx={{ display: 'flex', alignItems: 'center', gap: 1, flexWrap: 'wrap' }}>
        <AccessIcon size={16} color={look.text} aria-hidden style={{ flexShrink: 0 }} />
        <Typography sx={{ fontWeight: 700, fontSize: '0.9375rem', color: DS_TEXT.primary }}>
-          {AGENT_SYSTEM_LABELS[system.type] ?? system.type}
+          {titel}
        </Typography>
-        <Box sx={{ display: 'flex', gap: 0.75, flexWrap: 'wrap', ml: 'auto' }}>
+        <Box sx={{ display: 'flex', gap: 0.75, flexWrap: 'wrap', ml: 'auto', alignItems: 'center' }}>
-          <AgentAccessBadge access={system.access} />
+          <GenericBadge
-          <AgentConnectionStatusBadge status={system.status} />
+            label={aktiv ? 'Aktiv' : 'Inaktiv'}
            semanticVariant={aktiv ? 'confidenceHigh' : 'muted'}
            bold
          />
          <GenericBadge
            label={schreibend ? 'Schreiben' : 'Lesen'}
            semanticVariant={schreibend ? 'confidenceMedium' : 'muted'}
          />
          {editing && (
            <>
              <Tooltip title="System bearbeiten">
                <IconButton size="small" onClick={() => onEdit(system.id)} sx={{ color: DS_TEXT.secondary }}>
                  <Pencil size={14} />
                </IconButton>
              </Tooltip>
              <Tooltip title="System entfernen">
                <IconButton size="small" onClick={() => onDelete(system.id)} sx={{ color: DS_TEXT.secondary }}>
                  <Trash2 size={14} />
                </IconButton>
              </Tooltip>
            </>
          )}
        </Box>
      </Box>
      {/* Zugriffstyp im Klartext — nie nur farblich */}
      <Typography variant="body2" sx={{ color: look.text, fontWeight: 600 }}>
        {look.marker}
      </Typography>
      <Typography variant="body2" sx={{ color: DS_TEXT.secondary }}>
        {system.usage}
      </Typography>
-      {/* Berechtigungshinweis — der Satz, der die Verantwortung klärt */}
+      {/* Die Adresse steht offen da — sie ist genau das, was abgerufen wird. */}
-      <Box
+      {system.url && (
-        sx={{
+        <Link
-          display: 'flex',
+          href={system.url}
-          gap: 0.75,
+          target="_blank"
-          alignItems: 'flex-start',
+          rel="noopener noreferrer"
-          p: 1,
+          variant="caption"
-          borderRadius: 1.5,
+          sx={{ display: 'inline-flex', alignItems: 'center', gap: 0.5, color: DS_TEXT.brand, width: 'fit-content' }}
-          bgcolor: DS_BG.surface,
+        >
-          border: `1px solid ${DS_BORDER.default}`,
+          {system.url}
-        }}
+          <ExternalLink size={11} aria-hidden />
-      >
+        </Link>
-        <ShieldCheck size={14} color={DS_TEXT.secondary} aria-hidden style={{ flexShrink: 0, marginTop: 3 }} />
+      )}
-        <Typography variant="body2" sx={{ color: DS_TEXT.primary }}>
+
-          <Box component="span" sx={{ fontWeight: 700 }}>
+      <Box sx={{ display: 'flex', alignItems: 'center', gap: 1 }}>
-            Berechtigung:{' '}
+        <Switch
-          </Box>
+          size="small"
-          {system.permissionNote}
+          checked={aktiv}
          disabled={busy}
          onChange={(_, checked) => onToggle(system.id, checked)}
          slotProps={{ input: { 'aria-label': `Systemzugang ${titel} aktivieren` } }}
        />
        <Typography variant="caption" sx={{ color: aktiv ? DS_TEXT.success : DS_TEXT.muted, fontWeight: 600 }}>
          {aktiv ? 'Wird genutzt' : 'Derzeit abgeschaltet'}
        </Typography>
      </Box>
    </Box>
  )
 })
 // ── Eine Gruppe ───────────────────────────────────────────────────────────────
 function SystemGroup({ title, systems }: { title: string; systems: AgentSystem[] }) {
  if (systems.length === 0) return null
  return (
    <Box component="section" aria-label={title}>
      <DetailSectionTitle>{title}</DetailSectionTitle>
      <Box component="ul" sx={{ m: 0, p: 0, listStyle: 'none', display: 'grid', gap: 1.25 }}>
        {systems.map((system) => (
          <SystemRow key={system.id} system={system} />
        ))}
      </Box>
    </Box>
  )
 }
 // ── Reiter ────────────────────────────────────────────────────────────────────
 export function AgentSystemsTab({ agent }: { agent: TeamAgent }) {
-  const { reading, writing } = useMemo(() => {
+  const { mutate: saveSystems, isPending } = useSaveAgentSystems()
    const readOnly: AgentSystem[] = []
    const writable: AgentSystem[] = []
    for (const system of agent.systems) {
      if (system.access === AgentAccessLevel.READ) readOnly.push(system)
      else writable.push(system)
    }
    return { reading: readOnly, writing: writable }
  }, [agent.systems])
-  const intro = useMemo(() => {
+  /** `null` = Dialog zu, `'new'` = Anlegen, sonst die ID des bearbeiteten Zugangs. */
-    const name = `«${agent.name}»`
+  const [bearbeitet, setBearbeitet] = useState<string | null>(null)
-    if (reading.length > 0 && writing.length > 0) {
+  const [bearbeitungsmodus, setBearbeitungsmodus] = useState(false)
-      return `${name} liest ${systemCount(reading.length)} und schreibt nach Freigabe in ${systemCount(writing.length)}.`
+
-    }
+  const systems = agent.systems
-    if (reading.length > 0) {
+
-      return `${name} liest ${systemCount(reading.length)} und schreibt in keines davon.`
+  /**
-    }
+   * Anders als bei den Aufgaben wirkt hier jede Änderung sofort — ein
-    if (writing.length > 0) {
+   * Systemzugang ist ein Ein/Aus-Entscheid wie beim Kanalreiter, kein Formular
-      return `${name} schreibt nach Freigabe in ${systemCount(writing.length)}; weitere Zugänge bestehen nicht.`
+   * mit Zwischenstand. Zwei Speicherwege nebeneinander wären zwei Wahrheiten.
-    }
+   */
-    return `Für ${name} ist bisher kein Systemzugang hinterlegt.`
+  const speichern = useCallback(
-  }, [agent.name, reading.length, writing.length])
+    (liste: AgentSystem[]) => saveSystems({ id: agent.id, systems: liste }),
    [saveSystems, agent.id],
  )
  const handleToggle = useCallback(
    (id: string, enabled: boolean) => {
      speichern(systems.map((s) => (s.id === id ? { ...s, enabled } : s)))
    },
    [speichern, systems],
  )
  const handleDelete = useCallback(
    (id: string) => speichern(removeById(systems, id)),
    [speichern, systems],
  )
  const handleDialogSave = useCallback(
    (werte: EntityDraft, active: boolean) => {
      const bestehend = bearbeitet !== 'new' ? systems.find((s) => s.id === bearbeitet) : undefined
      const url = werte.url?.trim() ?? ''
      const eintrag: AgentSystem = {
        // Der Typ bleibt beim Bearbeiten erhalten; selbst erfasste Quellen sind
        // öffentliche Webquellen, weil genau das über die Adresse gelesen wird.
        type: bestehend?.type ?? AgentSystemType.PUBLIC_WEB,
        status: bestehend?.status ?? AgentConnectionStatus.CONNECTED,
        permissionNote: bestehend?.permissionNote ?? '',
        id: bestehend?.id ?? newEntityId(agent.id, 'system'),
        title: werte.title.trim(),
        usage: werte.description.trim(),
        access: werte.access as AgentAccessLevel,
        enabled: active,
        ...(url ? { url } : {}),
      }
      speichern(upsertById(systems, eintrag))
      setBearbeitet(null)
    },
    [bearbeitet, systems, agent.id, speichern],
  )
  const inBearbeitung = bearbeitet && bearbeitet !== 'new'
    ? systems.find((s) => s.id === bearbeitet)
    : undefined
  const focusRing = { '&:focus-visible': { outline: `2px solid ${DS_TEXT.brand}`, outlineOffset: 2 } }
  return (
-    <Box sx={{ display: 'grid', gap: 2.5 }}>
+    <Box sx={{ display: 'grid', gap: 2 }}>
-      {/* Einordnung — dieser Reiter zeigt den Stand, er verändert ihn nicht */}
+      <Box>
-      <Box
+        <Typography variant="body2" sx={{ color: DS_TEXT.secondary }}>
-        sx={{
+          Diese Systeme und Datenquellen darf {agent.name} verwenden. Ein abgeschalteter Zugang wird nicht
-          border: `1px solid ${DS_BORDER.default}`,
+          mehr abgefragt.
          borderRadius: 2,
          bgcolor: DS_BG.subtle,
          p: 1.5,
        }}
      >
        <Typography variant="body2" sx={{ color: DS_TEXT.primary, fontWeight: 600 }}>
          {intro}
        </Typography>
        <Typography variant="caption" sx={{ color: DS_TEXT.secondary }}>
          Diese Übersicht zeigt den aktuellen Stand. Eingerichtet werden Systemzugänge auf der Seite «Kanäle &
          Systeme».
        </Typography>
        <Box sx={{ display: 'flex', gap: 1, flexWrap: 'wrap', mt: 1.5 }}>
          <Button
            size="small"
            variant="outlined"
            startIcon={<Pencil size={14} aria-hidden />}
            onClick={() => setBearbeitungsmodus((v) => !v)}
            sx={{ textTransform: 'none', ...focusRing }}
          >
            {bearbeitungsmodus ? 'Bearbeiten beenden' : 'Systeme bearbeiten'}
          </Button>
          <Button
            size="small"
            variant="outlined"
            startIcon={<Plus size={14} aria-hidden />}
            onClick={() => setBearbeitet('new')}
            sx={{ textTransform: 'none', ...focusRing }}
          >
            Neues System anbinden
          </Button>
        </Box>
      </Box>
-      {agent.systems.length === 0 ? (
+      {systems.length === 0 ? (
        <Box
          sx={{
            border: `1px solid ${DS_BORDER.default}`,
@@ -212,11 +263,39 @@ export function AgentSystemsTab({ agent }: { agent: TeamAgent }) {
          </Typography>
        </Box>
      ) : (
-        <>
+        <Box component="ul" sx={{ m: 0, p: 0, listStyle: 'none', display: 'grid', gap: 1.25 }}>
-          <SystemGroup title={GROUP_TITLE_READ} systems={reading} />
+          {systems.map((system) => (
-          <SystemGroup title={GROUP_TITLE_WRITE} systems={writing} />
+            <SystemRow
-        </>
+              key={system.id}
              system={system}
              busy={isPending}
              editing={bearbeitungsmodus}
              onToggle={handleToggle}
              onEdit={setBearbeitet}
              onDelete={handleDelete}
            />
          ))}
        </Box>
      )}
      <AgentEntityDialog
        open={bearbeitet !== null}
        entityKey={bearbeitet ?? undefined}
        title={inBearbeitung ? 'System bearbeiten' : 'Neues System anbinden'}
        fields={SYSTEM_FIELDS}
        initial={{
          title: inBearbeitung ? systemTitel(inBearbeitung) : '',
          description: inBearbeitung?.usage ?? '',
          url: inBearbeitung?.url ?? '',
          access: inBearbeitung && istSchreibend(inBearbeitung)
            ? AgentAccessLevel.WRITE
            : AgentAccessLevel.READ,
        }}
        activeLabel="Zugang aktiv"
        initialActive={inBearbeitung ? istAktiv(inBearbeitung) : true}
        onSave={handleDialogSave}
        onClose={() => setBearbeitet(null)}
      />
    </Box>
  )
 }
@@ -9,11 +9,14 @@
 */
 import { memo, useCallback, useMemo, useState } from 'react'
-import { Box, Button, Switch, Typography } from '@mui/material'
+import { Box, Button, IconButton, Switch, Tooltip, Typography } from '@mui/material'
-import { RotateCcw, Save, ShieldCheck } from 'lucide-react'
+import { Pencil, Plus, RotateCcw, Save, ShieldCheck, Trash2 } from 'lucide-react'
 import type { AgentTask, TeamAgent } from '../../domain/teamAgent'
 import { DS_BG, DS_BORDER, DS_SHADOW, DS_SURFACE, DS_TEXT } from '../../lib/ds'
 import { GenericBadge } from '../shared/GenericBadge'
 import { AgentEntityDialog } from './AgentEntityDialog'
 import type { EntityDraft, EntityField } from './AgentEntityDialog'
 import { newEntityId, removeById, upsertById } from './agentEntityEditing'
 import { useSaveAgentTasks } from '../../hooks/useTeamAgents'
 // ── Eine Aufgabenzeile ────────────────────────────────────────────────────────
@@ -22,13 +25,17 @@ interface TaskRowProps {
  task: AgentTask
  busy: boolean
  onToggle: (id: string, enabled: boolean) => void
  /** Im Bearbeitungsmodus erscheinen Stift und Papierkorb an der Zeile (§2A). */
  editing: boolean
  onEdit: (id: string) => void
  onDelete: (id: string) => void
 }
 /**
 * `React.memo` ist Pflicht: ein Mitarbeiter führt bis zu zwölf Aufgaben, und
 * jeder Schalterklick verändert den Entwurf der ganzen Liste (CLAUDE.md §10.2).
 */
-const TaskRow = memo(function TaskRow({ task, busy, onToggle }: TaskRowProps) {
+const TaskRow = memo(function TaskRow({ task, busy, onToggle, editing, onEdit, onDelete }: TaskRowProps) {
  const handleChange = useCallback(
    (_event: unknown, checked: boolean) => onToggle(task.id, checked),
    [onToggle, task.id],
@@ -71,9 +78,26 @@ const TaskRow = memo(function TaskRow({ task, busy, onToggle }: TaskRowProps) {
      </Box>
      <Box sx={{ minWidth: 0, flex: 1 }}>
-        <Typography sx={{ fontWeight: 700, fontSize: '0.875rem', lineHeight: 1.3, color: DS_TEXT.primary }}>
+        <Box sx={{ display: 'flex', alignItems: 'flex-start', gap: 0.5 }}>
-          {task.title}
+          <Typography sx={{ fontWeight: 700, fontSize: '0.875rem', lineHeight: 1.3, color: DS_TEXT.primary, flex: 1 }}>
-        </Typography>
+            {task.title}
          </Typography>
          {editing && (
            <Box sx={{ display: 'flex', gap: 0.25, flexShrink: 0 }}>
              <Tooltip title="Aufgabe bearbeiten">
                <IconButton size="small" onClick={() => onEdit(task.id)} sx={{ color: DS_TEXT.secondary }}>
                  <Pencil size={14} />
                </IconButton>
              </Tooltip>
              <Tooltip title="Aufgabe löschen">
                <IconButton size="small" onClick={() => onDelete(task.id)} sx={{ color: DS_TEXT.secondary }}>
                  <Trash2 size={14} />
                </IconButton>
              </Tooltip>
            </Box>
          )}
        </Box>
        {/* Zwei Zeilen genügen: die Karte soll überflogen werden, der volle
            Wortlaut steht am Element. */}
@@ -111,10 +135,27 @@ const TaskRow = memo(function TaskRow({ task, busy, onToggle }: TaskRowProps) {
 // ── Register «Aufgaben» ───────────────────────────────────────────────────────
 /** Die Felder der Aufgabenmaske (Runde 10, §2A). */
 const TASK_FIELDS: EntityField[] = [
  { key: 'title', label: 'Aufgabentitel', required: true },
  { key: 'description', label: 'Aufgabenbeschreibung', type: 'multiline', required: true },
  {
    key: 'schedule',
    label: 'Auslöser oder Rhythmus',
    placeholder: 'z. B. täglich 06:00 oder bei Eingang',
    helperText: 'Wann die Aufgabe läuft — steht so auch im Personalblatt.',
  },
 ]
 export function AgentTasksTab({ agent }: { agent: TeamAgent }) {
  const [draft, setDraft] = useState<AgentTask[]>(agent.tasks)
  const saveTasks = useSaveAgentTasks()
  /** `null` = Dialog zu, `'new'` = Anlegen, sonst die ID des bearbeiteten Eintrags. */
  const [bearbeitet, setBearbeitet] = useState<string | null>(null)
  /** Zeigt die Bearbeiten- und Löschknöpfe an den Zeilen. */
  const [bearbeitungsmodus, setBearbeitungsmodus] = useState(false)
  /**
   * Beim Wechsel des Mitarbeiters wird der Entwurf neu aufgesetzt — sonst stünde
   * der Entwurf des zuvor gewählten Mitarbeiters in einem fremden Personalblatt.
@@ -147,6 +188,40 @@ export function AgentTasksTab({ agent }: { agent: TeamAgent }) {
    saveTasks.mutate({ id: agent.id, tasks: draft })
  }, [saveTasks, agent.id, draft])
  const handleDelete = useCallback((id: string) => {
    setDraft(prev => removeById(prev, id))
  }, [])
  /**
   * Anlegen und Bearbeiten teilen sich die Maske und diesen Griff.
   *
   * Der Eintrag landet im Entwurf und nicht direkt im Bestand — gespeichert
   * wird wie bisher bewusst erst über «Änderungen speichern». Zwei
   * Speicherwege für dieselbe Liste wären zwei Wahrheiten darüber, was gerade
   * gilt.
   */
  const handleDialogSave = useCallback((werte: EntityDraft, active: boolean) => {
    setDraft(prev => {
      const bestehend = bearbeitet !== 'new' ? prev.find(t => t.id === bearbeitet) : undefined
      const eintrag: AgentTask = {
        ...(bestehend ?? {
          id: newEntityId(agent.id, 'task'),
          requiresApproval: false,
        } as AgentTask),
        title: werte.title.trim(),
        description: werte.description.trim(),
        schedule: werte.schedule?.trim() || 'auf Auslösung',
        enabled: active,
      }
      return upsertById(prev, eintrag)
    })
    setBearbeitet(null)
  }, [bearbeitet, agent.id])
  const inBearbeitung = bearbeitet && bearbeitet !== 'new'
    ? draft.find(t => t.id === bearbeitet)
    : undefined
  const busy = saveTasks.isPending
  const focusRing = { '&:focus-visible': { outline: `2px solid ${DS_TEXT.brand}`, outlineOffset: 2 } }
@@ -160,6 +235,28 @@ export function AgentTasksTab({ agent }: { agent: TeamAgent }) {
        Speichern für {agent.name} wirksam.
      </Typography>
      {/* Auf Höhe der Überschrift, im Stil des bestehenden «Konfiguration öffnen» (§2A). */}
      <Box sx={{ display: 'flex', gap: 1, flexWrap: 'wrap', mt: 1.5 }}>
        <Button
          size="small"
          variant="outlined"
          startIcon={<Pencil size={14} aria-hidden />}
          onClick={() => setBearbeitungsmodus(v => !v)}
          sx={{ textTransform: 'none', ...focusRing }}
        >
          {bearbeitungsmodus ? 'Bearbeiten beenden' : 'Aufgaben bearbeiten'}
        </Button>
        <Button
          size="small"
          variant="outlined"
          startIcon={<Plus size={14} aria-hidden />}
          onClick={() => setBearbeitet('new')}
          sx={{ textTransform: 'none', ...focusRing }}
        >
          Neue Aufgabe
        </Button>
      </Box>
      {dirty && (
        <Box
          role="status"
@@ -227,10 +324,34 @@ export function AgentTasksTab({ agent }: { agent: TeamAgent }) {
          }}
        >
          {draft.map((task) => (
-            <TaskRow key={task.id} task={task} busy={busy} onToggle={handleToggle} />
+            <TaskRow
              key={task.id}
              task={task}
              busy={busy}
              onToggle={handleToggle}
              editing={bearbeitungsmodus}
              onEdit={setBearbeitet}
              onDelete={handleDelete}
            />
          ))}
        </Box>
      )}
      <AgentEntityDialog
        open={bearbeitet !== null}
        title={inBearbeitung ? 'Aufgabe bearbeiten' : 'Neue Aufgabe'}
        fields={TASK_FIELDS}
        entityKey={bearbeitet ?? undefined}
        initial={{
          title: inBearbeitung?.title ?? '',
          description: inBearbeitung?.description ?? '',
          schedule: inBearbeitung?.schedule ?? '',
        }}
        activeLabel="Aufgabe aktiv"
        initialActive={inBearbeitung?.enabled ?? true}
        onSave={handleDialogSave}
        onClose={() => setBearbeitet(null)}
      />
    </Box>
  )
 }
@@ -2,6 +2,7 @@ import { useEffect, useRef } from 'react'
 import { Box, IconButton, TextField, Tooltip, Typography } from '@mui/material'
 import { SendHorizonal } from 'lucide-react'
 import { AgentAvatar } from './AgentAvatar'
 import { AgentChatTranscript } from './AgentChatTranscript'
 import { AGENT_CHAT_MARKER, useAgentChat } from './useAgentChat'
 import { AGENT_CHAT_PROMPT } from '../../lib/constants'
 import { DS_BORDER, DS_TEXT } from '../../lib/ds'
@@ -19,7 +20,7 @@ export interface AgentWorkspaceHeroProps {
 * Höhe des obersten globalen Balkens. Der Chatkopf gilt bereits als verschwunden,
 * sobald er darunter liegt — nicht erst, wenn er den Fensterrand verlässt.
 */
-const TOP_BAR_PX = 64
+export const TOP_BAR_PX = 64
 /**
 * Gemeinsamer Chat-Einstieg aller fünf Agentenseiten (Runde 4, §4; Runde 5, §5).
@@ -153,6 +154,8 @@ export function AgentWorkspaceHero({ agentId, name, role, channels = [] }: Agent
          </Box>
        )}
      </Box>
      <AgentChatTranscript />
    </Box>
  )
 }
@@ -0,0 +1,155 @@
 /**
 * Property On — «Newsquellen manuell ablegen» (Runde 10, §2.6).
 *
 * Ersetzt die Liste verknüpfter Newsadressen im Einstellungsbereich. Der Grund
 * für den Tausch: Die Adressen standen dort als Auswahlfeld, ohne dass sie
 * irgendetwas bewirkt hätten — abgerufen wird, was unter «Systeme» als aktiver
 * Lesezugang steht. Zwei Orte für dieselbe Frage, von denen einer wirkungslos
 * war, ist schlechter als einer.
 *
 * Was hier abgelegt wird, fliesst dagegen tatsächlich in den nächsten Lauf:
 * Der Text wird beim Ablegen einmal aus der Datei gewonnen und geht zusammen
 * mit den gelesenen Seiten in dieselbe Beurteilung.
 *
 * Die Datei selbst verlässt den Browser nie — an den Server geht nur ihr Text.
 */
 import { memo, useCallback, useRef } from 'react'
 import { Box, Button, CircularProgress, IconButton, Tooltip, Typography } from '@mui/material'
 import { AlertTriangle, FileText, Trash2, Upload } from 'lucide-react'
 import {
  RESEARCH_DOCUMENT_LABELS,
  RESEARCH_DOCUMENT_MAX_BYTES,
 } from '../../domain/researchDocument'
 import type { ResearchDocument } from '../../domain/researchDocument'
 import {
  useRemoveResearchDocument,
  useResearchDocuments,
  useUploadResearchDocument,
 } from '../../hooks/useResearchDocuments'
 import { DS_BG, DS_BORDER, DS_SURFACE, DS_TEXT } from '../../lib/ds'
 const FOCUS_SX = { '&:focus-visible': { outline: `2px solid ${DS_TEXT.brand}`, outlineOffset: 2 } }
 function groesse(bytes: number): string {
  if (bytes < 1024) return `${bytes} B`
  if (bytes < 1024 * 1024) return `${Math.round(bytes / 1024)} KB`
  return `${(bytes / 1024 / 1024).toFixed(1)} MB`
 }
 function datum(iso: string): string {
  return new Date(iso).toLocaleDateString('de-CH', { day: '2-digit', month: '2-digit', year: 'numeric' })
 }
 const DokumentZeile = memo(function DokumentZeile({
  doc, onRemove, busy,
 }: { doc: ResearchDocument; onRemove: (id: string) => void; busy: boolean }) {
  const unbrauchbar = Boolean(doc.extractionNote)
  return (
    <Box
      component="li"
      sx={{
        display: 'flex', alignItems: 'flex-start', gap: 1, p: 1.25,
        border: `1px solid ${unbrauchbar ? DS_SURFACE.warning.border : DS_BORDER.default}`,
        borderRadius: 2,
        bgcolor: unbrauchbar ? DS_SURFACE.warning.bg : DS_BG.surface,
      }}
    >
      <FileText size={15} color={DS_TEXT.secondary} aria-hidden style={{ flexShrink: 0, marginTop: 2 }} />
      <Box sx={{ minWidth: 0, flex: 1 }}>
        <Typography sx={{ fontWeight: 600, fontSize: '0.8125rem', color: DS_TEXT.primary, wordBreak: 'break-word' }}>
          {doc.name}
        </Typography>
        <Typography variant="caption" sx={{ color: DS_TEXT.secondary, display: 'block' }}>
          {RESEARCH_DOCUMENT_LABELS[doc.kind]} · {groesse(doc.size)} · abgelegt am {datum(doc.uploadedAt)}
        </Typography>
        {doc.extractionNote && (
          <Box sx={{ display: 'flex', gap: 0.5, alignItems: 'flex-start', mt: 0.5 }}>
            <AlertTriangle size={12} color={DS_TEXT.warning} aria-hidden style={{ flexShrink: 0, marginTop: 2 }} />
            <Typography variant="caption" sx={{ color: DS_TEXT.warningDark }}>
              {doc.extractionNote}
            </Typography>
          </Box>
        )}
      </Box>
      <Tooltip title="Dokument entfernen">
        <span>
          <IconButton size="small" disabled={busy} onClick={() => onRemove(doc.id)} sx={{ color: DS_TEXT.secondary }}>
            <Trash2 size={14} />
          </IconButton>
        </span>
      </Tooltip>
    </Box>
  )
 })
 export function ResearchDocumentsField() {
  const { data: dokumente = [], isLoading } = useResearchDocuments()
  const upload = useUploadResearchDocument()
  const remove = useRemoveResearchDocument()
  const inputRef = useRef<HTMLInputElement>(null)
  const handleFiles = useCallback(
    (files: FileList | null) => {
      if (!files) return
      // Nacheinander: Die Extraktion ist rechenintensiv, und mehrere gleichzeitig
      // würden den Hauptthread für Sekunden blockieren.
      for (const file of Array.from(files)) upload.mutate(file)
      // Ohne Zurücksetzen liesse sich dieselbe Datei nicht erneut wählen.
      if (inputRef.current) inputRef.current.value = ''
    },
    [upload],
  )
  const handleRemove = useCallback((id: string) => remove.mutate(id), [remove])
  return (
    <Box sx={{ display: 'grid', gap: 1.25 }}>
      <input
        ref={inputRef}
        type="file"
        accept=".pdf,.docx"
        multiple
        hidden
        onChange={e => handleFiles(e.target.files)}
      />
      <Box sx={{ display: 'flex', gap: 1, alignItems: 'center', flexWrap: 'wrap' }}>
        <Button
          size="small"
          variant="outlined"
          disabled={upload.isPending}
          startIcon={upload.isPending
            ? <CircularProgress size={13} color="inherit" />
            : <Upload size={14} aria-hidden />}
          onClick={() => inputRef.current?.click()}
          sx={{ textTransform: 'none', ...FOCUS_SX }}
        >
          {upload.isPending ? 'Wird gelesen …' : 'Dokument ablegen'}
        </Button>
        <Typography variant="caption" sx={{ color: DS_TEXT.muted }}>
          PDF oder Word (.docx), höchstens {RESEARCH_DOCUMENT_MAX_BYTES / 1024 / 1024} MB je Datei
        </Typography>
      </Box>
      {isLoading ? (
        <Typography variant="caption" sx={{ color: DS_TEXT.muted }}>Dokumente werden geladen …</Typography>
      ) : dokumente.length === 0 ? (
        <Typography variant="caption" sx={{ color: DS_TEXT.muted }}>
          Noch nichts abgelegt. Abgelegte Dokumente gehen zusammen mit den aktiven Lesequellen in den
          nächsten Recherchelauf.
        </Typography>
      ) : (
        <Box component="ul" sx={{ listStyle: 'none', m: 0, p: 0, display: 'grid', gap: 0.75 }}>
          {dokumente.map(doc => (
            <DokumentZeile key={doc.id} doc={doc} onRemove={handleRemove} busy={remove.isPending} />
          ))}
        </Box>
      )}
    </Box>
  )
 }
@@ -3,6 +3,7 @@ import { Box, Drawer, IconButton, Typography } from '@mui/material'
 import { HelpCircle, X } from 'lucide-react'
 import { useNavigate } from 'react-router'
 import { useTeamStore } from '../../stores/teamStore'
 import { AiDisclaimer } from '../ui'
 import { useAgentWorkItem } from '../../hooks/useAgentWorkItems'
 import { useTeamAgents } from '../../hooks/useTeamAgents'
 import { AgentAvatar } from './AgentAvatar'
@@ -148,6 +149,8 @@ export function WorkItemDetailDrawer() {
                <Typography variant="body2" sx={{ color: DS_TEXT.secondary }}>{item.rejectionReason}</Typography>
              </Box>
            )}
            <AiDisclaimer />
          </Box>
        )}
      </Box>
@@ -0,0 +1,67 @@
 /**
 * Die drei Listengriffe der Agentenverwaltung (Runde 10, §2).
 *
 * Geprüft wird, was in den Reitern Aufgaben, Systeme und Kanäle täglich
 * passiert: einen Eintrag ändern, einen anlegen, einen entfernen — und dass
 * die übrige Reihenfolge dabei unberührt bleibt.
 */
 import { describe, expect, it } from 'vitest'
 import { newEntityId, removeById, upsertById } from '../agentEntityEditing'
 interface Eintrag {
  id: string
  titel: string
 }
 const liste: Eintrag[] = [
  { id: 'a', titel: 'Erster' },
  { id: 'b', titel: 'Zweiter' },
  { id: 'c', titel: 'Dritter' },
 ]
 describe('upsertById', () => {
  it('ersetzt einen bestehenden Eintrag an Ort und Stelle', () => {
    const ergebnis = upsertById(liste, { id: 'b', titel: 'Geändert' })
    expect(ergebnis.map((e) => e.id)).toEqual(['a', 'b', 'c'])
    expect(ergebnis[1].titel).toBe('Geändert')
  })
  it('hängt einen neuen Eintrag ans Ende', () => {
    const ergebnis = upsertById(liste, { id: 'd', titel: 'Vierter' })
    expect(ergebnis.map((e) => e.id)).toEqual(['a', 'b', 'c', 'd'])
  })
  it('lässt die übergebene Liste unverändert', () => {
    upsertById(liste, { id: 'b', titel: 'Geändert' })
    expect(liste[1].titel).toBe('Zweiter')
    expect(liste).toHaveLength(3)
  })
 })
 describe('removeById', () => {
  it('entfernt genau einen Eintrag', () => {
    expect(removeById(liste, 'b').map((e) => e.id)).toEqual(['a', 'c'])
  })
  it('lässt eine Liste ohne Treffer unverändert', () => {
    expect(removeById(liste, 'unbekannt').map((e) => e.id)).toEqual(['a', 'b', 'c'])
  })
 })
 describe('newEntityId', () => {
  it('stellt Agent und Art voran, damit die Kennung zuordenbar bleibt', () => {
    expect(newEntityId('livia', 'task')).toMatch(/^livia-task-/)
  })
  it('vergibt für jeden Aufruf eine eigene Kennung', () => {
    const kennungen = new Set(
      Array.from({ length: 50 }, () => newEntityId('nora', 'system')),
    )
    expect(kennungen.size).toBe(50)
  })
 })
@@ -0,0 +1,47 @@
 /**
 * Property On — die gemeinsamen Listenoperationen der Agentenverwaltung
 * (Runde 10, §2).
 *
 * Aufgaben, Systeme und Kanäle werden alle drei als Liste geführt und gleich
 * bearbeitet: einen Eintrag ändern, einen anlegen, einen entfernen. Diese drei
 * Griffe stehen deshalb einmal hier statt dreimal in den Reitern — sonst
 * unterscheiden sie sich nach der ersten Korrektur.
 *
 * Bewusst reine Funktionen ohne React: Sie lassen sich so ohne Renderer prüfen,
 * und die Reiter behalten die Hoheit über ihren Entwurf.
 */
 interface MitId { id: string }
 /**
 * Eintrag ersetzen oder anhängen.
 *
 * Neue Einträge kommen ans Ende und nicht an den Anfang: Wer etwas anlegt,
 * sucht es dort, wo die Liste weitergeht — und die gewachsene Reihenfolge der
 * bestehenden Einträge bleibt unangetastet.
 */
 export function upsertById<T extends MitId>(list: T[], eintrag: T): T[] {
  const idx = list.findIndex(e => e.id === eintrag.id)
  if (idx === -1) return [...list, eintrag]
  const kopie = [...list]
  kopie[idx] = eintrag
  return kopie
 }
 export function removeById<T extends MitId>(list: T[], id: string): T[] {
  return list.filter(e => e.id !== id)
 }
 /**
 * Kennung für einen neu angelegten Eintrag.
 *
 * Präfix aus Agent und Entität, damit man einer Kennung im Zweifel ansieht,
 * wohin sie gehört. `crypto.randomUUID` ist in allen Zielbrowsern vorhanden;
 * der Zeitstempel-Rückfall greift nur in Testumgebungen ohne Web-Crypto.
 */
 export function newEntityId(agentId: string, art: string): string {
  const zufall = typeof crypto !== 'undefined' && 'randomUUID' in crypto
    ? crypto.randomUUID().slice(0, 8)
    : Date.now().toString(36)
  return `${agentId}-${art}-${zufall}`
 }
@@ -50,6 +50,11 @@ import gian from '../../assets/team/gian.jpg'
 import ida from '../../assets/team/ida.jpg'
 import jana from '../../assets/team/jana.jpg'
 import zeno from '../../assets/team/zeno.jpg'
 // Thomas ist in Runde 6 dazugekommen und hat kein Porträt aus dem
 // Konzeptdokument. Statt den Kopf eines bestehenden Mitarbeitenden
 // zweitzuverwenden — jeder Kopf gehört genau einer Person — trägt er ein eigenes
 // Porträt. Herkunft und Lizenz stehen in `assets/team/HERKUNFT.md`.
 import thomas from '../../assets/team/thomas.jpg'
 export const AGENT_PHOTOS: Record<string, string | undefined> = {
  bruno,
@@ -86,4 +91,5 @@ export const AGENT_PHOTOS: Record<string, string | undefined> = {
  ida,
  jana,
  zeno,
  thomas,
 }
@@ -26,7 +26,7 @@ export { HistorySection } from './HistorySection'
 export { ChannelsSection } from './ChannelsSection'
 // Gemeinsame Bausteine der fünf Agentenseiten
-export { AgentWorkspaceHero } from './AgentWorkspaceHero'
+export { AgentWorkspaceHero, TOP_BAR_PX } from './AgentWorkspaceHero'
 export { AgentChatStickyBar } from './AgentChatStickyBar'
 export { useAgentChat } from './useAgentChat'
 export { ObjectDeepLink } from './ObjectDeepLink'
@@ -87,3 +87,6 @@ export {
  PROTOCOL_STATUS_SURFACE,
  PROTOCOL_STATUS_TEXT,
 } from './teamTokens'
 // Runde 9, §3: Gesprächsverlauf unter dem Chat-Einstieg.
 export { AgentChatTranscript } from './AgentChatTranscript'