fix(cpu): the dual-CCD panel misread a working AMD install, and recommend CPPC=Cache

Three problems in the dual-CCD dependency panel, reported from a 9950X3D with
AMD chipset drivers already installed.

Service detection probed four guessed names, two of which do not exist. The list
was "AMD3DVCacheSvc", "Amd3DVCacheSvc", "AmdV3DCacheSvc" and
"AMDProvisioningPackagesSvc"; on a real install the services are actually named
amd3dvcacheSvc and AmdPpkgSvc, so half the list could never match anything and
the fourth entry was probing the provisioning service as if it were the
optimizer. It now enumerates the service list and matches on the distinctive part
of the name or display name, which survives casing and any rename, and it reports
the name it found so the row is diagnosable instead of a dead end.

"Stopped" was reported as a fault. The optimizer installs with StartMode=Auto and
sits stopped until it has routing work, so stopped is its normal idle state --
confirmed on this machine, where it reads Stopped/Auto. The old panel told the
user to go and start it. The state is now split into Idle and Disabled, and only
Disabled is treated as unmet.

"Xbox Game Bar: unknown" came from a second, worse copy of a reader that already
existed. CpuPlanStatus read only AutoGameModeEnabled and returned null when the
value was absent, while GameModeMonitor.ReadCurrent already falls back to
AllowAutoGameMode. It now calls that one, and an absent value resolves to the
Windows default (Game Mode on) rather than "unknown". The row is also relabelled:
it reads Game Mode, not Game Bar, and said so incorrectly.

CPPC guidance now recommends Cache rather than Driver on asymmetric dual-CCD
X3D. Driver is AMD's official setting and routes dynamically, but that routing
depends on Xbox Game Bar recognising the title, which it often does not --
non-Steam launchers, emulators and older games all miss. Cache pins preferred
cores to the V-Cache CCD so routing does not depend on detection at all. It is a
tradeoff rather than a correction, so BiosRecommendation gained an Alternative
field and the panel renders Driver alongside with the reason to prefer each. The
prose in CpuPlanDetails and SettingDocsCatalog that asserted CPPC=Driver as a
hard dependency was reworded to match, and SETTINGS-REFERENCE.md regenerated.

Verified against this machine's real service list: the detector resolves
amd3dvcacheSvc / "AMD 3D V-Cache Performance Optimizer Service" as Idle, where
the old code reported Stopped and the panel said "start it". The dual-CCD panel
itself cannot be rendered here -- this is a single-CCD 9850X3D -- so the catalog
output the panel consumes is pinned by tests instead.

762 stable / 744 beta tests pass.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

Author: carterscode

docs/SETTINGS-REFERENCE.md

@@ -170,19 +170,19 @@ powercfg /setactive SCHEME_BALANCED   # restore the Balanced plan
 
 | Choice | Pro | Con |
 |---|---|---|
-| Build the optimized plan (recommended) | A Balanced clone tuned to your CPU -- aggressive boost and the right core-parking -- without High Performance's heat/boost cost. | For asymmetric dual-CCD X3D it isn't enough alone; it relies on BIOS CPPC=Driver + the AMD V-Cache service the app can't set. |
+| Build the optimized plan (recommended) | A Balanced clone tuned to your CPU -- aggressive boost and the right core-parking -- without High Performance's heat/boost cost. | For asymmetric dual-CCD X3D it isn't enough alone; it relies on the BIOS "CPPC Dynamic Preferred Cores" setting the app cannot set -- Cache pins games to the V-Cache CCD, Driver routes dynamically via the AMD V-Cache service. |
 | Keep Balanced / a stock plan | Zero setup, and fine on most modern CPUs whose own boost is already good. | Misses the per-CPU parking/boost tuning (notably for X3D chips). |
 
 **Per-scenario recommendation:**
 
 | Scenario | Setting |
 |---|---|
 | Single-CCD X3D (9850X3D / 9800X3D / 7800X3D) | Build optimized -- no parking, aggressive boost |
-| Asymmetric dual-CCD X3D (9950X3D / 7950X3D) | Build optimized -- parks frequency CCD; also verify BIOS CPPC=Driver + AMD V-Cache service + Game Bar |
+| Asymmetric dual-CCD X3D (9950X3D / 7950X3D) | Build optimized -- parks frequency CCD; also set BIOS CPPC=Cache (or Driver + the AMD V-Cache service + Game Mode) |
 | Non-X3D / Intel hybrid | Build optimized (no parking / leave Thread Director) or suggest Balanced |
 | Unknown CPU | Build optimized uses a labeled generic tune, or suggest the best prebuilt plan |
 
