test: add opt-in shifted FP32 Jet CV control

docs/validation/jet_circle_cv.md

@@ -113,3 +113,47 @@ These criteria are fixed before the continuation runs. There is no new physical
 Actual earlier scale-1 pilot cost was 52.3884s launch-to-exit, 46.1414s after READY for800 steps with full-field diagnostics every base step. A naive same-diagnostic3200-step scale-1 extrapolation is about210s; the new876 field samples reduce transfer count but add ray diagnostics and compression. Use conservative planning envelopes210–500s for scale1 and900–3200s for scale2, not timing guarantees. The scale2 conservative envelope accounts for4x cells and4x root steps; sparse sampling mitigates but does not eliminate that cost. Post-READY safety caps are1200s and5400s respectively, replacing the unsuitable fixed1800s assumption. Root owns compilation/startup timeout and serial launch decisions.
 
 Device-envelope estimates remain128/512MiB for s1/s2, at least1GiB free (or twice estimate). Output estimate is under64MiB per run including five primitive snapshots and876 sample records; no all-time populations are saved. Plan/metadata and sampled files are rewritten at each100-reference-time window to retain bounded partial evidence if interrupted. READY still follows compiled warmup and state/time reset, before measured stepping begins.
+
+## Dense-root temporal diagnostic: preparation only
+
+The audited continuation did not resolve time quadrature: all48 audited stride2 RMS changes exceeded their stride1 CV residuals, by factors1.55–11.46. That historical failure and its gates remain unchanged. The following is a measurement-only experiment to test this explanation, not a solver fix, a physics pass, or permission to extend GPU work. The separate periodic global stock-minus-raw mass residual also persists; denser contour quadrature cannot by itself resolve it.
+
+Future launch, only after the computer is online and root approves a serialized bounded run:
+
+```sh
+CUDA_VISIBLE_DEVICES="$VERIFIED_IDLE_GPU" python tests/validation/run_jet_circle_cv.py --repo "$PWD" --output "$NEW_DENSE_S1" --dense-root --steps 800 --scale 1
+CUDA_VISIBLE_DEVICES="$VERIFIED_IDLE_GPU" python tests/validation/run_jet_circle_cv.py --repo "$PWD" --output "$NEW_DENSE_S2" --dense-root --steps 800 --scale 2
+python tests/validation/analyze_jet_cv_continuation.py "$NEW_DENSE_S1" "$NEW_DENSE_S2" --output "$DENSE_COMPARISON_JSON"
+```
+
+This mode fixes Re100,beta.1 and reference t=0..800 (t*≈.9965), with800/3200 root intervals and801/3201 endpoint records. It is mutually exclusive with --continuation and rejects longer runs or other scales/Re. Physical geometry, source manifest, solver, velocity commands, kernel and raw observation path are unchanged. There are no new finest-hop hooks. Existing GPU population downloads occur every root interval for CPU primitive diagnostics; those distributions are discarded rather than retained.
+
+Dense scalar records contain CV endpoint inventories, each flux and split momentum terms, density/speed, physical composite mass, exact cumulative raw partitions and cumulative absolute aperture net mass. Rays remain on the exact old reference cadence:0..100 at dt1, then104..800 at dt4,276 samples for each scale. Schema2 maps their smaller arrays through ray_sample_indices into the dense records. Full primitive snapshots occur only at reference0,100,800. Saved data is capped at32MiB per case; dense arrays are scalar diagnostics, not all-time full fields. Schema/unit metadata, file hashes, complete-schedule checks and matched root time intervals remain mandatory.
+
+The analyzer derives root strides1,2,4 and the exact old cadence from the SAME dense primitive records, always keeping window endpoints and the SAME raw ledger. At scale2 these root strides correspond to reference dt.25,.5,1; the old cadence corresponds to root gaps4/16. Its fourth quadrature result and change from dense are separately identified. Existing residual normalizations and historical files are preserved. No automatic refinement-progress flags are issued for this temporal-only mode. Root-sampled agreement cannot certify finer-than-root time convergence or exclude aliasing; an unresolved outcome stays unresolved, with no automatic longer run.
+
+Three distinct throughput quantities must remain separate:
+
+- Prescribed unsigned nominal mass at rho_ref=1:2*Q_command*window_duration.
+- Observed raw absolute NET aperture mass: sum over root intervals of abs(dm_blowing)+abs(dm_suction), after spatial reduction within each aperture. This retains reversals between root intervals that abs(window-net) loses. Within-aperture or within-root/substep reversals remain unresolved by this ledger. The legacy raw_gross_mass_over_nominal field retains its old abs(window-net)/ONE-aperture-nominal definition; it is not this new quantity.
+- Sparse reconstructed absolute Q/M: true-arc quadrature of abs(u.n) and abs(rho*u.n), using each existing linear/quadratic ray estimate, followed by old-cadence time integration. This is estimator-dependent measured-field evidence, not exact wall truth, not dense-root quadrature, and not a prescribed nominal flow.
+
+Global stock-minus-raw mass balance is reported per root interval and summed per window, in reference mass units. Raw total-minus-wall/aperture partition discrepancies are also separate. Neither is bundled into the CV temporal error, and neither is called a proven raw-extractor defect. Source/geometry/state validity, both signed and gross budgets, old failures, and physics_validation_pass=false remain intact.
+
+Planning envelope from the earlier52-second800-step pilot: s1 60–240s, s2 600–2400s, with conservative post-READY caps1200/5400s. Scale2 has4x cells and4x root observations over the same reference horizon; sparse saving reduces output, not all CPU/PCIe observation cost. These are preparation estimates, not measured timings. Root owns startup/compilation timeout and GPU serialization. No GPU/remote action was taken to prepare this option.
+
+Budget enforcement preflights the projected retained file sizes before replacing each snapshot/window report or the sample+metadata pair. If32MiB would be exceeded, staged replacements are removed, the previous verified sample/hash-metadata pair remains intact, and execution stops. Temporary compression files need additional short-lived disk space and are distinct from the32MiB retained-evidence cap. This protects budget failures; it is not a filesystem crash-recovery transaction. Both raw partition identities, total−wall−aperture and aperture−blowing−suction, are saved separately from stock/raw and CV residuals.
+
+## Optional shifted-FP32 representation control
+
+The dense-root campaign accepts `--shifted-fp32` as an explicit numerical-representation control. Without it, the historical unshifted FP32 default remains unchanged. Use a fresh output directory and append the flag to the reviewed dense command, for example:
+
+```bash
+CUDA_VISIBLE_DEVICES="$VERIFIED_IDLE_GPU" python tests/validation/run_jet_circle_cv.py --repo "$PWD" --output "$NEW_SHIFTED_DENSE_S1" --dense-root --steps 800 --scale 1 --shifted-fp32
+```
+
+Root owns the future GPU launch and scale selection. This option requires the bounded dense campaign; it does not authorize another run. Geometry, Jet profile/amplitude, initial physical seed, viscosity, time horizon, root sampling, sparse rays/fields, normalization, thresholds, budgets and prior failed gates are unchanged. The `case.ddf_shifting` flag and `case.storage_variant` receipt appear in the plan, READY, window report and sample metadata. Preserve the unshifted evidence in its original directory. Compare like-scale records at identical root endpoints, including CV mass/momentum, global stock-minus-raw balance, raw partitions and measured aperture flux. A reduced mass residual would support representation sensitivity; it would not establish physical convergence or prove that every residual is roundoff.
+
+Both production blocked steppers already support this representation: initialization takes physical populations and encodes `g=f-w` to FP32; public download returns physical `f` decoded in FP64. The runner deliberately retains its historical FP32-rounded physical equilibrium seed for BOTH variants rather than also changing initial precision. Encoding introduces a small additional rounding difference: maximum per-population change 1.035e-10 and density change 3.201e-10 at both scales for this seed. Thus the decoded starting states are not bit-identical. The residual initial density offset is therefore not removed. All existing measurement routines receive physical populations and apply no extra weight shift. Snapshots keep the existing primitive-field precision.
+
+The existing `BlockCurvedBoundary` optional-input adapter invokes the same shifted-aware BFL helper as the AMR boundary: wall density restores the unit background, raw mass uses reflected-minus-outgoing (opposite weights cancel), and reaction restores twice the direction weight. No host correction is applied to raw rows. The shifted branch selects `compute_feq_from_momentum` rather than unshifted `compute_feq`, so this control changes existing numerical algebra as well as storage representation. It cannot isolate storage precision alone or identify collision as the sole cause. Block collision preserves the density perturbation in its shifted branch; blocked halo copies and AMR transfers already support shifted storage. This option changes no solver/kernel/API or source manifest. Existing shifted-storage/Jet host tests and the new runner codec tests are CPU evidence only; numerical GPU behavior remains to be checked by the reviewed control.

docs/validation/uniform_srt_diagnostic.md

@@ -1,52 +0,0 @@
-# First-failure uniform SRT diagnostic (prepared, not executed)
-
-Purpose: locate the first physical failure in the unchanged uniform D80 SRT control that was healthy at executed step 160 and nonfinite at the next observation, executed step 320. The original failure's summary `steps=160` is the last accepted observation, not the last executed step. This diagnostic does not select different numerical parameters, run an AMR case or perform a new benchmark campaign.
-
-## Exact source and configuration
-
-The default source is the containing repository (override with `--source`); the exact pinned production/runtime source is commit `9805383f9c50d867e8555471baf5dbda8333a652`. The manifest pins production files and the helper/runner dependencies directly against the original failure's `source_before.json`. All pinned contents match. Import guards require CelerisLab and the runner from the selected pinned checkout.
-
-The script calls the original `run_refined_dfg.config(helper,80)` factory and unchanged `Simulation(...).initialize()`. Thus it retains D80, U=.01, ν=.008, τ=.524, ω≈1.9084, shifted FP32, SRT, double buffer, parabolic local Zou–He inlet, all-nine pressure-NEQ damping .5, backflow clamp disabled, identical cylinder geometry and initialization. No clipping, equilibrium rewrite or solver patch is added.
-
-The inlet overload in this source may differ by FP32 rounding from older d79 code even where the algebra matches; that is not changed here and is not established as the cause of failure. MRT's outlet branch also differs. Neither prior MRT success nor this diagnostic establishes an SRT/outlet/body attribution.
-
-## Observation and stop contract
-
-- At most 320 actual solver steps, starting from the original fresh initialization. Stop at the first physical health failure (or wall deadline).
-- Read the production macroscopic path, its decoded populations, and force after every completed step. Preserve the actual executed count separately from the last observed count.
-- Independently report nonfinite physical populations, nonfinite physical macros and nonfinite reaction. Apply the original density [.5,1.5] and Mach≤.2 checks to physical FLUID nodes. A new population-only check may stop earlier than the original macro-only health check; the report explicitly distinguishes it.
-- Per-step `Simulation.run(1)` resets/reads the observation buffer for a one-step force window. This changes observation cadence and force accumulation windows, not configuration or fluid updates. A cumulative-force-only overflow from the original 100/60-step batching would not be reproduced identically; that limitation is explicit. Original macro warnings already show nonfinite populations/macros, so this instrument prioritizes locating the physical failure.
-- Ghost/inactive/body-solid populations are reported in separate categories; their NaNs do not independently trigger physical failure. Category masks are disjoint and complete. Boundary subtypes are decoded as the nibble, not mistaken for independent bit flags.
-- Physical region labels are body-near (within radius+3 cells), outlet/inlet-near (three fluid columns), wall-near (three fluid rows), and remaining bulk. These locate symptoms, not causal mechanisms.
-- Initial, preceding and firstbad/final compact reports retain category counts, finite global extrema and positions, the first 16 offending nodes in row-major order, their bad q indices/all populations, and up to four 5×5 population/flag neighborhoods. “First” identifies earliest sampled step; within that step the list is row-major, not an asserted temporal order among GPU threads.
-
-## Bounded evidence
-
-Only the immediately preceding and firstbad/final active-buffer states are retained. `states.npz` contains their exact raw shifted FP32 values, production-decoded FP32 populations and step numbers, plus flags. This is ~81 MiB at the exact D80 shape, with a 128 MiB artifact limit enforced. There are no saved field trajectories. Initial conditions are reproducible from the source/config; only their diagnostic summary is retained.
-
-These are diagnostic snapshots, not full restart checkpoints (spare buffers and observation/control state are not a restart bundle). `diagnostics.json` stores nonfinite numbers as explicit `NaN`, `+Inf`, `-Inf` strings and is strict finite JSON; NPZ preserves actual IEEE values. A force-only failure can have no offending fluid node. A clean cap means no sampled failure through 320, not benchmark acceptance.
-
-## CPU validation
-
-```sh
-python tests/validation/uniform_srt_diagnostic/test_diagnostic.py
-python tests/validation/uniform_srt_diagnostic/diagnose_uniform_srt.py --output /tmp/new-srt-preflight
-```
-
-Seven CPU-only tests pass: source/config, complete category partition, inactive nonfinite exclusion, independent population/macro/force reasons, health thresholds, bounded two-state artifact writing, and deadline/source guards. `py_compile` and the real-source default preflight pass. No CUDA import is required by preflight/tests and no GPU was executed here.
-
-## Root-only admitted execution
-
-After independent review and root GPU admission:
-
-```sh
-CUDA_VISIBLE_DEVICES=<admitted-device> timeout --signal=TERM --kill-after=30s <hard-budget>s python tests/validation/uniform_srt_diagnostic/diagnose_uniform_srt.py --source <exact-9805383-checkout> --execute --gpu-admitted --wall-seconds <soft-budget> --output <new-output-directory>
-```
-
-The external watchdog is required for a blocked CUDA call; cooperative wall checks cannot interrupt one. Budget should allow per-step downloads and ~81 MiB evidence writing; this diagnostic is not a performance measurement. The step ceiling cannot be increased by a CLI flag. `READY` is emitted after the first completed step and all observation paths. First physical failure is expected diagnostic evidence and returns exit 2; step cap returns 0. `preflight.json` records the pre-execution configuration, not a completion receipt.
-
-Original failure files, production source, original pilot runner and gates are untouched. This test-only handoff is based on exact commit 9805383; added diagnostic files are not part of the historical failure source manifest.
-
-## Historical reporting undercount (not changed here)
-
-The failed pilot executed to step 320 before its second observation failed. Its summary `steps=160` reflects `begin`, which advances only after an accepted observation. This is a reporting undercount, not evidence that the second batch did not execute. The original failure package and runner/gates are preserved unchanged. This diagnostic records both `executed_steps` and `observation_step`, and labels previous-state steps explicitly. Fixing the historical runner's reporting is a separate change.

tests/unit/test_jet_circle_cv.py

@@ -28,6 +28,41 @@ def eq(rho, u, v):
 
 
 class Host(unittest.TestCase):
+    def test_shifted_storage_receipt_preserves_physical_case(self):
+        for scale in (1, 2):
+            base = case(scale)
+            shifted = case(scale, ddf_shifting=True)
+            self.assertFalse(base.pop("ddf_shifting"))
+            self.assertTrue(shifted.pop("ddf_shifting"))
+            self.assertEqual(base.pop("storage_variant")["name"], "unshifted_fp32")
+            self.assertEqual(shifted.pop("storage_variant")["name"], "shifted_fp32")
+            self.assertEqual(base, shifted)
+
+    def test_shifted_physical_download_roundtrip(self):
+        from CelerisLab.lbm.population_storage import _encode_physical, _decode_stored
+        from run_jet_circle_cv import moments
+        from jet_cv_measurements import primitives
+
+        for speed in (0.03, 0.015):
+            seed = state((9, 48, 64), speed)
+            self.assertEqual(seed.dtype, np.float32)
+            plain = _decode_stored(_encode_physical(seed, False), False)
+            decoded = _decode_stored(_encode_physical(seed, True), True)
+            self.assertEqual(decoded.dtype, np.float64)
+            np.testing.assert_array_equal(plain, seed)
+            # Same FP32 physical seed; only encoding quantization may differ.
+            np.testing.assert_allclose(decoded, seed, rtol=0, atol=3e-10)
+            rho, momentum, velocity = moments(decoded)
+            rho2, velocity2 = primitives(decoded, CX, CY)
+            np.testing.assert_array_equal(rho, rho2)
+            np.testing.assert_array_equal(velocity, velocity2)
+            np.testing.assert_allclose(momentum, rho * velocity, atol=1e-17)
+            fluid = np.ones(seed.shape[1:], bool)
+            inv, flux = cv(decoded, fluid, (0, 0), (5, 4, 25, 20), 0.0072)
+            expected, _ = cv(seed, fluid, (0, 0), (5, 4, 25, 20), 0.0072)
+            np.testing.assert_allclose(inv, expected, rtol=0, atol=1e-6)
+            np.testing.assert_allclose(flux, 0, atol=1e-14)
+
     def test_descriptor_and_uniform_closed_flux(self):
         from CelerisLab.lbm.descriptors import D2Q9_EX, D2Q9_EY
 

tests/unit/test_jet_cv_measurements.py

@@ -31,6 +31,111 @@ from analyze_jet_cv_continuation import integrate, analyze
 
 
 class Measurements(unittest.TestCase):
+    def test_budget_failure_preserves_verified_pair(self):
+        from jet_cv_measurements import install_evidence
+
+        with tempfile.TemporaryDirectory() as tmp:
+            path = Path(tmp)
+            data = path / "samples.npz"
+            meta = path / "samples.json"
+            data.write_bytes(b"old-data")
+            meta.write_text("old-meta")
+            staged = path / ".samples.pending.npz"
+            staged_meta = path / ".meta.pending"
+            staged.write_bytes(b"x" * 100)
+            staged_meta.write_text("new-meta")
+            with self.assertRaisesRegex(RuntimeError, "last verified files preserved"):
+                install_evidence({data: staged, meta: staged_meta}, limit=20)
+            self.assertEqual(data.read_bytes(), b"old-data")
+            self.assertEqual(meta.read_text(), "old-meta")
+            self.assertEqual(
+                sorted(p.name for p in path.iterdir()), ["samples.json", "samples.npz"]
+            )
+
+    def test_dense_root_and_exact_old_cadence(self):
+        from jet_cv_measurements import old_sample_steps
+
+        for scale, count in ((1, 801), (2, 3201)):
+            c = case(scale, steps=800)
+            c["dense_root"] = True
+            dense = sample_steps(c)
+            old = old_sample_steps(c)
+            self.assertEqual(len(dense), count)
+            self.assertEqual(len(old), 276)
+            np.testing.assert_array_equal(dense, np.arange(800 * scale**2 + 1))
+            self.assertTrue(np.isin(old, dense).all())
+            np.testing.assert_array_equal(old[:101] / scale**2, np.arange(101))
+            np.testing.assert_array_equal(old[101:] / scale**2, np.arange(104, 801, 4))
+
+    def test_root_interval_absolute_net_mass_reversals(self):
+        from jet_cv_measurements import absolute_aperture_interval_mass
+
+        masks = (np.array([True, False]), np.array([False, True]))
+        rows = np.zeros((2, 4))
+        rows[0, 3] = 1
+        first = absolute_aperture_interval_mass(rows, *masks)
+        rows[0, 3] = -1
+        self.assertEqual(first + absolute_aperture_interval_mass(rows, *masks), 2)
+        self.assertEqual(abs(1 - 1), 0)
+
+    def test_dense_offline_oscillation_preserves_ledger(self):
+        import json
+        from jet_cv_measurements import old_sample_steps
+
+        for s in (1, 2):
+            c = case(s, steps=800)
+            c["dense_root"] = True
+            steps = sample_steps(c)
+            t = steps / s**2
+            n = len(t)
+            ridx = old_sample_steps(c)
+            # Nonzero steady reference fluxes cancel exact stock changes.
+            inv = np.zeros((n, 2, 2, 3))
+            inv[..., 0] = (100 - 0.001 * t[:, None, None]) * s**2
+            inv[..., 1] = -t[:, None, None] * 0.002 * s
+            flux = np.zeros_like(inv)
+            flux[..., 0] = 0.001 + 1e-4 * np.cos(np.pi / 2 * t[:, None, None])
+            flux[..., 1] = 0.002 / s
+            raw = np.zeros((n, 2, 5, 4))
+            with tempfile.TemporaryDirectory() as tmp:
+                path = Path(tmp)
+                (path / f"samples_s{s}.json").write_text(
+                    json.dumps(dict(case=c, sample_file="samples.npz"))
+                )
+                np.savez(
+                    path / "samples.npz",
+                    t_reference=t,
+                    cv_inventory=inv,
+                    cv_flux=flux,
+                    raw_cumulative=raw,
+                    ray_sample_indices=ridx,
+                    arc_estimates=np.zeros((len(ridx), 2, 2, 2, 2)),
+                    arc_absolute_estimates=np.zeros((len(ridx), 2, 2, 2, 2)),
+                    raw_absolute_aperture_mass_cumulative=np.broadcast_to(
+                        2 * t[:, None] * s**2, (n, 2)
+                    ),
+                    global_mass_reference=np.ones((n, 2)) * 100,
+                    level_stats=np.broadcast_to([1, 1, 0, 0.03, 100], (n, 3, 5)),
+                    velocity_error=np.zeros(n),
+                )
+                result = analyze(path)
+                w = result["windows"][1]
+                self.assertTrue(result["complete_schedule"])
+                np.testing.assert_allclose(
+                    np.array(w["normalized_cv_residual"])[0], 0, atol=1e-11
+                )
+                self.assertGreater(
+                    abs(np.array(w["old_cadence_change_from_dense"])[..., 0]).max(),
+                    0.005,
+                )
+                np.testing.assert_allclose(
+                    w["global_stock_raw_balance_sum_reference"], 0
+                )
+                np.testing.assert_allclose(
+                    w["raw_absolute_aperture_net_interval_mass_reference"], 200
+                )
+                np.testing.assert_allclose(w["raw_reaction_coefficient"], 0)
+
     def test_common_physical_schedule(self):
         a = sample_steps(case(1, steps=3200))
         b = sample_steps(case(2, steps=3200))
