fix(issue-6): round-5 — delete key, restart flow, single-line resx, data annotations

Fixes the four items from the v0.7.15 test report plus bugs found in review.

VS Code extension:
- Delete key was a silent no-op: native confirm() is blocked in webviews and
  the message omitted resourceGroup. Replace with a custom confirm modal, thread
  resourceGroup through, and reload the grid on success. Harden escapeJs to also
  HTML-encode &/</>/quotes so keys with those chars can't break the onclick.
- "Restart Backend" reported false success: gate the success notification on an
  actual post-restart health check (statusBar.update() now returns bool;
  add LrmService.isHealthy()).
- Edit modal ignored resourceGroup in multi-group projects: thread group through
  translateKey/getKeyDetails/saveEditedKey and key the details cache by group.
- Stale ApiClient after restart (new port): repoint StatusBar, Dashboard,
  Settings and ResourceEditor panels via setApiClient/refreshClients at both the
  restart and resource-path-change sites.
- lrmService.stop() no longer accumulates exit listeners (once() + captured ref).

Core / API:
- New .resx <data> entries were serialized single-line; normalize whitespace and
  re-indent on save so they match the standard multi-line format (all surfaces).
- Detect localization keys in Data Annotation attributes
  ([Display(Name=..., ResourceType=typeof(...))], ErrorMessageResourceName/Type):
  new DataAnnotationExtractor, KeyReference.ResourceTypeClassName, group-aware
  missing-key resolution in CodeScanner, and ResourceTypeClassName in the API
  CodeReference + referenceProvider patterns.

Tests: resx multi-line format, data-annotation extraction + scanner (single and
multi group), delete/get/update controller coverage (single and multi group),
deleteKeyMessage, backendHealth, escapeJs round-trip/injection, stale-client
swap, and a real-binary restart integration test (skips in CI when unbundled).

Author: nickprotop

Controllers/ScanController.cs

@@ -80,7 +80,8 @@ public ActionResult<ScanResponse> Scan([FromBody] ScanRequest? request)
                         File = r.FilePath,
                         Line = r.Line,
                         Pattern = r.Pattern,
-                        Confidence = r.Confidence.ToString()
+                        Confidence = r.Confidence.ToString(),
+                        ResourceTypeClassName = r.ResourceTypeClassName
                     }).ToList()
                 }).ToList()
             });
@@ -159,7 +160,8 @@ public ActionResult<ScanResponse> ScanFile([FromBody] FileScanRequest request)
                         File = r.FilePath,
                         Line = r.Line,
                         Pattern = r.Pattern,
-                        Confidence = r.Confidence.ToString()
+                        Confidence = r.Confidence.ToString(),
+                        ResourceTypeClassName = r.ResourceTypeClassName
                     }).ToList()
                 }).ToList()
             });
@@ -279,7 +281,8 @@ public ActionResult<KeyReferencesResponse> GetReferences(string keyName)
                     File = r.FilePath,
                     Line = r.Line,
                     Pattern = r.Pattern,
-                    Confidence = r.Confidence.ToString()
+                    Confidence = r.Confidence.ToString(),
+                    ResourceTypeClassName = r.ResourceTypeClassName
                 }).ToList()
             });
         }

LocalizationManager.Core/Backends/Resx/ResxResourceWriter.cs

@@ -80,11 +80,18 @@ public void Write(ResourceFile file)
                 WriteWithUniqueKeys(root, file.Entries);
             }
 
-            // Save with proper formatting using atomic write to prevent file corruption
+            // Save with proper formatting using atomic write to prevent file corruption.
+            // We re-indent the whole document on save (via NormalizeWhitespace) so newly
+            // added <data> elements get the same multi-line layout as existing/hand-edited
+            // entries instead of being collapsed onto a single line (issue #6). The
+            // standard .resx layout is 2-space indentation, which is idempotent for
+            // already-formatted files.
+            NormalizeWhitespace(xdoc.Root!);
+
             var tempPath = file.Language.FilePath + $".tmp.{Guid.NewGuid()}";
             try
             {
-                xdoc.Save(tempPath);
+                SaveIndented(xdoc, tempPath);
                 File.Move(tempPath, file.Language.FilePath, overwrite: true);
             }
             finally
@@ -196,7 +203,24 @@ public string SerializeToString(ResourceFile file)
             root.Add(CreateDataElement(entry));
         }
 
-        return xdoc.Declaration + Environment.NewLine + xdoc.ToString();
+        // Re-indent so new entries are multi-line (issue #6), consistent with Write().
+        NormalizeWhitespace(root);
+
+        var settings = new XmlWriterSettings
+        {
+            Indent = true,
+            IndentChars = "  ",
+            NewLineChars = "\n",
+            OmitXmlDeclaration = false
+        };
+        // Use a UTF-8-reporting writer so the emitted declaration keeps encoding="utf-8"
+        // (a plain StringWriter would force encoding="utf-16"), matching the on-disk file.
+        using var sw = new Utf8StringWriter();
+        using (var writer = XmlWriter.Create(sw, settings))
+        {
+            xdoc.Save(writer);
+        }
+        return sw.ToString();
     }
 
     /// <summary>
