test: preserve bounded historical replay and document versioned assessment

tests/validation/cycle_v2/PLAN.md

@@ -0,0 +1,17 @@
+# Frozen CPU-only cycle-assessor v2 plan
+
+Predeclared before evaluating v2 acceptance on archived flows, 2026-10-18.
+
+Cycle boundaries are every ascending lift Cl=0 crossing, found by linear interpolation between consecutive samples with Cl<0 then Cl>=0. Direction and zero level are fixed. No smoothing, optimized window, fitted phase, or alternative-method selection. Exact sampled zeros count once. Existing period2..5, lift amplitude>=.2, five recent consecutive cycles, period variation<=.005, extrema variation<=.005, mass/flux gates and official-reference tolerances remain unchanged.
+
+Complete cycles are resampled on257 evenly spaced phase points with the existing linear interpolation, extrema and trapezoidal integration. Force timing remains interval midpoint; pressure/mass/flux use their end-sample times. Partial cycles are excluded; implausible periods are rejected, and missing cycles must still fail consecutiveness. No density, collision, geometry, initialization, outlet or flow-data change.
+
+Official reference is rebuilt from the same pinned archive, lv6/dt4 line forces and pressure values, selecting its last complete ascending-crossing cycle. It uses the same v2 phase convention for scalar and waveform comparison. Original trough-phase reference and frozen422e549 assessment remain unchanged.
+
+Qualification order:
+1. Independent review of this definition and plan.
+2. Synthetic constant-period sinusoidal/harmonic signals sampled at dt*=.02, with fixed deterministic small perturbations confined to extrema; false local extrema must not create cycles. Test exact-zero ties, zero offset phase, genuine period drift above.005, low amplitude, insufficient cycles, invalid/nonfinite/nonmonotone input, and missing/extra crossings. No fitted noise parameters.
+3. Reanalyse official source waveform, archived full9 uniform data, and archived MRT uniform/refined data. Report every case and every gate, old and v2 side by side, including failures. No favorable-window selection.
+4. Independent code/result review. Write versioned reanalysis receipts with input hashes, assessor hash/version, reference construction and gates. Do not overwrite original results or alter the original failed exit2.
+
+Scope: DFG shedding signals with recurrent sign-changing lift. This does not define a universal cycle detector for signals without zero crossings. New acceptance is a separately identified measurement, never a claim that the historical frozen assessor passed.

tests/validation/cycle_v2/README.md

@@ -0,0 +1,27 @@
+# DFG ascending-zero assessor v2
+
+This CPU-only measurement correction is separate from the frozen assessor. It changes cycle boundaries, not numerical flow data or any gate value. PLAN.md was committed at1ca3bb8 before archived v2 outcomes; the crossing algorithm was committed at2369949 before those evaluations. No flow run is included.
+
+Every consecutive ascending Cl<0 to Cl>=0 crossing defines a candidate cycle. Times are linearly interpolated, with no suppression, smoothing or prominence choices. Fixed period/amplitude plausibility and all existing five-cycle, consecutive, recent, extrema, mass, flux and reference gates are reused. Invalid intervals are not reconnected across gaps. This definition is specific to sign-changing DFG shedding lift; no-zero or poorly sampled signals need another explicitly reviewed measurement, not silent fallback.
+
+Cycle extrema and trapezoidal integrals retain the existing257-point phase grid. Force uses midpoint time, pressure/mass/flux endpoint time. The official raw lv6/dt4 reference is rebuilt in the same ascending phase, using its last complete cycle over the entire supplied shared time coverage. Original trough-phase reference files are untouched. Raw pressure columns7 minus12 are interpolated at force sample times; physical time is multiplied by10. Reference mass/flux placeholders are not measured conservation evidence.
+
+`reanalyse.py` verifies the official archive hash, exact CSV equality to original summaries, and identical frozen gate outcomes. It reports any floating-point difference when replaying old cycle statistics instead of claiming bitwise identity across numerical library environments. All five supplied histories are reported, with their input/summary/code hashes, original identity, old and v2 results. Its new receipt is called reanalysis.json and cannot overwrite an existing output directory. It does not change the old run's exit code or accuracy_qualified field.
+
+Tests include constant and noncommensurate/asymmetric signals, fixed small peak noise, explicit false local extrema, genuine period drift above the unchanged gate, low amplitude, insufficient cycles, zero plateaus, extra/missing crossings, missing sample points, invalid data and coverage. The algorithm is still vulnerable to sign noise and aliasing near a crossing; these tests are bounded validation, not universal robustness proof. Synthetic source conditions and perturbations are specified in the test file, not fitted to flow results.
+
+Run tests:
+
+```
+python tests/validation/cycle_v2/test_periodic_v2.py
+```
+
+Reanalyse with every archived case named explicitly:
+
+```
+python tests/validation/cycle_v2/reanalyse.py --official-archive <pinned-official.zip> --history full9=<full9-history.csv> --history mrt_uniform=<mrt-uniform-history.csv> --history mrt_refined=<mrt-refined-history.csv> --output <new-directory>
+```
+
+Each history needs its original summary.json alongside it. Multiple observer variants may be listed separately; duplicate refined histories are not independent physical replications. Historical data and thresholds remain untouched. Any future production-run use requires explicit integration/review; this module does not alter default assessors.
+
+Frozen replay integrity permits at most1e-10 absolute floating difference per stored cycle number, with identical schema, counts and gate decisions. This is a CPU replay check only, not a change to physical accuracy or convergence thresholds. Actual archived uniform MRT differences were at most1.081e-13; other replayed cycle statistics matched exactly.

