fix: normalize closed-form Smagorinsky strain magnitude

docs/development/les_normalization_candidate.md

@@ -0,0 +1,70 @@
+# Minimal Smagorinsky normalization integration candidate
+
+This local candidate changes only the two closed-form D2Q9/D3Q19 coefficients
+from 18 to 18 sqrt(2), plus their convention comments. The intended convention
+is |S| = sqrt(2 S:S), with self-consistent effective tau. No Cs default,
+iterative formula/cap/iteration count, collision dispatch, AMR guard, inlet,
+channel-parity rule, or unrelated source file changes.
+
+The resulting turbulence_smag.cuh SHA256 is
+`a3db46c2e7d27530b2d1436e65cdbed0b72cc7e047bfbeef2a640877271b51aa`,
+exactly the independently reviewed temporary correction used in the paired
+scalar and end-to-end flow experiments. Its uncorrected baseline remains at
+validation checkpoint `9805383f9c50d867e8555471baf5dbda8333a652`.
+
+## Evidence and limits
+
+The separately audited scalar-helper GPU diagnostic on the cd3 source campaign
+covered 48 cases per variant. All 32 paired iterative results were bit-identical;
+maximum patched closed-form error was approximately 1.19e-7, versus 0.06454 for
+the baseline against the same standard convention. This is scalar evidence,
+not full-collision or turbulence qualification.
+
+The independently reviewed wall-bounded, x-periodic SRT/shifted-FP32/double-buffer
+shear experiment distinguished baseline from corrected source under identical
+predeclared criteria. Baseline Cs=1 SGS decrement errors at the last two
+checkpoints were approximately 28.50% and 28.05%; corrected errors were 0.0628%
+and 0.00612%. Corrected maximum Cs=1 profile error was approximately 0.11344%,
+and the Cs=0 observations were identical between variants. Cs=1 is an amplified
+normalization diagnostic, not a recommended physical coefficient. These data
+qualify this bounded normalization comparison, not general turbulence accuracy.
+
+The current direct-header host regression uses the existing independent
+Hermite tensor construction and quadratic bisection oracle. It covers 120
+parameter subcases across D2/D3, Cs=0/.16, rho=.7/1/1.3, tau0=.56/.8,
+equilibrium, both signs of shear and trace-free extension, including a 3D axis.
+It also checks converged iterative agreement, Cs=0 omega guard bounds, and
+explicitly proves that removing sqrt(2) in temporary headers fails the oracle.
+No stored candidate header or full solver fixture is added.
+
+MRT full-trace/bulk coupling, forcing/Guo correction, other streaming/storage
+paths, three-dimensional turbulent flows, and AMR LES remain uncertified.
+Full-stress closed form and deviatoric/capped iteration intentionally need not
+agree on isotropic or cap-active stresses. Existing guards remain unchanged.
+
+## Run and retain provenance
+
+From this candidate checkout:
+
+    PYTHONPATH=src python tests/unit/test_smagorinsky_normalization.py -v
+    PYTHONPATH=src python tests/unit/test_les_flow_runner.py -v
+
+The flow runner already supports `--variant corrected` against the exact
+reviewed helper hash. Its source-pin tests now exercise that current variant;
+they still verify that the archived baseline variant rejects the corrected
+source and that unrelated source tampering is rejected.
+
+Historical Re100, Jet, matched-DFG and paired-scalar manifests/runners are not
+repinned or weakened. Their baseline-source guards are expected to reject this
+changed production tree. Run those archived source-specific checks on the clean
+9805383 checkpoint; their old GPU evidence does not become evidence for this
+candidate. The new direct-current-header test is the regression for corrected
+production. Do not describe the historical full suite as passing on this tree.
+
+Before publication or main integration, obtain final independent diff review
+and rerun the applicable scalar/flow GPU commands on the exact final candidate
+commit after the executor reconnects. Retain new checkout/import/source-hash
+receipts and compare against the frozen baseline using separate processes.
+A new commit receipt is required even though its corrected header matches the
+previously tested temporary correction. No GPU rerun, publication, or main
+merge is claimed by this candidate preparation.

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.

src/CelerisLab/lbm/kernels/operators/turbulence_smag.cuh

