Make release validation portable across clean test environments

Author: TNFR AI Agent

.github/WORKFLOWS.md

@@ -25,6 +25,10 @@ percentage, prove physical theorems or certify every optional backend. Audit
 coverage excludes optional compute, documentation and deployment environments
 unless their dependencies happen to be installed through the declared groups.
 
+Each Python test job attempts to retain its JUnit report for 14 days, including
+when tests fail. A report from an interrupted run covers only the tests reached;
+its presence does not establish completion or success.
+
 ## Documentation publication
 
 The documentation workflow validates repository sources, stages them through

.github/workflows/ci.yml

@@ -119,10 +119,19 @@ jobs:
 
       - name: Run unit tests
         if: matrix.python-version != '3.11'
-        run: python -m pytest
+        run: python -m pytest --junitxml=test-results/pytest.xml
 
       - name: Run unit tests with coverage
         if: matrix.python-version == '3.11'
         run: |
-          python -m coverage run --source=src -m pytest
+          python -m coverage run --source=src -m pytest --junitxml=test-results/pytest.xml
           python -m coverage report -m
+
+      - name: Retain test results
+        if: always()
+        uses: actions/upload-artifact@v4
+        with:
+          name: pytest-python-${{ matrix.python-version }}
+          path: test-results/pytest.xml
+          if-no-files-found: warn
+          retention-days: 14

tests/c6_lineage_fixtures.py

@@ -0,0 +1,55 @@
+"""Portable byte-lineage inputs, deliberately not scientific C6 evidence."""
+
+import hashlib
+import json
+from copy import deepcopy
+
+
+def write_synthetic_c6_lineage(directory, count):
+    """Write a minimal B26-style input DAG for CLI prevalidation only.
+
+    Records contain matching producer metadata and hashes, but no nodal states
+    or admitted experiment manifest. Tests must stop at the analysis boundary;
+    accepting these byte links does not admit a scientific report.
+    """
+    if not 2 <= count <= 6:
+        raise ValueError("the byte-lineage fixture supports two through six inputs")
+    key_rows = (
+        (),
+        ("input_evidence",),
+        ("input_evidence", "source_input_evidence"),
+        ("input_evidence", "parent_input_evidence", "source_input_evidence"),
+        (
+            "input_evidence",
+            "parent_input_evidence",
+            "previous_input_evidence",
+            "source_input_evidence",
+        ),
+        (
+            "input_evidence",
+            "parent_input_evidence",
+            "previous_input_evidence",
+            "earlier_input_evidence",
+            "source_input_evidence",
+        ),
+    )
+    paths = tuple(directory / f"source_{index}.json" for index in range(count))
+    records = [None] * count
+    raw = [None] * count
+    for index in reversed(range(count)):
+        record = {
+            "manifest": {"claim_id": f"synthetic-byte-source-{index}"},
+            "source_scope": ["synthetic/byte-prevalidation-only"],
+        }
+        for key, target in zip(
+            key_rows[count - index - 1], range(index + 1, count), strict=True
+        ):
+            record[key] = {
+                "sha256": hashlib.sha256(raw[target]).hexdigest(),
+                "producer_manifest": deepcopy(records[target]["manifest"]),
+                "producer_source_scope": list(records[target]["source_scope"]),
+            }
+        records[index] = record
+        raw[index] = (json.dumps(record, sort_keys=True) + "\n").encode("utf-8")
+        paths[index].write_bytes(raw[index])
+    return paths

tests/physics/test_c6_winding_coupled_budget_report.py

@@ -10,6 +10,7 @@
 import pytest
 
 from benchmarks import c6_winding_coupled_budget as campaign
+from tests.c6_lineage_fixtures import write_synthetic_c6_lineage
 
 DIRECTORY = Path(__file__).resolve().parents[2] / "artifacts/research"
 INPUTS = tuple(DIRECTORY / name for name in campaign.INPUT_NAMES)
