@@ -75,20 +75,28 @@ settles. NVIDIA doesn't document this; measured on an RTX 5090 under sustained l
   settle drops 5 mV lower; 16 MHz holds. On generations with ~15 MHz bins, 16 MHz is one bin and
   may fold — degrading to less clock at less voltage (the safe direction), which the post-apply
   report flags when the rise reads back collapsed.
-- **A level flat can read back as a two-step staircase**: a flat written near a bin edge can keep
-  its first anchor(s) at the written clock while the tail rounds a bin up (a 925 mV cap's flat of
-  2498: 935/940 mV read 2497, 945 mV+ read 2505). The plateau pinning the boost is then the tail,
-  and the settle follows it up — 940 mV instead of the aimed 930. A stable realized state, not a
-  thermal transient: the staircase and the settle hold unchanged from 45 to 61 C with the deltas
-  frozen, against a stock table matching the reference anchor-for-anchor. Which anchors round
-  which way isn't predictable from the written value alone (the same 2498 rounds both ways within
-  one write; a 2408 flat rounds up to 2415 uniformly), so the plan doesn't try to pre-compensate;
-  the post-apply report names the higher point from the read-back instead.
+- **A level flat can read back as a two-step staircase**: every anchor rounds onto its own
+  ~7.5 MHz clock bin, and a flat written near a bin edge can keep its first anchor(s) at the
+  written clock while the tail rounds a bin up (a 925 mV cap's flat of 2498: 935/940 mV read
+  2497, 945 mV+ read 2505). The plateau pinning the boost is then the tail, and the settle
+  follows it up — 940 mV instead of the aimed 930. Which anchors round which way isn't
+  predictable from the written value alone (the same 2498 rounds both ways within one write; a
+  2408 flat rounds up to 2415 uniformly), but at a fixed thermal state the rounding is
+  deterministic and readable back in milliseconds — so the apply probes nearby (cap, flat) pairs
+  against their read-backs until the realized settle is the plan's (`CurveRefinement`; one or two
+  extra writes in the measured cases), keeping the closest attempt when nothing lands.
+- **The effective curve steps with temperature, per anchor, deltas frozen**: anchors cross
+  individual thresholds where their realized clock moves one bin (measured: 885 mV at ~52 C, the
+  890-915 mV region at ~58-61 C, the 925-965 mV window stable to 61 C). A point landed at apply
+  time holds only while the operating temperature stays on the same side of the nearby
+  thresholds: at 60 C under load a cool-applied 925 mV cap held its point exactly, while a
+  cool-applied 890 mV cap settled a step higher. Irreducible without probing at operating
+  temperature — the status line reads the live slice and says where the boost sits now.
 
 `GpuTuning.BuildCurvePlan` therefore writes the cap→flat segment as a straight line through
 (settle voltage, requested clock) with a fixed 16 MHz rise: the smallest the driver keeps, and a
-bound on the realized miss at half of it — one bin more when the flat's tail rounds up, which the
-report calls out. On a 10 mV gap this operates the card 5 mV above the
+bound on the realized miss at half of it, with the post-write refinement absorbing the bin
+rounding. On a 10 mV gap this operates the card 5 mV above the
 named cap (`--mv 900` runs at 905 mV); keeping the voltage at or under the cap would cost a
 stock-slope step of clock, the worse side of the trade.
 
 
@@ -27,18 +27,20 @@ public void PlainCap_WritesTheStraddle_AndFlattensAbove()
         Assert.Equal(0, exitCode);
         App.AssertWriteConfirmed(output);
 
-        // The shape signature, exact in the written deltas: the cap anchor and the band below share
-        // one offset at most a spread below stock (the segment is aimed so the settle voltage holds
-        // the stock clock, which writes the cap anchor a little under it), the flat top starts
-        // exactly the fixed 16 MHz spread above the cap anchor, and everything from there up is one
-        // level plateau. A flatten-at-the-cap shape would leave no rise between k and k+1; the
+        // The shape signature in the written deltas: the cap anchor and the band below share one
+        // offset near a spread below stock (the segment is aimed so the settle voltage holds the
+        // stock clock, which writes the cap anchor a little under it), the flat top starts about
+        // the fixed 16 MHz spread above the cap anchor, and everything from there up is one level
+        // plateau. The rise and the cap offset carry a bin of slack each way: the post-write
+        // refinement may move either by a few MHz to land the settle on the card's bin grid. A
+        // flatten-at-the-cap shape would leave no rise between k and k+1; the
         // stock-slope-continued shape would show a stock-step rise instead of the fixed spread.
         int[] deltas = ReadDeltasAlignedWith(stock);
         Assert.Equal(deltas[k], deltas[k - 1]);
