Add Stretch navigation debug case with VGGT tensors, sensor recording and replay

README.md

@@ -0,0 +1,194 @@
+---
+pretty_name: CROSS navigation debug — Stretch head survey and graph attachment
+language:
+  - en
+tags:
+  - robotics
+  - navigation
+  - vggt
+  - rgb-d
+  - odometry
+  - debugging
+---
+
+# CROSS navigation debug
+
+A self-contained recording of a supervised Stretch navigation run on **2026-10-26 (Asia/Singapore)**,
+targeting phone-map keyframe **1012**, including the exact VGGT inputs and outputs.
+
+**Observed failure:** during a left/down head survey, localization remained committed, but the local
+Stretch adapter's measured-depth check rejected every nearby connection to the reference map graph.
+The adapter then stopped with `no global route; navigation ended`.
+This dataset does **not** establish a bug in native CROSS or its learned BEV head. It includes those
+outputs, the adapter and the depth evidence so their interaction can be investigated.
+
+| Item | Included |
+|---|---|
+| Run | `stretch_cross_nav_live_20261026_goal1012_02` |
+| Actual navigation | 114.44 s; 7.88 m odometry distance; goal not reached |
+| Final camera XY distance to goal | 5.56 m |
+| Sensor recording | 680 synchronized RGB + aligned depth frames, intrinsics, odometry, camera/base TF, timestamped head joints |
+| Published processing records | 381, with 380 actual VGGT inference passes |
+| VGGT inputs | 429 unique lossless tensors, referenced 2,662 times across the input groups |
+| BEV replay | 380 original occupancy/observability/uncertainty image sets |
+| Numeric outputs | VGGT predictions, raw navigation heads, consumed camera BEV, base BEV and native planner memory |
+| Reference map | Record3D `2026-10-22--15-48-58`, including native map and its image/descriptor store |
+| Additional evidence | Measured obstacles, footprint snapshots, routes, retrieval results, control commands, robot status, transport timings, resolved configs and shutdown audit |
+| Source | Native CROSS commit `4781371e6f4db4241be0a0df7c238436680ee268`, local adapter, relay, inspector, replay viewer and relevant tests |
+
+The recording uses RGB and external odometry for CROSS. Measured robot depth is used separately by
+the adapter's execution/attachment checks. There is no separate raw IMU stream in this case.
+The phone map and robot odometry are estimates, not ground truth.
+
+## Start with the failure frames
+
+Indices below are **capture frame indices**, not reference-map keyframe IDs or robot source-frame IDs.
+Robot source-frame ID is capture index + 1 in this run.
+
+| Frame | Capture-relative time | Observation |
+|---|---:|---|
+| 639 | 159.88 s | Stationary head survey starts after a learned-path footprint veto |
+| 661 | 165.35 s | Front/down view accepted as settled; left/down target begins |
+| 675 | 168.89 s | Still localized; seven graph attachments survive the depth check |
+| 677 | 169.39 s | Still localized; zero attachments survive; exact obstacle evidence saved |
+| 679 | 169.89 s | Final observation; localized, nearest map keyframe 1057 about 0.183 m away, zero attachments |
+
+The attachment radius is 0.75 m. Empty attachments are produced by the local adapter before its
+execution gate stops navigation. `tools/analyze_attachment.py` rechecks the recorded depth veto
+without loading a model or executing robot commands. Whether the returns are physical obstacles,
+robot self observations, depth noise or accumulated old returns remains to be diagnosed.
+
+The earlier multi-second camera lag did **not** recur in this case. Estimated source age at PC
+receipt was 83 ms median / 131 ms p95. The source-age estimate is a lower bound based on a recent
+robot status sample, not a subtraction of wall clocks across computers.
+
+VGGT's seven input views at failure frame 677:
+
+![Frame 677 VGGT input group](previews/00000677/input_views.jpg)
+
+Raw head output, consumed camera BEV, and reprojected robot-base BEV at the same frame:
+
+![Frame 677 BEV stages](previews/00000677/bev_stages.png)
+
+Additional input/depth/BEV previews are in [`previews/`](previews).
+Small reports are directly browsable in [`reports/`](reports/stretch_cross_nav_live_20261026_goal1012_02).
+
+## Download and inspect
+
+```bash
+hf download jizhuochen/CROSS_nav_debug --repo-type dataset --local-dir CROSS_nav_debug
+cd CROSS_nav_debug
+python tools/unpack.py --output extracted
+```
+
+The unpacker verifies every archive's SHA-256, validates the individual run/map members and extracts
+into a new directory, including CROSS's validated relative package alias. Approximately 3.5 GB is
+downloaded; allow another 3.5 GB for extraction.
+Use a Python environment with `numpy` and `opencv-python` for the viewer/inspector. The full recorded
+environment is in `environment/pip_freeze.txt`; it is a version record, not a portable installer.
+
+Replay the recorded RGB, map/route, and BEV with zoom/rotation and layer controls:
+
+```bash
+python code/lite3_ROS/scripts/view_stretch_cross_nav_live_run.py \
+  --run extracted/runs/stretch_cross_nav_live_20261026_goal1012_02 --port 8088
+```
+
+Open <http://127.0.0.1:8088> and click **Replay recording**. This viewer opens no robot connection,
+loads no model and cannot arm navigation.
+
+Export exact model input tensors, an input contact sheet, predicted depth and the BEV stages:
+
+```bash
+python code/lite3_ROS/scripts/inspect_stretch_vggt_debug.py \
+  --debug extracted/runs/stretch_cross_nav_live_20261026_goal1012_02/vggt_debug \
+  --frame 677 --output inspection_677
+
+python tools/analyze_attachment.py --extracted extracted --frame 677
+```
+
+## Data layout
+
+The nine archives are independent download units; the VGGT numeric frames are split into three
+shards of at most about 700 MiB. Extract **all** archives to obtain the complete case.
+
+```text
+archives/
+  run_core.tar.gz          # run/query map, replay BEVs, logs, footprint evidence, configs
+  capture.tar              # exact recorded JPEG RGB and uint16 PNG depth, raw observations
+  vggt_metadata.tar.gz     # run provenance, frame index, planner config, writer status
+  vggt_views.tar           # lossless content-addressed VGGT input tensors
+  vggt_frames_000.tar      # per-frame manifest + numeric outputs (three shards)
+  vggt_frames_001.tar
+  vggt_frames_002.tar
+  reference_map.tar       # original phone map and complete .store sidecar
+  CROSS_source.tar.gz      # frozen native source, with upstream license
+code/                     # local adapter/relay/replay/inspection source and tests
+environment/              # versions, GPU information, source provenance
+reports/                  # directly browsable diagnostic logs and summaries
+previews/                 # selected VGGT input groups, depth and BEV stages
+manifest.json             # archive/member sizes, SHA-256 hashes, extraction paths
+SHA256SUMS                # checksums for every published file other than this checksum file
+tools/                    # verified extraction and offline attachment diagnosis
+```
+
+Extraction creates `runs/<run-id>/`, `maps/record3d_mapping_20261022_154858/` and `source/CROSS/`.
+
+### VGGT archive schema
+
+`vggt_debug/frames/<capture-index>/frame.json` describes each call and references arrays in the
+same directory's `arrays.npz`. Each actual call records its view order/roles, reference IDs where
+available, and links to `vggt_debug/views/<sha256>.npz`.
+
+These are the exact RGB CHW floating-point tensors **after CROSS preprocessing**. References may
+be retrieved map/session keyframes or an accepted anchor; they are not necessarily adjacent video
+frames. Repeated inputs are deduplicated without JPEG recompression or clipping resize overshoot.
+One processing record has zero model passes and is not assigned another frame's predictions.
+
+Outputs include the model's camera poses/intrinsics, depth/confidence, covisibility and scale
+fields where returned; raw occupancy/observability/uncertainty heads and gravity/metric fields;
+the actual BEV consumed by navigation; base-frame reprojection; and planner world-map accumulators
+and configuration. The source includes `load_debug_frame` and `load_debug_view` to restore the
+manifest/NPZ structure without pickle.
+
+### Geometry and timing
+
+Saved RGB and aligned depth are 480 pixels wide by 640 high after the relay's 90-degree clockwise
+rotation. Intrinsics and the optical transform were rotated consistently. Depth PNG values are
+uint16 millimetres. `camera_pose` is `T_odom_camera`, `base_pose_matrix` is `T_odom_base`, and
+`camera_in_base` is `T_base_camera`. All three are homogeneous 4x4 transforms.
+Camera/base TF and head joints are associated with the source image timestamp. Head pan/tilt
+changes therefore use the measured image-time extrinsic, not the requested head target.
+
+The reference map has its own coordinate system; use the saved map alignment/display transforms
+rather than assuming its axes match robot odometry. Source sensor stamps use the robot clock;
+receipt timestamps use the PC clock. `capture/transport.jsonl`, `robot_status.jsonl` and
+`network.jsonl` retain the measurements needed to distinguish those stages.
+
+## Reproduction scope and provenance
+
+Native CROSS source was unchanged. The local adapter adds route attachment, remaining-route cost,
+head surveying, measured-depth/footprint vetoes and command freshness checks. These policies and
+the final execution gate are included in `code/lite3_ROS/`; the robot-side lease and head action
+handoff are included in `code/stretch_ai/`. The Git HEAD of the adapter alone is insufficient:
+its relevant local source was uncommitted and is included directly.
+
+The configured maximum base speeds were 0.10 m/s and 0.25 rad/s, source evidence expired after
+1.2 s, and the execution footprint was 0.46 m wide. This case does not validate completion of all
+six survey views or arrival at the goal.
+
+The recorded model outputs can be inspected entirely offline. Re-running a model needs the native
+CROSS environment and the pretrained files from
+[Jamie-nus/VGGT-Omega-CROSS](https://huggingface.co/Jamie-nus/VGGT-Omega-CROSS).
+Their repository revision and individual SHA-256 hashes are in
+`reports/stretch_cross_nav_live_20261026_goal1012_02/vggt_provenance.json`.
+The checkpoint weights are not duplicated in this dataset.
+
+Arrays, RGB/depth images and native image/descriptor stores are byte-identical to the source recording.
+Sharing copies of text metadata/source have session credentials, local absolute paths and private
+interface addresses removed or replaced with portable/documentation values. Numerical transforms,
+timestamps, commands and predictions are preserved. Three model paths inside the query map's config
+were also made portable; every numerical map column was verified byte-identical. The original and
+shared map-container hashes are recorded in `environment/map_metadata_sanitization.json`.
+Source files retain their upstream licenses;
+no additional recording license is asserted here.

SHA256SUMS

@@ -0,0 +1,98 @@
+e97427af55a3cb4e014152ed6a512e5827ba5cd84daf38b0aafe25ce77a2917e  README.md
+c3dd418506684ae4b05b49daeeb6456509d1542621911e0029fa6c420d75c64b  archives/CROSS_source.tar.gz
+de8a67ce4a2f83967e3115038c128c270568475139b2bc5ae12f067e92db0417  archives/capture.tar
+3876fa21325aea0a41dba3f647a8645815ed9f431c3e3e399e8a3f3d47768200  archives/reference_map.tar
+afbd7f8dd07e62358316abd6d6fe8535376c28ddca90dbb1fa3dc363e79c551e  archives/run_core.tar.gz
+a53a2227a4b83fb50fd1bcec93130898312c19501c76ea848cf8b0528638b8c8  archives/vggt_frames_000.tar
+e8eaf555b391a5583eb22dbacd49b347cfa7a20f0536738942c9bee2352364d5  archives/vggt_frames_001.tar
+591ad815693b373535d3a41dd5c936adc6b31824e62942c14fb102cd7e5aa6a4  archives/vggt_frames_002.tar
+4f348ad90455e177818d9b542f15e1feed0100a7082117fd9f5bf0b4ba92dd38  archives/vggt_metadata.tar.gz
+179fc2cfea7987908b4d71c743d9c9bcba2e7bfc3a195cf24258a7e7ce79caf0  archives/vggt_views.tar
+49a6e137748b934e2f78b15cf74704fd8fdcb26107c5d210d783648287345750  code/lite3_ROS/LICENSE
+7e861070432a0da598c7e4974397c162df0582df0c94da41dd6e09efc7efcf27  code/lite3_ROS/scripts/capture_stretch_cross.py
+5445e49f09b7891d3ecf962aba966bf748dd50cba931df0382e1d416db1f04f3  code/lite3_ROS/scripts/inspect_stretch_vggt_debug.py
+bd96b963b13835dd45b3f3125e2893b8562971443782b29b1f86e6cf06c51fb8  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
+a92a704acfb8c5fa19fdd695114877da2b5ca315282782e518da50d22b24b942  code/lite3_ROS/tests/test_stretch_nav_control.py
+235a2d70fa9a747de21c4478f5676d43211c1451188e83829c085432a5d11310  code/lite3_ROS/tests/test_stretch_nav_geometry.py
+3dca0e20341b3b69c755022b144c81b0565cad1f47ea7d05b7b6d4d8d59ba09d  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
+cd219a565a5336cad8ab3dbe78c58cb5283f34fb7b966ab834d4982cccac3f4e  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
+fd175e65c176cac29a608d8e3457df0dc69d0b41f692ac511ea38eecbec67a4b  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
+b04985fb1dd67d3127a4b1d52e8571d9a9b5278d289909f6bedc464348ead7fa  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
+7b9c6018f60f9cb69e0c3209807730e02dc3d645ceedd7d1e5a16527d1845137  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
+0708446d8e711385c863f786140b6fd652a190b51996337e9d383f90b435d91c  environment/map_metadata_sanitization.json
+a356da246ff7accf3b5d70291af194283a4a0ee7597a7fad7d1bcbbc42cf58ca  environment/package_validation.json
+a1a25eb20977a72f4ac346c77a936fa5d46e5701b53968db49b73185f3675b29  environment/pip_freeze.txt
+372e5c3211d1d89eb2b2a8cb859318de6f15220cf698d3b66cfbcd51827a028f  environment/provenance.json
+fc7336eeaa5742ec7efb4992b0ec69bdfc2958842cd70697b2095c284f5c2a0f  manifest.json
+468878cb4d630572fc329124ebbb7605b1f7a8b4f0d4085b560f213b8d63b041  previews/00000639/bev_stages.png
+c511a8ec01080bdfbacea7ac7588f1444d731207d5c8b102968549acaf890919  previews/00000639/input_views.jpg
+9000cce2c9559440ae71f2f7dc060833551a9f1db5a770b871dbb7f74045357e  previews/00000639/manifest.json
+bc522a97a003e7ddc4865f34bce426e49a304a2927d6f269794615baa5679dcd  previews/00000639/predicted_depth.jpg
+819f072d6633fa81d4c7e982d4be595f7032bd4fbc85fae30c52e81e25b33895  previews/00000661/bev_stages.png
+62f088a3a6036fb982661bc2155374a2040ce88e4339fbf95883010a65770648  previews/00000661/input_views.jpg
+672acf70114d1ce6daa7a35db0be56626893b0f3f8c5af847aa48d64909c82c5  previews/00000661/manifest.json
+b357b896f4a88467727fe3b5359f287681ff587fe64cb7dec2cebdff5452a5ae  previews/00000661/predicted_depth.jpg
+0af1e69225ddfd72af3ef2fe8e72372455e8994512f867a7d052674ee561bfa1  previews/00000675/bev_stages.png
+e544c382af38e2be2a3afb5caaf6d03c337f5b9593038431f45630b5f37e82f1  previews/00000675/input_views.jpg
+e41074441c24d09571d0f45b0cd138fff9f693912e501c35eaf404f6a6b3ee82  previews/00000675/manifest.json
+ce984e80fa4db5b1a07a44e35859cf0a1d3fd634ae0cc5cb80d55012895d292b  previews/00000675/predicted_depth.jpg
+82284933280f515528500f623cdaccb642dde780c20d79dfbd528085b4c5981e  previews/00000677/bev_stages.png
+e29732687f29b4cf1524bb4702b8268a0a3a3a20e23125df209b90ef67206a95  previews/00000677/input_views.jpg
+c43e354b0981c59d2bb7bcd4df6e86de0fc677a61c8d564b34e7150a07f2ab21  previews/00000677/manifest.json
+fcc8e24d72ad8075b8549b3f3300929949c8599391aadc35aaf498eff00e2465  previews/00000677/predicted_depth.jpg
+eed6c9c4833a365424f3a458c29dbfaf1eb6b540a64482b2e0d28b0bcc4a22f9  previews/00000679/bev_stages.png
+a4a13fc1b431c5156dd02bb0ffc9859df0d1f6a28b1b5946047a9997fb8282ed  previews/00000679/input_views.jpg
+b7d0a352938fac7ac91105c1de055d07fe6f95cb402f6cef04a66c0e447700d9  previews/00000679/manifest.json
+bbcce73232fb26a9c355ebf3fc34c57c288b64773ae35d74d74635932cd4e46a  previews/00000679/predicted_depth.jpg
+cfb8a01ca341bc569fcb5b705c65fc6abe6037c59af4081f7f6871c988aa612e  reports/stretch_cross_nav_live_20261026_goal1012_02/attachment_recheck_677.json
+0ca8f075c93b12f217cb1c2fb33da71440cb0f9f90bf6faca14b44e098399fbb  reports/stretch_cross_nav_live_20261026_goal1012_02/events.jsonl
+e6217b3684ec4a811ca17334383b01d972f427737e289ec8e47db55c060d8f06  reports/stretch_cross_nav_live_20261026_goal1012_02/observations.jsonl
+1f52f5ab6c9bb5bf1286e8fd4ad63c8cefe04b7dba735e4e2ad8225ae05e3d03  reports/stretch_cross_nav_live_20261026_goal1012_02/recording_validation.json
+7cda24b9b0b0ea413c7b12ad463be3422893613465c2503eb35ec9f7669fcdda  reports/stretch_cross_nav_live_20261026_goal1012_02/resolved_bev_config.json
+a0757b71bb1b6aabc84112af4096dbb6b7b0b1613847994d03347eddf3de30f9  reports/stretch_cross_nav_live_20261026_goal1012_02/robot_relay_close.json
+91560292266b5a8a9b729dc581d32efc604ce0511a1d2fcf8317ee57e1e8f292  reports/stretch_cross_nav_live_20261026_goal1012_02/stop_audit.json
+88853550fed8b33883ffb84b9e92ab64313c3c8fd6453e8d40e3772ed5c3ec52  reports/stretch_cross_nav_live_20261026_goal1012_02/summary.json
+7786d1b64351eba77c1c35d2c45045f416cb03938d36575c3ea9cb2d0a9e43b8  reports/stretch_cross_nav_live_20261026_goal1012_02/vggt_index.jsonl
+b54449df6550926b70d7d6e9928b883dabab0bc494baedbf8ded7da797bc7422  reports/stretch_cross_nav_live_20261026_goal1012_02/vggt_provenance.json
+8f71c7695c695101660353dccf0a238b838ca7f916674eb6fd4a85f6a97fed6b  tools/analyze_attachment.py
+a6ce163de4ef4f52ded94f91f2aa5b64385ceebacd2bb5fb16dba950017f3b8d  tools/unpack.py

archives/CROSS_source.tar.gz

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

archives/capture.tar

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

archives/reference_map.tar

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

archives/run_core.tar.gz

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

archives/vggt_frames_000.tar

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

archives/vggt_frames_001.tar

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

archives/vggt_frames_002.tar

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

archives/vggt_metadata.tar.gz

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

archives/vggt_views.tar

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

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.

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

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

code/lite3_ROS/scripts/live_stretch_cross_nav.py

@@ -0,0 +1,936 @@
+#!/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.
+"""
+import argparse
+from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
+import json
+import math
+import os
+import pickle
+from pathlib import Path
+import secrets
+import signal
+import sys
+import threading
+import time
+from types import SimpleNamespace
+import uuid
+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 (PlanWait, attachment_clear,
+    competing_controllers, depth_obstacles, depth_veto,
+    execution_gate, remaining_path, wrap)
+from web_console.stretch_nav_geometry import body_to_world, world_to_body
+from web_console.stretch_nav_footprint import command_footprint_report, depth_support
+from web_console.stretch_nav_learned import learned_png, reproject_bev
+from web_console.stretch_nav_report import SavedRoute, clean_json, positions, save_json
+from web_console.stretch_nav_replay import ReplayService, save_bev_frame
+from web_console.stretch_nav_recovery import (CorrectionRecovery, CornerObserver, MeasuredObstacleMemory, camera_in_base,
+    clear_goal_cache, rectangle_path_clear, route_subgoal)
+from web_console.stretch_nav_survey import HeadSurvey
+from web_console.stretch_vggt_debug import VggtDebugRecorder, model_provenance, planner_snapshot
+from web_console.stretch_transport import camera_transport_diagnostics
+
+
+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
+                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 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 > 90. 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,
+                    '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)
+                            observation = survey.update(base, mount, joint, index, time.monotonic())
+                            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'],
+                        '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=1.2)
+    p.add_argument('--plan-hold-seconds', type=float, default=3.)
+    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 <= 1.5 or not 0. <= args.plan_hold_seconds <= 5.:
+        raise ValueError('Plan evidence must expire within 0.4–1.5 s; zero-velocity hold at most 5 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()

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

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

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

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

code/lite3_ROS/tests/test_stretch_nav_control.py

@@ -0,0 +1,156 @@
+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,
+)
+
+
+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', 8.6), ('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=7.)
+    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.9
+    assert execution_gate(p, r, now=10., robot_received=9.9, heartbeat=9.9) == ''
+    p['input_received'] = 8.7
+    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.)
+
+
+@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'}]

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

code/lite3_ROS/tests/test_stretch_nav_handoff.py

@@ -0,0 +1,410 @@
+"""Exercise command transport with fake sockets; these tests cannot reach hardware."""
+import importlib.util
+from pathlib import Path
+import sys
+import threading
+import time
+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() - 3.
+    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() - .4
+    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() - .4
+    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

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)

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

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)

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)

code/lite3_ROS/tests/test_stretch_nav_survey.py

@@ -0,0 +1,215 @@
+"""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 = 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 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")
+    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([0.0, 0.25, 0.75]):
+        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")
+    with pytest.raises(RuntimeError, match="timed out"):
+        survey.update(np.eye(4), camera(), joints(), 1, 12.1)
+
+
+def test_external_base_motion_aborts_stationary_survey():
+    survey = HeadSurvey()
+    survey.start(np.eye(4), camera(), camera(), joints(), 0.0, "blocked")
+    base = np.eye(4)
+    base[0, 3] = 0.1
+    with pytest.raises(RuntimeError, match="Base moved"):
+        survey.update(base, camera(), joints(), 1, 1.0)
+
+
+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"]

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'

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

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

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}}

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>

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

