Lock hard-mode schedules against direct periods.json edits

The watchdog trusted periods.json unconditionally, so hard mode on
a schedule was only as strong as "don't open the JSON file" -
disabling it, deleting it, or moving its endTime earlier all lifted
the block instantly. The watchdog now remembers each hard-mode
period's legitimate end time in memory once it sees it active, and
keeps enforcing its apps/sites regardless of what the file says
until that time passes. No new escape hatch - killing the elevated
watchdog process remains the intentional way out.

Author: zixload

Umbra.Core/WatchdogLoop.cs

@@ -73,6 +73,25 @@ public class Enforcer
         private DateTime? _periodWindowStartUtc;
         private string? _periodWindowLabel;
 
+        // Verrou de confiance pour les plages hard mode : éditer periods.json
+        // à la main pendant qu'une plage bloque activement (désactiver,
+        // supprimer, ou simplement reculer son heure de fin) n'a plus d'effet
+        // tant que l'heure de fin légitimement observée n'est pas atteinte.
+        // Pas de porte de secours par code ici (volontairement, plus simple
+        // que ce qu'on avait testé) - la vraie échappatoire reste de fermer
+        // le watchdog élevé depuis le Gestionnaire des tâches (déjà le cas
+        // avant ce verrou, ça continue de marcher pareil). En mémoire
+        // seulement : un redémarrage du watchdog réinitialise la confiance,
+        // même compromis assumé qu'ailleurs dans cette classe.
+        private readonly Dictionary<string, TrustedHardPeriod> _trustedHardPeriods = new();
+
+        internal class TrustedHardPeriod
+        {
+            public required List<string> Apps;
+            public required List<string> Sites;
+            public required DateTime LockedUntil;
+        }
+
         private readonly Action<string> _notify; // "done" | "break" | "work"
 
         public Enforcer(Action<string> notify)
@@ -105,20 +124,22 @@ public async Task TickAsync()
         {
             var s = Session.Load(); // fait aussi avancer les phases pomodoro dues
             var periodsData = Periods.Load();
-            var activePeriods = Periods.GetActivePeriods(periodsData, DateTime.Now);
+            var now = DateTime.Now;
+            var activePeriods = Periods.GetActivePeriods(periodsData, now);
             // Comme Session.IsBlockingActive pour une session manuelle : une
             // plage en PomodoroMode ne doit pas bloquer pendant sa pause,
             // même si elle reste "active" au sens fenêtre horaire (l'anneau
             // continue de tourner côté UI, seul le blocage s'arrête).
-            var blockingPeriods = activePeriods.Where(p => !p.PomodoroMode || !Periods.GetPomodoroTiming(p, DateTime.Now).IsBreak).ToList();
+            var blockingPeriods = activePeriods.Where(p => !p.PomodoroMode || !Periods.GetPomodoroTiming(p, now).IsBreak).ToList();
+            var phantomHardPeriods = ResolveHardLockedPeriods(periodsData, now);
             var sessionBlocking = Session.IsBlockingActive(s);
             // Indépendante de toute session/plage - "je ne veux jamais
             // pouvoir aller sur X" (voir AlwaysBlocklist). Un Load() de plus
             // par tick est négligeable : Blocklist.Load() tourne déjà tout
             // aussi souvent dès qu'une session manuelle est active, sur un
             // fichier tout aussi petit.
             var always = AlwaysBlocklist.Load();
-            var shouldBlock = sessionBlocking || blockingPeriods.Count > 0 || always.Apps.Count > 0 || always.Sites.Count > 0;
+            var shouldBlock = sessionBlocking || blockingPeriods.Count > 0 || always.Apps.Count > 0 || always.Sites.Count > 0 || phantomHardPeriods.Count > 0;
 
             TrackPeriodHistory(s, activePeriods);
 
@@ -150,6 +171,11 @@ public async Task TickAsync()
                 }
                 foreach (var a in always.Apps) apps.Add(a);
                 foreach (var st in always.Sites) sites.Add(st);
