@@ -65,6 +65,10 @@ All notable changes to this project will be documented in this file.
   interfaces from loading.
 - Keep spectral-cache writes from signature readouts off the caller's graph,
   including snapshot-only calls and graphs with an existing cache.
+- Handle the empty disagreement sector explicitly in matrix-exponential and
+  transient-gain calculations. Accept UTC `Z` timestamps consistently on Python
+  3.10 while preserving missing, nonmonotone and mixed-timezone evidence. Compare
+  FFT phase preservation by circular separation at the existing tolerance.
 - Make CLI byte-lineage tests independent of ignored historical artifacts,
   remove a pytest-benchmark fixture-name collision and compare spectral
   estimates against an analytic reference. CI retains per-Python JUnit reports.
 
@@ -217,10 +217,21 @@ def _parse_frequency_rows(text: str, *, max_rows: int):
 
 
 def _relative_times(timestamps: tuple[str, ...]):
+    """Read relative ISO times, normalizing only the terminal UTC designator.
+
+    Python 3.10 accepts an explicit ``+00:00`` offset but not a terminal ``Z``.
+    This conversion changes no stored timestamp, offset, missing-row or ordering
+    policy. A date alone followed by ``Z`` is not a UTC timestamp.
+    """
     parsed = []
     for value in timestamps:
         try:
-            parsed.append(datetime.fromisoformat(value))
+            terminal_utc = value.endswith("Z")
+            iso_value = value[:-1] + "+00:00" if terminal_utc else value
+            instant = datetime.fromisoformat(iso_value)
+            if terminal_utc and instant.utcoffset() is None:
+                raise ValueError("UTC designator requires a timezone-aware time")
+            parsed.append(instant)
         except ValueError:
             parsed.append(None)
     if not parsed:
 
@@ -10,9 +10,9 @@
 
 This module represents degenerate spectral information as **projectors**
 ``Π_λ = Q_λ Q_λ^H``.  A projector depends only on the subspace, so it is
-invariant under ``Q_λ → Q_λ · U``.  Every downstream spectral observable in TNFR
-is built from these projectors (see :mod:`tnfr.physics.spectral_certificates`),
-which makes basis independence structural rather than incidental.
+invariant under ``Q_λ → Q_λ · U``. Consumers of this projector API, including
+:mod:`tnfr.physics.spectral_certificates`, obtain that basis independence by
+construction. Other spectral APIs can retain basis-dependent coordinates.
 
 Scope
 =====
@@ -33,7 +33,7 @@
 
 import numpy as np
 
-try:  # scipy is an OPTIONAL dependency; the Schur certificate is gated on it
+try:  # Retained availability guard; SciPy is a declared core package dependency.
     from scipy.linalg import schur as _scipy_schur
 
     _HAS_SCIPY = True
@@ -224,16 +224,23 @@ def matrix_exponential(matrix, *, terms: int = 18) -> np.ndarray:
 
     Self-contained so the non-normal certificates need no SciPy: ``A`` is scaled
     by ``2^{-s}`` until its ∞-norm is ``≤ 1``, a truncated Taylor series is
-    evaluated, and the result is squared ``s`` times.
+    evaluated, and the result is squared ``s`` times. Input must be a finite
+    square matrix. On the zero-dimensional space, its exponential is the
+    empty identity, represented with shape ``(0, 0)``.
     """
     a = np.asarray(matrix, dtype=float)
+    if a.ndim != 2 or a.shape[0] != a.shape[1] or not np.all(np.isfinite(a)):
+        raise ValueError("matrix must be a finite square array")
+    orders = range(1, terms)
     n = a.shape[0]
+    if n == 0:
+        return np.eye(0)
     norm = float(np.linalg.norm(a, np.inf))
     s = max(0, int(np.ceil(np.log2(norm + 1.0))))
     b = a / (2**s)
     result = np.eye(n)
     term = np.eye(n)
-    for k in range(1, terms):
+    for k in orders:
         term = term @ b / k
         result = result + term
     for _ in range(s):
@@ -258,8 +265,11 @@ def transient_gain(matrix, *, t_max: float = 10.0, samples: int = 200) -> float:
     stable spectrum alone does not reveal.
     """
     a = np.asarray(matrix, dtype=float)