tests/validation/cycle_v2/periodic_v2.py

@@ -0,0 +1,102 @@
+"""Versioned ascending-zero DFG measurement; original data and gates unchanged."""
+
+import numpy as np
+
+from periodic import GATES, REFERENCE_GATES, compare
+
+VERSION = "dfg-ascending-zero-v2"
+
+
+def ascending_crossings(t, y):
+    t = np.asarray(t, dtype=float); y = np.asarray(y, dtype=float)
+    if t.ndim != 1 or y.shape != t.shape or not np.isfinite(t).all() or not np.isfinite(y).all():
+        raise ValueError("Finite one-dimensional time/signal arrays required")
+    if np.any(np.diff(t) <= 0):
+        raise ValueError("Strictly increasing times required")
+    i = np.flatnonzero((y[:-1] < 0) & (y[1:] >= 0))
+    return (t[i] - y[i] * (t[i+1] - t[i]) / (y[i+1] - y[i])).tolist()
+
+
+def validate_rows(rows):
+    keys = ("tstar", "tstar_force", "cd", "cl", "dp", "mass", "flux_in", "flux_out")
+    values = np.asarray([[row[k] for k in keys] for row in rows], dtype=float)
+    if not np.isfinite(values).all():
+        raise ValueError("Nonfinite observation")
+    if len(rows) and (np.any(np.diff(values[:, 0]) <= 0) or np.any(np.diff(values[:, 1]) <= 0)):
+        raise ValueError("Strictly increasing observation times required")
+
+
+def extract(rows, min_time=250.0):
+    validate_rows(rows)
+    if len(rows) < 3:
+        return []
+    t = np.array([r["tstar_force"] for r in rows])
+    cl = np.array([r["cl"] for r in rows])
+    ends = ascending_crossings(t, cl)
+    cycles = []
+    for a, b in zip(ends, ends[1:]):
+        if a < min_time or not GATES["min_period"] < b - a < GATES["max_period"]:
+            continue
+        grid = np.linspace(a, b, 257)
+        c = dict(start=a, end=b, period=b - a, st=1 / (b - a))
+        for key in ("cd", "cl", "dp", "mass", "flux_in", "flux_out"):
+            times = np.array(
+                [r["tstar" if key not in ("cd", "cl") else "tstar_force"] for r in rows]
+            )
+            # No endpoint extrapolation: pressure/mass must cover the whole cycle.
+            if a < times[0] or b > times[-1]:
+                break
+            v = np.interp(grid, times, [r[key] for r in rows])
+            c[key + "_min"] = float(v.min())
+            c[key + "_max"] = float(v.max())
+            c[key + "_midrange"] = float((v.min() + v.max()) / 2)
+            c[key + "_amplitude"] = float(v.max() - v.min())
+            c[key + "_time_mean"] = float(
+                np.sum((v[1:] + v[:-1]) * np.diff(grid) / 2) / (b - a)
+            )
+            if key in ("cd", "cl", "dp"):
+                c[key + "_waveform"] = v.tolist()
+        else:
+            c["flux_relative"] = abs(
+                c["flux_in_time_mean"] - c["flux_out_time_mean"]
+            ) / max(abs(c["flux_in_time_mean"]), 1e-30)
+            cycles.append(c)
+    return cycles
+
+
+def assess(rows):
+    cycles = extract(rows, min_time=GATES["min_tstar"])
+    tail = cycles[-GATES["cycles"] :]
+    checks = {}
+    checks["enough_cycles"] = len(tail) == GATES["cycles"]
+    if checks["enough_cycles"]:
+        checks["consecutive"] = all(
+            abs(a["end"] - b["start"]) < 1e-8 for a, b in zip(tail, tail[1:])
+        )
+        checks["recent"] = (
+            0 <= rows[-1]["tstar_force"] - tail[-1]["end"] <= GATES["max_period"]
+        )
+        checks["shedding"] = (
+            min(c["cl_amplitude"] for c in tail) >= GATES["min_lift_amplitude"]
+        )
+        periods = [c["period"] for c in tail]
+        checks["period"] = (
+            np.ptp(periods) / np.mean(periods) <= GATES["period_relative_range"]
+        )
+        checks["extrema"] = all(
+            np.ptp([c[k + "_" + e] for c in tail]) <= GATES["extrema_absolute_range"]
+            for k in ("cd", "cl", "dp")
+            for e in ("min", "max")
+        )
+        mass = [c["mass_time_mean"] for c in tail]
+        checks["mass"] = (
+            np.ptp(mass) / abs(np.mean(mass)) <= GATES["mass_relative_range"]
+        )
+        checks["flux"] = (
+            max(c["flux_relative"] for c in tail) <= GATES["cycle_mean_flux_relative"]
+        )
+    return dict(
+        periodic=bool(checks["enough_cycles"] and all(checks.values())),
+        checks={k: bool(v) for k, v in checks.items()},
+        cycles=cycles,
+    )