@@ -521,16 +522,18 @@ def test_cli_binds_six_input_hashes_and_output_source_identity(
 def test_cli_validates_all_historical_byte_links_before_analysis(
     tmp_path, monkeypatch, changed_index
 ):
-    paths = tuple(tmp_path / f"source_{i}.json" for i in range(6))
-    for i, (path, source) in enumerate(zip(paths, INPUTS, strict=True)):
-        path.write_bytes(source.read_bytes() + (b"\n" if i == changed_index else b""))
+    paths = write_synthetic_c6_lineage(tmp_path, 6)
     output = tmp_path / "report.json"
     _cli(monkeypatch, paths, output)
 
     def forbidden(*args):
         raise AssertionError("invalid historical hashes must fail before analysis")
 
     monkeypatch.setattr(campaign, "analyze_c6_winding_coupled_budget", forbidden)
+    monkeypatch.setattr(campaign, "current_git_source_provenance", lambda *args: None)
+    with pytest.raises(AssertionError, match="invalid historical hashes"):
+        campaign.main()
+    paths[changed_index].write_bytes(paths[changed_index].read_bytes() + b"\n")
     with pytest.raises(ValueError, match="lineage hashes"):
         campaign.main()
     assert not output.exists()

tests/physics/test_c6_winding_pressure_levels_report.py

@@ -12,6 +12,7 @@
 import pytest
 
 from benchmarks import c6_winding_pressure_levels as campaign
+from tests.c6_lineage_fixtures import write_synthetic_c6_lineage
 
 DIRECTORY = Path(__file__).resolve().parents[2] / "artifacts/research"
 INPUTS = tuple(
@@ -508,16 +509,18 @@ def test_cli_retains_four_input_hashes_and_distinct_output_source_provenance(
 def test_cli_rejects_wrong_historical_bytes_before_analysis(
     tmp_path, monkeypatch, changed_index
 ):
-    paths = tuple(tmp_path / f"source_{i}.json" for i in range(4))
-    for i, (path, source) in enumerate(zip(paths, INPUTS, strict=True)):
-        path.write_bytes(source.read_bytes() + (b"\n" if i == changed_index else b""))
+    paths = write_synthetic_c6_lineage(tmp_path, 4)
     output = tmp_path / "report.json"
     _cli(monkeypatch, paths, output)
 
     def forbidden(*args):
         raise AssertionError("wrong historical bytes must fail before replay")
 
     monkeypatch.setattr(campaign, "analyze_c6_winding_pressure_levels", forbidden)
+    monkeypatch.setattr(campaign, "current_git_source_provenance", lambda *args: None)
+    with pytest.raises(AssertionError, match="wrong historical bytes"):
+        campaign.main()
+    paths[changed_index].write_bytes(paths[changed_index].read_bytes() + b"\n")
     with pytest.raises(ValueError, match="lineage hashes"):
         campaign.main()
     assert not output.exists()

tests/physics/test_c6_winding_pressure_repayment_report.py

@@ -11,6 +11,7 @@
 import pytest
 
 from benchmarks import c6_winding_pressure_repayment as campaign
+from tests.c6_lineage_fixtures import write_synthetic_c6_lineage
 
 DIRECTORY = Path(__file__).resolve().parents[2] / "artifacts/research"
 INPUTS = tuple(
@@ -452,9 +453,7 @@ def test_cli_retains_three_source_hashes_and_separate_producer_manifest(
 def test_cli_checks_parent_and_source_byte_lineage_before_analysis(
     tmp_path, monkeypatch, wrong_index
 ):
-    paths = tuple(tmp_path / f"input_{i}.json" for i in range(3))
-    for i, (path, source) in enumerate(zip(paths, INPUTS, strict=True)):
-        path.write_bytes(source.read_bytes() + (b"\n" if i == wrong_index else b""))
+    paths = write_synthetic_c6_lineage(tmp_path, 3)
     output = tmp_path / "result.json"
     monkeypatch.setattr(
         sys,
@@ -476,6 +475,10 @@ def forbidden(*args):
         raise AssertionError("lineage failure must precede analysis")
 
     monkeypatch.setattr(campaign, "analyze_c6_winding_pressure_repayment", forbidden)
+    monkeypatch.setattr(campaign, "current_git_source_provenance", lambda *args: None)
+    with pytest.raises(AssertionError, match="lineage failure must precede analysis"):
+        campaign.main()
+    paths[wrong_index].write_bytes(paths[wrong_index].read_bytes() + b"\n")
     with pytest.raises(ValueError, match="lineage hashes"):
         campaign.main()
     assert not output.exists()

tests/physics/test_c6_winding_pressure_sign_report.py

@@ -10,6 +10,7 @@
 import pytest
 
 from benchmarks import c6_winding_pressure_sign as campaign
+from tests.c6_lineage_fixtures import write_synthetic_c6_lineage
 
 ARTIFACTS = Path(__file__).resolve().parents[2] / "artifacts/research"
 PARENT = ARTIFACTS / "c6_winding_carry_itinerary.json"
@@ -461,11 +462,8 @@ def test_cli_binds_both_distinct_input_hashes_and_retains_historical_sources(
 
 
 def test_cli_rejects_wrong_source_bytes_before_replay(tmp_path, monkeypatch):
-    parent_path, source_path, output = (
-        tmp_path / name for name in ("parent.json", "source.json", "output.json")
-    )
-    parent_path.write_bytes(PARENT.read_bytes())
-    source_path.write_bytes(SOURCE.read_bytes() + b"\n")
+    parent_path, source_path = write_synthetic_c6_lineage(tmp_path, 2)
+    output = tmp_path / "output.json"
     monkeypatch.setattr(
         sys,
         "argv",
@@ -484,6 +482,10 @@ def forbidden(*args):
         raise AssertionError("the wrong source bytes must fail before replay")
 
     monkeypatch.setattr(campaign, "analyze_c6_winding_pressure_sign", forbidden)
+    monkeypatch.setattr(campaign, "current_git_source_provenance", lambda *args: None)
+    with pytest.raises(AssertionError, match="the wrong source bytes"):
+        campaign.main()
+    source_path.write_bytes(source_path.read_bytes() + b"\n")
     with pytest.raises(ValueError, match="lineage hash"):
         campaign.main()
     assert not output.exists()

tests/physics/test_c6_winding_pressure_stencil_report.py

@@ -10,6 +10,7 @@
 import pytest
 
 from benchmarks import c6_winding_pressure_stencil as campaign
+from tests.c6_lineage_fixtures import write_synthetic_c6_lineage
 
 DIRECTORY = Path(__file__).resolve().parents[2] / "artifacts/research"
 INPUTS = tuple(
@@ -497,16 +498,18 @@ def test_cli_retains_all_five_input_hashes_and_distinct_output_source(
 def test_cli_rejects_wrong_historical_bytes_before_replay(
     tmp_path, monkeypatch, changed_index
 ):
-    paths = tuple(tmp_path / f"source_{i}.json" for i in range(5))
-    for i, (path, source) in enumerate(zip(paths, INPUTS, strict=True)):
-        path.write_bytes(source.read_bytes() + (b"\n" if i == changed_index else b""))
+    paths = write_synthetic_c6_lineage(tmp_path, 5)
     output = tmp_path / "report.json"
     _cli(monkeypatch, paths, output)
 
     def forbidden(*args):
         raise AssertionError("wrong historical bytes must fail before analysis")
 
     monkeypatch.setattr(campaign, "analyze_c6_winding_pressure_stencil", forbidden)
+    monkeypatch.setattr(campaign, "current_git_source_provenance", lambda *args: None)
+    with pytest.raises(AssertionError, match="wrong historical bytes"):
+        campaign.main()
+    paths[changed_index].write_bytes(paths[changed_index].read_bytes() + b"\n")
     with pytest.raises(ValueError, match="lineage hashes"):
         campaign.main()
     assert not output.exists()

tests/physics/test_constitutive_support_scope.py

@@ -6,8 +6,10 @@
 
 from copy import deepcopy
 from fractions import Fraction
+from math import ulp
 
 import networkx as nx
+import numpy as np
 import pytest
 
 from tnfr.dynamics.dnfr import default_compute_delta_nfr
@@ -126,7 +128,10 @@ def test_same_initial_support_has_distinct_declared_tangents_and_energy_work():
 
 
 @pytest.mark.parametrize("explicit_lengths", (False, True))
-def test_potential_distinguishes_metric_length_from_conductance(explicit_lengths):
+@pytest.mark.parametrize("triangle", ("L", "U"))
+def test_potential_distinguishes_metric_length_from_conductance(
+    explicit_lengths, triangle, monkeypatch
+):
     first = _graph(explicit_lengths=explicit_lengths)
     second = _graph(2, explicit_lengths=explicit_lengths)
     before = compute_structural_potential(first)
@@ -139,10 +144,20 @@ def test_potential_distinguishes_metric_length_from_conductance(explicit_lengths
     assert compute_phase_curvature(first) == compute_phase_curvature(second)
     # Four nodes cannot supply the correlation fit's ten distinct pairs.
     # This explicitly tests the normalized-spectrum fallback, not every xi fit.
+    eigvalsh = np.linalg.eigvalsh
+    monkeypatch.setattr(
+        np.linalg, "eigvalsh", lambda matrix: eigvalsh(matrix, UPLO=triangle)
+    )
     xi_first = estimate_coherence_length_with_provenance(first)
     xi_second = estimate_coherence_length_with_provenance(second)
     assert xi_first.method == xi_second.method == "spectral_gap"
-    assert xi_first.value == xi_second.value
+    # A positive weighted three-leaf star has exact normalized spectrum
+    # (0, 1, 1, 2), hence xi=1. Square-root normalization and either equivalent
+    # LAPACK triangle route can differ in their last bits under scaling.
+    # This is a numerical test tolerance, not a universal solver error bound.
+    assert (xi_first.value, xi_second.value) == pytest.approx(
+        (1.0, 1.0), rel=0.0, abs=16 * ulp(1.0)
+    )
 
 
 def test_zero_conductance_support_still_changes_non_epi_channels():