+    times = np.linspace(0.0, t_max, samples)
+    if a.shape == (0, 0):
+        return 0.0  # The only operator on the zero-dimensional space has norm zero.
     gain = 0.0
-    for t in np.linspace(0.0, t_max, samples):
+    for t in times:
         gain = max(gain, float(np.linalg.norm(matrix_exponential(a * t), 2)))
     return gain
 
 
@@ -6,12 +6,14 @@
 certificate on the non-consensus subspace ``{y : πᵀ y = 0}`` (the ``L``-invariant
 range of the consensus projection ``Q = I − 1 πᵀ``):
 
-* **U2 (bounded reorganization).**  The peak amplification ``sup_s ‖e^{−sL}‖`` on
-  the non-consensus subspace is certified both directly (``peak_gain``, an upper
-  scan) and from the resolvent (``kreiss_lower_bound``, the Kreiss lower bound);
-  ``kreiss ≤ peak`` by the Kreiss matrix theorem.  The integrated reorganization
-    ``J`` and its closed bound ``M‖LQ‖‖x₀‖/ω`` come from the structural-time
-    layer.
+* **U2 diagnostics.** ``peak_gain`` is the largest sampled amplification on a
+  finite structural-time window of the non-consensus subspace. It is not an
+  upper certificate for unsampled times or the infinite horizon. The resolvent
+  routine supplies a finite sampled comparison. The exact Kreiss inequality
+  relates global resolvent and semigroup suprema; it does not order these two
+  independently sampled maxima. The structural-time layer also supplies
+  integrated-reorganization estimates ``J`` and the reported comparison
+  ``M‖LQ‖‖x₀‖/ω``; a global bound requires an independently justified ``M``.
 * **Structural-potential magnitude.** The structural potential along the
   sampled relaxation window is ``Φ_s(s) = −B L e^{−sL} Q x₀`` with the
   inverse-square aggregation ``B[i][j] = d(i,j)^{−2}``. Its sampled absolute
