Refuse absolute-clock anchors when the backing stock read is floor-pinned

The inverted sibling of the previous commit: an entry carrying an
absolute clock (no offset) derives its offset as mhz minus the stock
clock at the anchor, and with no saved reference that stock source is
the same possibly idle-pinned baseline read. Deriving against the pinned
floor folds the pinning error into the offset - a mild target becomes a
positive delta of up to the anchor's whole stock clock - and the
resolved-clock bound structurally cannot catch it, because the resolved
value is the entry's own (plausible) clock by construction. Where the
false refusal failed loudly, this failed silently, in the overclocking
direction.

Only reachable with hand-written mhz-only documents (the tool's exports
always carry offsets); such an anchor now refuses with a pointer at
set-reference-curve, and a saved reference resolves it at any power
state.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01PACndXGEsXBAWWWjSvpJpW

Author: vuplea

src/TuningDocuments.cs

@@ -412,7 +412,9 @@ public static bool NamesGpu(string? gpuName, string? gpuPciIds)
     /// document: that is the structural guard against a different card's curve. An entry without
     /// an offset resolves it from its absolute clock against <paramref name="stock"/> — the saved
     /// reference curve, or a stock read, index-aligned with <paramref name="anchors"/> — invoked
-    /// lazily, so a document of plain offsets (every export this tool writes) never needs it.
+    /// lazily, so a document of plain offsets (every export this tool writes) never needs it —
+    /// and refused when the stock read backing it sits at the idle floor itself, where no offset
+    /// can be derived (save a reference curve instead).
     /// Each resolved clock is held to the planned path's plausible range — a replay must not
     /// write offsets no plan could have produced. The range's minimum is not enforced at anchors
     /// reading at the curve's floor clock (<see cref="GpuTuning.AtFloorClock"/>): at deep idle —
@@ -443,7 +445,26 @@ public static int[] ResolveCurveOffsetsKhz(TuningDoc doc, IReadOnlyList<(int Mv,
             int i = anchorIndices[e];
             CurveEntryDoc entry = entries[e];
 
-            long offsetMhz = entry.Offset ?? entry.Mhz!.Value - Stock()[i].Mhz;
+            // An absolute clock derives its offset from the anchor's stock clock, which a
+            // floor-pinned stock read doesn't hold - the derivation would fold the pinning error
+            // into the offset (a silent overclock by up to the anchor's whole stock clock), so
+            // it refuses instead. A saved reference curve, captured awake, resolves it.
+            long offsetMhz;
+            if (entry.Offset is { } offset)
+            {
+                offsetMhz = offset;
+            }
+            else if (GpuTuning.AtFloorClock(Stock(), i))
+            {
+                throw new CliError($"{what} sets an absolute clock at the {entry.Mv} mV anchor, "
+                    + "but the stock clock there currently reads at the idle floor, so the "
+                    + "offset to write can't be derived - retry with the card awake, or save a "
+                    + "reference curve first (set-reference-curve).");
+            }
+            else
+            {
+                offsetMhz = entry.Mhz!.Value - Stock()[i].Mhz;
+            }
 
             // A replay must not write what no plan could have produced (RunReplay holds the
             // memory offset to the same standard). The offset alone is bounded first, so a

tests/TuningDocumentsTests.cs

@@ -452,6 +452,39 @@ public void ResolveCurveOffsets_SkipsTheResolvedBoundOnAnUnreadableTable()
         Assert.Equal(-2_450_000, Resolve(doc, curve)[10]);
     }
 
+    [Fact]
+    public void ResolveCurveOffsets_RefusesAnAbsoluteClockAtAFloorPinnedAnchor()
+    {
+        // An absolute clock derives its offset from the stock clock at the anchor, which a
+        // floor-pinned stock read doesn't hold - deriving against the pinned 202 would turn a
+        // mild target into a huge positive delta. A named refusal, not a wrong write.
+        var idle = TestCurves.IdleFloorPinned(pinned: 8, floorMhz: 202);
+        var doc = new TuningDoc
+        {
+            Curve = new[] { new CurveEntryDoc { Mv = idle[5].Mv, Mhz = 900 } },
+        };
+
+        Assert.Throws<CliError>(() => Resolve(doc, idle));
+    }
+
+    [Fact]
+    public void ResolveCurveOffsets_ResolvesAnAbsoluteClockAgainstASavedReferenceAtIdle()
+    {
+        // With a saved reference the stock clock is known regardless of power state: the offset
+        // derives from the reference, and the pinned anchor's minimum exemption lets the small
+        // result through.
+        var idle = TestCurves.IdleFloorPinned(pinned: 8, floorMhz: 202);
+        var reference = TestCurves.Realistic();
+        var doc = new TuningDoc
+        {
+            Curve = new[] { new CurveEntryDoc { Mv = idle[5].Mv, Mhz = reference[5].Mhz - 120 } },
+        };
+
+        int[] deltasKhz = TuningDocuments.ResolveCurveOffsetsKhz(doc, idle, () => reference, "The tuning");
+
+        Assert.Equal(-120_000, deltasKhz[5]);
+    }
+
     private static int[] Resolve(TuningDoc doc, IReadOnlyList<(int Mv, int Mhz)> stock)
         => TuningDocuments.ResolveCurveOffsetsKhz(doc, stock, () => stock, "The tuning");