From 01d9ee11adebc8cc4acee43b8a45c605d0e00d65 Mon Sep 17 00:00:00 2001
From: Pixnop <77785313+Pixnop@users.noreply.github.com>
Date: Sun, 4 Oct 2026 22:34:38 +0200
Subject: [PATCH 1/3] Extract the duty cycle from TickAttribution into
 DutyCycle

The idle, warm-up and burst schedule that drove per-mod attribution now
lives in a class of its own, so a second feature can run on the same
schedule instead of keeping a copy that would drift. DutyCycle owns the
clamp, the interval, the warm-up and the burst length, and says what
each tick is for: idle, start, warm-up, sample or last sample.
TickAttribution folds a tree on the sample steps and keeps the rest of
what it had, with the same constructor, the same Apply and the same
properties, so AttributionMetrics and the commands are untouched.

Behaviour is unchanged. The schedule tests moved to DutyCycleTests,
where they run against the schedule alone, and the attribution tests
that check what attribution does with each step stay where they were.
The two mutation patterns that pointed at the moved code now point at
DutyCycle.cs.
---
 Pulse.Tests/DutyCycleTests.cs       | 162 ++++++++++++++++++++++++++++
 Pulse.Tests/TickAttributionTests.cs |  44 +-------
 Pulse/DutyCycle.cs                  | 129 ++++++++++++++++++++++
 Pulse/TickAttribution.cs            |  92 +++++-----------
 tools/mutation-check.sh             |  10 +-
 5 files changed, 329 insertions(+), 108 deletions(-)
 create mode 100644 Pulse.Tests/DutyCycleTests.cs
 create mode 100644 Pulse/DutyCycle.cs

diff --git a/Pulse.Tests/DutyCycleTests.cs b/Pulse.Tests/DutyCycleTests.cs
new file mode 100644
index 0000000..8cdf13c
--- /dev/null
+++ b/Pulse.Tests/DutyCycleTests.cs
@@ -0,0 +1,162 @@
+using Xunit;
+
+namespace Pulse.Tests;
+
+/// <summary>The schedule alone: when a burst starts, how many ticks it lasts, when it ends, and
+/// what a switch or a reload does to one in progress. No profiler, no trees and no owners:
+/// <c>TickAttributionTests</c> covers what attribution does with each step.</summary>
+public class DutyCycleTests
+{
+    /// <summary>Ticks the cycle <paramref name="ticks"/> times and returns what each tick was.</summary>
+    private static DutyStep[] Run(DutyCycle cycle, int ticks, double elapsedSeconds = 1.0)
+    {
+        DutyStep[] steps = new DutyStep[ticks];
+        for (int tick = 0; tick < ticks; tick++)
+        {
+            steps[tick] = cycle.OnTick(elapsedSeconds);
+        }
+
+        return steps;
+    }
+
+    [Fact]
+    public void Constructor_Floors_TheIntervalAndTheBurstLength()
+    {
+        DutyCycle cycle = new(0, 0);
+
+        Assert.Equal(1, cycle.BurstTicks);
+        Assert.Equal(DutyCycle.MinimumIntervalSeconds, cycle.IntervalSeconds);
+    }
+
+    [Fact]
+    public void Constructor_Caps_TheBurstLength()
+        => Assert.Equal(DutyCycle.MaximumBurstTicks, new DutyCycle(100000, 10).BurstTicks);
+
+    [Fact]
+    public void Constructor_Keeps_AConfiguredDutyCycle()
+    {
+        DutyCycle cycle = new(30, 10);
+
+        Assert.True(cycle.Enabled);
+        Assert.Equal(30, cycle.BurstTicks);
+        Assert.Equal(10, cycle.IntervalSeconds);
+    }
+
+    [Fact]
+    public void OnTick_StaysIdle_UntilTheIntervalHasPassed()
+    {
+        DutyCycle cycle = new(5, 10);
+
+        for (int tick = 0; tick < 9; tick++)
+        {
+            Assert.Equal(DutyStep.Idle, cycle.OnTick(1.0));
+            Assert.False(cycle.InBurst);
+        }
+
+        Assert.Equal(DutyStep.Start, cycle.OnTick(1.0));
+        Assert.True(cycle.InBurst);
+    }
+
+    /// <summary>Whatever the caller switches on at the start is switched on part-way through that
+    /// tick, so what it reads on the next one describes a tick only partly covered. That one is the
+    /// warm-up, and it is not a sample.</summary>
+    [Fact]
+    public void OnTick_WarmsUp_OnTheTickAfterTheBurstStarts()
+    {
+        DutyCycle cycle = new(1, 1);
+
+        Assert.Equal(DutyStep.Start, cycle.OnTick(1.0));
+        Assert.Equal(DutyStep.WarmUp, cycle.OnTick(1.0));
+        Assert.True(cycle.InBurst);
+        Assert.Equal(DutyStep.LastSample, cycle.OnTick(1.0));
+    }
+
+    [Fact]
+    public void OnTick_Takes_BurstTicksSamples_ThenEndsTheBurst()
+    {
+        DutyCycle cycle = new(3, 1);
+
+        Assert.Equal([DutyStep.Start, DutyStep.WarmUp, DutyStep.Sample, DutyStep.Sample], Run(cycle, 4));
+        Assert.True(cycle.InBurst);
+
+        Assert.Equal(DutyStep.LastSample, cycle.OnTick(1.0));
+        Assert.False(cycle.InBurst);
+    }
+
+    /// <summary>The interval counts from the end of a burst, and the next burst has the same shape
+    /// as the first: its own warm-up, then its own samples.</summary>
+    [Fact]
+    public void OnTick_Runs_ASecondBurstAfterTheNextInterval()
+    {
+        DutyCycle cycle = new(2, 2);
+        DutyStep[] oneBurst = [DutyStep.Idle, DutyStep.Start, DutyStep.WarmUp, DutyStep.Sample, DutyStep.LastSample];
+
+        Assert.Equal(oneBurst, Run(cycle, 5));
+        Assert.Equal(oneBurst, Run(cycle, 5));
+    }
+
+    [Fact]
+    public void OnTick_StaysIdle_WhileDisabled()
+    {
+        DutyCycle cycle = new(1, 1, enabled: false);
+
+        Assert.All(Run(cycle, 100), step => Assert.Equal(DutyStep.Idle, step));
+        Assert.False(cycle.Enabled);
+        Assert.False(cycle.InBurst);
+    }
+
+    /// <summary>The whole point of arming a cycle on a server that did not ask for it: it can be
+    /// switched on later, and then it runs exactly as if the config had said so.</summary>
+    [Fact]
+    public void Apply_Starts_TheCycle_OnAServerThatBootedWithItOff()
+    {
+        DutyCycle cycle = new(2, 1, enabled: false);
+        cycle.OnTick(1.0);
+
+        cycle.Apply(true, 2, 1);
+
+        Assert.Equal([DutyStep.Start, DutyStep.WarmUp, DutyStep.Sample, DutyStep.LastSample], Run(cycle, 4));
+    }
+
+    /// <summary>Switching it off part-way through a burst drops the burst instead of finishing it:
+    /// the cycle is out of the burst at once, and no later tick is a sample.</summary>
+    [Fact]
+    public void Apply_Drops_ABurstInProgress_WhenItIsSwitchedOff()
+    {
+        DutyCycle cycle = new(30, 1);
+        Run(cycle, 5);
+        Assert.True(cycle.InBurst);
+
+        cycle.Apply(false, 30, 1);
+
+        Assert.False(cycle.Enabled);
+        Assert.False(cycle.InBurst);
+        Assert.All(Run(cycle, 100), step => Assert.Equal(DutyStep.Idle, step));
+        Assert.False(cycle.InBurst);
+    }
+
+    /// <summary>Switching back on starts a fresh cycle, so the burst begins with its warm-up again
+    /// rather than carrying on from where the old one stopped.</summary>
+    [Fact]
+    public void Apply_WarmsUpAgain_WhenItIsSwitchedBackOn()
+    {
+        DutyCycle cycle = new(2, 1);
+        Run(cycle, 3);
+        cycle.Apply(false, 2, 1);
+
+        cycle.Apply(true, 2, 1);
+
+        Assert.Equal([DutyStep.Start, DutyStep.WarmUp, DutyStep.Sample, DutyStep.LastSample], Run(cycle, 4));
+    }
+
+    [Fact]
+    public void Apply_Takes_ANewDutyCycle_AndClampsItTheSameWay()
+    {
+        DutyCycle cycle = new(30, 10);
+
+        cycle.Apply(true, 100000, 0);
+
+        Assert.Equal(DutyCycle.MaximumBurstTicks, cycle.BurstTicks);
+        Assert.Equal(DutyCycle.MinimumIntervalSeconds, cycle.IntervalSeconds);
+    }
+}
diff --git a/Pulse.Tests/TickAttributionTests.cs b/Pulse.Tests/TickAttributionTests.cs
index 7707699..929ad52 100644
--- a/Pulse.Tests/TickAttributionTests.cs
+++ b/Pulse.Tests/TickAttributionTests.cs
@@ -6,6 +6,9 @@
 
 namespace Pulse.Tests;
 
