fix(cllc): converge steady-state at the resonant load-independent point

The CLLC frontend scenario (400 V in, 400 V / 8.25 A out, fr = fsw = 120 kHz,
n = 1, symmetric tank) printed "[CLLC] steady-state solver did not fully
converge" (~2.44 A residual), which the frontend treats as an error — even
though the emitted waveform already matches SPICE (the reference-design PtP
tests pass). Two issues, both fixed:

- Observable residual. The convergence residual was the 4-state antisymmetry
  norm over {iLr1, iLm, vCr1, vCr2}. The two series resonant caps are tracked
  independently, but the tank only ever sees their SUM (Vc = vCr1 + vCr2); the
  common-mode split between them is a gauge freedom that affects no waveform.
  The raw norm penalized that unobservable split (and mixed amps with volts),
  reading ~2.4 at the load-independent point while the physical state was
  converged. Gate and report on the antisymmetry of the OBSERVABLE states only:
  iLr1, iLm, and the total cap voltage (vCr1 + vCr2).

- LIP perturbation removed on this path. The 0.5% Vi perturbation existed only
  to keep a Newton Jacobian non-singular at Vi ≈ Vo, but the 4-state path uses
  damped Picard (no Jacobian). It only injected a ~0.5% inconsistency between
  the solved seed (Vi·1.005) and the re-propagated waveform (true Vi), which
  surfaced directly as residual. Solving at the true Vi makes the converged
  state self-consistent.

Result: residual 2.44 -> below the 0.5 gate. [cllc-topology] 36/36 pass and
CLLC reference-design PtP 6/6 pass (waveforms unchanged within SPICE agreement).

Test: Test_Cllc_FrontendRepro_SteadyState_Converges (TestCllc.cpp).

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: AlfVII

src/converter_models/Cllc.cpp

@@ -1177,13 +1177,14 @@ double get_value_or(T&& val, double default_val) {
                                    std::abs(Iload_reflected) * 1.5);
         CllcStateVector x0_seed{ -Ires_est, -Im_pk_est, 0.0 };
 
-        // LIP perturbation (mirrors LLC) to avoid the singular-Jacobian ridge
-        // when Vi ≈ Vo and fsw ≈ fr.
+        // No LIP perturbation for the 4-state path: that trick (mirrored from
+        // LLC) only existed to keep a Newton Jacobian non-singular at Vi ≈ Vo,
+        // but this path uses the damped-Picard solver, which inverts no Jacobian.
+        // Perturbing Vi here only injects a ~0.5% inconsistency between the seed
+        // (solved at Vi·1.005) and the waveform (re-propagated at the true Vi),
+        // which shows up directly as steady-state antisymmetry residual. Solve at
+        // the true Vi so the converged state is self-consistent.
         double Vi_solver = Vi;
-        double denom_vo = std::max(std::abs(Vi), std::abs(Vo));
-        if (denom_vo > 0 && std::abs(Vi - Vo) / denom_vo < 0.005) {
-            Vi_solver = Vi * 1.005;
-        }
 
         // -------------------------------------------------------------------
         // ASYMMETRIC vs SYMMETRIC TANK BRANCH
@@ -1287,6 +1288,24 @@ double get_value_or(T&& val, double default_val) {
             // safely and yields a benign no-power waveform.
             // Re-propagate with the authoritative Vi (drop the LIP perturbation).
             segs4 = cllc4_propagate_half_cycle(x0_4, Thalf_eff, Vi, Vo, tp4);
+
+            // Re-measure convergence on the OBSERVABLE states. The 4-state model
+            // tracks the two series resonant caps (vCr1, vCr2) independently, but
+            // the tank only ever sees their SUM (Vc_pos = vCr1 + vCr2 below) — the
+            // common-mode split between the caps is a gauge freedom that does not
+            // affect any emitted waveform. The raw 4-D residual penalizes that
+            // unobservable split, so it can read several "A" (actually volts, the
+            // norm mixes A and V) at the resonant Load-Independent Point even when
+            // the physical waveform is fully converged (and matches SPICE). Gate
+            // and report on the antisymmetry of the observables only: the tank
+            // current, the magnetizing current, and the TOTAL cap voltage.
+            if (!segs4.empty() && residual >= 0.0) {
+                const CllcState4& xe = segs4.back().x_end;
+                double rI1 = xe.iLr1 + x0_4.iLr1;
+                double rIm = xe.iLm  + x0_4.iLm;
+                double rVsum = (xe.vCr1 + xe.vCr2) + (x0_4.vCr1 + x0_4.vCr2);
+                residual = std::sqrt(rI1 * rI1 + rIm * rIm + rVsum * rVsum);
+            }
             // Sample 4-state segments, then collapse vCr1+vCr2 → Vc_pos so
             // the downstream symmetric-aware code path works unchanged.
             std::vector<double> vCr1_pos(N + 1, 0.0), vCr2_pos(N + 1, 0.0);

tests/TestCllc.cpp

@@ -1542,3 +1542,30 @@ namespace {
     }
 
 } // anonymous namespace
+
+// Captured from the WebFrontend CLLC scenario suite (2026-06-14): 400 V in,
+// 400 V / 8.25 A out, fr = 120 kHz, n = 1, Lm = 200 µH. The steady-state Newton
+// solve must converge to at or below MKF's own gate floor across the input-
+// voltage corners; on capture the residual was ~2.44 A / 1.39 A and the solver
+// printed a non-convergence warning the frontend treats as an error.
+TEST_CASE("Test_Cllc_FrontendRepro_SteadyState_Converges", "[converter-model][cllc-topology][frontend-repro]") {
+    const std::string CLLC_INPUT = R"JSON(
+{"inputVoltage":{"nominal":400,"tolerance":0.1},"bridgeType":"fullBridge","minSwitchingFrequency":80000,"maxSwitchingFrequency":200000,"resonantFrequency":120000,"qualityFactor":0.4,"inductanceRatio":5,"integratedResonantInductor1":true,"integratedResonantInductor2":false,"bidirectional":false,"resonantInductorRatio":1,"resonantCapacitorRatio":1,"operatingPoints":[{"outputVoltages":[400],"outputCurrents":[8.25],"switchingFrequency":120000,"ambientTemperature":25,"powerFlow":"forward"}],"desiredTurnsRatios":[1],"desiredMagnetizingInductance":0.0002,"numberOfPeriods":2}
+)JSON";
+    constexpr double convergenceFloorA = 0.5;  // Cllc.cpp gate floor
+
+    OpenMagnetics::CllcConverter cllc(json::parse(CLLC_INPUT));
+    REQUIRE_NOTHROW(cllc.process_design_requirements());
+
+    const std::vector<double> turnsRatios = {1.0};   // from desiredTurnsRatios
+    const double magnetizingInductance = 200e-6;     // from desiredMagnetizingInductance
+    REQUIRE_NOTHROW(cllc.process_operating_points(turnsRatios, magnetizingInductance));
+
+    const double residual = cllc.get_last_steady_state_residual();
+    INFO("CLLC last steady-state residual = " << residual << " A (gate floor "
+         << convergenceFloorA << " A; observed on capture ~2.44 A / 1.39 A)");
+    for (double r : cllc.get_per_op_steady_state_residual()) {
+        CHECK(r <= convergenceFloorA);
+    }
+    CHECK(residual <= convergenceFloorA);
+}