@@ -330,6 +354,53 @@ private static void UpdateDataElement(XElement dataElement, ResourceEntry entry)
         }
     }
 
+    /// <summary>
+    /// Removes whitespace-only text nodes that sit between elements so the document can
+    /// be cleanly re-indented on save. Without this, existing files keep their original
+    /// whitespace text nodes while newly-added elements have none, producing a mix of
+    /// multi-line and single-line entries (issue #6). Text content inside a leaf element
+    /// (e.g. the actual value text) is left untouched.
+    /// </summary>
+    private static void NormalizeWhitespace(XElement element)
+    {
+        // Only strip inter-element whitespace from container elements (those that have
+        // child elements). Leaf elements like <value> hold the real text and are left as-is.
+        if (element.HasElements)
+        {
+            foreach (var text in element.Nodes().OfType<XText>().ToList())
+            {
+                if (string.IsNullOrWhiteSpace(text.Value))
+                {
+                    text.Remove();
+                }
+            }
+
+            foreach (var child in element.Elements())
+            {
+                NormalizeWhitespace(child);
+            }
+        }
+    }
+
+    /// <summary>
+    /// Saves the document with consistent 2-space indentation, preserving the
+    /// declaration. Mirrors the layout produced by the standard .resx writer.
+    /// </summary>
+    private static void SaveIndented(XDocument xdoc, string path)
+    {
+        var settings = new XmlWriterSettings
+        {
+            Indent = true,
+            IndentChars = "  ",
+            Encoding = new System.Text.UTF8Encoding(encoderShouldEmitUTF8Identifier: false),
+            NewLineChars = "\n",
+            OmitXmlDeclaration = false
+        };
+
+        using var writer = XmlWriter.Create(path, settings);
+        xdoc.Save(writer);
+    }
+
     /// <summary>
     /// Creates a new data element for an entry.
     /// </summary>
@@ -388,4 +459,13 @@ private static bool IsValidCultureCode(string code, out CultureInfo? culture)
             return false;
         }
     }
+
+    /// <summary>
+    /// StringWriter that reports UTF-8 as its encoding so XmlWriter emits
+    /// <c>encoding="utf-8"</c> in the declaration instead of the default utf-16.
+    /// </summary>
+    private sealed class Utf8StringWriter : StringWriter
+    {
+        public override System.Text.Encoding Encoding => System.Text.Encoding.UTF8;
+    }
 }

LocalizationManager.Core/Scanning/CodeScanner.cs