+/// <summary>Attribution's own arithmetic, and what it does with each step of its duty cycle: which
+/// tick's tree it folds, when it publishes, what it drops when the cycle is restarted. The schedule
+/// alone is <c>DutyCycleTests</c>'s.</summary>
 public class TickAttributionTests
 {
     /// <summary>One profiled tick as the engine leaves it: a thousand ticks of wall time, four
@@ -60,19 +63,8 @@ private static AttributionBurst Cycle(TickAttribution attribution, ProfileEntryR
     private static double Share(AttributionBurst burst, string modid)
         => burst.Seconds.Single(entry => entry.Key == modid).Value / burst.BusySeconds;
 
-    [Fact]
-    public void Constructor_Floors_TheIntervalAndTheBurstLength()
-    {
-        TickAttribution attribution = new(0, 0);
-
-        Assert.Equal(1, attribution.BurstTicks);
-        Assert.Equal(TickAttribution.MinimumIntervalSeconds, attribution.IntervalSeconds);
-    }
-
-    [Fact]
-    public void Constructor_Caps_TheBurstLength()
-        => Assert.Equal(TickAttribution.MaximumBurstTicks, new TickAttribution(100000, 10).BurstTicks);
-
+    /// <summary>The cycle's own clamping is <c>DutyCycleTests</c>'s. What this checks is that the two
+    /// numbers reach the cycle the right way round, and come back out of it.</summary>
     [Fact]
     public void Constructor_Keeps_AConfiguredDutyCycle()
     {
@@ -82,21 +74,6 @@ public void Constructor_Keeps_AConfiguredDutyCycle()
         Assert.Equal(10, attribution.IntervalSeconds);
     }
 
-    [Fact]
-    public void OnTick_LeavesTheProfilerOff_UntilTheIntervalHasPassed()
-    {
-        TickAttribution attribution = new(5, 10);
-
-        for (int tick = 0; tick < 9; tick++)
-        {
-            Assert.Null(attribution.OnTick(1.0, Tick(), Owners));
-            Assert.False(attribution.Profiling);
-        }
-
-        Assert.Null(attribution.OnTick(1.0, Tick(), Owners));
-        Assert.True(attribution.Profiling);
-    }
-
     /// <summary>The tick that turns the profiler on never got its Begin(), so the tree it ends with
     /// is whatever the last burst left behind. Folding it would count that stale tick again.</summary>
     [Fact]
@@ -290,17 +267,6 @@ public void Apply_Discards_TheStaleSample_WhenItIsSwitchedBackOn()
         Assert.Equal(1, burst.Ticks);
     }
 
-    [Fact]
-    public void Apply_Takes_ANewDutyCycle_AndClampsItTheSameWay()
-    {
-        TickAttribution attribution = new(30, 10);
-
-        attribution.Apply(true, 100000, 0);
-
-        Assert.Equal(TickAttribution.MaximumBurstTicks, attribution.BurstTicks);
-        Assert.Equal(TickAttribution.MinimumIntervalSeconds, attribution.IntervalSeconds);
-    }
-
     /// <summary>What <c>/pulse attribution status</c> reports, and it has to match the tick counter
     /// on the wire: both count the ticks completed bursts folded.</summary>
     [Fact]
diff --git a/Pulse/DutyCycle.cs b/Pulse/DutyCycle.cs
new file mode 100644
index 0000000..51f68a9
--- /dev/null
+++ b/Pulse/DutyCycle.cs
@@ -0,0 +1,129 @@
+namespace Pulse;
+
+/// <summary>The schedule of a measurement too costly to leave running: idle for an interval, then
+/// a burst of consecutive ticks, then idle again.</summary>
+/// <remarks>Only the schedule. It is told how long each tick took and says what this tick is for
+/// (<see cref="DutyStep"/>); what a burst switches on, what it reads and where it publishes is the
+/// caller's, and nothing here knows about meters, the server or the engine. That is what makes the
+/// whole schedule drivable from a unit test, and what lets every measurement that runs in bursts
+/// share it instead of writing it out again.
+/// <para>A burst starts on one tick, spends the next as a warm-up, and takes
+/// <see cref="BurstTicks"/> samples after that. The warm-up exists because whatever the caller
+/// switches on at the start is switched on part-way through that tick, and what the caller reads at
+/// the start of the next one describes the tick before: a tick only partly covered, so it never
+/// counts. Every sample counts toward the burst whatever the caller managed to read on it, so a
+/// burst always ends.</para></remarks>
+internal sealed class DutyCycle
+{
+    /// <summary>Shortest interval between bursts. The duty cycle is the whole reason a measurement
+    /// like this is affordable, so it stays a duty cycle.</summary>
+    public const int MinimumIntervalSeconds = 1;
+
+    /// <summary>Longest burst. Ten seconds at the default tick rate, which is already far more than
+    /// tick composition varies over.</summary>
+    public const int MaximumBurstTicks = 300;
+
+    private double idleSeconds;
+    private int burstTicksElapsed;
+    private bool warm;
+
+    public DutyCycle(int burstTicks, int intervalSeconds, bool enabled = true)
+        => Apply(enabled, burstTicks, intervalSeconds);
+
+    /// <summary>Whether the cycle runs at all. Off, every tick is <see cref="DutyStep.Idle"/>.</summary>
+    public bool Enabled { get; private set; }
+
+    /// <summary>Samples per burst, not counting the warm-up.</summary>
+    public int BurstTicks { get; private set; }
+
+    /// <summary>Seconds between the end of one burst and the start of the next.</summary>
+    public int IntervalSeconds { get; private set; }
+
+    /// <summary>Whether a burst is running as of the last tick: true after a start, a warm-up and a
+    /// sample, false after an idle tick and after the last sample, which ends the burst.</summary>
+    public bool InBurst { get; private set; }
+
+    /// <summary>Takes a cycle, clamped the way the config file's is, and starts it over.</summary>
+    /// <remarks>Restarting rather than adjusting in place is what makes switching this off
+    /// mid-burst safe: the burst in progress is dropped instead of finished, and a later switch-on
+    /// begins from idle with the whole interval still to wait. A new interval or burst length
+    /// applied to a running cycle restarts it the same way.</remarks>
+    public void Apply(bool enabled, int burstTicks, int intervalSeconds)
+    {
+        Enabled = enabled;
+        BurstTicks = Math.Clamp(burstTicks, 1, MaximumBurstTicks);
+        IntervalSeconds = Math.Max(MinimumIntervalSeconds, intervalSeconds);
+        Restart();
+    }
+
+    /// <summary>Advances the schedule by one tick of <paramref name="elapsedSeconds"/> and says
+    /// what the caller does with it.</summary>
+    public DutyStep OnTick(double elapsedSeconds)
+    {
+        if (!Enabled)
+        {
+            return DutyStep.Idle;
+        }
+
+        if (!InBurst)
+        {
+            idleSeconds += elapsedSeconds;
+            if (idleSeconds < IntervalSeconds)
+            {
+                return DutyStep.Idle;
+            }
+
+            idleSeconds = 0;
+            burstTicksElapsed = 0;
+            warm = false;
+            InBurst = true;
+            return DutyStep.Start;
+        }
+
+        if (!warm)
+        {
+            warm = true;
+            return DutyStep.WarmUp;
+        }
+
+        if (++burstTicksElapsed < BurstTicks)
+        {
+            return DutyStep.Sample;
+        }
+
+        Restart();
+        return DutyStep.LastSample;
+    }
+
+    /// <summary>Back to idle, with the interval counted from now.</summary>
+    private void Restart()
+    {
+        InBurst = false;
+        idleSeconds = 0;
+        burstTicksElapsed = 0;
+        warm = false;
+    }
+}
+
+/// <summary>What one tick of a <see cref="DutyCycle"/> asks of whoever owns the work.</summary>
+internal enum DutyStep
+{
+    /// <summary>Nothing: the cycle is off, or still waiting out its interval.</summary>
+    Idle,
+
+    /// <summary>The interval has passed and a burst starts on this tick: whatever the burst needs
+    /// switched on gets switched on now.</summary>
+    Start,
+
+    /// <summary>The tick after the start. What the caller reads on it describes the tick the burst
+    /// started in, which was only partly covered, so it is not a sample.</summary>
+    WarmUp,
+
+    /// <summary>A tick of the burst to read a sample on.</summary>
+    Sample,
+
+    /// <summary>The burst's last sample, read the same way as any other. The burst is over by the
+    /// time this is returned: the cycle is idle again and <see cref="DutyCycle.InBurst"/> is
+    /// false.</summary>
+    LastSample,
+}
diff --git a/Pulse/TickAttribution.cs b/Pulse/TickAttribution.cs
index 4c686c9..2cc7553 100644
--- a/Pulse/TickAttribution.cs
+++ b/Pulse/TickAttribution.cs
@@ -8,9 +8,9 @@
 
 namespace Pulse;
 
-/// <summary>The duty cycle and the arithmetic behind per-mod tick attribution: when the engine's
-/// frame profiler should be running, and how one profiled tick's mark tree becomes seconds per
-/// mod.</summary>
+/// <summary>The arithmetic behind per-mod tick attribution, on the schedule of a
+/// <see cref="DutyCycle"/>: when the engine's frame profiler should be running, and how one
+/// profiled tick's mark tree becomes seconds per mod.</summary>
 /// <remarks>Knows nothing about meters, the server or the profiler flag itself. It is handed the
 /// previous tick's completed tree and says whether the profiler should be on when the current tick
 /// ends, which is what makes the whole duty cycle drivable from a unit test.</remarks>
@@ -30,14 +30,6 @@ internal sealed class TickAttribution
     /// <c>PropertyName()</c>.</summary>
     public const string BehaviorPrefix = "done-behavior-";
 
-    /// <summary>Shortest interval between bursts. The duty cycle is the whole reason this is
-    /// affordable, so it stays a duty cycle.</summary>
-    public const int MinimumIntervalSeconds = 1;
-
-    /// <summary>Longest burst. Ten seconds of profiling at the default tick rate, which is already
-    /// far more than tick composition varies over.</summary>
-    public const int MaximumBurstTicks = 300;
-
     /// <summary>The engine's bucket for the throttle sleep, charged in <c>ServerMain.Process</c>
     /// (1.22.7:1553). It is the one root mark that is not work, so it is what busy time is measured
     /// against rather than attributed.</summary>
@@ -50,31 +42,31 @@ internal sealed class TickAttribution
     /// other mark in the tree is the engine's own.</summary>
     private static readonly string[] OwnedPrefixes = ["gmle", "gmlb", "dce", "dcb", "sdcb", BehaviorPrefix];
 
+    private readonly DutyCycle cycle;
+
     private readonly Dictionary<string, long> ticksByMod = [];
 
     /// <summary>Every mod that has appeared in any burst so far, so one that goes quiet publishes a
     /// zero instead of freezing its gauge at the share it had when it stopped.</summary>
     private readonly HashSet<string> seenMods = [];
 
-    private double idleSeconds;
-    private int burstTicksElapsed;
     private int sampled;
     private long busyTicks;
     private long dropped;
-    private bool warm;
 
     public TickAttribution(int burstTicks, int intervalSeconds, bool enabled = true)
-        => Apply(enabled, burstTicks, intervalSeconds);
+        => cycle = new DutyCycle(burstTicks, intervalSeconds, enabled);
 
     /// <summary>Whether the duty cycle runs at all.</summary>
-    public bool Enabled { get; private set; }
+    public bool Enabled => cycle.Enabled;
 
-    public int BurstTicks { get; private set; }
+    public int BurstTicks => cycle.BurstTicks;
 
-    public int IntervalSeconds { get; private set; }
+    public int IntervalSeconds => cycle.IntervalSeconds;
 
-    /// <summary>Whether the engine's frame profiler has to be enabled when the current tick ends.</summary>
-    public bool Profiling { get; private set; }
+    /// <summary>Whether the engine's frame profiler has to be enabled when the current tick ends:
+    /// exactly while the duty cycle is inside a burst.</summary>
+    public bool Profiling => cycle.InBurst;
 
     /// <summary>Ticks folded into a completed burst since the server booted, which is the number
     /// <c>pulse_attribution_ticks_total</c> reports.</summary>
@@ -86,10 +78,8 @@ public TickAttribution(int burstTicks, int intervalSeconds, bool enabled = true)
     /// back off on the next tick, and a later switch-on begins from a clean burst.</remarks>
     public void Apply(bool enabled, int burstTicks, int intervalSeconds)
     {
-        Enabled = enabled;
-        BurstTicks = Math.Clamp(burstTicks, 1, MaximumBurstTicks);
-        IntervalSeconds = Math.Max(MinimumIntervalSeconds, intervalSeconds);
-        Restart();
+        cycle.Apply(enabled, burstTicks, intervalSeconds);
+        ClearBurst();
     }
 
     /// <summary>Advances the duty cycle by one tick, folding <paramref name="previousTick"/> when
@@ -97,48 +87,25 @@ public void Apply(bool enabled, int burstTicks, int intervalSeconds)
     /// one.</summary>
     public AttributionBurst? OnTick(double elapsedSeconds, ProfileEntryRange? previousTick, OwnerLookup owner)
     {
-        if (!Enabled)
-        {
-            return null;
-        }
+        DutyStep step = cycle.OnTick(elapsedSeconds);
 
-        if (!Profiling)
+        // Idle, the start and the warm-up carry nothing to fold. On the warm-up, the previous tick
+        // is the one the profiler was switched on part-way through: it never got its Begin(), and
+        // the tree it ended with is whatever the last burst left in the profiler. One stale sample
+        // per burst, discarded here rather than folded.
+        if (step is not (DutyStep.Sample or DutyStep.LastSample))
         {
-            idleSeconds += elapsedSeconds;
-            if (idleSeconds < IntervalSeconds)
-            {
-                return null;
-            }
-
-            idleSeconds = 0;
-            burstTicksElapsed = 0;
-            warm = false;
-            Profiling = true;
-            return null;
-        }
-
-        // The profiler was switched on part-way through the previous tick, so that tick never got
-        // its Begin() and the tree it ended with is whatever the last burst left in the profiler.
-        // One stale sample per burst, discarded here rather than folded.
-        if (!warm)
-        {
-            warm = true;
             return null;
         }
 
+        // The cycle counted this sample whether or not there was a tree to read, so a burst always
+        // ends and the profiler always goes back off.
         if (previousTick != null)
         {
             Fold(previousTick, owner);
         }
 
-        // Counted whether or not there was a tree to read, so a burst always ends and the profiler
-        // always goes back off.
-        if (++burstTicksElapsed < BurstTicks)
-        {
-            return null;
-        }
-
-        return Take();
+        return step == DutyStep.LastSample ? Take() : null;
     }
 
     /// <summary>Folds one completed tick's tree into the burst.</summary>
@@ -228,7 +195,8 @@ private void Add(string modid, long ticks)
         ticksByMod[modid] = accumulated + ticks;
     }
 
