feat(overclock): flujo de tuning guiado con perfiles validados

- StartTuning en la 05 ESTABILIDAD: biseccion con techo anunciado (preset Performance), journal real, checkpoint y perfil validado que desbloquea juegos
- WmiClockStallProbe (EffectiveClockStall por WMI, resto SensorUnavailable, corte de carga 50), TransactionOverclockJournal, AmdTuningCeilingSource, StoreBackedGameProfileRepository
- Fix catalogo: presets escalares con literal int caian en FromIndex (Scalar=0); 17 presets a sufijo d + guard
- Suite 1692 passed, 0 failed; build 0W/0E

Author: Pyromesis

src/CA-O.Core/Overclock/Catalog/OverclockCatalog.cs

@@ -25,19 +25,19 @@ public static class OverclockCatalog
             "knob_nvidia_power_limit", "knob_nvidia_power_limit_desc", requiresReboot: false,
             presets:
             [
-                (OverclockProfile.Conservative, 100),
-                (OverclockProfile.Balanced, 110),
-                (OverclockProfile.Performance, 120),
+                (OverclockProfile.Conservative, 100d),
+                (OverclockProfile.Balanced, 110d),
+                (OverclockProfile.Performance, 120d),
             ]),
 
         Build(new KnobId("nvidia.gpu.thermalLimit"), OverclockComponent.Gpu,
             KnobRange.Scalar(60, 95), 1, KnobUnit.Celsius, RiskLevel.High, EvidenceLevel.Vendor,
             "knob_nvidia_thermal_limit", "knob_nvidia_thermal_limit_desc", requiresReboot: false,
             presets:
             [
-                (OverclockProfile.Conservative, 83),
-                (OverclockProfile.Balanced, 86),
-                (OverclockProfile.Performance, 90),
+                (OverclockProfile.Conservative, 83d),
+                (OverclockProfile.Balanced, 86d),
+                (OverclockProfile.Performance, 90d),
             ],
             // CA-O never raises this past the driver's own default for the profile
             // Conservative; the ceiling is what the engine negotiates downward.
@@ -53,7 +53,7 @@ public static class OverclockCatalog
             "knob_nvidia_core_offset", "knob_nvidia_core_offset_desc", requiresReboot: false,
             presets:
             [
-                (OverclockProfile.Conservative, 0),
+                (OverclockProfile.Conservative, 0d),
                 (OverclockProfile.Balanced, 60_000_000d),
                 (OverclockProfile.Performance, 120_000_000d),
             ],
@@ -65,7 +65,7 @@ public static class OverclockCatalog
             "knob_nvidia_mem_offset", "knob_nvidia_mem_offset_desc", requiresReboot: false,
             presets:
             [
-                (OverclockProfile.Conservative, 0),
+                (OverclockProfile.Conservative, 0d),
                 (OverclockProfile.Balanced, 250_000_000d),
                 (OverclockProfile.Performance, 500_000_000d),
             ],
@@ -76,9 +76,9 @@ public static class OverclockCatalog
             "knob_nvidia_fan_target", "knob_nvidia_fan_target_desc", requiresReboot: false,
             presets:
             [
-                (OverclockProfile.Conservative, 0),
-                (OverclockProfile.Balanced, 0),
-                (OverclockProfile.Performance, 15),
+                (OverclockProfile.Conservative, 0d),
+                (OverclockProfile.Balanced, 0d),
+                (OverclockProfile.Performance, 15d),
             ]),
 
         // Read-only reporting knob: CA-O measures the thermal ceiling and shows it,
@@ -103,9 +103,9 @@ public static class OverclockCatalog
             "knob_amd_power_limit", "knob_amd_power_limit_desc", requiresReboot: false,
             presets:
             [
-                (OverclockProfile.Conservative, 100),
-                (OverclockProfile.Balanced, 110),
-                (OverclockProfile.Performance, 120),
+                (OverclockProfile.Conservative, 100d),
+                (OverclockProfile.Balanced, 110d),
+                (OverclockProfile.Performance, 120d),
             ],
             backendId: AmdAdlxBackendId),
     ];
