Fix critical delete bug: don't mass-delete on EntryID change

Two fixes for delete propagation in Phase 1:

1. When Outlook contact not found by EntryID, try to re-match
   by name/email/phone before assuming it was deleted. Outlook
   can change EntryIDs on restart or profile changes, causing
   the sync to think ALL contacts were deleted.

2. When Starface contact not found in current list, DON'T delete
   from Outlook. The contact may belong to a different address
   book. Just drop the mapping and let Phase 2/3 re-link it.

These changes make delete propagation much safer and prevent
accidental mass-deletion of contacts.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

README.md

@@ -42,6 +42,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.

installer/setup.iss

@@ -2,7 +2,7 @@
 ; Erfordert Inno Setup 6.x (https://jrsoftware.org/isinfo.php)
 
 #define MyAppName "Starface Outlook Sync"
-#define MyAppVersion "0.0.0.15"
+#define MyAppVersion "0.0.0.23"
 #define MyAppPublisher "HackerSoft - Hacker-Net Telekommunikation"
 #define MyAppURL "https://www.hacker-net.de"
 #define MyAppExeName "StarfaceOutlookSync.exe"

src/StarfaceOutlookSync/Models/UserSettings.cs

@@ -1,5 +1,6 @@
 using System;
 using System.IO;
+using Microsoft.Win32;
 using Newtonsoft.Json;
 
 namespace StarfaceOutlookSync.Models
@@ -7,6 +8,8 @@ namespace StarfaceOutlookSync.Models
     public class UserSettings
     {
         public bool StartMinimized { get; set; } = false;
+        public bool SyncOnStart { get; set; } = false;
+        public bool AutoAcceptOutlookPrompt { get; set; } = false;
 
         private static readonly string SettingsFile = Path.Combine(
             Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData),
@@ -32,6 +35,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;
         }
     }
 }

src/StarfaceOutlookSync/Services/OutlookContactsService.cs

@@ -394,29 +394,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 ?? ""),
-                FirstName = (string)(ci.FirstName ?? ""),
-                LastName = (string)(ci.LastName ?? ""),
-                Company = (string)(ci.CompanyName ?? ""),
-                JobTitle = (string)(ci.JobTitle ?? ""),
-                Email = (string)(ci.Email1Address ?? ""),
-                EmailSecondary = (string)(ci.Email2Address ?? ""),
-                PhoneWork = (string)(ci.BusinessTelephoneNumber ?? ""),
-                PhoneMobile = (string)(ci.MobileTelephoneNumber ?? ""),
-                PhoneHome = (string)(ci.HomeTelephoneNumber ?? ""),
-                Fax = (string)(ci.BusinessFaxNumber ?? ""),
-                Street = (string)(ci.BusinessAddressStreet ?? ""),
-                City = (string)(ci.BusinessAddressCity ?? ""),
-                PostalCode = (string)(ci.BusinessAddressPostalCode ?? ""),
-                State = (string)(ci.BusinessAddressState ?? ""),
-                Country = (string)(ci.BusinessAddressCountry ?? ""),
-                Website = (string)(ci.WebPage ?? ""),
-                Notes = (string)(ci.Body ?? ""),
-                Salutation = (string)(ci.Title ?? ""),
+                OutlookEntryId = SafeGet(ci, "EntryID"),
+                FirstName = SafeGet(ci, "FirstName"),
+                LastName = SafeGet(ci, "LastName"),
+                Company = SafeGet(ci, "CompanyName"),
+                JobTitle = SafeGet(ci, "JobTitle"),
+                Email = SafeGet(ci, "Email1Address"),
+                EmailSecondary = SafeGet(ci, "Email2Address"),
+                PhoneWork = SafeGet(ci, "BusinessTelephoneNumber"),
+                PhoneMobile = SafeGet(ci, "MobileTelephoneNumber"),
+                PhoneHome = SafeGet(ci, "HomeTelephoneNumber"),
+                Fax = SafeGet(ci, "BusinessFaxNumber"),
+                Street = SafeGet(ci, "BusinessAddressStreet"),
+                City = SafeGet(ci, "BusinessAddressCity"),
+                PostalCode = SafeGet(ci, "BusinessAddressPostalCode"),
+                State = SafeGet(ci, "BusinessAddressState"),
+                Country = SafeGet(ci, "BusinessAddressCountry"),
+                Website = SafeGet(ci, "WebPage"),
+                Notes = SafeGet(ci, "Body"),
+                Salutation = SafeGet(ci, "Title"),
                 Birthday = GetBirthdayString(ci)
             };
         }