@@ -51,6 +51,7 @@ public ScanResult Scan(
 
         // Get all keys from resource files
         var resourceKeys = GetAllResourceKeys(resourceFiles);
+        var keysByGroup = GetKeysByGroup(resourceFiles);
 
         // Discover source files
         var allExtensions = _scanners.SelectMany(s => s.SupportedExtensions).Distinct();
@@ -87,7 +88,7 @@ public ScanResult Scan(
                 Key = key,
                 ReferenceCount = references.Count,
                 References = references,
-                ExistsInResources = resourceKeys.Contains(key),
+                ExistsInResources = KeyExists(references, key, resourceKeys, keysByGroup),
                 DefinedInLanguages = GetLanguagesForKey(resourceFiles, key)
             };
 
@@ -158,6 +159,7 @@ public ScanResult ScanSingleFile(
 
         // Get all keys from resource files
         var resourceKeys = GetAllResourceKeys(resourceFiles);
+        var keysByGroup = GetKeysByGroup(resourceFiles);
 
         // Detect file type and get appropriate scanner
         var extension = Path.GetExtension(filePath);
@@ -200,7 +202,7 @@ public ScanResult ScanSingleFile(
                     Key = key,
                     ReferenceCount = references.Count,
                     References = references,
-                    ExistsInResources = resourceKeys.Contains(key),
+                    ExistsInResources = KeyExists(references, key, resourceKeys, keysByGroup),
                     DefinedInLanguages = GetLanguagesForKey(resourceFiles, key)
                 };
 
@@ -276,6 +278,7 @@ public ScanResult ScanSingleFileContent(
 
         // Get all keys from resource files
         var resourceKeys = GetAllResourceKeys(resourceFiles);
+        var keysByGroup = GetKeysByGroup(resourceFiles);
 
         // Detect file type and get appropriate scanner
         var extension = Path.GetExtension(filePath);
@@ -317,7 +320,7 @@ public ScanResult ScanSingleFileContent(
                     Key = key,
                     ReferenceCount = references.Count,
                     References = references,
-                    ExistsInResources = resourceKeys.Contains(key),
+                    ExistsInResources = KeyExists(references, key, resourceKeys, keysByGroup),
                     DefinedInLanguages = GetLanguagesForKey(resourceFiles, key)
                 };
 
@@ -523,6 +526,81 @@ private HashSet<string> GetAllResourceKeys(List<ResourceFile> resourceFiles)
             StringComparer.OrdinalIgnoreCase);
     }
 
+    /// <summary>
+    /// Builds a map of resource-group BaseName -> set of keys defined in that group's
+    /// default file(s). Used to resolve Data Annotation references that name a specific
+    /// <c>ResourceType</c> against the correct group rather than the global union.
+    /// </summary>
+    private static Dictionary<string, HashSet<string>> GetKeysByGroup(List<ResourceFile> resourceFiles)
+    {
+        var map = new Dictionary<string, HashSet<string>>(StringComparer.OrdinalIgnoreCase);
+
+        var defaultFiles = resourceFiles.Where(f => f.Language.IsDefault).ToList();
+        if (defaultFiles.Count == 0)
+            defaultFiles = resourceFiles;
+
+        foreach (var file in defaultFiles)
+        {
+            var baseName = file.Language.BaseName;
+            if (string.IsNullOrEmpty(baseName))
+                continue;
+
+            if (!map.TryGetValue(baseName, out var set))
+            {
+                set = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
+                map[baseName] = set;
+            }
+
+            foreach (var entry in file.Entries)
+                set.Add(entry.Key);
+        }
+
+        return map;
+    }
+
+    /// <summary>
+    /// Decides whether a key group exists in resources. References that name a
+    /// specific <c>ResourceType</c> (Data Annotations) must be resolved against that
+    /// group; untyped references fall back to the global union (<paramref name="allKeys"/>).
+    /// </summary>
+    private static bool KeyExists(
+        IReadOnlyList<KeyReference> references,
+        string key,
+        HashSet<string> allKeys,
+        Dictionary<string, HashSet<string>> keysByGroup)
+    {
+        // A key can be referenced both ways at once (e.g. `Resources.K` AND a
+        // `[Display(..., ResourceType = typeof(R))]`). The key exists if ANY of its
+        // references can resolve it:
+        //  - an untyped reference resolves against the global union;
+        //  - a typed reference resolves against its own group (or the union if that
+        //    group's resx is unknown, to avoid spurious "missing" noise).
+        var hasUntyped = references.Any(r => string.IsNullOrEmpty(r.ResourceTypeClassName));
+        if (hasUntyped && allKeys.Contains(key))
+        {
+            return true;
+        }
+
+        foreach (var boundType in references
+                     .Select(r => r.ResourceTypeClassName)
+                     .Where(t => !string.IsNullOrEmpty(t))
+                     .Distinct())
+        {
+            var existsInBoundGroup = keysByGroup.TryGetValue(boundType!, out var groupKeys)
+                ? groupKeys.Contains(key)
+                : allKeys.Contains(key);
+            if (existsInBoundGroup)
+            {
+                return true;
+            }
+        }
+
+        // No reference could resolve the key. If there were only untyped references we
+        // already returned false above via the allKeys check; this also covers the
+        // all-typed case where none of the bound groups contain the key.
+        return false;
+    }
+
     private List<string> GetLanguagesForKey(List<ResourceFile> resourceFiles, string key)
     {
         var languages = new List<string>();

LocalizationManager.Core/Scanning/Models/KeyReference.cs

@@ -44,4 +44,13 @@ public class KeyReference
     /// Warning message if confidence is low
     /// </summary>
     public string? Warning { get; set; }
+
+    /// <summary>
+    /// For keys referenced via a Data Annotation attribute (e.g.
+    /// <c>[Display(Name = "K", ResourceType = typeof(GlassResources))]</c>), the
+    /// simple class name of the resource type (<c>GlassResources</c>). Maps to a
+    /// resx group's BaseName so the key can be resolved against the correct group.
+    /// Null for ordinary references that are not bound to a specific resource type.
+    /// </summary>
+    public string? ResourceTypeClassName { get; set; }
 }

LocalizationManager.Core/Scanning/Scanners/CSharpScanner.cs

@@ -69,6 +69,10 @@ public override List<KeyReference> ScanContent(
         // Scan for indexer patterns
         ScanIndexerAccess(cleanedContent, originalContent, filePath, references, injectedLocalizerVariables);
 
+        // Scan for Data Annotation attributes that name a resource key + ResourceType,
+        // e.g. [Display(Name = "K", ResourceType = typeof(GlassResources))].
+        ScanDataAnnotations(cleanedContent, filePath, references);
+
         // Scan for dynamic patterns (unless strict mode)
         if (!strictMode)
         {
@@ -198,6 +202,23 @@ private void ScanIndexerAccess(string content, string originalContent, string fi
         }
     }
 
+    private void ScanDataAnnotations(string content, string filePath, List<KeyReference> references)
+    {
+        foreach (var match in DataAnnotationExtractor.Extract(content))
+        {
+            references.Add(new KeyReference
+            {
+                Key = match.Key,
+                FilePath = filePath,
+                Line = match.Line,
+                Pattern = match.Pattern,
+                Context = match.Pattern,
+                Confidence = ConfidenceLevel.High,
+                ResourceTypeClassName = match.ResourceTypeClassName
+            });
+        }
+    }
+
     private void ScanDynamicPatterns(string content, string originalContent, string filePath, List<KeyReference> references, List<string> methodNames)
     {
         var escapedMethods = methodNames.Select(Regex.Escape);