diff --git a/Pulse.Tests/DutyCycleTests.cs b/Pulse.Tests/DutyCycleTests.cs
new file mode 100644
index 0000000..479eaf4
--- /dev/null
+++ b/Pulse.Tests/DutyCycleTests.cs
@@ -0,0 +1,199 @@
+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(1, cycle.IntervalSeconds);
+    }
+
+    [Fact]
+    public void Constructor_Caps_TheBurstLength()
+        => Assert.Equal(300, 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>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>
+    [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>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]
+    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(300, cycle.BurstTicks);
+        Assert.Equal(1, cycle.IntervalSeconds);
+    }
+}
diff --git a/Pulse.Tests/TickAttributionTests.cs b/Pulse.Tests/TickAttributionTests.cs
index 7707699..41baaa1 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]
@@ -273,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]
@@ -290,17 +290,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..db94502
--- /dev/null
+++ b/Pulse/DutyCycle.cs
@@ -0,0 +1,126 @@
+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;
+            }
+
+            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..88b10d4 100644
--- a/Pulse/TickAttribution.cs
+++ b/Pulse/TickAttribution.cs
@@ -8,12 +8,12 @@
 
 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>
+/// ends.</remarks>
 internal sealed class TickAttribution
 {
     /// <summary>Everything the engine spends on itself: its own server systems, the time between
@@ -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>
-    /// <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()
+    /// <summary>Nothing accumulated: what a burst gathers so far is dropped.</summary>
+    /// <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()
     {
-        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 535d829..5a59be1 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."
@@ -290,10 +290,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/TickAttribution.cs \
-    's/if \(!warm\)/if (false)/' \
-    "attribution: the stale sample from the tick the profiler came on 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"
@@ -306,6 +302,83 @@ 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.
+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"
+
+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 \
+    '/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"
+
+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/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"
@@ -416,9 +489,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/' \