@@ -41,6 +41,12 @@ print(optimizer.report)
 ReAnchor searches each output's numeric settings against the whole-program
 metric. A new setting must improve the training score and pass a fold check.
 
+For every compatible output, ReAnchor saves the original configuration and score,
+enables probability-based execution, and fits the numeric settings. It then compares
+the fitted behavior against the original using a fold check. If rejected, it restores
+the exact original configuration, including removing an entry that was originally absent.
+The adapter handles the backend used on each call; calibration does not inspect it.
+
 Before fitting each output, ReAnchor runs the program and records that output's
 probabilities on every call. A threshold anywhere between two neighboring P(True) values makes the
 same decisions, so ReAnchor tries the midpoint of each gap between them. For
@@ -78,7 +84,9 @@ additional backend calls. Native-output promotion also changes the request.
 
 `compile` requires caching by default to avoid repeating identical backend
 calls; it does not guarantee a fixed request count. Pass `require_cache=False`
-to run without this check.
+to run without this check. The cache check inspects statically bound or globally
+configured clients. For programs selecting clients inside `forward()`, disable
+the check and manage caching on those clients.
 
 ## Native outputs on a generative LM
 
@@ -88,19 +96,18 @@ has an entry in the predictor's `fields`, `Predict` asks the LM for
 probabilities instead. `Predict` then applies the threshold or weights to pick
 the value, and the output still returns a `bool` or a `Literal` member.
 
-ReAnchor adds this entry for each native output on a generative LM. It keeps the
-entry only when the fitted setting beats the native value under the same fold
-check. Otherwise it removes the entry, and the output keeps its native behavior.
-The `report` row for a kept entry has `"promoted": True`. The first pass with
-probabilities sends new requests, because the request changes.
+The first pass with probabilities sends new requests, because the request changes.
+If the fitted behavior is rejected, restoring the original configuration returns
+an unconfigured native field to direct generation.
 
 ```python
 dspy.configure(lm=dspy.LM("your-provider/your-model"))  # Use your model's identifier.
 tuned = ReAnchor(metric).compile(dspy.Predict(Match), trainset=trainset)
 ```
 
-A System One model such as Jev always returns probabilities, so this step does
-not apply there.
+A System One model such as Jev always returns probabilities. Enabling probability
+execution leaves its request unchanged; restoring a field restores its original
+decoding settings, not direct generation.
 
 ## Errors
 
@@ -123,7 +130,10 @@ your backend's load.
   skipped it. Each fitted row has an `observed` entry with the number of calls
   and settings tried; threshold and cut reports also summarize observed values. Its
   `fold_check` entry counts the search steps whose better training score passed
-  or failed the fold check.
+  or failed the fold check. Per-field `train_score_original` is the score before
+  enabling probabilities, `train_score_at_start` is the probability-based baseline,
+  and `train_score` describes the retained behavior. Rejected configurations have
+  a `skipped` reason instead of a fitted `value`.
 
 Your metric may return a number or a `dspy.Prediction` with a `score`.
 
 
@@ -25,10 +25,10 @@
 only when those held-out scores beat the current setting's. This discourages gains confined to
 small portions of the dataset, but can accept them when they recur across folds.
 
