refactor: Use git config --show-scope for reliable level detection

Context:
The original implementation inferred GitConfigurationLevel by parsing
file paths from config origins (e.g., checking if path contains
"/.gitconfig" for global). This approach is error-prone because:
- Path conventions vary across platforms and Git installations
- System config can be in multiple locations (prefix-dependent)
- Custom config paths break the path-based detection
- Worktree configs weren't handled

Justification:
Git's --show-scope flag directly reports whether each config entry is
from system, global, local, worktree, or command line scope. Using this
flag eliminates path-parsing heuristics and defers to Git's
authoritative knowledge of config scope.

Implementation:
- Replaced DetermineLevel() path-parsing logic with ParseScope() that
  maps Git's scope strings directly to GitConfigurationLevel enum
- Updated ConfigCache.Load() to parse scope field from git output
- Updated EnsureCacheLoaded() to include --show-scope flag
- ConfigCacheEntry constructor now accepts level directly

Scope parsing maps: system/global/local/worktree → enum values,
treating worktree as local (both are repository-specific).

All 52 tests pass with this change.

Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>

Author: derrickstolee

src/shared/Core/GitConfiguration.cs

@@ -117,37 +117,27 @@ internal class ConfigCacheEntry
         public string Value { get; set; }
         public GitConfigurationLevel Level { get; set; }
 
-        public ConfigCacheEntry(string origin, string value)
+        public ConfigCacheEntry(string origin, string value, GitConfigurationLevel level)
         {
             Origin = origin;
             Value = value;
-            Level = DetermineLevel(origin);
+            Level = level;
         }
 
-        private static GitConfigurationLevel DetermineLevel(string origin)
+        /// <summary>
+        /// Parse scope string from 'git config --show-scope' to GitConfigurationLevel.
+        /// </summary>
+        public static GitConfigurationLevel ParseScope(string scope)
         {
-            if (string.IsNullOrEmpty(origin))
-                return GitConfigurationLevel.Unknown;
-
-            // Origins look like: "file:/path/to/config", "command line:", "standard input:"
-            if (!origin.StartsWith("file:"))
-                return GitConfigurationLevel.Unknown;
-
-            string path = origin.Substring(5); // Remove "file:" prefix
-
-            // System config is typically in /etc/gitconfig or $(prefix)/etc/gitconfig
-            if (path.Contains("/etc/gitconfig") || path.EndsWith("/gitconfig"))
-                return GitConfigurationLevel.System;
-
-            // Global config is typically in ~/.gitconfig or ~/.config/git/config
-            if (path.Contains("/.gitconfig") || path.Contains("/.config/git/config"))
-                return GitConfigurationLevel.Global;
-
-            // Local config is typically in .git/config within a repository
-            if (path.Contains("/.git/config"))
-                return GitConfigurationLevel.Local;
-
-            return GitConfigurationLevel.Unknown;
+            return scope switch
+            {
+                "system" => GitConfigurationLevel.System,
+                "global" => GitConfigurationLevel.Global,
+                "local" => GitConfigurationLevel.Local,
+                "worktree" => GitConfigurationLevel.Local,  // Treat worktree as local
+                "command" => GitConfigurationLevel.Unknown,
+                _ => GitConfigurationLevel.Unknown
+            };
         }
     }
 
@@ -167,17 +157,36 @@ public void Load(string data, ITrace trace)
             {
                 var entries = new Dictionary<string, List<ConfigCacheEntry>>(GitConfigurationKeyComparer.Instance);
 
+                var scope = new StringBuilder();
                 var origin = new StringBuilder();
                 var key = new StringBuilder();
                 var value = new StringBuilder();
 
                 int i = 0;
                 while (i < data.Length)
                 {
+                    scope.Clear();
                     origin.Clear();
                     key.Clear();
                     value.Clear();
 
+                    // Read scope (NUL terminated)
+                    while (i < data.Length && data[i] != '\0')
+                    {
+                        scope.Append(data[i++]);
+                    }
+
+                    if (i >= data.Length)
+                    {
+                        trace.WriteLine("Invalid Git configuration output. Expected null terminator (\\0) after scope.");
+                        break;
+                    }
+
+                    // Skip the NUL terminator
+                    i++;
+
+                    GitConfigurationLevel level = ConfigCacheEntry.ParseScope(scope.ToString());
+
                     // Read origin (NUL terminated)
                     while (i < data.Length && data[i] != '\0')
                     {
@@ -224,7 +233,7 @@ public void Load(string data, ITrace trace)
                     i++;
 
                     string keyStr = key.ToString();
-                    var entry = new ConfigCacheEntry(origin.ToString(), value.ToString());
+                    var entry = new ConfigCacheEntry(origin.ToString(), value.ToString(), level);
 
                     if (!entries.ContainsKey(keyStr))
                     {
@@ -359,7 +368,7 @@ private void EnsureCacheLoaded()
             if (!_useCache || _cache.IsLoaded)
                 return;
 
-            using (ChildProcess git = _git.CreateProcess("config list --show-origin -z"))
+            using (ChildProcess git = _git.CreateProcess("config list --show-scope --show-origin -z"))
             {
                 git.Start(Trace2ProcessClass.Git);
                 // To avoid deadlocks, always read the output stream first and then wait
@@ -372,8 +381,8 @@ private void EnsureCacheLoaded()
                         _cache.Load(data, _trace);
                         break;
                     default:
-                        _trace.WriteLine($"Failed to load config cache (exit={git.ExitCode})");
-                        // Don't throw - fall back to individual commands
+                        _trace.WriteLine($"Failed to load config cache (exit={git.ExitCode}), will use individual git config commands");
+                        // Don't throw - cache stays unloaded and operations fall back to individual commands
                         break;
                 }
             }