fix(magos-modificus): search all Steam libraries for the compatdata prefix (#21)

## What
Small follow-up fix to the Phase 1 Steam discovery library (#18): the
compatdata (Proton prefix) resolution now searches **all Steam
libraries**, not just the main install.

## Why
A launch-smoke-test on a real Linux machine surfaced this: the user's
Darktide compatdata lives at `/games/steamapps/compatdata/1361210/` —
under a **Steam library drive**, not the main Steam install. Steam
places the prefix on whichever drive it chose at install time, which is
frequently a library. The previous logic checked only
`<SteamInstallPath>/steamapps/compatdata/<appid>/`, so it reported
`CompatdataPath: (missing)` → `DiscoveryIncomplete`, blocking the
launch.

## The fix
`SteamService.FindCompatdata` now probes candidates across **the main
install + each library** (main install first for prior-behavior
preservation, then libraries in `libraryfolders.vdf` order, deduped),
first existing wins. The discovery already parsed `libraryfolders.vdf`
for the Darktide search — reuses that list.
`DiscoveryResult.CompatdataPath` stays a single string — **no interface
change**. Windows discovery + Proton/Darktide resolution untouched.

## Test
New `Compatdata_in_secondary_library_is_found` — fixtures a secondary
library with the compatdata (not under the main install) → asserts
`Status: Complete` + the correct library path. Existing
main-install-compatdata test still passes (main install probed first).

## Verification
- **coder** — impl + test; `dotnet build` 0/0; `dotnet test` green
(Steam 39 = 38 + 1; full main suite 117). No new deps.
- **Light review path** — this is a one-method targeted fix with a clear
test; skipping the formal qa/code-review cycle. CI gates Win + Linux on
this PR; the diff is small for direct review.
- After merge: re-run `dotnet run --project
tests/Magos.Modificus.EnginseerClient.Tests -- discover` → `Status:
Complete` (compatdata found under the library).

Builds on merged #18 (Steam). Independent of #20 (Enginseer-client,
still open).

Author: ModifAmorphic

magos-modificus/steam/SteamService.cs

@@ -69,7 +69,7 @@ private DiscoveryResult DiscoverLinux()
 
         var libraries = ReadLibraries(resolved.Path, warnings);
         var darktide = FindDarktide(libraries, warnings);
-        var compatdata = FindCompatdata(resolved.Path);
+        var compatdata = FindCompatdata(resolved.Path, libraries);
         var proton = FindProton(resolved.Path, _options.LinuxCompatibilityToolsDir, warnings);
 
         var status = StatusForLinux(resolved.Path, darktide, compatdata, proton?.Path);
@@ -202,12 +202,48 @@ private IReadOnlyList<string> ReadLibraries(string steamRoot, List<string> warni
         return null;
     }
 
-    private string? FindCompatdata(string steamRoot)
+    /// <summary>
+    /// Resolves the Darktide compatdata (Proton prefix) for the configured app
+    /// id. Probes the main Steam install first, then each library declared in
+    /// <c>libraryfolders.vdf</c> (in order); the first existing dir wins.
+    /// </summary>
+    /// <remarks>
+    /// The prefix is created on whichever drive Steam chose at install time, so
+    /// it frequently lives under a Steam *library* rather than the main install
+    /// (e.g. <c>/games/steamapps/compatdata/&lt;appid&gt;/</c>). Probing the
+    /// main install first preserves prior behavior — when the prefix is there it
+    /// still wins — and the library scan is deterministic (VDF order).
+    /// </remarks>
+    private string? FindCompatdata(string steamRoot, IReadOnlyList<string> libraries)
     {
-        var dir = Path.Combine(
-            steamRoot, "steamapps", "compatdata", _options.DarktideAppId.ToString(CultureInfo.InvariantCulture));
+        var appId = _options.DarktideAppId.ToString(CultureInfo.InvariantCulture);
+
+        // Main install first, then each library in VDF order — the main install
+        // is yielded explicitly so it's probed first even if the VDF lists it
+        // later (or omits it); the explicit duplicate is skipped below.
+        foreach (var root in CompatdataCandidateRoots(steamRoot, libraries))
+        {
+            var dir = Path.Combine(root, "steamapps", "compatdata", appId);
+            if (Directory.Exists(dir))
+            {
+                return dir;
+            }
+        }
+
+        return null;
+    }
 
-        return Directory.Exists(dir) ? dir : null;
+    private static IEnumerable<string> CompatdataCandidateRoots(string steamRoot, IReadOnlyList<string> libraries)
+    {
+        yield return steamRoot;
+        foreach (var lib in libraries)
+        {
+            // Skip the main install when the VDF lists it — it's yielded first above.
+            if (!string.Equals(lib, steamRoot, StringComparison.Ordinal))
+            {
+                yield return lib;
+            }
+        }
     }
 
     /// <summary>

magos-modificus/tests/Magos.Modificus.Steam.Tests/LinuxDiscoveryTests.cs

@@ -115,6 +115,28 @@ public void Darktide_in_secondary_library_is_found()
         Assert.Contains(result.Warnings, w => w.Contains("Searched 2 Steam libraries", StringComparison.Ordinal));
     }
 
+    [Fact]
+    public void Compatdata_in_secondary_library_is_found()
+    {
+        // The Proton prefix (compatdata) is created on whichever drive Steam
+        // chose at install time — frequently a Steam *library* drive rather than
+        // the main install (e.g. /games/steamapps/compatdata/<appid>/). Discovery
+        // must probe each library, not just the main install, or it reports
+        // CompatdataPath missing → DiscoveryIncomplete and blocks the launch.
+        using var fx = new SteamFixture();
+        var secondary = Path.Combine(fx.TempRoot, "secondary-lib");
+        Directory.CreateDirectory(secondary);
+        fx.WithLibraryFoldersAtSteamRoot(fx.SteamRoot, secondary);
+        fx.WithDarktide(fx.SteamRoot);
+        fx.WithCompatdata(secondary); // prefix only under the secondary library
+        fx.WithProtonInCommon(fx.SteamRoot, "Proton - Experimental");
+
+        var result = fx.Service.Discover();
+
+        Assert.Equal(DiscoveryStatus.Complete, result.Status);
+        Assert.Equal(fx.ExpectedCompatdataPath(secondary), result.CompatdataPath);
+    }
+
     [Fact]
     public void Missing_steam_root_falls_back_to_flatpak_when_valid()
     {