-    /// <summary>Closes the burst and starts the next one empty.</summary>
+    /// <summary>Closes the burst and starts the next one empty. The duty cycle has already gone
+    /// back to idle by the time this runs, so the profiler is off from the next tick.</summary>
     private AttributionBurst Take()
     {
         double frequency = Stopwatch.Frequency;
@@ -241,20 +209,16 @@ private AttributionBurst Take()
 
         AttributionBurst burst = new(seconds, busyTicks / frequency, sampled, dropped);
         TicksProfiled += sampled;
-        Restart();
+        ClearBurst();
         return burst;
     }
 
-    /// <summary>Back to idle with nothing accumulated, and the profiler off from the next tick.</summary>
+    /// <summary>Nothing accumulated: what a burst gathers so far is dropped.</summary>
     /// <remarks>Everything a burst gathers is dropped here, but <c>seenMods</c> is not: a mod that
     /// has been measured once keeps publishing a zero rather than freezing its gauge, whether the
     /// burst ended on its own or an operator cut it short.</remarks>
-    private void Restart()
+    private void ClearBurst()
     {
-        Profiling = false;
-        idleSeconds = 0;
-        burstTicksElapsed = 0;
-        warm = false;
         ticksByMod.Clear();
         busyTicks = 0;
         sampled = 0;
diff --git a/tools/mutation-check.sh b/tools/mutation-check.sh
index bbdffb5..c0e2196 100755
--- a/tools/mutation-check.sh
+++ b/tools/mutation-check.sh
@@ -52,7 +52,7 @@ mutate() { # <file> <sed -E expression> <label>
     git checkout -- "$file"
 }
 
-MUTATED="Pulse/PrometheusText.cs Pulse/MetricsAggregator.cs Pulse/LogClassifier.cs Pulse/MetricsHttpServer.cs Pulse/TickBookkeeper.cs Pulse/EngineSample.cs Pulse/PingSummary.cs Pulse/EntityBreakdown.cs Pulse/SuspendBookkeeper.cs Pulse/TickAttribution.cs Pulse/ModOwners.cs Pulse/ConfigUpgrade.cs Pulse/ConfigLoad.cs Pulse/PulseCommands.cs Pulse/AttributionMetrics.cs Pulse.Otlp/OtlpOptions.cs Pulse.Otlp/ExportFailureLog.cs Pulse.Otlp/PulseOtlpModSystem.cs"
+MUTATED="Pulse/PrometheusText.cs Pulse/MetricsAggregator.cs Pulse/LogClassifier.cs Pulse/MetricsHttpServer.cs Pulse/TickBookkeeper.cs Pulse/EngineSample.cs Pulse/PingSummary.cs Pulse/EntityBreakdown.cs Pulse/SuspendBookkeeper.cs Pulse/DutyCycle.cs Pulse/TickAttribution.cs Pulse/ModOwners.cs Pulse/ConfigUpgrade.cs Pulse/ConfigLoad.cs Pulse/PulseCommands.cs Pulse/AttributionMetrics.cs Pulse.Otlp/OtlpOptions.cs Pulse.Otlp/ExportFailureLog.cs Pulse.Otlp/PulseOtlpModSystem.cs"
 
 if ! git diff --quiet -- $MUTATED; then
     echo "One of $MUTATED has uncommitted changes; refusing to mutate over them."
@@ -267,9 +267,9 @@ mutate Pulse/TickAttribution.cs \
     's/if \(entry\.ElapsedTicks < 0\)/if (entry.ElapsedTicks <= 0)/' \
     "attribution: the wrap clamp fires on a mark that legitimately took no time"
 
-mutate Pulse/TickAttribution.cs \
+mutate Pulse/DutyCycle.cs \
     's/if \(!warm\)/if (false)/' \
-    "attribution: the stale sample from the tick the profiler came on is folded instead of discarded"
+    "duty cycle: the tick after a burst starts is taken for a sample, so the stale one is folded instead of discarded"
 
 mutate Pulse/TickAttribution.cs \
     's/if \(mark\.Key == SleepMark\)/if (false)/' \
@@ -393,9 +393,9 @@ mutate Pulse/ConfigLoad.cs \
 # Switching attribution from a command is a promise about a live server: that a server which never
 # asked for it is not paying for it, that a reload names only what it could not apply, and that a
 # ten minute look does not quietly become permanent. All three fail silently when they are wrong.
-mutate Pulse/TickAttribution.cs \
+mutate Pulse/DutyCycle.cs \
     's/if \(!Enabled\)/if (false)/' \
-    "attribution: the duty cycle runs on a server that never switched it on"
+    "duty cycle: it runs on a server that never switched it on"
 
 mutate Pulse/AttributionMetrics.cs \
     's/\+\+unprimedTicks > UnprimedTickLimit/++unprimedTicks >= UnprimedTickLimit/' \

From dd8dbb45d0e4c5a88dde8fe2de0c87a328d4d411 Mon Sep 17 00:00:00 2001
From: Pixnop <77785313+Pixnop@users.noreply.github.com>
Date: Sun, 4 Oct 2026 22:39:13 +0200
Subject: [PATCH 2/3] Pin every branch of DutyCycle with a mutation

The schedule is the part every burst of every measurement will now run
on, so each way it can drift gets a mutation in tools/mutation-check.sh:
the idle branch, counting seconds rather than ticks, the interval
boundary, the burst length boundary, the end of a burst, what Apply
drops, and the three clamps. Attribution's own use of the steps gets
two more, and a third for a reload that has to take the half-folded
burst with it.

Four tests back them. A reload mid-interval restarts the interval from
the reload, which nothing checked before: the mutant that kept the idle
time already counted survived the old suite. The interval is counted in
seconds, so the class itself fails when it counts ticks. A reload that
leaves the cycle on drops the burst in progress the way a switch-off
does. And attribution drops what a cut-short burst had folded, which
used to be covered only because the burst end and the reload shared one
Restart.
---
 Pulse.Tests/DutyCycleTests.cs       | 37 +++++++++++++++++
 Pulse.Tests/TickAttributionTests.cs | 23 +++++++++++
 tools/mutation-check.sh             | 63 +++++++++++++++++++++++++++++
 3 files changed, 123 insertions(+)

diff --git a/Pulse.Tests/DutyCycleTests.cs b/Pulse.Tests/DutyCycleTests.cs
index 8cdf13c..24dccb7 100644
--- a/Pulse.Tests/DutyCycleTests.cs
+++ b/Pulse.Tests/DutyCycleTests.cs
@@ -57,6 +57,14 @@ public void OnTick_StaysIdle_UntilTheIntervalHasPassed()
         Assert.True(cycle.InBurst);
     }
 