-**Risks.** Low. The plan is additive -- your existing Windows plans are never modified or deleted, and you can switch back at any time. For asymmetric dual-CCD X3D the power plan alone is not sufficient: it depends on the AMD CCD-routing stack (BIOS CPPC=Driver, the 3D V-Cache Optimizer service, and Xbox Game Bar), which the app surfaces but cannot set.
+**Risks.** Low. The plan is additive -- your existing Windows plans are never modified or deleted, and you can switch back at any time. For asymmetric dual-CCD X3D the power plan alone is not sufficient: which CCD a game lands on is decided by the BIOS "CPPC Dynamic Preferred Cores" setting. Cache pins games to the V-Cache CCD outright; Driver routes them dynamically and then also depends on the 3D V-Cache Optimizer service and Xbox Game Bar game-detection. The app surfaces this but cannot set it.
 
 **Command line (PowerShell):**
 

src/GamerGuardian/Models/CpuTuneDefinition.cs

@@ -20,7 +20,11 @@ public enum ParkingStrategy { Default, NoParking, ParkFrequencyCcd }
 public sealed record PowerOverride(Guid Subgroup, Guid Setting, uint Value, string Label);
 
 /// <summary>An advisory BIOS recommendation (never read or applied by the app).</summary>
-public sealed record BiosRecommendation(string Name, string RecommendedValue, string Rationale);
+/// <param name="Alternative">A second defensible value and when to prefer it, for
+/// settings where there is a real tradeoff rather than one right answer. Null when
+/// the setting has a single sensible value.</param>
+public sealed record BiosRecommendation(
+    string Name, string RecommendedValue, string Rationale, string? Alternative = null);
 
 /// <summary>
 /// One catalog entry: how to recognize a CPU class and the gaming-optimized

src/GamerGuardian/Services/CpuPlanDetails.cs

@@ -106,9 +106,11 @@ public static string Rationale(CpuTuneResult r)
             return "Your CPU has two core clusters (CCDs) but only one carries the extra 3D V-Cache "
                 + "that games benefit from. This plan parks the other, higher-frequency cluster during "
                 + "light loads so Windows keeps game threads on the cache cluster, while still unparking "
-                + "every core under heavy multi-threaded work. It depends on the AMD 3D V-Cache Optimizer "
-                + "service, Xbox Game Bar game-detection, and BIOS \"CPPC = Driver\" to route correctly "
-                + "(see the dependency checklist above).";
+                + "every core under heavy multi-threaded work. The power plan alone does not decide which "
+                + "cluster a game lands on: that comes from the BIOS setting \"CPPC Dynamic Preferred "
+                + $"Cores\". Setting it to {CpuTuneCatalog.PreferredCppcValue} pins games to the cache cluster outright; leaving it on "
+                + "Driver instead routes them dynamically and depends on the AMD 3D V-Cache Optimizer "
+                + "service plus Xbox Game Bar recognising the game (see the dependency checklist above).";
 
         if (r.IsGeneric)
             return "A conservative, safe tune: it only raises boost aggressiveness and makes no "

src/GamerGuardian/Services/CpuPlanStatus.cs

@@ -1,8 +1,34 @@
+using GamerGuardian.Monitors;
 using Microsoft.Win32;
 
 namespace GamerGuardian.Services;
 
-public enum CcdServiceState { Running, Stopped, NotFoundOrUnknown }
+/// <summary>
+/// What the app could learn about the AMD 3D V-Cache Optimizer service.
+///
+/// <para><see cref="Stopped"/> is split from <see cref="Disabled"/> deliberately.
+/// The service is installed with StartMode=Auto and sits Stopped until it has
+/// routing work to do, so "stopped" is its normal idle state and is not something
+/// the user needs to fix. Only a Disabled start mode is actually broken.</para>
+/// </summary>
+public enum CcdServiceState
+{
+    /// <summary>No service matching the optimizer was found at all.</summary>
+    NotInstalled,
+    /// <summary>Present and currently running.</summary>
+    Running,
+    /// <summary>Present, start mode is Automatic or Manual, not running right now.
+    /// This is the expected idle state, not a fault.</summary>
+    Idle,
+    /// <summary>Present but its start mode is Disabled, so it can never run.</summary>
+    Disabled,
+}
+
+/// <summary>What was found, so the UI can name it instead of guessing.</summary>
+/// <param name="State">Installed/running/idle/disabled.</param>
+/// <param name="ServiceName">The service's real name, or null when nothing matched.</param>
+/// <param name="DisplayName">Its display name, or null.</param>
+public sealed record CcdServiceInfo(CcdServiceState State, string? ServiceName, string? DisplayName);
 
 /// <summary>Status of the asymmetric dual-CCD X3D routing dependencies.</summary>
 public enum CcdDependencyStatus