@@ -425,8 +436,9 @@ namespace StarfaceOutlookSync.Services
         {
             try
             {
-                DateTime bday = ci.Birthday;
-                if (bday.Year > 1900 && bday != DateTime.MinValue)
+                object val = ci.GetType().InvokeMember("Birthday",
+                    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 { }

src/StarfaceOutlookSync/Services/StarfaceApiClient.cs

@@ -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,43 +116,63 @@ namespace StarfaceOutlookSync.Services
         {
             var books = new List<StarfaceAddressBook>();
 
-            books.Add(new StarfaceAddressBook
-            {
-                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
+            // Alle Tags laden - die Starface nutzt Tags als Adressbuch-Zuordnung
+            var allTags = new JArray();
             try
             {
                 var resp = await _http.GetAsync($"{_baseUrl}/contacts/tags");
                 if (resp.IsSuccessStatusCode)
                 {
-                    var tags = JArray.Parse(await resp.Content.ReadAsStringAsync());
-                    foreach (var tag in tags)
-                    {
-                        books.Add(new StarfaceAddressBook
-                        {
-                            Type = "tag",
-                            TagId = tag["id"]?.ToString() ?? "",
-                            Name = $"Tag: {tag["name"]}"
-                        });
-                    }
+                    allTags = JArray.Parse(await resp.Content.ReadAsStringAsync());
+                    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 = tagName
+                });
+            }
+
             return books;
         }
 
@@ -248,6 +269,16 @@ namespace StarfaceOutlookSync.Services
         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}";
@@ -273,12 +304,27 @@ namespace StarfaceOutlookSync.Services
         {
             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);
+
+            if (!resp.IsSuccessStatusCode)
+            {
+                var respBody = await resp.Content.ReadAsStringAsync();
+                OnDebug?.Invoke($"PUT /contacts/{contactId} fehlgeschlagen: {(int)resp.StatusCode}\n{respBody}");
+            }
+
             return resp.IsSuccessStatusCode;
         }
 

src/StarfaceOutlookSync/Services/SyncEngine.cs

@@ -17,61 +17,94 @@ namespace StarfaceOutlookSync.Services
 
         /// <summary>
         /// Findet einen passenden Kontakt in der Kandidatenliste.
-        /// Matching-Reihenfolge: E-Mail, dann Vorname+Nachname+Firma, dann Vorname+Nachname.
+        /// 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;
 
-            // 1. Exakte E-Mail
-            if (!string.IsNullOrEmpty(contact.Email))
+            foreach (var c in candidates)
             {
-                var byEmail = candidates.FirstOrDefault(c =>
-                    !string.IsNullOrEmpty(c.Email) &&
-                    c.Email.Equals(contact.Email, StringComparison.OrdinalIgnoreCase));
-                if (byEmail != null) return byEmail;
-            }
-
-            // 2. Vorname + Nachname + Firma (staerkstes Match ohne E-Mail)
-            if ((!string.IsNullOrEmpty(contact.FirstName) || !string.IsNullOrEmpty(contact.LastName))
-                && !string.IsNullOrEmpty(contact.Company))
-            {
-                var byNameCompany = candidates.FirstOrDefault(c =>
-                    c.FirstName.Equals(contact.FirstName, StringComparison.OrdinalIgnoreCase) &&
-                    c.LastName.Equals(contact.LastName, StringComparison.OrdinalIgnoreCase) &&
-                    c.Company.Equals(contact.Company, StringComparison.OrdinalIgnoreCase));
-                if (byNameCompany != null) return byNameCompany;
-            }
-
-            // 3. Vorname + Nachname (ohne Firma)
-            if (!string.IsNullOrEmpty(contact.FirstName) || !string.IsNullOrEmpty(contact.LastName))
-            {
-                var byName = candidates.FirstOrDefault(c =>
-                    c.FirstName.Equals(contact.FirstName, StringComparison.OrdinalIgnoreCase) &&
-                    c.LastName.Equals(contact.LastName, StringComparison.OrdinalIgnoreCase) &&
-                    (!string.IsNullOrEmpty(c.FirstName) || !string.IsNullOrEmpty(c.LastName)));
-                if (byName != null) return byName;
-            }
-
-            // 4. Telefonnummer (Buero oder Mobil)
-            if (!string.IsNullOrEmpty(contact.PhoneWork))
-            {
-                var byPhone = candidates.FirstOrDefault(c =>
-                    !string.IsNullOrEmpty(c.PhoneWork) &&
-                    NormalizePhone(c.PhoneWork) == NormalizePhone(contact.PhoneWork));
-                if (byPhone != null) return byPhone;
-            }
-            if (!string.IsNullOrEmpty(contact.PhoneMobile))
-            {
-                var byMobile = candidates.FirstOrDefault(c =>
-                    !string.IsNullOrEmpty(c.PhoneMobile) &&
-                    NormalizePhone(c.PhoneMobile) == NormalizePhone(contact.PhoneMobile));
-                if (byMobile != null) return byMobile;
+                if (IsMatch(contact, c))
+                    return c;
             }
 
             return null;
         }
 
+        private static bool IsMatch(UnifiedContact a, UnifiedContact b)
+        {
+            // Mindestens ein identifizierendes Feld muss vorhanden sein
+            bool hasName = !string.IsNullOrEmpty(a.FirstName) || !string.IsNullOrEmpty(a.LastName);
+            bool hasEmail = !string.IsNullOrEmpty(a.Email);
+            bool hasPhone = !string.IsNullOrEmpty(a.PhoneWork) || !string.IsNullOrEmpty(a.PhoneMobile);
+
+            if (!hasName && !hasEmail && !hasPhone) return false;
+
+            // E-Mail: wenn auf beiden Seiten vorhanden, muss sie gleich sein
+            // Wenn nur auf einer Seite vorhanden -> kein Match
+            if (!FieldsCompatible(a.Email, b.Email)) return false;
+
+            // Name: wenn auf einer Seite vorhanden, muss er gleich sein
+            if (!FieldsCompatible(a.FirstName, b.FirstName)) return false;
+            if (!FieldsCompatible(a.LastName, b.LastName)) return false;
+
+            // Firma: wenn auf einer Seite vorhanden, muss sie gleich sein
+            // Leere Firma vs. gefuellte Firma = verschiedene Kontakte
+            if (!FieldsCompatible(a.Company, b.Company)) return false;
+
+            // Telefon/Fax: wenn auf einer Seite vorhanden, muss es gleich sein
+            if (!PhoneFieldsCompatible(a.PhoneWork, b.PhoneWork)) return false;
+            if (!PhoneFieldsCompatible(a.PhoneMobile, b.PhoneMobile)) return false;
+            if (!PhoneFieldsCompatible(a.PhoneHome, b.PhoneHome)) return false;
+            if (!PhoneFieldsCompatible(a.Fax, b.Fax)) return false;
+
+            // Mindestens ein starkes Match muss vorhanden sein
+            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)
+                             && (!string.IsNullOrEmpty(a.FirstName) || !string.IsNullOrEmpty(a.LastName));
+            bool phoneMatch = (!string.IsNullOrEmpty(a.PhoneWork) && !string.IsNullOrEmpty(b.PhoneWork)
+                               && NormalizePhone(a.PhoneWork) == NormalizePhone(b.PhoneWork))
+                              || (!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);
+
+            // Email oder Name reicht. Telefon/Fax nur mit Firma zusammen.
+            return emailMatch || nameMatch || (phoneMatch && companyMatch) || (companyMatch && phoneMatch);
+        }
+
+        /// <summary>
+        /// Prueft ob zwei Felder kompatibel sind.
+        /// Beide leer = kompatibel. Beide gleich = kompatibel.
+        /// Eins leer, eins gefuellt = NICHT kompatibel (verschiedene Kontakte).
+        /// </summary>
+        private static bool FieldsCompatible(string a, string b)
+        {
+            bool aEmpty = string.IsNullOrEmpty(a);
+            bool bEmpty = string.IsNullOrEmpty(b);
+
+            if (aEmpty && bEmpty) return true;
+            if (aEmpty != bEmpty) return false; // Einer leer, anderer nicht
+            return a.Equals(b, StringComparison.OrdinalIgnoreCase);
+        }
+
+        private static bool PhoneFieldsCompatible(string a, string b)
+        {
+            bool aEmpty = string.IsNullOrEmpty(a);
+            bool bEmpty = string.IsNullOrEmpty(b);
+
+            if (aEmpty && bEmpty) return true;
+            if (aEmpty != bEmpty) return false;
+            return NormalizePhone(a) == NormalizePhone(b);
+        }
+
         private static string NormalizePhone(string phone)
         {
             if (string.IsNullOrEmpty(phone)) return "";
@@ -144,6 +177,50 @@ namespace StarfaceOutlookSync.Services
                         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 geloescht -> in Starface auch loeschen
+                            if (profile.SyncDirection == SyncDirection.Both || profile.SyncDirection == SyncDirection.OutlookToStarface)
+                            {
+                                if (await starface.DeleteContactAsync(mapping.StarfaceId))
+                                {
+                                    result.Updated++;
+                                    Log($"  Geloescht (OL->SF): {sc.DisplayName}");
+                                }
+                            }
+                            else
+                            {
+                                newMappings.Add(mapping);
+                            }
+                            continue;
+                        }
+
+                        if (oc != null && sc == null)
+                        {
+                            // Starface-Kontakt nicht gefunden.
+                            // Kann passieren wenn der Kontakt einem anderen Adressbuch gehoert.
+                            // NICHT loeschen, nur Mapping entfernen - wird in Phase 2/3 neu verknuepft
+                            Log($"  Starface-Kontakt nicht in Liste (anderes Adressbuch?): {oc.DisplayName}");
+                            // Mapping verwerfen, Outlook-Kontakt als unverarbeitet belassen
+                            // damit er in Phase 2 neu zugeordnet oder erstellt werden kann
                             continue;
                         }
 