code/lite3_ROS/web_console/stretch_nav_control.py

@@ -0,0 +1,191 @@
+"""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
+
+
+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 execution_gate(plan, robot, *, now, robot_received, heartbeat, state='active', max_plan_age=1.2):
+    """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.
+    """
+    if state not in ('preparing', 'active'):
+        return 'teleop owns control'
+    if now - heartbeat > 2.:
+        return 'viewer heartbeat expired'
+    if robot is None or now - robot_received > .3:
+        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 or now - plan['input_received'] > max_plan_age:
+        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'
+    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 not plan.get('route_ids'):
+        return 'no global route'
+    if plan.get('arrived'):
+        return 'goal reached'
+    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 = 3.
+    since: float | None = None
+
+    def holds(self, reason, now):
+        if reason not in ('sensor/plan evidence stale', 'no executable local path', 'robot status stale'):
+            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

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"}

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

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

code/lite3_ROS/web_console/stretch_nav_recovery.py

@@ -0,0 +1,391 @@
+"""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 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 > 18.0:
+                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))],
+                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

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]

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

code/lite3_ROS/web_console/stretch_nav_survey.py

@@ -0,0 +1,131 @@
+"""Stationary yaw/pitch observations for blocked Stretch navigation; no I/O."""
+
+import math
+
+import numpy as np
+
+from .stretch_nav_control import 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. No survey result requests base motion.
+    At most two passes are allowed until the base moves 20 cm; the enclosing
+    controller has an independent 90 s/100 degree recovery budget.
+    """
+
+    def __init__(self):
+        self.active = False
+        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.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
+        return True
+
+    def snapshot(self):
+        return {
+            "active": self.active,
+            "pass": self.passes,
+            "view": min(self.index + 1, len(self.targets)),
+            "total": len(self.targets),
+            "label": 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")
+        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 > 40.0 or now - self.since > 12.0:
+            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,
+            "scan_w": 0.0,
+            "coverage": 0.0,
+            "speed_scale": 0.5,
+            "lookahead": 0.22,
+            "survey_complete": complete,
+            "survey_label": label,
+        }

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

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

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

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.

code/stretch_ai/scripts/capture_lingbot_rgbd_ros2.py

@@ -0,0 +1,176 @@
+#!/usr/bin/env python3
+"""Capture synchronized head RGB-D and TF without issuing robot commands.
+
+Run inside the robot's ROS 2 environment. Images are saved losslessly, with
+depth in metres, and rotated clockwise to match Stretch's upright head view.
+"""
+
+import argparse
+import json
+import time
+from pathlib import Path
+
+import cv2
+import message_filters
+import numpy as np
+import rclpy
+from cv_bridge import CvBridge
+from rclpy.qos import qos_profile_sensor_data
+from rclpy.time import Time
+from sensor_msgs.msg import CameraInfo, Image
+from tf2_ros import Buffer, TransformException, TransformListener
+
+
+def stamp_seconds(stamp):
+    return stamp.sec + stamp.nanosec * 1e-9
+
+
+def transform_matrix(transform):
+    q = transform.rotation
+    x, y, z, w = q.x, q.y, q.z, q.w
+    matrix = np.eye(4, dtype=np.float64)
+    matrix[:3, :3] = [
+        [1 - 2 * (y * y + z * z), 2 * (x * y - z * w), 2 * (x * z + y * w)],
+        [2 * (x * y + z * w), 1 - 2 * (x * x + z * z), 2 * (y * z - x * w)],
+        [2 * (x * z - y * w), 2 * (y * z + x * w), 1 - 2 * (x * x + y * y)],
+    ]
+    t = transform.translation
+    matrix[:3, 3] = [t.x, t.y, t.z]
+    return matrix
+
+
+def rotate_intrinsics_clockwise(k, height):
+    """Rotate both the pixel axes and optical frame, including principal point."""
+    return np.array(
+        [[k[1, 1], 0, height - 1 - k[1, 2]], [0, k[0, 0], k[0, 2]], [0, 0, 1]],
+        dtype=np.float32,
+    )
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--output", type=Path, required=True)
+    parser.add_argument("--frames", type=int, default=12)
+    parser.add_argument("--interval", type=float, default=0.2)
+    parser.add_argument("--timeout", type=float, default=40)
+    parser.add_argument("--world-frame", default="map")
+    args = parser.parse_args()
+    args.output.mkdir(parents=True, exist_ok=False)
+
+    rclpy.init()
+    node = rclpy.create_node("lingbot_depth_readonly_capture")
+    bridge = CvBridge()
+    tf_buffer = Buffer()
+    listener = TransformListener(tf_buffer, node)
+    state = {"info": None, "pair": None}
+    info_sub = node.create_subscription(
+        CameraInfo,
+        "/camera/color/camera_info",
+        lambda msg: state.update(info=msg),
+        qos_profile_sensor_data,
+    )
+    color_sub = message_filters.Subscriber(
+        node, Image, "/camera/color/image_raw", qos_profile=qos_profile_sensor_data
+    )
+    depth_sub = message_filters.Subscriber(
+        node, Image, "/camera/aligned_depth_to_color/image_raw", qos_profile=qos_profile_sensor_data
+    )
+    sync = message_filters.ApproximateTimeSynchronizer(
+        [color_sub, depth_sub], queue_size=10, slop=0.02
+    )
+    sync.registerCallback(lambda color, depth: state.update(pair=(color, depth)))
+    # T_native_optical_from_upright_optical for a clockwise image rotation.
+    optical_rotation = np.eye(4)
+    optical_rotation[:3, :3] = [[0, 1, 0], [-1, 0, 0], [0, 0, 1]]
+    records = []
+    start = time.monotonic()
+    last_stamp = -float("inf")
+    last_error = "No synchronized image pair received"
+    try:
+        while len(records) < args.frames and time.monotonic() - start < args.timeout:
+            rclpy.spin_once(node, timeout_sec=0.1)
+            if state["info"] is None or state["pair"] is None:
+                continue
+            color_msg, depth_msg = state["pair"]
+            stamp = stamp_seconds(color_msg.header.stamp)
+            if stamp - last_stamp < args.interval:
+                continue
+            try:
+                pose_msg = tf_buffer.lookup_transform(
+                    args.world_frame,
+                    color_msg.header.frame_id,
+                    Time.from_msg(color_msg.header.stamp),
+                )
+                robot_pose_msg = tf_buffer.lookup_transform(
+                    args.world_frame, "base_link", Time.from_msg(color_msg.header.stamp)
+                )
+            except TransformException as exc:
+                last_error = str(exc)
+                continue
+            rgb_native = bridge.imgmsg_to_cv2(color_msg, desired_encoding="rgb8")
+            raw = bridge.imgmsg_to_cv2(depth_msg, desired_encoding="passthrough")
+            if depth_msg.encoding == "16UC1":
+                depth_native = raw.astype(np.float32) / 1000.0
+            elif depth_msg.encoding == "32FC1":
+                depth_native = raw.astype(np.float32)
+            else:
+                raise ValueError(f"Unsupported depth encoding: {depth_msg.encoding}")
+            if rgb_native.shape[:2] != depth_native.shape:
+                raise ValueError("Color and aligned depth dimensions differ")
+            info = state["info"]
+            k_native = np.array(info.k).reshape(3, 3)
+            k = rotate_intrinsics_clockwise(k_native, rgb_native.shape[0])
+            rgb = np.rot90(rgb_native, k=3).copy()
+            depth = np.rot90(depth_native, k=3).copy()
+            pose = transform_matrix(pose_msg.transform) @ optical_rotation
+            robot_pose = transform_matrix(robot_pose_msg.transform)
+            directory = args.output / f"frame_{len(records):03d}"
+            directory.mkdir()
+            if not cv2.imwrite(str(directory / "rgb.png"), cv2.cvtColor(rgb, cv2.COLOR_RGB2BGR)):
+                raise OSError("Could not write RGB image")
+            np.save(directory / "depth_input_m.npy", depth)
+            cv2.imwrite(
+                str(directory / "raw_depth.png"), np.nan_to_num(depth * 1000).astype(np.uint16)
+            )
+            np.savetxt(directory / "intrinsics.txt", k)
+            np.savetxt(directory / "camera_pose.txt", pose)
+            np.savetxt(directory / "robot_pose.txt", robot_pose)
+            record = {
+                "directory": directory.name,
+                "rgb_timestamp_s": stamp,
+                "depth_timestamp_s": stamp_seconds(depth_msg.header.stamp),
+                "sync_difference_s": abs(stamp - stamp_seconds(depth_msg.header.stamp)),
+                "tf_timestamp_s": stamp_seconds(pose_msg.header.stamp),
+                "source_optical_frame": color_msg.header.frame_id,
+                "world_frame": args.world_frame,
+                "image_rotation": "90 degrees clockwise",
+                "shape_hw": list(depth.shape),
+                "intrinsics_pixels": k.tolist(),
+                "intrinsics_native_pixels": k_native.tolist(),
+                "camera_pose_world_from_upright_optical": pose.tolist(),
+                "robot_pose_world_from_base_link": robot_pose.tolist(),
+                "distortion_native": list(info.d),
+                "distortion_model": info.distortion_model,
+                "rgb_encoding_source": color_msg.encoding,
+                "depth_encoding_source": depth_msg.encoding,
+                "depth_unit": "metres",
+            }
+            (directory / "metadata.json").write_text(json.dumps(record, indent=2) + "\n")
+            records.append(record)
+            last_stamp = stamp
+            print(
+                f"Captured {directory.name}: {depth.shape}, sync={record['sync_difference_s']:.6f}s",
+                flush=True,
+            )
+        (args.output / "capture.json").write_text(
+            json.dumps({"frames": records, "elapsed_s": time.monotonic() - start}, indent=2) + "\n"
+        )
+        if len(records) != args.frames:
+            raise TimeoutError(f"Captured {len(records)}/{args.frames}: {last_error}")
+    finally:
+        node.destroy_node()
+        rclpy.shutdown()
+
+
+if __name__ == "__main__":
+    main()

code/stretch_ai/scripts/depth_nav_control.py

@@ -0,0 +1,363 @@
+"""CPU navigation controls and robot-local velocity leases; no ROS/model imports."""
+
+import math
+from bisect import bisect_left
+from dataclasses import dataclass
+
+import numpy as np
+
+
+def wrap_angle(angle):
+    return math.atan2(math.sin(angle), math.cos(angle))
+
+
+def validated_head_target(command, enabled):
+    """Validate optional leased observation; the depth stack leaves it off."""
+    target = command.get("head_target")
+    if target is None:
+        return None
+    if not enabled:
+        raise ValueError("head control disabled")
+    target = np.asarray(target, dtype=float)
+    if target.shape != (2,) or not np.isfinite(target).all():
+        raise ValueError("invalid head target")
+    if not -2.8 <= target[0] <= .65 or not -1.4 <= target[1] <= 0.:
+        raise ValueError("head target outside observation limits")
+    if float(command.get("v", math.inf)) != 0. or abs(float(command.get("w", math.inf))) > .15:
+        raise ValueError("head observation requires a stopped or slowly rotating base")
+    return target
+
+
+def interpolate_head(samples, stamp, max_gap=.10):
+    """Head joint feedback at the RGB/TF time, never latest-state substitution."""
+    if not samples:
+        return None
+    stamps = [v[0] for v in samples]
+    k = bisect_left(stamps, stamp)
+    if k < len(samples) and abs(stamps[k] - stamp) < 1e-6:
+        return np.asarray(samples[k][1], float).copy()
+    if 0 < k < len(samples) and 0 < stamps[k] - stamps[k - 1] <= max_gap:
+        t = (stamp - stamps[k - 1]) / (stamps[k] - stamps[k - 1])
+        return (1. - t) * np.asarray(samples[k - 1][1]) + t * np.asarray(samples[k][1])
+    return None
+
+
+class LeasedHeadController:
+    """Asynchronous head action with explicit cancellation, including late ACKs.
+
+    The relay supplies a ROS goal factory; tests supply ordinary fake futures.
+    A failure remains visible until the session is restarted.
+    """
+    def __init__(self, client, make_goal):
+        self.client, self.make_goal = client, make_goal
+        self.future = self.goal = self.result = None
+        self.sent = None
+        self.cancel_requested = False
+        self.cancel_sent = False
+        self.cancel_future = None
+        self.state, self.error = 'idle' if client is not None else 'disabled', ''
+
+    def _cancel(self):
+        self.cancel_requested = True
+        if self.goal is not None and not self.cancel_sent:
+            self.cancel_future = self.goal.cancel_goal_async()
+            self.cancel_sent, self.state = True, 'cancelling'
+
+    def update(self, target, joint, allowed):
+        target = None if target is None else np.asarray(target, float)
+        want = allowed and target is not None and not self.error
+        changed = want and self.sent is not None and np.max(np.abs(target - self.sent)) > .04
+        if not want or changed:
+            self._cancel()
+        if self.future is not None and self.future.done():
+            self.goal = self.future.result()
+            self.future = None
+            if self.goal is None or not self.goal.accepted:
+                self.error, self.state, self.goal = 'head trajectory rejected', 'failed', None
+            else:
+                self.result, self.state = self.goal.get_result_async(), 'moving'
+                if self.cancel_requested:
+                    self._cancel()
+        if self.result is not None and self.result.done():
+            response = self.result.result()
+            if not self.cancel_requested and (response is None or response.result.error_code != 0):
+                detail = '' if response is None else f" ({response.result.error_code}): {getattr(response.result, 'error_string', '')}"
+                self.error, self.state = 'head trajectory failed' + detail, 'failed'
+            else:
+                self.state = 'cancelled' if self.cancel_requested else 'settled'
+            self.goal = self.result = None
+        if not want:
+            self.sent = None
+        elif not self.error and self.future is None and self.goal is None and (self.sent is None or changed):
+            if self.client is None or not self.client.server_is_ready():
+                self.error, self.state = 'head trajectory server unavailable', 'failed'
+            else:
+                # Tilt has a lower velocity bound than pan. A downward survey
+                # must allow that slower joint to reach its observation pose.
+                travel = np.abs(target - np.asarray(joint)[9:11]) / np.array([.35, .25])
+                duration = max(.5, float(np.max(travel)) + .5)
+                self.future = self.client.send_goal_async(self.make_goal(target, duration))
+                self.sent, self.cancel_requested, self.cancel_sent = target.copy(), False, False
+                self.state = 'requested'
+
+    def close(self):
+        self._cancel()
+        if self.future is not None:
+            def cancel_late(future):
+                handle = future.result()
+                if handle is not None and handle.accepted and not self.cancel_sent:
+                    self.cancel_future = handle.cancel_goal_async()
+                    self.cancel_sent = True
+            if self.future.done():
+                cancel_late(self.future)
+            else:
+                self.future.add_done_callback(cancel_late)
+
+
+class HeadControlMode:
+    """Yield the bridge's streaming controller for head-only ROS trajectories.
+
+    Only prepare() makes a request, after explicit navigation handoff. Restore
+    the original state on close, including a disable ACK racing shutdown.
+    """
+    def __init__(self, disable, enable, request):
+        self.disable, self.enable, self.request = disable, enable, request
+        self.original = None
+        self.future = self.restore_future = None
+        self.owned = self.ready = self.closing = False
+        self.error = ''
+
+    def prepare(self, streaming):
+        if self.closing or self.error or streaming is None:
+            return False
+        if self.original is None:
+            self.original = bool(streaming)
+        if not self.original:
+            self.ready = streaming is False
+            return self.ready
+        if self.future is None and not self.owned:
+            if not self.disable.service_is_ready():
+                return False
+            self.future = self.disable.call_async(self.request())
+        if self.future is not None and self.future.done():
+            result = self.future.result()
+            self.future = None
+            if result is None or not result.success:
+                self.error = 'could not yield streaming head control'
+                return False
+            self.owned = True
+        self.ready = self.owned and streaming is False
+        return self.ready
+
+    def close(self):
+        self.closing = True
+        if self.original is not True or self.restore_future is not None:
+            return
+        def restore(_future=None):
+            if self.restore_future is None:
+                if not self.enable.service_is_ready():
+                    self.error = 'could not restore streaming head control'
+                else:
+                    self.restore_future = self.enable.call_async(self.request())
+        if self.future is not None and not self.future.done():
+            self.future.add_done_callback(restore)
+        elif self.owned or self.future is not None:
+            restore()
+
+
+def relative_goal_to_world(forward_left, pose):
+    """Freeze a ROS body-frame (x forward, y left) goal in world XY."""
+    forward, left = np.asarray(forward_left, dtype=float)
+    x, y, yaw = np.asarray(pose, dtype=float)
+    if not np.isfinite([forward, left, x, y, yaw]).all():
+        raise ValueError("Goal and pose must be finite")
+    return np.array(
+        [
+            x + forward * math.cos(yaw) - left * math.sin(yaw),
+            y + forward * math.sin(yaw) + left * math.cos(yaw),
+        ]
+    )
+
+
+def twist_rollout(pose, v, w, horizon, samples=24):
+    t = np.linspace(0, horizon, samples)
+    if abs(w) < 1e-6:
+        local = np.column_stack([v * t, np.zeros_like(t)])
+    else:
+        local = np.column_stack([v / w * np.sin(w * t), v / w * (1 - np.cos(w * t))])
+    c, s = math.cos(pose[2]), math.sin(pose[2])
+    return local @ np.array([[c, s], [-s, c]]) + pose[:2]
+
+
+def rollout_allowed(pose, v, w, grid, planning_pose, args):
+    from depth_only_path_planner import ego_to_cells, world_to_ego
+    from depth_nav_footprint import collisions_at
+    from depth_nav_trajectories import body_extent
+
+    samples = max(
+        24,
+        int(
+            np.ceil(
+                (abs(v) + body_extent(args) * abs(w))
+                * args.control_horizon
+                / (args.grid_resolution / 4)
+            )
+        )
+        + 1,
+    )
+    points = twist_rollout(pose, v, w, args.control_horizon, samples)
+    local = world_to_ego(points, planning_pose[:2], planning_pose[2])
+    rows, cols, inside = ego_to_cells(local, args, grid["blocked"].shape)
+    headings = pose[2] - planning_pose[2] + w * np.linspace(0, args.control_horizon, len(points))
+    if collisions_at(local, headings, grid, args).any():
+        return False, "command footprint intersects depth obstacles or map boundary"
+    if (
+        args.unknown_policy != "assume"
+        and (grid["unknown_footprint"][rows, cols] > args.max_control_unknown_ratio + 1e-6).any()
+    ):
+        return False, "command footprint lacks observed floor support"
+    return True, "clear"
+
+
+def pursuit_velocity(path_world, pose, goal_world, args):
+    from depth_only_path_planner import world_to_ego
+
+    distance = float(np.linalg.norm(goal_world - pose[:2]))
+    if distance <= args.goal_tolerance:
+        return 0.0, 0.0
+    if not len(path_world):
+        return 0.0, 0.0
+    nearest = int(np.argmin(np.linalg.norm(path_world - pose[:2], axis=1)))
+    ahead = path_world[nearest:]
+    lengths = np.r_[0, np.cumsum(np.linalg.norm(np.diff(ahead, axis=0), axis=1))]
+    target = ahead[min(len(ahead) - 1, int(np.searchsorted(lengths, args.pursuit_lookahead)))]
+    right, forward = world_to_ego(target[None], pose[:2], pose[2])[0]
+    heading = math.atan2(-right, forward)
+    if abs(heading) > args.turn_in_place_angle or forward <= 0:
+        return 0.0, float(
+            np.clip(args.turn_gain * heading, -args.max_angular_speed, args.max_angular_speed)
+        )
+    curvature = -2 * right / max(right**2 + forward**2, 0.01)
+    v = min(args.max_linear_speed, max(0.0, distance - args.goal_tolerance) * 0.5)
+    if abs(curvature) > 1e-6:
+        v = min(v, args.max_angular_speed / abs(curvature))
+    return float(v), float(v * curvature)
+
+
+def candidate_prefix_allowed(paths, grid, goal_distance, args):
+    """Batch-check each candidate's first pursuit command without Python loops."""
+    from depth_only_path_planner import ego_to_cells
+    from depth_nav_footprint import collisions_at
+
+    lengths = np.cumsum(np.linalg.norm(np.diff(paths, axis=1), axis=-1), axis=1)
+    reaches = lengths >= args.pursuit_lookahead
+    index = np.where(reaches.any(axis=1), reaches.argmax(axis=1) + 1, paths.shape[1] - 1)
+    target = paths[np.arange(len(paths)), index]
+    right, forward = target[:, 0], target[:, 1]
+    heading = np.arctan2(-right, forward)
+    curvature = -2 * right / np.maximum(right**2 + forward**2, 0.01)
+    v = np.full(
+        len(paths), min(args.max_linear_speed, max(0.0, goal_distance - args.goal_tolerance) * 0.5)
+    )
+    v = np.minimum(v, args.max_angular_speed / np.maximum(np.abs(curvature), 1e-9))
+    turn = (np.abs(heading) > args.turn_in_place_angle) | (forward <= 0)
+    w = np.where(
+        turn,
+        np.clip(args.turn_gain * heading, -args.max_angular_speed, args.max_angular_speed),
+        v * curvature,
+    )
+    v[turn] = 0
+    t = np.linspace(0, args.control_horizon, 24)[None]
+    angle = w[:, None] * t
+    radius = v / np.where(np.abs(w) < 1e-6, 1.0, w)
+    rollout = np.stack(
+        [-radius[:, None] * (1 - np.cos(angle)), radius[:, None] * np.sin(angle)], axis=-1
+    )
+    straight = np.abs(w) < 1e-6
+    rollout[straight, :, 0] = 0
+    rollout[straight, :, 1] = v[straight, None] * t
+    rows, cols, inside = ego_to_cells(rollout, args, grid["blocked"].shape)
+    rr, cc = np.clip(rows, 0, grid["blocked"].shape[0] - 1), np.clip(
+        cols, 0, grid["blocked"].shape[1] - 1
+    )
+    invalid = collisions_at(rollout, angle, grid, args) | (
+        (grid["unknown_footprint"][rr, cc] > args.max_control_unknown_ratio + 1e-6)
+        & (args.unknown_policy != "assume")
+    )
+    return ~invalid.any(axis=1)
+
+
+@dataclass
+class VelocityLease:
+    """Fail closed on stale evidence/state, bad commands, expiry and latched stop."""
+
+    max_ttl: float = 0.35
+    max_frame_age: float = 0.8
+    max_v: float = 0.15
+    max_w: float = 0.4
+    session: str | None = None
+    armed: bool = False
+    latched: bool = False
+    sequence: int = -1
+    expires: float = -math.inf
+    evidence_expires: float = -math.inf
+    velocity: tuple = (0.0, 0.0)
+    reason: str = "unarmed"
+
+    def arm(self, session, healthy):
+        if self.latched or not healthy or not isinstance(session, str) or not session:
+            return False
+        if self.session is not None and self.session != session:
+            return False
+        self.session, self.armed = session, True
+        return True
+
+    def stop(self, reason, latch=False):
+        self.velocity = (0.0, 0.0)
+        self.expires = -math.inf
+        self.reason = reason
+        if latch:
+            self.latched, self.armed = True, False
+
+    def accept(self, command, now, frame_age, healthy):
+        if self.latched:
+            return False
+        try:
+            seq = int(command["seq"])
+            ttl, v, w = map(float, (command["ttl"], command["v"], command["w"]))
+        except (ValueError, TypeError, KeyError):
+            self.stop("malformed command")
+            return False
+        if (
+            self.latched
+            or not self.armed
+            or not healthy
+            or command.get("session") != self.session
+            or seq <= self.sequence
+            or not np.isfinite([ttl, v, w, frame_age]).all()
+            or not 0 < ttl <= self.max_ttl
+            or not 0 <= frame_age < self.max_frame_age
+            or not 0 <= v <= self.max_v
+            or abs(w) > self.max_w
+        ):
+            self.stop("rejected command or stale evidence")
+            return False
+        self.sequence = seq
+        self.velocity = (v, w)
+        self.expires = now + ttl
+        self.evidence_expires = now + self.max_frame_age - frame_age
+        self.reason = "command active"
+        return True
+
+    def output(self, now, healthy, runstopped=False):
+        if runstopped and self.armed:
+            self.stop("run-stop latched; restart the live session", latch=True)
+        if self.latched:
+            return (0.0, 0.0)
+        if not healthy:
+            self.stop("state, camera or posture unavailable")
+        if now >= min(self.expires, self.evidence_expires):
+            self.stop(
+                "command/evidence expired" if self.armed and not self.latched else self.reason
+            )
+        return self.velocity if self.armed and not self.latched else (0.0, 0.0)