+                foreach (var p in phantomHardPeriods)
+                {
+                    foreach (var a in p.Apps) apps.Add(a);
+                    foreach (var st in p.Sites) sites.Add(st);
+                }
 
                 try
                 {
@@ -233,6 +259,41 @@ public async Task TickAsync()
             _lastPhase = curPhase;
         }
 
+        // Plusieurs plages hard mode peuvent être verrouillées à la fois
+        // (clé = Period.Id, stable même si la plage est renommée ensuite).
+        // Retourne les plages "fantômes" - verrouillées en mémoire mais plus
+        // présentes/actives légitimement dans periods.json (désactivée,
+        // supprimée, horaire reculé...) - dont il faut quand même continuer
+        // à bloquer apps/sites jusqu'à l'heure de fin retenue.
+        internal List<TrustedHardPeriod> ResolveHardLockedPeriods(PeriodsData periodsData, DateTime now)
+        {
+            var seenIds = new HashSet<string>();
+            foreach (var p in periodsData.Periods)
+            {
+                if (!p.HardMode || !Periods.PeriodCoversNow(p, now)) continue;
+                seenIds.Add(p.Id);
+                var end = now.AddSeconds(Periods.GetTiming(p, now).RemainingSeconds);
+                if (!_trustedHardPeriods.TryGetValue(p.Id, out var trusted) || end >= trusted.LockedUntil)
+                {
+                    _trustedHardPeriods[p.Id] = new TrustedHardPeriod
+                    {
+                        Apps = new List<string>(p.Apps),
+                        Sites = new List<string>(p.Sites),
+                        LockedUntil = end,
+                    };
+                }
+            }
+
+            var phantoms = new List<TrustedHardPeriod>();
+            foreach (var (id, trusted) in _trustedHardPeriods.ToList())
+            {
+                if (seenIds.Contains(id)) continue; // toujours légitimement actif, rien à défendre
+                if (now < trusted.LockedUntil) phantoms.Add(trusted);
+                else _trustedHardPeriods.Remove(id); // engagement écoulé
+            }
+            return phantoms;
+        }
+
         // Une session manuelle a sa propre fenêtre (Session.Stop / fin de
         // pomodoro), donc on ne suit une fenêtre de plage que quand aucune
         // session n'est active du tout - sinon le même temps se

Umbra.Tests/WatchdogLoopTests.cs