@@ -18,18 +44,22 @@ public enum CcdDependencyStatus
 
 /// <summary>
 /// Pure status logic for the dual-CCD X3D dependency stack, plus best-effort
-/// readers. The app can never claim full "optimized" because BIOS CPPC=Driver is
-/// not readable from user mode — it surfaces what it can and stays honest.
+/// readers. The app can never claim full "optimized" because the BIOS CPPC setting
+/// is not readable from user mode — it surfaces what it can and stays honest.
 /// </summary>
 public static class CpuPlanStatus
 {
     /// <summary>Pure: combine the checkable signals into a status. Unit-tested.</summary>
     public static CcdDependencyStatus DependencyStatus(
         bool planActive, CcdServiceState service, bool? gameBarEnabled)
     {
-        if (service == CcdServiceState.NotFoundOrUnknown)
+        if (service == CcdServiceState.NotInstalled)
             return CcdDependencyStatus.Unknown;
-        if (!planActive || service == CcdServiceState.Stopped)
+        // A Disabled start mode is the only service state the user must act on.
+        // Idle is normal: the optimizer is demand-driven and sits stopped until a
+        // game gives it something to route. Reporting that as an unmet dependency
+        // sent people off to reinstall drivers that were already installed.
+        if (!planActive || service == CcdServiceState.Disabled)
             return CcdDependencyStatus.PartlyUnmet;
         if (gameBarEnabled == false)
             return CcdDependencyStatus.PartlyUnmet;
@@ -38,33 +68,88 @@ public static CcdDependencyStatus DependencyStatus(
 
     // ---- Best-effort readers (not unit-tested) ----
 
-    private static readonly string[] AmdServiceNames =
-        { "AMD3DVCacheSvc", "Amd3DVCacheSvc", "AmdV3DCacheSvc", "AMDProvisioningPackagesSvc" };
-
-    public static CcdServiceState ReadAmdVCacheService()
+    /// <summary>
+    /// Finds the AMD 3D V-Cache Optimizer service by enumerating the service list
+    /// and matching, rather than probing a list of guessed names.
+    ///
+    /// <para>The previous version tried four hardcoded names, two of which
+    /// ("AmdV3DCacheSvc", "AMDProvisioningPackagesSvc") do not exist on a real
+    /// install — the actual names are <c>amd3dvcacheSvc</c> and <c>AmdPpkgSvc</c>.
+    /// Any name AMD ships that a future driver renames would break it again, and the
+    /// failure mode was the worst possible one: "not detected (install AMD chipset
+    /// drivers)" on a machine where they were already installed.</para>
+    /// </summary>
+    public static CcdServiceInfo ReadAmdVCacheService()
     {
-        foreach (var name in AmdServiceNames)
+        try
         {
-            try
+            foreach (var sc in System.ServiceProcess.ServiceController.GetServices())
             {
-                using var sc = new System.ServiceProcess.ServiceController(name);
-                var status = sc.Status; // throws if the service does not exist
-                return status == System.ServiceProcess.ServiceControllerStatus.Running
-                    ? CcdServiceState.Running
-                    : CcdServiceState.Stopped;
+                using (sc)
+                {
+                    if (!LooksLikeVCacheOptimizer(sc.ServiceName, sc.DisplayName)) continue;
+
+                    var state = sc.Status == System.ServiceProcess.ServiceControllerStatus.Running
+                        ? CcdServiceState.Running
+                        : IsDisabled(sc.ServiceName) ? CcdServiceState.Disabled : CcdServiceState.Idle;
+
+                    return new CcdServiceInfo(state, sc.ServiceName, sc.DisplayName);
+                }
             }
-            catch { /* not this name; try the next */ }
         }
-        return CcdServiceState.NotFoundOrUnknown;
+        catch { /* enumeration denied or unavailable -- fall through */ }
+
+        return new CcdServiceInfo(CcdServiceState.NotInstalled, null, null);
+    }
+
+    /// <summary>Matches the optimizer by service name or display name. Pure, so the
+    /// matching rule is unit-tested without touching the service manager.</summary>
+    public static bool LooksLikeVCacheOptimizer(string? serviceName, string? displayName)
+    {
+        // Match on the distinctive part rather than a full name: the shipped service
+        // is "amd3dvcacheSvc" / "AMD 3D V-Cache Performance Optimizer Service", and
+        // matching the middle survives casing and Svc/Service suffix changes.
+        return Contains(serviceName, "3dvcache")
+               || Contains(displayName, "3d v-cache")
+               || Contains(displayName, "3d vcache");
+
+        static bool Contains(string? haystack, string needle) =>
+            haystack is not null &&
+            haystack.Contains(needle, StringComparison.OrdinalIgnoreCase);
+    }
+
+    /// <summary>Start mode from the registry. ServiceController exposes StartType
+    /// only on .NET Core 3.0+ for some platforms, and reading the key is the same
+    /// registry-first approach the rest of the app uses.</summary>
+    private static bool IsDisabled(string serviceName)
+    {
+        try
+        {
+            using var k = Registry.LocalMachine.OpenSubKey(
+                $@"SYSTEM\CurrentControlSet\Services\{serviceName}", writable: false);
+            // 4 == SERVICE_DISABLED
+            return k?.GetValue("Start") is int start && start == 4;
+        }
+        catch { return false; }
     }
 
+    /// <summary>
+    /// Whether Windows Game Mode is on — the signal the AMD optimizer's game
+    /// detection rides on.
+    ///
+    /// <para>Reuses <see cref="GameModeMonitor.ReadCurrent"/> rather than reading the
+    /// registry again. The duplicate reader here checked only
+    /// <c>AutoGameModeEnabled</c> and returned null when it was absent, which is why
+    /// the panel said "unknown" on machines that had simply never had the value
+    /// written. Absent now resolves to the Windows default instead.</para>
+    /// </summary>
     public static bool? ReadGameBarEnabled()
     {
         try
         {
-            using var k = Registry.CurrentUser.OpenSubKey(@"Software\Microsoft\GameBar");
-            var v = k?.GetValue("AutoGameModeEnabled");
-            return v is int i ? i != 0 : null;
+            // Neither value present means the user has never changed it, so the
+            // effective state is the Windows 11 default: Game Mode on.
+            return GameModeMonitor.ReadCurrent() ?? true;
         }
         catch { return null; }
     }

src/GamerGuardian/Services/CpuTuneCatalog.cs

@@ -71,10 +71,32 @@ private static IReadOnlyList<PowerOverride> BoostOnlyRecipe() => new[]
 
     // ---- BIOS guidance (advisory only) ----
 
+    /// <summary>
+    /// What to set "CPPC Dynamic Preferred Cores" to on an asymmetric dual-CCD X3D.
+    /// Referenced by the dependency panel so the advice reads the same everywhere.
+    /// </summary>
+    public const string PreferredCppcValue = "Cache";
+
     private static IReadOnlyList<BiosRecommendation> BiosAmdDualCcd() => new[]
     {
-        new BiosRecommendation("CPPC Dynamic Preferred Cores", "Driver",
-            "Lets the AMD 3D V-Cache Optimizer route game threads to the cache CCD; 'Auto' makes the kernel ignore the optimizer."),
+        // Cache rather than Driver, for a gaming-first machine.
+        //
+        // Driver is AMD's official configuration: it hands preferred-core ranking to
+        // the chipset driver's 3D V-Cache Optimizer, which switches CCDs depending on
+        // whether Xbox Game Bar recognises the foreground app as a game. That
+        // detection is the weak link -- it misses non-Steam launchers, emulators and
+        // plenty of older or indie titles, and when it misses, the game runs on the
+        // frequency CCD and loses most of the V-Cache benefit.
+        //
+        // Cache pins preferred cores to the V-Cache CCD outright, so routing does not
+        // depend on detection working. The cost is that heavily multi-threaded
+        // non-gaming work no longer gets first claim on the faster CCD.
+        new BiosRecommendation("CPPC Dynamic Preferred Cores", PreferredCppcValue,
+            "Pins preferred cores to the CCD carrying the 3D V-Cache, so games land there without depending on Xbox Game Bar recognising them. "
+            + "Option names vary by board vendor and AGESA version; some boards label the choices Auto / Driver / Frequency / Cache.",
+            Alternative: "Driver -- AMD's official setting. It switches CCDs dynamically via the 3D V-Cache Optimizer service, "
+            + "so productivity work can still use the faster CCD, but game routing then depends on Xbox Game Bar detecting the title. "
+            + "Prefer it if you run heavy multi-threaded work on the same machine; prefer Cache if this is mainly a gaming PC."),
         new BiosRecommendation("EXPO / Memory profile", "Enabled", "Runs RAM at its rated speed/timings."),
         new BiosRecommendation("Global C-States", "Auto / Enabled", "Required for proper boost behavior; do not disable."),
         new BiosRecommendation("Resizable BAR (Smart Access Memory)", "Enabled", "Improves GPU memory access in many games."),

src/GamerGuardian/Services/SettingDocsCatalog.cs

@@ -416,11 +416,11 @@ public static IReadOnlyList<ChoiceTradeoff> ProsConsFor(string settingId)
             HowItHelps: "Aggressive boost lets the CPU reach and hold its gaming clocks; correct parking keeps game threads on the right cores; faster ramp thresholds reduce clock-up latency. All without the heat/boost-headroom cost of High Performance.",
             Scenarios: Scenarios(
                 ("Single-CCD X3D (9850X3D / 9800X3D / 7800X3D)", "Build optimized -- no parking, aggressive boost"),
-                ("Asymmetric dual-CCD X3D (9950X3D / 7950X3D)", "Build optimized -- parks frequency CCD; also verify BIOS CPPC=Driver + AMD V-Cache service + Game Bar"),
+                ("Asymmetric dual-CCD X3D (9950X3D / 7950X3D)", "Build optimized -- parks frequency CCD; also set BIOS CPPC=Cache (or Driver + the AMD V-Cache service + Game Mode)"),
                 ("Non-X3D / Intel hybrid", "Build optimized (no parking / leave Thread Director) or suggest Balanced"),
                 ("Unknown CPU", "Build optimized uses a labeled generic tune, or suggest the best prebuilt plan")),
             Recommended: "Build optimized for your CPU (or suggest Balanced)",
-            Risks: "Low. The plan is additive -- your existing Windows plans are never modified or deleted, and you can switch back at any time. For asymmetric dual-CCD X3D the power plan alone is not sufficient: it depends on the AMD CCD-routing stack (BIOS CPPC=Driver, the 3D V-Cache Optimizer service, and Xbox Game Bar), which the app surfaces but cannot set.",
+            Risks: "Low. The plan is additive -- your existing Windows plans are never modified or deleted, and you can switch back at any time. For asymmetric dual-CCD X3D the power plan alone is not sufficient: which CCD a game lands on is decided by the BIOS \"CPPC Dynamic Preferred Cores\" setting. Cache pins games to the V-Cache CCD outright; Driver routes them dynamically and then also depends on the 3D V-Cache Optimizer service and Xbox Game Bar game-detection. The app surfaces this but cannot set it.",
             ReversibleVia: "Switch the active plan back via Settings > System > Power, or 'powercfg /setactive SCHEME_BALANCED'. The GamerGuardian plan can be deleted from the legacy Power control panel if you no longer want it."),
 
         // ---- System toggles -----------------------------------------------
@@ -1235,7 +1235,7 @@ public static IReadOnlyList<ChoiceTradeoff> ProsConsFor(string settingId)
             ("Balanced (default)", "Lets modern CPUs' boost algorithms run (often better than a pegged plan) and saves power when idle.", "A few ms of clock-ramp latency at the start of bursts on older CPUs.")),
 
         ["cpuplan"] = Pc(
-            ("Build the optimized plan (recommended)", "A Balanced clone tuned to your CPU -- aggressive boost and the right core-parking -- without High Performance's heat/boost cost.", "For asymmetric dual-CCD X3D it isn't enough alone; it relies on BIOS CPPC=Driver + the AMD V-Cache service the app can't set."),
+            ("Build the optimized plan (recommended)", "A Balanced clone tuned to your CPU -- aggressive boost and the right core-parking -- without High Performance's heat/boost cost.", "For asymmetric dual-CCD X3D it isn't enough alone; it relies on the BIOS \"CPPC Dynamic Preferred Cores\" setting the app cannot set -- Cache pins games to the V-Cache CCD, Driver routes dynamically via the AMD V-Cache service."),
             ("Keep Balanced / a stock plan", "Zero setup, and fine on most modern CPUs whose own boost is already good.", "Misses the per-CPU parking/boost tuning (notably for X3D chips).")),
 
         ["powerthrottling"] = Pc(