loopgain 0.4.3__tar.gz → 0.5.0__tar.gz

{loopgain-0.4.3 → loopgain-0.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: loopgain
-Version: 0.4.3
+Version: 0.5.0
 Summary: An open-source cost controller for AI agent loops. Stops a loop when it has actually converged and rolls back before it degrades — replacing the max_iterations guess with a real-time loop-gain (Aβ) monitor with five named threshold bands and best-so-far rollback.
 Author-email: Dave Fitzsimmons <hello@loopgain.ai>
 License: Apache-2.0
@@ -102,7 +102,6 @@ result = lg.result
 print(result.outcome)              # "converged" | "oscillating" | "diverged" | "stalled" | "max_iterations"
 print(result.best_output)          # the lowest-error iteration's output
 print(result.iterations_used)
-print(result.gain_margin)          # 1 / max(Aβ_smooth)
 print(result.savings_vs_fixed_cap)
 ```
 
@@ -213,17 +212,9 @@ Returns `False` once a terminal state fires.
 
 Current state name. One of `INIT`, `FAST_CONVERGE`, `CONVERGING`, `STALLING`, `OSCILLATING`, `DIVERGING`, `TARGET_MET`, `MAX_ITERATIONS`. The corresponding terminal `result.outcome` values are `converged`, `oscillating`, `diverged`, `stalled` (v0.2 trajectory mode only — STALLING terminating after 2 consecutive readings), `max_iterations`, or `in_progress`.
 
-### `lg.eta -> int | None`
-
-Best-effort closed-form estimate of iterations remaining, exposed for instrumentation. Returns `None` whenever it isn't well-defined — which is most of the time on real, jump-dominated loops, so don't depend on it for control.
-
-### `lg.gain_margin -> float | None`
-
-`1 / max(Aβ_smooth)`. `> 1` means stable headroom across the entire run.
-
 ### `lg.result -> LoopGainResult`
 
-Terminal result with `outcome`, `iterations_used`, `best_index`, `best_output`, `best_error`, `convergence_profile`, `error_history`, `gain_margin`, `savings_vs_fixed_cap`. Safe to call mid-loop.
+Terminal result with `outcome`, `iterations_used`, `best_index`, `best_output`, `best_error`, `convergence_profile`, `error_history`, `savings_vs_fixed_cap`. Safe to call mid-loop.
 
 ### `lg.send_telemetry(endpoint, token, workload_id=None, timeout=2.0, allow_insecure=False, framework=None, loop_type=None, team=None, include_per_iteration=True) -> bool`
 

{loopgain-0.4.3 → loopgain-0.5.0}/README.md

@@ -53,7 +53,6 @@ result = lg.result
 print(result.outcome)              # "converged" | "oscillating" | "diverged" | "stalled" | "max_iterations"
 print(result.best_output)          # the lowest-error iteration's output
 print(result.iterations_used)
-print(result.gain_margin)          # 1 / max(Aβ_smooth)
 print(result.savings_vs_fixed_cap)
 ```
 
@@ -164,17 +163,9 @@ Returns `False` once a terminal state fires.
 
 Current state name. One of `INIT`, `FAST_CONVERGE`, `CONVERGING`, `STALLING`, `OSCILLATING`, `DIVERGING`, `TARGET_MET`, `MAX_ITERATIONS`. The corresponding terminal `result.outcome` values are `converged`, `oscillating`, `diverged`, `stalled` (v0.2 trajectory mode only — STALLING terminating after 2 consecutive readings), `max_iterations`, or `in_progress`.
 
-### `lg.eta -> int | None`
-
-Best-effort closed-form estimate of iterations remaining, exposed for instrumentation. Returns `None` whenever it isn't well-defined — which is most of the time on real, jump-dominated loops, so don't depend on it for control.
-
-### `lg.gain_margin -> float | None`
-
-`1 / max(Aβ_smooth)`. `> 1` means stable headroom across the entire run.
-
 ### `lg.result -> LoopGainResult`
 
-Terminal result with `outcome`, `iterations_used`, `best_index`, `best_output`, `best_error`, `convergence_profile`, `error_history`, `gain_margin`, `savings_vs_fixed_cap`. Safe to call mid-loop.
+Terminal result with `outcome`, `iterations_used`, `best_index`, `best_output`, `best_error`, `convergence_profile`, `error_history`, `savings_vs_fixed_cap`. Safe to call mid-loop.
 
 ### `lg.send_telemetry(endpoint, token, workload_id=None, timeout=2.0, allow_insecure=False, framework=None, loop_type=None, team=None, include_per_iteration=True) -> bool`
 

{loopgain-0.4.3 → loopgain-0.5.0}/loopgain/_version.py

@@ -7,4 +7,4 @@ from here so the value never drifts between ``__version__`` and the
 ``pyproject.toml``) for each release.
 """
 
-__version__ = "0.4.3"
+__version__ = "0.5.0"

{loopgain-0.4.3 → loopgain-0.5.0}/loopgain/core.py

@@ -9,8 +9,7 @@ real-time loop-gain monitor that classifies the loop into one of five
 named states and decides whether to continue, stop, or roll back.
 
 The math is foundational EE control theory. The product layer is the
-threshold bands, the best-so-far buffer, the ETA prediction, and the
-clean Python API.
+threshold bands, the best-so-far buffer, and the clean Python API.
 
 License: Apache-2.0
 """
