test: prepare isolated uniform full9 DFG pilot

test: pin isolated full9 bodyless inlet comparison
experiment: isolate full-state regularized west velocity inlet
2026-10-18 09:41:10 -07:00 · 2026-10-18 09:18:47 -07:00 · 2026-10-18 09:16:25 -07:00 · 2026-10-18 08:48:34 -07:00 · 2026-10-18 08:01:01 -07:00
70 changed files with 1212 additions and 1065 deletions
@@ -0,0 +1,72 @@
+# One bounded bodyless SRT inlet control
+
+Preparation only; review precedes any GPU admission. This test-only opt-in is based on
+8e378aa047bb35ae4ec46037eff7256bd2f074e7. Historical first-health evidence and its source
+manifest are untouched. The control calls the same pinned D80 config factory and uses
+unchanged production `Simulation.initialize()` / `run(1)`; `--without-cylinder` changes
+only the single cylinder object list to empty. No profile, wall/source plane, domain,
+collision, relaxation, speed, representation, step cap, health limit or field observation
+is adjusted. SRT tau=.524 and the existing inlet/outlet remain as in the failed run.
+
+Production already supports zero objects through `ensure_packed_buffers`. The absent
+body has no force observable: the control never calls `read_force(0)`, records `force:null`
+and `force_observation:not_applicable_no_body`, and does not invent a zero force. Physical
+population/macro/Mach/density checks remain intact. Existing per-step diagnostics, first
+health crossing, immediately preceding/current raw+decoded state capture, 128 MiB budget,
+external watchdog and maximum 320 steps remain unchanged. No extra baseline run is needed.
+
+Removing the cylinder necessarily turns its former solid cells into fluid. Those cells
+receive the same production parabolic fluid initializer; shared fluid and boundary-ghost
+cells retain the original initializer and configuration. This is not a transplant of the
+baseline's solid-cell state into new fluid. Removing the body also removes its cut links
+and specializes the existing kernel for zero objects, as ordinary Simulation already does.
+The spatial `body_near` category is retained only as the **former-cylinder neighborhood**
+for comparing locations. It does not claim an actual body is present; body-solid flag
+counts should be zero in the control.
+
+## Explicit identity and source checks
+
+The unchanged manifest still pins numerical source 9805383, as used by the baseline8e
+harness. The new test-only HEAD does not pretend to be that historical run. Preflight,
+READY and diagnostic/result records include the control label, original baseline harness
+commit, new diagnostic checkout revision/dirty status, selected numerical checkout
+revision/dirty status, and new diagnostic file hash. Production/helper bytes are verified
+against the original manifest before either case. A later development checkout with
+changed numerical files is rejected; the old pin is not silently accepted or regenerated.
+The default cylinder case remains available for compatibility, but this requested control
+uses only `--without-cylinder` and a distinct new output directory.
+
+## Interpretation before seeing outcomes
+
+- Similar early inlet-region failure without a cylinder: cylinder presence is not
+  necessary for this observed short-time instability under these settings. This supports
+  investigating inlet/collision/kinetic-state dynamics; it does not prove a specific
+  boundary defect or exclude other shared boundaries/initialization effects.
+- No health violation through 320: removing the body changes the observed onset, consistent
+  with a body-generated transient or altered amplification interacting with the inlet.
+  This does not prove the cylinder is erroneous, establish inlet stability beyond320,
+  or certify SRT generally.
+- Different failure location/time: geometry affects the transient; classify the preserved
+  incoming distributions and moments before assigning any mechanism.
+
+The baseline failed at196 on finite Mach>.2, not nonfinite state. A control can likewise
+stop on a finite threshold crossing. Do not describe either as a NaN blow-up unless the
+separate diagnostic flags establish that.
+
+CPU-only checks:
+
+```sh
+python tests/validation/uniform_srt_diagnostic/test_diagnostic.py
+python tests/validation/uniform_srt_diagnostic/diagnose_uniform_srt.py --without-cylinder --output /tmp/new-bodyless-preflight
+```
+
+After review and root admission, from the explicitly recorded test checkout:
+
+```sh
+CUDA_VISIBLE_DEVICES=<admitted-device> timeout --signal=TERM --kill-after=30s 240s python tests/validation/uniform_srt_diagnostic/diagnose_uniform_srt.py --without-cylinder --execute --gpu-admitted --wall-seconds 180 --output output/new-srt-bodyless-control
+```
+
+This patch performs no GPU run or remote push. Original runner gates/results and
+production files are unchanged. The extra tests verify removal-only selection without
+mutating inputs, reject unexpected object sets, verify absence of force readback, and
+retain physical health failures when force is unavailable.
@@ -0,0 +1,31 @@
+# Fixed-window inlet history (test-only)
+
+Opt in with `--record-inlet-history`, together with `--without-cylinder` for the requested control. Default execution still retains only the original first-health pair. This followup is based on bodyless diagnostic `66a27410504fef477808d6079ce79ca1ae6b903c`; the numerical source manifest remains unchanged at `9805383f9c50d867e8555471baf5dbda8333a652`. Actual diagnostic/numerical checkout revisions and script SHA256 are recorded separately.
+
+The requested observation window is **completed steps 0 through 196 inclusive**. Recording stops after196, but evolution continues under the original first-health/320-step/wall-time stop behavior. An earlier failure preserves the recorded prefix, including its failing observation. `complete_for_requested_window` means all197 requested frames exist; it never means complete history past196. `diagnostic_terminal_step` records the terminal observed step separately.
+
+`inlet_history.npz` contains:
+- `raw_shifted[time,q,y,x]`: unchanged FP32 bits, all9q, all330 rows, x0..3, copied from already-existing active-buffer raw snapshots.
+- Static uint16 `flags[y,x]`, global x/y indices, contiguous int64 `steps`.
+- `time_s=steps*dt` and `tstar=steps*mean_speed/diameter`, plus requested range and diagnostic terminal step.
+- Step zero is the initialized state; subsequent states are completed postcollision active-buffer observations. Ghost/solid flags remain distinct from physical-fluid health checks.
+
+Full configuration, physical parameters and source identity remain in `preflight.json`; `diagnostics.json` adds the history SHA256, size, window and completeness receipt. No additional full-field copies or solver calls are introduced. The new history copies only x0..3 from the baseline's existing raw snapshot. Baseline two-state evidence and health gates remain intact.
+
+The full requested raw payload is9,361,440 bytes (8.928MiB). Flags, time arrays, coordinates and NPZ overhead keep it below12MiB. Initialization checks the fixed-window allocation against that bound with64KiB overhead reserve, and saving checks actual artifact size. This fits inside the existing128MiB total evidence cap with the original pair. The12MiB limit is an artifact-size bound, not peak RAM: the retained strip list and stacked output briefly coexist. There is no variable compression/overflow policy.
+
+CPU checks:
+
+```sh
+python tests/validation/uniform_srt_diagnostic/test_diagnostic.py
+python tests/validation/uniform_srt_diagnostic/test_history.py
+python tests/validation/uniform_srt_diagnostic/diagnose_uniform_srt.py --without-cylinder --record-inlet-history --output /tmp/new-inlet-history-preflight
+```
+
+After independent review and root GPU admission, from this exact test checkout, with a new output directory:
+
+```sh
+CUDA_VISIBLE_DEVICES=<admitted-device> timeout --signal=TERM --kill-after=30s 240s python tests/validation/uniform_srt_diagnostic/diagnose_uniform_srt.py --without-cylinder --record-inlet-history --execute --gpu-admitted --wall-seconds 180 --output output/new-srt-inlet-history
+```
+
+The homogeneous linear surrogate is a separate analysis artifact. This history will allow comparison with actual startup, including initialization mismatch and wall-junction propagation; neither the recorder nor the surrogate changes a boundary or establishes a corrective scheme. No GPU run is included in this commit.
@@ -32,6 +32,7 @@ INLET_SCHEME_MAP = {
    "channel_stabilized": 1,
    "equilibrium": 2,
    "regularized": 3,
+    "experimental_regularized_full9": 4,
 }
 OUTLET_MAP = {"neq_extrap": 0, "zero_gradient": 1, "blended": 2}
 Y_WALL_BC_MAP = {"bounce_back": 0, "free_slip": 1, "on_site_velocity": 2}
@@ -162,6 +163,11 @@ class LBMConfig:
            raise ValueError("wall_slot_width requires on_site_velocity and velocity=0")
        if self.top_wall_bc == "reservoir" and (self.y_wall_bc != "on_site_velocity" or self.velocity != 0):
            raise ValueError("reservoir requires on_site_velocity and velocity=0")