+    /// <summary>The interval is seconds, not ticks: half-second ticks take twice as many to cross it,
+    /// and the burst starts on the one that lands exactly on it.</summary>
+    [Fact]
+    public void OnTick_CountsTheInterval_InSeconds()
+        => Assert.Equal(
+            [DutyStep.Idle, DutyStep.Idle, DutyStep.Idle, DutyStep.Start],
+            Run(new DutyCycle(5, 2), 4, 0.5));
+
     /// <summary>Whatever the caller switches on at the start is switched on part-way through that
     /// tick, so what it reads on the next one describes a tick only partly covered. That one is the
     /// warm-up, and it is not a sample.</summary>
@@ -135,6 +143,35 @@ public void Apply_Drops_ABurstInProgress_WhenItIsSwitchedOff()
         Assert.False(cycle.InBurst);
     }
 
+    /// <summary>A reload that leaves the cycle on drops the burst in progress the same way, and the
+    /// burst length it brings is the one the next burst runs.</summary>
+    [Fact]
+    public void Apply_Drops_ABurstInProgress_WhenItIsReapplied()
+    {
+        DutyCycle cycle = new(30, 1);
+        Run(cycle, 5);
+        Assert.True(cycle.InBurst);
+
+        cycle.Apply(true, 2, 1);
+
+        Assert.False(cycle.InBurst);
+        Assert.Equal([DutyStep.Start, DutyStep.WarmUp, DutyStep.Sample, DutyStep.LastSample], Run(cycle, 4));
+    }
+
+    /// <summary>A new interval is counted from the reload, not from whatever the old one had already
+    /// waited.</summary>
+    [Fact]
+    public void Apply_Restarts_TheInterval_OfARunningCycle()
+    {
+        DutyCycle cycle = new(5, 10);
+        Run(cycle, 6);
+
+        cycle.Apply(true, 5, 10);
+
+        Assert.All(Run(cycle, 9), step => Assert.Equal(DutyStep.Idle, step));
+        Assert.Equal(DutyStep.Start, cycle.OnTick(1.0));
+    }
+
     /// <summary>Switching back on starts a fresh cycle, so the burst begins with its warm-up again
     /// rather than carrying on from where the old one stopped.</summary>
     [Fact]