tests/validation/cycle_v2/reanalyse.py

@@ -0,0 +1,112 @@
+"""Versioned read-only DFG reanalysis; never overwrites a flow receipt."""
+import argparse
+import csv
+import hashlib
+import io
+import json
+from pathlib import Path
+import sys
+import zipfile
+import numpy as np
+sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
+import periodic as frozen
+import periodic_v2 as v2
+
+OFFICIAL_SHA256 = '08db59605b2f60efc512d2bbc79628ea5d1cc720c0986938a16920884a0215be'
+PREFIX = 'logs/results_cc2d_bench2_referencenew/'
+
+
+def sha(path): return hashlib.sha256(Path(path).read_bytes()).hexdigest()
+
+
+def official_reference(path):
+    if sha(path) != OFFICIAL_SHA256: raise ValueError('Wrong official archive')
+    with zipfile.ZipFile(path) as z:
+        force = np.loadtxt(io.BytesIO(z.read(PREFIX+'bdforces_q2_lv6_dt4')))
+        pressure = np.loadtxt(io.BytesIO(z.read(PREFIX+'pointvalues_q2_lv6_dt4')))
+    tf=force[:,1]*10; tp=pressure[:,1]*10
+    if not np.isfinite(force).all() or not np.isfinite(pressure).all():
+        raise ValueError('Nonfinite official input')
+    if np.any(np.diff(tf)<=0) or np.any(np.diff(tp)<=0): raise ValueError('Official time order')
+    # Entire supplied interval, restricted only to shared force/pressure coverage.
+    mask=(tf>=tp[0])&(tf<=tp[-1]); force=force[mask]; tf=tf[mask]
+    dp=np.interp(tf,tp,pressure[:,6]-pressure[:,11])
+    rows=[dict(tstar=float(t),tstar_force=float(t),cd=float(f[3]),cl=float(f[4]),dp=float(p),
+               mass=1.,flux_in=1.,flux_out=1.) for t,f,p in zip(tf,force,dp)]
+    cycles=v2.extract(rows,min_time=0.)
+    if not cycles: raise ValueError('No complete official cycle')
+    ref=cycles[-1]
+    return ref,dict(archive_sha256=OFFICIAL_SHA256,selection='lv6/dt4 last complete ascending Cl=0 cycle in entire shared input coverage',
+        eligible_time=[float(tf[0]),float(tf[-1])],complete_cycles=len(cycles),
+        pressure='columns7 minus12, interpolated at original force times; physical time multiplied by10',
+        artificial_fields='mass/flux placeholders only; official archive is not used to certify conservation')
+
+
+def frozen_replay_difference(current_cycles, archived_cycles):
+    """Integrity-only FP replay allowance, not a physical acceptance threshold."""
+    if len(current_cycles) != len(archived_cycles):
+        raise ValueError('Frozen cycle count differs from original')
+    deltas=[]
+    for current, archived in zip(current_cycles, archived_cycles):
+        if current.keys()!=archived.keys(): raise ValueError('Frozen cycle schema differs')
+        for key in current:
+            x=np.asarray(current[key]); y=np.asarray(archived[key])
+            if x.shape!=y.shape or not np.isfinite(x).all() or not np.isfinite(y).all():
+                raise ValueError('Frozen cycle shape or finite-state mismatch')
+            deltas.append(float(np.max(np.abs(x-y))))
+    difference=max(deltas,default=0.)
+    if difference>1e-10: raise ValueError('Frozen replay exceeds FP integrity allowance')
+    return difference
+
+
+def main():
+    parser=argparse.ArgumentParser(description=__doc__)
+    parser.add_argument('--official-archive',type=Path,required=True)
+    parser.add_argument('--history',action='append',required=True,help='Unique label=CSV path; all cases reported')
+    parser.add_argument('--output',type=Path,required=True)
+    a=parser.parse_args()
+    if a.output.exists(): raise ValueError('Use a new output directory')
+    cases=[]; labels=set()
+    reference,reference_info=official_reference(a.official_archive)
+    old_ref_path=Path(frozen.__file__).parent/'data/dfg_re100/reference_cycle.json'
+    old_ref=json.loads(old_ref_path.read_text())
+    for item in a.history:
+        label,path=item.split('=',1); path=Path(path)
+        if label in labels: raise ValueError('Duplicate case label')
+        labels.add(label)
+        rows=[{k:float(v) for k,v in r.items()} for r in csv.DictReader(path.open())]
+        source_receipt_path=path.with_name('summary.json')
+        source_receipt=json.loads(source_receipt_path.read_text())
+        if rows != source_receipt.get('history'):
+            raise ValueError('CSV differs from original summary history')
+        v2.validate_rows(rows)
+        old=frozen.assess(rows); new=v2.assess(rows)
+        for key in ('periodic', 'checks'):
+            if old[key] != source_receipt.get(key):
+                raise ValueError('Frozen reassessment differs from original summary')
+        replay_difference=frozen_replay_difference(old['cycles'],source_receipt['cycles'])
+        old_comparison=frozen.compare(old['cycles'][-1],old_ref) if old['cycles'] else None
+        new_comparison=v2.compare(new['cycles'][-1],reference) if new['cycles'] else None
+        # This is assessment of recorded observables, not proof of unrecorded population health.
+        healthy=bool(rows and all(.5<=r['rho_min']<=r['rho_max']<=1.5 and 0<=r['max_mach']<=.2 for r in rows))
+        cases.append(dict(label=label,input_csv_sha256=sha(path),
+            original_summary_sha256=sha(source_receipt_path),
+            frozen_cycle_max_absolute_replay_difference=replay_difference,
+            original_identity={k:source_receipt[k] for k in ('case','collision','observation_mode','numerical_source_commit','checkout','checkout_revision','mode','status') if k in source_receipt},
+            observations=len(rows),
+            recorded_end_tstar=rows[-1]['tstar'] if rows else None,recorded_observations_healthy=healthy,
+            frozen=old,frozen_reference=old_comparison,v2=new,v2_reference=new_comparison,
+            v2_recorded_observable_agreement=bool(healthy and new['periodic'] and new_comparison and new_comparison['reference_agreement'])))
+    a.output.mkdir(parents=True)
+    result=dict(assessment_version=v2.VERSION,original_receipts_unchanged=True,
+        phase='Every ascending Cl<0 to Cl>=0 crossing; linear interpolation, no suppression',
+        gates=v2.GATES,reference_gates=v2.REFERENCE_GATES,reference=reference,reference_provenance=reference_info,
+        code_sha256={Path(p).name:sha(p) for p in [__file__,v2.__file__,frozen.__file__]},
+        frozen_reference_sha256=sha(old_ref_path),cases=cases)
+    (a.output/'reanalysis.json').write_text(json.dumps(result,indent=2,allow_nan=False)+'\n')
+    print(json.dumps([dict(case=c['label'],old_periodic=c['frozen']['periodic'],
+        v2_checks=c['v2']['checks'],v2_reference=c['v2_reference'],
+        recorded_observable_agreement=c['v2_recorded_observable_agreement']) for c in cases],indent=2))
+
+
+if __name__=='__main__': main()

