CLAUDE: DP rung D4 - Java switch: ONE pose_scene_dp entry per scene

Binds the D3-validated tp_proc_exec_pose_scene_dp in TpJna/GpuQuadJna
(+ base GpuQuad stubs, non-throwing negative return = the FAIL-safe
hook) and adds the one-entry-per-scene branch to the lean pose path:

- new saved curt.pose_scene_dp (default ON, 'Pose scene as ONE GPU DP
  entry'): eligibility = frozen lean shape only (fixed cycles, 1-inner
  cap, freeze 0, 3-angle lma_use_R, uniform MB, JNA backend, no armed
  capture, no debug-save holders); everything else falls back to the
  host-driven (B3) loop automatically.
- scene 0 (per template/sequence) always runs the host-driven loop -
  it seeds the resident per-sequence state through the production
  C1/C2 register path - then is REPLAYED through the DP entry as the
  one-shot oracle: per-cycle packed rows vs the captured resident-step
  results, the final anchor vs the fitted angles, and the last-cycle
  peak rows keyed by packed index (the B3 order-independence rule),
  all bit-compared. PASS arms DP from scene 1; FAIL (or any mid-run
  native failure) disables DP for the run and prints why.
- DP scenes reconstruct the scene bookkeeping from the returned trace
  by the exact leanFitScene/IntersceneLma double rules (candidate =
  packed[16..18] widened, dATR in double, RMS = packed[19..22],
  rejected step == the legacy runLma -1 -> coast), fetch/unpack the
  resident last-cycle peaks exactly like leanMeasure, and print the
  same QC/cycles/Done-line fields - the real-scene gate is 497 Done
  lines byte-identical to the 07/16 22:52 saves-OFF record.
- gpuTaskBuild steps 1-5 extracted verbatim into poseMeasureSetup()
  (shared with the DP entry); new 'scene DP entry' profile stage;
  Stage0 kernel count synced 36 -> 40 (the native-only D1-D3 sessions
  added the DP kernels but could not touch the Java constant).

Gates: mvn clean package PASS; Stage0 PASS 40/40; native run_cases.sh
ALL PASS (pose_corr @tol 0 + dp_cycles + measure_dp + scene_dp).
Real-scene gate = Andrey's next routine run: expect the D4 oracle PASS
line after scene 0, 'DP scene entry active' from scene 1, poses/QC
byte-identical, post ~19.5 -> ~8-10 ms/scene.
Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

src/main/java/com/elphel/imagej/gpu/GpuQuad.java