-        Assert.InRange(deltas[k], -16_000, 0);
+        Assert.InRange(deltas[k], -24_000, 8_000);
         long capAnchorKhz = stock[k].Mhz * 1000L + deltas[k];
         long flatTopKhz = stock[k + 1].Mhz * 1000L + deltas[k + 1];
-        Assert.Equal(16_000, flatTopKhz - capAnchorKhz);
+        Assert.InRange(flatTopKhz - capAnchorKhz, 8_000, 24_000);
         for (int i = k + 2; i < deltas.Length; i++)
         {
             Assert.Equal(flatTopKhz, stock[i].Mhz * 1000L + deltas[i]);
@@ -61,16 +63,18 @@ public void ReducedClockCap_WritesOneSharedOffset_FromTheBandThroughTheFlatStart
 
         // The cap anchor's offset is one value carried by the band below it - that shared offset is
         // what keeps the clock on a stock-parallel slope however deep the boost settles - and the
-        // flat top starts exactly the fixed 16 MHz spread above the cap anchor. Both equalities
-        // hold regardless of whether the run planned from the saved reference or a live read.
+        // flat top starts about the fixed 16 MHz spread above the cap anchor, with a bin of slack
+        // each way for the post-write refinement. Both hold regardless of whether the run planned
+        // from the saved reference or a live read.
         // The margin on the reduction is loose on purpose: planned from the saved reference, the
         // written delta is (live - reference) - 60, so the thermal gap between this run and the
         // reference capture rides on it; this only has to prove a real reduction landed.
         int[] deltas = ReadDeltasAlignedWith(stock);
         Assert.True(deltas[k] < -20_000, $"the cap anchor's delta ({deltas[k]} kHz) is not the requested reduction");
         Assert.Equal(deltas[k], deltas[k - 1]);
-        Assert.Equal(16_000,
-            (stock[k + 1].Mhz * 1000L + deltas[k + 1]) - (stock[k].Mhz * 1000L + deltas[k]));
+        Assert.InRange(
+            (stock[k + 1].Mhz * 1000L + deltas[k + 1]) - (stock[k].Mhz * 1000L + deltas[k]),
+            8_000, 24_000);
     }
 
     [SkippableFact]
@@ -102,18 +106,18 @@ public void Status_WhileCapped_ReportsTheOperatingPoint()
 
         var (exitCode, output) = App.Run(null, "status");
 
-        // The status line names the point the boost settles on: at or above the cap point, with
-        // wide-but-bounded slack upward. The driver can round the written flatten's tail a bin
-        // up, which starts the pinning plateau - and moves the inferred point - a few anchors
-        // above the written flat start (the post-apply report carries a note when it does); a
-        // read at a temperature away from the reference can seam the flat's edge similarly. The
-        // settle-law physics itself is LoadTests' subject; this asserts status reports a sane
-        // point near the cap.
+        // The status line names the point the boost settles on. The apply refines its write
+        // against the read-back until the realized point is the plan's settle (one boost step
+        // below the flat start, floored at the cap), so a same-power-state status read moments
+        // later reports that point - one boost step of slack each way covers an anchor stepping
+        // with temperature between the two reads, and a refinement that ran out of probes on a
+        // knife-edge write. The settle-law physics itself is LoadTests' subject.
         Assert.Equal(0, exitCode);
         Match m = Regex.Match(output, @"operating point (\d+) mV");
         Assert.True(m.Success, $"no 'operating point' report in: {output}");
+        int settleMv = Math.Max(stock[k].Mv, stock[k + 1].Mv - GpuTuning.BoostStepMv);
         Assert.InRange(int.Parse(m.Groups[1].Value, CultureInfo.InvariantCulture),
-            stock[k].Mv - GpuTuning.BoostStepMv, stock[k].Mv + 25);
+            settleMv - GpuTuning.BoostStepMv, settleMv + GpuTuning.BoostStepMv);
     }
 
     [SkippableFact]
 
