loopgain 0.4.2__tar.gz → 0.5.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: loopgain
-Version: 0.4.2
+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)
 ```
 
@@ -183,6 +182,7 @@ LoopGain saves money by stopping a loop once it stops improving — fewer iterat
 
 - **Savings depend on your workload.** Loops that usually succeed fast save the most (~96%); adversarial, failure-prone loops save less (~78–84%). The headline is a blend — run the benchmark on your own loops before quoting a number.
 - **LoopGain detects convergence, not correctness.** It stops when your error signal stops improving — which means more iterations won't help, *not* that the loop succeeded. On the benchmark this preserved quality (it rarely stopped early on a worse output; false-stop rate ≤4.5%), but a loop can stall with the error still above zero — a plateau at, say, 2 failing tests. So check `result.best_error` (or your own pass/fail) before you trust the output: if it plateaued short of your target, that's a quality gap LoopGain can't see, and a false stop that forces a rerun is the one way it eats into the savings. LoopGain decides *when to stop*; you decide *whether the answer is good enough*.
+- **LoopGain is only as right as your verifier.** It acts on the error signal you give it. If your verifier reports zero errors, LoopGain trusts that and stops — so a verifier with blind spots can report success on an answer that is still wrong, and LoopGain will confidently stop there. This is not the plateau case above: the error reads zero and the loop looks like a clean success, so neither LoopGain nor its convergence signal can flag it. The quality of the stop is bounded by the quality of the check behind your error signal. Pair LoopGain with the strongest verifier you can afford at the stop — executable tests over a sampled subset, a schema or type check over a vibe, a held-out check the loop didn't optimize against.
 
 ---
 
@@ -212,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.2 → 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)
 ```
 
@@ -134,6 +133,7 @@ LoopGain saves money by stopping a loop once it stops improving — fewer iterat
 
 - **Savings depend on your workload.** Loops that usually succeed fast save the most (~96%); adversarial, failure-prone loops save less (~78–84%). The headline is a blend — run the benchmark on your own loops before quoting a number.
 - **LoopGain detects convergence, not correctness.** It stops when your error signal stops improving — which means more iterations won't help, *not* that the loop succeeded. On the benchmark this preserved quality (it rarely stopped early on a worse output; false-stop rate ≤4.5%), but a loop can stall with the error still above zero — a plateau at, say, 2 failing tests. So check `result.best_error` (or your own pass/fail) before you trust the output: if it plateaued short of your target, that's a quality gap LoopGain can't see, and a false stop that forces a rerun is the one way it eats into the savings. LoopGain decides *when to stop*; you decide *whether the answer is good enough*.
+- **LoopGain is only as right as your verifier.** It acts on the error signal you give it. If your verifier reports zero errors, LoopGain trusts that and stops — so a verifier with blind spots can report success on an answer that is still wrong, and LoopGain will confidently stop there. This is not the plateau case above: the error reads zero and the loop looks like a clean success, so neither LoopGain nor its convergence signal can flag it. The quality of the stop is bounded by the quality of the check behind your error signal. Pair LoopGain with the strongest verifier you can afford at the stop — executable tests over a sampled subset, a schema or type check over a vibe, a held-out check the loop didn't optimize against.
 
 ---
 
@@ -163,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.2 → 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.2"
+__version__ = "0.5.0"