@@ -151,6 +153,8 @@ def peak_transient_gain(
     """
     t_max, samples = _scan_parameters(t_max, samples)
     lsub = restricted_generator(adjacency)
+    if lsub.shape == (0, 0):
+        return 0.0, 0.0  # No disagreement coordinates or amplification to scan.
     best, s_star = 0.0, 0.0
     for s in np.linspace(0.0, t_max, samples):
         g = float(np.linalg.norm(matrix_exponential(-lsub * s), 2))
 
@@ -150,6 +150,44 @@ def test_matrix_exponential_of_zero_is_identity():
     assert np.allclose(matrix_exponential(np.zeros((3, 3))), np.eye(3))
 
 
+def test_empty_matrix_exponential_is_identity_without_a_norm_reduction(monkeypatch):
+    def forbidden_norm(*args, **kwargs):
+        raise AssertionError("An empty identity needs no numerical norm reduction")
+
+    monkeypatch.setattr(np.linalg, "norm", forbidden_norm)
+    matrix = np.empty((0, 0))
+    result = matrix_exponential(matrix)
+
+    np.testing.assert_array_equal(result, np.eye(0))
+    assert result.shape == (0, 0)
+    assert result is not matrix
+    assert (result @ np.empty(0)).shape == (0,)
+
+
+@pytest.mark.parametrize(
+    "matrix",
+    [
+        0.0,
+        [],
+        [1.0, 2.0],
+        np.empty((0, 2)),
+        np.empty((2, 0)),
+        np.empty((0, 0, 0)),
+        [[0.0, float("nan")], [0.0, 0.0]],
+        [[float("inf")]],
+        [[-float("inf")]],
+    ],
+)
+def test_matrix_exponential_rejects_malformed_or_nonfinite_matrices(matrix):
+    with pytest.raises(ValueError, match="finite square"):
+        matrix_exponential(matrix)
+
+
+def test_empty_matrix_exponential_does_not_bypass_series_index_validation():
+    with pytest.raises(TypeError):
+        matrix_exponential(np.empty((0, 0)), terms=1.5)
+
+
 def test_matrix_exponential_matches_diagonal():
     d = np.diag([-1.0, -2.0, 0.5])
     expected = np.diag([np.exp(-1.0), np.exp(-2.0), np.exp(0.5)])
@@ -160,6 +198,14 @@ def test_transient_gain_of_zero_generator_is_one():
     assert transient_gain(np.zeros((3, 3))) == pytest.approx(1.0, abs=1e-9)
 
 
+def test_empty_transient_sector_has_zero_gain_without_a_norm_reduction(monkeypatch):
+    def forbidden_norm(*args, **kwargs):
+        raise AssertionError("The zero-dimensional sector has operator norm zero")
+
+    monkeypatch.setattr(np.linalg, "norm", forbidden_norm)
+    assert transient_gain(np.empty((0, 0))) == 0.0
+
+
 # --------------------------------------------------------------------------- #
 # Certificate and exports
 # --------------------------------------------------------------------------- #
 
@@ -171,12 +171,15 @@ def test_small_perturbation_has_small_potential_magnitude_without_u6_verdict():
 
 
 @pytest.mark.parametrize("kwargs", [{"t_max": -1.0}, {"samples": 1}])
-def test_finite_transient_scans_reject_degenerate_windows(kwargs):
-    x = _unit([1.0, -1.0, 0.5, -0.5, 0.25, -0.25, 0.125])
+@pytest.mark.parametrize(
+    "adjacency", [NORMAL, np.zeros((1, 1))], ids=["nontrivial", "trivial"]
+)
+def test_finite_transient_scans_reject_degenerate_windows(kwargs, adjacency):
+    x = _unit([(-1) ** i / (i + 1) for i in range(len(adjacency))])
     with pytest.raises(ValueError):
-        peak_transient_gain(NORMAL, **kwargs)
+        peak_transient_gain(adjacency, **kwargs)
     with pytest.raises(ValueError):
-        structural_potential_peak(NORMAL, x, **kwargs)
+        structural_potential_peak(adjacency, x, **kwargs)
 
 
 def test_transient_certificate_reports_unassessed_tail():
@@ -195,7 +198,17 @@ def test_transient_certificate_rejects_unimplemented_metric_label():
         certify_transient_u2(NON_NORMAL, X4, norm_kind="weighted_l2")
 
 
-def test_single_node_certificate_has_trivial_nonconsensus_sector():
+def test_single_node_certificate_has_trivial_nonconsensus_sector(monkeypatch):
+    original_norm = np.linalg.norm
+
+    def reject_empty_reduction(value, *args, **kwargs):
+        # NumPy 2.2 rejects both empty infinity and spectral norm reductions.
+        # Keep this boundary covered when newer NumPy supplies zero itself.
+        if np.asarray(value).size == 0:
+            raise ValueError("Empty norm reduction has no maximum")
+        return original_norm(value, *args, **kwargs)
+
+    monkeypatch.setattr(np.linalg, "norm", reject_empty_reduction)
     certificate = certify_transient_u2(np.zeros((1, 1)), np.array([0.25]))
 
     assert certificate.peak_gain == 0.0
 
@@ -308,17 +308,24 @@ def test_fft_step_rejects_tampered_diffusion_operator() -> None:
         engine.fft_accelerated_step(graph, state, 0.01)
 
 
-def test_fft_phase_step_respects_live_u3_gate() -> None:
+@pytest.mark.parametrize("phase_origin", (0.0, math.tau - 0.1))
+def test_fft_phase_step_respects_live_u3_gate(phase_origin: float) -> None:
     graph = nx.path_graph(2)
     graph.graph["DELTA_PHI_MAX"] = 0.1
-    graph.nodes[0].update(EPI=0.2, nu_f=0.0, theta=0.0)
-    graph.nodes[1].update(EPI=0.2, nu_f=0.0, theta=0.5)
+    phases = (phase_origin, (phase_origin + 0.5) % math.tau)
+    for node, phase in enumerate(phases):
+        graph.nodes[node].update(EPI=0.2, nu_f=0.0, theta=phase)
     engine = FFTDynamicsEngine(enable_caching=False)
     state = engine.fft_accelerated_step(graph, engine.create_fft_state(graph), 0.1)
     engine.reconstruct_graph_from_fft(graph, state)
 
-    assert get_attr(graph.nodes[0], ALIAS_THETA) == pytest.approx(0.0, abs=1e-14)
-    assert get_attr(graph.nodes[1], ALIAS_THETA) == pytest.approx(0.5, abs=1e-14)
+    # A round-trip error below zero wraps near 2*pi. U3 and phase preservation
+    # concern circular separation, including preparations across that branch.
+    for node, expected in enumerate(phases):
+        error = math.remainder(
+            get_attr(graph.nodes[node], ALIAS_THETA) - expected, math.tau
+        )
+        assert error == pytest.approx(0.0, abs=1e-14)
 
 
 @pytest.mark.parametrize("channel", ("phase", "capacity"))
 
@@ -4,6 +4,7 @@
 import importlib.util
 import sys
 import zipfile
+from datetime import datetime
 from pathlib import Path
 
 import pytest
@@ -63,6 +64,63 @@ def test_time_unavailability_is_explicit_without_dropping_samples(
     assert record.time_status == status
 
 
+@pytest.mark.parametrize(
+    "times,elapsed,status",
+    [
+        (
+            ("2020-01-01T00:00:00Z", "2020-01-01T00:00:01.25Z"),
+            (0.0, 1.25),
+            "relative_seconds",
+        ),
+        (
+            ("2020-01-01T00:00:00Z", "2020-01-01T01:00:01+01:00"),
+            (0.0, 1.0),
+            "relative_seconds",
+        ),
+        (
+            ("2020-01-01T00:00:01Z", "2020-01-01T00:00:00Z"),
+            (0.0, -1.0),
+            "nonmonotone_timestamp",
+        ),
+        (
+            ("2020-01-01T00:00:00", "2020-01-01T00:00:01Z"),
+            (None, None),
+            "mixed_timezone_unavailable",
+        ),
+        (
+            ("2020-01-01Z", "2020-01-01T00:00:01Z"),
+            (None, None),
+            "unavailable_timestamp",
+        ),
+    ],
+)
+def test_utc_designator_with_legacy_iso_parser_preserves_time_admission(
+    tmp_path, monkeypatch, times, elapsed, status
+):
+    received = []
+
+    class LegacyDatetime:
+        @staticmethod
+        def fromisoformat(value):
+            received.append(value)
+            # Reproduce Python 3.10's missing terminal-Z support without
+            # requiring that interpreter on every development machine.
+            if value.endswith("Z"):
+                raise ValueError("Invalid isoformat string")
+            return datetime.fromisoformat(value)
+
+    monkeypatch.setattr(BENCH, "datetime", LegacyDatetime)
+    path = archive(tmp_path, f"timestamp,frequency\n{times[0]},50\n{times[1]},\n")
+    record = BENCH.load_grid_frequency_record(path)
+    assert record.timestamps == times
+    assert record.values_hz == (50.0, None)
+    assert record.missing == (False, True)
+    assert record.source_line_numbers == (2, 3)
+    assert record.elapsed_seconds == elapsed
+    assert record.time_status == status
+    assert len(received) == 2 and all(not value.endswith("Z") for value in received)
+
+
 @pytest.mark.parametrize(
     "limits,match",
     [