-On a generative LM, a native `bool` or `Literal` output returns its value without probabilities
-unless it has an entry in `fields`. Calibration adds that entry, which asks the LM for
-probabilities, and keeps it only when the fitted setting beats the native output under the same
-fold check.
+Calibration enables probability-based execution for every compatible output by adding an entry
+in `fields`. After fitting, it compares against the original behavior under the same fold check
+and restores the original field configuration unless the fitted behavior wins. The adapter
+handles probability requests for the backend used on each call.
 
 """
 
@@ -61,34 +61,23 @@ def predictors(program) -> list[tuple[str, Predict]]:
     return [(name, p) for name, p in program.named_parameters() if isinstance(p, Predict) and decision_outputs(p)]
 
 
-def resolved_lm(predict: Predict):
-    """The client the predictor calls: its own, or the configured one."""
+def caches(predict: Predict) -> bool:
+    """Check caching for a statically bound or configured client."""
     lm = predict.lm or dspy.settings.lm
     if lm is None:
-        raise ValueError("ReAnchor needs an LM or decision client, bound to the predictor or configured globally.")
-    return lm
-
-
-def caches(predict: Predict) -> bool:
-    """Whether repeated requests from the predictor are answered from the cache."""
-    lm = resolved_lm(predict)
+        raise ValueError(
+            "ReAnchor cannot check caching without a bound or globally configured client. "
+            "For runtime client selection, pass require_cache=False."
+        )
     enabled = predict.config.get("cache", getattr(lm, "cache", False))
     return bool(enabled) and getattr(lm, "_cache_responses", True)
 
 
-def _state(predict: Predict, fields: dict) -> DecisionState:
-    system_one = getattr(resolved_lm(predict), "supports_decision_requests", False) is True
-    return DecisionState(predict.signature, fields, system_one=system_one)
-
-
-def evidenced(predict: Predict) -> set[str]:
-    """The outputs the predictor currently decodes from probabilities."""
-    return set(_state(predict, predict.fields).types)
-
-
 def effective(predict: Predict, field: str) -> dict:
     """The output's full configuration: its stored overrides on top of its type's defaults."""
-    return _state(predict, {**predict.fields, field: predict.fields.get(field, {})}).fields[field]
+    fields = dict(predict.fields)
+    fields.setdefault(field, {})
+    return DecisionState(predict.signature, fields).fields[field]
 
 
 def metric_value(metric: Callable, example, pred) -> float:
@@ -138,8 +127,7 @@ def score() -> list[float]:
     for name, predict in predictors(program):
         for field, kind in decision_outputs(predict).items():
             original = copy.deepcopy(predict.fields.get(field))
-            promoted = field not in evidenced(predict)
-            native = score() if promoted else None
+            before = score()
             predict.fields[field] = effective(predict, field)
             evidence = _observe(program, predict, field, trainset, metric, num_threads)
             row = {"predictor": name, "field": field}
@@ -153,20 +141,11 @@ def score() -> list[float]:
             base = score()
             best, fitted, observed, check = fit(predict, field, kind, evidence, score, base)
             row.update(parameter=parameter, value=best, train_score=_mean(fitted), train_score_at_start=_mean(base))
-            row.update(observed=observed, fold_check=check)
-            if promoted:
-                row["train_score_native"] = _mean(native)
-                if _select(native, [(fitted, (), None)])[0] is None:
-                    _restore(predict, field, original)
-                    row = {
-                        "predictor": name,
-                        "field": field,
-                        "skipped": "probabilities did not beat the native output",
-                        "train_score_native": row["train_score_native"],
-                        "train_score": row["train_score"],
-                    }
-                else:
-                    row["promoted"] = True
+            row.update(observed=observed, fold_check=check, train_score_original=_mean(before))
+            if _select(before, [(fitted, (), None)])[0] is None:
+                _restore(predict, field, original)
+                row.pop("value")
+                row.update(skipped="fitted behavior did not beat the original", train_score=_mean(before))
             report.append(row)
     return report
 
@@ -211,7 +190,8 @@ def _gaps(values: list[float], lo: float, hi: float, geometric: bool = False) ->
     gaps = []
     for a, b in itertools.pairwise(points):
         middle, width = (math.sqrt(a * b), math.log(b / a)) if geometric else ((a + b) / 2, b - a)
-        gaps.append((_tidy(middle, a, b), width))
+        if a < middle < b:  # Adjacent floats can round the midpoint onto a boundary.
+            gaps.append((_tidy(middle, a, b), width))
     return gaps
 
 
 
@@ -21,18 +21,17 @@ class ReAnchor(Teleprompter):
     backend's probabilities without adding request parameters. Identical requests reuse cached
     answers, but changed upstream decisions can produce new downstream requests.
 
-    On a generative LM, a native `bool` or `Literal` output is answered without probabilities.
-    ReAnchor gives such an output an entry in the predictor's `fields`, which asks the LM for
-    probabilities, and keeps the entry only when the fitted setting beats the native output on the
-    training set.
+    ReAnchor enables probability-based execution for every compatible output through the predictor's
+    `fields`. It keeps each fitted configuration only when it beats the original behavior and passes
+    a fold check; otherwise it restores the original configuration, including absent field entries.
 
     Args:
         metric: Per-example metric to maximize, as in `dspy.Evaluate`. It may return a number, or a
             `dspy.Prediction` with a `score`.
         num_threads: Evaluation concurrency, as in `dspy.Evaluate`.
         log_dir: When set, report.json is written here.
-        require_cache: When True, `compile` raises if a predictor's client does not cache responses.
-            Set it to False to calibrate anyway; every candidate setting then sends new requests.
+        require_cache: When True, check caching on statically bound or globally configured clients.
+            Set it to False for runtime client selection or to allow uncached requests.
 
     After `compile`, `report` holds the fitted parameters and the metric's mean before and after
     calibration, on the training set and on the validation set when one is given.
@@ -60,7 +59,7 @@ def compile(self, student, *, trainset, valset=None):
         found = predictors(program)
         if not found:
             raise ValueError("The student must contain at least one Predict with a decision output.")
-        uncached = [name for name, predict in found if not caches(predict)]
+        uncached = [name for name, predict in found if not caches(predict)] if self.require_cache else []
         if self.require_cache and uncached:
             raise ValueError(
                 f"Predictors {uncached} do not cache responses, so every candidate setting would send new requests. "
 
@@ -90,7 +90,7 @@ def forward(self, pair):
     program = ReAnchor(metric, num_threads=2).compile(Wrapper(), trainset=examples())
     assert isinstance(program, Wrapper)
     assert program.judge.fields["match"]["threshold"] == 0.8
-    assert "threshold" in program.judges[0].fields["match"]
+    assert program.judges[0].fields == {}  # No further gain after calibrating the first judge.
 
 
 class Items(dspy.Module):
@@ -193,19 +193,25 @@ def test_a_native_bool_on_a_generative_lm_is_promoted_when_probabilities_score_b
     assert student.fields == {}
     assert program.fields == {"match": {"threshold": 0.8}}
     row = optimizer.report["fitted"][0]
-    assert row["promoted"] is True and row["train_score_native"] == 0.5556 and row["train_score"] == 0.7778
+    assert "skipped" not in row and row["train_score_original"] == 0.5556 and row["train_score"] == 0.7778
 
 
-def test_a_native_bool_stays_native_when_probabilities_do_not_score_better():
+@pytest.mark.parametrize("accurate_probabilities", [True, False])
+def test_a_native_bool_stays_native_when_probabilities_do_not_score_better(accurate_probabilities):
     def right(inputs, evidence):
         answer = inputs["pair"].startswith("same")
-        return {"match": noul(0.9 if answer else 0.1)} if evidence else {"match": answer}
+        probability = (0.9 if answer else 0.1) if accurate_probabilities else 0.9
+        return {"match": noul(probability)} if evidence else {"match": answer}
 
     dspy.configure(lm=ComputedLM(right, adapter=dspy.JSONAdapter()))
     optimizer = ReAnchor(metric, num_threads=2, require_cache=False)
     program = optimizer.compile(dspy.Predict(Sig), trainset=examples())
     assert program.fields == {}
-    assert optimizer.report["fitted"][0]["skipped"] == "probabilities did not beat the native output"
+    row = optimizer.report["fitted"][0]
+    assert row["skipped"] == "fitted behavior did not beat the original"
+    assert row["train_score"] == row["train_score_original"] == 1.0
+    assert row["train_score_at_start"] == (1.0 if accurate_probabilities else 0.5556)
+    assert "value" not in row
 
 
 def test_a_native_bool_stays_native_when_probabilities_win_only_one_example():
@@ -222,7 +228,49 @@ def one_miss(inputs, evidence):
     optimizer = ReAnchor(metric, num_threads=2, require_cache=False)
     program = optimizer.compile(dspy.Predict(Sig), trainset=train)
     assert program.fields == {}
-    assert optimizer.report["fitted"][0]["skipped"] == "probabilities did not beat the native output"
+    assert optimizer.report["fitted"][0]["skipped"] == "fitted behavior did not beat the original"
+
+
+@pytest.mark.parametrize("binding", ["call", "context"])
+@pytest.mark.parametrize("backend", ["jev", "lm"])
+def test_runtime_clients_can_calibrate_without_static_cache_checks(jev, binding, backend):
+    client = jev if backend == "jev" else ComputedLM(generative, adapter=dspy.JSONAdapter())
+
+    class Routed(dspy.Module):
+        def __init__(self):
+            super().__init__()
+            self.judge = dspy.Predict(Sig)
+
+        def forward(self, pair):
+            if binding == "call":
+                return self.judge(pair=pair, lm=client)
+            with dspy.context(lm=client):
+                return self.judge(pair=pair)
+
+    with dspy.context(lm=None):
+        with pytest.raises(ValueError, match="require_cache=False"):
+            ReAnchor(metric).compile(Routed(), trainset=examples())
+        optimizer = ReAnchor(metric, num_threads=2, require_cache=False)
+        program = optimizer.compile(Routed(), trainset=examples())
+        assert program.judge.fields == {"match": {"threshold": 0.8}}
+        assert program(pair="different").match is False
+        assert optimizer.report["train_score"] == 0.7778
+
+
+@pytest.mark.parametrize("original", [None, {}, {"criteria": {"true": {"what": "same item"}}}])
+def test_rejected_jev_configuration_is_restored_exactly(original):
+    student = dspy.Predict(Sig)
+    if original is not None:
+        student.fields["match"] = copy.deepcopy(original)
+    # All True is already perfect; fitting must not leave materialized defaults behind.
+    train = [dspy.Example(pair="same", match=True).with_inputs("pair") for _ in range(10)]
+    optimizer = ReAnchor(metric, num_threads=2)
+    program = optimizer.compile(student, trainset=train)
+    assert program.fields == student.fields
+    row = optimizer.report["fitted"][0]
+    assert row["skipped"] == "fitted behavior did not beat the original"
+    assert row["train_score_original"] == row["train_score"] == 1.0
+    assert "value" not in row
 
 
 def test_a_partial_field_entry_is_filled_from_the_type_defaults(system_one):
 
@@ -32,7 +32,7 @@ def test_zero_probability_can_be_classified_on_either_side(system_one, target):
     program = dspy.Predict(Match)
     train = [dspy.Example(pair=str(i), match=target).with_inputs("pair") for i in range(10)]
     report = calibrate(program, train, lambda g, p: float(p.match == g.match), num_threads=2)
-    assert program.fields["match"]["threshold"] == (0.0 if target else 0.5)
+    assert program.fields == ({"match": {"threshold": 0.0}} if target else {})
     assert report[0]["train_score"] == 1.0
 
 
@@ -92,10 +92,22 @@ def test_score_cuts_stay_at_their_defaults_when_the_metric_ignores_the_level(sys
     program = dspy.Predict(RateLevel)
     train = [dspy.Example(item=k, rating={"lo": 0, "hi": 2}[k]).with_inputs("item") for k in ["lo", "hi"]]
     report = calibrate(program, train, lambda g, p, trace=None: 1 - abs(p.rating.value - g.rating) / 2, num_threads=2)
-    assert program.fields["rating"]["cuts"] == [0.5, 1.5]
+    assert program.fields == {}
     assert report[0]["train_score"] == report[0]["train_score_at_start"]
 
 
+def test_score_search_does_not_collapse_cuts_at_adjacent_floats(system_one):
+    # The midpoint between 0.7 and this observed mean rounds back to 0.7.
+    probability = 0.7000000000000001
+    system_one(lambda state, name, q: score({0: 1 - probability, 1: probability, 2: 0.0}))
+    program = dspy.Predict(RateLevel)
+    program.fields["rating"] = {"cuts": [0.7, 1.5]}
+    train = [dspy.Example(item=str(i), rating=1).with_inputs("item") for i in range(6)]
+    report = calibrate(program, train, lambda g, p: float(p.rating.level == g.rating), num_threads=2)
+    assert program.fields["rating"] == {"cuts": [0.7, 1.5]}
+    assert report[0]["train_score"] == 1.0
+
+
 class Route(dspy.Signature):
     ticket: str = dspy.InputField()
     queue: Annotated[Literal["billing", "tech"], Choice[("billing", "Payments"), ("tech", "Bugs")]] = dspy.OutputField(
@@ -176,8 +188,8 @@ def test_outputs_the_metric_does_not_read_keep_their_numeric_settings(system_one
     assert rows["noise"]["train_score"] == rows["noise"]["train_score_at_start"]
     assert rows["kind"]["train_score"] == rows["kind"]["train_score_at_start"]
     assert "skipped" not in rows["match"] and program.fields["match"]["threshold"] == 0.8
-    assert program.fields["noise"]["threshold"] == 0.5
-    assert program.fields["kind"]["weights"] == {"x": 1.0, "y": 1.0}
+    assert "noise" not in program.fields
+    assert "kind" not in program.fields
     assert len({repr(c) for c in client.calls}) == 2
 
 
@@ -337,7 +349,7 @@ def test_a_threshold_stays_when_its_whole_gain_is_one_example(system_one):
     system_one(answer)
     program = dspy.Predict(Match)
     report = calibrate(program, train, lambda g, p, trace=None: float(p.match == g.match), num_threads=2)
-    assert program.fields["match"]["threshold"] == 0.5
+    assert program.fields == {}
     assert report[0]["fold_check"] == {"passed": 0, "failed": 1}
 
 
@@ -357,7 +369,7 @@ def test_score_cuts_stay_when_their_whole_gain_is_one_example(system_one):
     items = [f"lo{i}" for i in range(19)] + ["odd0"] + [f"hi{i}" for i in range(20)]
     train = [dspy.Example(item=k, rating=2 if k.startswith("hi") else 0).with_inputs("item") for k in items]
     report = calibrate(program, train, lambda g, p, trace=None: float(p.rating.level == g.rating), num_threads=2)
-    assert program.fields["rating"]["cuts"] == [0.5, 1.5]
+    assert program.fields == {}
     assert report[0]["fold_check"]["failed"] >= 1
 
 
@@ -368,5 +380,5 @@ def test_choice_weights_stay_when_their_whole_gain_is_one_example(system_one):
     items = [f"x{i}" for i in range(20)] + [f"y{i}" for i in range(19)] + ["odd0"]
     train = [dspy.Example(item=k, kind="x" if k.startswith("x") else "y").with_inputs("item") for k in items]
     report = calibrate(program, train, lambda g, p, trace=None: float(p.kind == g.kind), num_threads=2)
-    assert program.fields["kind"]["weights"] == {"x": 1.0, "y": 1.0}
+    assert program.fields == {}
     assert report[0]["fold_check"]["failed"] >= 1