@@ -0,0 +1,118 @@
+using Umbra.Core;
+
+namespace Umbra.Tests;
+
+// Couvre le verrou de confiance des plages hard mode (WatchdogLoop.Enforcer) :
+// une fois qu'une plage hard mode est observée active, un periods.json
+// modifié à la main (désactivée, supprimée, horaire reculé) ne doit plus
+// pouvoir la débloquer avant son heure de fin légitime. Teste la méthode de
+// résolution directement (internal, voir InternalsVisibleTo) plutôt que
+// TickAsync en entier, qui touche le fichier hosts/pare-feu réels.
+public class WatchdogLoopTests : IDisposable
+{
+    private readonly string _tempDir;
+
+    public WatchdogLoopTests()
+    {
+        _tempDir = Path.Combine(Path.GetTempPath(), "umbra-tests-" + Guid.NewGuid());
+        Config.DataDir = _tempDir;
+    }
+
+    public void Dispose()
+    {
+        try { Directory.Delete(_tempDir, recursive: true); } catch { }
+    }
+
+    private static WatchdogLoop.Enforcer MakeEnforcer() => new(_ => { });
+
+    private static Period MakeHardPeriod(string id, DateTime now, int startOffsetMin, int endOffsetMin) => new()
+    {
+        Id = id,
+        Name = "test",
+        Enabled = true,
+        Recurring = true,
+        Days = new List<int> { (int)now.DayOfWeek },
+        Date = Periods.TodayKey(now),
+        StartTime = now.AddMinutes(startOffsetMin).ToString("HH:mm"),
+        EndTime = now.AddMinutes(endOffsetMin).ToString("HH:mm"),
+        HardMode = true,
+        Apps = new List<string> { "app.exe" },
+        Sites = new List<string> { "example.com" },
+    };
+
+    [Fact]
+    public void ResolveHardLockedPeriods_CurrentlyActivePeriod_ReturnsNoPhantom()
+    {
+        var enforcer = MakeEnforcer();
+        var now = DateTime.Now;
+        var data = new PeriodsData { Periods = new List<Period> { MakeHardPeriod("p1", now, -10, 10) } };
+
+        Assert.Empty(enforcer.ResolveHardLockedPeriods(data, now));
+    }
+
+    [Fact]
+    public void ResolveHardLockedPeriods_DisabledWhileLocked_StaysEnforced()
+    {
+        var enforcer = MakeEnforcer();
+        var now = DateTime.Now;
+        var p = MakeHardPeriod("p1", now, -10, 10);
+        enforcer.ResolveHardLockedPeriods(new PeriodsData { Periods = new List<Period> { p } }, now);
+
+        var disabled = MakeHardPeriod("p1", now, -10, 10);
+        disabled.Enabled = false; // "edition" directe : desactivee alors qu'il reste largement du temps
+        var phantoms = enforcer.ResolveHardLockedPeriods(new PeriodsData { Periods = new List<Period> { disabled } }, now);
+        Assert.Single(phantoms);
+        Assert.Contains("app.exe", phantoms[0].Apps);
+        Assert.Contains("example.com", phantoms[0].Sites);
+    }
+
+    [Fact]
+    public void ResolveHardLockedPeriods_DeletedWhileLocked_StaysEnforced()
+    {
+        var enforcer = MakeEnforcer();
+        var now = DateTime.Now;
+        var data = new PeriodsData { Periods = new List<Period> { MakeHardPeriod("p1", now, -10, 10) } };
+        enforcer.ResolveHardLockedPeriods(data, now);
+
+        var phantoms = enforcer.ResolveHardLockedPeriods(new PeriodsData(), now);
+        Assert.Single(phantoms);
+    }
+
+    [Fact]
+    public void ResolveHardLockedPeriods_EndTimeMovedEarlier_IsIgnored()
+    {
+        var enforcer = MakeEnforcer();
+        var now = DateTime.Now;
+        var p = MakeHardPeriod("p1", now, -10, 60); // se termine dans 1h
+        enforcer.ResolveHardLockedPeriods(new PeriodsData { Periods = new List<Period> { p } }, now);
+
+        // "edition" directe de endTime pour faire croire que la plage vient de se terminer
+        var edited = MakeHardPeriod("p1", now, -10, -1);
+        var phantoms = enforcer.ResolveHardLockedPeriods(new PeriodsData { Periods = new List<Period> { edited } }, now);
+        Assert.Single(phantoms); // l'ancienne echeance (dans ~1h) fait toujours foi
+    }
+
+    [Fact]
+    public void ResolveHardLockedPeriods_DeletedAfterWindowEnds_NoLongerEnforced()
+    {
+        var enforcer = MakeEnforcer();
+        var now = DateTime.Now;
+        var covering = MakeHardPeriod("p1", now, -10, 1); // se termine dans 1 min
+        enforcer.ResolveHardLockedPeriods(new PeriodsData { Periods = new List<Period> { covering } }, now);
+
+        var later = now.AddMinutes(2); // après la fin légitime
+        Assert.Empty(enforcer.ResolveHardLockedPeriods(new PeriodsData(), later));
+    }
+
+    [Fact]
+    public void ResolveHardLockedPeriods_NonHardModePeriod_NeverLocked()
+    {
+        var enforcer = MakeEnforcer();
+        var now = DateTime.Now;
+        var p = MakeHardPeriod("p1", now, -10, 10);
+        p.HardMode = false;
+        enforcer.ResolveHardLockedPeriods(new PeriodsData { Periods = new List<Period> { p } }, now);
+
+        Assert.Empty(enforcer.ResolveHardLockedPeriods(new PeriodsData(), now)); // rien a defendre, ce n'etait pas hard mode
+    }
+}