diff --git a/Pulse.Tests/TickAttributionTests.cs b/Pulse.Tests/TickAttributionTests.cs
index 929ad52..41baaa1 100644
--- a/Pulse.Tests/TickAttributionTests.cs
+++ b/Pulse.Tests/TickAttributionTests.cs
@@ -250,6 +250,29 @@ public void Apply_Drops_ABurstInProgress_WhenItIsSwitchedOff()
         Assert.False(attribution.Profiling);
     }
 
+    /// <summary>What a burst had folded when it was cut short, by a reload or by switching attribution
+    /// off and on, is thrown away with it: the next burst publishes its own samples and nothing of the
+    /// ones that were dropped.</summary>
+    [Fact]
+    public void Apply_Clears_WhatTheBurstInProgressHadFolded()
+    {
+        TickAttribution attribution = new(3, 1);
+
+        // The start, the warm-up and two of the three samples: cut short just before the last.
+        for (int tick = 0; tick < 4; tick++)
+        {
+            Assert.Null(attribution.OnTick(1.0, Tick(), Owners));
+        }
+
+        attribution.Apply(true, 3, 1);
+        AttributionBurst burst = Cycle(attribution, Tick(), Owners);
+        AttributionBurst fresh = Cycle(new TickAttribution(3, 1), Tick(), Owners);
+
+        Assert.Equal(fresh.Ticks, burst.Ticks);
+        Assert.Equal(fresh.BusySeconds, burst.BusySeconds, 12);
+        Assert.Equal(fresh.Seconds, burst.Seconds);
+    }
+
     /// <summary>Re-enabling starts a fresh cycle, so the stale tree the profiler left behind while
     /// it was off is discarded rather than folded into the first burst.</summary>
     [Fact]