@@ -134,6 +239,57 @@ class Measurements(unittest.TestCase):
                 snap["uniform_velocity_reference"][0][fluid], 0.01, rtol=1e-7
             )
 
+    def test_dense_recorder_retains_sparse_rays(self):
+        h = 0.5
+        y, x = np.mgrid[:64, :64]
+        x = (x + 0.5) * h
+        y = (y + 0.5) * h
+        fluid = (x - 16) ** 2 + (y - 16) ** 2 > 25
+        fine_leaf = fluid.copy()
+        fine_leaf[:, :4] = False
+        root_leaf = np.zeros((32, 32), bool)
+        root_leaf[:, :2] = True
+
+        def eq(ny, nx):
+            cu = CX[:, None, None] * 0.01
+            return np.broadcast_to(
+                W[:, None, None] * (1 + 3 * cu + 4.5 * cu * cu - 1.5 * 0.01**2),
+                (9, ny, nx),
+            ).copy()
+
+        ug = eq(64, 64)
+        levels = [eq(32, 32), ug.copy()]
+        c = dict(
+            scale=1,
+            dense_root=True,
+            steps=800,
+            center=[16, 16],
+            diameter=10,
+            u=0.01,
+            nu=0.0072,
+            contours=[[9, 9, 23, 23], [7, 7, 25, 25]],
+        )
+        data = {
+            name: [cv(ug, mask, (0, 0), r, c["nu"]) for r in c["contours"]]
+            for name, mask in [("uniform_adapter", fluid), ("amr_api", fine_leaf)]
+        }
+        with tempfile.TemporaryDirectory() as tmp:
+            rec = MeasurementRecorder(
+                c, tmp, fluid, [root_leaf, fine_leaf], (0, 0), CX, CY
+            )
+            for step in (0, 101):
+                rec.capture(step, ug, levels, data, {k: np.zeros(2) for k in data}, 0.0)
+                rec.records[-1]["raw_cumulative"] = np.zeros((2, 5, 4))
+                rec.records[-1]["raw_absolute_aperture_mass_cumulative"] = np.zeros(2)
+            rec.flush()
+            a = np.load(Path(tmp) / "samples_s1.npz")
+            np.testing.assert_array_equal(a["step"], [0, 101])
+            np.testing.assert_array_equal(a["ray_sample_indices"], [0])
+            self.assertEqual(a["arc_estimates"].shape, (1, 2, 2, 2, 2))
+            self.assertTrue(
+                np.all(a["arc_absolute_estimates"] >= abs(a["arc_estimates"]) - 1e-14)
+            )
+
     def test_offline_mass_force_normalization(self):
         import json
 

tests/validation/analyze_jet_cv_continuation.py

@@ -32,7 +32,7 @@ def analyze(directory):
     t = a["t_reference"]
     if not len(t) or t[0] != 0 or np.any(np.diff(t) <= 0):
         raise ValueError("Sample reference times must increase strictly from zero")
-    from jet_cv_measurements import sample_steps
+    from jet_cv_measurements import sample_steps, old_sample_steps
 
     complete_schedule = np.array_equal(t, sample_steps(c) / s**2)
     records = []
@@ -45,7 +45,15 @@ def analyze(directory):
     )  # angular impulse reference = root/s^2 (not used in force tests)
     q0 = 2 * np.pi / 12 * (c["diameter"] / 2) * c["jet_speed"]
     f0 = 0.5 * (c["u"] * s) ** 2 * (c["diameter"] / s)
-    for lo in range(0, 3200, 100):
+    dense_root = c.get("dense_root", False)
+    old_times = old_sample_steps(c) / s**2
+    ray_indices = (
+        a["ray_sample_indices"] if "ray_sample_indices" in a else np.arange(len(t))
+    )
+    ray_times = t[ray_indices]
+    if dense_root and complete_schedule and not np.array_equal(ray_times, old_times):
+        raise ValueError("Sparse ray records do not match the declared old cadence")
+    for lo in range(0, c.get("steps", 3200 * s * s) // (s * s), 100):
         hi = lo + 100
         ids = np.flatnonzero((t >= lo) & (t <= hi))
         if len(ids) < 2 or t[ids[0]] != lo or t[ids[-1]] != hi:
@@ -54,8 +62,14 @@ def analyze(directory):
         delta = inv[last] - inv[first]
         ledger = raw[last] - raw[first]
         cv_variants = []
-        for stride in (1, 2, 4):
-            selected = np.unique(np.r_[ids[::stride], ids[-1]])
+        selections = [np.unique(np.r_[ids[::stride], ids[-1]]) for stride in (1, 2, 4)]
+        if dense_root:
+            selections.append(ids[np.isin(t[ids], old_times)])
+        for selected in selections:
+            if t[selected[0]] != lo or t[selected[-1]] != hi:
+                raise ValueError(
+                    "Every quadrature selection must retain both window endpoints"
+                )
             total = integrate(t[selected], flux[selected])
             m = delta[:, :, 0] + total[:, :, 0]
             j = -delta[:, :, 1:] - total[:, :, 1:]
@@ -68,16 +82,61 @@ def analyze(directory):
                     axis=-1,
                 )
             )
+        ray_ids = np.flatnonzero((ray_times >= lo) & (ray_times <= hi))
         arc = (
-            integrate(t[ids], a["arc_estimates"][ids]) / 100
+            integrate(ray_times[ray_ids], a["arc_estimates"][ray_ids]) / 100
         )  # Q/M rate conversion is unity
         # Each estimator, aperture, Q/M; compare against signed prescribed Q (rho_ref=1 for M only).
         arc_ratio = arc / np.array([q0, -q0])[None, None, :, None]
         global_delta = (
             a["global_mass_reference"][last] - a["global_mass_reference"][first]
         )