+        if self.inlet_scheme == "experimental_regularized_full9":
+            if (not self.is_d2q9 or self.collision != "SRT"
+                    or self.streaming != "double_buffer" or self.store_precision != "FP32"
+                    or self.les_enabled or self.y_wall_bc != "bounce_back"):
+                raise ValueError("experimental_regularized_full9 requires D2Q9/SRT/FP32/double_buffer, bounce_back walls, no LES")
        if self.y_wall_bc == "on_site_velocity":
            if (not self.is_d2q9 or self.collision != "SRT"
                    or self.streaming != "double_buffer" or self.store_precision != "FP32"
@@ -74,7 +74,7 @@ __device__ __forceinline__ float west_velocity_rho_closure_d3q19(

 __device__ __forceinline__ bool inlet_scheme_uses_post_collision_ghost()
 {
-#if INLET_SCHEME == 0
+#if INLET_SCHEME == 0 || INLET_SCHEME == 4
    return true;
 #else
    return false;
@@ -0,0 +1,36 @@
+// Experimental D2Q9 west velocity boundary: full-state stress regularization.
+// Palabos boundaryTemplates::compute_PiNeq / regularized velocity completion.
+// This returns PRE-collision populations. The existing step kernel collides once.
+#ifndef CELERIS_EXPERIMENTAL_FULL9_INLET_CUH
+#define CELERIS_EXPERIMENTAL_FULL9_INLET_CUH
+
+#if LATTICE_MODEL == LATTICE_D2Q9
+__device__ inline void apply_experimental_full9_inlet_d2q9(
+    float* __restrict__ f, float ux_target, float uy_target)
+{
+    const float rho = west_velocity_rho_closure_d2q9(f, ux_target);
+    float eq[9];
+    compute_feq(rho, ux_target, uy_target, eq);
+    // Only known pulled directions are read; unknown wrapped q1/5/7 are ignored.
+    // f and eq use the same shifting convention, so weights cancel in K.
+    const float k2 = f[2] - eq[2];
+    const float k3 = f[3] - eq[3];
+    const float k4 = f[4] - eq[4];
+    const float k6 = f[6] - eq[6];
+    const float k8 = f[8] - eq[8];
+    const float pxx = 2.0f * (k2 + k6 + k8);
+    const float pyy = k3 + k4 + 2.0f * (k6 + k8);
+    const float pxy = 2.0f * (k6 - k8);
+    const int cx[9] = {0, 1,-1, 0, 0, 1,-1, 1,-1};
+    const int cy[9] = {0, 0, 0, 1,-1, 1,-1,-1, 1};
+    for (int q = 0; q < 9; ++q) {
+        const float weight = q == 0 ? W0_VAL : (q < 5 ? WS_VAL : WE_VAL);
+        const float stress = weight * (
+            4.5f * (((float)(cx[q]*cx[q]) - 1.0f/3.0f) * pxx
+                  + ((float)(cy[q]*cy[q]) - 1.0f/3.0f) * pyy)
+            + 9.0f * (float)(cx[q]*cy[q]) * pxy);
+        f[q] = eq[q] + stress;
+    }
+}
+#endif
+#endif
@@ -24,6 +24,7 @@
 #include "inlet/channel_stabilized.cuh"
 #include "inlet/equilibrium.cuh"
 #include "inlet/regularized.cuh"
+#include "inlet/experimental_full9.cuh"
 #include "outlet/pressure_neq.cuh"

 #if DIM == 2
@@ -45,6 +46,8 @@ __device__ __forceinline__ void apply_inlet_pull_d2q9(

 #if INLET_SCHEME == 0
    apply_zou_he_left_velocity_inlet_d2q9(f, u_target, v_target);
+#elif INLET_SCHEME == 4
+    apply_experimental_full9_inlet_d2q9(f, u_target, v_target);
 #elif INLET_SCHEME == 1 || INLET_SCHEME == 3
    float f_neb[NQ];
    const unsigned long k_neb = linear_index(x + 1u, y);
@@ -143,6 +146,8 @@ __device__ __forceinline__ void apply_inlet_esopull_d2q9(

 #if INLET_SCHEME == 0
    apply_zou_he_left_velocity_inlet_d2q9(f, u_target, v_target);
+#elif INLET_SCHEME == 4
+    apply_experimental_full9_inlet_d2q9(f, u_target, v_target);
 #elif INLET_SCHEME == 1 || INLET_SCHEME == 3
  #if INLET_SCHEME == 1
    apply_channel_stabilized_inlet_d2q9(f, f_neb, (float)y);
@@ -0,0 +1,26 @@
+# Experimental uniform DFG pilot
+
+Numerical source remains926ca27407c26ca11283282a6e53249925725376. This test-only followup uses a separate dfg_source_manifest.json, pins the official reference-cycle file, and records actual execution HEAD independently. The historical bodyless manifest is unchanged and correctly rejects this checkout because the shared runner gained optional hooks. Use historical939c10c for that historical entrypoint; do not repin old evidence.
+
+The new run_dfg.py is uniform-only, with the original D80 cylinder, SRT tau.524, shiftedFP32 double buffer, original initialization, noLES/force, pressure-NEQ outlet all-nine damping.5. Only inlet scheme is experimental_regularized_full9. It reuses run_refined_dfg.run_case and the existing pressure, force, physical mass/flux and periodic/reference helpers. Legacy run_case callers retain the original inlet and dense pilot cadence.
+
+This pilot advances40,000steps to t*=5 with sparse observations every4000steps (t*=.5), matching the standard pre240 cadence. Every100-step batch contributes its full momentum impulse; force time is the interval midpoint, pressure time its endpoint. First100steps provide warmup; the next four100-step batches measure warmed step+force cost. All500steps are included in the physical trajectory and observation impulse; no reset or discarded evolution. Calibration durations and total step/force/startup/wall timings are recorded. Batch force download synchronizes GPU work through the existing API.
+
+A first unhealthy sample identifies only the first observed failure, not its onset. Receipts separate executed_steps, last_observed_step and the existing steps field; timeout retains available progress, history and calibration. No per-step field download or new health threshold is introduced. Runtime admission uses180seconds internally, with an external240second watchdog. Later full-run admission must use measured batched timings, not the earlier per-step snapshot diagnostic rate. Same-size historical MRT full campaigns took roughly354–373seconds, but this pilot measures the present SRT/full9 case.
+
+CPU checks from this checkout:
+
+```
+python tests/validation/experimental_full9/test_dfg.py
+python tests/validation/experimental_full9/test_full9.py
+python -m py_compile tests/validation/experimental_full9/run_dfg.py tests/validation/run_refined_dfg.py
+python tests/validation/experimental_full9/run_dfg.py --output /tmp/new-full9-dfg-preflight
+```
+
+After independent review and explicit GPU admission only:
+
+```
+CUDA_VISIBLE_DEVICES=<admitted-device> timeout --signal=TERM --kill-after=30s 240s python tests/validation/experimental_full9/run_dfg.py --execute --gpu-admitted --wall-seconds 180 --output output/new-full9-dfg-pilot
+```
+
+This entrypoint intentionally has no full-run execution option. Existing official-reference assessment is reused and accuracy_pass requires health, periodicity and reference agreement for future qualification; pilot accuracy_qualified is alwaysfalse. A healthy pilot qualifies bounded admission/timing only. No grid convergence, canonical outlet, refined/MRT/other precision, long-time accuracy or general stability claim follows.
@@ -0,0 +1,38 @@
+# Isolated experimental full-nine inlet comparison
+
+This is preparation for one separately admitted, at-most320-step bodyless robustness comparison. It is not public support, a default change, proof of root cause, or boundary-accuracy acceptance.
+
+## Source and isolation
+Numerical commit: `926ca27407c26ca11283282a6e53249925725376`, based on history diagnostic `e92de3742476ea5afd6b84ff9538992df48548f7`. The new manifest pins numerical files and separately hashes the two runtime harness files. Actual checkout HEAD/dirty state is recorded on execution; --source must resolve to the executing harness checkout. The historical manifest is unchanged and intentionally rejects the new numerical tree. The original Zou–He default and IDs0..3 remain unchanged.
+
+Explicit scheme `experimental_regularized_full9` is ID4. Configuration guards restrict it to D2Q9, SRT, double-buffer, FP32 storage, bounce-back y walls, and no LES; shifted and unshifted storage are tested. The bodyless runner uses exactly the old config factory, changes only inlet scheme, and removes only the original cylinder. Original initialization, profile, boundary planes, outlet/all-nine damping, viscosity, timestep and health gates remain unchanged.
+
+The new helper computes rho from the existing west known-population closure. At the prescribed velocity, known Kq=Fq−Feq gives Pi_xx=2(K2+K6+K8), Pi_yy=K3+K4+2(K6+K8), Pi_xy=2(K6−K8). It reconstructs all nine pre-collision populations from equilibrium plus the second-order stress projection. The existing step kernel then applies SRT exactly once. Old-buffer timing is unchanged. This preserves prescribed physical velocity moments while intentionally changing the boundary's kinetic reconstruction; it is not numerically identical to Zou–He.
+
+Primary mapping: [Palabos stress construction](https://unigespc.gitlab.io/palabos/docs/html/d0/dfa/boundary_templates_8h_source.html), [velocity completion before base collision](https://unigespc.gitlab.io/palabos/docs/html/d2/d68/regularized_boundary_dynamics_8hh_source.html), [Latt–Chopard equations10–12](https://arxiv.org/pdf/physics/0506157). This independently implemented mapping does not use Celeris's differently defined existing incoming-only donor-damped `regularized` option.
+
+Near-wall inlet known inputs are unchanged. This comparison includes their existing interaction; it does not silently move walls or repair initialization. An EsoPull dispatch arm is present because that function is preprocessed even in double-buffer builds; the configuration guard rejects running that streaming variant.
+
+## Tests and bounded analytical check
+
+```sh
+python tests/validation/experimental_full9/test_full9.py
+python tests/validation/experimental_full9/test_runner.py
+OPENBLAS_NUM_THREADS=1 OMP_NUM_THREADS=1 python tests/validation/experimental_full9/check_linear_strip.py
+python tests/validation/experimental_full9/run_bodyless.py --record-inlet-history --output /tmp/new-full9-preflight
+```
+
+The host tests compile the actual helper and canonical macro/SRT headers with g++, in shifted/unshifted modes. They check equilibrium, mass/momentum, prescribed stress, ignored wrapped q1/5/7, exactly-one collision, source ordering, legacy IDs/defaults and rejected configurations. These tests do not certify CUDA compilation.
+
+The fixed homogeneous linear comparison uses the original five k samples, width32, rho1, U=.0028664576821029186, tau=.524 and zero far incoming perturbation. The prior3π/4 Zou–He radius1.0186489 becomes .9802484 with full9; all five sampled full9 radii are below1. This is a finite sampled surrogate result, not a continuous stability proof or a match to the actual dominant≈2π/3 history spectrum. No parameter tuning or new flow is part of this check.
+
+## Exact admitted command
+From the final clean reviewed checkout, after explicit GPU admission:
+
+```sh
+CUDA_VISIBLE_DEVICES=<admitted-device> timeout --signal=TERM --kill-after=30s 240s python tests/validation/experimental_full9/run_bodyless.py --record-inlet-history --execute --gpu-admitted --wall-seconds 180 --output output/new-experimental-full9-bodyless
+```
+
+The shared diagnostic still stops on its unchanged first-health/320-step/wall ceiling. Optional raw history records the fixed0..196 window only, with the existing12MiB bound and completeness receipt; evolution can continue beyond196. Use a new output directory and preserve old evidence.
+
+A healthy320-step result would support only bounded robustness to this exact startup. Failure remains evidence, not a reason to tune the scheme after seeing results. Compare step-count/health, finite fields, density/Mach, inlet target moments and retained modal history; conservation and long-time/cylinder accuracy require later separate tests. No default/dev integration is authorized by this experiment.
@@ -0,0 +1,31 @@
+"""Bounded fixed-parameter linear comparison; no nonlinear flow or GPU run."""
+import json
+from pathlib import Path
+import numpy as np
+from scipy.linalg import eigvals
+cx=np.array([0,1,-1,0,0,1,-1,1,-1]);cy=np.array([0,0,0,1,-1,1,-1,-1,1]);w=np.array([4/9]+[1/9]*4+[1/36]*4)
+U=.0028664576821029186;omega=1/.524;cu=cx*U
+base=w*(1+3*cu+4.5*cu**2-1.5*U**2)
+E=w[:,None]*((1+3*cu+4.5*cu**2-1.5*U*U)[:,None]+(3*cx+9*cu*cx-3*U)[:,None]*(cx-U)[None,:]+(3*cy+9*cu*cy)[:,None]*cy[None,:])
+C=(1-omega)*np.eye(9)+omega*E
+r=np.array([1,0,2,1,1,0,2,0,2])/(1-U);I=np.eye(9)
+B=I.copy();B[1]=I[2]+2/3*U*r;B[5]=I[6]+.5*(I[4]-I[3])+U/6*r;B[7]=I[8]+.5*(I[3]-I[4])+U/6*r
+T=np.array([[0,0,2,0,0,0,2,0,2],[0,0,0,1,1,0,2,0,2],[0,0,0,0,0,0,2,0,-2]])
+R=w[:,None]*np.array([4.5*(cx*cx-1/3),4.5*(cy*cy-1/3),9*cx*cy]).T
+Bfull=base[:,None]*r+R@T@(I-base[:,None]*r)
+assert np.max(abs(Bfull[:,[1,5,7]]))<1e-15
+assert np.max(abs(np.array([np.ones(9),cx,cy])@Bfull-np.array([r,U*r,np.zeros(9)])))<1e-14
+
+def radius(n,k,b):
+    A=np.zeros((9*n,9*n),complex)
+    for x in range(n):
+        local=C@b if x==0 else C
+        for q in range(9):
+            donor=x-int(cx[q])
+            if 0<=donor<n:A[9*x:9*x+9,9*donor+q]+=local[:,q]*np.exp(-1j*k*cy[q])
+    return float(np.max(abs(eigvals(A,check_finite=False))))
+
+def main():
+    rows=[dict(k_over_pi=k/np.pi,zou_he=radius(32,k,B),experimental_full9=radius(32,k,Bfull)) for k in [0,np.pi/4,np.pi/2,3*np.pi/4,np.pi]]
+    print(json.dumps(dict(scope='Width32, zero incoming far perturbation, five original fixed k samples; negative samples do not prove stability',U=U,tau=.524,rows=rows),indent=2,allow_nan=False))
+if __name__=='__main__':main()
@@ -0,0 +1,121 @@
+{
+  "commit": "926ca27407c26ca11283282a6e53249925725376",
+  "historical_numerical_source_commit": "9805383f9c50d867e8555471baf5dbda8333a652",
+  "variant": "experimental_regularized_full9",
+  "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": "215b09829e10453b333aae69811ffc638c7aa26ae418f25f8654a1a20a74f212",
+    "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": "1203739c346cb4986e4ecb3090a70114eecc1688ae886d5abfcdb643be256acb",
+    "src/CelerisLab/lbm/kernels/boundary/inlet/equilibrium.cuh": "f0964c811b2c41a5aaa1c6d99c490b06e850c634eb8749f1f05ef61f93c2de1d",
+    "src/CelerisLab/lbm/kernels/boundary/inlet/experimental_full9.cuh": "f2475d6322f060b256f37d81e43d6aa3a1918e2eac83c076c32c2599b674f596",
+    "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": "4955786adc6d0853f2a9703611ea76e58ef045d6d6f4295bd795b05dc2f00dcd",
+    "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": "992169a38ab16ab20a9b9bb4a29853cafe1d6bc07adba0df435a104be1de7b68",
+    "tests/validation/source_provenance.py": "6dfe8f2d819dba0e240ba761d31162a5033685d492d09db75eb2b8aaab3a5a4c"
+  },
+  "runtime_sha256": {
+    "tests/validation/experimental_full9/run_dfg.py": "400f6ff373623e5312c8dfae3cb8dc0172360e40feb2a9780443ec7f7ded6eea",
+    "tests/validation/uniform_srt_diagnostic/diagnose_uniform_srt.py": "56b9ef786001c7760abab8d870f6437d719b427c21964f00067188f5fb27caad",
+    "tests/validation/source_provenance.py": "6dfe8f2d819dba0e240ba761d31162a5033685d492d09db75eb2b8aaab3a5a4c",
+    "tests/validation/data/dfg_re100/reference_cycle.json": "073d1bda1629697efebad95667bfe80598e217d708dbffd7d5f6c6999379c55f"
+  },
+  "experiment": "uniform_full9_dfg_sparse_pilot"
+}
@@ -0,0 +1,58 @@
+"""Explicit experimental full9 inlet, exact original bodyless SRT control otherwise.
+
+CPU preflight by default. No acceptance claim; requires separate GPU admission.
+"""
+import argparse
+import hashlib
+import math
+import os
+from pathlib import Path
+import sys
+
+HERE=Path(__file__).resolve().parent
+ROOT=HERE.parents[2]
+sys.path.insert(0,str(HERE.parent/'uniform_srt_diagnostic'))
+import diagnose_uniform_srt as diagnostic
+
+VARIANT='experimental_regularized_full9'
+
+def configuration(source):
+    if source.resolve()!=ROOT.resolve():
+        raise ValueError('Experimental source must equal the executing harness checkout')
+    cfg,body,p,manifest=diagnostic.source_config(source,HERE/'source_manifest.json')
+    if cfg['method']['collision']!='SRT' or cfg['method']['inlet']['scheme']!='zou_he_local':
+        raise ValueError('Unexpected baseline factory')
+    cfg['method']['inlet']['scheme']=VARIANT
+    return cfg,diagnostic.select_body(body,True),p,manifest
+
+def main():
+    parser=argparse.ArgumentParser(description=__doc__)
+    parser.add_argument('--source',type=Path,default=ROOT)
+    parser.add_argument('--output',type=Path,required=True)
+    parser.add_argument('--record-inlet-history',action='store_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=configuration(a.source)
+    from source_provenance import checkout_provenance
+    a.identity=dict(experimental_variant=VARIANT,
+        observation_mode='inlet_raw_history' if a.record_inlet_history else 'first_health_pair',
+        history_limit_bytes=diagnostic.HISTORY_LIMIT_BYTES if a.record_inlet_history else None,
+        history_requested_steps=[0,196] if a.record_inlet_history else None,
+        control='without_cylinder',force_observation='not_applicable_no_body',
+        baseline_diagnostic_commit='66a27410504fef477808d6079ce79ca1ae6b903c',
+        numerical_source_commit=manifest['commit'],
+        diagnostic_checkout=checkout_provenance(ROOT),numerical_checkout=checkout_provenance(a.source),
+        diagnostic_sha256=hashlib.sha256(Path(__file__).read_bytes()).hexdigest(),
+        shared_diagnostic_sha256=hashlib.sha256(Path(diagnostic.__file__).read_bytes()).hexdigest())
+    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)
+    diagnostic.dump(a.output/'preflight.json',dict(**a.identity,source=manifest,config=cfg,body=body,parameters=p,
+        max_steps=320,max_evidence_bytes=diagnostic.LIMIT_BYTES,executed=False))
+    return diagnostic.execute(a,cfg,body,p) if a.execute else 0
+
+if __name__=='__main__':raise SystemExit(main())
@@ -0,0 +1,113 @@
+"""Uniform experimental full9 DFG pilot; CPU preflight unless explicitly admitted."""
+import argparse
+import hashlib
+import json
+import math
+import os
+from pathlib import Path
+import sys
+import time
+
+HERE = Path(__file__).resolve().parent
+ROOT = HERE.parents[2]
+sys.path.insert(0, str(HERE.parent / 'uniform_srt_diagnostic'))
+import diagnose_uniform_srt as diagnostic
+
+VARIANT = 'experimental_regularized_full9'
+OBSERVATION = 'uniform_sparse_pilot_v1'
+
+
+def configuration(source):
+    if source.resolve() != ROOT.resolve():
+        raise ValueError('Source must equal executing harness checkout')
+    cfg, body, p, manifest = diagnostic.source_config(source, HERE / 'dfg_source_manifest.json')
+    cfg['method']['inlet']['scheme'] = VARIANT
+    return cfg, body, p, manifest
+
+
+def accuracy_pass(result):
+    """Standard later qualification predicate; pilot never qualifies accuracy."""
+    return (result.get('healthy') is True and result.get('periodic') is True
+            and result.get('reference_comparison', {}).get('reference_agreement') is True)
+
+
+def identity(manifest):
+    return dict(experimental_variant=VARIANT, collision='SRT', control='with_cylinder',
+                observation_mode=OBSERVATION, numerical_source_commit=manifest['commit'],
+                manifest_sha256=hashlib.sha256((HERE / 'dfg_source_manifest.json').read_bytes()).hexdigest())
+
+
+def verify_pilot(result, expected):
+    import run_refined_dfg as runner
+    runner.ensure_finite(result)
+    if any(result.get(k) != v for k, v in expected.items()):
+        raise ValueError('Pilot identity mismatch')
+    if (result.get('case') != 'uniform' or result.get('mode') != 'pilot'
+            or result.get('status') != 'pilot_complete' or result.get('healthy') is not True
+            or result.get('steps') != 40000 or result.get('executed_steps') != 40000):
+        raise ValueError('Incomplete or mislabeled pilot')
+    timings = result.get('calibration_batches_seconds', [])
+    if len(timings) != 5 or any(isinstance(v, bool) or not isinstance(v, (int, float)) or v <= 0 for v in timings):
+        raise ValueError('Missing positive calibration timings')
+    rows = result.get('history', [])
+    if len(rows) != 10:
+        raise ValueError('Incomplete sparse pilot history')
+    for i, row in enumerate(rows, 1):
+        for key in ('cd', 'cl', 'mass', 'flux_in', 'flux_out', 'dp'):
+            if isinstance(row.get(key), bool) or not isinstance(row.get(key), (int, float)):
+                raise ValueError('Missing numeric pilot observation')
+        if (row.get('step') != i * 4000 or row.get('tstar') != i * .5
+                or row.get('tstar_force') != i * .5 - .25
+                or not .5 <= row.get('rho_min', 0) <= row.get('rho_max', 2) <= 1.5
+                or not 0 <= row.get('max_mach', 1) <= .2):
+            raise ValueError('Invalid sparse pilot observation')
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument('--source', type=Path, default=ROOT)
+    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, default=180.)
+    a = parser.parse_args()
+    a.source = a.source.resolve()
+    cfg, body, p, manifest = configuration(a.source)
+    import run_refined_dfg as runner
+    from source_provenance import checkout_provenance
+    h, periodic = runner.helpers(a.source)
+    if not math.isfinite(a.wall_seconds) or a.wall_seconds <= 0:
+        raise ValueError('Finite positive wall ceiling required')
+    if a.execute and (not a.gpu_admitted or not os.environ.get('CUDA_VISIBLE_DEVICES')):
+        raise ValueError('Explicit GPU admission and device selection required')
+    if a.output.exists() and any(a.output.iterdir()):
+        raise ValueError('Use new/empty output directory')
+    a.output.mkdir(parents=True, exist_ok=True)
+    receipt = identity(manifest)
+    receipt['checkout'] = checkout_provenance(ROOT)
+    diagnostic.dump(a.output / 'preflight.json', dict(**receipt, config=cfg, body=body,
+        parameters=p, source=manifest, max_steps=40000, cap_tstar=5.,
+        observation_width_tstar=.5, force_batch_steps=100,
+        calibration='First 100 steps warmup; next 400 timed, counted in physical trajectory',
+        gates=periodic.GATES, reference_gates=periodic.REFERENCE_GATES,
+        wall_seconds=a.wall_seconds, executed=False, accuracy_qualified=False))
+    if not a.execute:
+        return 0
+    a.mode = 'pilot'
+    a.deadline = time.monotonic() + a.wall_seconds
+    progress = {}
+    try:
+        result = runner.run_case(a, h, periodic, 'uniform', inlet_scheme=VARIANT,
+                                sparse_pilot=True, receipt_identity=receipt, progress=progress)
+    except TimeoutError:
+        diagnostic.dump(a.output / 'result.json', dict(**receipt, status='wall_time_limit',
+                        healthy=False, accuracy_qualified=False, **progress))
+        return 3
+    if result['healthy']:
+        verify_pilot(result, receipt)
+    diagnostic.dump(a.output / 'result.json', dict(**result, accuracy_qualified=False))
+    return 0 if result['healthy'] else 2
+
+
+if __name__ == '__main__':
+    raise SystemExit(main())
@@ -0,0 +1,118 @@
+{
+  "commit": "926ca27407c26ca11283282a6e53249925725376",
+  "historical_numerical_source_commit": "9805383f9c50d867e8555471baf5dbda8333a652",
+  "variant": "experimental_regularized_full9",
+  "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": "215b09829e10453b333aae69811ffc638c7aa26ae418f25f8654a1a20a74f212",
+    "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": "1203739c346cb4986e4ecb3090a70114eecc1688ae886d5abfcdb643be256acb",
+    "src/CelerisLab/lbm/kernels/boundary/inlet/equilibrium.cuh": "f0964c811b2c41a5aaa1c6d99c490b06e850c634eb8749f1f05ef61f93c2de1d",
+    "src/CelerisLab/lbm/kernels/boundary/inlet/experimental_full9.cuh": "f2475d6322f060b256f37d81e43d6aa3a1918e2eac83c076c32c2599b674f596",
+    "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": "4955786adc6d0853f2a9703611ea76e58ef045d6d6f4295bd795b05dc2f00dcd",
+    "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"
+  },
+  "runtime_sha256": {
+    "tests/validation/uniform_srt_diagnostic/diagnose_uniform_srt.py": "56b9ef786001c7760abab8d870f6437d719b427c21964f00067188f5fb27caad",
+    "tests/validation/experimental_full9/run_bodyless.py": "840edd524edb66ec06a3b8784c9e561f139a77cf49550125817193f25363c694"
+  }
+}
@@ -0,0 +1,153 @@
+"""Focused host checks for the uniform experimental DFG pilot."""
+from copy import deepcopy
+import importlib.util
+import json
+from pathlib import Path
+import subprocess
+import sys
+from tempfile import TemporaryDirectory
+import unittest
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+import run_dfg as r
+
+
+def test_factory_and_default():
+    cfg, body, p, manifest = r.configuration(r.ROOT)
+    r.configuration(r.ROOT)
+    import run_refined_dfg as runner
+    h, _ = runner.helpers(r.ROOT)
+    old, old_body, old_p = runner.config(h, 80)
+    assert old['method']['inlet']['scheme'] == 'zou_he_local'
+    old['method']['inlet']['scheme'] = r.VARIANT
+    assert cfg == old and body == old_body and p == old_p
+    assert len(body['objects']) == 1 and p['diameter'] == 80
+    assert cfg == runner.config(h, 80, r.VARIANT)[0]
+    assert manifest['commit'] == '926ca27407c26ca11283282a6e53249925725376'
+
+
+def receipt():
+    _, _, _, m = r.configuration(r.ROOT)
+    expected = r.identity(m)
+    rows = [dict(step=i*4000, tstar=i*.5, tstar_force=i*.5-.25,
+                 rho_min=.99, rho_max=1.01, max_mach=.03,
+                 cd=3., cl=.1, dp=2., mass=.8, flux_in=.41, flux_out=.41)
+            for i in range(1, 11)]
+    return expected, dict(**expected, case='uniform', mode='pilot', status='pilot_complete',
+                         healthy=True, steps=40000, executed_steps=40000, history=rows,
+                         calibration_batches_seconds=[.001]*5)
+
+
+def test_receipts():
+    expected, result = receipt()
+    r.verify_pilot(result, expected)
+    for key, value in [('collision', 'MRT'), ('experimental_variant', 'zou_he_local'),
+                       ('observation_mode', 'first_health_pair'), ('control', 'without_cylinder'),
+                       ('numerical_source_commit', 'other'), ('case', 'refined'),
+                       ('steps', 39999), ('executed_steps', 39999), ('healthy', False)]:
+        bad = deepcopy(result); bad[key] = value
+        with unittest.TestCase().assertRaises(ValueError): r.verify_pilot(bad, expected)
+    for change in ('nan', 'missing', 'time', 'count'):
+        bad = deepcopy(result)
+        if change == 'nan': bad['history'][-1]['tstar'] = float('nan')
+        if change == 'missing': del bad['history'][0]['cd']
+        if change == 'time': bad['history'][0]['tstar_force'] = .5
+        if change == 'count': bad['history'].pop()
+        with unittest.TestCase().assertRaises(ValueError): r.verify_pilot(bad, expected)
+
+
+def test_accuracy_requires_reference():
+    assert not r.accuracy_pass(dict(healthy=True, periodic=True))
+    assert r.accuracy_pass(dict(healthy=True, periodic=True,
+                               reference_comparison=dict(reference_agreement=True)))
+    assert not r.accuracy_pass(dict(healthy=True, periodic=False,
+                                   reference_comparison=dict(reference_agreement=True)))
+
+
+def test_preflight_and_source_guards():
+    with TemporaryDirectory() as temp:
+        subprocess.run([sys.executable, str(Path(r.__file__)), '--output', temp], check=True)
+        out = json.loads((Path(temp)/'preflight.json').read_text())
+        assert out['max_steps'] == 40000 and out['observation_width_tstar'] == .5
+        assert not out['executed'] and not out['accuracy_qualified']
+        assert out['wall_seconds'] == 180 and out['control'] == 'with_cylinder'
+    with unittest.TestCase().assertRaises(ValueError): r.configuration(r.ROOT.parent)
+    with unittest.TestCase().assertRaisesRegex(ValueError, 'Pinned source mismatch'):
+        r.diagnostic.source_config(r.ROOT, Path(r.__file__).with_name('source_manifest.json'))
+
+
+def test_shared_source_semantics():
+    r.configuration(r.ROOT)
+    import run_refined_dfg as runner
+    text = Path(runner.__file__).read_text()
+    assert 'sparse_pilot=False' in text
+    assert '(a.mode == "pilot" and not sparse_pilot)' in text
+    assert 'impulse += sim.read_force(0).astype(np.float64) * batch' in text
+    assert 'tstar_force=(begin + n / 2) * SPEED / p["diameter"]' in text
+    assert 'cd=float(impulse[0] / n / den)' in text
+    assert 'mass = float(rho[fluid].sum()) * p["dx"] ** 2' in text
+    assert 'executed_steps += batch' in text
+    assert 'First unhealthy observation; onset between observations is unknown' in text
+
+
+def test_accounted_calibration_and_failure_progress():
+    import numpy as np
+    import types
+    from unittest.mock import patch
+    r.configuration(r.ROOT)
+    import run_refined_dfg as runner
+    h, periodic = runner.helpers(r.ROOT)
+    _, _, p = runner.config(h, 80)
+    count = [0]
+    fail = [False]
+    class Simulation:
+        def __init__(self, *args, **kwargs):
+            self.field = types.SimpleNamespace(flag=np.ones(p['nx']*p['ny'], np.uint8))
+        def __enter__(self): return self
+        def __exit__(self, *args): pass
+        def initialize(self): count[0] = 0
+        def run(self, n): count[0] += n
+        def read_force(self, body): return np.array([.004, .002])
+        def get_macroscopic(self):
+            shape = (p['ny'], p['nx'])
+            return dict(rho=np.full(shape, float('nan') if fail[0] else 1.),
+                        ux=np.full(shape, .01), uy=np.zeros(shape))
+    modules = {
+        'CelerisLab.simulation': types.SimpleNamespace(Simulation=Simulation),
+        'CelerisLab.cuda.context': types.SimpleNamespace(CudaContext=object),
+        'CelerisLab.lbm.refinement_stepper': types.SimpleNamespace(FixedPatchStepper=object),
+    }
+    with patch.dict(sys.modules, modules), patch.object(h, 'pressure_probes', return_value=dict(dp=2.)):
+        with TemporaryDirectory() as temp:
+            args = types.SimpleNamespace(source=r.ROOT, output=Path(temp), mode='pilot', deadline=float('inf'))
+            progress = {}
+            result = runner.run_case(args, h, periodic, 'uniform', inlet_scheme=r.VARIANT,
+                                     sparse_pilot=True, progress=progress)
+            assert count[0] == 40000 and result['executed_steps'] == 40000
+            assert len(result['history']) == 10 and len(result['calibration_batches_seconds']) == 5
+            assert abs(result['history'][0]['cd'] - 1.) < 1e-14
+            assert result['history'][0]['tstar_force'] == .25
+        fail[0] = True
+        with TemporaryDirectory() as temp:
+            args.output = Path(temp)
+            result = runner.run_case(args, h, periodic, 'uniform', inlet_scheme=r.VARIANT,
+                                     sparse_pilot=True, progress=progress)
+            assert result['executed_steps'] == 4000 and result['steps'] == 0
+            assert result['first_observed_failure_step'] == 4000 and result['last_observed_step'] == 0
+        fail[0] = False
+        with TemporaryDirectory() as temp:
+            args.output = Path(temp)
+            def deadline(_):
+                if count[0] >= 500: raise TimeoutError('test deadline')
+            count[0] = 0
+            with patch.object(runner, 'check_deadline', side_effect=deadline):
+                with unittest.TestCase().assertRaises(TimeoutError):
+                    runner.run_case(args, h, periodic, 'uniform', inlet_scheme=r.VARIANT,
+                                    sparse_pilot=True, progress=progress)
+            assert progress['executed_steps'] == 500 and progress['last_observed_step'] == 0
+            assert len(progress['calibration_batches_seconds']) == 5
+
+
+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())
@@ -0,0 +1,105 @@
+"""Host-compile the actual numerical helper; no CUDA or flow evolution."""
+import ctypes
+from pathlib import Path
+import subprocess
+import sys
+from tempfile import TemporaryDirectory
+import unittest
+import numpy as np
+ROOT=Path(__file__).resolve().parents[3]
+sys.path.insert(0,str(ROOT/'src'))
+from CelerisLab.config import LBMConfig, INLET_SCHEME_MAP
+cx=np.array([0,1,-1,0,0,1,-1,1,-1]);cy=np.array([0,0,0,1,-1,1,-1,-1,1]);w=np.array([4/9]+[1/9]*4+[1/36]*4)
+M=np.array([np.ones(9),cx,cy]);Q=np.array([cx*cx,cy*cy,cx*cy])
+TEMP=TemporaryDirectory();libs=[]
+for shifted in [0,1]:
+    code=f'''
+#include <cmath>
+#define __device__
+#define __forceinline__ inline
+#define __fdiv_rn(a,b) ((a)/(b))
+#define LATTICE_D2Q9 0
+#define LATTICE_MODEL 0
+#define NQ 9
+#define CS2 (1.0f/3.0f)
+#define NY 330
+#define U0 .01f
+#define W0_VAL (4.0f/9.0f)
+#define WS_VAL (1.0f/9.0f)
+#define WE_VAL (1.0f/36.0f)
+#define USE_DDF_SHIFTING {shifted}
+#define INLET_SCHEME 4
+#include "operators/macro.cuh"
+#include "operators/collision_srt.cuh"
+#include "boundary/inlet/common.cuh"
+#include "boundary/inlet/experimental_full9.cuh"
+extern "C" int apply(float* f,float u,float v,int collision) {{
+    apply_experimental_full9_inlet_d2q9(f,u,v);
+    int count=0;
+    if (collision && inlet_scheme_uses_post_collision_ghost()) {{
+        float rho,ux,uy,eq[9]; compute_rho_u(f,rho,ux,uy); compute_feq(rho,ux,uy,eq);
+        collide_srt_no_force(f,eq,1.0f/.524f); ++count;
+    }}
+    return count;
+}}
+'''
+    src=Path(TEMP.name)/f'test{shifted}.cpp';src.write_text(code);lib=src.with_suffix('.so')
+    subprocess.run(['g++','-std=c++11','-shared','-fPIC','-O2','-ffp-contract=off','-I',str(ROOT/'src/CelerisLab/lbm/kernels'),str(src),'-o',str(lib)],check=True)
+    dll=ctypes.CDLL(str(lib));dll.apply.argtypes=[ctypes.POINTER(ctypes.c_float),ctypes.c_float,ctypes.c_float,ctypes.c_int];dll.apply.restype=ctypes.c_int;libs.append(dll)
+
+def eq(rho,u,v):
+    cu=cx*u+cy*v;return w*rho*(1+3*cu+4.5*cu*cu-1.5*(u*u+v*v))
+def reference(f,u,v):
+    rho=(f[0]+f[3]+f[4]+2*(f[2]+f[6]+f[8]))/(1-u);e=eq(rho,u,v);k=f-e
+    pi=np.array([2*(k[2]+k[6]+k[8]),k[3]+k[4]+2*(k[6]+k[8]),2*(k[6]-k[8])])
+    stress=w*(4.5*((cx*cx-1/3)*pi[0]+(cy*cy-1/3)*pi[1])+9*cx*cy*pi[2])
+    return e,stress,pi
+
+def apply(f,u,v,shifted,collision=0):
+    raw=np.asarray(f-shifted*w,dtype=np.float32);count=libs[shifted].apply(raw.ctypes.data_as(ctypes.POINTER(ctypes.c_float)),u,v,collision)
+    return raw.astype(float)+shifted*w,count
+
+def test_moments_stress_and_shift():
+    rng=np.random.default_rng(92)
+    for _ in range(20):
+        f=eq(1.02,.003,0)+rng.normal(0,.001,9);e,s,pi=reference(f,.003,.001)
+        outputs=[]
+        for shifted in [0,1]:
+            out,count=apply(f,.003,.001,shifted);outputs.append(out)
+            assert count==0
+            np.testing.assert_allclose(out,e+s,atol=2e-7,rtol=0)
+            np.testing.assert_allclose(M@out,M@e,atol=3e-7,rtol=0)
+            np.testing.assert_allclose(Q@(out-e),pi,atol=2e-7,rtol=0)
+        np.testing.assert_allclose(*outputs,atol=2e-7,rtol=0)
+
+def test_unknown_inputs_ignored_and_equilibrium():
+    for shifted in [0,1]:
+        f=eq(1.01,.004,0);out,_=apply(f,.004,0,shifted)
+        np.testing.assert_allclose(out,f,atol=2e-7,rtol=0)
+        f[[1,5,7]]=np.nan;ignored,_=apply(f,.004,0,shifted)
+        assert np.isfinite(ignored).all()
+        np.testing.assert_array_equal(out,ignored)
+
+def test_exactly_once_srt():
+    f=eq(1,.003,0)+np.array([.001,0,.002,.003,-.001,0,.002,0,-.002]);e,s,_=reference(f,.003,0)
+    for shifted in [0,1]:
+        out,count=apply(f,.003,0,shifted,1)
+        assert count==1
+        np.testing.assert_allclose(out,e+(1-1/.524)*s,atol=3e-7,rtol=0)
+        assert np.max(abs(out-(e+(1-1/.524)**2*s)))>1e-4
+    source=(ROOT/'src/CelerisLab/lbm/kernels/step/one_step_double.cu').read_text()
+    part=source.split('#if DIM == 2',2)[-1].split('#elif DIM == 3')[0]
+    assert part.index('apply_boundary_pull(f,')<part.index('collide_dispatch(f,')<part.index('stream_pull_store(k,')
+    assert part.count('collide_dispatch(f,')==1
+
+def test_config_guard_and_legacy_ids():
+    assert {k:INLET_SCHEME_MAP[k] for k in ['zou_he_local','channel_stabilized','equilibrium','regularized']}==dict(zou_he_local=0,channel_stabilized=1,equilibrium=2,regularized=3)
+    assert LBMConfig().inlet_scheme=='zou_he_local'
+    for shifted in [False,True]:
+        c=LBMConfig(inlet_scheme='experimental_regularized_full9',ddf_shifting=shifted);c.validate();assert c.to_macros()['INLET_SCHEME']==4
+    for change in [dict(collision='MRT'),dict(collision='TRT'),dict(streaming='esopull'),dict(store_precision='FP16S'),dict(les_enabled=True),dict(y_wall_bc='free_slip'),dict(lattice_model='D3Q19')]:
+        with unittest.TestCase().assertRaises(ValueError):LBMConfig(inlet_scheme='experimental_regularized_full9',**change).validate()
+
+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_')))
+    TEMP.cleanup();raise SystemExit(not result.wasSuccessful())
@@ -0,0 +1,41 @@
+"""Experimental provenance and removal-only config checks, CPU only."""
+from copy import deepcopy
+from pathlib import Path
+import sys
+import unittest
+sys.path.insert(0,str(Path(__file__).resolve().parent))
+import run_bodyless as r
+
+def test_config_only_boundary_changes():
+    cfg,body,p,manifest=r.configuration(r.ROOT)
+    import run_refined_dfg as runner
+    h,_=runner.helpers(r.ROOT);baseline,baseline_body,baseline_p=runner.config(h,80)
+    expected=deepcopy(baseline);expected['method']['inlet']['scheme']=r.VARIANT
+    assert cfg==expected and p==baseline_p
+    expected_body=deepcopy(baseline_body);expected_body['objects']=[]
+    assert body==expected_body
+    assert manifest['commit']=='926ca27407c26ca11283282a6e53249925725376'
+    assert cfg['method']['collision']=='SRT' and cfg['method']['outlet']['srt_neq_damp']==.5
+
+def test_historical_manifest_rejects_candidate():
+    with unittest.TestCase().assertRaisesRegex(ValueError,'Pinned source mismatch'):
+        r.diagnostic.source_config(r.ROOT)
+
+def test_different_runtime_checkout_rejected():
+    with unittest.TestCase().assertRaisesRegex(ValueError,'executing harness checkout'):
+        r.configuration(r.ROOT.parent)
+
+def test_experimental_preflight():
+    import subprocess,json
+    from tempfile import TemporaryDirectory
+    with TemporaryDirectory() as temp:
+        subprocess.run([sys.executable,str(Path(r.__file__)),'--output',temp,'--record-inlet-history'],check=True,capture_output=True)
+        result=json.loads((Path(temp)/'preflight.json').read_text())
+        assert result['experimental_variant']==r.VARIANT
+        assert result['history_requested_steps']==[0,196] and result['max_steps']==320
+        assert not result['executed']
+        assert result['numerical_source_commit']=='926ca27407c26ca11283282a6e53249925725376'
+
+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())
@@ -39,8 +39,8 @@ def helpers(source):
    return h, periodic


-def config(h, diameter):
-    cfg, body, p = h.make_config(diameter, SPEED, "SRT", "neq_extrap", "zou_he_local")
+def config(h, diameter, inlet_scheme="zou_he_local"):
+    cfg, body, p = h.make_config(diameter, SPEED, "SRT", "neq_extrap", inlet_scheme)
    cfg["method"]["outlet"]["srt_neq_damp"] = 0.5
    return cfg, body, p

@@ -159,7 +159,8 @@ def verify_source(source):
    return expected


-def run_case(a, h, periodic, case):
+def run_case(a, h, periodic, case, *, inlet_scheme="zou_he_local",
+             sparse_pilot=False, receipt_identity=None, progress=None):
    from CelerisLab.simulation import Simulation
    from CelerisLab.cuda.context import CudaContext
    from CelerisLab.lbm.refinement_stepper import FixedPatchStepper
@@ -167,10 +168,18 @@ def run_case(a, h, periodic, case):
    from contextlib import ExitStack

    refined = case == "refined"
-    cfgdict, bodydict, p = config(h, 40 if refined else 80)
+    if refined and inlet_scheme != "zou_he_local":
+        raise ValueError("Experimental inlet is uniform-only")
+    cfgdict, bodydict, p = config(h, 40 if refined else 80, inlet_scheme)
+    identity = {} if receipt_identity is None else dict(receipt_identity)
+    calibration_batches = []
+    executed_steps = 0
    cap = 5.0 if a.mode == "pilot" else 300.0
    max_steps = math.ceil(cap * p["diameter"] / SPEED)
    rows = []
+    if progress is not None:
+        progress.update(executed_steps=0, last_observed_step=0, history=rows,
+                        calibration_batches_seconds=calibration_batches)
    healthy = True
    step_seconds = 0.0
    started = time.monotonic()
@@ -233,7 +242,7 @@ def run_case(a, h, periodic, case):
                check_deadline(a.deadline)
                width = (
                    0.02
-                    if a.mode == "pilot" or begin * SPEED / p["diameter"] >= 240
+                    if (a.mode == "pilot" and not sparse_pilot) or begin * SPEED / p["diameter"] >= 240
                    else 0.5
                )
                n = min(max(1, round(width * p["diameter"] / SPEED)), max_steps - begin)
@@ -259,8 +268,14 @@ def run_case(a, h, periodic, case):
                    while done < n:
                        check_deadline(a.deadline)
                        batch = min(100, n - done)
+                        batch_started = time.monotonic() if sparse_pilot else None
                        sim.run(batch)
+                        executed_steps += batch
+                        if progress is not None:
+                            progress["executed_steps"] = executed_steps
                        impulse += sim.read_force(0).astype(np.float64) * batch
+                        if sparse_pilot and len(calibration_batches) < 5:
+                            calibration_batches.append(time.monotonic() - batch_started)
                        done += batch
                        check_deadline(a.deadline)
                step_seconds += time.monotonic() - tick
@@ -320,6 +335,8 @@ def run_case(a, h, periodic, case):
                check_deadline(a.deadline)
                ensure_finite(row)
                rows.append(row)
+                if progress is not None:
+                    progress["last_observed_step"] = row["step"]
                if writer is None:
                    writer = csv.DictWriter(out, fieldnames=row)
                    writer.writeheader()
@@ -335,6 +352,9 @@ def run_case(a, h, periodic, case):
                    break
                if len(rows) == 1:
                    ready = dict(
+                        **identity,
+                        calibration_batches_seconds=calibration_batches,
+                        calibration_note="First 100 steps warmup, next 400 timed; all included in trajectory and force interval",
                        case=case,
                        mode=a.mode,
                        step=begin,
@@ -347,6 +367,12 @@ def run_case(a, h, periodic, case):
                    )
                    print("READY " + json.dumps(ready, allow_nan=False), flush=True)
    result = dict(
+        **identity,
+        calibration_batches_seconds=calibration_batches,
+        first_observed_failure_step=executed_steps if not healthy and not refined else None,
+        last_observed_step=rows[-1]["step"] if rows else 0,
+        failure_timing="First unhealthy observation; onset between observations is unknown" if not healthy else None,
+        executed_steps=executed_steps if not refined else begin,
        case=case,
        mode=a.mode,
        history=rows,
@@ -1,9 +1,11 @@
 """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.
+No solver or numerical parameter modifications. --without-cylinder removes only the body;
+all other geometry and the production initialization remain unchanged.
 """
 import argparse
+from copy import deepcopy
 import hashlib
 import importlib
 import json
@@ -19,6 +21,63 @@ import numpy as np
 HERE=Path(__file__).resolve().parent
 DEFAULT_SOURCE=HERE.parents[2]
 LIMIT_BYTES=128*1024**2
+HISTORY_LIMIT_BYTES=12*1024**2
+HISTORY_RESERVE_BYTES=64*1024
+
+
+class InletHistory:
+    """Optional copies of existing snapshots only; never changes solver/health stop."""
+    def __init__(self, flags, parameters, limit=HISTORY_LIMIT_BYTES):
+        self.flags = np.array(flags[:, :4], copy=True)
+        self.parameters = parameters
+        self.limit = limit
+        self.frames = []
+        self.steps = []
+        planned_bytes = 197 * (9 * self.flags.shape[0] * 4 * 4 + 24) + self.flags.nbytes
+        if planned_bytes + HISTORY_RESERVE_BYTES > self.limit:
+            raise ValueError('Requested history window exceeds 12 MiB budget')
+
+    def record(self, state):
+        if int(state['step']) > 196:
+            return
+        raw = state['raw']
+        if (raw.dtype != np.float32 or raw.ndim != 3 or raw.shape[0] != 9
+                or raw.shape[1] != self.flags.shape[0] or raw.shape[2] < 4):
+            raise ValueError('History requires raw shifted FP32 D2Q9 with four inlet columns')
+        step = int(state['step'])
+        if step != len(self.steps):
+            raise ValueError('History requires contiguous completed steps starting at zero')
+        frame = raw[:, :, :4]
+        self.frames.append(frame.copy())
+        self.steps.append(step)
+
+    def save(self, output, terminal_step):
+        steps = np.asarray(self.steps, dtype=np.int64)
+        raw = np.stack(self.frames) if self.frames else np.empty((0, 9, self.flags.shape[0], 4), np.float32)
+        path = output / 'inlet_history.npz'
+        np.savez(path, raw_shifted=raw, flags=self.flags, steps=steps,
+                 time_s=steps * self.parameters['dt'],
+                 tstar=steps * self.parameters['mean_speed'] / self.parameters['diameter'],
+                 x_indices=np.arange(4), y_indices=np.arange(self.flags.shape[0]),
+                 requested_step_range=np.array([0,196],np.int64),
+                 diagnostic_terminal_step=np.array(terminal_step,np.int64))
+        size = path.stat().st_size
+        if size > self.limit:
+            raise RuntimeError('History exceeded its reserved artifact bound')
+        return dict(mode='inlet_raw_history', requested_first_step=0, requested_last_step=196,
+                    complete_for_requested_window=len(steps)==197,
+                    diagnostic_terminal_step=int(terminal_step), frames=len(steps),
+                    first_step=None if not len(steps) else int(steps[0]),
+                    last_step=None if not len(steps) else int(steps[-1]),
+                    bytes=size, limit_bytes=self.limit,
+                    sha256=hashlib.sha256(path.read_bytes()).hexdigest(),
+                    layout='time,q,y,x; active postcollision raw shifted FP32; step zero is initialization',
+                    window_policy='Recording stops after step196; evolution and health stopping remain unchanged')
+
+
+def record_history(history, state):
+    if history is not None:
+        history.record(state)


 def dump(path,value):
@@ -30,9 +89,9 @@ def number(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():
+def source_config(source, manifest_path=None):
+    manifest=json.loads((HERE/'source_manifest.json' if manifest_path is None else manifest_path).read_text())
+    for name,digest in {**manifest['sha256'],**manifest.get('runtime_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'))
@@ -47,6 +106,20 @@ def source_config(source):
    return cfg,body,p,manifest


+def select_body(body, without_cylinder=False):
+    selected = deepcopy(body)
+    if without_cylinder:
+        if len(selected["objects"]) != 1 or selected["objects"][0]["type"] != "cylinder":
+            raise ValueError("Bodyless control requires exactly the original cylinder")
+        selected["objects"] = []
+    return selected
+
+
+def body_force(sim, body):
+    # No body means no body-id 0 and no force observable; never fabricate zeros.
+    return sim.read_force(0).astype(np.float64) if body["objects"] else None
+
+
 def categories(flags,p):
    """Disjoint physical categories; subtype nibble is not a bitfield."""
    from CelerisLab.lbm.descriptors import FLUID,SOLID,OBSTACLE
@@ -163,6 +236,8 @@ def execute(a,cfg,body,p):
            sim.initialize()  # Exact original production initialization, unchanged.
            flags=sim.get_flags().reshape(p['ny'],p['nx'])
            current=snapshot(sim,p)
+            history=InletHistory(flags,p) if a.record_inlet_history else None
+            record_history(history,current)
            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:
@@ -172,26 +247,29 @@ def execute(a,cfg,body,p):
                        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)
+                        force=body_force(sim,body)
                        current=snapshot(sim,p)
+                        record_history(history,current)
                        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,
+                            print('READY '+json.dumps(dict(**a.identity,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),
+            details=dict(**a.identity,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.')
+            if history is not None:
+                details['inlet_history']=history.save(a.output,current['step'])
            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)
+            print(json.dumps(dict(**a.identity,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


@@ -200,17 +278,32 @@ def main():
    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('--without-cylinder',action='store_true',
+                        help='Remove only the cylinder for the bounded inlet control')
+    parser.add_argument('--record-inlet-history',action='store_true',
+                        help='Record bounded raw x0..3 history without changing health stopping')
    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)
+    body=select_body(body,a.without_cylinder)
+    from source_provenance import checkout_provenance
+    a.identity=dict(observation_mode='inlet_raw_history' if a.record_inlet_history else 'first_health_pair',
+        history_limit_bytes=HISTORY_LIMIT_BYTES if a.record_inlet_history else None,
+        history_requested_steps=[0,196] if a.record_inlet_history else None,
+        control="without_cylinder" if a.without_cylinder else "baseline_cylinder",
+        force_observation="not_applicable_no_body" if a.without_cylinder else "per_step_body_reaction",
+        baseline_diagnostic_commit="8e378aa047bb35ae4ec46037eff7256bd2f074e7",
+        diagnostic_checkout=checkout_provenance(DEFAULT_SOURCE),
+        numerical_checkout=checkout_provenance(a.source),
+        diagnostic_sha256=hashlib.sha256(Path(__file__).read_bytes()).hexdigest())
    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,
+    dump(a.output/'preflight.json',dict(**a.identity,source=manifest,config=cfg,body=body,parameters=p,
+        max_steps=320,
        max_evidence_bytes=LIMIT_BYTES,executed=False))
    if not a.execute: return 0
    return execute(a,cfg,body,p)
@@ -94,6 +94,38 @@ def test_source_guard_and_deadline():
    with unittest.TestCase().assertRaises(TimeoutError): d.deadline_check(0)


+def test_bodyless_selection_preserves_baseline():
+    from copy import deepcopy
+    baseline_config, baseline_body, baseline_parameters = deepcopy((cfg,body,p))
+    selected = d.select_body(body,True)
+    assert selected == {"objects": []}
+    assert (cfg,body,p) == (baseline_config,baseline_body,baseline_parameters)
+    assert d.select_body(body) == baseline_body
+    assert d.select_body(body) is not body
+    assert p['nx']==1761 and p['ny']==330 and p['mean_speed']==.01
+    assert np.isclose(3*p['viscosity']+.5,.524)
+    for invalid in ({"objects":[]},{"objects":body['objects']*2},
+                    {"objects":[{"type":"other"}]}):
+        with unittest.TestCase().assertRaises(ValueError): d.select_body(invalid,True)
+
+
+def test_absent_force_is_not_zero_or_read():
+    class FakeSimulation:
+        def __init__(self): self.calls=[]
+        def read_force(self,index):
+            self.calls.append(index)
+            return np.array([1.,2.],np.float32)
+    sim=FakeSimulation()
+    assert d.body_force(sim,{"objects":[]}) is None and not sim.calls
+    np.testing.assert_array_equal(d.body_force(sim,body),[1.,2.])
+    assert sim.calls==[0]
+    g,m,f,params=fixture()
+    report=d.diagnose(g,m,None,f,params,1)
+    assert report['force'] is None and not report['force_nonfinite']
+    m['ux'][3,1]=.2
+    assert d.diagnose(g,m,None,f,params,2)['physical_failure']
+
+
 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_')))
@@ -0,0 +1,91 @@
+"""CPU-only fixed-window observation tests; no GPU or simulated acceptance."""
+from contextlib import redirect_stdout
+from io import StringIO
+from pathlib import Path
+from tempfile import TemporaryDirectory
+from types import SimpleNamespace, ModuleType
+from unittest.mock import patch
+import json
+import sys
+import unittest
+import numpy as np
+sys.path.insert(0,str(Path(__file__).resolve().parent))
+import diagnose_uniform_srt as d
+
+
+def test_raw_bits_copy_and_prefix():
+    flags=np.ones((12,20),np.uint16);p=dict(dt=.25,mean_speed=.01,diameter=80)
+    h=d.InletHistory(flags,p)
+    raw=np.arange(9*12*20,dtype=np.uint32).reshape(9,12,20).view(np.float32)
+    raw[0,0,0]=np.float32(-0.)
+    expected=raw[:,:,:4].view(np.uint32).copy()
+    h.record(dict(raw=raw,step=0)); raw.fill(7); flags.fill(0)
+    h.record(dict(raw=raw,step=1))
+    with TemporaryDirectory() as temp:
+        receipt=h.save(Path(temp),1);z=np.load(Path(temp)/'inlet_history.npz')
+        np.testing.assert_array_equal(z['raw_shifted'][0].view(np.uint32),expected)
+        assert np.all(z['flags']==1)
+        np.testing.assert_array_equal(z['steps'],[0,1])
+        np.testing.assert_array_equal(z['time_s'],[0,.25])
+        np.testing.assert_array_equal(z['tstar'],[0,.01/80])
+        assert not receipt['complete_for_requested_window'] and receipt['diagnostic_terminal_step']==1
+
+
+def test_fixed_window_bound_and_late_stop():
+    flags=np.ones((330,1761),np.uint16);p=dict(dt=.1,mean_speed=.01,diameter=80)
+    h=d.InletHistory(flags,p);raw=np.zeros((9,330,4),np.float32)
+    for step in range(321):h.record(dict(raw=raw,step=step))
+    assert len(h.frames)==197
+    with TemporaryDirectory() as temp:
+        r=h.save(Path(temp),320)
+        assert r['complete_for_requested_window'] and r['last_step']==196 and r['diagnostic_terminal_step']==320
+        assert r['bytes']<d.HISTORY_LIMIT_BYTES
+    with unittest.TestCase().assertRaises(ValueError):d.InletHistory(flags,p,limit=100)
+    with unittest.TestCase().assertRaises(ValueError):
+        d.InletHistory(flags,p).record(dict(raw=np.zeros((9,331,4),np.float32),step=0))
+
+
+def test_off_by_default():
+    import subprocess
+    with TemporaryDirectory() as temp:
+        subprocess.run([sys.executable,str(Path(d.__file__)),'--output',temp],check=True,capture_output=True)
+        r=json.loads((Path(temp)/'preflight.json').read_text())
+        assert r['observation_mode']=='first_health_pair' and r['history_requested_steps'] is None
+        assert not (Path(temp)/'inlet_history.npz').exists()
+    # Off-path must not inspect or modify observation state.
+    d.record_history(None,object())
+
+
+def test_execution_identical_and_failure_included():
+    class Sim:
+        def __init__(self,*args,**kwargs):self.stepper=SimpleNamespace(step_count=0);self.calls=[]
+        def __enter__(self):instances.append(self);return self
+        def __exit__(self,*args):pass
+        def initialize(self):self.calls.append('initialize')
+        def get_flags(self):return np.ones((12,20),np.uint16)
+        def run(self,n):self.calls.append(('run',n));self.stepper.step_count+=n
+    module=ModuleType('CelerisLab.simulation');module.Simulation=Sim
+    def snapshot(sim,p):
+        raw=np.full((9,12,20),sim.stepper.step_count,np.float32)
+        return dict(raw=raw,g=raw.copy(),macro={},step=sim.stepper.step_count)
+    def diagnose(g,m,f,flags,p,step):return dict(physical_failure=step==3)
+    p=dict(ny=12,nx=20,dt=.1,mean_speed=.01,diameter=80);instances=[];details=[]
+    def save(output,prev,current,flags,report):details.append((prev['step'],current['step'],report));return 0
+    with patch.dict(sys.modules,{'CelerisLab.simulation':module}),patch.object(d,'snapshot',snapshot),patch.object(d,'diagnose',diagnose),patch.object(d,'save_states',save),redirect_stdout(StringIO()):
+        for enabled in [False,True]:
+            with TemporaryDirectory() as temp:
+                a=SimpleNamespace(wall_seconds=100,output=Path(temp),identity={},record_inlet_history=enabled)
+                assert d.execute(a,{},dict(objects=[]),p)==2
+                if enabled:
+                    z=np.load(Path(temp)/'inlet_history.npz')
+                    np.testing.assert_array_equal(z['steps'],[0,1,2,3])
+                    assert np.all(z['raw_shifted'][-1]==3)
+                    assert details[-1][2]['inlet_history']['diagnostic_terminal_step']==3
+    assert instances[0].calls==instances[1].calls==['initialize',('run',1),('run',1),('run',1)]
+    assert [(p,c) for p,c,_ in details]==[(2,3),(2,3)]
+    assert details[0][2]['status']==details[1][2]['status']=='first_physical_failure'
+
+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())
@@ -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.
@@ -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
-}
@@ -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.
@@ -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
-}
@@ -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"
-}
@@ -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
@@ -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"
-}
@@ -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
@@ -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"
-}
@@ -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
@@ -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"
-}
@@ -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"
-}
@@ -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
@@ -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"
-}
@@ -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.
@@ -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"
-}
@@ -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.
@@ -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"
-}
@@ -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.
@@ -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"
-}
@@ -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.
@@ -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"
-}
@@ -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
@@ -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"
-}
@@ -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
@@ -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"
-}
@@ -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
@@ -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"
-}
@@ -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.
@@ -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"
-}
@@ -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.
@@ -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"
-}
@@ -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.
Author	SHA1	Message	Date
TRON	c0be841b2e	test: prepare isolated uniform full9 DFG pilot	2026-10-18 09:41:10 -07:00
TRON	939c10c867	test: pin isolated full9 bodyless inlet comparison	2026-10-18 09:18:47 -07:00
TRON	926ca27407	experiment: isolate full-state regularized west velocity inlet	2026-10-18 09:16:25 -07:00
TRON	e92de37424	test: add opt-in fixed-window inlet population history	2026-10-18 08:48:34 -07:00
TRON	66a2741050	test: add cylinder-free control for bounded SRT inlet diagnosis	2026-10-18 08:01:01 -07:00