@@ -0,0 +1,158 @@
+namespace SimpleNvidiaUndervolt;
+
+/// <summary>
+/// The post-write refinement of a planned curve write. The driver realizes written clocks by
+/// rounding every anchor onto its own clock bin, and a flat written near a bin edge can realize
+/// as a staircase whose plateau — and so the boost's settle point — sits a step above the plan's
+/// promise (see DEVELOPMENT.md, "Where the boost settles"). No value-level rule predicts the
+/// rounding, but it is deterministic at a fixed thermal state and readable back in milliseconds,
+/// so the exact write is found by probing: when the plan's own write misses its operating point,
+/// nearby (cap, flat) pairs are written and judged against their read-backs, keeping the best
+/// realization — measured, never modeled, so it carries no constants from any one card. The
+/// budget is small and the values move by less than a bin, and a probe sequence that never lands
+/// keeps the closest attempt: the refinement can only improve on the plan's write, and the
+/// realized point is reported from the final read-back either way. What it cannot beat is the
+/// thermal slice: anchors step with temperature, so a point landed at apply time can still sit a
+/// step away at operating temperature — physics the report's notes carry, not error.
+/// </summary>
+internal static class CurveRefinement
+{
+    /// <summary>Extra writes the probing may spend after the plan's own. The measured cases
+    /// converge in one or two; the budget covers a full bin of flat values either way.</summary>
+    internal const int MaxExtraWrites = 8;
+
+    /// <summary>The clock slack an on-target realization may keep: half a read-back bin — the
+    /// resolution the effective curve reports at, so probing below it chases noise.</summary>
+    internal const int ClockToleranceMhz = 4;
+
+    /// <summary>What the refinement left on the card: the deltas the final write holds (also
+    /// copied into the plan's array by <see cref="GpuTuning.Apply"/>), the settle point of the
+    /// final read-back (null when it wasn't readable), how many extra writes were spent, and
+    /// whether the point is the plan's own.</summary>
+    internal sealed record Outcome(int[] DeltasKhz, (int Mv, int Mhz)? Realized, int ExtraWrites,
+        bool OnTarget);
+
+    /// <summary>
+    /// Judges the plan's write by <paramref name="planReadBack"/> and, when its realized settle
+    /// point misses the plan's, probes alternative (cap, flat) pairs through
+    /// <paramref name="apply"/> — which writes a delta array and returns the effective read-back.
+    /// Candidates come from the read-back itself (the flat re-aimed at the value its first anchor
+    /// realized, the cap re-centered to keep the settle clock) with a small scan as fallback.
+    /// Ends on the best-scoring pair, re-applied if a later probe overwrote it; the outcome's
+    /// realization is always the final read-back's, so a thermal step between probes can't leave
+    /// a stale claim behind.
+    /// </summary>
+    public static Outcome Refine(Func<int[], IReadOnlyList<(int Mv, int Mhz)>> apply,
+        IReadOnlyList<(int Mv, int Mhz)> stock, GpuTuning.CurvePlan plan,
+        IReadOnlyList<(int Mv, int Mhz)> planReadBack)
+    {
+        (int Mv, int Mhz)? realized = GpuTuning.EffectiveOperatingPoint(planReadBack);
+        if (OnTarget(realized, plan))
+        {
+            return new Outcome(plan.DeltasKhz, realized, 0, true);
+        }
+
+        int bestScore = Score(realized, plan);
+        int[] bestDeltas = plan.DeltasKhz;
+        var bestRealized = realized;
+        int[] lastWritten = plan.DeltasKhz;
+        int writes = 0;
+
+        var tried = new HashSet<(int C, int V)> { (plan.CapMhz, plan.FlatMhz) };
+        foreach ((int c, int v) in Candidates(plan, planReadBack))
+        {
+            if (writes >= MaxExtraWrites)
+            {
+                break;
+            }
+
+            if (v <= c || !tried.Add((c, v)))
+            {
+                continue;
+            }
+
+            int[] deltas = DeltasFor(stock, plan, c, v);
+            IReadOnlyList<(int Mv, int Mhz)> effective = apply(deltas);
+            writes++;
+            lastWritten = deltas;
+
+            var r = GpuTuning.EffectiveOperatingPoint(effective);
+            int score = Score(r, plan);
+            if (score < bestScore)
+            {
+                (bestScore, bestDeltas, bestRealized) = (score, deltas, r);
+            }
+
+            if (OnTarget(r, plan))
+            {
+                return new Outcome(deltas, r, writes, true);
+            }
+        }
+
+        // Land on the best probed pair. Its realization is re-read rather than recalled: between
+        // probes an anchor can step with temperature, and the report must carry what the card
+        // holds now, not what this pair realized a moment ago.
+        if (!ReferenceEquals(lastWritten, bestDeltas))
+        {
+            bestRealized = GpuTuning.EffectiveOperatingPoint(apply(bestDeltas));
+            writes++;
+        }
+
+        return new Outcome(bestDeltas, bestRealized, writes, OnTarget(bestRealized, plan));
+    }
+
+    /// <summary>Whether a realization is the plan's settle point: the voltage exactly (settle
+    /// voltages move in whole boost steps, so any miss is a full step) and the clock within
+    /// read-back resolution.</summary>
+    internal static bool OnTarget((int Mv, int Mhz)? realized, GpuTuning.CurvePlan plan)
+        => realized is { } r && r.Mv == plan.SettleMv
+                             && Math.Abs(r.Mhz - plan.SettleMhz) <= ClockToleranceMhz;
+
+    /// <summary>The miss of a realization, for keep-best: clock error plus heavily weighted
+    /// voltage error — a settle step costs power at every operating second, a few MHz is within
+    /// read-back noise. An unreadable realization never wins.</summary>
+    private static int Score((int Mv, int Mhz)? realized, GpuTuning.CurvePlan plan)
+        => realized is { } r
+            ? Math.Abs(r.Mhz - plan.SettleMhz) + 4 * Math.Abs(r.Mv - plan.SettleMv)
+            : int.MaxValue;
+
+    /// <summary>The probe sequence: first the pairs the read-back suggests — the flat re-aimed at
+    /// the value its first anchor realized (the read-back is the local bin grid), with the cap
+    /// kept, re-centered so the settle-point clock stays on the request, and dropped a step — then
+    /// a flat-value scan around the plan's own, downward through one bin and one step up.</summary>
+    private static IEnumerable<(int C, int V)> Candidates(GpuTuning.CurvePlan plan,
+        IReadOnlyList<(int Mv, int Mhz)> planReadBack)
+    {
+        if (GpuTuning.PointAtVoltage(planReadBack, plan.FlatMv) is { } flatRead)
+        {
+            int vr = flatRead.Mhz;
+            yield return (plan.CapMhz, vr);
+            yield return (2 * plan.SettleMhz - vr, vr);
+            yield return (plan.CapMhz - 4, vr - 8);
+        }
+
+        for (int d = 1; d <= 6; d++)
+        {
+            yield return (plan.CapMhz, plan.FlatMhz - d);
+        }
+
+        yield return (plan.CapMhz, plan.FlatMhz + 1);
+        yield return (plan.CapMhz, plan.FlatMhz + 2);
+    }
+
+    /// <summary>The delta array for a probed (cap, flat) pair — the plan's own shape
+    /// (<see cref="GpuTuning.CapShapeMhz"/>) at the probed clocks, relative to the same stock
+    /// curve the plan was built from. Anchor 0 stays unwritten like every plan.</summary>
+    private static int[] DeltasFor(IReadOnlyList<(int Mv, int Mhz)> stock,
+        GpuTuning.CurvePlan plan, int capMhz, int flatMhz)
+    {
+        int[] newMhz = GpuTuning.CapShapeMhz(stock, plan.CapIndex, capMhz, flatMhz, plan.CapPoints);
+        var deltasKhz = new int[stock.Count];
+        for (int i = 1; i < stock.Count; i++)
+        {
+            deltasKhz[i] = (newMhz[i] - stock[i].Mhz) * 1000;
+        }
+
+        return deltasKhz;
+    }
+}