tests/validation/cycle_v2/test_periodic_v2.py

@@ -0,0 +1,108 @@
+"""Predeclared synthetic measurement tests; no flow outcome is used for tuning."""
+from pathlib import Path
+import sys
+import unittest
+import numpy as np
+sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
+import periodic
+import periodic_v2 as v2
+
+
+def signal(periods=None, noise=0., offset=0., amplitude=1., irregular=False, harmonic=0.):
+    periods = np.full(20, 3.3) if periods is None else np.asarray(periods)
+    boundaries = 250.37 + np.r_[0., np.cumsum(periods)]
+    t = np.arange(boundaries[0]-.1, boundaries[-1]+.1, .02)
+    if irregular: t = t[np.arange(len(t)) % 7 != 0]
+    phase = np.interp(t, boundaries, np.arange(len(boundaries))) * 2*np.pi
+    lift = amplitude*(np.sin(phase) + harmonic*np.sin(2*phase)) + offset
+    # Fixed seed and fixed peak-local mask; not fitted to any flow dataset.
+    lift += noise*np.random.default_rng(1729).uniform(-1,1,len(t))*(abs(np.sin(phase))>.9)
+    return [dict(tstar=x+.01, tstar_force=x, cl=l,
+                 cd=3.2+.03*np.cos(2*p), dp=2.45+.05*np.cos(p),
+                 mass=1., flux_in=1., flux_out=1.) for x,l,p in zip(t,lift,phase)]
+
+
+def test_constant_period_peak_noise_and_mean_offset():
+    for noise, offset in [(0.,0.),(.0001,0.),(.001,0.),(.001,.08)]:
+        result=v2.assess(signal(noise=noise,offset=offset))
+        assert result['periodic'], result['checks']
+        periods=np.array([c['period'] for c in result['cycles'][-5:]])
+        assert max(abs(periods-3.3))<1e-5
+
+
+def test_noncommensurate_asymmetric_waveform():
+    result=v2.assess(signal(periods=[3.313]*20,harmonic=.1,offset=.08,noise=.001))
+    assert result['periodic'], result['checks']
+    periods=np.array([c['period'] for c in result['cycles'][-5:]])
+    assert max(abs(periods-3.313))<5e-5
+
+
+def test_false_local_extrema_do_not_split_cycles():
+    rows=signal()
+    y=np.array([r['cl'] for r in rows])
+    # A fixed .002 dip at every positive peak creates a local minimum while
+    # preserving all zero crossings. This is the predeclared false-extremum case.
+    peaks=np.flatnonzero((y[1:-1]>y[:-2]) & (y[1:-1]>=y[2:]) & (y[1:-1]>.9))+1
+    for i in peaks: rows[i]['cl']-=.002
+    assert v2.assess(rows)['periodic']
+    assert not periodic.assess(rows)['periodic']
+
+
+def test_true_drift_is_rejected():
+    result=v2.assess(signal(periods=np.arange(20)*.01+3.2))
+    assert not result['periodic'] and not result['checks']['period']
+    measured=np.array([c['period'] for c in result['cycles'][-5:]])
+    assert np.ptp(measured)/np.mean(measured)>.005
+
+
+def test_insufficient_cycles_and_amplitude():
+    assert not v2.assess(signal(periods=[3.3]*4))['periodic']
+    result=v2.assess(signal(amplitude=.05))
+    assert not result['periodic'] and not result['checks']['shedding']
+
+
+def test_exact_zero_plateau_and_crossing_noise():
+    assert v2.ascending_crossings([0,1,2,3,4,5],[-1,0,0,1,-1,0])==[1.,5.]
+    # All crossings retained, even a short sign reversal: no hidden debounce.
+    assert len(v2.ascending_crossings([0,1,2,3,4,5],[-1,.001,-.001,.001,1,2]))==2
+    assert v2.ascending_crossings([0,1,2],[1,.1,2])==[]
+
+
+def test_extra_and_missing_cycles_not_reconnected():
+    for last in [[3.3,.2,3.1,3.3],[3.3,6.6,3.3,3.3]]:
+        result=v2.assess(signal(periods=[3.3]*12+last))
+        assert not result['periodic'] and not result['checks']['consecutive']
+
+
+def test_invalid_inputs_and_irregular_sampling():
+    for t,y in [([0,0],[-1,1]),([1,0],[-1,1]),([0,1],[-1,float('nan')])]:
+        with unittest.TestCase().assertRaises(ValueError):v2.ascending_crossings(t,y)
+    rows=signal();rows[1]['dp']=float('inf')
+    with unittest.TestCase().assertRaises(ValueError):v2.assess(rows)
+    assert v2.assess(signal(irregular=True))['periodic']
+
+
+def test_coverage_and_unchanged_gates():
+    rows=signal()
+    cycles=v2.extract(rows,min_time=250.)
+    # Move end-sample coverage late; force remains unchanged. Partial cycles excluded.
+    delayed=[dict(r,tstar=r['tstar']+10.) for r in rows]
+    other=v2.extract(delayed,min_time=250.)
+    assert len(other)<len(cycles) and all(c['start']>=delayed[0]['tstar'] for c in other)
+    assert v2.GATES is periodic.GATES and v2.REFERENCE_GATES is periodic.REFERENCE_GATES
+    assert v2.compare is periodic.compare
+
+
+def test_frozen_replay_integrity_allowance():
+    from reanalyse import frozen_replay_difference
+    baseline=[dict(period=3.3,wave=[0.,1.,0.])]
+    assert frozen_replay_difference(baseline,[dict(period=3.3+1e-13,wave=[0.,1.,0.])])<1e-10
+    for bad in [[dict(period=3.3+1e-6,wave=[0.,1.,0.])],
+                [dict(period=float('nan'),wave=[0.,1.,0.])],[]]:
+        with unittest.TestCase().assertRaises(ValueError): frozen_replay_difference(baseline,bad)
+
+
+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())

