fix(core): address Copilot review comments

- Fix PID parse index in CleanupOldTempDirectories (index 2, not 3)
- Wrap all DeleteDirectory enumeration in try/catch for concurrent-safety
- Extract directory name in ShouldSkipDirectory to handle both bare names and full paths
- Update Option.cs GetOrAdd comment to note factory may run multiple times under contention
- Dispose Process handle with 'using' in GracefulExit.CurrentProcessAsync
- Guard PreParseVersions against duplicate keys from custom IDownloadSource implementations

Co-authored-by: Claude <noreply@anthropic.com>

Author: JusterZhu

src/c#/GeneralUpdate.Core/Configuration/Option.cs

@@ -69,9 +69,9 @@ protected Option(string name)
         /// <exception cref="ArgumentNullException">Thrown when <paramref name="name" /> is <c>null</c>.</exception>
         public static Option<T> ValueOf<T>(string name, T defaultValue = default!)
         {
-            // GetOrAdd is lock-free on ConcurrentDictionary; the factory runs at most once per key.
-            // First registration wins — subsequent calls with the same name return the existing
-            // singleton instance (preserving the original default value).
+            // GetOrAdd is lock-free on ConcurrentDictionary. Under contention the
+            // factory may run multiple times, but only one instance is stored and
+            // returned by all racing callers. The factory must be side-effect-free.
             var raw = _registry.GetOrAdd(name, _ => new Option<T>(name, defaultValue));
 
             // If the existing entry was registered with a different type T, create a new one.

src/c#/GeneralUpdate.Core/Download/DownloadPlanBuilder.cs

@@ -86,9 +86,15 @@ public static bool HasUpdate(
     /// <summary>Pre-parses versions for a list of assets to avoid repeated Semver.TryParse calls.</summary>
     private static Dictionary<DownloadAsset, SemVersion?> PreParseVersions(IEnumerable<DownloadAsset> assets)
     {
-        return assets.ToDictionary(
-            a => a,
-            a => ParseVersion(a.Version));
+        var map = new Dictionary<DownloadAsset, SemVersion?>();
+        foreach (var a in assets)
+        {
+            // Custom IDownloadSource implementations could return duplicate records;
+            // silently accept the first occurrence rather than throwing.
+            if (!map.ContainsKey(a))
+                map[a] = ParseVersion(a.Version);
+        }
+        return map;
     }
 
     /// <summary>

src/c#/GeneralUpdate.Core/FileSystem/BlackMatcher.cs

@@ -95,9 +95,16 @@ public bool IsBlacklistedFormat(string extension)
     /// Uses case-insensitive substring containment matching (<c>string.IndexOf</c>) for evaluation.
     /// The directory is considered skippable if its name contains any string from the <c>Directories</c> list.
     /// </remarks>
-    public bool ShouldSkipDirectory(string directoryName)
-        => _config.Directories?.Any(d =>
-            directoryName.StartsWith(d, StringComparison.OrdinalIgnoreCase)) == true;
+    public bool ShouldSkipDirectory(string directoryOrPath)
+    {
+        // Extract the directory name from a possible full path so both
+        // bare names ("backup-2026") and full paths (".backups/backup-2026") work.
+        var dirName = Path.GetFileName(directoryOrPath.TrimEnd(Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar));
+        if (string.IsNullOrEmpty(dirName)) return false;
+
+        return _config.Directories?.Any(d =>
+            dirName.StartsWith(d, StringComparison.OrdinalIgnoreCase)) == true;
+    }
 
     /// <summary>
     /// Matches a file name against a simple Glob pattern.

src/c#/GeneralUpdate.Core/FileSystem/StorageManager.cs

@@ -248,9 +248,10 @@ public static void CleanupOldTempDirectories(TimeSpan? maxAge = null)
                         var dirName = dirInfo.Name;
 
                         // Parse timestamp from "generalupdate_yyyy-MM-dd-HHmmss-fff_PID_name"
+                        // Splitting by '_': [0]=prefix, [1]=timestamp, [2]=PID, [3..]=name.
                         // If the PID segment matches the current process, skip it.
                         var parts = dirName.Split('_');
-                        if (parts.Length >= 4 && int.TryParse(parts[3], out var pid) && pid == currentPid)
+                        if (parts.Length >= 3 && int.TryParse(parts[2], out var pid) && pid == currentPid)
                             continue;
 
                         if (dirInfo.CreationTimeUtc < cutoff)
@@ -346,42 +347,58 @@ public static void DeleteDirectory(string targetDir)
             // Enumerate then delete with per-item exception handling.
             // Between enumeration and deletion, concurrent processes may add/remove
             // files — handle these races gracefully instead of crashing.
-            foreach (var file in Directory.GetFiles(targetDir))
+            try
             {
+                foreach (var file in Directory.GetFiles(targetDir))
+                {
+                    try
+                    {
+                        File.SetAttributes(file, FileAttributes.Normal);
+                        File.Delete(file);
+                    }
+                    catch (FileNotFoundException) { /* raced away — already deleted */ }
+                    catch (DirectoryNotFoundException) { /* raced away */ }
+                    catch (UnauthorizedAccessException ex)
+                    {
+                        GeneralTracer.Warn($"StorageManager.DeleteDirectory: cannot delete file '{Path.GetFileName(file)}': {ex.Message}");
+                    }
+                }
+
                 try
                 {
-                    File.SetAttributes(file, FileAttributes.Normal);
-                    File.Delete(file);
+                    foreach (var dir in Directory.GetDirectories(targetDir))
+                    {
+                        try
+                        {
+                            DeleteDirectory(dir);
+                        }
+                        catch (DirectoryNotFoundException) { /* raced away */ }
+                        catch (UnauthorizedAccessException ex)
+                        {
+                            GeneralTracer.Warn($"StorageManager.DeleteDirectory: cannot delete directory '{Path.GetFileName(dir)}': {ex.Message}");
+                        }
+                    }
                 }
-                catch (FileNotFoundException) { /* raced away — already deleted */ }
-                catch (DirectoryNotFoundException) { /* raced away */ }
+                catch (DirectoryNotFoundException) { /* parent raced away */ }
                 catch (UnauthorizedAccessException ex)
                 {
-                    GeneralTracer.Warn($"StorageManager.DeleteDirectory: cannot delete file '{Path.GetFileName(file)}': {ex.Message}");
+                    GeneralTracer.Warn($"StorageManager.DeleteDirectory: cannot enumerate subdirectories: {ex.Message}");
                 }
-            }
 
-            foreach (var dir in Directory.GetDirectories(targetDir))
-            {
                 try
                 {
-                    DeleteDirectory(dir);
+                    Directory.Delete(targetDir, false);
                 }
                 catch (DirectoryNotFoundException) { /* raced away */ }
                 catch (UnauthorizedAccessException ex)
                 {
-                    GeneralTracer.Warn($"StorageManager.DeleteDirectory: cannot delete directory '{Path.GetFileName(dir)}': {ex.Message}");
+                    GeneralTracer.Warn($"StorageManager.DeleteDirectory: cannot delete directory '{Path.GetFileName(targetDir)}': {ex.Message}");
                 }
             }
-
-            try
-            {
-                Directory.Delete(targetDir, false);
-            }
-            catch (DirectoryNotFoundException) { /* raced away */ }
+            catch (DirectoryNotFoundException) { /* parent raced away before enumeration */ }
             catch (UnauthorizedAccessException ex)
             {
-                GeneralTracer.Warn($"StorageManager.DeleteDirectory: cannot delete directory '{Path.GetFileName(targetDir)}': {ex.Message}");
+                GeneralTracer.Warn($"StorageManager.DeleteDirectory: cannot enumerate '{targetDir}': {ex.Message}");
             }
         }
 

src/c#/GeneralUpdate.Core/GracefulExit.cs

@@ -61,7 +61,7 @@ public static Task CurrentProcessAsync(int timeoutMs = 3000)
             // a no-op, but the process will exit when the async call stack unwinds.
             if (Environment.OSVersion.Platform == PlatformID.Win32NT)
             {
-                var p = Process.GetCurrentProcess();
+                using var p = Process.GetCurrentProcess();
                 if (!p.HasExited)
                     p.CloseMainWindow();
             }