@@ -121,28 +120,10 @@ class LoopGainResult:
     error_history: list[float] = field(default_factory=list)
     """All observed error magnitudes, in order."""
 
-    gain_margin: Optional[float] = None
-    """``1 / max(Aβ_smooth)``. > 1 means stable headroom; < 1 means the
-    loop crossed into oscillation/divergence at some point."""
-
     savings_vs_fixed_cap: Optional[int] = None
     """Iterations saved versus the assumed fixed cap (default 10).
     Zero if the loop hit ``max_iterations``; otherwise non-negative."""
 
-    first_eta_prediction: Optional[int] = None
-    """First non-None ``eta`` snapshot captured during the loop —
-    the predicted iterations-remaining at the moment the prediction
-    became computable. ``None`` if no prediction was ever made
-    (e.g., ``target_error`` is ``None`` or ``0`` so the prediction
-    formula is undefined, loop never converged toward target, or the
-    loop terminated before two observations)."""
-
-    first_eta_at_iteration: Optional[int] = None
-    """Iteration count when ``first_eta_prediction`` was captured.
-    ``None`` if no prediction was ever made. Predicted *total*
-    iterations = ``first_eta_at_iteration + first_eta_prediction``,
-    comparable to ``iterations_used`` for calibration."""
-
 
 class LoopGain:
     """Barkhausen stability monitor for AI agent loops.
@@ -239,8 +220,6 @@ class LoopGain:
         self._state: str = INIT
         self._state_history: list[str] = []
         self._terminal: bool = False
-        self._first_eta_prediction: Optional[int] = None
-        self._first_eta_at_iteration: Optional[int] = None
 
         # Opt-in anonymous funnel telemetry (see loopgain.funnel). No-op
         # unless the user has explicitly opted in; fully fail-silent and
@@ -348,17 +327,6 @@ class LoopGain:
             self._state = MAX_ITERATIONS
             self._terminal = True
 
-        # Snapshot the first computable eta prediction for calibration.
-        # eta is None until smoothing settles and the loop looks convergent;
-        # we capture the *first* value it produces and the iteration it was
-        # produced at, so predicted_total = at_iter + eta is comparable to
-        # iterations_used.
-        if self._first_eta_prediction is None:
-            eta_now = self.eta
-            if eta_now is not None and eta_now > 0:
-                self._first_eta_prediction = eta_now
-                self._first_eta_at_iteration = len(self._error_history)
-
         # Funnel telemetry: if this observation drove the loop terminal
         # (oscillating / diverging / stalled / max-iterations), count the
         # coarse outcome. The TARGET_MET case is handled at its early return.
@@ -382,46 +350,6 @@ class LoopGain:
         """Current state name."""
         return self._state
 
-    @property
-    def eta(self) -> Optional[int]:
-        """Predicted iterations remaining to reach ``target_error``.
-
-        Closed-form Barkhausen prediction:
-
-            n_remaining = log(E_target / E_current) / log(Aβ_smooth)
-
-        Returns ``None`` when the prediction isn't well-defined:
-        no Aβ yet, ``target_error`` is ``None`` (no target to predict
-        against) or ``0`` (the formula has a log-of-zero singularity),
-        target already met, or ``Aβ_smooth >= 1`` (non-converging gain).
-        """
-        if not self._smoothed_history or not self._error_history:
-            return None
-        if self.target_error is None or self.target_error <= 0:
-            return None
-        e_current = self._error_history[-1]
-        if e_current <= self.target_error:
-            return 0
-        ab_smooth = self._smoothed_history[-1]
-        if ab_smooth >= 1.0 or ab_smooth <= 0:
-            return None
-        n = math.log(self.target_error / e_current) / math.log(ab_smooth)
-        return max(0, math.ceil(n))
-
-    @property
-    def gain_margin(self) -> Optional[float]:
-        """Gain margin ``GM = 1 / max(Aβ_smooth)``.
-
-        ``GM > 1`` means the loop never crossed into oscillation. The
-        larger, the more headroom. Returns ``None`` if no Aβ data yet.
-        """
-        if not self._smoothed_history:
-            return None
-        max_g = max(self._smoothed_history)
-        if max_g == 0:
-            return float("inf")
-        return 1.0 / max_g
-
     @property
     def result(self) -> LoopGainResult:
         """Construct the terminal result. Safe to call any time."""
@@ -468,10 +396,7 @@ class LoopGain:
             best_error=best_error,
             convergence_profile=list(self._smoothed_history),
             error_history=list(self._error_history),
-            gain_margin=self.gain_margin,
             savings_vs_fixed_cap=savings,
-            first_eta_prediction=self._first_eta_prediction,
-            first_eta_at_iteration=self._first_eta_at_iteration,
         )
 
     # ----- Internal helpers -----

{loopgain-0.4.3 → loopgain-0.5.0}/loopgain/telemetry.py

@@ -37,12 +37,11 @@ def _safe_float(x: Any) -> Any:
 
     Standard JSON (RFC 8259) forbids Infinity and NaN literals. Python's
     json.dumps emits them by default, and strict parsers — including the
-    Cloudflare-side receiver — reject the payload. gain_margin in particular
-    is 1/max(Aβ_smooth) and goes to +inf whenever the smoothed gain is zero
-    (e.g. a constant-error trajectory). Aβ values themselves can go to inf
-    if a previous error is exactly zero. Collapsing to None keeps the
-    dashboard's "no data" semantics intact instead of dropping the whole
-    payload.
+    Cloudflare-side receiver — reject the payload. Aβ values can go to inf
+    if a previous error is exactly zero, so the convergence-profile summary
+    and per-iteration arrays are wrapped in this coercion. Collapsing to None
+    keeps the dashboard's "no data" semantics intact instead of dropping the
+    whole payload.
     """
     if isinstance(x, float) and not math.isfinite(x):
         return None