{loopgain-0.4.2 → 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 -----
@@ -514,6 +439,8 @@ class LoopGain:
         loop_type: Optional[str] = None,
         team: Optional[str] = None,
         include_per_iteration: bool = True,
+        retries: int = 2,
+        retry_backoff: float = 0.25,
     ) -> bool:
         """Send anonymized telemetry to a receiver endpoint.
 
@@ -544,6 +471,12 @@ class LoopGain:
                 per-iteration Aβ + error trajectories (capped) so the
                 dashboard's Loop Detail scrubber works. Set ``False`` to
                 send only aggregate summary stats.
+            retries: Additional attempts if a send fails *transiently*
+                (timeout, connection error, 5xx/429). Default 2 (up to 3
+                attempts). Set to 0 for single-shot. Deterministic failures
+                (bad token, etc.) are never retried.
+            retry_backoff: Base seconds between attempts; the nth retry waits
+                ``retry_backoff * n``. Default 0.25.
 
         Returns:
             ``True`` on 2xx response, ``False`` otherwise.
@@ -572,5 +505,11 @@ class LoopGain:
             include_per_iteration=include_per_iteration,
         )
         return send_payload(
-            endpoint, token, payload, timeout=timeout, allow_insecure=allow_insecure
+            endpoint,
+            token,
+            payload,
+            timeout=timeout,
+            allow_insecure=allow_insecure,
+            retries=retries,
+            retry_backoff=retry_backoff,
         )

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

@@ -22,7 +22,9 @@ from __future__ import annotations
 
 import json
 import math
+import socket
 import statistics
+import time
 import urllib.error
 import urllib.request
 from datetime import datetime, timezone
@@ -35,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
@@ -84,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
@@ -174,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"),
@@ -183,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,
@@ -218,18 +213,43 @@ def build_payload(
     return payload
 
 
+def _is_transient(exc: BaseException) -> bool:
+    """Is this send failure worth retrying?
+
+    Transient = timeout, connection/DNS error, or a 5xx/429 from the server —
+    a later attempt might succeed. Deterministic failures (4xx other than 429,
+    a refused redirect) will never succeed on retry, so they are *not*
+    transient and we give up immediately.
+    """
+    if isinstance(exc, urllib.error.HTTPError):  # subclass of URLError — check first
+        return exc.code >= 500 or exc.code == 429
+    return isinstance(exc, (TimeoutError, socket.timeout, urllib.error.URLError, OSError))
+
+
 def send_payload(
     endpoint: str,
     token: str,
     payload: dict[str, Any],
     timeout: float = 2.0,
     allow_insecure: bool = False,
+    retries: int = 2,
+    retry_backoff: float = 0.25,
 ) -> bool:
     """POST a telemetry payload to the given endpoint.
 
     Best-effort: errors are swallowed; never raises. Returns ``True`` if
     the server returned a 2xx status, ``False`` otherwise.
 