src/StarfaceOutlookSync/StarfaceOutlookSync.csproj

@@ -7,9 +7,9 @@
     <AssemblyTitle>Starface Outlook Sync</AssemblyTitle>
     <Company>HackerSoft - Hacker-Net Telekommunikation</Company>
     <Product>Starface Outlook Sync</Product>
-    <Version>0.0.0.15</Version>
-    <AssemblyVersion>0.0.0.15</AssemblyVersion>
-    <FileVersion>0.0.0.15</FileVersion>
+    <Version>0.0.0.23</Version>
+    <AssemblyVersion>0.0.0.23</AssemblyVersion>
+    <FileVersion>0.0.0.23</FileVersion>
     <Description>Synchronisiert Outlook-Kontakte mit Starface Telefonanlage</Description>
     <Copyright>Stefan Hacker - HackerSoft</Copyright>
     <RuntimeIdentifier>win-x64</RuntimeIdentifier>

src/StarfaceOutlookSync/UI/AboutForm.cs

@@ -27,7 +27,7 @@ namespace StarfaceOutlookSync.UI
 
             var lblVersion = new Label
             {
-                Text = "Version 0.0.0.15",
+                Text = "Version 0.0.0.23",
                 Left = 0, Top = 56, Width = 340, Height = 20,
                 TextAlign = ContentAlignment.MiddleCenter,
                 ForeColor = Color.Gray

src/StarfaceOutlookSync/UI/MainForm.cs

@@ -22,6 +22,7 @@ namespace StarfaceOutlookSync.UI
         private StatusStrip _statusBar;
         private ToolStripStatusLabel _statusLabel;
         private Timer _autoSyncTimer;
+        private volatile bool _syncRunning = false;
 
         public MainForm()
         {
@@ -30,14 +31,31 @@ namespace StarfaceOutlookSync.UI
             SetupAutoSync();
             RefreshProfileList();
 
-            // Minimiert starten falls in Einstellungen aktiviert
+            // Einstellungen laden und anwenden
             var settings = UserSettings.Load();
+            settings.ApplyOutlookSecuritySetting();
+
             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,8 +76,8 @@ namespace StarfaceOutlookSync.UI
         private void InitializeComponent()
         {
             Text = "Starface Kontakt-Sync";
-            Size = new Size(620, 450);
-            MinimumSize = new Size(500, 350);
+            Size = new Size(830, 450);
+            MinimumSize = new Size(830, 350);
             StartPosition = FormStartPosition.CenterScreen;
             Font = new Font("Segoe UI", 9);
             Icon = AppIcon.GetIcon();
@@ -158,6 +176,7 @@ 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());
         }
 
@@ -318,6 +337,13 @@ namespace StarfaceOutlookSync.UI
 
         private async Task RunSync(SyncProfile profile)
         {
+            if (_syncRunning)
+            {
+                SetStatus("Sync laeuft bereits, bitte warten...");
+                return;
+            }
+
+            _syncRunning = true;
             try
             {
                 SetStatus($"Synchronisiere '{profile.Name}'...");
@@ -340,6 +366,10 @@ namespace StarfaceOutlookSync.UI
                     ex.Message, ToolTipIcon.Error);
                 SetStatus($"Fehler: {ex.Message}");
             }
+            finally
+            {
+                _syncRunning = false;
+            }
         }
 
         private void SetStatus(string text)