code/stretch_ai/scripts/depth_nav_debug.py

@@ -0,0 +1,539 @@
+"""Bounded asynchronous debug recording; no robot, model or GPU operations."""
+
+from collections import OrderedDict
+from datetime import datetime, timezone
+import hashlib
+import json
+from pathlib import Path
+import queue
+import sys
+import threading
+import time
+from types import SimpleNamespace
+
+import numpy as np
+
+
+def clean_json(value):
+    if isinstance(value, np.ndarray) and value.ndim == 0:
+        return clean_json(value.item())
+    if isinstance(value, dict):
+        return {str(k): clean_json(v) for k, v in value.items()}
+    if isinstance(value, (list, tuple, np.ndarray)):
+        return [clean_json(v) for v in value]
+    if isinstance(value, np.generic):
+        return clean_json(value.item())
+    if isinstance(value, float) and not np.isfinite(value):
+        return None
+    if isinstance(value, Path):
+        return str(value)
+    return value
+
+
+def freeze_voxels(snapshot, now):
+    names = (
+        "points",
+        "colors",
+        "state",
+        "keys",
+        "ids",
+        "scores",
+        "age_s",
+        "last_frame",
+        "evidence_frame",
+        "geometry_frame",
+        "geometry_support",
+        "last_hit_support",
+        "source_raw_depth_m",
+        "source_refined_depth_m",
+    )
+    result = {name: snapshot[name].copy() for name in names if name in snapshot}
+    for name in ("last_seen", "last_hit", "last_supported"):
+        if name in snapshot:
+            result[name + "_age_s"] = (now - snapshot[name]).astype(np.float32)
+    return result
+
+
+def current_view(point, arrays, args):
+    """Explain why sparse projective clearing can/cannot remove a sample."""
+    if not all(
+        k in arrays
+        for k in ("camera_pose", "camera_K", "raw_depth_m", "refined_depth_m", "retained_mask")
+    ):
+        return {"status": "not_recorded"}
+    pose, k = arrays["camera_pose"], arrays["camera_K"]
+    camera = (point - pose[:3, 3]) @ pose[:3, :3]
+    z = float(camera[2])
+    max_depth = getattr(args, "max_depth", 5.0)  # Older runs used a 5 m limit.
+    if z <= 0.3:
+        return {"status": "behind_or_too_close_to_camera_for_clearing", "camera_z_m": z}
+    distance = float(np.linalg.norm(camera))
+    if z > max_depth:
+        return {
+            "status": "outside_clearing_depth_limit",
+            "camera_z_m": z,
+            "camera_distance_m": distance,
+            "depth_limit_m": max_depth,
+        }
+    u = int(np.rint(k[0, 0] * camera[0] / z + k[0, 2]))
+    v = int(np.rint(k[1, 1] * camera[1] / z + k[1, 2]))
+    h, w = arrays["raw_depth_m"].shape
+    if not (1 <= u < w - 1 and 1 <= v < h - 1):
+        return {"status": "outside_clearing_image_patch", "pixel_uv": [u, v], "camera_z_m": z}
+    raw = arrays["raw_depth_m"][v - 1 : v + 2, u - 1 : u + 2]
+    refined = arrays["refined_depth_m"][v - 1 : v + 2, u - 1 : u + 2]
+    from lingbot_voxel_map import VoxelMapConfig, clearing_patch_evidence
+
+    clear, valid, agreement, farther = clearing_patch_evidence(
+        raw.reshape(9),
+        refined.reshape(9),
+        z,
+        VoxelMapConfig(voxel_size=args.voxel_size, max_depth_m=max_depth),
+    )
+    status = (
+        "reliable_farther_patch"
+        if clear
+        else (
+            "occluded_or_same_depth"
+            if valid.all() and not farther.all()
+            else "missing_or_disagreeing_depth"
+        )
+    )
+    return {
+        "status": status,
+        "pixel_uv": [u, v],
+        "camera_z_m": z,
+        "camera_distance_m": distance,
+        "depth_limit_kind": "optical_axis",
+        "raw_depth_m": float(raw[1, 1]),
+        "refined_depth_m": float(refined[1, 1]),
+        "valid_patch_fraction": float(valid.mean()),
+        "farther_patch_fraction": float(farther.mean()),
+        "agreement_patch_fraction": float(agreement.mean()),
+        "retained_patch_fraction": float(
+            arrays["retained_mask"][v - 1 : v + 2, u - 1 : u + 2].mean()
+        ),
+    }
+
+
+def collision_report(context, trigger):
+    from depth_nav_footprint import collisions_at, footprint_witnesses
+    from depth_nav_control import twist_rollout
+    from depth_nav_trajectories import body_extent
+    from depth_only_path_planner import (
+        ego_to_cells,
+        ego_to_world,
+        world_to_ego,
+        obstacle_height_mask,
+    )
+
+    arrays, meta = context["arrays"], context["metadata"]
+    if "voxel_points" not in arrays or "hard_source" not in arrays:
+        return {
+            "stage": meta.get("stage", "unknown"),
+            "note": "Frame did not reach mapping/planning",
+        }
+    args = SimpleNamespace(**meta["settings"])
+    planning_pose = arrays["planning_pose"]
+    control = trigger.get("control", {})
+    pose = np.asarray(control.get("robot_pose") or planning_pose.tolist(), dtype=float)
+    if pose.shape != (3,) or not np.isfinite(pose).all():
+        pose = planning_pose
+    v, w = float(control.get("proposed_v", 0)), float(control.get("proposed_w", 0))
+    samples = max(
+        24,
+        int(
+            np.ceil(
+                (abs(v) + body_extent(args) * abs(w))
+                * args.control_horizon
+                / (args.grid_resolution / 4)
+            )
+        )
+        + 1,
+    )
+    world = twist_rollout(pose, v, w, args.control_horizon, samples)
+    points = world_to_ego(world, planning_pose[:2], planning_pose[2])
+    headings = pose[2] - planning_pose[2] + w * np.linspace(0, args.control_horizon, samples)
+    grid = {key: arrays[key] for key in ("hard_source", "blocked", "unknown_footprint")}
+    grid.update(direct_footprint=True, collision_cache={})
+    for key in ("collision_cells", "collision_cell_size", "collision_cell_angle"):
+        if key in arrays:
+            grid[key] = arrays[key] if key == "collision_cells" else float(arrays[key])
+    collides = collisions_at(points, headings, grid, args)
+    first = int(np.flatnonzero(collides)[0]) if collides.any() else 0
+    contacts, boundary = footprint_witnesses(points[first], headings[first], grid, args)
+    report = {
+        "command_first_collision_s": (
+            None
+            if not collides.any()
+            else float(np.linspace(0, args.control_horizon, samples)[first])
+        ),
+        "map_boundary_contact": boundary,
+        "collision_cell_count": len(contacts),
+        "contact_cells_ego": contacts[:16].tolist(),
+        "contact_voxels": [],
+        "contact_pose_ego": [
+            float(points[first, 0]),
+            float(points[first, 1]),
+            float(headings[first]),
+        ],
+        "collision_cell_size_m": grid.get("collision_cell_size", args.grid_resolution),
+        "collision_cell_angle_rad": grid.get("collision_cell_angle", 0.0),
+    }
+    voxels, state = arrays["voxel_points"], arrays["voxel_state"]
+    plane = arrays["floor_plane"]
+    height = voxels @ plane[:3] + plane[3] if len(plane) == 4 else np.zeros(len(voxels))
+    hazard = obstacle_height_mask(height, args)
+    active = hazard & ((state == 1) | ((state == 0) & args.block_uncertain_obstacles))
+    local = world_to_ego(voxels, planning_pose[:2], planning_pose[2])
+    if "collision_cells" in grid:
+        voxel_cells = np.floor(voxels[:, :2] / args.voxel_size).astype(np.int64)
+        contact_cells = np.floor(
+            ego_to_world(contacts, planning_pose[:2], planning_pose[2]) / args.voxel_size
+        ).astype(np.int64)
+    else:
+        r, c, _ = ego_to_cells(local, args, grid["hard_source"].shape)
+        voxel_cells = np.column_stack([r, c])
+        r, c, _ = ego_to_cells(contacts, args, grid["hard_source"].shape)
+        contact_cells = np.column_stack([r, c])
+    selected = np.zeros(len(voxels), bool)
+    for cell in contact_cells[:16]:
+        selected |= (voxel_cells == cell).all(axis=1) & active
+    for index in np.flatnonzero(selected)[:16]:
+        score = float(arrays.get("voxel_scores", np.full(len(voxels), np.nan))[index])
+        origin = (
+            "aged_sensor_supported_surface"
+            if state[index] == 0 and score >= 0.7
+            else (
+                "unconfirmed_model_or_sensor_disagreement"
+                if state[index] == 0 and np.isfinite(score)
+                else (
+                    "uncertain_origin_not_recorded"
+                    if state[index] == 0
+                    else "sensor_supported_surface"
+                )
+            )
+        )
+        entry = {
+            "index": int(index),
+            "world_xyz": voxels[index].tolist(),
+            "ego_xy": local[index].tolist(),
+            "height_m": float(height[index]),
+            "state": int(state[index]),
+            "score": score,
+            "origin": origin,
+            "current_view": current_view(voxels[index], arrays, args),
+        }
+        point_delta = local[index] - points[first]
+        heading = headings[first]
+        if args.footprint_shape == "rectangle":
+            width = np.cos(heading) * point_delta[0] + np.sin(heading) * point_delta[1]
+            length = (
+                -np.sin(heading) * point_delta[0]
+                + np.cos(heading) * point_delta[1]
+                - args.robot_length_offset
+            )
+            gap = np.hypot(
+                max(0.0, abs(width) - args.robot_width / 2 - args.safety_margin),
+                max(0.0, abs(length) - args.robot_length / 2 - args.safety_margin),
+            )
+        else:
+            gap = max(0.0, np.linalg.norm(point_delta) - args.robot_radius - args.safety_margin)
+        entry["point_inside_actual_footprint"] = bool(gap <= 1e-9)
+        entry["point_clearance_m"] = float(gap)
+        for name in (
+            "ids",
+            "age_s",
+            "last_seen_age_s",
+            "last_hit_age_s",
+            "last_supported_age_s",
+            "last_frame",
+            "evidence_frame",
+            "geometry_frame",
+            "geometry_support",
+            "last_hit_support",
+            "source_raw_depth_m",
+            "source_refined_depth_m",
+        ):
+            if "voxel_" + name in arrays:
+                entry[name] = arrays["voxel_" + name][index].item()
+        distance2 = ((voxels - voxels[index]) ** 2).sum(axis=1)
+        entry["neighbors_within_10cm"] = int(((distance2 <= 0.1**2) & (state != 2)).sum()) - 1
+        report["contact_voxels"].append(entry)
+    report["unknown_space_contacts"] = bool(
+        len(contacts) and not report["contact_voxels"] and args.unknown_policy == "block"
+    )
+    if (
+        "proposal_scores" in arrays
+        and len(arrays.get("bank_poses", []))
+        and not len(arrays["proposal_valid"])
+    ):
+        report["rejected_candidate_examples"] = []
+        for index in np.argsort(arrays["proposal_scores"])[:3]:
+            path = arrays["bank_poses"][index]
+            hit = collisions_at(path[:, :2], path[:, 2], grid, args)
+            report["rejected_candidate_examples"].append(
+                {
+                    "index": int(index),
+                    "first_collision_pose": (
+                        None if not hit.any() else path[np.flatnonzero(hit)[0]].tolist()
+                    ),
+                }
+            )
+    return clean_json(report)
+
+
+class DebugRecorder:
+    """No file writes on control/inference threads. Retain bounded snapshots."""
+
+    def __init__(self, output, args):
+        self.output = Path(output)
+        self.directory = self.output / "debug"
+        self.directory.mkdir(exist_ok=True)
+        self.max_snapshots = args.debug_max_snapshots
+        self.interval = args.debug_snapshot_interval
+        self.stuck_seconds = args.debug_stuck_seconds
+        self.started = time.monotonic()
+        self.jobs = queue.Queue(maxsize=128)
+        self.lock = threading.Lock()
+        self.contexts = OrderedDict()
+        self.stop = threading.Event()
+        self.last_periodic = self.last_incident = -np.inf
+        self.last_control = -np.inf
+        self.control_key = None
+        self.pause_snapshots = {}
+        self.progress_pose = None
+        self.progress_time = self.started
+        self.was_commanding_motion = False
+        self.counter = self.written_events = self.written_snapshots = self.dropped = 0
+        self.pending_snapshots = 0
+        self.last_snapshot = self.last_error = ""
+        sources = self.directory / "source"
+        sources.mkdir(exist_ok=True)
+        hashes = {}
+        for name in (
+            "depth_nav_live.py",
+            "depth_nav_control.py",
+            "depth_nav_footprint.py",
+            "depth_nav_trajectories.py",
+            "depth_nav_memory.py",
+            "depth_nav_debug.py",
+            "depth_nav_live_viewer.html",
+            "lingbot_voxel_map.py",
+            "lingbot_depth_geometry.py",
+            "lingbot_depth_model.py",
+            "lingbot_depth_eval.py",
+            "depth_nav_robot_relay.py",
+            "capture_lingbot_rgbd_ros2.py",
+        ):
+            path = Path(__file__).with_name(name)
+            data = path.read_bytes()
+            (sources / name).write_bytes(data)
+            hashes[name] = hashlib.sha256(data).hexdigest()
+        manifest = {
+            "schema_version": 1,
+            "started_utc": datetime.now(timezone.utc).isoformat(),
+            "python": sys.version,
+            "numpy": np.__version__,
+            "settings": clean_json(vars(args)),
+            "source_sha256": hashes,
+            "snapshots_compressed": False,
+        }
+        (self.output / "run_manifest.json").write_text(json.dumps(manifest, indent=2) + "\n")
+        self.thread = threading.Thread(target=self._write, name="depth-nav-debug", daemon=True)
+        self.thread.start()
+        self.event("session_start", {"execute": args.execute})
+
+    def _enqueue(self, job):
+        try:
+            self.jobs.put_nowait(job)
+            return True
+        except queue.Full:
+            self.dropped += 1
+            return False
+
+    def event(self, kind, data):
+        record = {
+            "event": kind,
+            "utc": datetime.now(timezone.utc).isoformat(),
+            "elapsed_s": time.monotonic() - self.started,
+            **clean_json(data),
+        }
+        self._enqueue(("event", record))
+
+    def publish(self, context):
+        with self.lock:
+            self.contexts[context["metadata"]["frame_id"]] = context
+            while len(self.contexts) > 3:
+                self.contexts.popitem(last=False)
+        now = time.monotonic()
+        if self.interval > 0 and now - self.last_periodic >= self.interval:
+            self.last_periodic = now
+            self.incident("periodic", {"frame_id": context["metadata"]["frame_id"]}, periodic=True)
+
+    def incident(self, reason, data, *, force=False, periodic=False, context=None):
+        now = time.monotonic()
+        with self.lock:
+            if context is None:
+                context = self.contexts.get(data.get("frame_id"))
+                if context is None and self.contexts:
+                    context = next(reversed(self.contexts.values()))
+            if context is None:
+                return False
+            if self.pending_snapshots >= 2 or (
+                not force and not periodic and now - self.last_incident < 10
+            ):
+                return False
+            self.counter += 1
+            name = f"snapshot_{self.counter:06d}"
+            self.pending_snapshots += 1
+            if not periodic:
+                self.last_incident = now
+        trigger = {
+            "reason": reason,
+            "utc": datetime.now(timezone.utc).isoformat(),
+            "elapsed_s": now - self.started,
+            **clean_json(data),
+        }
+        trigger["source_frame_age_s"] = max(
+            0.0, now - context["metadata"].get("received_monotonic", now)
+        )
+        queued = self._enqueue(("snapshot", (name, context, trigger)))
+        if not queued:
+            with self.lock:
+                self.pending_snapshots -= 1
+        return queued
+
+    def control(self, data, now):
+        key = (
+            data["reason"],
+            bool(data["v"] or data["w"]),
+            bool(abs(data["v"]) > 0.001),
+            int(np.sign(data["w"])) if abs(data["w"]) > 0.02 else 0,
+            data.get("robot_reason"),
+            data.get("healthy"),
+            data.get("armed"),
+            data.get("goal_version"),
+        )
+        changed = key != self.control_key
+        if changed or now - self.last_control >= 1.0:
+            self.control_key, self.last_control = key, now
+            self.event("control", data)
+        if data.get("execute") and data.get("armed"):
+            if any(
+                word in data["reason"]
+                for word in ("overlaps", "intersects", "admissible", "lacks", "stale")
+            ):
+                # A clear/stale oscillation is one recurring cause, not a new
+                # incident every frame. Keep every transition in events.jsonl,
+                # but bound the expensive image/map captures per pause cause.
+                cause = data["reason"]
+                if now - self.pause_snapshots.get(cause, -np.inf) >= 10:
+                    if self.incident(
+                        "control_pause",
+                        {"frame_id": data.get("frame_id"), "control": data},
+                        force=True,
+                    ):
+                        self.pause_snapshots[cause] = now
+            pose = data.get("robot_pose")
+            if pose is not None:
+                xy = np.asarray(pose)[:2]
+                moving = bool(data["v"] or data["w"])
+                if (
+                    self.progress_pose is None
+                    or (moving and not self.was_commanding_motion)
+                    or np.linalg.norm(xy - self.progress_pose) >= 0.10
+                ):
+                    self.progress_pose, self.progress_time = xy.copy(), now
+                if moving and now - self.progress_time >= self.stuck_seconds:
+                    self.incident(
+                        "no_translation",
+                        {
+                            "frame_id": data.get("frame_id"),
+                            "control": data,
+                            "no_translation_s": now - self.progress_time,
+                        },
+                    )
+                self.was_commanding_motion = moving
+        else:
+            self.was_commanding_motion = False
+
+    def status(self):
+        return {
+            "enabled": True,
+            "directory": str(self.directory),
+            "snapshots_written": self.written_snapshots,
+            "pending_snapshots": self.pending_snapshots,
+            "events_written": self.written_events,
+            "dropped_jobs": self.dropped,
+            "last_snapshot": self.last_snapshot,
+            "error": self.last_error,
+        }
+
+    def _write(self):
+        try:
+            with (self.output / "events.jsonl").open("w", buffering=1) as log:
+                while not self.stop.is_set() or not self.jobs.empty():
+                    try:
+                        kind, job = self.jobs.get(timeout=0.05)
+                    except queue.Empty:
+                        continue
+                    try:
+                        if kind == "event":
+                            log.write(json.dumps(job, allow_nan=False) + "\n")
+                            self.written_events += 1
+                        else:
+                            name, context, trigger = job
+                            arrays = {k: v for k, v in context["arrays"].items() if v is not None}
+                            # Stored ZIP avoids compression competing for CPU.
+                            np.savez(self.directory / (name + ".npz"), **arrays)
+                            document = {
+                                "schema_version": 1,
+                                "snapshot": name,
+                                "trigger": trigger,
+                                "frame": clean_json(context["metadata"]),
+                                "diagnosis": collision_report(context, trigger),
+                                "viewer_payload": context.get("viewer_payload"),
+                            }
+                            (self.directory / (name + ".json")).write_text(
+                                json.dumps(document, allow_nan=False) + "\n"
+                            )
+                            self.written_snapshots += 1
+                            self.last_snapshot = str(self.directory / (name + ".json"))
+                            log.write(
+                                json.dumps(
+                                    {
+                                        "event": "snapshot_saved",
+                                        "snapshot": name,
+                                        "trigger": trigger,
+                                        "source_frame_id": context["metadata"]["frame_id"],
+                                        "diagnosis": document["diagnosis"],
+                                    }
+                                )
+                                + "\n"
+                            )
+                            snapshots = sorted(self.directory.glob("snapshot_*.json"))
+                            for old in snapshots[: -self.max_snapshots]:
+                                old.with_suffix(".npz").unlink(missing_ok=True)
+                                old.unlink(missing_ok=True)
+                    except Exception as exc:
+                        self.last_error = f"{type(exc).__name__}: {exc}"
+                        if kind == "snapshot":
+                            (self.directory / (name + ".npz")).unlink(missing_ok=True)
+                            (self.directory / (name + ".json")).unlink(missing_ok=True)
+                        log.write(
+                            json.dumps({"event": "debug_error", "error": self.last_error}) + "\n"
+                        )
+                    finally:
+                        if kind == "snapshot":
+                            with self.lock:
+                                self.pending_snapshots -= 1
+                        self.jobs.task_done()
+        except Exception as exc:
+            self.last_error = f"{type(exc).__name__}: {exc}"
+
+    def close(self):
+        self.stop.set()
+        self.thread.join(timeout=3)
+        if self.thread.is_alive():
+            self.last_error = "Debug writer did not finish within shutdown timeout"