tests/validation/experimental_full9/DFG_FULL.md

@@ -0,0 +1,43 @@
+# Uniform full-nine DFG qualification
+
+This is a separate full-run entrypoint. The pilot wrapper, pilot manifest, shared observer, reference data, gates and all production files remain byte-identical to c0be841. Numerical source remains 926ca27407c26ca11283282a6e53249925725376; actual execution HEAD is recorded separately. A new full manifest pins the added wrapper and the original pilot manifest.
+
+## Admission and case
+
+Require the completed exact c0be841 uniform SRT/full9 cylinder pilot directory, including result.json, preflight.json and uniform/ready.json. Admission checks finite complete pilot history, collision/inlet/case/observation/source identity, physical configuration, body, parameters, frozen gates, READY, clean checkout and positive timings. Bodyless, MRT, refined, stale-source or malformed receipts cannot admit this run.
+
+Restart from the unchanged original production initialization, not a pilot continuation. Keep D80, lattice mean U=.01, viscosity=.008, tau=.524, shifted FP32 double buffer, cylinder/walls/domain, no LES/force, and pressure-NEQ outlet all-nine damping .5. Only the already tested experimental inlet differs from the historical baseline.
+
+Maximum 2,400,000 steps to t*=300. Reuse the existing observer: t*=.5 intervals before240, then .02 through300. All force batches are included; force time is the interval midpoint, pressure time its endpoint. Early calibration remains accounted in the physical trajectory. Sparse health checks identify first observed failure, not exact onset. Timeout retains progress.
+
+Success requires the full physical cap, healthy completion, frozen periodic convergence AND official-reference agreement. Healthy completion alone or periodicity alone returns failure. The project tolerances remain unchanged; the reference data are official DFG data. This does not qualify a canonical do-nothing outlet, grid convergence, AMR, MRT, LES or other precision paths.
+
+## Cost and bounds
+
+Measured pilot startup: 3.3353 s. Step plus force: 3.6794 s for 40,000 steps. Linear step-work extrapolation is 220.764 s, before additional late-time dense observations and altered batch subdivision. The full observer has 3,480 intervals (480 sparse and 3,000 dense), compared with 10 pilot intervals. Prior same-size MRT full runs took 354–373 s total. Expect several minutes, with timing reported rather than promised.
+
+Internal cap: 720 s maximum. Outer watchdog: 900 s, then 30 s termination grace. The wrapper rejects a larger internal cap. Expiry preserves an incomplete result and does not qualify accuracy. No GPU execution is performed during preparation.
+
+## Commands
+
+CPU tests:
+
+```
+python tests/validation/experimental_full9/test_dfg_full.py
+python tests/validation/experimental_full9/test_dfg.py
+python tests/validation/experimental_full9/test_full9.py
+```
+
+Preflight against the actual retained pilot directory:
+
+```
+python tests/validation/experimental_full9/run_dfg_full.py --pilot-results <actual-c0be841-pilot-directory> --output <new-preflight-directory>
+```
+
+After independent review and explicit full-run admission:
+
+```
+CUDA_VISIBLE_DEVICES=<admitted-device> timeout --signal=TERM --kill-after=30s 900s python tests/validation/experimental_full9/run_dfg_full.py --pilot-results <actual-c0be841-pilot-directory> --execute --gpu-admitted --wall-seconds 720 --output output/new-full9-dfg-full
+```
+
+The four admission tests use clearly labeled synthetic receipts. They are host regression fixtures, not measured pilot evidence. Runtime admission uses the actual retained pilot receipts.

