Add case 05: false forward-left occupancy and historical-reference ablation

README.md

@@ -23,6 +23,7 @@ Both supervised runs were recorded on **2026-10-26 (Asia/Singapore)** toward ref
 |---|---|---:|---:|---|
 | **20261026_goal1012_02** | Measured-depth checks reject all local graph attachments during a head survey | 680 | 380 | [Evidence, download and replay](cases/20261026_goal1012_02/README.md) |
 | **20261026_goal1012_03** | Transient false BEV occupancy triggers the added path guard; a separate braking handoff bug stops the survey | 500 | 240 | [Evidence, download and replay](cases/20261026_goal1012_03/README.md) |
+| **20261026_goal1012_05** | False forward-left occupancy despite survey floor evidence; historical-reference lifting ablation; complete head survey followed by a separate depth-attachment stop | 749 | 376 | [Evidence, download and replay](cases/20261026_goal1012_05/README.md) |
 
 Each case is self-contained, including original RGB/depth, odometry and image-time transforms, exact
 VGGT input tensors and numeric outputs, BEV replay, planner evidence, the reference map, recorded
@@ -52,10 +53,19 @@ cases/
     reports/
     tools/
     post_run_fixes/        # later changes, explicitly separate from recorded source
+  20261026_goal1012_05/
+    README.md
+    archives/
+    code/
+    environment/
+    manifest.json
+    previews/
+    reports/
+    tools/
 ```
 
 Archives always belong to their containing case. Archive/member SHA-256 hashes and extraction paths
-are in each case's `manifest.json`. Case 03 also includes a file-level `SHA256SUMS`.
+are in each case's `manifest.json`. Cases 03 and 05 also include file-level `SHA256SUMS`.
 The cases include identical reference-map/source archives so either can be downloaded independently.
 Pretrained model weights are referenced by repository/revision/hash in the case provenance.
 
@@ -64,7 +74,7 @@ Pretrained model weights are referenced by repository/revision/hash in the case
 ```python
 from huggingface_hub import snapshot_download
 
-case_id = "20261026_goal1012_03"  # or "20261026_goal1012_02"
+case_id = "20261026_goal1012_05"  # or "20261026_goal1012_02" / "20261026_goal1012_03"
 snapshot_download(
     repo_id="jizhuochen/CROSS_nav_debug",
     repo_type="dataset",
@@ -76,12 +86,13 @@ snapshot_download(
 Change into the downloaded case folder, then run its verifier/unpacker:
 
 ```bash
-cd CROSS_nav_debug/cases/20261026_goal1012_03
+cd CROSS_nav_debug/cases/20261026_goal1012_05
 python tools/unpack.py --output extracted
 ```
 
 Case 02 needs approximately **3.5 GB** for download plus **3.5 GB** for extraction; case 03 needs
-approximately **2.3 GB** for each. Replay and saved-output inspection need no robot or GPU.
+approximately **2.3 GB** for each; case 05 needs approximately **3.6 GB** to download and **3.7 GB** to extract.
+Replay and saved-output inspection need no robot or GPU.
 
 ## Layout migration
 

cases/20261026_goal1012_05/README.md

@@ -0,0 +1,174 @@
+# Case 20261026_goal1012_05: false forward-left occupancy driven by historical reference lifting
+
+Supervised Stretch run on **2026-10-26, Asia/Singapore**, toward reference-map keyframe **1012**.
+Reference mapping sequence: Record3D `2026-10-22--15-48-58`.
+
+## Finding
+
+The final displayed BEV contains a false obstacle in the nearby forward-left patch. At capture
+frame **747**, selected cells A and B lie on floor seen during the robot's head survey, but receive
+high occupancy after the camera returns to its driving view. A controlled offline ablation shows
+that explicitly lifting the historical phone references into the BEV head strongly contributes.
+
+![Current RGB, survey floor evidence, BEV and native map memory](reports/bev_diagnosis/region_analysis.png)
+
+| Evidence | Cell A | Cell B |
+|---|---:|---:|
+| BEV row, column | 190, 190 | 189, 189 |
+| Forward / left from robot base | 0.475 / 0.475 m | 0.525 / 0.525 m |
+| Current occupancy | **0.883898** | **0.947792** |
+| Current predicted observability | 0.733810 | 0.640831 |
+| Raw head occupancy at the corresponding position | 0.883943 | 0.947565 |
+| Separate native accumulated occupancy | 0.511303 | 0.592291 |
+| Survey frames with nearby floor returns and no elevated returns in the projected patch | **22** | **21** |
+| Latest floor frame | 639 | 638 |
+| Latest floor height range over base origin | −31.4 to −20.8 mm | −31.1 to −14.0 mm |
+| Latest floor depth pixels / nearby returns | 49 / 49 | 49 / 49 |
+
+Cell A was predicted only **0.017629 occupied** at frame 634 during the floor survey; it rises to
+0.883898 in frame 747 at the same odometry-world location. Its latest direct floor observation was
+**27.06 s** earlier; cell B's was 27.33 s earlier. The current ground projections are outside the
+camera image: A is approximately `(−92, 976)` in the 480 × 640 image. Positive historical depth rays
+also indicate free space at sampled column heights from **0.12 through 1.32 m for A**, and through
+**1.20 m for B**, without matching surface returns at those samples. These are discrete historical
+measurements, not continuous clearance certificates or a claim that all furniture farther left is absent.
+
+The saved camera-to-base reprojection reproduces with **zero maximum absolute difference**.
+The high value is present in the raw learned head output. The web viewer shows this current
+reprojected BEV; it does not render a cached phone-mapping occupancy grid. Native planner map
+memory is separate and retains lower occupancy at these cells, below its 0.6 blocking threshold.
+
+## Historical-reference ablation
+
+The actual input group contains the current robot RGB and six phone references:
+**799, 798, 800, 797, 803, 527**. Recent robot floor-survey frames are not members of this group.
+
+![Exact input-view group for frame 747](previews/00000747/input_views.jpg)
+
+The offline experiment recomputes transformer features once from those exact seven tensors,
+retains the **recorded depth, confidence, camera-pose encoding, metric scale, gravity and TF**,
+then changes only which views the BEV head explicitly lifts/uses:
+
+| BEV-head mask | Occupancy at A | Observability at A |
+|---|---:|---:|
+| All seven recorded views | **0.884494** | 0.734061 |
+| Current robot view only; all phone lifting disabled | **0.045817** | 0.015535 |
+| Drop one phone reference at a time | 0.872603–0.891582 | See detailed report |
+
+This is strong evidence that historical reference lifting collectively drives the false patch.
+No single reference's removal fixes it. The current-only result also reports that the cell is
+unobserved; its low occupancy is **not** permission to drive through unseen space.
+
+All seven images remain in the transformer context in this experiment. The result does not isolate
+pure geometric lifting from other head use of those reference views, identify one historical
+chair/person, prove the scene's exact change since mapping, or remove every learned
+appearance prior. Original intermediate transformer tokens were not archived, so feature recomputation
+is near but not bit-identical: the baseline occupancy differs from the recording by 0.000596 at A,
+with maximum 0.005352 across the raw occupancy grid. Repeated baseline maximum base-grid difference
+is 0.001892, much smaller than the 0.838676 ablation effect at A. Numeric results and grids are under
+`reports/bev_diagnosis/reference_ablation/`.
+
+An earlier exploratory rerun using recomputed geometry is retained there with a
+`recomputed_geometry_` prefix. The primary report uses the exact recorded geometry described above.
+All ablations are explicitly **offline counterfactuals**, separate from original `vggt_debug` outputs.
+Runtime thresholds, model predictions and navigation policy were not changed by this investigation.
+
+## Run outcome and separate final stop
+
+The robot travelled **5.10 m in 100.91 s**, completing all six survey views in **39.06 s** with zero
+head-action cancellations, 534 renewals from fresh robot feedback, and zero nonzero base requests
+during the survey. This run used the installed timing fix; it is part of the recorded adapter source.
+
+After resuming briefly, it stopped with `no global route; navigation ended`, still localized and
+**13.78 m** camera-XY distance from the goal. The adapter's measured-depth attachment veto rejected
+all nearby graph connections. Rechecking final frame 747 with the retained obstacle memory saved at
+frame 742 finds **ten points in the 20–23 cm rear band of the starting footprint**, outside the 20 cm
+self mask but inside the 23 cm collision rectangle. That memory alone rejects all **13** nearby
+permanent keyframe candidates at path fraction zero. Their physical/noise/self-observation origin
+has not been established. This final stop is separate from the selected false learned-occupancy cells.
+
+Relay exit was verified with code 0, streaming head control was restored, and a four-second TF audit
+found less than 0.015 mm base translation. This case documents a successful survey and subsequent
+failure, not arrival at keyframe 1012.
+
+## Contents and download
+
+- **749** original RGB/depth pairs, image-time intrinsics, odometry, camera/base TF and head joints.
+- **376** actual VGGT passes, **497** unique exact lossless input tensors, **2,633** view references.
+- **377** debug frame manifests, including one processing frame without a model pass; no outputs fabricated.
+- **376** original occupancy/observability/uncertainty replay sets, raw head and consumed BEV arrays.
+- Native planner accumulators, routes, footprint evidence, commands, timing, robot state and shutdown audit.
+- Complete reference map and final native query map, with their lossless image/descriptor stores.
+- Frozen native CROSS and actual pre-run adapter source; offline analysis and ablation tools.
+- Numeric diagnosis, annotated figure, CSV timeline and independently labeled counterfactual grids.
+
+```python
+from huggingface_hub import snapshot_download
+
+snapshot_download(
+    repo_id="jizhuochen/CROSS_nav_debug",
+    repo_type="dataset",
+    allow_patterns="cases/20261026_goal1012_05/**",
+    local_dir="CROSS_nav_debug",
+)
+```
+
+```bash
+cd CROSS_nav_debug/cases/20261026_goal1012_05
+python tools/unpack.py --output extracted
+```
+
+The nine archives total **3.61 GB**. Allow approximately another 3.7 GB for extraction.
+Each case has independent reference-map/source archives. `manifest.json` verifies archive and member
+SHA-256 hashes; `SHA256SUMS` covers the published case files.
+
+## Repeat the diagnosis or inspect the run
+
+Use a Python environment with NumPy, OpenCV and Matplotlib for the diagnosis. Replay and input
+inspection need NumPy/OpenCV. They require no robot or GPU. Recorded package versions are provenance,
+not a portable environment installer.
+
+```bash
+python tools/diagnose_bev_region.py \
+  --run extracted/runs/stretch_cross_nav_live_20261026_goal1012_05 \
+  --frame 747 --output repeated_region_diagnosis
+
+python code/lite3_ROS/scripts/inspect_stretch_vggt_debug.py \
+  --debug extracted/runs/stretch_cross_nav_live_20261026_goal1012_05/vggt_debug \
+  --frame 747 --output inspection_747
+
+python code/lite3_ROS/scripts/view_stretch_cross_nav_live_run.py \
+  --run extracted/runs/stretch_cross_nav_live_20261026_goal1012_05 --port 8088
+```
+
+Open <http://127.0.0.1:8088> and select **Replay recording**. The saved-run viewer cannot arm motion.
+
+The separately recorded attachment condition can be checked without a model:
+
+```bash
+python tools/analyze_attachment.py --extracted extracted --frame 747 --evidence-frame 742
+```
+
+Repeating the GPU ablation additionally requires the native CROSS environment and the documented
+pretrained backbone/navigation heads under the chosen CROSS checkout's `models/VGGT-Omega-CROSS/`:
+
+```bash
+python tools/ablate_bev_references.py \
+  --run extracted/runs/stretch_cross_nav_live_20261026_goal1012_05 \
+  --cross-root /path/to/CROSS --adapter-root code/lite3_ROS \
+  --frame 747 --output repeated_reference_ablation
+```
+
+The original numeric ablation results can be inspected without loading a model.
+
+## Provenance
+
+Native CROSS revision: `4781371e6f4db4241be0a0df7c238436680ee268`, unchanged for this investigation.
+Checkpoint repository/revision/hashes are in `reports/vggt_provenance.json`; weights from
+[Jamie-nus/VGGT-Omega-CROSS](https://huggingface.co/Jamie-nus/VGGT-Omega-CROSS) are not duplicated.
+
+RGB/depth, model arrays and native stores are byte-identical to the recording. Sharing copies of
+text have credentials, private network addresses and local absolute paths removed or made portable.
+Three checkpoint paths in query-map metadata were made portable; all 50 numerical arrays were
+verified unchanged. Recorded source is distinguished from later offline analysis. No new recording
+license is asserted; source retains its included upstream licenses.

cases/20261026_goal1012_05/SHA256SUMS

@@ -0,0 +1,101 @@
+5601d10711cb431a43ccb8075170175d09a3dae4715c223aedcc2d36b1523b2d  README.md
+c3dd418506684ae4b05b49daeeb6456509d1542621911e0029fa6c420d75c64b  archives/CROSS_source.tar.gz
+4a6dec652cc53d8db40188df5d72870d974e17ff282f42ee96bd5ea205e691b4  archives/capture.tar
+3876fa21325aea0a41dba3f647a8645815ed9f431c3e3e399e8a3f3d47768200  archives/reference_map.tar
+71ab36b2cf266ea5054737b3dddf94b17fe4b2a16651173dc62d7ba752dc1049  archives/run_core.tar.gz
+dfe5cbec1b39558d5ce92503447663b744944da8bd4994ec0d1cb7908a371c84  archives/vggt_frames_000.tar
+74a02595997103e82261b734e8afa42a7b4693f8cd1caec407c3534988ce7d76  archives/vggt_frames_001.tar
+94113852d76817332b7bea586fead14ee6b229c438dc8c87c31e658d786ab114  archives/vggt_frames_002.tar
+7802f06f457281e0153170f2f8614c2a940dfc886bf6aa2a5b8eed614e458550  archives/vggt_metadata.tar.gz
+935373a868f7cba2a3325fde2d1eb61f69325a55763873021c2253fb535d0ff1  archives/vggt_views.tar
+49a6e137748b934e2f78b15cf74704fd8fdcb26107c5d210d783648287345750  code/lite3_ROS/LICENSE
+7e861070432a0da598c7e4974397c162df0582df0c94da41dd6e09efc7efcf27  code/lite3_ROS/scripts/capture_stretch_cross.py
+4cad1fbc6612c000da3be953ad8ef3cabf62e6eb09ebf615d17fafe5a0167768  code/lite3_ROS/scripts/diagnose_stretch_bev_blockage.py
+fd63aaa56167b49042caa4fb0d432b68edd5ef8ffe91929192b86b33ff2c33a4  code/lite3_ROS/scripts/diagnose_stretch_bev_region.py
+5445e49f09b7891d3ecf962aba966bf748dd50cba931df0382e1d416db1f04f3  code/lite3_ROS/scripts/inspect_stretch_vggt_debug.py
+b6efe176c7cc9b0cda4fb62d9e308338e01c24cd0ceb0b9c852ea4b0734e56ec  code/lite3_ROS/scripts/live_stretch_cross_nav.py
+1290eafa6369623d9d36fcbd7c240b92dbee54efbd9372b1fc64732a2fa9b90e  code/lite3_ROS/scripts/monitor_stretch_transport.py
+17ebc68ab1e30bc0601d1eb2f212e449dd3036d4a0dce7d48662431693ef4967  code/lite3_ROS/scripts/replay_stretch_cross_nav.py
+7b9b7ac8ebdcb8884808a4cf34b4ef0fdf5ee2b042f0ffd81fca16d4e4fefbb9  code/lite3_ROS/scripts/view_stretch_cross_nav_live_run.py
+23cd5d206ea6e42850dc750d6712ff305b9896d9c09d0924e3c86a1131690c90  code/lite3_ROS/tests/test_stretch_capture_format.py
+7a3c08f8a2032d7fe367b49e7b97fcd6d564ad80991e608675fcc336b01017e3  code/lite3_ROS/tests/test_stretch_nav_control.py
+235a2d70fa9a747de21c4478f5676d43211c1451188e83829c085432a5d11310  code/lite3_ROS/tests/test_stretch_nav_geometry.py
+bee61e6ce0677ffda2efa836dc14c44ffb0a0adbf4b10b0841de43e73569f6c9  code/lite3_ROS/tests/test_stretch_nav_handoff.py
+b15144072cf25d495fc432d9b0f22abfe40996cf07e0be5e8e47beef0026055b  code/lite3_ROS/tests/test_stretch_nav_learned.py
+9ddca6a3f18124eec96edee4558fa568ed7a583c1a6dc20dc709987e9a8d76ce  code/lite3_ROS/tests/test_stretch_nav_recovery.py
+b18a7a46290b231b23c611ea34f22c2d542846d4d9e1dd9185086744a81608a9  code/lite3_ROS/tests/test_stretch_nav_replay.py
+f706d7715b2dec1f755997c5c98d1c7d0f93475da23ba026c91b7c080b36138b  code/lite3_ROS/tests/test_stretch_nav_routing.py
+0373c6ca335999d054caeaf1099c24d42a56e97f0e4b7b098a6bf9368b6a163d  code/lite3_ROS/tests/test_stretch_nav_survey.py
+a37f95cbb179efb7e72d0f29fe49a06a2e53c48ae7b3d6e686c4b68e59a816d7  code/lite3_ROS/tests/test_stretch_transport.py
+3581f52fa7653cbfdb852f07654dcc5f0f0395133c9d3a81d789a7d3f7f57fda  code/lite3_ROS/tests/test_stretch_vggt_debug.py
+e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855  code/lite3_ROS/web_console/__init__.py
+96cbcccde95c2b6da8d4cc9cc237ecbdff6604218e59845e92429df9e38ba43b  code/lite3_ROS/web_console/cross_run.py
+522597d97ddbf997e7f80246a6c6ea17e11e66435db1669a4ac9fddf8b9b2be2  code/lite3_ROS/web_console/static/cross_nav.css
+7837119d23b87b5776017dfc86f8aa121327ab4611c15ee409e7866425e325e3  code/lite3_ROS/web_console/static/cross_nav_live.html
+d8daea837482d5ea105e4e5e21dc483d4343401568fefbad6f6536ec015422db  code/lite3_ROS/web_console/static/cross_nav_live.js
+3b6e15d45dbb7fca5bd2094291e961ddc5472cd887009e6009a56dab668d721f  code/lite3_ROS/web_console/static/vendor/plotly.min.js
+09b48f8e6b31d2ab018f12f359ce4db23b35c9d53cd065d6fadfbac55544cb93  code/lite3_ROS/web_console/stretch_nav_control.py
+670f0d2a352f836915a0dd8af22ba3f9268fad8fba0ff16c375f76dd759018c0  code/lite3_ROS/web_console/stretch_nav_footprint.py
+0851f120f415788483d6ef52c4bdb8afd14d9651a1ad4acb87ae19489dd1b3ad  code/lite3_ROS/web_console/stretch_nav_geometry.py
+75facca8ee2cbf17055298bc44301fd9c6c6313e133e7c6a5bedc36ab667710c  code/lite3_ROS/web_console/stretch_nav_learned.py
+189a52c4987f9fd042253ba263b9cd6bcb24a4c79badc46aa43a0cba902d215e  code/lite3_ROS/web_console/stretch_nav_recovery.py
+8a8b4c95878343eae73605474aa818cb7e283b13c3155b2d2492ddf1c5832570  code/lite3_ROS/web_console/stretch_nav_replay.py
+15318ba6d6e7b574c0ba50d49db1ebdbd03c44ff0c0f5e33ff3fb69462d3c4fc  code/lite3_ROS/web_console/stretch_nav_report.py
+6725df9d6b83a9bbaf6d7f93d30d0ff16988d5317f6fba1fa958aca720d63e9c  code/lite3_ROS/web_console/stretch_nav_survey.py
+8fdacb65956c47aff77d8f6a19a72960c117a7d89c7a6429f4cf7288dd2b272b  code/lite3_ROS/web_console/stretch_nav_viewer.py
+dde3814d364392aab6078402199a743b9653cb3b90ebfb5bd2932463930379a2  code/lite3_ROS/web_console/stretch_transport.py
+c9372443e127bbce7e6b7a0a920607c4115cdfa4b3ba0eb98cd1f9a8d282e16b  code/lite3_ROS/web_console/stretch_vggt_debug.py
+980c4c38bfef6167490f632ac7f39438bc32b14e00d3ad95147f862066ac496a  code/stretch_ai/LICENSE
+741574f7529734e5492a50ccd51e190a975f67f864fe8ec92c66063d9ed77fcb  code/stretch_ai/scripts/capture_lingbot_rgbd_ros2.py
+3838bb9e7bab6f71b1e10bc2f24c10f614f671897fbfdf1d5545db1ba952184b  code/stretch_ai/scripts/depth_nav_control.py
+ea99cdb412cc962f5e1cf72ed0dd255eb177024f1a7169349af5b78746386815  code/stretch_ai/scripts/depth_nav_debug.py
+c3ead5fbff583e23f5c0ef26afe123e8137c870dc1250b96ea309f453b753e46  code/stretch_ai/scripts/depth_nav_footprint.py
+9ad308cb8123eb819747136140dacd1e1a7571604412c764080935d71aa4fcc5  code/stretch_ai/scripts/depth_nav_live.py
+b4634c91e7113318e2322782e3070c018d59971b8cadc89f56b3933c14f3bb58  code/stretch_ai/scripts/depth_nav_memory.py
+c90128690eb85ddf883dcd48ab61980e8a2799c57368521925325daec3bdf44d  code/stretch_ai/scripts/depth_nav_robot_relay.py
+86a32af7fe5b740fd56a146571e3ae80fd99674c101f4c8143b13ff3e701d3ae  code/stretch_ai/scripts/depth_nav_trajectories.py
+03f7f193be8bbae5b03508a1d05f11d58ee2344bbf4ac3d59a945b8f2edaf19b  code/stretch_ai/scripts/depth_only_path_planner.py
+221d420a595a2ab6d6561b25d60d342867d02a0dcf0f16927fd898bc5c5578af  code/stretch_ai/scripts/lingbot_depth_eval.py
+a80afef0149ff5e7f3ceeece04c71db212aaee1403e531aaf695ee616120feb9  code/stretch_ai/scripts/lingbot_depth_geometry.py
+55787d89d8da689b57e10a47477b93e2ae75d29a5c0feee03816845af5e9cb99  code/stretch_ai/scripts/lingbot_depth_model.py
+7e362f18cbe8b27f6bd8a2cc6c6a858ef9adab9328ff29a12a7de8efb125eaf6  code/stretch_ai/scripts/lingbot_depth_sequence.py
+690816adfed07da9aafb39f55a71c49b5e89998e9905a33904884cb2b3e8b91c  code/stretch_ai/scripts/lingbot_voxel_map.py
+032592ce282329eb7537a355fe096ccc3ab8eb6108ea932f62cffc252f38ddd1  environment/gpu.txt
+6a6229b3e2ca8ea0b17a5d0d3346baa3fba732cf56322b1bf14527a87705cea9  environment/map_metadata_sanitization.json
+9f6cf1a536b4287a65458ae087b1a4531d2fec1a73eda5b27908189ec596fb59  environment/package_validation.json
+a1a25eb20977a72f4ac346c77a936fa5d46e5701b53968db49b73185f3675b29  environment/pip_freeze.txt
+372e5c3211d1d89eb2b2a8cb859318de6f15220cf698d3b66cfbcd51827a028f  environment/provenance.json
+6b88f85ba6878da27c2344e063fff4fda22d98ba3482a5680a540320be993c8d  environment/source_provenance.json
+bf08abe65e2a3dd0ab87d648daca029b6fccbe5921f319f6811ffafbf9d19447  manifest.json
+2ef9102f39e71e009e5e2d520714be27838b4f02392a13527e6a5a1072fd4fab  previews/00000747/bev_stages.png
+6b471e1c4e4d0b061f6feae099fed888b19c9d9bd124a5efbe7ab3d10b7e0064  previews/00000747/input_views.jpg
+2d3bb50b275181d8101909e4782acd113d985cb16dd3e7691ad7e44500f9174b  previews/00000747/manifest.json
+d3261dd3e93363573304889605cbd81c3f8ad0df69522e072be1da16fd423991  previews/00000747/predicted_depth.jpg
+3f2a22d9a811a371467f067ad42dea9306d6ca33675113059376f44fe61044b6  previews/rgb_00000574.jpg
+5021b57d94747c3ec68a92c890c500d8dbafa8f84302f64764692d10a42ff2d8  previews/rgb_00000627.jpg
+41a119b9f73e899178e9df291ee0f3e1274722b4d963f890bbca7de62bcf5b04  previews/rgb_00000708.jpg
+a5b189f15f22cff8c02a535dfb511e50a8eed7855fe3e14fc828838854514fc6  previews/rgb_00000730.jpg
+68ac018c1520de6c0fe59c3bad2ffadf0217bb5fc9d26021113ee5cbcf3c2c44  previews/rgb_00000747.jpg
+6dbd717673bc85f4e84074189ef6d846408cc22a18e5697b79bd94f820ba486b  reports/attachment_recheck_747.json
+3e0c997ce1afd2c23dbb8a3b6ebed2ca2e4b6cb51a2cf15104c8c50fc4a2bf3e  reports/bev_diagnosis/bev_overview.jpg
+3f3584df7eb8358abb2d9f1feb74d29c105c8346f445f94052f030bcbe5e88b4  reports/bev_diagnosis/diagnosis_stdout.log
+f51bcd30505943678f2eef7bb4d92c2acfa9aefae2fde248da86faa984751709  reports/bev_diagnosis/occupancy_timeline.csv
+de1bfa68797606388c854795452d2b004c4f970e260354b56810ceb8c1eaabd8  reports/bev_diagnosis/reference_ablation/head_mask_outputs.npz
+d27c74eb80db253e3f082a45058b5d182e7c7cfb30e8b2a314e7e1b443bb12b7  reports/bev_diagnosis/reference_ablation/recomputed_geometry_head_mask_outputs.npz
+c6abf6652889ea316411366df32c95e91d0ea68772703e1df3cdef78d1f7a0fa  reports/bev_diagnosis/reference_ablation/recomputed_geometry_report.json
+23e18837a11c22d98dfe529438a0bb9bea8eb5052cb801dc57fb340b8c767b5b  reports/bev_diagnosis/reference_ablation/report.json
+7dba4803fb68eaf6c2cc21231de967e33e4ed8505647b2b0fda30c8b6e2c53f5  reports/bev_diagnosis/region_analysis.png
+e5426064c3618af3de6f3d8cddd174d4d526a6ebf3e54b40e6be953376d70075  reports/bev_diagnosis/region_report.json
+8bd3efb512db0cb0af79ebf9e8583b35ba204b949a123ea32d26e39fbb5da2a0  reports/events.jsonl
+4f94c9d7f5056a057f7135cddc487cbd1dd6dbfe4b9872aa270c39aef2b3b31e  reports/observations.jsonl
+9c0aa8c80abcd19fecd7e1c7ebd5625589ca31a3485c579e561d70715b43f782  reports/recording_validation.json
+7cda24b9b0b0ea413c7b12ad463be3422893613465c2503eb35ec9f7669fcdda  reports/resolved_bev_config.json
+c12cf47ad229e57334cfc09b40364a87ef611c404c512b4274c9c37e70dce691  reports/robot_relay_close.json
+57839abd8587ec641810a9f1d0469bc1554c93ae11cdd4ddfa709a5d0b432390  reports/stop_audit.json
+9afea9b7e214f61f538af275594537d96f5e854642c09d0ed976666e3a030555  reports/summary.json
+f5348a69f87ff8631d510307e93b44473bba5cccd81b967454606a337630268f  reports/vggt_index.jsonl
+e699148a36a85eb93762475186cc20486fbca3f519469d86c31a3753ea3b9235  reports/vggt_provenance.json
+78fe2343a74e73794e9123bf016549a96c87ac4545e08c328ebdb0cdf699c9b4  tools/ablate_bev_references.py
+bc28cc2c49952142cb68ed5daf6b94e52c75c3dafaecdf3728016823f6bbce1f  tools/analyze_attachment.py
+fd63aaa56167b49042caa4fb0d432b68edd5ef8ffe91929192b86b33ff2c33a4  tools/diagnose_bev_region.py
+a6ce163de4ef4f52ded94f91f2aa5b64385ceebacd2bb5fb16dba950017f3b8d  tools/unpack.py

cases/20261026_goal1012_05/archives/CROSS_source.tar.gz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c3dd418506684ae4b05b49daeeb6456509d1542621911e0029fa6c420d75c64b
+size 28251800

cases/20261026_goal1012_05/archives/capture.tar

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4a6dec652cc53d8db40188df5d72870d974e17ff282f42ee96bd5ea205e691b4
+size 124999680

cases/20261026_goal1012_05/archives/reference_map.tar

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3876fa21325aea0a41dba3f647a8645815ed9f431c3e3e399e8a3f3d47768200
+size 208558080

cases/20261026_goal1012_05/archives/run_core.tar.gz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:71ab36b2cf266ea5054737b3dddf94b17fe4b2a16651173dc62d7ba752dc1049
+size 367815430

cases/20261026_goal1012_05/archives/vggt_frames_000.tar

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:dfe5cbec1b39558d5ce92503447663b744944da8bd4994ec0d1cb7908a371c84
+size 733143040

cases/20261026_goal1012_05/archives/vggt_frames_001.tar

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:74a02595997103e82261b734e8afa42a7b4693f8cd1caec407c3534988ce7d76
+size 729374720

cases/20261026_goal1012_05/archives/vggt_frames_002.tar

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:94113852d76817332b7bea586fead14ee6b229c438dc8c87c31e658d786ab114
+size 597340160

cases/20261026_goal1012_05/archives/vggt_metadata.tar.gz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7802f06f457281e0153170f2f8614c2a940dfc886bf6aa2a5b8eed614e458550
+size 9396

cases/20261026_goal1012_05/archives/vggt_views.tar

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:935373a868f7cba2a3325fde2d1eb61f69325a55763873021c2253fb535d0ff1
+size 819107840

cases/20261026_goal1012_05/code/lite3_ROS/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 DeepRoboticsLab
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

cases/20261026_goal1012_05/code/lite3_ROS/scripts/capture_stretch_cross.py

@@ -0,0 +1,131 @@
+#!/usr/bin/env python3
+"""Record timestamped Stretch observations through an unarmed temporary relay.
+
+Only SUB sockets are opened on the PC. No arm, mode, joint or velocity requests are sent.
+Place a STOP file in the output directory or use Ctrl+C to finish and close our relay.
+"""
+import argparse
+import json
+from pathlib import Path
+import signal
+import sys
+import time
+from types import SimpleNamespace
+
+import numpy as np
+
+
+def json_value(value):
+    if isinstance(value, np.ndarray):
+        return value.tolist()
+    if isinstance(value, np.generic):
+        return value.item()
+    raise TypeError(f'Cannot serialize {type(value).__name__}')
+
+
+def atomic_json(path, data):
+    temporary = path.with_suffix('.json.tmp')
+    temporary.write_text(json.dumps(data, indent=2, allow_nan=False, default=json_value) + '\n')
+    temporary.replace(path)
+
+
+def main():
+    import zmq
+
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument('--robot-ip', default='192.0.2.2')
+    parser.add_argument('--stretch-root', type=Path, default=Path('/workspace/stretch_ai'))
+    parser.add_argument('--output', type=Path, required=True)
+    parser.add_argument('--fps', type=float, default=4.)
+    args = parser.parse_args()
+    output = args.output.resolve()
+    output.mkdir(parents=True, exist_ok=False)
+    for name in ('rgb', 'depth'):
+        (output / name).mkdir()
+    sys.path.insert(0, str(args.stretch_root / 'scripts'))
+    from depth_nav_live import RobotRelayProcess
+
+    options = SimpleNamespace(robot_ip=args.robot_ip, ssh_user='hello-robot', container=None,
+                              world_frame='odom', plan_hz=args.fps,
+                              relay_max_frame_age=.8, command_ttl=.3)
+    relay = RobotRelayProcess(options, output)
+    context = zmq.Context()
+    observations = context.socket(zmq.SUB)
+    observations.setsockopt(zmq.SUBSCRIBE, b'')
+    observations.setsockopt(zmq.CONFLATE, 1)
+    observations.setsockopt(zmq.LINGER, 0)
+    observations.connect(f'tcp://{args.robot_ip}:4511')
+    states = context.socket(zmq.SUB)
+    states.setsockopt(zmq.SUBSCRIBE, b'')
+    states.setsockopt(zmq.CONFLATE, 1)
+    states.setsockopt(zmq.LINGER, 0)
+    states.connect(f'tcp://{args.robot_ip}:4513')
+    stopped = False
+
+    def stop(*_):
+        nonlocal stopped
+        stopped = True
+
+    signal.signal(signal.SIGTERM, stop)
+    signal.signal(signal.SIGINT, stop)
+    state = {'status': 'starting', 'frames': 0, 'world_frame': 'odom',
+             'robot_ip': args.robot_ip, 'robot_commands_sent': 0, 'armed': False}
+    started, last_frame, first_stamp = time.monotonic(), -1, None
+    error = None
+    atomic_json(output / 'capture.json', state)
+    try:
+        relay.start()
+        state.update(status='recording', relay_directory=relay.directory, container=relay.container)
+        with (output / 'observations.jsonl').open('w', buffering=1) as log:
+            while not stopped and not (output / 'STOP').exists():
+                if relay.process is not None and relay.process.poll() is not None:
+                    raise RuntimeError('Our temporary observation relay exited; inspect robot_relay.log')
+                if states.poll(0):
+                    robot = states.recv_pyobj()
+                    if robot.get('armed'):
+                        raise RuntimeError('Relay unexpectedly armed; passive capture aborted')
+                    state['robot_status'] = {key: robot.get(key) for key in
+                        ('healthy', 'armed', 'reason', 'capture_error', 'base_pose', 'sensor_age')}
+                if not observations.poll(250):
+                    state['elapsed_s'] = time.monotonic() - started
+                    atomic_json(output / 'capture.json', state)
+                    continue
+                packet = observations.recv_pyobj()
+                if packet['frame_id'] <= last_frame:
+                    continue
+                if packet['world_frame'] != 'odom':
+                    raise ValueError('Capture requires continuous odom TF')
+                last_frame = packet['frame_id']
+                index = state['frames']
+                stem = f'{index:08d}'
+                (output / 'rgb' / f'{stem}.jpg').write_bytes(np.asarray(packet['rgb_jpg'], np.uint8).tobytes())
+                (output / 'depth' / f'{stem}.png').write_bytes(np.asarray(packet['depth_png'], np.uint8).tobytes())
+                row = {key: value.tolist() if isinstance(value, np.ndarray) else value
+                       for key, value in packet.items() if key not in ('rgb_jpg', 'depth_png')}
+                first_stamp = row['sensor_stamp'] if first_stamp is None else first_stamp
+                row.update(frame_idx=index, relative_time_s=row['sensor_stamp'] - first_stamp,
+                           received_monotonic=time.monotonic(), received_unix_s=time.time())
+                log.write(json.dumps(row, allow_nan=False, default=json_value) + '\n')
+                atomic_json(output / 'latest.json', row)
+                state.update(frames=index + 1, latest_frame=index, duration_s=row['relative_time_s'],
+                             elapsed_s=time.monotonic() - started)
+                atomic_json(output / 'capture.json', state)
+                if index % 20 == 0:
+                    print(f"Recorded {index + 1} RGB-D/TF observations; {row['relative_time_s']:.1f}s; passive", flush=True)
+    except BaseException as exc:
+        error = str(exc)
+        state.update(status='failed', error=error)
+        raise
+    finally:
+        relay.close()
+        observations.close()
+        states.close()
+        context.term()
+        if error is None:
+            state['status'] = 'completed'
+        state['elapsed_s'] = time.monotonic() - started
+        atomic_json(output / 'capture.json', state)
+
+
+if __name__ == '__main__':
+    main()

cases/20261026_goal1012_05/code/lite3_ROS/scripts/diagnose_stretch_bev_blockage.py

@@ -0,0 +1,420 @@
+#!/usr/bin/env python3
+"""Trace a recorded BEV footprint rejection and compare it with depth and map memory.
+
+Read-only offline analysis: no robot connection, model inference or policy changes.
+"""
+
+import argparse
+import csv
+import json
+import math
+import sys
+from pathlib import Path
+
+import cv2
+import numpy as np
+
+ROOT = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(ROOT if (ROOT / "web_console").is_dir() else ROOT / "code/lite3_ROS"))
+from web_console.stretch_nav_control import depth_obstacles, wrap  # noqa: E402
+from web_console.stretch_nav_geometry import body_to_world, world_to_body  # noqa: E402
+from web_console.stretch_nav_learned import reproject_bev  # noqa: E402
+from web_console.stretch_nav_recovery import rectangle_path_clear  # noqa: E402
+from web_console.stretch_nav_report import clean_json  # noqa: E402
+from web_console.stretch_vggt_debug import load_debug_frame  # noqa: E402
+
+
+def rectangle_samples(path, half=0.23, horizon=1.2):
+    """Same rotation/translation samples as the recorded rectangular guard."""
+    path = np.vstack([[0.0, 0.0], np.asarray(path, float).reshape(-1, 2)])
+    offsets = np.array(np.meshgrid(np.linspace(-half, half, 11), np.linspace(-half, half, 11))).reshape(2, -1).T
+    travelled, heading = 0.0, 0.0
+    for index, (a, b) in enumerate(zip(path[:-1], path[1:])):
+        distance = float(np.linalg.norm(b - a))
+        if distance < 1e-5:
+            continue
+        yaw = math.atan2(*(b - a)[::-1])
+        samples = [("rotate", a, angle) for angle in np.linspace(heading, heading + wrap(yaw - heading), 8)]
+        samples += [
+            ("translate", a + t * (b - a), yaw)
+            for t in np.linspace(
+                0.0, min(1.0, max(0.0, horizon - travelled) / distance), max(2, int(distance / 0.04) + 1)
+            )
+        ]
+        for stage, center, angle in samples:
+            c, s = math.cos(angle), math.sin(angle)
+            yield index, stage, center, angle, offsets @ np.array([[c, s], [-s, c]]) + center
+        travelled, heading = travelled + distance, yaw
+        if travelled >= horizon:
+            break
+
+
+def trace_rectangle(path, grid):
+    probability = np.asarray(grid["prob"]).copy()
+    n, res = len(probability), float(grid["res"])
+    axis = (n / 2 - np.arange(n) - 0.5) * res
+    probability[(abs(axis[:, None]) <= 0.23) & (abs(axis[None, :]) <= 0.23)] = 0.0
+    first, all_cells = None, set()
+    for segment, stage, center, angle, points in rectangle_samples(path):
+        rc = np.floor(n / 2 - points / res).astype(int)
+        inside = ((rc >= 0) & (rc < n)).all(1)
+        if not inside.all():
+            if first is None:
+                first = {
+                    "reason": "outside grid",
+                    "segment": segment,
+                    "stage": stage,
+                    "center_body_xy": center,
+                    "yaw_rad": angle,
+                    "cells": [],
+                }
+            continue
+        blocked = (probability[rc[:, 0], rc[:, 1]] > 0.6) & (grid["obs"][rc[:, 0], rc[:, 1]] > 0.5)
+        cells = np.unique(rc[blocked], axis=0)
+        all_cells.update(map(tuple, cells))
+        if len(cells) and first is None:
+            first = {
+                "reason": "learned occupancy",
+                "segment": segment,
+                "stage": stage,
+                "center_body_xy": center,
+                "yaw_rad": angle,
+                "cells": cells.tolist(),
+            }
+    result = {"clear": first is None, "first_contact": first, "all_blocking_cells": sorted(all_cells)}
+    assert result["clear"] == rectangle_path_clear(path, grid), (
+        "Diagnostic disagrees with recorded guard implementation"
+    )
+    return result
+
+
+def project_ground(point_xy, source):
+    camera, K = np.asarray(source["camera_pose"]), np.asarray(source["camera_K"])
+    ground = np.r_[point_xy, np.asarray(source["base_pose_matrix"])[2, 3]]
+    camera_point = (ground - camera[:3, 3]) @ camera[:3, :3]
+    pixel = (K @ camera_point)[:2] / camera_point[2]
+    return pixel, camera_point
+
+
+def depth_at_ground(run, source, point_xy):
+    pixel, camera_point = project_ground(point_xy, source)
+    depth = cv2.imread(str(run / "capture/depth" / f"{source['frame_idx']:08d}.png"), cv2.IMREAD_UNCHANGED)
+    if depth is None:
+        raise FileNotFoundError("Recorded depth missing")
+    result = {
+        "frame": source["frame_idx"],
+        "time_s": source["relative_time_s"],
+        "pixel_uv": pixel,
+        "expected_ground_depth_m": camera_point[2],
+        "inside_image": False,
+    }
+    u, v = np.rint(pixel).astype(int)
+    if camera_point[2] <= 0 or not (3 <= u < depth.shape[1] - 3 and 3 <= v < depth.shape[0] - 3):
+        return result
+    result["inside_image"] = True
+    patch = depth[v - 3 : v + 4, u - 3 : u + 4].astype(float) / 1000.0
+    vv, uu = np.mgrid[v - 3 : v + 4, u - 3 : u + 4]
+    valid = (patch > 0.1) & (patch < 3.0)
+    if not valid.any():
+        return result
+    K, camera = np.asarray(source["camera_K"]), np.asarray(source["camera_pose"])
+    z = patch[valid]
+    pc = np.column_stack([(uu[valid] - K[0, 2]) * z / K[0, 0], (vv[valid] - K[1, 2]) * z / K[1, 1], z])
+    points = pc @ camera[:3, :3].T + camera[:3, 3]
+    nearby = np.linalg.norm(points[:, :2] - point_xy, axis=1) <= 0.10
+    result.update(valid_depth_pixels=int(valid.sum()), nearby_returns=int(nearby.sum()))
+    if nearby.any():
+        height = points[nearby, 2] - np.asarray(source["base_pose_matrix"])[2, 3]
+        result.update(
+            median_height_m=float(np.median(height)),
+            min_height_m=float(height.min()),
+            max_height_m=float(height.max()),
+            floor_returns=int((abs(height) <= 0.08).sum()),
+            elevated_returns=int((height > 0.12).sum()),
+            median_depth_m=float(np.median(z[nearby])),
+        )
+    return result
+
+
+def column_free_space(run, rows, point_xy):
+    """Positive ray evidence at sampled heights; exclude missing/long-range depth."""
+    heights = np.arange(0.12, 1.801, 0.12)
+    result = [{"height_m": float(z), "free_frames": [], "surface_frames": []} for z in heights]
+    for source in rows:
+        camera, K = np.asarray(source["camera_pose"]), np.asarray(source["camera_K"])
+        depth = cv2.imread(str(run / "capture/depth" / f"{source['frame_idx']:08d}.png"), -1).astype(float) / 1000.0
+        points = np.column_stack([np.repeat(np.asarray(point_xy)[None], len(heights), axis=0), heights])
+        pc = (points - camera[:3, 3]) @ camera[:3, :3]
+        uv = (pc @ K.T)[:, :2] / pc[:, 2:3]
+        for index, (u, v) in enumerate(np.rint(uv).astype(int)):
+            if pc[index, 2] <= 0 or not (0 <= u < depth.shape[1] and 0 <= v < depth.shape[0]):
+                continue
+            measured = depth[v, u]
+            if not 0.1 < measured < 10.0:
+                continue
+            residual = measured - pc[index, 2]
+            if residual > 0.08:
+                result[index]["free_frames"].append(source["frame_idx"])
+            elif abs(residual) <= 0.08:
+                result[index]["surface_frames"].append(source["frame_idx"])
+    return {
+        "method": "Measured depth exceeds expected optical depth by >8 cm at projected column samples; "
+        "only finite recorded depth between 0.1 and 10 m is used.",
+        "samples": result,
+        "note": "Discrete historical ray evidence, not a continuous collision certificate.",
+    }
+
+
+def map_probability(state, point_xy):
+    world = state["world"]
+    row, col = np.floor((point_xy - world["o"]) / world["c"]["res"]).astype(int)[::-1]
+    den = float(world["den"][row, col])
+    return {
+        "row": int(row),
+        "column": int(col),
+        "weight": den,
+        "observability_sum": float(world["seen"][row, col]),
+        "occupancy": float(world["num"][row, col] / max(den, 1e-6)),
+        "block_threshold": world["c"]["block_p"],
+        "bump_count": len(state.get("bumps", [])),
+    }
+
+
+def sampled(array, uv):
+    xy = np.asarray([[uv]], np.float32)
+    return float(cv2.remap(np.asarray(array, np.float32), xy[:, :, 0], xy[:, :, 1], cv2.INTER_LINEAR)[0, 0])
+
+
+def draw_report(run, raw, frame, debug, cell, timeline, depth_history, output):
+    import matplotlib
+
+    matplotlib.use("Agg")
+    import matplotlib.pyplot as plt
+    from matplotlib.patches import Polygon, Rectangle
+
+    grid = debug["outputs"]["body_grid"]
+    observation = debug["outputs"]["observation"]
+    base = np.asarray(raw[frame]["base_pose_matrix"])
+    point = np.asarray(cell["world_xy"])
+    floor_rows = [x for x in depth_history if x.get("floor_returns", 0) >= 3]
+    earlier = max([x for x in floor_rows if 20 <= x["pixel_uv"][1] <= 600] or floor_rows, key=lambda x: x["frame"])
+    fig, axes = plt.subplots(2, 3, figsize=(17, 10), constrained_layout=True)
+    for axis, index, label in [
+        (axes[0, 0], frame, "Trigger frame"),
+        (axes[0, 1], earlier["frame"], "Same world location seen earlier"),
+    ]:
+        rgb = cv2.cvtColor(cv2.imread(str(run / "capture/rgb" / f"{index:08d}.jpg")), cv2.COLOR_BGR2RGB)
+        axis.imshow(rgb)
+        pixel, _ = project_ground(point, raw[index])
+        if 0 <= pixel[0] < rgb.shape[1] and 0 <= pixel[1] < rgb.shape[0]:
+            axis.scatter(*pixel, s=180, marker="o", facecolors="none", edgecolors="lime", linewidths=2)
+        else:
+            axis.annotate(
+                "Flagged ground cell is below this image",
+                xy=(np.clip(pixel[0], 0, rgb.shape[1] - 1), rgb.shape[0] - 8),
+                xytext=(12, rgb.shape[0] - 90),
+                color="white",
+                fontsize=9,
+                bbox={"facecolor": "black", "alpha": 0.8},
+                arrowprops={"arrowstyle": "->", "color": "red"},
+            )
+        axis.set_title(f"{label}: {index}")
+        axis.axis("off")
+
+    n, res = len(grid["prob"]), 0.05
+    extent = (n * res / 2, -n * res / 2, -n * res / 2, n * res / 2)
+    axis = axes[0, 2]
+    image = axis.imshow(grid["prob"], extent=extent, origin="upper", cmap="RdYlGn_r", vmin=0, vmax=1)
+    axis.contour(grid["obs"], levels=[0.5], extent=extent, origin="upper", colors="gray", linewidths=0.5)
+    axis.set_title("Current learned BEV: occupancy; gray = obs 0.5")
+    world = debug["outputs"]["planner_state"]["world"]
+    rr, cc = np.mgrid[:n, :n]
+    local = np.column_stack([(n / 2 - rr.ravel() - 0.5) * res, (n / 2 - cc.ravel() - 0.5) * res])
+    world_xy = body_to_world(local, base)
+    vu = ((world_xy - world["o"]) / world["c"]["res"] - 0.5).astype(np.float32)
+    probability = world["num"] / np.maximum(world["den"], 1e-6)
+    history_grid = cv2.remap(probability, vu[:, 0].reshape(n, n), vu[:, 1].reshape(n, n), cv2.INTER_LINEAR)
+    axes[1, 2].imshow(history_grid, extent=extent, origin="upper", cmap="RdYlGn_r", vmin=0, vmax=1)
+    axes[1, 2].set_title("Native map memory: low occupancy at X")
+    path = np.asarray(observation["native_local_path_body"])
+    for axis in [axes[0, 2], axes[1, 2]]:
+        axis.plot(path[:, 1], path[:, 0], color="blue", label="native path")
+        axis.scatter(cell["body_xy"][1], cell["body_xy"][0], c="black", marker="x", s=85, label="first blocking cell")
+        axis.add_patch(Rectangle((-0.23, -0.23), 0.46, 0.46, fill=False, color="black", linewidth=1.5))
+        contact = cell["contact"]
+        c, s = np.cos(contact["yaw_rad"]), np.sin(contact["yaw_rad"])
+        corners = np.array([[-0.23, -0.23], [-0.23, 0.23], [0.23, 0.23], [0.23, -0.23]])
+        corners = corners @ np.array([[c, s], [-s, c]]) + contact["center_body_xy"]
+        axis.add_patch(Polygon(corners[:, ::-1], fill=False, edgecolor="purple", label="first rejected footprint"))
+        axis.set(xlim=(1.3, -1.3), ylim=(-0.4, 2.1), xlabel="Left [m]", ylabel="Forward [m]")
+        axis.set_aspect("equal")
+        axis.legend(fontsize=7, loc="upper left")
+    fig.colorbar(image, ax=[axes[0, 2], axes[1, 2]], label="Occupancy prediction", shrink=0.6)
+
+    axis = axes[1, 0]
+    axis.plot([x["time_s"] for x in timeline], [x["current_occupancy"] for x in timeline], "o-", label="current BEV")
+    axis.plot(
+        [x["time_s"] for x in timeline], [x["fused_occupancy"] for x in timeline], ".-", label="native map memory"
+    )
+    axis.axhline(0.6, color="red", linestyle="--", label="occupancy threshold")
+    axis.set(
+        xlabel="Capture-relative time [s]",
+        ylabel="Occupancy at same world point",
+        ylim=(0, 1),
+        title="Transient rise in the current BEV",
+    )
+    axis.legend(fontsize=8)
+    axis.grid(alpha=0.2)
+    axis = axes[1, 1]
+    depth_rows = [x for x in depth_history if x.get("nearby_returns", 0)]
+    axis.plot(
+        [x["time_s"] for x in depth_rows], [x["median_height_m"] for x in depth_rows], ".", label="measured height"
+    )
+    axis.axhline(0.12, color="red", linestyle="--", label="depth guard obstacle height")
+    axis.axhspan(-0.08, 0.08, color="green", alpha=0.15, label="floor comparison band")
+    axis.set(
+        xlabel="Capture-relative time [s]",
+        ylabel="Height over base origin [m]",
+        ylim=(-0.12, 0.3),
+        title="Depth returns at that location agree with floor",
+    )
+    axis.legend(fontsize=8)
+    axis.grid(alpha=0.2)
+    fig.suptitle(f"Frame {frame}: false-occupancy evidence and the local adapter survey trigger", fontsize=15)
+    fig.savefig(output / "blockage_analysis.png", dpi=150)
+    plt.close(fig)
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--run", type=Path, required=True)
+    parser.add_argument("--frame", type=int, default=494)
+    parser.add_argument("--output", type=Path, required=True)
+    args = parser.parse_args()
+    run, output, frame = args.run.resolve(), args.output.resolve(), args.frame
+    output.mkdir(parents=True, exist_ok=True)
+    raw = {x["frame_idx"]: x for x in map(json.loads, (run / "capture/observations.jsonl").read_text().splitlines())}
+    debug = load_debug_frame(run / "vggt_debug", frame)
+    result = debug["outputs"]
+    observation, grid = result["observation"], {**result["body_grid"], "res": result["consumed_bev"]["res"]}
+    trace = trace_rectangle(observation["native_local_path_body"], grid)
+    if trace["clear"] or not trace["first_contact"]["cells"]:
+        raise ValueError("Selected frame has no learned occupancy rejection")
+    rc = np.array(trace["first_contact"]["cells"][0])
+    body = (len(grid["prob"]) / 2 - rc - 0.5) * grid["res"]
+    world_point = body_to_world([body], np.asarray(raw[frame]["base_pose_matrix"]))[0]
+    cell = {
+        "row": int(rc[0]),
+        "column": int(rc[1]),
+        "body_xy": body,
+        "world_xy": world_point,
+        "probability": grid["prob"][tuple(rc)],
+        "observability": grid["obs"][tuple(rc)],
+        "error_score": grid["err"][tuple(rc)],
+        "contact": trace["first_contact"],
+    }
+    counterfactual = {**grid, "prob": grid["prob"].copy()}
+    counterfactual["prob"][tuple(rc)] = 0.0
+    history = [
+        depth_at_ground(run, row, world_point)
+        for index, row in sorted(raw.items())
+        if index <= frame and raw[frame]["relative_time_s"] - row["relative_time_s"] <= 20.0
+    ]
+    timeline = []
+    for path in sorted((run / "vggt_debug/frames").glob("*/frame.json")):
+        index = int(path.parent.name)
+        if (
+            index > frame + 2
+            or index not in raw
+            or raw[frame]["relative_time_s"] - raw[index]["relative_time_s"] > 20.0
+        ):
+            continue
+        data = load_debug_frame(run / "vggt_debug", index)
+        out = data.get("outputs", {})
+        if not out.get("body_grid") or not out.get("planner_state", {}).get("world"):
+            continue
+        base = np.asarray(raw[index]["base_pose_matrix"])
+        local = world_to_body(world_point, base)
+        pixel = (len(grid["prob"]) / 2 - local / grid["res"] - 0.5)[::-1]
+        g = out["body_grid"]
+        timeline.append(
+            {
+                "frame": index,
+                "time_s": raw[index]["relative_time_s"],
+                "current_occupancy": sampled(g["prob"], pixel),
+                "current_observability": sampled(g["obs"], pixel),
+                "fused_occupancy": map_probability(out["planner_state"], world_point)["occupancy"],
+            }
+        )
+    bev = result["consumed_bev"]
+    recomputed = reproject_bev(
+        bev["prob"],
+        bev["observability"],
+        bev["uncertainty"],
+        bev["R_bev_from_cam"],
+        np.asarray(raw[frame]["camera_pose"]),
+        np.asarray(raw[frame]["base_pose_matrix"]),
+        grid["res"],
+    )
+    source_uv = grid["base_pixel_to_camera_pixel"] @ np.r_[rc[::-1], 1.0]
+    raw_head = debug["passes"][0]["head_calls"][0]["outputs"]
+    with np.load(run / "footprint_evidence" / f"{frame:08d}.npz", allow_pickle=False) as evidence:
+        memory = evidence["measured_obstacles_odom"].copy()
+    depth = cv2.imread(str(run / "capture/depth" / f"{frame:08d}.png"), cv2.IMREAD_UNCHANGED).astype(float) / 1000
+    current_obstacles = depth_obstacles(depth, raw[frame]["camera_K"], raw[frame]["camera_pose"])
+    floors = [x for x in history if x.get("floor_returns", 0) >= 3 and x.get("elevated_returns") == 0]
+    report = {
+        "run": run.name,
+        "capture_frame": frame,
+        "native_planner_status": observation["native_planner_status"],
+        "native_status_meaning": "6 = valid episode-map route",
+        "recorded_rectangle_clear": observation["rectangle_clear"],
+        "trace": trace,
+        "first_blocking_cell": cell,
+        "native_accumulated_map_at_cell": map_probability(result["planner_state"], world_point),
+        "raw_head_occupancy_at_same_cell": sampled(raw_head["prob"], source_uv),
+        "counterfactual_one_cell_removed": {
+            "rectangle_clear": rectangle_path_clear(observation["native_local_path_body"], counterfactual),
+            "note": "Offline attribution test only; the recorded/runtime prediction and thresholds are unchanged.",
+        },
+        "base_reprojection_max_absolute_difference": float(abs(recomputed["prob"] - grid["prob"]).max()),
+        "thresholds": {"occupancy": 0.6, "observability": 0.5},
+        "current_image_projection": depth_at_ground(run, raw[frame], world_point),
+        "floor_history_observations": len(floors),
+        "latest_floor_observation": max(floors, key=lambda x: x["frame"]),
+        "nearby_elevated_returns_current": int((np.linalg.norm(current_obstacles - world_point, axis=1) <= 0.1).sum()),
+        "nearby_elevated_returns_remembered": int((np.linalg.norm(memory - world_point, axis=1) <= 0.1).sum()),
+        "all_depth_history": history,
+        "occupancy_timeline": timeline,
+        "column_free_space": column_free_space(run, [raw[x["frame"]] for x in history], world_point),
+        "vggt_inputs": [
+            {"role": v["role"], "reference": v.get("reference"), "asset": v["asset"]}
+            for v in debug["passes"][0]["views"]
+        ],
+        "finding": "A transient current-frame occupancy prediction triggers the added rectangular path guard, "
+        "while native map-memory planning still supplies a route. The first rejected cell is below "
+        "the current image and agrees with floor in recent RGB-D history. This strongly supports "
+        "a false obstacle at that cell; it does not certify every part of the physical route.",
+    }
+    (output / "report.json").write_text(json.dumps(clean_json(report), indent=2, allow_nan=False) + "\n")
+    with (output / "occupancy_timeline.csv").open("w", newline="") as f:
+        writer = csv.DictWriter(f, fieldnames=list(timeline[0]))
+        writer.writeheader()
+        writer.writerows(timeline)
+    draw_report(run, raw, frame, debug, cell, timeline, history, output)
+    print(
+        json.dumps(
+            clean_json(
+                {
+                    k: v
+                    for k, v in report.items()
+                    if k not in {"all_depth_history", "occupancy_timeline", "column_free_space", "vggt_inputs"}
+                }
+            ),
+            indent=2,
+        )
+    )
+
+
+if __name__ == "__main__":
+    main()

cases/20261026_goal1012_05/code/lite3_ROS/scripts/diagnose_stretch_bev_region.py

@@ -0,0 +1,193 @@
+"""Compare arbitrary saved BEV cells with survey depth, raw heads and planner memory; no hardware."""
+
+import argparse
+import csv
+import json
+import sys
+from pathlib import Path
+
+import cv2
+import numpy as np
+
+ROOT = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(ROOT if (ROOT / 'web_console').is_dir() else ROOT / 'code/lite3_ROS'))
+from scripts.diagnose_stretch_bev_blockage import (  # noqa: E402
+    column_free_space,
+    depth_at_ground,
+    map_probability,
+    project_ground,
+    sampled,
+)
+from web_console.stretch_nav_geometry import body_to_world, world_to_body  # noqa: E402
+from web_console.stretch_nav_learned import reproject_bev  # noqa: E402
+from web_console.stretch_nav_report import clean_json  # noqa: E402
+from web_console.stretch_vggt_debug import load_debug_frame  # noqa: E402
+
+
+def timeline(run, raw, cells, begin, end):
+    result = []
+    for path in sorted((run / 'vggt_debug/frames').glob('*/frame.json')):
+        index = int(path.parent.name)
+        if index > end or raw[index]['relative_time_s'] < begin:
+            continue
+        data = json.loads(path.read_text())
+        metadata = data.get('outputs', {})
+        if not metadata.get('body_grid') or not metadata.get('planner_state'):
+            continue
+        with np.load(path.parent / 'arrays.npz', allow_pickle=False) as archive:
+            cache = {}
+
+            def unpack(value):
+                if isinstance(value, dict):
+                    if 'npz_key' in value:
+                        key = value['npz_key']
+                        if key not in cache:
+                            cache[key] = archive[key]
+                        return cache[key]
+                    return {k: unpack(v) for k, v in value.items()}
+                if isinstance(value, list):
+                    return [unpack(v) for v in value]
+                return value
+
+            grid = unpack(metadata['body_grid'])
+            state = unpack(metadata['planner_state'])
+            n, res = len(grid['prob']), .05
+            for cell in cells:
+                body = world_to_body(cell['world_xy'], np.asarray(raw[index]['base_pose_matrix']))
+                rc = np.floor(n / 2 - body / res).astype(int)
+                if not ((rc >= 0) & (rc < n)).all():
+                    continue
+                result.append({'frame': index, 'time_s': raw[index]['relative_time_s'], 'cell': cell['label'],
+                    'current_occupancy': float(grid['prob'][tuple(rc)]),
+                    'current_observability': float(grid['obs'][tuple(rc)]),
+                    'fused_occupancy': map_probability(state, cell['world_xy'])['occupancy']})
+    return result
+
+
+def figure(run, raw, debug, cells, curve, output):
+    import matplotlib
+
+    matplotlib.use('Agg')
+    import matplotlib.pyplot as plt
+    from matplotlib.patches import Rectangle
+
+    frame = debug['capture_frame']
+    floor_views = [row for row in cells[0]['depth_history'] if row.get('floor_returns', 0) >= 40]
+    selected = max(floor_views, key=lambda row: min(row['pixel_uv'][0], 480 - row['pixel_uv'][0],
+                                                   row['pixel_uv'][1], 640 - row['pixel_uv'][1]))['frame']
+    fig, axes = plt.subplots(2, 3, figsize=(17, 10), constrained_layout=True)
+    for axis, index, title in ((axes[0, 0], frame, 'Current RGB'),
+                               (axes[0, 1], selected, 'Survey RGB: same fixed world cells')):
+        rgb = cv2.cvtColor(cv2.imread(str(run / 'capture/rgb' / f'{index:08d}.jpg')), cv2.COLOR_BGR2RGB)
+        axis.imshow(rgb)
+        for cell in cells:
+            uv, _ = project_ground(cell['world_xy'], raw[index])
+            if 0 <= uv[0] < rgb.shape[1] and 0 <= uv[1] < rgb.shape[0]:
+                axis.scatter(*uv, s=170, facecolors='none', edgecolors='lime', linewidths=2)
+                axis.annotate(cell['label'], uv + [8, -8], color='lime', weight='bold')
+        axis.set_title(f'{title}, frame {index}')
+        axis.axis('off')
+    axes[0, 0].text(.02, .98, 'A and B ground centres are outside this view', transform=axes[0, 0].transAxes,
+                   va='top', color='white', bbox={'facecolor': 'black', 'alpha': .7})
+    grid = debug['outputs']['body_grid']
+    half, res = len(grid['prob']) * .05 / 2, .05
+    extent = (half, -half, -half, half)
+    axes[0, 2].imshow(grid['prob'], extent=extent, origin='upper', cmap='RdYlGn_r', vmin=0, vmax=1)
+    axes[0, 2].set(xlim=(3., -3.), ylim=(-.5, 5.), title='Current BEV: forward-left red patch',
+                   xlabel='Left [m]', ylabel='Forward [m]')
+    world = debug['outputs']['planner_state']['world']
+    n = len(grid['prob'])
+    rr, cc = np.mgrid[:n, :n]
+    local = np.column_stack([(n / 2 - rr.ravel() - .5) * res, (n / 2 - cc.ravel() - .5) * res])
+    xy = body_to_world(local, np.asarray(raw[frame]['base_pose_matrix']))
+    uv = ((xy - world['o']) / world['c']['res'] - .5).astype(np.float32)
+    fused = cv2.remap(world['num'] / np.maximum(world['den'], 1e-6),
+                      uv[:, 0].reshape(n, n), uv[:, 1].reshape(n, n), cv2.INTER_LINEAR)
+    for axis, values, title in ((axes[1, 0], grid['prob'], 'Current occupancy: detailed near field'),
+                                 (axes[1, 1], fused, 'Separate native planner memory')):
+        axis.imshow(values, extent=extent, origin='upper', cmap='RdYlGn_r', vmin=0, vmax=1)
+        axis.set(xlim=(1.5, -.3), ylim=(-.3, 1.5), title=title, xlabel='Left [m]', ylabel='Forward [m]')
+    for axis in (axes[0, 2], axes[1, 0], axes[1, 1]):
+        axis.add_patch(Rectangle((-.23, -.23), .46, .46, fill=False, color='black', linewidth=1.5))
+        for cell in cells:
+            fwd, left = cell['body_xy']
+            axis.scatter(left, fwd, marker='x', color='black', s=60)
+            axis.annotate(cell['label'], (left + .025, fwd + .025), weight='bold')
+        axis.set_aspect('equal')
+    for label, style in (('A', '-'), ('B', '--')):
+        points = [x for x in curve if x['cell'] == label]
+        axes[1, 2].plot([x['time_s'] for x in points], [x['current_occupancy'] for x in points],
+                         style, label=f'{label}: current')
+        axes[1, 2].plot([x['time_s'] for x in points], [x['fused_occupancy'] for x in points],
+                         style, alpha=.6, label=f'{label}: fused memory')
+    axes[1, 2].axhline(.6, color='red', linewidth=.8, label='blocking threshold')
+    axes[1, 2].set(xlabel='Capture-relative time [s]', ylabel='Occupancy', ylim=(0, 1),
+                   title='Same fixed world cells through the survey')
+    axes[1, 2].legend(fontsize=8)
+    axes[1, 2].grid(alpha=.2)
+    fig.suptitle('Frame 747: false occupancy in the nearby forward-left patch', fontsize=15)
+    fig.savefig(output / 'region_analysis.png', dpi=150)
+    plt.close(fig)
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument('--run', type=Path, required=True)
+    parser.add_argument('--frame', type=int, default=747)
+    parser.add_argument('--output', type=Path, required=True)
+    args = parser.parse_args()
+    run, output, frame = args.run.resolve(), args.output.resolve(), args.frame
+    output.mkdir(parents=True, exist_ok=True)
+    raw = {r['frame_idx']: r for r in map(json.loads,
+        (run / 'capture/observations.jsonl').read_text().splitlines())}
+    debug = load_debug_frame(run / 'vggt_debug', frame)
+    grid, bev = debug['outputs']['body_grid'], debug['outputs']['consumed_bev']
+    history = [r for r in raw.values() if r['frame_idx'] <= frame and
+               r['relative_time_s'] >= raw[frame]['relative_time_s'] - 60.]
+    recomputed = reproject_bev(bev['prob'], bev['observability'], bev['uncertainty'],
+        bev['R_bev_from_cam'], raw[frame]['camera_pose'], raw[frame]['base_pose_matrix'], bev['res'])
+    cells = []
+    for label, rc in (('A', (190, 190)), ('B', (189, 189))):
+        body = (len(grid['prob']) / 2 - np.asarray(rc) - .5) * bev['res']
+        xy = body_to_world([body], np.asarray(raw[frame]['base_pose_matrix']))[0]
+        depth_history = [depth_at_ground(run, source, xy) for source in history]
+        floors = [row for row in depth_history if row.get('floor_returns', 0) >= 3 and
+                  row.get('elevated_returns', 0) == 0]
+        if not floors:
+            raise ValueError('No supporting floor observation at selected cell')
+        uv = grid['base_pixel_to_camera_pixel'] @ [rc[1], rc[0], 1.]
+        raw_head = debug['passes'][0]['head_calls'][0]['outputs']
+        cells.append({'label': label, 'row': rc[0], 'column': rc[1], 'body_xy': body,
+            'world_xy': xy, 'current_occupancy': float(grid['prob'][rc]),
+            'observability': float(grid['obs'][rc]), 'error_score': float(grid['err'][rc]),
+            'raw_head_occupancy': sampled(raw_head['prob'], uv),
+            'native_memory': map_probability(debug['outputs']['planner_state'], xy),
+            'current_floor_projection': depth_history[-1], 'floor_observations': len(floors),
+            'latest_floor_observation': floors[-1], 'depth_history': depth_history,
+            'column_free_space': column_free_space(run, history, xy)})
+    curve = timeline(run, raw, cells, history[0]['relative_time_s'], frame)
+    report = {'run': run.name, 'capture_frame': frame,
+        'display_provenance': 'The viewer uses the current reprojected VGGT BEV. '
+                              'Native planner WorldMap memory is separate.',
+        'reprojection_max_abs_difference': float(abs(recomputed['prob'] - grid['prob']).max()),
+        'cells': cells, 'occupancy_timeline': curve,
+        'vggt_input_views': debug['passes'][0]['views'],
+        'finding': 'The selected nearby forward-left cells have high current learned occupancy despite positive '
+                   'survey floor and free-space ray evidence. This supports a false-occupancy diagnosis at these '
+                   'cells, without declaring the entire left-hand furniture row absent.',
+        'stop_relationship': 'The eventual fatal stop was the separate measured-depth graph-attachment veto. '
+                             'These selected cells are not asserted to have caused that stop.'}
+    (output / 'region_report.json').write_text(json.dumps(clean_json(report), indent=2, allow_nan=False) + '\n')
+    with (output / 'occupancy_timeline.csv').open('w', newline='') as stream:
+        writer = csv.DictWriter(stream, fieldnames=list(curve[0]))
+        writer.writeheader()
+        writer.writerows(curve)
+    figure(run, raw, debug, cells, curve, output)
+    print(json.dumps(clean_json({'frame': frame, 'reprojection_difference': report['reprojection_max_abs_difference'],
+        'cells': [{k: c[k] for k in ('label', 'body_xy', 'current_occupancy', 'observability',
+                                   'raw_head_occupancy', 'native_memory', 'floor_observations',
+                                   'latest_floor_observation')} for c in cells]}), indent=2))
+
+
+if __name__ == '__main__':
+    main()

cases/20261026_goal1012_05/code/lite3_ROS/scripts/inspect_stretch_vggt_debug.py

@@ -0,0 +1,98 @@
+#!/usr/bin/env python3
+"""Export one saved VGGT input group, depth views and BEV stages without a GPU."""
+
+import argparse
+import json
+import math
+import sys
+from pathlib import Path
+
+import cv2
+import numpy as np
+
+ROOT = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(ROOT))
+from web_console.stretch_vggt_debug import load_debug_frame, load_debug_view, write_npz  # noqa: E402
+
+
+def sheet(images, labels, *, width=256, height=342, columns=4):
+    columns = min(columns, len(images))
+    rows = math.ceil(len(images) / columns)
+    canvas = np.full((rows * (height + 48), columns * width, 3), 24, np.uint8)
+    for index, (image, label) in enumerate(zip(images, labels)):
+        y, x = divmod(index, columns)
+        y, x = y * (height + 48), x * width
+        h, w = image.shape[:2]
+        scale = min(width / w, height / h)
+        resized = cv2.resize(image, (max(1, round(w * scale)), max(1, round(h * scale))))
+        ox, oy = x + (width - resized.shape[1]) // 2, y + 42 + (height - resized.shape[0]) // 2
+        canvas[oy:oy + resized.shape[0], ox:ox + resized.shape[1]] = resized
+        cv2.putText(canvas, label[:42], (x + 6, y + 24), cv2.FONT_HERSHEY_SIMPLEX, .43, (235, 235, 235), 1)
+    return canvas
+
+
+def probability_image(array):
+    p = np.clip(np.nan_to_num(np.asarray(array, float), nan=.5), 0, 1)
+    return np.stack((np.full_like(p, 80), 200 * (1 - p) + 35, 210 * p + 25), -1).astype(np.uint8)
+
+
+def export_frame(directory, number, output, pass_index=0):
+    data = load_debug_frame(directory, number)
+    if not data['passes']:
+        raise ValueError('No VGGT inference occurred on this frame; choose a frame with passes in index.jsonl')
+    call = data['passes'][pass_index]
+    views = call['views']
+    inputs = [load_debug_view(directory, view['asset']) for view in views]
+    images = [(np.clip(image.transpose(1, 2, 0), 0, 1) * 255).round().astype(np.uint8)[..., ::-1]
+              for image in inputs]
+    labels = [f"{view['index']} {view['role']}" +
+              (f" kf {view['reference'].get('id', view['reference'].get('keyframe_id'))}"
+               if 'reference' in view else '') for view in views]
+    output = Path(output)
+    output.mkdir(parents=True, exist_ok=True)
+    cv2.imwrite(str(output / 'input_views.jpg'), sheet(images, labels))
+    write_npz(output / 'model_inputs.npz', {'images': np.stack(inputs)})
+    prediction = call.get('prediction', {})
+    depth = prediction.get('depth')
+    if depth is not None and len(depth):
+        colored = []
+        for view in depth:
+            finite = view[np.isfinite(view) & (view > 0)]
+            upper = np.percentile(finite, 98) if len(finite) else 1.
+            scaled = np.clip(np.nan_to_num(view / max(upper, 1e-9)), 0, 1)
+            colored.append(cv2.applyColorMap((255 * scaled).astype(np.uint8), cv2.COLORMAP_TURBO))
+        cv2.imwrite(str(output / 'predicted_depth.jpg'), sheet(colored, labels[:len(colored)]))
+    out = data.get('outputs', {})
+    head = call.get('head_calls', [])
+    stages = [('raw head: camera BEV', head[0]['outputs'] if head else None),
+              ('consumed: camera BEV', out.get('consumed_bev')),
+              ('robot base BEV', out.get('body_grid'))]
+    tiles, names = [], []
+    for stage, value in stages:
+        if not value:
+            continue
+        for key, alias in (('prob', 'prob'), ('observability', 'obs'), ('uncertainty', 'err')):
+            if value.get(key, value.get(alias)) is not None:
+                layer = value.get(key, value.get(alias))
+                tiles.append(probability_image(1 - layer if key == 'observability' else layer))
+                names.append(f'{stage}: {key}')
+    if tiles:
+        cv2.imwrite(str(output / 'bev_stages.png'), sheet(tiles, names, width=300, height=300, columns=3))
+    metadata = json.loads((Path(directory) / 'frames' / f'{number:08d}' / 'frame.json').read_text())
+    (output / 'manifest.json').write_text(json.dumps(metadata, indent=2) + '\n')
+    return {'capture_frame': number, 'pass_index': pass_index, 'views': len(views), 'output': str(output.resolve())}
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument('--debug', type=Path, required=True)
+    parser.add_argument('--frame', type=int, required=True)
+    parser.add_argument('--pass-index', type=int, default=0)
+    parser.add_argument('--output', type=Path)
+    args = parser.parse_args()
+    output = args.output or args.debug / 'inspection' / f'{args.frame:08d}'
+    print(json.dumps(export_frame(args.debug, args.frame, output, args.pass_index), indent=2))
+
+
+if __name__ == '__main__':
+    main()

cases/20261026_goal1012_05/code/lite3_ROS/scripts/live_stretch_cross_nav.py

@@ -0,0 +1,992 @@
+#!/usr/bin/env python3
+"""Live native CROSS navigation with explicit browser handoff and expiring control.
+
+Starts in passive teleop mode. Only Start navigation may switch mode/arm the
+robot. Stop/failure ends this run and closes its temporary robot relay.
+"""
+# Local imports follow the repository-path bootstrap for direct execution.
+# ruff: noqa: E402
+import argparse
+import json
+import math
+import os
+import pickle
+import secrets
+import signal
+import sys
+import threading
+import time
+import uuid
+from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
+from pathlib import Path
+from types import SimpleNamespace
+from urllib.parse import parse_qs, urlsplit
+
+import cv2
+import numpy as np
+import zmq
+
+ROOT = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(ROOT))
+from web_console.cross_run import RunArtifacts, matrix
+from web_console.stretch_nav_control import (
+    DEFAULT_MAX_PLAN_AGE,
+    DEFAULT_PLAN_HOLD_SECONDS,
+    PlanWait,
+    attachment_clear,
+    competing_controllers,
+    depth_obstacles,
+    depth_veto,
+    execution_gate,
+    remaining_path,
+    stationary_head_command,
+    wrap,
+)
+from web_console.stretch_nav_footprint import command_footprint_report, depth_support
+from web_console.stretch_nav_geometry import body_to_world, world_to_body
+from web_console.stretch_nav_learned import learned_png, reproject_bev
+from web_console.stretch_nav_recovery import (
+    CornerObserver,
+    CorrectionRecovery,
+    MeasuredObstacleMemory,
+    camera_in_base,
+    clear_goal_cache,
+    rectangle_path_clear,
+    route_subgoal,
+)
+from web_console.stretch_nav_replay import ReplayService, save_bev_frame
+from web_console.stretch_nav_report import SavedRoute, clean_json, positions, save_json
+from web_console.stretch_nav_survey import HeadSurvey
+from web_console.stretch_transport import camera_transport_diagnostics
+from web_console.stretch_vggt_debug import VggtDebugRecorder, model_provenance, planner_snapshot
+
+
+def warmup_native_navigation():
+    """Compile native grid searches before opening any robot transport."""
+    try:
+        import numba
+    except ImportError as exc:
+        raise RuntimeError('Live navigation requires CROSS nav dependencies: install CROSS[nav] in this environment') from exc
+    from cross_nav.plan import _dijkstra
+    from cross_nav.policy.bev_policy import _astar, astar
+
+    search = _astar()
+    if not hasattr(search, 'signatures') or not hasattr(_dijkstra, 'signatures'):
+        raise RuntimeError('Live navigation requires CROSS nav dependencies: install CROSS[nav] in this environment')
+    started = time.perf_counter()
+    ok = np.ones((8, 8), dtype=bool)
+    cost = np.ones((8, 8), dtype=np.float64)
+    astar(ok, cost, [4, 4], [4, 6])
+    _dijkstra(ok, 4, 4, cost, False, True)
+    return {'numba_version': numba.__version__, 'warmup_s': time.perf_counter() - started,
+            'astar_signatures': [str(value) for value in search.signatures],
+            'dijkstra_signatures': [str(value) for value in _dijkstra.signatures]}
+
+
+class LiveState:
+    def __init__(self, args):
+        self.args = args
+        self.lock = threading.RLock()
+        self.done = threading.Event()
+        self.token = secrets.token_urlsafe(24)
+        self.session = uuid.uuid4().hex
+        self.packet = self.plan = self.robot = None
+        self.plan_epoch = 0
+        self.observation_requested = False
+        self.observation_reason = ''
+        self.last_control = {}
+        self.robot_received = self.heartbeat = -math.inf
+        self.phase, self.reason = 'teleop', 'Loading models; teleop remains in control'
+        self.commanded = 0.
+        self.motion_commands = 0
+        self.relay_ever_requested = False
+        self.processed = 0
+        self.conflicts = []
+        self.images = {}
+        self.last_json = {}
+        self.replay = ReplayService(args.output)
+        self.events = (args.output / 'events.jsonl').open('a', buffering=1)
+
+    def event(self, kind, **data):
+        with self.lock:
+            self.events.write(json.dumps(clean_json({'type': kind, 'time_unix': time.time(), **data})) + '\n')
+
+    def finish(self, reason):
+        with self.lock:
+            self.phase, self.reason = 'stopped', reason
+            self.done.set()
+            self.event('stop', reason=reason)
+
+    def gate(self):
+        if self.phase == 'stopped':
+            return 'session ended'
+        if self.conflicts:
+            return 'Close competing base controller: ' + ', '.join(f"{c['client']} (PID {c['pid']})" for c in self.conflicts)
+        return execution_gate(self.plan, self.robot, now=time.monotonic(),
+            robot_received=self.robot_received, heartbeat=self.heartbeat, state='preparing',
+            max_plan_age=self.args.max_plan_age)
+
+    def snapshot(self):
+        with self.lock:
+            return clean_json({'phase': self.phase, 'reason': self.reason,
+                'ready': self.phase == 'teleop' and not self.gate(), 'gate': self.gate(),
+                'goal_keyframe': self.args.goal, 'processed': self.processed,
+                'robot': self.robot, 'motion_commands': self.motion_commands,
+                'frame': self.last_json, 'control': self.last_control, 'token': self.token,
+                'capture_frame': self.packet['frame_idx'] if self.packet is not None else None,
+                'v_max': self.args.max_v, 'w_max': self.args.max_w,
+                'max_plan_age_s': self.args.max_plan_age, 'competing_controllers': self.conflicts,
+                'replay_available': self.phase == 'stopped' and (self.args.output / 'final_status.json').is_file()})
+
+
+class Handler(BaseHTTPRequestHandler):
+    def log_message(self, *_):
+        pass
+
+    def send(self, code, body, mime='application/json'):
+        body = body if isinstance(body, bytes) else json.dumps(clean_json(body), allow_nan=False).encode()
+        self.send_response(code)
+        self.send_header('Content-Type', mime)
+        self.send_header('Content-Length', str(len(body)))
+        self.send_header('Cache-Control', 'no-store')
+        self.send_header('X-Content-Type-Options', 'nosniff')
+        self.send_header('Content-Security-Policy', "default-src 'self'; script-src 'self' 'unsafe-eval'; style-src 'self' 'unsafe-inline'; img-src 'self' data: blob:; connect-src 'self'; worker-src 'self' blob:; frame-ancestors 'none'")
+        self.end_headers()
+        try:
+            self.wfile.write(body)
+        except (BrokenPipeError, ConnectionResetError):
+            pass
+
+    def do_GET(self):
+        state = self.server.state
+        path = self.path.split('?', 1)[0]
+        assets = {'/': ('cross_nav_live.html', 'text/html; charset=utf-8'),
+            '/cross_nav_live.js': ('cross_nav_live.js', 'text/javascript'),
+            '/cross_nav.css': ('cross_nav.css', 'text/css'),
+            '/vendor/plotly.min.js': ('vendor/plotly.min.js', 'text/javascript')}
+        try:
+            if path in assets:
+                file, mime = assets[path]
+                return self.send(200, (ROOT / 'web_console/static' / file).read_bytes(), mime)
+            if path == '/api/status':
+                return self.send(200, state.snapshot())
+            if path == '/api/map':
+                return self.send(200, state.map_data)
+            if path.startswith('/api/replay/'):
+                if state.phase != 'stopped':
+                    return self.send(409, {'error': 'Replay becomes available after the run ends'})
+                query = parse_qs(urlsplit(self.path).query)
+                key = query.get('run', [None])[0]
+                if path == '/api/replay/runs':
+                    return self.send(200, {'runs': state.replay.listing(), 'current_run': state.replay.current.name})
+                archive = state.replay.get(key)
+                if path == '/api/replay/manifest':
+                    return self.send(200, archive.manifest())
+                if path == '/api/replay/map':
+                    return self.send(200, json.loads((archive.root / 'map.json').read_text()))
+                if path == '/api/replay/frame':
+                    result = archive.frame(int(query.get('index', ['0'])[0]))
+                    result['token'] = state.token
+                    return self.send(200, result)
+                if path in ('/api/replay/rgb', '/api/replay/bev'):
+                    number = int(query['frame'][0])
+                    layer = query.get('layer', [None])[0] if path.endswith('/bev') else None
+                    if path.endswith('/bev') and layer is None:
+                        raise ValueError('BEV layer required')
+                    return self.send(200, archive.image(number, layer), 'image/png' if layer else 'image/jpeg')
+                return self.send(404, {'error': 'Unknown replay action'})
+            with state.lock:
+                if path == '/api/rgb.jpg' and state.packet is not None:
+                    data = np.asarray(state.packet['rgb_jpg'], np.uint8).tobytes()
+                    return self.send(200, data, 'image/jpeg')
+                if path.startswith('/api/bev/') and path.split('/')[-1] in state.images:
+                    return self.send(200, state.images[path.split('/')[-1]], 'image/png')
+            return self.send(404, {'error': 'Data not available yet'})
+        except (OSError, ValueError, KeyError, IndexError) as exc:
+            self.send(404, {'error': str(exc)})
+
+    def do_POST(self):
+        state = self.server.state
+        expected = f'http://127.0.0.1:{self.server.server_port}'
+        if self.headers.get('X-Session') != state.token or self.headers.get('Origin') not in (None, expected):
+            return self.send(403, {'error': 'Invalid viewer session or origin'})
+        with state.lock:
+            if self.path == '/api/heartbeat':
+                state.heartbeat = time.monotonic()
+                return self.send(200, {'ok': True})
+            if self.path == '/api/start':
+                if state.phase != 'teleop':
+                    return self.send(409, {'error': 'A run can be started once; Stop ends the session'})
+                reason = state.gate()
+                if reason:
+                    return self.send(409, {'error': reason})
+                state.phase, state.reason = 'preparing', 'Browser requested navigation handoff'
+                state.event('start_requested', goal=state.args.goal)
+                return self.send(202, {'phase': state.phase})
+            if self.path == '/api/stop':
+                state.finish('Stopped by operator; temporary relay will close')
+                return self.send(200, {'phase': 'stopped'})
+        return self.send(404, {'error': 'Unknown action'})
+
+
+def capture_loop(state, relay):
+    context = zmq.Context()
+    sub = context.socket(zmq.SUB)
+    sub.setsockopt(zmq.SUBSCRIBE, b'')
+    sub.setsockopt(zmq.CONFLATE, 1)
+    sub.setsockopt(zmq.LINGER, 0)
+    sub.connect(f'tcp://{state.args.robot_ip}:4511')
+    root = state.args.output / 'capture'
+    for name in ('rgb', 'depth'):
+        (root / name).mkdir(parents=True, exist_ok=True)
+    first, last, count, previous_received = None, -1, 0, None
+    try:
+        with (root / 'observations.jsonl').open('a', buffering=1) as log, \
+                (root / 'transport.jsonl').open('a', buffering=1) as timing_log:
+            while not state.done.is_set():
+                if relay.process.poll() is not None:
+                    raise RuntimeError('Owned robot relay exited')
+                if not sub.poll(200):
+                    continue
+                recv_started = time.monotonic()
+                payload = sub.recv()
+                recv_finished = time.monotonic()
+                packet = pickle.loads(payload)
+                received = time.monotonic()
+                with state.lock:
+                    timing = camera_transport_diagnostics(packet, state.robot, state.robot_received, received)
+                timing.update(wire_bytes=len(payload), recv_call_s=recv_finished - recv_started,
+                    deserialize_s=received - recv_finished,
+                    receive_gap_s=received - previous_received if previous_received is not None else None)
+                previous_received = received
+                if packet['world_frame'] != 'odom':
+                    raise ValueError('Continuous odom frame required')
+                if packet['frame_id'] <= last:
+                    continue
+                last = packet['frame_id']
+                first = packet['sensor_stamp'] if first is None else first
+                row = {k: v for k, v in packet.items() if k not in ('rgb_jpg', 'depth_png')}
+                row['camera_in_base'] = camera_in_base(packet['camera_pose'], packet['base_pose_matrix'])
+                for stamp_name in ('camera_tf_stamp', 'base_tf_stamp'):
+                    if stamp_name in packet and abs(packet[stamp_name] - packet['sensor_stamp']) > .025:
+                        raise ValueError('Camera/base TF is not synchronized to its image')
+                row.update(frame_idx=count, relative_time_s=packet['sensor_stamp'] - first,
+                    received_monotonic=received, received_unix_s=time.time(), transport=timing)
+                write_started = time.monotonic()
+                stem = f'{count:08d}'
+                (root / 'rgb' / f'{stem}.jpg').write_bytes(np.asarray(packet['rgb_jpg'], np.uint8).tobytes())
+                (root / 'depth' / f'{stem}.png').write_bytes(np.asarray(packet['depth_png'], np.uint8).tobytes())
+                log.write(json.dumps(clean_json(row), allow_nan=False) + '\n')
+                save_json(root / 'latest.json', row)
+                with state.lock:
+                    state.packet = {**packet, **row}
+                    phase, commands = state.phase, state.motion_commands
+                count += 1
+                save_json(root / 'capture.json', {'status': 'recording', 'frames': count,
+                    'phase': phase, 'nonzero_motion_commands': commands, 'world_frame': 'odom'})
+                timing_log.write(json.dumps(clean_json({'frame_idx': count - 1,
+                    'frame_id': packet['frame_id'], 'received_unix_s': row['received_unix_s'],
+                    **timing, 'record_and_publish_s': time.monotonic() - write_started,
+                    'capture_metrics': packet.get('capture_metrics')}), allow_nan=False) + '\n')
+    except BaseException as exc:
+        state.finish('Capture error: ' + str(exc))
+        state.event('capture_error', error=str(exc))
+    finally:
+        save_json(root / 'capture.json', {'status': 'completed', 'frames': count,
+            'nonzero_motion_commands': state.motion_commands, 'world_frame': 'odom'})
+        sub.close()
+        context.term()
+
+
+def control_loop(state):
+    """Independent 20 Hz owner of the robot-local lease. Never waits for inference."""
+    from cross_nav.policy.robot import pure_pursuit
+
+    context = zmq.Context()
+    status = context.socket(zmq.SUB)
+    status.setsockopt(zmq.SUBSCRIBE, b'')
+    status.setsockopt(zmq.CONFLATE, 1)
+    status.setsockopt(zmq.LINGER, 0)
+    status.connect(f'tcp://{state.args.robot_ip}:4513')
+    commands = context.socket(zmq.PUSH)
+    commands.setsockopt(zmq.SNDHWM, 1)
+    commands.setsockopt(zmq.IMMEDIATE, 1)
+    commands.setsockopt(zmq.LINGER, 0)
+    commands.connect(f'tcp://{state.args.robot_ip}:4512')
+    mode = context.socket(zmq.PUB)
+    mode.setsockopt(zmq.LINGER, 0)
+    mode.connect(f'tcp://{state.args.robot_ip}:4402')
+    sequence, previous, last_tick, next_mode, prepare_started = 0, None, time.monotonic(), 0., None
+    plan_wait = PlanWait(timeout=state.args.plan_hold_seconds)
+    next_scan = 0.
+    scan_started, scan_angle, scan_previous = None, 0., None
+    scan_origin = None
+    control_epoch = 0
+    veto_since, progress_origin, progress_at = None, None, None
+
+    def send(command):
+        try:
+            commands.send_json(command, flags=zmq.NOBLOCK)
+        except zmq.Again:
+            return False
+        return True
+
+    try:
+        with (state.args.output / 'commands.jsonl').open('a', buffering=1) as log, \
+                (state.args.output / 'robot_status.jsonl').open('a', buffering=1) as robot_log:
+            while not state.done.is_set():
+                now = time.monotonic()
+                if now >= next_scan:
+                    with state.lock:
+                        state.conflicts = competing_controllers()
+                    next_scan = now + 1.
+                if status.poll(0):
+                    robot = status.recv_pyobj()
+                    robot_log.write(json.dumps(clean_json({'received_unix': time.time(),
+                        'received_monotonic': time.monotonic(), **robot})) + '\n')
+                    with state.lock:
+                        state.robot, state.robot_received = robot, time.monotonic()
+                with state.lock:
+                    robot, robot_at, plan, phase, heartbeat = (state.robot, state.robot_received,
+                        state.plan, state.phase, state.heartbeat)
+                    epoch = state.plan_epoch
+                if epoch != control_epoch:
+                    scan_started, scan_angle, scan_origin, scan_previous = None, 0., None, None
+                    veto_since, progress_origin, progress_at = None, None, None
+                    control_epoch = epoch
+                # Process scanning, deserialization or waiting for the GIL can
+                # take time. Gate this snapshot using the current clock.
+                now = time.monotonic()
+                v, w = 0., 0.
+                head_target = None
+                head_feedback = None
+                footprint_report = None
+                requested_velocity = [0., 0.]
+                depth_blocked = learned_blocked = False
+                queued = None
+                reason = 'Teleop owns control; no arm/mode/velocity requests'
+                if phase in ('preparing', 'active'):
+                    if state.conflicts:
+                        state.finish('Competing base controller detected; navigation ended')
+                        break
+                    gate = execution_gate(plan, robot, now=now, robot_received=robot_at,
+                        heartbeat=heartbeat, state=phase, max_plan_age=state.args.max_plan_age)
+                    if gate == 'goal reached':
+                        state.finish('Goal keyframe reached (camera XY within 0.4 m; heading not enforced)')
+                        break
+                    recovering = gate == 'map correction recovery' and now < plan.get('recovery_deadline', 0.)
+                    holding = phase == 'active' and robot is not None and (recovering or plan_wait.holds(gate, now))
+                    if gate and not holding:
+                        state.finish(gate + '; navigation ended')
+                        break
+                    if robot.get('armed') and robot.get('session') != state.session:
+                        raise RuntimeError('Relay is owned by another session')
+                    if phase == 'active' and not robot.get('armed'):
+                        raise RuntimeError('Navigation lease lost; no automatic re-arm')
+                    if phase == 'active' and not gate:
+                        head_feedback, _ = stationary_head_command(plan, robot, now=now, robot_received=robot_at)
+                    if head_feedback is not None:
+                        # The view target/anchor/deadline is fixed by the planner.
+                        # Keep its head action alive using fresh source feedback,
+                        # regardless of VGGT cadence, with no base movement.
+                        sequence += 1
+                        head_target = head_feedback['head_target']
+                        if scan_started is None:
+                            scan_started, scan_origin = now, np.asarray(robot['base_pose'], float)[:2].copy()
+                        if now - scan_started > 260.:
+                            raise RuntimeError('Observation recovery exhausted without forward progress')
+                        with state.lock:
+                            if epoch != state.plan_epoch or state.done.is_set():
+                                head_feedback = None
+                                head_target = None
+                            command = {'type': 'velocity', 'session': state.session, 'seq': sequence,
+                                'frame_id': robot['frame_id'], 'ttl': .3, 'v': 0., 'w': 0.}
+                            if head_feedback is not None:
+                                command.update(head_feedback)
+                            queued = send(command)
+                        reason = ('Head survey: ' + (plan.get('survey_label') or 'observing')
+                            if plan.get('stationary_survey') else
+                            'Corner observation: ' + plan.get('corner_phase', 'look'))
+                        progress_at = now
+                        previous = np.asarray(robot['base_pose'], float).copy()
+                    elif holding:
+                        # Renew only zero velocity using fresh camera evidence. An old
+                        # path never receives extra execution time during this hold.
+                        sequence += 1
+                        queued = send({'type': 'velocity', 'session': state.session, 'seq': sequence,
+                            'frame_id': robot['frame_id'], 'ttl': .3, 'v': 0., 'w': 0.})
+                        reason = 'Holding at zero: ' + gate
+                        previous = np.asarray(robot['base_pose'], float).copy()
+                    elif phase == 'preparing':
+                        prepare_started = prepare_started or now
+                        if now - prepare_started > 15.:
+                            raise RuntimeError('Navigation mode/lease preparation timed out')
+                        if robot.get('control_mode') != 'navigation':
+                            if now >= next_mode:
+                                mode.send_pyobj({'control_mode': 'navigation', 'step': int(robot['bridge_step']) + 1})
+                                next_mode = now + 1.
+                            reason = 'Switching base to navigation mode; joints unchanged'
+                        elif not robot.get('healthy'):
+                            reason = 'Waiting for healthy robot TF and camera'
+                        elif not robot.get('armed'):
+                            state.relay_ever_requested = True
+                            send({'type': 'arm', 'session': state.session})
+                            reason = 'Arming expiring robot-local velocity lease'
+                        else:
+                            with state.lock:
+                                state.phase = 'active'
+                            reason = 'Navigation active'
+                    else:
+                        pose = np.asarray(robot['base_pose'], float)
+                        if previous is not None:
+                            dt = now - last_tick
+                            if np.linalg.norm(pose[:2] - previous[:2]) > .2 + .2 * dt or abs(wrap(pose[2] - previous[2])) > .3 + .4 * dt:
+                                raise RuntimeError('Odom discontinuity')
+                        if not robot.get('armed'):
+                            raise RuntimeError('Navigation lease lost; no automatic re-arm')
+                        path = remaining_path(plan['path_odom'], pose)
+                        head_target = plan.get('head_target')
+                        if plan.get('observation_hold'):
+                            v, w = 0., float(np.clip(plan.get('scan_w', 0.),
+                                -min(.15, state.args.max_w), min(.15, state.args.max_w)))
+                            reason = ('Head survey: ' + (plan.get('survey_label') or 'observing')
+                                if plan.get('stationary_survey') else 'Corner observation: ' + plan.get('corner_phase', 'look'))
+                        elif plan.get('planner_status') == 2:
+                            _, w = pure_pursuit(path, v_max=state.args.max_v, w_max=min(.15, state.args.max_w))
+                            v, reason = 0., 'Guarded native no-route scan'
+                        else:
+                            v, w = pure_pursuit(path, v_max=state.args.max_v * plan.get('speed_scale', 1.),
+                                w_max=state.args.max_w, lookahead=plan.get('lookahead', .4))
+                            reason = 'Following CROSS local plan'
+                        v *= min(1., max(0., plan['goal_distance'] - .4) / .6)
+                        if progress_origin is None or np.linalg.norm(pose[:2] - progress_origin) > .05:
+                            progress_origin, progress_at = pose[:2].copy(), now
+                        if plan.get('observation_hold'):
+                            progress_at = now
+                        # Scan budgets follow physical odometry and do not reset
+                        # merely because the planner briefly changes status.
+                        scanning = plan.get('observation_hold') or plan.get('planner_status') == 2
+                        if scan_origin is not None and np.linalg.norm(pose[:2] - scan_origin) > .2:
+                            scan_started, scan_angle, scan_origin = None, 0., None
+                        if scanning:
+                            if scan_started is None:
+                                scan_started, scan_origin = now, pose[:2].copy()
+                            if scan_previous is not None:
+                                scan_angle += abs(wrap(pose[2] - scan_previous))
+                            if now - scan_started > 260. or scan_angle > np.deg2rad(100):
+                                raise RuntimeError('Observation recovery exhausted without forward progress')
+                        scan_previous = pose[2]
+                        requested_velocity = [float(v), float(w)]
+                        depth_blocked = depth_veto(plan['depth_obstacles'], pose, v, w)
+                        if plan.get('footprint_grid') is not None:
+                            footprint_report = command_footprint_report(
+                                plan['footprint_grid'], plan['planning_base'], pose, v, w)
+                            learned_blocked = not footprint_report['clear']
+                        if (depth_blocked or learned_blocked) and abs(v) + abs(w) > 1e-8:
+                            v, w = 0., 0.
+                            reason = ('Measured-depth veto' if depth_blocked else 'Learned-footprint veto') + ': obstacle in command footprint'
+                            veto_since = now if veto_since is None else veto_since
+                        else:
+                            veto_since = None
+                        if not plan.get('observation_hold') and (
+                            (veto_since is not None and now - veto_since > 1.) or now - progress_at > 10.
+                        ):
+                            with state.lock:
+                                state.observation_requested = True
+                                state.observation_reason = ('measured depth' if depth_blocked else
+                                    'learned footprint' if learned_blocked else 'no odometry progress')
+                        sequence += 1
+                        with state.lock:
+                            # A correction can arrive after this thread took its
+                            # snapshot. Never send its now-invalid path command.
+                            if epoch != state.plan_epoch or state.done.is_set():
+                                v, w, head_target = 0., 0., None
+                                reason = 'Holding at zero: route generation changed'
+                            command = {'type': 'velocity', 'session': state.session, 'seq': sequence,
+                                'frame_id': plan['frame_id'], 'ttl': .3, 'v': float(v), 'w': float(w)}
+                            if head_target is not None:
+                                command['head_target'] = head_target
+                            queued = send(command)
+                        if queued:
+                            with state.lock:
+                                state.motion_commands += int(abs(v) + abs(w) > 1e-8)
+                                # Relay-published velocity, rather than a queued
+                                # PC request, drives the native bump expectation.
+                                state.commanded += max(0., robot.get('v', 0.)) * min(.1, now - last_tick)
+                        previous = pose.copy()
+                    last_tick = now
+                with state.lock:
+                    if not state.done.is_set():
+                        state.reason = reason
+                control = {'phase': phase, 'reason': reason, 'v': float(v), 'w': float(w),
+                    'time_unix': time.time(), 'sequence': sequence,
+                    'plan_frame_id': plan.get('frame_id') if plan else None,
+                    'plan_capture_frame': plan.get('capture_frame') if plan else None, 'command_queued': queued,
+                    'plan_input_age_s': now - plan['input_received'] if plan else None,
+                    'plan_build_age_s': now - plan.get('published', now) if plan else None,
+                    'robot_state_age_s': now - robot_at, 'max_plan_age_s': state.args.max_plan_age,
+                    'holding_for_plan': phase == 'active' and reason.startswith('Holding'),
+                    'plan_epoch': epoch, 'relay_sequence': robot.get('accepted_sequence') if robot else None,
+                    'head_target': head_target,
+                    'head_control_source': 'fresh_robot_feedback' if head_feedback is not None else 'plan',
+                    'head_evidence_frame_id': head_feedback['frame_id'] if head_feedback is not None else None,
+                    'requested_velocity': requested_velocity, 'requested_pose': robot.get('base_pose') if robot else None,
+                    'depth_blocked': depth_blocked, 'learned_blocked': learned_blocked,
+                    'footprint': footprint_report,
+                    'relay_reason': robot.get('reason') if robot else None,
+                    'relay_velocity': [robot.get('v'), robot.get('w')] if robot else None,
+                    'nonzero_motion_commands': state.motion_commands}
+                log.write(json.dumps(clean_json(control), allow_nan=False) + '\n')
+                with state.lock:
+                    state.last_control = clean_json(control)
+                save_json(state.args.output / 'control.json', control)
+                state.done.wait(.05)
+    except BaseException as exc:
+        state.finish('Control error: ' + str(exc))
+        state.event('control_error', error=str(exc))
+    finally:
+        if state.relay_ever_requested:
+            for _ in range(3):
+                send({'type': 'stop', 'session': state.session})
+                time.sleep(.03)
+        final_control = {'phase': state.phase, 'reason': state.reason, 'v': 0., 'w': 0.,
+            'time_unix': time.time(), 'sequence': sequence, 'stop_requested': state.relay_ever_requested,
+            'nonzero_motion_commands': state.motion_commands}
+        save_json(state.args.output / 'control.json', final_control)
+        with (state.args.output / 'commands.jsonl').open('a') as log:
+            log.write(json.dumps(final_control) + '\n')
+        for socket in (status, commands, mode):
+            socket.close()
+        context.term()
+
+
+def run_mapping(state):
+    from cross.core.config import load_config
+    from cross.core.types import Camera
+    from cross.pipeline import add_session_args, finish_session_args, mode_config_files, session_factory
+    from cross_nav.policy.bev_policy import BEVPlannerPolicy, Episode
+
+    args = state.args
+    while state.packet is None and not state.done.wait(.1):
+        pass
+    if state.done.is_set():
+        return
+    with state.lock:
+        initial = state.packet
+    rgb = cv2.imdecode(np.asarray(initial['rgb_jpg'], np.uint8), cv2.IMREAD_COLOR)
+    camera_config = Camera(K=np.asarray(initial['camera_K']), frame_width=rgb.shape[1], frame_height=rgb.shape[0])
+    parser = argparse.ArgumentParser()
+    add_session_args(parser)
+    options = parser.parse_args(['--mode', 'mono', '--odometry', 'external', '--mono-estimator', 'ff'])
+    finish_session_args(options)
+    heads = args.cross_root / 'models/VGGT-Omega-CROSS/nav'
+    occupancy, visibility = heads / 'cross_nav_occupancy.pt', heads / 'cross_nav_observability.pt'
+    overrides = ['pose_est.ff.checkpoint=finetuned', 'pose_est.obs_max_interval_steps=1',
+        f'pose_est.ff.nav_bev_head={occupancy}', f'pose_est.ff.nav_bev_visibility={visibility}',
+        f'pose_est.ff.nav_bev_visibility_gravity={occupancy}', 'mapping.loop_closure.async_pgo=False']
+    config = load_config(*mode_config_files('mono', 'external', 'ff'), sets=overrides)
+    artifacts = RunArtifacts(args.output / 'mapping', {'mode': 'mono', 'odometry': 'external',
+        'dataset': str(args.output / 'capture'), 'loaded_map': str(args.map_run / 'map.pkl'),
+        'goal_keyframe': args.goal, 'config_overrides': overrides, 'max_v': args.max_v, 'max_w': args.max_w,
+        'max_plan_age_s': args.max_plan_age, 'plan_hold_seconds': args.plan_hold_seconds,
+        'checkpoint_provenance': json.loads((heads / 'provenance.json').read_text())})
+    session = debug_archive = None
+    mapping_error = None
+    try:
+        session = artifacts.wrap_factory(session_factory(options, camera_config, config))()
+        session.load_map(args.map_run / 'map.pkl')
+        pe = session.mapper.pose_est
+        if args.vggt_debug:
+            debug_archive = VggtDebugRecorder(args.vggt_debug_dir or args.output / 'vggt_debug', {
+                'origin': 'live_recorded', 'cross_root': str(args.cross_root),
+                'map_run': str(args.map_run), 'config_overrides': overrides,
+                'resolved_config': json.loads((args.output / 'mapping/resolved_config.json').read_text()),
+                'camera_catalog': clean_json(session.mapper.cameras), 'session_camera_id': session.mapper.cam_id,
+                'checkpoint_provenance': artifacts.metadata['checkpoint_provenance'],
+                **model_provenance(args.cross_root),
+            }, on_error=lambda exc: state.finish('VGGT debug archive error: ' + str(exc)))
+            debug_archive.attach(pe)
+        route_planner = SavedRoute(args.map_run / 'map.pkl')
+        bev_config = json.loads((args.cross_root / 'cross_nav/configs/policy/bev_planner_vfin2.json').read_text())
+        bev_config.update(backbone=str(args.cross_root / 'models/VGGT-Omega-CROSS/vggt_omega_cross_1b_512.pt'),
+            occupancy=str(occupancy), visibility=str(visibility), visibility_gravity=str(occupancy))
+        # Match the 46 cm execution footprint. Never shrink inflation to invent
+        # clearance in a narrow passage; also check the oriented rectangle.
+        bev_config['planner']['radius'] = .23
+        bev_config['map'].update(radius=.23, retry_radii=[])
+        save_json(args.output / 'resolved_bev_config.json', bev_config)
+        if debug_archive:
+            save_json(debug_archive.root / 'planner_config.json', bev_config)
+        policy = BEVPlannerPolicy(bev_config, predictor=pe.backend.nav)
+        episode = Episode()
+        recovery, corners = CorrectionRecovery(), CornerObserver()
+        survey = HeadSurvey()
+        obstacle_memory = MeasuredObstacleMemory()
+        evidence_directory = args.output / 'footprint_evidence'
+        evidence_directory.mkdir()
+        last_evidence = -math.inf
+        neutral_mount, previous_goal = None, None
+        prior, last, streak, previous_alignment = None, -1, 0, None
+        trajectory, previous_expected = [], 0.
+        with (args.output / 'observations.jsonl').open('a', buffering=1) as log:
+            while not state.done.is_set():
+                with state.lock:
+                    raw = state.packet
+                    phase, cumulative = state.phase, state.commanded
+                if raw is None or raw['frame_idx'] <= last:
+                    state.done.wait(.03)
+                    continue
+                index, camera, base = raw['frame_idx'], np.asarray(raw['camera_pose']), np.asarray(raw['base_pose_matrix'])
+                mount = camera_in_base(camera, base)
+                if neutral_mount is None:
+                    neutral_mount = mount.copy()
+                rgb = cv2.cvtColor(cv2.imdecode(np.asarray(raw['rgb_jpg'], np.uint8), cv2.IMREAD_COLOR), cv2.COLOR_BGR2RGB)
+                pe.set_gravity(camera[:3, :3].T @ [0., 0., 1.])
+                passes = pe._n_passes
+                started = time.monotonic()
+                if debug_archive:
+                    debug_archive.begin_frame(raw)
+                session.process({'rgb': rgb, 'frame_idx': index, 'timestamp': raw['sensor_stamp'],
+                    'delta_pose': None if prior is None else np.linalg.inv(prior) @ camera})
+                prior, last = camera, index
+                c0, best, weights = session.belief(matrix)
+                localized = bool(session.localized())
+                streak = streak + 1 if localized else 0
+                diagnostics = session.mapper.last_step_diagnostics
+                audit = [{'id': int(a['keyframe_id']), 'score': float(a['retrieval_score']),
+                    'verified': bool(a['verified']), 'loaded': bool(a['loaded'])}
+                    for a in diagnostics.get('retrieval_audit', [])]
+                fresh = pe._n_passes != passes and pe.last_bev is not None
+                bev = pe.last_bev if fresh else None
+                grid = planner_debug = None
+                record = {'frame_idx': index, 'time_s': raw['relative_time_s'], 'localized': localized,
+                    'localized_streak': streak, 'weights': weights, 'retrieval': audit,
+                    'camera_display': None, 'global_route': [], 'local_path_display': [],
+                    'goal_keyframe': args.goal, 'route_ids': [], 'goal_distance': None,
+                    'planner_name': 'Waiting for committed map pose', 'n_views': 0, 'trajectory': trajectory[-1500:]}
+                plan = None if localized else {'input_received': raw['received_monotonic'],
+                    'localized': False, 'localized_streak': 0, 'goal_distance': 0.}
+                if bev is not None:
+                    grid = reproject_bev(bev['prob'], bev['observability'], bev['uncertainty'],
+                        bev['R_bev_from_cam'], camera, base, bev['res'])
+                    images = {f'{layer}.png': learned_png(grid['prob'], grid['obs'], grid['err'], layer)
+                        for layer in ('occupancy', 'visibility', 'uncertainty')}
+                    save_bev_frame(args.output, int(index), images)
+                    with state.lock:
+                        state.images = images
+                    record.update(n_views=bev['n_views'], scale_source=bev['scale_source'],
+                        bev_size=bev['size'], bev_res=bev['res'], gravity_head_deg=bev['gravity_head_deg'])
+                if localized and bev is not None:
+                    alignment = c0 @ np.linalg.inv(camera)
+                    with state.lock:
+                        active = state.phase == 'active'
+                    was_pending = recovery.pending
+                    correction = recovery.update(previous_alignment if active else None, alignment, base, time.monotonic())
+                    if correction['started']:
+                        survey.cancel()
+                        route_planner.reset_attachment()
+                        clear_goal_cache(episode)
+                        corners.reset()
+                        previous_goal = None
+                        with state.lock:
+                            state.plan_epoch += 1
+                            state.plan = {'input_received': raw['received_monotonic'], 'localized': True,
+                                'localized_streak': streak, 'goal_distance': 0., 'recovery_pending': True,
+                                'recovery_deadline': correction['deadline']}
+                        state.event('map_correction_recovery_started', frame_idx=index,
+                            previous_alignment=previous_alignment, alignment=alignment,
+                            base_pose_matrix=base, weights=weights, **correction)
+                    if was_pending and not recovery.pending:
+                        corners.restore_neutral(base, time.monotonic())
+                        state.event('map_correction_recovery_complete', frame_idx=index, **correction)
+                    record.update(map_correction_at_base_m=correction['distance_m'],
+                        map_correction_angle_deg=correction['rotation_deg'], correction_recovery=correction,
+                        camera_in_base=mount, neutral_camera_in_base=neutral_mount)
+                    previous_alignment = alignment
+                    inverse_alignment = np.linalg.inv(alignment)
+                    depth = cv2.imdecode(np.asarray(raw['depth_png'], np.uint8), cv2.IMREAD_UNCHANGED).astype(float) / 1000
+                    obstacles = depth_obstacles(depth, raw['camera_K'], camera)
+                    obstacle_memory.observing(survey.active, raw['received_monotonic'])
+                    obstacles = obstacle_memory.update(obstacles, raw['received_monotonic'], base[:2, 3])
+                    reference_camera = base @ neutral_mount
+                    def can_attach(_keyframe_id, point_map):
+                        point_odom = positions(inverse_alignment, [point_map])[0]
+                        target_base_xy = base[:2, 3] + point_odom[:2] - reference_camera[:2, 3]
+                        return attachment_clear(obstacles, raw['base_pose'], target_base_xy)
+                    # Head panning must not move the virtual camera used for
+                    # graph attachment or change camera->base goal conversion.
+                    route = route_planner.route(alignment @ reference_camera, args.goal, can_attach=can_attach)
+                    ids = route['ids']
+                    route_map = np.asarray(route['positions']).reshape(-1, 3)
+                    goal_map = route_planner.matrices[args.goal][:3, 3]
+                    goal_odom = positions(inverse_alignment, [goal_map])[0]
+                    goal_distance = float(np.linalg.norm(goal_odom[:2] - reference_camera[:2, 3]))
+                    route_odom = positions(inverse_alignment, route_map)
+                    offset = reference_camera[:2, 3] - base[:2, 3]
+                    hint = route_subgoal(route_odom[:, :2] - offset, base, goal_odom[:2] - offset)
+                    with state.lock:
+                        joint = state.robot.get('joint_positions', []) if state.robot else []
+                    image_head = raw.get('head_joints')
+                    if image_head is not None and len(joint) >= 11:
+                        joint = np.asarray(joint, float).copy()
+                        joint[9:11] = image_head
+                    elif active and (hint['corner'] is not None or corners.phase != 'cruise' or survey.active):
+                        raise ValueError('Timestamped head joint feedback missing; refusing camera scan')
+
+                    def start_survey(reason):
+                        if image_head is None:
+                            raise ValueError('Timestamped head joint feedback missing; refusing camera survey')
+                        if not survey.start(base, mount, neutral_mount, joint, time.monotonic(), reason):
+                            return False
+                        clear_goal_cache(episode)
+                        corners.reset()
+                        with state.lock:
+                            state.plan_epoch += 1
+                            if state.plan is not None:
+                                state.plan = {**state.plan, 'observation_hold': True, 'stationary_survey': True,
+                                    'scan_w': 0., 'head_target': None, 'survey_label': survey.snapshot()['label']}
+                        state.event('head_survey_started', frame_idx=index, reason=reason,
+                            pass_number=survey.passes, targets=survey.targets)
+                        return True
+
+                    observation = {'phase': 'cruise', 'target': hint['target'], 'hold': False,
+                                   'head_target': None, 'scan_w': 0., 'speed_scale': 1., 'lookahead': .4}
+                    if active and not recovery.pending:
+                        with state.lock:
+                            request_observation = state.observation_requested
+                            request_reason = state.observation_reason
+                            state.observation_requested = False
+                        if request_observation:
+                            start_survey(request_reason or 'stuck')
+                        if survey.active:
+                            count = len(survey.views)
+                            was_braking = survey.braking
+                            observation = survey.update(base, mount, joint, index, time.monotonic())
+                            if was_braking and not survey.braking:
+                                state.event('head_survey_base_stopped', frame_idx=index,
+                                    pass_number=survey.passes, base_pose_matrix=base)
+                            if len(survey.views) > count:
+                                state.event('head_survey_view', pass_number=survey.passes, **survey.views[-1])
+                            if observation.get('survey_complete'):
+                                clear_goal_cache(episode)
+                                corners.reset()
+                                state.event('head_survey_complete', frame_idx=index, pass_number=survey.passes)
+                        else:
+                            observation = corners.update(hint, base, mount, neutral_mount, joint,
+                                {**grid, 'res': bev['res']}, time.monotonic())
+                    target_base = observation['target']
+                    if previous_goal is not None and np.linalg.norm(target_base - previous_goal) > .6:
+                        clear_goal_cache(episode)
+                    previous_goal = np.asarray(target_base).copy()
+                    goal_body = world_to_body(target_base, base)
+                    cat = {'prob': grid['prob'][None], 'obs': grid['obs'][None], 'err': grid['err'][None],
+                        'log_scale': np.array([bev['log_scale']]), 'odometry': np.array([bev['scale_source'] == 'anchors']),
+                        'up_head_deg': np.array([bev['gravity_head_deg']]), 'n_views': np.array([bev['n_views']])}
+                    paths, debug = policy.plan_maps(cat, goal_body[None], [episode],
+                        [{'ep': state.session, 'odom': raw['base_pose'], 'expect': max(0., cumulative - previous_expected)}], [True])
+                    planner_debug = debug[0]
+                    previous_expected = cumulative
+                    path = paths[0]
+                    code = int(debug[0]['status'])
+                    native_path, native_code = path.copy(), code
+                    rectangle_clear = rectangle_path_clear(path, {**grid, 'res': bev['res']})
+                    if not rectangle_clear and not observation['hold']:
+                        # Request observation rather than executing a route that
+                        # clears a centre point but clips a rectangular corner.
+                        code = 2
+                        side = 1. if goal_body[1] >= 0 else -1.
+                        path = np.tile([0., side * .3], (len(path), 1))
+                    if active and not recovery.pending and code == 2 and not observation['hold']:
+                        if start_survey('native no route' if rectangle_clear else 'learned path footprint'):
+                            observation = survey.update(base, mount, joint, index, time.monotonic())
+                    if observation['hold']:
+                        path = np.zeros_like(path)
+                    with state.lock:
+                        control = state.last_control
+                    control_report = control.get('footprint')
+                    footprint_diagnostics = depth_support(control_report, obstacles) if control_report else None
+                    if footprint_diagnostics is not None:
+                        footprint_diagnostics['command_capture_frame'] = control.get('plan_capture_frame')
+                        for cell in footprint_diagnostics['cells'] + footprint_diagnostics.get('self_cells', []):
+                            cell['display_body_xy'] = world_to_body(cell['world_xy'], base).tolist()
+                    evidence = None
+                    if active and (survey.active or control.get('learned_blocked') or control.get('depth_blocked')) and (
+                        time.monotonic() - last_evidence >= 1.
+                    ):
+                        last_evidence = time.monotonic()
+                        evidence = f'footprint_evidence/{index:08d}.npz'
+                        np.savez_compressed(args.output / evidence, **grid, res=bev['res'],
+                            base=base, camera=camera, measured_obstacles_odom=obstacles,
+                            native_path_body=native_path, native_planner_status=native_code)
+                    path_odom = body_to_world(path, base)
+                    path_odom_with_origin = np.vstack([base[:2, 3], path_odom])
+                    plan = {'input_received': raw['received_monotonic'], 'localized': True,
+                        'localized_streak': streak, 'frame_id': raw['frame_id'],
+                        'capture_frame': index,
+                        'route_ids': ids, 'path_odom': path_odom_with_origin, 'planner_status': code,
+                        'published': time.monotonic(),
+                        'goal_distance': goal_distance, 'arrived': goal_distance <= .4,
+                        'depth_obstacles': obstacles, 'recovery_pending': recovery.pending,
+                        'footprint_grid': {**grid, 'res': bev['res']}, 'planning_base': base,
+                        'recovery_deadline': correction['deadline'], 'epoch': state.plan_epoch,
+                        'observation_hold': observation['hold'], 'head_target': observation['head_target'],
+                        'head_anchor': observation.get('head_anchor'),
+                        'head_deadline': observation.get('head_deadline'),
+                        'stationary_survey': observation['phase'].startswith('survey'),
+                        'survey_label': observation.get('survey_label'),
+                        'corner_phase': observation['phase'], 'scan_w': observation['scan_w'],
+                        'scan_authorized': code == 2, 'speed_scale': observation['speed_scale'],
+                        'lookahead': observation['lookahead']}
+                    camera_display = positions(state.display, [c0[:3, 3]])[0]
+                    trajectory.append(camera_display.tolist())
+                    names = ['goal route', 'local waypoint', 'no route / scan', 'near goal',
+                        'remembered route', 'relaxed route', 'episode-map route']
+                    record.update(camera_display=camera_display, global_route=positions(state.display, route_map),
+                        local_path_display=positions(state.display @ alignment, np.column_stack([path_odom, np.zeros(len(path_odom))])),
+                        local_path_body=path, goal_body=goal_body, goal_distance=goal_distance,
+                        route_ids=ids, route_cost_m=route.get('cost_m'), route_attachment=route.get('attachment'),
+                        corner_observation=observation, rectangle_clear=rectangle_clear,
+                        head_survey=survey.snapshot(), footprint_diagnostics=footprint_diagnostics,
+                        footprint_evidence=evidence, native_local_path_body=native_path,
+                        native_planner_status=native_code,
+                        planner_name=names[code], blind_zone=bool(debug[0]['blind_zone']),
+                        trajectory=trajectory[-1500:], native_map_camera=c0)
+                record['compute_s'] = time.monotonic() - started
+                record['input_age_at_publish_s'] = time.monotonic() - raw['received_monotonic']
+                if debug_archive:
+                    debug_archive.finish_frame(
+                        observation={key: value for key, value in record.items() if key != 'trajectory'},
+                        consumed_bev=bev, body_grid=grid, planner_debug=planner_debug,
+                        planner_state=planner_snapshot(episode) if planner_debug is not None else None)
+                    record['vggt_debug_frame'] = f'frames/{index:08d}/frame.json'
+                with state.lock:
+                    state.plan, state.last_json = plan, clean_json(record)
+                    state.processed += 1
+                save_json(args.output / 'latest_plan.json', record)
+                log.write(json.dumps(clean_json(record), allow_nan=False) + '\n')
+                if state.processed % 20 == 1:
+                    print(json.dumps({'processed': state.processed, 'frame': index, 'localized': localized,
+                        'streak': streak, 'views': record['n_views'], 'phase': phase}), flush=True)
+        artifacts.metadata.update(nonzero_motion_commands=state.motion_commands, stop_reason=state.reason)
+        session.release()
+        artifacts.finish()
+    except BaseException as exc:
+        mapping_error = exc
+        state.finish('Mapping/planning error: ' + str(exc))
+        artifacts.finish(exc)
+        raise
+    finally:
+        if debug_archive:
+            debug_archive.close(mapping_error)
+
+
+def main():
+    p = argparse.ArgumentParser(description=__doc__)
+    p.add_argument('--robot-ip', default='192.0.2.2')
+    p.add_argument('--cross-root', type=Path, default=Path('/workspace/CROSS'))
+    p.add_argument('--stretch-root', type=Path, default=Path('/workspace/stretch_ai'))
+    p.add_argument('--map-run', type=Path, required=True)
+    p.add_argument('--output', type=Path, required=True)
+    p.add_argument('--goal', type=int, default=1012)
+    p.add_argument('--port', type=int, default=8088)
+    p.add_argument('--max-v', type=float, default=.10)
+    p.add_argument('--max-w', type=float, default=.25)
+    p.add_argument('--max-plan-age', type=float, default=DEFAULT_MAX_PLAN_AGE,
+        help='Driving-plan evidence age in seconds (default: 2.0; range: 0.4–3.0)')
+    p.add_argument('--plan-hold-seconds', type=float, default=DEFAULT_PLAN_HOLD_SECONDS,
+        help='Wait at zero for a fresh plan/status in seconds (default: 8.0; range: 0–15)')
+    p.add_argument('--vggt-debug', action=argparse.BooleanOptionalAction, default=True,
+        help='Save every VGGT input group and numeric output in a separate debug archive (default: enabled)')
+    p.add_argument('--vggt-debug-dir', type=Path, help='Debug archive directory; default: OUTPUT/vggt_debug')
+    args = p.parse_args()
+    if not 0 < args.max_v <= .10 or not 0 < args.max_w <= .25:
+        raise ValueError('Initial live test is limited to 0.10 m/s and 0.25 rad/s')
+    if not .4 <= args.max_plan_age <= 3. or not 0. <= args.plan_hold_seconds <= 15.:
+        raise ValueError('Plan evidence must expire within 0.4–3.0 s; zero-velocity hold at most 15 s')
+    args.output, args.map_run = args.output.resolve(), args.map_run.resolve()
+    if args.vggt_debug_dir is not None:
+        args.vggt_debug_dir = args.vggt_debug_dir.resolve()
+    args.cross_root, args.stretch_root = args.cross_root.resolve(), args.stretch_root.resolve()
+    required = [args.cross_root / 'cross_nav/configs/policy/bev_planner_vfin2.json',
+                args.cross_root / 'models/VGGT-Omega-CROSS/vggt_omega_cross_1b_512.pt',
+                args.cross_root / 'models/VGGT-Omega-CROSS/nav/cross_nav_occupancy.pt',
+                args.cross_root / 'models/VGGT-Omega-CROSS/nav/cross_nav_observability.pt']
+    for file in required:
+        if not file.is_file():
+            raise FileNotFoundError(f'Required navigation file is missing: {file}')
+    graph = json.loads((args.map_run / 'graph.json').read_text())
+    nodes = [n for n in graph['nodes'] if not n['temporary']]
+    if args.goal not in {n['id'] for n in nodes}:
+        raise ValueError('Goal must be a permanent reference map keyframe')
+    sys.path[:0] = [str(args.cross_root), str(args.stretch_root / 'scripts')]
+    planner_runtime = warmup_native_navigation()
+    # Detect an occupied viewer port before creating a run or touching the robot.
+    server = ThreadingHTTPServer(('127.0.0.1', args.port), Handler)
+    try:
+        args.output.mkdir(parents=True, exist_ok=False)
+        state = LiveState(args)
+    except BaseException:
+        server.server_close()
+        raise
+    source = json.loads((args.map_run / 'run.json').read_text())
+    state.display = np.asarray(source['T_display_from_map'])
+    state.map_data = {'nodes': [{'id': n['id'], 'position': positions(state.display, [np.asarray(n['pose'])[:3, 3]])[0].tolist()}
+        for n in nodes], 'goal': args.goal}
+    save_json(args.output / 'map.json', state.map_data)
+    save_json(args.output / 'planner_runtime.json', planner_runtime)
+    server.daemon_threads = True
+    server.state = state
+    threading.Thread(target=server.serve_forever, daemon=True).start()
+    print(f'Live CROSS handoff: http://127.0.0.1:{args.port} — passive until Start navigation', flush=True)
+    shutdown = threading.Event()
+    def interrupt(*_):
+        shutdown.set()
+        state.finish('Process interrupted by operator')
+    signal.signal(signal.SIGINT, interrupt)
+    signal.signal(signal.SIGTERM, interrupt)
+    from depth_nav_live import RobotRelayProcess
+    relay = RobotRelayProcess(SimpleNamespace(robot_ip=args.robot_ip, ssh_user='hello-robot', container=None,
+        world_frame='odom', plan_hz=4., relay_max_frame_age=args.max_plan_age, command_ttl=.3,
+        enable_head=True), args.output)
+    threads = []
+    try:
+        relay.start()
+        for target in (capture_loop, control_loop):
+            t = threading.Thread(target=target, args=(state, relay) if target is capture_loop else (state,), daemon=True)
+            t.start()
+            threads.append(t)
+        os.chdir(args.cross_root)
+        run_mapping(state)
+    except BaseException as exc:
+        state.finish('Live pipeline error: ' + str(exc))
+        state.event('pipeline_error', error=str(exc))
+        import traceback
+        traceback.print_exc()
+    finally:
+        state.done.set()
+        for t in threads:
+            t.join(timeout=2.)
+        relay_closed = relay.close()
+        if relay_closed is False:
+            state.reason += '; robot relay shutdown could not be verified'
+        # This runner retains only the review UI after stopping. Do not retain
+        # the pipeline's model-reuse cache and several GB of GPU memory.
+        if 'cross.pipeline' in sys.modules:
+            cache = getattr(sys.modules['cross.pipeline'], '_MODEL_CACHE', None)
+            if cache is not None:
+                cache.clear()
+            import gc
+            gc.collect()
+            import torch
+            torch.cuda.empty_cache()
+        save_json(args.output / 'final_status.json', state.snapshot())
+        print(f'Live session ended; relay shutdown verified={relay_closed is not False}. Viewer remains available.', flush=True)
+    # Retain the local review page after the run ends. A new run uses a new directory.
+    while not shutdown.wait(1.):
+        pass
+    server.shutdown()
+    server.server_close()
+
+
+if __name__ == '__main__':
+    main()

cases/20261026_goal1012_05/code/lite3_ROS/scripts/monitor_stretch_transport.py

@@ -0,0 +1,74 @@
+#!/usr/bin/env python3
+"""Read-only TCP, interface and host-load samples during a Stretch run."""
+
+import argparse
+import inspect
+import json
+import shlex
+import subprocess
+import time
+from concurrent.futures import ThreadPoolExecutor
+from pathlib import Path
+
+
+def snapshot():
+    import os
+    import subprocess
+    import time
+    from pathlib import Path
+
+    result = {'unix_s': time.time(), 'monotonic_s': time.monotonic(), 'load': os.getloadavg()}
+    for name in ('net/dev', 'pressure/cpu', 'pressure/io', 'stat'):
+        try:
+            result[name] = Path('/proc', name).read_text()
+        except OSError as exc:
+            result[name] = str(exc)
+    # TCP memory and congestion statistics distinguish stale bytes already in
+    # the kernel from application-level ZMQ queues. No robot commands are sent.
+    for key, command in (
+        ('tcp', ['ss', '-tinm', ('( sport >= :4401 and sport <= :4513 ) or '
+                 '( dport >= :4401 and dport <= :4513 )')]),
+        ('routes', ['ip', 'route']),
+        ('wireless', ['cat', '/proc/net/wireless']),
+    ):
+        try:
+            completed = subprocess.run(command, capture_output=True, text=True, timeout=2, check=False)
+            result[key] = completed.stdout or completed.stderr
+        except (OSError, subprocess.TimeoutExpired) as exc:
+            result[key] = str(exc)
+    return result
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument('--robot-ip', default='192.0.2.2')
+    parser.add_argument('--output', type=Path, required=True)
+    parser.add_argument('--duration', type=float, default=900.)
+    parser.add_argument('--interval', type=float, default=1.)
+    args = parser.parse_args()
+    if args.duration <= 0 or args.interval < .5:
+        raise ValueError('Duration must be positive and interval at least 0.5 s')
+    remote_code = inspect.getsource(snapshot) + '\nimport json\nprint(json.dumps(snapshot()))\n'
+    ssh = ['ssh', '-o', 'BatchMode=yes', '-o', 'ConnectTimeout=2',
+           f'hello-robot@{args.robot_ip}', shlex.join(['python3', '-c', remote_code])]
+
+    def remote():
+        try:
+            completed = subprocess.run(ssh, capture_output=True, text=True, timeout=4, check=False)
+            return json.loads(completed.stdout) if completed.returncode == 0 else {'error': completed.stderr}
+        except (OSError, subprocess.TimeoutExpired, ValueError) as exc:
+            return {'error': str(exc)}
+
+    args.output.parent.mkdir(parents=True, exist_ok=True)
+    started = time.monotonic()
+    with args.output.open('x', buffering=1) as log, ThreadPoolExecutor(max_workers=2) as pool:
+        while time.monotonic() - started < args.duration:
+            tick = time.monotonic()
+            local_future, remote_future = pool.submit(snapshot), pool.submit(remote)
+            log.write(json.dumps({'received_unix_s': time.time(),
+                'pc': local_future.result(), 'robot': remote_future.result()}) + '\n')
+            time.sleep(max(0., args.interval - (time.monotonic() - tick)))
+
+
+if __name__ == '__main__':
+    main()

cases/20261026_goal1012_05/code/lite3_ROS/scripts/replay_stretch_cross_nav.py

@@ -0,0 +1,164 @@
+#!/usr/bin/env python3
+"""Replay saved Stretch RGB/odometry through native CROSS with its trained BEV heads.
+
+No robot/network/control interface is opened. The reference map is read-only.
+"""
+import argparse
+import hashlib
+import json
+import os
+from pathlib import Path
+import sys
+import time
+
+import cv2
+import numpy as np
+
+ROOT = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(ROOT))
+from web_console.cross_run import RunArtifacts, matrix
+from web_console.stretch_nav_learned import learned_png, reproject_bev
+from web_console.stretch_nav_replay import save_bev_frame
+from web_console.stretch_nav_report import clean_json, save_json
+from web_console.stretch_vggt_debug import VggtDebugRecorder, model_provenance
+
+
+def main():
+    p = argparse.ArgumentParser(description=__doc__)
+    for name in ('capture', 'probe', 'map-run', 'output'):
+        p.add_argument('--' + name, type=Path, required=True)
+    p.add_argument('--cross-root', type=Path, default=Path('/workspace/CROSS'))
+    p.add_argument('--heads', type=Path)
+    p.add_argument('--archive-run', type=Path, help='Backfill missing playback BEVs in this stopped live run')
+    p.add_argument('--skip-numeric-bevs', action='store_true', help='Save playback images without extra numeric BEV copies')
+    p.add_argument('--vggt-debug', action='store_true', help='Archive recomputed VGGT input groups and numeric outputs')
+    p.add_argument('--vggt-debug-dir', type=Path, help='Debug directory; default: OUTPUT/vggt_debug')
+    args = p.parse_args()
+    capture, probe, map_run, output = [getattr(args, n).resolve() for n in ('capture', 'probe', 'map_run', 'output')]
+    debug_path = (args.vggt_debug_dir or output / 'vggt_debug').resolve()
+    cross_root = args.cross_root.resolve()
+    heads = (args.heads or cross_root / 'models/VGGT-Omega-CROSS/nav').resolve()
+    occupancy, visibility = heads / 'cross_nav_occupancy.pt', heads / 'cross_nav_observability.pt'
+    source_rows = json.loads((probe / 'observations.json').read_text())
+    archive = args.archive_run.resolve() if args.archive_run else None
+    if archive is not None:
+        if capture != archive / 'capture':
+            raise ValueError('Playback archive must own the selected capture')
+        status = json.loads((archive / 'final_status.json').read_text())
+        if status['phase'] != 'stopped':
+            raise ValueError('Playback backfill requires a stopped run')
+    raw = {r['frame_idx']: r for r in map(json.loads, (capture / 'observations.jsonl').read_text().splitlines())}
+    os.chdir(cross_root)
+    sys.path.insert(0, str(cross_root))
+    from cross.core.config import load_config
+    from cross.core.types import Camera
+    from cross.pipeline import add_session_args, finish_session_args, mode_config_files, session_factory
+    first = raw[source_rows[0]['capture_frame']]
+    image = cv2.imread(str(capture / 'rgb' / f"{first['frame_idx']:08d}.jpg"))
+    h, w = image.shape[:2]
+    camera = Camera(K=np.asarray(first['camera_K']), frame_width=w, frame_height=h)
+    parser = argparse.ArgumentParser()
+    add_session_args(parser)
+    options = parser.parse_args(['--mode', 'mono', '--odometry', 'external', '--mono-estimator', 'ff'])
+    finish_session_args(options)
+    overrides = ['pose_est.ff.checkpoint=finetuned', 'pose_est.obs_max_interval_steps=1',
+        f'pose_est.ff.nav_bev_head={occupancy}', f'pose_est.ff.nav_bev_visibility={visibility}',
+        f'pose_est.ff.nav_bev_visibility_gravity={occupancy}']
+    if archive is not None:
+        overrides = json.loads((archive / 'mapping/run.json').read_text())['config_overrides']
+    config = load_config(*mode_config_files('mono', 'external', mono_estimator='ff'), sets=overrides)
+    artifacts = RunArtifacts(output, {'mode': 'mono', 'odometry': 'external', 'dataset': str(capture),
+        'loaded_map': str(map_run / 'map.pkl'), 'source_probe': str(probe), 'robot_commands_sent': 0,
+        'learned_bev_heads_available': True, 'config_overrides': overrides,
+        'depth_used_for_inference': False, 'gravity_source': 'recorded odom camera TF',
+        'checkpoint_provenance': json.loads((heads / 'provenance.json').read_text())})
+    (output / 'bevs').mkdir()
+    session, prior, observed = None, None, []
+    debug_archive = replay_error = None
+    try:
+        session = artifacts.wrap_factory(session_factory(options, camera, config))()
+        session.load_map(map_run / 'map.pkl')
+        estimator = session.mapper.pose_est
+        if args.vggt_debug:
+            debug_archive = VggtDebugRecorder(debug_path, {
+                'origin': 'recomputed_from_capture', 'source_capture': str(capture),
+                'source_probe': str(probe), 'config_overrides': overrides,
+                'checkpoint_provenance': artifacts.metadata['checkpoint_provenance'],
+                'resolved_config': json.loads((output / 'resolved_config.json').read_text()),
+                'camera_catalog': clean_json(session.mapper.cameras), 'session_camera_id': session.mapper.cam_id,
+                **model_provenance(cross_root),
+            })
+            debug_archive.attach(estimator)
+        for source in source_rows:
+            index = source['capture_frame']
+            row = raw[index]
+            pose = np.asarray(row['camera_pose'], dtype=float)
+            rgb = cv2.cvtColor(cv2.imread(str(capture / 'rgb' / f'{index:08d}.jpg')), cv2.COLOR_BGR2RGB)
+            estimator.set_gravity(pose[:3, :3].T @ np.array([0., 0., 1.]))
+            passes = estimator._n_passes
+            started = time.perf_counter()
+            if debug_archive:
+                debug_archive.begin_frame(row)
+            session.process({'rgb': rgb, 'timestamp': row['sensor_stamp'], 'frame_idx': index,
+                'delta_pose': None if prior is None else np.linalg.inv(prior) @ pose})
+            prior = pose
+            c0, best, weights = session.belief(matrix)
+            diagnostic = session.mapper.last_step_diagnostics
+            audit = [{'keyframe_id': int(a['keyframe_id']), 'score': float(a['retrieval_score']),
+                      'verified': bool(a['verified']), 'loaded': bool(a['loaded'])}
+                     for a in diagnostic.get('retrieval_audit', [])]
+            bev = estimator.last_bev if estimator._n_passes != passes else None
+            metadata = {k: v for k, v in (bev or {}).items()
+                        if k not in ('prob', 'observability', 'uncertainty')}
+            grid = None
+            if bev is not None:
+                for key in ('prob', 'observability', 'uncertainty'):
+                    array = np.asarray(bev[key], dtype=np.float32)
+                    if array.shape != (400, 400) or not np.isfinite(array).all():
+                        raise ValueError(f'Invalid learned {key} on frame {index}')
+                if not args.skip_numeric_bevs:
+                    np.savez_compressed(output / 'bevs' / f'{index:08d}.npz',
+                        prob=bev['prob'], obs=bev['observability'], err=bev['uncertainty'],
+                        R_bev_from_cam=bev['R_bev_from_cam'], up_cam=bev['up_cam'])
+                if archive is not None or debug_archive:
+                    grid = reproject_bev(bev['prob'], bev['observability'], bev['uncertainty'],
+                        bev['R_bev_from_cam'], pose, np.asarray(row['base_pose_matrix']), bev['res'])
+                if archive is not None:
+                    images = {f'{name}.png': learned_png(grid['prob'], grid['obs'], grid['err'], name)
+                        for name in ('occupancy', 'visibility', 'uncertainty')}
+                    save_bev_frame(archive, int(index), images, source='reconstructed', only_missing=True)
+            record = {'capture_frame': index, 'timestamp': row['sensor_stamp'],
+                'localized': bool(session.localized()), 'map_pose': c0, 'best_pose': best,
+                'weights': weights, 'retrieval': audit, 'camera_pose_odom': pose,
+                'base_pose_odom': row['base_pose'], 'bev_fresh': bev is not None,
+                'bev': metadata, 'process_s': time.perf_counter() - started}
+            if debug_archive:
+                debug_archive.finish_frame(observation=record, consumed_bev=bev, body_grid=grid)
+            observed.append(record)
+            artifacts.records[-1].update(localized=record['localized'], retrieval_audit=audit)
+            save_json(output / 'observations.json', observed)
+            print(json.dumps({'processed':len(observed), 'total':len(source_rows), 'frame':index,
+                'localized':record['localized'], 'fresh_bev':bev is not None,
+                'scale_source':metadata.get('scale_source'), 'n_views':metadata.get('n_views'),
+                'process_s':record['process_s']}), flush=True)
+        session.release()
+        artifacts.finish()
+    except BaseException as exc:
+        replay_error = exc
+        artifacts.finish(exc)
+        raise
+    finally:
+        if debug_archive:
+            debug_archive.close(replay_error)
+    summary = {'processed_frames': len(observed), 'localized_frames': sum(r['localized'] for r in observed),
+        'fresh_bev_frames': sum(r['bev_fresh'] for r in observed),
+        'distinct_verified_map_keyframes': sorted({a['keyframe_id'] for r in observed
+            for a in r['retrieval'] if a['loaded'] and a['verified']}),
+        'robot_commands_sent': 0, 'ground_truth_available': False,
+        'reference_map_sha256': hashlib.sha256((map_run / 'map.pkl').read_bytes()).hexdigest()}
+    save_json(output / 'result.json', summary)
+    print(json.dumps(summary), flush=True)
+
+
+if __name__ == '__main__':
+    main()

cases/20261026_goal1012_05/code/lite3_ROS/scripts/view_stretch_cross_nav_live_run.py

@@ -0,0 +1,69 @@
+#!/usr/bin/env python3
+"""Review a stopped live run. Opens no robot transport or model and cannot arm."""
+import argparse
+from http.server import ThreadingHTTPServer
+import json
+from pathlib import Path
+import secrets
+import sys
+import threading
+
+import numpy as np
+
+ROOT = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(ROOT))
+from scripts.live_stretch_cross_nav import Handler
+from web_console.stretch_nav_replay import ReplayService
+
+
+class Review:
+    def __init__(self, directory):
+        self.root = Path(directory).resolve()
+        self.replay = ReplayService(self.root)
+        snapshot = self.root / 'review.json'
+        if not snapshot.is_file():
+            snapshot = self.root / 'final_status.json'
+        self.data = json.loads(snapshot.read_text())
+        self.data.update(phase='stopped', ready=False, gate='Saved run; motion controls disabled', review=True,
+            replay_available=True)
+        self.phase = 'stopped'
+        self.token = secrets.token_urlsafe(24)
+        self.lock = threading.RLock()
+        self.map_data = json.loads((self.root / 'map.json').read_text())
+        archive = self.replay.get()
+        self.images = {}
+        for name in ('occupancy', 'visibility', 'uncertainty'):
+            path = self.root / 'review_bev' / f'{name}.png'
+            if path.is_file():
+                self.images[f'{name}.png'] = path.read_bytes()
+            elif archive.bev_ids:
+                self.images[f'{name}.png'] = archive.image(archive.bev_ids[-1], name)
+        self.packet = ({'rgb_jpg': np.frombuffer(archive.image(archive.raw_ids[-1]), np.uint8)}
+                       if archive.raw_ids else None)
+
+    def snapshot(self):
+        return {**self.data, 'token': self.token}
+
+    def finish(self, _):
+        pass
+
+
+def main():
+    p = argparse.ArgumentParser(description=__doc__)
+    p.add_argument('--run', type=Path, required=True)
+    p.add_argument('--port', type=int, default=8088)
+    args = p.parse_args()
+    server = ThreadingHTTPServer(('127.0.0.1', args.port), Handler)
+    server.daemon_threads = True
+    server.state = Review(args.run)
+    print(f'Saved live-run review: http://127.0.0.1:{args.port} (motion disabled)', flush=True)
+    try:
+        server.serve_forever()
+    except KeyboardInterrupt:
+        pass
+    finally:
+        server.server_close()
+
+
+if __name__ == '__main__':
+    main()

cases/20261026_goal1012_05/code/lite3_ROS/tests/test_stretch_capture_format.py

@@ -0,0 +1,15 @@
+import json
+
+import numpy as np
+
+from scripts.capture_stretch_cross import atomic_json
+
+
+def test_nested_robot_status_and_numpy_scalars_serialize(tmp_path):
+    path = tmp_path / 'capture.json'
+    state = {'robot_status': {'base_pose': np.array([1., 2., .3]), 'armed': np.bool_(False)},
+             'frames': np.int64(7)}
+    atomic_json(path, state)
+    assert json.loads(path.read_text()) == {
+        'robot_status': {'base_pose': [1., 2., .3], 'armed': False}, 'frames': 7}
+    assert not path.with_suffix('.json.tmp').exists()

cases/20261026_goal1012_05/code/lite3_ROS/tests/test_stretch_nav_control.py

@@ -0,0 +1,249 @@
+import numpy as np
+import pytest
+
+from web_console.stretch_nav_control import (
+    PlanWait,
+    alignment_correction,
+    attachment_clear,
+    competing_controllers,
+    depth_veto,
+    execution_gate,
+    remaining_path,
+    stationary_head_command,
+)
+
+
+def planar_transform(angle=0., x=0., y=0.):
+    c, s = np.cos(angle), np.sin(angle)
+    return np.array([[c, -s, 0., x], [s, c, 0., y], [0., 0., 1., 0.], [0., 0., 0., 1.]])
+
+
+def test_small_map_rotation_about_distant_robot_does_not_look_like_position_jump():
+    base = planar_transform(x=20., y=10.)
+    angle = np.deg2rad(2.3)
+    corrected = base @ planar_transform(angle) @ np.linalg.inv(base)
+    assert np.linalg.norm(corrected[:3, 3]) > .5  # The former origin-based check stopped here.
+    distance, rotation = alignment_correction(np.eye(4), corrected, base)
+    assert distance == pytest.approx(0., abs=1e-12)
+    assert rotation == pytest.approx(angle)
+
+
+def test_map_correction_is_independent_of_odom_origin():
+    previous = planar_transform(.3, 1., 2.)
+    current = planar_transform(.32, 1.1, 2.2)
+    base = planar_transform(.7, 12., 8.)
+    expected = alignment_correction(previous, current, base)
+    rebase = planar_transform(-.8, 100., -200.)
+    actual = alignment_correction(previous @ np.linalg.inv(rebase), current @ np.linalg.inv(rebase), rebase @ base)
+    np.testing.assert_allclose(actual, expected, atol=1e-12)
+
+
+@pytest.mark.parametrize('translation,angle', [(.51, 0.), (0., np.deg2rad(26))])
+def test_real_map_pose_jump_still_exceeds_stop_limits(translation, angle):
+    base = planar_transform(x=20., y=10.)
+    corrected = planar_transform(x=translation) @ base @ planar_transform(angle) @ np.linalg.inv(base)
+    distance, rotation = alignment_correction(np.eye(4), corrected, base)
+    assert distance > .5 or rotation > np.deg2rad(25)
+
+
+@pytest.mark.parametrize('bad', [np.full((4, 4), np.nan), np.eye(3)])
+def test_invalid_alignment_is_rejected(bad):
+    with pytest.raises(ValueError, match='Invalid map alignment'):
+        alignment_correction(np.eye(4), bad, np.eye(4))
+
+
+def valid_inputs():
+    plan = {'input_received': 9.8, 'localized': True, 'localized_streak': 3,
+            'route_ids': [1, 2], 'planner_status': 0,
+            'goal_distance': 2., 'path_odom': [[0., 0.], [1., 0.]]}
+    robot = {'is_runstopped': False, 'is_homed': True, 'posture_ok': True,
+             'healthy': True, 'latched': False}
+    return plan, robot
+
+
+def test_teleop_never_passes_execution_gate():
+    p, r = valid_inputs()
+    assert execution_gate(p, r, now=10., robot_received=9.9, heartbeat=9.9, state='teleop')
+    assert execution_gate(p, r, now=10., robot_received=9.9, heartbeat=9.9) == ''
+
+
+@pytest.mark.parametrize('field,value', [('localized', False), ('localized_streak', 2),
+    ('input_received', 7.9), ('input_received', np.nan),
+    ('route_ids', []), ('planner_status', 2), ('path_odom', []), ('goal_distance', np.nan)])
+def test_bad_plan_blocks_commands(field, value):
+    p, r = valid_inputs()
+    p[field] = value
+    assert execution_gate(p, r, now=10., robot_received=9.9, heartbeat=9.9)
+
+
+@pytest.mark.parametrize('verified_at', [None, 7., -np.inf])
+def test_committed_localization_can_bridge_map_match_gaps(verified_at):
+    p, r = valid_inputs()
+    # Accept both new plans with no verification clock and older recorded plans.
+    if verified_at is not None:
+        p['verified_at'] = verified_at
+    assert execution_gate(p, r, now=10., robot_received=9.9, heartbeat=9.9) == ''
+    # Only new sensor/plan evidence keeps execution alive during a longer gap.
+    p['input_received'] = 39.8
+    assert execution_gate(p, r, now=40., robot_received=39.9, heartbeat=39.9) == ''
+    p['localized'] = False
+    assert execution_gate(p, r, now=40., robot_received=39.9, heartbeat=39.9) == (
+        'waiting for stable committed localization')
+
+
+@pytest.mark.parametrize('field,value', [('is_runstopped', True), ('is_homed', False),
+    ('posture_ok', False), ('latched', True), ('healthy', False)])
+def test_unavailable_robot_blocks_commands(field, value):
+    p, r = valid_inputs()
+    r[field] = value
+    assert execution_gate(p, r, now=10., robot_received=9.9, heartbeat=9.9)
+
+
+def test_stale_browser_and_status_block_commands():
+    p, r = valid_inputs()
+    assert execution_gate(p, r, now=10., robot_received=9.9, heartbeat=4.)
+    assert execution_gate(p, r, now=10., robot_received=9., heartbeat=9.9)
+
+
+def test_follow_path_drops_passed_prefix_and_rotates_into_current_base():
+    result = remaining_path([[0., 0.], [0., 1.], [0., 2.]], [0., .6, np.pi / 2])
+    np.testing.assert_allclose(result[:, 0], [0., .4, 1.4], atol=1e-8)
+    np.testing.assert_allclose(result[:, 1], 0., atol=1e-8)
+
+
+def test_depth_guard_vetoes_swept_body_but_ignores_off_path_returns():
+    obstacle = np.array([[.30, -.01], [.30, 0.], [.30, .01]])
+    assert depth_veto(obstacle, [0., 0., 0.], .1, 0.)
+    assert not depth_veto(obstacle + [0., 1.], [0., 0., 0.], .1, 0.)
+
+
+def test_attachment_rejects_measured_wall_between_base_and_nearby_keyframe():
+    obstacle = np.array([[.35, -.01], [.35, 0.], [.35, .01]])
+    assert not attachment_clear(obstacle, [0., 0., 0.], [.5, 0.])
+    assert attachment_clear(obstacle, [0., 0., 0.], [-.5, 0.])
+
+
+def test_attachment_handles_sideways_connection_and_robot_self_mask():
+    obstacle = np.array([[0., .35], [.01, .35], [-.01, .35], [0., 0.]])
+    assert not attachment_clear(obstacle, [0., 0., np.pi / 2], [0., .5])
+    assert attachment_clear(obstacle, [0., 0., np.pi / 2], [0., -.5])
+
+
+def test_relaxed_plan_limit_still_expires():
+    p, r = valid_inputs()
+    p['input_received'] = 8.1
+    assert execution_gate(p, r, now=10., robot_received=9.9, heartbeat=9.9) == ''
+    p['input_received'] = 7.9
+    assert execution_gate(p, r, now=10., robot_received=9.9, heartbeat=9.9)
+
+
+def test_plan_wait_recovers_transient_gaps_but_ends_sustained_gap():
+    wait = PlanWait(timeout=3.)
+    assert wait.holds('sensor/plan evidence stale', 10.)
+    assert wait.holds('sensor/plan evidence stale', 12.9)
+    assert not wait.holds('sensor/plan evidence stale', 13.1)
+    assert not wait.holds('', 14.)
+    assert wait.since is None
+    assert wait.holds('sensor/plan evidence stale', 20.)
+
+
+def stationary_inputs():
+    plan, robot = valid_inputs()
+    plan.update(input_received=5., frame_id=1, observation_hold=True, stationary_survey=True,
+                head_target=[.5, -1.05], head_anchor=np.eye(4), head_deadline=25., scan_w=0.)
+    robot.update(frame_id=100, sensor_age=.08, tf_age=.02, base_pose=[0., 0., 0.],
+                 joint_positions=np.zeros(11), head_enabled=True)
+    return plan, robot
+
+
+def test_stationary_head_uses_current_sensor_evidence_even_when_vggt_is_late():
+    plan, robot = stationary_inputs()
+    # The driving image expired long ago; the latest source image is fresh.
+    command, fault = stationary_head_command(plan, robot, now=10., robot_received=9.95)
+    assert not fault and command == {'frame_id': 100, 'head_target': [.5, -1.05], 'v': 0., 'w': 0.}
+    assert execution_gate(plan, robot, now=10., robot_received=9.95, heartbeat=9.9) == ''
+    plan['observation_hold'] = False
+    assert execution_gate(plan, robot, now=10., robot_received=9.95, heartbeat=9.9) == 'sensor/plan evidence stale'
+
+
+def test_stationary_scan_can_complete_without_a_global_attachment_but_cannot_drive():
+    plan, robot = stationary_inputs()
+    plan['route_ids'] = []
+    assert execution_gate(plan, robot, now=10., robot_received=9.95, heartbeat=9.9) == ''
+    plan.update(observation_hold=False, input_received=9.8)
+    assert execution_gate(plan, robot, now=10., robot_received=9.95, heartbeat=9.9) == 'no global route'
+
+
+@pytest.mark.parametrize('change', ['rotation', 'deadline', 'bad_deadline', 'sensor', 'tf', 'joints', 'base', 'head'])
+def test_head_only_renewal_cannot_hide_expiry_missing_feedback_or_base_motion(change):
+    plan, robot = stationary_inputs()
+    if change == 'rotation':
+        plan['scan_w'] = .1
+    elif change == 'deadline':
+        plan['head_deadline'] = 9.9
+    elif change == 'bad_deadline':
+        plan['head_deadline'] = np.inf
+    elif change == 'sensor':
+        robot['sensor_age'] = .8
+    elif change == 'tf':
+        robot['tf_age'] = .6
+    elif change == 'joints':
+        robot['joint_positions'] = np.zeros(9)
+    elif change == 'base':
+        robot['base_pose'] = [.06, 0., 0.]
+    elif change == 'head':
+        robot['head_enabled'] = False
+    assert execution_gate(plan, robot, now=10., robot_received=9.95, heartbeat=9.9)
+
+
+@pytest.mark.parametrize('field,value', [('is_runstopped', True), ('healthy', False), ('latched', True)])
+def test_stationary_head_does_not_override_stop_or_health_faults(field, value):
+    plan, robot = stationary_inputs()
+    robot[field] = value
+    assert execution_gate(plan, robot, now=10., robot_received=9.95, heartbeat=9.9)
+    robot[field] = not value
+    assert execution_gate(plan, robot, now=10., robot_received=9.95, heartbeat=4.) == 'viewer heartbeat expired'
+
+
+def test_relaxed_browser_and_status_limits_allow_jitter_and_still_expire():
+    plan, robot = valid_inputs()
+    assert execution_gate(plan, robot, now=10., robot_received=9.6, heartbeat=7.) == ''
+    assert execution_gate(plan, robot, now=10., robot_received=9.49, heartbeat=7.) == 'robot status stale'
+    assert execution_gate(plan, robot, now=10., robot_received=9.9, heartbeat=4.9) == 'viewer heartbeat expired'
+
+
+def test_default_wait_tolerates_a_longer_compute_gap_at_zero():
+    wait = PlanWait()
+    assert wait.holds('sensor/plan evidence stale', 10.)
+    assert wait.holds('sensor/plan evidence stale', 17.9)
+    assert not wait.holds('sensor/plan evidence stale', 18.1)
+
+
+def test_corner_rotation_waits_for_new_geometry_while_stationary_survey_cannot_reanchor():
+    plan, robot = stationary_inputs()
+    plan['stationary_survey'] = False
+    robot['base_pose'] = [0., 0., .2]
+    assert execution_gate(plan, robot, now=10., robot_received=9.95, heartbeat=9.9) == (
+        'head observation feedback unavailable')
+    # A new processed corner view accounts for the permitted base rotation.
+    plan['head_anchor'] = planar_transform(.2)
+    assert execution_gate(plan, robot, now=10., robot_received=9.95, heartbeat=9.9) == ''
+    plan.update(stationary_survey=True, head_anchor=np.eye(4))
+    assert execution_gate(plan, robot, now=10., robot_received=9.95, heartbeat=9.9) == (
+        'base moved during head observation')
+
+
+@pytest.mark.parametrize('reason', ['viewer heartbeat expired',
+    'waiting for stable committed localization', 'robot state/camera/TF unavailable', 'robot stop latched'])
+def test_plan_wait_never_treats_other_faults_as_transient(reason):
+    assert not PlanWait().holds(reason, 10.)
+
+
+def test_known_teleop_process_detected_without_matching_our_live_adapter(tmp_path):
+    for pid, args in [(100, ['python', '/app/teleop.py', '--robot-ip', '192.0.2.1']),
+                      (101, ['python', '/app/live_stretch_cross_nav.py']),
+                      (102, ['bash', '-c', 'python teleop.py'])]:
+        directory = tmp_path / str(pid)
+        directory.mkdir()
+        (directory / 'cmdline').write_bytes(b'\0'.join(a.encode() for a in args))
+    assert competing_controllers(tmp_path) == [{'pid': 100, 'client': 'teleop.py'}]

cases/20261026_goal1012_05/code/lite3_ROS/tests/test_stretch_nav_geometry.py

@@ -0,0 +1,39 @@
+import numpy as np
+import pytest
+
+from web_console.stretch_nav_geometry import body_to_world, measured_bev, world_to_body
+
+
+def test_body_goal_transform_handles_yaw_and_offset():
+    base = np.array([[0., -1, 0, 4], [1, 0, 0, 2], [0, 0, 1, 0], [0, 0, 0, 1]])
+    points = np.array([[2., 1.], [0., -1.]])
+    world = body_to_world(points, base)
+    np.testing.assert_allclose(world, [[3, 4], [5, 2]])
+    np.testing.assert_allclose([world_to_body(p, base) for p in world], points, atol=1e-12)
+
+
+def test_missing_depth_stays_unknown_instead_of_becoming_free():
+    K = np.array([[40., 0, 30], [0, 40, 20], [0, 0, 1]])
+    camera = np.array([[0., 0, 1, 0], [-1, 0, 0, 0], [0, -1, 0, 1], [0, 0, 0, 1]])
+    result = measured_bev(np.zeros((40, 60)), K, camera, np.eye(4), size=80)
+    assert result['observed_cells'] == 0
+    assert result['occupied_cells'] == 0
+    assert (result['prob'] == .5).all()
+
+
+def test_elevated_surface_blocks_without_marking_occluded_floor_free():
+    K = np.array([[40., 0, 30], [0, 40, 20], [0, 0, 1]])
+    camera = np.array([[0., 0, 1, 0], [-1, 0, 0, 0], [0, -1, 0, 1], [0, 0, 0, 1]])
+    result = measured_bev(np.ones((40, 60)), K, camera, np.eye(4), size=100)
+    assert result['occupied_cells'] > 0
+    # Ground 2m ahead would project into the wall, whose measured depth is 1m.
+    row, col = int(50 - 2 / .05), 50
+    assert result['obs'][row, col] == 0
+    assert result['prob'][row, col] == pytest.approx(.5)
+
+
+def test_geometry_rejects_nonfinite_transforms():
+    camera = np.eye(4)
+    camera[0, 3] = np.nan
+    with pytest.raises(ValueError, match='Nonfinite'):
+        measured_bev(np.ones((20, 20)), np.eye(3), camera, np.eye(4))

cases/20261026_goal1012_05/code/lite3_ROS/tests/test_stretch_nav_handoff.py

@@ -0,0 +1,528 @@
+"""Exercise command transport with fake sockets; these tests cannot reach hardware."""
+import importlib.util
+import sys
+import threading
+import time
+from pathlib import Path
+from types import SimpleNamespace
+
+import numpy as np
+import pytest
+
+
+def load_adapter():
+    path = Path(__file__).resolve().parents[1] / 'scripts/live_stretch_cross_nav.py'
+    spec = importlib.util.spec_from_file_location('stretch_live_adapter', path)
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+    return module
+
+
+class Socket:
+    def __init__(self):
+        self.sent = []
+
+    def setsockopt(self, *_):
+        pass
+
+    def connect(self, *_):
+        pass
+
+    def poll(self, *_):
+        return False
+
+    def close(self):
+        pass
+
+    def send_json(self, command, **_):
+        self.sent.append(command)
+
+    def send_pyobj(self, command):
+        self.sent.append(command)
+
+
+class Context:
+    def __init__(self):
+        self.sockets = []
+
+    def socket(self, *_):
+        result = Socket()
+        self.sockets.append(result)
+        return result
+
+    def term(self):
+        pass
+
+
+def setup(monkeypatch, tmp_path):
+    module = load_adapter()
+    context = Context()
+    monkeypatch.setattr(module.zmq, 'Context', lambda: context)
+    monkeypatch.setattr(module, 'competing_controllers', lambda: [])
+    monkeypatch.setitem(sys.modules, 'cross_nav.policy.robot', SimpleNamespace(
+        pure_pursuit=lambda *_a, **_k: (_ for _ in ()).throw(AssertionError('Must not follow a path'))))
+    args = SimpleNamespace(output=tmp_path, robot_ip='unreachable.invalid', goal=1012, max_v=.1, max_w=.25, max_plan_age=1.2, plan_hold_seconds=3.)
+    state = module.LiveState(args)
+    return module, state, context
+
+
+def test_passive_loop_never_sends_arm_mode_stop_or_velocity(monkeypatch, tmp_path):
+    module, state, context = setup(monkeypatch, tmp_path)
+    # Complete several real control ticks before ending the fake session.
+    timer = threading.Timer(.18, state.done.set)
+    timer.start()
+    module.control_loop(state)
+    timer.join()
+    assert len(context.sockets) == 3
+    assert all(not socket.sent for socket in context.sockets)
+    assert state.motion_commands == 0
+
+
+def test_loss_of_localization_sends_stop_only(monkeypatch, tmp_path):
+    module, state, context = setup(monkeypatch, tmp_path)
+    state.phase = 'active'
+    state.relay_ever_requested = True
+    state.heartbeat = state.robot_received = time.monotonic()
+    state.robot = {'is_runstopped': False, 'is_homed': True, 'posture_ok': True,
+                   'healthy': True, 'latched': False}
+    state.plan = {'input_received': time.monotonic(), 'goal_distance': 2., 'localized': False}
+    module.control_loop(state)
+    assert state.phase == 'stopped'
+    commands = [command for socket in context.sockets for command in socket.sent]
+    assert len(commands) == 3
+    assert all(command['type'] == 'stop' for command in commands)
+    assert state.motion_commands == 0
+
+
+def test_browser_disconnect_stops_without_motion(monkeypatch, tmp_path):
+    module, state, context = setup(monkeypatch, tmp_path)
+    state.phase = 'active'
+    state.relay_ever_requested = True
+    state.heartbeat = time.monotonic() - 6.
+    module.control_loop(state)
+    assert state.phase == 'stopped'
+    assert all(c['type'] == 'stop' for socket in context.sockets for c in socket.sent)
+    assert 'heartbeat' in state.reason
+
+
+def test_brief_plan_gap_sends_zero_then_resumes_only_with_fresh_plan(monkeypatch, tmp_path):
+    module, state, context = setup(monkeypatch, tmp_path)
+    monkeypatch.setitem(sys.modules, 'cross_nav.policy.robot', SimpleNamespace(pure_pursuit=lambda *_a, **_k: (.08, 0.)))
+    state.phase = 'active'
+    state.relay_ever_requested = True
+    now = time.monotonic()
+    state.heartbeat = state.robot_received = now
+    state.robot = {'is_runstopped': False, 'is_homed': True, 'posture_ok': True, 'healthy': True,
+                   'latched': False, 'armed': True, 'session': state.session, 'frame_id': 1, 'base_pose': [0., 0., 0.]}
+    state.plan = {'input_received': now - 1.3, 'goal_distance': 2., 'localized': True,
+                  'localized_streak': 3, 'route_ids': [1, 2],
+                  'planner_status': 0, 'path_odom': [[0., 0.], [1., 0.]], 'frame_id': 1,
+                  'depth_obstacles': np.empty((0, 2))}
+    fresh = threading.Timer(.075, lambda: state.plan.update(input_received=time.monotonic()))
+    end = threading.Timer(.23, lambda: state.finish('End simulated run'))
+    fresh.start()
+    end.start()
+    module.control_loop(state)
+    fresh.join()
+    end.join()
+    commands = [c for socket in context.sockets for c in socket.sent if c['type'] == 'velocity']
+    assert commands[0]['v'] == commands[0]['w'] == 0.
+    assert any(c['v'] > 0 for c in commands)
+    assert all(c['ttl'] == .3 for c in commands)
+    import json
+    assert json.loads((tmp_path / 'control.json').read_text())['v'] == 0.
+
+
+@pytest.mark.parametrize('has_old_verification_clock', [False, True])
+def test_map_match_gap_continues_fresh_local_plan(monkeypatch, tmp_path, has_old_verification_clock):
+    module, state, context = setup(monkeypatch, tmp_path)
+    monkeypatch.setitem(sys.modules, 'cross_nav.policy.robot', SimpleNamespace(pure_pursuit=lambda *_a, **_k: (.08, 0.)))
+    state.phase = 'active'
+    state.relay_ever_requested = True
+    now = time.monotonic()
+    state.heartbeat = state.robot_received = now
+    state.robot = {'is_runstopped': False, 'is_homed': True, 'posture_ok': True, 'healthy': True,
+                   'latched': False, 'armed': True, 'session': state.session, 'frame_id': 1, 'base_pose': [0., 0., 0.]}
+    state.plan = {'input_received': now, 'goal_distance': 2., 'localized': True,
+                  'localized_streak': 3, 'route_ids': [1, 2],
+                  'planner_status': 0, 'path_odom': [[0., 0.], [1., 0.]], 'frame_id': 1,
+                  'depth_obstacles': np.empty((0, 2))}
+    if has_old_verification_clock:
+        state.plan['verified_at'] = now - 30.
+    end = threading.Timer(.18, lambda: state.finish('End simulated visual gap'))
+    end.start()
+    module.control_loop(state)
+    end.join()
+    commands = [c for socket in context.sockets for c in socket.sent]
+    velocity = [c for c in commands if c['type'] == 'velocity']
+    assert velocity and all(c['v'] == .08 and c['w'] == 0. for c in velocity)
+    assert all(c['ttl'] == .3 for c in velocity)
+    assert [c['type'] for c in commands[-3:]] == ['stop', 'stop', 'stop']
+    assert state.reason == 'End simulated visual gap'
+
+
+def test_sustained_plan_gap_never_executes_stale_path(monkeypatch, tmp_path):
+    module, state, context = setup(monkeypatch, tmp_path)
+    state.args.plan_hold_seconds = .08
+    state.phase = 'active'
+    state.relay_ever_requested = True
+    now = time.monotonic()
+    state.heartbeat = state.robot_received = now
+    state.robot = {'is_runstopped': False, 'is_homed': True, 'posture_ok': True, 'healthy': True,
+                   'latched': False, 'armed': True, 'session': state.session, 'frame_id': 1, 'base_pose': [0., 0., 0.]}
+    state.plan = {'input_received': now - 1.3, 'goal_distance': 2.}
+    module.control_loop(state)
+    assert state.phase == 'stopped'
+    commands = [c for socket in context.sockets for c in socket.sent if c['type'] == 'velocity']
+    assert commands and all(c['v'] == c['w'] == 0. for c in commands)
+
+
+def test_competing_teleop_blocks_mode_switch_and_arm(monkeypatch, tmp_path):
+    module, state, context = setup(monkeypatch, tmp_path)
+    monkeypatch.setattr(module, 'competing_controllers', lambda: [{'pid': 123, 'client': 'teleop.py'}])
+    state.phase = 'preparing'
+    module.control_loop(state)
+    assert state.phase == 'stopped'
+    assert 'Competing' in state.reason
+    assert all(not socket.sent for socket in context.sockets)
+
+
+def test_time_spent_scanning_controllers_counts_toward_plan_expiry(monkeypatch, tmp_path):
+    module, state, context = setup(monkeypatch, tmp_path)
+    clock = [10.]
+    monkeypatch.setattr(module.time, 'monotonic', lambda: clock[0])
+    def slow_scan():
+        clock[0] = 13.
+        return []
+    monkeypatch.setattr(module, 'competing_controllers', slow_scan)
+    state.phase = 'active'
+    state.relay_ever_requested = True
+    state.args.plan_hold_seconds = 0.
+    state.heartbeat = state.robot_received = 13.
+    state.robot = {'is_runstopped': False, 'is_homed': True, 'posture_ok': True,
+                   'healthy': True, 'latched': False}
+    state.plan = {'input_received': 10., 'goal_distance': 2., 'localized': True,
+                  'localized_streak': 3, 'route_ids': [1, 2], 'planner_status': 0,
+                  'path_odom': [[0., 0.], [1., 0.]]}
+    module.control_loop(state)
+    assert state.reason == 'sensor/plan evidence stale; navigation ended'
+    assert state.motion_commands == 0
+    assert all(c['type'] == 'stop' for socket in context.sockets for c in socket.sent)
+
+
+def test_planner_warmup_compiles_both_searches_without_robot_transport(monkeypatch):
+    module = load_adapter()
+    calls = []
+    def dijkstra(*args):
+        calls.append('dijkstra')
+        dijkstra.signatures.append('compiled')
+    dijkstra.signatures = []
+    search = SimpleNamespace(signatures=[])
+    def astar(*args):
+        calls.append('astar')
+        search.signatures.append('compiled')
+    monkeypatch.setitem(sys.modules, 'numba', SimpleNamespace(__version__='test'))
+    monkeypatch.setitem(sys.modules, 'cross_nav.plan', SimpleNamespace(_dijkstra=dijkstra))
+    monkeypatch.setitem(sys.modules, 'cross_nav.policy.bev_policy', SimpleNamespace(_astar=lambda: search, astar=astar))
+    monkeypatch.setattr(module.zmq, 'Context', lambda: (_ for _ in ()).throw(AssertionError('No transport during warmup')))
+    result = module.warmup_native_navigation()
+    assert calls == ['astar', 'dijkstra']
+    assert result['astar_signatures'] == result['dijkstra_signatures'] == ['compiled']
+
+
+def test_unaccelerated_planner_is_rejected_before_handoff(monkeypatch):
+    module = load_adapter()
+    monkeypatch.setitem(sys.modules, 'numba', SimpleNamespace(__version__='test'))
+    monkeypatch.setitem(sys.modules, 'cross_nav.plan', SimpleNamespace(_dijkstra=lambda *_: None))
+    monkeypatch.setitem(sys.modules, 'cross_nav.policy.bev_policy',
+                        SimpleNamespace(_astar=lambda: (lambda *_: None), astar=lambda *_: None))
+    with pytest.raises(RuntimeError, match='requires CROSS nav dependencies'):
+        module.warmup_native_navigation()
+
+
+def active_plan(state):
+    now = time.monotonic()
+    state.phase, state.relay_ever_requested = 'active', True
+    state.heartbeat = state.robot_received = now
+    state.robot = {'is_runstopped': False, 'is_homed': True, 'posture_ok': True, 'healthy': True,
+                   'latched': False, 'armed': True, 'session': state.session, 'frame_id': 1,
+                   'base_pose': [0., 0., 0.], 'head_enabled': True}
+    state.plan = {'input_received': now, 'goal_distance': 2., 'localized': True,
+                  'localized_streak': 3, 'route_ids': [1, 2], 'planner_status': 0,
+                  'path_odom': [[0., 0.], [1., 0.]], 'frame_id': 1,
+                  'depth_obstacles': np.empty((0, 2))}
+
+
+def test_correction_recovery_keeps_lease_at_zero_then_resumes(monkeypatch, tmp_path):
+    module, state, context = setup(monkeypatch, tmp_path)
+    active_plan(state)
+    monkeypatch.setitem(sys.modules, 'cross_nav.policy.robot', SimpleNamespace(pure_pursuit=lambda *_a, **_k: (.08, 0.)))
+    state.plan.update(recovery_pending=True, recovery_deadline=time.monotonic() + 12.)
+    fresh = threading.Timer(.075, lambda: state.plan.update(recovery_pending=False))
+    end = threading.Timer(.20, lambda: state.finish('End recovery simulation'))
+    fresh.start()
+    end.start()
+    module.control_loop(state)
+    fresh.join()
+    end.join()
+    commands = [c for socket in context.sockets for c in socket.sent if c['type'] == 'velocity']
+    assert commands[0]['v'] == commands[0]['w'] == 0.
+    assert any(c['v'] > 0 for c in commands)
+
+
+def test_brief_robot_status_gap_holds_zero_until_fresh_status_returns(monkeypatch, tmp_path):
+    module, state, context = setup(monkeypatch, tmp_path)
+    active_plan(state)
+    state.robot_received = time.monotonic() - .6
+    monkeypatch.setitem(sys.modules, 'cross_nav.policy.robot', SimpleNamespace(pure_pursuit=lambda *_a, **_k: (.08, 0.)))
+    def refresh():
+        state.robot_received = time.monotonic()
+        state.plan['input_received'] = time.monotonic()
+    fresh = threading.Timer(.075, refresh)
+    end = threading.Timer(.20, lambda: state.finish('End status gap simulation'))
+    fresh.start()
+    end.start()
+    module.control_loop(state)
+    fresh.join()
+    end.join()
+    commands = [c for socket in context.sockets for c in socket.sent if c['type'] == 'velocity']
+    assert commands[0]['v'] == commands[0]['w'] == 0.
+    assert any(c['v'] > 0 for c in commands)
+
+
+def test_sustained_robot_status_gap_stops_without_executing_a_path(monkeypatch, tmp_path):
+    module, state, context = setup(monkeypatch, tmp_path)
+    active_plan(state)
+    state.args.plan_hold_seconds = .08
+    state.robot_received = time.monotonic() - .6
+    module.control_loop(state)
+    assert state.phase == 'stopped' and 'robot status stale' in state.reason
+    commands = [c for socket in context.sockets for c in socket.sent if c['type'] == 'velocity']
+    assert commands and all(c['v'] == c['w'] == 0. for c in commands)
+
+
+def test_pose_correction_racing_control_snapshot_cannot_execute_old_route(monkeypatch, tmp_path):
+    module, state, context = setup(monkeypatch, tmp_path)
+    active_plan(state)
+    def corrected(*_a, **_k):
+        state.plan_epoch += 1
+        return .1, 0.
+    monkeypatch.setitem(sys.modules, 'cross_nav.policy.robot', SimpleNamespace(pure_pursuit=corrected))
+    end = threading.Timer(.12, lambda: state.finish('End correction race'))
+    end.start()
+    module.control_loop(state)
+    end.join()
+    commands = [c for socket in context.sockets for c in socket.sent if c['type'] == 'velocity']
+    assert commands and all(c['v'] == c['w'] == 0. for c in commands)
+
+
+def test_corner_observation_sends_head_target_with_zero_base_translation(monkeypatch, tmp_path):
+    module, state, context = setup(monkeypatch, tmp_path)
+    active_plan(state)
+    state.plan.update(observation_hold=True, head_target=[-1.2, -.4], scan_w=0., corner_phase='look')
+    end = threading.Timer(.12, lambda: state.finish('End head scan simulation'))
+    end.start()
+    module.control_loop(state)
+    end.join()
+    commands = [c for socket in context.sockets for c in socket.sent if c['type'] == 'velocity']
+    assert commands and all(c['v'] == c['w'] == 0. and c['head_target'] == [-1.2, -.4] for c in commands)
+
+
+def test_native_scan_is_rotation_only_even_if_pursuit_requests_translation(monkeypatch, tmp_path):
+    module, state, context = setup(monkeypatch, tmp_path)
+    active_plan(state)
+    state.plan.update(planner_status=2, scan_authorized=True)
+    monkeypatch.setitem(sys.modules, 'cross_nav.policy.robot', SimpleNamespace(pure_pursuit=lambda *_a, **_k: (.08, .1)))
+    end = threading.Timer(.12, lambda: state.finish('End native scan simulation'))
+    end.start()
+    module.control_loop(state)
+    end.join()
+    commands = [c for socket in context.sockets for c in socket.sent if c['type'] == 'velocity']
+    assert commands and all(c['v'] == 0. and c['w'] == .1 for c in commands)
+
+
+def test_learned_veto_does_not_block_stationary_yaw_pitch_survey(monkeypatch, tmp_path):
+    module, state, context = setup(monkeypatch, tmp_path)
+    active_plan(state)
+    monkeypatch.setattr(module, 'command_footprint_report', lambda *_a, **_k: {
+        'clear': False, 'reason': 'learned occupancy', 'cells': [], 'blocking_cell_count': 1})
+    state.plan.update(observation_hold=True, stationary_survey=True, head_target=[-.7, -1.05],
+                      scan_w=0., corner_phase='survey', survey_label='right floor',
+                      footprint_grid={'prob': np.ones((20, 20)), 'obs': np.ones((20, 20)), 'res': .05},
+                      planning_base=np.eye(4))
+    end = threading.Timer(.12, lambda: state.finish('End yaw/pitch simulation'))
+    end.start()
+    module.control_loop(state)
+    end.join()
+    commands = [c for socket in context.sockets for c in socket.sent if c['type'] == 'velocity']
+    assert commands and all(c['v'] == c['w'] == 0. and c['head_target'] == [-.7, -1.05] for c in commands)
+    assert state.last_control['learned_blocked']
+    assert state.last_control['reason'] == 'Head survey: right floor'
+
+
+def test_survey_transition_with_null_label_holds_then_accepts_fresh_head_target(monkeypatch, tmp_path):
+    module, state, context = setup(monkeypatch, tmp_path)
+    active_plan(state)
+    # Mapping invalidates the driving plan before publishing its first survey
+    # view. The old plan contains an explicit null label and no head target.
+    state.plan.update(observation_hold=True, stationary_survey=True, head_target=None,
+                      scan_w=0., survey_label=None)
+    ticks = [0]
+
+    def tick(_seconds):
+        ticks[0] += 1
+        if ticks[0] == 1:
+            state.plan = {**state.plan, 'survey_label': 'front floor', 'head_target': [-.05, -1.05]}
+        if ticks[0] >= 3:
+            state.done.set()
+        return state.done.is_set()
+
+    monkeypatch.setattr(state.done, 'wait', tick)
+    module.control_loop(state)
+    commands = [c for socket in context.sockets for c in socket.sent if c['type'] == 'velocity']
+    assert ticks[0] == 3 and state.phase == 'active'
+    assert commands and all(c['v'] == c['w'] == 0. for c in commands)
+    assert 'head_target' not in commands[0]
+    assert commands[-1]['head_target'] == [-.05, -1.05]
+    assert state.last_control['reason'] == 'Head survey: front floor'
+
+
+def test_persistent_learned_veto_requests_observation_without_executing_path(monkeypatch, tmp_path):
+    module, state, context = setup(monkeypatch, tmp_path)
+    active_plan(state)
+    monkeypatch.setitem(sys.modules, 'cross_nav.policy.robot', SimpleNamespace(pure_pursuit=lambda *_a, **_k: (.08, 0.)))
+    clock = [time.monotonic()]
+    monkeypatch.setattr(module.time, 'monotonic', lambda: clock[0])
+    state.plan.update(footprint_grid={'prob': np.ones((20, 20)), 'obs': np.ones((20, 20)), 'res': .05},
+                      planning_base=np.eye(4))
+    ticks = [0]
+    def tick(_seconds):
+        ticks[0] += 1
+        clock[0] += .1
+        state.heartbeat = state.robot_received = state.plan['input_received'] = clock[0]
+        if ticks[0] >= 15:
+            state.done.set()
+        return state.done.is_set()
+    monkeypatch.setattr(state.done, 'wait', tick)
+    module.control_loop(state)
+    commands = [c for socket in context.sockets for c in socket.sent if c['type'] == 'velocity']
+    assert commands and all(c['v'] == c['w'] == 0. for c in commands)
+    assert state.observation_requested and state.observation_reason == 'learned footprint'
+    assert state.last_control['footprint']['blocking_cell_count'] > 0
+
+
+def fresh_head_plan(state):
+    active_plan(state)
+    now = time.monotonic()
+    state.robot.update(frame_id=100, sensor_age=.08, tf_age=.02, joint_positions=np.zeros(11))
+    state.plan.update(input_received=now - 4., frame_id=1, observation_hold=True, stationary_survey=True,
+                      head_target=[.5, -1.05], scan_w=0., survey_label='left floor',
+                      head_anchor=np.eye(4), head_deadline=now + 20.)
+
+
+def test_stationary_head_renews_with_new_source_frames_without_vggt_updates(monkeypatch, tmp_path):
+    module, state, context = setup(monkeypatch, tmp_path)
+    fresh_head_plan(state)
+    ticks = [0]
+
+    def tick(_seconds):
+        ticks[0] += 1
+        state.robot_received = state.heartbeat = time.monotonic()
+        state.robot['frame_id'] += 1
+        if ticks[0] == 4:
+            state.done.set()
+        return state.done.is_set()
+
+    monkeypatch.setattr(state.done, 'wait', tick)
+    module.control_loop(state)
+    commands = [c for socket in context.sockets for c in socket.sent if c['type'] == 'velocity']
+    assert [c['frame_id'] for c in commands] == [100, 101, 102, 103]
+    assert all(c['v'] == c['w'] == 0. and c['head_target'] == [.5, -1.05] for c in commands)
+    assert state.motion_commands == 0
+    assert state.last_control['head_control_source'] == 'fresh_robot_feedback'
+
+
+def test_head_observation_deadline_never_renews_with_fresh_status(monkeypatch, tmp_path):
+    module, state, context = setup(monkeypatch, tmp_path)
+    fresh_head_plan(state)
+    deadline = state.plan['head_deadline']
+    clock = [time.monotonic()]
+    monkeypatch.setattr(module.time, 'monotonic', lambda: clock[0])
+    ticks = [0]
+
+    def tick(_seconds):
+        ticks[0] += 1
+        clock[0] = deadline + .01
+        state.robot_received = state.heartbeat = clock[0]
+        return False
+
+    monkeypatch.setattr(state.done, 'wait', tick)
+    module.control_loop(state)
+    assert state.phase == 'stopped' and 'head observation deadline expired' in state.reason
+    commands = [c for socket in context.sockets for c in socket.sent if c['type'] == 'velocity']
+    assert len(commands) == 1 and commands[0]['v'] == commands[0]['w'] == 0.
+    assert state.plan['head_deadline'] == deadline
+
+
+def test_head_renewal_cannot_resume_driving_until_a_fresh_plan_arrives(monkeypatch, tmp_path):
+    module, state, context = setup(monkeypatch, tmp_path)
+    fresh_head_plan(state)
+    monkeypatch.setitem(sys.modules, 'cross_nav.policy.robot',
+                        SimpleNamespace(pure_pursuit=lambda *_a, **_k: (.08, 0.)))
+    ticks = [0]
+
+    def tick(_seconds):
+        ticks[0] += 1
+        state.robot_received = state.heartbeat = time.monotonic()
+        if ticks[0] == 1:
+            state.plan.update(observation_hold=False, head_target=None)
+        elif ticks[0] == 2:
+            state.plan.update(input_received=time.monotonic(), frame_id=100)
+        elif ticks[0] == 3:
+            state.done.set()
+        return state.done.is_set()
+
+    monkeypatch.setattr(state.done, 'wait', tick)
+    module.control_loop(state)
+    commands = [c for socket in context.sockets for c in socket.sent if c['type'] == 'velocity']
+    assert [c['v'] for c in commands] == [0., 0., .08]
+    assert commands[0]['head_target'] == [.5, -1.05]
+    assert 'head_target' not in commands[1] and 'head_target' not in commands[2]
+
+
+@pytest.mark.parametrize('fault', ['stop', 'runstop', 'camera', 'status', 'base', 'correction'])
+def test_head_renewal_cancels_on_stop_lost_feedback_motion_or_correction(monkeypatch, tmp_path, fault):
+    module, state, context = setup(monkeypatch, tmp_path)
+    fresh_head_plan(state)
+    ticks = [0]
+
+    def tick(_seconds):
+        ticks[0] += 1
+        if ticks[0] == 1:
+            if fault == 'stop':
+                state.finish('Stopped by operator')
+            elif fault == 'runstop':
+                state.robot['is_runstopped'] = True
+            elif fault == 'camera':
+                state.robot['sensor_age'] = 1.
+            elif fault == 'status':
+                state.robot_received = time.monotonic() - 1.
+            elif fault == 'base':
+                state.robot['base_pose'] = [.06, 0., 0.]
+            elif fault == 'correction':
+                state.plan_epoch += 1
+                state.plan = {'input_received': time.monotonic(), 'goal_distance': 0., 'localized': True,
+                              'localized_streak': 3, 'recovery_pending': True,
+                              'recovery_deadline': time.monotonic() + 12.}
+        if ticks[0] >= 3:
+            state.done.set()
+        return state.done.is_set()
+
+    monkeypatch.setattr(state.done, 'wait', tick)
+    module.control_loop(state)
+    commands = [c for socket in context.sockets for c in socket.sent]
+    velocity = [c for c in commands if c['type'] == 'velocity']
+    assert velocity[0]['head_target'] == [.5, -1.05]
+    assert all('head_target' not in c for c in velocity[1:])
+    assert all(c['v'] == c['w'] == 0. for c in velocity)
+    assert all(c['type'] == 'stop' for c in commands[-3:])

cases/20261026_goal1012_05/code/lite3_ROS/tests/test_stretch_nav_learned.py

@@ -0,0 +1,55 @@
+import numpy as np
+import pytest
+
+from web_console.stretch_nav_learned import reproject_bev
+
+
+def camera_pose(yaw=0., x=0., y=0.):
+    c, s = np.cos(yaw), np.sin(yaw)
+    world_yaw = np.array([[c, -s, 0.], [s, c, 0.], [0., 0., 1.]])
+    pose = np.eye(4)
+    # Level optical camera looks along base +X, optical right is base -Y.
+    pose[:3, :3] = world_yaw @ np.array([[0., 0., 1.], [-1., 0., 0.], [0., -1., 0.]])
+    pose[:3, 3] = [x, y, .7]
+    return pose
+
+
+R_BEV_CAMERA = np.array([[1., 0., 0.], [0., 0., 1.], [0., -1., 0.]])
+
+
+def test_camera_offset_moves_obstacle_into_base_grid():
+    prob = np.zeros((64, 64), np.float32)
+    prob[30, 31] = .83
+    result = reproject_bev(prob, np.ones_like(prob), prob / 2,
+                           R_BEV_CAMERA, camera_pose(x=.2, y=.1), np.eye(4), .1)
+    assert result['prob'][28, 30] == pytest.approx(.83)
+    assert result['err'][28, 30] == pytest.approx(.415)
+    assert result['obs'][-1, -1] == 0.
+    assert result['prob'][-1, -1] == .5
+    assert result['err'][-1, -1] == 1.
+
+
+def test_camera_pan_rotates_grid_into_base_heading():
+    prob = np.zeros((64, 64), np.float32)
+    prob[26, 31] = .72
+    result = reproject_bev(prob, np.ones_like(prob), np.zeros_like(prob),
+                           R_BEV_CAMERA, camera_pose(yaw=np.pi / 2), np.eye(4), .1)
+    assert result['prob'][32, 26] == pytest.approx(.72)
+
+
+def test_base_and_camera_rotated_together_preserve_grid():
+    rng = np.random.default_rng(123)
+    prob = rng.random((64, 64), dtype=np.float32)
+    base = np.eye(4)
+    base[:2, :2] = [[0., -1.], [1., 0.]]
+    result = reproject_bev(prob, np.ones_like(prob), np.zeros_like(prob),
+                           R_BEV_CAMERA, camera_pose(yaw=np.pi / 2), base, .1)
+    np.testing.assert_allclose(result['prob'], prob)
+
+
+def test_invalid_learned_transform_rejected():
+    p = np.zeros((8, 8))
+    bad = np.eye(4)
+    bad[0, 0] = np.nan
+    with pytest.raises(ValueError):
+        reproject_bev(p, p, p, R_BEV_CAMERA, bad, np.eye(4), .1)

cases/20261026_goal1012_05/code/lite3_ROS/tests/test_stretch_nav_recovery.py

@@ -0,0 +1,222 @@
+"""Synthetic camera motion, map corrections and occluded corners; no hardware."""
+
+from types import SimpleNamespace
+
+import numpy as np
+import pytest
+
+from web_console.stretch_nav_control import alignment_correction
+from web_console.stretch_nav_recovery import (
+    CornerObserver,
+    CorrectionRecovery,
+    MeasuredObstacleMemory,
+    camera_in_base,
+    clear_goal_cache,
+    rectangle_command_clear,
+    rectangle_path_clear,
+    route_subgoal,
+)
+
+
+def transform(yaw=0.0, xy=(0.0, 0.0)):
+    c, s = np.cos(yaw), np.sin(yaw)
+    t = np.eye(4)
+    t[:2, :2] = [[c, -s], [s, c]]
+    t[:2, 3] = xy
+    return t
+
+
+def mount(yaw=0.0):
+    # Both orientation and camera centre move about the head joint.
+    camera = np.eye(4)
+    camera[:3, :3] = [[0, 0, 1], [-1, 0, 0], [0, -1, 0]]
+    camera[:3, 3] = [0.1, 0.0, 0.7]
+    return transform(yaw) @ camera
+
+
+def grid():
+    return {"prob": np.zeros((200, 200)), "obs": np.ones((200, 200)), "res": 0.05}
+
+
+def test_dynamic_head_extrinsic_does_not_create_a_map_correction():
+    base = transform(0.4, (10.0, 7.0))
+    alignment = transform(0.2, (3.0, -2.0))
+    neutral = mount()
+    attached = []
+    for pan in [0.0, -0.5, -1.3, 0.4]:
+        camera = base @ mount(pan)
+        cross_camera = alignment @ camera
+        recovered = cross_camera @ np.linalg.inv(camera)
+        np.testing.assert_allclose(camera_in_base(camera, base), mount(pan), atol=1e-12)
+        distance, angle = alignment_correction(alignment, recovered, base)
+        assert distance < 1e-10 and angle < 1e-7
+        attached.append(recovered @ base @ neutral)
+    np.testing.assert_allclose(attached, np.tile(attached[0], (4, 1, 1)), atol=1e-12)
+    # A fixed extrinsic would falsely interpret the same pan as robot motion.
+    wrong = (alignment @ base @ mount(-1.3)) @ np.linalg.inv(base @ neutral)
+    assert alignment_correction(alignment, wrong, base)[1] > 1.0
+
+
+def test_large_correction_holds_and_automatically_recovers_after_fresh_samples():
+    recovery = CorrectionRecovery()
+    corrected = transform(0.04, (1.05, 0.0))
+    result = recovery.update(np.eye(4), corrected, np.eye(4), 10.0)
+    assert result["started"] and result["pending"]
+    for now in [10.3, 10.6]:
+        assert recovery.update(corrected, corrected, np.eye(4), now)["pending"]
+    assert not recovery.update(corrected, corrected, np.eye(4), 10.9)["pending"]
+
+
+def test_repeated_position_flips_do_not_extend_recovery_indefinitely():
+    recovery = CorrectionRecovery()
+    a, b = np.eye(4), transform(xy=(1.0, 0.0))
+    recovery.update(a, b, a, 0.0)
+    for t in range(1, 13):
+        recovery.update(b if t % 2 else a, a if t % 2 else b, a, float(t))
+    with pytest.raises(RuntimeError, match="did not settle"):
+        recovery.update(a, b, a, 12.1)
+
+
+def test_goal_cache_reset_preserves_obstacle_memory_and_scale():
+    world, bumps = object(), [np.array([1.0, 2.0])]
+    episode = SimpleNamespace(
+        world=world, bumps=bumps, log_scale=0.6, route=np.ones((3, 2)), route_age=3, no_route=4, side=-1.0, expect=0.1
+    )
+    clear_goal_cache(episode)
+    assert episode.route is None and episode.expect == 0
+    assert episode.world is world and episode.bumps is bumps and episode.log_scale == 0.6
+
+
+def test_right_corner_subgoal_stays_before_the_bend():
+    hint = route_subgoal([[0.25, 0.0], [0.6, 0.0], [1.0, 0.0], [1.0, -0.5], [1.0, -1.5]], np.eye(4), [1.0, -1.5])
+    assert hint["corner"] is not None
+    assert hint["target"][0] < hint["corner"][0]
+    assert hint["target"][1] == pytest.approx(0.0)
+    assert hint["outgoing"][1] < 0
+
+
+def test_straight_route_uses_arc_length_not_a_distant_overlapping_node():
+    hint = route_subgoal([[0.5, 0.0], [1.0, 0.0], [2.0, 0.0]], np.eye(4), [2.0, 0.0])
+    assert hint["corner"] is None
+    np.testing.assert_allclose(hint["target"], [1.5, 0.0])
+
+
+def test_sideways_graph_attachment_is_not_mistaken_for_an_aisle_bend():
+    # Independent synthetic trail resembling an off-centre mapping camera.
+    route = [[0.16, -0.48], [0.47, -0.66], [0.54, -0.78], [0.58, -0.91], [0.58, -1.04], [0.53, -1.48], [0.53, -2.0]]
+    hint = route_subgoal(route, np.eye(4), route[-1])
+    assert hint["corner"] is not None and hint["corner"][1] < -0.7
+    assert hint["outgoing"][1] < -0.9
+    assert 0.0 < hint["target"][0] < 0.4 and hint["target"][1] == pytest.approx(0.0)
+
+
+def test_depth_memory_survives_a_camera_pan_and_expires_in_odom():
+    memory = MeasuredObstacleMemory(horizon=12.0)
+    obstacle = np.array([[0.3, 0.0], [0.3, 0.01], [0.3, -0.01]])
+    memory.update(obstacle, 0.0, [0.0, 0.0])
+    retained = memory.update(np.empty((0, 2)), 5.0, [0.0, 0.0])
+    assert len(retained) >= 3  # Preserve enough returns for the hard veto.
+    assert len(memory.update(np.empty((0, 2)), 12.1, [0.0, 0.0])) == 0
+
+
+def test_look_and_return_require_settled_images_before_advance():
+    observer = CornerObserver()
+    joint = np.zeros(11)
+    joint[10] = -0.4
+    hint = {"target": np.zeros(2), "corner": np.array([0.3, 0.0]), "outgoing": np.array([0.0, -1.0])}
+    result = observer.update(hint, np.eye(4), mount(), mount(), joint, grid(), 0.0)
+    assert result["hold"] and result["phase"] == "look" and result["head_target"][0] < -1.0
+    for i, pan in enumerate([-0.5, -1.0, -np.pi / 2, -np.pi / 2, -np.pi / 2]):
+        joint[9] = pan
+        result = observer.update(hint, np.eye(4), mount(pan), mount(), joint, grid(), i + 1.0)
+        assert result["hold"]
+    assert observer.phase == "return"
+    assert result["coverage"] == 1.0
+    for i in range(3):
+        joint[9] = 0.0
+        result = observer.update(hint, np.eye(4), mount(), mount(), joint, grid(), 6.0 + i)
+    assert observer.phase == "advance"
+    result = observer.update(hint, np.eye(4), mount(), mount(), joint, grid(), 9.0)
+    assert not result["hold"] and result["speed_scale"] == 0.5
+
+
+def test_scan_waits_for_head_limit_before_requesting_base_rotation():
+    observer = CornerObserver()
+    joint = np.zeros(11)
+    joint[10] = -0.4
+    hint = {"target": np.zeros(2), "corner": np.array([0.3, 0.0]), "outgoing": np.array([0.0, 1.0])}
+    result = observer.update(hint, np.eye(4), mount(), mount(), joint, grid(), 0.0)
+    assert result["head_target"][0] == 0.65 and result["scan_w"] == 0.0
+    joint[9] = 0.65
+    result = observer.update(hint, np.eye(4), mount(0.65), mount(), joint, grid(), 1.0)
+    assert result["scan_w"] == 0.15 and result["hold"]
+
+
+def test_recovery_interrupted_pan_returns_to_neutral_before_translation():
+    observer = CornerObserver()
+    observer.restore_neutral(np.eye(4), 10.0)
+    joint = np.zeros(11)
+    joint[9:11] = [-1.2, -0.4]
+    hint = {"target": np.array([1.0, 0.0]), "corner": None}
+    result = observer.update(hint, np.eye(4), mount(-1.2), mount(), joint, grid(), 10.5)
+    assert result["hold"] and result["phase"] == "return"
+    assert result["head_target"][0] == pytest.approx(0.0)
+
+
+def test_blocked_approach_can_observe_before_reaching_the_waypoint():
+    observer = CornerObserver()
+    joint = np.zeros(11)
+    joint[10] = -0.4
+    hint = {"target": np.array([0.6, 0.0]), "corner": np.array([0.9, 0.0]), "outgoing": np.array([0.0, -1.0])}
+    result = observer.update(hint, np.eye(4), mount(), mount(), joint, grid(), 0.0)
+    assert result["phase"] == "approach" and not result["hold"]
+    result = observer.update(hint, np.eye(4), mount(), mount(), joint, grid(), 2.0, force_observation=True)
+    assert result["phase"] == "look" and result["hold"]
+
+
+def test_unseen_branch_never_becomes_approved_after_a_head_scan():
+    observer = CornerObserver()
+    joint = np.zeros(11)
+    joint[10] = -0.4
+    hint = {"target": np.zeros(2), "corner": np.array([0.1, 0.0]), "outgoing": np.array([0.0, -1.0])}
+    unseen = grid()
+    unseen["obs"][:] = 0.0
+    observer.update(hint, np.eye(4), mount(), mount(), joint, unseen, 0.0)
+    for i in range(3):
+        joint[9] = -np.pi / 2
+        observer.update(hint, np.eye(4), mount(-np.pi / 2), mount(), joint, unseen, i + 1.0)
+    for i in range(2):
+        joint[9] = 0.0
+        observer.update(hint, np.eye(4), mount(), mount(), joint, unseen, i + 4.0)
+    with pytest.raises(RuntimeError, match="remains occluded"):
+        observer.update(hint, np.eye(4), mount(), mount(), joint, unseen, 6.0)
+
+
+def test_rectangle_rejects_obstacle_that_a_20cm_circle_would_miss():
+    g = grid()
+    # Centreline x=.5, return at x=.5,y=.225 clips the 46 cm body.
+    g["prob"][int(100 - 0.5 / 0.05), int(100 - 0.225 / 0.05)] = 1.0
+    assert not rectangle_path_clear([[0.5, 0.0], [1.0, 0.0]], g)
+    assert rectangle_path_clear([[0.5, 0.0], [1.0, 0.0]], grid())
+
+
+def test_pure_rotation_checks_sweeping_corners_of_the_body():
+    g = grid()
+    # Outside the stationary body, within its corners' swept circle.
+    g["prob"][int(100 - 0.30 / 0.05), 100] = 1.0
+    assert rectangle_command_clear(g, np.eye(4), np.zeros(3), 0.0, 0.0)
+    assert not rectangle_command_clear(g, np.eye(4), np.zeros(3), 0.0, 0.7)
+
+
+def test_command_footprint_uses_planning_frame_after_base_motion():
+    g = grid()
+    g["prob"][int(100 - 0.5 / 0.05), 100] = 1.0
+    base = transform(np.pi / 2, (4.0, 2.0))
+    assert rectangle_command_clear(g, base, [4.0, 2.0, np.pi / 2], 0.1, 0.0)
+    assert not rectangle_command_clear(g, base, [4.0, 2.25, np.pi / 2], 0.1, 0.0)
+
+
+@pytest.mark.parametrize("bad", [np.eye(3), np.full((4, 4), np.nan), np.diag([2.0, 1.0, 1.0, 1.0])])
+def test_invalid_dynamic_extrinsic_rejected(bad):
+    with pytest.raises(ValueError):
+        camera_in_base(bad, np.eye(4))

cases/20261026_goal1012_05/code/lite3_ROS/tests/test_stretch_nav_replay.py

@@ -0,0 +1,250 @@
+"""Historical frames, asset confinement and HTTP replay use synthetic recordings."""
+
+import http.client
+import json
+import threading
+from http.server import ThreadingHTTPServer
+
+import cv2
+import numpy as np
+import pytest
+
+from scripts.view_stretch_cross_nav_live_run import Handler, Review
+from web_console.stretch_nav_replay import LAYERS, ReplayArchive, ReplayService, read_rows, save_bev_frame
+
+
+def jsonl(path, rows):
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text("".join(json.dumps(row) + "\n" for row in rows))
+
+
+@pytest.fixture
+def recording(tmp_path):
+    root = tmp_path / "stretch_cross_nav_live_synthetic"
+    (root / "capture/rgb").mkdir(parents=True)
+    (root / "review_bev").mkdir()
+    status = {"phase": "stopped", "reason": "Goal reached", "goal_keyframe": 7, "frame": {"frame_idx": 30}}
+    for name in ("review.json", "final_status.json"):
+        (root / name).write_text(json.dumps(status))
+    (root / "map.json").write_text(json.dumps({"nodes": [], "goal": 7}))
+    raw = [{"frame_idx": number, "relative_time_s": time, "received_unix_s": 100 + time,
+            "sensor_stamp": 900 + time, "head_joints": [time / 10, -0.4]}
+           for number, time in [(10, 0.0), (20, 2.0), (30, 5.0)]]
+    jsonl(root / "capture/observations.jsonl", raw)
+    (root / "capture/latest.json").write_text(json.dumps(raw[-1]))
+    for row in raw:
+        cv2.imwrite(str(root / f"capture/rgb/{row['frame_idx']:08d}.jpg"),
+                    np.full((24, 32, 3), row["frame_idx"], np.uint8))
+    plans = [{"frame_idx": number, "time_s": time, "localized": True, "bev_size": 16, "bev_res": 0.05,
+              "trajectory": [[1, 0, 0]] if number == 20 else [[1, 0, 0], [2, 0, 0]],
+              "global_route": [], "local_path_display": [], "goal_distance": 1.0}
+             for number, time in [(20, 2), (30, 5)]]
+    jsonl(root / "observations.jsonl", plans)
+    jsonl(root / "commands.jsonl", [
+        {"time_unix": 100, "phase": "teleop", "reason": "Teleop"},
+        {"time_unix": 101, "phase": "active", "reason": "Following path", "nonzero_motion_commands": 4},
+        {"time_unix": 105.5, "phase": "stopped", "reason": "Goal reached"},
+    ])
+    jsonl(root / "robot_status.jsonl", [
+        {"received_unix": 100, "head_action_state": "idle", "joint_positions": [0.0] * 11},
+        {"received_unix": 104, "head_action_state": "moving", "joint_positions": [9.0] * 11},
+        {"received_unix": 106, "head_action_state": "future", "joint_positions": [99.0] * 11},
+    ])
+    jsonl(root / "events.jsonl", [
+        {"time_unix": 101, "type": "start_requested"},
+        {"time_unix": 105.5, "type": "stop", "reason": "Goal reached"},
+        {"time_unix": 200, "type": "stop", "reason": "Later review shutdown"},
+    ])
+    for frame in (20, 30):
+        images = {f"{layer}.png": cv2.imencode(".png", np.full((16, 16, 3), frame, np.uint8))[1].tobytes()
+                  for layer in LAYERS}
+        save_bev_frame(root, frame, images, source="recorded" if frame == 30 else "reconstructed")
+        if frame == 30:
+            for name, data in images.items():
+                (root / "review_bev" / name).write_bytes(data)
+    return root
+
+
+def test_timeline_uses_recorded_time_and_preserves_bev_provenance(recording):
+    manifest = ReplayArchive(recording).manifest()
+    assert [row["time_s"] for row in manifest["frames"]] == [0, 2, 5]
+    assert manifest["recorded_bev_frames"] == manifest["reconstructed_bev_frames"] == 1
+    assert manifest["start_index"] == 0
+    assert len(manifest["events"]) == 2  # Later server shutdown is not part of the run.
+
+
+def test_prefirst_frame_does_not_leak_future_map_bev_control_or_pose(recording):
+    frame = ReplayArchive(recording).frame(0)
+    assert frame["frame"]["trajectory"] == []
+    assert frame["replay"]["bev_urls"] == {} and frame["replay"]["bev_frame"] is None
+    assert frame["recorded_phase"] == "teleop"
+    assert frame["robot"]["head_action_state"] == "idle"
+    assert frame["processed"] == 0
+
+
+def test_historical_map_and_image_time_head_pose_are_selected_without_future_state(recording):
+    archive = ReplayArchive(recording)
+    early, later = archive.frame(1), archive.frame(2)
+    assert len(early["frame"]["trajectory"]) == 1 and len(later["frame"]["trajectory"]) == 2
+    assert early["replay"]["bev_frame"] == 20 and early["replay"]["bev_source"] == "reconstructed"
+    assert early["robot"]["joint_positions"][9:11] == [0.2, -0.4]
+    assert later["robot"]["head_action_state"] == "moving"
+    assert later["recorded_phase"] == "active" and later["phase"] == "stopped"
+    assert not later["ready"] and later["gate"] == "Replay; motion controls disabled"
+    assert early["motion_commands"] == 4  # PC receive time, not the offset sensor clock.
+
+
+def test_sparse_legacy_bev_is_not_shown_before_its_saved_frame(recording):
+    import shutil
+    shutil.rmtree(recording / "replay")
+    archive = ReplayArchive(recording)
+    assert archive.frame(1)["replay"]["bev_frame"] is None
+    assert archive.frame(2)["replay"]["bev_frame"] == 30
+
+
+def test_rgb_and_bev_assets_remain_confined_to_their_recording(recording, tmp_path):
+    archive = ReplayArchive(recording)
+    outside = tmp_path / "private.jpg"
+    outside.write_bytes(b"private")
+    image = recording / "capture/rgb/00000020.jpg"
+    image.unlink()
+    image.symlink_to(outside)
+    with pytest.raises(ValueError, match="escaped"):
+        archive.image(20)
+    with pytest.raises(KeyError):
+        archive.image(999)
+    with pytest.raises(KeyError):
+        archive.image(20, "../../private")
+    with pytest.raises(KeyError):
+        archive.frame(-1)
+
+
+def test_bev_symlink_escape_is_rejected_when_loading_archive(recording, tmp_path):
+    outside = tmp_path / "private.png"
+    outside.write_bytes(b"private")
+    image = recording / "replay/bev/00000020/occupancy.png"
+    image.unlink()
+    image.symlink_to(outside)
+    with pytest.raises(ValueError, match="escaped"):
+        ReplayArchive(recording)
+
+
+def test_backfill_does_not_overwrite_original_recorded_images(recording):
+    original = (recording / "replay/bev/00000030/occupancy.png").read_bytes()
+    save_bev_frame(recording, 30, {f"{name}.png": b"replacement" for name in LAYERS},
+                   source="reconstructed", only_missing=True)
+    assert (recording / "replay/bev/00000030/occupancy.png").read_bytes() == original
+    assert ReplayArchive(recording).frame(2)["replay"]["bev_source"] == "recorded"
+
+
+def test_partial_bev_without_commit_metadata_is_ignored(recording):
+    (recording / "replay/bev/00000020/meta.json").unlink()
+    assert ReplayArchive(recording).frame(1)["replay"]["bev_frame"] is None
+
+
+def test_committed_backfill_invalidates_a_cached_manifest(recording):
+    service = ReplayService(recording)
+    assert service.get().manifest()["bev_frames"] == 2
+    images = {f"{layer}.png": (recording / "review_bev" / f"{layer}.png").read_bytes() for layer in LAYERS}
+    save_bev_frame(recording, 10, images)
+    assert service.get().manifest()["bev_frames"] == 3
+    assert service.get().frame(0)["replay"]["bev_frame"] == 10
+
+
+def test_failed_bev_write_never_commits_a_complete_frame(recording, monkeypatch):
+    from pathlib import Path
+    original = Path.write_bytes
+    def fail_on_visibility(path, data):
+        if path.name == "visibility.png.tmp":
+            raise OSError("Synthetic disk failure")
+        return original(path, data)
+    monkeypatch.setattr(Path, "write_bytes", fail_on_visibility)
+    with pytest.raises(OSError, match="Synthetic"):
+        save_bev_frame(recording, 10, {f"{layer}.png": b"image" for layer in LAYERS})
+    assert not (recording / "replay/bev/00000010/meta.json").exists()
+    assert ReplayArchive(recording).frame(0)["replay"]["bev_frame"] is None
+
+
+def test_incomplete_final_jsonl_row_is_tolerated_but_corruption_is_not(tmp_path):
+    path = tmp_path / "rows.jsonl"
+    path.write_text('{"frame":1}\n{"frame":')
+    assert read_rows(path) == [{"frame": 1}]
+    path.write_text('{"frame":\n{"frame":2}\n')
+    with pytest.raises(json.JSONDecodeError):
+        read_rows(path)
+
+
+def test_run_selection_is_allowlisted_and_excludes_escaped_or_unfinished_runs(recording, tmp_path):
+    service = ReplayService(recording)
+    assert service.listing()[0]["id"] == recording.name
+    with pytest.raises(KeyError):
+        service.get("../private")
+    outside = tmp_path / "outside"
+    outside.mkdir()
+    (tmp_path / "stretch_cross_nav_live_escape").symlink_to(outside.parent)
+    assert len(service.listing()) == 1
+    (recording / "final_status.json").write_text('{"phase":"active"}')
+    assert service.listing() == []
+    with pytest.raises(ValueError, match="stopped"):
+        ReplayArchive(recording)
+
+
+def test_saved_server_serves_replay_and_cannot_arm_motion(recording):
+    server = ThreadingHTTPServer(("127.0.0.1", 0), Handler)
+    server.daemon_threads = True
+    server.state = Review(recording)
+    thread = threading.Thread(target=server.serve_forever, daemon=True)
+    thread.start()
+    client = http.client.HTTPConnection("127.0.0.1", server.server_port)
+    try:
+        for url, status in [
+            ("/api/replay/runs", 200), ("/api/replay/manifest", 200),
+            ("/api/replay/frame?index=1", 200), ("/api/replay/rgb?frame=20", 200),
+            ("/api/replay/bev?frame=20&layer=occupancy", 200),
+            ("/api/replay/bev?frame=20", 404), ("/api/replay/frame?index=-1", 404),
+            ("/api/replay/rgb?frame=../private", 404), ("/api/replay/map?run=../private", 404),
+        ]:
+            client.request("GET", url)
+            response = client.getresponse()
+            response.read()
+            assert response.status == status, url
+        client.request("POST", "/api/start", body="{}", headers={"X-Session": server.state.token,
+                       "Origin": f"http://127.0.0.1:{server.server_port}"})
+        response = client.getresponse()
+        response.read()
+        assert response.status == 409 and server.state.phase == "stopped"
+    finally:
+        client.close()
+        server.shutdown()
+        server.server_close()
+        thread.join(timeout=3)
+
+
+def test_future_recording_reopens_without_a_manual_review_export(recording):
+    import shutil
+    (recording / "review.json").unlink()
+    shutil.rmtree(recording / "review_bev")
+    (recording / "capture/latest.json").unlink()
+    state = Review(recording)
+    assert state.snapshot()["phase"] == "stopped"
+    assert state.packet["rgb_jpg"].tobytes().startswith(b"\xff\xd8")
+    assert set(state.images) == {f"{name}.png" for name in LAYERS}
+
+
+def test_replay_is_unavailable_during_live_navigation(recording):
+    server = ThreadingHTTPServer(("127.0.0.1", 0), Handler)
+    server.state = Review(recording)
+    server.state.phase = "active"
+    thread = threading.Thread(target=server.serve_forever, daemon=True)
+    thread.start()
+    client = http.client.HTTPConnection("127.0.0.1", server.server_port)
+    try:
+        client.request("GET", "/api/replay/manifest")
+        response = client.getresponse()
+        response.read()
+        assert response.status == 409
+    finally:
+        client.close()
+        server.shutdown()
+        server.server_close()
+        thread.join(timeout=3)

cases/20261026_goal1012_05/code/lite3_ROS/tests/test_stretch_nav_routing.py

@@ -0,0 +1,162 @@
+"""Route attachment on synthetic graphs; no CROSS checkout, map or robot needed."""
+from types import SimpleNamespace
+
+import numpy as np
+import pytest
+
+from web_console.stretch_nav_report import SavedRoute
+
+
+def pose(x=0., y=0.):
+    result = np.eye(4)
+    result[:2, 3] = [x, y]
+    return result
+
+
+class NativeGraph:
+    def __init__(self, edges):
+        self.edges = edges
+        self.reads = 0
+
+    def _get_neighbors(self, key):
+        return [b for a, b in self.edges if a == key]
+
+    def _get_edge_cost(self, a, b):
+        self.reads += 1
+        return self.edges[a, b]
+
+
+class NativePlanning:
+    def __init__(self, owner, edges, plans):
+        self.owner = owner
+        self.planner = NativeGraph(edges)
+        self.plans = plans
+        self.goal = None
+
+    def set_goal(self, *, goal_kf_id):
+        self.goal = goal_kf_id
+
+    def plan_to_goal(self, *, algorithm):
+        assert algorithm == 'astar'
+        ids = self.plans[self.owner.current]
+        assert ids[-1] == self.goal
+        return {'detailed_path': ids, 'detail_level': 'backbone',
+                'detailed_cost': sum(self.planner.edges[a, b] for a, b in zip(ids, ids[1:]))}
+
+
+def route_fixture(short_cost=7.42, long_cost=33.88):
+    route = SavedRoute.__new__(SavedRoute)
+    route.matrices = {1: pose(.1916), 2: pose(.1951), 3: pose(-4.), 9: pose(4., 4.)}
+    route.permanent = {key: SimpleNamespace(id=key) for key in route.matrices}
+    route.current = 1
+    # Two visits overlap spatially, but following recording order gives different
+    # costs to the same goal. Plans are fixed independently of the selection code.
+    edges = {(1, 3): 10., (3, 9): long_cost - 10., (2, 9): short_cost}
+    route.planning = NativePlanning(route, edges, {1: [1, 3, 9], 2: [2, 9], 3: [3, 9]})
+    route.attachment_radius, route.switch_margin = .75, .25
+    route._goal, route._cost_to_goal, route._previous_ids = None, {}, ()
+    return route
+
+
+def test_remaining_distance_beats_millimetres_of_nearest_frame_advantage():
+    route = route_fixture()
+    result = route.route(pose(), 9)
+    assert result['attachment']['nearest_keyframe'] == 1
+    assert result['ids'] == [2, 9]
+    assert result['cost_m'] == pytest.approx(7.42)
+    assert result['attachment']['total_m'] == pytest.approx(7.6151)
+
+
+def test_repeated_nearest_visit_switches_do_not_reset_to_long_loop():
+    route = route_fixture()
+    # Repeated visits flip the nearest keyframe while both remain local.
+    for x in [0., .193, .4, .193, 0.] * 20:
+        result = route.route(pose(x), 9)
+        assert result['ids'] == [2, 9]
+        assert result['cost_m'] < 8.
+
+
+def test_valid_short_route_remains_candidate_as_another_visit_gets_closer():
+    route = route_fixture()
+    route.matrices[1] = pose(.30)
+    route.matrices[2] = pose(-.56)
+    # A nearest+0.25 m filter used to drop frame 2 here and select the long loop.
+    for x in [0., .005, .01, 0.]:
+        result = route.route(pose(x), 9)
+        assert result['ids'] == [2, 9]
+        assert result['attachment']['distance_m'] < route.attachment_radius
+
+
+def test_continuity_keeps_route_when_total_costs_differ_by_only_centimetres():
+    route = route_fixture(short_cost=7.45, long_cost=10.01)
+    # Use independent direct edges of nearly equal cost.
+    route.planning.planner.edges = {(1, 9): 7.42, (2, 9): 7.45}
+    route.planning.plans[1] = [1, 9]
+    route._set_goal(9)
+    route._previous_ids = (2, 9)
+    result = route.route(pose(), 9)
+    assert result['start_keyframe'] == 2
+    assert result['attachment']['selected_on_previous_route']
+
+
+def test_continuity_never_preserves_long_route_against_substantial_saving():
+    route = route_fixture()
+    route._set_goal(9)
+    route._previous_ids = (1, 3, 9)
+    assert route.route(pose(), 9)['start_keyframe'] == 2
+
+
+def test_blocked_attachment_cannot_win_on_remaining_distance():
+    route = route_fixture()
+    result = route.route(pose(), 9, can_attach=lambda key, _point: key != 2)
+    assert result['start_keyframe'] == 1
+    assert result['attachment']['connection_check'] == 'measured_depth'
+
+
+def test_no_clear_local_attachment_returns_no_route():
+    result = route_fixture().route(pose(), 9, can_attach=lambda *_: False)
+    assert result['status'] == 'no_local_graph_attachment'
+    assert not result['ids']
+
+
+def test_distant_node_with_short_route_does_not_allow_teleporting_to_goal():
+    result = route_fixture().route(pose(20.), 9)
+    assert result['status'] == 'no_local_graph_attachment'
+    assert not result['ids']
+
+
+def test_disconnected_nearest_node_does_not_hide_connected_local_start():
+    route = route_fixture()
+    del route.planning.planner.edges[1, 3]
+    assert route.route(pose(), 9)['ids'] == [2, 9]
+
+
+def test_cost_to_go_is_cached_and_goal_change_resets_continuity():
+    route = route_fixture()
+    route.route(pose(), 9)
+    reads = route.planning.planner.reads
+    route.route(pose(.01), 9)
+    assert route.planning.planner.reads == reads
+    result = route.route(pose(), 1)
+    assert result['ids'] == [1]
+    assert route._cost_to_goal == {1: 0.}
+    assert not result['attachment']['selected_on_previous_route']
+
+
+def test_goal_attachment_retains_singleton_route_for_final_approach():
+    route = route_fixture()
+    result = route.route(pose(4., 4.), 9)
+    assert result['status'] == 'route_found'
+    assert result['ids'] == [9]
+    assert result['cost_m'] == 0.
+
+
+def test_local_attachment_cost_decreases_while_approaching_goal():
+    route = route_fixture()
+    totals = [route.route(pose(x, 4.), 9)['attachment']['total_m'] for x in [3.4, 3.6, 3.8, 4.]]
+    assert all(b < a for a, b in zip(totals, totals[1:]))
+
+
+def test_invalid_pose_is_rejected():
+    with pytest.raises(ValueError, match='Invalid committed camera pose'):
+        route_fixture().route(np.full((4, 4), np.nan), 9)

cases/20261026_goal1012_05/code/lite3_ROS/tests/test_stretch_nav_survey.py

@@ -0,0 +1,290 @@
+"""Blocked starts, settled yaw/pitch observations and footprint evidence; no hardware."""
+
+import numpy as np
+import pytest
+
+from web_console.stretch_nav_control import depth_veto
+from web_console.stretch_nav_footprint import command_footprint_report, depth_support
+from web_console.stretch_nav_recovery import (
+    CornerObserver,
+    MeasuredObstacleMemory,
+    camera_in_base,
+    rectangle_path_clear,
+)
+from web_console.stretch_nav_survey import HeadSurvey
+
+
+def camera(pan=0.0, tilt=-0.4):
+    c, s = np.cos(pan), np.sin(pan)
+    yaw = np.array([[c, -s, 0.0], [s, c, 0.0], [0.0, 0.0, 1.0]])
+    c, s = np.cos(-tilt), np.sin(-tilt)
+    pitch = np.array([[c, 0.0, s], [0.0, 1.0, 0.0], [-s, 0.0, c]])
+    mount = np.eye(4)
+    mount[:3, :3] = yaw @ pitch @ np.array([[0, 0, 1], [-1, 0, 0], [0, -1, 0]])
+    mount[:3, 3] = [0.04 * np.cos(pan), 0.04 * np.sin(pan), 1.3]
+    return mount
+
+
+def joints(pan=0.0, tilt=-0.4):
+    values = np.zeros(11)
+    values[9:11] = [pan, tilt]
+    return values
+
+
+def empty_grid():
+    return {"prob": np.zeros((200, 200)), "obs": np.ones((200, 200)), "res": 0.05}
+
+
+def complete_survey(survey, now=0.0, frame=0):
+    while survey.active:
+        target = [0.0, -0.4] if survey.braking else survey.targets[survey.index][1]
+        result = survey.update(np.eye(4), camera(*target), joints(*target), frame, now)
+        assert result["hold"] and result["scan_w"] == 0.0
+        now, frame = now + 0.25, frame + 1
+    return now, result
+
+
+def stop_base(survey, base=None):
+    base = np.eye(4) if base is None else base
+    for frame, now in enumerate([0., .35, .70]):
+        result = survey.update(base, camera(), joints(), frame, now)
+        if frame < 2:
+            assert result['head_target'] is None and result['hold'] and result['scan_w'] == 0.
+    assert not survey.braking
+
+
+def test_stuck_forward_goal_gets_distinct_yaw_and_pitch_views_before_neutral_return():
+    survey = HeadSurvey()
+    assert survey.start(np.eye(4), camera(), camera(), joints(), 0.0, "learned footprint")
+    targets = np.array([target for _, target in survey.targets])
+    assert targets[:, 0].min() < -0.6 and targets[:, 0].max() > 0.5
+    assert targets[:, 1].min() < -1.0
+    np.testing.assert_allclose(targets[-1], [0.0, -0.4])
+    _, result = complete_survey(survey)
+    assert result["survey_complete"] and result["hold"]
+    assert len(survey.views) == 6 and survey.snapshot()["settled_views"] == 6
+
+
+def test_duplicate_frames_or_moving_head_do_not_complete_a_view():
+    survey = HeadSurvey()
+    survey.start(np.eye(4), camera(), camera(), joints(), 0.0, "blocked")
+    target = survey.targets[0][1]
+    for now in [0.0, 0.5, 1.0, 1.5]:
+        survey.update(np.eye(4), camera(*target), joints(*target), 1, now)
+    assert survey.index == 0
+    for frame, tilt in enumerate([-0.6, -0.8, -1.0], 2):
+        survey.update(np.eye(4), camera(tilt=tilt), joints(tilt=tilt), frame, 2.0 + frame / 10)
+    assert survey.index == 0
+
+
+def test_joint_reaching_without_settled_camera_tf_does_not_count():
+    survey = HeadSurvey()
+    survey.start(np.eye(4), camera(), camera(), joints(), 0.0, "blocked")
+    target = survey.targets[0][1]
+    for frame in range(6):
+        survey.update(np.eye(4), camera(0.1 * frame, target[1]), joints(*target), frame, frame * 0.5)
+    assert not survey.views
+
+
+def test_settled_head_with_action_offset_counts_the_actual_image_time_extrinsic():
+    survey = HeadSurvey()
+    survey.start(np.eye(4), camera(), camera(), joints(), 0.0, "blocked")
+    stop_base(survey)
+    target = np.array(survey.targets[0][1])
+    # A successful hardware action can settle about three degrees short. The
+    # resulting view is useful, and its measured extrinsic must be retained.
+    actual = target + [0.04, 0.054]
+    actual_mount = camera(*actual)
+    for frame, now in enumerate([1.0, 1.25, 1.75], 3):
+        result = survey.update(np.eye(4), actual_mount, joints(*actual), frame, now)
+        assert result["hold"] and result["scan_w"] == 0.0
+    assert survey.index == 1 and len(survey.views) == 1
+    np.testing.assert_allclose(survey.views[0]["head_joints"], actual)
+    np.testing.assert_allclose(survey.views[0]["camera_in_base"], actual_mount)
+    assert not np.allclose(actual_mount, camera(*target))
+
+
+def test_stationary_camera_far_from_head_target_does_not_complete_a_view():
+    survey = HeadSurvey()
+    survey.start(np.eye(4), camera(), camera(), joints(), 0.0, "blocked")
+    actual = np.array(survey.targets[0][1]) + [0.0, 0.08]
+    for frame in range(6):
+        survey.update(np.eye(4), camera(*actual), joints(*actual), frame, frame * 0.5)
+    assert survey.index == 0 and not survey.views
+
+
+def test_survey_is_bounded_and_only_progress_allows_more_passes():
+    survey = HeadSurvey()
+    for start in [0.0, 15.0]:
+        survey.start(np.eye(4), camera(), camera(), joints(), start, "blocked")
+        now, _ = complete_survey(survey, start)
+    assert not survey.start(np.eye(4), camera(), camera(), joints(), now, "blocked")  # Cooldown.
+    with pytest.raises(RuntimeError, match="two passes"):
+        survey.start(np.eye(4), camera(), camera(), joints(), now + 4.0, "blocked")
+    base = np.eye(4)
+    base[0, 3] = 0.21
+    assert survey.start(base, camera(), camera(), joints(), now + 4.0, "blocked")
+    assert survey.passes == 1
+
+
+def test_survey_times_out_without_fresh_settled_frames():
+    survey = HeadSurvey()
+    survey.start(np.eye(4), camera(), camera(), joints(), 0.0, "blocked")
+    stop_base(survey)
+    with pytest.raises(RuntimeError, match="timed out"):
+        survey.update(np.eye(4), camera(), joints(), 3, 20.8)
+
+
+def test_slower_head_turn_has_time_to_settle_with_its_frozen_anchor_and_deadline():
+    survey = HeadSurvey()
+    survey.start(np.eye(4), camera(), camera(), joints(), 0., 'blocked')
+    stop_base(survey)
+    result = survey.update(np.eye(4), camera(tilt=-.8), joints(tilt=-.8), 3, 12.8)
+    assert result['head_deadline'] == pytest.approx(20.7)
+    np.testing.assert_array_equal(result['head_anchor'], survey.base)
+    target = survey.targets[0][1]
+    for frame, now in enumerate([13., 13.4, 13.9], 4):
+        survey.update(np.eye(4), camera(*target), joints(*target), frame, now)
+    assert len(survey.views) == 1
+
+
+def test_external_base_motion_aborts_stationary_survey():
+    survey = HeadSurvey()
+    survey.start(np.eye(4), camera(), camera(), joints(), 0.0, "blocked")
+    stop_base(survey)
+    base = np.eye(4)
+    base[0, 3] = 0.1
+    with pytest.raises(RuntimeError, match="Base moved"):
+        survey.update(base, camera(), joints(), 3, 1.0)
+
+
+def test_survey_waits_for_braking_then_anchors_to_the_stopped_pose():
+    survey = HeadSurvey()
+    survey.start(np.eye(4), camera(), camera(), joints(), 0., 'blocked while driving')
+    # Image age plus physical deceleration creates 10.5 cm of legitimate
+    # movement after the triggering image, as observed in the hardware run.
+    for frame, (now, x) in enumerate([(0., 0.), (.25, .046), (.5, .073),
+                                     (.75, .092), (1., .105), (1.3, .107), (1.7, .107)]):
+        base = np.eye(4)
+        base[0, 3] = x
+        result = survey.update(base, camera(), joints(), frame, now)
+        assert result['hold'] and result['scan_w'] == 0.
+        if now < 1.7:
+            assert survey.braking and result['head_target'] is None
+    assert not survey.braking and result['head_target'] is not None
+    assert survey.base[0, 3] == pytest.approx(.107)
+    assert not survey.views  # Braking frames cannot count as head observations.
+    base[0, 3] += .051
+    with pytest.raises(RuntimeError, match='Base moved'):
+        survey.update(base, camera(), joints(), 7, 2.)
+
+
+def test_duplicate_frames_cannot_establish_base_standstill():
+    survey = HeadSurvey()
+    survey.start(np.eye(4), camera(), camera(), joints(), 0., 'blocked')
+    for now in [0., 1., 2.]:
+        result = survey.update(np.eye(4), camera(), joints(), 1, now)
+        assert survey.braking and result['head_target'] is None
+
+
+def test_base_keeps_creeping_during_braking_never_starts_head_motion():
+    survey = HeadSurvey()
+    survey.start(np.eye(4), camera(), camera(), joints(), 0., 'blocked')
+    for frame in range(20):
+        base = np.eye(4)
+        base[0, 3] = .008 * frame
+        result = survey.update(base, camera(), joints(), frame, .25 * frame)
+        assert result['head_target'] is None
+    with pytest.raises(RuntimeError, match='braking timed out'):
+        survey.update(base, camera(), joints(), 21, 6.01)
+
+
+def test_excess_motion_during_braking_still_aborts():
+    survey = HeadSurvey()
+    survey.start(np.eye(4), camera(), camera(), joints(), 0., 'blocked')
+    base = np.eye(4)
+    base[0, 3] = .201
+    with pytest.raises(RuntimeError, match='braking envelope'):
+        survey.update(base, camera(), joints(), 1, .5)
+
+
+def test_cancelled_downward_scan_restores_pitch_and_yaw_after_correction():
+    observer = CornerObserver()
+    observer.restore_neutral(np.eye(4), 1.0)
+    result = observer.update({"target": np.array([1.0, 0.0]), "corner": None}, np.eye(4),
+                             camera(-0.7, -1.05), camera(), joints(-0.7, -1.05), empty_grid(), 1.1)
+    np.testing.assert_allclose(result["head_target"], [0.0, -0.4], atol=1e-10)
+    for i in range(3):
+        observer.update({"target": np.array([1.0, 0.0]), "corner": None}, np.eye(4),
+                        camera(0.0, -1.05), camera(), joints(0.0, -1.05), empty_grid(), 1.2 + i)
+    assert observer.phase == "return"  # Yaw is restored but pitch is still wrong.
+
+
+def test_camera_tf_compensation_holds_for_combined_pitch_and_yaw():
+    base = np.eye(4)
+    base[:2, 3] = [4.0, 2.0]
+    alignment = np.eye(4)
+    alignment[:2, 3] = [-2.0, 7.0]
+    for pan, tilt in [(0.0, -0.4), (0.55, -1.05), (-0.7, -1.05), (-0.7, -0.4)]:
+        actual = base @ camera(pan, tilt)
+        recovered = (alignment @ actual) @ np.linalg.inv(actual)
+        np.testing.assert_allclose(camera_in_base(actual, base), camera(pan, tilt), atol=1e-12)
+        np.testing.assert_allclose(recovered @ base @ camera(), alignment @ base @ camera(), atol=1e-12)
+
+
+def test_depth_obstacles_survive_a_long_survey_and_its_return():
+    memory = MeasuredObstacleMemory()
+    obstacle = np.array([[0.3, 0.0], [0.3, 0.01], [0.3, -0.01]])
+    memory.update(obstacle, 0.0, [0.0, 0.0])
+    memory.observing(True, 1.0)
+    assert len(memory.update(np.empty((0, 2)), 35.0, [0.0, 0.0])) >= 3
+    memory.observing(False, 36.0)
+    assert len(memory.update(np.empty((0, 2)), 40.0, [0.0, 0.0])) >= 3
+    assert not len(memory.update(np.empty((0, 2)), 48.1, [0.0, 0.0]))
+
+
+def test_own_body_prediction_is_logged_without_locking_the_robot_in_place():
+    grid = empty_grid()
+    grid["prob"][100, 100] = 0.9
+    report = command_footprint_report(grid, np.eye(4), np.zeros(3), 0.1, 0.0)
+    assert report["clear"] and report["ignored_current_body_cell_count"] == 1
+    assert report["self_cells"][0]["probability"] == 0.9
+    unsupported = depth_support(report, np.empty((0, 2)))
+    assert unsupported["depth_supported_cells"] == 0
+    assert unsupported["self_cells"][0]["nearest_depth_return_m"] is None
+    assert rectangle_path_clear([[0.5, 0.0], [1.0, 0.0]], grid)
+    assert grid["prob"][100, 100] == 0.9  # Original prediction is not overwritten.
+
+
+def test_missing_depth_never_clears_a_prediction_in_newly_swept_space():
+    grid = empty_grid()
+    grid["prob"][94, 100] = 0.9  # 27.5 cm ahead, beyond the current body.
+    report = command_footprint_report(grid, np.eye(4), np.zeros(3), 0.1, 0.0)
+    unsupported = depth_support(report, np.empty((0, 2)))
+    assert not unsupported["clear"] and unsupported["depth_supported_cells"] == 0
+    assert not rectangle_path_clear([[0.5, 0.0]], grid)
+
+
+def test_measured_depth_veto_is_preserved_at_the_existing_body_edge():
+    points = np.array([[0.215, 0.0], [0.215, 0.01], [0.215, -0.01]])
+    assert depth_veto(points, np.zeros(3), 0.1, 0.0)
+
+
+def test_report_depth_support_uses_world_frame_and_preserves_guard_decision():
+    grid = empty_grid()
+    grid["prob"][93, 100] = 0.95
+    base = np.eye(4)
+    base[:2, 3] = [4.0, 7.0]
+    report = command_footprint_report(grid, base, [4.0, 7.0, 0.0], 0.15, 0.0)
+    assert not report["clear"] and report["sweep_time_s"] > 0.0
+    point = report["cells"][0]["world_xy"]
+    result = depth_support(report, np.tile(point, (3, 1)))
+    assert result["depth_supported_cells"] == 1
+    assert result["cells"][0]["nearby_depth_returns"] == 3
+
+
+def test_unknown_predictions_do_not_become_learned_obstacles():
+    grid = empty_grid()
+    grid["prob"][:] = 1.0
+    grid["obs"][:] = 0.0
+    assert command_footprint_report(grid, np.eye(4), np.zeros(3), 0.1, 0.0)["clear"]

cases/20261026_goal1012_05/code/lite3_ROS/tests/test_stretch_transport.py

@@ -0,0 +1,80 @@
+from web_console.stretch_transport import camera_transport_diagnostics
+
+
+def test_transport_age_uses_robot_clock_despite_large_pc_clock_offset():
+    packet = {'frame_id': 40, 'sensor_stamp': 900., 'sensor_age': .06}
+    robot = {'frame_id': 52, 'ros_now_s': 903.}
+    result = camera_transport_diagnostics(packet, robot, 1200., 1200.02)
+    assert result['source_frame_gap'] == 12
+    assert abs(result['source_age_via_status_s'] - 3.02) < 1e-9
+    assert abs(result['post_publish_delay_via_status_s'] - 2.96) < 1e-9
+
+
+def test_old_status_does_not_produce_a_transport_age():
+    result = camera_transport_diagnostics({'frame_id': 5, 'sensor_stamp': 10.},
+        {'frame_id': 6, 'ros_now_s': 11.}, 100., 101.)
+    assert 'source_age_via_status_s' not in result
+
+
+def test_old_relay_and_missing_status_remain_compatible():
+    packet = {'frame_id': 5, 'sensor_stamp': 10., 'sensor_age': .03}
+    assert camera_transport_diagnostics(packet, None, 0., 1.) == {'source_age_at_send_s': .03}
+    result = camera_transport_diagnostics(packet, {'frame_id': 6}, 1., 1.1)
+    assert result['source_frame_gap'] == 1
+    assert 'source_age_via_status_s' not in result
+
+
+def test_receiver_records_timing_and_preserves_image_bytes(monkeypatch, tmp_path):
+    import importlib.util
+    import json
+    import pickle
+    from pathlib import Path
+    from types import SimpleNamespace
+
+    import numpy as np
+
+    path = Path(__file__).resolve().parents[1] / 'scripts/live_stretch_cross_nav.py'
+    spec = importlib.util.spec_from_file_location('camera_transport_live_test', path)
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+    state = module.LiveState(SimpleNamespace(output=tmp_path, robot_ip='unreachable.invalid'))
+    packet = {'world_frame': 'odom', 'frame_id': 7, 'sensor_stamp': 1000., 'sensor_age': .05,
+        'camera_pose': np.eye(4), 'base_pose_matrix': np.eye(4),
+        'camera_tf_stamp': 1000., 'base_tf_stamp': 1000.,
+        'rgb_jpg': np.frombuffer(b'exact-rgb', dtype=np.uint8),
+        'depth_png': np.frombuffer(b'exact-depth', dtype=np.uint8)}
+    payload = pickle.dumps(packet)
+
+    class Socket:
+        calls = 0
+
+        def setsockopt(self, *_):
+            pass
+
+        def connect(self, *_):
+            pass
+
+        def poll(self, *_):
+            self.calls += 1
+            if self.calls > 1:
+                state.done.set()
+                return False
+            return True
+
+        def recv(self):
+            return payload
+
+        def close(self):
+            pass
+
+    monkeypatch.setattr(module.zmq, 'Context', lambda: SimpleNamespace(socket=lambda *_: Socket(), term=lambda: None))
+    module.capture_loop(state, SimpleNamespace(process=SimpleNamespace(poll=lambda: None)))
+    root = tmp_path / 'capture'
+    assert (root / 'rgb/00000000.jpg').read_bytes() == b'exact-rgb'
+    assert (root / 'depth/00000000.png').read_bytes() == b'exact-depth'
+    timing = json.loads((root / 'transport.jsonl').read_text())
+    assert timing['wire_bytes'] == len(payload)
+    assert timing['deserialize_s'] >= 0
+    assert timing['record_and_publish_s'] >= 0
+    assert state.packet['sensor_stamp'] == 1000.
+    assert state.phase == 'teleop'

cases/20261026_goal1012_05/code/lite3_ROS/tests/test_stretch_vggt_debug.py

@@ -0,0 +1,237 @@
+"""Synthetic inference, buffer reuse and disk failures; no checkpoints or robot."""
+
+import hashlib
+import json
+import threading
+from types import SimpleNamespace
+
+import numpy as np
+import pytest
+import torch
+
+from scripts.inspect_stretch_vggt_debug import export_frame
+from web_console import stretch_vggt_debug as debug
+
+
+class Head:
+    size, res = 8, .05
+
+    def __call__(self, tokens, pts, patch_hw, dino, depth, conf, pose_enc, hw, log_scale,
+                 up_cam=None, views=None):
+        self.result = {'prob': torch.full((8, 8), .1234567), 'observability': torch.ones(8, 8),
+                       'uncertainty': torch.zeros(8, 8), 'up_cam': torch.tensor([0., -1., 0.]),
+                       'up_head': torch.tensor([0., -1., 0.]), 'log_scale': log_scale, 'res': self.res}
+        return self.result
+
+
+class Backend:
+    def __init__(self):
+        self.nav = Head()
+        self.depth = torch.zeros(2, 4, 6)
+        self.counter = 0
+        self.calib_focal = .91
+        self.last_nav = None
+
+    def infer(self, images, n_depth=None, focal=None):
+        self.counter += 1
+        self.depth.fill_(self.counter)
+        self.last_nav = {'pose_enc': torch.ones(1, len(images), 9)}
+        self.result = SimpleNamespace(c2w=np.tile(np.eye(4), (len(images), 1, 1)),
+                                      K=np.tile(np.eye(3), (len(images), 1, 1)), depth=self.depth,
+                                      depth_conf=torch.ones_like(self.depth), hw=(4, 6),
+                                      covis=np.ones((len(images), len(images))), log_scale=.3)
+        return self.result
+
+
+class Estimator:
+    def __init__(self):
+        self.backend = Backend()
+        self._R_model_to_cam = np.eye(4)
+        self._cameras = None
+
+    def estimate_pose(self, ref_image, ref_depth, curr_image, curr_depth, odom_anchor=None,
+                      ref_rel_poses=None, ref_cam_ids=None, **kwargs):
+        images = torch.stack([curr_image, ref_image[0]])
+        pred = self.backend.infer(images, n_depth=None, focal=.8)
+        out = self.backend.nav({}, 5, (1, 1), None, pred.depth, pred.depth_conf,
+                               self.backend.last_nav['pose_enc'], (4, 6), .3,
+                               up_cam=np.array([0., -1., 0.]), views=np.array([True, False]))
+        self.last_bev = {'prob': out['prob'].half().numpy(), 'observability': out['observability'].numpy(),
+                         'uncertainty': out['uncertainty'].numpy()}
+        self.last_info = {'view_tags': ['curr_L', 'ref0_L'], 'c2w_metric': pred.c2w, 'valid': True}
+        self.last_result = (torch.zeros(1, 7), np.ones(1, bool), torch.ones(1))
+        return self.last_result
+
+
+def image():
+    return torch.linspace(-.01, 1.02, 72).reshape(3, 4, 6)
+
+
+def run_frame(recorder, estimator, number=1):
+    recorder.begin_frame({'frame_idx': number, 'camera_pose': np.eye(4), 'head_joints': [0., -.4]})
+    value = image()
+    result = estimator.estimate_pose(value[None], None, value, None,
+                                     odom_anchor={'T_prev_curr': np.eye(4), 'image': value},
+                                     ref_rel_poses=[(0, 1, np.eye(4))])
+    assert result is estimator.last_result
+    recorder.finish_frame(observation={'retrieval': [{'id': 42, 'loaded': True, 'verified': False}]},
+                          consumed_bev=estimator.last_bev,
+                          body_grid={'prob': np.ones((8, 8)), 'obs': np.ones((8, 8)), 'err': np.zeros((8, 8))})
+
+
+def test_hooks_preserve_predictions_and_capture_exact_inputs_and_full_precision_head(tmp_path):
+    reference = Estimator()
+    expected = reference.estimate_pose(image()[None], None, image(), None)
+    estimator = Estimator()
+    recorder = debug.VggtDebugRecorder(tmp_path / 'debug', {'origin': 'synthetic'})
+    recorder.attach(estimator)
+    run_frame(recorder, estimator)
+    for actual, value in zip(estimator.last_result, expected):
+        np.testing.assert_array_equal(np.asarray(actual), np.asarray(value))
+    assert isinstance(estimator.backend.nav, debug._RecordingHead)
+    recorder.close()
+    assert isinstance(estimator.backend.nav, Head)
+    assert 'infer' not in vars(estimator.backend) and 'estimate_pose' not in vars(estimator)
+    record = debug.load_debug_frame(recorder.root, 1)
+    call = record['passes'][0]
+    assert call['infer_args'] == {'n_depth': None, 'focal': .8}
+    assert call['effective_calib_focal'] == .91
+    assert call['views'][1]['reference']['id'] == 42
+    np.testing.assert_array_equal(debug.load_debug_view(recorder.root, call['views'][0]['asset']), image().numpy())
+    assert call['head_calls'][0]['outputs']['prob'].dtype == np.float32
+    assert record['outputs']['consumed_bev']['prob'].dtype == np.float16
+    np.testing.assert_array_equal(call['head_calls'][0]['inputs']['views'], [True, False])
+    status = json.loads((recorder.root / 'status.json').read_text())
+    assert status['frames'] == status['passes'] == status['unique_views'] == 1
+
+
+def test_reused_output_buffers_and_shared_reference_assets_survive_later_passes(tmp_path):
+    estimator = Estimator()
+    recorder = debug.VggtDebugRecorder(tmp_path / 'debug')
+    recorder.attach(estimator)
+    run_frame(recorder, estimator, 1)
+    run_frame(recorder, estimator, 2)
+    estimator.backend.depth.fill_(99)
+    recorder.close()
+    first, second = [debug.load_debug_frame(recorder.root, number) for number in (1, 2)]
+    np.testing.assert_array_equal(first['passes'][0]['prediction']['depth'], 1)
+    np.testing.assert_array_equal(second['passes'][0]['prediction']['depth'], 2)
+    assert len(list((recorder.root / 'views').glob('*.npz'))) == 1
+
+
+def test_interrupted_inference_retains_its_inputs_and_error(tmp_path):
+    estimator = Estimator()
+    def fail(_images, n_depth=None, focal=None):
+        raise ValueError('synthetic inference failure')
+    estimator.backend.infer = fail
+    recorder = debug.VggtDebugRecorder(tmp_path / 'debug')
+    recorder.attach(estimator)
+    recorder.begin_frame({'frame_idx': 3})
+    with pytest.raises(ValueError, match='synthetic inference failure'):
+        estimator.estimate_pose(image()[None], None, image(), None)
+    recorder.close('synthetic inference failure')
+    data = debug.load_debug_frame(recorder.root, 3)
+    assert data['interrupted'] == data['passes'][0]['inference_error'] == 'synthetic inference failure'
+    np.testing.assert_array_equal(debug.load_debug_view(recorder.root, data['passes'][0]['views'][0]['asset']),
+                                  image().numpy())
+
+
+def test_background_disk_failure_is_explicit_and_does_not_commit_partial_frame(monkeypatch, tmp_path):
+    errors = []
+    def fail(*_args, **_kwargs):
+        raise OSError('synthetic disk full')
+    monkeypatch.setattr(debug, 'write_npz', fail)
+    estimator = Estimator()
+    recorder = debug.VggtDebugRecorder(tmp_path / 'debug', on_error=errors.append)
+    recorder.attach(estimator)
+    run_frame(recorder, estimator)
+    recorder.pending.join()
+    with pytest.raises(RuntimeError, match='synthetic disk full'):
+        recorder.check()
+    with pytest.raises(RuntimeError, match='synthetic disk full'):
+        recorder.close()
+    assert len(errors) == 1
+    assert not list((recorder.root / 'frames').glob('*/frame.json'))
+    assert json.loads((recorder.root / 'status.json').read_text())['status'] == 'failed'
+
+
+def test_full_queue_is_explicit_and_close_flushes_the_retained_frame(monkeypatch, tmp_path):
+    entered, release = threading.Event(), threading.Event()
+    original = debug.VggtDebugRecorder._write
+    def paused(self, job):
+        entered.set()
+        assert release.wait(5)
+        original(self, job)
+    monkeypatch.setattr(debug.VggtDebugRecorder, '_write', paused)
+    recorder = debug.VggtDebugRecorder(tmp_path / 'debug', max_pending=1)
+    estimator = Estimator()
+    recorder.attach(estimator)
+    try:
+        run_frame(recorder, estimator, 1)
+        assert entered.wait(2)
+        run_frame(recorder, estimator, 2)
+        with pytest.raises(RuntimeError, match='cannot keep up'):
+            run_frame(recorder, estimator, 3)
+    finally:
+        release.set()
+        recorder.close()
+    rows = (recorder.root / 'index.jsonl').read_text().splitlines()
+    assert [json.loads(line)['capture_frame'] for line in rows] == [1, 2, 3]
+
+
+def test_inspector_exports_input_group_and_bev_stages_without_a_model(tmp_path):
+    recorder = debug.VggtDebugRecorder(tmp_path / 'debug')
+    estimator = Estimator()
+    recorder.attach(estimator)
+    run_frame(recorder, estimator)
+    recorder.close()
+    result = export_frame(recorder.root, 1, tmp_path / 'inspection')
+    assert result['views'] == 2
+    assert all((tmp_path / 'inspection' / name).is_file() for name in
+               ('input_views.jpg', 'predicted_depth.jpg', 'bev_stages.png', 'model_inputs.npz', 'manifest.json'))
+    with np.load(tmp_path / 'inspection/model_inputs.npz', allow_pickle=False) as arrays:
+        np.testing.assert_array_equal(arrays['images'][0], image().numpy())
+
+
+def test_object_arrays_and_asset_traversal_are_rejected(tmp_path):
+    with pytest.raises(TypeError, match='Object arrays'):
+        debug.snapshot(np.array([object()], dtype=object))
+    with pytest.raises(ValueError, match='asset'):
+        debug.load_debug_view(tmp_path, '../escape')
+
+
+def test_planner_memory_snapshot_preserves_fusion_evidence_before_buffer_reuse(tmp_path):
+    world = SimpleNamespace(o=np.array([1., 2.]), num=np.ones((8, 8)), den=np.full((8, 8), 2.),
+                            seen=np.full((8, 8), .7), c={'res': .1, 'block_p': .6})
+    episode = SimpleNamespace(world=world, pose=np.zeros(3), bumps=[[1., 2.]], route=None)
+    recorder = debug.VggtDebugRecorder(tmp_path / 'debug')
+    recorder.begin_frame({'frame_idx': 4})
+    recorder.finish_frame(planner_state=debug.planner_snapshot(episode))
+    world.num[:] = 99
+    recorder.close()
+    saved = debug.load_debug_frame(recorder.root, 4)['outputs']['planner_state']['world']
+    np.testing.assert_array_equal(saved['num'], 1.)
+    np.testing.assert_array_equal(saved['den'], 2.)
+    np.testing.assert_array_equal(saved['seen'], .7)
+    assert saved['c']['block_p'] == .6
+
+
+def test_bfloat16_snapshot_preserves_numeric_values_exactly():
+    value = torch.tensor([.12345, 2000., 1e-8], dtype=torch.bfloat16)
+    saved = debug.snapshot(value)
+    assert saved.dtype == np.float32
+    np.testing.assert_array_equal(saved, value.float().numpy())
+
+
+def test_checkpoint_provenance_records_revision_and_hashes_of_actual_files(monkeypatch, tmp_path):
+    monkeypatch.setattr(debug.subprocess, 'run', lambda *_a, **_kw: SimpleNamespace(stdout='abc123\n'))
+    root = tmp_path / 'cross'
+    heads = root / 'models/VGGT-Omega-CROSS/nav'
+    heads.mkdir(parents=True)
+    names = ('vggt_omega_cross_1b_512.pt', 'nav/cross_nav_occupancy.pt', 'nav/cross_nav_observability.pt')
+    for name in names:
+        (heads.parent / name).write_bytes(name.encode())
+    provenance = debug.model_provenance(root)
+    assert provenance['cross_git_revision'] == 'abc123'
+    for name in names:
+        assert provenance['checkpoints'][name]['sha256'] == hashlib.sha256(name.encode()).hexdigest()

cases/20261026_goal1012_05/code/lite3_ROS/web_console/cross_run.py

@@ -0,0 +1,116 @@
+"""Retain native CROSS maps and trajectories without editing the CROSS checkout."""
+
+import json
+import time
+from pathlib import Path
+
+import numpy as np
+
+
+def matrix(pose):
+    return pose.matrix().detach().cpu().numpy()
+
+
+class RunArtifacts:
+    def __init__(self, directory, metadata):
+        self.directory = Path(directory).resolve()
+        self.directory.mkdir(parents=True, exist_ok=False)
+        self.metadata = {**metadata, "status": "running", "has_ground_truth": False}
+        self.records = []
+        self.session = None
+        self.original_release = None
+        self.started = time.perf_counter()
+        self.write_status()
+
+    def write_status(self):
+        path = self.directory / "run.json"
+        temporary = path.with_suffix(".json.tmp")
+        temporary.write_text(json.dumps(self.metadata, indent=2, allow_nan=False) + "\n")
+        temporary.replace(path)
+
+    def wrap_factory(self, factory):
+        def make():
+            from cross.core.config import config_to_dict
+
+            session = self.session = factory()
+            process, self.original_release = session.process, session.release
+            config = config_to_dict(session.mapper.config)
+            (self.directory / "resolved_config.json").write_text(json.dumps(config, indent=2) + "\n")
+
+            def record(frame):
+                started = time.perf_counter()
+                result = process(frame)
+                _, best, weights = session.belief(matrix)
+                estimate = getattr(session, "last_estimate", None)
+                diagnostics = getattr(estimate, "diagnostics", {})
+                row = {
+                    "frame_idx": int(frame["frame_idx"]), "timestamp": float(frame["timestamp"]),
+                    "pose": np.asarray(best).tolist(), "weights": np.asarray(weights).tolist(),
+                    "process_s": time.perf_counter() - started,
+                    "frontend_valid": bool(diagnostics.get("valid", True)),
+                    "imu_samples_provided": len(frame.get("imu", [])),
+                }
+                self.records.append(row)
+                return result
+
+            def save_release():
+                try:
+                    self.save(session)
+                finally:
+                    self.release()
+
+            session.process, session.release = record, save_release
+            return session
+        return make
+
+    def save(self, session):
+        session.save_map(self.directory / "map.pkl")
+        manager = session.hypothesis_manager
+        times = np.array([r["timestamp"] for r in self.records])
+        nodes = []
+        for key, node in manager.nodes.items():
+            stamp = getattr(node, "timestamp", None)
+            row = {"id": int(key), "pose": matrix(node.pose_mu[0]).tolist(), "temporary": bool(node.temporary)}
+            if stamp is not None and len(times) and np.isfinite(stamp):
+                index = int(np.argmin(np.abs(times - float(stamp))))
+                row.update(timestamp=float(stamp), frame_idx=self.records[index]["frame_idx"])
+            nodes.append(row)
+        visual = [{"hypothesis": int(hid), "source": int(a), "target": int(b), "factors": len(factors)}
+                  for hid, hypothesis in manager.hypotheses.items()
+                  for (a, b), factors in hypothesis.visual_edges.items()]
+        graph = {"nodes": nodes, "odometry_edges": [list(map(int, edge)) for edge in manager.odom_edges],
+                 "visual_edges": visual}
+        (self.directory / "graph.json").write_text(json.dumps(graph, indent=2, allow_nan=False) + "\n")
+        self.write_trajectory("trajectory.jsonl")
+        frontend = getattr(session, "frontend", None)
+        service = getattr(frontend, "service", None)
+        self.metadata.update(
+            frames_processed=len(self.records), keyframes=len(nodes),
+            permanent_keyframes=sum(not node["temporary"] for node in nodes),
+            odometry_edges=len(graph["odometry_edges"]), visual_edge_pairs=len(visual),
+            map_saved=True, valid_frontend_frames=sum(r["frontend_valid"] for r in self.records),
+        )
+        if service is not None:
+            self.metadata["inertial_frontend_service"] = dict(service.stats)
+        if frontend is not None and hasattr(frontend, "stats"):
+            self.metadata["inertial_frontend"] = dict(frontend.stats)
+        self.write_status()
+
+    def write_trajectory(self, filename):
+        with (self.directory / filename).open("w") as stream:
+            for record in self.records:
+                stream.write(json.dumps(record, allow_nan=False) + "\n")
+
+    def release(self):
+        if self.original_release:
+            release, self.original_release = self.original_release, None
+            release()
+
+    def finish(self, error=None):
+        self.metadata.update(status="failed" if error else "completed", frames_processed=len(self.records),
+                             wall_seconds=time.perf_counter() - self.started)
+        if error:
+            self.metadata["error"] = str(error)
+            self.write_trajectory("trajectory.partial.jsonl")
+        self.write_status()
+        self.release()

cases/20261026_goal1012_05/code/lite3_ROS/web_console/static/cross_nav.css

@@ -0,0 +1,3 @@
+:root{color-scheme:dark;--bg:#0c1720;--panel:#13232f;--line:#2b414f;--text:#e6eff1;--muted:#98afbd;--mint:#72dec0;--amber:#f3c77c}*{box-sizing:border-box}body{margin:0;background:var(--bg);color:var(--text);font:14px/1.5 system-ui,-apple-system,sans-serif}header{padding:21px 32px;display:flex;align-items:center;justify-content:space-between;gap:20px;border-bottom:1px solid var(--line);background:#11212c}header>div{display:flex;align-items:center;gap:30px}h1,h2,h3,p{margin:0}h1{font-size:25px;font-weight:650;letter-spacing:-.5px}h2{font-size:18px;font-weight:620}h3{font-size:14px;font-weight:630}.eyebrow{font-size:10px;letter-spacing:1.8px;color:var(--muted);display:block;margin-bottom:5px}header .eyebrow{margin:0;color:#b2cccf}.badge{font-size:10px;border:1px solid var(--line);border-radius:18px;padding:5px 9px;white-space:nowrap;color:var(--muted)}.passive{color:var(--mint);border-color:#355b51}main{max-width:1800px;margin:auto;padding:25px 28px}.summary{display:flex;justify-content:space-between;gap:20px;align-items:center;margin-bottom:22px}.summary h2{font-size:24px;letter-spacing:-.3px}.summary p{color:var(--muted);margin-top:4px}.metrics{display:flex;gap:40px}.metrics>div{display:flex;flex-direction:column;text-align:right}.metrics strong{font-size:28px;line-height:1.2}.metrics span{font-size:11px;color:var(--muted);margin-top:5px}.notice{display:flex;gap:18px;align-items:center;padding:13px 17px;border:1px solid #67543a;border-radius:8px;background:#28271f;color:#e7cfaa;margin-bottom:22px;font-size:12px}.notice b{white-space:nowrap;color:var(--amber)}.workspace{display:grid;grid-template-columns:255px minmax(370px,1.35fr) minmax(280px,1fr);gap:18px;align-items:stretch}.card{background:var(--panel);border:1px solid var(--line);border-radius:10px;overflow:hidden}.card-head{display:flex;align-items:center;justify-content:space-between;gap:12px;padding:18px 18px 10px}.card-head h2{font-size:17px}.card-head .eyebrow{font-size:9px}.stages{grid-row:span 2;padding:20px 17px}.stage{display:flex;gap:12px;margin:21px 0}.step{display:grid;place-items:center;flex:0 0 28px;height:28px;border-radius:7px;color:var(--mint);background:#1b3d3c;font-size:11px}.step.amber{background:#443a2b;color:var(--amber)}.stage p{font-size:12px;color:var(--mint);margin-top:3px}.stage small{display:block;font-size:10px;color:var(--muted);margin-top:2px}.divider{border-top:1px solid var(--line);margin:22px 0 17px}.goal-row{display:flex;gap:8px;margin:10px 0}.goal-row input{min-width:0;width:100%}.help{font-size:11px;color:var(--muted);line-height:1.6}.check{display:flex;gap:7px;align-items:center;margin-top:11px;font-size:12px}input[type=checkbox],input[type=range]{accent-color:var(--mint)}button,select,input[type=number]{font:inherit;background:#1a303e;color:var(--text);border:1px solid #3c5667;border-radius:6px;padding:7px 10px}button{cursor:pointer;font-size:11px;white-space:nowrap}button:hover{border-color:var(--mint);color:var(--mint)}button:disabled{opacity:.5;cursor:wait}.primary{color:var(--mint);border-color:#4f9c8b;background:#1c423f}.buttons{display:flex;gap:6px}.buttons button{padding:6px 9px}.quiet{color:var(--muted)}#global-map{height:420px;min-width:0;width:100%}.map-caption{padding:0 18px 15px}.image-card{display:flex;flex-direction:column}#robot-rgb{display:block;max-height:360px;min-height:220px;width:100%;object-fit:contain;background:#0e1b25}.image-meta{padding:11px 17px;display:flex;align-items:center;justify-content:space-between;color:var(--muted);font-size:11px}.image-card>.help{padding:0 17px 15px}.bev-wrap{padding:0 17px;display:flex;justify-content:center}#bev{width:100%;max-width:430px;aspect-ratio:1;background:#0f1e29;border-radius:6px}.bev-card>.help{padding:8px 18px 18px}.legend{display:flex;flex-wrap:wrap;gap:7px 15px;padding:12px 18px 0;font-size:10px;color:var(--muted)}.legend i{display:inline-block;width:7px;height:7px;margin-right:5px;border-radius:2px}.free{background:#3fc09f}.obstacle{background:#ef6e69}.unknown{background:#213140}.path{background:#b1e8ff}.references{min-width:0}#reference-images{display:grid;grid-template-columns:repeat(3,minmax(0,1fr));gap:9px;padding:8px 16px}figure{margin:0;min-width:0}figure img{width:100%;height:140px;object-fit:contain;border-radius:5px;background:#0c1720}figcaption{font-size:10px;color:var(--muted);margin-top:5px}figcaption b{color:var(--text);font-weight:550}.references>.help{padding:8px 17px 17px}.details{grid-column:2/4}.details dl{display:grid;grid-template-columns:repeat(3,minmax(0,1fr));gap:17px 25px;padding:10px 20px 18px;margin:0}.details dt{font-size:10px;letter-spacing:.7px;text-transform:uppercase;color:var(--muted)}.details dd{margin:4px 0 0;font-size:13px}.details>.help{padding:0 20px 18px}.timeline{margin-top:18px;padding:14px 17px;display:flex;gap:18px;align-items:center}.timeline>div{flex:1;min-width:100px}.timeline label{font-size:11px;color:var(--muted);display:block;margin-bottom:7px}.timeline input{width:100%;margin:0}.timeline>span{font-size:11px;white-space:nowrap;color:var(--muted)}footer{color:#809baa;font-size:10px;padding:17px 2px}#build-state{font-size:11px;color:var(--amber);margin-top:10px}#error{padding:14px;border:1px solid #bd6262;background:#3a2025;margin-bottom:15px;border-radius:6px}button:focus-visible,input:focus-visible,select:focus-visible{outline:2px solid var(--mint);outline-offset:3px}@media(min-width:1450px){#global-map{height:475px}#robot-rgb{max-height:410px}figure img{height:165px}}@media(max-width:1150px){.workspace{grid-template-columns:235px minmax(0,1fr)}.stages{grid-row:span 3}.image-card{grid-column:2}#robot-rgb{max-height:320px}.bev-card,.references{grid-column:2}.details{grid-column:1/3}.metrics{gap:20px}.summary h2{font-size:21px}.metrics strong{font-size:23px}}@media(max-width:700px){header{padding:17px;align-items:flex-start}header>div{display:block}header .eyebrow{margin-bottom:6px}h1{font-size:21px}header .badge{font-size:8px;padding:5px 7px;white-space:normal;max-width:115px;text-align:center}main{padding:18px 12px}.summary{display:block}.metrics{margin-top:20px;justify-content:space-between;gap:10px}.metrics>div{text-align:left}.metrics span{font-size:9px}.notice{display:block}.notice b{display:block;margin-bottom:5px}.workspace{display:flex;flex-direction:column}.stages{order:0}.map-card{order:1}.image-card{order:2}.bev-card{order:3}.references{order:4}.details{order:5}.stage{margin:15px 0}.details dl{grid-template-columns:repeat(2,minmax(0,1fr))}#global-map{height:370px}.card-head{padding:15px 14px 10px}.card-head h2{font-size:15px}.timeline{gap:10px;flex-wrap:wrap}.timeline>div{min-width:200px;order:0;flex-basis:75%}.timeline>span{order:1}.timeline #stop-capture{margin-left:auto;order:2}figure img{height:130px}.references #reference-images{gap:7px;padding:8px 12px}}
+
+.notice label{display:flex;align-items:center;gap:10px;white-space:nowrap}.notice>span{flex:1}.notice select{max-width:230px}@media(max-width:900px){.notice{flex-wrap:wrap}.notice>span{flex-basis:100%}.notice label{white-space:normal}}

cases/20261026_goal1012_05/code/lite3_ROS/web_console/static/cross_nav_live.html

@@ -0,0 +1,26 @@
+<!doctype html>
+<html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1"><title>Live Stretch · CROSS navigation</title><link rel="stylesheet" href="/cross_nav.css"><script defer src="/vendor/plotly.min.js"></script><script defer src="/cross_nav_live.js"></script><style>
+#global-map{height:550px}.live-controls{display:flex;gap:12px;align-items:center;flex-wrap:wrap;margin:18px 0}.stop{background:#a33a43;color:white;border-color:#ed7f88;font-weight:750;padding:14px 25px}.start{padding:14px 25px}.live-status{flex:1;min-width:240px}.live-status strong{display:block;font-size:18px}.live-meta{display:flex;gap:24px;flex-wrap:wrap;margin:12px 0;color:var(--muted)}.live-images{display:grid;grid-template-columns:1fr 1fr;gap:16px}.live-images img{width:100%;max-height:480px;object-fit:contain;background:#0a141e}.live-grid{display:grid;grid-template-columns:1.15fr 1fr;gap:18px}.card{padding:20px}.live-card h2{margin-bottom:14px}#bev{max-width:100%;display:block;margin:auto}#plan-note{margin-top:10px}.pill{border:1px solid var(--line);border-radius:5px;padding:4px 8px;font-size:12px}.live-layer{display:flex;gap:14px;flex-wrap:wrap;margin-top:10px}.live-layer label{display:flex;gap:6px;align-items:center}#rgb{height:450px;width:100%;object-fit:contain;background:#0b1822}.live-help{max-width:1000px}.notice{align-items:center}@media(max-width:950px){.live-grid{grid-template-columns:1fr}#global-map{height:430px}.live-images{grid-template-columns:1fr}header>div{gap:8px;flex-wrap:wrap}}
+.replay-panel{margin:16px 0;display:grid;gap:14px}.replay-panel[hidden],#handoff-note[hidden]{display:none}.replay-toolbar{display:flex;gap:10px;align-items:center;flex-wrap:wrap}.replay-toolbar select{max-width:420px}.replay-timeline{display:flex;align-items:center;gap:14px}.replay-timeline input{flex:1;min-width:100px}.replay-clock{font-variant-numeric:tabular-nums;white-space:nowrap}.replay-notes{margin:0;color:var(--muted)}@media(max-width:700px){.replay-toolbar select{max-width:100%}.replay-timeline{flex-wrap:wrap}}
+</style></head><body>
+<header><div><span class="eyebrow">STRETCH / CROSS · LIVE</span><h1 id="page-title">Teleop → navigation</h1></div><span class="badge" id="phase">CONNECTING</span></header>
+<main>
+<section class="summary"><div><span class="eyebrow">PHONE REFERENCE MAP</span><h2>Goal keyframe <span id="goal">1012</span></h2><p>2026-10-22 · 15:48:58 · learned BEV + graph routing</p></div><div class="metrics"><div><strong id="count">0</strong><span>processed observations</span></div><div><strong id="distance">—</strong><span>camera distance to goal</span></div><div><strong id="commands">0</strong><span>motion commands sent</span></div></div></section>
+<div class="notice live-help" id="handoff-note"><b>Operator handoff</b><span>Teleop until the pose is committed and Start navigation becomes available. Close the teleop client completely, then click Start navigation. Keep this page open. Stop navigation ends the run and releases the temporary relay. Goal arrival checks position within 0.4 m; final heading is not enforced.</span></div>
+<div id="error" role="alert" hidden></div>
+<div class="live-controls"><div class="live-status"><strong id="state-title">Loading observations</strong><span id="reason">Teleop remains in control</span></div><button id="start" class="primary start" disabled>Start navigation to 1012</button><button id="stop" class="stop">Stop navigation / end run</button><button id="replay-open" class="primary" disabled>Replay recording</button><button id="export">Save current result</button></div>
+<section class="card replay-panel" id="replay-panel" hidden aria-label="Recorded run playback">
+<div class="replay-toolbar"><strong>Recorded run</strong><select id="replay-run" aria-label="Recording"></select><button id="replay-close">Close replay</button></div>
+<div class="replay-toolbar"><button id="replay-prev" aria-label="Previous RGB frame">◀ Frame</button><button id="replay-play" class="primary">Play</button><button id="replay-next" aria-label="Next RGB frame">Frame ▶</button><label>Speed <select id="replay-speed"><option value="0.5">0.5×</option><option value="1" selected>1×</option><option value="2">2×</option><option value="4">4×</option></select></label><select id="replay-event" aria-label="Jump to recorded event"><option value="">Jump to event…</option></select></div>
+<div class="replay-timeline"><input id="replay-seek" type="range" min="0" max="0" value="0" step="1" aria-label="Seek replay"><output id="replay-clock" class="replay-clock">00:00 / 00:00</output></div>
+<p class="replay-notes" id="replay-note">RGB, map and occupancy playback. Motion controls are disabled.</p>
+</section>
+<div class="live-meta"><span id="localization">Localization pending</span><span id="route">Graph route pending</span><span>Speed limit: 0.10 m/s · 0.25 rad/s</span></div>
+<div class="live-grid">
+<section class="card live-card"><div class="card-head"><div><span class="eyebrow">GLOBAL MAP</span><h2>Pose, route & local path</h2></div><div class="buttons"><button id="top">Top</button><button id="reset">3D / reset</button></div></div><div id="global-map"></div><div class="live-layer"><label><input type="checkbox" data-layer="map" checked>Phone map</label><label><input type="checkbox" data-layer="route" checked>Graph route</label><label><input type="checkbox" data-layer="track" checked>CROSS camera path</label><label><input type="checkbox" data-layer="local" checked>Local plan</label></div><p class="help">Drag to rotate · scroll to zoom. Camera poses and floor-projected local paths use the same map alignment.</p></section>
+<section class="card live-card"><span class="eyebrow" id="rgb-label">LIVE ROBOT RGB</span><h2>Camera observation</h2><img id="rgb" alt="Current Stretch camera RGB"><p class="help" id="frame-note">Waiting for camera</p></section>
+<section class="card live-card"><div class="card-head"><div><span class="eyebrow">LEARNED BEV</span><h2>Occupancy & local planning</h2></div><div class="buttons"><select id="bev-range" aria-label="BEV view range"><option value="10">20 m view</option><option value="3">6 m view</option><option value="1.5">3 m near field</option></select><select id="layer" aria-label="BEV layer"><option value="occupancy">Occupancy</option><option value="visibility">Observability</option><option value="uncertainty">Occupancy error</option></select></div></div><canvas id="bev" width="600" height="600"></canvas><div class="legend" id="legend"></div><p class="help" id="plan-note">BEVs appear after a VGGT pass. The local plan appears after map commitment.</p></section>
+<section class="card live-card"><span class="eyebrow">CURRENT RUN</span><h2>Localization & handoff</h2><dl id="details"></dl><p class="help">The local route comes from native cross_nav. Swept-footprint checks use learned occupancy and measured depth. A blocked start triggers a stationary head survey. Nearby depth returns support an obstacle prediction; missing returns do not prove free space. This is the first supervised drive test; keep the robot run-stop within reach.</p><p class="help">To resume manual testing after Stop, wait for the relay to close and start a new run. After a brief plan gap, an active run continues only with a fresh valid plan. A stopped run never re-arms automatically.</p></section>
+</div>
+<footer id="page-footer">Live RGB + odometry · trained occupancy/observability heads · phone map preserved · controls require this local page</footer>
+</main></body></html>

cases/20261026_goal1012_05/code/lite3_ROS/web_console/static/cross_nav_live.js

@@ -0,0 +1,233 @@
+'use strict';
+const el=id=>document.getElementById(id);
+let state=null,liveState=null,map=null,drawn=-1,polling=false,plotReady=false;
+const replay={active:false,manifest:null,index:0,playing:false,run:null,anchorTime:0,anchorWall:0,generation:0,busy:false,pending:null};
+const initial={eye:{x:1.35,y:-1.65,z:1.2},up:{x:0,y:0,z:1}};
+const colors={map:'#688a9a',route:'#e9bd7c',track:'#72dec0',local:'#b1e8ff'};
+async function api(path,body){const options=body===undefined?{}:{method:'POST',headers:{'X-Session':liveState?.token||state?.token,'Content-Type':'application/json'},body:JSON.stringify(body),keepalive:true};const response=await fetch(path,options),data=await response.json();if(!response.ok)throw Error(data.error||response.status);return data;}
+function trace(points,name,layer,extra={}){const p=points||[];return {type:'scatter3d',mode:'lines',name,x:p.map(x=>x[0]),y:p.map(x=>x[1]),z:p.map(x=>x[2]),line:{color:colors[layer],width:layer==='map'?2:5},visible:document.querySelector(`[data-layer=${layer}]`).checked,meta:{layer},...extra};}
+async function drawMap(){const f=state.frame;if(!map)return;const data=[trace(map.nodes.map(n=>n.position),'Phone camera keyframes','map'),trace(f.global_route,'Graph route','route'),trace(f.trajectory,'CROSS camera path','track'),trace(f.local_path_display,'Local plan on floor','local')];const goal=map.nodes.find(n=>n.id===state.goal_keyframe);if(goal)data.push(trace([goal.position],`Goal ${state.goal_keyframe}`,'route',{mode:'markers',marker:{size:7,color:'#f3c77c',symbol:'diamond'}}));if(f.camera_display)data.push(trace([f.camera_display],'Robot camera','track',{mode:'markers',marker:{size:6,color:'#72dec0'}}));const layout={paper_bgcolor:'#13232f',font:{family:'system-ui',color:'#98afbd'},showlegend:false,margin:{t:0,b:0,l:0,r:0},uirevision:'live-map',scene:{aspectmode:'data',dragmode:'orbit',camera:el('global-map')._fullLayout?.scene?._scene?.getCamera()||initial,xaxis:{title:'X (m)',gridcolor:'#2b414f'},yaxis:{title:'Y (m)',gridcolor:'#2b414f'},zaxis:{title:'Z · up (m)',gridcolor:'#2b414f'}}};await Plotly.react(el('global-map'),data,layout,{responsive:true,scrollZoom:true,displayModeBar:false});plotReady=true;}
+function drawBEV() {
+  const f=state?.frame;
+  if(!f?.bev_size||(state.playback&&!state.replay.bev_urls[el('layer').value])){
+    const ctx=el('bev').getContext('2d');ctx.fillStyle='#0f1e29';ctx.fillRect(0,0,600,600);
+    ctx.fillStyle='#a9bfcb';ctx.font='16px system-ui';ctx.textAlign='center';
+    ctx.fillText('No saved BEV at this time',300,300);el('legend').replaceChildren();return;
+  }
+  const layer=el('layer').value,ctx=el('bev').getContext('2d'),img=new Image();
+  img.onload=()=>{
+    if(state.frame!==f)return;
+    const pad=36,size=528,fullHalf=f.bev_size*f.bev_res/2;
+    const half=Math.min(fullHalf,Number(el('bev-range').value));
+    const p=x=>[pad+size*(.5-x[1]/(2*half)),pad+size*(.5-x[0]/(2*half))];
+    ctx.fillStyle='#0f1e29';ctx.fillRect(0,0,600,600);ctx.imageSmoothingEnabled=false;
+    const sourceSize=img.width*half/fullHalf,sourceStart=(img.width-sourceSize)/2;
+    ctx.drawImage(img,sourceStart,sourceStart,sourceSize,sourceSize,pad,pad,size,size);
+    ctx.save();ctx.beginPath();ctx.rect(pad,pad,size,size);ctx.clip();
+    ctx.strokeStyle='#98afbd30';const step=half<=1.5?.25:half<=3?.5:1;
+    for(let i=-half;i<=half;i+=step){
+      ctx.beginPath();ctx.moveTo(...p([i,-half]));ctx.lineTo(...p([i,half]));
+      ctx.moveTo(...p([-half,i]));ctx.lineTo(...p([half,i]));ctx.stroke();
+    }
+    if(f.local_path_body?.length){
+      ctx.strokeStyle='#b1e8ff';ctx.lineWidth=3;ctx.beginPath();ctx.moveTo(...p([0,0]));
+      for(const x of f.local_path_body)ctx.lineTo(...p(x));ctx.stroke();
+    }
+    const body=p([.23,.23]),bodySize=size*.46/(2*half);
+    ctx.strokeStyle='white';ctx.lineWidth=2;ctx.strokeRect(...body,bodySize,bodySize);
+    for(const cell of [...(f.footprint_diagnostics?.self_cells||[]),...(f.footprint_diagnostics?.cells||[])]){
+      const xy=cell.display_body_xy||cell.grid_body_xy,point=p(xy),width=Math.max(4,size*f.bev_res/(2*half));
+      ctx.fillStyle=(f.footprint_diagnostics?.self_cells||[]).includes(cell)?'#9aafbf':cell.depth_supported?'#ff6868':'#ffa63d';
+      ctx.fillRect(point[0]-width/2,point[1]-width/2,width,width);
+    }
+    const origin=p([0,0]);ctx.fillStyle='white';ctx.beginPath();ctx.arc(...origin,3,0,Math.PI*2);ctx.fill();
+    if(f.goal_body){ctx.fillStyle='#f3c77c';ctx.beginPath();ctx.arc(...p(f.goal_body),5,0,Math.PI*2);ctx.fill();}
+    ctx.restore();ctx.fillStyle='#a9bfcb';ctx.font='12px system-ui';ctx.textAlign='center';
+    ctx.fillText(`FORWARD +${half} m`,300,20);ctx.fillText(`LEFT +${half} m`,90,585);
+    ctx.fillText(`RIGHT −${half} m`,505,585);
+  };
+  img.src=state.playback?state.replay.bev_urls[layer]:`/api/bev/${layer}.png?t=${f.frame_idx}`;
+  const palette={occupancy:[['#37b794','0 free'],['#debe60','0.5'],['#e95b65','1 occupied']],
+    visibility:[['#192a3c','0 unseen'],['#ade2ff','1 observed']],
+    uncertainty:[['#192a3c','0 low error'],['#ffae4c','1 high error']]}[layer];
+  el('legend').replaceChildren();
+  for(const [color,label]of [...palette,['white','Robot footprint'],['#b1e8ff','Local path'],
+      ['#9aafbf','Own-body prediction (excluded)'],['#ffa63d','Learned blocking cell'],['#ff6868','Blocker with nearby depth returns']]){
+    const span=document.createElement('span'),mark=document.createElement('i');mark.style.background=color;
+    span.append(mark,document.createTextNode(label));el('legend').append(span);
+  }
+}
+function details() {
+  const f=state.frame,survey=f.head_survey,diagnostic=f.footprint_diagnostics;
+  const joint=state.robot?.joint_positions;
+  const cells=diagnostic?.cells||[],supported=cells.filter(c=>c.depth_supported).length;
+  const rows=[
+    ['Map pose',f.localized?`Committed · ${f.localized_streak} consecutive observations`:'Tentative · continue teleop'],
+    ['Map matches',(f.retrieval||[]).filter(a=>a.loaded&&a.verified).map(a=>a.id).join(', ')||'No verified map views'],
+    ['Local planner',f.planner_name||'Loading'],
+    ['Pose recovery',f.correction_recovery?.pending?`Holding · ${f.correction_recovery.stable_samples} stable views`:'Ready'],
+    ['Head survey',survey?.active?`Pass ${survey.pass} · view ${survey.view}/${survey.total} · ${survey.label}`:
+      survey?.settled_views?`${survey.settled_views} settled views completed`:'Idle'],
+    ['Corner observation',f.corner_observation?`${f.corner_observation.phase} · ${Math.round(100*(f.corner_observation.coverage||0))}% branch visibility`:'Cruise'],
+    ['Head pan / tilt',joint?.length>=11?`${(joint[9]*180/Math.PI).toFixed(1)}° / ${(joint[10]*180/Math.PI).toFixed(1)}°`:'Unavailable'],
+    ['Head action',state.robot?.head_action_state||'Unavailable'],
+    ['Footprint veto',state.control?.learned_blocked?'Learned occupancy':state.control?.depth_blocked?'Measured depth':'No veto reported'],
+    ['Own-body predictions',`${diagnostic?.ignored_current_body_cell_count||0} excluded from learned veto`],
+    ['Blocking cells',cells.length?`${diagnostic.blocking_cell_count} cells · ${supported}/${cells.length} shown cells have nearby depth returns`:'No blocking cells reported'],
+    ['Last relay velocity',state.robot?.v==null?'Unavailable':`${state.robot.v.toFixed(3)} m/s · ${(state.robot.w||0).toFixed(3)} rad/s`],
+    ['Handoff gate',state.ready?'Ready for explicit Start':state.gate],
+    ['Plan age limit',`${state.max_plan_age_s||.8} s · 0.3 s command expiry`],
+    ['Blind-zone fallback',f.blind_zone?'Assumed support used':'Not used'],
+    ['Inference',`${f.n_views||0} views · ${(f.compute_s||0).toFixed(2)} s`],
+    ['Goal arrival','Neutral camera XY within 0.4 m; heading not enforced'],
+    [state.playback?'Recorded phase':'Run state',state.playback?state.recorded_phase:state.phase]
+  ];
+  el('details').replaceChildren();
+  for(const [key,value]of rows){
+    const div=document.createElement('div'),dt=document.createElement('dt'),dd=document.createElement('dd');
+    dt.textContent=key;dd.textContent=value;div.append(dt,dd);el('details').append(div);
+  }
+}
+function showError(error){el('error').textContent=error.message||String(error);el('error').hidden=false;}
+function clockText(seconds){const n=Math.max(0,Math.floor(seconds));return `${Math.floor(n/60).toString().padStart(2,'0')}:${(n%60).toString().padStart(2,'0')}`;}
+async function render(next,force=false){
+  state=next;const recorded=Boolean(state.playback),f=state.frame||{};
+  el('phase').textContent=recorded?'REPLAY':state.phase.toUpperCase();
+  el('phase').style.color=state.phase==='active'&&!recorded?'#72dec0':'#f3c77c';
+  el('page-title').textContent=recorded?'Navigation replay':'Teleop → navigation';
+  document.title=recorded?'Recorded Stretch navigation':state.review?'Saved Stretch navigation run':'Live Stretch navigation';
+  el('handoff-note').hidden=Boolean(state.review||recorded);
+  el('page-footer').textContent=recorded||state.review?'Saved RGB, map and BEV · robot motion controls disabled':
+    'Live RGB + odometry · trained occupancy/observability heads · phone map preserved';
+  el('rgb-label').textContent=recorded||state.review?'RECORDED HEAD RGB':'LIVE ROBOT RGB';
+  el('goal').textContent=state.goal_keyframe;el('start').textContent=`Start navigation to ${state.goal_keyframe}`;
+  el('start').disabled=recorded||!state.ready;el('stop').disabled=recorded||state.phase==='stopped';
+  el('replay-open').disabled=liveState?.phase!=='stopped'||liveState?.replay_available===false;
+  el('replay-open').textContent=recorded?'Restart replay':'Replay recording';
+  el('count').textContent=state.processed;el('commands').textContent=state.motion_commands;
+  el('state-title').textContent=recorded?`Replay · recorded ${state.recorded_phase}`:
+    ({teleop:state.ready?'Ready for navigation handoff':'Teleop / relocalizing',preparing:'Preparing navigation',active:'CROSS navigation active',stopped:'Run stopped'})[state.phase];
+  el('reason').textContent=state.reason;
+  el('distance').textContent=f.goal_distance==null?'—':`${f.goal_distance.toFixed(2)} m`;
+  el('localization').textContent=f.localized?`Committed · streak ${f.localized_streak}`:'Localization pending';
+  el('route').textContent=f.route_ids?.length?`${f.route_ids.length} route keyframes · ${f.route_cost_m?.toFixed(1)} m graph route`:'Graph route pending';
+  if(recorded){
+    el('rgb').src=state.replay.rgb_url;
+    el('frame-note').textContent=`RGB frame ${state.replay.frame_idx} · map frame ${state.replay.map_frame??'pending'} · ${clockText(state.replay.time_s)}`;
+  }else if(state.capture_frame!=null){
+    el('rgb').src=`/api/rgb.jpg?t=${Date.now()}`;
+    el('frame-note').textContent=state.review?'Saved RGB · robot connections disabled':`Latest RGB · processed frame ${f.frame_idx??'pending'}`;
+  }
+  details();const key=`${recorded?replay.run:'current'}:${f.frame_idx}:${state.replay?.bev_frame??''}`;
+  if(force||drawn!==key){
+    drawn=key;
+    const provenance=recorded?(state.replay.bev_source==='reconstructed'?' · reconstructed offline':state.replay.bev_frame!=null?' · recorded':' · no BEV saved yet'):'';
+    el('plan-note').textContent=f.bev_size?`${f.bev_size*f.bev_res} × ${f.bev_size*f.bev_res} m · base frame · ${f.planner_name}${provenance}`:'Waiting for learned BEV';
+    drawBEV();await drawMap();
+  }
+}
+async function poll(){
+  if(polling)return;polling=true;
+  try{
+    const next=await api('/api/status');liveState=next;
+    if(replay.active&&next.phase!=='stopped'){
+      pauseReplay();replay.active=false;replay.pending=null;replay.generation++;
+      el('replay-panel').hidden=true;map=null;drawn=-1;
+    }
+    if(!map)map=await api('/api/map');
+    if(!replay.active)await render(next);
+    if(!replay.active&&next.phase!=='stopped')await api('/api/heartbeat',{});
+    el('error').hidden=true;
+  }catch(error){showError(error);el('start').disabled=true;}
+  finally{polling=false;}
+}
+function pauseReplay(){replay.playing=false;el('replay-play').textContent='Play';}
+function playReplay(){
+  if(!replay.active||!replay.manifest?.frames.length)return;
+  if(replay.index>=replay.manifest.frames.length-1)requestReplayFrame(0);
+  replay.anchorTime=replay.manifest.frames[replay.index].time_s;replay.anchorWall=performance.now();
+  replay.playing=true;el('replay-play').textContent='Pause';
+}
+function updateReplayControls(){
+  const m=replay.manifest;if(!m)return;
+  el('replay-seek').value=replay.index;
+  el('replay-clock').textContent=`${clockText(m.frames[replay.index]?.time_s||0)} / ${clockText(m.duration_s)}`;
+  el('replay-prev').disabled=replay.index<=0;el('replay-next').disabled=replay.index>=m.frames.length-1;
+  const b=state?.replay;
+  const note=b?.bev_frame==null?'No occupancy has been saved by this point.':
+    `BEV frame ${b.bev_frame} · ${b.bev_source==='reconstructed'?'reconstructed offline from recorded input':'recorded during the run'} · age ${Math.max(0,b.time_s-b.bev_time_s).toFixed(2)} s.`;
+  el('replay-note').textContent=`${m.frames.length} RGB frames · ${m.bev_frames} saved BEVs · motion controls disabled. ${note}${replay.index===m.frames.length-1?' Outcome: '+m.outcome:''}`;
+}
+async function requestReplayFrame(index){
+  if(!replay.active||!replay.manifest?.frames.length)return;
+  replay.index=Math.max(0,Math.min(replay.manifest.frames.length-1,index));
+  replay.pending=replay.index;updateReplayControls();
+  if(replay.busy)return;
+  replay.busy=true;const generation=replay.generation;
+  try{
+    while(replay.active&&generation===replay.generation&&replay.pending!==null){
+      const wanted=replay.pending;replay.pending=null;
+      const data=await api(`/api/replay/frame?run=${encodeURIComponent(replay.run)}&index=${wanted}`);
+      if(!replay.active||generation!==replay.generation)break;
+      if(replay.pending!==null&&replay.pending!==wanted)continue;
+      await render(data);updateReplayControls();
+    }
+  }catch(error){pauseReplay();showError(error);}
+  finally{
+    replay.busy=false;
+    if(replay.active&&replay.pending!==null)requestReplayFrame(replay.pending);
+  }
+}
+async function loadReplay(run,autoplay=true){
+  pauseReplay();const generation=++replay.generation;replay.pending=null;replay.run=run;
+  const manifest=await api(`/api/replay/manifest?run=${encodeURIComponent(run)}`);
+  if(generation!==replay.generation)return;replay.manifest=manifest;
+  if(!replay.manifest.frames.length)throw Error('This recording has no saved RGB frames');
+  const savedMap=await api(`/api/replay/map?run=${encodeURIComponent(run)}`);
+  if(generation!==replay.generation)return;map=savedMap;drawn=-1;
+  el('replay-seek').max=replay.manifest.frames.length-1;
+  el('replay-event').replaceChildren(new Option('Jump to event…',''));
+  for(const event of replay.manifest.events)el('replay-event').add(new Option(`${clockText(event.time_s)} · ${event.label}`,event.index));
+  replay.active=true;el('replay-run').value=run;el('replay-panel').hidden=false;
+  await requestReplayFrame(replay.manifest.start_index);if(autoplay)playReplay();
+}
+async function openReplay(){
+  if(liveState?.phase!=='stopped')return;
+  try{
+    const listing=await api('/api/replay/runs');
+    el('replay-run').replaceChildren();
+    for(const run of listing.runs)el('replay-run').add(new Option(run.id,run.id));
+    const key=listing.runs.find(r=>r.id===replay.run)?.id||listing.current_run||listing.runs[0]?.id;
+    if(!key)throw Error('No completed recordings are available yet');
+    el('replay-run').value=key;await loadReplay(key);
+  }catch(error){showError(error);}
+}
+async function closeReplay(){
+  pauseReplay();replay.active=false;replay.pending=null;replay.generation++;
+  el('replay-panel').hidden=true;map=await api('/api/map');drawn=-1;await render(liveState,true);
+}
+setInterval(()=>{
+  if(!replay.active||!replay.playing)return;
+  const m=replay.manifest,target=replay.anchorTime+(performance.now()-replay.anchorWall)/1000*Number(el('replay-speed').value);
+  let low=0,high=m.frames.length;
+  while(low<high){const mid=(low+high)>>1;if(m.frames[mid].time_s<=target)low=mid+1;else high=mid;}
+  const index=Math.max(0,low-1);if(index!==replay.index)requestReplayFrame(index);
+  if(target>=m.duration_s)pauseReplay();
+},80);
+el('start').onclick=async()=>{if(replay.active)return;el('start').disabled=true;try{await api('/api/start',{});await poll();}catch(e){el('error').textContent=e.message;el('error').hidden=false;}};
+el('stop').onclick=async()=>{if(replay.active)return;try{await api('/api/stop',{});await poll();}catch(e){el('error').textContent=e.message;el('error').hidden=false;}};
+el('layer').onchange=drawBEV;
+el('bev-range').onchange=drawBEV;
+el('top').onclick=()=>Plotly.relayout(el('global-map'),{'scene.camera':{eye:{x:0,y:0,z:2.7},up:{x:0,y:1,z:0}}});el('reset').onclick=()=>Plotly.relayout(el('global-map'),{'scene.camera':initial});
+document.querySelectorAll('[data-layer]').forEach(input=>input.onchange=()=>{if(!plotReady)return;const plot=el('global-map'),ids=plot.data.map((t,i)=>t.meta?.layer===input.dataset.layer?i:-1).filter(i=>i>=0);Plotly.relayout(plot,{'scene.camera':plot._fullLayout.scene._scene.getCamera()}).then(()=>Plotly.restyle(plot,{visible:input.checked},ids));});
+el('export').onclick=()=>{const url=URL.createObjectURL(new Blob([JSON.stringify(state,null,2)],{type:'application/json'})),a=document.createElement('a');a.href=url;a.download='stretch-cross-live.json';a.click();setTimeout(()=>URL.revokeObjectURL(url),1000);};
+el('replay-open').onclick=openReplay;
+el('replay-close').onclick=()=>closeReplay().catch(showError);
+el('replay-run').onchange=()=>loadReplay(el('replay-run').value).catch(showError);
+el('replay-play').onclick=()=>replay.playing?pauseReplay():playReplay();
+el('replay-prev').onclick=()=>{pauseReplay();requestReplayFrame(replay.index-1);};
+el('replay-next').onclick=()=>{pauseReplay();requestReplayFrame(replay.index+1);};
+el('replay-seek').oninput=()=>{pauseReplay();requestReplayFrame(Number(el('replay-seek').value));};
+el('replay-event').onchange=()=>{if(el('replay-event').value!==''){pauseReplay();requestReplayFrame(Number(el('replay-event').value));}};
+el('replay-speed').onchange=()=>{if(replay.playing)playReplay();};
+poll();setInterval(poll,650);

cases/20261026_goal1012_05/code/lite3_ROS/web_console/stretch_nav_control.py

@@ -0,0 +1,259 @@
+"""Execution gates and transforms for the live Stretch/CROSS adapter, without I/O."""
+import math
+from dataclasses import dataclass
+from pathlib import Path
+
+import numpy as np
+
+DEFAULT_MAX_PLAN_AGE = 2.0
+DEFAULT_PLAN_HOLD_SECONDS = 8.0
+HEAD_VIEW_TIMEOUT = 20.0
+HEAD_SURVEY_TIMEOUT = 120.0
+
+
+def wrap(angle):
+    return math.atan2(math.sin(angle), math.cos(angle))
+
+
+def alignment_correction(previous, current, base):
+    """Map-pose correction at the current base, independent of the odom origin.
+
+    Alignment translations describe the coordinate origin. A small rotation
+    about a distant robot can move that origin substantially without moving
+    the estimated robot position. Compare both alignments at the same base.
+    """
+    previous, current, base = [np.asarray(value, dtype=float) for value in (previous, current, base)]
+    if any(value.shape != (4, 4) or not np.isfinite(value).all() for value in (previous, current, base)):
+        raise ValueError('Invalid map alignment or base transform')
+    before, after = previous @ base, current @ base
+    distance = float(np.linalg.norm(after[:3, 3] - before[:3, 3]))
+    rotation = previous[:3, :3].T @ current[:3, :3]
+    angle = float(np.arccos(np.clip((np.trace(rotation) - 1.) / 2., -1., 1.)))
+    return distance, angle
+
+
+def stationary_head_command(plan, robot, *, now, robot_received):
+    """Renew a bounded head-only observation from current robot feedback.
+
+    Its target, frozen odometry anchor and deadline still come from planning.
+    Renewing never changes that deadline, advances a view, or permits driving.
+    The returned frame ID is checked against source time by the existing relay.
+    """
+    if (not plan or not plan.get('observation_hold') or plan.get('head_target') is None
+            or plan.get('head_deadline') is None):
+        return None, ''
+    if plan.get('scan_w', 0.) != 0.:
+        return None, ''  # Any base rotation still needs a fresh driving plan.
+    try:
+        deadline = float(plan['head_deadline'])
+        target = np.asarray(plan['head_target'], float)
+        anchor = np.asarray(plan['head_anchor'], float)
+        pose = np.asarray(robot['base_pose'], float)
+        joint = np.asarray(robot['joint_positions'], float)
+        status_age = now - robot_received
+        sensor_age, tf_age = float(robot['sensor_age']), float(robot['tf_age'])
+        frame_id = int(robot['frame_id'])
+    except (KeyError, TypeError, ValueError, OverflowError):
+        return None, 'head observation feedback unavailable'
+    if (not np.isfinite(deadline) or target.shape != (2,) or anchor.shape != (4, 4)
+            or not np.isfinite(target).all() or not np.isfinite(anchor).all()
+            or not -2.8 <= target[0] <= .65 or not -1.4 <= target[1] <= 0.):
+        return None, 'invalid head observation request'
+    if now >= deadline:
+        return None, 'head observation deadline expired'
+    if (pose.shape != (3,) or joint.ndim != 1 or len(joint) < 11
+            or not np.isfinite(pose).all() or not np.isfinite(joint).all()
+            or not np.isfinite([status_age, sensor_age, tf_age]).all()
+            or not 0. <= status_age <= .5 or not -.02 <= sensor_age + status_age < .75
+            or not -.02 <= tf_age + status_age < .5 or frame_id < 0):
+        return None, 'head observation feedback unavailable'
+    yaw = math.atan2(anchor[1, 0], anchor[0, 0])
+    if np.linalg.norm(pose[:2] - anchor[:2, 3]) > .05 or abs(wrap(pose[2] - yaw)) > math.radians(5):
+        # A directed corner look can follow a permitted base rotation. Hold
+        # until its next image supplies the updated pose/extrinsic. A survey
+        # has a confirmed stationary origin and must not re-anchor that way.
+        return None, ('base moved during head observation' if plan.get('stationary_survey') else
+                      'head observation feedback unavailable')
+    if robot.get('head_enabled') is not True:
+        return None, 'leased head control unavailable'
+    return {'frame_id': frame_id, 'head_target': target.tolist(), 'v': 0., 'w': 0.}, ''
+
+
+def execution_gate(plan, robot, *, now, robot_received, heartbeat, state='active',
+                   max_plan_age=DEFAULT_MAX_PLAN_AGE):
+    """Require fresh planning evidence and CROSS's stable map commitment.
+
+    CROSS carries its committed pose through map-match gaps using odometry.
+    Retrieval verification is diagnostic, not a separate execution deadline.
+    The PC plan-age gate starts at receipt. Independently, the robot lease
+    validates full source-image age, including transport and compute time.
+    A bounded stationary head target instead uses current sensor/TF/joint
+    feedback; it cannot authorize base movement or mark a view as settled.
+    """
+    if state not in ('preparing', 'active'):
+        return 'teleop owns control'
+    if now - heartbeat > 5.:
+        return 'viewer heartbeat expired'
+    if robot is None or now - robot_received > .5:
+        return 'robot status stale'
+    if robot.get('is_runstopped') is not False or robot.get('is_homed') is not True:
+        return 'robot run-stopped or unhomed'
+    if not robot.get('posture_ok'):
+        return 'arm must already be retracted'
+    if robot.get('latched'):
+        return 'robot stop latched'
+    if robot.get('head_error'):
+        return 'head observation fault: ' + str(robot['head_error'])
+    if state == 'active' and not robot.get('healthy'):
+        return 'robot state/camera/TF unavailable'
+    if plan is None:
+        return 'sensor/plan evidence stale'
+    if not np.isfinite([plan['input_received'], plan.get('goal_distance', math.nan)]).all():
+        return 'invalid plan timing or goal'
+    head_only = (plan.get('observation_hold') and plan.get('head_target') is not None
+                 and plan.get('head_deadline') is not None and plan.get('scan_w', 0.) == 0.)
+    if not head_only and now - plan['input_received'] > max_plan_age:
+        return 'sensor/plan evidence stale'
+    if not plan.get('localized') or plan.get('localized_streak', 0) < 3:
+        return 'waiting for stable committed localization'
+    if plan.get('recovery_pending'):
+        return 'map correction recovery'
+    if plan.get('arrived') and now - plan['input_received'] <= max_plan_age:
+        return 'goal reached'
+    head_command, head_fault = stationary_head_command(plan, robot, now=now, robot_received=robot_received)
+    if head_fault:
+        return head_fault
+    if head_command is not None:
+        return ''
+    if now - plan['input_received'] > max_plan_age:
+        return 'sensor/plan evidence stale'
+    if not plan.get('route_ids'):
+        return 'no global route'
+    if plan.get('observation_hold'):
+        if plan.get('head_target') is not None and robot.get('head_enabled') is not True:
+            return 'leased head control unavailable'
+        return ''
+    if plan.get('planner_status') == 2 and plan.get('scan_authorized'):
+        return ''
+    if plan.get('planner_status') == 2 or len(plan.get('path_odom', [])) < 2:
+        return 'no executable local path'
+    return ''
+
+
+@dataclass
+class PlanWait:
+    """Hold at zero through a short perception gap, without re-arming the lease.
+
+    Physical faults and lost localization never qualify for a transient hold.
+    A brief missing status stream also permits only zero velocity. An active
+    run can continue only after fresh robot status and its current plan pass
+    the full gate again. Sustained gaps end the run.
+    """
+    timeout: float = DEFAULT_PLAN_HOLD_SECONDS
+    since: float | None = None
+
+    def holds(self, reason, now):
+        if reason not in ('sensor/plan evidence stale', 'no executable local path', 'robot status stale',
+                          'head observation feedback unavailable'):
+            self.since = None
+            return False
+        if self.since is None:
+            self.since = now
+        return now - self.since < self.timeout
+
+
+def competing_controllers(proc_root='/proc'):
+    """Identify known local base clients that publish even while their keys are up."""
+    found = []
+    for entry in Path(proc_root).iterdir():
+        if not entry.name.isdecimal():
+            continue
+        try:
+            args = (entry / 'cmdline').read_bytes().split(b'\0')
+            words = [a.decode(errors='replace') for a in args if a]
+        except (OSError, PermissionError):
+            continue
+        if not words or not Path(words[0]).name.startswith('python'):
+            continue
+        for word in words[1:]:
+            if (Path(word).name in ('teleop.py', 'manual_teleop.py', 'depth_nav_live.py')
+                    or word == 'stretch.app.manual_teleop'):
+                found.append({'pid': int(entry.name), 'client': Path(word).name})
+                break
+    return found
+
+
+def remaining_path(path_world, pose):
+    """Trim a saved odom path at the nearest segment and return forward/left."""
+    points = np.asarray(path_world, dtype=float).reshape(-1, 2)
+    pose = np.asarray(pose, dtype=float)
+    if len(points) < 2 or not np.isfinite(points).all() or not np.isfinite(pose).all():
+        return np.empty((0, 2))
+    delta = np.diff(points, axis=0)
+    t = np.clip(np.sum((pose[:2] - points[:-1]) * delta, axis=1)
+                / np.maximum(np.sum(delta ** 2, axis=1), 1e-9), 0., 1.)
+    projected = points[:-1] + t[:, None] * delta
+    k = int(np.argmin(np.linalg.norm(projected - pose[:2], axis=1)))
+    ahead = np.vstack([projected[k], points[k + 1:]]) - pose[:2]
+    c, s = np.cos(pose[2]), np.sin(pose[2])
+    return ahead @ np.array([[c, -s], [s, c]])
+
+
+def depth_obstacles(depth, K, camera, base_z=0.):
+    """Current measured returns for a short-horizon veto, separate from CROSS planning."""
+    depth, K, camera = map(np.asarray, (depth, K, camera))
+    vv, uu = np.mgrid[0:depth.shape[0]:3, 0:depth.shape[1]:3]
+    z = depth[::3, ::3]
+    valid = np.isfinite(z) & (z > .12) & (z < 3.)
+    if valid.sum() < 100:
+        raise ValueError('insufficient measured depth for execution guard')
+    z, uu, vv = z[valid], uu[valid], vv[valid]
+    pc = np.column_stack([(uu - K[0, 2]) * z / K[0, 0],
+                          (vv - K[1, 2]) * z / K[1, 1], z])
+    world = pc @ camera[:3, :3].T + camera[:3, 3]
+    return world[(world[:, 2] > base_z + .12) & (world[:, 2] < base_z + 1.8), :2]
+
+
+def depth_veto(points_world, pose, v, w, *, horizon=1., half_width=.23, half_length=.23):
+    """Veto a 1 s swept rectangle when measured points intersect it.
+
+    The starting footprint is excluded as a robot self mask. This is a veto of
+    known returns, not evidence that unobserved near-field space is free.
+    """
+    points, pose = np.asarray(points_world), np.asarray(pose)
+    c, s = np.cos(pose[2]), np.sin(pose[2])
+    local = (points - pose[:2]) @ np.array([[c, -s], [s, c]])
+    local = local[(np.abs(local[:, 0]) > .20) | (np.abs(local[:, 1]) > .20)]
+    for t in np.linspace(0., horizon, 16):
+        theta = w * t
+        center = np.array([v * t, 0.]) if abs(w) < 1e-6 else np.array([
+            v / w * np.sin(theta), v / w * (1. - np.cos(theta))])
+        c, s = np.cos(theta), np.sin(theta)
+        relative = (local - center) @ np.array([[c, -s], [s, c]])
+        inside = (np.abs(relative[:, 0]) <= half_length) & (np.abs(relative[:, 1]) <= half_width)
+        if inside.sum() >= 3:
+            return True
+    return False
+
+
+def attachment_clear(points_world, pose, target_xy):
+    """Reject a straight local attachment intersecting measured obstacle returns.
+
+    Use the execution guard's footprint and robot self mask. Unknown space is
+    left to the native local planner; this check only vetoes measured returns.
+    """
+    points, pose, target = map(np.asarray, (points_world, pose, target_xy))
+    if not all(np.isfinite(value).all() for value in (points, pose, target)):
+        raise ValueError('Invalid attachment geometry')
+    c, s = np.cos(pose[2]), np.sin(pose[2])
+    rotation = np.array([[c, -s], [s, c]])
+    local = (points - pose[:2]) @ rotation
+    local = local[(np.abs(local[:, 0]) > .20) | (np.abs(local[:, 1]) > .20)]
+    end = (target - pose[:2]) @ rotation
+    steps = max(2, int(np.ceil(np.linalg.norm(end) / .025)) + 1)
+    for fraction in np.linspace(0., 1., steps):
+        relative = local - fraction * end
+        inside = (np.abs(relative[:, 0]) <= .23) & (np.abs(relative[:, 1]) <= .23)
+        if inside.sum() >= 3:
+            return False
+    return True

cases/20261026_goal1012_05/code/lite3_ROS/web_console/stretch_nav_footprint.py

@@ -0,0 +1,87 @@
+"""Explain the learned command-footprint veto without changing its thresholds."""
+
+import math
+
+import numpy as np
+
+
+def command_footprint_report(grid, planning_base, pose, v, w, horizon=1.0, max_cells=12):
+    """Use the execution guard's exact sweep; return its first blocking cells.
+
+    Cell centres are reported in the planning base and continuous odom frames.
+    Learned predictions under the image-time body are excluded, matching native
+    cross_nav's own-footprint rule. Newly swept space and the separate measured
+    depth veto retain their checks. Ignored predictions remain in diagnostics.
+    """
+    prob, obs = np.asarray(grid["prob"]), np.asarray(grid["obs"])
+    n, res = len(prob), float(grid["res"])
+    if prob.shape != (n, n) or obs.shape != prob.shape or res <= 0:
+        raise ValueError("Invalid command footprint grid")
+    offsets = np.array(np.meshgrid(np.linspace(-0.23, 0.23, 11), np.linspace(-0.23, 0.23, 11))).reshape(2, -1).T
+    yaw = math.atan2(planning_base[1, 0], planning_base[0, 0])
+    c, s = math.cos(yaw), math.sin(yaw)
+    world_to_plan = np.array([[c, -s], [s, c]])
+    c, s = math.cos(pose[2]), math.sin(pose[2])
+    world_to_robot = np.array([[c, -s], [s, c]])
+    ignored = set()
+
+    def cells_at(indices):
+        cells = []
+        for row, col in indices:
+            body_xy = (n / 2 - np.array([row, col]) - 0.5) * res
+            point = body_xy @ world_to_plan.T + planning_base[:2, 3]
+            cells.append({
+                "row": int(row), "column": int(col), "grid_body_xy": body_xy.tolist(),
+                "world_xy": point.tolist(), "probability": float(prob[row, col]),
+                "observability": float(obs[row, col]),
+                "uncertainty": float(grid["err"][row, col]) if "err" in grid else None,
+            })
+        return cells
+
+    def result(clear, reason, blocked=(), t=None):
+        return {"clear": clear, "reason": reason, "sweep_time_s": t,
+                "blocking_cell_count": len(blocked), "cells": cells_at(blocked[:max_cells]),
+                "ignored_current_body_cell_count": len(ignored),
+                "self_cells": cells_at(sorted(ignored)[:min(4, max_cells)])}
+
+    for t in np.linspace(0.0, horizon, 16):
+        angle = w * t
+        center = (
+            np.array([v * t, 0.0])
+            if abs(w) < 1e-6
+            else np.array([v / w * math.sin(angle), v / w * (1.0 - math.cos(angle))])
+        )
+        c, s = math.cos(angle), math.sin(angle)
+        local = offsets @ np.array([[c, s], [-s, c]]) + center
+        world = local @ world_to_robot.T + pose[:2]
+        fl = (world - planning_base[:2, 3]) @ world_to_plan
+        rc = np.floor(n / 2 - fl / res).astype(int)
+        if ((rc < 0) | (rc >= n)).any():
+            return result(False, "outside learned grid", t=float(t))
+        occupied = (prob[rc[:, 0], rc[:, 1]] > 0.6) & (obs[rc[:, 0], rc[:, 1]] > 0.5)
+        centres = (n / 2 - rc - 0.5) * res
+        # Freeze this exemption at the image-time planning base. Moving into
+        # a predicted obstacle after that image must never mask the obstacle.
+        own_body = (np.abs(centres) <= 0.23).all(1)
+        ignored.update(map(tuple, rc[occupied & own_body]))
+        if (occupied & ~own_body).any():
+            blocked = np.unique(rc[occupied & ~own_body], axis=0)
+            return result(False, "learned occupancy", blocked, float(t))
+    return result(True, "clear")
+
+
+def depth_support(report, points_world):
+    """Label nearby measured returns; absence of returns is not free-space proof."""
+    points = np.asarray(points_world, float).reshape(-1, 2)
+    def support(cells):
+        result = []
+        for cell in cells:
+            distances = np.linalg.norm(points - cell["world_xy"], axis=1)
+            count = int((distances <= 0.10).sum())
+            result.append({**cell, "nearby_depth_returns": count, "depth_supported": count >= 3,
+                           "nearest_depth_return_m": float(distances.min()) if len(distances) else None})
+        return result
+    cells = support(report["cells"])
+    return {**report, "cells": cells, "self_cells": support(report.get("self_cells", [])),
+            "depth_supported_cells": sum(c["depth_supported"] for c in cells),
+            "depth_note": "Nearby obstacle returns only; no returns does not establish free space"}

cases/20261026_goal1012_05/code/lite3_ROS/web_console/stretch_nav_geometry.py

@@ -0,0 +1,99 @@
+"""Measured-depth BEV baseline for passive CROSS planner inspection.
+
+This is explicitly not CROSS's learned occupancy or observability head. Floor
+height is an odometry-frame prior. The output probabilities are fixed planning
+encodings, not calibrated predictions or proof of safe execution.
+"""
+import cv2
+import numpy as np
+
+
+def body_yaw(transform):
+    return float(np.arctan2(transform[1, 0], transform[0, 0]))
+
+
+def body_to_world(points, base):
+    yaw = body_yaw(base)
+    rotation = np.array([[np.cos(yaw), -np.sin(yaw)], [np.sin(yaw), np.cos(yaw)]])
+    return np.asarray(points) @ rotation.T + base[:2, 3]
+
+
+def world_to_body(point, base):
+    yaw = body_yaw(base)
+    rotation = np.array([[np.cos(yaw), -np.sin(yaw)], [np.sin(yaw), np.cos(yaw)]])
+    return (np.asarray(point)[:2] - base[:2, 3]) @ rotation
+
+
+def measured_bev(depth, K, camera, base, *, size=200, res=.05, max_depth=3.,
+                 floor_z=0., obstacle_min=.2, obstacle_max=1.6):
+    """Robot-centered (rows forward, columns right) occupancy encoding and visibility.
+
+    Floor visibility is tested against the current depth image, including
+    occlusion. Elevated returns set occupancy directly. Unobserved cells stay
+    unknown. Actual base/camera transforms account for head pan, tilt and offset.
+    """
+    depth = np.asarray(depth, dtype=float)
+    K, camera, base = [np.asarray(value, dtype=float) for value in (K, camera, base)]
+    if depth.ndim != 2 or K.shape != (3, 3) or camera.shape != (4, 4) or base.shape != (4, 4):
+        raise ValueError('Invalid depth or calibrated transforms')
+    if not np.isfinite(np.r_[K.ravel(), camera.ravel(), base.ravel(), floor_z]).all():
+        raise ValueError('Nonfinite geometry')
+    rr, cc = np.mgrid[:size, :size]
+    fl = np.stack([(size / 2 - rr - .5) * res, (size / 2 - cc - .5) * res], -1)
+    xy = body_to_world(fl.reshape(-1, 2), base)
+    ground = np.column_stack([xy, np.full(len(xy), floor_z)])
+    ground_camera = (ground - camera[:3, 3]) @ camera[:3, :3]
+    z = ground_camera[:, 2]
+    forward = (z > .1) & (z <= max_depth)
+    denominator = np.where(forward, z, 1.)
+    u = np.rint(K[0, 0] * ground_camera[:, 0] / denominator + K[0, 2]).astype(int)
+    v = np.rint(K[1, 1] * ground_camera[:, 1] / denominator + K[1, 2]).astype(int)
+    h, w = depth.shape
+    inside = forward & (u >= 0) & (u < w) & (v >= 0) & (v < h)
+    sample = np.full(len(xy), np.nan)
+    sample[inside] = depth[v[inside], u[inside]]
+    visible = inside & np.isfinite(sample) & (sample > .1) & (sample <= max_depth)
+    visible &= sample >= z - .08
+    observed = visible.reshape(size, size).astype(np.float32)
+    probability = np.where(observed > 0, .01, .5).astype(np.float32)
+
+    vv, uu = np.mgrid[0:h:3, 0:w:3]
+    zz = depth[::3, ::3]
+    valid = np.isfinite(zz) & (zz > .1) & (zz <= max_depth)
+    zz, uu, vv = zz[valid], uu[valid], vv[valid]
+    pc = np.column_stack([(uu - K[0, 2]) * zz / K[0, 0],
+                          (vv - K[1, 2]) * zz / K[1, 1], zz])
+    points = pc @ camera[:3, :3].T + camera[:3, 3]
+    height = points[:, 2] - floor_z
+    yaw = body_yaw(base)
+    d = points[:, :2] - base[:2, 3]
+    forward_xy = d[:, 0] * np.cos(yaw) + d[:, 1] * np.sin(yaw)
+    left_xy = -d[:, 0] * np.sin(yaw) + d[:, 1] * np.cos(yaw)
+    row = np.floor(size / 2 - forward_xy / res).astype(int)
+    col = np.floor(size / 2 - left_xy / res).astype(int)
+    in_grid = (row >= 0) & (row < size) & (col >= 0) & (col < size)
+    obstacle = ((height >= obstacle_min) & (height <= obstacle_max)) | (height < -.2)
+    selected = in_grid & obstacle
+    probability[row[selected], col[selected]] = .99
+    observed[row[selected], col[selected]] = 1.
+    heights = np.full((size, size), -np.inf, np.float32)
+    np.maximum.at(heights, (row[in_grid], col[in_grid]), height[in_grid])
+    return {'prob': probability, 'obs': observed, 'height': heights, 'res': res,
+            'points_odom': points[::max(1, len(points) // 2500)],
+            'source': 'measured_depth_geometry', 'floor_z_odom': float(floor_z),
+            'occupied_cells': int((probability > .6).sum()),
+            'observed_cells': int((observed > .5).sum())}
+
+
+def bev_png(probability, observed, layer='occupancy'):
+    p, v = np.asarray(probability), np.asarray(observed)
+    image = np.full((*p.shape, 3), (33, 49, 64), np.uint8)
+    if layer == 'occupancy':
+        image[v > .5] = (63, 192, 159)
+        image[p > .6] = (239, 110, 105)
+    else:
+        image[v > .5] = (68, 166, 218)
+    success, encoded = cv2.imencode('.png', image[..., ::-1])
+    if not success:
+        raise OSError('Could not encode BEV')
+    return encoded.tobytes()

cases/20261026_goal1012_05/code/lite3_ROS/web_console/stretch_nav_learned.py

@@ -0,0 +1,57 @@
+"""Place native camera-centred CROSS BEVs in the recorded robot base frame."""
+import cv2
+import numpy as np
+
+from .stretch_nav_geometry import body_yaw
+
+
+def reproject_bev(prob, obs, err, rotation_bev_camera, camera, base, res):
+    """Resample at cell centres, preserving probabilities and unknown borders.
+
+    Native axes are right/forward/up at the camera. The planner consumes a grid
+    centred on the base, with rows forward and columns right of the base heading.
+    Both frames use recorded odom up; camera height therefore cancels in XY.
+    """
+    arrays = [np.asarray(a, dtype=np.float32) for a in (prob, obs, err)]
+    n = arrays[0].shape[0]
+    if any(a.shape != (n, n) or not np.isfinite(a).all() for a in arrays):
+        raise ValueError('Learned BEV layers must be finite matching square grids')
+    camera, base, rotation = map(np.asarray, (camera, base, rotation_bev_camera))
+    if not all(np.isfinite(a).all() for a in (camera, base, rotation)) or res <= 0:
+        raise ValueError('Invalid learned BEV transform or resolution')
+    yaw = body_yaw(base)
+    # Destination pixel (column, row) -> base forward/left -> odom -> camera BEV.
+    dst = np.array([[0., 0.], [n - 1., 0.], [0., n - 1.]], np.float32)
+    forward = (n / 2 - dst[:, 1] - .5) * res
+    left = (n / 2 - dst[:, 0] - .5) * res
+    world = np.column_stack([
+        base[0, 3] + np.cos(yaw) * forward - np.sin(yaw) * left,
+        base[1, 3] + np.sin(yaw) * forward + np.cos(yaw) * left,
+        np.full(3, camera[2, 3]),
+    ])
+    native = (world - camera[:3, 3]) @ camera[:3, :3] @ rotation.T
+    src = np.column_stack([native[:, 0] / res + n / 2 - .5,
+                           n / 2 - native[:, 1] / res - .5]).astype(np.float32)
+    affine = cv2.getAffineTransform(dst, src)
+    warped = [cv2.warpAffine(a, affine, (n, n),
+        flags=cv2.INTER_LINEAR | cv2.WARP_INVERSE_MAP, borderMode=cv2.BORDER_CONSTANT,
+        borderValue=border) for a, border in zip(arrays, (.5, 0., 1.))]
+    return {'prob': warped[0], 'obs': warped[1], 'err': warped[2],
+            'base_pixel_to_camera_pixel': affine}
+
+
+def learned_png(prob, obs, err, layer):
+    """Continuous, explicitly separate occupancy/observability/error scales."""
+    values = {'occupancy': prob, 'visibility': obs, 'uncertainty': err}[layer]
+    palette = {
+        'occupancy': [(55, 183, 148), (222, 190, 96), (233, 91, 101)],
+        'visibility': [(25, 42, 60), (48, 128, 182), (173, 226, 255)],
+        'uncertainty': [(25, 42, 60), (155, 112, 70), (255, 174, 76)],
+    }[layer]
+    p = np.clip(np.asarray(values, dtype=np.float32), 0., 1.)
+    image = np.stack([np.interp(p, [0., .5, 1.], np.array(palette)[:, channel])
+                      for channel in range(3)], axis=-1).astype(np.uint8)
+    success, encoded = cv2.imencode('.png', image[..., ::-1])
+    if not success:
+        raise OSError('Could not encode learned BEV')
+    return encoded.tobytes()

cases/20261026_goal1012_05/code/lite3_ROS/web_console/stretch_nav_recovery.py

@@ -0,0 +1,393 @@
+"""Odometry-frame recovery and corner observation for the Stretch adapter.
+
+No hardware or CROSS imports. A moving head changes the observation transform,
+never the neutral camera reference used to attach the base to the saved route.
+"""
+
+import math
+from collections import deque
+from dataclasses import dataclass
+
+import numpy as np
+
+from .stretch_nav_control import HEAD_VIEW_TIMEOUT, alignment_correction, wrap
+from .stretch_nav_geometry import world_to_body
+
+
+def camera_in_base(camera, base):
+    """T_base_camera from the two TF poses at the *image* timestamp."""
+    camera, base = np.asarray(camera, float), np.asarray(base, float)
+    for value in (camera, base):
+        if value.shape != (4, 4) or not np.isfinite(value).all():
+            raise ValueError("Invalid timestamped camera/base TF")
+        if (
+            not np.allclose(value[3], [0, 0, 0, 1], atol=1e-5)
+            or not np.allclose(value[:3, :3].T @ value[:3, :3], np.eye(3), atol=1e-4)
+            or np.linalg.det(value[:3, :3]) < 0.99
+        ):
+            raise ValueError("Non-rigid camera/base TF")
+    return np.linalg.inv(base) @ camera
+
+
+def camera_yaw(camera_base):
+    forward = np.asarray(camera_base)[:3, 2]
+    if np.linalg.norm(forward[:2]) < 0.2:
+        raise ValueError("Camera points too vertically for a corner scan")
+    return math.atan2(forward[1], forward[0])
+
+
+def camera_pitch(camera_base):
+    forward = np.asarray(camera_base)[:3, 2]
+    if not np.isfinite(forward).all() or np.linalg.norm(forward) < 0.9:
+        raise ValueError("Invalid camera direction")
+    return math.atan2(forward[2], np.linalg.norm(forward[:2]))
+
+
+def clear_goal_cache(episode):
+    """Discard goal-specific routes, retaining occupancy, bumps and metric scale."""
+    episode.route, episode.route_age = None, 0
+    episode.no_route, episode.side, episode.expect = 0, 0.0, 0.0
+
+
+class MeasuredObstacleMemory:
+    """Short odometry-frame depth history, so a pan does not erase the front.
+
+    This veto retains known returns for 12 seconds. Native occupancy memory
+    remains separate; retained moving-object returns may delay a command.
+    """
+
+    def __init__(self, horizon=12.0):
+        self.horizon, self.frames = horizon, deque()
+        self.preserve_from = None
+
+    def observing(self, active, now):
+        """Keep pre-scan returns throughout a stationary survey and its exit."""
+        if active and self.preserve_from is None:
+            self.preserve_from = now - self.horizon
+        elif not active and self.preserve_from is not None:
+            if self.frames:
+                self.frames = deque([(now, np.vstack([p for _, p in self.frames]))])
+            self.preserve_from = None
+
+    def update(self, points, now, origin):
+        points = np.asarray(points, float).reshape(-1, 2)
+        if not np.isfinite(points).all():
+            raise ValueError("Nonfinite measured obstacle history")
+        if len(points):
+            cells, counts = np.unique(np.round(points / 0.02), axis=0, return_counts=True)
+            points = np.repeat(cells, np.minimum(counts, 3), axis=0) * 0.02
+        self.frames.append((now, points))
+        cutoff = now - self.horizon if self.preserve_from is None else self.preserve_from
+        while self.frames and self.frames[0][0] < cutoff:
+            self.frames.popleft()
+        combined = np.vstack([p for _, p in self.frames])
+        combined = combined[np.linalg.norm(combined - np.asarray(origin)[:2], axis=1) < 3.5]
+        cells, counts = np.unique(np.round(combined / 0.02), axis=0, return_counts=True)
+        return np.repeat(cells, np.minimum(counts, 3), axis=0) * 0.02
+
+
+@dataclass
+class CorrectionRecovery:
+    timeout: float = 12.0
+    pending: bool = False
+    since: float = 0.0
+    stable_since: float = 0.0
+    samples: int = 0
+    anchor: object = None
+
+    def update(self, previous, current, base, now):
+        """Hold after a large correction, then require a coherent new alignment.
+
+        Compare at the current base to avoid odom-origin artifacts. The anchor
+        also catches a succession of small corrections that add up to drift.
+        """
+        distance, angle = (0.0, 0.0) if previous is None else alignment_correction(previous, current, base)
+        large = distance > 0.5 or angle > math.radians(25)
+        started = large and not self.pending
+        if started:
+            self.pending, self.since = True, now
+            self.anchor, self.stable_since, self.samples = np.asarray(current).copy(), now, 0
+        if self.pending:
+            if now - self.since > self.timeout:
+                raise RuntimeError("Map pose correction did not settle within 12 s")
+            spread, turn = alignment_correction(self.anchor, current, base)
+            if large or distance > 0.12 or angle > math.radians(5) or spread > 0.20 or turn > math.radians(8):
+                self.anchor, self.stable_since, self.samples = np.asarray(current).copy(), now, 0
+            else:
+                self.samples += 1
+            if self.samples >= 3 and now - self.stable_since >= 0.6:
+                self.pending = False
+        return {
+            "started": started,
+            "large": large,
+            "pending": self.pending,
+            "distance_m": distance,
+            "rotation_deg": math.degrees(angle),
+            "deadline": self.since + self.timeout,
+            "stable_samples": self.samples,
+        }
+
+
+def route_subgoal(route_xy, base, goal_xy, lookahead=1.5):
+    """Arc-length subgoal, stopping short of an upcoming sharp bend."""
+    xy = np.asarray(route_xy, float).reshape(-1, 2)
+    origin = np.asarray(base)[:2, 3]
+    if not len(xy):
+        xy = np.asarray(goal_xy, float)[None, :2]
+    xy = np.vstack([origin, xy])
+    xy = xy[np.r_[True, np.linalg.norm(np.diff(xy, axis=0), axis=1) > 0.03]]
+    if len(xy) == 1:
+        return {"target": xy[0], "corner": None}
+    arc = np.r_[0.0, np.cumsum(np.linalg.norm(np.diff(xy, axis=0), axis=1))]
+
+    def at(d):
+        return np.array([np.interp(d, arc, xy[:, k]) for k in (0, 1)])
+
+    # Sample over a finite baseline: adjacent camera poses alone give noisy
+    # curvature. Include the bend's actual location, rather than cutting it.
+    bends = []
+    for distance in np.arange(0.35, min(arc[-1] - 0.35, 1.8), 0.05):
+        if distance - 0.3 < arc[1]:
+            continue  # The base->first-camera connector is not an aisle bend.
+        point = at(distance)
+        before, after = point - at(distance - 0.3), at(distance + 0.35) - point
+        angle = math.atan2(before[0] * after[1] - before[1] * after[0], np.dot(before, after))
+        if abs(angle) >= math.radians(40):
+            bends.append((abs(angle), distance, point, angle))
+        elif bends:
+            break  # Only the first bend, not a sharper turn much farther away.
+    if bends:
+        _, distance, point, angle = max(bends, key=lambda v: v[0])
+        after = at(min(arc[-1], distance + 0.6)) - point
+        approach = at(max(0.0, distance - 0.30))
+        body_corner = world_to_body(point, base)
+        if abs(math.atan2(body_corner[1], body_corner[0])) > math.radians(30):
+            # The recorded camera trail may lie to one side of the base. Peek
+            # from the incoming aisle before asking for lateral displacement.
+            forward = base[:2, 0] / np.linalg.norm(base[:2, 0])
+            approach = origin + max(0.0, body_corner[0] - 0.30) * forward
+        return {
+            "target": approach,
+            "corner": point,
+            "outgoing": after / np.linalg.norm(after),
+            "angle_deg": math.degrees(angle),
+        }
+    return {"target": at(min(lookahead, arc[-1])), "corner": None}
+
+
+def observed_branch(grid, base, corner, outgoing):
+    """Fraction of a short branch strip seen in the current learned BEV."""
+    p = np.asarray(corner) + np.linspace(0.1, 0.7, 7)[:, None] * np.asarray(outgoing)
+    lateral = np.array([-outgoing[1], outgoing[0]])
+    p = (p[:, None] + np.array([-0.15, 0.0, 0.15])[None, :, None] * lateral).reshape(-1, 2)
+    fl = np.array([world_to_body(v, base) for v in p])
+    n = len(grid["obs"])
+    rc = np.floor(n / 2 - fl / grid["res"]).astype(int)
+    inside = ((rc >= 0) & (rc < n)).all(1)
+    seen = np.zeros(len(p), bool)
+    seen[inside] = grid["obs"][rc[inside, 0], rc[inside, 1]] > 0.5
+    return float(seen.mean())
+
+
+class CornerObserver:
+    """Approach -> look -> return -> advance; at most two short peeks.
+
+    Only processed, settled camera TF views count. The control thread keeps
+    zero base velocity for look/return, except a bounded, guarded scan rotation
+    when the desired view is outside the head's joint limits.
+    """
+
+    def __init__(self):
+        self.phase = "cruise"
+        self.corner = self.outgoing = self.approach = None
+        self.since = 0.0
+        self.count = self.peeks = 0
+        self.coverage = 0.0
+        self.view_coverages = []
+        self.previous_mount = None
+        self.done_at = None
+        self.scan_only = False
+        self.scan_cooldown = -math.inf
+
+    def reset(self):
+        self.__init__()
+
+    def restore_neutral(self, base, now):
+        """A correction may interrupt a scan with the head still turned."""
+        self.reset()
+        self.phase, self.since, self.scan_only = "return", now, True
+        self.corner = self.approach = base[:2, 3].copy()
+        self.outgoing = base[:2, 0].copy()
+
+    def update(self, hint, base, mount, neutral, joint, grid, now, *, no_route=False, force_observation=False):
+        target = hint["target"]
+        yaw = math.atan2(base[1, 0], base[0, 0])
+        origin = base[:2, 3]
+        result = {
+            "phase": self.phase,
+            "target": target,
+            "hold": False,
+            "head_target": None,
+            "scan_w": 0.0,
+            "coverage": self.coverage,
+            "speed_scale": 1.0,
+            "lookahead": 0.4,
+        }
+        if force_observation and self.phase == "advance":
+            self.phase, self.approach = "approach", origin.copy()
+        if self.phase == "advance":
+            if np.dot(origin - self.corner, self.outgoing) > 0.4 or np.linalg.norm(origin - self.done_at) > 1.0:
+                self.phase = "cruise"
+            else:
+                result.update(phase="advance", speed_scale=0.5, lookahead=0.22)
+                # Retain the bend as an intermediate waypoint until passed.
+                result["target"] = self.corner + 0.65 * self.outgoing
+                return result
+        if self.phase == "cruise":
+            if hint["corner"] is not None:
+                self.corner, self.outgoing = hint["corner"].copy(), hint["outgoing"].copy()
+                self.approach = target.copy()
+                self.phase, self.peeks, self.scan_only = "approach", 0, False
+                self.coverage = 0.0
+            elif no_route and now >= self.scan_cooldown:
+                direction = target - origin
+                if np.linalg.norm(direction) < 0.1:
+                    return result
+                self.corner, self.outgoing = origin.copy(), direction / np.linalg.norm(direction)
+                self.approach = origin.copy()
+                self.phase, self.scan_only = "approach", True
+                self.coverage = 0.0
+            else:
+                return result
+        if self.phase == "approach":
+            if force_observation:
+                self.approach = origin.copy()
+            result.update(phase="approach", target=self.approach, speed_scale=0.5, lookahead=0.22)
+            if np.linalg.norm(origin - self.approach) > (0.04 if self.peeks else 0.16):
+                return result
+            self.phase, self.since, self.count = "look", now, 0
+            self.view_coverages = []
+            self.coverage = 0.0
+            self.previous_mount = None
+        if self.phase in ("look", "return"):
+            if now - self.since > HEAD_VIEW_TIMEOUT:
+                raise RuntimeError("Corner camera scan timed out; no unobserved advance")
+            joint = np.asarray(joint, float)
+            if len(joint) < 11 or not np.isfinite(joint).all():
+                raise ValueError("Head joint feedback unavailable for corner observation")
+            desired = (
+                wrap(math.atan2(self.outgoing[1], self.outgoing[0]) - yaw)
+                if self.phase == "look"
+                else camera_yaw(neutral)
+            )
+            error = wrap(desired - camera_yaw(mount))
+            pan = joint[9] + error
+            clamped = float(np.clip(pan, -2.8, 0.65))
+            tilt = joint[10]
+            if self.phase == "return":
+                tilt += camera_pitch(neutral) - camera_pitch(mount)
+            result.update(
+                phase=self.phase,
+                hold=True,
+                head_target=[clamped, float(np.clip(tilt, -1.4, 0.0))],
+                head_anchor=np.asarray(base).copy(),
+                head_deadline=self.since + HEAD_VIEW_TIMEOUT,
+                speed_scale=0.5,
+                lookahead=0.22,
+                target=self.approach,
+            )
+            # Head first. Base rotation is allowed only after the limited head
+            # position is reached; the independent footprint veto still applies.
+            if abs(pan - clamped) > 0.10 and abs(joint[9] - clamped) < 0.08:
+                result["scan_w"] = math.copysign(0.15, error)
+            settled = (
+                self.previous_mount is not None and np.linalg.norm(mount[:3, 3] - self.previous_mount[:3, 3]) < 0.005
+            )
+            if settled:
+                _, moved = alignment_correction(self.previous_mount, mount, np.eye(4))
+                settled = moved < math.radians(1)
+            self.previous_mount = mount.copy()
+            pitch_ready = self.phase != "return" or abs(camera_pitch(neutral) - camera_pitch(mount)) < math.radians(4)
+            self.count = self.count + 1 if settled and abs(error) < math.radians(6) and pitch_ready else 0
+            if self.phase == "look" and self.count:
+                self.view_coverages.append(observed_branch(grid, base, self.corner, self.outgoing))
+                self.view_coverages = self.view_coverages[-2:]
+                self.coverage = min(self.view_coverages)
+            if self.count >= 2:
+                if self.phase == "look":
+                    self.phase, self.count, self.since = "return", 0, now
+                elif self.scan_only:
+                    self.phase, self.scan_cooldown = "cruise", now + 12.0
+                elif self.coverage >= 0.5:
+                    self.phase, self.done_at = "advance", origin.copy()
+                elif self.peeks < 2 and np.linalg.norm(self.corner - origin) > 0.14:
+                    # A closer, short approach followed by another stationary
+                    # look. Native planning + rectangle checks must clear it.
+                    self.approach = origin + 0.12 * (self.corner - origin) / np.linalg.norm(self.corner - origin)
+                    self.peeks += 1
+                    self.phase = "approach"
+                else:
+                    raise RuntimeError("Corner remains occluded after bounded peeks; reposition required")
+                self.previous_mount = None
+            result["coverage"] = self.coverage
+        return result
+
+
+def rectangle_command_clear(grid, planning_base, pose, v, w, horizon=1.0):
+    """Actual 1 s swept square, including pure rotation, in the learned grid."""
+    from .stretch_nav_footprint import command_footprint_report
+
+    return command_footprint_report(grid, planning_base, pose, v, w, horizon, max_cells=0)["clear"]
+
+
+def rectangle_path_clear(path, grid, half_width=0.23, half_length=0.23, horizon=1.2):
+    """Check an oriented swept body against observed learned occupancy.
+
+    Unknown is not relabelled free here. The native visibility planner handles
+    observation requests, while measured depth remains a separate hard veto.
+    """
+    path = np.vstack([[0.0, 0.0], np.asarray(path, float).reshape(-1, 2)])
+    if not np.isfinite(path).all():
+        return False
+    offsets = (
+        np.array(np.meshgrid(np.linspace(-half_length, half_length, 11), np.linspace(-half_width, half_width, 11)))
+        .reshape(2, -1)
+        .T
+    )
+    travelled, heading = 0.0, 0.0
+    n, res = len(grid["prob"]), grid["res"]
+    # Match native cross_nav: the robot already occupies this area. Keep the
+    # original prediction intact for diagnostics and for all newly swept cells.
+    probability = np.asarray(grid["prob"]).copy()
+    axis = (n / 2 - np.arange(n) - 0.5) * res
+    probability[(np.abs(axis[:, None]) <= half_length) & (np.abs(axis[None, :]) <= half_width)] = 0.0
+    for a, b in zip(path[:-1], path[1:]):
+        d = float(np.linalg.norm(b - a))
+        if d < 1e-5:
+            continue
+        yaw = math.atan2(*(b - a)[::-1])
+        for angle in np.linspace(heading, heading + wrap(yaw - heading), 8):
+            c, s = math.cos(angle), math.sin(angle)
+            points = offsets @ np.array([[c, s], [-s, c]]) + a
+            rc = np.floor(n / 2 - points / res).astype(int)
+            inside = ((rc >= 0) & (rc < n)).all(1)
+            if (
+                not inside.all()
+                or ((probability[rc[:, 0], rc[:, 1]] > 0.6) & (grid["obs"][rc[:, 0], rc[:, 1]] > 0.5)).any()
+            ):
+                return False
+        count = max(2, int(d / 0.04) + 1)
+        for t in np.linspace(0.0, min(1.0, max(0.0, horizon - travelled) / d), count):
+            c, s = math.cos(yaw), math.sin(yaw)
+            points = offsets @ np.array([[c, s], [-s, c]]) + a + t * (b - a)
+            rc = np.floor(n / 2 - points / res).astype(int)
+            inside = ((rc >= 0) & (rc < n)).all(1)
+            if (
+                not inside.all()
+                or ((probability[rc[:, 0], rc[:, 1]] > 0.6) & (grid["obs"][rc[:, 0], rc[:, 1]] > 0.5)).any()
+            ):
+                return False
+        travelled, heading = travelled + d, yaw
+        if travelled >= horizon:
+            break
+    return True

cases/20261026_goal1012_05/code/lite3_ROS/web_console/stretch_nav_replay.py

@@ -0,0 +1,226 @@
+"""Disk-backed, read-only playback of Stretch navigation recordings."""
+
+import json
+import math
+from bisect import bisect_right
+from pathlib import Path
+from urllib.parse import urlencode
+
+LAYERS = ("occupancy", "visibility", "uncertainty")
+
+
+def save_bev_frame(directory, frame, images, *, source="recorded", only_missing=False):
+    """Commit already encoded layers together; meta.json marks a complete frame."""
+    if not isinstance(frame, int) or frame < 0 or source not in ("recorded", "reconstructed"):
+        raise ValueError("Invalid replay BEV frame")
+    root = Path(directory) / "replay" / "bev" / f"{frame:08d}"
+    if only_missing and (root / "meta.json").is_file():
+        return
+    if any(not isinstance(images.get(f"{name}.png"), bytes) for name in LAYERS):
+        raise ValueError("All three encoded BEV layers are required")
+    root.mkdir(parents=True, exist_ok=True)
+    for name in LAYERS:
+        path = root / f"{name}.png"
+        temporary = path.with_suffix(".png.tmp")
+        temporary.write_bytes(images[path.name])
+        temporary.replace(path)
+    path = root / "meta.json"
+    temporary = path.with_suffix(".json.tmp")
+    temporary.write_text(json.dumps({"frame_idx": frame, "source": source}) + "\n")
+    temporary.replace(path)
+    marker = root.parent.parent / "last_bev.json"
+    temporary = marker.with_suffix(".json.tmp")
+    temporary.write_text(json.dumps({"frame_idx": frame, "source": source}) + "\n")
+    temporary.replace(marker)
+
+
+def read_rows(path):
+    """An in-flight last JSONL line may be incomplete; earlier corruption is an error."""
+    if not path.is_file():
+        return []
+    lines = path.read_text().splitlines(keepends=True)
+    rows = []
+    for index, line in enumerate(lines):
+        if not line.strip():
+            continue
+        try:
+            rows.append(json.loads(line))
+        except json.JSONDecodeError:
+            if index == len(lines) - 1 and not line.endswith("\n"):
+                break
+            raise
+    return rows
+
+
+def confined(root, relative):
+    path = (root / relative).resolve()
+    if not path.is_relative_to(root):
+        raise ValueError("Replay asset escaped its recording")
+    return path
+
+
+class ReplayArchive:
+    def __init__(self, directory):
+        self.root = Path(directory).resolve()
+        status = self.root / "final_status.json"
+        if not status.is_file():
+            status = self.root / "review.json"
+        self.base = json.loads(status.read_text())
+        if self.base.get("phase") != "stopped":
+            raise ValueError("Replay requires a stopped recording")
+        self.raw = read_rows(self.root / "capture/observations.jsonl")
+        self.raw_ids = [int(row["frame_idx"]) for row in self.raw]
+        self.raw_by_id = dict(zip(self.raw_ids, self.raw))
+        self.times = [float(row["relative_time_s"]) for row in self.raw]
+        if not all(math.isfinite(t) for t in self.times) or self.times != sorted(self.times):
+            raise ValueError("Invalid recording timeline")
+        if self.raw_ids != sorted(set(self.raw_ids)):
+            raise ValueError("Invalid recording frame order")
+        self.plans = read_rows(self.root / "observations.jsonl")
+        self.plan_ids = [row["frame_idx"] for row in self.plans]
+        if self.plan_ids != sorted(set(self.plan_ids)):
+            raise ValueError("Invalid recorded plan order")
+        self.controls = sorted(read_rows(self.root / "commands.jsonl"), key=lambda row: row["time_unix"])
+        self.control_times = [row["time_unix"] for row in self.controls]
+        self.robots = sorted(read_rows(self.root / "robot_status.jsonl"), key=lambda row: row["received_unix"])
+        self.robot_times = [row["received_unix"] for row in self.robots]
+        self.events = read_rows(self.root / "events.jsonl")
+        self.bevs = {}
+        for path in (self.root / "replay/bev").glob("*/meta.json"):
+            if not path.parent.name.isdecimal():
+                continue
+            index = int(path.parent.name)
+            if index not in self.raw_by_id:
+                continue
+            meta = json.loads(confined(self.root, path.relative_to(self.root)).read_text())
+            if all(confined(self.root, path.parent.relative_to(self.root) / f"{name}.png").is_file()
+                   for name in LAYERS):
+                self.bevs[index] = {"path": path.parent.relative_to(self.root), "source": meta["source"]}
+        # Older sessions kept only the last displayed BEV. Never show it early.
+        last_bev = next((p for p in reversed(self.plans) if p.get("bev_size")), None)
+        if last_bev and last_bev["frame_idx"] not in self.bevs and all(
+            confined(self.root, Path("review_bev") / f"{name}.png").is_file() for name in LAYERS
+        ):
+            self.bevs[last_bev["frame_idx"]] = {"path": Path("review_bev"), "source": "recorded"}
+        self.bev_ids = sorted(self.bevs)
+
+    @staticmethod
+    def latest(rows, keys, value):
+        index = bisect_right(keys, value) - 1
+        return rows[index] if index >= 0 else None
+
+    def manifest(self):
+        received = [r.get("received_unix_s", -math.inf) for r in self.raw]
+        markers = []
+        start = 0
+        for event in self.events:
+            if not received:
+                break
+            if event['time_unix'] > received[-1] + 1.0:
+                continue  # Exclude later review-server shutdown events.
+            index = max(0, min(len(self.raw) - 1, bisect_right(received, event["time_unix"]) - 1))
+            if event["type"] == "start_requested":
+                start = index
+            markers.append({"index": index, "time_s": self.times[index], "type": event["type"],
+                            "label": event.get("reason", event["type"].replace("_", " "))})
+        return {
+            "run": self.root.name, "frames": [{"frame_idx": i, "time_s": t} for i, t in zip(self.raw_ids, self.times)],
+            "outcome": self.base.get("reason", "Run ended"),
+            "duration_s": self.times[-1] if self.times else 0.0, "start_index": start, "events": markers,
+            "bev_frames": len(self.bev_ids), "processed_frames": len(self.plans),
+            "recorded_bev_frames": sum(m["source"] == "recorded" for m in self.bevs.values()),
+            "reconstructed_bev_frames": sum(m["source"] == "reconstructed" for m in self.bevs.values()),
+        }
+
+    def frame(self, index):
+        if index < 0 or index >= len(self.raw):
+            raise KeyError("Unknown replay index")
+        raw = self.raw[index]
+        number = raw["frame_idx"]
+        plan = self.latest(self.plans, self.plan_ids, number)
+        plan = dict(plan) if plan else {"frame_idx": None, "trajectory": [], "global_route": [],
+                                     "local_path_display": [], "planner_name": "Before first processed observation"}
+        stamp = raw.get("received_unix_s", -math.inf)
+        control = self.latest(self.controls, self.control_times, stamp) or {}
+        robot = dict(self.latest(self.robots, self.robot_times, stamp) or {})
+        if raw.get("head_joints") is not None:
+            joint = list(robot.get("joint_positions", [0.0] * 11))
+            if len(joint) >= 11:
+                joint[9:11] = raw["head_joints"]
+                robot["joint_positions"] = joint
+        bev_index = bisect_right(self.bev_ids, number) - 1
+        bev = self.bev_ids[bev_index] if bev_index >= 0 else None
+        if bev is not None:
+            source_plan = self.latest(self.plans, self.plan_ids, bev) or {}
+            plan.update(bev_size=source_plan.get("bev_size", 400), bev_res=source_plan.get("bev_res", 0.05))
+        query = {"run": self.root.name}
+        replay = {
+            "index": index, "time_s": raw["relative_time_s"], "frame_idx": number,
+            "map_frame": plan["frame_idx"], "bev_frame": bev,
+            "bev_time_s": self.raw_by_id[bev]["relative_time_s"] if bev is not None else None,
+            "bev_source": self.bevs[bev]["source"] if bev is not None else None,
+            "rgb_url": "/api/replay/rgb?" + urlencode({**query, "frame": number}),
+            "bev_urls": {name: "/api/replay/bev?" + urlencode({**query, "frame": bev, "layer": name})
+                         for name in LAYERS} if bev is not None else {},
+        }
+        return {
+            **{key: self.base.get(key) for key in ("goal_keyframe", "max_plan_age_s", "v_max", "w_max")},
+            "phase": "stopped", "ready": False, "review": True, "playback": True,
+            "gate": "Replay; motion controls disabled", "recorded_phase": control.get("phase", "teleop"),
+            "reason": control.get("reason", "Recorded observations"), "frame": plan, "robot": robot,
+            "control": control, "replay": replay, "capture_frame": number,
+            "processed": bisect_right(self.plan_ids, number),
+            "motion_commands": control.get("nonzero_motion_commands", 0),
+        }
+
+    def image(self, number, layer=None):
+        if layer is None:
+            if number not in self.raw_by_id:
+                raise KeyError("Unknown recorded RGB frame")
+            relative = Path("capture/rgb") / f"{number:08d}.jpg"
+        else:
+            if layer not in LAYERS or number not in self.bevs:
+                raise KeyError("Unknown recorded BEV frame or layer")
+            relative = self.bevs[number]["path"] / f"{layer}.png"
+        return confined(self.root, relative).read_bytes()
+
+
+class ReplayService:
+    """Only completed recordings in the current run's parent are selectable."""
+
+    def __init__(self, current):
+        self.current = Path(current).resolve()
+        self.parent = self.current.parent
+        self.cache = {}
+
+    def directories(self):
+        result = {}
+        for path in [self.current, *self.parent.glob("stretch_cross_nav_live_*")]:
+            root = path.resolve()
+            if root.parent != self.parent or not (root / "map.json").is_file():
+                continue
+            status = root / "final_status.json"
+            if not status.is_file():
+                status = root / "review.json"
+            if not status.is_file():
+                continue
+            data = json.loads(status.read_text())
+            capture = root / "capture/observations.jsonl"
+            if data.get("phase") == "stopped" and capture.is_file() and capture.stat().st_size > 0:
+                result[root.name] = (root, data)
+        return result
+
+    def listing(self):
+        return [{"id": key, "goal_keyframe": data.get("goal_keyframe"), "reason": data.get("reason")}
+                for key, (_, data) in sorted(self.directories().items(), reverse=True)]
+
+    def get(self, key=None):
+        key = key or self.current.name
+        root, _ = self.directories()[key]
+        # A backfill can add images while the read-only page is open.
+        signature = tuple((root / name).stat().st_mtime_ns if (root / name).exists() else 0
+                          for name in ("capture/observations.jsonl", "observations.jsonl", "replay/bev",
+                                       "replay/last_bev.json"))
+        if key not in self.cache or self.cache[key][0] != signature:
+            self.cache[key] = (signature, ReplayArchive(root))
+        return self.cache[key][1]

cases/20261026_goal1012_05/code/lite3_ROS/web_console/stretch_nav_report.py

@@ -0,0 +1,352 @@
+"""Saved native CROSS relocalization, native graph routing and learned or geometric BEV planning."""
+import heapq
+import json
+from pathlib import Path
+from types import SimpleNamespace
+
+import cv2
+import numpy as np
+
+from .stretch_nav_geometry import body_to_world, body_yaw, measured_bev, bev_png, world_to_body
+from .stretch_nav_learned import reproject_bev, learned_png
+
+
+def clean_json(value):
+    if isinstance(value, dict):
+        return {str(k): clean_json(v) for k, v in value.items()}
+    if isinstance(value, (list, tuple)):
+        return [clean_json(v) for v in value]
+    if isinstance(value, np.ndarray):
+        return clean_json(value.tolist())
+    if isinstance(value, np.generic):
+        return clean_json(value.item())
+    if isinstance(value, float) and not np.isfinite(value):
+        return None
+    return value
+
+
+def save_json(path, data):
+    temporary = path.with_suffix('.json.tmp')
+    temporary.write_text(json.dumps(clean_json(data), indent=2, allow_nan=False) + '\n')
+    temporary.replace(path)
+
+
+def positions(transform, points):
+    points = np.asarray(points, dtype=float).reshape(-1, 3)
+    return points @ transform[:3, :3].T + transform[:3, 3]
+
+
+class SavedRoute:
+    """Feed saved native pose/odometry records to CROSS's unmodified PlanningSystem.
+
+    Choose a local attachment by connection distance plus remaining native graph
+    cost. Keep the previous route when competing routes have nearly equal cost.
+    No new visual or geometric shortcut edges are invented by this adapter.
+    """
+    def __init__(self, map_path, *, attachment_radius=.75, switch_margin=.25):
+        from cross.db.store import read_map
+        from cross.core.types import Edge, EdgeType
+        from cross.core.planning_system import PlanningSystem
+
+        data = read_map(map_path)
+        records = list(data['db_data']['keyframes']) + list(data['hypo_data']['temp_keyframes'])
+        nodes = {int(r['id']): SimpleNamespace(id=int(r['id']), temporary=bool(r['temporary']),
+            pose_mu=r['pose_mu'].cpu(), pose_charts=r.get('pose_charts')) for r in records}
+        edges = {tuple(key): Edge(mean=r['mean'].cpu(), std=r['std'].cpu(), type=EdgeType[r['type']])
+                 for key, r in data['hypo_data']['odom_edges'].items()}
+        adjacency = {}
+        for a, b in edges:
+            adjacency.setdefault(a, set()).add(b)
+            adjacency.setdefault(b, set()).add(a)
+        manager = SimpleNamespace(nodes=nodes, odom_edges=edges, proximity_edges={}, proximity_adjacency={},
+            chart_aware=bool(data.get('coordinate_charts_version')), odom_adjacency=lambda: adjacency)
+        self.permanent = {k: v for k, v in nodes.items() if not v.temporary}
+        self.matrices = {k: v.pose_mu[0].matrix().numpy() for k, v in nodes.items()}
+        self.current = next(iter(self.permanent))
+        system = SimpleNamespace(device='cpu', hypothesis_manager=manager,
+            get_current_kf=lambda: {'closest_perm_node': nodes[self.current]})
+        self.planning = PlanningSystem(system, config={'use_temporary_keyframes': False})
+        self.attachment_radius = attachment_radius
+        self.switch_margin = switch_margin
+        if not np.isfinite([attachment_radius, switch_margin]).all() or (
+            attachment_radius <= 0 or switch_margin < 0
+        ):
+            raise ValueError('Invalid route attachment limits')
+        self._goal = None
+        self._cost_to_goal = {}
+        self._previous_ids = ()
+
+    def reset_attachment(self):
+        """Forget route continuity after a global localization correction."""
+        self._previous_ids = ()
+
+    def _set_goal(self, goal_id):
+        if goal_id not in self.permanent:
+            raise ValueError('Goal must be an original permanent keyframe')
+        if goal_id == self._goal:
+            return
+        # The saved graph is immutable. Compute cost-to-go once per goal using
+        # exactly the neighbors and edge weights used by native CROSS planning.
+        # Reverse edges also handle directed graphs without assuming symmetry.
+        native = self.planning.planner
+        reverse = {key: [] for key in self.permanent}
+        for key in self.permanent:
+            for neighbor in native._get_neighbors(key):
+                if neighbor not in reverse:
+                    continue
+                cost = native._get_edge_cost(key, neighbor)
+                if cost < 0 or np.isnan(cost):
+                    raise ValueError('Invalid native planning edge cost')
+                if np.isfinite(cost):
+                    reverse[neighbor].append((key, cost))
+        costs, queue = {goal_id: 0.}, [(0., goal_id)]
+        while queue:
+            cost, key = heapq.heappop(queue)
+            if cost > costs[key]:
+                continue
+            for neighbor, weight in reverse[key]:
+                candidate = cost + weight
+                if candidate < costs.get(neighbor, np.inf):
+                    costs[neighbor] = candidate
+                    heapq.heappush(queue, (candidate, neighbor))
+        self.planning.set_goal(goal_kf_id=goal_id)
+        self._goal, self._cost_to_goal, self._previous_ids = goal_id, costs, ()
+
+    def route(self, camera_pose, goal_id, *, can_attach=None):
+        """Select a bounded local start; optional predicate checks its connection.
+
+        ``can_attach(keyframe_id, map_position)`` may veto an attachment using
+        current measured obstacles. Local planning still decides how to move.
+        """
+        camera_pose = np.asarray(camera_pose, dtype=float)
+        if camera_pose.shape != (4, 4) or not np.isfinite(camera_pose).all():
+            raise ValueError('Invalid committed camera pose')
+        self._set_goal(int(goal_id))
+        distances = {key: float(np.linalg.norm(self.matrices[key][:3, 3] - camera_pose[:3, 3]))
+                     for key in self.permanent}
+        nearest = min(distances, key=distances.get)
+        # All bounded local starts compete on total cost. A window relative to
+        # the nearest frame can discard a valid short route at an overlapping
+        # visit, even though its attachment remains close and unobstructed.
+        radius = self.attachment_radius
+        candidates = []
+        for key, distance in distances.items():
+            remaining = self._cost_to_goal.get(key, np.inf)
+            if distance > radius or not np.isfinite(remaining):
+                continue
+            if can_attach is not None and not can_attach(key, self.matrices[key][:3, 3]):
+                continue
+            candidates.append((distance + remaining, distance, key))
+        diagnostics = {'nearest_keyframe': nearest, 'nearest_distance_m': distances[nearest],
+                       'attachment_limit_m': radius, 'candidate_count': len(candidates),
+                       'connection_check': 'measured_depth' if can_attach is not None else 'map_distance_only',
+                       'switch_margin_m': self.switch_margin}
+        if not candidates:
+            self._previous_ids = ()
+            return {'status': 'no_local_graph_attachment', 'start_keyframe': None,
+                    'ids': [], 'positions': [], 'attachment': diagnostics}
+        best = min(candidates)
+        previous = set(self._previous_ids)
+        continuing = [candidate for candidate in candidates if candidate[2] in previous]
+        if continuing:
+            keep = min(continuing)
+            if keep[0] <= best[0] + self.switch_margin:
+                best = keep
+        total, distance, self.current = best
+        # Native backbone expansion has no segment to expand for [goal]. Keep
+        # that valid singleton so the live controller can approach/declare arrival.
+        result = ({'detailed_path': [self.current], 'detailed_cost': 0., 'detail_level': 'backbone'}
+                  if self.current == self._goal else self.planning.plan_to_goal(algorithm='astar'))
+        if not result or not result.get('detailed_path'):
+            self._previous_ids = ()
+            return {'status': 'no_graph_route', 'start_keyframe': self.current,
+                    'ids': [], 'positions': [], 'attachment': diagnostics}
+        ids = result['detailed_path']
+        self._previous_ids = tuple(ids)
+        diagnostics.update(distance_m=distance, remaining_m=result['detailed_cost'],
+                           total_m=distance + result['detailed_cost'],
+                           selection_total_m=total,
+                           best_candidate_total_m=min(candidates)[0], selected_on_previous_route=self.current in previous)
+        return {'status': 'route_found', 'start_keyframe': self.current, 'ids': ids,
+                'positions': [self.matrices[k][:3, 3] for k in ids],
+                'cost_m': result['detailed_cost'], 'algorithm': 'native CROSS A*',
+                'attachment': diagnostics,
+                'start_rule': 'local connection distance + remaining native graph cost, with route continuity',
+                'detail_level': result['detail_level']}
+
+
+def build_report(capture, probe, map_run, output, goal_id=None):
+    from cross_nav.policy.bev_policy import BEVPlannerPolicy, Episode
+
+    capture, probe, map_run, output = map(Path, (capture, probe, map_run, output))
+    output.mkdir(parents=True, exist_ok=True)
+    (output / 'frames').mkdir(exist_ok=True)
+    save_json(output / 'state.json', {'status': 'building', 'robot_commands_sent': 0})
+    rows = json.loads((probe / 'observations.json').read_text())
+    learned = (probe / 'bevs').is_dir()
+    size, resolution = (400, .05) if learned else (200, .05)
+    raw_rows = {r['frame_idx']: r for r in map(json.loads, (capture / 'observations.jsonl').read_text().splitlines())}
+    source_run = json.loads((map_run / 'run.json').read_text())
+    source_graph = json.loads((map_run / 'graph.json').read_text())
+    display = np.asarray(source_run['T_display_from_map'])
+    route_planner = SavedRoute(map_run / 'map.pkl')
+    committed = [row for row in rows if row['localized']]
+    if not committed:
+        raise ValueError('No committed native relocalization observations')
+    final = committed[-1]
+    final_raw = raw_rows[final['capture_frame']]
+    final_map_camera = np.asarray(final['map_pose'])
+    final_odom_camera = np.asarray(final_raw['camera_pose'])
+    final_base = np.asarray(final_raw['base_pose_matrix'])
+    T_map_odom = final_map_camera @ np.linalg.inv(final_odom_camera)
+    if goal_id is None:
+        nearest_id = min(route_planner.permanent, key=lambda k: np.linalg.norm(
+            route_planner.matrices[k][:3, 3] - final_map_camera[:3, 3]))
+        candidates = []
+        for key in route_planner.permanent:
+            point = route_planner.matrices[key][:3, 3]
+            point_odom = positions(np.linalg.inv(T_map_odom), [point])[0]
+            fl = world_to_body(point_odom, final_base)
+            if 1.5 <= np.linalg.norm(fl) <= 4.5 and fl[0] > .5:
+                # Repeated visits can be nearby in space but far along the graph.
+                candidates.append((np.linalg.norm(fl - [3., 0.]) + .02 * abs(key - nearest_id), key))
+        goal_id = min(candidates)[1] if candidates else min(route_planner.permanent,
+            key=lambda k: np.linalg.norm(route_planner.matrices[k][:3, 3] - final_map_camera[:3, 3]))
+    if int(goal_id) not in route_planner.permanent:
+        raise ValueError('Goal must be an original permanent map keyframe')
+
+    # Native CPU policy consumes cached network predictions or the geometric baseline.
+    cross_root = Path('/workspace/CROSS')
+    config = json.loads((cross_root / 'cross_nav/configs/policy/bev_planner_vfin2.json').read_text())
+    for field in ('backbone', 'occupancy', 'visibility', 'visibility_gravity'):
+        config[field] = None
+    policy = BEVPlannerPolicy(config, predictor=SimpleNamespace(size=size, res=resolution))
+    episode = Episode()
+    selected = sorted(set(np.linspace(0, len(rows) - 1, 25).astype(int).tolist()
+                          + [i for i, row in enumerate(rows) if row['localized']]))
+    frames, trajectory = [], []
+    for number, row_index in enumerate(selected):
+        row = rows[row_index]
+        index = row['capture_frame']
+        raw = raw_rows[index]
+        camera, base = np.asarray(raw['camera_pose']), np.asarray(raw['base_pose_matrix'])
+        depth = cv2.imread(str(capture / 'depth' / f'{index:08d}.png'), cv2.IMREAD_UNCHANGED).astype(float) / 1000
+        geometry = measured_bev(depth, raw['camera_K'], camera, base)
+        frame_dir = output / 'frames' / f'{index:08d}'
+        frame_dir.mkdir(exist_ok=True)
+        np.savez_compressed(frame_dir / 'geometry.npz', prob=geometry['prob'], obs=geometry['obs'],
+                            height=geometry['height'], K=raw['camera_K'], T_odom_camera=camera, T_odom_base=base)
+        bev_meta = row.get('bev', {})
+        fresh = bool(row.get('bev_fresh', False)) if learned else True
+        if learned:
+            if fresh:
+                with np.load(probe / 'bevs' / f'{index:08d}.npz') as native:
+                    planned_bev = reproject_bev(native['prob'], native['obs'], native['err'],
+                        native['R_bev_from_cam'], camera, base, resolution)
+            else:
+                planned_bev = {'prob': np.full((size, size), .5, np.float32),
+                               'obs': np.zeros((size, size), np.float32),
+                               'err': np.ones((size, size), np.float32)}
+            np.savez_compressed(frame_dir / 'learned_base.npz', **planned_bev)
+            for layer in ('occupancy', 'visibility', 'uncertainty'):
+                (frame_dir / f'{layer}.png').write_bytes(learned_png(
+                    planned_bev['prob'], planned_bev['obs'], planned_bev['err'], layer))
+        else:
+            planned_bev = {**geometry, 'err': np.zeros((size, size), np.float32)}
+            for layer in ('occupancy', 'visibility'):
+                (frame_dir / f'{layer}.png').write_bytes(bev_png(geometry['prob'], geometry['obs'], layer))
+        map_camera = np.asarray(row['map_pose'])
+        graph_route = {'status': 'waiting_for_committed_pose', 'ids': [], 'positions': []}
+        goal_body = np.array([2., 0.])
+        global_positions = []
+        local_goal_kind = 'local 2 m forward demo; map localization pending'
+        if row['localized']:
+            alignment = map_camera @ np.linalg.inv(camera)
+            graph_route = route_planner.route(map_camera, goal_id)
+            global_positions = positions(display, graph_route['positions'])
+            route_points_odom = positions(np.linalg.inv(alignment), graph_route['positions'])
+            if len(route_points_odom):
+                distances = np.linalg.norm(route_points_odom[:, :2] - base[:2, 3], axis=1)
+                eligible = np.flatnonzero(distances >= 1.5)
+                target = route_points_odom[eligible[0] if len(eligible) else -1]
+                goal_body = world_to_body(target, base)
+                local_goal_kind = 'subgoal on native CROSS graph route'
+            trajectory.append(positions(display, [map_camera[:3, 3]])[0])
+        maps = {'prob': planned_bev['prob'][None], 'obs': planned_bev['obs'][None],
+                'err': planned_bev['err'][None], 'log_scale': np.array([bev_meta.get('log_scale', 0.)]),
+                'odometry': np.array([bev_meta.get('scale_source') == 'anchors']),
+                'up_head_deg': np.array([bev_meta.get('gravity_head_deg', 0.)]),
+                'n_views': np.array([bev_meta.get('n_views', 1)]), 'fresh': np.array([fresh])}
+        # Zero actual commanded travel: passive pushing must not create fictitious bump events.
+        odom = np.array([*base[:2, 3], body_yaw(base)])
+        paths, details = policy.plan_maps(maps, goal_body[None], [episode],
+                                          [{'ep': 'passive', 'odom': odom, 'expect': 0.}], [True])
+        debug = details[0]
+        local_path = paths[0]
+        local_display = []
+        camera_display = None
+        if row['localized']:
+            alignment = map_camera @ np.linalg.inv(camera)
+            path_odom_xy = body_to_world(local_path, base)
+            path_odom = np.column_stack([path_odom_xy, np.zeros(len(path_odom_xy))])
+            local_display = positions(display @ alignment, path_odom)
+            camera_display = positions(display, [map_camera[:3, 3]])[0]
+        matches = sorted(row['retrieval'], key=lambda r: r['score'], reverse=True)[:6]
+        status_names = ['goal route', 'local waypoint', 'no route / scan', 'near-goal approach',
+                        'remembered route', 'relaxed local route', 'episode-map route']
+        record = {'frame_idx': index, 'time_s': raw['relative_time_s'], 'localized': row['localized'],
+            'weights': row['weights'], 'retrieval': matches, 'graph_route': graph_route,
+            'global_route_display': global_positions, 'local_path_body': local_path,
+            'local_path_display': local_display, 'camera_display': camera_display,
+            'goal_body': goal_body, 'goal_kind': local_goal_kind, 'goal_keyframe': int(goal_id),
+            'planner_status': status_names[int(debug['status'])], 'planner_status_code': int(debug['status']),
+            'blind_zone_assumed': bool(debug['blind_zone']), 'vis_threshold': debug['vis_threshold'],
+            'bev_source': 'cross_shared_vggt_heads' if learned else 'measured_depth_geometry',
+            'learned_bev_heads_available': learned, 'bev_fresh': fresh, 'bev_metadata': bev_meta,
+            'robot_commands_sent': 0, 'bev_size': size, 'bev_resolution_m': resolution,
+            'floor_z_odom': 0., 'camera_height_m': float(camera[2, 3]),
+            'occupied_cells': int((planned_bev['prob'] > .6).sum()),
+            'observed_cells': int((planned_bev['obs'] > .5).sum()),
+            'measured_depth_occupied_cells': geometry['occupied_cells'],
+            'occupancy_range': [planned_bev['prob'].min(), planned_bev['prob'].max()],
+            'observability_range': [planned_bev['obs'].min(), planned_bev['obs'].max()],
+            'camera_K': raw['camera_K'], 'T_odom_camera': camera, 'T_odom_base': base,
+            'native_map_camera_pose': map_camera if row['localized'] else None,
+            'point_cloud_odom': geometry['points_odom'],
+            'retrieval_note': 'Native last-step diagnostics; may carry between backend observation frames.'}
+        save_json(frame_dir / 'frame.json', record)
+        frames.append({'id': index, 'time_s': raw['relative_time_s'], 'localized': row['localized']})
+        save_json(output / 'state.json', {'status': 'building', 'frames_ready': number + 1,
+                                        'frames_total': len(selected), 'robot_commands_sent': 0})
+    nodes = [{'id': node['id'], 'position': positions(display, [np.asarray(node['pose'])[:3, 3]])[0],
+              'frame_idx': node.get('frame_idx')} for node in source_graph['nodes'] if not node['temporary']]
+    map_data = {'nodes': nodes, 'trajectory': trajectory, 'goal_keyframe': int(goal_id),
+                'recording': '2026-10-22--15-48-58', 'coordinates': source_run['coordinates']}
+    save_json(output / 'map.json', map_data)
+    manifest = {'status': 'ready', 'capture': str(capture.resolve()), 'probe': str(probe.resolve()),
+        'map_run': str(map_run.resolve()), 'phone_dataset': source_run['dataset'], 'frames': frames,
+        'default_frame': len(frames) - 1, 'goal_keyframe': int(goal_id),
+        'native_probe_result': json.loads((probe / 'result.json').read_text()),
+        'learned_bev_heads_available': learned,
+        'bev_source': 'cross_shared_vggt_heads' if learned else 'measured_depth_geometry',
+        'bev_size': size, 'bev_resolution_m': resolution,
+        'checkpoint_provenance': json.loads((probe / 'run.json').read_text()).get('checkpoint_provenance') if learned else None,
+        'native_local_planner': 'cross_nav.policy.bev_policy.BEVPlannerPolicy.plan_maps',
+        'native_graph_planner': 'cross.core.planning_system.PlanningSystem (A*)',
+        'raw_depth_max_m': 3., 'robot_commands_sent': 0,
+        'notes': (["Trained occupancy and observability heads read CROSS's shared VGGT pass.",
+                  'RGB and external camera odometry only; raw depth is a separate comparison.',
+                  'Recorded camera TF supplies gravity and camera-to-base reprojection.',
+                  'Occupancy error and observability are distinct learned confidence outputs.',
+                  'The native nav service observation cadence (obs_max_interval_steps=1) is enabled.',
+                  'Plans are passive inspection results, with no robot commands.',
+                  'The local planner uses its native circular footprint and recovery rules; no physical drive test.']
+                  if learned else ['The occupancy/observability navigation heads are not used in this comparison.',
+                  'BEV probabilities are geometric encodings, not learned/calibrated confidence.',
+                  'The floor is assumed at odom Z=0; camera pan/tilt/offset come from timestamped TF.',
+                  'Plans are passive inspection results, with no robot commands.',
+                  'The local planner uses its native circular footprint and recovery rules; no physical drive test.'])}
+    save_json(output / 'manifest.json', manifest)
+    save_json(output / 'state.json', {'status': 'ready', 'frames_ready': len(frames),
+                                    'goal_keyframe': int(goal_id), 'robot_commands_sent': 0})
+    return manifest

cases/20261026_goal1012_05/code/lite3_ROS/web_console/stretch_nav_survey.py

@@ -0,0 +1,169 @@
+"""Stationary yaw/pitch observations for blocked Stretch navigation; no I/O."""
+
+import math
+
+import numpy as np
+
+from .stretch_nav_control import HEAD_SURVEY_TIMEOUT, HEAD_VIEW_TIMEOUT, alignment_correction, wrap
+from .stretch_nav_recovery import camera_pitch, camera_yaw
+
+HEAD_TARGET_TOLERANCE_RAD = math.radians(4)
+
+
+class HeadSurvey:
+    """Observe floor and both sides, then restore the driving camera pose.
+
+    Targets are frozen from image-time joint/TF feedback. Only distinct,
+    settled processed images count. First hold zero base velocity and wait
+    for fresh standstill observations before anchoring or moving the head.
+    No survey result requests base motion.
+    At most two passes are allowed until the base moves 20 cm; the enclosing
+    controller has an independent 260 s/100 degree recovery budget.
+    """
+
+    def __init__(self):
+        self.active = False
+        self.braking = False
+        self.brake_reference = self.brake_stable_since = None
+        self.brake_frame, self.brake_count = -1, 0
+        self.origin = self.base = None
+        self.passes = self.index = 0
+        self.targets = []
+        self.views = []
+        self.started = self.since = self.next_allowed = 0.0
+        self.previous_mount = self.stable_since = None
+        self.last_frame = -1
+        self.count = 0
+        self.reason = ""
+
+    def cancel(self):
+        self.active = False
+        self.braking = False
+        self.next_allowed = 0.0
+
+    def start(self, base, mount, neutral, joint, now, reason):
+        if self.active:
+            return False
+        joint = np.asarray(joint, float)
+        if joint.ndim != 1 or len(joint) < 11 or not np.isfinite(joint).all():
+            raise ValueError("Timestamped head joint feedback unavailable for survey")
+        base = np.asarray(base, float)
+        if self.origin is None or np.linalg.norm(base[:2, 3] - self.origin) > 0.2:
+            self.origin, self.passes = base[:2, 3].copy(), 0
+        if now < self.next_allowed:
+            return False
+        if self.passes >= 2:
+            raise RuntimeError("Head survey exhausted two passes without forward progress; footprint remains blocked")
+        pan = float(np.clip(joint[9] + wrap(camera_yaw(neutral) - camera_yaw(mount)), -2.8, 0.65))
+        tilt = float(np.clip(joint[10] + camera_pitch(neutral) - camera_pitch(mount), -1.4, 0.0))
+        # Look far enough down to inspect the otherwise hidden near floor.
+        down_pitch = max(-1.25, min(-1.05, camera_pitch(neutral) - 0.45))
+        down = float(np.clip(joint[10] + down_pitch - camera_pitch(mount), -1.4, 0.0))
+        left, right = min(0.65, pan + 0.55), max(-2.8, pan - 0.70)
+        self.targets = [
+            ("front floor", [pan, down]),
+            ("left floor", [left, down]),
+            ("right floor", [right, down]),
+            ("right surroundings", [right, tilt]),
+            ("left surroundings", [left, tilt]),
+            ("return to driving view", [pan, tilt]),
+        ]
+        self.base = base.copy()
+        self.passes += 1
+        self.index, self.count, self.last_frame = 0, 0, -1
+        self.started = self.since = now
+        self.previous_mount = self.stable_since = None
+        self.views, self.reason, self.active = [], reason, True
+        # The triggering image predates the zero-velocity request. Let the
+        # base decelerate, then anchor to a newly observed stationary pose.
+        self.braking = True
+        self.brake_reference = self.brake_stable_since = None
+        self.brake_frame, self.brake_count = -1, 0
+        return True
+
+    def snapshot(self):
+        return {
+            "active": self.active,
+            "braking": self.braking,
+            "pass": self.passes,
+            "view": min(self.index + 1, len(self.targets)),
+            "total": len(self.targets),
+            "label": ("waiting for base to stop" if self.braking else
+                      self.targets[min(self.index, len(self.targets) - 1)][0] if self.targets else "idle"),
+            "settled_views": len(self.views),
+            "reason": self.reason,
+        }
+
+    def update(self, base, mount, joint, frame, now):
+        if not self.active:
+            raise RuntimeError("No active head survey")
+        if self.braking:
+            distance, angle = alignment_correction(self.base, base, np.eye(4))
+            if distance > 0.20 or angle > math.radians(20):
+                raise RuntimeError("Base exceeded head-survey braking envelope")
+            if now - self.started > 6.0:
+                raise RuntimeError("Head survey braking timed out waiting for base standstill")
+            if frame > self.brake_frame:
+                moved, turned = ((math.inf, math.inf) if self.brake_reference is None else
+                    alignment_correction(self.brake_reference, base, np.eye(4)))
+                if moved > .005 or turned > math.radians(1):
+                    self.brake_reference = np.asarray(base).copy()
+                    self.brake_stable_since, self.brake_count = now, 1
+                else:
+                    self.brake_count += 1
+                self.brake_frame = frame
+                if self.brake_count >= 3 and now - self.brake_stable_since >= .6:
+                    self.base = np.asarray(base).copy()
+                    self.braking, self.since = False, now
+            if self.braking:
+                return {"phase": "survey_braking", "target": self.base[:2, 3].copy(),
+                        "hold": True, "head_target": None, "scan_w": 0.0,
+                        "coverage": 0.0, "speed_scale": 0.5, "lookahead": .22,
+                        "survey_complete": False, "survey_label": "waiting for base to stop"}
+        distance, angle = alignment_correction(self.base, base, np.eye(4))
+        if distance > 0.05 or angle > math.radians(5):
+            raise RuntimeError("Base moved during stationary head survey")
+        if now - self.started > HEAD_SURVEY_TIMEOUT or now - self.since > HEAD_VIEW_TIMEOUT:
+            raise RuntimeError("Head survey timed out waiting for settled camera observations")
+        joint = np.asarray(joint, float)
+        if len(joint) < 11 or not np.isfinite(joint).all():
+            raise ValueError("Timestamped head joint feedback unavailable for survey")
+        label, target = self.targets[self.index]
+        complete = False
+        if frame > self.last_frame:
+            # Successful hardware actions can settle a few degrees short of
+            # their targets. Use the same four-degree allowance as the corner
+            # pitch return; geometry uses the measured image-time camera TF.
+            reached = np.max(np.abs(joint[9:11] - target)) < HEAD_TARGET_TOLERANCE_RAD
+            settled = False
+            if self.previous_mount is not None:
+                moved, turned = alignment_correction(self.previous_mount, mount, np.eye(4))
+                settled = moved < 0.005 and turned < math.radians(1)
+            self.previous_mount, self.last_frame = np.asarray(mount).copy(), frame
+            if reached and settled:
+                self.count += 1
+                self.stable_since = now if self.stable_since is None else self.stable_since
+            else:
+                self.count, self.stable_since = 0, None
+            if self.count >= 2 and now - self.stable_since >= 0.4:
+                self.views.append({"label": label, "frame_idx": int(frame), "head_joints": joint[9:11].tolist(),
+                                   "camera_in_base": np.asarray(mount).tolist()})
+                self.index += 1
+                self.since, self.count = now, 0
+                self.stable_since = self.previous_mount = None
+                if self.index == len(self.targets):
+                    self.active, complete, self.next_allowed = False, True, now + 3.0
+        return {
+            "phase": "survey_return" if label == "return to driving view" else "survey",
+            "target": self.base[:2, 3].copy(),
+            "hold": True,
+            "head_target": target,
+            "head_anchor": self.base.copy(),
+            "head_deadline": min(self.since + HEAD_VIEW_TIMEOUT, self.started + HEAD_SURVEY_TIMEOUT),
+            "scan_w": 0.0,
+            "coverage": 0.0,
+            "speed_scale": 0.5,
+            "lookahead": 0.22,
+            "survey_complete": complete,
+            "survey_label": label,
+        }

cases/20261026_goal1012_05/code/lite3_ROS/web_console/stretch_nav_viewer.py

@@ -0,0 +1,178 @@
+"""Loopback-only saved pipeline viewer; its actions never send robot commands."""
+import argparse
+from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
+import json
+from pathlib import Path
+import secrets
+import subprocess
+import threading
+
+ROOT = Path(__file__).resolve().parents[1]
+STATIC = ROOT / 'web_console/static'
+
+
+class Report:
+    def __init__(self, directory, comparison=None):
+        self.root = Path(directory).resolve()
+        kind = 'learned' if self.manifest()['learned_bev_heads_available'] else 'depth'
+        self.sources = {kind: self.root}
+        if comparison:
+            self.sources['depth'] = Path(comparison).resolve()
+        self.source = next(iter(self.sources))
+        self.token = secrets.token_urlsafe(24)
+        self.worker = None
+        self.lock = threading.Lock()
+
+    def manifest(self):
+        return json.loads((self.root / 'manifest.json').read_text())
+
+    def frame(self, index):
+        if index not in {row['id'] for row in self.manifest()['frames']}:
+            raise KeyError('Unknown saved frame')
+        return self.root / 'frames' / f'{index:08d}'
+
+    def status(self):
+        state = json.loads((self.root / 'state.json').read_text())
+        manifest = self.manifest()
+        capture = json.loads((Path(manifest['capture']) / 'capture.json').read_text())
+        return {**state, 'manifest': manifest, 'capture': capture, 'token': self.token,
+                'version': (self.root / 'manifest.json').stat().st_mtime_ns,
+                'source': self.source, 'sources': list(self.sources),
+                'replanning': self.worker is not None and self.worker.poll() is None}
+
+    def select_source(self, source):
+        with self.lock:
+            if source not in self.sources:
+                raise ValueError('Unknown BEV report')
+            if self.worker is not None and self.worker.poll() is None:
+                raise ValueError('Wait for the current replan to finish')
+            self.source, self.root = source, self.sources[source]
+
+    def replan(self, goal):
+        nodes = json.loads((self.root / 'map.json').read_text())['nodes']
+        if isinstance(goal, bool) or goal not in {n['id'] for n in nodes}:
+            raise ValueError('Choose an original permanent keyframe')
+        with self.lock:
+            if self.worker is not None and self.worker.poll() is None:
+                raise ValueError('A replan is already running')
+            manifest = self.manifest()
+            command = ['/workspace/miniforge3/envs/cross_latest/bin/python', '-u',
+                str(ROOT / 'scripts/build_stretch_nav_report.py'), '--capture', manifest['capture'],
+                '--probe', manifest['probe'], '--map-run', manifest['map_run'], '--output', str(self.root),
+                '--goal-id', str(goal)]
+            with (self.root / 'replan.log').open('ab') as log:
+                self.worker = subprocess.Popen(command, cwd=ROOT, stdin=subprocess.DEVNULL,
+                                               stdout=log, stderr=subprocess.STDOUT)
+
+
+class Handler(BaseHTTPRequestHandler):
+    def log_message(self, *_):
+        pass
+
+    def send(self, code, value, content_type='application/json'):
+        if not isinstance(value, bytes):
+            value = json.dumps(value, allow_nan=False).encode()
+        self.send_response(code)
+        self.send_header('Content-Type', content_type)
+        self.send_header('Content-Length', str(len(value)))
+        self.send_header('Cache-Control', 'no-store')
+        self.send_header('X-Content-Type-Options', 'nosniff')
+        self.send_header('Content-Security-Policy', "default-src 'self'; script-src 'self' 'unsafe-eval'; "
+                         "style-src 'self' 'unsafe-inline'; img-src 'self' data: blob:; worker-src 'self' blob:; "
+                         "connect-src 'self'; frame-ancestors 'none'")
+        self.end_headers()
+        try:
+            self.wfile.write(value)
+        except (BrokenPipeError, ConnectionResetError):
+            pass
+
+    def do_GET(self):
+        report = self.server.report
+        path = self.path.split('?', 1)[0]
+        assets = {'/': ('cross_nav.html', 'text/html; charset=utf-8'),
+                  '/cross_nav.js': ('cross_nav.js', 'text/javascript; charset=utf-8'),
+                  '/cross_nav.css': ('cross_nav.css', 'text/css; charset=utf-8'),
+                  '/vendor/plotly.min.js': ('vendor/plotly.min.js', 'text/javascript; charset=utf-8')}
+        try:
+            if path in assets:
+                file, mime = assets[path]
+                return self.send(200, (STATIC / file).read_bytes(), mime)
+            if path == '/api/status':
+                return self.send(200, report.status())
+            if path == '/api/map':
+                return self.send(200, (report.root / 'map.json').read_bytes())
+            parts = path.strip('/').split('/')
+            if len(parts) == 3 and parts[:2] == ['api', 'frame']:
+                return self.send(200, (report.frame(int(parts[2])) / 'frame.json').read_bytes())
+            if len(parts) == 4 and parts[:2] == ['api', 'bev'] and parts[3] in (
+                    'occupancy.png', 'visibility.png', 'uncertainty.png'):
+                return self.send(200, (report.frame(int(parts[2])) / parts[3]).read_bytes(), 'image/png')
+            if len(parts) == 4 and parts[:2] == ['api', 'image']:
+                manifest = report.manifest()
+                if parts[2] == 'robot':
+                    index = int(parts[3])
+                    report.frame(index)
+                    file = Path(manifest['capture']) / 'rgb' / f'{index:08d}.jpg'
+                elif parts[2] == 'phone':
+                    node = next(n for n in json.loads((report.root / 'map.json').read_text())['nodes']
+                                if n['id'] == int(parts[3]))
+                    file = Path(manifest['phone_dataset']) / 'rgb' / f"{node['frame_idx']:08d}.jpg"
+                else:
+                    raise KeyError('Unknown image source')
+                return self.send(200, file.read_bytes(), 'image/jpeg')
+            if path == '/api/live.jpg':
+                capture = Path(report.manifest()['capture'])
+                latest = json.loads((capture / 'latest.json').read_text())
+                return self.send(200, (capture / 'rgb' / f"{latest['frame_idx']:08d}.jpg").read_bytes(), 'image/jpeg')
+            return self.send(404, {'error': 'Not found'})
+        except (KeyError, OSError, StopIteration):
+            self.send(404, {'error': 'Saved pipeline data unavailable'})
+        except (ValueError, TypeError) as exc:
+            self.send(400, {'error': str(exc)})
+
+    def do_POST(self):
+        report = self.server.report
+        if self.headers.get('X-Session') != report.token:
+            return self.send(403, {'error': 'Invalid viewer session'})
+        expected = f'http://127.0.0.1:{self.server.server_port}'
+        if self.headers.get('Origin') not in (None, expected):
+            return self.send(403, {'error': 'Wrong origin'})
+        try:
+            length = int(self.headers.get('Content-Length', 0))
+            if not 0 <= length <= 2048:
+                raise ValueError('Request too large')
+            data = json.loads(self.rfile.read(length) or b'{}')
+            if self.path == '/api/goal':
+                report.replan(data.get('goal_keyframe'))
+                return self.send(202, {'status': 'replanning', 'robot_commands_sent': 0})
+            if self.path == '/api/source':
+                report.select_source(data.get('source'))
+                return self.send(200, {'source': report.source, 'robot_commands_sent': 0})
+            if self.path == '/api/stop-capture':
+                (Path(report.manifest()['capture']) / 'STOP').touch()
+                return self.send(200, {'status': 'capture_stop_requested', 'robot_commands_sent': 0})
+            self.send(404, {'error': 'Unknown action'})
+        except (ValueError, TypeError) as exc:
+            self.send(400, {'error': str(exc)})
+
+
+def main(argv=None):
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument('--report', type=Path, required=True)
+    parser.add_argument('--comparison', type=Path)
+    parser.add_argument('--port', type=int, default=8087)
+    args = parser.parse_args(argv)
+    server = ThreadingHTTPServer(('127.0.0.1', args.port), Handler)
+    server.daemon_threads = True
+    server.report = Report(args.report, args.comparison)
+    print(f'Stretch / CROSS pipeline: http://127.0.0.1:{args.port}', flush=True)
+    try:
+        server.serve_forever()
+    except KeyboardInterrupt:
+        pass
+    finally:
+        server.server_close()
+
+
+if __name__ == '__main__':
+    main()

cases/20261026_goal1012_05/code/lite3_ROS/web_console/stretch_transport.py

@@ -0,0 +1,24 @@
+"""Camera timing diagnostics. These estimates never grant a control lease."""
+
+import math
+
+
+def camera_transport_diagnostics(packet, robot, robot_received, received):
+    result = {'source_age_at_send_s': packet.get('sensor_age')}
+    if not robot:
+        return result
+    status_age = received - robot_received
+    result['status_local_age_s'] = status_age
+    if robot.get('frame_id') is not None:
+        result['source_frame_gap'] = robot['frame_id'] - packet['frame_id']
+    # Both source stamps use the robot's ROS clock. Avoid comparing clocks on
+    # different hosts. Unknown status transit time makes this a lower bound
+    # under a steady ROS clock, rather than an exact one-way network latency.
+    ros_now = robot.get('ros_now_s')
+    stamp = packet.get('sensor_stamp')
+    if ros_now is not None and stamp is not None and 0 <= status_age < .5:
+        age = ros_now + status_age - stamp
+        if math.isfinite(age):
+            result['source_age_via_status_s'] = age
+            result['post_publish_delay_via_status_s'] = age - packet.get('sensor_age', 0.)
+    return result

cases/20261026_goal1012_05/code/lite3_ROS/web_console/stretch_vggt_debug.py

@@ -0,0 +1,401 @@
+"""Lossless, disk-backed VGGT inference archives without changing CROSS source."""
+
+from __future__ import annotations
+
+import functools
+import hashlib
+import inspect
+import json
+import math
+import queue
+import subprocess
+import threading
+import time
+import zipfile
+from pathlib import Path
+
+import numpy as np
+
+
+def model_provenance(cross_root):
+    root = Path(cross_root).resolve()
+    revision = subprocess.run(["git", "-C", str(root), "rev-parse", "HEAD"],
+                              check=True, capture_output=True, text=True).stdout.strip()
+    files = {}
+    for name in ("vggt_omega_cross_1b_512.pt", "nav/cross_nav_occupancy.pt", "nav/cross_nav_observability.pt"):
+        path = root / "models/VGGT-Omega-CROSS" / name
+        digest = hashlib.sha256()
+        with path.open("rb") as stream:
+            for block in iter(lambda: stream.read(8 * 1024 * 1024), b""):
+                digest.update(block)
+        files[name] = {"bytes": path.stat().st_size, "sha256": digest.hexdigest()}
+    return {"cross_git_revision": revision, "checkpoints": files}
+
+
+def snapshot(value):
+    """Own CPU copies: CUDA-graph outputs and planner buffers are reused."""
+    if isinstance(value, np.ndarray):
+        if value.dtype.hasobject:
+            raise TypeError("Object arrays are not permitted in VGGT debug archives")
+        return value.copy()
+    if hasattr(value, "detach"):
+        tensor = value.detach().cpu()
+        # Every bfloat16 value is represented exactly by float32.
+        if str(tensor.dtype) == "torch.bfloat16":
+            tensor = tensor.float()
+        return tensor.numpy().copy()
+    if isinstance(value, np.generic):
+        return value.item()
+    if isinstance(value, dict):
+        return {str(key): snapshot(item) for key, item in value.items()}
+    if isinstance(value, (tuple, list)):
+        return [snapshot(item) for item in value]
+    if value is None or isinstance(value, (str, bool, int, float)):
+        return value
+    raise TypeError(f"Unsupported VGGT debug value: {type(value).__name__}")
+
+
+def atomic_json(path, data):
+    temporary = path.with_suffix(path.suffix + ".tmp")
+    temporary.write_text(json.dumps(data, indent=2, allow_nan=False) + "\n")
+    temporary.replace(path)
+
+
+def write_npz(path, arrays):
+    """Fast, lossless ZIP compression; no pickle and no reduced precision."""
+    temporary = path.with_suffix(path.suffix + ".tmp")
+    with zipfile.ZipFile(temporary, "w", compression=zipfile.ZIP_DEFLATED, compresslevel=1) as archive:
+        for key, array in arrays.items():
+            with archive.open(key + ".npy", "w", force_zip64=True) as stream:
+                np.lib.format.write_array(stream, np.asarray(array), allow_pickle=False)
+    temporary.replace(path)
+
+
+def pack(value, arrays, name="data"):
+    if isinstance(value, np.ndarray):
+        key = name.replace("/", "_")
+        if key in arrays:
+            raise ValueError(f"Duplicate archive array key: {key}")
+        arrays[key] = value
+        return {"npz_key": key, "shape": list(value.shape), "dtype": str(value.dtype)}
+    if isinstance(value, dict):
+        return {key: pack(item, arrays, f"{name}.{key}") for key, item in value.items()}
+    if isinstance(value, list):
+        return [pack(item, arrays, f"{name}.{index}") for index, item in enumerate(value)]
+    if isinstance(value, float) and not math.isfinite(value):
+        return {"nonfinite": str(value)}
+    return value
+
+
+class _RecordingHead:
+    def __init__(self, original, recorder):
+        self.original, self.recorder = original, recorder
+        self.signature = inspect.signature(original)
+
+    def __getattr__(self, name):
+        return getattr(self.original, name)
+
+    def __call__(self, *args, **kwargs):
+        result = self.original(*args, **kwargs)
+        recorder = self.recorder
+        if recorder.current is not None:
+            started = time.perf_counter()
+            if recorder.active_pass is None:
+                raise RuntimeError("BEV prediction has no matching recorded VGGT pass")
+            bound = self.signature.bind(*args, **kwargs)
+            bound.apply_defaults()
+            keys = ("pts", "patch_hw", "hw", "log_scale", "up_cam", "views")
+            recorder.active_pass["head_calls"].append({
+                "inputs": snapshot({key: bound.arguments.get(key) for key in keys}),
+                "outputs": snapshot(result),
+            })
+            recorder.copy_s += time.perf_counter() - started
+        return result
+
+
+class VggtDebugRecorder:
+    """Archive every actual pass, with bounded asynchronous compression.
+
+    Hooks delegate unchanged and return the original objects. No robot or
+    network transport is imported. A full queue or write failure is explicit;
+    a live caller can close navigation rather than silently lose debug data.
+    """
+
+    def __init__(self, directory, metadata=None, *, on_error=None, max_pending=8):
+        if max_pending < 1:
+            raise ValueError("VGGT debug queue must have a positive bound")
+        self.root = Path(directory).resolve()
+        self.root.mkdir(parents=True, exist_ok=False)
+        (self.root / "views").mkdir()
+        (self.root / "frames").mkdir()
+        self.on_error = on_error
+        self.pending = queue.Queue(maxsize=max_pending)
+        self.error = None
+        self.run_error = None
+        self.closed = False
+        self.current = self.active_pass = None
+        self.hooks = []
+        self.assets = set()
+        self.frames = self.passes = self.bytes = 0
+        self.write_s = self.copy_s = 0.0
+        self.submitted = set()
+        self.started = time.time()
+        atomic_json(self.root / "run.json", {
+            "schema_version": 1, "created_unix": self.started, "metadata": metadata or {},
+            "input_encoding": "Exact per-view CHW tensors; shared content-addressed lossless NPZ assets",
+            "bfloat16_storage": "Converted losslessly to float32; original dtype recorded on inference inputs",
+            "outputs": "Geometry predictions, raw float BEV-head outputs, consumed BEV, base grid and planner state",
+            "intermediate_transformer_tokens_saved": False,
+            "write_policy": "Bounded asynchronous lossless compression; no sampling or silent drops",
+        })
+        self._status("running")
+        self.worker = threading.Thread(target=self._worker, name="vggt-debug-writer", daemon=True)
+        self.worker.start()
+
+    def _status(self, phase):
+        atomic_json(self.root / "status.json", {
+            "status": phase, "frames": self.frames, "passes": self.passes,
+            "unique_views": len(self.assets), "bytes": self.bytes,
+            "write_s": self.write_s, "snapshot_s": self.copy_s,
+            "queued_frames": self.pending.qsize(), "error": str(self.error) if self.error else None,
+            "run_error": self.run_error,
+        })
+
+    def check(self):
+        if self.error is not None:
+            raise RuntimeError(f"VGGT debug archive failed: {self.error}") from self.error
+        if self.closed:
+            raise RuntimeError("VGGT debug archive is closed")
+
+    def attach(self, estimator):
+        import torch
+
+        self.check()
+        backend = estimator.backend
+        if not callable(getattr(backend, "infer", None)) or not callable(getattr(backend, "nav", None)):
+            raise ValueError("VGGT debug capture requires a backend with infer() and an enabled BEV head")
+        original_infer = backend.infer
+        infer_signature = inspect.signature(original_infer)
+        original_estimate = estimator.estimate_pose
+        estimate_signature = inspect.signature(original_estimate)
+        run = json.loads((self.root / "run.json").read_text())
+        run["runtime"] = {"torch": str(torch.__version__), "cuda": torch.version.cuda,
+                          "backend": type(backend).__name__, "estimator": type(estimator).__name__,
+                          "cuda_graphs": bool(getattr(backend, "cuda_graphs", False)),
+                          "compiled": bool(getattr(backend, "_compiled", False))}
+        atomic_json(self.root / "run.json", run)
+
+        @functools.wraps(original_infer)
+        def infer(images, *args, **kwargs):
+            if self.current is None:
+                return original_infer(images, *args, **kwargs)
+            started = time.perf_counter()
+            self.active_pass = {"images": snapshot(images), "image_dtype": str(images.dtype), "head_calls": []}
+            self.current["passes"].append(self.active_pass)
+            self.copy_s += time.perf_counter() - started
+            try:
+                result = original_infer(images, *args, **kwargs)
+            except BaseException as exc:
+                self.active_pass["inference_error"] = str(exc)
+                raise
+            started = time.perf_counter()
+            try:
+                bound = infer_signature.bind(images, *args, **kwargs)
+                bound.apply_defaults()
+                names = ("c2w", "K", "depth", "depth_conf", "hw", "covis", "log_scale")
+                prediction = {name: getattr(result, name, None) for name in names}
+                nav = getattr(backend, "last_nav", None)
+                self.active_pass.update({
+                    "infer_args": snapshot({key: bound.arguments.get(key) for key in ("n_depth", "focal")}),
+                    "effective_calib_focal": snapshot(getattr(backend, "calib_focal", None)),
+                    "prediction": snapshot(prediction),
+                    "pose_encoding": snapshot(nav.get("pose_enc")) if nav else None,
+                })
+            finally:
+                self.copy_s += time.perf_counter() - started
+            return result
+
+        @functools.wraps(original_estimate)
+        def estimate(*args, **kwargs):
+            if self.current is None:
+                return original_estimate(*args, **kwargs)
+            begin = len(self.current["passes"])
+            bound = estimate_signature.bind(*args, **kwargs)
+            bound.apply_defaults()
+            anchor = bound.arguments.get("odom_anchor")
+            context = {key: bound.arguments.get(key) for key in ("ref_rel_poses", "ref_cam_ids")}
+            context["source_context"] = bound.arguments.get("kwargs", {})
+            context["odom_anchor"] = ({key: value for key, value in anchor.items()
+                                       if key not in ("image", "extra_images")} if anchor else None)
+            result = original_estimate(*args, **kwargs)
+            calls = self.current["passes"][begin:]
+            for index, call in enumerate(calls):
+                call["estimate_context"] = snapshot(context)
+                call["estimator_info"] = snapshot(getattr(estimator, "last_info", {})) if index == 0 else {}
+                call["principal_point_rotation"] = snapshot(getattr(estimator, "_R_model_to_cam", None))
+                call["camera_calibrations"] = snapshot(getattr(estimator, "_cameras", None))
+                if index == 0:
+                    poses, valid, confidence = result
+                    call["relative_pose_result"] = snapshot({
+                        "poses": poses.matrix() if hasattr(poses, "matrix") else poses,
+                        "valid": valid, "confidence": confidence,
+                    })
+            return result
+
+        self._replace(backend, "infer", infer)
+        self._replace(estimator, "estimate_pose", estimate)
+        self._replace(backend, "nav", _RecordingHead(backend.nav, self))
+
+    def _replace(self, owner, name, replacement):
+        self.hooks.append((owner, name, name in vars(owner), vars(owner).get(name)))
+        setattr(owner, name, replacement)
+
+    def begin_frame(self, raw):
+        self.check()
+        if self.current is not None:
+            raise RuntimeError("Previous VGGT debug frame was not completed")
+        number = int(raw["frame_idx"])
+        if number < 0 or number in self.submitted:
+            raise ValueError("VGGT debug frame IDs must be unique and nonnegative")
+        self.current = {"capture_frame": number, "source": snapshot({key: value for key, value in raw.items()
+                        if key not in ("rgb_jpg", "depth_png")}), "passes": []}
+        self.active_pass = None
+
+    def finish_frame(self, **outputs):
+        self.check()
+        if self.current is None:
+            raise RuntimeError("No current VGGT debug frame")
+        started = time.perf_counter()
+        self.current["outputs"] = snapshot(outputs)
+        self.copy_s += time.perf_counter() - started
+        job, self.current, self.active_pass = self.current, None, None
+        try:
+            self.pending.put_nowait(job)
+        except queue.Full as exc:
+            self.current = job
+            raise RuntimeError("VGGT debug writer cannot keep up; no frames were silently dropped") from exc
+        self.submitted.add(job["capture_frame"])
+
+    def _view(self, image):
+        image = np.ascontiguousarray(image)
+        digest = hashlib.sha256(str((image.dtype.str, image.shape)).encode() + image.tobytes()).hexdigest()
+        if digest not in self.assets:
+            path = self.root / "views" / f"{digest}.npz"
+            write_npz(path, {"image": image})
+            self.bytes += path.stat().st_size
+            self.assets.add(digest)
+        return {"asset": digest, "shape": list(image.shape), "dtype": str(image.dtype)}
+
+    def _write(self, job):
+        started = time.perf_counter()
+        number = job["capture_frame"]
+        directory = self.root / "frames" / f"{number:08d}"
+        directory.mkdir()
+        audit = job.get("outputs", {}).get("observation", {}).get("retrieval", [])
+        for call in job["passes"]:
+            images = call.pop("images")
+            tags = call.get("estimator_info", {}).get("view_tags", [])
+            call["views"] = []
+            for index, image in enumerate(images):
+                tag = tags[index] if index < len(tags) else f"view_{index}"
+                view = {"index": index, "role": tag, **self._view(image)}
+                if tag.startswith("ref") and tag.endswith("_L"):
+                    reference = int(tag[3:-2])
+                    if reference < len(audit):
+                        view["reference"] = audit[reference]
+                call["views"].append(view)
+        arrays = {}
+        data = pack(job, arrays)
+        write_npz(directory / "arrays.npz", arrays)
+        # This JSON is the completion marker, written after all referenced assets.
+        atomic_json(directory / "frame.json", data)
+        with (self.root / "index.jsonl").open("a") as stream:
+            stream.write(json.dumps({"capture_frame": number, "passes": len(job["passes"]),
+                                     "file": f"frames/{number:08d}/frame.json"}) + "\n")
+        self.frames += 1
+        self.passes += len(job["passes"])
+        self.bytes += sum(path.stat().st_size for path in directory.iterdir())
+        self.write_s += time.perf_counter() - started
+        self._status("running")
+
+    def _worker(self):
+        while True:
+            job = self.pending.get()
+            try:
+                if job is None:
+                    return
+                if self.error is None:
+                    self._write(job)
+            except BaseException as exc:
+                self.error = exc
+                if self.on_error:
+                    try:
+                        self.on_error(exc)
+                    except Exception as callback_error:
+                        self.error = RuntimeError(f"{exc}; archive error callback also failed: {callback_error}")
+            finally:
+                self.pending.task_done()
+
+    def close(self, error=None):
+        if self.closed:
+            return
+        self.run_error = str(error) if error else None
+        # Retain an interrupted inference and whatever outputs were available.
+        if self.current is not None:
+            job, self.current = self.current, None
+            job["interrupted"] = str(error) if error else "Frame interrupted before completion"
+            self.pending.put(job)
+        for owner, name, existed, value in reversed(self.hooks):
+            if existed:
+                setattr(owner, name, value)
+            else:
+                delattr(owner, name)
+        self.hooks.clear()
+        self.active_pass = None
+        self.pending.put(None)
+        self.worker.join()
+        self.closed = True
+        self._status("failed" if self.error else "closed")
+        if self.error is not None:
+            raise RuntimeError(f"VGGT debug archive failed: {self.error}") from self.error
+
+
+def planner_snapshot(episode):
+    result = {key: getattr(episode, key, None) for key in
+              ("pose", "expect", "bumps", "route", "route_age", "no_route", "side", "log_scale", "n_bumps")}
+    world = getattr(episode, "world", None)
+    result["world"] = ({key: getattr(world, key) for key in ("o", "num", "den", "seen", "c")}
+                       if world is not None else None)
+    return result
+
+
+def load_debug_frame(directory, number):
+    root = Path(directory).resolve()
+    frame = root / "frames" / f"{int(number):08d}"
+    if int(number) < 0 or frame.resolve().parent != (root / "frames").resolve():
+        raise ValueError("Invalid debug frame")
+    data = json.loads((frame / "frame.json").read_text())
+    with np.load(frame / "arrays.npz", allow_pickle=False) as archive:
+        def unpack(value):
+            if isinstance(value, dict):
+                if "npz_key" in value:
+                    array = archive[value["npz_key"]].copy()
+                    if list(array.shape) != value["shape"] or str(array.dtype) != value["dtype"]:
+                        raise ValueError("VGGT debug array metadata mismatch")
+                    return array
+                return {key: unpack(item) for key, item in value.items()}
+            if isinstance(value, list):
+                return [unpack(item) for item in value]
+            return value
+        return unpack(data)
+
+
+def load_debug_view(directory, asset):
+    if len(asset) != 64 or any(char not in "0123456789abcdef" for char in asset):
+        raise ValueError("Invalid VGGT view asset")
+    root = Path(directory).resolve()
+    path = root / "views" / f"{asset}.npz"
+    if path.resolve().parent != (root / "views").resolve():
+        raise ValueError("VGGT view asset escapes archive")
+    with np.load(path, allow_pickle=False) as archive:
+        return archive["image"].copy()

cases/20261026_goal1012_05/code/stretch_ai/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2024 Hello Robot, Inc.
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.