Push coverage to ~97% headroom above the 95% nightly gate

After the parser fix the nightly cleared 95% with little margin.
This commit closes the largest remaining gaps so a small
incidental change does not immediately drop us back under the
gate.

New / updated test files:

* tests/test_entropy_solver_option_z_smoke.py: end-to-end
  EntropySolver.solve() with use_jax_jacobian=true and a
  registered JAX CVODE factory. Exercises the wire-up at
  entropy_solver.py:2417-2424 (factory invocation +
  Option-Z-active log) and _solve_cvode lines 1900-1905 +
  2002-2005 (JAX RHS / Jacobian install path: dense linsolver,
  banded keys popped).

* tests/test_cvode_jax_exception_paths.py: forces the rhs_fn /
  jacfn except branches by passing wrong-shape ydot / J buffers
  so the in-place numpy assignment raises (cvode_jax.py:217-237).
  Plus a happy-path test of the radio_isotope_params 5-tuple
  branch (line 179).

* tests/test_entropy_solver_remaining_gaps.py: smoke + unit
  tests for the small scattered branches: energy_balance with
  inner_bc_kind=1 dispatch (line 1450), set_initial_entropy
  fallback paths when called pre-initialize (1143-1144,
  1157-1158), and the Phi_global mean fallback when
  mass_total = 0 (line 2885).

* tests/test_parser_toml_dispatch.py: extends with two new
  regression tests covering the bad-radionuclide TypeError
  wrap and the IC-method-2 init_temperature loadtxt path.

* tests/test_cli_more_branches.py: adds tests for the
  ImportError fallback in _version_message (lines 60-61) and
  the vnv module-spec-load failure (line 921).

* tests/test_entropy_solver_eos_method2_smoke.py: now also
  calls get_state() so the UserDefinedEOS branch in
  entropy_solver.py:2848-2850 (no get_mass_within_radii) is
  exercised end-to-end.

No production-code changes. All 33 affected tests pass; full
suite (565 tests) verified locally before this commit.

Author: timlichtenberg

tests/test_cli_more_branches.py

@@ -262,6 +262,71 @@ def read_text(self, encoding=None):
 # ──────────────────────────────────────────────────────────────────────
 
 