@@ -5,7 +5,9 @@
 //   nu_t = (C_s * Delta)^2 * |S|,  Delta = 1 (lattice unit)
 //   omega_eff = 1 / (3*(nu + nu_t) + 0.5)
 //
-// |S| is estimated from non-equilibrium second-order moments using tau0.
+// |S| = sqrt(2 S_ij S_ij), with Delta = 1 in lattice units.
+// The stress estimate uses self-consistent tau_eff; tau0 is molecular.
+// Closed form uses full stress. Iteration uses deviatoric stress and a cap.
 // ============================================================================
 
 #ifndef CELERIS_OPERATORS_TURBULENCE_SMAG_CUH
@@ -65,12 +67,12 @@ __device__ __forceinline__ float compute_omega_smag(const float* __restrict__ f,
 
 #if LES_CLOSED_FORM
     // Closed-form Smagorinsky (no iteration):
-    //   ω = 2 / (τ₀ + √(τ₀² + 18·Cs²·√Q / ρ))
+    //   ω = 2 / (τ₀ + √(τ₀² + 18·√2·Cs²·√Q / ρ))
     // where Q = Πneq_ij · Πneq_ij (Frobenius norm squared)
     const float Q = pixx*pixx + piyy*piyy + 2.0f*pixy*pixy;
     const float sqrtQ = sqrtf(fmaxf(Q, 0.0f));
     const float smag_const_sq = LES_CS * LES_CS;
-    const float discriminant = tau0*tau0 + 18.0f * smag_const_sq * sqrtQ / rho_safe;
+    const float discriminant = tau0*tau0 + 18.0f * sqrtf(2.0f) * smag_const_sq * sqrtQ / rho_safe;
     const float tau_eff = 0.5f * (tau0 + sqrtf(fmaxf(discriminant, tau0*tau0)));
     return clamp_omega(1.0f / fmaxf(tau_eff, 0.500001f));
 #else
@@ -140,7 +142,7 @@ __device__ __forceinline__ float compute_omega_smag(const float* __restrict__ f,
                   + 2.0f*(pixy*pixy + pixz*pixz + piyz*piyz);
     const float sqrtQ = sqrtf(fmaxf(Q, 0.0f));
     const float smag_const_sq = LES_CS * LES_CS;
-    const float discriminant = tau0*tau0 + 18.0f * smag_const_sq * sqrtQ / rho_safe;
+    const float discriminant = tau0*tau0 + 18.0f * sqrtf(2.0f) * smag_const_sq * sqrtQ / rho_safe;
     const float tau_eff = 0.5f * (tau0 + sqrtf(fmaxf(discriminant, tau0*tau0)));
     return clamp_omega(1.0f / fmaxf(tau_eff, 0.500001f));
 #else

tests/unit/test_les_flow_runner.py

@@ -41,9 +41,9 @@ class GuardTests(unittest.TestCase):
         with self.assertRaisesRegex(RuntimeError, "velocity/profile"):
             decode_macros(invalid, w, cx, cy)
 
-    def test_baseline_pins(self):
+    def test_current_corrected_pins(self):
         self.assertEqual(
-            source_guard(ROOT, "baseline")["base_commit"],
+            source_guard(ROOT, "corrected")["base_commit"],
             "cd3a657f9d3833e812c3cca173525f165b48710a",
         )
 
@@ -55,20 +55,7 @@ class GuardTests(unittest.TestCase):
                 dest = root / name
                 dest.parent.mkdir(parents=True, exist_ok=True)
                 shutil.copyfile(ROOT / name, dest)
-            # Rebuild the reviewed candidate from actual pinned headers, not fixtures.
-            candidate = root / "header_candidate"
-            subprocess.run(
-                [
-                    sys.executable,
-                    str(HERE / "les/prepare.py"),
-                    "--repo",
-                    str(ROOT),
-                    "--output-dir",
-                    str(candidate),
-                ],
-                check=True,
-            )
-            shutil.copyfile(candidate / "patched" / HEADER, root / HEADER)
+            # Current production is the corrected variant; archived baseline pins stay frozen.
             with patch(
                 "run_uniform_les_flow.subprocess.check_output",
                 return_value="isolated-fixture\n",

tests/unit/test_smagorinsky_normalization.py

@@ -0,0 +1,99 @@
+"""Direct-current-header regression; historical candidate manifests stay frozen."""
+
+import importlib.util
+from pathlib import Path
+import shutil
+import sys
+from tempfile import TemporaryDirectory
+import unittest
+
+ROOT = Path(__file__).resolve().parents[2]
+HELPERS = ROOT / "tests/validation/les"
+sys.path.insert(0, str(HELPERS))
+spec = importlib.util.spec_from_file_location(
+    "smagorinsky_oracle", HELPERS / "test_candidate.py"
+)
+oracle = importlib.util.module_from_spec(spec)
+spec.loader.exec_module(oracle)
+HEADER = Path("src/CelerisLab/lbm/kernels/operators/turbulence_smag.cuh")
+DESCRIPTORS = Path("src/CelerisLab/lbm/kernels/core/descriptors.cuh")
+
+
+class SmagorinskyNormalization(unittest.TestCase):
+    def test_current_header_matches_independent_tensor_oracle(self):
+        with TemporaryDirectory() as directory:
+            build_dir = Path(directory)
+            for dim in (2, 3):
+                for cs in (0.0, 0.16):
+                    # Compile directly against this checkout, not saved candidate headers.
+                    closed = oracle.build(
+                        ROOT.parent, ROOT.name, dim, cs, 1, 3, build_dir
+                    )
+                    converged = oracle.build(
+                        ROOT.parent, ROOT.name, dim, cs, 0, 200, build_dir
+                    )
+                    for rho in (0.7, 1.0, 1.3):
+                        for tau0 in (0.56, 0.8):
+                            for kind, magnitude in (
+                                ("equilibrium", 0.0),
+                                ("shear", -0.02),
+                                ("shear", 0.02),
+                                ("extension", -0.02),
+                                ("extension", 0.02),
+                            ):
+                                stress = oracle.tensor(
+                                    dim, kind, magnitude * rho, 0, dim - 1
+                                )
+                                f, eq = oracle.state(dim, rho, stress)
+                                expected = 1 / oracle.standard_tau(
+                                    tau0, cs, oracle.norm(stress), rho
+                                )
+                                with self.subTest(
+                                    dim=dim,
+                                    cs=cs,
+                                    rho=rho,
+                                    tau=tau0,
+                                    kind=kind,
+                                    sign=magnitude,
+                                ):
+                                    self.assertAlmostEqual(
+                                        closed(f, eq, rho, tau0), expected, delta=3e-6
+                                    )
+                                    self.assertAlmostEqual(
+                                        converged(f, eq, rho, tau0),
+                                        expected,
+                                        delta=3e-6,
+                                    )
+                    if cs == 0:
+                        f, eq = oracle.state(
+                            dim, 1.0, oracle.tensor(dim, "equilibrium", 0.0)
+                        )
+                        self.assertAlmostEqual(
+                            closed(f, eq, 1.0, 0.50001), 1.99, delta=3e-6
+                        )
+                        self.assertAlmostEqual(
+                            closed(f, eq, 1.0, 200.0), 0.01, delta=3e-6
+                        )
+
+    def test_removing_sqrt_two_is_detected(self):
+        with TemporaryDirectory() as directory:
+            root = Path(directory)
+            for relative in (HEADER, DESCRIPTORS):
+                target = root / "old_convention" / relative
+                target.parent.mkdir(parents=True, exist_ok=True)
+                shutil.copyfile(ROOT / relative, target)
+            target = root / "old_convention" / HEADER
+            text = target.read_text()
+            factor = "18.0f * sqrtf(2.0f) * smag_const_sq"
+            self.assertEqual(text.count(factor), 2)
+            target.write_text(text.replace(factor, "18.0f * smag_const_sq"))
+            for dim in (2, 3):
+                old = oracle.build(root, "old_convention", dim, 0.16, 1, 3, root)
+                stress = oracle.tensor(dim, "shear", 0.02)
+                f, eq = oracle.state(dim, 1.0, stress)
+                expected = 1 / oracle.standard_tau(0.8, 0.16, oracle.norm(stress), 1.0)
+                self.assertGreater(abs(old(f, eq, 1.0, 0.8) - expected), 1e-3)
+
+
+if __name__ == "__main__":
+    unittest.main()

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())