@@ -133,9 +133,9 @@ public static class OverclockCatalog
             "knob_cpu_max_freq", "knob_cpu_max_freq_desc", requiresReboot: false,
             presets:
             [
-                (OverclockProfile.Conservative, 100),
-                (OverclockProfile.Balanced, 100),
-                (OverclockProfile.Performance, 100),
+                (OverclockProfile.Conservative, 100d),
+                (OverclockProfile.Balanced, 100d),
+                (OverclockProfile.Performance, 100d),
             ]),
     ];
 

src/CA-O.Core/Overclock/Reporting/FileValidatedProfileStore.cs

@@ -0,0 +1,83 @@
+using System.Globalization;
+using System.Text;
+using System.Text.Json;
+using CAO.Shared;
+
+namespace CAO.Core.Overclock.Reporting;
+
+/// <summary>
+/// File-backed validated profiles. Same discipline as the checkpoint store: atomic
+/// writes, unreadable files quarantined and never deleted, transient I/O skipped.
+/// One file per knob, so saving twice keeps the latest run instead of history.
+/// </summary>
+public sealed class FileValidatedProfileStore : IValidatedProfileStore
+{
+    private static readonly JsonSerializerOptions SerializerOptions = new()
+    {
+        WriteIndented = false,
+        PropertyNameCaseInsensitive = true,
+    };
+
+    private readonly string _directory;
+
+    public FileValidatedProfileStore(string? directory = null) =>
+        _directory = directory ?? CaOPaths.OverclockProfilesDirectory;
+
+    public async Task<IReadOnlyList<ValidatedOverclockProfile>> ListAsync(CancellationToken cancellationToken)
+    {
+        var result = new List<ValidatedOverclockProfile>();
+        if (!Directory.Exists(_directory))
+        {
+            return result;
+        }
+
+        foreach (var file in Directory.EnumerateFiles(_directory, "*.json"))
+        {
+            cancellationToken.ThrowIfCancellationRequested();
+
+            ValidatedOverclockProfile? profile;
+            try
+            {
+                var json = await File.ReadAllTextAsync(file, cancellationToken).ConfigureAwait(false);
+                profile = JsonSerializer.Deserialize<ValidatedOverclockProfile>(json, SerializerOptions);
+            }
+            catch (JsonException)
+            {
+                profile = null;
+            }
+            catch (IOException)
+            {
+                continue;
+            }
+
+            if (profile is null)
+            {
+                Quarantine(file);
+                continue;
+            }
+
+            result.Add(profile);
+        }
+
+        return result;
+    }
+
+    public async Task SaveAsync(ValidatedOverclockProfile profile, CancellationToken cancellationToken)
+    {
+        ArgumentNullException.ThrowIfNull(profile);
+
+        Directory.CreateDirectory(_directory);
+        var path = Path.Combine(_directory, profile.Knob.Value + ".json");
+
+        var temp = path + ".tmp";
+        var json = JsonSerializer.Serialize(profile, SerializerOptions);
+        await File.WriteAllTextAsync(temp, json, Encoding.UTF8, cancellationToken).ConfigureAwait(false);
+        File.Move(temp, path, overwrite: true);
+    }
+
+    private static void Quarantine(string file)
+    {
+        var stamp = DateTimeOffset.UtcNow.ToString("yyyyMMdd'T'HHmmss'Z'", CultureInfo.InvariantCulture);
+        File.Move(file, $"{file}.corrupt-{stamp}-unparseable");
+    }
+}

src/CA-O.Core/Overclock/Reporting/ValidatedProfile.cs

@@ -0,0 +1,26 @@
+using System.Text.Json.Serialization;
+
+namespace CAO.Core.Overclock.Reporting;
+
+/// <summary>
+/// A tuning run that reached its ceiling without a fault, kept as the machine's
+/// validated answer for one knob. This is the only thing a game profile may
+/// reference: a value no run has produced is a guess, and CA-O does not ship
+/// guesses (design 6.9).
+/// </summary>
+public sealed record ValidatedOverclockProfile(
+    [property: JsonPropertyName("knob")] KnobId Knob,
+    [property: JsonPropertyName("component")] OverclockComponent Component,
+    [property: JsonPropertyName("stableValue")] double StableValue,
+    [property: JsonPropertyName("stableCeiling")] double? StableCeiling,
+    [property: JsonPropertyName("validatedUtc")] DateTimeOffset ValidatedAtUtc,
+    [property: JsonPropertyName("driverVersion")] string? DriverVersion,
+    [property: JsonPropertyName("pointsPassed")] int PointsPassed);
+
+/// <summary>Where validated profiles live. One file per knob; saving twice keeps the latest.</summary>
+public interface IValidatedProfileStore
+{
+    Task<IReadOnlyList<ValidatedOverclockProfile>> ListAsync(CancellationToken cancellationToken);
+
+    Task SaveAsync(ValidatedOverclockProfile profile, CancellationToken cancellationToken);
+}