tests/validation/experimental_full9/dfg_full_source_manifest.json

@@ -0,0 +1,123 @@
+{
+  "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",
+    "tests/validation/experimental_full9/run_dfg_full.py": "b82f3fcab73f20ce86394a4de80022022434215b3e07fa9aaf5cbd8118413ef1",
+    "tests/validation/experimental_full9/dfg_source_manifest.json": "f5b7ebfc136555f5cdfebd95b886bd8263491f27b8abd723bbe76c9b1aeba476"
+  },
+  "experiment": "uniform_full9_dfg_full_qualification"
+}

tests/validation/experimental_full9/run_dfg_full.py

@@ -0,0 +1,115 @@
+"""Separately admitted full uniform DFG qualification after the pinned sparse pilot."""
+import argparse
+import hashlib
+import json
+import math
+import os
+from pathlib import Path
+import sys
+import time
+
+HERE = Path(__file__).resolve().parent
+sys.path.insert(0, str(HERE))
+import run_dfg as pilot
+
+OBSERVATION = 'uniform_standard_full_v1'
+
+
+def configuration(source):
+    cfg, body, parameters, pilot_manifest = pilot.configuration(source)
+    _, _, _, full_manifest = pilot.diagnostic.source_config(source, HERE / 'dfg_full_source_manifest.json')
+    return cfg, body, parameters, pilot_manifest, full_manifest
+
+
+def admit_pilot(path, cfg, body, parameters, manifest):
+    import run_refined_dfg as runner
+    expected = pilot.identity(manifest)
+    result = runner.read_finite_json(path / 'result.json')
+    preflight = runner.read_finite_json(path / 'preflight.json')
+    ready = runner.read_finite_json(path / 'uniform/ready.json')
+    pilot.verify_pilot(result, expected)
+    for name, document in [('preflight', preflight), ('ready', ready)]:
+        if any(document.get(k) != v for k, v in expected.items()):
+            raise ValueError('Pilot ' + name + ' identity mismatch')
+    if (preflight.get('config') != cfg or preflight.get('body') != body
+            or preflight.get('parameters') != parameters or preflight.get('source') != manifest
+            or preflight.get('max_steps') != 40000 or preflight.get('cap_tstar') != 5.
+            or preflight.get('observation_width_tstar') != .5
+            or preflight.get('gates') != runner.helpers(pilot.ROOT)[1].GATES
+            or preflight.get('reference_gates') != runner.helpers(pilot.ROOT)[1].REFERENCE_GATES):
+        raise ValueError('Pilot physical plan or gates mismatch')
+    if (ready.get('case') != 'uniform' or ready.get('mode') != 'pilot'
+            or ready.get('step') != 4000 or ready.get('tstar') != .5
+            or ready.get('runner_sha256') != runner.runner_hash()
+            or ready.get('all_runtime_and_observation_paths_exercised') is not True
+            or ready.get('calibration_batches_seconds') != result.get('calibration_batches_seconds')):
+        raise ValueError('Pilot READY mismatch')
+    checkout = result.get('checkout')
+    if (checkout != preflight.get('checkout') or checkout != ready.get('checkout')
+            or not isinstance(checkout, dict) or checkout.get('checkout_dirty') is not False
+            or checkout.get('checkout_revision') != 'c0be841b2e6e1ccba3b8343cecd3cee2fe0ed14f'):
+        raise ValueError('Pilot checkout provenance mismatch')
+    for key in ['startup_seconds', 'step_seconds', 'wall_seconds']:
+        value = result.get(key)
+        if isinstance(value, bool) or not isinstance(value, (float, int)) or value <= 0:
+            raise ValueError('Invalid pilot timing')
+    return dict(result_sha256=hashlib.sha256((path/'result.json').read_bytes()).hexdigest(),
+                checkout=checkout, startup_seconds=result['startup_seconds'],
+                step_seconds=result['step_seconds'], wall_seconds=result['wall_seconds'],
+                step_force_scaled_seconds=60 * result['step_seconds'])
+
+
+def qualified(result):
+    return (result.get('mode') == 'full' and result.get('case') == 'uniform'
+            and result.get('steps') == 2400000 and result.get('executed_steps') == 2400000
+            and pilot.accuracy_pass(result))
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument('--source', type=Path, default=pilot.ROOT)
+    parser.add_argument('--output', type=Path, required=True)
+    parser.add_argument('--pilot-results', 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=720.)
+    a = parser.parse_args(); a.source = a.source.resolve()
+    cfg, body, parameters, pilot_manifest, full_manifest = configuration(a.source)
+    import run_refined_dfg as runner
+    from source_provenance import checkout_provenance
+    h, periodic = runner.helpers(a.source)
+    admission = admit_pilot(a.pilot_results, cfg, body, parameters, pilot_manifest)
+    if not math.isfinite(a.wall_seconds) or not 0 < a.wall_seconds <= 720:
+        raise ValueError('Full-run internal ceiling must be positive and at most720 seconds')
+    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 = dict(experimental_variant=pilot.VARIANT, collision='SRT', control='with_cylinder',
+        observation_mode=OBSERVATION, numerical_source_commit=full_manifest['commit'],
+        manifest_sha256=hashlib.sha256((HERE/'dfg_full_source_manifest.json').read_bytes()).hexdigest(),
+        checkout=checkout_provenance(pilot.ROOT), pilot_admission=admission)
+    pilot.diagnostic.dump(a.output/'preflight.json', dict(**receipt, config=cfg, body=body,
+        parameters=parameters, source=full_manifest, max_steps=2400000, cap_tstar=300.,
+        observations='t*=.5 before240; .02 thereafter; forces at interval midpoint, pressure at endpoint',
+        initialization='Original production initialization; restart, no pilot continuation',
+        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 = 'full'; a.deadline = time.monotonic() + a.wall_seconds
+    progress = {}
+    try:
+        result = runner.run_case(a, h, periodic, 'uniform', inlet_scheme=pilot.VARIANT,
+                                sparse_pilot=True, receipt_identity=receipt, progress=progress)
+    except TimeoutError:
+        pilot.diagnostic.dump(a.output/'result.json', dict(**receipt, status='wall_time_limit',
+            healthy=False, accuracy_qualified=False, **progress))
+        return 3
+    passed = qualified(result)
+    pilot.diagnostic.dump(a.output/'result.json', dict(**result, accuracy_qualified=passed))
+    return 0 if passed else 2
+
+
+if __name__ == '__main__':
+    raise SystemExit(main())

tests/validation/experimental_full9/test_dfg_full.py

@@ -0,0 +1,97 @@
+"""CPU-only full admission and unchanged observer tests; fixture receipts are synthetic."""
+from copy import deepcopy
+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_full as f
+import test_dfg as pilot_tests
+
+
+def fixture(path):
+    cfg, body, parameters, manifest, _ = f.configuration(f.pilot.ROOT)
+    import run_refined_dfg as runner
+    _, periodic = runner.helpers(f.pilot.ROOT)
+    expected, result = pilot_tests.receipt()
+    checkout = dict(checkout_revision='c0be841b2e6e1ccba3b8343cecd3cee2fe0ed14f', checkout_dirty=False)
+    result.update(checkout=checkout, startup_seconds=3.3353, step_seconds=3.6794, wall_seconds=8.)
+    preflight = dict(**expected, checkout=checkout, config=cfg, body=body, parameters=parameters,
+                     source=manifest, max_steps=40000, cap_tstar=5., observation_width_tstar=.5,
+                     gates=periodic.GATES, reference_gates=periodic.REFERENCE_GATES)
+    ready = dict(**expected, checkout=checkout, case='uniform', mode='pilot', step=4000,
+                 tstar=.5, runner_sha256=runner.runner_hash(),
+                 all_runtime_and_observation_paths_exercised=True,
+                 calibration_batches_seconds=result['calibration_batches_seconds'])
+    (path/'uniform').mkdir(exist_ok=True)
+    for name, data in [('result.json', result), ('preflight.json', preflight), ('uniform/ready.json', ready)]:
+        (path/name).write_text(json.dumps(data))
+    return cfg, body, parameters, manifest
+
+
+def test_admission_rejects_mismatches():
+    with TemporaryDirectory() as temp:
+        path = Path(temp); args = fixture(path)
+        receipt = f.admit_pilot(path, *args)
+        assert abs(receipt['step_force_scaled_seconds'] - 220.764) < 1e-10
+        cases = [('result.json', 'collision', 'MRT'),
+                 ('result.json', 'step_seconds', float('nan')),
+                 ('result.json', 'healthy', False),
+                 ('uniform/ready.json', 'step', 160),
+                 ('uniform/ready.json', 'runner_sha256', 'wrong'),
+                 ('preflight.json', 'body', {'objects': []}),
+                 ('preflight.json', 'gates', {}),
+                 ('preflight.json', 'source', {})]
+        for filename, key, value in cases:
+            fixture(path)
+            target = path/filename; data=json.loads(target.read_text()); data[key]=value
+            target.write_text(json.dumps(data))
+            with unittest.TestCase().assertRaises(ValueError): f.admit_pilot(path, *args)
+        fixture(path); (path/'uniform/ready.json').unlink()
+        with unittest.TestCase().assertRaises(FileNotFoundError): f.admit_pilot(path, *args)
+
+
+def test_full_requires_health_periodicity_and_reference():
+    good = dict(case='uniform', mode='full', steps=2400000, executed_steps=2400000,
+                healthy=True, periodic=True, reference_comparison=dict(reference_agreement=True))
+    assert f.qualified(good)
+    for key, value in [('healthy', False), ('periodic', False), ('steps', 40000),
+                       ('executed_steps', 2399900), ('mode', 'pilot'), ('case', 'refined'),
+                       ('reference_comparison', {}),
+                       ('reference_comparison', dict(reference_agreement=False))]:
+        bad=deepcopy(good); bad[key]=value; assert not f.qualified(bad)
+
+
+def test_preflight_preserves_physics_and_gates():
+    with TemporaryDirectory() as temp:
+        root=Path(temp); incoming=root/'pilot'; incoming.mkdir(); cfg, body, params, _=fixture(incoming)
+        output=root/'full'
+        subprocess.run([sys.executable, str(Path(f.__file__)), '--pilot-results', str(incoming),
+                        '--output', str(output)], check=True)
+        data=json.loads((output/'preflight.json').read_text())
+        assert data['config']==cfg and data['body']==body and data['parameters']==params
+        assert data['max_steps']==2400000 and data['cap_tstar']==300 and data['wall_seconds']==720
+        assert not data['accuracy_qualified'] and not data['executed']
+        assert data['numerical_source_commit']=='926ca27407c26ca11283282a6e53249925725376'
+        assert 'restart' in data['initialization']
+
+
+def test_old_files_and_late_observer_unchanged():
+    root=f.pilot.ROOT
+    for name in ['tests/validation/run_refined_dfg.py',
+                 'tests/validation/experimental_full9/run_dfg.py',
+                 'tests/validation/experimental_full9/dfg_source_manifest.json',
+                 'tests/validation/periodic.py']:
+        old=subprocess.check_output(['git','-C',str(root),'show','c0be841:'+name])
+        assert old==(root/name).read_bytes()
+    source=(root/'tests/validation/run_refined_dfg.py').read_text()
+    assert 'begin * SPEED / p["diameter"] >= 240' in source
+    assert 'cap = 5.0 if a.mode == "pilot" else 300.0' in source
+
+
+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())