+    A single send is one HTTP POST with a ``timeout``-second deadline. The
+    warm round-trip to the hosted receiver is ~150 ms, so the default 2 s
+    timeout has wide headroom; the failure mode in practice is a *transient*
+    outlier (a cold database first-write, a momentary network blip) that
+    blows past it. Because a low-frequency caller may send only one aggregate
+    per run, a single dropped send loses that whole run's data — so a transient
+    failure is retried up to ``retries`` times with a short linear backoff.
+    Deterministic failures (bad token, malformed payload, refused redirect)
+    are *not* retried. Still best-effort throughout: the loop never raises.
+
     Args:
         endpoint: Telemetry receiver URL (e.g.,
             ``https://telemetry.loopgain.ai/v1/aggregate``). Must use
@@ -240,13 +260,18 @@ def send_payload(
         token: Bearer token issued by the receiver. Identifies the customer
             account; rotatable; not linked to any production secrets.
         payload: Dict from ``build_payload``.
-        timeout: Per-request timeout in seconds. Default 2.0.
+        timeout: Per-attempt timeout in seconds. Default 2.0.
         allow_insecure: If ``True``, permit ``http://`` endpoints. Intended
             for local development against a self-hosted receiver on
             ``http://localhost``. Default ``False``.
+        retries: Number of *additional* attempts after the first if the send
+            fails transiently. Default 2 (so up to 3 attempts total). Set to
+            0 to restore single-shot behavior.
+        retry_backoff: Base seconds to sleep between attempts; the nth retry
+            waits ``retry_backoff * n`` (0.25 s, 0.50 s, …). Default 0.25.
 
     Returns:
-        ``True`` on 2xx response, ``False`` otherwise.
+        ``True`` on a 2xx response, ``False`` otherwise.
     """
     # Refuse to attach the bearer token to anything but http(s); silently
     # best-effort so a misconfigured endpoint can't break the user's loop.
@@ -263,23 +288,33 @@ def send_payload(
 
     try:
         body = json.dumps(payload).encode("utf-8")
-        req = urllib.request.Request(
-            endpoint,
-            data=body,
-            method="POST",
-            headers={
-                "Content-Type": "application/json",
-                "Authorization": f"Bearer {token}",
-                "User-Agent": f"loopgain/{LIBRARY_VERSION}",
-            },
-        )
-        # Use the no-redirect seam so a malicious or misconfigured
-        # endpoint can't 302 the bearer token to a different host.
-        with _open_request(req, timeout) as resp:
-            return 200 <= resp.status < 300
     except Exception:
-        # Best-effort: never break the user's loop because telemetry failed.
-        # Catches URLError, HTTPError, TimeoutError, OSError, plus the
-        # ValueError that urllib raises for malformed URLs (e.g., missing scheme),
-        # plus any JSON-encoding edge case in the payload.
+        # A payload that won't JSON-encode will never send — don't retry.
         return False
+
+    req = urllib.request.Request(
+        endpoint,
+        data=body,
+        method="POST",
+        headers={
+            "Content-Type": "application/json",
+            "Authorization": f"Bearer {token}",
+            "User-Agent": f"loopgain/{LIBRARY_VERSION}",
+        },
+    )
+
+    attempts = max(1, retries + 1)
+    for i in range(attempts):
+        try:
+            # Use the no-redirect seam so a malicious or misconfigured
+            # endpoint can't 302 the bearer token to a different host.
+            with _open_request(req, timeout) as resp:
+                return 200 <= resp.status < 300
+        except Exception as exc:
+            # Best-effort: never break the user's loop because telemetry failed.
+            # Retry only transient failures, and only if attempts remain.
+            last = i == attempts - 1
+            if last or not _is_transient(exc):
+                return False
+            time.sleep(retry_backoff * (i + 1))
+    return False

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: loopgain
-Version: 0.4.2
+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)
 ```
 
@@ -183,6 +182,7 @@ LoopGain saves money by stopping a loop once it stops improving — fewer iterat
 
 - **Savings depend on your workload.** Loops that usually succeed fast save the most (~96%); adversarial, failure-prone loops save less (~78–84%). The headline is a blend — run the benchmark on your own loops before quoting a number.
 - **LoopGain detects convergence, not correctness.** It stops when your error signal stops improving — which means more iterations won't help, *not* that the loop succeeded. On the benchmark this preserved quality (it rarely stopped early on a worse output; false-stop rate ≤4.5%), but a loop can stall with the error still above zero — a plateau at, say, 2 failing tests. So check `result.best_error` (or your own pass/fail) before you trust the output: if it plateaued short of your target, that's a quality gap LoopGain can't see, and a false stop that forces a rerun is the one way it eats into the savings. LoopGain decides *when to stop*; you decide *whether the answer is good enough*.
+- **LoopGain is only as right as your verifier.** It acts on the error signal you give it. If your verifier reports zero errors, LoopGain trusts that and stops — so a verifier with blind spots can report success on an answer that is still wrong, and LoopGain will confidently stop there. This is not the plateau case above: the error reads zero and the loop looks like a clean success, so neither LoopGain nor its convergence signal can flag it. The quality of the stop is bounded by the quality of the check behind your error signal. Pair LoopGain with the strongest verifier you can afford at the stop — executable tests over a sampled subset, a schema or type check over a vibe, a held-out check the loop didn't optimize against.
 
 ---
 
@@ -212,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.2 → 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.2 → 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.2 → 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 -----
@@ -660,3 +633,117 @@ def test_send_payload_refuses_redirects():
         req = urllib.request.Request("https://example.com/")
         with pytest.raises(urllib.error.HTTPError):
             method(req, io.BytesIO(b""), 302, "Found", {})
+
+
+# ----- send_payload retry behavior (transient failures) -----
+
+import socket as _socket
+import urllib.error as _uerr
+
+from loopgain import telemetry as _tele
+
+
+class _OkResp:
+    status = 202
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *args):
+        pass
+
+
+def _retry_payload():
+    return build_payload(_make_terminated_loop(), workload_id="retry-test")
+
+
+def test_send_payload_retries_transient_then_succeeds(monkeypatch):
+    """A transient failure (timeout) is retried; a later success returns True."""
+    calls = {"n": 0}
+
+    def flaky(req, timeout=None):
+        calls["n"] += 1
+        if calls["n"] < 3:
+            raise _socket.timeout("slow first attempts")
+        return _OkResp()
+
+    sleeps: list[float] = []
+    monkeypatch.setattr("loopgain.telemetry._open_request", flaky)
+    monkeypatch.setattr("loopgain.telemetry.time.sleep", lambda s: sleeps.append(s))
+
+    ok = send_payload("https://t.example/v1/aggregate", token="t", payload=_retry_payload())
+    assert ok is True
+    assert calls["n"] == 3                 # two transient failures, third succeeds
+    assert sleeps == [0.25, 0.5]           # linear backoff between attempts
+
+
+def test_send_payload_gives_up_after_retries_on_persistent_5xx(monkeypatch):
+    """A persistent transient (503) exhausts retries and returns False."""
+    calls = {"n": 0}
+
+    def always_503(req, timeout=None):
+        calls["n"] += 1
+        raise _uerr.HTTPError("https://t.example", 503, "unavailable", {}, None)
+
+    monkeypatch.setattr("loopgain.telemetry._open_request", always_503)
+    monkeypatch.setattr("loopgain.telemetry.time.sleep", lambda s: None)
+
+    ok = send_payload("https://t.example/v1/aggregate", token="t", payload=_retry_payload(), retries=2)
+    assert ok is False
+    assert calls["n"] == 3                  # 1 initial + 2 retries
+
+
+def test_send_payload_does_not_retry_deterministic_4xx(monkeypatch):
+    """A 401 will never succeed on retry — fail fast, no backoff."""
+    calls = {"n": 0}
+    slept = {"n": 0}
+
+    def unauthorized(req, timeout=None):
+        calls["n"] += 1
+        raise _uerr.HTTPError("https://t.example", 401, "unauthorized", {}, None)
+
+    monkeypatch.setattr("loopgain.telemetry._open_request", unauthorized)
+    monkeypatch.setattr("loopgain.telemetry.time.sleep", lambda s: slept.__setitem__("n", slept["n"] + 1))
+
+    ok = send_payload("https://t.example/v1/aggregate", token="bad", payload=_retry_payload())
+    assert ok is False
+    assert calls["n"] == 1                  # no retry on a deterministic 4xx
+    assert slept["n"] == 0
+
+
+def test_send_payload_retries_zero_is_single_shot(monkeypatch):
+    """retries=0 restores the original single-attempt behavior."""
+    calls = {"n": 0}
+
+    def timeout(req, timeout=None):
+        calls["n"] += 1
+        raise TimeoutError()
+
+    monkeypatch.setattr("loopgain.telemetry._open_request", timeout)
+    monkeypatch.setattr("loopgain.telemetry.time.sleep", lambda s: None)
+
+    ok = send_payload("https://t.example/v1/aggregate", token="t", payload=_retry_payload(), retries=0)
+    assert ok is False
+    assert calls["n"] == 1
+
+
+def test_send_payload_never_raises_on_unexpected_error(monkeypatch):
+    """A non-transient, unexpected error is swallowed (best-effort), no retry."""
+    def boom(req, timeout=None):
+        raise RuntimeError("unexpected")
+
+    monkeypatch.setattr("loopgain.telemetry._open_request", boom)
+    monkeypatch.setattr("loopgain.telemetry.time.sleep", lambda s: None)
+
+    assert send_payload("https://t.example/v1/aggregate", token="t", payload=_retry_payload()) is False
+
+
+def test_is_transient_classification():
+    assert _tele._is_transient(TimeoutError()) is True
+    assert _tele._is_transient(_socket.timeout()) is True
+    assert _tele._is_transient(_uerr.URLError("dns")) is True
+    assert _tele._is_transient(_uerr.HTTPError("u", 503, "x", {}, None)) is True
+    assert _tele._is_transient(_uerr.HTTPError("u", 429, "x", {}, None)) is True
+    assert _tele._is_transient(_uerr.HTTPError("u", 400, "x", {}, None)) is False
+    assert _tele._is_transient(_uerr.HTTPError("u", 401, "x", {}, None)) is False
+    assert _tele._is_transient(RuntimeError("x")) is False