@@ -86,12 +85,14 @@ if TYPE_CHECKING:
 
 
 # Schema version is incremented when the payload format breaks compatibility.
-# v2 (2026-05-13) adds first_eta_prediction + first_eta_at_iteration for the
-# ETA Accuracy dashboard panel. v3 (2026-05-14) adds the optional
-# per_iteration block (capped trajectories) and the framework/loop_type/team
-# classification fields. Receiver remains backward-compatible: v1/v2 payloads
-# are still accepted (new fields default to None / NULL).
-SCHEMA_VERSION = 3
+# v2 (2026-05-13) added an ETA-calibration block and v1 carried a gain_margin
+# field; both were removed in v4 (2026-06-09) when ETA and gain margin were
+# discontinued (neither fired reliably on real trajectories). v3 (2026-05-14)
+# added the optional per_iteration block (capped trajectories) and the
+# framework/loop_type/team classification fields. The receiver remains
+# backward-compatible: older payloads are still accepted and the dropped
+# fields are simply ignored.
+SCHEMA_VERSION = 4
 
 
 # Library version sourced from loopgain._version so there's exactly one
@@ -176,7 +177,6 @@ def build_payload(
         "loop": {
             "outcome": result.outcome,
             "iterations_used": result.iterations_used,
-            "gain_margin": _safe_float(result.gain_margin),
             "savings_vs_fixed_cap": result.savings_vs_fixed_cap,
             "convergence_profile_summary": profile_summary,
             "rollback_triggered": result.outcome in ("oscillating", "diverged"),
@@ -185,13 +185,6 @@ def build_payload(
             # (iterations_used-1-best_index) — the "Iteration Waste" view.
             # Privacy-safe: an integer position, no output/error content.
             "best_index": result.best_index,
-            # v2: first computable eta snapshot, for ETA calibration dashboard.
-            # Predicted total iterations = first_eta_at_iteration +
-            # first_eta_prediction; compare to iterations_used to compute the
-            # calibration error. Both are None when no prediction was made
-            # (target_error=0, loop never looked convergent, etc.).
-            "first_eta_prediction": result.first_eta_prediction,
-            "first_eta_at_iteration": result.first_eta_at_iteration,
         },
         "thresholds": {
             "fast_converge": lg.thresholds.fast_converge,

{loopgain-0.4.3 → loopgain-0.5.0}/loopgain.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: loopgain
-Version: 0.4.3
+Version: 0.5.0
 Summary: An open-source cost controller for AI agent loops. Stops a loop when it has actually converged and rolls back before it degrades — replacing the max_iterations guess with a real-time loop-gain (Aβ) monitor with five named threshold bands and best-so-far rollback.
 Author-email: Dave Fitzsimmons <hello@loopgain.ai>
 License: Apache-2.0
@@ -102,7 +102,6 @@ result = lg.result
 print(result.outcome)              # "converged" | "oscillating" | "diverged" | "stalled" | "max_iterations"
 print(result.best_output)          # the lowest-error iteration's output
 print(result.iterations_used)
-print(result.gain_margin)          # 1 / max(Aβ_smooth)
 print(result.savings_vs_fixed_cap)
 ```
 
@@ -213,17 +212,9 @@ Returns `False` once a terminal state fires.
 
 Current state name. One of `INIT`, `FAST_CONVERGE`, `CONVERGING`, `STALLING`, `OSCILLATING`, `DIVERGING`, `TARGET_MET`, `MAX_ITERATIONS`. The corresponding terminal `result.outcome` values are `converged`, `oscillating`, `diverged`, `stalled` (v0.2 trajectory mode only — STALLING terminating after 2 consecutive readings), `max_iterations`, or `in_progress`.
 
-### `lg.eta -> int | None`
-
-Best-effort closed-form estimate of iterations remaining, exposed for instrumentation. Returns `None` whenever it isn't well-defined — which is most of the time on real, jump-dominated loops, so don't depend on it for control.
-
-### `lg.gain_margin -> float | None`
-
-`1 / max(Aβ_smooth)`. `> 1` means stable headroom across the entire run.
-
 ### `lg.result -> LoopGainResult`
 
-Terminal result with `outcome`, `iterations_used`, `best_index`, `best_output`, `best_error`, `convergence_profile`, `error_history`, `gain_margin`, `savings_vs_fixed_cap`. Safe to call mid-loop.
+Terminal result with `outcome`, `iterations_used`, `best_index`, `best_output`, `best_error`, `convergence_profile`, `error_history`, `savings_vs_fixed_cap`. Safe to call mid-loop.
 
 ### `lg.send_telemetry(endpoint, token, workload_id=None, timeout=2.0, allow_insecure=False, framework=None, loop_type=None, team=None, include_per_iteration=True) -> bool`
 

{loopgain-0.4.3 → loopgain-0.5.0}/tests/test_core.py

@@ -2,7 +2,7 @@
 
 Covers the five band transitions, the three canonical scenarios from the
 spec (converging / oscillating / diverging), TARGET_MET short-circuit,
-best-so-far buffer correctness, and ETA calibration.
+and best-so-far buffer correctness.
 """
 
 from __future__ import annotations
@@ -179,109 +179,6 @@ def test_best_so_far_works_without_outputs():
     assert result.best_error == 2.0
 
 
-# ----- ETA prediction calibration -----
-
-
-def test_eta_prediction_calibration():
-    """Synthetic monotonic decay: predicted iterations matches actual ±1."""
-    target = 0.1
-    ab = 0.5
-    errors = _decay(ab, e0=100.0)
-    # Iteration index where error first drops below target.
-    actual_n = next(i for i, e in enumerate(errors) if e < target)
-
-    lg = LoopGain(target_error=target, max_iterations=100)
-    # Feed a few errors so smoothed Aβ stabilizes.
-    lg.observe(errors[0])
-    lg.observe(errors[1])
-    lg.observe(errors[2])
-    # ETA at this point should predict ~(actual_n - 2) more iterations.
-    eta = lg.eta
-    assert eta is not None
-    assert abs(eta - (actual_n - 2)) <= 1, f"eta={eta}, expected ~{actual_n - 2}"
-
-
-def test_eta_none_when_not_converging():
-    """ETA is None when Aβ_smooth >= 1 (non-converging)."""
-    lg = LoopGain(target_error=0.5)
-    for _ in range(3):
-        lg.observe(10.0)  # constant errors -> Aβ = 1
-        if not lg.should_continue():
-            break
-    assert lg.eta is None
-
-
-def test_eta_none_when_target_is_zero():
-    lg = LoopGain(target_error=0.0)
-    lg.observe(100.0)
-    lg.observe(50.0)
-    assert lg.eta is None
-
-
-# ----- First-eta snapshot (for ETA Accuracy dashboard panel) -----
-
-
-def test_first_eta_snapshot_captured_during_converging_run():
-    """Result carries the first non-None eta and the iter it was made at."""
-    target = 0.1
-    errors = _decay(0.5, e0=100.0)
-    lg = LoopGain(target_error=target, max_iterations=100)
-    for e in errors:
-        lg.observe(e)
-        if not lg.should_continue():
-            break
-
-    result = lg.result
-    # First eta becomes computable on the 2nd observation (smoothed_history
-    # exists, target > 0, current > target, Aβ_smooth < 1).
-    assert result.first_eta_at_iteration == 2
-    assert result.first_eta_prediction is not None
-    assert result.first_eta_prediction > 0
-    # Predicted total iterations should be within ±2 of actual (the prediction
-    # is made early, before smoothing has fully settled).
-    predicted_total = result.first_eta_at_iteration + result.first_eta_prediction
-    assert abs(predicted_total - result.iterations_used) <= 2
-
-
-def test_first_eta_snapshot_none_when_target_is_zero():
-    """No prediction is captured when target_error=0 (eta is always None)."""
-    lg = LoopGain(target_error=0.0, max_iterations=5)
-    for _ in range(5):
-        lg.observe(10.0)
-    result = lg.result
-    assert result.first_eta_prediction is None
-    assert result.first_eta_at_iteration is None
-
-
-def test_first_eta_snapshot_none_when_loop_never_converges():
-    """Oscillating loop (Aβ ≈ 1) never produces a positive eta."""
-    lg = LoopGain(target_error=0.5)
-    for _ in range(5):
-        lg.observe(10.0)
-        if not lg.should_continue():
-            break
-    result = lg.result
-    assert result.first_eta_prediction is None
-    assert result.first_eta_at_iteration is None
-
-
-def test_first_eta_snapshot_is_idempotent():
-    """Subsequent observations don't overwrite the first prediction."""
-    target = 0.1
-    errors = _decay(0.5, e0=100.0)
-    lg = LoopGain(target_error=target, max_iterations=100)
-    lg.observe(errors[0])
-    lg.observe(errors[1])
-    first = lg._first_eta_prediction
-    first_iter = lg._first_eta_at_iteration
-    assert first is not None
-    # Run a few more iterations; the snapshot should not change.
-    for e in errors[2:6]:
-        lg.observe(e)
-    assert lg._first_eta_prediction == first
-    assert lg._first_eta_at_iteration == first_iter
-
-
 # ----- observe() input coercion -----
 
 
@@ -353,23 +250,6 @@ def test_max_iterations_with_converging_loop():
     assert not lg.should_continue()
 
 
-# ----- gain_margin -----
-
-
-def test_gain_margin_greater_than_one_for_converging():
-    lg = LoopGain(max_iterations=10)
-    for e in _decay(0.5)[:5]:
-        lg.observe(e)
-    gm = lg.gain_margin
-    assert gm is not None
-    assert gm > 1.0
-
-
-def test_gain_margin_none_before_observations():
-    lg = LoopGain()
-    assert lg.gain_margin is None
-
-
 # ----- result before any observations -----
 
 

{loopgain-0.4.3 → loopgain-0.5.0}/tests/test_stress.py

@@ -130,8 +130,7 @@ def test_very_large_error_magnitudes():
         lg.observe(e)
     # Aβ = 0.4 → FAST_CONVERGE.
     assert lg.state in (FAST_CONVERGE, CONVERGING)
-    assert lg.gain_margin is not None
-    assert lg.gain_margin > 1.0
+    assert lg.result.convergence_profile  # Aβ computed without overflow
 
 
 def test_zero_error_in_middle_of_run_anomalous():
@@ -245,19 +244,6 @@ def test_result_callable_mid_loop():
     assert r2.iterations_used == 3
 
 
-def test_eta_before_any_observation():
-    """eta on a fresh instance is None, not a crash."""
-    lg = LoopGain(target_error=0.5)
-    assert lg.eta is None
-
-
-def test_gain_margin_with_single_observation():
-    """Single observation has no Aβ yet → gain_margin is None."""
-    lg = LoopGain()
-    lg.observe(10.0)
-    assert lg.gain_margin is None
-
-
 # ----- Mixed input types -----
 
 

{loopgain-0.4.3 → loopgain-0.5.0}/tests/test_telemetry.py

@@ -53,7 +53,6 @@ def test_payload_loop_section_has_outcome_and_stats():
     loop = p["loop"]
     assert loop["outcome"] == "converged"
     assert loop["iterations_used"] == 4
-    assert loop["gain_margin"] is not None
     assert loop["savings_vs_fixed_cap"] is not None
     assert "convergence_profile_summary" in loop
     assert "rollback_triggered" in loop
@@ -120,7 +119,7 @@ def test_payload_workload_id_optional():
 
 
 def test_payload_serializes_strict_json_for_constant_error_trajectory():
-    """A constant-error trajectory pushes gain_margin to +inf (1/max(Aβ)=1/0).
+    """A zero-error trajectory pushes Aβ to +inf (E(n)/E(n-1) with E(n-1)=0).
 
     Standard JSON forbids Infinity / NaN, and the receiver rejects payloads
     that include them. The build_payload sanitizer must coerce non-finite
@@ -135,8 +134,8 @@ def test_payload_serializes_strict_json_for_constant_error_trajectory():
     # Strict round-trip: allow_nan=False raises on inf/nan.
     encoded = json.dumps(p, allow_nan=False)
     decoded = json.loads(encoded)
-    assert decoded["loop"]["gain_margin"] is None
-    # Per-iteration Aβ values can also be non-finite (E(n)/E(n-1) with E(n-1)=0).
+    # Per-iteration Aβ values can be non-finite (E(n)/E(n-1) with E(n-1)=0)
+    # and the convergence-profile summary must stay finite-or-None too.
     for v in decoded["per_iteration"]["convergence_profile"]:
         assert v is None or isinstance(v, (int, float))
 
@@ -190,50 +189,24 @@ def test_payload_for_not_started_loop():
     assert p["loop"]["convergence_profile_summary"]["samples"] == 0
 
 
-# ----- v2 schema: ETA calibration fields -----
+# ----- schema version -----
 
 
-def test_payload_schema_version_is_v3():
-    """Schema bumped to v3 with the addition of per_iteration + classification."""
-    assert SCHEMA_VERSION == 3
+def test_payload_schema_version_is_v4():
+    """Schema bumped to v4 when ETA + gain_margin were removed from the payload."""
+    assert SCHEMA_VERSION == 4
     lg = _make_terminated_loop()
     p = build_payload(lg)
-    assert p["schema_version"] == 3
+    assert p["schema_version"] == 4
 
 
-def test_payload_includes_first_eta_fields_when_loop_converged():
-    """A converging loop produces a captured eta snapshot."""
+def test_payload_loop_section_drops_eta_and_gain_margin():
+    """v4 no longer carries the discontinued ETA / gain_margin fields."""
     lg = _make_terminated_loop()
-    p = build_payload(lg)
-    loop = p["loop"]
-    assert "first_eta_prediction" in loop
-    assert "first_eta_at_iteration" in loop
-    assert loop["first_eta_prediction"] is not None
-    assert loop["first_eta_at_iteration"] is not None
-    assert loop["first_eta_prediction"] > 0
-    assert loop["first_eta_at_iteration"] >= 2
-
-
-def test_payload_first_eta_none_for_target_zero():
-    """target_error=0 means eta is never computable; both fields are None."""
-    lg = LoopGain(target_error=0.0, max_iterations=4)
-    for _ in range(4):
-        lg.observe(10.0)
-    p = build_payload(lg)
-    assert p["loop"]["first_eta_prediction"] is None
-    assert p["loop"]["first_eta_at_iteration"] is None
-
-
-def test_payload_first_eta_none_for_diverging_loop():
-    """A divergent loop never produces a positive eta."""
-    lg = LoopGain(target_error=0.5, max_iterations=20)
-    for e in [10.0, 12.0, 15.0, 20.0, 30.0]:
-        if not lg.should_continue():
-            break
-        lg.observe(e)
-    p = build_payload(lg)
-    assert p["loop"]["first_eta_prediction"] is None
-    assert p["loop"]["first_eta_at_iteration"] is None
+    loop = build_payload(lg)["loop"]
+    assert "gain_margin" not in loop
+    assert "first_eta_prediction" not in loop
+    assert "first_eta_at_iteration" not in loop
 
 
 # ----- send_payload behavior -----