src/StarfaceOutlookSync/UI/ProfileEditorForm.cs

@@ -333,9 +333,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();

src/StarfaceOutlookSync/UI/SettingsForm.cs

@@ -6,7 +6,7 @@ namespace StarfaceOutlookSync.UI
 {
     public class SettingsForm : Form
     {
-        private CheckBox _chkStartMinimized;
+        private CheckBox _chkStartMinimized, _chkSyncOnStart, _chkAutoAcceptOutlook;
         private Button _btnSave, _btnCancel;
         private readonly UserSettings _settings;
 
@@ -19,7 +19,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,20 +33,47 @@ 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 = 310, Height = 36,
+                ForeColor = UserSettings.IsOutlookSecurityLockedByPolicy() ? Color.OrangeRed : Color.Gray,
+                Font = new Font("Segoe UI", 8)
+            };
+
             _btnSave = new Button
             {
-                Text = "Speichern", Left = 80, Top = 100, Width = 85, Height = 28,
+                Text = "Speichern", Left = 95, Top = 170, 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 = 170, Width = 85, Height = 28,
                 DialogResult = DialogResult.Cancel
             };
 
-            Controls.AddRange(new Control[] { _chkStartMinimized, _btnSave, _btnCancel });
+            Size = new Size(380, 260);
+            Controls.AddRange(new Control[] { _chkStartMinimized, _chkSyncOnStart, _chkAutoAcceptOutlook, lblHint, _btnSave, _btnCancel });
             AcceptButton = _btnSave;
             CancelButton = _btnCancel;
         }
@@ -54,6 +81,8 @@ namespace StarfaceOutlookSync.UI
         private void Save()
         {
             _settings.StartMinimized = _chkStartMinimized.Checked;
+            _settings.SyncOnStart = _chkSyncOnStart.Checked;
+            _settings.AutoAcceptOutlookPrompt = _chkAutoAcceptOutlook.Checked;
             _settings.Save();
             DialogResult = DialogResult.OK;
             Close();