diff --git a/tools/mutation-check.sh b/tools/mutation-check.sh
index c0e2196..4552dc4 100755
--- a/tools/mutation-check.sh
+++ b/tools/mutation-check.sh
@@ -283,6 +283,69 @@ mutate Pulse/TickAttribution.cs \
     's/foreach \(string modid in seenMods\.Order\(StringComparer\.Ordinal\)\)/foreach (string modid in ticksByMod.Keys.Order(StringComparer.Ordinal))/' \
     "attribution: a mod that goes quiet is dropped, freezing its share gauge at whatever it last read"
 
+# The duty cycle is the schedule every burst of every measurement runs on, so each way it can drift
+# is a measurement that quietly runs too often, too long, or on a tick it should have discarded.
+# Its warm-up and its enabled check are mutated elsewhere in this file, the two patterns that
+# pointed at TickAttribution before the schedule moved out of it; these are the rest of its
+# branches. That the idle phase is entered at all, that it counts seconds and starts exactly on the
+# interval, that a burst is exactly its length and then ends, that applying a cycle drops the burst
+# in progress and the idle time already counted, and the clamps every configured value goes
+# through.
+mutate Pulse/DutyCycle.cs \
+    's/if \(!InBurst\)/if (false)/' \
+    "duty cycle: the idle phase never runs, so nothing waits out the interval and a burst never starts"
+
+mutate Pulse/DutyCycle.cs \
+    's/idleSeconds \+= elapsedSeconds;/idleSeconds++;/' \
+    "duty cycle: the interval counts ticks instead of the seconds they took"
+
+mutate Pulse/DutyCycle.cs \
+    's/if \(idleSeconds < IntervalSeconds\)/if (idleSeconds <= IntervalSeconds)/' \
+    "duty cycle: the interval boundary is inclusive, so a burst due exactly on it waits one more tick"
+
+mutate Pulse/DutyCycle.cs \
+    's/if \(\+\+burstTicksElapsed < BurstTicks\)/if (++burstTicksElapsed <= BurstTicks)/' \
+    "duty cycle: a burst takes one sample more than its length"
+
+mutate Pulse/DutyCycle.cs \
+    '/public DutyStep OnTick/,/^    }/s/Restart\(\);//' \
+    "duty cycle: the last sample leaves the burst running, so it never ends and the interval is never waited again"
+
+mutate Pulse/DutyCycle.cs \
+    '/public void Apply/,/^    }/s/Restart\(\);//' \
+    "duty cycle: applying a cycle leaves the burst in progress running instead of dropping it"
+
+mutate Pulse/DutyCycle.cs \
+    '/private void Restart/,/^    }/s/idleSeconds = 0;//' \
+    "duty cycle: a reload keeps the idle time the old interval had already counted"
+
+mutate Pulse/DutyCycle.cs \
+    's/Math\.Clamp\(burstTicks, 1, MaximumBurstTicks\)/Math.Max(1, burstTicks)/' \
+    "duty cycle: the burst length cap is gone, so a configured burst of any length runs"
+
+mutate Pulse/DutyCycle.cs \
+    's/Math\.Clamp\(burstTicks, 1, MaximumBurstTicks\)/Math.Min(burstTicks, MaximumBurstTicks)/' \
+    "duty cycle: the burst length floor is gone, so a burst of no ticks is accepted"
+
+mutate Pulse/DutyCycle.cs \
+    's/Math\.Max\(MinimumIntervalSeconds, intervalSeconds\)/intervalSeconds/' \
+    "duty cycle: the interval floor is gone, so a zero interval starts a burst on every tick"
+
+# What attribution does with each step is its own: reading the warm-up as a sample counts a tree
+# that is not this burst's, never closing on the last sample publishes nothing at all, and a cycle
+# restarted mid-burst has to take what the burst had folded with it.
+mutate Pulse/TickAttribution.cs \
+    's/if \(step is not \(DutyStep\.Sample or DutyStep\.LastSample\)\)/if (step == DutyStep.Idle)/' \
+    "attribution: a start or a warm-up is read as a sample too, so the stale tree from the tick the profiler came on is folded"
+
+mutate Pulse/TickAttribution.cs \
+    's/return step == DutyStep\.LastSample \? Take\(\) : null;/return null;/' \
+    "attribution: the last sample never closes the burst, so nothing is ever published"
+
+mutate Pulse/TickAttribution.cs \
+    '/public void Apply/,/^    }/s/ClearBurst\(\);//' \
+    "attribution: a reload mid-burst keeps the half-folded sample, so the next burst publishes the ticks that were dropped too"
+
 mutate Pulse/ModOwners.cs \
     's/byName\[name\] = resolved;//' \
     "mod owners: a class registry miss is asked again on every profiled tick"