@@ -3080,6 +3080,60 @@ public class GpuQuad{ // quad camera description
 	/** Upload gc + cv once per scene for the batched chain (the granular path re-uploads them every cycle). */
 	public void uploadPoseCycleGeometry() {
 	}
+	/**
+	 * DP rung D4 (ladder ratified 2026-07-16): the FULL per-scene pose solve as ONE
+	 * device entry (num_cycles x [measure chain -> prepare -> resident step -> commit],
+	 * self-chained on-device). Base/JCuda has no DP chain - the host-driven lean loop
+	 * stays the fallback. By Claude on 07/17/2026.
+	 */
+	public boolean supportsPoseSceneDp() {
+		return false;
+	}
+	/**
+	 * ONE JNA crossing per SCENE: the D3-validated pose_scene_dp parent. Nullable
+	 * camera/task/centers groups follow the C2 configuration-register contract;
+	 * readback arrays (trace/mstats/result/vector_out/prep_out/stats) are filled when
+	 * non-null. Returns the last cycle's corr-row count (>0) or a negative.
+	 */
+	public int execPoseSceneDp(
+			IntersceneLmaFloat.Camera reference,
+			IntersceneLmaFloat.Camera scene,
+			float [] reference_xyz,
+			float [] reference_atr,
+			float [] scene_xyz,
+			float [] scene_atr,
+			int []   task_map,
+			float [] task_centers,
+			int      num_cycles,
+			float    lambda,
+			float    pure_weight,          // prepare_light only (frozen conditioning)
+			float    rms_diff,
+			int      num_tiles,
+			int      corr_slot,
+			int      ntile_shift,
+			int      num_components,
+			boolean  use_eigen,
+			float    eig_min_sqrt,
+			float    eig_max_sqrt,
+			float    min_confidence,
+			boolean  same_weights,
+			boolean  prepare_light,
+			float [] centers,              // null = keep resident (per-sequence)
+			float [] pull_targets,         // full mode; null = keep resident
+			float [] param_regweights,     // full mode; null = keep resident
+			float [] vector,               // entry anchor [3]
+			float [] trace,                // [num_cycles*25] or null
+			int []   mstats,               // [num_cycles*5] or null
+			float [] result,               // final packed [25]
+			float [] vector_out,           // final anchor [3] or null
+			float [] prep_out,             // last full prepare [8] or null
+			int []   stats) {              // last-cycle {pairs, surviving, misaligned} or null
+		return -1;
+	}
+	/** Backend error string for a failed pose entry (the D4 FAIL-safe prints it instead of throwing). */
+	public String poseLastError() {
+		return "no native backend";
+	}
 
 	public void execRBGA(
 			double [] color_weights,

src/main/java/com/elphel/imagej/gpu/jna/GpuQuadJna.java

@@ -876,6 +876,81 @@ public class GpuQuadJna extends GpuQuad {
         final float [] peaks = new float [num_rows * PEAK_ROW_FLOATS];
         return (lib.tp_proc_get_peaks(proc, peaks) == num_rows) ? peaks : null;
     }
+    // ---- DP rung D4: the full per-scene pose solve as ONE device entry (design 2026-07-16) ---- // By Claude on 07/17/2026
+    @Override public boolean supportsPoseSceneDp() { return !rectilinear; }
+    @Override public int execPoseSceneDp(
+            final IntersceneLmaFloat.Camera reference,
+            final IntersceneLmaFloat.Camera scene,
+            final float [] reference_xyz,
+            final float [] reference_atr,
+            final float [] scene_xyz,
+            final float [] scene_atr,
+            final int []   task_map,
+            final float [] task_centers,
+            final int      num_cycles,
+            final float    lambda,
+            final float    pure_weight,
+            final float    rms_diff,
+            final int      num_tiles,
+            final int      corr_slot,
+            final int      ntile_shift,
+            final int      num_components,
+            final boolean  use_eigen,
+            final float    eig_min_sqrt,
+            final float    eig_max_sqrt,
+            final float    min_confidence,
+            final boolean  same_weights,
+            final boolean  prepare_light,
+            final float [] centers,
+            final float [] pull_targets,
+            final float [] param_regweights,
+            final float [] vector,
+            final float [] trace,
+            final int []   mstats,
+            final float [] result,
+            final float [] vector_out,
+            final float [] prep_out,
+            final int []   stats) {
+        final boolean have_pose = (scene_xyz != null) || (scene_atr != null) ||
+                (reference_xyz != null) || (reference_atr != null);
+        float[] poseVectors = null;
+        if (have_pose) {
+            poseVectors = new float[12];
+            copyPoseVector3(reference_xyz, poseVectors, 0);
+            copyPoseVector3(reference_atr, poseVectors, 3);
+            copyPoseVector3(scene_xyz, poseVectors, 6);
+            copyPoseVector3(scene_atr, poseVectors, 9);
+        }
+        final int n = lib.tp_proc_exec_pose_scene_dp(
+                proc,
+                (reference != null) ? poseCameraMeta(reference) : null,
+                (reference != null) ? reference.radial : null,
+                (reference != null) ? reference.rByRDist : null,
+                (reference != null) ? reference.rByRDist.length : 0,
+                (reference != null) ? reference.ers : null,
+                (reference != null) ? reference.ers.length : 0,
+                (scene != null) ? poseCameraMeta(scene) : null,
+                (scene != null) ? scene.radial : null,
+                (scene != null) ? scene.rByRDist : null,
+                (scene != null) ? scene.rByRDist.length : 0,
+                (scene != null) ? scene.ers : null,
+                (scene != null) ? scene.ers.length : 0,
+                poseVectors, task_map, task_centers,
+                num_cycles, lambda, pure_weight, rms_diff,
+                num_tiles, corr_slot, ntile_shift,
+                num_components, use_eigen ? 1 : 0,
+                eig_min_sqrt, eig_max_sqrt,
+                min_confidence, same_weights ? 1 : 0,
+                prepare_light ? 1 : 0,
+                centers, pull_targets, param_regweights,
+                vector,
+                trace, mstats, result, vector_out, prep_out, stats);
+        // A negative return is the D4 FAIL-safe hook: the caller prints tp_last_error()
+        // and falls back to the host-driven loop - do NOT throw here (unlike the B3
+        // entry, mid-run DP failure must degrade, not abort). By Claude on 07/17/2026.
+        return n;
+    }
+    @Override public String poseLastError() { return lib.tp_last_error(); }
     @Override public void uploadPoseCycleGeometry() {
         setGeometryCorrection(); // gc (resets rbr_ready -> one in-chain rebuild, same bits)
         setExtrinsicsVector(quadCLT.getGeometryCorrection().expandSensors(

src/main/java/com/elphel/imagej/gpu/jna/Stage0.java

@@ -10,7 +10,7 @@ import com.sun.jna.Pointer;
  *        com.elphel.imagej.gpu.jna.Stage0 [kernel_src_dir] [libcudadevrt.a]
  */
 public class Stage0 {
-	private static final int EXPECTED_KERNELS = 36; // 19 base + 2 conditioning + 4 consolidate + 2 peak + pose fx/J + 4 pose LMA + products + 3 resident prepare (rung C1) // By Claude on 07/17/2026
+	private static final int EXPECTED_KERNELS = 40; // 36 (through rung C1) + 2 DP-cycles (D1: pose_lma_dp_cycles/commit) + measure-chain DP (D2: pose_measure_dp + launch helpers) + scene DP parent family (D3: pose_scene_dp lma/step/commit) - the native D1-D3 sessions could not touch this Java constant, synced at D4 // By Claude on 07/17/2026
     public static void main(String[] args) {
         String srcdir = (args.length > 0) ? args[0] : "/home/elphel/git/tile_processor_gpu/src";
         String devrt  = (args.length > 1) ? args[1] : "/usr/local/cuda/targets/x86_64-linux/lib/libcudadevrt.a";

src/main/java/com/elphel/imagej/gpu/jna/TpJna.java

@@ -243,6 +243,34 @@ public interface TpJna extends Library {
                                       float[] sceneRbr, int sceneRbrLen, float[] sceneErs, int sceneErsLen,
                                       float[] poseVectors, int[] taskMap, float[] taskCenters,
                                       int[] stats);
+    /** DP rung D4 (ladder ratified 2026-07-16): the FULL per-scene pose solve as ONE
+     *  device entry - numCycles x [D2 measure chain -> full/light prepare -> six-stage
+     *  resident step -> commit], self-chained on-device with zero interior host round
+     *  trips. Camera/task/centers groups follow the C2 configuration-register contract
+     *  (null = keep resident). pull/regw are the full-prepare objective rows (null =
+     *  keep resident); vector = the entry anchor [3]. Readbacks: trace [numCycles*25]
+     *  per-cycle packed rows, mstats [numCycles*5] per-cycle measure counts, result =
+     *  final packed [25], vectorOut = final anchor [3], prepOut = last full prepare [8],
+     *  stats = last-cycle {pairs, surviving, misaligned} (each nullable). Peaks/corr
+     *  indices stay resident for the unchanged fetch calls. Returns the LAST cycle's
+     *  corr-row count (>0) or a negative (host -1xx / device guard codes).
+     *  By Claude on 07/17/2026. */
+    int     tp_proc_exec_pose_scene_dp(Pointer proc,
+                                      float[] refMeta, float[] refRadial,
+                                      float[] refRbr, int refRbrLen, float[] refErs, int refErsLen,
+                                      float[] sceneMeta, float[] sceneRadial,
+                                      float[] sceneRbr, int sceneRbrLen, float[] sceneErs, int sceneErsLen,
+                                      float[] poseVectors, int[] taskMap, float[] taskCenters,
+                                      int numCycles, float lambda, float pureWeight, float rmsDiff,
+                                      int numTiles, int corrSlot, int ntileShift,
+                                      int numComponents, int useEigen,
+                                      float eigMinSqrt, float eigMaxSqrt,
+                                      float minConfidence, int sameWeights,
+                                      int prepareLight,
+                                      float[] centers, float[] pullTargets, float[] paramRegweights,
+                                      float[] vector,
+                                      float[] trace, int[] mstats, float[] result,
+                                      float[] vectorOut, float[] prepOut, int[] stats);
     /** Deterministic double normal-equation products for the lean pose LMA.
      *  jt is parameter-major [numParams][numValues]; out is row-major H followed by b.
      *  Damping and the small solve remain in Java. 0 on success. */

src/main/java/com/elphel/imagej/tileprocessor/CuasRtParameters.java

@@ -38,6 +38,7 @@ public class CuasRtParameters {
 	public double   pose_debias =     0.0;   // rung-2 optional envelope de-bias hook (Andrey's ruling 07/13/2026, default OFF): fraction of the MCLT window-autocorr envelope divided out of the pixel-domain correlation BEFORE peak extraction (corr *= envelope^-frac, envelope normalized 1.0 at center). The envelope multiplies the true correlation peak and pulls the centroid toward center - argmax under-reports offsets by alpha ~0.75-0.9 (probed 07/13, the residual per-cycle convergence tax). 0 = off (bit-identical to no hook); 1 = full divide. GPU kernel contract: optional precomputed de-bias array pointer, NULL = off. Enabling needs its own A/B run. // By Claude on 07/13/2026
 	public int      pose_lma_debug =  0;     // inner-LMA debug level, passed to the inner runLma (max with the run's own debugLevel): 0 = quiet (default; ALSO gates the per-scene "CuasPoseRT cycles:" trace line - >=1 to print it); 2 = one line PER INNER STEP ("LMA step N: {good,done} full RMS= ... pure RMS= ... + lambda=...") - the convergence trajectory INSIDE each outer cycle; 3-4 = progressively deeper solver dumps (parameter vectors, matrices). VERBOSE at >=2 - use for short investigation runs, not production. // By Claude on 07/12/2026, trace gate 07/13
 	public int      pose_freeze_cycle = 0;   // rung C3/C3b FALSIFIED 07/16 (freeze@1: az +48% roll +100%; freeze@2: az +30% roll +54%, NOT-settled 51->228): conditioning re-derivation matters through ALL cycles. 0 = never freeze = per-cycle (DEFAULT, restores C2 quality). Mechanism kept validated (bit-exact light path) for DP-era experiments (e.g. previous-scene conditioning). Was: freeze the lean-pose LMA conditioning (weights/eigen/selection/pull/reg) at this FULL prepare count; later cycles run light (fresh offsets only). 0 = never freeze = re-derive every cycle (highest accuracy, the pre-C3 behavior); 1 = freeze at cycle 1 (FAILED its gate: blurriest-pose conditioning, azimuth +48%); 2 = freeze at cycle 2 (post-first-correction measurement ~= converged). Keeps the high-accuracy opportunity selectable at runtime (Andrey 07/16). // By Claude on 07/16/2026
+	public boolean  pose_scene_dp =   true;  // DP rung D4 (ladder ratified 07/16/2026): run the FULL per-scene lean pose solve as ONE device entry (pose_scene_dp parent: pose_cycles x [measure chain -> full prepare -> resident LMA step -> commit], self-chained on-device, one end-of-scene readback). Scene 0 always runs the host-driven (B3) loop to seed the resident per-sequence state AND is replayed through the DP entry as a one-shot bit-exact oracle; FAIL disables DP for the run (fail-safe). Requires JNA backend + uniform MB + fixed cycles + inner cap 1 + freeze 0; ineligible scenes/configs fall back to the host-driven loop automatically. OFF = the validated B3 host-driven loop (the A/B knob). // By Claude on 07/17/2026
 	public boolean  rend_test =       false; // RT full-render product (CuasRender.testRenderSequence): per scene raw /jp4/ -> conditionSceneToGpu -> virtual-grid render at BORROWED stored pose+ERS rates -> -CUAS-RT-RENDER hyperstack [s00..s15, merged][scenes], comparable to -CUAS-INDIVIDUAL/MERGED-CUAS-DBG. NON-exclusive: runs AFTER the pose stage when both are ON (the pose stage is part of the RT cycle - Andrey 07/06/2026). // By Claude on 07/05/2026
 	public boolean  log_test =        false; // LoG A/B with the RT render (CuasRender): also save -CUAS-RT-RENDER-LOG-ORACLE (product convolved with the EXISTING pre-DNN pixel LoG, LINEAR alpha=1) and -CUAS-RT-RENDER-LOG-FOLDED (same render, LoG folded into the GPU aberration kernels via CuasLogFold - no pixel convolution; originals restored). The aberration+LoG kernel-fold validation (RT-seed step 1b). // By Claude on 07/06/2026
 	public boolean  log_ident =       false; // LoG ISOLATION test with the RT render (CuasRender): render with IDENTITY kernels (-CUAS-RT-RENDER-ID, aberrations skipped), pixel-LoG it (-ID-LOG-ORACLE), and render with PURE-LoG kernels (-LOG-ONLY). If -LOG-ONLY vs -ID-LOG-ORACLE residual persists, the fold/L0 is wrong; if it collapses to the wrap floor, the aberration-kernel interaction was responsible (Andrey 07/06/2026). // By Claude on 07/06/2026
@@ -170,6 +171,8 @@ public class CuasRtParameters {
 				"0 = quiet (also hides the per-scene 'CuasPoseRT cycles:' trace; >=1 shows it); 2 = one line per INNER LMA step (good/done flags, full/pure RMS, lambda); 3-4 = deeper solver dumps. VERBOSE at >=2 - for short investigation runs.");
 		gd.addNumericField("Pose freeze conditioning at cycle",      this.pose_freeze_cycle, 0,3,"", // By Claude on 07/16/2026
 				"Freeze lean-pose LMA weights/eigen at this full-prepare count; later cycles reuse them (light prepare). 0 = never (re-derive every cycle, highest accuracy); 2 = recommended (post-first-correction measurement); 1 = falsified (blurry cycle-1 conditioning).");
+		gd.addCheckbox ("Pose scene as ONE GPU DP entry",            this.pose_scene_dp, // By Claude on 07/17/2026
+				"DP rung D4: the whole per-scene pose solve (cycles x measure+prepare+LMA step) as ONE device entry, one end-of-scene readback. Scene 0 runs the host-driven loop and is replayed through the DP entry as a one-shot bit-exact oracle; FAIL disables DP for the run. Ineligible configs (JCuda, non-uniform MB, convergence exit, inner cap != 1, freeze != 0, debug saves) fall back automatically. OFF = the host-driven (B3) loop.");
 
 		gd.addMessage("=== RT render diagnostics ==="); // By Codex on 07/15/2026
 		gd.addCheckbox ("CUAS RT render (full product)",             this.rend_test, // By Claude on 07/05/2026
@@ -365,6 +368,7 @@ public class CuasRtParameters {
 		this.pose_debias =         gd.getNextNumber();       // By Claude on 07/13/2026
 		this.pose_lma_debug =(int) gd.getNextNumber();       // By Claude on 07/12/2026
 		this.pose_freeze_cycle =(int) gd.getNextNumber();    // By Claude on 07/16/2026
+		this.pose_scene_dp =       gd.getNextBoolean();      // By Claude on 07/17/2026
 		this.rend_test =           gd.getNextBoolean();      // By Claude on 07/05/2026
 		this.log_test =            gd.getNextBoolean();      // By Claude on 07/06/2026
 		this.log_ident =           gd.getNextBoolean();      // By Claude on 07/06/2026
@@ -474,6 +478,7 @@ public class CuasRtParameters {
 		properties.setProperty(prefix+"pose_debias",     this.pose_debias+"");    // double  // By Claude on 07/13/2026
 		properties.setProperty(prefix+"pose_lma_debug",  this.pose_lma_debug+""); // int     // By Claude on 07/12/2026
 		properties.setProperty(prefix+"pose_freeze_cycle", this.pose_freeze_cycle+""); // int // By Claude on 07/16/2026
+		properties.setProperty(prefix+"pose_scene_dp",   this.pose_scene_dp+"");  // boolean // By Claude on 07/17/2026
 		properties.setProperty(prefix+"rend_test",       this.rend_test+"");      // boolean // By Claude on 07/05/2026
 		properties.setProperty(prefix+"log_test",        this.log_test+"");       // boolean // By Claude on 07/06/2026
 		properties.setProperty(prefix+"log_ident",       this.log_ident+"");      // boolean // By Claude on 07/06/2026
@@ -583,6 +588,7 @@ public class CuasRtParameters {
 		if (properties.getProperty(prefix+"pose_debias")!=null)     this.pose_debias=Double.parseDouble(properties.getProperty(prefix+"pose_debias"));         // By Claude on 07/13/2026
 		if (properties.getProperty(prefix+"pose_lma_debug")!=null)  this.pose_lma_debug=Integer.parseInt(properties.getProperty(prefix+"pose_lma_debug"));     // By Claude on 07/12/2026
 		if (properties.getProperty(prefix+"pose_freeze_cycle")!=null) this.pose_freeze_cycle=Integer.parseInt(properties.getProperty(prefix+"pose_freeze_cycle")); // By Claude on 07/16/2026
+		if (properties.getProperty(prefix+"pose_scene_dp")!=null)   this.pose_scene_dp=Boolean.parseBoolean(properties.getProperty(prefix+"pose_scene_dp"));       // By Claude on 07/17/2026
 		if (properties.getProperty(prefix+"rend_test")!=null)       this.rend_test=Boolean.parseBoolean(properties.getProperty(prefix+"rend_test"));           // By Claude on 07/05/2026
 		if (properties.getProperty(prefix+"log_test")!=null)        this.log_test=Boolean.parseBoolean(properties.getProperty(prefix+"log_test"));             // By Claude on 07/06/2026
 		if (properties.getProperty(prefix+"log_ident")!=null)       this.log_ident=Boolean.parseBoolean(properties.getProperty(prefix+"log_ident"));           // By Claude on 07/06/2026
@@ -695,6 +701,7 @@ public class CuasRtParameters {
 		cp.pose_debias = this.pose_debias; // By Claude on 07/13/2026
 		cp.pose_lma_debug = this.pose_lma_debug; // By Claude on 07/12/2026
 		cp.pose_freeze_cycle = this.pose_freeze_cycle; // By Claude on 07/16/2026
+		cp.pose_scene_dp = this.pose_scene_dp;         // By Claude on 07/17/2026
 		cp.rend_test = this.rend_test; // By Claude on 07/05/2026
 		cp.log_test = this.log_test; // By Claude on 07/06/2026
 		cp.log_ident = this.log_ident; // By Claude on 07/06/2026