src/CA-O.Infrastructure/Overclock/AmdTuningCeilingSource.cs

@@ -0,0 +1,59 @@
+using CAO.Core.Overclock;
+using CAO.Core.Overclock.Reporting;
+
+namespace CAO.Infrastructure.Overclock;
+
+/// <summary>
+/// The real bounds ADLX reports for the one AMD knob with a public setter.
+/// AMD power limits already are percent of TDP, so there is no anchor to
+/// resolve and no conversion to get wrong: the driver range is the ceiling.
+/// A range the driver would not report gets a row with its reason, not a
+/// missing row that would read as "nothing bounded it".
+/// </summary>
+public sealed class AmdTuningCeilingSource : IOverclockCeilingSource
+{
+    private readonly IAmdTuningApi _tuning;
+
+    public AmdTuningCeilingSource(IAmdTuningApi tuning) =>
+        _tuning = tuning ?? throw new ArgumentNullException(nameof(tuning));
+
+    public ValueTask<IReadOnlyList<TuningCeiling>> ReadAsync(CancellationToken ct)
+    {
+        ct.ThrowIfCancellationRequested();
+
+        if (!_tuning.IsAvailable)
+        {
+            return new ValueTask<IReadOnlyList<TuningCeiling>>([]);
+        }
+
+        if (!_tuning.TryDescribe(out var device) || device is null)
+        {
+            TuningCeiling unknown = new(
+                AmdKnobs.PowerLimit,
+                NvidiaTuningCeilingSource.PercentUnitKey,
+                null,
+                null,
+                _tuning.UnavailableReasonKey ?? NvidiaTuningCeilingSource.UnavailableReasonKey);
+            return new ValueTask<IReadOnlyList<TuningCeiling>>([unknown]);
+        }
+
+        if (device.MinPowerLimitPercent is not int min || device.MaxPowerLimitPercent is not int max)
+        {
+            TuningCeiling noRange = new(
+                AmdKnobs.PowerLimit,
+                NvidiaTuningCeilingSource.PercentUnitKey,
+                null,
+                null,
+                AmdAdlxBackend.RangeUnavailableReasonKey);
+            return new ValueTask<IReadOnlyList<TuningCeiling>>([noRange]);
+        }
+
+        TuningCeiling ceiling = new(
+            AmdKnobs.PowerLimit,
+            NvidiaTuningCeilingSource.PercentUnitKey,
+            min,
+            max,
+            null);
+        return new ValueTask<IReadOnlyList<TuningCeiling>>([ceiling]);
+    }
+}

src/CA-O.Infrastructure/Overclock/Gaming/GameOverclockSource.cs

@@ -67,6 +67,14 @@ public interface IAntiCheatScanner
 public interface IGameProfileRepository
 {
     IReadOnlyList<GameOverclockProfile> List();
+
+    /// <summary>
+    /// Async over the same answer. The default keeps the sync one so existing
+    /// repositories do not change; stores backed by disk override it so the
+    /// page never blocks the UI thread on file I/O.
+    /// </summary>
+    Task<IReadOnlyList<GameOverclockProfile>> ListAsync(CancellationToken ct) =>
+        Task.FromResult(List());
 }
 
 /// <summary>The repository that has no validated profile, because none has been produced yet.</summary>
@@ -85,7 +93,10 @@ public sealed class SystemGameOverclockSource : IGameOverclockSource
     private readonly IGameProfileRepository _profiles;
 
     public SystemGameOverclockSource()
-        : this(new GameDetectionProvider(), new AntiCheatScanProvider(), new EmptyGameProfileRepository())
+        : this(
+            new GameDetectionProvider(),
+            new AntiCheatScanProvider(),
+            new StoreBackedGameProfileRepository(new CAO.Core.Overclock.Reporting.FileValidatedProfileStore()))
     {
     }
 
@@ -122,7 +133,7 @@ public async ValueTask<GameOverclockSnapshot> ReadAsync(CancellationToken ct)
             detected = [];
         }
 