+def test_version_message_handles_missing_dependency(monkeypatch):
+    """Lines 60-61 of cli.py: ``_version_message`` builds the
+    ``aragog --versions`` block by importing each dependency by name;
+    when one raises ImportError or other exceptions, the line must
+    fall back to ``"not installed"`` rather than aborting the whole
+    listing.
+
+    Discriminator: a regression that let the exception propagate
+    would make ``aragog --versions`` (the bug-report-friendly mode)
+    crash on any environment that lacks one of the optional deps.
+    """
+    import importlib
+
+    import aragog.cli as cli_mod
+
+    real_import = importlib.import_module
+
+    def _faulty_import(name, package=None):
+        if name == 'jax':
+            raise ImportError('intentional test fault')
+        return real_import(name, package=package)
+
+    monkeypatch.setattr(importlib, 'import_module', _faulty_import)
+    msg = cli_mod._version_message()
+    assert 'aragog ' in msg
+    assert 'jax: not installed' in msg, (
+        f'expected "jax: not installed" line on ImportError; got {msg!r}'
+    )
+
+
+def test_vnv_handles_module_spec_load_failure(monkeypatch, tmp_path):
+    """Line 921 of cli.py: when ``importlib.util.spec_from_file_location``
+    cannot build a spec / loader, ``aragog vnv <topic>`` must raise
+    ClickException with a "could not load" message.
+
+    Discriminator: forced spec=None via monkeypatch makes the loader
+    branch fire. A regression that swallowed the failure or let the
+    None-spec into ``module_from_spec`` would crash with AttributeError
+    deeper in the stack instead of the user-facing "could not load".
+    """
+    import importlib.util
+
+    from click.testing import CliRunner
+
+    import aragog.cli as cli_mod
+
+    figures_dir = tmp_path / 'figs'
+    figures_dir.mkdir()
+    (figures_dir / 'verify_demo.py').write_text('def main(): pass\n', encoding='utf-8')
+    monkeypatch.setattr(cli_mod, '_vnv_figures_dir', lambda: figures_dir)
+
+    real_spec_from_file = importlib.util.spec_from_file_location
+
+    def _none_spec(*args, **kwargs):
+        return None
+
+    monkeypatch.setattr(importlib.util, 'spec_from_file_location', _none_spec)
+    runner = CliRunner()
+    result = runner.invoke(cli_mod.cli, ['vnv', 'demo'])
+    assert result.exit_code != 0
+    assert 'could not load' in (result.output or '').lower()
+    # Restore (autouse cleanup happens via monkeypatch but assert).
+    monkeypatch.setattr(importlib.util, 'spec_from_file_location', real_spec_from_file)
+
+
 def test_serialize_params_walks_radionuclide_list_and_unboxes_np_scalars():
     """Lines 732, 736: ``_serialize_params`` recurses into lists and
     unboxes numpy scalars via ``.item()``.

tests/test_cvode_jax_exception_paths.py

@@ -0,0 +1,242 @@
+"""Exception paths inside ``build_jax_rhs_and_jacobian``'s rhs_fn /
+jacfn callbacks.
+
+The factory's contract is that any uncaught exception inside the
+JAX-traced RHS or Jacobian must be swallowed (logged + return 1) so
+CVODE can fall back to its own finite-difference Jacobian rather
+than aborting the integrator partway through a long solve.
+
+The contract tests in test_cvode_jax_factory.py and the invocation
+tests in test_cvode_jax_factory_invocation.py exercise the happy
+paths but not these except branches (lines 221-223, 235-237 of
+solver/cvode_jax.py). Force the failures by giving the in-place
+output buffers the wrong shape so the trailing ``ydot[:] = ...`` /
+``J[...] = ...`` write raises during numpy broadcast.
+"""
+
+from __future__ import annotations
+
+import logging
+import os
+from pathlib import Path
+
+import numpy as np
+import pytest
+
+jax = pytest.importorskip('jax')
+jnp = pytest.importorskip('jax.numpy')
+eqx = pytest.importorskip('equinox')
+
+jax.config.update('jax_enable_x64', True)
+
+pytestmark = pytest.mark.unit
+
+
+_REPO_ROOT = Path(__file__).resolve().parent.parent
+_FWL_DATA = os.environ.get('FWL_DATA')
+_CANDIDATES = [
+    os.environ.get('ARAGOG_TEST_EOS_DIR'),
+    f'{_FWL_DATA}/aragog/spider_eos' if _FWL_DATA else None,
+    str(_REPO_ROOT.parent / 'output' / 'coupled_parity' / 'spider' / 'data' / 'spider_eos'),
+]
+EOS_DIR = next(
+    (Path(p) for p in _CANDIDATES if p and Path(p).exists()),
+    Path(_CANDIDATES[-1]),
+)
+needs_eos = pytest.mark.skipif(
+    not EOS_DIR.exists(),
+    reason=f'SPIDER P-S tables not found at {EOS_DIR}.',
+)
+
+
+def _make_const_property_mesh(N: int = 8):
+    """Minimal MeshArrays for cheap factory tests."""
+    from aragog.jax.phase import MeshArrays
+
+    R_INNER = 3.480e6
+    R_OUTER = 6.371e6
+    r_stag = np.linspace(R_INNER, R_OUTER, N)
+    dr = np.diff(r_stag)
+    r_basic = np.zeros(N + 1)
+    r_basic[0] = R_INNER
+    r_basic[-1] = R_OUTER
+    r_basic[1:-1] = 0.5 * (r_stag[:-1] + r_stag[1:])
+    area = 4.0 * np.pi * r_basic**2
+    volume = (4.0 / 3.0) * np.pi * np.diff(r_basic**3)
+    ml = np.maximum(np.minimum(r_basic - R_INNER, R_OUTER - r_basic), 1.0)
+    d_dr = np.zeros((N + 1, N))
+    for i in range(1, N):
+        d_dr[i, i - 1] = -1.0 / dr[i - 1]
+        d_dr[i, i] = 1.0 / dr[i - 1]
+    d_dr[0, :] = d_dr[1, :]
+    d_dr[-1, :] = d_dr[-2, :]
+    q_mat = np.zeros((N + 1, N))
+    q_mat[0, 0] = 1.0
+    q_mat[-1, -1] = 1.0
+    for i in range(1, N):
+        q_mat[i, i - 1] = 0.5
+        q_mat[i, i] = 0.5
+    P_stag = np.linspace(135e9, 1e5, N)
+    P_basic = q_mat @ P_stag
+    return MeshArrays(
+        d_dr_matrix=jnp.asarray(d_dr),
+        quantity_matrix=jnp.asarray(q_mat),
+        area=jnp.asarray(area),
+        volume=jnp.asarray(volume),
+        radii_basic=jnp.asarray(r_basic),
+        radii_stag=jnp.asarray(r_stag),
+        mixing_length=jnp.asarray(ml),
+        mixing_length_sq=jnp.asarray(ml**2),
+        mixing_length_cu=jnp.asarray(ml**3),
+        P_stag=jnp.asarray(P_stag),
+        P_basic=jnp.asarray(P_basic),
+        gravity=jnp.full(N + 1, 10.0),
+    )
+
+
+def _make_bc():
+    from aragog.jax.solver import BoundaryParams
+
+    return BoundaryParams(
+        outer_bc_type=4,
+        outer_bc_value=0.0,
+        emissivity=1.0,
+        T_eq=255.0,
+        inner_bc_type=2,
+        inner_bc_value=0.0,
+        core_density=10500.0,
+        core_heat_capacity=880.0,
+        tfac_core_avg=1.147,
+    )
+
+
+def _build_factory():
+    """Build a factory at quasi_steady mode against a real EOS."""
+    if not EOS_DIR.exists():
+        pytest.skip(f'EOS unavailable at {EOS_DIR}')
+
+    from aragog.jax.eos import EntropyEOS_JAX
+    from aragog.jax.nondim import NonDimScales
+    from aragog.jax.phase import PhaseParams
+    from aragog.solver.cvode_jax import build_jax_rhs_and_jacobian
+
+    eos_jax = EntropyEOS_JAX(EOS_DIR)
+    params = PhaseParams()
+    mesh = _make_const_property_mesh(N=8)
+    bc = _make_bc()
+    n_stag = int(mesh.P_stag.shape[0])
+    state_scale = np.full(n_stag, 3.0e3)
+    scales = NonDimScales(state_scale=state_scale, t_ref=1.0)
+    heating = np.zeros(n_stag)
+    rhs_fn, jac_fn, info = build_jax_rhs_and_jacobian(
+        eos_jax=eos_jax,
+        phase_params=params,
+        mesh_arrays=mesh,
+        boundary_params=bc,
+        heating_array=heating,
+        scales=scales,
+        core_bc_mode='quasi_steady',
+    )
+    return rhs_fn, jac_fn, info, n_stag
+
+
+@needs_eos
+def test_factory_rhs_fn_returns_one_on_buffer_shape_mismatch(caplog):
+    """Passing an ``ydot_nd`` whose length disagrees with the JAX
+    output forces the in-place write ``ydot_nd[:] = np.asarray(result)``
+    to raise. The except branch must catch, log an ERROR-level
+    message naming the failure, and return 1 so CVODE drops to its
+    own FD-Jacobian.
+
+    Discriminator: silence + return 0 would let CVODE proceed with
+    a stale ydot, producing a corrupt trajectory. The non-zero
+    return AND the error log are both required.
+    """
+    rhs_fn, _, info, n_stag = _build_factory()
+    y_nd = np.full(n_stag, 3050.0 / 3.0e3)
+    ydot_nd = np.zeros(n_stag - 3)  # wrong length: 5 vs n_stag=8
+
+    with caplog.at_level(logging.ERROR, logger='fwl.aragog.solver.cvode_jax'):
+        rc = rhs_fn(0.0, y_nd, ydot_nd)
+
+    assert rc == 1, f'shape-mismatch rhs_fn must return 1; got {rc}'
+    err_msgs = [r.message for r in caplog.records if r.levelno >= logging.ERROR]
+    assert any('JAX RHS failed' in m for m in err_msgs), (
+        f'expected "JAX RHS failed" error log; got {err_msgs}'
+    )
+
+
+@needs_eos
+def test_factory_jacfn_returns_one_on_buffer_shape_mismatch(caplog):
+    """Same exception contract for the Jacobian callback. Wrong-shape
+    J buffer forces the in-place write ``J[...] = np.asarray(jac)``
+    to raise. The except branch must catch, log an ERROR, and return
+    1 so CVODE drops to its FD Jacobian.
+    """
+    _, jacfn, info, n_stag = _build_factory()
+    y_nd = np.full(n_stag, 3050.0 / 3.0e3)
+    fy_nd = np.zeros(n_stag)
+    J = np.zeros((n_stag - 1, n_stag - 1))  # wrong shape: (7,7) vs (8,8)
+
+    with caplog.at_level(logging.ERROR, logger='fwl.aragog.solver.cvode_jax'):
+        rc = jacfn(0.0, y_nd, fy_nd, J)
+
+    assert rc == 1, f'shape-mismatch jacfn must return 1; got {rc}'
+    err_msgs = [r.message for r in caplog.records if r.levelno >= logging.ERROR]
+    assert any('JAX Jacobian failed' in m for m in err_msgs), (
+        f'expected "JAX Jacobian failed" error log; got {err_msgs}'
+    )
+
+
+@needs_eos
+def test_factory_with_radio_isotope_params_builds_callable_radio_heating(caplog):
+    """Lines 179 of cvode_jax.py: the ``radio_isotope_params`` 5-tuple
+    branch builds a JAX-traceable ``H_radio(t_yr)`` callable via
+    ``make_radio_heating_fn``.
+
+    Discriminator: a regression that lost the 5-tuple unpacking
+    would raise during construction. Verifies the factory builds
+    AND the resulting RHS callback executes once without errors,
+    which means the radio-heating call inside the JAX trace did
+    not fail.
+    """
+    from aragog.jax.eos import EntropyEOS_JAX
+    from aragog.jax.nondim import NonDimScales
+    from aragog.jax.phase import PhaseParams
+    from aragog.solver.cvode_jax import build_jax_rhs_and_jacobian
+
+    eos_jax = EntropyEOS_JAX(EOS_DIR)
+    params = PhaseParams()
+    mesh = _make_const_property_mesh(N=8)
+    bc = _make_bc()
+    n_stag = int(mesh.P_stag.shape[0])
+    state_scale = np.full(n_stag, 3.0e3)
+    scales = NonDimScales(state_scale=state_scale, t_ref=1.0)
+    heating = np.zeros(n_stag)
+
+    # 5-tuple in the factory's expected order:
+    # (heat_prod, abundance, concentration, t0_years, half_life_years).
+    # Values approximate Al26 at the Solar System epoch.
+    rhs_fn, _jac_fn, info = build_jax_rhs_and_jacobian(
+        eos_jax=eos_jax,
+        phase_params=params,
+        mesh_arrays=mesh,
+        boundary_params=bc,
+        heating_array=heating,
+        scales=scales,
+        core_bc_mode='quasi_steady',
+        radio_isotope_params=(
+            0.3583,  # heat_prod
+            1.0,  # abundance
+            1.0e-9,  # concentration
+            4.55e9,  # t0_years
+            7.17e5,  # half_life_years
+        ),
+    )
+    # First call must succeed: the radio_heating function fires
+    # inside the JAX trace at this t.
+    y_nd = np.full(n_stag, 3050.0 / 3.0e3)
+    ydot_nd = np.zeros(n_stag)
+    rc = rhs_fn(0.0, y_nd, ydot_nd)
+    assert rc == 0, f'radio-heating-aware rhs_fn returned {rc}; expected 0'
+    assert info['rhs_calls'] == 1

tests/test_entropy_solver_eos_method2_smoke.py

@@ -204,6 +204,18 @@ def test_solver_loads_external_mesh_with_eos_method_2(shared_eos, tmp_path_facto
     final_y = solver._solution.y[:, -1] if solver._solution.y.ndim == 2 else solver._solution.y
     assert np.all(np.isfinite(final_y)), 'eos_method=2 final state has NaN'
 
+    # Discriminator: get_state() with UserDefinedEOS triggers the
+    # discrete-sum mantle-mass branch (entropy_solver.py:2848-2850)
+    # because UserDefinedEOS lacks the analytic
+    # ``get_mass_within_radii`` method that AdamsWilliamsonEOS
+    # provides. M_mantle must come back finite and physically
+    # plausible for an Earth-like geometry (a few 1e24 kg).
+    out = solver.get_state()
+    assert np.isfinite(out.M_mantle)
+    assert 1.0e23 < float(out.M_mantle) < 1.0e25, (
+        f'M_mantle = {float(out.M_mantle):.3e} kg outside plausible Earth-like mantle range'
+    )
+
 
 def test_solver_reset_reloads_external_mesh_on_each_call(shared_eos, tmp_path_factory):
     """``EntropySolver.reset()`` must re-read the eos_file when