+        dense_details = {}
+        if dense_root:
+            absolute = (
+                a["raw_absolute_aperture_mass_cumulative"][last]
+                - a["raw_absolute_aperture_mass_cumulative"][first]
+            ) / s**2
+            stock_raw = np.diff(a["global_mass_reference"][ids], axis=0) - np.diff(
+                raw[ids, :, 2, 3], axis=0
+            )
+            partition = ledger[:, 2] - ledger[:, 0] - ledger[:, 1]
+            dense_details = dict(
+                quadrature_names=[
+                    "root_stride1",
+                    "root_stride2",
+                    "root_stride4",
+                    "exact_old_cadence",
+                ],
+                root_dt_reference=1 / s**2,
+                old_cadence_change_from_dense=(
+                    cv_variants[3] - cv_variants[0]
+                ).tolist(),
+                root_temporal_sensitivity_max=float(
+                    np.max(abs(np.array(cv_variants)[1:3] - cv_variants[0]))
+                ),
+                raw_absolute_aperture_net_interval_mass_reference=absolute.tolist(),
+                prescribed_unsigned_nominal_mass_reference=float(2 * q0 * 100),
+                legacy_raw_gross_field_definition="raw_gross_mass_over_nominal retains abs(window net blowing)+abs(window net suction), divided by ONE nominal aperture throughput; it is not root-interval absolute throughput.",
+                raw_absolute_to_prescribed_unsigned_nominal=(
+                    absolute / (2 * q0 * 100)
+                ).tolist(),
+                global_stock_raw_balance_max_abs_root_interval_reference=np.max(
+                    abs(stock_raw), axis=0
+                ).tolist(),
+                global_stock_raw_balance_sum_reference=stock_raw.sum(axis=0).tolist(),
+                raw_total_minus_wall_aperture_reference=partition.tolist(),
+                raw_aperture_minus_blowing_suction_reference=(
+                    ledger[:, 1] - ledger[:, 3] - ledger[:, 4]
+                ).tolist(),
+                measured_ray_absolute_volume_mass_reference=integrate(
+                    ray_times[ray_ids], a["arc_absolute_estimates"][ray_ids]
+                ).tolist(),
+                measured_ray_cadence="Sparse old cadence; estimator-dependent, not dense-root or exact wall throughput",
+            )
         records.append(
             dict(
+                **dense_details,
                 t_reference=[lo, hi],
                 startup=hi <= 800,
                 normalized_cv_residual=np.array(cv_variants).tolist(),
@@ -97,6 +156,12 @@ def analyze(directory):
         )
     return dict(
         scale=s,
+        dense_root=dense_root,
+        previous_temporal_failure_retained=(
+            "Prior continuation stride2 changes exceeded baseline residual in all48 audited comparisons; this diagnostic does not retroactively change those gates."
+            if dense_root
+            else None
+        ),
         complete_schedule=bool(complete_schedule),
         sample_checksum_verified=checksum_verified,
         windows=records,
@@ -122,8 +187,10 @@ def main():
         results=results,
         physics_validation_pass=False,
     )
-    if sorted(x["scale"] for x in results) == [1, 2] and all(
-        x["complete_schedule"] for x in results
+    if (
+        not any(x.get("dense_root", False) for x in results)
+        and sorted(x["scale"] for x in results) == [1, 2]
+        and all(x["complete_schedule"] for x in results)
     ):
         ordered = sorted(results, key=lambda x: x["scale"])
         summary = []

tests/validation/jet_cv_measurements.py

@@ -10,13 +10,63 @@ LINEAR = np.array([2.5, -1.5, 0.0])
 QUADRATIC = np.array([4.375, -5.25, 1.875])
 
 
+EVIDENCE_LIMIT = 32 * 1024**2
+
+
+def install_evidence(replacements, limit=None):
+    """Preflight retained bytes before replacing files; cap failure preserves old pair.
+
+    Staged compression bytes are temporary disk overhead, not retained evidence.
+    This guards budget failures, not a transactional crash-recovery filesystem.
+    """
+    temporary = set(replacements.values())
+    try:
+        directory = next(iter(replacements)).parent
+        retained = sum(
+            p.stat().st_size
+            for p in directory.iterdir()
+            if p.is_file() and p not in temporary
+        )
+        projected = retained - sum(p.stat().st_size for p in replacements if p.exists())
+        projected += sum(p.stat().st_size for p in temporary)
+        if limit is not None and projected > limit:
+            raise RuntimeError(
+                "Dense-root 32 MiB retained-evidence budget would be exceeded; last verified files preserved"
+            )
+        for target, staged in replacements.items():
+            staged.replace(target)
+    finally:
+        for p in temporary:
+            if p.exists():
+                p.unlink()
+
+
+def write_evidence_text(path, text, *, dense_root=False):
+    staged = path.with_name("." + path.name + ".pending")
+    staged.write_text(text)
+    install_evidence({path: staged}, EVIDENCE_LIMIT if dense_root else None)
+
+
 def sample_steps(c):
     """Same reference times at both scales; dense startup retained."""
+    if c.get("dense_root", False):
+        return np.arange(c["steps"] + 1, dtype=int)
+    return old_sample_steps(c)
+
+
+def old_sample_steps(c):
+    """Exact previous physical cadence, clipped to this campaign's endpoint."""
     s2 = c["scale"] ** 2
-    reference = sorted(set(range(0, 101)) | set(range(100, 3201, 4)))
+    end = c.get("steps", 3200 * s2) // s2
+    reference = sorted(set(range(0, min(100, end) + 1)) | set(range(100, end + 1, 4)))
     return np.array(reference, int) * s2
 
 
+def absolute_aperture_interval_mass(rows, blowing, suction):
+    """Sum absolute aperture NET masses for one root interval, not per-link flux."""
+    return float(abs(rows[blowing, 3].sum()) + abs(rows[suction, 3].sum()))
+
+
 def factors(scale):
     """Lref=one s=1 root length, Tref=one s=1 root time, rho_ref=1."""
     return dict(
@@ -105,7 +155,7 @@ def ray_geometry(fluid, origin, center, radius, h=0.5):
     )
 
 
-def reconstruct_aperture(rho, vel, geo):
+def reconstruct_aperture(rho, vel, geo, *, return_absolute=False):
     field = np.concatenate((rho[None], vel), axis=0)
     x, y, a, b = geo["ix"], geo["iy"], geo["a"], geo["b"]
     ray = (
@@ -115,12 +165,24 @@ def reconstruct_aperture(rho, vel, geo):
         + field[:, y + 1, x + 1] * a * b
     )
     estimates = []
+    absolute = []
     for coeff in (LINEAR, QUADRATIC):
         wall = np.einsum("cajk,k->caj", ray, coeff)
         un = np.einsum("caj,ajc->aj", wall[1:], geo["normal"])
         q = np.sum(un * geo["ds"], axis=1)
         mass = np.sum(wall[0] * un * geo["ds"], axis=1)
         estimates.append(np.stack((q, mass), axis=-1))
+        absolute.append(
+            np.stack(
+                (
+                    np.sum(abs(un) * geo["ds"], axis=1),
+                    np.sum(abs(wall[0] * un) * geo["ds"], axis=1),
+                ),
+                axis=-1,
+            )
+        )
+    if return_absolute:
+        return ray, np.array(estimates), np.array(absolute)
     return ray, np.array(estimates)
 
 
@@ -136,6 +198,8 @@ class MeasurementRecorder:
         self.cx = cx
         self.cy = cy
         self.records = []
+        self.sparse_rays = []
+        self.ray_steps = set(old_sample_steps(c).tolist())
         self.rays = [
             ray_geometry(fluid_u, (0.0, 0.0), np.array(c["center"]), c["diameter"] / 2),
             ray_geometry(leaves[1], origin_a, np.array(c["center"]), c["diameter"] / 2),
@@ -179,8 +243,16 @@ class MeasurementRecorder:
         record["cv_inventory"] = []
         record["cv_flux"] = []
         record["momentum_flux_terms"] = []
-        record["arc_ray_values"] = []
-        record["arc_estimates"] = []
+        save_ray = not c.get("dense_root", False) or step in self.ray_steps
+        ray_record = dict(
+            sample_index=len(self.records),
+            arc_ray_values=[],
+            arc_estimates=[],
+            arc_absolute_estimates=[],
+        )
+        if not c.get("dense_root", False):
+            record["arc_ray_values"] = []
+            record["arc_estimates"] = []
         record["nearest_mass_flux"] = [
             nearest_flux[k] for k in ("uniform_adapter", "amr_api")
         ]
@@ -203,9 +275,18 @@ class MeasurementRecorder:
                 rtol=2e-10,
             )
             record["momentum_flux_terms"].append(terms)
-            ray, estimates = reconstruct_aperture(rho, vel, self.rays[idx])
-            record["arc_ray_values"].append(ray)
-            record["arc_estimates"].append(estimates)
+            if save_ray:
+                ray, estimates, absolute = reconstruct_aperture(
+                    rho, vel, self.rays[idx], return_absolute=True
+                )
+                ray_record["arc_ray_values"].append(ray)
+                ray_record["arc_estimates"].append(estimates)
+                ray_record["arc_absolute_estimates"].append(absolute)
+                if not c.get("dense_root", False):
+                    record["arc_ray_values"].append(ray)
+                    record["arc_estimates"].append(estimates)
+        if c.get("dense_root", False) and save_ray:
+            self.sparse_rays.append(ray_record)
         self.records.append(record)
         if step // s**2 in (0, 100, 800, 1600, 3200) and step % s**2 == 0:
             fields = {}
@@ -223,7 +304,11 @@ class MeasurementRecorder:
                 fields[name + "_origin_reference"] = np.asarray(origin) / s
                 fields[name + "_h_reference"] = np.array(h / s)
             file = self.output / f"fields_s{s}_tref{step//s**2}.npz"
-            np.savez_compressed(file, **fields)
+            staged = file.with_name("." + file.name + ".pending.npz")
+            np.savez_compressed(staged, **fields)
+            install_evidence(
+                {file: staged}, EVIDENCE_LIMIT if c.get("dense_root", False) else None
+            )
             self.snapshots.append(
                 dict(
                     file=file.name,
@@ -236,19 +321,32 @@ class MeasurementRecorder:
     def flush(self):
         path = self.output / f"samples_s{self.c['scale']}.npz"
         arrays = {k: np.array([r[k] for r in self.records]) for k in self.records[0]}
+        if self.c.get("dense_root", False):
+            arrays["ray_sample_indices"] = np.array(
+                [r["sample_index"] for r in self.sparse_rays], dtype=int
+            )
+            for key in ("arc_ray_values", "arc_estimates", "arc_absolute_estimates"):
+                arrays[key] = np.array([r[key] for r in self.sparse_rays])
         for i, g in enumerate(self.rays):
             for k in ("normal", "ds", "positions"):
                 arrays[f"ray_{i}_{k}"] = g[k]
         arrays["ray_offsets_fine_cells"] = OFFSETS
         arrays["linear_coefficients"] = LINEAR
         arrays["quadratic_coefficients"] = QUADRATIC
-        np.savez_compressed(path, **arrays)
+        staged = path.with_name("." + path.name + ".pending.npz")
+        np.savez_compressed(staged, **arrays)
         metadata = dict(
-            schema=1,
+            schema=2 if self.c.get("dense_root", False) else 1,
             case=self.c,
+            dense_root=bool(self.c.get("dense_root", False)),
+            ray_sample_index_key=(
+                "ray_sample_indices" if self.c.get("dense_root", False) else None
+            ),
+            raw_absolute_throughput_definition="Cumulative sum of abs(blowing NET dm)+abs(suction NET dm) per root interval; unresolved within-aperture/substep reversals; not abs(window net).",
+            absolute_throughput_definition="Quadrature integral of abs(reconstructed u.n), abs(reconstructed rho*u.n); not abs(signed integral), not prescribed nominal, not exact wall truth.",
             reference_conversion=factors(self.c["scale"]),
             sample_file=path.name,
-            sample_sha256=hashlib.sha256(path.read_bytes()).hexdigest(),
+            sample_sha256=hashlib.sha256(staged.read_bytes()).hexdigest(),
             sample_count=len(self.records),
             snapshots=self.snapshots,
             level_stats_columns=[
@@ -280,6 +378,10 @@ class MeasurementRecorder:
             ],
             warning="Extrapolation and nearest-node values are estimator-dependent, not exact wall values. Fields/ray arrays use root-lattice units except explicitly named reference arrays.",
         )
-        (self.output / f"samples_s{self.c['scale']}.json").write_text(
-            json.dumps(metadata, indent=2) + "\n"
+        meta_path = self.output / f"samples_s{self.c['scale']}.json"
+        meta_staged = meta_path.with_name("." + meta_path.name + ".pending")
+        meta_staged.write_text(json.dumps(metadata, indent=2) + "\n")
+        install_evidence(
+            {path: staged, meta_path: meta_staged},
+            EVIDENCE_LIMIT if self.c.get("dense_root", False) else None,
         )

tests/validation/run_jet_circle_cv.py

@@ -18,11 +18,24 @@ CY = np.array([0, 0, 0, 1, -1, 1, -1, -1, 1])
 W = np.array([4 / 9] + [1 / 9] * 4 + [1 / 36] * 4)
 
 
-def case(scale=1, re=100, steps=800):
+def case(scale=1, re=100, steps=800, ddf_shifting=False):
     u = 0.03 / scale
     d = 24.084 * scale
     return dict(
         scale=scale,
+        ddf_shifting=bool(ddf_shifting),
+        storage_variant=dict(
+            name="shifted_fp32" if ddf_shifting else "unshifted_fp32",
+            device_populations="g=f-w" if ddf_shifting else "f",
+            device_dtype="float32",
+            equilibrium_path=(
+                "compute_feq_from_momentum" if ddf_shifting else "compute_feq"
+            ),
+            initial_physical_seed="historical FP32-rounded equilibrium, identical in both variants",
+            downloaded_populations="physical f, decoded by public stepper.download()",
+            downloaded_dtype="float64" if ddf_shifting else "float32",
+            raw_exchange="physical reaction and mass; no host weight correction",
+        ),
         re_d=re,
         beta=0.1,
         nx=192 * scale,
@@ -226,7 +239,7 @@ def run_case(c, ctx, output, provenance, continuation=False):
         collision="SRT",
         streaming="double_buffer",
         store_precision="FP32",
-        ddf_shifting=False,
+        ddf_shifting=c.get("ddf_shifting", False),
         les_enabled=False,
     )
     fine_cfg = LBMConfig(
@@ -237,7 +250,7 @@ def run_case(c, ctx, output, provenance, continuation=False):
         collision="SRT",
         streaming="double_buffer",
         store_precision="FP32",
-        ddf_shifting=False,
+        ddf_shifting=c.get("ddf_shifting", False),
         les_enabled=False,
     )
     obj = SimObject(
@@ -350,6 +363,10 @@ def run_case(c, ctx, output, provenance, continuation=False):
             for name in ("uniform_adapter", "amr_api")
         }
 
+        from jet_cv_measurements import absolute_aperture_interval_mass
+
+        cumulative_absolute_aperture_mass = np.zeros(2)
+
         def capture(step):
             ug = uniform.download()
             levels = amr.download()
@@ -381,6 +398,10 @@ def run_case(c, ctx, output, provenance, continuation=False):
                         for name in ("uniform_adapter", "amr_api")
                     ]
                 )
+                if c.get("dense_root", False):
+                    recorder.records[-1][
+                        "raw_absolute_aperture_mass_cumulative"
+                    ] = cumulative_absolute_aperture_mass.copy()
             return data, error, aperture
 
         previous, _, previous_aperture = capture(0)
@@ -427,7 +448,17 @@ def run_case(c, ctx, output, provenance, continuation=False):
             np.testing.assert_allclose(
                 ar.sum(axis=0)[:2], obs["total"]["impulse"], atol=1e-13, rtol=1e-13
             )
-            for name, rr in [("uniform_adapter", ur), ("amr_api", ar)]:
+            np.testing.assert_allclose(
+                ar[:, 3].sum(), obs["total"]["mass_into_fluid"], atol=1e-13, rtol=1e-13
+            )
+            for backend_index, (name, rr) in enumerate(
+                [("uniform_adapter", ur), ("amr_api", ar)]
+            ):
+                cumulative_absolute_aperture_mass[
+                    backend_index
+                ] += absolute_aperture_interval_mass(
+                    rr, masks["blowing"], masks["suction"]
+                )
                 for k, mask in masks.items():
                     subtotal = rr[mask].sum(axis=0)
                     accumulated[name][k] += subtotal
@@ -519,8 +550,12 @@ def run_case(c, ctx, output, provenance, continuation=False):
                     physics_validation_pass=False,
                     precision="FP32 evolution, FP64 host diagnostics",
                 )
-                (output / f"re{c['re_d']}_s{c['scale']}.json").write_text(
-                    json.dumps(payload, indent=2) + "\n"
+                from jet_cv_measurements import write_evidence_text
+
+                write_evidence_text(
+                    output / f"re{c['re_d']}_s{c['scale']}.json",
+                    json.dumps(payload, indent=2) + "\n",
+                    dense_root=c.get("dense_root", False),
                 )
                 print(
                     json.dumps(
@@ -552,16 +587,33 @@ def main():
         action="store_true",
         help="Fixed measurement campaign: Re100, scale1/2, 3200 reference steps",
     )
+    p.add_argument(
+        "--dense-root",
+        action="store_true",
+        help="Bounded ref0..800 scalar diagnostics at every root interval; sparse rays/fields",
+    )
+    p.add_argument(
+        "--shifted-fp32",
+        action="store_true",
+        help="Opt-in shifted numerical-representation control for --dense-root; historical unshifted default unchanged",
+    )
     p.add_argument("--plan", action="store_true")
     a = p.parse_args()
+    if a.shifted_fp32 and not a.dense_root:
+        p.error("--shifted-fp32 requires the bounded --dense-root campaign")
     if a.steps <= 0 or a.steps > 3200:
         p.error("steps must be 1..3200")
     if a.re == 400 and not a.allow_re400:
         p.error("Re400 requires explicit conditional-campaign opt-in")
+    if a.dense_root:
+        if a.continuation or a.scale not in (1, 2) or a.re != 100 or a.steps != 800:
+            p.error(
+                "--dense-root requires --re 100 --scale 1/2 --steps 800, without --continuation"
+            )
     if a.continuation:
         if a.scale not in (1, 2) or a.re != 100 or a.steps != 3200:
             p.error("--continuation requires --re 100 --scale 1/2 --steps 3200")
-    c = case(a.scale, a.re, a.steps)
+    c = case(a.scale, a.re, a.steps, ddf_shifting=a.shifted_fp32)
     if a.continuation:
         from jet_cv_measurements import sample_steps, factors
 
@@ -575,12 +627,28 @@ def main():
             post_ready_budget_seconds=1200 if a.scale == 1 else 5400,
             runtime_estimate_seconds=[210, 500] if a.scale == 1 else [900, 3200],
         )
+    if a.dense_root:
+        from jet_cv_measurements import sample_steps, old_sample_steps, factors
+
+        c.update(
+            dense_root=True,
+            measurement_schema=2,
+            reference_conversion=factors(a.scale),
+            post_ready_budget_seconds=1200 if a.scale == 1 else 5400,
+            runtime_estimate_seconds=[60, 240] if a.scale == 1 else [600, 2400],
+        )
+        c.update(
+            sample_count=len(sample_steps(c)),
+            sparse_ray_sample_count=len(old_sample_steps(c)),
+            scalar_sample_dt_reference=1 / a.scale**2,
+            raw_interval_dt_reference=1 / a.scale**2,
+        )
     plan = dict(
         case=c,
         required_revision=PIN,
         required_free_device_mib=1024,
         estimated_peak_device_mib=128 * a.scale**2,
-        estimated_output_mib=64 if a.continuation else 2,
+        estimated_output_mib=32 if a.dense_root else (64 if a.continuation else 2),
         max_steps=c["steps"],
         gpu_launch_owner="root; this runner does not select or reserve a GPU",
     )
@@ -612,7 +680,9 @@ def main():
             free, total = cuda.mem_get_info()
         if free < max(1024, 2 * plan["estimated_peak_device_mib"]) * 1024**2:
             raise RuntimeError("Insufficient free device memory")
-        run_case(c, ctx, a.output, provenance, continuation=a.continuation)
+        run_case(
+            c, ctx, a.output, provenance, continuation=a.continuation or a.dense_root
+        )
     print(
         json.dumps(
             dict(status="COMPLETE_DIAGNOSTIC_ONLY", physics_validation_pass=False)

tests/validation/uniform_srt_diagnostic/cpu_test_results.txt

@@ -1,12 +0,0 @@
-unittest.case.FunctionTestCase (test_bounded_state_evidence) ... ok
-unittest.case.FunctionTestCase (test_disjoint_complete_categories) ... ok
-unittest.case.FunctionTestCase (test_exact_config_and_source) ... ok
-unittest.case.FunctionTestCase (test_inactive_nonfinite_does_not_fail) ... ok
-unittest.case.FunctionTestCase (test_original_safety_limits) ... ok
-unittest.case.FunctionTestCase (test_population_macro_force_separate) ... ok
-unittest.case.FunctionTestCase (test_source_guard_and_deadline) ... ok
-
-----------------------------------------------------------------------
-Ran 7 tests in 0.039s
-
-OK

tests/validation/uniform_srt_diagnostic/diagnose_uniform_srt.py

@@ -1,219 +0,0 @@
-"""Read-only observations of the exact failed SRT control, at most 320 steps.
-
-Default is CPU preflight. Execution requires root admission and an external watchdog.
-No solver, initialization, geometry or numerical parameter modifications.
-"""
-import argparse
-import hashlib
-import importlib
-import json
-import math
-import os
-from pathlib import Path
-import sys
-import time
-from tempfile import TemporaryDirectory
-
-import numpy as np
-
-HERE=Path(__file__).resolve().parent
-DEFAULT_SOURCE=HERE.parents[2]
-LIMIT_BYTES=128*1024**2
-
-
-def dump(path,value):
-    path.write_text(json.dumps(value,indent=2,allow_nan=False))
-
-
-def number(value):
-    value=float(value)
-    return value if math.isfinite(value) else ('NaN' if math.isnan(value) else ('+Inf' if value>0 else '-Inf'))
-
-
-def source_config(source):
-    manifest=json.loads((HERE/'source_manifest.json').read_text())
-    for name,digest in manifest['sha256'].items():
-        if hashlib.sha256((source/name).read_bytes()).hexdigest()!=digest:
-            raise ValueError('Pinned source mismatch: '+name)
-    sys.path.insert(0,str(source/'src')); sys.path.insert(0,str(source/'tests/validation'))
-    import CelerisLab
-    if Path(CelerisLab.__file__).resolve()!=source/'src/CelerisLab/__init__.py':
-        raise ValueError('Wrong CelerisLab import')
-    runner=importlib.import_module('run_refined_dfg')
-    if Path(runner.__file__).resolve()!=source/'tests/validation/run_refined_dfg.py':
-        raise ValueError('Wrong runner import')
-    h,_=runner.helpers(source)
-    cfg,body,p=runner.config(h,80)  # Exact original config factory, not a reimplementation.
-    return cfg,body,p,manifest
-
-
-def categories(flags,p):
-    """Disjoint physical categories; subtype nibble is not a bitfield."""
-    from CelerisLab.lbm.descriptors import FLUID,SOLID,OBSTACLE
-    y,x=np.indices(flags.shape); fluid=(flags&FLUID)!=0
-    masks={}; left=fluid.copy()
-    for name,test in (
-        ('body_near',(x-p['center'][0])**2+(y-p['center'][1])**2 <= (p['radius']+3)**2),
-        ('outlet_near',x>=flags.shape[1]-4),('inlet_near',x<=3),
-        ('wall_near',(y<=3)|(y>=flags.shape[0]-4))):
-        masks[name]=left&test; left &= ~test
-    masks['bulk']=left
-    subtype=flags&0xf0
-    masks['inlet_ghost']=(~fluid)&(subtype==0x20)
-    masks['outlet_ghost']=(~fluid)&(subtype==0x30)
-    masks['wall_ghost']=(~fluid)&(subtype==0x10)
-    assigned=np.logical_or.reduce(list(masks.values()))
-    masks['body_solid']=(~assigned)&(((flags&OBSTACLE)!=0)|((flags&SOLID)!=0))
-    assigned|=masks['body_solid']; masks['other_inactive']=~assigned
-    return fluid,masks
-
-
-def finite_extrema(a,mask):
-    good=mask&np.isfinite(a)
-    if not good.any(): return dict(min=None,max=None)
-    idx=np.flatnonzero(good); values=a.ravel()[idx]
-    lo=int(idx[np.argmin(values)]); hi=int(idx[np.argmax(values)])
-    return dict(min=float(a.ravel()[lo]),max=float(a.ravel()[hi]),
-                min_yx=list(map(int,np.unravel_index(lo,a.shape))),
-                max_yx=list(map(int,np.unravel_index(hi,a.shape))))
-
-
-def diagnose(g,macro,force,flags,p,step):
-    fluid,masks=categories(flags,p)
-    badpop=~np.isfinite(g); badnode=badpop.any(axis=0)
-    badmacro=np.logical_or.reduce([~np.isfinite(macro[k]) for k in ('rho','ux','uy')])
-    with np.errstate(over='ignore',invalid='ignore'):
-        mach=np.sqrt(3*(np.asarray(macro['ux'],np.float64)**2+np.asarray(macro['uy'],np.float64)**2))
-    rho=macro['rho']
-    # Exactly the original physical macro/reaction conditions, now sampled each step.
-    nonfinite_macro=bool(np.any(badmacro&fluid))
-    force_bad=force is not None and not np.isfinite(force).all()
-    density_bad=bool(np.any(fluid&((rho<.5)|(rho>1.5))))
-    mach_bad=bool(np.any(fluid&(mach>.2)))
-    population_bad=bool(np.any(badnode&fluid))
-    original_failure=nonfinite_macro or force_bad or density_bad or mach_bad
-    offending=fluid&(badnode|badmacro|(rho<.5)|(rho>1.5)|(mach>.2))
-    examples=[]
-    for y,x in np.argwhere(offending)[:16]:
-        examples.append(dict(y=int(y),x=int(x),physical_xy_m=[float(x*p['dx']),float((y-.5)*p['dx'])],
-            category=next(name for name,mask in masks.items() if mask[y,x]),flag=int(flags[y,x]),
-            nonfinite_q=np.flatnonzero(badpop[:,y,x]).tolist(),
-            populations=[number(v) for v in g[:,y,x]],
-            rho=number(rho[y,x]),ux=number(macro['ux'][y,x]),uy=number(macro['uy'][y,x])))
-    neighborhoods=[]
-    for node in examples[:4]:
-        y,x=node['y'],node['x']; y0,y1=max(0,y-2),min(flags.shape[0],y+3); x0,x1=max(0,x-2),min(flags.shape[1],x+3)
-        neighborhoods.append(dict(bounds_xy=[x0,y0,x1,y1],flags=flags[y0:y1,x0:x1].tolist(),
-            physical_populations=[[[number(v) for v in row] for row in plane] for plane in g[:,y0:y1,x0:x1]]))
-    return dict(step=step,tstar=step*p['mean_speed']/p['diameter'],
-        physical_failure=bool(original_failure or population_bad),
-        original_health_failure=bool(original_failure),
-        physical_population_nonfinite=population_bad,physical_macro_nonfinite=nonfinite_macro,
-        force_nonfinite=bool(force_bad),density_limit=density_bad,mach_limit=mach_bad,
-        force=None if force is None else [number(v) for v in force],
-        categories={name:dict(nodes=int(mask.sum()),nonfinite_population_nodes=int((mask&badnode).sum()),
-            nonfinite_populations=int(badpop[:,mask].sum()),nonfinite_macro_nodes=int((mask&badmacro).sum()))
-            for name,mask in masks.items()},
-        rho=finite_extrema(rho,fluid),mach=finite_extrema(mach,fluid),
-        first_physical_examples=examples,local_neighborhoods=neighborhoods)
-
-
-def snapshot(sim,p):
-    # Public physical decode and original production macro path. No host reconstruction
-    # substitutes for the original health check. get_ddf shares its completed-step cache.
-    with np.errstate(all='ignore'):
-        macro={k:np.asarray(v).copy() for k,v in sim.get_macroscopic().items()}
-        g=sim.get_ddf().reshape(9,p['ny'],p['nx'])
-    import pycuda.driver as cuda
-    raw=np.empty_like(g,dtype=np.float32)
-    with sim.ctx.activate():
-        cuda.memcpy_dtoh(raw,sim.field.ddf_gpu)
-    return dict(raw=raw,g=g,macro=macro,step=int(sim.stepper.step_count))
-
-
-def save_states(dest,previous,current,flags,diagnostic):
-    """Two states only; raw shifted bits and decoded observations, no trajectory."""
-    arrays={'flags':flags}
-    for name,state in (('previous',previous),('current',current)):
-        if state is None: continue
-        arrays[name+'_raw_shifted']=state['raw']
-        arrays[name+'_physical']=state['g']
-        arrays[name+'_step']=np.array(state['step'],np.int64)
-    # At D80, raw+physical for two states ~84 MiB; reserve >4 MiB for JSON/NPZ overhead.
-    if sum(v.nbytes for v in arrays.values())>LIMIT_BYTES-4*1024**2:
-        raise ValueError('Evidence arrays exceed bounded artifact budget')
-    np.savez(dest/'states.npz',**arrays)
-    dump(dest/'diagnostics.json',diagnostic)
-    size=sum(p.stat().st_size for p in dest.iterdir() if p.is_file())
-    if size>LIMIT_BYTES: raise RuntimeError('Evidence directory exceeds 128 MiB')
-    return size
-
-
-def deadline_check(deadline):
-    if time.monotonic()>=deadline: raise TimeoutError('Diagnostic wall ceiling reached')
-
-
-def execute(a,cfg,body,p):
-    from CelerisLab.simulation import Simulation
-    started=time.monotonic(); deadline=started+a.wall_seconds
-    previous=None; prior_report=None; initial_report=None
-    with TemporaryDirectory() as temp:
-        temp=Path(temp); dump(temp/'lbm.json',cfg); dump(temp/'body.json',body)
-        with Simulation(str(temp/'lbm.json'),str(temp/'body.json'),device_id=0) as sim:
-            sim.initialize()  # Exact original production initialization, unchanged.
-            flags=sim.get_flags().reshape(p['ny'],p['nx'])
-            current=snapshot(sim,p)
-            initial_report=diagnose(current['g'],current['macro'],None,flags,p,0)
-            report=initial_report; status='initial_physical_failure' if report['physical_failure'] else 'step_cap_reached'
-            try:
-                deadline_check(deadline)
-                if not report['physical_failure']:
-                    for _ in range(320):
-                        deadline_check(deadline)
-                        previous=current; prior_report=report
-                        sim.run(1)  # Same solver; observation buffers reset/read once per step.
-                        force=sim.read_force(0).astype(np.float64)
-                        current=snapshot(sim,p)
-                        report=diagnose(current['g'],current['macro'],force,flags,p,current['step'])
-                        if current['step']==1:
-                            print('READY '+json.dumps(dict(step=1,all_observation_paths_exercised=True,
-                                physical_healthy=not report['physical_failure']),allow_nan=False),flush=True)
-                        if report['physical_failure']:
-                            status='first_physical_failure'; break
-                        deadline_check(deadline)
-            except TimeoutError:
-                status='wall_time_limit'
-            details=dict(status=status,executed_steps=int(sim.stepper.step_count),
-                observation_step=current['step'],previous_observation_step=None if previous is None else previous['step'],
-                initial=initial_report,preceding=prior_report,current=report,
-                wall_seconds=time.monotonic()-started,
-                storage='raw_shifted FP32 is exact active-buffer data; physical is production FP32 decoded G. Both are diagnostic snapshots, not complete restart checkpoints.',
-                health_scope='Physical FLUID nodes and force only; ghost/body categories cannot independently trigger physical failure.',
-                interpretation='Near-region labels locate symptoms, not the root cause. Per-step inspection changes observation cadence only. No physical acceptance.')
-            size=save_states(a.output,previous,current,flags,details)
-            print(json.dumps(dict(status=status,executed_steps=int(sim.stepper.step_count),evidence_bytes=size),allow_nan=False),flush=True)
-            return 0 if status=='step_cap_reached' else 2
-
-
-def main():
-    parser=argparse.ArgumentParser(description=__doc__)
-    parser.add_argument('--source',type=Path,default=DEFAULT_SOURCE)
-    parser.add_argument('--output',type=Path,required=True)
-    parser.add_argument('--execute',action='store_true')
-    parser.add_argument('--gpu-admitted',action='store_true')
-    parser.add_argument('--wall-seconds',type=float)
-    a=parser.parse_args(); a.source=a.source.resolve()
-    cfg,body,p,manifest=source_config(a.source)
-    if a.output.exists() and any(a.output.iterdir()): raise ValueError('Use a new/empty output directory')
-    if a.execute and (not a.gpu_admitted or not os.environ.get('CUDA_VISIBLE_DEVICES') or
-            a.wall_seconds is None or not math.isfinite(a.wall_seconds) or a.wall_seconds<=0):
-        raise ValueError('Explicit root admission, device selection and finite wall ceiling required')
-    a.output.mkdir(parents=True,exist_ok=True)
-    dump(a.output/'preflight.json',dict(source=manifest,config=cfg,body=body,parameters=p,
-        diagnostic_sha256=hashlib.sha256(Path(__file__).read_bytes()).hexdigest(),max_steps=320,
-        max_evidence_bytes=LIMIT_BYTES,executed=False))
-    if not a.execute: return 0
-    return execute(a,cfg,body,p)
-
-
-if __name__=='__main__': raise SystemExit(main())

tests/validation/uniform_srt_diagnostic/source_manifest.json

@@ -1,112 +0,0 @@
-{
-  "commit": "9805383f9c50d867e8555471baf5dbda8333a652",
-  "failure_source_receipt_sha256": "a77f71550c52d4b8b6e946a3cb98fc5de5db3da1bcbbb3457c6d60167677ce4e",
-  "sha256": {
-    "src/CelerisLab/__init__.py": "21cc469bd6e970a1f9ff5970c8eea4602065e41fc881854759ee565ee55c10c6",
-    "src/CelerisLab/body/__init__.py": "e4e0e8f0769a94428d5b02fac790443997556cfc5515a5f1ed1595d2c694d69d",
-    "src/CelerisLab/body/action_smoother.py": "b1a23ee6bbd4850b172cb8738c5c3546ee465a54189e6af9d8044f023d4687dc",
-    "src/CelerisLab/body/coupling/__init__.py": "c931f7eb318d48408c3e2febcc6917c88c8dcc1697cbf4329b1f340d94c35763",
-    "src/CelerisLab/body/coupling/soa_packer.py": "8ec26fd55ef74801bbd5ab6bd3d0a7dabc750cbd498aaac2ca4c61a0108ad3c9",
-    "src/CelerisLab/body/ddf_patch.py": "60fcfb7441e73bf290bcff41ca3a83da3e7ddad765d7247464e8f02e3043b4e2",
-    "src/CelerisLab/body/geometry/__init__.py": "ada88980ab672959aca9aa3a4c4aade3219524b2ab68110cd2a2f41e3e0ca90a",
-    "src/CelerisLab/body/geometry/base.py": "cceca14361ca2f34d34a3e43730e1a79b8ca81be00f0dd62e884db32b479419f",
-    "src/CelerisLab/body/geometry/circle.py": "7605ca7c21103f1d801ac73ab8dd18dffbdac425b2dee7b8858b283628a9e436",
-    "src/CelerisLab/body/jets.py": "4104c24af4651f4bb4f8d8fd36fb6d88f41c6e4469822f36e22e74c9ede31dac",
-    "src/CelerisLab/body/manager.py": "01b653d25bd9b4333379c8bfd12383596b686d2029f2e91b1c91b618540ec6b3",
-    "src/CelerisLab/body/objects.py": "8e63cee8faa9cc6243bcff428be628dfad73a02a9a3b8ece7d78c0a63406a08d",
-    "src/CelerisLab/body/preprocess/__init__.py": "dfd9d58bc07f626ab23a70053e31b88a6d9165d2e4c76a4e9f48abe674d3d2ec",
-    "src/CelerisLab/body/preprocess/flag_overlay.py": "831fc9e9736b758847759a085ff133eb49ec91318ace4fda76f85960138ee300",
-    "src/CelerisLab/body/registry.py": "fbb7327780adbdc6da15ebdb799980daf32df22ee974af0893d7409f177bbb68",
-    "src/CelerisLab/body/sync_plan.py": "3a15bfe9ebeb91482dbfc68850761ef39c872cc12d2efc795babd0c01e392323",
-    "src/CelerisLab/common/__init__.py": "d4dbde78bc97fccc9eabac9abae8f0f15c112c10ff8e9b45bd9401d4723df1ef",
-    "src/CelerisLab/common/_types.py": "aad2ff1a9033d4fd68783ad7123afb47201ddc58785cb6dc0246947037072a5f",
-    "src/CelerisLab/common/checkpoint.py": "b2f960aecd5ac27a3a7130b809ffad4709c44d522edef0359ab952654625410b",
-    "src/CelerisLab/common/pathline.py": "a1b6efcc0a076d0f1dc8d49a595779426d7d5626b00072a59bac710ff02ad046",
-    "src/CelerisLab/common/preprocess.py": "7fc78a08857cf8e98519500b094a1d896af189b6b15658ff9b388ed51bed4515",
-    "src/CelerisLab/common/render.py": "0e055476257eb2bcd11e733766e52195de02f8fad228f570a3511a7c831bdc29",
-    "src/CelerisLab/common/streakline/__init__.py": "13ff1cfa416fdd721a08a659e76b5a5a99b8d3201add10a83b7b0bc654bc1eec",
-    "src/CelerisLab/common/streakline/_config.py": "a9185ef68e9c7b5d5a1dc0b04a28341e2ad91d13c145a7c106636a878cf0a605",
-    "src/CelerisLab/common/streakline/_integrate.py": "3fbd4368b2c8d0e7fda40dc65aac5df02b085008b4c68acd83cb7ae45d33a13b",
-    "src/CelerisLab/common/streakline/_render.py": "236cd637414ee318c4d66f9aed32110d8dc42a100d65fde06172f7cd0ba62c65",
-    "src/CelerisLab/common/streakline/_streakline.py": "1a3e08daa706b5f83cdeb337e9a945a36ddf7583c40af1d0bb9d825ac954df37",
-    "src/CelerisLab/config.py": "2f1bba7515f5bc08cb3a8d140bcafe7fa0689e01b3b06494697bb2956a71530e",
-    "src/CelerisLab/configs/CONFIG.md": "41cafdbe525366c08aa9d0416ea026ccf0026ba7123b8a9b65f968a80d928e3a",
-    "src/CelerisLab/configs/config_body.json": "055f261f0828ca1d4f2bb694bd15b72bbcabe31d552326208f28e37f761adab1",
-    "src/CelerisLab/configs/config_lbm.json": "17e4311f1f250c6ece59177a8b6ff856b69a016c7c10267e774b030a0a390865",
-    "src/CelerisLab/configs/config_lbm_flume_mrt_zouhe.json": "8f593321db05a563a42931603a228d61cbcba06dfbe113262d5cd0ad93c0fe79",
-    "src/CelerisLab/configs/config_lbm_flume_trt_regularized.json": "f4bba8e6a4339fc3c4eb14f6e2f57c4b22993c73703c773d853edfbe34736e56",
-    "src/CelerisLab/configs/config_lbm_three_cylinder_triangle.json": "eeb8e7149dbe4aa6b3a9562802735aa950750dfbe2d972a0727e788573afa817",
-    "src/CelerisLab/cuda/__init__.py": "0d01dff9f0399c8baba822aab5ca0122a135f011008ed8a499ebd9f7e5b06aea",
-    "src/CelerisLab/cuda/compiler_v2.py": "c4cc3ec4445c8d75e6a253dd87963877117a722bc73b9d4811806fc6045d08c1",
-    "src/CelerisLab/cuda/context.py": "013dd4ec6d01d2fbd11afdfb103eac6a273bd9f798d663d761b851eeb27885e9",
-    "src/CelerisLab/cuda/obs_layout.py": "5ffb2c3aeeaaaaeb64f2cd8febfbcf4ad9919e5414020ad753cfade0683b21c2",
-    "src/CelerisLab/lbm/__init__.py": "7f60fb3aaae81501b510d08c2fedff44fcb05657260eb10b6f5cc91e7204306b",
-    "src/CelerisLab/lbm/block_stepper.py": "00b313daddc6e63d8ab8423c9190ca7e92ad291de20a2f6b80eb53e3f2d85ec7",
-    "src/CelerisLab/lbm/blocks.py": "1e644c5719993f418185ad4a10b6950a30636fc912befd9eab41ff48b4cf85cd",
-    "src/CelerisLab/lbm/channel.py": "2d5b5ff43414cb35633ac4ce90ce2c3a3353950b25c168e1c2ab58d498dd8b0f",
-    "src/CelerisLab/lbm/curved_links.py": "b6957fa13d13f864dba4f7364e93a39905d062dbb3ee9b3f5191add81fff0732",
-    "src/CelerisLab/lbm/descriptors.py": "c9f025dfc14da43b989047b84cc22bd05d5cc92c9ec695c1da68fdfb788e3f2b",
-    "src/CelerisLab/lbm/equilibrium.py": "2fb2f2bb7ff326d23abce80fc2a4c0907b17740ea3e29fe6ae079c5044783826",
-    "src/CelerisLab/lbm/field.py": "0e727eacc3706add4d8d15c418e9b631050871f831698d3ac689dd5f2c701b9b",
-    "src/CelerisLab/lbm/hierarchy.py": "f234975074f6b6d289d573ff6ea6832feae0e27cb04f80b37fe81792b13a12e7",
-    "src/CelerisLab/lbm/initializers.py": "dacf9586963e862d6d0a98ef1a066036be6f91e9d423720661d8ef2c1fb2df6a",
-    "src/CelerisLab/lbm/kernels/blocks.cu": "e3b9606f861bfea8c4b0f34e8356bb230081f899c584f67be89178d889099b17",
-    "src/CelerisLab/lbm/kernels/boundary/bounce_back.cuh": "aba3748c564ed91b161d268ef8b737b7c7be96a823063d201f3da684dd845233",
-    "src/CelerisLab/lbm/kernels/boundary/curved_boundary.cuh": "aeb16bfd483514fb03e15a2fed437d673c3b8b2fe68ab83edf4244ef593878ea",
-    "src/CelerisLab/lbm/kernels/boundary/esopull_curved_helpers.cuh": "b9b474bc4edaff05681c5443235472d04072d0d775fc0eb9c5967faef52b0258",
-    "src/CelerisLab/lbm/kernels/boundary/ibm_kernels.cuh": "e6909b547dc8d64cdd8a76a90660243a8f5fee535caa161b52b4dd8b7c29934b",
-    "src/CelerisLab/lbm/kernels/boundary/inlet/channel_stabilized.cuh": "efe077afcbb6b731256a987c2fd79a1dbc470c902f87070d60421ea6cb13d4e2",
-    "src/CelerisLab/lbm/kernels/boundary/inlet/common.cuh": "59b38a89439878e00de7de16b9c7b03feff443fcc5a421593f7d2536dcbb7ab8",
-    "src/CelerisLab/lbm/kernels/boundary/inlet/equilibrium.cuh": "f0964c811b2c41a5aaa1c6d99c490b06e850c634eb8749f1f05ef61f93c2de1d",
-    "src/CelerisLab/lbm/kernels/boundary/inlet/regularized.cuh": "943d4a571818bacb89c70bccfaac202691121e3e385803ce6309123a0a03ddaf",
-    "src/CelerisLab/lbm/kernels/boundary/inlet/zou_he_local.cuh": "e73e66b853b1e4e0e30d8f4185d832aa414ce670a1813ce2b5459f2887f71f89",
-    "src/CelerisLab/lbm/kernels/boundary/inlet_outlet.cuh": "de8b213a6da42c2e5e9f8966199fc66ea4541b85144a90f3f5dbad3c6ab63b97",
-    "src/CelerisLab/lbm/kernels/boundary/outlet/pressure_neq.cuh": "c8b2adc66d12fe602076ddc9693c5c208711fcaddb58aa9a31401a269f51c4c4",
-    "src/CelerisLab/lbm/kernels/boundary/planar_velocity.cuh": "501b2759d0e2e4280cb6fdd127d66a50fa89f6de48fc2cae9a7eafb11ae90bed",
-    "src/CelerisLab/lbm/kernels/config.h": "7d1124125e0b354558297934460e64c760fb68cdd7bf6d01a1238bb2eaab8c37",
-    "src/CelerisLab/lbm/kernels/config/config_grid.h": "1db3e030ebdc116cd7f02362d1fd077daac55e8f0b4329f6285948c224d3ca5d",
-    "src/CelerisLab/lbm/kernels/config/config_method.h": "4374e04a130f90f97d17cc20c40d2f9ea0ed0dd8603817d07f215d02266e247c",
-    "src/CelerisLab/lbm/kernels/config/config_objects.h": "db793af052c756561a190a3ff2cb93ee5fe28462ee4f97c6af80882b4dc8b072",
-    "src/CelerisLab/lbm/kernels/config/config_obs.h": "c11e2249359145b5c4cbaaf0487506fa77c1f4b82c7c169ddc574aa0babcd727",
-    "src/CelerisLab/lbm/kernels/config/config_physics.h": "8ac0990b168e1058588676cc05c80df8634cfd671dbc92a89246c3c372d83a4e",
-    "src/CelerisLab/lbm/kernels/core/descriptors.cuh": "8440bc14857da9007982650f828a23608eec9f7cc4bf772e8c8dc1239cb45356",
-    "src/CelerisLab/lbm/kernels/core/flags.cuh": "0025705f24710330d9d9195f713879bfb650a85a3449baef0e196b831af104ab",
-    "src/CelerisLab/lbm/kernels/core/layout.cuh": "1fbd820021c89ac3efcde24145996cb0147769e607e498e61f308ed3e0b13706",
-    "src/CelerisLab/lbm/kernels/core/obs.cuh": "b742b77c9f61e1f020fe9922c3838ae9d855e17b381154958b58f10a22938922",
-    "src/CelerisLab/lbm/kernels/core/params.cuh": "6e18bf730d936d940e3d85452f0714a2eaae31bf41002f9fd520ec5b372878dd",
-    "src/CelerisLab/lbm/kernels/core/precision.cuh": "849df14b4cce50af52399e4b8f3e997196f3ae5f1163f68e28df3e6b2507a8c4",
-    "src/CelerisLab/lbm/kernels/kernel_v2.cu": "c7bd3fb705b77261ba2441c52a24a7e6a7865c165cba088a1b75201c4d29c408",
-    "src/CelerisLab/lbm/kernels/operators/collision_mrt.cuh": "aee444eb60c47a3fd518dca975d1af05425a0818a0ec6c3fb3f6150f60c2cb44",
-    "src/CelerisLab/lbm/kernels/operators/collision_srt.cuh": "6b7ff842f392c8f853d2d1a97cc69bfe50f21283f73e659404da07cf6c95f5e1",
-    "src/CelerisLab/lbm/kernels/operators/collision_trt.cuh": "9725b9840b9ad8b4ec7be61ff5d06d3151e86d1a87585c13f2fbf934d0d2c5f6",
-    "src/CelerisLab/lbm/kernels/operators/forcing_guo.cuh": "969a430c1af03f32e3bd0df95d805e64f56334717c44dd4ba208ba503062a24b",
-    "src/CelerisLab/lbm/kernels/operators/helpers.cuh": "0b3a4d95d7d19f5fec09e5423b8f4cc99f8a226b541967425967330da5a051ec",
-    "src/CelerisLab/lbm/kernels/operators/macro.cuh": "2be20eb2b7d7f5522daaad7f4b57b1ff8cdf883efe4a67846a96783b2fe846a3",
-    "src/CelerisLab/lbm/kernels/operators/turbulence_smag.cuh": "ff7f000297ee0817e255ad9fcb6a13b647e3ddd5b206518d35f38d2895a9f501",
-    "src/CelerisLab/lbm/kernels/refinement.cu": "129f3d91da93b4324f88a0da73a4da1e5390f72c14cce574ee63306712da9895",
-    "src/CelerisLab/lbm/kernels/step/aux_kernels.cu": "578a5b20a157241ee678547059abb1372dd5a589ad06bb2c15b987eb01ca1013",
-    "src/CelerisLab/lbm/kernels/step/block_channel.cu": "befbf6d757e532a59c166d41f920d16d71557cd3a574478e7aa83da737c48cbd",
-    "src/CelerisLab/lbm/kernels/step/curved_double.cu": "bfa7a1df1e939020314d49755045f7a85fe4a19cc1c68dbe62653c66c5e7c2b3",
-    "src/CelerisLab/lbm/kernels/step/esopull_macro.cu": "c73116020ca217ede1e4de27c8269c31f9d91e33433ac8252a21e9b14187c50f",
-    "src/CelerisLab/lbm/kernels/step/esopull_sync.cu": "c0ff3e72900c3ab89a05dd03684e96d3b740cf1672d565727fc2af165933d087",
-    "src/CelerisLab/lbm/kernels/step/init_flow.cu": "305be3bb12fc0d039acec1701baabcf0e8a35e683c49c34f2af8ca9867d2b29c",
-    "src/CelerisLab/lbm/kernels/step/one_step_double.cu": "f9f8242b38e8e0cf8425b75e2b0215bc15363c62eaa0fb43c761b8e0931bfdc9",
-    "src/CelerisLab/lbm/kernels/step/one_step_esopull.cu": "aa223b2744ae6c9125673df311a96ce588032c1ba58bebb11fd33ecb990f8ed4",
-    "src/CelerisLab/lbm/kernels/streaming/esopull_semantic_helpers.cuh": "dd5a9091628b079efd97e53fd49e52d09dcee88529235db77a5648e02937af6e",
-    "src/CelerisLab/lbm/kernels/streaming/esopull_single_buffer.cuh": "77ed4ab9a0ebc5ff62a91a7c39066ef395391ae36e9040a69fb2bd8b1626dc79",
-    "src/CelerisLab/lbm/kernels/streaming/pull_double_buffer.cuh": "b65d741ed78b7b62f99531ba0c0ce1936663d8dc9640e7d7d16c707f1baf6549",
-    "src/CelerisLab/lbm/population_storage.py": "a6a86c29c52c892edfe4802fb773c387212e3f4cc86708d80e154986ddf88044",
-    "src/CelerisLab/lbm/raw_exchange.py": "8694202466eba848563e298656353b0f5db94e21a01fa05f51aad6dc2b9fd311",
-    "src/CelerisLab/lbm/refinement.py": "08c2a0557276a98cbcaa459d9bb7a9735d8bbbf64a6114c57af2fda61481a687",
-    "src/CelerisLab/lbm/refinement_stepper.py": "f2bb34fa90805ad21c3e7cf9f9a67d88d3ae3e249b4517d3898567b4bf9e364d",
-    "src/CelerisLab/lbm/refinement_tables.py": "fdd344024b89df3a83174dc810ca5e32db5e19eb8b1609f8f73b0821f56546b6",
-    "src/CelerisLab/lbm/stepper.py": "0dcb7cd7ae87e33e3dc67a38b6aa43042fbe673e37d9ad165342ee1d695933ce",
-    "src/CelerisLab/lbm/synchronized_remap.py": "7400fc4beaffd4649d6a9c524d38ce5fd6fa7eeb32eb5332e4030a4b6648f197",
-    "src/CelerisLab/simulation.py": "0a03904dc6de88667d7af699005a289adf8b09f0976cb0d099b041f4830a8f4c",
-    "tests/validation/data/refined_dfg/source_manifest.json": "e495948b10f8112c77ca67255122b5e8bc9e32570e8c899802afcb85e608fef4",
-    "tests/validation/periodic.py": "a2212c0e2705126327a5019e9cafe64eeca398da1b75061ff23630c9843697a6",
-    "tests/validation/re100_helpers.py": "289c6e01075ff361573f862b90cfd61e5980c9a8efcbc78aef69979b4004fd60",
-    "tests/validation/run_refined_dfg.py": "256aacd84b3f8412a31ffaba9c4b5635db895c3177686dd34ef8e31f08119414",
-    "tests/validation/source_provenance.py": "6dfe8f2d819dba0e240ba761d31162a5033685d492d09db75eb2b8aaab3a5a4c"
-  }
-}

tests/validation/uniform_srt_diagnostic/test_diagnostic.py

@@ -1,100 +0,0 @@
-"""CPU-only synthetic diagnostic and source-contract tests; no simulation results."""
-import json
-from pathlib import Path
-import sys
-from tempfile import TemporaryDirectory
-import unittest
-import numpy as np
-sys.path.insert(0,str(Path(__file__).resolve().parent))
-import diagnose_uniform_srt as d
-cfg,body,p,manifest=d.source_config(d.DEFAULT_SOURCE)
-
-
-def fixture():
-    flags=np.ones((12,20),np.uint16)
-    flags[:,0]=2|0x20; flags[:,-1]=2|0x30
-    flags[[0,-1]]=2|0x10; flags[5,6]=2|0x40|0x200
-    g=np.full((9,12,20),1/9,np.float32)
-    macro=dict(rho=np.ones((12,20)),ux=np.zeros((12,20)),uy=np.zeros((12,20)))
-    params=dict(center=[6,5],radius=1,dx=.1,mean_speed=.01,diameter=80)
-    return g,macro,flags,params
-
-
-def test_exact_config_and_source():
-    assert manifest['commit']=='9805383f9c50d867e8555471baf5dbda8333a652'
-    assert p['diameter']==80 and p['mean_speed']==.01 and p['nx']==1761 and p['ny']==330
-    assert cfg['method']['collision']=='SRT' and cfg['method']['ddf_shifting']
-    assert cfg['method']['outlet']['srt_neq_damp']==.5
-    assert np.isclose(3*p['viscosity']+.5,.524)
-    assert body['objects'][0]['center']==[160,160.5]
-
-
-def test_inactive_nonfinite_does_not_fail():
-    g,m,f,p=fixture(); fluid,_=d.categories(f,p)
-    g[:,~fluid]=np.nan
-    for a in m.values(): a[~fluid]=np.nan
-    r=d.diagnose(g,m,np.zeros(2),f,p,1)
-    assert not r['physical_failure']
-    assert r['categories']['body_solid']['nonfinite_population_nodes']==1
-    assert r['categories']['outlet_ghost']['nodes']==10
-    assert r['categories']['inlet_ghost']['nodes']==10
-    json.dumps(r,allow_nan=False)
-
-
-def test_population_macro_force_separate():
-    g,m,f,p=fixture(); g[4,6,17]=np.inf
-    r=d.diagnose(g,m,np.zeros(2),f,p,27)
-    assert r['physical_failure'] and r['physical_population_nonfinite']
-    assert not r['original_health_failure'] and not r['force_nonfinite']
-    assert r['first_physical_examples'][0]['category']=='outlet_near'
-    assert r['first_physical_examples'][0]['nonfinite_q']==[4]
-    assert r['first_physical_examples'][0]['populations'][4]=='+Inf'
-    json.dumps(r,allow_nan=False)
-    g,m,f,p=fixture(); m['ux'][6,10]=np.nan
-    r=d.diagnose(g,m,np.zeros(2),f,p,28)
-    assert r['physical_macro_nonfinite'] and not r['physical_population_nonfinite']
-    assert not r['force_nonfinite'] and r['original_health_failure']
-    g,m,f,p=fixture(); r=d.diagnose(g,m,np.array([np.nan,0]),f,p,29)
-    assert r['force_nonfinite'] and not r['physical_macro_nonfinite']
-    assert not r['first_physical_examples']
-
-
-def test_original_safety_limits():
-    g,m,f,p=fixture(); m['rho'][5,7]=.49
-    r=d.diagnose(g,m,[0,0],f,p,1)
-    assert r['density_limit'] and r['first_physical_examples'][0]['category']=='body_near'
-    g,m,f,p=fixture(); m['ux'][6,10]=.2
-    assert d.diagnose(g,m,[0,0],f,p,1)['mach_limit']
-
-
-def test_disjoint_complete_categories():
-    _,_,f,p=fixture(); fluid,masks=d.categories(f,p)
-    np.testing.assert_array_equal(sum(mask.astype(int) for mask in masks.values()),np.ones(f.shape))
-    physical=sum(masks[k].astype(int) for k in ('body_near','inlet_near','outlet_near','wall_near','bulk'))
-    np.testing.assert_array_equal(physical,fluid.astype(int))
-
-
-def test_bounded_state_evidence():
-    g,m,f,p=fixture(); state=dict(raw=g.copy(),g=g,macro=m,step=1)
-    with TemporaryDirectory() as tmp:
-        dest=Path(tmp); size=d.save_states(dest,state,state,f,{'status':'synthetic_test'})
-        assert size<d.LIMIT_BYTES
-        with np.load(dest/'states.npz') as saved:
-            np.testing.assert_array_equal(saved['previous_raw_shifted'],g)
-            np.testing.assert_array_equal(saved['current_physical'],g)
-        assert sorted(x.name for x in dest.iterdir())==['diagnostics.json','states.npz']
-    actual_bytes=4*(9*330*1761*4)+(330*1761*2)+16
-    assert actual_bytes<d.LIMIT_BYTES-4*1024**2
-
-
-def test_source_guard_and_deadline():
-    with TemporaryDirectory() as tmp:
-        with unittest.TestCase().assertRaises((ValueError,FileNotFoundError)):
-            d.source_config(Path(tmp))
-    with unittest.TestCase().assertRaises(TimeoutError): d.deadline_check(0)
-
-
-if __name__=='__main__':
-    result=unittest.TextTestRunner(verbosity=2).run(unittest.TestSuite(
-        unittest.FunctionTestCase(fn) for name,fn in sorted(globals().items()) if name.startswith('test_')))
-    raise SystemExit(not result.wasSuccessful())

validation-evidence/2026-10-18/README.txt

@@ -1,12 +0,0 @@
-CelerisLab reviewed scalar evidence,2026-10-18.
-
-The two archives are intact originals. SHA256 and exact sizes are in transport_manifest.json.
-Equilibrium comparator92da2e8:exit0,2400000steps healthy;ascending-zero v2 qualification passes. Frozen result.json remains periodic=false/accuracy_qualified=false;qualification_v2.json is separate and binds both original receipts.
-Shifted/unshifted tiny e8b8c58:exit0,23methods pass,one N64 interval each mode only;no shifted full-N64 trajectory.
-No production/default/dev/main change.
-
-Both archives retain all their original member bytes,including gzip protection inventories. Metadata were scanned for credentials/private keys/access tokens and unrelated private paths. Only the authorized CelerisLab project/interpreter/system metadata and a reviewed literal official-reference fixture path were found. No credentials or unrelated private paths.
-
-Original larger archives,all scientific receipts and any successful Drive transfers are retained. This single existing-validation-branch commit is evidence transport only.
-
-CPU covered-predictor pair5468695:44tests pass;one FP64 raw/stress pair exit0;raw4samples exact to07879bc;both unchanged campaign/comparative/conservation screens pass,historical uniform pressure budget fails separately for both.No GPU pin or production/default/main/dev merge.

validation-evidence/2026-10-18/dev-projected-integration-eec4677/INTEGRATION_CLEANUP_RECEIPT.json

@@ -1,505 +0,0 @@
-{
-  "utc": "2026-10-18T23:44:13.848348+00:00",
-  "status": "REMOTE_DEV_INTEGRATED_AND_BOUNDED_CLEANUP_COMPLETE",
-  "integration": {
-    "utc": "2026-10-18T23:41:22.351573+00:00",
-    "status": "remote_dev_fast_forward_confirmed",
-    "candidate": "eec4677db1308e2a9ce4e5f195c994356c11de13",
-    "production": "a135252ae78b47b57d7e77d19001700b3bedac8b",
-    "local_dev_preserved": "f75d543586315b6272cfdf23046aa7d4550f5fbe",
-    "local_dev_not_ancestor_of_remote_baseline": true,
-    "remote_before": {
-      "refs/heads/claude/dense-jet-validation": "17f3f11007de0df8f5b03e05f5ef0477cb2edb4d",
-      "refs/heads/claude/jet-condition": "fbf6f1d1224f19a42dae4630a74c6aad845134a3",
-      "refs/heads/claude/les-normalization": "5465832fe5617e1685b0f48926b14065fdf84491",
-      "refs/heads/claude/projected-explosion": "519473a61c7b319183aa54e55b9f097499dde0bf",
-      "refs/heads/claude/refinement-mrt": "aceea293a3ad3ba4b6b8de0c21c1ed4413efece1",
-      "refs/heads/claude/smoke-test": "5ad4995f89f7db30db9f6c10321194aa9abbc68c",
-      "refs/heads/claude/window-dfg-runner": "185a919cc5b1e00d2ea98f3a9ae53916e5056120",
-      "refs/heads/dev": "ed9d8c937d446b854d6963bd92d718bb4fb98b96",
-      "refs/heads/main": "eeda651626dbbc4d9fb2695ad069898b0bbcd5ab",
-      "refs/heads/tron/full9-inlet": "2359605b7aae694851671f3229aaa83b783f5856",
-      "refs/heads/tron/multigrid-usage": "f75d543586315b6272cfdf23046aa7d4550f5fbe",
-      "refs/heads/tron/spacetime-coupling": "f287b460fd06125cf83294e4bd8cd8f7bf3230e3",
-      "refs/heads/tron/validation-2d": "e81a103f3007e9bc86a0c29dcf73c35af0ed4f39"
-    },
-    "remote_after": {
-      "refs/heads/claude/dense-jet-validation": "17f3f11007de0df8f5b03e05f5ef0477cb2edb4d",
-      "refs/heads/claude/jet-condition": "fbf6f1d1224f19a42dae4630a74c6aad845134a3",
-      "refs/heads/claude/les-normalization": "5465832fe5617e1685b0f48926b14065fdf84491",
-      "refs/heads/claude/projected-explosion": "519473a61c7b319183aa54e55b9f097499dde0bf",
-      "refs/heads/claude/refinement-mrt": "aceea293a3ad3ba4b6b8de0c21c1ed4413efece1",
-      "refs/heads/claude/smoke-test": "5ad4995f89f7db30db9f6c10321194aa9abbc68c",
-      "refs/heads/claude/window-dfg-runner": "185a919cc5b1e00d2ea98f3a9ae53916e5056120",
-      "refs/heads/dev": "eec4677db1308e2a9ce4e5f195c994356c11de13",
-      "refs/heads/main": "eeda651626dbbc4d9fb2695ad069898b0bbcd5ab",
-      "refs/heads/tron/full9-inlet": "2359605b7aae694851671f3229aaa83b783f5856",
-      "refs/heads/tron/multigrid-usage": "f75d543586315b6272cfdf23046aa7d4550f5fbe",
-      "refs/heads/tron/spacetime-coupling": "f287b460fd06125cf83294e4bd8cd8f7bf3230e3",
-      "refs/heads/tron/validation-2d": "e81a103f3007e9bc86a0c29dcf73c35af0ed4f39"
-    },
-    "push_exit": 0,
-    "checks": {
-      "remote_exact": true,
-      "remote_dev_exact": true,
-      "main_unchanged": true,
-      "all_local_worktrees_unchanged": true,
-      "local_dev_checkout_and_branch_preserved": true,
-      "root_index_unchanged": true,
-      "all_local_branches_tags_preserved": true,
-      "candidate_clean_exact": true
-    },
-    "source_scope": {
-      "chain": [
-        "ed9d8c937d446b854d6963bd92d718bb4fb98b96",
-        "a135252ae78b47b57d7e77d19001700b3bedac8b",
-        "1aa8110ec8caf04350638d2e07361ce72ba5d22e",
-        "2cf9853952e52f59bea63cf5c1d3a1cd76e53eed",
-        "eec4677db1308e2a9ce4e5f195c994356c11de13"
-      ],
-      "production_src_tree": "f262316529a99eb922813212d0fbb0c6fb385590",
-      "constant_default": "constant",
-      "files": [
-        "docs/development/projected_pair_explosion.md",
-        "src/CelerisLab/lbm/kernels/blocks.cu",
-        "src/CelerisLab/lbm/refinement_stepper.py",
-        "src/CelerisLab/lbm/refinement_tables.py",
-        "tests/unit/test_les_flow_runner.py",
-        "tests/unit/test_projected_explosion.py",
-        "tests/unit/test_projected_pair_gate.py",
-        "tests/unit/test_projected_pair_stepper.py",
-        "tests/validation/data/les_flow/source_pins_a135252.json",
-        "tests/validation/multigrid/check_projected_pairs.py",
-        "tests/validation/run_uniform_les_flow.py",
-        "tests/validation/taylor_green/assess_projected_pairs.py",
-        "tests/validation/taylor_green/run_case.py",
-        "tests/validation/taylor_green/test_projected_pairs.py"
-      ],
-      "diff_stat": " docs/development/projected_pair_explosion.md       |  57 +++\n src/CelerisLab/lbm/kernels/blocks.cu               |  33 ++\n src/CelerisLab/lbm/refinement_stepper.py           |  29 +-\n src/CelerisLab/lbm/refinement_tables.py            |  44 +++\n tests/unit/test_les_flow_runner.py                 |  57 ++-\n tests/unit/test_projected_explosion.py             | 394 +++++++++++++++++++\n tests/unit/test_projected_pair_gate.py             | 162 ++++++++\n tests/unit/test_projected_pair_stepper.py          | 198 ++++++++++\n .../data/les_flow/source_pins_a135252.json         | 110 ++++++\n .../validation/multigrid/check_projected_pairs.py  | 425 ++++++++++++++++++++\n tests/validation/run_uniform_les_flow.py           |  10 +-\n .../taylor_green/assess_projected_pairs.py         | 208 ++++++++++\n tests/validation/taylor_green/run_case.py          | 155 +++++++-\n .../taylor_green/test_projected_pairs.py           | 434 +++++++++++++++++++++\n 14 files changed, 2269 insertions(+), 47 deletions(-)\n"
-    },
-    "remote_commit_tree": "7952cba5b8383712bbafdcc98cbdcd2b4111123d",
-    "remote_src_tree": "f262316529a99eb922813212d0fbb0c6fb385590"
-  },
-  "cleanup": {
-    "utc": "2026-10-18T23:42:13.216523+00:00",
-    "removed": [
-      {
-        "path": "/home/frank14f/CelerisLab/output/review-jet-063508d-20261015",
-        "commit": "063508d1a3440c1311c3a7e6eb1a2b83e12a2092",
-        "tree": "746f07e1aae0de9744e9dcb2dae185577bbacacc",
-        "tracked_files": 440,
-        "source_bytes": 9233268,
-        "allocated_bytes": 10534912,
-        "management_bytes": 81920,
-        "reflog_commits": [
-          "063508d1a3440c1311c3a7e6eb1a2b83e12a2092"
-        ],
-        "recoverable_via_remote_dev": "eec4677db1308e2a9ce4e5f195c994356c11de13",
-        "clean": true,
-        "untracked_or_ignored_files": 0,
-        "command": [
-          "git",
-          "-c",
-          "gc.auto=0",
-          "-c",
-          "maintenance.auto=false",
-          "-C",
-          "/home/frank14f/CelerisLab",
-          "worktree",
-          "remove",
-          "/home/frank14f/CelerisLab/output/review-jet-063508d-20261015"
-        ],
-        "exit": 0,
-        "stdout": "",
-        "stderr": "",
-        "recovery_map": "review-jet-063508d-20261015_recovery.json.gz",
-        "recovery_map_sha256": "8805598e9274f7f2e1cd1dbb75aca1cecae2412a44e18e221e5e0a75606dbccc"
-      },
-      {
-        "path": "/home/frank14f/CelerisLab/output/review-jet-19bd308-20261015",
-        "commit": "19bd3088ef30e3193402e921c387b50c81ddbd45",
-        "tree": "c1d6203d02404798c597ad2c3755b112d3db6226",
-        "tracked_files": 440,
-        "source_bytes": 9234697,
-        "allocated_bytes": 10534912,
-        "management_bytes": 81920,
-        "reflog_commits": [
-          "19bd3088ef30e3193402e921c387b50c81ddbd45"
-        ],
-        "recoverable_via_remote_dev": "eec4677db1308e2a9ce4e5f195c994356c11de13",
-        "clean": true,
-        "untracked_or_ignored_files": 0,
-        "command": [
-          "git",
-          "-c",
-          "gc.auto=0",
-          "-c",
-          "maintenance.auto=false",
-          "-C",
-          "/home/frank14f/CelerisLab",
-          "worktree",
-          "remove",
-          "/home/frank14f/CelerisLab/output/review-jet-19bd308-20261015"
-        ],
-        "exit": 0,
-        "stdout": "",
-        "stderr": "",
-        "recovery_map": "review-jet-19bd308-20261015_recovery.json.gz",
-        "recovery_map_sha256": "a83afe1b0900963d9ad7b94f4260a6e55b45e1fd6410b5c09976f0ead96bd5c6"
-      },
-      {
-        "path": "/home/frank14f/CelerisLab/output/review-jet-508d412-20261015",
-        "commit": "508d412e43aff7a27cba2a60255ebf2500fdfb18",
-        "tree": "4b0189adf5480e3f757193e0d660df3a318fadad",
-        "tracked_files": 440,
-        "source_bytes": 9230649,
-        "allocated_bytes": 10530816,
-        "management_bytes": 81920,
-        "reflog_commits": [
-          "508d412e43aff7a27cba2a60255ebf2500fdfb18"
-        ],
-        "recoverable_via_remote_dev": "eec4677db1308e2a9ce4e5f195c994356c11de13",
-        "clean": true,
-        "untracked_or_ignored_files": 0,
-        "command": [
-          "git",
-          "-c",
-          "gc.auto=0",
-          "-c",
-          "maintenance.auto=false",
-          "-C",
-          "/home/frank14f/CelerisLab",
-          "worktree",
-          "remove",
-          "/home/frank14f/CelerisLab/output/review-jet-508d412-20261015"
-        ],
-        "exit": 0,
-        "stdout": "",
-        "stderr": "",
-        "recovery_map": "review-jet-508d412-20261015_recovery.json.gz",
-        "recovery_map_sha256": "41bd6140c7058cb492f801671ddd3e293127dad0c66d4d1ee0df1c50788d4f3e"
-      },
-      {
-        "path": "/home/frank14f/CelerisLab/output/review-jet-62c525e-20261015",
-        "commit": "62c525e73532a974663be2e112af671fa868b972",
-        "tree": "0152729f4898295c508def8360b415fe147ee57b",
-        "tracked_files": 437,
-        "source_bytes": 9194520,
-        "allocated_bytes": 10489856,
-        "management_bytes": 81920,
-        "reflog_commits": [
-          "62c525e73532a974663be2e112af671fa868b972"
-        ],
-        "recoverable_via_remote_dev": "eec4677db1308e2a9ce4e5f195c994356c11de13",
-        "clean": true,
-        "untracked_or_ignored_files": 0,
-        "command": [
-          "git",
-          "-c",
-          "gc.auto=0",
-          "-c",
-          "maintenance.auto=false",
-          "-C",
-          "/home/frank14f/CelerisLab",
-          "worktree",
-          "remove",
-          "/home/frank14f/CelerisLab/output/review-jet-62c525e-20261015"
-        ],
-        "exit": 0,
-        "stdout": "",
-        "stderr": "",
-        "recovery_map": "review-jet-62c525e-20261015_recovery.json.gz",
-        "recovery_map_sha256": "a06d4f65f1ed3002bbef0bf21786741276cf0a4a09888238354bf2aab8ae4722"
-      },
-      {
-        "path": "/home/frank14f/CelerisLab/output/review-jet-f1e0342-20261015",
-        "commit": "f1e03423f336bfdf120e5f2ee5c949fded17130c",
-        "tree": "3b6106280809096d1dfb73037894d0846f2572ce",
-        "tracked_files": 440,
-        "source_bytes": 9237148,
-        "allocated_bytes": 10534912,
-        "management_bytes": 81920,
-        "reflog_commits": [
-          "f1e03423f336bfdf120e5f2ee5c949fded17130c"
-        ],
-        "recoverable_via_remote_dev": "eec4677db1308e2a9ce4e5f195c994356c11de13",
-        "clean": true,
-        "untracked_or_ignored_files": 0,
-        "command": [
-          "git",
-          "-c",
-          "gc.auto=0",
-          "-c",
-          "maintenance.auto=false",
-          "-C",
-          "/home/frank14f/CelerisLab",
-          "worktree",
-          "remove",
-          "/home/frank14f/CelerisLab/output/review-jet-f1e0342-20261015"
-        ],
-        "exit": 0,
-        "stdout": "",
-        "stderr": "",
-        "recovery_map": "review-jet-f1e0342-20261015_recovery.json.gz",
-        "recovery_map_sha256": "1444f7ca5825ce490660f38be89be0331f57a87a26828f9f25eaa123f3a93683"
-      },
-      {
-        "path": "/home/frank14f/CelerisLab/output/review-jet-99ddb5f-20261016",
-        "commit": "99ddb5fc27e5a2c52bd27312981e34e6be98883b",
-        "tree": "d616e328a0afee4e2832fc7999852306205f761e",
-        "tracked_files": 440,
-        "source_bytes": 9242940,
-        "allocated_bytes": 10539008,
-        "management_bytes": 81920,
-        "reflog_commits": [
-          "99ddb5fc27e5a2c52bd27312981e34e6be98883b"
-        ],
-        "recoverable_via_remote_dev": "eec4677db1308e2a9ce4e5f195c994356c11de13",
-        "clean": true,
-        "untracked_or_ignored_files": 0,
-        "command": [
-          "git",
-          "-c",
-          "gc.auto=0",
-          "-c",
-          "maintenance.auto=false",
-          "-C",
-          "/home/frank14f/CelerisLab",
-          "worktree",
-          "remove",
-          "/home/frank14f/CelerisLab/output/review-jet-99ddb5f-20261016"
-        ],
-        "exit": 0,
-        "stdout": "",
-        "stderr": "",
-        "recovery_map": "review-jet-99ddb5f-20261016_recovery.json.gz",
-        "recovery_map_sha256": "47bef4af7d27850a277603c5247ed9532534c90727e9870b8174ec38e45994ab"
-      }
-    ],
-    "skipped": [],
-    "before_bytes": {
-      "output_bytes": 1867370496,
-      "git_management_bytes": 64847872,
-      "receipt_bytes": 5877760,
-      "total_bytes": 1932218368
-    },
-    "after_bytes": {
-      "output_bytes": 1805164544,
-      "git_management_bytes": 64356352,
-      "receipt_bytes": 6836224,
-      "total_bytes": 1869520896
-    },
-    "worktrees_before": 38,
-    "worktrees_after": 32,
-    "checks": {
-      "only_selected_worktrees_removed": true,
-      "remaining_worktrees_unchanged": true,
-      "all_refs_unchanged": true,
-      "branches_tags_root_index_remote_unchanged": true,
-      "all_source_object_files_preserved": true,
-      "all_scientific_evidence_files_preserved": true,
-      "untracked_and_ignored_user_files_preserved": true,
-      "dev_checkout_retained": true
-    },
-    "evidence_files": 10001,
-    "evidence_aggregate_sha256": "503dcd4dbd4514e577b09b761c66502d3f8c8e57ef1c7e12f46c0a24a6af0ea4",
-    "original_source_object_files": 2154,
-    "no_scientific_evidence_deleted": true,
-    "no_refs_or_source_history_pruned": true,
-    "no_environment_changes": true
-  },
-  "current_remote_heads": {
-    "refs/heads/claude/dense-jet-validation": "17f3f11007de0df8f5b03e05f5ef0477cb2edb4d",
-    "refs/heads/claude/jet-condition": "fbf6f1d1224f19a42dae4630a74c6aad845134a3",
-    "refs/heads/claude/les-normalization": "5465832fe5617e1685b0f48926b14065fdf84491",
-    "refs/heads/claude/projected-explosion": "519473a61c7b319183aa54e55b9f097499dde0bf",
-    "refs/heads/claude/refinement-mrt": "aceea293a3ad3ba4b6b8de0c21c1ed4413efece1",
-    "refs/heads/claude/smoke-test": "5ad4995f89f7db30db9f6c10321194aa9abbc68c",
-    "refs/heads/claude/window-dfg-runner": "185a919cc5b1e00d2ea98f3a9ae53916e5056120",
-    "refs/heads/dev": "eec4677db1308e2a9ce4e5f195c994356c11de13",
-    "refs/heads/main": "eeda651626dbbc4d9fb2695ad069898b0bbcd5ab",
-    "refs/heads/tron/full9-inlet": "2359605b7aae694851671f3229aaa83b783f5856",
-    "refs/heads/tron/multigrid-usage": "f75d543586315b6272cfdf23046aa7d4550f5fbe",
-    "refs/heads/tron/spacetime-coupling": "f287b460fd06125cf83294e4bd8cd8f7bf3230e3",
-    "refs/heads/tron/validation-2d": "e81a103f3007e9bc86a0c29dcf73c35af0ed4f39"
-  },
-  "current_local_dev": {
-    "path": "/home/frank14f/CelerisLab/output/dev-worktree",
-    "commit": "f75d543586315b6272cfdf23046aa7d4550f5fbe",
-    "clean": true,
-    "preserved_reason": "f75d543 is not ancestor of remote ed9d8c9;no reset/unrelated local merge"
-  },
-  "constant_default": "constant",
-  "projected_eligibility": "explicit opt-in experimental scope unchanged",
-  "science_scope": {
-    "TG": "narrow four-case Re100 smooth-decay diagnostic only;projected PASS,constant relative velocity FAIL,aggregate false preserved",
-    "LES": "new named current profile resolves only introduced pin mismatches;uniform corrected regression only;Cs1 amplified diagnostic",
-    "unresolved_historical_issues": [
-      "channel.py Jet-CV mismatch",
-      "pre-existing optional dependency errors"
-    ],
-    "no_new_GPU_or_tests": true
-  },
-  "preserved_original_archives": {
-    "projected-grid-11901a7-20261018/CelerisLab_projected_grid_11901a7_complete_20261018.zip": "c20e364e72b96858bf7bc317cba3d02a40e03be74ab1816048e78f7e89678f47",
-    "projected-pairs-gate-1aa8110-20261018/CelerisLab_projected_pair_gate_1aa8110_20261018.zip": "589a5537069cb7f10c6e349648aae2900b0af996b0dc1ac147a138581cb913e3",
-    "projected-pairs-tg-2cf9853-20261018/CelerisLab_projected_pairs_TG_2cf9853_20261018.zip": "d312bfd0175e5a79d1a28a595ba229a6d8435ba13e3b9058c409fcc9737cafc1",
-    "uniform-les-eec4677-20261018/CelerisLab_uniform_LES_eec4677_20261018.zip": "7b8e6951b24a8c2852387bc0a026e133c491931d97340056195a981fb51db879"
-  },
-  "proof_files": {
-    "cleanup.py": {
-      "bytes": 6513,
-      "sha256": "5b3db9f9d59b58be1ea9c4427ab06d1e2f41671d3a17245a97cb7979da6b6826"
-    },
-    "cleanup_activity_preflight.json": {
-      "bytes": 588,
-      "sha256": "51d0b5403b66980cb4d272bae498c4c71197634cd5c892877ca4ab351cf02a11"
-    },
-    "cleanup_after.json.gz": {
-      "bytes": 710267,
-      "sha256": "c897f2d61c04c1c2bcc955108d41538b277663ed1059e560bfe7ebf3d993fc00"
-    },
-    "cleanup_before.json.gz": {
-      "bytes": 834537,
-      "sha256": "12213622ee7b4ad2e48b32f3c0d1f8b676b362243430329781dc76a76908cc88"
-    },
-    "cleanup_result.json": {
-      "bytes": 7540,
-      "sha256": "d042619320d9c26ff92cd531cf4d4620dfc673aaacb3a10f892819beb790beb0"
-    },
-    "dev_push_result.json": {
-      "bytes": 333,
-      "sha256": "e6cb70eea47d92840ab2253cc3afc1fa842e3b08a4fc4b8c4fa8c62941f7fa3b"
-    },
-    "dev_push_started.json": {
-      "bytes": 1532,
-      "sha256": "0ff359e7153eaa44f53c9e6a4c61e336ce34a416d27db4fbb59e88d4db36502a"
-    },
-    "evidence_before.json.gz": {
-      "bytes": 470636,
-      "sha256": "f255aec46b524325c006427f809d83f2792f46aac35fe5e089a61e36ba38910b"
-    },
-    "gate_common.py": {
-      "bytes": 3086,
-      "sha256": "106688da96d6946cc7d86bcff9fba16ebebb1cb8ac6d84f083afdac51f44ae30"
-    },
-    "integrate.py": {
-      "bytes": 3831,
-      "sha256": "d25de325d395ef8f315f16bf5471c30776986239980037015ec761c375ed3687"
-    },
-    "integration_before.json.gz": {
-      "bytes": 834540,
-      "sha256": "38a1d639a3dd0be479ddb2959b4cdc9bcd1f28aff9153471e06aa96f44b9f020"
-    },
-    "integration_first_attempt_error.txt": {
-      "bytes": 747,
-      "sha256": "8af828b2e3f1deb96457fd52298f1cfec9b18351e714f6b35ffabcda89d1bb47"
-    },
-    "integration_result.json": {
-      "bytes": 5178,
-      "sha256": "3d8bb9f2ef761e0e94a1695d1b7a7aec02f724f837269922d4faf1c1d239b0ca"
-    },
-    "inventory.json": {
-      "bytes": 997138,
-      "sha256": "2865b1162bfd704c43bb8c108a7b0b75fc9df4709a0d75cb2195d9f71ada601b"
-    },
-    "inventory.py": {
-      "bytes": 2750,
-      "sha256": "78bed3f832fb245cf80e88e80864293242544726b2141a66f4ace6ee08f19547"
-    },
-    "management.py": {
-      "bytes": 4710,
-      "sha256": "3dbfadb0a13532d21282f2830269eb40398485be9063460fc87ff3414516b451"
-    },
-    "protected_extra_files.json.gz": {
-      "bytes": 19413,
-      "sha256": "4efcc18c5d028f38c761ba0ffcf949c793ef8e42aa80f4ba60bb2486944cf9e8"
-    },
-    "protection_before.json.gz": {
-      "bytes": 834539,
-      "sha256": "60a786d506e7dd3b94836541a601821fb26e4a5e68393fb23cc87a73d8c5669d"
-    },
-    "publish_receipt.py": {
-      "bytes": 2736,
-      "sha256": "5ed94713bdf9de11c8a0ce6b772c8ef3f025a7b4cc41f986d442ae3f80e7fa1b"
-    },
-    "publish_reviewed_dev.py": {
-      "bytes": 2817,
-      "sha256": "efb08358295f94a843047804866110d3de132ff2ea372c5c6f3641b3952a54e2"
-    },
-    "remote_only_integration_after.json.gz": {
-      "bytes": 834552,
-      "sha256": "2d2b125fcd1826be790ddecabdb27dec8851c84c0f46e23aa0e749407f6b4045"
-    },
-    "remote_only_integration_before.json.gz": {
-      "bytes": 834552,
-      "sha256": "0368c5f0c393a78474fa872950512c2b3db10b30277d2477056b1696782d8c4c"
-    },
-    "review-jet-063508d-20261015_recovery.json.gz": {
-      "bytes": 35325,
-      "sha256": "8805598e9274f7f2e1cd1dbb75aca1cecae2412a44e18e221e5e0a75606dbccc"
-    },
-    "review-jet-063508d-20261015_removal.json": {
-      "bytes": 942,
-      "sha256": "50381cd4a36e616fdcada15fe2508a3aa4cadfcca22d65ada15b66c8c9b01373"
-    },
-    "review-jet-19bd308-20261015_recovery.json.gz": {
-      "bytes": 35320,
-      "sha256": "a83afe1b0900963d9ad7b94f4260a6e55b45e1fd6410b5c09976f0ead96bd5c6"
-    },
-    "review-jet-19bd308-20261015_removal.json": {
-      "bytes": 942,
-      "sha256": "8fc1b317a8a16ae6325ada98201771834583891a8a81f5f440993441b1675bc0"
-    },
-    "review-jet-508d412-20261015_recovery.json.gz": {
-      "bytes": 35321,
-      "sha256": "41bd6140c7058cb492f801671ddd3e293127dad0c66d4d1ee0df1c50788d4f3e"
-    },
-    "review-jet-508d412-20261015_removal.json": {
-      "bytes": 942,
-      "sha256": "51610ededb9123dfb492e2802ff28f823ba1589a1bb56c675a1adf6e0dfe07af"
-    },
-    "review-jet-62c525e-20261015_recovery.json.gz": {
-      "bytes": 35026,
-      "sha256": "a06d4f65f1ed3002bbef0bf21786741276cf0a4a09888238354bf2aab8ae4722"
-    },
-    "review-jet-62c525e-20261015_removal.json": {
-      "bytes": 942,
-      "sha256": "cf62efc212a7211049ff2d5e338a29f838b741eebad7a23f756ee7d4c651de3f"
-    },
-    "review-jet-99ddb5f-20261016_recovery.json.gz": {
-      "bytes": 35321,
-      "sha256": "47bef4af7d27850a277603c5247ed9532534c90727e9870b8174ec38e45994ab"
-    },
-    "review-jet-99ddb5f-20261016_removal.json": {
-      "bytes": 942,
-      "sha256": "c2ef4fcf118fa0c0eb07ca48ad37c0fdcab50a85a2f7b53c1ccc9f1219fe1977"
-    },
-    "review-jet-f1e0342-20261015_recovery.json.gz": {
-      "bytes": 35320,
-      "sha256": "1444f7ca5825ce490660f38be89be0331f57a87a26828f9f25eaa123f3a93683"
-    },
-    "review-jet-f1e0342-20261015_removal.json": {
-      "bytes": 942,
-      "sha256": "00f9680a25e46a104e5eeb6dd42a762e9755964f4854d5312da51fa5c86d58e4"
-    },
-    "seal_receipt.py": {
-      "bytes": 4270,
-      "sha256": "3b71e9842c3f38a51fb359611dc5a4a1f5bfc389a997b8222f26ac02c808886a"
-    },
-    "source_objects_before.json.gz": {
-      "bytes": 144229,
-      "sha256": "b7eba34841f7cdb8b12718523233778ee241bd05a4cbdd2d3028e1dcc9d57bdf"
-    }
-  },
-  "final_prepublication_footprint": {
-    "output_bytes": 1805185024,
-    "git_management_bytes": 64356352,
-    "receipt_bytes": 6856704,
-    "total_bytes": 1869541376
-  },
-  "no_new_branch": true,
-  "no_force_push": true,
-  "no_GitHub_publication": true,
-  "no_source_history_pruning": true
-}

validation-evidence/2026-10-18/dev-projected-integration-eec4677/README.txt

@@ -1,13 +0,0 @@
-Reviewed projected-pair chain integrated by ordinary fast-forward to Gitea dev.
-Remote dev:eec4677db1308e2a9ce4e5f195c994356c11de13;main unchanged:eeda651626dbbc4d9fb2695ad069898b0bbcd5ab.
-Commit source tree:f262316529a99eb922813212d0fbb0c6fb385590;constant default retained.
-Local dev preserved clean atf75d543586315b6272cfdf23046aa7d4550f5fbe because it is not ancestor
-of the remote baseline.No reset or unrelated local merge;all other local refs kept.
-Six clean inactive detached Jet source copies removed only after exact Git-blob
-recovery verification;all commits remain ancestors of remote dev.All source
-objects,common refs,scientific evidence/original archives,user files/environments
-and32 remaining worktrees preserved.Exact paths/commit IDs in JSON receipt.
-No new GPU/test run.Historical TG constant failure/aggregatefalse,Jet-CV mismatch
-and optional dependency issues kept separate from current LES pin resolution.
-Full before/after inventories and per-file recovery maps remain at/home/frank14f/CelerisLab/output/dev-projected-integration-eec4677-20261018 with hashes.
-Temporary footprint before this small receipt publication:1869541376bytes.

validation-evidence/2026-10-18/dev-projected-integration-eec4677/RECEIPT_MANIFEST.json

@@ -1,42 +0,0 @@
-{
-  "files": {
-    "INTEGRATION_CLEANUP_RECEIPT.json": {
-      "bytes": 21807,
-      "sha256": "91e30b209c92ee6c117d78caba4c2a07d2b52979f25828e7613070d7eeb682a2"
-    },
-    "README.txt": {
-      "bytes": 1160,
-      "sha256": "83ddbac006c836319f7d7dcc54923a87a63ae6ba98b469e8a651aa473290b45b"
-    }
-  },
-  "candidate": "eec4677db1308e2a9ce4e5f195c994356c11de13",
-  "source_scope": {
-    "chain": [
-      "ed9d8c937d446b854d6963bd92d718bb4fb98b96",
-      "a135252ae78b47b57d7e77d19001700b3bedac8b",
-      "1aa8110ec8caf04350638d2e07361ce72ba5d22e",
-      "2cf9853952e52f59bea63cf5c1d3a1cd76e53eed",
-      "eec4677db1308e2a9ce4e5f195c994356c11de13"
-    ],
-    "production_src_tree": "f262316529a99eb922813212d0fbb0c6fb385590",
-    "constant_default": "constant",
-    "files": [
-      "docs/development/projected_pair_explosion.md",
-      "src/CelerisLab/lbm/kernels/blocks.cu",
-      "src/CelerisLab/lbm/refinement_stepper.py",
-      "src/CelerisLab/lbm/refinement_tables.py",
-      "tests/unit/test_les_flow_runner.py",
-      "tests/unit/test_projected_explosion.py",
-      "tests/unit/test_projected_pair_gate.py",
-      "tests/unit/test_projected_pair_stepper.py",
-      "tests/validation/data/les_flow/source_pins_a135252.json",
-      "tests/validation/multigrid/check_projected_pairs.py",
-      "tests/validation/run_uniform_les_flow.py",
-      "tests/validation/taylor_green/assess_projected_pairs.py",
-      "tests/validation/taylor_green/run_case.py",
-      "tests/validation/taylor_green/test_projected_pairs.py"
-    ],
-    "diff_stat": " docs/development/projected_pair_explosion.md       |  57 +++\n src/CelerisLab/lbm/kernels/blocks.cu               |  33 ++\n src/CelerisLab/lbm/refinement_stepper.py           |  29 +-\n src/CelerisLab/lbm/refinement_tables.py            |  44 +++\n tests/unit/test_les_flow_runner.py                 |  57 ++-\n tests/unit/test_projected_explosion.py             | 394 +++++++++++++++++++\n tests/unit/test_projected_pair_gate.py             | 162 ++++++++\n tests/unit/test_projected_pair_stepper.py          | 198 ++++++++++\n .../data/les_flow/source_pins_a135252.json         | 110 ++++++\n .../validation/multigrid/check_projected_pairs.py  | 425 ++++++++++++++++++++\n tests/validation/run_uniform_les_flow.py           |  10 +-\n .../taylor_green/assess_projected_pairs.py         | 208 ++++++++++\n tests/validation/taylor_green/run_case.py          | 155 +++++++-\n .../taylor_green/test_projected_pairs.py           | 434 +++++++++++++++++++++\n 14 files changed, 2269 insertions(+), 47 deletions(-)\n"
-  },
-  "original_archives_preserved": true
-}

validation-evidence/2026-10-18/projected-grid-11901a7/TRANSPORT_MANIFEST.json

@@ -1,9 +0,0 @@
-{
-  "archive": "CelerisLab_projected_grid_11901a7_complete_20261018.zip",
-  "bytes": 423726,
-  "sha256": "c20e364e72b96858bf7bc317cba3d02a40e03be74ab1816048e78f7e89678f47",
-  "source": "11901a7f77557a901e017a171eeae1758d584fa5",
-  "numerical_source": "519473a61c7b319183aa54e55b9f097499dde0bf",
-  "route": "ExistingGiteaevidencebranch fallback after explicitlyauthorized same-argumentDrive retry failed atOpenAI fileblob network transport;not an approval bypass",
-  "scope": "Evidence-only transport;no oldsource harness integration;all originalmember bytes retained"
-}

validation-evidence/2026-10-18/projected-grid-11901a7/TRANSPORT_README.txt

@@ -1,6 +0,0 @@
-Matched projected-G diagnostic onexact11901a7/519numerics.
-Projected_linear passes allfrozen baselinegates;constantfailsvelocitygate;aggregatefails.
-All fourcasecontrols valid;finestcontrols andearlypressuretransients reported separately.
-Complete original receipts,failedattempts,recoveryauthorization,monitor drytests,source/build/PTX/runtime/protection records included.
-No production/default change,convergence ornewalgorithm qualification.
-ArchiveSHA256:c20e364e72b96858bf7bc317cba3d02a40e03be74ab1816048e78f7e89678f47

validation-evidence/2026-10-18/projected-pairs-gate-1aa8110/TRANSPORT_MANIFEST.json

@@ -1,23 +0,0 @@
-{
-  "archive": "CelerisLab_projected_pair_gate_1aa8110_20261018.zip",
-  "bytes": 4551692,
-  "sha256": "589a5537069cb7f10c6e349648aae2900b0af996b0dc1ac147a138581cb913e3",
-  "baseline": "ed9d8c937d446b854d6963bd92d718bb4fb98b96",
-  "candidate": "1aa8110ec8caf04350638d2e07361ce72ba5d22e",
-  "production": "a135252ae78b47b57d7e77d19001700b3bedac8b",
-  "driver_sha256": "3dbaa6547cb0a4cb1541054f3b64ad8b6e18cc70527ac6166e56b944e9bd464a",
-  "route": "Authorized evidence-only fallback to existing Gitea branch after confirmed Drive blob transport failure",
-  "drive_failure": {
-    "action": "Drive upload of exact complete archive",
-    "folder_id": "1nMnnyD2UvwhdfNDHY_L1Bbn9LiDjr_WS",
-    "status": "confirmed_transport_failure",
-    "drive_file_id_returned": false,
-    "approval_denial": false,
-    "endpoint": "sdmntprcentralus.oaiusercontent.com",
-    "elapsed_ms": 216022,
-    "azure_client_request_id": "36a2db34-002d-432b-990c-66a228f87268",
-    "reason": "OpenAI file blob upload failed: error sending request",
-    "retry_attempted": false
-  },
-  "scope": "Complete original ZIP, no fragments; no source integration"
-}

validation-evidence/2026-10-18/projected-pairs-gate-1aa8110/TRANSPORT_README.txt

@@ -1,8 +0,0 @@
-PASS: exact ed9d8c9 baseline versus exact 1aa8110 test-only candidate / a135252 production source.
-Six host guards and both sequential GPU processes passed; 136.855 seconds total.
-Six default bit-equivalence groups, six projected groups and two changed-remap groups passed.
-112 actual compiler sidecars retained and source/config/PTX verified.
-No production promotion/default change, main/dev update, LES re-pin or new conservation claim.
-Complete original evidence in one ZIP; all 57 manifest payloads verified.
-Drive blob ingress failed after 216022 ms before any Drive file ID; approved existing-branch fallback.
-Archive SHA256: 589a5537069cb7f10c6e349648aae2900b0af996b0dc1ac147a138581cb913e3

validation-evidence/2026-10-18/projected-pairs-tg-2cf9853/TRANSPORT_MANIFEST.json

@@ -1,24 +0,0 @@
-{
-  "archive": "CelerisLab_projected_pairs_TG_2cf9853_20261018.zip",
-  "bytes": 4567931,
-  "sha256": "d312bfd0175e5a79d1a28a595ba229a6d8435ba13e3b9058c409fcc9737cafc1",
-  "candidate": "2cf9853952e52f59bea63cf5c1d3a1cd76e53eed",
-  "production": "a135252ae78b47b57d7e77d19001700b3bedac8b",
-  "source_fingerprint": "a5dbfd804befce868067d79a23e5fd47dce7f505b3f9b1bb2145fb57cb5f2178",
-  "capture_helper_sha256": "3dbaa6547cb0a4cb1541054f3b64ad8b6e18cc70527ac6166e56b944e9bd464a",
-  "route": "Authorized evidence-only fallback to existing Gitea branch after confirmed Drive blob transport failure",
-  "drive_failure": {
-    "action": "Upload intact CelerisLab_projected_pairs_TG_2cf9853_20261018.zip",
-    "folder_id": "1nMnnyD2UvwhdfNDHY_L1Bbn9LiDjr_WS",
-    "status": "confirmed_transport_failure",
-    "drive_file_id_returned": false,
-    "approval_denial": false,
-    "endpoint": "sdmntprcentralus.oaiusercontent.com",
-    "elapsed_ms": 216449,
-    "azure_client_request_id": "2a1827d5-986d-4999-a920-9ea1bd63fba7",
-    "reason": "OpenAI file blob upload failed: error sending request",
-    "retry_attempted": false,
-    "archive_sha256": "d312bfd0175e5a79d1a28a595ba229a6d8435ba13e3b9058c409fcc9737cafc1"
-  },
-  "scope": "Complete original ZIP, no fragments; no source integration"
-}

validation-evidence/2026-10-18/projected-pairs-tg-2cf9853/TRANSPORT_README.txt

@@ -1,8 +0,0 @@
-Exact2cf9853 generic projected-pair TG repeat / a135252 production source.
-Four fresh cases and assessment completed,18.568578 seconds,589299712 active updates.
-Projected_linear PASS;constant velocity relative gate FAIL;aggregate FALSE.
-All absolute gates and case/control validity pass;all scalar samples identical to11901a7.
-19 host tests and dry-run passed;initial external count assertion retained.
-Six actual build sidecars/source/config/PTX verified;no tuning/default switch/source merge.
-Complete intact ZIP with105manifest payloads;authorized existing Gitea evidence branch fallback.
-Archive SHA256: d312bfd0175e5a79d1a28a595ba229a6d8435ba13e3b9058c409fcc9737cafc1

validation-evidence/2026-10-18/transport_manifest.json

@@ -1,37 +0,0 @@
-{
-  "archives": [
-    {
-      "name": "CelerisLab_equilibrium_DFG_92da2e8_complete_results_20261018.tar.xz",
-      "bytes": 637088,
-      "sha256": "f0d45630c7d72f795ceccfd60a49b29881530903aaeb7b0a655c549ad1b40cd4",
-      "credential_scan": "No credentials/private-key/access-token patterns,including decompressed protection inventories",
-      "metadata_paths": "Only explicitly authorized CelerisLab project,existing interpreter and system/ephemeral paths",
-      "source_fixture_literal": "/workspace/shared/dfg_research/20141124_dfg_bench2_official.zip",
-      "no_unrelated_private_paths": true,
-      "archive_bytes_unchanged": true,
-      "no_credentials_or_unrelated_private_paths": true,
-      "archive_member_bytes_preserved": true
-    },
-    {
-      "name": "CelerisLab_shifted_unshifted_tiny_e8b8c58_20261018.zip",
-      "bytes": 82506,
-      "sha256": "81e05cf4c606310c966f905864497f0254edb70c77b107a6e77af570c7c54efa",
-      "credential_scan": "No credentials/private-key/access-token patterns,including decompressed protection inventories",
-      "metadata_paths": "Only explicitly authorized CelerisLab project,existing interpreter and system/ephemeral paths",
-      "source_fixture_literal": null,
-      "no_unrelated_private_paths": true,
-      "archive_bytes_unchanged": true,
-      "no_credentials_or_unrelated_private_paths": true,
-      "archive_member_bytes_preserved": true
-    },
-    {
-      "name": "CelerisLab_FP64_predictor_pair_5468695_20261018.zip",
-      "bytes": 61110,
-      "sha256": "28b6ce8804e3c448f829ea3516f8dff893373c899eb6d7b0f6a1d0edf6ca772e",
-      "scope": "CPU scalar result only,source5468695 not merged into any GPU/production branch",
-      "no_credentials_or_unrelated_private_paths": true,
-      "archive_member_bytes_preserved": true
-    }
-  ],
-  "scope": "Intact original archives,transport only via existing validation branch;original result and qualification hash bindings preserved"
-}

validation-evidence/2026-10-18/uniform-les-eec4677/TRANSPORT_MANIFEST.json

@@ -1,30 +0,0 @@
-{
-  "archive": "CelerisLab_uniform_LES_eec4677_20261018.zip",
-  "bytes": 4528905,
-  "sha256": "7b8e6951b24a8c2852387bc0a026e133c491931d97340056195a981fb51db879",
-  "candidate": "eec4677db1308e2a9ce4e5f195c994356c11de13",
-  "production": "a135252ae78b47b57d7e77d19001700b3bedac8b",
-  "source_fingerprint": "a5dbfd804befce868067d79a23e5fd47dce7f505b3f9b1bb2145fb57cb5f2178",
-  "capture_helper_sha256": "3dbaa6547cb0a4cb1541054f3b64ad8b6e18cc70527ac6166e56b944e9bd464a",
-  "route": "Authorized existing Gitea evidence branch fallback using documented current-session blob transport failures; no Drive submission for this archive",
-  "drive_failure": {
-    "status": "known_session_blob_transport_failure",
-    "approval_denial": false,
-    "this_archive_upload_attempted": false,
-    "basis": [
-      {
-        "archive": "CelerisLab_projected_pairs_TG_2cf9853_20261018.zip",
-        "status": "confirmed blob ingress transport failure",
-        "endpoint": "sdmntprcentralus.oaiusercontent.com",
-        "elapsed_ms": 216449,
-        "azure_client_request_id": "2a1827d5-986d-4999-a920-9ea1bd63fba7"
-      },
-      {
-        "archive": "CelerisLab_TG_2cf9853_REVIEW_SUBSET_20261018.zip",
-        "status": "MCP upload timeout,no ID returned,two folder lookups found no matches"
-      }
-    ],
-    "current_archive_sha256": "7b8e6951b24a8c2852387bc0a026e133c491931d97340056195a981fb51db879"
-  },
-  "scope": "Complete original ZIP, no fragments; no source integration"
-}

validation-evidence/2026-10-18/uniform-les-eec4677/TRANSPORT_README.txt

@@ -1,8 +0,0 @@
-PASS: exacteec4677 existing uniform LES corrected regression / a135252 production source.
-12 host runner/oracle checks and one actual corrected GPU run passed,exit0.
-Three READY/reset records,DONEpassedtrue;Cs0/.16/1;6228 reported launches,10.535915seconds.
-Manifest pins101 sources;historical profiles unchanged.Three actual build sidecars/PTX/source/config audits passed.
-No baseline GPU,sweep,threshold/default/source integration changes;Cs1 amplified diagnostic only.
-Complete intact archive with47manifest payloads;all original bytes verified.
-Existing-session confirmed Drive blob failures used as authorized fallback basis;this archive not submitted to Drive.
-Archive SHA256: 7b8e6951b24a8c2852387bc0a026e133c491931d97340056195a981fb51db879

validation-evidence/2026-10-19/axis-square-afa8f6a/TRANSPORT_MANIFEST.json

@@ -1,22 +0,0 @@
-{
-  "archive": "CelerisLab_axis_square_afa8f6a_20261019.zip",
-  "bytes": 170503,
-  "sha256": "e5348495e462973df35ab8675d456f024856397232010e276e132d5c21609c5c",
-  "candidate": "afa8f6aca10177d5901a9aeae650d3419212c6d0",
-  "production": "a135252ae78b47b57d7e77d19001700b3bedac8b",
-  "source_branch": "tron/shear-probe-guards-caa573f",
-  "diagnostic": "axis_square_shear_n128",
-  "axis_module_sha256": "0baffa6eb99c268ce998d90300c993d45bb3b7b27c524b636874d75808bd0a8c",
-  "screening_pass": null,
-  "qualification_eligible": false,
-  "all_traces_complete": true,
-  "global_rows": 8,
-  "trace_times": 36,
-  "native_cell_time_triplets": 720,
-  "independently_verified_before_cleanup": true,
-  "matrix_assessor_run": false,
-  "late_fit_performed": false,
-  "physical_pass_claim": false,
-  "route": "Existing Gitea validation evidence branch",
-  "payload_scope": "Complete scientific ZIP, transport README and manifest only"
-}

validation-evidence/2026-10-19/axis-square-afa8f6a/TRANSPORT_README.txt

@@ -1,9 +0,0 @@
-Short square shear orientation diagnostic: exact afa8f6aca10177d5901a9aeae650d3419212c6d0; production a135252ae78b47b57d7e77d19001700b3bedac8b unchanged.
-Four fresh cases, root steps 0..8 only; no extra cases or broad test reruns.
-axis_square_shear_n128; mode(2,0), phase pi/4, POST-G initialization, square(32,32,96,96).
-8 global rows, 36 trace times, 720 native rho/ux/uy cell-time triplets; six build sidecars audited before cleanup.
-screening_pass=null; qualification_eligible=false; no late fit or physical pass claim.
-Signed unit-area native group moments retain actual centers, widths, areas and parity; no interpolation.
-Root-sync samples do not resolve fine substeps. No snapshot, field dump, checkpoint or rerun.
-Archive SHA256: e5348495e462973df35ab8675d456f024856397232010e276e132d5c21609c5c
-Only intended scientific files; no task history or process listings.

validation-evidence/2026-10-19/centered-face-3552e6e/TRANSPORT_MANIFEST.json

@@ -1,32 +0,0 @@
-{
-  "archive": "CelerisLab_centered_face_3552e6e_20261019.zip",
-  "bytes": 681926,
-  "sha256": "0cc8db143a72d6f3a2957a27279b4fa4a7b76d4d20a2da1ea48599e0f250eb79",
-  "candidate": "3552e6ee92696415491e756824887a3dbbbec492",
-  "production": "a135252ae78b47b57d7e77d19001700b3bedac8b",
-  "source_branch": "experiment/centered-face-square",
-  "diagnostic": "centered_face_square_n128",
-  "advance_to_review": false,
-  "checks": {
-    "bottom_step1_clear": true,
-    "top_step1_nonworse": false,
-    "bottom_step8_nonworse": true,
-    "top_step8_nonworse": true,
-    "vertical_null": true,
-    "acoustic_nonworse": false,
-    "sampled_pressure_nonworse": true,
-    "step8_pressure_nonworse": true
-  },
-  "qualification_eligible": false,
-  "qualified": false,
-  "global_rows": 8,
-  "trace_times": 36,
-  "native_cell_time_triplets": 720,
-  "actual_source_config_ptx_captured_and_verified_before_cleanup": true,
-  "official_comparison_serialization_failed": true,
-  "recovered_unchanged_comparison": true,
-  "no_gpu_reruns": true,
-  "physical_pass_claim": false,
-  "route": "Existing Gitea validation evidence branch",
-  "payload_scope": "Complete scientific ZIP, transport README and manifest only"
-}

validation-evidence/2026-10-19/centered-face-3552e6e/TRANSPORT_README.txt

@@ -1,8 +0,0 @@
-Centered-face square experimental comparison: exact 3552e6ee92696415491e756824887a3dbbbec492; production a135252ae78b47b57d7e77d19001700b3bedac8b unchanged.
-Four fresh sequential cases: U128/U256/current projected/centered_face_v1. Root steps 0..8 only.
-1900544 ACTIVE updates, 8 global rows, 36 trace times, 720 native cell-time triplets; six actual source/config/PTX builds captured and audited before cleanup.
-Recovered unchanged comparison: advance_to_review=false; top_step1_nonworse and acoustic_nonworse fail.
-Official comparison CLI exit1 was a NumPy bool_ JSON serialization defect; partial output and traceback retained. Host-only comparison recovery converted scalar types only. No GPU or CLI reruns.
-qualification_eligible=false; qualified=false; no physical pass or main promotion. Local arithmetic deadbands are not accumulated error bounds.
-Archive SHA256: 0cc8db143a72d6f3a2957a27279b4fa4a7b76d4d20a2da1ea48599e0f250eb79
-Only intended scientific files; no task history, process listings or approval exchanges.

validation-evidence/2026-10-19/nested-shear-335624c/TRANSPORT_MANIFEST.json

@@ -1,13 +0,0 @@
-{
-  "archive": "CelerisLab_nested_shear_335624c_20261019.zip",
-  "bytes": 2110640,
-  "sha256": "8ff04b86f58d5e863394fedf8a87648879cdf7277b6d1bb326208858322d3e04",
-  "snapshot_sha256": "4e8b8af02ba54db48dc2ea36f24c16fc6004f77e4c8f143fca809ec7fbaa7884",
-  "candidate": "335624c27b8fc9925e708fb61bde5eea5c04d2a4",
-  "production": "a135252ae78b47b57d7e77d19001700b3bedac8b",
-  "diagnostic": "nested_shear_n128",
-  "scientific_status": "FAIL",
-  "contract_valid": true,
-  "route": "Existing authorized Gitea validation evidence branch",
-  "payload_scope": "Complete scientific ZIP, transport README and manifest only"
-}

validation-evidence/2026-10-19/nested-shear-335624c/TRANSPORT_README.txt

@@ -1,11 +0,0 @@
-Nested shear validation: exact 335624c27b8fc9925e708fb61bde5eea5c04d2a4; production a135252ae78b47b57d7e77d19001700b3bedac8b unchanged.
-57 host tests and four source-only dry runs passed. Four fresh GPU cases completed
-sequentially; valid frozen scientific outcome: FAIL.
-Both uniform controls pass; constant and projected depth-3 runs fail own pressure
-and comparative rate/residual/pressure budgets. No rerun or tuning.
-Eight actual build sidecars audited; one projected final macro snapshot, no
-population dump or time series. Complete original archive with 66 intended members.
-Archive SHA256: 8ff04b86f58d5e863394fedf8a87648879cdf7277b6d1bb326208858322d3e04
-Snapshot SHA256: 4e8b8af02ba54db48dc2ea36f24c16fc6004f77e4c8f143fca809ec7fbaa7884
-Archive excludes private task history, process listings and unrelated artifacts.
-This evidence-only commit changes no source branch or source file.

validation-evidence/2026-10-19/postg-70c83b7/TRANSPORT_MANIFEST.json

@@ -1,19 +0,0 @@
-{
-  "archive": "CelerisLab_postg_70c83b7_20261019.zip",
-  "bytes": 575798,
-  "sha256": "0e18ae96a1f3e87f0482385b8c683d9e8a349de39c4155dd7bcedc1686200cf6",
-  "candidate": "70c83b7233888cb7287c8d1905563590c9e72ef4",
-  "production": "a135252ae78b47b57d7e77d19001700b3bedac8b",
-  "source_branch": "tron/shear-probe-guards-caa573f",
-  "diagnostic": "postg_shear_n128",
-  "initialization_id": "postg_first_gradient_v1",
-  "qualification_eligible": false,
-  "initializer_sha256": "9c909fa013c092490ee21532e3125b2a78a4c5102c7a1bdc0e76986d3f0ef903",
-  "probe_module_sha256": "e2e6490d281cc275f448dc6d6ea7b9b4407cc74a51e9256b86c08c8626b89b76",
-  "all_trace_complete": true,
-  "total_trace_rows": 774,
-  "independently_verified_before_cleanup": true,
-  "matrix_assessor_run": false,
-  "route": "Existing authorized Gitea validation evidence branch",
-  "payload_scope": "Complete scientific ZIP, transport README and manifest only"
-}

validation-evidence/2026-10-19/postg-70c83b7/TRANSPORT_README.txt

@@ -1,10 +0,0 @@
-POST-G startup counterfactual: exact 70c83b7233888cb7287c8d1905563590c9e72ef4; production a135252ae78b47b57d7e77d19001700b3bedac8b and equilibrium oracle unchanged.
-76 host tests and three exact dry runs pass; three fresh serial cases, no matrix assessor.
-postg_shear_n128; initialization_id=postg_first_gradient_v1; qualification_eligible=false.
-All traces complete: True; total trace rows: 774.
-15 main rows, 24 probes, five source/config/PTX sidecars independently verified before cleanup.
-Equilibrium source1f64f7e cases are historical controls; per-time metrics compared without scalar-equality assertions.
-Finite projected scalar failure retained. Startup compatibility diagnostic only, not a production fix or long-time qualification.
-No extra cases, tuning, reruns, snapshots, field dumps or checkpoints. Fine substeps unresolved.
-Archive SHA256: 0e18ae96a1f3e87f0482385b8c683d9e8a349de39c4155dd7bcedc1686200cf6
-Only intended scientific files; no task history or process listings.

validation-evidence/2026-10-19/scaled-n256-92b8afe/TRANSPORT_MANIFEST.json

@@ -1,30 +0,0 @@
-{
-  "archive": "CelerisLab_scaled_n256_92b8afe_20261019.zip",
-  "bytes": 4047594,
-  "sha256": "e1a970d0359c8a5f2df6a66bad4c8b8ab64e01fac4f7660ac8e604046f89abcb",
-  "candidate": "92b8afeeed66c8ac05b37e90d0a592b2b3d0ce01",
-  "production": "a135252ae78b47b57d7e77d19001700b3bedac8b",
-  "source_fingerprint": "a5dbfd804befce868067d79a23e5fd47dce7f505b3f9b1bb2145fb57cb5f2178",
-  "capture_helper_sha256": "3dbaa6547cb0a4cb1541054f3b64ad8b6e18cc70527ac6166e56b944e9bd464a",
-  "route": "Authorized existing Gitea evidence branch fallback using documented current-session blob transport failures; no Drive submission for this archive",
-  "drive_failure": {
-    "status": "known_session_blob_transport_failure",
-    "approval_denial": false,
-    "this_archive_upload_attempted": false,
-    "basis": [
-      {
-        "archive": "CelerisLab_projected_pairs_TG_2cf9853_20261018.zip",
-        "status": "confirmed blob ingress transport failure",
-        "endpoint": "sdmntprcentralus.oaiusercontent.com",
-        "elapsed_ms": 216449,
-        "azure_client_request_id": "2a1827d5-986d-4999-a920-9ea1bd63fba7"
-      },
-      {
-        "archive": "CelerisLab_TG_2cf9853_REVIEW_SUBSET_20261018.zip",
-        "status": "MCP upload timeout,no ID returned,two folder lookups found no matches"
-      }
-    ],
-    "current_archive_sha256": "e1a970d0359c8a5f2df6a66bad4c8b8ab64e01fac4f7660ac8e604046f89abcb"
-  },
-  "scope": "Complete original ZIP, no fragments; no source integration"
-}

validation-evidence/2026-10-19/scaled-n256-92b8afe/TRANSPORT_README.txt

@@ -1,10 +0,0 @@
-Exact92b8afe bounded scaled_n256 same-placement resolution diagnostic / unchangeda135252 production.
-22 host tests and four dry guards passed;four fresh GPU cases+assessment completed41.122633seconds.
-4714397696 active updates;constant/projected/aggregate frozen gates allPASS.
-Uniform256 fresh/historical main+early bridge and recorded runtime identical.
-AMR velocity/pressure/energy raw errors lower at all4postinitial times;mass errors higher.
-Uniform512 controls not uniformly better;all6relative budgets floor-dominated;no convergence certificate.
-Six actual build sidecars/source/config/PTX audits pass.Original pinned2cf references included separately.
-Complete intact ZIP with117manifest payloads;no source push/default change/extra case/tuning.
-Known session Drive blob transport failures used as authorized existing Gitea fallback;this archive not submitted to Drive.
-Archive SHA256: e1a970d0359c8a5f2df6a66bad4c8b8ab64e01fac4f7660ac8e604046f89abcb

validation-evidence/2026-10-19/scaled-shear-9748ef9/TRANSPORT_MANIFEST.json

@@ -1,33 +0,0 @@
-{
-  "archive": "CelerisLab_scaled_shear_9748ef9_20261019.zip",
-  "bytes": 4084568,
-  "sha256": "81db3d724a7de1d08202bf693d9ef94ff1a8ade086614b843868657d9de54dda",
-  "candidate": "9748ef91ef3bfd366756ef0c8a056df8faa75679",
-  "review_base": "eec4677db1308e2a9ce4e5f195c994356c11de13",
-  "flow": "shear_wave",
-  "shear_wave_sha256": "81d5c8ee60864372887cddf9239580c82fb6750d956038f1e3ee9de61aa4e877",
-  "production": "a135252ae78b47b57d7e77d19001700b3bedac8b",
-  "source_fingerprint": "a5dbfd804befce868067d79a23e5fd47dce7f505b3f9b1bb2145fb57cb5f2178",
-  "capture_helper_sha256": "3dbaa6547cb0a4cb1541054f3b64ad8b6e18cc70527ac6166e56b944e9bd464a",
-  "route": "Authorized existing Gitea evidence branch fallback using documented current-session blob transport failures; no Drive submission for this archive",
-  "drive_failure": {
-    "status": "known_session_blob_transport_failure",
-    "approval_denial": false,
-    "this_archive_upload_attempted": false,
-    "basis": [
-      {
-        "archive": "CelerisLab_projected_pairs_TG_2cf9853_20261018.zip",
-        "status": "confirmed blob ingress transport failure",
-        "endpoint": "sdmntprcentralus.oaiusercontent.com",
-        "elapsed_ms": 216449,
-        "azure_client_request_id": "2a1827d5-986d-4999-a920-9ea1bd63fba7"
-      },
-      {
-        "archive": "CelerisLab_TG_2cf9853_REVIEW_SUBSET_20261018.zip",
-        "status": "MCP upload timeout,no ID returned,two folder lookups found no matches"
-      }
-    ],
-    "current_archive_sha256": "81db3d724a7de1d08202bf693d9ef94ff1a8ade086614b843868657d9de54dda"
-  },
-  "scope": "Complete original ZIP, no fragments; no source integration"
-}

validation-evidence/2026-10-19/scaled-shear-9748ef9/TRANSPORT_README.txt

@@ -1,11 +0,0 @@
-Exact9748ef9 scaled oblique(2,1) shear-wave diagnostic;production unchanged a135252.
-51 host tests/four source-only preflights passed;four fixed fresh cases and assessment completed 19.712796s.
-4714397696 active updates;contract_valid=True;scientificstatus=FAIL;passed=False.
-Independent uniform256 bridge:complete scalar rows/build sidecars/runtime exact to retained de5b0cc.
-Both uniform controls pass own screens;projected256 own/budget/controlled PASS.
-Constant256 pressure own screen and rate/residual/pressure budgets FAIL;finite exit1 retained.
-Signed rate bias,excess over BOTH controls,raw/scaled pressure,full modal/phase/mass and interval data retained.
-All six actual sidecars independently audited;no tuning,retry,extra cases,source publication or integration.
-Two resolutions/one phase and placement give descriptive trends,not an order or localization proof.
-Known session Drive blob transport failure used for authorized Gitea fallback;this archive not submitted to Drive.
-Complete original ZIP;archive SHA256:81db3d724a7de1d08202bf693d9ef94ff1a8ade086614b843868657d9de54dda

validation-evidence/2026-10-19/shear-wave-de5b0cc/TRANSPORT_MANIFEST.json

@@ -1,33 +0,0 @@
-{
-  "archive": "CelerisLab_shear_wave_de5b0cc_20261019.zip",
-  "bytes": 4031180,
-  "sha256": "a8924472f25c61dc107f344a80cd8d07baa35772542bf76357475d0c3346cffa",
-  "candidate": "de5b0cc080794d0ce44d37f845aa8e8dbf8c2016",
-  "review_base": "eec4677db1308e2a9ce4e5f195c994356c11de13",
-  "flow": "shear_wave",
-  "shear_wave_sha256": "81d5c8ee60864372887cddf9239580c82fb6750d956038f1e3ee9de61aa4e877",
-  "production": "a135252ae78b47b57d7e77d19001700b3bedac8b",
-  "source_fingerprint": "a5dbfd804befce868067d79a23e5fd47dce7f505b3f9b1bb2145fb57cb5f2178",
-  "capture_helper_sha256": "3dbaa6547cb0a4cb1541054f3b64ad8b6e18cc70527ac6166e56b944e9bd464a",
-  "route": "Authorized existing Gitea evidence branch fallback using documented current-session blob transport failures; no Drive submission for this archive",
-  "drive_failure": {
-    "status": "known_session_blob_transport_failure",
-    "approval_denial": false,
-    "this_archive_upload_attempted": false,
-    "basis": [
-      {
-        "archive": "CelerisLab_projected_pairs_TG_2cf9853_20261018.zip",
-        "status": "confirmed blob ingress transport failure",
-        "endpoint": "sdmntprcentralus.oaiusercontent.com",
-        "elapsed_ms": 216449,
-        "azure_client_request_id": "2a1827d5-986d-4999-a920-9ea1bd63fba7"
-      },
-      {
-        "archive": "CelerisLab_TG_2cf9853_REVIEW_SUBSET_20261018.zip",
-        "status": "MCP upload timeout,no ID returned,two folder lookups found no matches"
-      }
-    ],
-    "current_archive_sha256": "a8924472f25c61dc107f344a80cd8d07baa35772542bf76357475d0c3346cffa"
-  },
-  "scope": "Complete original ZIP, no fragments; no source integration"
-}

validation-evidence/2026-10-19/shear-wave-de5b0cc/TRANSPORT_README.txt

@@ -1,11 +0,0 @@
-Exactde5b0cc first bounded oblique(2,1) shear-wave diagnostic / unchangeda135252 production.
-43 host checks and four source-only preflights passed;four fresh physical cases+assessment completed12.081603seconds.
-589299712 active updates;valid finite data,contract_validtrue,scientificassessmentFAIL.
-Both uniform controls own screensPASS;constant pressure screenFAIL(exit1 retained).
-Projected own screensPASS,but rate/residual controlled budgetsFAIL;no controlled-pass.
-All fits available;modal/phase,fit/interval rates,residuals,raw/scaled spuriouspressure andmass retained.
-Pressure usescontinuumA_exact^2/4,notTG pressure semantics;coefficient-one|kh|² screens diagnostic only.
-Six actual sidecars/source/config/PTX audits pass;no tuning/retry/source publication/merge.
-Complete intact ZIP with114manifest payloads;older92b8afe object/bundle/archive preserved.
-Known session Drive blob transport failures used as authorized existing Gitea fallback;this archive not submitted to Drive.
-Archive SHA256: a8924472f25c61dc107f344a80cd8d07baa35772542bf76357475d0c3346cffa

validation-evidence/2026-10-19/signed-probes-1f64f7e/TRANSPORT_MANIFEST.json

@@ -1,15 +0,0 @@
-{
-  "archive": "CelerisLab_signed_probes_1f64f7e_20261019.zip",
-  "bytes": 777103,
-  "sha256": "3cc338af0bad8e44ff5bd89232f2981e513797875b58d8aa3ed3ae6d2ce7f97e",
-  "candidate": "1f64f7eb11c14ae1106136de941b74a02142382e",
-  "production": "a135252ae78b47b57d7e77d19001700b3bedac8b",
-  "source_branch": "tron/shear-probe-guards-caa573f",
-  "probe_module_sha256": "e2e6490d281cc275f448dc6d6ea7b9b4407cc74a51e9256b86c08c8626b89b76",
-  "scalar_rows_and_checked_runtime_exact": true,
-  "mechanism_diagnostic_usable": true,
-  "independently_verified_before_cleanup": true,
-  "matrix_assessor_run": false,
-  "route": "Existing authorized Gitea validation evidence branch",
-  "payload_scope": "Complete scientific ZIP, transport README and manifest only"
-}

validation-evidence/2026-10-19/signed-probes-1f64f7e/TRANSPORT_README.txt

@@ -1,9 +0,0 @@
-Signed shear probes: exact 1f64f7eb11c14ae1106136de941b74a02142382e; production a135252ae78b47b57d7e77d19001700b3bedac8b unchanged.
-68 host tests and four exact dry runs pass; four fresh serial cases; no matrix assessor.
-20 main rows match audited previous rows. All four raw traces are retained when valid, with 258 root times and 24 probes.
-Seven actual source/config/PTX sidecars independently verified before module load and compiler cleanup.
-Scalar consistency: True; mechanism usable: True.
-Nested projected finite scalar screen failure preserved. No algorithm changes, reruns, snapshots, populations or checkpoints.
-Root-sync samples do not resolve fine substeps; actual centers and displacements retained.
-Archive SHA256: 3cc338af0bad8e44ff5bd89232f2981e513797875b58d8aa3ed3ae6d2ce7f97e
-Only intended scientific files; no task history or process listings; no source-branch changes in this evidence commit.

validation-evidence/2026-10-19/twin-shear-02bde0f/TRANSPORT_MANIFEST.json

@@ -1,14 +0,0 @@
-{
-  "archive": "CelerisLab_twin_shear_02bde0f_20261019.zip",
-  "bytes": 127830,
-  "sha256": "a93ec5a45868cc0c550588a0eacc6702f442d4b7675cff82608694bcf4117451",
-  "candidate": "02bde0f75187786a2ce10abc9a863f750b6343a8",
-  "production": "a135252ae78b47b57d7e77d19001700b3bedac8b",
-  "diagnostic": "twin_shear_n128",
-  "scientific_status": "FAIL",
-  "contract_valid": true,
-  "audit_order_limitation": "Sidecars and PTX hashes were captured/verified before cleanup. Independent source/config reconstruction occurred after cleanup; the requested independent pre-cleanup source audit was not performed. No rerun or source fix.",
-  "independent_pre_cleanup_source_audit_complete": false,
-  "route": "Existing authorized Gitea validation evidence branch",
-  "payload_scope": "Complete scientific ZIP, transport README and manifest only"
-}

validation-evidence/2026-10-19/twin-shear-02bde0f/TRANSPORT_README.txt

@@ -1,9 +0,0 @@
-Depth-2 twin shear validation: exact 02bde0f75187786a2ce10abc9a863f750b6343a8; production a135252ae78b47b57d7e77d19001700b3bedac8b unchanged.
-61 host tests and four dry runs pass; four fresh serial cases; scientific FAIL, contract valid.
-Controls pass. Constant fails own pressure and comparative rate/residual/pressure budgets.
-Projected passes own screens and pressure budget, but fails comparative rate/residual budgets.
-Six actual sidecars independently reconstructed after scratch cleanup; requested independent pre-cleanup audit was not performed.
-No GPU rerun, tuning, snapshots, early traces, checkpoints or population dumps.
-Audit-order limitation: Sidecars and PTX hashes were captured/verified before cleanup. Independent source/config reconstruction occurred after cleanup; the requested independent pre-cleanup source audit was not performed. No rerun or source fix.
-Archive SHA256: a93ec5a45868cc0c550588a0eacc6702f442d4b7675cff82608694bcf4117451
-Only intended scientific files; no task history or process listings; no source-branch changes.

validation-evidence/2026-10-19/wide-x-be8e6d6/TRANSPORT_MANIFEST.json

@@ -1,16 +0,0 @@
-{
-  "archive": "CelerisLab_wide_x_be8e6d6_20261019.zip",
-  "bytes": 260873,
-  "sha256": "ff50714f38df9c2ce37ce8e11bd88751477133a62b9fadd5da54a3be47705d1e",
-  "candidate": "be8e6d691d6d18baa8403f2d942b5aa382456ac1",
-  "production": "a135252ae78b47b57d7e77d19001700b3bedac8b",
-  "source_branch": "tron/shear-probe-guards-caa573f",
-  "preset_sha256": "13d16ba355117e2d074edccd9dc5d694c2fc13c673a0abdfca6401f6ed917733",
-  "probe_module_sha256": "e2e6490d281cc275f448dc6d6ea7b9b4407cc74a51e9256b86c08c8626b89b76",
-  "runner_screening_pass": false,
-  "mechanism_diagnostic_usable": true,
-  "independently_verified_before_cleanup": true,
-  "matrix_assessor_run": false,
-  "route": "Existing authorized Gitea validation evidence branch",
-  "payload_scope": "Complete scientific ZIP, transport README and manifest only"
-}

validation-evidence/2026-10-19/wide-x-be8e6d6/TRANSPORT_README.txt

@@ -1,9 +0,0 @@
-Wide-x projected three-level shear: exact be8e6d691d6d18baa8403f2d942b5aa382456ac1; production a135252ae78b47b57d7e77d19001700b3bedac8b unchanged.
-72 host tests and one exact dry run pass; one fresh GPU case, no controls or matrix assessor.
-Runner screen pass: False; mechanism usable: True.
-Five main rows, 258 root trace times, unchanged 24 targets and three independently verified pre-cleanup build sidecars.
-Twenty probe locations match original nested, four horizontal probes shift; changed locations excluded from direct comparisons.
-None crosses the new x=28 face. No qualification pass, reflection proof or pure gap-effect claim. Fine substeps unresolved.
-No algorithm changes, reruns, snapshots, field dumps or checkpoints.
-Archive SHA256: ff50714f38df9c2ce37ce8e11bd88751477133a62b9fadd5da54a3be47705d1e
-Only intended scientific files; no task history or process listings.