-        var profiles = _profiles.List();
+        var profiles = await _profiles.ListAsync(ct).ConfigureAwait(false);
         var entries = new List<GameOverclockEntry>(detected.Count);
         foreach (var game in detected)
         {

src/CA-O.Infrastructure/Overclock/Gaming/StoreBackedGameProfileRepository.cs

@@ -0,0 +1,64 @@
+using CAO.Core.Gaming;
+using CAO.Core.Overclock;
+using CAO.Core.Overclock.Gaming;
+using CAO.Core.Overclock.Reporting;
+using CAO.Shared;
+
+namespace CAO.Infrastructure.Overclock.Gaming;
+
+/// <summary>
+/// Game profiles built from tuning runs on this machine. A validated GPU answer
+/// unlocks one profile per known title, referencing the Custom preset: the value
+/// was measured here, not taken from a vendor slide. No validated answer means
+/// no profile, which is why every row says "no validated profile" on a fresh
+/// machine instead of offering a number nobody ran.
+/// </summary>
+public sealed class StoreBackedGameProfileRepository : IGameProfileRepository
+{
+    public const string CustomPresetLabelKey = "preset_custom";
+
+    private readonly IValidatedProfileStore _profiles;
+
+    public StoreBackedGameProfileRepository(IValidatedProfileStore profiles) =>
+        _profiles = profiles ?? throw new ArgumentNullException(nameof(profiles));
+
+    public IReadOnlyList<GameOverclockProfile> List() =>
+        ListAsync(CancellationToken.None).GetAwaiter().GetResult();
+
+    public async Task<IReadOnlyList<GameOverclockProfile>> ListAsync(CancellationToken ct)
+    {
+        IReadOnlyList<ValidatedOverclockProfile> validated;
+        try
+        {
+            validated = await _profiles.ListAsync(ct).ConfigureAwait(false);
+        }
+        catch (OperationCanceledException)
+        {
+            throw;
+        }
+        catch (Exception)
+        {
+            // An unreadable profile store is not "no validated profile": it is
+            // unknown, and the gate reports that through ScanUnavailable rows
+            // only when the scan itself failed. Here the honest answer is to
+            // offer nothing rather than a profile whose backing file is gone.
+            return [];
+        }
+
+        if (!validated.Any(v => v.Component == OverclockComponent.Gpu))
+        {
+            return [];
+        }
+
+        return GameProfileCatalog.All
+            .Select(g => new GameOverclockProfile(
+                g.GameId,
+                g.DisplayName,
+                OverclockProfile.Custom,
+                CustomPresetLabelKey,
+                PreferHighPerformanceGpu: true,
+                GpuPreferenceEvidence: EvidenceLevel.Empirical,
+                g.GuidanceEs))
+            .ToList();
+    }
+}

src/CA-O.Infrastructure/Overclock/TransactionOverclockJournal.cs

@@ -0,0 +1,39 @@
+using CAO.Core.Overclock.Stability;
+using CAO.Infrastructure.Persistence;
+using CAO.Shared;
+
+namespace CAO.Infrastructure.Overclock;
+
+/// <summary>
+/// The tuning engine's journal, backed by the same append-only transaction file
+/// the rest of the app uses. The run id is the transaction id, so a tuning run
+/// shows up in the journal next to every optimization, and it never closes:
+/// closing is the caller's job, and a tuning that closed its own transaction
+/// could report a terminal state nobody verified.
+/// </summary>
+public sealed class TransactionOverclockJournal : IOverclockJournal
+{
+    public const string OptimizationId = "overclock-tune";
+
+    private readonly FileTransactionJournal _inner;
+    private readonly Guid _runId;
+
+    public TransactionOverclockJournal(FileTransactionJournal inner, Guid runId)
+    {
+        _inner = inner ?? throw new ArgumentNullException(nameof(inner));
+        _runId = runId;
+    }
+
+    public ValueTask WriteAsync(TransactionPhase phase, string? detail, CancellationToken cancellationToken)
+    {
+        // The engine calls from a worker thread; Append flushes to disk inline.
+        _inner.Append(new TransactionEvent(
+            _runId,
+            OptimizationId,
+            DateTime.UtcNow,
+            phase,
+            Terminal: false,
+            detail));
+        return ValueTask.CompletedTask;
+    }
+}