From acaddd0104e55a869a31ebecc9e412cea1873f63 Mon Sep 17 00:00:00 2001
From: Pixnop <77785313+Pixnop@users.noreply.github.com>
Date: Sun, 4 Oct 2026 23:23:38 +0200
Subject: [PATCH 3/3] Leave the resets of a burst to Restart and pin the
 documented clamps

The start of a burst reset the idle time, the sample count and the warm-up flag that Restart had already reset when the previous burst ended or the cycle was applied, so neither copy could be pinned by a mutation. Restart now owns them, with a mutation each. The cap and floor tests compared against the constants themselves, so a moved cap passed; they now assert the 300 ticks and 1 second the README documents. The burst end's ClearBurst gets the mutation Apply's already had, and the duty cycle mutations sit in one block.
---
 Pulse.Tests/DutyCycleTests.cs |  8 ++++----
 Pulse/DutyCycle.cs            |  3 ---
 Pulse/TickAttribution.cs      |  8 ++++----
 tools/mutation-check.sh       | 30 ++++++++++++++++++++----------
 4 files changed, 28 insertions(+), 21 deletions(-)

diff --git a/Pulse.Tests/DutyCycleTests.cs b/Pulse.Tests/DutyCycleTests.cs
index 24dccb7..479eaf4 100644
--- a/Pulse.Tests/DutyCycleTests.cs
+++ b/Pulse.Tests/DutyCycleTests.cs
@@ -25,12 +25,12 @@ public void Constructor_Floors_TheIntervalAndTheBurstLength()
         DutyCycle cycle = new(0, 0);
 
         Assert.Equal(1, cycle.BurstTicks);
-        Assert.Equal(DutyCycle.MinimumIntervalSeconds, cycle.IntervalSeconds);
+        Assert.Equal(1, cycle.IntervalSeconds);
     }
 
     [Fact]
     public void Constructor_Caps_TheBurstLength()
-        => Assert.Equal(DutyCycle.MaximumBurstTicks, new DutyCycle(100000, 10).BurstTicks);
+        => Assert.Equal(300, new DutyCycle(100000, 10).BurstTicks);
 
     [Fact]
     public void Constructor_Keeps_AConfiguredDutyCycle()
@@ -193,7 +193,7 @@ public void Apply_Takes_ANewDutyCycle_AndClampsItTheSameWay()
 
         cycle.Apply(true, 100000, 0);
 
