Add local physical-goal verification and audited 200-case benchmark

.github/workflows/image-goal.yml

@@ -21,6 +21,10 @@ jobs:
         run: >-
           python -m unittest tests.test_jev_client tests.test_image_goal_benchmark
           tests.test_image_goal_freeze tests.test_image_goal_scenes
-          tests.test_image_goal_report -v
+          tests.test_image_goal_report tests.test_local_goal_verifier
+          tests.test_local_goal_benchmark tests.test_local_goal_scenes
+          tests.test_local_goal_verifier_report tests.test_sensor_goal_observers
+          tests.test_sensor_goal_verifier tests.test_sensor_goal_benchmark
+          tests.test_sensor_goal_scenes tests.test_sensor_goal_verifier_report -v
       - name: Preserve published evidence and existing Space files
-        run: python -m unittest discover -s publishing/huggingface -p 'test_publish_image_goals.py' -v
+        run: python -m unittest discover -s publishing/huggingface -p 'test_publish*goal*.py' -v

README.md

@@ -8,6 +8,30 @@
 
 **Research alpha.** The recorded demo covers the original one-scene simulation pilot; the frozen benchmark is a separate experiment. Training runs locally. No human-video action bridge or hardware skill is established.
 
+**[Local goal verifier v0.3](benchmarks/local-goal-verifier-20261019/README.md).**
+A local CPU verifier recognizes **16/16 completed native scenes** with **0/48
+false completions** on incomplete native scenes. It checks identity, frames,
+freshness, uncertainty and 200 ms of physical observations. All 128 evidence
+fault controls produce the specified conservative response; eight consistent
+sensor forgeries still cause eight physical false completions. Native compute
+p95 is **0.317 ms**, excluding sensing and the required observation window.
+This is measured-state verification, not learned vision or a robot controller.
+[Inspect all 200 cases](https://dvidia-robot-simulation-lab.static.hf.space/image-goals/v03/index.html) ·
+[Research](https://research.dvidia.org/papers/local-goal-verifier-v03/) ·
+[Run locally](docs/local-goal-verifier.md).
+
+**[Independent sensor corroboration v0.4](benchmarks/sensor-goal-verifier-v04/README.md).**
+RGB and PiPER drive checks prevent **69/112 deliberately false completion
+readings**, while **43 remain** through orientation, identity, support, sampling
+and replay blind spots. The conservative gate also abstains on **73/80 baseline
+true completions**, including all 64 injected sensor-fault controls. Processed
+path latency is **22.1 ms median / 31.5 ms p95**, excluding the 200 ms evidence
+window and rendering. This is a paired synthetic benchmark, not an independent
+physical-sensor or hardware result.
+[Inspect the cases](https://dvidia-robot-simulation-lab.static.hf.space/image-goals/v04/index.html) ·
+[Research](https://research.dvidia.org/papers/sensor-corroboration-v04/) ·
+[Protocol](docs/sensor-goal-verifier.md).
+
 **[Image-goal verification: measured Jev results](benchmarks/image-goal-20261019/README.md).**
 32 native PiPER fixtures test missing targets, wrong arrangements, unreleased
 contact and moving shoes that render identically to settled shoes. The runnable

benchmarks/local-goal-verifier-20261019/INDEPENDENT-REVIEW.md

@@ -0,0 +1,21 @@
+# Independent review: local goal verifier v0.3
+
+The completed 200-case run passed the independent artifact, decision and metric review. All 12 source hashes match both the working files and the pinned Git commit; original Jev benchmark sources and fixtures remain unchanged.
+
+| Cohort | Cases | Result |
+| --- | ---: | --- |
+| Native physical scenes | 64 | 16/16 completed states recognized; 48/48 incomplete states rejected; 0 false completions. |
+| Perturbed evidence | 128 | 120 unknown and 8 incomplete, matching the declared evidence contracts. The underlying scenes are still complete. |
+| Internally consistent false evidence | 8 | 8/8 false completions against moving physical states. This limitation is retained. |
+
+Overall physical false completion is **8/56**, despite **200/200 packet-contract agreement**. The latter must not be presented as perception accuracy or universal physical correctness.
+
+The review independently recomputed native history predicates, checked every raw-to-packet mapping, restored all 64 final native states and reconstructed their pose, speed and contact measurements. All 200 full verifier decisions reproduce. All 128 evidence interventions and eight matching-image moving controls were checked. This did not rerun full trajectories or test hardware.
+
+Across 20,000 repeated calls, compute latency was **0.266583 ms median**, **0.31816905 ms p95**, and **0.962875 ms maximum**. Acquisition and the required 200 ms observation history are excluded, as are parsing, rendering, networking and actuation. Repetitions do not increase the number of physical cases.
+
+The verifier rejects the two pre-freeze issues reproduced during review: huge JSON integers and accumulated timestamp drift. Its current tests pass, along with 9 report tests and 11 publication tests.
+
+These are privileged native measurements with asserted zero uncertainty and eight correlated authored layouts. The protocol discloses development exposure. Forged measurements remain a deliberate blind spot; no image inference, new Jev calls, learned policy or real-robot transfer is demonstrated.
+
+[Structured checks and source hashes](independent-review.json).

benchmarks/local-goal-verifier-20261019/README.md

@@ -0,0 +1,113 @@
+# Local physical-goal verifier v0.3
+
+DVIDIA research · 19 October 2026 · 200 fixed cases · zero provider calls
+
+The local verifier recognized **16/16 completed native scenes** and rejected
+all **48 incomplete native scenes**. It checks explicit measured conditions
+rather than asking an image model to interpret physical thresholds. This is a
+verification component, not a learned perception system or robot controller.
+
+- [Interactive evidence on Hugging Face](https://dvidia-robot-simulation-lab.static.hf.space/image-goals/v03/index.html)
+- [Research article](https://research.dvidia.org/papers/local-goal-verifier-v03/)
+- [Run locally and inspect the contract](../../docs/local-goal-verifier.md)
+- [Metrics and provenance](metrics.json) · [Frozen protocol](protocol.json)
+- [Prior Jev response forensics](jev-forensics.json)
+- [Independent audit](INDEPENDENT-REVIEW.md) · [Machine-readable audit](independent-review.json)
+
+## Why the prior run recognized only one of eight
+
+We reconstructed all 64 original requests and reparsed the saved responses.
+The images, telemetry, request hashes and typed answers match the frozen run.
+There was no missing telemetry or client completion-probability cutoff: the
+completion verdict came directly from the provider's Choice answer.
+
+Of eight physically complete scenes, three visible ones received `unknown`,
+four covered ones received `incomplete`, and one visible scene received
+`complete`. Every positive's supplied native measurements satisfied the physical
+requirements. Covered and visible controls had identical measured-state payloads.
+This demonstrates unreliable use of sufficient telemetry on those cases. The
+model's internal reason is unknown; we did not evaluate an alternative prompt,
+new model, or repeated provider samples.
+
+The new verifier computes pose error and checks motion, support and release
+over the latest 100 observations at a declared 2 ms cadence. It requires trusted
+identity, coordinate frame, goal and current clock, and explicit uncertainty
+bounds. Definite physical violations return incomplete. Missing, invalid, stale
+or insufficient evidence returns unknown. Passing every condition returns complete.
+
+## Fresh benchmark
+
+| Cohort | Cases | Complete / incomplete / unknown | Physical false completion |
+| --- | ---: | ---: | ---: |
+| Fresh native simulation | 64 | 16 / 48 / 0 | 0/48 |
+| Perturbed evidence on completed states | 128 | 0 / 8 / 120 | Not applicable: no physical negatives |
+| Consistent sensor forgeries on moving states | 8 | 8 / 0 / 0 | **8/8** |
+| All scheduled cases | 200 | 24 / 56 / 120 | **8/56** |
+
+Native positives include eight visible and eight occluded completed states.
+The other six scenarios per layout cover missing targets, a decoy object,
+incorrect position/orientation, unreleased contact and motion. Moving controls
+share their completed control's exact image and pose, but have an explicitly
+assigned native velocity. No artificial object attachment, gravity compensation
+or external force was introduced.
+
+All 128 fault cases agree with the prespecified evidence verdict: 120 return
+unknown for insufficient or invalid evidence, and eight fabricated force spikes
+produce incomplete. Their underlying physical states remain complete. These are
+conservative evidence checks, not 128 extra robot tasks completed successfully.
+
+All eight self-consistent forged observation streams fool the verifier. They
+are retained as **physical false completions**, even though complete is the
+arithmetically correct verdict for the supplied packet. The benchmark therefore
+has 200/200 packet-contract agreement but eight physical false completions.
+This distinction is the reason to publish separate cohorts. A trusted sensor
+path and independent calibration remain necessary.
+
+All 64 native cases constructed successfully; no cases were discarded or
+retried. Physical truth is derived by the frozen native measurement code,
+independently of the new verifier. The protocol uses eight seeded layouts and
+fixed thresholds; one default-seed layout was inspected in an initial unit check
+without parameter tuning. The full development preflight used seed 20261018;
+the measured run uses 20261019. This is not claimed as a fully unseen test set.
+
+## Compute and scope
+
+There are 100 timed verifier calls per case after ten warm-ups: 20,000 timed
+calls total. Native cases take **0.295 ms p50, 0.317 ms p95, 0.386 ms p99 and
+0.799 ms maximum**. Across all cohorts: **0.267 ms p50, 0.318 ms p95,
+0.398 ms p99 and 0.963 ms maximum**. Early rejection paths and corrupted
+packets make the aggregate timing different from native timing.
+
+Timing surrounds the verifier with parsed inputs already in memory. It excludes
+sensing, the required **200 ms history accumulation**, rendering, serialization,
+networking and actuation. This is a repeated-call microbenchmark on an arm64
+Mac with ten logical CPUs, Python 3.12.9 and Darwin 25.5.0; it is not a real-time
+deadline or an end-to-end reaction measurement. It must not be presented as a
+speedup over the prior Jev online-request measurement, which timed different work.
+Native fixture generation, rendering and control-file writing took 13.101 seconds.
+No GPU or hosted model was used by the verifier.
+
+The narrow 30 g rigid proxy and privileged native state remain substantial
+limits. This does not validate deformable real shoes, sensor identity estimation,
+force measurement, calibrated uncertainty, manipulation success or hardware
+transfer. Zero uncertainty means exact-native-state assumptions, not a claim
+about real sensors. A sampled window also does not establish continuous safety.
+
+## Reproduce and audit
+
+Benchmark source commit: `b4c76b13ccbdaff4f01726bee50fae5fcc1e4e4a`.
+The source and twelve dependency hashes are frozen in `protocol.json`. Native
+assets retain PiPER upstream commit `0059d4335f8156206f63a35662313385f7ad6d74`.
+The earlier generator, Jev client and scorer remain unchanged. Protocol,
+inputs and results have separate hashes in `metrics.json`.
+
+The public evidence includes every packet, native state and image, all 20,000
+timings, complete decisions, the input seal and publication seal. Generation
+failures abort scoring with sealed diagnostics; category mismatches with valid
+packets stay in the measured inventory. No credential is needed or included.
+
+Original DVIDIA source and authored fixtures are MIT. Upstream PiPER and MuJoCo
+notices remain applicable. No Jev weights, new training or raw customer footage
+are redistributed. The next step is to test estimated observations and calibrated
+uncertainty against independent truth, then connect the verifier to bounded
+controller recovery—not to treat simulator truth as a solved perception system.

benchmarks/local-goal-verifier-20261019/independent-review.json

@@ -0,0 +1,135 @@
+{
+  "benchmark_source_commit": "b4c76b13ccbdaff4f01726bee50fae5fcc1e4e4a",
+  "checks": {
+    "all_full_local_decisions_reproduced": 200,
+    "complete_two_hundred_case_inventory": true,
+    "exact_alias_pose_history_and_png_pairs": 8,
+    "exact_native_packet_history_mappings": 64,
+    "forged_streams_retain_physical_negative_truth": 8,
+    "independent_metric_and_quantile_recomputation": true,
+    "independently_checked_evidence_perturbations": 128,
+    "native_final_states_restored_and_measurements_reconstructed": 64,
+    "native_max_force_reconstruction_error_n": 3.087976365723222e-07,
+    "native_raw_history_predicates_recomputed": 64,
+    "publisher_tests_passed": 11,
+    "report_tests_passed": 9,
+    "twelve_frozen_source_files_match_working_tree_and_recorded_git_blobs": true,
+    "verifier_adversarial_tests_passed": 16,
+    "zero_generation_invalid": true
+  },
+  "independent_metrics": {
+    "blind_spot": {
+      "expected_matches": 8,
+      "latency_us": {
+        "max": 962.875,
+        "p50": 299.875,
+        "p95": 374.0794999999998,
+        "p99": 454.3614299999999,
+        "samples": 800
+      },
+      "physical_false_completion": [
+        8,
+        8
+      ],
+      "physical_true_completion": [
+        0,
+        0
+      ],
+      "planned": 8,
+      "verdicts": {
+        "complete": 8
+      }
+    },
+    "evidence_fault": {
+      "expected_matches": 128,
+      "latency_us": {
+        "max": 929.75,
+        "p50": 260.583,
+        "p95": 314.583,
+        "p99": 404.25333000000006,
+        "samples": 12800
+      },
+      "physical_false_completion": [
+        0,
+        0
+      ],
+      "physical_true_completion": [
+        0,
+        128
+      ],
+      "planned": 128,
+      "verdicts": {
+        "incomplete": 8,
+        "unknown": 120
+      }
+    },
+    "native": {
+      "expected_matches": 64,
+      "latency_us": {
+        "max": 799.084,
+        "p50": 295.083,
+        "p95": 317.46105,
+        "p99": 386.2583400000002,
+        "samples": 6400
+      },
+      "physical_false_completion": [
+        0,
+        48
+      ],
+      "physical_true_completion": [
+        16,
+        16
+      ],
+      "planned": 64,
+      "verdicts": {
+        "complete": 16,
+        "incomplete": 48
+      }
+    },
+    "overall": {
+      "expected_matches": 200,
+      "latency_us": {
+        "max": 962.875,
+        "p50": 266.583,
+        "p95": 318.16904999999997,
+        "p99": 398.29282999999987,
+        "samples": 20000
+      },
+      "physical_false_completion": [
+        8,
+        56
+      ],
+      "physical_true_completion": [
+        16,
+        144
+      ],
+      "planned": 200,
+      "verdicts": {
+        "complete": 24,
+        "incomplete": 56,
+        "unknown": 120
+      }
+    }
+  },
+  "input_integrity_sha256": "850abb8d4699713ae38665cefd9f45447ca2a3cb4c645c9d14a1f3ea4b4eb6b8",
+  "interpretation": [
+    "All 64 native cases meet the expected physical verdict with privileged native measurements; 16/16 positives are recognized and 0/48 native negatives are falsely completed.",
+    "All 128 evidence perturbations match the expected packet verdict : 120 unknown and 8 incomplete. Their underlying native scenes remain complete; this is not 128 new physical scenes.",
+    "All 8 consistent forgeries produce physical false completions. Overall physical false completion is 8/56; packet-contract agreement 200/200 is not physical or perception accuracy.",
+    "The 20,000 timing samples repeat 100 calls per case and exclude the required 200 ms observation history, acquisition, parsing, rendering, networking and actuators."
+  ],
+  "limitations": [
+    "This is artifact and implementation review plus restoration of final native states, not independent re-execution of each full trajectory or hardware validation.",
+    "Native observations use source-asserted zero uncertainty. The verifier neither authenticates those assertions nor estimates identity, pose, motion or contact from pixels.",
+    "The 8 layouts are correlated authored resets with development exposure documented in the protocol. Fresh does not mean wholly unseen or broadly representative.",
+    "The prior Jev run is a separate retrospective diagnostic. No new provider calls or matched-provider comparison were performed.",
+    "Two pre-freeze robustness findings were corrected: large JSON integers could raise, and per-step clock tolerance could accumulate. Current frozen version rejects both and reports actual aggregate history span."
+  ],
+  "original_core_intact": true,
+  "protocol_sha256": "453d671c9b2addcfb90eed095a9b39fea866f5089c432ed951de6a5717c00e6a",
+  "results_sha256": "2b3cfb91736bf6fc3c68826fc328878d65246cc8cebf15fe8278d3535f6126f9",
+  "reviewed_at": "2026-10-19T09:01:05.765334+00:00",
+  "schema": "dvidia.local-goal-independent-review/v1",
+  "sealed_input_files": 332,
+  "status": "passed"
+}