Release v0.0.0.30

Add autostart management (per-user / all-users) in settings
Setup setzt den Autostart weiterhin fuer alle Benutzer (HKLM); die Task-Beschreibung im Installer stellt das jetzt klar. In den Einstellungen neuer Abschnitt "Autostart": - "Nur fuer diesen Benutzer" -> HKCU\...\Run - "Fuer alle Benutzer" -> HKLM\...\Run, nur mit Admin-Rechten aenderbar (so laesst sich der vom Setup gesetzte All-User-Autostart auch entfernen). Neuer AutostartManager kapselt Lesen/Setzen/Entfernen beider Run-Eintraege und die Admin-Pruefung. Single-Instance-Mutex verhindert weiterhin einen Doppelstart, falls beide Eintraege gesetzt sind. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
2026-06-08 13:53:34 +02:00 · 2026-06-08 13:52:34 +02:00 · 2026-06-08 13:47:10 +02:00 · 2026-06-08 13:43:03 +02:00 · 2026-06-08 13:35:55 +02:00 · 2026-06-08 13:18:35 +02:00
23 changed files with 2666 additions and 302 deletions
@@ -0,0 +1,146 @@
 # Changelog
 Alle nennenswerten Aenderungen an Starface Outlook Sync werden hier dokumentiert.
 Format orientiert sich an [Keep a Changelog](https://keepachangelog.com/de/),
 Versionsschema ist `x.x.x.x` (siehe `release.sh`).
 ## [Unreleased]
 ### Behoben
 - **Dubletten auf beiden Seiten beim Synchronisieren.** Mehrere zusammenhaengende
  Ursachen wurden beseitigt:
  - Eine unvollstaendig geladene Starface-Kontaktliste (z.B. durch einen
    Lade-Fehler oder Timeout) liess die Engine Kontakte faelschlich als
    "geloescht" ansehen, ihr Mapping verwerfen und sie beim naechsten Lauf neu
    anlegen. Der Kontakt-Abruf bricht jetzt mit Fehlermeldung ab (inkl.
    Wiederholversuch), statt still mit einer Teil-Liste weiterzuarbeiten.
  - Ist ein Starface-Kontakt nicht in der geladenen Liste, wird er jetzt per
    ID direkt abgefragt: existiert er noch (liegt also in einem **anderen
    Adressbuch**), bleibt das Mapping erhalten und es wird nichts neu angelegt
    (keine Dublette). Ist er **wirklich geloescht** (404), wird er je nach
    Sync-Richtung in Starface neu angelegt bzw. die Loeschung nach Outlook
    gespiegelt. (Vorher wurde das Mapping faelschlich behalten und der Kontakt
    in Outlook->Starface gar nicht neu angelegt.)
  - Das Wiederzuordnen bestehender Kontakte war zu streng: eine von Starface
    umformatierte Telefonnummer konnte einen eindeutigen E-Mail- oder
    Namens-Treffer ueberstimmen und so eine Neuanlage statt Verknuepfung
    ausloesen. Ein gleicher E-Mail- oder voller Namens-Treffer reicht jetzt.
 - **Synchronisation extrem langsam / schrieb bei jedem Lauf alle Kontakte neu.**
  Die Aenderungserkennung verglich einen einzigen Hash gegen beide Seiten.
  Outlook und Starface stellen denselben Kontakt aber unterschiedlich dar
  (nicht uebertragene Felder, abweichendes Telefonformat), wodurch der Hash nie
  uebereinstimmte und praktisch jeder Kontakt bei jedem Sync neu geschrieben
  wurde. Jede Seite hat jetzt eine eigene Baseline (`LastOutlookHash` /
  `LastStarfaceHash`); nur tatsaechlich geaenderte Kontakte werden geschrieben.
 ### Hinzugefuegt
 - **Autostart-Verwaltung in den Einstellungen.** Neuer Abschnitt "Autostart" mit
  zwei Optionen: "Nur fuer diesen Benutzer" (HKCU) und "Fuer alle Benutzer"
  (HKLM). Die Option fuer alle Benutzer ist nur mit Admin-Rechten aenderbar -
  darueber laesst sich auch der vom Setup gesetzte Autostart fuer alle wieder
  entfernen. Das Setup setzt den Autostart weiterhin fuer alle Benutzer (HKLM),
  der Hinweis im Installer wurde entsprechend klargestellt.
 - **Protokoll automatisch leeren (Einstellung).** Neuer Wert "Protokoll
  auto-leeren - Eintraege aelter als (Tage)". Bei 0 (Standard) bleibt alles
  erhalten; bei >0 werden aeltere Eintraege automatisch entfernt (beim Start,
  vor jedem Sync, beim Oeffnen des Protokolls und beim Speichern der
  Einstellungen).
 - **Protokoll zeigt jetzt, WAS geaendert wurde.** Pro Sync werden die einzelnen
  Aktionen (erstellt / aktualisiert / geloescht / verknuepft / zusammengefuehrt je
  Kontakt) ins Protokoll geschrieben - sowohl beim manuellen Sync (Fenster) als
  auch bei Auto-/Tray-Sync.
 - **Benachrichtigungen schaltbar (Einstellungen).** Zwei unabhaengige Haken:
  "Tray-Benachrichtigungen (allgemein)" fuer Info-Meldungen (Sync laeuft/fertig)
  und "Benachrichtigungen bei Warnungen/Fehlern" fuer Konflikte und Fehler. So
  kann man z.B. nur noch bei Konflikten/Fehlern benachrichtigt werden - oder gar
  nicht. Das Protokoll wird unabhaengig davon immer geschrieben.
 - **Protokoll (Logdatei) + "Protokoll"-Button.** Syncs, Ergebnisse, Konflikte
  (lokal und von anderen Arbeitsplaetzen) und Fehler werden dauerhaft in
  `%AppData%\StarfaceOutlookSync\sync.log` festgehalten - so ist auch nach dem
  Verschwinden einer Tray-Meldung nachvollziehbar, wer/was/wann. Im Hauptfenster
  oeffnet der Button "Protokoll" einen Betrachter (Aktualisieren/Leeren/Ordner
  oeffnen). Die Datei rotiert bei 2 MB.
 - **Clientuebergreifende Konflikt-Hinweise (Mehrplatz).** Wird ein echter
  Feld-Konflikt aufgeloest, legt der Client eine Notiz im gemeinsamen Verzeichnis
  (`conflicts/`) ab - zugeordnet nach Kontakt (StarfaceId). Ein anderer
  Arbeitsplatz zeigt die Meldung beim naechsten Sync nur an, wenn er den Kontakt
  selbst hat UND sein eigener Feldwert vom uebernommenen Wert abweicht - so wird
  der ueberschriebene Arbeitsplatz gewarnt, waehrend bereits aktuelle Clients
  nicht benachrichtigt werden. Bereits gezeigte Notizen merkt sich jeder Client
  lokal; alte Notizen werden nach 7 Tagen aufgeraeumt.
 - **Clientuebergreifende Sync-Sperre (Mehrplatz).** In den Einstellungen laesst
  sich ein gemeinsames Verzeichnis (Netzlaufwerk/UNC) hinterlegen. Synct ein
  Arbeitsplatz, legt er dort eine Lock-Datei an (atomar via `CreateNew`); andere
  Clients warten, bis sie frei ist (bis 2 Min, sonst wird der Lauf uebersprungen).
  Stuerzt ein Client ab, uebernimmt ein anderer die verwaiste Sperre. Ist kein
  Verzeichnis konfiguriert oder nicht erreichbar, wird ohne diese Sperre
  weitergearbeitet (der lokale Schutz auf dem PC bleibt).
 - **Feldweises 3-Wege-Merge bei Konflikten (bidirektional).** Wenn derselbe
  Kontakt zwischen zwei Syncs auf beiden Seiten geaendert wurde, bleiben jetzt
  Aenderungen an *unterschiedlichen* Feldern beide erhalten (z.B. einer aendert
  die Telefonnummer in Outlook, ein anderer die E-Mail in Starface). Nur wenn
  DASSELBE Feld auf beiden Seiten unterschiedlich geaendert wurde, greift die
  Vorrang-Regel (Outlook gewinnt). Dafuer wird im Mapping zusaetzlich ein
  Snapshot des letzten Sync-Stands je Seite gespeichert. Solche echten
  Feld-Konflikte werden dem Benutzer per Tray-Meldung angezeigt.
 ### Geaendert
 - **Manueller und automatischer Sync vereinheitlicht.** Beide Pfade laufen jetzt
  ueber einen gemeinsamen `SyncCoordinator` und nutzen damit dieselben Schutz-
  und Komfortfunktionen: lokaler Re-Entrancy-Schutz (prozessweit - auch manuell
  vs. automatisch koennen nicht mehr gleichzeitig laufen), clientuebergreifende
  Lock-Datei, Konflikt-Notizen anderer Arbeitsplaetze und vollstaendiges
  Protokoll. Vorher umging der manuelle "Synchronisieren"-Button (Fenster) die
  Lock-Datei und einen Teil des Protokolls.
 - **Doppelte Syncs verhindert (lokal).** Der Schutz gegen gleichzeitig laufende
  Syncs (manuell + Auto-Sync-Timer) ist jetzt atomar (`Interlocked`) statt eines
  nicht-atomaren `volatile bool`, bei dem beide in einem Zeitfenster
  durchrutschen konnten.
 - **Ein-Richtungs-Modi sind jetzt echtes "Ersetzen".** Outlook->Starface macht
  das Starface-Adressbuch zu einer exakten Kopie von Outlook: Kontakte, die nur
  in Starface existieren (kein Pendant in Outlook), werden geloescht.
  Starface->Outlook entsprechend umgekehrt. Schutz: Ist die Quelle komplett
  leer (z.B. falscher Ordner gewaehlt), wird die Loeschphase uebersprungen
  statt die Zielseite zu leeren. Mass-Loeschungen finden nur bei vollstaendig
  geladener Liste statt (unvollstaendige Ladevorgaenge brechen vorher ab).
 - **Bidirektionale Loeschungen** werden jetzt erkannt. Wird ein Kontakt auf
  einer Seite geloescht und ist die andere Seite seit dem letzten Sync
  unveraendert (Abgleich ueber die gespeicherte Baseline), wird die Loeschung
  auf die andere Seite gespiegelt – statt den Kontakt wieder anzulegen. Wurde
  die andere Seite zwischenzeitlich bearbeitet, gewinnt die Bearbeitung und der
  Kontakt wird neu angelegt (kein Datenverlust). In den Ein-Richtungs-Modi
  bleibt die jeweilige Quelle fuehrend (Loeschung im Ziel wird wiederhergestellt).
 - Starface-Kontaktdetails werden beim Laden parallel abgerufen (8 gleichzeitig)
  statt einzeln nacheinander – deutlich schneller bei grossen Adressbuechern.
 - `UpdateContact` (Outlook) und `UpdateContactAsync` (Starface) geben jetzt den
  frisch eingelesenen Stand zurueck, damit die Baseline nach dem Schreiben
  korrekt gesetzt wird und der Sync sauber konvergiert.
 ### Migration
 - Bestehende Mapping-Dateien werden beim ersten Sync automatisch uebernommen
  (ein ruhiger Durchlauf ohne Massen-Update).
 - **Bereits vorhandene Dubletten werden nicht automatisch entfernt** – die Fixes
  verhindern nur neue. Vorhandene Doppel-Kontakte einmalig manuell bereinigen.
 ## [0.0.0.23]
 ### Behoben
 - Kritischer Loesch-Fehler: Kontakte wurden bei einer geaenderten Outlook-EntryID
  nicht mehr massenhaft geloescht.
 ### Geaendert
 - Outlook-Sicherheitsschluessel werden fuer Domaenenumgebungen zusaetzlich nach
  HKLM geschrieben (unterdrueckt die Outlook-Sicherheitsabfrage).
 ## Aeltere Versionen
 Aeltere Releases (v0.0.0.1 – v0.0.0.22) sind ueber die Git-Historie und die
 Git-Tags nachvollziehbar.
@@ -8,7 +8,10 @@ Windows-Anwendung zur bidirektionalen Synchronisation von Kontakten zwischen Mic
 - **Profil-System** zum Verwalten mehrerer Sync-Konfigurationen (verschiedene Adressbuecher oder Anlagen)
 - **Starface-Adressbuecher**: Zentrales Adressbuch, persoenliches Adressbuch und Tag-basierte Adressbuecher
 - **Outlook-Kontaktordner**: Frei waehlbarer Kontaktordner als Sync-Ziel
- **Sync-Richtung** konfigurierbar: Outlook -> Starface, Starface -> Outlook oder bidirektional
+- **Sync-Richtung** konfigurierbar:
  - *Bidirektional*: Aenderungen werden in beide Richtungen abgeglichen (inkl. Loeschungen)
  - *Outlook -> Starface*: Das Starface-Adressbuch wird zur exakten Kopie von Outlook (nur in Starface vorhandene Kontakte werden geloescht)
  - *Starface -> Outlook*: Der Outlook-Ordner wird zur exakten Kopie von Starface (nur in Outlook vorhandene Kontakte werden geloescht)
 - **Intelligentes Matching**: Kontakte werden anhand von E-Mail-Adresse oder Name abgeglichen
 - **Aenderungserkennung**: Nur geaenderte Kontakte werden uebertragen (Hash-basiert)
 - **Auto-Sync**: Optionaler automatischer Sync in konfigurierbarem Intervall
@@ -42,6 +45,32 @@ Windows-Anwendung zur bidirektionalen Synchronisation von Kontakten zwischen Mic
 5. Starface-Adressbuch und Outlook-Kontaktordner waehlen
 6. Speichern und "Jetzt synchronisieren"
 ### Outlook-Sicherheitsabfrage unterdruecken
 Beim Zugriff auf Outlook-Kontakte zeigt Outlook standardmaessig einen
 Sicherheitsdialog ("Ein Programm versucht auf Ihre E-Mail-Adressinformationen
 zuzugreifen"). Dieser kann in den Einstellungen der App deaktiviert werden:
 1. In der App auf "Einstellungen" klicken
 2. "Outlook-Sicherheitsabfrage automatisch erlauben" aktivieren
 3. Speichern
 **Auf Domaenen-PCs / Terminal Servern:**
 Die Outlook-Sicherheitseinstellungen werden dort per Gruppenrichtlinie (GPO)
 gesteuert und sind im Trust Center ausgegraut. In diesem Fall muss die App
 **einmalig als Administrator** gestartet werden, damit die Registry-Keys
 unter HKLM geschrieben werden koennen:
 1. Rechtsklick auf die App -> "Als Administrator ausfuehren"
 2. Einstellungen -> "Outlook-Sicherheitsabfrage automatisch erlauben" aktivieren
 3. Speichern und App schliessen
 4. Outlook neu starten
 5. App kann danach wieder normal (ohne Admin) gestartet werden
 Die Einstellung bleibt dauerhaft bestehen und gilt fuer alle Benutzer
 auf dem Rechner.
 ### Deinstallation
 Ueber Windows Einstellungen -> Apps oder die Systemsteuerung.
@@ -231,11 +260,60 @@ StarfaceOutlookSync.exe
 Alle Daten werden lokal pro Benutzer gespeichert:
 - `%AppData%\StarfaceOutlookSync\profiles.json` - Sync-Profile mit Zugangsdaten
 - `%AppData%\StarfaceOutlookSync\mappings\` - Kontakt-Zuordnungen pro Profil
 - `%AppData%\StarfaceOutlookSync\sync.log` - Protokoll (Syncs, Konflikte, Fehler);
  im Hauptfenster ueber den Button **Protokoll** einsehbar
 ### SSL-Zertifikate
 Self-signed Zertifikate der Starface werden automatisch akzeptiert. Es ist kein manueller Zertifikat-Import erforderlich.
 ### Mehrplatz-Betrieb / Sync-Sperre
 Mehrere Arbeitsplaetze koennen dasselbe Starface-Adressbuch pflegen. Damit sich
 gleichzeitig laufende Syncs nicht ins Gehege kommen (Dubletten, ueberschriebene
 Aenderungen), gibt es zwei Schutzebenen:
 **1. Lokal (immer aktiv):** Auf einem PC kann nie mehr als ein Sync gleichzeitig
 laufen. Startet der Auto-Sync-Timer, waehrend ein manueller Sync laeuft (oder
 umgekehrt), wird der zweite Lauf uebersprungen. Atomar per `Interlocked`.
 **2. Clientuebergreifend (optional):** In den Einstellungen kann ein
 **gemeinsames Verzeichnis** (Netzlaufwerk oder UNC-Pfad wie
 `\\server\freigabe\sync`) hinterlegt werden. Funktionsweise:
 - Beim Start eines Syncs legt der Client dort die Datei **`starface-sync.lock`**
  an - **atomar** ueber `FileMode.CreateNew`: das Anlegen schlaegt fehl, wenn
  die Datei bereits existiert. Damit kann immer nur ein Client gleichzeitig die
  Sperre halten.
 - Die Datei wird waehrend des gesamten Syncs **offen gehalten** und am Ende
  wieder **geloescht**. Sie existiert also nur, solange tatsaechlich gerade
  synchronisiert wird (bei kleinen Adressbuechern nur sehr kurz).
 - Inhalt der Datei: `Rechnername | Benutzer | UTC-Zeitstempel | Prozess-ID` -
  damit man sieht, wer gerade synct.
 - Findet ein anderer Client die Sperre vor, **wartet** er (Abfrage alle 3
  Sekunden, bis zu 2 Minuten) und synct erst danach. Wird die Sperre nicht frei,
  wird der Lauf uebersprungen und beim naechsten Intervall erneut versucht.
 - **Absturzsicher:** Stuerzt ein Client mitten im Sync ab, gibt Windows das
  Datei-Handle frei. Die verwaiste Lock-Datei gilt nach 15 Minuten als veraltet
  und wird vom naechsten Client uebernommen. Lebt der Halter noch, scheitert das
  Loeschen am offenen Handle - die Sperre bleibt also korrekt bestehen.
 - Ist **kein** Verzeichnis konfiguriert oder es ist nicht erreichbar, laeuft der
  Sync ohne diese Sperre weiter (die lokale Sperre bleibt aktiv).
 **Konflikt-Hinweise:** Wird im bidirektionalen Modus ein echter Feld-Konflikt
 aufgeloest (dasselbe Feld auf beiden Seiten unterschiedlich geaendert, Outlook
 gewinnt), legt der Client eine Notiz im Unterordner `conflicts/` des gemeinsamen
 Verzeichnisses ab - zugeordnet ueber die StarfaceId des Kontakts. Beim naechsten
 Sync zeigt ein anderer Arbeitsplatz die Meldung als Tray-Hinweis - aber **nur,
 wenn er den Kontakt selbst hat UND sein eigener Feldwert vom uebernommenen Wert
 abweicht** (so erfaehrt der ueberschriebene Arbeitsplatz davon, waehrend Clients,
 die den Wert ohnehin schon haben, nicht benachrichtigt werden). Gezeigte Notizen
 merkt sich jeder Client lokal, veraltete Notizen werden nach 7 Tagen entfernt.
 > Hinweis: Im Mehrplatz-Betrieb sollte die **bidirektionale** Sync-Richtung
 > verwendet werden. Die Ein-Richtungs-Modi ("Ersetzen") wuerden die von anderen
 > Arbeitsplaetzen gepflegten Kontakte loeschen.
 ## Lizenz
 Proprietaer - Alle Rechte vorbehalten.
@@ -2,7 +2,7 @@
 ; Erfordert Inno Setup 6.x (https://jrsoftware.org/isinfo.php)
 #define MyAppName "Starface Outlook Sync"
-#define MyAppVersion "0.0.0.11"
+#define MyAppVersion "0.0.0.30"
 #define MyAppPublisher "HackerSoft - Hacker-Net Telekommunikation"
 #define MyAppURL "https://www.hacker-net.de"
 #define MyAppExeName "StarfaceOutlookSync.exe"
@@ -32,7 +32,7 @@ Name: "german"; MessagesFile: "compiler:Languages\German.isl"
 [Tasks]
 Name: "desktopicon"; Description: "Desktop-Verknuepfung erstellen"; GroupDescription: "Zusaetzliche Optionen:"
-Name: "autostart"; Description: "Bei Windows-Anmeldung automatisch starten"; GroupDescription: "Zusaetzliche Optionen:"; Flags: checkedonce
+Name: "autostart"; Description: "Bei Windows-Anmeldung automatisch starten (fuer ALLE Benutzer; einzelne Benutzer spaeter in den Einstellungen)"; GroupDescription: "Zusaetzliche Optionen:"; Flags: checkedonce
 [Files]
 ; Hauptanwendung - Pfad anpassen nach Build
@@ -0,0 +1,26 @@
 namespace StarfaceOutlookSync.Models
 {
    /// <summary>
    /// Hinweis ueber einen aufgeloesten Feld-Konflikt, der im gemeinsamen
    /// Verzeichnis abgelegt wird, damit auch andere Arbeitsplaetze (die denselben
    /// Kontakt pflegen) erfahren, dass ein Wert ueberschrieben wurde.
    /// </summary>
    public class ConflictNotice
    {
        public string Id { get; set; } = "";
        public string ByHost { get; set; } = "";
        public string ByUser { get; set; } = "";
        public string TimestampUtc { get; set; } = "";
        public string StarfaceId { get; set; } = "";
        public string ContactName { get; set; } = "";
        public string Field { get; set; } = "";
        public string FieldKey { get; set; } = "";
        public string OutlookValue { get; set; } = "";
        public string StarfaceValue { get; set; } = "";
        public string Winner { get; set; } = "";
        public override string ToString() =>
            $"{ContactName}: Feld '{Field}' geaendert an Arbeitsplatz {ByHost} " +
            $"(Outlook: '{OutlookValue}' / Starface: '{StarfaceValue}') -> {Winner} uebernommen";
    }
 }
@@ -45,6 +45,22 @@ namespace StarfaceOutlookSync.Models
        public string ProfileId { get; set; } = "";
        public string OutlookEntryId { get; set; } = "";
        public string StarfaceId { get; set; } = "";
        // Getrennte Baselines pro Seite. Outlook und Starface stellen denselben
        // Kontakt unterschiedlich dar (Felder, Telefonformat), daher MUSS jede
        // Seite gegen ihre eigene zuletzt-gesehene Repraesentation verglichen
        // werden - sonst gilt jeder Kontakt bei jedem Sync als geaendert.
        public string LastOutlookHash { get; set; } = "";
        public string LastStarfaceHash { get; set; } = "";
        // Snapshot des zuletzt synchronisierten Stands je Seite. Ermoeglicht ein
        // feldweises 3-Wege-Merge bei Konflikten (welche Seite hat welches Feld
        // geaendert), statt den ganzen Datensatz zu ueberschreiben. Null bei
        // Alt-Mappings -> dann Fallback auf ganz-ueberschreiben.
        public UnifiedContact LastOutlook { get; set; }
        public UnifiedContact LastStarface { get; set; }
        // Alt-Feld (vor v0.0.0.24). Nur noch fuer Migration bestehender Mappings.
        public string LastSyncHash { get; set; } = "";
    }
@@ -56,5 +72,28 @@ namespace StarfaceOutlookSync.Models
        public int Updated { get; set; }
        public int Errors { get; set; }
        public System.Collections.Generic.List<string> ErrorMessages { get; set; } = new System.Collections.Generic.List<string>();
        // Was konkret veraendert wurde (erstellt/aktualisiert/geloescht je Kontakt),
        // fuer das Protokoll.
        public System.Collections.Generic.List<string> Changes { get; set; } = new System.Collections.Generic.List<string>();
        // Echte Feld-Konflikte (dasselbe Feld auf beiden Seiten geaendert), die
        // ueber die Vorrang-Regel aufgeloest wurden. Fuer Benutzer-Hinweise.
        public System.Collections.Generic.List<FieldConflict> Conflicts { get; set; } = new System.Collections.Generic.List<FieldConflict>();
    }
    public class FieldConflict
    {
        public string StarfaceId { get; set; } = "";
        public string ContactName { get; set; } = "";
        public string Field { get; set; } = "";       // Anzeige-Label, z.B. "E-Mail"
        public string FieldKey { get; set; } = "";     // stabiler Schluessel, z.B. "Email"
        public string OutlookValue { get; set; } = "";
        public string StarfaceValue { get; set; } = "";
        public string Winner { get; set; } = "";  // "Outlook" oder "Starface"
        public override string ToString() =>
            $"{ContactName}: Feld '{Field}' auf beiden Seiten geaendert " +
            $"(Outlook: '{OutlookValue}' / Starface: '{StarfaceValue}') -> {Winner} uebernommen";
    }
 }
@@ -1,5 +1,6 @@
 using System;
 using System.IO;
 using Microsoft.Win32;
 using Newtonsoft.Json;
 namespace StarfaceOutlookSync.Models
@@ -7,6 +8,22 @@ namespace StarfaceOutlookSync.Models
    public class UserSettings
    {
        public bool StartMinimized { get; set; } = false;
        public bool SyncOnStart { get; set; } = false;
        public bool AutoAcceptOutlookPrompt { get; set; } = false;
        // Tray-Benachrichtigungen. Allgemein = Info-Meldungen (Sync laeuft/fertig).
        // WarnungenFehler = nur Konflikte und Fehler. Beide unabhaengig schaltbar.
        public bool NotificationsEnabled { get; set; } = true;
        public bool NotifyWarningsErrors { get; set; } = true;
        // Protokoll-Eintraege aelter als X Tage automatisch entfernen. 0 = aus
        // (alle Eintraege bleiben erhalten).
        public int LogRetentionDays { get; set; } = 0;
        // Gemeinsames Verzeichnis (Netzlaufwerk/UNC) fuer die clientuebergreifende
        // Sync-Sperre. Leer = keine Sperre (nur lokaler Schutz). Verhindert, dass
        // mehrere Arbeitsplaetze gleichzeitig dasselbe Adressbuch synchronisieren.
        public string SharedDirectory { get; set; } = "";
        private static readonly string SettingsFile = Path.Combine(
            Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData),
@@ -32,6 +49,86 @@ namespace StarfaceOutlookSync.Models
                File.WriteAllText(SettingsFile, JsonConvert.SerializeObject(this, Formatting.Indented));
            }
            catch { }
            ApplyOutlookSecuritySetting();
        }
        public void ApplyOutlookSecuritySetting()
        {
            var versions = new[] { "16.0", "15.0" };
            var securityValues = new (string name, int value)[]
            {
                ("ObjectModelGuard", 2),
                ("PromptOOMAddressBookAccess", 2),
                ("PromptOOMAddressInformationAccess", 2),
                ("PromptOOMSend", 2),
                ("PromptOOMSaveAs", 2),
                ("PromptOOMFormulaAccess", 2),
                ("PromptOOMCustomAction", 2),
                ("PromptSimpleMAPISend", 2),
                ("PromptSimpleMAPINameResolve", 2),
                ("PromptSimpleMAPIOpenMessage", 2),
                ("AdminSecurityMode", 3),
            };
            // In alle moeglichen Pfade schreiben (HKCU + HKLM, Policies + direkt)
            var roots = new[] { Registry.CurrentUser, Registry.LocalMachine };
            var prefixes = new[]
            {
                @"Software\Policies\Microsoft\Office",
                @"Software\Microsoft\Office"
            };
            foreach (var ver in versions)
            {
                foreach (var root in roots)
                {
                    foreach (var prefix in prefixes)
                    {
                        var regPath = $@"{prefix}\{ver}\Outlook\Security";
                        try
                        {
                            if (AutoAcceptOutlookPrompt)
                            {
                                var key = root.CreateSubKey(regPath);
                                if (key != null)
                                {
                                    foreach (var (name, value) in securityValues)
                                        key.SetValue(name, value, RegistryValueKind.DWord);
                                    key.Close();
                                }
                            }
                            else
                            {
                                try { root.DeleteSubKey(regPath, false); } catch { }
                            }
                        }
                        catch { } // Kein Fehler wenn Rechte fehlen - naechsten Pfad versuchen
                    }
                }
            }
        }
        /// <summary>
        /// Prueft ob die Outlook-Sicherheitseinstellung per GPO blockiert wird.
        /// </summary>
        public static bool IsOutlookSecurityLockedByPolicy()
        {
            try
            {
                // Wenn HKLM Policies gesetzt sind und wir dort nicht schreiben koennen
                var key = Registry.LocalMachine.OpenSubKey(
                    @"Software\Policies\Microsoft\Office\16.0\Outlook\Security", false);
                if (key != null)
                {
                    var val = key.GetValue("AdminSecurityMode");
                    key.Close();
                    if (val != null) return true;
                }
            }
            catch { }
            return false;
        }
    }
 }
@@ -0,0 +1,76 @@
 using System;
 using System.Diagnostics;
 using System.Security.Principal;
 using Microsoft.Win32;
 namespace StarfaceOutlookSync.Services
 {
    /// <summary>
    /// Verwaltet den Windows-Autostart ueber die Run-Schluessel:
    ///  - pro Benutzer  -> HKCU\...\Run
    ///  - alle Benutzer -> HKLM\...\Run  (nur mit Admin-Rechten aenderbar)
    /// Das Setup setzt den Autostart fuer alle Benutzer (HKLM); hierueber laesst
    /// er sich nachtraeglich umstellen oder entfernen.
    /// </summary>
    public static class AutostartManager
    {
        private const string RunKey = @"Software\Microsoft\Windows\CurrentVersion\Run";
        private const string ValueName = "StarfaceOutlookSync";
        private static string ExePath()
        {
            try
            {
                var p = Process.GetCurrentProcess().MainModule?.FileName;
                if (!string.IsNullOrEmpty(p)) return p;
            }
            catch { }
            return System.Reflection.Assembly.GetEntryAssembly()?.Location ?? "";
        }
        public static bool IsAdmin()
        {
            try
            {
                using (var id = WindowsIdentity.GetCurrent())
                    return new WindowsPrincipal(id).IsInRole(WindowsBuiltInRole.Administrator);
            }
            catch { return false; }
        }
        public static bool GetUserAutostart() => HasValue(Registry.CurrentUser);
        public static bool GetMachineAutostart() => HasValue(Registry.LocalMachine);
        public static void SetUserAutostart(bool enabled) => SetValue(Registry.CurrentUser, enabled);
        /// <summary>Setzt/entfernt den Autostart fuer alle Benutzer. Braucht Admin-Rechte. Gibt Erfolg zurueck.</summary>
        public static bool SetMachineAutostart(bool enabled) => SetValue(Registry.LocalMachine, enabled);
        private static bool HasValue(RegistryKey root)
        {
            try
            {
                using (var k = root.OpenSubKey(RunKey, false))
                    return k?.GetValue(ValueName) != null;
            }
            catch { return false; }
        }
        private static bool SetValue(RegistryKey root, bool enabled)
        {
            try
            {
                using (var k = root.CreateSubKey(RunKey))
                {
                    if (k == null) return false;
                    if (enabled)
                        k.SetValue(ValueName, "\"" + ExePath() + "\"", RegistryValueKind.String);
                    else if (k.GetValue(ValueName) != null)
                        k.DeleteValue(ValueName, false);
                }
                return true;
            }
            catch { return false; }
        }
    }
 }
@@ -0,0 +1,178 @@
 using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
 using Newtonsoft.Json;
 using StarfaceOutlookSync.Models;
 namespace StarfaceOutlookSync.Services
 {
    /// <summary>
    /// Verteilt Konflikt-Hinweise ueber das gemeinsame Verzeichnis an alle
    /// Arbeitsplaetze. Wer einen echten Feld-Konflikt aufloest, legt eine Notiz
    /// ab; andere Clients zeigen beim naechsten Sync die Notizen zu Kontakten,
    /// die sie selbst gemappt haben (per StarfaceId). Bereits gezeigte Notizen
    /// merkt sich jeder Client lokal, damit sie nicht doppelt erscheinen.
    /// </summary>
    public class ConflictNotifier
    {
        private static readonly TimeSpan Ttl = TimeSpan.FromDays(7);
        private readonly string _seenFile;
        public ConflictNotifier()
        {
            var dir = Path.Combine(
                Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData),
                "StarfaceOutlookSync");
            try { Directory.CreateDirectory(dir); } catch { }
            _seenFile = Path.Combine(dir, "seen-conflicts.json");
        }
        private static string ConflictsDir(string sharedDir) => Path.Combine(sharedDir, "conflicts");
        /// <summary>Legt fuer jeden Konflikt eine Notiz im gemeinsamen Verzeichnis ab.</summary>
        public void Write(string sharedDir, IEnumerable<FieldConflict> conflicts)
        {
            if (string.IsNullOrWhiteSpace(sharedDir)) return;
            var list = conflicts?.ToList();
            if (list == null || list.Count == 0) return;
            try
            {
                var dir = ConflictsDir(sharedDir);
                Directory.CreateDirectory(dir);
                var host = Environment.MachineName;
                var user = Environment.UserName;
                var ts = DateTime.UtcNow.ToString("o");
                foreach (var c in list)
                {
                    var notice = new ConflictNotice
                    {
                        Id = Guid.NewGuid().ToString("N"),
                        ByHost = host,
                        ByUser = user,
                        TimestampUtc = ts,
                        StarfaceId = c.StarfaceId,
                        ContactName = c.ContactName,
                        Field = c.Field,
                        FieldKey = c.FieldKey,
                        OutlookValue = c.OutlookValue,
                        StarfaceValue = c.StarfaceValue,
                        Winner = c.Winner
                    };
                    try
                    {
                        File.WriteAllText(Path.Combine(dir, notice.Id + ".json"),
                            JsonConvert.SerializeObject(notice, Formatting.Indented));
                    }
                    catch { }
                }
            }
            catch { }
        }
        /// <summary>
        /// Liefert ungesehene Konflikt-Notizen, die Kontakte dieses Clients
        /// betreffen und nicht von ihm selbst stammen. Es werden nur die Notizen
        /// zurueckgegeben, bei denen der EIGENE aktuelle Feldwert vom uebernommenen
        /// (Gewinner-)Wert abweicht - wer den Wert ohnehin schon hat, wird nicht
        /// benachrichtigt. myContacts bildet StarfaceId -> eigener Kontaktstand ab.
        /// Markiert verarbeitete Notizen als gesehen und raeumt veraltete auf.
        /// </summary>
        public List<ConflictNotice> GetPending(string sharedDir, IDictionary<string, UnifiedContact> myContacts)
        {
            var result = new List<ConflictNotice>();
            if (string.IsNullOrWhiteSpace(sharedDir)) return result;
            var dir = ConflictsDir(sharedDir);
            string[] files;
            try
            {
                if (!Directory.Exists(dir)) return result;
                files = Directory.GetFiles(dir, "*.json");
            }
            catch { return result; }
            var seen = LoadSeen();
            var host = Environment.MachineName;
            var existingIds = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
            foreach (var f in files)
            {
                ConflictNotice n = null;
                try { n = JsonConvert.DeserializeObject<ConflictNotice>(File.ReadAllText(f)); }
                catch { }
                if (n == null || string.IsNullOrEmpty(n.Id)) continue;
                // Veraltete Notizen entfernen.
                if (DateTime.TryParse(n.TimestampUtc, out var ts)
                    && DateTime.UtcNow - ts.ToUniversalTime() > Ttl)
                {
                    try { File.Delete(f); } catch { }
                    continue;
                }
                existingIds.Add(n.Id);
                if (seen.Contains(n.Id)) continue;                              // schon gezeigt
                if (string.Equals(n.ByHost, host, StringComparison.OrdinalIgnoreCase))
                {
                    seen.Add(n.Id);                                             // selbst erzeugt -> nicht erneut anzeigen
                    continue;
                }
                // Habe ich diesen Kontakt ueberhaupt?
                UnifiedContact mine = null;
                bool haveContact = !string.IsNullOrEmpty(n.StarfaceId)
                                   && myContacts != null
                                   && myContacts.TryGetValue(n.StarfaceId, out mine);
                if (!haveContact)
                    continue;                                                   // betrifft mich nicht (kein seen -> evtl. spaeter relevant)
                // Bin ich wirklich betroffen? Nur wenn mein aktueller Feldwert vom
                // uebernommenen Wert abweicht. Wer den Gewinner-Wert schon hat, wird
                // nicht benachrichtigt.
                if (mine != null && !string.IsNullOrEmpty(n.FieldKey))
                {
                    var winnerValue = string.Equals(n.Winner, "Outlook", StringComparison.OrdinalIgnoreCase)
                        ? n.OutlookValue : n.StarfaceValue;
                    var myValue = ContactMerger.GetValue(mine, n.FieldKey);
                    if (ContactMerger.ValuesEqual(n.FieldKey, myValue, winnerValue))
                    {
                        seen.Add(n.Id);                                         // nicht betroffen -> als erledigt merken
                        continue;
                    }
                }
                result.Add(n);
                seen.Add(n.Id);
            }
            // Gesehen-Liste auf noch vorhandene Notizen eindampfen.
            seen.IntersectWith(existingIds);
            SaveSeen(seen);
            return result;
        }
        private HashSet<string> LoadSeen()
        {
            try
            {
                if (File.Exists(_seenFile))
                    return new HashSet<string>(
                        JsonConvert.DeserializeObject<List<string>>(File.ReadAllText(_seenFile)) ?? new List<string>(),
                        StringComparer.OrdinalIgnoreCase);
            }
            catch { }
            return new HashSet<string>(StringComparer.OrdinalIgnoreCase);
        }
        private void SaveSeen(HashSet<string> seen)
        {
            try { File.WriteAllText(_seenFile, JsonConvert.SerializeObject(seen.ToList())); }
            catch { }
        }
    }
 }
@@ -0,0 +1,146 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
 using StarfaceOutlookSync.Models;
 namespace StarfaceOutlookSync.Services
 {
    /// <summary>
    /// Feldweises 3-Wege-Merge zweier Kontaktstaende gegen ihre Baseline.
    /// Erlaubt es, dass zwei Stellen unterschiedliche Felder desselben Kontakts
    /// aendern, ohne dass eine Aenderung verloren geht. Nur wenn DASSELBE Feld
    /// auf beiden Seiten geaendert wurde, greift die Vorrang-Regel.
    /// </summary>
    public static class ContactMerger
    {
        private class FieldDef
        {
            public string Key;
            public string Label;
            public Func<UnifiedContact, string> Get;
            public Action<UnifiedContact, string> Set;
            public bool IsPhone;
        }
        private static readonly FieldDef[] Fields = new[]
        {
            new FieldDef { Key = "FirstName",      Label = "Vorname",        Get = c => c.FirstName,      Set = (c, v) => c.FirstName = v },
            new FieldDef { Key = "LastName",       Label = "Nachname",       Get = c => c.LastName,       Set = (c, v) => c.LastName = v },
            new FieldDef { Key = "Company",        Label = "Firma",          Get = c => c.Company,        Set = (c, v) => c.Company = v },
            new FieldDef { Key = "JobTitle",       Label = "Position",       Get = c => c.JobTitle,       Set = (c, v) => c.JobTitle = v },
            new FieldDef { Key = "Email",          Label = "E-Mail",         Get = c => c.Email,          Set = (c, v) => c.Email = v },
            new FieldDef { Key = "EmailSecondary", Label = "E-Mail 2",       Get = c => c.EmailSecondary, Set = (c, v) => c.EmailSecondary = v },
            new FieldDef { Key = "PhoneWork",      Label = "Telefon",        Get = c => c.PhoneWork,      Set = (c, v) => c.PhoneWork = v,   IsPhone = true },
            new FieldDef { Key = "PhoneMobile",    Label = "Mobil",          Get = c => c.PhoneMobile,    Set = (c, v) => c.PhoneMobile = v, IsPhone = true },
            new FieldDef { Key = "PhoneHome",      Label = "Telefon privat", Get = c => c.PhoneHome,      Set = (c, v) => c.PhoneHome = v,   IsPhone = true },
            new FieldDef { Key = "Fax",            Label = "Fax",            Get = c => c.Fax,            Set = (c, v) => c.Fax = v,         IsPhone = true },
            new FieldDef { Key = "Street",         Label = "Strasse",        Get = c => c.Street,         Set = (c, v) => c.Street = v },
            new FieldDef { Key = "City",           Label = "Ort",            Get = c => c.City,           Set = (c, v) => c.City = v },
            new FieldDef { Key = "PostalCode",     Label = "PLZ",            Get = c => c.PostalCode,     Set = (c, v) => c.PostalCode = v },
            new FieldDef { Key = "State",          Label = "Bundesland",     Get = c => c.State,          Set = (c, v) => c.State = v },
            new FieldDef { Key = "Country",        Label = "Land",           Get = c => c.Country,        Set = (c, v) => c.Country = v },
            new FieldDef { Key = "Website",        Label = "Webseite",       Get = c => c.Website,        Set = (c, v) => c.Website = v },
            new FieldDef { Key = "Notes",          Label = "Notizen",        Get = c => c.Notes,          Set = (c, v) => c.Notes = v },
            new FieldDef { Key = "Salutation",     Label = "Anrede",         Get = c => c.Salutation,     Set = (c, v) => c.Salutation = v },
            new FieldDef { Key = "Title",          Label = "Titel",          Get = c => c.Title,          Set = (c, v) => c.Title = v },
            new FieldDef { Key = "Birthday",       Label = "Geburtstag",     Get = c => c.Birthday,       Set = (c, v) => c.Birthday = v },
        };
        /// <summary>Liest den Wert eines Feldes per stabilem Schluessel.</summary>
        public static string GetValue(UnifiedContact c, string key)
        {
            if (c == null || string.IsNullOrEmpty(key)) return "";
            var f = Fields.FirstOrDefault(x => x.Key == key);
            return f == null ? "" : (f.Get(c) ?? "");
        }
        /// <summary>Vergleicht zwei Feldwerte (telefon-normalisiert je nach Feld).</summary>
        public static bool ValuesEqual(string key, string a, string b)
        {
            var f = Fields.FirstOrDefault(x => x.Key == key);
            return Equal(a ?? "", b ?? "", f?.IsPhone ?? false);
        }
        /// <summary>
        /// Fuehrt den Outlook- und Starface-Stand gegen ihre jeweilige Baseline
        /// zusammen. outlookWins entscheidet bei echten Feld-Konflikten.
        /// </summary>
        public static (UnifiedContact merged, List<FieldConflict> conflicts) Merge(
            UnifiedContact baseOutlook, UnifiedContact baseStarface,
            UnifiedContact outlook, UnifiedContact starface,
            bool outlookWins)
        {
            var merged = new UnifiedContact
            {
                OutlookEntryId = outlook.OutlookEntryId,
                StarfaceId = starface.StarfaceId
            };
            var conflicts = new List<FieldConflict>();
            foreach (var f in Fields)
            {
                string olv = f.Get(outlook) ?? "";
                string sfv = f.Get(starface) ?? "";
                string bol = f.Get(baseOutlook) ?? "";
                string bsf = f.Get(baseStarface) ?? "";
                bool olChanged = !Equal(olv, bol, f.IsPhone);
                bool sfChanged = !Equal(sfv, bsf, f.IsPhone);
                string chosen;
                if (olChanged && !sfChanged)
                {
                    chosen = olv;
                }
                else if (sfChanged && !olChanged)
                {
                    chosen = sfv;
                }
                else if (olChanged && sfChanged)
                {
                    if (Equal(olv, sfv, f.IsPhone))
                    {
                        // Beide auf denselben Wert geaendert -> kein echter Konflikt.
                        chosen = olv;
                    }
                    else
                    {
                        chosen = outlookWins ? olv : sfv;
                        conflicts.Add(new FieldConflict
                        {
                            StarfaceId = starface.StarfaceId,
                            ContactName = outlook.DisplayName,
                            Field = f.Label,
                            FieldKey = f.Key,
                            OutlookValue = olv,
                            StarfaceValue = sfv,
                            Winner = outlookWins ? "Outlook" : "Starface"
                        });
                    }
                }
                else
                {
                    // Keine Seite hat dieses Feld geaendert -> Outlook-Wert behalten.
                    chosen = olv;
                }
                f.Set(merged, chosen);
            }
            return (merged, conflicts);
        }
        private static bool Equal(string a, string b, bool isPhone)
        {
            if (isPhone)
                return NormalizePhone(a) == NormalizePhone(b);
            return string.Equals(a ?? "", b ?? "", StringComparison.OrdinalIgnoreCase);
        }
        private static string NormalizePhone(string phone)
        {
            if (string.IsNullOrEmpty(phone)) return "";
            return new string(phone.Where(c => char.IsDigit(c) || c == '+').ToArray());
        }
    }
 }
@@ -0,0 +1,124 @@
 using System;
 using System.Collections.Generic;
 using System.Globalization;
 using System.IO;
 using System.Text;
 namespace StarfaceOutlookSync.Services
 {
    /// <summary>
    /// Einfaches, threadsicheres Datei-Protokoll. Haelt fest, was bei Syncs
    /// passiert (Ergebnisse, Konflikte, Fehler) - dauerhaft nachlesbar, auch
    /// nachdem eine Tray-Meldung verschwunden ist.
    /// </summary>
    public static class Logger
    {
        private static readonly object _lock = new object();
        private const long MaxBytes = 2 * 1024 * 1024; // 2 MB, dann Rotation
        public static string LogFilePath { get; } = Path.Combine(
            Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData),
            "StarfaceOutlookSync", "sync.log");
        public static void Log(string message)
        {
            try
            {
                lock (_lock)
                {
                    Directory.CreateDirectory(Path.GetDirectoryName(LogFilePath));
                    Rotate();
                    var line = $"[{DateTime.Now:yyyy-MM-dd HH:mm:ss}] {message}{Environment.NewLine}";
                    File.AppendAllText(LogFilePath, line, Encoding.UTF8);
                }
            }
            catch { }
        }
        private static void Rotate()
        {
            try
            {
                var fi = new FileInfo(LogFilePath);
                if (fi.Exists && fi.Length > MaxBytes)
                {
                    var bak = LogFilePath + ".1";
                    if (File.Exists(bak)) File.Delete(bak);
                    File.Move(LogFilePath, bak);
                }
            }
            catch { }
        }
        public static string ReadAll()
        {
            try
            {
                lock (_lock)
                {
                    if (!File.Exists(LogFilePath)) return "";
                    using (var fs = new FileStream(LogFilePath, FileMode.Open, FileAccess.Read, FileShare.ReadWrite))
                    using (var sr = new StreamReader(fs, Encoding.UTF8))
                        return sr.ReadToEnd();
                }
            }
            catch { return ""; }
        }
        /// <summary>
        /// Entfernt Protokoll-Eintraege, die aelter als <paramref name="days"/>
        /// Tage sind. days &lt;= 0 -> nichts tun (alle Eintraege bleiben).
        /// </summary>
        public static void PruneOlderThan(int days)
        {
            if (days <= 0) return;
            try
            {
                lock (_lock)
                {
                    if (!File.Exists(LogFilePath)) return;
                    var cutoff = DateTime.Now.AddDays(-days);
                    var lines = File.ReadAllLines(LogFilePath, Encoding.UTF8);
                    var kept = new List<string>(lines.Length);
                    foreach (var line in lines)
                    {
                        // Eintraege ohne erkennbaren Zeitstempel (z.B. Fortsetzungs-
                        // zeilen) bleiben erhalten; nur datierte Alt-Eintraege fliegen raus.
                        if (TryParseLineDate(line, out var dt) && dt < cutoff)
                            continue;
                        kept.Add(line);
                    }
                    if (kept.Count != lines.Length)
                        File.WriteAllLines(LogFilePath, kept, Encoding.UTF8);
                }
            }
            catch { }
        }
        private static bool TryParseLineDate(string line, out DateTime dt)
        {
            dt = default;
            // Format: "[yyyy-MM-dd HH:mm:ss] ..."
            if (line != null && line.Length >= 21 && line[0] == '[' && line[20] == ']')
            {
                return DateTime.TryParseExact(line.Substring(1, 19), "yyyy-MM-dd HH:mm:ss",
                    CultureInfo.InvariantCulture, DateTimeStyles.None, out dt);
            }
            return false;
        }
        public static void Clear()
        {
            try
            {
                lock (_lock)
                {
                    if (File.Exists(LogFilePath)) File.Delete(LogFilePath);
                    var bak = LogFilePath + ".1";
                    if (File.Exists(bak)) File.Delete(bak);
                }
            }
            catch { }
        }
    }
 }
@@ -350,7 +350,13 @@ namespace StarfaceOutlookSync.Services
            }
        }
-        public bool UpdateContact(string entryId, UnifiedContact contact)
+        /// <summary>
        /// Aktualisiert den Outlook-Kontakt und gibt den frisch eingelesenen
        /// Stand zurueck (null bei Fehler). Der zurueckgegebene Kontakt liefert
        /// den massgeblichen Hash NACH dem Schreiben - noetig damit die naechste
        /// Synchronisation den Kontakt nicht erneut als geaendert erkennt.
        /// </summary>
        public UnifiedContact UpdateContact(string entryId, UnifiedContact contact)
        {
            try
            {
@@ -361,15 +367,17 @@ namespace StarfaceOutlookSync.Services
                MapToOutlook(contact, ci);
                ci.Save();
                var updated = MapFromOutlook(ci);
                Marshal.ReleaseComObject(ci);
                Marshal.ReleaseComObject(ns);
-                return true;
+                return updated;
            }
            catch (Exception ex)
            {
                System.Diagnostics.Debug.WriteLine($"Error updating contact: {ex.Message}");
-                return false;
+                return null;
            }
        }
@@ -394,29 +402,40 @@ namespace StarfaceOutlookSync.Services
            }
        }
        private static string SafeGet(dynamic ci, string property)
        {
            try
            {
                object val = ci.GetType().InvokeMember(property,
                    System.Reflection.BindingFlags.GetProperty, null, ci, null);
                return val?.ToString() ?? "";
            }
            catch { return ""; }
        }
        private UnifiedContact MapFromOutlook(dynamic ci)
        {
            return new UnifiedContact
            {
-                OutlookEntryId = (string)(ci.EntryID ?? ""),
+                OutlookEntryId = SafeGet(ci, "EntryID"),
-                FirstName = (string)(ci.FirstName ?? ""),
+                FirstName = SafeGet(ci, "FirstName"),
-                LastName = (string)(ci.LastName ?? ""),
+                LastName = SafeGet(ci, "LastName"),
-                Company = (string)(ci.CompanyName ?? ""),
+                Company = SafeGet(ci, "CompanyName"),
-                JobTitle = (string)(ci.JobTitle ?? ""),
+                JobTitle = SafeGet(ci, "JobTitle"),
-                Email = (string)(ci.Email1Address ?? ""),
+                Email = SafeGet(ci, "Email1Address"),
-                EmailSecondary = (string)(ci.Email2Address ?? ""),
+                EmailSecondary = SafeGet(ci, "Email2Address"),
-                PhoneWork = (string)(ci.BusinessTelephoneNumber ?? ""),
+                PhoneWork = SafeGet(ci, "BusinessTelephoneNumber"),
-                PhoneMobile = (string)(ci.MobileTelephoneNumber ?? ""),
+                PhoneMobile = SafeGet(ci, "MobileTelephoneNumber"),
-                PhoneHome = (string)(ci.HomeTelephoneNumber ?? ""),
+                PhoneHome = SafeGet(ci, "HomeTelephoneNumber"),
-                Fax = (string)(ci.BusinessFaxNumber ?? ""),
+                Fax = SafeGet(ci, "BusinessFaxNumber"),
-                Street = (string)(ci.BusinessAddressStreet ?? ""),
+                Street = SafeGet(ci, "BusinessAddressStreet"),
-                City = (string)(ci.BusinessAddressCity ?? ""),
+                City = SafeGet(ci, "BusinessAddressCity"),
-                PostalCode = (string)(ci.BusinessAddressPostalCode ?? ""),
+                PostalCode = SafeGet(ci, "BusinessAddressPostalCode"),
-                State = (string)(ci.BusinessAddressState ?? ""),
+                State = SafeGet(ci, "BusinessAddressState"),
-                Country = (string)(ci.BusinessAddressCountry ?? ""),
+                Country = SafeGet(ci, "BusinessAddressCountry"),
-                Website = (string)(ci.WebPage ?? ""),
+                Website = SafeGet(ci, "WebPage"),
-                Notes = (string)(ci.Body ?? ""),
+                Notes = SafeGet(ci, "Body"),
-                Salutation = (string)(ci.Title ?? ""),
+                Salutation = SafeGet(ci, "Title"),
                Birthday = GetBirthdayString(ci)
            };
        }
@@ -425,8 +444,9 @@ namespace StarfaceOutlookSync.Services
        {
            try
            {
-                DateTime bday = ci.Birthday;
+                object val = ci.GetType().InvokeMember("Birthday",
-                if (bday.Year > 1900 && bday != DateTime.MinValue)
+                    System.Reflection.BindingFlags.GetProperty, null, ci, null);
                if (val is DateTime bday && bday.Year > 1900 && bday != DateTime.MinValue)
                    return bday.ToString("yyyy-MM-dd");
            }
            catch { }
@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Net;
 using System.Net.Http;
 using System.Security.Cryptography;
@@ -115,42 +116,62 @@ namespace StarfaceOutlookSync.Services
        {
            var books = new List<StarfaceAddressBook>();
-            books.Add(new StarfaceAddressBook
+            // Alle Tags laden - die Starface nutzt Tags als Adressbuch-Zuordnung
-            {
+            var allTags = new JArray();
                Type = "central",
                Name = "Zentrales Adressbuch"
            });
            var userId = await GetCurrentUserIdAsync();
            if (!string.IsNullOrEmpty(userId))
            {
                books.Add(new StarfaceAddressBook
                {
                    Type = "user",
                    UserId = userId,
                    Name = "Persoenliches Adressbuch"
                });
            }
            // Tags als virtuelle Adressbuecher
            try
            {
                var resp = await _http.GetAsync($"{_baseUrl}/contacts/tags");
                if (resp.IsSuccessStatusCode)
                {
-                    var tags = JArray.Parse(await resp.Content.ReadAsStringAsync());
+                    allTags = JArray.Parse(await resp.Content.ReadAsStringAsync());
-                    foreach (var tag in tags)
+                    OnDebug?.Invoke($"Gefundene Tags: {allTags.Count}");
                    foreach (var t in allTags)
                        OnDebug?.Invoke($"  Tag: {t["name"]} (id: {t["id"]}, alias: {t["alias"]}, owner: {t["owner"]})");
                }
            }
            catch { }
            // Zentrales Adressbuch (folder/all)
            var allTag = allTags.FirstOrDefault(t => t["name"]?.ToString() == "folder/all"
                                                  || t["alias"]?.ToString()?.Contains("folder.all") == true);
            books.Add(new StarfaceAddressBook
            {
                Type = "central",
                TagId = allTag?["id"]?.ToString() ?? "",
                Name = "Zentrales Adressbuch"
            });
            // Persoenliches Adressbuch (folder/private mit owner = userId)
            var userId = await GetCurrentUserIdAsync();
            if (!string.IsNullOrEmpty(userId))
            {
                var privateTag = allTags.FirstOrDefault(t =>
                    (t["name"]?.ToString() == "folder/private" || t["alias"]?.ToString()?.Contains("folder.private") == true)
                    && t["owner"]?.ToString() == userId);
                books.Add(new StarfaceAddressBook
                {
                    Type = "user",
                    UserId = userId,
                    TagId = privateTag?["id"]?.ToString() ?? "",
                    Name = "Persoenliches Adressbuch"
                });
            }
            // Alle weiteren Tags als Adressbuecher anbieten
            foreach (var tag in allTags)
            {
                var tagName = tag["name"]?.ToString() ?? "";
                // folder/all und folder/private bereits oben erfasst
                if (tagName == "folder/all" || tagName == "folder/private") continue;
                books.Add(new StarfaceAddressBook
                {
                    Type = "tag",
                    TagId = tag["id"]?.ToString() ?? "",
-                            Name = $"Tag: {tag["name"]}"
+                    Name = tagName
                });
            }
                }
            }
            catch { }
            return books;
        }
@@ -173,7 +194,16 @@ namespace StarfaceOutlookSync.Services
                    query += $"&tags={book.TagId}";
                var resp = await _http.GetAsync($"{_baseUrl}/contacts?{query}");
-                if (!resp.IsSuccessStatusCode) break;
+                if (!resp.IsSuccessStatusCode)
                {
                    // WICHTIG: nicht still abbrechen. Eine unvollstaendige Liste
                    // laesst die Sync-Engine Kontakte faelschlich als geloescht
                    // ansehen -> Mappings werden verworfen -> Dubletten.
                    throw new Exception(
                        $"Starface-Kontaktliste konnte nicht vollstaendig geladen werden " +
                        $"(Seite {page}: HTTP {(int)resp.StatusCode}). Synchronisation abgebrochen, " +
                        $"um Dubletten zu vermeiden.");
                }
                var body = await resp.Content.ReadAsStringAsync();
                JArray array;
@@ -211,31 +241,40 @@ namespace StarfaceOutlookSync.Services
                OnDebug?.Invoke($"Seite {page}: {array.Count} Kontakte in Liste");
                // Die Listen-API gibt nur Summary zurueck.
                // Jeden Kontakt einzeln abrufen fuer alle Felder.
                foreach (var item in array)
                {
                    var id = item["id"]?.ToString();
                    if (string.IsNullOrEmpty(id)) continue;
                    try
                    {
                        var detailResp = await _http.GetAsync($"{_baseUrl}/contacts/{id}");
                        if (detailResp.IsSuccessStatusCode)
                        {
                            var detailBody = await detailResp.Content.ReadAsStringAsync();
                            var detailObj = JObject.Parse(detailBody);
                if (firstPage)
                {
-                                OnDebug?.Invoke($"Starface Kontakt-Detail (1. Kontakt):\n{detailObj.ToString(Formatting.Indented)}");
+                    var firstId = array[0]?["id"]?.ToString();
                    if (!string.IsNullOrEmpty(firstId))
                    {
                        var sample = await FetchDetailAsync(firstId);
                        if (sample != null)
                            OnDebug?.Invoke($"Starface Kontakt-Detail (1. Kontakt):\n{sample.ToString(Formatting.Indented)}");
                    }
                    firstPage = false;
                }
-                            contacts.Add(MapFromStarface(detailObj));
+                // Die Listen-API liefert nur eine Zusammenfassung; jeder Kontakt
-                        }
+                // muss einzeln geladen werden. Das parallelisieren (begrenzt),
-                    }
+                // sonst dauert es bei vielen Kontakten extrem lange.
-                    catch { }
+                var ids = array
                    .Select(it => it["id"]?.ToString())
                    .Where(id => !string.IsNullOrEmpty(id))
                    .ToList();
                const int maxParallel = 8;
                for (int i = 0; i < ids.Count; i += maxParallel)
                {
                    var batch = ids.Skip(i).Take(maxParallel)
                        .Select(async id =>
                        {
                            var detail = await FetchDetailAsync(id);
                            // null = 404 (zwischenzeitlich geloescht) -> ueberspringen.
                            return detail == null ? null : MapFromStarface(detail);
                        })
                        .ToList();
                    var mapped = await Task.WhenAll(batch);
                    contacts.AddRange(mapped.Where(c => c != null));
                }
                if (array.Count < pageSize) break;
@@ -245,32 +284,130 @@ namespace StarfaceOutlookSync.Services
            return contacts;
        }
        /// <summary>
        /// Laedt das Detail-JSON eines Kontakts mit kleiner Wiederholung.
        /// Gibt null zurueck, wenn der Kontakt zwischen Listen- und Detail-Abruf
        /// wirklich geloescht wurde (404 - harmlos, wird uebersprungen).
        /// Wirft bei transienten Fehlern, damit der Aufrufer NICHT mit einer
        /// unvollstaendigen Liste weiterarbeitet (sonst entstehen Dubletten).
        /// </summary>
        private async Task<JObject> FetchDetailAsync(string id)
        {
            for (int attempt = 0; attempt < 3; attempt++)
            {
                try
                {
                    var resp = await _http.GetAsync($"{_baseUrl}/contacts/{id}");
                    if (resp.IsSuccessStatusCode)
                        return JObject.Parse(await resp.Content.ReadAsStringAsync());
                    // 404 = zwischenzeitlich geloescht; nicht erneut versuchen.
                    if (resp.StatusCode == HttpStatusCode.NotFound) return null;
                }
                catch { }
                await Task.Delay(250 * (attempt + 1));
            }
            throw new Exception(
                $"Starface-Kontakt {id} konnte nach mehreren Versuchen nicht geladen werden. " +
                $"Synchronisation abgebrochen, um Dubletten zu vermeiden.");
        }
        public async Task<UnifiedContact> CreateContactAsync(UnifiedContact contact, StarfaceAddressBook book)
        {
            var sfContact = MapToStarface(contact);
            // Tag zuweisen - die Starface verlangt dass jeder Kontakt einem Tag zugeordnet ist
            if (!string.IsNullOrEmpty(book.TagId))
            {
                sfContact["tags"] = new JArray
                {
                    new JObject { ["id"] = book.TagId }
                };
            }
            var query = "";
            if (book.Type == "user" && !string.IsNullOrEmpty(book.UserId))
                query = $"?userId={book.UserId}";
-            var content = new StringContent(sfContact.ToString(), Encoding.UTF8, "application/json");
+            var body = sfContact.ToString();
-            var resp = await _http.PostAsync($"{_baseUrl}/contacts{query}", content);
+            OnDebug?.Invoke($"POST /contacts{query} Body:\n{body}");
            if (!resp.IsSuccessStatusCode) return null;
-            var created = JObject.Parse(await resp.Content.ReadAsStringAsync());
+            var content = new StringContent(body, Encoding.UTF8, "application/json");
            var resp = await _http.PostAsync($"{_baseUrl}/contacts{query}", content);
            var respBody = await resp.Content.ReadAsStringAsync();
            if (!resp.IsSuccessStatusCode)
            {
                OnDebug?.Invoke($"POST /contacts fehlgeschlagen: {(int)resp.StatusCode} {resp.StatusCode}\n{respBody}");
                return null;
            }
            var created = JObject.Parse(respBody);
            return MapFromStarface(created);
        }
-        public async Task<bool> UpdateContactAsync(string contactId, UnifiedContact contact, StarfaceAddressBook book)
+        /// <summary>
        /// Aktualisiert den Starface-Kontakt und gibt den massgeblichen Stand
        /// NACH dem Schreiben zurueck (null bei Fehler). Wird fuer die getrennte
        /// Hash-Baseline benoetigt, damit der Kontakt beim naechsten Sync nicht
        /// erneut faelschlich als geaendert gilt.
        /// </summary>
        public async Task<UnifiedContact> UpdateContactAsync(string contactId, UnifiedContact contact, StarfaceAddressBook book)
        {
            var sfContact = MapToStarface(contact);
            sfContact["id"] = contactId;
            // Tag beibehalten
            if (!string.IsNullOrEmpty(book.TagId))
            {
                sfContact["tags"] = new JArray { new JObject { ["id"] = book.TagId } };
            }
            var query = "";
            if (book.Type == "user" && !string.IsNullOrEmpty(book.UserId))
                query = $"?userId={book.UserId}";
-            var content = new StringContent(sfContact.ToString(), Encoding.UTF8, "application/json");
+            var body = sfContact.ToString();
            var content = new StringContent(body, Encoding.UTF8, "application/json");
            var resp = await _http.PutAsync($"{_baseUrl}/contacts/{contactId}{query}", content);
-            return resp.IsSuccessStatusCode;
+
            if (!resp.IsSuccessStatusCode)
            {
                var respBody = await resp.Content.ReadAsStringAsync();
                OnDebug?.Invoke($"PUT /contacts/{contactId} fehlgeschlagen: {(int)resp.StatusCode}\n{respBody}");
                return null;
            }
            // Frischen Stand zurueckgeben. Manche Versionen liefern den Kontakt
            // direkt in der PUT-Antwort, sonst per GET nachladen.
            try
            {
                var respBody = await resp.Content.ReadAsStringAsync();
                if (!string.IsNullOrWhiteSpace(respBody))
                {
                    var obj = JObject.Parse(respBody);
                    if (obj["blocks"] != null)
                        return MapFromStarface(obj);
                }
            }
            catch { }
            return await GetContactAsync(contactId) ?? contact;
        }
        /// <summary>Laedt einen einzelnen Kontakt mit allen Feldern.</summary>
        public async Task<UnifiedContact> GetContactAsync(string contactId)
        {
            try
            {
                var resp = await _http.GetAsync($"{_baseUrl}/contacts/{contactId}");
                if (!resp.IsSuccessStatusCode) return null;
                var obj = JObject.Parse(await resp.Content.ReadAsStringAsync());
                return MapFromStarface(obj);
            }
            catch { return null; }
        }
        public async Task<bool> DeleteContactAsync(string contactId)
@@ -284,7 +421,10 @@ namespace StarfaceOutlookSync.Services
            var contact = new UnifiedContact();
            contact.StarfaceId = item["id"]?.ToString() ?? "";
-            var attrs = new Dictionary<string, string>();
+            // Attribute per "name"-Feld mappen (zuverlaessiger als displayKey,
            // weil viele Felder USER_DEFINED als displayKey haben)
            var byName = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
            var byDisplayKey = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
            var blocks = item["blocks"] as JArray;
            if (blocks != null)
            {
@@ -294,79 +434,123 @@ namespace StarfaceOutlookSync.Services
                    if (blockAttrs == null) continue;
                    foreach (var attr in blockAttrs)
                    {
-                        var key = attr["displayKey"]?.ToString() ?? "";
+                        var name = attr["name"]?.ToString() ?? "";
                        var displayKey = attr["displayKey"]?.ToString() ?? "";
                        var val = attr["value"]?.ToString() ?? "";
                        if (!string.IsNullOrEmpty(val))
-                            attrs[key] = val;
+                        {
                            if (!string.IsNullOrEmpty(name))
                                byName[name] = val;
                            // displayKey nur als Fallback (viele sind USER_DEFINED)
                            if (!string.IsNullOrEmpty(displayKey) && displayKey != "USER_DEFINED")
                                byDisplayKey[displayKey] = val;
                        }
                    }
                }
            }
-            contact.FirstName = attrs.GetValueOrDefault("NAME", "");
+            // Primaer nach name-Feld mappen, Fallback auf displayKey
-            contact.LastName = attrs.GetValueOrDefault("SURNAME", "");
+            string Get(string name, string displayKey = null)
-            contact.Company = attrs.GetValueOrDefault("COMPANY", "");
+            {
-            contact.JobTitle = attrs.GetValueOrDefault("JOB_TITLE", "");
+                if (byName.TryGetValue(name, out var v)) return v;
-            contact.Email = attrs.GetValueOrDefault("EMAIL", "");
+                if (displayKey != null && byDisplayKey.TryGetValue(displayKey, out v)) return v;
-            contact.PhoneWork = attrs.GetValueOrDefault("OFFICE_PHONE_NUMBER", "");
+                return "";
-            contact.PhoneMobile = attrs.GetValueOrDefault("MOBILE_PHONE_NUMBER", "");
+            }
-            contact.PhoneHome = attrs.GetValueOrDefault("PRIVATE_PHONE_NUMBER", "");
+
-            contact.Fax = attrs.GetValueOrDefault("FAX_NUMBER", "");
+            contact.FirstName = Get("firstname", "NAME");
-            contact.Street = attrs.GetValueOrDefault("STREET", "");
+            contact.LastName = Get("familyname", "SURNAME");
-            contact.City = attrs.GetValueOrDefault("CITY", "");
+            contact.Company = Get("company", "COMPANY");
-            contact.PostalCode = attrs.GetValueOrDefault("POSTAL_CODE", "");
+            contact.JobTitle = Get("jobtitle", "JOB_TITLE");
-            contact.State = attrs.GetValueOrDefault("STATE", "");
+            contact.Email = Get("e-mail", "EMAIL");
-            contact.Country = attrs.GetValueOrDefault("COUNTRY", "");
+            contact.PhoneWork = Get("phone", "PHONE_NUMBER");
-            contact.Website = attrs.GetValueOrDefault("URL", "");
+            contact.PhoneMobile = Get("mobile", "MOBILE_PHONE_NUMBER");
-            contact.Notes = attrs.GetValueOrDefault("NOTE", "");
+            contact.PhoneHome = Get("homephone", "PRIVATE_PHONE_NUMBER");
-            contact.Salutation = attrs.GetValueOrDefault("SALUTATION", "");
+            contact.Fax = Get("fax", "FAX_NUMBER");
-            contact.Title = attrs.GetValueOrDefault("TITLE", "");
+            contact.Street = Get("street", "STREET");
-            contact.Birthday = attrs.GetValueOrDefault("BIRTHDAY", "");
+            contact.City = Get("city", "CITY");
            contact.PostalCode = Get("postcode", "POSTAL_CODE");
            contact.State = Get("state", "STATE");
            contact.Country = Get("country", "COUNTRY");
            contact.Website = Get("url", "URL");
            contact.Notes = Get("comment", "NOTE");
            contact.Salutation = Get("salutation", "SALUTATION");
            contact.Title = Get("title", "TITLE");
            contact.Birthday = Get("birthday", "BIRTHDAY");
            return contact;
        }
        private JObject MapToStarface(UnifiedContact contact)
        {
-            var attrs = new JArray();
+            JArray MakeAttrs(params (string displayKey, string name, string value)[] fields)
            void AddAttr(string displayKey, string name, string value)
            {
-                if (!string.IsNullOrEmpty(value))
+                var arr = new JArray();
-                    attrs.Add(new JObject { ["displayKey"] = displayKey, ["name"] = name, ["value"] = value });
+                foreach (var (dk, n, v) in fields)
                {
                    if (!string.IsNullOrEmpty(v))
                        arr.Add(new JObject { ["displayKey"] = dk, ["name"] = n, ["value"] = v });
                }
                return arr;
            }
-            AddAttr("NAME", "firstName", contact.FirstName);
+            // Block-Struktur wie von der Starface erwartet
-            AddAttr("SURNAME", "lastName", contact.LastName);
+            var contactBlock = MakeAttrs(
-            AddAttr("COMPANY", "company", contact.Company);
+                ("NAME", "firstname", contact.FirstName),
-            AddAttr("JOB_TITLE", "jobTitle", contact.JobTitle);
+                ("SURNAME", "familyname", contact.LastName),
-            AddAttr("EMAIL", "email", contact.Email);
+                ("COMPANY", "company", contact.Company)
-            AddAttr("OFFICE_PHONE_NUMBER", "businessPhone", contact.PhoneWork);
+            );
-            AddAttr("MOBILE_PHONE_NUMBER", "mobilePhone", contact.PhoneMobile);
+
-            AddAttr("PRIVATE_PHONE_NUMBER", "homePhone", contact.PhoneHome);
+            var addressBlock = MakeAttrs(
-            AddAttr("FAX_NUMBER", "fax", contact.Fax);
+                ("USER_DEFINED", "street", contact.Street),
-            AddAttr("STREET", "street", contact.Street);
+                ("POSTAL_CODE", "postcode", contact.PostalCode),
-            AddAttr("CITY", "city", contact.City);
+                ("USER_DEFINED", "city", contact.City),
-            AddAttr("POSTAL_CODE", "postalCode", contact.PostalCode);
+                ("USER_DEFINED", "state", contact.State),
-            AddAttr("STATE", "state", contact.State);
+                ("USER_DEFINED", "country", contact.Country)
-            AddAttr("COUNTRY", "country", contact.Country);
+            );
-            AddAttr("URL", "website", contact.Website);
+
-            AddAttr("NOTE", "notes", contact.Notes);
+            var phoneBlock = MakeAttrs(
-            AddAttr("SALUTATION", "salutation", contact.Salutation);
+                ("PHONE_NUMBER", "phone", contact.PhoneWork),
-            AddAttr("TITLE", "title", contact.Title);
+                ("PRIVATE_PHONE_NUMBER", "homephone", contact.PhoneHome),
-            AddAttr("BIRTHDAY", "birthday", contact.Birthday);
+                ("MOBILE_PHONE_NUMBER", "mobile", contact.PhoneMobile),
                ("FAX_NUMBER", "fax", contact.Fax)
            );
            var emailBlock = MakeAttrs(
                ("EMAIL", "e-mail", contact.Email),
                ("URL", "url", contact.Website),
                ("USER_DEFINED", "comment", contact.Notes)
            );
            var blocks = new JArray();
            blocks.Add(new JObject
            {
                ["name"] = "contact",
                ["resourceKey"] = "de.vertico.starface.addressbook.block.label_contact",
                ["attributes"] = contactBlock
            });
            blocks.Add(new JObject
            {
                ["name"] = "address",
                ["resourceKey"] = "de.vertico.starface.addressbook.block.label_address",
                ["attributes"] = addressBlock
            });
            blocks.Add(new JObject
            {
                ["name"] = "telephone",
                ["resourceKey"] = "de.vertico.starface.addressbook.block.label_telephone",
                ["attributes"] = phoneBlock
            });
            blocks.Add(new JObject
            {
                ["name"] = "email",
                ["resourceKey"] = "de.vertico.starface.addressbook.block.label_email",
                ["attributes"] = emailBlock
            });
            return new JObject
            {
                ["id"] = contact.StarfaceId ?? "",
-                ["blocks"] = new JArray
+                ["blocks"] = blocks
                {
                    new JObject
                    {
                        ["name"] = "contact",
                        ["resourceKey"] = "contact",
                        ["attributes"] = attrs
                    }
                }
            };
        }
@@ -0,0 +1,163 @@
 using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Threading;
 using System.Threading.Tasks;
 using StarfaceOutlookSync.Models;
 namespace StarfaceOutlookSync.Services
 {
    /// <summary>
    /// Gemeinsame Orchestrierung fuer JEDEN Sync-Lauf - egal ob automatisch
    /// (Tray/Timer) oder manuell (Fortschrittsfenster). Sorgt einheitlich fuer:
    ///  - lokalen Re-Entrancy-Schutz (prozessweit, statisch),
    ///  - clientuebergreifende Lock-Datei,
    ///  - Anzeige/Logging von Konflikt-Notizen anderer Arbeitsplaetze,
    ///  - Protokollierung (Start, Ergebnis, Aenderungen, Konflikte, Fehler),
    ///  - Verteilen eigener Konflikt-Notizen.
    /// Die eigentliche UI (Tray-Meldung vs. Fenster) bleibt beim Aufrufer.
    /// </summary>
    public class SyncCoordinator
    {
        // Prozessweit: nie zwei Syncs gleichzeitig - auch nicht manuell + automatisch.
        private static int _running = 0;
        private readonly ProfileManager _profileManager = new ProfileManager();
        private readonly ConflictNotifier _notifier = new ConflictNotifier();
        public class SyncOutcome
        {
            public bool Skipped;
            public string SkipReason = "";
            public SyncResult Result;
            public Exception Error;
            public List<ConflictNotice> RemoteNotices = new List<ConflictNotice>();
        }
        /// <summary>
        /// Fuehrt einen Sync koordiniert aus. runEngine kapselt den eigentlichen
        /// Engine-Aufruf (inkl. ggf. Task.Run/Progress-Anbindung des Aufrufers),
        /// damit das Threading-Verhalten pro Pfad erhalten bleibt. status erhaelt
        /// Fortschrittstexte (Warten auf Sperre, Synchronisiere ...).
        /// </summary>
        public async Task<SyncOutcome> RunAsync(SyncProfile profile,
            Func<Task<SyncResult>> runEngine, Action<string> status)
        {
            var outcome = new SyncOutcome();
            if (Interlocked.CompareExchange(ref _running, 1, 0) != 0)
            {
                outcome.Skipped = true;
                outcome.SkipReason = "Sync laeuft bereits, bitte warten...";
                return outcome;
            }
            SyncLock crossLock = null;
            var settings = UserSettings.Load();
            Logger.PruneOlderThan(settings.LogRetentionDays);
            var sharedDir = settings.SharedDirectory;
            try
            {
                crossLock = await AcquireCrossClientLock(sharedDir, status);
                if (crossLock == null)
                {
                    outcome.Skipped = true;
                    outcome.SkipReason = "Anderer Arbeitsplatz synchronisiert gerade - uebersprungen.";
                    Logger.Log($"Sync '{profile.Name}' uebersprungen: anderer Arbeitsplatz synct gerade.");
                    return outcome;
                }
                // Konflikt-Hinweise anderer Arbeitsplaetze ermitteln, BEVOR der Sync
                // den eigenen Stand auf den Gewinner-Wert angleicht.
                try
                {
                    outcome.RemoteNotices = _notifier.GetPending(sharedDir, MyContactsByStarfaceId());
                    foreach (var n in outcome.RemoteNotices)
                        Logger.Log($"  KONFLIKT (anderer Arbeitsplatz): {n}");
                }
                catch { }
                Logger.Log($"Sync gestartet: '{profile.Name}' (Richtung: {profile.SyncDirection})");
                status?.Invoke($"Synchronisiere '{profile.Name}'...");
                SyncResult result;
                try
                {
                    result = await runEngine();
                }
                catch (Exception ex)
                {
                    outcome.Error = ex;
                    Logger.Log($"Sync FEHLER '{profile.Name}': {ex.Message}");
                    return outcome;
                }
                outcome.Result = result;
                var msg = $"{profile.Name}: {result.Created} erstellt, {result.Updated} aktualisiert"
                          + (result.Errors > 0 ? $", {result.Errors} Fehler" : "")
                          + (result.Conflicts.Count > 0 ? $", {result.Conflicts.Count} Konflikt(e)" : "");
                Logger.Log($"Sync fertig: {msg}");
                foreach (var ch in result.Changes) Logger.Log($"  {ch}");
                foreach (var em in result.ErrorMessages) Logger.Log($"  Fehler: {em}");
                foreach (var c in result.Conflicts) Logger.Log($"  KONFLIKT: {c}");
                // Andere Arbeitsplaetze ueber eigene Konflikte informieren.
                if (result.Conflicts.Count > 0)
                    _notifier.Write(sharedDir, result.Conflicts);
                return outcome;
            }
            finally
            {
                crossLock?.Dispose();
                Interlocked.Exchange(ref _running, 0);
            }
        }
        private async Task<SyncLock> AcquireCrossClientLock(string dir, Action<string> status)
        {
            if (string.IsNullOrWhiteSpace(dir))
                return SyncLock.NoOp();
            try
            {
                // Legt das Verzeichnis bei Bedarf an (idempotent). Funktioniert mit
                // UNC-Pfaden (\\server\freigabe\...) - kein Netzlaufwerk noetig.
                Directory.CreateDirectory(dir);
            }
            catch
            {
                status?.Invoke("Gemeinsames Verzeichnis nicht erreichbar - synce ohne Sperre.");
                return SyncLock.NoOp();
            }
            var deadline = DateTime.UtcNow.AddMinutes(2);
            int attempt = 0;
            while (true)
            {
                var l = SyncLock.TryAcquire(dir, out var heldBy);
                if (l != null) return l;
                if (DateTime.UtcNow >= deadline) return null;
                attempt++;
                status?.Invoke($"Warte auf anderen Arbeitsplatz ({heldBy ?? "unbekannt"})... ({attempt})");
                await Task.Delay(3000);
            }
        }
        private Dictionary<string, UnifiedContact> MyContactsByStarfaceId()
        {
            var map = new Dictionary<string, UnifiedContact>(StringComparer.OrdinalIgnoreCase);
            try
            {
                foreach (var p in _profileManager.GetProfiles())
                    foreach (var m in _profileManager.GetMappings(p.Id))
                        if (!string.IsNullOrEmpty(m.StarfaceId) && !map.ContainsKey(m.StarfaceId))
                            map[m.StarfaceId] = m.LastOutlook;
            }
            catch { }
            return map;
        }
    }
 }
@@ -15,30 +15,90 @@ namespace StarfaceOutlookSync.Services
        private void Log(string message) => OnProgress?.Invoke(message);
-        private static UnifiedContact FindMatch(UnifiedContact contact, List<UnifiedContact> candidates)
+        /// <summary>Protokolliert eine tatsaechliche Aenderung (fuer Live-Log UND SyncResult.Changes).</summary>
        private void Action(SyncResult result, string message)
        {
-            // Erst E-Mail-Match
+            Log("  " + message);
-            if (!string.IsNullOrEmpty(contact.Email))
+            result?.Changes.Add(message);
            {
                var byEmail = candidates.FirstOrDefault(c =>
                    !string.IsNullOrEmpty(c.Email) &&
                    c.Email.Equals(contact.Email, StringComparison.OrdinalIgnoreCase));
                if (byEmail != null) return byEmail;
        }
-            // Dann Name-Match
+        /// <summary>
-            if (!string.IsNullOrEmpty(contact.FirstName) || !string.IsNullOrEmpty(contact.LastName))
+        /// Setzt die Baseline eines Mappings auf den uebergebenen Stand beider
        /// Seiten (Snapshot + Hash). Der Snapshot wird fuer das Feld-Merge bei
        /// kuenftigen Konflikten gebraucht.
        /// </summary>
        private static void SetBaseline(SyncMapping m, UnifiedContact outlook, UnifiedContact starface)
        {
-                var byName = candidates.FirstOrDefault(c =>
+            m.LastOutlook = outlook;
-                    c.FirstName.Equals(contact.FirstName, StringComparison.OrdinalIgnoreCase) &&
+            m.LastStarface = starface;
-                    c.LastName.Equals(contact.LastName, StringComparison.OrdinalIgnoreCase) &&
+            m.LastOutlookHash = outlook?.GetHash() ?? "";
-                    (!string.IsNullOrEmpty(c.FirstName) || !string.IsNullOrEmpty(c.LastName)));
+            m.LastStarfaceHash = starface?.GetHash() ?? "";
-                if (byName != null) return byName;
+            m.LastSyncHash = "";
        }
        /// <summary>
        /// Findet einen passenden Kontakt in der Kandidatenliste.
        /// Strenges Matching: Felder die auf einer Seite gefuellt sind muessen
        /// auf der anderen auch gefuellt (und gleich) sein.
        /// Ein leeres Feld auf einer Seite und ein gefuelltes auf der anderen
        /// bedeutet: verschiedene Kontakte.
        /// </summary>
        private static UnifiedContact FindMatch(UnifiedContact contact, List<UnifiedContact> candidates)
        {
            if (candidates == null || candidates.Count == 0) return null;
            foreach (var c in candidates)
            {
                if (IsMatch(contact, c))
                    return c;
            }
            return null;
        }
        private static bool IsMatch(UnifiedContact a, UnifiedContact b)
        {
            bool hasName = (!string.IsNullOrEmpty(a.FirstName) || !string.IsNullOrEmpty(a.LastName))
                           && (!string.IsNullOrEmpty(b.FirstName) || !string.IsNullOrEmpty(b.LastName));
            // Starke Identifikatoren
            bool emailMatch = !string.IsNullOrEmpty(a.Email) && !string.IsNullOrEmpty(b.Email)
                              && a.Email.Equals(b.Email, StringComparison.OrdinalIgnoreCase);
            bool nameMatch = hasName
                             && (a.FirstName ?? "").Equals(b.FirstName ?? "", StringComparison.OrdinalIgnoreCase)
                             && (a.LastName ?? "").Equals(b.LastName ?? "", StringComparison.OrdinalIgnoreCase);
            bool phoneMatch = (!string.IsNullOrEmpty(a.PhoneWork) && !string.IsNullOrEmpty(b.PhoneWork)
                               && NormalizePhone(a.PhoneWork) == NormalizePhone(b.PhoneWork))
                              || (!string.IsNullOrEmpty(a.PhoneMobile) && !string.IsNullOrEmpty(b.PhoneMobile)
                               && NormalizePhone(a.PhoneMobile) == NormalizePhone(b.PhoneMobile))
                              || (!string.IsNullOrEmpty(a.Fax) && !string.IsNullOrEmpty(b.Fax)
                               && NormalizePhone(a.Fax) == NormalizePhone(b.Fax));
            bool companyMatch = !string.IsNullOrEmpty(a.Company) && !string.IsNullOrEmpty(b.Company)
                                && a.Company.Equals(b.Company, StringComparison.OrdinalIgnoreCase);
            // Widerspruch: beide haben eine E-Mail, aber unterschiedlich -> verschiedene Personen.
            bool emailContradiction = !string.IsNullOrEmpty(a.Email) && !string.IsNullOrEmpty(b.Email) && !emailMatch;
            // Gleiche E-Mail ist der staerkste Identifikator und reicht allein.
            if (emailMatch) return true;
            // Gleicher voller Name reicht, solange keine widerspruechliche E-Mail vorliegt.
            // (Telefon-Umformatierung durch Starface darf einen Namens-Treffer NICHT verhindern.)
            if (nameMatch && !emailContradiction) return true;
            // Schwacher Pfad: Telefon/Fax nur zusammen mit gleicher Firma und ohne E-Mail-Widerspruch.
            if (phoneMatch && companyMatch && !emailContradiction) return true;
            return false;
        }
        private static string NormalizePhone(string phone)
        {
            if (string.IsNullOrEmpty(phone)) return "";
            // Nur Ziffern und + behalten
            return new string(phone.Where(c => char.IsDigit(c) || c == '+').ToArray());
        }
        public async Task<SyncResult> SyncProfileAsync(SyncProfile profile)
        {
            var result = new SyncResult
@@ -49,7 +109,6 @@ namespace StarfaceOutlookSync.Services
            try
            {
                // Starface verbinden
                Log("Verbinde mit Starface...");
                using (var starface = new StarfaceApiClient(profile.StarfaceConnection))
                {
@@ -62,10 +121,6 @@ namespace StarfaceOutlookSync.Services
                        return result;
                    }
                    var mappings = _profileManager.GetMappings(profile.Id);
                    var mappingByOutlook = mappings.ToDictionary(m => m.OutlookEntryId, m => m);
                    var mappingByStarface = mappings.ToDictionary(m => m.StarfaceId, m => m);
                    // Kontakte laden
                    Log("Lade Outlook-Kontakte...");
                    var outlookContacts = _outlookService.GetContacts(profile.OutlookFolderPath);
@@ -75,144 +130,514 @@ namespace StarfaceOutlookSync.Services
                    var starfaceContacts = await starface.GetContactsAsync(profile.StarfaceAddressBook);
                    Log($"{starfaceContacts.Count} Starface-Kontakte geladen");
-                    // Outlook -> Starface
+                    // Bestehende Mappings laden
-                    if (profile.SyncDirection == SyncDirection.Both ||
+                    var mappings = _profileManager.GetMappings(profile.Id);
                        profile.SyncDirection == SyncDirection.OutlookToStarface)
                    {
                        Log("Synchronisiere Outlook -> Starface...");
                        foreach (var oc in outlookContacts)
                        {
                            try
                            {
                                SyncMapping existing = null;
                                if (!string.IsNullOrEmpty(oc.OutlookEntryId))
                                    mappingByOutlook.TryGetValue(oc.OutlookEntryId, out existing);
-                                if (existing != null)
+                    // Sets fuer schnellen Lookup
                    var mappingByOutlook = new Dictionary<string, SyncMapping>();
                    var mappingByStarface = new Dictionary<string, SyncMapping>();
                    foreach (var m in mappings)
                    {
-                                    var hash = oc.GetHash();
+                        if (!string.IsNullOrEmpty(m.OutlookEntryId))
-                                    if (hash != existing.LastSyncHash)
+                            mappingByOutlook[m.OutlookEntryId] = m;
-                                    {
+                        if (!string.IsNullOrEmpty(m.StarfaceId))
-                                        if (await starface.UpdateContactAsync(existing.StarfaceId, oc, profile.StarfaceAddressBook))
+                            mappingByStarface[m.StarfaceId] = m;
                                        {
                                            existing.LastSyncHash = hash;
                                            result.Updated++;
                    }
                    // Tracking: welche Kontakte wurden bereits verarbeitet
                    var processedStarfaceIds = new HashSet<string>();
                    var processedOutlookIds = new HashSet<string>();
                    var newMappings = new List<SyncMapping>();
                    // ============================================
                    // Phase 1: Bestehende Mappings abgleichen
                    // ============================================
                    Log("Gleiche bestehende Zuordnungen ab...");
                    foreach (var mapping in mappings.ToList())
                    {
                        var oc = outlookContacts.FirstOrDefault(c => c.OutlookEntryId == mapping.OutlookEntryId);
                        var sc = starfaceContacts.FirstOrDefault(c => c.StarfaceId == mapping.StarfaceId);
                        if (oc != null) processedOutlookIds.Add(oc.OutlookEntryId);
                        if (sc != null) processedStarfaceIds.Add(sc.StarfaceId);
                        if (oc == null && sc == null)
                        {
                            // Beide Seiten geloescht -> Mapping entfernen
                            Log($"  Mapping verwaist (beide geloescht), entferne");
                            continue;
                        }
                        if (oc == null && sc != null)
                        {
                            // Outlook-Kontakt nicht gefunden.
                            // Erst pruefen ob er vielleicht nur eine neue EntryID hat
                            var reMatch = FindMatch(sc, outlookContacts.Where(c =>
                                !processedOutlookIds.Contains(c.OutlookEntryId)).ToList());
                            if (reMatch != null)
                            {
                                // Kontakt existiert noch in Outlook, nur EntryID geaendert
                                Log($"  EntryID geaendert, verknuepfe neu: {sc.DisplayName}");
                                mapping.OutlookEntryId = reMatch.OutlookEntryId;
                                processedOutlookIds.Add(reMatch.OutlookEntryId);
                                newMappings.Add(mapping);
                                continue;
                            }
                            // Wirklich in Outlook geloescht.
                            if (profile.SyncDirection == SyncDirection.OutlookToStarface)
                            {
                                // Outlook ist fuehrend -> Loeschung nach Starface spiegeln.
                                if (await starface.DeleteContactAsync(mapping.StarfaceId))
                                {
                                    result.Updated++;
                                    Action(result, $"Geloescht (OL->SF): {sc.DisplayName}");
                                }
                                continue;
                            }
                            if (profile.SyncDirection == SyncDirection.Both)
                            {
                                // Bidirektional: anhand der Baseline pruefen, ob die
                                // Starface-Seite seit dem letzten Sync unveraendert ist.
                                bool sfUnchanged = !string.IsNullOrEmpty(mapping.LastStarfaceHash)
                                                   && sc.GetHash() == mapping.LastStarfaceHash;
                                if (sfUnchanged)
                                {
                                    // Unveraendert + in Outlook geloescht -> Loeschung gilt
                                    // -> auch aus Starface entfernen.
                                    if (await starface.DeleteContactAsync(mapping.StarfaceId))
                                    {
                                        result.Updated++;
                                        Action(result, $"Geloescht (OL->SF): {sc.DisplayName}");
                                    }
                                    continue;
                                }
                                // In Outlook geloescht, aber in Starface geaendert ->
                                // Bearbeitung gewinnt, in Outlook neu anlegen (Phase 3).
                                Log($"  In Outlook geloescht, in Starface geaendert -> neu anlegen: {sc.DisplayName}");
                                processedStarfaceIds.Remove(sc.StarfaceId);
                                continue;
                            }
                            // StarfaceToOutlook: Starface ist alleinige Quelle -> in Outlook
                            // neu anlegen (Loeschung im Ziel zaehlt nicht).
                            Log($"  Outlook-Kontakt geloescht, wird neu angelegt: {sc.DisplayName}");
                            processedStarfaceIds.Remove(sc.StarfaceId);
                            continue;
                        }
                        if (oc != null && sc == null)
                        {
                            // Starface-Kontakt nicht in der geladenen Liste. Zwei Faelle
                            // unterscheiden, indem wir ihn per ID direkt abfragen:
                            //  (a) per ID noch vorhanden -> liegt in einem ANDEREN
                            //      Adressbuch -> Mapping behalten, NICHT neu anlegen
                            //      (sonst Dublette).
                            //  (b) per ID 404 -> in Starface WIRKLICH geloescht.
                            bool stillExists = !string.IsNullOrEmpty(mapping.StarfaceId)
                                && await starface.GetContactAsync(mapping.StarfaceId) != null;
                            if (stillExists)
                            {
                                Log($"  Starface-Kontakt in anderem Adressbuch, behalte Mapping: {oc.DisplayName}");
                                newMappings.Add(mapping);
                                continue;
                            }
                            // Wirklich in Starface geloescht.
                            if (profile.SyncDirection == SyncDirection.StarfaceToOutlook)
                            {
                                // Starface ist fuehrend -> Loeschung nach Outlook spiegeln.
                                if (_outlookService.DeleteContact(oc.OutlookEntryId))
                                {
                                    result.Updated++;
                                    Action(result, $"Geloescht (SF->OL): {oc.DisplayName}");
                                }
                                continue;
                            }
                            if (profile.SyncDirection == SyncDirection.Both)
                            {
                                // Bidirektional: anhand der Baseline entscheiden, ob der
                                // Outlook-Kontakt seit dem letzten Sync unveraendert ist.
                                bool olUnchanged = !string.IsNullOrEmpty(mapping.LastOutlookHash)
                                                   && oc.GetHash() == mapping.LastOutlookHash;
                                if (olUnchanged)
                                {
                                    // Unveraendert + in Starface geloescht -> Loeschung gilt
                                    // -> aus Outlook entfernen.
                                    if (_outlookService.DeleteContact(oc.OutlookEntryId))
                                    {
                                        result.Updated++;
                                        Action(result, $"Geloescht (SF->OL): {oc.DisplayName}");
                                    }
                                    continue;
                                }
                                // In Starface geloescht, aber in Outlook geaendert ->
                                // Bearbeitung gewinnt, in Starface neu anlegen.
                                Log($"  In Starface geloescht, in Outlook geaendert -> neu anlegen: {oc.DisplayName}");
                                processedOutlookIds.Remove(oc.OutlookEntryId);
                                continue;
                            }
                            // OutlookToStarface: Outlook ist alleinige Quelle -> Kontakt
                            // in Starface neu anlegen (Loeschung im Ziel zaehlt nicht).
                            Log($"  Starface-Kontakt geloescht, wird neu angelegt: {oc.DisplayName}");
                            processedOutlookIds.Remove(oc.OutlookEntryId);
                            continue;
                        }
                        if (oc != null && sc != null)
                        {
                            // Beide vorhanden -> auf Aenderungen pruefen.
                            // WICHTIG: jede Seite gegen ihre EIGENE Baseline pruefen.
                            // Outlook und Starface stellen denselben Kontakt
                            // unterschiedlich dar, ein gemeinsamer Hash schlaegt nie an.
                            var olHash = oc.GetHash();
                            var sfHash = sc.GetHash();
                            // Migration alter Mappings (nur LastSyncHash vorhanden):
                            // aktuellen Stand als Baseline uebernehmen und als synchron
                            // annehmen, damit kein Massen-Update ausgeloest wird.
                            if (string.IsNullOrEmpty(mapping.LastOutlookHash) &&
                                string.IsNullOrEmpty(mapping.LastStarfaceHash))
                            {
                                SetBaseline(mapping, oc, sc);
                                newMappings.Add(mapping);
                                continue;
                            }
                            bool olChanged = olHash != mapping.LastOutlookHash;
                            bool sfChanged = sfHash != mapping.LastStarfaceHash;
                            if (!olChanged && !sfChanged)
                            {
                                // Unveraendert. Snapshots aelterer Mappings (nur Hash)
                                // nachtragen, damit kuenftige Konflikte gemergt werden koennen.
                                if (mapping.LastOutlook == null || mapping.LastStarface == null)
                                    SetBaseline(mapping, oc, sc);
                                newMappings.Add(mapping);
                                continue;
                            }
                            if (olChanged && !sfChanged && (profile.SyncDirection == SyncDirection.Both || profile.SyncDirection == SyncDirection.OutlookToStarface))
                            {
                                // Outlook hat sich geaendert -> Starface updaten
                                var updated = await starface.UpdateContactAsync(mapping.StarfaceId, oc, profile.StarfaceAddressBook);
                                if (updated != null)
                                {
                                    SetBaseline(mapping, oc, updated);
                                    result.Updated++;
                                    Action(result, $"Aktualisiert (OL->SF): {oc.DisplayName}");
                                }
                            }
                            else if (sfChanged && !olChanged && (profile.SyncDirection == SyncDirection.Both || profile.SyncDirection == SyncDirection.StarfaceToOutlook))
                            {
                                // Starface hat sich geaendert -> Outlook updaten
                                var updated = _outlookService.UpdateContact(mapping.OutlookEntryId, sc);
                                if (updated != null)
                                {
                                    SetBaseline(mapping, updated, sc);
                                    result.Updated++;
                                    Action(result, $"Aktualisiert (SF->OL): {sc.DisplayName}");
                                }
                            }
                            else if (olChanged && sfChanged)
                            {
                                // Beide Seiten geaendert.
                                if (profile.SyncDirection == SyncDirection.Both
                                    && mapping.LastOutlook != null && mapping.LastStarface != null)
                                {
                                    // Feldweises 3-Wege-Merge: unterschiedliche Felder
                                    // bleiben beide erhalten; nur bei gleichem Feld auf
                                    // beiden Seiten gewinnt Outlook.
                                    var (merged, conflicts) = ContactMerger.Merge(
                                        mapping.LastOutlook, mapping.LastStarface, oc, sc, outlookWins: true);
                                    var updatedSf = await starface.UpdateContactAsync(mapping.StarfaceId, merged, profile.StarfaceAddressBook);
                                    var updatedOl = _outlookService.UpdateContact(mapping.OutlookEntryId, merged);
                                    if (updatedSf != null || updatedOl != null)
                                    {
                                        if (updatedOl != null)
                                        {
                                            mapping.LastOutlook = updatedOl;
                                            mapping.LastOutlookHash = updatedOl.GetHash();
                                        }
                                        if (updatedSf != null)
                                        {
                                            mapping.LastStarface = updatedSf;
                                            mapping.LastStarfaceHash = updatedSf.GetHash();
                                        }
                                        mapping.LastSyncHash = "";
                                        result.Updated++;
                                        foreach (var cf in conflicts) result.Conflicts.Add(cf);
                                        Action(result, conflicts.Count > 0
                                            ? $"Beidseitig geaendert, zusammengefuehrt ({conflicts.Count} Feld-Konflikt(e), Outlook gewinnt): {oc.DisplayName}"
                                            : $"Beidseitig geaendert, zusammengefuehrt: {oc.DisplayName}");
                                    }
                                }
                                else if (profile.SyncDirection != SyncDirection.StarfaceToOutlook)
                                {
                                    // Fallback ohne Snapshot bzw. OutlookToStarface:
                                    // Outlook gewinnt komplett.
                                    var updated = await starface.UpdateContactAsync(mapping.StarfaceId, oc, profile.StarfaceAddressBook);
                                    if (updated != null)
                                    {
                                        SetBaseline(mapping, oc, updated);
                                        result.Updated++;
                                        Action(result, $"Konflikt (OL gewinnt): {oc.DisplayName}");
                                    }
                                }
                                else
                                {
-                                    var match = FindMatch(oc, starfaceContacts);
+                                    var updated = _outlookService.UpdateContact(mapping.OutlookEntryId, sc);
-                                    if (match != null && !string.IsNullOrEmpty(match.StarfaceId))
+                                    if (updated != null)
                                    {
-                                        if (await starface.UpdateContactAsync(match.StarfaceId, oc, profile.StarfaceAddressBook))
+                                        SetBaseline(mapping, updated, sc);
                                        result.Updated++;
                                        Action(result, $"Konflikt (SF gewinnt): {sc.DisplayName}");
                                    }
                                }
                            }
                        }
                        newMappings.Add(mapping);
                    }
                    // ============================================
                    // Phase 2: Neue Outlook-Kontakte (ohne Mapping)
                    // ============================================
                    if (profile.SyncDirection == SyncDirection.Both || profile.SyncDirection == SyncDirection.OutlookToStarface)
                    {
-                                            _profileManager.AddOrUpdateMapping(new SyncMapping
+                        var unmappedOutlook = outlookContacts
                            .Where(c => !string.IsNullOrEmpty(c.OutlookEntryId) && !processedOutlookIds.Contains(c.OutlookEntryId))
                            .ToList();
                        if (unmappedOutlook.Count > 0)
                            Log($"Neue Outlook-Kontakte: {unmappedOutlook.Count}");
                        // Starface-Kontakte die noch kein Mapping haben (fuer Duplikat-Check)
                        var unmappedStarface = starfaceContacts
                            .Where(c => !string.IsNullOrEmpty(c.StarfaceId) && !processedStarfaceIds.Contains(c.StarfaceId))
                            .ToList();
                        foreach (var oc in unmappedOutlook)
                        {
                            try
                            {
                                // Duplikat-Check: existiert der Kontakt schon in der Starface?
                                var match = FindMatch(oc, unmappedStarface);
                                if (match != null)
                                {
                                    // Existiert schon -> verknuepfen und updaten
                                    var updated = await starface.UpdateContactAsync(match.StarfaceId, oc, profile.StarfaceAddressBook);
                                    if (updated != null)
                                    {
                                        newMappings.Add(new SyncMapping
                                        {
                                            ProfileId = profile.Id,
                                            OutlookEntryId = oc.OutlookEntryId,
                                            StarfaceId = match.StarfaceId,
-                                                LastSyncHash = oc.GetHash()
+                                            LastOutlook = oc,
                                            LastStarface = updated,
                                            LastOutlookHash = oc.GetHash(),
                                            LastStarfaceHash = updated.GetHash()
                                        });
                                        processedStarfaceIds.Add(match.StarfaceId);
                                        unmappedStarface.Remove(match);
                                        result.Updated++;
                                        Action(result, $"Verknuepft (OL->SF): {oc.DisplayName}");
                                    }
                                }
                                else
                                {
                                    // Neu -> in Starface erstellen
                                    Log($"  Erstelle in Starface: {oc.DisplayName}");
                                    var created = await starface.CreateContactAsync(oc, profile.StarfaceAddressBook);
                                    if (created != null && !string.IsNullOrEmpty(created.StarfaceId))
                                    {
-                                            _profileManager.AddOrUpdateMapping(new SyncMapping
+                                        newMappings.Add(new SyncMapping
                                        {
                                            ProfileId = profile.Id,
                                            OutlookEntryId = oc.OutlookEntryId,
                                            StarfaceId = created.StarfaceId,
-                                                LastSyncHash = oc.GetHash()
+                                            LastOutlook = oc,
                                            LastStarface = created,
                                            LastOutlookHash = oc.GetHash(),
                                            LastStarfaceHash = created.GetHash()
                                        });
                                        result.Created++;
                                        Action(result, $"Erstellt (OL->SF): {oc.DisplayName}");
                                    }
                                    else
                                    {
                                        Log($"  FEHLER: Kontakt konnte nicht erstellt werden: {oc.DisplayName}");
                                        result.Errors++;
                                    }
                                }
                            }
                            catch (Exception ex)
                            {
                                result.Errors++;
-                                result.ErrorMessages.Add($"{oc.DisplayName}: {ex.Message}");
+                                result.ErrorMessages.Add($"OL->SF {oc.DisplayName}: {ex.Message}");
                            }
                        }
                    }
-                    // Starface -> Outlook
+                    // ============================================
-                    if (profile.SyncDirection == SyncDirection.Both ||
+                    // Phase 3: Neue Starface-Kontakte (ohne Mapping)
-                        profile.SyncDirection == SyncDirection.StarfaceToOutlook)
+                    // ============================================
                    if (profile.SyncDirection == SyncDirection.Both || profile.SyncDirection == SyncDirection.StarfaceToOutlook)
                    {
-                        Log("Synchronisiere Starface -> Outlook...");
+                        var unmappedStarface = starfaceContacts
-                        foreach (var sc in starfaceContacts)
+                            .Where(c => !string.IsNullOrEmpty(c.StarfaceId) && !processedStarfaceIds.Contains(c.StarfaceId))
                            .ToList();
                        if (unmappedStarface.Count > 0)
                            Log($"Neue Starface-Kontakte: {unmappedStarface.Count}");
                        // Outlook-Kontakte die noch kein Mapping haben (fuer Duplikat-Check)
                        var unmappedOutlook = outlookContacts
                            .Where(c => !string.IsNullOrEmpty(c.OutlookEntryId) && !processedOutlookIds.Contains(c.OutlookEntryId))
                            .ToList();
                        foreach (var sc in unmappedStarface)
                        {
                            try
                            {
-                                SyncMapping existing = null;
+                                // Duplikat-Check: existiert der Kontakt schon in Outlook?
-                                if (!string.IsNullOrEmpty(sc.StarfaceId))
+                                var match = FindMatch(sc, unmappedOutlook);
-                                    mappingByStarface.TryGetValue(sc.StarfaceId, out existing);
+                                if (match != null)
                                if (existing != null)
                                {
-                                    var hash = sc.GetHash();
+                                    // Existiert schon -> verknuepfen und updaten
-                                    if (hash != existing.LastSyncHash)
+                                    var updated = _outlookService.UpdateContact(match.OutlookEntryId, sc);
                                    if (updated != null)
                                    {
-                                        if (_outlookService.UpdateContact(existing.OutlookEntryId, sc))
+                                        newMappings.Add(new SyncMapping
                                        {
                                            existing.LastSyncHash = hash;
                                            result.Updated++;
                                        }
                                    }
                                }
                                else
                                {
                                    var match = FindMatch(sc, outlookContacts);
                                    if (match != null && !string.IsNullOrEmpty(match.OutlookEntryId))
                                    {
                                        if (_outlookService.UpdateContact(match.OutlookEntryId, sc))
                                        {
                                            _profileManager.AddOrUpdateMapping(new SyncMapping
                                        {
                                            ProfileId = profile.Id,
                                            OutlookEntryId = match.OutlookEntryId,
                                            StarfaceId = sc.StarfaceId,
-                                                LastSyncHash = sc.GetHash()
+                                            LastStarface = sc,
                                            LastOutlook = updated,
                                            LastStarfaceHash = sc.GetHash(),
                                            LastOutlookHash = updated.GetHash()
                                        });
                                        processedOutlookIds.Add(match.OutlookEntryId);
                                        unmappedOutlook.Remove(match);
                                        result.Updated++;
                                        Action(result, $"Verknuepft (SF->OL): {sc.DisplayName}");
                                    }
                                }
                                else
                                {
                                    // Neu -> in Outlook erstellen
                                    var created = _outlookService.CreateContact(sc, profile.OutlookFolderPath);
                                    if (created != null && !string.IsNullOrEmpty(created.OutlookEntryId))
                                    {
-                                            _profileManager.AddOrUpdateMapping(new SyncMapping
+                                        newMappings.Add(new SyncMapping
                                        {
                                            ProfileId = profile.Id,
                                            OutlookEntryId = created.OutlookEntryId,
                                            StarfaceId = sc.StarfaceId,
-                                                LastSyncHash = sc.GetHash()
+                                            LastStarface = sc,
                                            LastOutlook = created,
                                            LastStarfaceHash = sc.GetHash(),
                                            LastOutlookHash = created.GetHash()
                                        });
                                        result.Created++;
-                                        }
+                                        Action(result, $"Erstellt (SF->OL): {sc.DisplayName}");
                                    }
                                }
                            }
                            catch (Exception ex)
                            {
                                result.Errors++;
-                                result.ErrorMessages.Add($"{sc.DisplayName}: {ex.Message}");
+                                result.ErrorMessages.Add($"SF->OL {sc.DisplayName}: {ex.Message}");
                            }
                        }
                    }
                    // ============================================
                    // Phase 4: Ersetzen-Modus - Zielseite an Quelle angleichen
                    // ============================================
                    // In den Ein-Richtungs-Modi soll die Zielseite eine exakte Kopie
                    // der Quelle werden. Kontakte, die nur auf der Zielseite existieren
                    // (kein Mapping, kein Treffer in der Quelle), werden geloescht.
                    // Sicher, weil unvollstaendige Ladevorgaenge vorher abbrechen.
                    if (profile.SyncDirection == SyncDirection.OutlookToStarface)
                    {
                        // Schutz gegen versehentliches Leerraeumen (z.B. falscher Ordner).
                        if (outlookContacts.Count == 0)
                        {
                            Log("Ersetzen-Modus uebersprungen: Outlook-Ordner ist leer (Schutz vor versehentlichem Leeren).");
                        }
                        else
                        {
                            var leftover = starfaceContacts
                                .Where(c => !string.IsNullOrEmpty(c.StarfaceId) && !processedStarfaceIds.Contains(c.StarfaceId))
                                .ToList();
                            if (leftover.Count > 0)
                                Log($"Ersetzen-Modus: entferne {leftover.Count} Kontakt(e) aus Starface, die nicht in Outlook existieren");
                            foreach (var sc in leftover)
                            {
                                try
                                {
                                    if (await starface.DeleteContactAsync(sc.StarfaceId))
                                    {
                                        result.Updated++;
                                        Action(result, $"Geloescht (nur in Starface): {sc.DisplayName}");
                                    }
                                }
                                catch (Exception ex)
                                {
                                    result.Errors++;
                                    result.ErrorMessages.Add($"Loeschen SF {sc.DisplayName}: {ex.Message}");
                                }
                            }
                        }
                    }
                    else if (profile.SyncDirection == SyncDirection.StarfaceToOutlook)
                    {
                        if (starfaceContacts.Count == 0)
                        {
                            Log("Ersetzen-Modus uebersprungen: Starface-Adressbuch ist leer (Schutz vor versehentlichem Leeren).");
                        }
                        else
                        {
                            var leftover = outlookContacts
                                .Where(c => !string.IsNullOrEmpty(c.OutlookEntryId) && !processedOutlookIds.Contains(c.OutlookEntryId))
                                .ToList();
                            if (leftover.Count > 0)
                                Log($"Ersetzen-Modus: entferne {leftover.Count} Kontakt(e) aus Outlook, die nicht in Starface existieren");
                            foreach (var oc in leftover)
                            {
                                try
                                {
                                    if (_outlookService.DeleteContact(oc.OutlookEntryId))
                                    {
                                        result.Updated++;
                                        Action(result, $"Geloescht (nur in Outlook): {oc.DisplayName}");
                                    }
                                }
                                catch (Exception ex)
                                {
                                    result.Errors++;
                                    result.ErrorMessages.Add($"Loeschen OL {oc.DisplayName}: {ex.Message}");
                                }
                            }
                        }
                    }
                    // Mappings speichern
                    _profileManager.SaveMappings(profile.Id, newMappings);
                    _profileManager.UpdateLastSync(profile.Id);
-                    _profileManager.SaveMappings(profile.Id, mappings);
+
                    await starface.LogoutAsync();
-                    Log("Synchronisation abgeschlossen!");
+
                    Log($"Fertig: {result.Created} erstellt, {result.Updated} aktualisiert, {result.Errors} Fehler");
                }
            }
            catch (Exception ex)
@@ -0,0 +1,120 @@
 using System;
 using System.Diagnostics;
 using System.IO;
 using System.Text;
 namespace StarfaceOutlookSync.Services
 {
    /// <summary>
    /// Clientuebergreifende Sperre ueber eine Lock-Datei in einem gemeinsamen
    /// Verzeichnis (Netzlaufwerk/Share). Verhindert, dass mehrere Arbeitsplaetze
    /// gleichzeitig dasselbe Starface-Adressbuch synchronisieren.
    ///
    /// Atomar ueber FileMode.CreateNew: das Anlegen schlaegt fehl, wenn die Datei
    /// schon existiert. Die Datei wird waehrend des Syncs offen gehalten
    /// (FileShare.None) - stuerzt ein Client ab, gibt das Betriebssystem das
    /// Handle frei und ein anderer Client kann die (dann verwaiste) Datei
    /// uebernehmen. Eine reine Zeitstempel-Pruefung allein waere nicht sicher.
    /// </summary>
    public sealed class SyncLock : IDisposable
    {
        public const string LockFileName = "starface-sync.lock";
        // Aelter als das -> als verwaist behandeln und Uebernahme VERSUCHEN.
        // Lebt der Eigentuemer noch, schlaegt das Loeschen am offenen Handle fehl,
        // die Sperre bleibt also korrekt bestehen.
        private static readonly TimeSpan StaleAfter = TimeSpan.FromMinutes(15);
        private FileStream _stream;
        private readonly string _path;
        private SyncLock(string path, FileStream stream)
        {
            _path = path;
            _stream = stream;
        }
        /// <summary>Sperre, die nichts haelt (wenn kein gemeinsames Verzeichnis konfiguriert/erreichbar ist).</summary>
        public static SyncLock NoOp() => new SyncLock(null, null);
        /// <summary>
        /// Versucht die Sperre zu holen. Gibt null zurueck, wenn gerade ein
        /// anderer (lebender) Client synct. heldBy enthaelt - sofern lesbar -
        /// Infos zum aktuellen Halter.
        /// </summary>
        public static SyncLock TryAcquire(string dir, out string heldBy)
        {
            heldBy = null;
            var path = Path.Combine(dir, LockFileName);
            var lockObj = TryCreate(path);
            if (lockObj != null) return lockObj;
            // Existiert bereits. Halter ermitteln und ggf. verwaiste Datei uebernehmen.
            heldBy = ReadOwner(path);
            if (IsStale(path))
            {
                try { File.Delete(path); } // scheitert, wenn der Halter noch lebt (Handle offen)
                catch { return null; }
                return TryCreate(path);
            }
            return null;
        }
        private static SyncLock TryCreate(string path)
        {
            try
            {
                var fs = new FileStream(path, FileMode.CreateNew, FileAccess.Write, FileShare.None);
                var info = $"{Environment.MachineName}|{Environment.UserName}|{DateTime.UtcNow:o}|pid{GetPid()}";
                var bytes = Encoding.UTF8.GetBytes(info);
                fs.Write(bytes, 0, bytes.Length);
                fs.Flush();
                return new SyncLock(path, fs);
            }
            catch (IOException) { return null; }          // existiert schon
            catch (UnauthorizedAccessException) { return null; }
        }
        private static int GetPid()
        {
            try { return Process.GetCurrentProcess().Id; } catch { return 0; }
        }
        private static string ReadOwner(string path)
        {
            try
            {
                // Eigene Freigabe, falls der Halter die Datei nur zum Schreiben offen hat.
                using (var fs = new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.ReadWrite))
                using (var sr = new StreamReader(fs))
                {
                    var raw = sr.ReadToEnd();
                    var parts = raw.Split('|');
                    return parts.Length >= 1 ? parts[0] : null;
                }
            }
            catch { return null; }
        }
        private static bool IsStale(string path)
        {
            try
            {
                var age = DateTime.UtcNow - File.GetLastWriteTimeUtc(path);
                return age > StaleAfter;
            }
            catch { return false; }
        }
        public void Dispose()
        {
            try { _stream?.Dispose(); } catch { }
            _stream = null;
            if (!string.IsNullOrEmpty(_path))
            {
                try { File.Delete(_path); } catch { }
            }
        }
    }
 }
@@ -7,9 +7,9 @@
    <AssemblyTitle>Starface Outlook Sync</AssemblyTitle>
    <Company>HackerSoft - Hacker-Net Telekommunikation</Company>
    <Product>Starface Outlook Sync</Product>
-    <Version>0.0.0.11</Version>
+    <Version>0.0.0.30</Version>
-    <AssemblyVersion>0.0.0.11</AssemblyVersion>
+    <AssemblyVersion>0.0.0.30</AssemblyVersion>
-    <FileVersion>0.0.0.11</FileVersion>
+    <FileVersion>0.0.0.30</FileVersion>
    <Description>Synchronisiert Outlook-Kontakte mit Starface Telefonanlage</Description>
    <Copyright>Stefan Hacker - HackerSoft</Copyright>
    <RuntimeIdentifier>win-x64</RuntimeIdentifier>
@@ -27,7 +27,7 @@ namespace StarfaceOutlookSync.UI
            var lblVersion = new Label
            {
-                Text = "Version 0.0.0.11",
+                Text = "Version 0.0.0.30",
                Left = 0, Top = 56, Width = 340, Height = 20,
                TextAlign = ContentAlignment.MiddleCenter,
                ForeColor = Color.Gray
@@ -0,0 +1,108 @@
 using System;
 using System.Drawing;
 using System.Drawing.Drawing2D;
 namespace StarfaceOutlookSync.UI
 {
    /// <summary>
    /// Generiert das App-Icon programmatisch (Kontakt-Symbol mit Sync-Pfeilen).
    /// Kein externes ICO-File noetig.
    /// </summary>
    public static class AppIcon
    {
        private static Icon _icon;
        public static Icon GetIcon()
        {
            if (_icon != null) return _icon;
            _icon = CreateIcon(32);
            return _icon;
        }
        public static Icon GetSmallIcon()
        {
            return CreateIcon(16);
        }
        private static Icon CreateIcon(int size)
        {
            using (var bmp = new Bitmap(size, size))
            using (var g = Graphics.FromImage(bmp))
            {
                g.SmoothingMode = SmoothingMode.AntiAlias;
                g.Clear(Color.Transparent);
                if (size >= 32)
                    DrawIcon32(g);
                else
                    DrawIcon16(g);
                return Icon.FromHandle(bmp.GetHicon());
            }
        }
        private static void DrawIcon32(Graphics g)
        {
            // Hintergrund: abgerundetes Quadrat
            using (var bgBrush = new SolidBrush(Color.FromArgb(0, 120, 212)))
            {
                FillRoundedRect(g, bgBrush, 0, 0, 31, 31, 6);
            }
            // Person (Kopf)
            using (var whiteBrush = new SolidBrush(Color.White))
            {
                g.FillEllipse(whiteBrush, 11, 4, 10, 10);
                // Person (Koerper)
                g.FillPie(whiteBrush, 6, 14, 20, 18, 180, 180);
            }
            // Sync-Pfeile unten rechts
            using (var arrowPen = new Pen(Color.FromArgb(120, 255, 120), 2f))
            {
                arrowPen.StartCap = LineCap.Round;
                arrowPen.EndCap = LineCap.ArrowAnchor;
                // Pfeil rechts
                g.DrawArc(arrowPen, 20, 22, 10, 8, 200, 140);
                arrowPen.Color = Color.FromArgb(255, 200, 80);
                // Pfeil links
                g.DrawArc(arrowPen, 20, 22, 10, 8, 20, 140);
            }
        }
        private static void DrawIcon16(Graphics g)
        {
            // Hintergrund
            using (var bgBrush = new SolidBrush(Color.FromArgb(0, 120, 212)))
            {
                FillRoundedRect(g, bgBrush, 0, 0, 15, 15, 3);
            }
            // Person (vereinfacht)
            using (var whiteBrush = new SolidBrush(Color.White))
            {
                g.FillEllipse(whiteBrush, 4, 1, 7, 7);
                g.FillPie(whiteBrush, 2, 8, 12, 10, 180, 180);
            }
            // Kleiner Sync-Indikator
            using (var dotBrush = new SolidBrush(Color.FromArgb(120, 255, 120)))
            {
                g.FillEllipse(dotBrush, 11, 11, 4, 4);
            }
        }
        private static void FillRoundedRect(Graphics g, Brush brush, int x, int y, int w, int h, int r)
        {
            using (var path = new GraphicsPath())
            {
                path.AddArc(x, y, r * 2, r * 2, 180, 90);
                path.AddArc(x + w - r * 2, y, r * 2, r * 2, 270, 90);
                path.AddArc(x + w - r * 2, y + h - r * 2, r * 2, r * 2, 0, 90);
                path.AddArc(x, y + h - r * 2, r * 2, r * 2, 90, 90);
                path.CloseFigure();
                g.FillPath(brush, path);
            }
        }
    }
 }
@@ -0,0 +1,92 @@
 using System;
 using System.Diagnostics;
 using System.Drawing;
 using System.IO;
 using System.Windows.Forms;
 using StarfaceOutlookSync.Models;
 using StarfaceOutlookSync.Services;
 namespace StarfaceOutlookSync.UI
 {
    /// <summary>Zeigt das Sync-Protokoll an (read-only) mit Aktualisieren/Leeren.</summary>
    public class LogViewerForm : Form
    {
        private TextBox _txt;
        private Button _btnClose;
        private Panel _panel;
        public LogViewerForm()
        {
            Text = "Protokoll";
            Size = new Size(720, 500);
            StartPosition = FormStartPosition.CenterParent;
            Font = new Font("Segoe UI", 9);
            _txt = new TextBox
            {
                Multiline = true,
                ReadOnly = true,
                ScrollBars = ScrollBars.Both,
                WordWrap = false,
                Dock = DockStyle.Fill,
                BackColor = Color.White,
                Font = new Font("Consolas", 9)
            };
            _panel = new Panel { Dock = DockStyle.Bottom, Height = 44 };
            var btnRefresh = new Button { Text = "Aktualisieren", Left = 10, Top = 8, Width = 100, Height = 28 };
            btnRefresh.Click += (s, e) => LoadLog();
            var btnClear = new Button { Text = "Leeren", Left = 118, Top = 8, Width = 80, Height = 28 };
            btnClear.Click += (s, e) =>
            {
                if (MessageBox.Show("Protokoll wirklich leeren?", "Protokoll",
                        MessageBoxButtons.YesNo, MessageBoxIcon.Question) == DialogResult.Yes)
                {
                    Logger.Clear();
                    LoadLog();
                }
            };
            var btnFolder = new Button { Text = "Ordner oeffnen", Left = 206, Top = 8, Width = 120, Height = 28 };
            btnFolder.Click += (s, e) => OpenFolder();
            _btnClose = new Button
            {
                Text = "Schliessen", Top = 8, Width = 100, Height = 28,
                Anchor = AnchorStyles.Top | AnchorStyles.Right
            };
            _btnClose.Click += (s, e) => Close();
            _panel.Controls.AddRange(new Control[] { btnRefresh, btnClear, btnFolder, _btnClose });
            Controls.Add(_txt);
            Controls.Add(_panel);
            Load += (s, e) =>
            {
                _btnClose.Left = _panel.ClientSize.Width - _btnClose.Width - 10;
                LoadLog();
            };
        }
        private void LoadLog()
        {
            Logger.PruneOlderThan(UserSettings.Load().LogRetentionDays);
            _txt.Text = Logger.ReadAll();
            _txt.SelectionStart = _txt.TextLength;
            _txt.ScrollToCaret();
        }
        private void OpenFolder()
        {
            try
            {
                var dir = Path.GetDirectoryName(Logger.LogFilePath);
                Process.Start(new ProcessStartInfo { FileName = dir, UseShellExecute = true });
            }
            catch { }
        }
    }
 }
@@ -15,14 +15,19 @@ namespace StarfaceOutlookSync.UI
    {
        private readonly ProfileManager _profileManager = new ProfileManager();
        private readonly SyncEngine _syncEngine = new SyncEngine();
        private readonly SyncCoordinator _coordinator = new SyncCoordinator();
        private NotifyIcon _trayIcon;
        private ContextMenuStrip _trayMenu;
        private ListView _profileList;
-        private Button _btnNew, _btnEdit, _btnDelete, _btnSync, _btnSettings, _btnInfo;
+        private Button _btnNew, _btnEdit, _btnDelete, _btnSync, _btnReset, _btnSettings, _btnLog, _btnInfo;
        private StatusStrip _statusBar;
        private ToolStripStatusLabel _statusLabel;
        private Timer _autoSyncTimer;
        // Aktive Benachrichtigungs-Einstellung (pro Sync-Lauf gesetzt).
        private bool _notifyGeneral = true;
        private bool _notifyWarn = true;
        public MainForm()
        {
            InitializeComponent();
@@ -30,14 +35,34 @@ namespace StarfaceOutlookSync.UI
            SetupAutoSync();
            RefreshProfileList();
-            // Minimiert starten falls in Einstellungen aktiviert
+            // Einstellungen laden und anwenden
            var settings = UserSettings.Load();
            settings.ApplyOutlookSecuritySetting();
            // Protokoll bei Bedarf auf das eingestellte Alter eindampfen.
            Logger.PruneOlderThan(settings.LogRetentionDays);
            if (settings.StartMinimized)
            {
                WindowState = FormWindowState.Minimized;
                ShowInTaskbar = false;
                Visible = false;
            }
            // Beim Start automatisch synchronisieren
            if (settings.SyncOnStart)
            {
                _ = SyncAllProfiles();
            }
        }
        private async Task SyncAllProfiles()
        {
            var profiles = _profileManager.GetProfiles().Where(p => p.Enabled).ToList();
            foreach (var profile in profiles)
            {
                await RunSync(profile);
            }
        }
        protected override void SetVisibleCore(bool value)
@@ -58,10 +83,11 @@ namespace StarfaceOutlookSync.UI
        private void InitializeComponent()
        {
            Text = "Starface Kontakt-Sync";
-            Size = new Size(620, 450);
+            Size = new Size(830, 450);
-            MinimumSize = new Size(500, 350);
+            MinimumSize = new Size(830, 350);
            StartPosition = FormStartPosition.CenterScreen;
            Font = new Font("Segoe UI", 9);
            Icon = AppIcon.GetIcon();
            // Profil-Liste
            _profileList = new ListView
@@ -97,16 +123,22 @@ namespace StarfaceOutlookSync.UI
            _btnDelete = new Button { Text = "Loeschen", Width = 80, Height = 30 };
            _btnDelete.Click += (s, e) => DeleteProfile();
-            _btnSync = new Button { Text = "Jetzt synchronisieren", Width = 150, Height = 30 };
+            _btnSync = new Button { Text = "Synchronisieren", Width = 110, Height = 30 };
            _btnSync.Click += async (s, e) => await SyncSelectedProfile();
-            _btnSettings = new Button { Text = "Einstellungen", Width = 100, Height = 30 };
+            _btnReset = new Button { Text = "Sync Reset", Width = 80, Height = 30 };
            _btnReset.Click += (s, e) => ResetSync();
            _btnSettings = new Button { Text = "Einstellungen", Width = 95, Height = 30 };
            _btnSettings.Click += (s, e) => ShowSettings();
            _btnLog = new Button { Text = "Protokoll", Width = 80, Height = 30 };
            _btnLog.Click += (s, e) => ShowLog();
            _btnInfo = new Button { Text = "Info", Width = 50, Height = 30 };
            _btnInfo.Click += (s, e) => ShowAbout();
-            buttonPanel.Controls.AddRange(new Control[] { _btnNew, _btnEdit, _btnDelete, _btnSync, _btnSettings, _btnInfo });
+            buttonPanel.Controls.AddRange(new Control[] { _btnNew, _btnEdit, _btnDelete, _btnSync, _btnReset, _btnSettings, _btnLog, _btnInfo });
            // Statusbar
            _statusBar = new StatusStrip();
@@ -121,10 +153,26 @@ namespace StarfaceOutlookSync.UI
        private void SetupTrayIcon()
        {
            _trayMenu = new ContextMenuStrip();
            _trayIcon = new NotifyIcon
            {
                Text = "Starface Kontakt-Sync",
                Icon = AppIcon.GetSmallIcon(),
                ContextMenuStrip = _trayMenu,
                Visible = true
            };
            _trayIcon.DoubleClick += (s, e) => ShowMainWindow();
            UpdateTrayMenu();
        }
        private void UpdateTrayMenu()
        {
            _trayMenu.Items.Clear();
            _trayMenu.Items.Add("Oeffnen", null, (s, e) => ShowMainWindow());
            _trayMenu.Items.Add("-");
            // Schnell-Sync fuer jedes Profil
            var profiles = _profileManager.GetProfiles();
            foreach (var p in profiles.Where(p => p.Enabled))
            {
@@ -138,17 +186,8 @@ namespace StarfaceOutlookSync.UI
            if (profiles.Any(p => p.Enabled))
                _trayMenu.Items.Add("-");
            _trayMenu.Items.Add("Ueber", null, (s, e) => ShowAbout());
            _trayMenu.Items.Add("Beenden", null, (s, e) => ExitApplication());
            _trayIcon = new NotifyIcon
            {
                Text = "Starface Kontakt-Sync",
                Icon = SystemIcons.Application, // Placeholder, wird durch eigenes Icon ersetzt
                ContextMenuStrip = _trayMenu,
                Visible = true
            };
            _trayIcon.DoubleClick += (s, e) => ShowMainWindow();
        }
        private void SetupAutoSync()
@@ -216,7 +255,7 @@ namespace StarfaceOutlookSync.UI
            }
            // Tray-Menu aktualisieren
-            SetupTrayIcon();
+            UpdateTrayMenu();
        }
        private void NewProfile()
@@ -255,6 +294,36 @@ namespace StarfaceOutlookSync.UI
            }
        }
        private void ResetSync()
        {
            if (_profileList.SelectedItems.Count == 0)
            {
                MessageBox.Show("Bitte ein Profil auswaehlen.", "Sync Reset",
                    MessageBoxButtons.OK, MessageBoxIcon.Information);
                return;
            }
            var profile = _profileList.SelectedItems[0].Tag as SyncProfile;
            if (profile == null) return;
            var msg = $"Sync-Zuordnungen fuer '{profile.Name}' zuruecksetzen?\n\n" +
                      "Alle Kontakt-Verknuepfungen werden geloescht.\n" +
                      "Beim naechsten Sync werden die Kontakte neu abgeglichen.\n" +
                      "Es werden keine Kontakte geloescht.";
            if (MessageBox.Show(msg, "Sync Reset",
                MessageBoxButtons.YesNo, MessageBoxIcon.Warning) == DialogResult.Yes)
            {
                _profileManager.SaveMappings(profile.Id, new List<SyncMapping>());
                // LastSync auch zuruecksetzen
                profile.LastSync = "";
                _profileManager.UpdateProfile(profile);
                RefreshProfileList();
                MessageBox.Show("Sync-Zuordnungen wurden zurueckgesetzt.",
                    "Sync Reset", MessageBoxButtons.OK, MessageBoxIcon.Information);
            }
        }
        private Task SyncSelectedProfile()
        {
            if (_profileList.SelectedItems.Count == 0)
@@ -278,30 +347,85 @@ namespace StarfaceOutlookSync.UI
        private async Task RunSync(SyncProfile profile)
        {
            var settings = UserSettings.Load();
            _notifyGeneral = settings.NotificationsEnabled;
            _notifyWarn = settings.NotifyWarningsErrors;
            try
            {
-                SetStatus($"Synchronisiere '{profile.Name}'...");
+                // Lokaler Guard, Lock-Datei, Konflikt-Notizen und Protokoll laufen
-                _trayIcon.ShowBalloonTip(2000, "Starface Sync",
+                // zentral im Coordinator (gemeinsam mit dem manuellen Sync-Pfad).
-                    $"Synchronisiere '{profile.Name}'...", ToolTipIcon.Info);
+                var outcome = await _coordinator.RunAsync(
                    profile,
                    runEngine: () => _syncEngine.SyncProfileAsync(profile),
                    status: SetStatus);
-                var result = await _syncEngine.SyncProfileAsync(profile);
+                if (outcome.Skipped)
                {
                    SetStatus(outcome.SkipReason);
                    return;
                }
                // Konflikt-Hinweise anderer Arbeitsplaetze als Tray-Meldung (falls aktiv).
                ShowRemoteNoticesTray(outcome.RemoteNotices);
                if (outcome.Error != null)
                {
                    Balloon(3000, "Starface Sync Fehler", outcome.Error.Message, ToolTipIcon.Error, warn: true);
                    SetStatus($"Fehler: {outcome.Error.Message}");
                    return;
                }
                var result = outcome.Result;
                var msg = $"{profile.Name}: {result.Created} erstellt, {result.Updated} aktualisiert";
                if (result.Errors > 0) msg += $", {result.Errors} Fehler";
                if (result.Conflicts.Count > 0) msg += $", {result.Conflicts.Count} Konflikt(e)";
-                _trayIcon.ShowBalloonTip(3000, "Starface Sync", msg,
+                // Zusammenfassung als Warnung werten, wenn Fehler/Konflikte auftraten.
-                    result.Errors > 0 ? ToolTipIcon.Warning : ToolTipIcon.Info);
+                bool noteworthy = result.Errors > 0 || result.Conflicts.Count > 0;
                Balloon(3000, "Starface Sync", msg,
                    result.Errors > 0 ? ToolTipIcon.Warning : ToolTipIcon.Info, warn: noteworthy);
                // Echte Feld-Konflikte gesondert melden (eigener Wert wurde ueberschrieben).
                if (result.Conflicts.Count > 0)
                {
                    var detail = string.Join("\n", result.Conflicts.Take(5).Select(c => c.ToString()));
                    if (result.Conflicts.Count > 5)
                        detail += $"\n... und {result.Conflicts.Count - 5} weitere";
                    Balloon(10000, $"Konflikt bei {result.Conflicts.Count} Kontakt(en)", detail, ToolTipIcon.Warning, warn: true);
                }
                SetStatus(msg);
            }
            catch (Exception ex)
            {
-                _trayIcon.ShowBalloonTip(3000, "Starface Sync Fehler",
+                Balloon(3000, "Starface Sync Fehler", ex.Message, ToolTipIcon.Error, warn: true);
                    ex.Message, ToolTipIcon.Error);
                SetStatus($"Fehler: {ex.Message}");
                Logger.Log($"Sync FEHLER '{profile.Name}': {ex.Message}");
            }
        }
        /// <summary>Zeigt Konflikt-Hinweise anderer Arbeitsplaetze als Tray-Meldung.</summary>
        private void ShowRemoteNoticesTray(System.Collections.Generic.List<ConflictNotice> notices)
        {
            if (notices == null || notices.Count == 0) return;
            var detail = string.Join("\n", notices.Take(5).Select(p => p.ToString()));
            if (notices.Count > 5)
                detail += $"\n... und {notices.Count - 5} weitere";
            Balloon(10000, $"Konflikt an anderem Arbeitsplatz ({notices.Count})", detail, ToolTipIcon.Warning, warn: true);
        }
        /// <summary>
        /// Zeigt eine Tray-Meldung - aber nur, wenn die passende Benachrichtigungs-
        /// Einstellung aktiv ist. warn=true -> Warnungen/Fehler (Konflikte, Fehler),
        /// warn=false -> allgemeine Info-Meldungen.
        /// </summary>
        private void Balloon(int ms, string title, string text, ToolTipIcon icon, bool warn)
        {
            bool allow = warn ? _notifyWarn : _notifyGeneral;
            if (allow) _trayIcon.ShowBalloonTip(ms, title, text, icon);
        }
        private void SetStatus(string text)
        {
            if (InvokeRequired)
@@ -326,6 +450,14 @@ namespace StarfaceOutlookSync.UI
            }
        }
        private void ShowLog()
        {
            using (var log = new LogViewerForm())
            {
                log.ShowDialog(this);
            }
        }
        private void ExitApplication()
        {
            _autoSyncTimer?.Stop();
@@ -22,6 +22,7 @@ namespace StarfaceOutlookSync.UI
        private NumericUpDown _numAutoSync;
        private Button _btnTest, _btnLoadBooks, _btnSave, _btnCancel;
        private Label _lblTestResult;
        private Label _lblDirectionHint;
        private List<StarfaceAddressBook> _addressBooks = new List<StarfaceAddressBook>();
        private List<string> _outlookFolderPaths = new List<string>();
@@ -101,7 +102,18 @@ namespace StarfaceOutlookSync.UI
            _cmbDirection = new ComboBox { Left = 12, Top = y, Width = 250, DropDownStyle = ComboBoxStyle.DropDownList };
            _cmbDirection.Items.AddRange(new object[] { "Bidirektional", "Outlook -> Starface", "Starface -> Outlook" });
            _cmbDirection.SelectedIndex = 0;
-            panel.Controls.Add(_cmbDirection); y += 32;
+            panel.Controls.Add(_cmbDirection); y += 28;
            _lblDirectionHint = new Label
            {
                Left = 12, Top = y, Width = 360, Height = 32,
                ForeColor = Color.FromArgb(150, 80, 0),
                Font = new Font("Segoe UI", 8.25f)
            };
            _cmbDirection.SelectedIndexChanged += (s, e) => UpdateDirectionHint();
            panel.Controls.Add(_lblDirectionHint);
            UpdateDirectionHint();
            y += 36;
            panel.Controls.Add(MakeLabel("Auto-Sync Intervall (Minuten, 0 = manuell):", 12, y)); y += 22;
            _numAutoSync = new NumericUpDown { Left = 12, Top = y, Width = 80, Minimum = 0, Maximum = 1440, Value = 0 };
@@ -122,6 +134,22 @@ namespace StarfaceOutlookSync.UI
            CancelButton = _btnCancel;
        }
        private void UpdateDirectionHint()
        {
            switch (_cmbDirection.SelectedIndex)
            {
                case 1: // Outlook -> Starface
                    _lblDirectionHint.Text = "Achtung: Das Starface-Adressbuch wird zur exakten Kopie von Outlook.\nKontakte, die nur in Starface existieren, werden geloescht.";
                    break;
                case 2: // Starface -> Outlook
                    _lblDirectionHint.Text = "Achtung: Der Outlook-Ordner wird zur exakten Kopie von Starface.\nKontakte, die nur in Outlook existieren, werden geloescht.";
                    break;
                default: // Bidirektional
                    _lblDirectionHint.Text = "Aenderungen werden in beide Richtungen abgeglichen.";
                    break;
            }
        }
        private Label MakeLabel(string text, int x, int y)
        {
            return new Label { Text = text, Left = x, Top = y, AutoSize = true };
@@ -333,9 +361,23 @@ namespace StarfaceOutlookSync.UI
            };
            if (_isNew)
            {
                _pm.AddProfile(profile);
            }
            else
            {
                // Wenn Adressbuch gewechselt wurde, Mappings zuruecksetzen
                if (_existingProfile.StarfaceAddressBook?.TagId != profile.StarfaceAddressBook?.TagId
                    || _existingProfile.StarfaceAddressBook?.Type != profile.StarfaceAddressBook?.Type)
                {
                    _pm.SaveMappings(profile.Id, new List<SyncMapping>());
                    profile.LastSync = "";
                    MessageBox.Show(
                        "Adressbuch wurde geaendert.\nSync-Zuordnungen wurden automatisch zurueckgesetzt.",
                        "Adressbuch geaendert", MessageBoxButtons.OK, MessageBoxIcon.Information);
                }
                _pm.UpdateProfile(profile);
            }
            DialogResult = DialogResult.OK;
            Close();
@@ -1,12 +1,18 @@
 using System.Drawing;
 using System.Windows.Forms;
 using StarfaceOutlookSync.Models;
 using StarfaceOutlookSync.Services;
 namespace StarfaceOutlookSync.UI
 {
    public class SettingsForm : Form
    {
-        private CheckBox _chkStartMinimized;
+        private CheckBox _chkStartMinimized, _chkSyncOnStart, _chkAutoAcceptOutlook;
        private CheckBox _chkNotifGeneral, _chkNotifWarn;
        private CheckBox _chkAutostartUser, _chkAutostartAll;
        private NumericUpDown _numLogRetention;
        private TextBox _txtSharedDir;
        private Button _btnBrowseShared;
        private Button _btnSave, _btnCancel;
        private readonly UserSettings _settings;
@@ -19,7 +25,7 @@ namespace StarfaceOutlookSync.UI
        private void InitializeComponent()
        {
            Text = "Einstellungen";
-            Size = new Size(350, 180);
+            Size = new Size(380, 250);
            FormBorderStyle = FormBorderStyle.FixedDialog;
            MaximizeBox = false;
            MinimizeBox = false;
@@ -33,28 +39,168 @@ namespace StarfaceOutlookSync.UI
                Checked = _settings.StartMinimized
            };
            _chkSyncOnStart = new CheckBox
            {
                Text = "Beim Start automatisch synchronisieren",
                Left = 20, Top = 52, AutoSize = true,
                Checked = _settings.SyncOnStart
            };
            _chkAutoAcceptOutlook = new CheckBox
            {
                Text = "Outlook-Sicherheitsabfrage automatisch erlauben",
                Left = 20, Top = 80, AutoSize = true,
                Checked = _settings.AutoAcceptOutlookPrompt
            };
            var hintText = "Hinweis: Outlook muss nach Aenderung neu gestartet werden.";
            if (UserSettings.IsOutlookSecurityLockedByPolicy())
                hintText += "\nAuf Domaenen-PCs: App einmalig als Admin starten!";
            var lblHint = new Label
            {
                Text = hintText,
                Left = 38, Top = 102, Width = 320, Height = 36,
                ForeColor = UserSettings.IsOutlookSecurityLockedByPolicy() ? Color.OrangeRed : Color.Gray,
                Font = new Font("Segoe UI", 8)
            };
            _chkNotifGeneral = new CheckBox
            {
                Text = "Tray-Benachrichtigungen (allgemein)",
                Left = 20, Top = 144, AutoSize = true,
                Checked = _settings.NotificationsEnabled
            };
            _chkNotifWarn = new CheckBox
            {
                Text = "Benachrichtigungen bei Warnungen/Fehlern (Konflikte, Fehler)",
                Left = 20, Top = 170, AutoSize = true,
                Checked = _settings.NotifyWarningsErrors
            };
            var lblLogRetention = new Label
            {
                Text = "Protokoll auto-leeren - Eintraege aelter als (Tage, 0 = aus):",
                Left = 20, Top = 204, AutoSize = true
            };
            _numLogRetention = new NumericUpDown
            {
                Left = 305, Top = 200, Width = 55, Minimum = 0, Maximum = 3650,
                Value = System.Math.Max(0, System.Math.Min(3650, _settings.LogRetentionDays))
            };
            var lblShared = new Label
            {
                Text = "Gemeinsames Verzeichnis fuer Sync-Sperre (Mehrplatz, optional):",
                Left = 20, Top = 240, AutoSize = true
            };
            _txtSharedDir = new TextBox
            {
                Left = 20, Top = 262, Width = 250,
                Text = _settings.SharedDirectory
            };
            _btnBrowseShared = new Button
            {
                Text = "...", Left = 274, Top = 261, Width = 36, Height = 24
            };
            _btnBrowseShared.Click += (s, e) => BrowseSharedDir();
            var lblSharedHint = new Label
            {
                Text = "Netzlaufwerk/UNC, das alle Arbeitsplaetze erreichen. Leer = keine\n" +
                       "clientuebergreifende Sperre (nur Schutz auf diesem PC).",
                Left = 20, Top = 288, Width = 330, Height = 32,
                ForeColor = Color.Gray, Font = new Font("Segoe UI", 8)
            };
            // === Autostart ===
            bool isAdmin = AutostartManager.IsAdmin();
            var lblAutostart = new Label
            {
                Text = "Autostart (bei Windows-Anmeldung starten)",
                Left = 12, Top = 332, AutoSize = true, Font = new Font("Segoe UI", 10, FontStyle.Bold)
            };
            _chkAutostartUser = new CheckBox
            {
                Text = "Nur fuer diesen Benutzer",
                Left = 20, Top = 360, AutoSize = true,
                Checked = AutostartManager.GetUserAutostart()
            };
            _chkAutostartAll = new CheckBox
            {
                Text = "Fuer alle Benutzer" + (isAdmin ? "" : " (nur mit Admin-Rechten aenderbar)"),
                Left = 20, Top = 386, AutoSize = true,
                Checked = AutostartManager.GetMachineAutostart(),
                Enabled = isAdmin
            };
            _btnSave = new Button
            {
-                Text = "Speichern", Left = 80, Top = 100, Width = 85, Height = 28,
+                Text = "Speichern", Left = 95, Top = 422, Width = 85, Height = 28,
                DialogResult = DialogResult.None
            };
            _btnSave.Click += (s, e) => Save();
            _btnCancel = new Button
            {
-                Text = "Abbrechen", Left = 174, Top = 100, Width = 85, Height = 28,
+                Text = "Abbrechen", Left = 189, Top = 422, Width = 85, Height = 28,
                DialogResult = DialogResult.Cancel
            };
-            Controls.AddRange(new Control[] { _chkStartMinimized, _btnSave, _btnCancel });
+            Size = new Size(380, 512);
            Controls.AddRange(new Control[] { _chkStartMinimized, _chkSyncOnStart, _chkAutoAcceptOutlook, lblHint,
                _chkNotifGeneral, _chkNotifWarn, lblLogRetention, _numLogRetention,
                lblShared, _txtSharedDir, _btnBrowseShared, lblSharedHint,
                lblAutostart, _chkAutostartUser, _chkAutostartAll, _btnSave, _btnCancel });
            AcceptButton = _btnSave;
            CancelButton = _btnCancel;
        }
        private void BrowseSharedDir()
        {
            using (var dlg = new FolderBrowserDialog())
            {
                dlg.Description = "Gemeinsames Verzeichnis fuer die Sync-Sperre waehlen";
                if (!string.IsNullOrWhiteSpace(_txtSharedDir.Text))
                {
                    try { dlg.SelectedPath = _txtSharedDir.Text; } catch { }
                }
                if (dlg.ShowDialog(this) == DialogResult.OK)
                    _txtSharedDir.Text = dlg.SelectedPath;
            }
        }
        private void Save()
        {
            _settings.StartMinimized = _chkStartMinimized.Checked;
            _settings.SyncOnStart = _chkSyncOnStart.Checked;
            _settings.AutoAcceptOutlookPrompt = _chkAutoAcceptOutlook.Checked;
            _settings.NotificationsEnabled = _chkNotifGeneral.Checked;
            _settings.NotifyWarningsErrors = _chkNotifWarn.Checked;
            _settings.LogRetentionDays = (int)_numLogRetention.Value;
            _settings.SharedDirectory = _txtSharedDir.Text.Trim();
            _settings.Save();
            // Sofort anwenden, damit der Effekt direkt sichtbar ist.
            Logger.PruneOlderThan(_settings.LogRetentionDays);
            // Autostart (Registry). Pro Benutzer immer; alle Benutzer nur mit Admin.
            AutostartManager.SetUserAutostart(_chkAutostartUser.Checked);
            if (AutostartManager.IsAdmin())
            {
                if (!AutostartManager.SetMachineAutostart(_chkAutostartAll.Checked))
                    MessageBox.Show(this,
                        "Autostart fuer alle Benutzer konnte nicht geaendert werden (Rechte?).",
                        "Autostart", MessageBoxButtons.OK, MessageBoxIcon.Warning);
            }
            DialogResult = DialogResult.OK;
            Close();
        }
@@ -11,6 +11,7 @@ namespace StarfaceOutlookSync.UI
    {
        private readonly SyncProfile _profile;
        private readonly SyncEngine _engine = new SyncEngine();
        private readonly SyncCoordinator _coordinator = new SyncCoordinator();
        private TextBox _txtLog;
        private ProgressBar _progressBar;
        private Button _btnClose, _btnStart;
@@ -41,7 +42,8 @@ namespace StarfaceOutlookSync.UI
            _progressBar = new ProgressBar
            {
                Left = 12, Top = 38, Width = 460, Height = 22,
-                Style = ProgressBarStyle.Marquee
+                Style = ProgressBarStyle.Blocks,
                Value = 0
            };
            _txtLog = new TextBox
@@ -91,19 +93,46 @@ namespace StarfaceOutlookSync.UI
            _progressBar.Style = ProgressBarStyle.Marquee;
            _lblResult.Text = "";
-            _engine.OnProgress += AppendLog;
+            // Engine-Aufruf inkl. Live-Log: laeuft im Hintergrund, damit das
-
+            // Fenster reagiert. Guard/Lock/Notizen/Protokoll uebernimmt der
-            try
+            // Coordinator (gemeinsam mit dem Auto-/Tray-Sync).
            Func<Task<SyncResult>> runEngine = async () =>
            {
-                var result = await Task.Run(() => _engine.SyncProfileAsync(_profile));
+                _engine.OnProgress += AppendLog;
                try { return await Task.Run(() => _engine.SyncProfileAsync(_profile)); }
                finally { _engine.OnProgress -= AppendLog; }
            };
            var outcome = await _coordinator.RunAsync(_profile, runEngine, status: AppendLog);
            _progressBar.Style = ProgressBarStyle.Blocks;
            _progressBar.Value = 100;
-                var resultText = $"Erstellt: {result.Created}  |  Aktualisiert: {result.Updated}  |  Fehler: {result.Errors}";
+            if (outcome.Skipped)
-                _lblResult.Text = resultText;
+            {
                _lblResult.Text = outcome.SkipReason;
                _lblResult.ForeColor = Color.OrangeRed;
                AppendLog(outcome.SkipReason);
            }
            else if (outcome.Error != null)
            {
                _lblResult.Text = $"Fehler: {outcome.Error.Message}";
                _lblResult.ForeColor = Color.Red;
                AppendLog($"FEHLER: {outcome.Error.Message}");
            }
            else
            {
                var result = outcome.Result;
                _lblResult.Text = $"Erstellt: {result.Created}  |  Aktualisiert: {result.Updated}  |  Fehler: {result.Errors}";
                _lblResult.ForeColor = result.Errors > 0 ? Color.OrangeRed : Color.Green;
                // Konflikt-Hinweise anderer Arbeitsplaetze im Fenster zeigen.
                foreach (var n in outcome.RemoteNotices)
                    AppendLog($"Konflikt an anderem Arbeitsplatz: {n}");
                foreach (var c in result.Conflicts)
                    AppendLog($"KONFLIKT: {c}");
                if (result.ErrorMessages.Count > 0)
                {
                    AppendLog("--- Fehler ---");
@@ -111,14 +140,7 @@ namespace StarfaceOutlookSync.UI
                        AppendLog(err);
                }
            }
            catch (Exception ex)
            {
                _lblResult.Text = $"Fehler: {ex.Message}";
                _lblResult.ForeColor = Color.Red;
                AppendLog($"FEHLER: {ex.Message}");
            }
            _engine.OnProgress -= AppendLog;
            _btnStart.Enabled = true;
            _btnStart.Text = "Erneut synchronisieren";
            _btnClose.Enabled = true;