-        Assert.Equal(DutyCycle.MaximumBurstTicks, cycle.BurstTicks);
-        Assert.Equal(DutyCycle.MinimumIntervalSeconds, cycle.IntervalSeconds);
+        Assert.Equal(300, cycle.BurstTicks);
+        Assert.Equal(1, cycle.IntervalSeconds);
     }
 }
diff --git a/Pulse/DutyCycle.cs b/Pulse/DutyCycle.cs
index 51f68a9..db94502 100644
--- a/Pulse/DutyCycle.cs
+++ b/Pulse/DutyCycle.cs
@@ -73,9 +73,6 @@ public DutyStep OnTick(double elapsedSeconds)
                 return DutyStep.Idle;
             }
 
-            idleSeconds = 0;
-            burstTicksElapsed = 0;
-            warm = false;
             InBurst = true;
             return DutyStep.Start;
         }
diff --git a/Pulse/TickAttribution.cs b/Pulse/TickAttribution.cs
index 2cc7553..88b10d4 100644
--- a/Pulse/TickAttribution.cs
+++ b/Pulse/TickAttribution.cs
@@ -13,7 +13,7 @@ namespace Pulse;
 /// profiled tick's mark tree becomes seconds per mod.</summary>
 /// <remarks>Knows nothing about meters, the server or the profiler flag itself. It is handed the
 /// previous tick's completed tree and says whether the profiler should be on when the current tick
-/// ends, which is what makes the whole duty cycle drivable from a unit test.</remarks>
+/// ends.</remarks>
 internal sealed class TickAttribution
 {
     /// <summary>Everything the engine spends on itself: its own server systems, the time between
@@ -214,9 +214,9 @@ private AttributionBurst Take()
     }
 
     /// <summary>Nothing accumulated: what a burst gathers so far is dropped.</summary>
-    /// <remarks>Everything a burst gathers is dropped here, but <c>seenMods</c> is not: a mod that
-    /// has been measured once keeps publishing a zero rather than freezing its gauge, whether the
-    /// burst ended on its own or an operator cut it short.</remarks>
+    /// <remarks>Not <c>seenMods</c>: a mod that has been measured once keeps publishing a zero
+    /// rather than freezing its gauge, whether the burst ended on its own or an operator cut it
+    /// short.</remarks>
     private void ClearBurst()
     {
         ticksByMod.Clear();
diff --git a/tools/mutation-check.sh b/tools/mutation-check.sh
index 4552dc4..7c2b419 100755
--- a/tools/mutation-check.sh
+++ b/tools/mutation-check.sh
@@ -267,10 +267,6 @@ mutate Pulse/TickAttribution.cs \
     's/if \(entry\.ElapsedTicks < 0\)/if (entry.ElapsedTicks <= 0)/' \
     "attribution: the wrap clamp fires on a mark that legitimately took no time"
 
-mutate Pulse/DutyCycle.cs \
-    's/if \(!warm\)/if (false)/' \
-    "duty cycle: the tick after a burst starts is taken for a sample, so the stale one is folded instead of discarded"
-
 mutate Pulse/TickAttribution.cs \
     's/if \(mark\.Key == SleepMark\)/if (false)/' \
     "attribution: the throttle sleep is attributed as if it were work"
@@ -285,12 +281,10 @@ mutate Pulse/TickAttribution.cs \
 
 # The duty cycle is the schedule every burst of every measurement runs on, so each way it can drift
 # is a measurement that quietly runs too often, too long, or on a tick it should have discarded.
-# Its warm-up and its enabled check are mutated elsewhere in this file, the two patterns that
-# pointed at TickAttribution before the schedule moved out of it; these are the rest of its
-# branches. That the idle phase is entered at all, that it counts seconds and starts exactly on the
-# interval, that a burst is exactly its length and then ends, that applying a cycle drops the burst
-# in progress and the idle time already counted, and the clamps every configured value goes
-# through.
+mutate Pulse/DutyCycle.cs \
+    's/if \(!warm\)/if (false)/' \
+    "duty cycle: the tick after a burst starts is taken for a sample, so the stale one is folded instead of discarded"
+
 mutate Pulse/DutyCycle.cs \
     's/if \(!InBurst\)/if (false)/' \
     "duty cycle: the idle phase never runs, so nothing waits out the interval and a burst never starts"
@@ -319,6 +313,18 @@ mutate Pulse/DutyCycle.cs \
     '/private void Restart/,/^    }/s/idleSeconds = 0;//' \
     "duty cycle: a reload keeps the idle time the old interval had already counted"
 
+mutate Pulse/DutyCycle.cs \
+    '/private void Restart/,/^    }/s/burstTicksElapsed = 0;//' \
+    "duty cycle: the sample count carries over between bursts, so every burst after the first ends on its first sample"
+
+mutate Pulse/DutyCycle.cs \
+    '/private void Restart/,/^    }/s/warm = false;//' \
+    "duty cycle: the next burst skips its warm-up and folds the tree from the tick the profiler came on"
+
+mutate Pulse/DutyCycle.cs \
+    's/MaximumBurstTicks = 300;/MaximumBurstTicks = 299;/' \
+    "duty cycle: the burst cap the README documents moves"
+
 mutate Pulse/DutyCycle.cs \
     's/Math\.Clamp\(burstTicks, 1, MaximumBurstTicks\)/Math.Max(1, burstTicks)/' \
     "duty cycle: the burst length cap is gone, so a configured burst of any length runs"
@@ -346,6 +352,10 @@ mutate Pulse/TickAttribution.cs \
     '/public void Apply/,/^    }/s/ClearBurst\(\);//' \
     "attribution: a reload mid-burst keeps the half-folded sample, so the next burst publishes the ticks that were dropped too"
 
+mutate Pulse/TickAttribution.cs \
+    '/private AttributionBurst Take/,/^    }/s/ClearBurst\(\);//' \
+    "attribution: a published burst is not cleared, so the next one adds its ticks to the last one's"
+
 mutate Pulse/ModOwners.cs \
     's/byName\[name\] = resolved;//' \
     "mod owners: a class registry miss is asked again on every profiled tick"