From 231d8353f8115e51e8318946e3ea03d4f6153532 Mon Sep 17 00:00:00 2001
From: Sam Gu <127461594+SamGu-NRX@users.noreply.github.com>
Date: Tue, 13 Oct 2026 17:41:14 -0500
Subject: [PATCH 01/62] fix(packet): qualify study evidence and proposed
 validation

https://github.com/SamGu-NRX/BaseScanning/pull/22#discussion_r4113999645
https://github.com/SamGu-NRX/BaseScanning/pull/22#discussion_r4114080315
https://github.com/SamGu-NRX/BaseScanning/pull/22#discussion_r4114080318
---
 packet/README.md           | 14 ++++++++------
 packet/validator-checks.md |  3 ++-
 2 files changed, 10 insertions(+), 7 deletions(-)

diff --git a/packet/README.md b/packet/README.md
index 541ce1982..76abdba6e 100644
--- a/packet/README.md
+++ b/packet/README.md
@@ -85,18 +85,20 @@ performance.
 6. **Estimated depth with its uncertainty** (S6). A phone without LiDAR can infer metric depth
    from the image, but used without its uncertainty it creates surfaces that are not there.
    Proposal: a depth `source` of `estimated`, which requires a `sigma` file (float32 meters, one
-   standard deviation per depth pixel, the depth's layout).
+   standard deviation per depth pixel, the depth's layout). To keep malformed uncertainty from
+   reaching geometry calculations, the proposed validator must require exactly `w * h` samples
+   (`4 * w * h` bytes), all finite and non-negative. A missing, truncated or unreadable map is a
+   validation problem, not an exception.
 7. **The frame of a plane's boundary.** 0.4 lists `planes[].boundary` without saying its frame.
    ARKit's `boundaryVertices` are relative to the anchor transform, not to `planeExtent`'s centre
    and `rotationOnYAxis`, and packet 1.1 found that mixing the two is an easy mistake. Proposal:
    carry the anchor-frame boundary in a new field whose frame is stated, rather than giving the
    existing `boundary` a meaning an existing reader might not share, and have the validator check
    it lies within `planeExtent` once the centre and rotation are applied.
-8. **Photos that frame one span.** With learned depth on ETH3D photos, an along-wall edge came to
-   0.9 in p90 when seen within 15° of face-on and 24 in beyond 45° (#59,
-   `experiments/edge-geometry`), so a distance measured inside one face-on photo is likely far
-   better than one chained across the walk. Proposal: a still or
-   keyframe purpose `span` that names the marks the photo frames.
+8. **Photos that frame one span.** With learned depth on ETH3D electro photos scaled using the
+   laser reference, in-plane edges had along-wall error of 0.9 in p90 within 15° of face-on and
+   24 in beyond 45° (#59, `experiments/edge-geometry`). Proposal: a still or keyframe purpose
+   `span` that names the marks the photo frames.
 9. **Scale references in view.** One reference near the meter may not be enough: on MARViN's
    walks ARKit's scale varied 1.8% (robust SD) within a walk (#59, `experiments/drift-anatomy`),
    so a reference helps where it appears. Proposal: `references[]` with `kind` (door, brick course, and hand-held ones such
diff --git a/packet/validator-checks.md b/packet/validator-checks.md
index 37a8cf041..f5be618be 100644
--- a/packet/validator-checks.md
+++ b/packet/validator-checks.md
@@ -52,7 +52,8 @@ case.
 `geometry/mesh.ply` is a binary little-endian PLY. 0.4 does not fix its index and count types, so
 this check proposes one layout as well:
 - `float x, y, z` per vertex, and per face a `uchar` count followed by that many `int` indices,
-  then an optional `uchar classification`;
+  then `uchar classification` when `mesh.classified` is true. The property may be absent only
+  when the flag is false, so a mesh cannot claim face classes without carrying them;
 - the body length equals exactly what the vertex and face counts imply;
 - vertex and face counts are non-negative, and every vertex coordinate is finite;
 - every face is a triangle, and every index satisfies `0 <= index < vertex_count`;

From ec357bb56897440ddaa959790feea0ec3642d53c Mon Sep 17 00:00:00 2001
From: Sam Gu <127461594+SamGu-NRX@users.noreply.github.com>
Date: Tue, 13 Oct 2026 17:44:30 -0500
Subject: [PATCH 02/62] fix(check): include independent verification in root
 dispatch

https://github.com/SamGu-NRX/BaseScanning/pull/13#discussion_r4114226413
---
 Makefile          | 17 ++++++++++++-----
 tests/makefile.sh | 11 ++++++-----
 2 files changed, 18 insertions(+), 10 deletions(-)

diff --git a/Makefile b/Makefile
index 21d3fd050..138e460e5 100644
--- a/Makefile
+++ b/Makefile
@@ -1,34 +1,36 @@
 # Each suite target runs the commands of its CI job in .github/workflows/.
 # `make check` runs server, web and ios, then scoring, measure-lab, evals, recon
-# and meter-closeup where the branch has them.
+# meter-closeup and verification where the branch has them.
 # tests/makefile.sh checks this dispatch with stub suites.
 
 XCODEGEN ?= xcodegen
 # Must match XCODEGEN_VERSION in .github/workflows/ios.yml; other versions write a different project.
 XCODEGEN_VERSION := 2.46.0
 
-# The file each experiment suite's target needs. These suites arrive in separate pull requests, so
+# The file each optional suite's target needs. These suites arrive in separate pull requests, so
 # `check` includes one only when its file exists and the Makefile works before and after each
-# merge. Once all five are on main, list them in `check` directly so a deleted folder fails.
+# merge. Once all six are on main, list them in `check` directly so a deleted folder fails.
 SCORING := experiments/scoring/pyproject.toml
 MEASURE_LAB := experiments/measure-lab/Makefile
 EVALS := experiments/evals/Makefile
 RECON := recon/Makefile
 METER_CLOSEUP := experiments/meter-closeup/Makefile
+VERIFICATION := verification/Makefile
 
 # $(call present,FILE,TARGET) is TARGET when FILE exists, otherwise nothing.
 present = $(if $(wildcard $(1)),$(2))
 # $(call require,FILE,PR): stop before any command runs when the suite's file is missing.
 require = @test -f $(1) || { echo "make $@: $(1) is missing; the suite arrives with pull request $(2)." >&2; exit 1; }
 
-.PHONY: check server web ios ios-project smoke scoring measure-lab evals recon meter-closeup
+.PHONY: check server web ios ios-project smoke scoring measure-lab evals recon meter-closeup verification
 
 check: server web ios \
 	$(call present,$(SCORING),scoring) \
 	$(call present,$(MEASURE_LAB),measure-lab) \
 	$(call present,$(EVALS),evals) \
 	$(call present,$(RECON),recon) \
-	$(call present,$(METER_CLOSEUP),meter-closeup)
+	$(call present,$(METER_CLOSEUP),meter-closeup) \
+	$(call present,$(VERIFICATION),verification)
 
 server:
 	cd server && uv sync --locked
@@ -85,6 +87,11 @@ meter-closeup:
 	$(call require,$(METER_CLOSEUP),#16)
 	$(MAKE) -C experiments/meter-closeup check
 
+# PR #13 added this suite; leaving it out lets `make check` skip the independent verifier.
+verification:
+	$(call require,$(VERIFICATION),#13)
+	$(MAKE) -C verification test
+
 # Posts each scene in server/examples to a placement server and prints its decision:
 # make smoke URL=https://house-scanning-server.vercel.app [KEY_FILE=server/.env.private.local]
 smoke:
diff --git a/tests/makefile.sh b/tests/makefile.sh
index 9e7552bd5..361870a41 100755
--- a/tests/makefile.sh
+++ b/tests/makefile.sh
@@ -27,10 +27,10 @@ EOF
 done
 export PATH="$work/bin:$PATH"
 
-suites="scoring measure-lab evals recon meter-closeup"
+suites="scoring measure-lab evals recon meter-closeup verification"
 folder() {
 	case $1 in
-	recon) echo recon ;;
+	recon | verification) echo "$1" ;;
 	*) echo "experiments/$1" ;;
 	esac
 }
@@ -66,8 +66,8 @@ fail() {
 }
 
 # 1. `make check` runs server, web and ios, then exactly the experiment suites present, in order,
-#    for all 32 combinations. "." is the ios build, which runs from the root.
-for mask in $(seq 0 31); do
+#    for all 64 combinations. "." is the ios build, which runs from the root.
+for mask in $(seq 0 63); do
 	present=()
 	expected="server web ."
 	i=0
@@ -106,6 +106,7 @@ expect_commands evals "experiments/evals uv sync --locked
 experiments/evals make test"
 expect_commands recon "recon make test"
 expect_commands meter-closeup "experiments/meter-closeup make check"
+expect_commands verification "verification make test"
 
 # 3. Naming a missing suite fails loudly and runs nothing.
 for suite in $suites; do
@@ -119,7 +120,7 @@ done
 
 # 4. A failing command inside a present suite fails `make check`, and nothing runs after it.
 for FAIL_AT in "experiments/scoring uv" "experiments/measure-lab make" "experiments/evals uv" \
-	"experiments/evals make" "recon make" "experiments/meter-closeup make"; do
+	"experiments/evals make" "recon make" "experiments/meter-closeup make" "verification make"; do
 	make_tree $suites
 	if run_make check; then
 		fail "check passed although $FAIL_AT failed"

From a5e976d75c88263a4fb79c6d48d0b9f788367dc5 Mon Sep 17 00:00:00 2001
From: Sam Gu <127461594+SamGu-NRX@users.noreply.github.com>
Date: Tue, 13 Oct 2026 17:46:52 -0500
Subject: [PATCH 03/62] fix(verification): keep simulator evidence tied to its
 own run

https://github.com/SamGu-NRX/BaseScanning/pull/13#discussion_r4115325486
https://github.com/SamGu-NRX/BaseScanning/pull/13#discussion_r4115325493
https://github.com/SamGu-NRX/BaseScanning/pull/13#discussion_r4114865933
https://github.com/SamGu-NRX/BaseScanning/pull/13#discussion_r4114352263
https://github.com/SamGu-NRX/BaseScanning/pull/13#discussion_r4114352258
---
 verification/hsverify/a11yaudit.py   | 22 +++++---
 verification/hsverify/simrun.py      | 34 +++++++++---
 verification/tests/test_a11yaudit.py | 21 +++++++-
 verification/tests/test_simrun.py    | 79 +++++++++++++++++++++++++++-
 4 files changed, 142 insertions(+), 14 deletions(-)

diff --git a/verification/hsverify/a11yaudit.py b/verification/hsverify/a11yaudit.py
index f02b604bb..0873a121e 100644
--- a/verification/hsverify/a11yaudit.py
+++ b/verification/hsverify/a11yaudit.py
@@ -90,7 +90,7 @@ def audit_problems(screens: list[dict], harness_ran: bool, min_screens: int) ->
     """Why this run is not evidence of an audit; empty when it is."""
     problems = []
     if not harness_ran:
-        problems.append("the audit harness did not run (no TEST SUCCEEDED or TEST FAILED line)")
+        problems.append("the audit harness did not finish successfully")
     problems += [f"screen {s.get('index')}: {s['error']}" for s in screens if "error" in s]
     audited = audited_screens(screens)
     if not audited:
@@ -102,7 +102,7 @@ def audit_problems(screens: list[dict], harness_ran: bool, min_screens: int) ->
 
 def run_harness(
     udid: str, bundle_id: str, args: argparse.Namespace, launch: list[str], out: Path
-) -> str:
+) -> tuple[str, int]:
     env = os.environ | {
         "TEST_RUNNER_AUDIT_BUNDLE": bundle_id,
         "TEST_RUNNER_AUDIT_ARGS": ARG_SEPARATOR.join(launch),
@@ -126,7 +126,7 @@ def run_harness(
     simrun.wait_for_other_builds(args.build_wait)
     result = subprocess.run(cmd, env=env, capture_output=True, text=True)
     (out / "xcodebuild-test.log").write_text(result.stdout + result.stderr)
-    return result.stdout
+    return result.stdout, result.returncode
 
 
 def write_report(out: Path, data: dict) -> None:
@@ -171,6 +171,7 @@ def write_report(out: Path, data: dict) -> None:
     (out / "index.html").write_text(page)
 
 
+@simrun.device_lock()
 def main(argv: list[str] | None = None) -> int:
     parser = argparse.ArgumentParser(description=__doc__.split("\n\n")[0])
     parser.add_argument("--ref", default="origin/t3/ios-mvf")
@@ -222,7 +223,11 @@ def main(argv: list[str] | None = None) -> int:
     if app is None:
         print(f"Build failed; see {out / 'build.log'}")
         return 1
-    device = simrun.ensure_device()
+    try:
+        device = simrun.ensure_device()
+    except BaseException:
+        simrun.discard_app(app)
+        raise
     udid = device["udid"]
     try:
         bundle_id = simrun.bundle_id_of(app)
@@ -234,13 +239,18 @@ def main(argv: list[str] | None = None) -> int:
             ["xcrun", "simctl", "privacy", udid, "grant", "camera", bundle_id], capture_output=True
         )
         print(f"Auditing {bundle_id} at {sha[:12]}...", flush=True)
-        output = run_harness(udid, bundle_id, args, launch, out)
+        output, test_returncode = run_harness(udid, bundle_id, args, launch, out)
     finally:
+        simrun.discard_app(app)
         subprocess.run(["xcrun", "simctl", "shutdown", udid], capture_output=True)
 
     screens, issues = parse_output(output)
     symbols = symbol_name_labels(screens)
-    harness_ran = "** TEST SUCCEEDED **" in output or "** TEST FAILED **" in output
+    harness_ran = (
+        test_returncode == 0
+        and "** TEST SUCCEEDED **" in output
+        and "** TEST FAILED **" not in output
+    )
     problems = audit_problems(screens, harness_ran, args.min_screens)
     data = {
         # ok: the run is evidence of an audit. Issues found are counted separately below.
diff --git a/verification/hsverify/simrun.py b/verification/hsverify/simrun.py
index 235d96d8e..8d42bbeb1 100644
--- a/verification/hsverify/simrun.py
+++ b/verification/hsverify/simrun.py
@@ -30,6 +30,7 @@
 import shutil
 import subprocess
 import sys
+import tempfile
 import threading
 import time
 from collections.abc import Iterable
@@ -52,6 +53,7 @@
 DEFAULT_REPORTS = Path.home() / "house-scanning-data" / "reports" / "sim"
 DERIVED_DATA = Path("/tmp/hs-verify-derived-data")
 BUILD_LOCK = Path("/tmp/hs-verify-xcodebuild.lock")
+DEVICE_LOCK = Path("/tmp/hs-verify-simulator.lock")
 BUILT_APP_DIR = "built-app"  # in the report folder, until the Simulator has installed it
 
 
@@ -219,11 +221,14 @@ def build_app(
         built = DERIVED_DATA / "Build" / "Products" / "Debug-iphonesimulator" / f"{scheme}.app"
         app = None
         if code == 0 and built.exists():
-            app = out / BUILT_APP_DIR / built.name
-            shutil.rmtree(app.parent, ignore_errors=True)
-            shutil.copytree(built, app, symlinks=True)
+            app = Path(tempfile.mkdtemp(prefix=f"{BUILT_APP_DIR}-", dir=out)) / built.name
+            try:
+                shutil.copytree(built, app, symlinks=True)
+            except BaseException:
+                discard_app(app)
+                raise
     text = log_path.read_text(errors="replace")
-    warnings = sorted(set(re.findall(r"^.*: warning: .*$", text, re.M)))
+    warnings = sorted(set(re.findall(r"^(?:.*: )?warning: .*$", text, re.M)))
     errors = sorted(set(re.findall(r"^.*: error: .*$", text, re.M)))
     result = {
         "ok": code == 0,
@@ -239,7 +244,7 @@ def build_app(
 
 def discard_app(app: Path) -> None:
     """Remove this run's copy of the app once the Simulator has installed its own."""
-    if app.parent.name == BUILT_APP_DIR:
+    if app.parent.name.startswith(f"{BUILT_APP_DIR}-"):
         shutil.rmtree(app.parent, ignore_errors=True)
 
 
@@ -529,6 +534,16 @@ def collect_crashes(since: float, out: Path) -> list[str]:
     return found
 
 
+@contextlib.contextmanager
+def device_lock():
+    """Hold the shared Simulator until install, capture and shutdown have finished."""
+    DEVICE_LOCK.touch()
+    with DEVICE_LOCK.open() as lock:
+        fcntl.flock(lock, fcntl.LOCK_EX)
+        yield
+
+
+@device_lock()
 def main(argv: list[str] | None = None) -> int:
     parser = argparse.ArgumentParser(description=__doc__.split("\n\n")[0])
     parser.add_argument("--ref", default="origin/main", help="git ref to build")
@@ -608,7 +623,12 @@ def main(argv: list[str] | None = None) -> int:
         flush=True,
     )
 
-    device = ensure_device(args.udid)
+    try:
+        device = ensure_device(args.udid)
+    except BaseException:
+        if app is not None:
+            discard_app(app)
+        raise
     rep = RunReport(
         ref=args.ref,
         sha=sha,
@@ -654,6 +674,8 @@ def main(argv: list[str] | None = None) -> int:
         if rep.crash_reports:
             rep.problems.append(f"Crash reports: {', '.join(rep.crash_reports)}")
     finally:
+        if app is not None:
+            discard_app(app)
         services.close()
         rep.peak_memory = peak_rss_mb()
         if not args.keep_booted:
diff --git a/verification/tests/test_a11yaudit.py b/verification/tests/test_a11yaudit.py
index 6013a20e3..7a2f1fd03 100644
--- a/verification/tests/test_a11yaudit.py
+++ b/verification/tests/test_a11yaudit.py
@@ -1,3 +1,7 @@
+import argparse
+import subprocess
+
+from hsverify import a11yaudit
 from hsverify.a11yaudit import audit_problems, audited_screens, parse_output, symbol_name_labels
 
 
@@ -51,7 +55,7 @@ def test_zero_screens_is_not_evidence():
 
 def test_harness_that_did_not_run_is_not_evidence():
     problems = audit_problems(NINE, harness_ran=False, min_screens=9)
-    assert problems == ["the audit harness did not run (no TEST SUCCEEDED or TEST FAILED line)"]
+    assert problems == ["the audit harness did not finish successfully"]
 
 
 def test_too_few_distinct_screens():
@@ -79,3 +83,18 @@ def test_error_lines_from_the_harness_are_parsed_as_screens():
         "screen 1: app not running",
         "no screen was audited",
     ]
+
+
+def test_failed_xctest_cannot_be_clean_evidence(tmp_path, monkeypatch):
+    output = "\n".join(f'A11Y_SCREEN={{"index":{i},"issues":0}}' for i in range(1, 10))
+    output += "\n** TEST SUCCEEDED **"
+    monkeypatch.setattr(a11yaudit.simrun, "wait_for_other_builds", lambda _: None)
+    monkeypatch.setattr(
+        a11yaudit.subprocess,
+        "run",
+        lambda *args, **kwargs: subprocess.CompletedProcess([], 65, output, "failed"),
+    )
+    args = argparse.Namespace(build_wait=0, seconds=1, idle=1)
+    text, code = a11yaudit.run_harness("mock", "mock", args, [], tmp_path)
+    screens, _ = parse_output(text)
+    assert audit_problems(screens, harness_ran=code == 0, min_screens=9)
diff --git a/verification/tests/test_simrun.py b/verification/tests/test_simrun.py
index 515f29828..b4981cecc 100644
--- a/verification/tests/test_simrun.py
+++ b/verification/tests/test_simrun.py
@@ -1,11 +1,15 @@
+import contextlib
 import datetime as dt
 import io
 import json
 import queue
 import subprocess
+import sys
 from pathlib import Path
 
-from hsverify import simrun
+import pytest
+
+from hsverify import gitref, simrun
 from hsverify.simrun import (
     ShotRecord,
     app_export,
@@ -186,3 +190,76 @@ def fake_build(cmd, **kwargs):
     assert (app / "Info.plist").read_text() == "run A"
     simrun.discard_app(app)
     assert not app.parent.exists() and out.exists()
+
+
+def test_shared_output_keeps_both_app_copies(tmp_path, monkeypatch):
+    derived = tmp_path / "derived"
+    built = derived / "Build" / "Products" / "Debug-iphonesimulator" / "HouseScan.app"
+    monkeypatch.setattr(simrun, "DERIVED_DATA", derived)
+    monkeypatch.setattr(simrun, "BUILD_LOCK", tmp_path / "lock")
+    monkeypatch.setattr(simrun, "wait_for_other_builds", lambda _: 0.0)
+
+    def fake_build(cmd, **kwargs):
+        built.mkdir(parents=True, exist_ok=True)
+        (built / "Info.plist").write_text("app")
+        kwargs["stdout"].write("warning: Run script build phase\n/path/File: warning: warning\n")
+        return subprocess.CompletedProcess(cmd, 0)
+
+    monkeypatch.setattr(simrun.subprocess, "run", fake_build)
+    tree, out = tmp_path / "tree", tmp_path / "report"
+    (tree / "ios" / "HouseScan.xcodeproj").mkdir(parents=True)
+    out.mkdir()
+    result, first = simrun.build_app(tree, out, 0, "ios/HouseScan.xcodeproj", "HouseScan")
+    _, second = simrun.build_app(tree, out, 0, "ios/HouseScan.xcodeproj", "HouseScan")
+    assert first != second and first.exists() and second.exists()
+    assert len(result["warnings"]) == 2
+    simrun.discard_app(first)
+    assert not first.exists() and second.exists()
+
+
+@pytest.mark.parametrize("failure", ["device", "bundle", "install"])
+def test_failed_preparation_discards_app_copy(tmp_path, monkeypatch, failure):
+    out = tmp_path / "out"
+    app = out / "built-app-unique" / "HouseScan.app"
+    app.mkdir(parents=True)
+    monkeypatch.setattr(simrun, "DEVICE_LOCK", tmp_path / "device.lock")
+    monkeypatch.setattr(gitref, "fetch", lambda: None)
+    monkeypatch.setattr(gitref, "resolve", lambda _: "a" * 40)
+    monkeypatch.setattr(
+        gitref, "detached_worktree", lambda *args, **kwargs: contextlib.nullcontext(tmp_path)
+    )
+    monkeypatch.setattr(simrun, "static_c4_check", lambda _: {})
+    monkeypatch.setattr(simrun, "build_app", lambda *args: ({"ok": True}, app))
+
+    def fail():
+        raise RuntimeError("preparation failed")
+
+    monkeypatch.setattr(
+        simrun, "ensure_device", lambda _: fail() if failure == "device" else {"udid": "mock"}
+    )
+    monkeypatch.setattr(simrun, "bundle_id_of", lambda _: fail() if failure == "bundle" else "mock")
+    monkeypatch.setattr(simrun, "prepare_display", lambda *args: None)
+    monkeypatch.setattr(simrun, "simctl", lambda *args: fail() if args[0] == "install" else "")
+    monkeypatch.setattr(
+        simrun.subprocess, "run", lambda *args, **kwargs: subprocess.CompletedProcess([], 0)
+    )
+    monkeypatch.setattr(simrun, "peak_rss_mb", lambda: {})
+    monkeypatch.setattr(simrun.report, "write_sim_report", lambda *args: None)
+    with pytest.raises(RuntimeError, match="preparation failed"):
+        simrun.main(["--out", str(out)])
+    assert not app.parent.exists()
+
+
+def test_device_lock_excludes_another_runner_and_releases(tmp_path, monkeypatch):
+    monkeypatch.setattr(simrun, "DEVICE_LOCK", tmp_path / "device.lock")
+    script = """import fcntl, sys
+with open(sys.argv[1]) as lock:
+    try:
+        fcntl.flock(lock, fcntl.LOCK_EX | fcntl.LOCK_NB)
+    except BlockingIOError:
+        sys.exit(43)
+"""
+    cmd = [sys.executable, "-c", script, str(simrun.DEVICE_LOCK)]
+    with simrun.device_lock():
+        assert subprocess.run(cmd, timeout=5, check=False).returncode == 43
+    assert subprocess.run(cmd, timeout=5, check=False).returncode == 0

From c6442176eb155282ba1ac10b779606d5afc6b574 Mon Sep 17 00:00:00 2001
From: Sam Gu <127461594+SamGu-NRX@users.noreply.github.com>
Date: Tue, 13 Oct 2026 17:47:13 -0500
Subject: [PATCH 04/62] fix(verification): validate interior footprints and
 replay failures

https://github.com/SamGu-NRX/BaseScanning/pull/13#discussion_r4114226423
https://github.com/SamGu-NRX/BaseScanning/pull/13#discussion_r4115043212
https://github.com/SamGu-NRX/BaseScanning/pull/13#discussion_r4115325475
https://github.com/SamGu-NRX/BaseScanning/pull/13#discussion_r4114835310
https://github.com/SamGu-NRX/BaseScanning/pull/13#discussion_r4115325477
https://github.com/SamGu-NRX/BaseScanning/pull/13#discussion_r4114352256
https://github.com/SamGu-NRX/BaseScanning/pull/13#discussion_r4114676179
https://github.com/SamGu-NRX/BaseScanning/pull/13#discussion_r4115325497
---
 verification/hsverify/replaycheck.py          |  8 +++--
 verification/hsverify/resultcheck.py          | 20 +++++++++--
 .../scenes/eth3d-facade/build_scene.py        |  7 ++--
 verification/tests/test_build_scene.py        |  9 +++++
 verification/tests/test_replaycheck.py        | 18 ++++++++++
 verification/tests/test_resultcheck.py        | 33 +++++++++++++++++--
 6 files changed, 85 insertions(+), 10 deletions(-)

diff --git a/verification/hsverify/replaycheck.py b/verification/hsverify/replaycheck.py
index eaf415414..1f6fab57a 100644
--- a/verification/hsverify/replaycheck.py
+++ b/verification/hsverify/replaycheck.py
@@ -46,7 +46,11 @@ def numbers(value: Any, count: int) -> list[float] | None:
         return None
     if not all(isinstance(v, (int, float)) and not isinstance(v, bool) for v in value):
         return None
-    return [float(v) for v in value] if all(math.isfinite(v) for v in value) else None
+    try:
+        converted = [float(v) for v in value]
+    except OverflowError:
+        return None
+    return converted if all(math.isfinite(v) for v in converted) else None
 
 
 def rigid_problems(m: np.ndarray, tol: float = 1e-3) -> list[str]:
@@ -246,7 +250,7 @@ def main(argv: list[str] | None = None) -> int:
     errors, summary = check_format(folder, session)
     report: dict = {"session": str(folder), "format_errors": errors, "summary": summary}
     truth_path = folder / "ground_truth.json"
-    if truth_path.exists():
+    if truth_path.exists() and not errors:
         report["pose_accuracy"] = accuracy(session, json.loads(truth_path.read_text()))
     if args.json:
         print(json.dumps(report, indent=2))
diff --git a/verification/hsverify/resultcheck.py b/verification/hsverify/resultcheck.py
index bb276281a..e1ab5a718 100644
--- a/verification/hsverify/resultcheck.py
+++ b/verification/hsverify/resultcheck.py
@@ -91,6 +91,7 @@ class RuleSet:
     battery_height_ft: float | None = None
     # the rules' headroom.min_ft: how high a wall view without out_ft reached
     headroom_ft: float | None = None
+    corner_allowance_ft: float | None = None
 
     @classmethod
     def from_yaml(cls, text: str) -> RuleSet:
@@ -150,6 +151,7 @@ def reach(key: str) -> Need:
             value("sweep", "wall_join_ft"),
             value("battery", "height_ft"),
             headroom,
+            value("route", "corner_allowance_ft"),
         )
 
 
@@ -450,10 +452,11 @@ def off_wall(lo: float, hi: float, outcome: str, wall_id: str) -> str | None:
     for run in result.get("sweep", []):
         if run["outcome"] not in ("pass", "unsure"):
             continue
-        for start in dict.fromkeys(run["start_ft"]):  # a run's two ends bound all its starts
+        for start in run_starts(run["start_ft"], rules.step_ft):
             battery = (start, start + rules.width_ft)
             if (why := off_wall(*battery, run["outcome"], run["wall_id"])) is not None:
                 problems.append(f"sweep {run['outcome']} start {start:.2f} {why}")
+                break
     return problems
 
 
@@ -1109,8 +1112,19 @@ def with_past_ends_asked(scene: dict, requests: list[dict], rules: RuleSet) -> d
 # --- Case expectations -----------------------------------------------------------------------
 
 
-def assumption_mismatches(assumed: dict[str, float], result: dict) -> list[str]:
+def assumption_mismatches(
+    assumed: dict[str, float], result: dict, rules: RuleSet | None = None
+) -> list[str]:
     out = []
+    configured = (
+        {"battery_width": rules.width_ft, "corner_allowance": rules.corner_allowance_ft}
+        if rules
+        else {}
+    )
+    for key, value in assumed.items():
+        actual = configured.get(key)
+        if actual is not None and abs(actual - value) > EPS:
+            out.append(f"case assumes {key} {value}, rules use {actual}")
     for key, value in assumed.items():
         for check in result.get("checks", []):
             threshold = check.get("threshold_ft")
@@ -1394,7 +1408,7 @@ def with_ground_short_of(scene: dict, rules: RuleSet, margin_ft: float = 0.1) ->
     m = copy.deepcopy(scene)
     for entry in m["coverage"]["observed"]:
         if entry["band"] == "ground":
-            entry["out_ft"] = min(entry["out_ft"], reach)
+            entry["out_ft"] = min(entry.get("out_ft", 0.0), reach)
     return m
 
 
diff --git a/verification/scenes/eth3d-facade/build_scene.py b/verification/scenes/eth3d-facade/build_scene.py
index a5cb9f841..f794a9e4f 100644
--- a/verification/scenes/eth3d-facade/build_scene.py
+++ b/verification/scenes/eth3d-facade/build_scene.py
@@ -487,12 +487,13 @@ def band_coverage(band, walls, facing, kfs, seen=visible):
     down so it never claims more. `seen(kf, wall, X, walls)` is `visible`; tests replace it."""
     samples = []  # (s0, s1, reach) per sample seen
     for w in walls:
-        for s in np.arange(w.s0 + COVERAGE_STEP_FT / 2, w.s0 + w.length, COVERAGE_STEP_FT):
+        for a in np.arange(w.s0, w.s0 + w.length, COVERAGE_STEP_FT):
+            b = min(a + COVERAGE_STEP_FT, w.s0 + w.length)
+            s = (a + b) / 2
             fd = next((v for (wid, a, b, v) in facing if wid == w.id and a <= s < b), None)
             probes = band_probes(band, w, s, fd)
             if probes is not None and any(all(seen(k, w, X, walls) for X in probes) for k in kfs):
-                half = COVERAGE_STEP_FT / 2
-                samples.append([s - half, s + half, band_reach(band, fd)])
+                samples.append([a, b, band_reach(band, fd)])
     merged = []  # consecutive samples, also across a corner, keep the smaller reach
     for a, b, reach in samples:
         if merged and abs(merged[-1][1] - a) < 1e-6:
diff --git a/verification/tests/test_build_scene.py b/verification/tests/test_build_scene.py
index d2983bfb7..1e0c6bfd4 100644
--- a/verification/tests/test_build_scene.py
+++ b/verification/tests/test_build_scene.py
@@ -92,3 +92,12 @@ def only_low(kf, w, X, walls):
 
     entries, _ = build_scene.band_coverage("wall", [wall("w", 0.0, 2.0)], [], ["kf"], only_low)
     assert entries == []
+
+
+@pytest.mark.parametrize("length", [2.2, 2.3, 0.05])
+def test_non_grid_wall_has_no_excess_or_missing_tail(length):
+    entries, spans = build_scene.band_coverage(
+        "wall", [wall("w", 0.0, length)], [], ["kf"], seen_everywhere
+    )
+    assert entries[0]["span_ft"] == [0.0, length]
+    assert spans == [[0.0, length]]
diff --git a/verification/tests/test_replaycheck.py b/verification/tests/test_replaycheck.py
index dd830e2e3..ef07b710e 100644
--- a/verification/tests/test_replaycheck.py
+++ b/verification/tests/test_replaycheck.py
@@ -4,6 +4,7 @@
 import numpy as np
 import pytest
 
+from hsverify import replaycheck
 from hsverify.replaycheck import (
     accuracy,
     check_format,
@@ -136,3 +137,20 @@ def test_accuracy_separates_scale_from_alignment(tmp_path, scale):
     assert result["max_vertical_axis_mismatch"] == pytest.approx(0, abs=1e-9)
     expected_final = (1 - scale) * 39
     assert result["anchored_error_m_final"] == pytest.approx(expected_final, abs=1e-3)
+
+
+def test_oversized_integer_is_a_format_error(tmp_path):
+    session = session_with(tmp_path, [[0, 0, 0]])
+    session["keyframes"][0]["intrinsics"][0] = 10**400
+    errors, _ = check_format(tmp_path, session)
+    assert any("finite numbers" in e for e in errors)
+
+
+def test_invalid_replay_with_ground_truth_still_reports(tmp_path, capsys):
+    session = session_with(tmp_path, [[0, 0, 0]])
+    del session["keyframes"][0]["pose"]
+    (tmp_path / "session.json").write_text(json.dumps(session))
+    (tmp_path / "ground_truth.json").write_text("{}")
+    assert replaycheck.main([str(tmp_path), "--json"]) == 1
+    data = json.loads(capsys.readouterr().out)
+    assert data["format_errors"] and "pose_accuracy" not in data
diff --git a/verification/tests/test_resultcheck.py b/verification/tests/test_resultcheck.py
index 5846b7a9a..08935bd3a 100644
--- a/verification/tests/test_resultcheck.py
+++ b/verification/tests/test_resultcheck.py
@@ -412,7 +412,7 @@ def test_rules_come_from_rules_yaml_and_a_missing_one_is_loud():
 openings: {exempt_bottom_above_ft: null}
 facing: {min_ft: {value: 3}}
 headroom: {min_ft: {value: 6.5}}
-route: {height_ft: {value: 1}}
+route: {height_ft: {value: 1}, corner_allowance_ft: {value: 0.5}}
 sweep: {step_ft: {value: 0.166666666667}, wall_join_ft: {value: 0.6}}
 """
     rules = RuleSet.from_yaml(text)
@@ -1335,7 +1335,7 @@ def test_a_passing_footprint_keeps_the_wall_error_clear_of_its_stretch_end():
     ]
     r = result(spot=False, sweep=[pass_run(6.846, 10.0 - 31 / 12)])
     assert footprint_problems(scene, r, RULES) == [
-        "sweep pass start 7.42 ends within its error (0.60 ft) of its straight wall's end at 10.00"
+        "sweep pass start 7.01 ends within its error (0.60 ft) of its straight wall's end at 10.00"
     ]
     r["sweep"][0]["outcome"] = "unsure"  # unsure may stand that close
     assert footprint_problems(scene, r, RULES) == []
@@ -1479,3 +1479,32 @@ def test_a_band_gap_under_the_coverage_tolerance_is_rounding():
     assert gaps_over([(-6.5, 18.0)], 9.94, 18.011) == [(18.0, 18.011)]
     assert gaps_over([(0.0, 1.0), (1.009, 3.0)], 0.5, 2.0) == []
     assert gaps_over([(0.0, 1.0), (1.011, 3.0)], 0.5, 2.0) == [(1.0, 1.011)]
+
+
+@pytest.mark.parametrize("outcome", ["pass", "unsure"])
+def test_interior_sweep_start_cannot_cross_a_corner(outcome):
+    scene = copy.deepcopy(SCENE)
+    scene["walls"][0]["baseline"] = [[-12.0, 0.0], [5.0, 0.0], [5.0, 7.0]]
+    result = {"sweep": [{"wall_id": "w1", "start_ft": [1.0, 8.0], "outcome": outcome}]}
+    assert footprint_problems(scene, result, RULES)
+
+
+def test_ground_trimming_keeps_omitted_reach_at_zero():
+    scene = copy.deepcopy(SCENE)
+    scene["coverage"]["observed"] = [
+        {"band": "ground", "span_ft": [-12, 0]},
+        {"band": "ground", "span_ft": [0, 12], "out_ft": 100},
+    ]
+    trimmed = with_ground_short_of(scene, RULES)
+    assert trimmed["coverage"]["observed"][0]["out_ft"] == 0
+
+
+def test_geometric_assumptions_compare_active_rules():
+    rules = replace(RULES, corner_allowance_ft=0.5)
+    assert (
+        len(assumption_mismatches({"battery_width": 100, "corner_allowance": 100}, {}, rules)) == 2
+    )
+    assert (
+        assumption_mismatches({"battery_width": rules.width_ft, "corner_allowance": 0.5}, {}, rules)
+        == []
+    )

From 853c2dfa9889cce89f7b8932ccc65a9de9664b79 Mon Sep 17 00:00:00 2001
From: Sam Gu <127461594+SamGu-NRX@users.noreply.github.com>
Date: Tue, 13 Oct 2026 17:48:00 -0500
Subject: [PATCH 05/62] fix(verification): reject incomplete evidence and stale
 input hashes

https://github.com/SamGu-NRX/BaseScanning/pull/13#discussion_r4114352255
https://github.com/SamGu-NRX/BaseScanning/pull/13#discussion_r4114865938
https://github.com/SamGu-NRX/BaseScanning/pull/13#discussion_r4114226429
https://github.com/SamGu-NRX/BaseScanning/pull/13#discussion_r4114226433
https://github.com/SamGu-NRX/BaseScanning/pull/13#discussion_r4114331241
https://github.com/SamGu-NRX/BaseScanning/pull/13#discussion_r4114352260
https://github.com/SamGu-NRX/BaseScanning/pull/13#discussion_r4115043204
https://github.com/SamGu-NRX/BaseScanning/pull/13#discussion_r4115043208
---
 verification/hsverify/e2e.py          | 31 ++++++++-----
 verification/hsverify/gitref.py       |  2 +-
 verification/hsverify/scoreboard.py   | 14 +++++-
 verification/scoreboard/metrics.yaml  |  2 +
 verification/tests/test_e2e.py        | 67 ++++++++++++++++++++++++++-
 verification/tests/test_gitref.py     |  7 +++
 verification/tests/test_scoreboard.py | 25 ++++++++++
 7 files changed, 134 insertions(+), 14 deletions(-)

diff --git a/verification/hsverify/e2e.py b/verification/hsverify/e2e.py
index 87e8bde35..7d7321584 100644
--- a/verification/hsverify/e2e.py
+++ b/verification/hsverify/e2e.py
@@ -151,9 +151,12 @@ def read_bundle(path: Path) -> tuple[bytes, dict[str, bytes]]:
         declared = sum(i.file_size for i in infos)
         if declared > MAX_BUNDLE_BYTES:
             raise SystemExit(f"{path}: declares {declared} bytes, limit {MAX_BUNDLE_BYTES}")
-        scene = next((i for i in infos if i.filename.endswith("scene.json")), None)
-        if scene is None:
-            raise SystemExit(f"{path}: no scene.json in the bundle")
+        scenes = [i for i in infos if i.filename == "scene.json"]
+        if len(scenes) != 1:
+            raise SystemExit(
+                f"{path}: expected exactly one canonical scene.json, found {len(scenes)}"
+            )
+        scene = scenes[0]
         raw = read_bounded(bundle, scene, MAX_SCENE_BYTES)
         images = {
             Path(i.filename).name: read_bounded(bundle, i, MAX_IMAGE_BYTES)
@@ -467,7 +470,7 @@ def judge(
     contract += property_problems(url, endpoint, item, result, schemas, rules)
     if item.real and ms > LATENCY_BUDGET_MS:
         contract.append(f"real-derived scene took {ms:.0f} ms, budget {LATENCY_BUDGET_MS:.0f}")
-    mismatches = assumption_mismatches(item.rules_assumed, result)
+    mismatches = assumption_mismatches(item.rules_assumed, result, rules)
     expected = expectation_problems(item.expect, result) if item.expect and not mismatches else []
     problems = contract + expected
 
@@ -491,7 +494,8 @@ def property_problems(
     problems: list[str] = []
 
     def resend(name: str, scene: dict) -> dict | None:
-        other, failure = answer(url, endpoint, variant(item, name, scene))
+        transformed = variant(item, name, scene)
+        other, failure = answer(url, endpoint, transformed)
         if failure:
             problems.append(f"{name}: {failure}")
             return None
@@ -499,7 +503,10 @@ def resend(name: str, scene: dict) -> dict | None:
         if errors:
             problems.append(f"{name}: result schema: {errors[0]}")
             return None
-        problems.extend(f"{name}: {p}" for p in invariant_problems(scene, other, rules=rules))
+        problems.extend(
+            f"{name}: {p}"
+            for p in invariant_problems(scene, other, sent=transformed.raw, rules=rules)
+        )
         return other
 
     # 1. Same input, same answer.
@@ -661,8 +668,11 @@ def judge_hostile(
         and not (endpoint.accepts_zip)
     ):
         return {
-            "status": "skipped",
-            "skip_reason": "the endpoint takes neither a zip nor an upload",
+            "status": "fail",
+            "problems": ["large-input probe was not exercised: endpoint accepts no archive"],
+            "contract_problems": [
+                "large-input probe was not exercised: endpoint accepts no archive"
+            ],
         }
     before = limit.reset() if limit else 0.0
     status, payload, ms = post(url, endpoint, item, timeout_s=HOSTILE_BUDGET_MS / 1000 + 5)
@@ -712,9 +722,8 @@ def write_report(out: Path, meta: dict, records: list[dict]) -> dict:
     killed = bool(meta["peak_memory"].get("server_killed"))
     report = meta | {
         "counts": counts,
-        "all_passed": all(r["status"] in ("pass", "skipped") for r in records)
-        and bool(checked)
-        and not killed,
+        # A missing listed scene leaves the run incomplete, even when other scenes passed.
+        "all_passed": all(r["status"] == "pass" for r in records) and bool(checked) and not killed,
         "latency_ms": max(real) if real else None,
         "scenes_answered": sum(1 for r in records if "decision" in r),
         "scenes_checked": len(checked),
diff --git a/verification/hsverify/gitref.py b/verification/hsverify/gitref.py
index e711e295d..59f1431d6 100644
--- a/verification/hsverify/gitref.py
+++ b/verification/hsverify/gitref.py
@@ -24,7 +24,7 @@ def git(*args: str, cwd: Path = REPO) -> str:
 
 
 def fetch() -> None:
-    git("fetch", "--quiet", "origin")
+    git("fetch", "--quiet", "--prune", "origin")
 
 
 def resolve(ref: str) -> str:
diff --git a/verification/hsverify/scoreboard.py b/verification/hsverify/scoreboard.py
index 3cca83fe9..725557158 100644
--- a/verification/hsverify/scoreboard.py
+++ b/verification/hsverify/scoreboard.py
@@ -750,7 +750,19 @@ def render_markdown(board: Board) -> str:
 
 def list_prs() -> list[dict]:
     out = subprocess.run(
-        ["gh", "pr", "list", "--repo", GITHUB_REPO, "--state", "open", "--json", PR_FIELDS],
+        [
+            "gh",
+            "pr",
+            "list",
+            "--repo",
+            GITHUB_REPO,
+            "--state",
+            "open",
+            "--limit",
+            "10000",
+            "--json",
+            PR_FIELDS,
+        ],
         check=True,
         capture_output=True,
         text=True,
diff --git a/verification/scoreboard/metrics.yaml b/verification/scoreboard/metrics.yaml
index c73e9cc0c..2013f8c08 100644
--- a/verification/scoreboard/metrics.yaml
+++ b/verification/scoreboard/metrics.yaml
@@ -162,6 +162,8 @@ metrics:
       glob: ~/house-scanning-data/reports/e2e/*/report.json
       # True only when at least one scene was answered and checked and none broke the contract.
       key: contract_ok
+      # A failed or incomplete run cannot establish the advertised black-box acceptance.
+      valid_key: all_passed
       equals: true
       require_current_sha: true
 
diff --git a/verification/tests/test_e2e.py b/verification/tests/test_e2e.py
index 13d70f552..a7707e1ec 100644
--- a/verification/tests/test_e2e.py
+++ b/verification/tests/test_e2e.py
@@ -384,7 +384,7 @@ def test_a_prebuilt_zip_goes_as_application_zip_when_the_endpoint_takes_it(refus
     RefusingServer.content_types.clear()
     bomb = hostile_inputs()[4]
     json_only = Endpoint("/p", "application/json")
-    assert judge_hostile(refusing_url, json_only, bomb, SCHEMAS)["status"] == "skipped"
+    assert judge_hostile(refusing_url, json_only, bomb, SCHEMAS)["status"] == "fail"
     zip_too = Endpoint("/p", "application/json", accepts_zip=True)
     assert judge_hostile(refusing_url, zip_too, bomb, SCHEMAS)["status"] == "pass"
     assert RefusingServer.content_types == ["application/zip"]
@@ -484,3 +484,68 @@ def test_a_200_that_is_not_a_json_object_is_a_failure_not_a_crash(monkeypatch):
         assert "not a JSON object" in record["contract_problems"][0]
         hostile = judge_hostile("http://unused", endpoint, hostile_inputs()[3], SCHEMAS)
         assert hostile["status"] == "fail" and "not a JSON object" in hostile["problems"][0]
+
+
+@pytest.mark.parametrize(
+    "extra",
+    [
+        {"status": "skipped", "skip_reason": "missing scene"},
+        {"status": "fail", "expectation_problems": ["wrong decision"], "contract_problems": []},
+    ],
+)
+def test_run_acceptance_is_separate_from_contract_invariants(tmp_path, extra):
+    report = e2e.write_report(tmp_path, META, [CHECKED, {"name": "other", **extra}])
+    assert not report["all_passed"]
+    assert report["contract_ok"]
+
+
+def test_unexercised_large_input_probe_fails_contract():
+    item = hostile_inputs()[-1]
+    item.bundle = b"archive"
+    record = judge_hostile("unused", Endpoint("/place", "application/json"), item, {})
+    assert record["status"] == "fail" and record["contract_problems"]
+
+
+def test_bundle_uses_exact_canonical_scene(tmp_path):
+    archive = tmp_path / "scene.zip"
+    with zipfile.ZipFile(archive, "w") as z:
+        z.writestr("old-scene.json", b"old")
+        z.writestr("scene.json", b"canonical")
+    assert e2e.read_bundle(archive)[0] == b"canonical"
+
+
+@pytest.mark.parametrize("names", [["old-scene.json"], ["scene.json", "scene.json"]])
+def test_bundle_rejects_missing_or_duplicate_canonical_scene(tmp_path, names):
+    archive = tmp_path / "scene.zip"
+    with zipfile.ZipFile(archive, "w") as z:
+        for name in names:
+            z.writestr(name, b"{}")
+    with pytest.raises(SystemExit, match=r"exactly one canonical scene\.json"):
+        e2e.read_bundle(archive)
+
+
+def test_transformed_answer_checks_its_own_hash(monkeypatch):
+    calls = []
+    original = {"decision": "pass", "stats": {}, "sweep": []}
+    monkeypatch.setattr(
+        e2e, "post", lambda *args, **kwargs: (200, json.dumps(original).encode(), 1)
+    )
+    monkeypatch.setattr(e2e, "answer", lambda *args: (original, None))
+    monkeypatch.setattr(e2e, "schema_errors", lambda *args: [])
+
+    def check_hash(scene, result, sent=None, rules=None):
+        calls.append((scene, sent))
+        return ["stale input hash"] if sent is not None else []
+
+    monkeypatch.setattr(e2e, "invariant_problems", check_hash)
+    monkeypatch.setattr(e2e, "with_ground_short_of", lambda *args: None)
+    monkeypatch.setattr(e2e, "with_more_error", lambda *args: None)
+    monkeypatch.setattr(e2e, "tape_to_tap", lambda *args: None)
+    monkeypatch.setattr(e2e, "with_less_coverage", lambda *args: None)
+    scene = {"walls": [{"id": "w1", "baseline": [[-1, 0], [1, 0]]}], "meter": {"pos": [0, 1, 0]}}
+    probe = SceneInput(name="test", scene=scene, raw=json.dumps(scene).encode(), source="test")
+    failures = e2e.property_problems(
+        "unused", Endpoint("/p", "application/json"), probe, original, {"result": {}}, RULES
+    )
+    assert calls and all(raw == json.dumps(scene, indent=1).encode() for scene, raw in calls)
+    assert any("stale input hash" in p for p in failures)
diff --git a/verification/tests/test_gitref.py b/verification/tests/test_gitref.py
index da2c1511a..3903936d3 100644
--- a/verification/tests/test_gitref.py
+++ b/verification/tests/test_gitref.py
@@ -12,3 +12,10 @@ def test_two_uses_of_one_sha_get_separate_trees_and_both_clean_up():
 def test_show_returns_none_for_a_missing_file():
     assert gitref.show("HEAD", "no/such/file") is None
     assert gitref.show("HEAD", "verification/pyproject.toml") is not None
+
+
+def test_fetch_prunes_deleted_refs(monkeypatch):
+    calls = []
+    monkeypatch.setattr(gitref, "git", lambda *args: calls.append(args))
+    gitref.fetch()
+    assert calls == [("fetch", "--quiet", "--prune", "origin")]
diff --git a/verification/tests/test_scoreboard.py b/verification/tests/test_scoreboard.py
index 21292cb27..a67c7111b 100644
--- a/verification/tests/test_scoreboard.py
+++ b/verification/tests/test_scoreboard.py
@@ -2,6 +2,7 @@
 import datetime as dt
 import json
 import os
+import subprocess
 import textwrap
 import time
 
@@ -675,3 +676,27 @@ def test_tail_keeps_last_three_lines_with_spaces_collapsed():
         sb._tail("a\n\n...   [ 82%]\nb\n  87 passed  in 1s \n")
         == "... [ 82%] / b / 87 passed in 1s"
     )
+
+
+def test_pr_inventory_exceeds_default_page(monkeypatch):
+    prs = [{"number": n} for n in range(1, 42)]
+
+    def fake_run(cmd, **kwargs):
+        assert int(cmd[cmd.index("--limit") + 1]) > 30
+        assert kwargs["timeout"] == sb.PR_LIST_TIMEOUT_S
+        return subprocess.CompletedProcess(cmd, 0, stdout=json.dumps(prs))
+
+    monkeypatch.setattr(sb.subprocess, "run", fake_run)
+    assert sb.list_prs() == prs
+
+
+def test_s2_contract_credit_requires_successful_full_run(tmp_path):
+    _, metrics = sb.load_metrics()
+    metric = next(m for m in metrics if m.id == "S2-8")
+    metric.probe["glob"] = str(tmp_path / "*" / "report.json")
+    write_report(
+        tmp_path / "r" / "report.json",
+        {"sha": SHA, "contract_ok": True, "all_passed": False},
+        100,
+    )
+    assert sb.probe_report(metric.probe, SHA).status == "gap"

From b5da197b97f42c0568d4b9424ab3780762837245 Mon Sep 17 00:00:00 2001
From: Sam Gu <127461594+SamGu-NRX@users.noreply.github.com>
Date: Tue, 13 Oct 2026 17:49:41 -0500
Subject: [PATCH 06/62] fix(recon): preserve evidence and refuse incomplete
 cached outputs

https://github.com/SamGu-NRX/BaseScanning/pull/20#discussion_r4114128928
https://github.com/SamGu-NRX/BaseScanning/pull/20#discussion_r4114128930
https://github.com/SamGu-NRX/BaseScanning/pull/20#discussion_r4114128938
https://github.com/SamGu-NRX/BaseScanning/pull/20#discussion_r4114194380
https://github.com/SamGu-NRX/BaseScanning/pull/20#discussion_r4114194382
https://github.com/SamGu-NRX/BaseScanning/pull/20#discussion_r4114194384
https://github.com/SamGu-NRX/BaseScanning/pull/20#discussion_r4114621091
https://github.com/SamGu-NRX/BaseScanning/pull/20#discussion_r4114621094
https://github.com/SamGu-NRX/BaseScanning/pull/20#discussion_r4114621095
https://github.com/SamGu-NRX/BaseScanning/pull/20#discussion_r4115044062
https://github.com/SamGu-NRX/BaseScanning/pull/20#discussion_r4115044074
https://github.com/SamGu-NRX/BaseScanning/pull/20#discussion_r4115044084
https://github.com/SamGu-NRX/BaseScanning/pull/20#discussion_r4115044089
https://github.com/SamGu-NRX/BaseScanning/pull/20#discussion_r4115044093
https://github.com/SamGu-NRX/BaseScanning/pull/20#discussion_r4115044096
https://github.com/SamGu-NRX/BaseScanning/pull/20#discussion_r4115044099
https://github.com/SamGu-NRX/BaseScanning/pull/20#discussion_r4115044101
https://github.com/SamGu-NRX/BaseScanning/pull/20#discussion_r4115917428
---
 recon/HANDOFF.md                |  12 +-
 recon/models/moge_depth.py      |  18 +-
 recon/recon/capture.py          |  98 ++++++++-
 recon/recon/coverage.py         |  45 +++--
 recon/recon/depth.py            |  49 ++++-
 recon/recon/pipeline.py         |  23 ++-
 recon/recon/scene.py            |  17 +-
 recon/tests/test_review_debt.py | 348 ++++++++++++++++++++++++++++++++
 recon/tests/test_worker.py      |   5 +-
 9 files changed, 570 insertions(+), 45 deletions(-)
 create mode 100644 recon/tests/test_review_debt.py

diff --git a/recon/HANDOFF.md b/recon/HANDOFF.md
index 16b84e388..b952169d2 100644
--- a/recon/HANDOFF.md
+++ b/recon/HANDOFF.md
@@ -126,17 +126,13 @@ In `recon/` on this branch:
 
 ## 6. Known defects
 
-Reviewers confirmed these in the worker at this branch's head, and none is fixed. Each can let the server settle a check on evidence the worker doesn't have. No replacement below has been built or validated.
+These defects remain after the review-debt repairs. They can let the server settle a check on evidence the worker does not have. The saved ETH3D results above predate those repairs; dataset acceptance has not been rerun.
 
-- **One view can count as two for free space.** `recon/coverage.py:183-187, 205-243`: `_slab` treats a voxel as observed when its fused weight is above zero, and any single frame gives it weight. Repro: a capture in which one frame alone sees the space in front of a wall cell reports a facing clearance there. Wall and ground cells need two positions 0.25 m apart for the same claim. The server at 903d86f can settle a check on that clearance. A fix needs visibility kept per frame for free space, with the same two-position test as the wall and ground.
-- **The overhead strip is narrower than a battery.** `recon/coverage.py:42, 231-242`: overhead space is sampled only 0.10 to 0.56 m out from the wall front. Repro: an eave 0.05 m out from the wall, or 0.7 m out over a 3 ft deep battery, is not found, and the cell reports clearance above it. A fix needs the footprint of the battery the chosen rule places, passed from the server's rules or request.
-- **Old facing and overhead entries survive a small meter move.** `recon/scene.py:50-57, 87-89`: when the meter moves 5 cm or less, the bundle's existing `facing` and `overheads` entries are kept and the new ones appended, although the reconstructed wall's line and orientation replaced the phone's. Repro: a bundle with a phone-measured facing gap, and a reconstructed wall rotated a few degrees about the meter, sends both the old gap and the new one. A fix needs the target wall's earlier entries dropped whenever its line is replaced, as they already are when the meter moves more than 5 cm.
+- **One view can count as two for free space.** `recon/coverage.py:189-193, 208-246`: `_slab` treats a voxel as observed when its fused weight is above zero, and any single frame gives it weight. Repro: a capture in which one frame alone sees the space in front of a wall cell reports a facing clearance there. Wall and ground cells need two positions 0.25 m apart for the same claim. The server at 903d86f can settle a check on that clearance. A fix needs visibility kept per frame for free space, with the same two-position test as the wall and ground.
+- **The overhead strip is narrower than a battery.** `recon/coverage.py:42, 236-245`: overhead space is sampled only 0.10 to 0.56 m out from the wall front. Repro: an eave 0.05 m out from the wall, or 0.7 m out over a 3 ft deep battery, is not found, and the cell reports clearance above it. A fix needs the footprint of the battery the chosen rule places, passed from the server's rules or request.
 - **The photos-only clearance error is not calibrated.** `recon/pipeline.py:29-35`: facing gaps and overhead clearances from photos carry ±0.56 ft. That comes from the 95% interval of the evals' surface pair-error p90 over 1 to 3 m spans, not from any measurement of where the fused volume puts a boundary. The evals put surface p90 at 5.64 in [4.63, 6.66] and edges at 9.65 in [4.93, 15.01]. Repro: a photos-only overhead clearance measured at 7.10 ft passes the 6.5 ft headroom rule, since 7.10 − 0.56 = 6.54 > 6.5. A fix needs the clearance estimator's own measured uncertainty, or a gate that returns the check unresolved until that exists.
 
-- **Partly occupied space counts as clear.** `recon/coverage.py:223, 235` (threshold at 179): a step out from the wall, or up over the footprint, counts as blocked only when at least 20% of its sampled voxels are occupied, on two steps in a row. That 20% has no source. Otherwise `free_space` reports the space clear through voxels the reconstruction marks occupied. Repro: at 5 cm voxels, a 5 cm rail crossing the facing band (0.3 to 1.8 m high) fills 1 of its 31 height rows, about 3%, and the facing clearance runs straight through it. An obstruction thinner than two steps passes the same way. A fix needs any occupied voxel in the band to end the clear distance or leave the check unresolved.
-- **LiDAR without a confidence map is fused unfiltered.** `recon/depth.py:90-92` (accepted at `recon/capture.py:182-189`): a keyframe whose `depth` names a `file` but no `confidenceFile` is accepted, and `lidar()` then keeps every positive sample, including ARKit's low-confidence ones that section 4 says to drop. Repro: a packet keyframe with `"depth": {"file": "k.f32", "w": 256, "h": 192}` has all its samples fused, with no confidence filter. A fix needs a missing confidence map either refused, or treated as that frame having no usable LiDAR.
-
-Two more are filed as issues for the server team: coverage samples ground on a flat plane at the meter's height rather than the fitted slope (#95), and coverage cells can reach past the fitted wall's ends (#96).
+The worker now replaces the target wall's prior measurements, stops clearance at any occupied sampled voxel, and refuses LiDAR without a confidence map. Ground coverage follows the fitted slope, and only whole cells within the fitted wall extent are exported. The regressions are in `tests/test_review_debt.py`; they do not validate the remaining clearance policies above.
 
 ## 7. Data
 
diff --git a/recon/models/moge_depth.py b/recon/models/moge_depth.py
index 0c049b79b..f26c881dd 100644
--- a/recon/models/moge_depth.py
+++ b/recon/models/moge_depth.py
@@ -16,6 +16,7 @@
 import math
 import os
 import sys
+import tempfile
 from pathlib import Path
 
 DATA = Path(os.environ.get("HOUSE_SCANNING_DATA", Path.home() / "house-scanning-data"))
@@ -28,6 +29,21 @@
 MPS_CAP_GB = 3.6
 
 
+def write_depth(target: Path, depth) -> None:
+    import numpy as np
+
+    temporary = None
+    try:
+        with tempfile.NamedTemporaryFile(dir=target.parent, suffix=".npz", delete=False) as f:
+            temporary = Path(f.name)
+            np.savez(f, depth=depth.astype(np.float32))
+        # A killed writer cannot leave a partially written archive at the reusable cache path.
+        os.replace(temporary, target)
+    finally:
+        if temporary is not None:
+            temporary.unlink(missing_ok=True)
+
+
 def main(manifest: Path) -> None:
     import cv2
     import numpy as np
@@ -58,7 +74,7 @@ def main(manifest: Path) -> None:
             out = model.infer(rgb, resolution_level=RESOLUTION_LEVEL, fov_x=fov_x, use_fp16=True)
         depth = out["depth"].float().cpu().numpy()
         depth[~out["mask"].cpu().numpy().astype(bool)] = np.nan
-        np.savez(item["out"], depth=depth.astype(np.float32))
+        write_depth(Path(item["out"]), depth)
         print(f"{Path(item['image']).name}: median {np.nanmedian(depth):.2f} m", file=sys.stderr)
         del out, rgb
         if device == "mps":
diff --git a/recon/recon/capture.py b/recon/recon/capture.py
index 3c573ff87..a585c1282 100644
--- a/recon/recon/capture.py
+++ b/recon/recon/capture.py
@@ -26,6 +26,9 @@
 import hashlib
 import json
 import re
+import shutil
+import struct
+import tempfile
 import zipfile
 from dataclasses import dataclass, field
 from pathlib import Path
@@ -94,6 +97,10 @@ def __post_init__(self) -> None:
 
 ROTATION_TOL = 1e-2  # scene.json rounds poses to 4 decimals; anything further off is not a pose
 
+# Existing bundle admission policy in verification/hsverify/e2e.py, not measured capture maxima.
+MAX_BUNDLE_ENTRIES = 2000
+MAX_BUNDLE_BYTES = 512 * 2**20
+
 
 def column_major(pose: list[float]) -> np.ndarray:
     """A 4x4 from 16 column-major numbers, its rotation snapped to the nearest proper rotation.
@@ -119,18 +126,101 @@ def unpack(path: Path, work: Path) -> Path:
     """A folder as is; a zip extracted once under `work`, keyed by its sha256."""
     if path.is_dir():
         return path
-    digest = hashlib.sha256(path.read_bytes()).hexdigest()[:16]
+    if path.stat().st_size > MAX_BUNDLE_BYTES:
+        raise ValueError(f"{path}: archive exceeds {MAX_BUNDLE_BYTES} bytes")
+    with path.open("rb") as f:
+        digest = hashlib.file_digest(f, "sha256").hexdigest()[:16]
     out = work / "bundles" / digest
     if not out.exists():
+        _zip_directory_limits(path)
         with zipfile.ZipFile(path) as z:
-            names = [n for n in z.namelist() if not n.startswith("__MACOSX/")]
-            for n in names:
+            infos = z.infolist()
+            if len(infos) > MAX_BUNDLE_ENTRIES:
+                raise ValueError(f"{path}: {len(infos)} entries, limit {MAX_BUNDLE_ENTRIES}")
+            if sum(i.file_size for i in infos) > MAX_BUNDLE_BYTES:
+                raise ValueError(f"{path}: expanded archive exceeds {MAX_BUNDLE_BYTES} bytes")
+            members = [i for i in infos if not i.filename.startswith("__MACOSX/")]
+            for info in members:
+                n = info.filename
                 if n.startswith("/") or ".." in Path(n).parts:
                     raise ValueError(f"{path}: unsafe entry {n!r}")
-            z.extractall(out, members=names)
+            out.parent.mkdir(parents=True, exist_ok=True)
+            # Extraction stays private until every CRC-checked member finishes. Failed extraction
+            # cannot leave a partial cache directory that a later run mistakes for a complete one.
+            stage = Path(tempfile.mkdtemp(dir=out.parent, prefix=f".{digest}-"))
+            try:
+                written = 0
+                for info in members:
+                    dest = stage / info.filename
+                    if info.is_dir():
+                        dest.mkdir(parents=True, exist_ok=True)
+                        continue
+                    dest.parent.mkdir(parents=True, exist_ok=True)
+                    with z.open(info) as src, dest.open("wb") as dst:
+                        while chunk := src.read(2**20):
+                            written += len(chunk)
+                            if written > MAX_BUNDLE_BYTES:
+                                raise ValueError(f"{path}: expanded archive exceeds byte limit")
+                            dst.write(chunk)
+                try:
+                    stage.rename(out)
+                except OSError:
+                    # Another run of this exact content may have finished first.
+                    if not out.is_dir():
+                        raise
+            finally:
+                if stage.exists():
+                    shutil.rmtree(stage)
     return out
 
 
+def _zip_directory_limits(path: Path) -> None:
+    """Check central-directory records in bounded reads before ZipFile allocates their metadata.
+    ZIP64 and split archives exceed this worker's ordinary ZIP admission format and are refused.
+    The record layouts are PKWARE APPNOTE sections 4.3.12 and 4.3.16."""
+    with path.open("rb") as f:
+        size = path.stat().st_size
+        f.seek(max(0, size - 22 - 65535))
+        tail = f.read(22 + 65535)
+        end = len(tail)
+        while True:
+            pos = tail.rfind(b"PK\x05\x06", 0, end)
+            if pos < 0:
+                raise ValueError(f"{path}: missing ZIP end record")
+            if pos + 22 <= len(tail):
+                record = struct.unpack("<4s4H2IH", tail[pos : pos + 22])
+                if pos + 22 + record[-1] == len(tail):
+                    break
+            end = pos
+        _, disk, central_disk, disk_entries, total_entries, length, offset, _ = record
+        if disk or central_disk or disk_entries != total_entries:
+            raise ValueError(f"{path}: split ZIP archives are not supported")
+        if total_entries > MAX_BUNDLE_ENTRIES:
+            raise ValueError(f"{path}: {total_entries} entries, limit {MAX_BUNDLE_ENTRIES}")
+        directory_end = offset + length
+        end_offset = size - len(tail) + pos
+        if length == 0xFFFFFFFF or offset == 0xFFFFFFFF or directory_end != end_offset:
+            raise ValueError(f"{path}: ZIP64 or inconsistent ZIP directory")
+        f.seek(offset)
+        count, expanded = 0, 0
+        while f.tell() < directory_end:
+            header = f.read(46)
+            if len(header) != 46 or header[:4] != b"PK\x01\x02":
+                raise ValueError(f"{path}: invalid ZIP central-directory record")
+            fields = struct.unpack("<4s6H3I5H2I", header)
+            count += 1
+            expanded += fields[9]
+            if count > MAX_BUNDLE_ENTRIES:
+                raise ValueError(f"{path}: {count} entries, limit {MAX_BUNDLE_ENTRIES}")
+            if expanded > MAX_BUNDLE_BYTES:
+                raise ValueError(f"{path}: expanded archive exceeds {MAX_BUNDLE_BYTES} bytes")
+            f.seek(sum(fields[10:13]), 1)
+            if f.tell() > directory_end:
+                raise ValueError(f"{path}: ZIP central-directory record exceeds directory")
+        if count != total_entries:
+            raise ValueError(f"{path}: inconsistent ZIP entry count")
+
+
 def _find(root: Path, name: str) -> Path | None:
     hits = [p for p in root.rglob(name) if "__MACOSX" not in p.parts]
     if len(hits) > 1:
diff --git a/recon/recon/coverage.py b/recon/recon/coverage.py
index a04d50d01..a0a1eaa59 100644
--- a/recon/recon/coverage.py
+++ b/recon/recon/coverage.py
@@ -31,7 +31,7 @@
 from recon.capture import FEET, UP, Frame
 from recon.depth import Depth
 from recon.fusion import MAX_RANGE_M, Mesh, Volume
-from recon.geometry import WallFrame
+from recon.geometry import Ground, WallFrame
 
 CELL_M = 0.1524  # half a foot, the app's cell
 WALL_TOP_M = 1.9812  # 6.5 ft, the headroom the export's wall band claims
@@ -110,6 +110,8 @@ def face_offsets(wall: WallFrame, mesh: Mesh, cells: np.ndarray) -> np.ndarray:
     """Per cell, how far a flat, full-height face stands in front of the fitted plane (0 if none).
     Flat: in at least 75% of the 10 cm height bins from 0.3 to 1.9 m, the front-most surface within
     0.6 m lies within 3 cm of their median. A bush or bin is neither, so it stays an occluder."""
+    if not len(cells):
+        return np.zeros(0)
     loc = wall.local(mesh.vertices.astype(np.float64))
     s, h, out = loc[:, 0], loc[:, 1], loc[:, 2]
     keep = (out > -0.15) & (out < 0.6) & (h > 0.3) & (h < 1.9)
@@ -146,6 +148,7 @@ def wall_and_ground(
     vol: Volume,
     mesh: Mesh,
     cells: np.ndarray,
+    ground: Ground | None = None,
 ) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
     centres = np.array([f.center for f in frames])
     faces = face_offsets(wall, mesh, cells)
@@ -164,7 +167,10 @@ def wall_and_ground(
     S = np.broadcast_to(alongs[:, :, None], (len(cells), 2, len(outs)))
     Oo = np.maximum(np.broadcast_to(outs[None, None, :], S.shape), faces[:, None, None] + 0.05)
     gpts = wall.world(S, np.zeros_like(S), Oo).reshape(-1, 3)
-    gseen = two_positions(seen_by(gpts, UP, frames, depths, vol), centres).reshape(
+    if ground is not None:
+        gpts[:, 1] = ground.height_at(gpts[:, 0], gpts[:, 2])
+    gnormal = UP if ground is None else ground.normal
+    gseen = two_positions(seen_by(gpts, gnormal, frames, depths, vol), centres).reshape(
         len(cells), 2, len(outs)
     )
     row_ok = gseen.all(axis=1)  # (C, outs)
@@ -207,7 +213,8 @@ def free_space(wall: WallFrame, vol: Volume, cells: np.ndarray):
     The facing gap and clear distance are measured out from the wall's reconstructed front, not
     from the fitted plane: in front of a pilaster 0.3 m proud, something 1.3 m out of the plane
     is 1.0 m from the face the battery would stand against. The front is the first free step
-    past the wall's occupied voxels, so both read up to a voxel short, never long. Overhead
+    past the wall's occupied voxels. The gap also backs off one voxel from the first occupied
+    sample, so voxel sampling does not extend it into the obstacle. Overhead
     clearance is a height above the ground over the footprint in front of that face."""
     step = vol.voxel
     n = len(cells)
@@ -217,38 +224,40 @@ def free_space(wall: WallFrame, vol: Volume, cells: np.ndarray):
     for c in range(n):
         across = cells[c] + CELL_M * np.array([0.25, 0.5, 0.75])
         front = wall_front(wall, vol, across)
-        hits = 0
         for out in np.arange(front + step, front + FACING_MAX_M, step):
             share, seen = _slab(wall, vol, across, fh, [out])
-            hits = hits + 1 if share >= OCCUPIED_SHARE else 0
-            if hits == 2:
-                facing_gap[c] = out - step - front
+            # Any reconstructed occupied voxel stops clearance, including one-step thin rails.
+            if share > 0:
+                facing_gap[c] = max(0.0, out - step - front)
                 break
             if not seen:
                 break
-            if hits == 0:
-                facing_clear[c] = out - front
+            facing_clear[c] = out - front
         oo = front + np.arange(OVERHEAD_OUT_M[0], OVERHEAD_OUT_M[1] + 1e-9, step)
-        hits = 0
         for h in np.arange(0.3, OVERHEAD_MAX_M, step):
             share, seen = _slab(wall, vol, across, [h], oo)
-            hits = hits + 1 if share >= OCCUPIED_SHARE else 0
-            if hits == 2:
-                over_gap[c] = h - step
+            if share > 0:
+                over_gap[c] = max(0.0, h - step)
                 break
             if not seen:
                 break
-            if hits == 0:
-                over_clear[c] = h
+            over_clear[c] = h
     return facing_gap, facing_clear, over_gap, over_clear
 
 
 def compute(
-    wall: WallFrame, frames: list[Frame], depths: dict[str, Depth], vol: Volume, mesh: Mesh
+    wall: WallFrame,
+    frames: list[Frame],
+    depths: dict[str, Depth],
+    vol: Volume,
+    mesh: Mesh,
+    ground: Ground | None = None,
 ) -> CellCoverage:
     lo, hi = wall.s_range
-    cells = np.arange(np.floor(lo / CELL_M) * CELL_M, hi - 1e-9, CELL_M)
-    wall_ok, ground_out, _ = wall_and_ground(wall, frames, depths, vol, mesh, cells)
+    # Only complete cells inside the fitted extent can support the full exported half-foot span.
+    start = np.ceil(lo / CELL_M - 1e-9) * CELL_M
+    cells = np.arange(start, hi - CELL_M + 1e-9, CELL_M)
+    wall_ok, ground_out, _ = wall_and_ground(wall, frames, depths, vol, mesh, cells, ground)
     fg, fc, og, oc = free_space(wall, vol, cells)
     return CellCoverage(cells, wall_ok, ground_out, fg, fc, og, oc)
 
diff --git a/recon/recon/depth.py b/recon/recon/depth.py
index 14889b09e..82a87419a 100644
--- a/recon/recon/depth.py
+++ b/recon/recon/depth.py
@@ -16,11 +16,14 @@
 
 from __future__ import annotations
 
+import fcntl
 import hashlib
 import json
 import os
 import subprocess
 import sys
+import zipfile
+import zlib
 from dataclasses import dataclass
 from pathlib import Path
 
@@ -83,20 +86,22 @@ def rotated_intrinsics(k: np.ndarray, w: float, h: float, turns: int) -> np.ndar
 
 def lidar(frame: Frame) -> Depth:
     d = frame.lidar
+    if d.confidence is None:
+        raise ValueError(f"{d.file}: LiDAR depth requires its confidence map")
     depth = np.fromfile(d.file, dtype="<f4")
     if depth.size != d.width * d.height:
         raise ValueError(f"{d.file}: {depth.size} values, expected {d.width} x {d.height}")
     depth = depth.reshape(d.height, d.width).copy()
-    if d.confidence is not None:
-        conf = np.fromfile(d.confidence, dtype=np.uint8).reshape(d.height, d.width)
-        depth[conf < MIN_CONFIDENCE] = np.nan
+    conf = np.fromfile(d.confidence, dtype=np.uint8).reshape(d.height, d.width)
+    depth[conf < MIN_CONFIDENCE] = np.nan
     depth[~(depth > 0)] = np.nan
     color = cv2.resize(_image(frame), (d.width, d.height), interpolation=cv2.INTER_AREA)
     return Depth(depth, scaled(frame.intrinsics, d.width / frame.width), color, "lidar")
 
 
 def _image(frame: Frame) -> np.ndarray:
-    img = cv2.imread(str(frame.image), cv2.IMREAD_COLOR)
+    # Poses, intrinsics and LiDAR describe sensor pixels, regardless of JPEG EXIF orientation.
+    img = cv2.imread(str(frame.image), cv2.IMREAD_COLOR | cv2.IMREAD_IGNORE_ORIENTATION)
     if img is None:
         raise FileNotFoundError(frame.image)
     if img.shape[:2] != (frame.height, frame.width):
@@ -169,6 +174,23 @@ def cache_file(work: Path, fid: str, suffix: str) -> Path:
 def moge(capture: Capture, work: Path) -> dict[str, Depth]:
     """MoGe-2 depth per frame at up to MAX_SIDE px, in the frame's own (unrotated) orientation,
     cached under `work` by the capture's content (`moge_cache`)."""
+    work.mkdir(parents=True, exist_ok=True)
+    # The lock covers key repair, inputs, inference and reads, so concurrent runs cannot read a
+    # partially written archive or launch duplicate inference for the same cache root.
+    with (work / ".moge.lock").open("a") as lock:
+        fcntl.flock(lock, fcntl.LOCK_EX)
+        return _moge_locked(capture, work)
+
+
+def _cached_depth(path: Path, shape: tuple[int, int]) -> np.ndarray:
+    with np.load(path, allow_pickle=False) as archive:
+        d = archive["depth"]
+        if d.shape != shape or d.dtype.kind != "f":
+            raise ValueError(f"{path}: expected floating depth with shape {shape}, got {d.shape}")
+        return d.astype(np.float32)
+
+
+def _moge_locked(capture: Capture, work: Path) -> dict[str, Depth]:
     work = moge_cache(capture, work)
     manifest, meta = [], {}
     for f in capture.frames:
@@ -184,7 +206,22 @@ def moge(capture: Capture, work: Path) -> dict[str, Depth]:
         k_up = rotated_intrinsics(k_small, small.shape[1], small.shape[0], turns)
         out = cache_file(work, f.id, ".moge2.npz")
         meta[f.id] = (out, turns, k_small, small)
-        if not out.exists():
+        valid = False
+        if out.exists():
+            try:
+                _cached_depth(out, np.rot90(small, turns).shape[:2])
+                valid = True
+            except (
+                ValueError,
+                OSError,
+                KeyError,
+                EOFError,
+                TypeError,
+                zipfile.BadZipFile,
+                zlib.error,
+            ):
+                out.unlink()
+        if not valid:
             manifest.append({"image": str(up_path), "fx": float(k_up[0]), "out": str(out)})
     if manifest:
         (work / "moge2.json").write_text(json.dumps(manifest, indent=1))
@@ -203,7 +240,7 @@ def moge(capture: Capture, work: Path) -> dict[str, Depth]:
         )
     depths = {}
     for fid, (out, turns, k_small, small) in meta.items():
-        d = np.rot90(np.load(out)["depth"], -turns).astype(np.float32)
+        d = np.rot90(_cached_depth(out, np.rot90(small, turns).shape[:2]), -turns)
         if d.shape != small.shape[:2]:
             raise ValueError(f"{out}: depth {d.shape} does not match the image {small.shape[:2]}")
         depths[fid] = Depth(np.ascontiguousarray(d), k_small, small, "moge2")
diff --git a/recon/recon/pipeline.py b/recon/recon/pipeline.py
index 15794a1cc..2c0b5ded1 100644
--- a/recon/recon/pipeline.py
+++ b/recon/recon/pipeline.py
@@ -57,7 +57,7 @@ def reconstruct(
     # Only frames with a depth map can see anything (depth.depth_maps: LiDAR frames saved
     # without depth get none).
     seeing = [f for f in capture.frames if f.id in depths]
-    cov = coverage.compute(wall, seeing, depths, vol, surface)
+    cov = coverage.compute(wall, seeing, depths, vol, surface, ground)
     _log(f"coverage over {len(cov.cells)} cells ({time.perf_counter() - t0:.0f} s)")
     return {
         "depths": depths,
@@ -124,7 +124,28 @@ def write_model(r: dict, path: Path) -> None:
 def run(
     bundle: Path, out: Path, work: Path, depth_mode: str, server_url: str | None, move_meter: bool
 ) -> dict:
+    owned = (
+        "model.glb",
+        "geometry.json",
+        "scene.json",
+        "coverage.json",
+        "report.md",
+        "result.json",
+        "site-plan.svg",
+    )
+    bundle_path, out_path = bundle.resolve(), out.resolve()
+    if bundle.is_dir():
+        overlap = bundle_path.is_relative_to(out_path) or out_path.is_relative_to(bundle_path)
+    else:
+        overlap = bundle_path in {(out_path / name).resolve() for name in owned}
+    if overlap:
+        raise ValueError(
+            f"output {out} overlaps capture input {bundle}; use a separate output folder"
+        )
     out.mkdir(parents=True, exist_ok=True)
+    # A failed or --no-server rerun must not leave an earlier run's answer beside new outputs.
+    for name in owned:
+        (out / name).unlink(missing_ok=True)
     capture = cap.load(bundle, work)
     _log(f"{capture.source}: {len(capture.frames)} frames from {bundle}")
     t0 = time.perf_counter()
diff --git a/recon/recon/scene.py b/recon/recon/scene.py
index 6f0ce4bcc..c0ee6db48 100644
--- a/recon/recon/scene.py
+++ b/recon/recon/scene.py
@@ -4,8 +4,8 @@
 
 A scan bundle's scene is updated: the meter's wall takes the fitted line (over the union of its
 fitted extent and the phone's baseline), `coverage.observed` is replaced by the occlusion-aware
-coverage, and the measured facing gaps and overhead clearances are added to whatever the phone
-marked. A Measure Lab session gets a new scene with the same parts.
+coverage, and the target wall's measured facing gaps and overhead clearances are replaced.
+A Measure Lab session gets a new scene with the same parts.
 
 The fitted wall takes the source of the depth that built it (`pipeline.WALL_SOURCE`: "mesh" from
 LiDAR, "plane" from photos alone) and no `plus_minus_ft`; a bundle's tapped bound is removed. The
@@ -83,10 +83,17 @@ def build(
     target["baseline"] = [_plan_ft(wall.world(s, 0.0)) for s in (lo, hi)]
     target["source"] = wall_source
     target.pop("plus_minus_ft", None)
-    doc.setdefault("coverage", {})["observed"] = observed(cov)[:500]
+    entries = observed(cov)
+    # scene.schema.json caps observed entries at 500; a partial export hides valid observations.
+    if len(entries) > 500:
+        raise ValueError(
+            f"coverage.observed has {len(entries)} entries; scene contract limit is 500"
+        )
+    doc.setdefault("coverage", {})["observed"] = entries
     facing, overheads = measurements(cov, wid, plus_minus_ft)
-    doc["facing"] = [*doc.get("facing", []), *facing]
-    doc["overheads"] = [*doc.get("overheads", []), *overheads]
+    # Replacing the wall invalidates its old spans even when the meter stays in place.
+    doc["facing"] = [*[m for m in doc.get("facing", []) if m["wall_id"] != wid], *facing]
+    doc["overheads"] = [*[m for m in doc.get("overheads", []) if m["wall_id"] != wid], *overheads]
     return doc
 
 
diff --git a/recon/tests/test_review_debt.py b/recon/tests/test_review_debt.py
new file mode 100644
index 000000000..65b6ac0a9
--- /dev/null
+++ b/recon/tests/test_review_debt.py
@@ -0,0 +1,348 @@
+"""Regressions for review findings that survived the reconstruction handoff."""
+
+import fcntl
+import importlib.util
+import io
+import json
+import struct
+import zipfile
+from dataclasses import replace
+from pathlib import Path
+
+import cv2
+import numpy as np
+import pytest
+from test_worker import (
+    NO_COVERAGE,
+    WALL,
+    _all_visible_setup,
+    _capture_named_scan,
+    _fake_moge,
+    _lidar_frames,
+    _slab_volume,
+)
+
+from recon import capture as cap
+from recon import coverage, depth, geometry, pipeline, scene
+from recon.coverage import CELL_M
+
+
+def test_replacing_wall_drops_its_old_measurements_and_keeps_other_walls():
+    old_facing = {"wall_id": "w", "span_ft": [-1, 1], "depth_ft": 20}
+    old_overhead = {"wall_id": "w", "span_ft": [-1, 1], "clearance_ft": 10}
+    other = {"wall_id": "v", "span_ft": [1, 2], "depth_ft": 3}
+    prior = {
+        "meter": {"wall_id": "w", "pos": [0, 5, 0]},
+        "walls": [{"id": "w", "baseline": [[-1, 0], [1, 0]]}],
+        "facing": [old_facing, other],
+        "overheads": [old_overhead],
+    }
+    capture = cap.Capture("scan-bundle", Path("b"), [], 0.0, WALL.meter, None, prior)
+    rotated = replace(WALL, along=np.array([np.cos(0.1), 0, np.sin(0.1)]))
+    doc = scene.build(capture, rotated, NO_COVERAGE, "mesh", 0.5)
+    assert doc["facing"] == [other] and doc["overheads"] == []
+    assert prior["facing"] == [old_facing, other]
+
+
+@pytest.mark.parametrize("n", [500, 501])
+def test_export_observations_refuses_contract_overflow_without_slicing(monkeypatch, n):
+    entries = [{"band": "wall", "span_ft": [i, i + 0.5]} for i in range(n)]
+    monkeypatch.setattr(scene, "observed", lambda _: entries)
+    capture = cap.Capture("measure-lab", Path("b"), [], 0.0, None, None)
+    if n == 501:
+        with pytest.raises(ValueError, match=r"501 entries.*limit is 500"):
+            scene.build(capture, WALL, NO_COVERAGE, "mesh", 0.5)
+    else:
+        assert (
+            scene.build(capture, WALL, NO_COVERAGE, "mesh", 0.5)["coverage"]["observed"] == entries
+        )
+
+
+def test_coverage_exports_only_cells_inside_fitted_extent(monkeypatch):
+    wall, frames, depths, vol, surface, _ = _all_visible_setup()
+    monkeypatch.setattr(coverage, "seen_by", lambda points, *_: np.ones((len(points), 2), bool))
+    monkeypatch.setattr(
+        coverage, "free_space", lambda wall, vol, cells: (np.zeros(len(cells)),) * 4
+    )
+    wall = replace(wall, s_range=(0.9 * CELL_M, 2.1 * CELL_M))
+    cov = coverage.compute(wall, frames, depths, vol, surface)
+    np.testing.assert_allclose(cov.cells, [CELL_M])
+    entries = coverage.observed(cov)
+    assert all(0.5 <= e["span_ft"][0] < e["span_ft"][1] <= 1.0 for e in entries)
+    cov = coverage.compute(replace(wall, s_range=(0.01, 0.02)), frames, depths, vol, surface)
+    assert cov.cells.size == 0 and coverage.observed(cov) == []
+
+
+def test_ground_coverage_uses_local_slope_height_and_normal(monkeypatch):
+    setup = _all_visible_setup()
+    ground = geometry.Ground(np.zeros(3), np.array([0.0, 1, -0.2]), 0.0, 10)
+    sampled = []
+
+    def see(points, normal, *_):
+        if normal is ground.normal:
+            sampled.append(points.copy())
+            seen = np.abs(points[:, 1] - 0.2 * points[:, 2]) < 1e-9
+        else:
+            seen = np.ones(len(points), bool)
+        return np.repeat(seen[:, None], 2, axis=1)
+
+    monkeypatch.setattr(coverage, "seen_by", see)
+    _, reach, _ = coverage.wall_and_ground(*setup, ground)
+    assert sampled and np.all(sampled[0][:, 1] > 0)
+    np.testing.assert_allclose(reach, coverage.GROUND_MAX_M)
+
+
+def test_depth_test_sees_sloped_ground_and_rejects_horizontal_datum():
+    # Two cameras look vertically down at y = 0.2*z. Pixel-ray intersections supply metric depth.
+    from test_worker import DOWN, GROUND_FRAMES, H, K, W
+
+    frames = GROUND_FRAMES
+    v, _u = np.mgrid[:H, :W]
+    dz_per_depth = (v + 0.5 - K[3]) / K[1]
+    d = 1.5 / (1 + 0.2 * dz_per_depth)
+    depths = {
+        f.id: depth.Depth(d.astype(np.float32), K, np.zeros((H, W, 3), np.uint8), "lidar")
+        for f in frames
+    }
+    assert np.array_equal(frames[0].cam_to_world[:3, :3], DOWN)
+
+    class EmptyRays:
+        voxel = 0.05
+
+        def blocked(self, start, ends, stop_short):
+            return np.zeros(len(ends), bool)
+
+    points = np.array([[0.0, 0.12, 0.6], [0.0, -0.12, -0.6]])
+    normal = np.array([0.0, 1, -0.2]) / np.sqrt(1.04)
+    assert coverage.seen_by(points, normal, frames, depths, EmptyRays()).all()
+    horizontal = points.copy()
+    horizontal[:, 1] = 0.0
+    assert not coverage.seen_by(horizontal, normal, frames, depths, EmptyRays()).any()
+
+
+def test_reconstruction_passes_fitted_ground_to_coverage(monkeypatch):
+    wall, frames, depths, _, surface, _ = _all_visible_setup()
+    capture = cap.Capture("measure-lab", Path("b"), frames, 0.0, wall.meter, None)
+    ground = geometry.Ground(np.zeros(3), np.array([0.0, 1, -0.2]), 0.0, 10)
+    volume = _slab_volume([], 7)
+    monkeypatch.setattr(pipeline.fusion, "integrate", lambda *_: volume)
+    monkeypatch.setattr(pipeline.fusion, "mesh", lambda _: surface)
+    monkeypatch.setattr(pipeline.geometry, "fit_ground", lambda *_: ground)
+    monkeypatch.setattr(pipeline.geometry, "wall_lines", lambda *_: ["line"])
+    monkeypatch.setattr(pipeline.geometry, "choose_wall", lambda *_: "line")
+    monkeypatch.setattr(pipeline.geometry, "wall_frame", lambda *_: wall)
+
+    def compute(*args):
+        assert args[-1] is ground
+        return NO_COVERAGE
+
+    monkeypatch.setattr(pipeline.coverage, "compute", compute)
+    assert pipeline.reconstruct(capture, depths, {"source": "lidar"})["coverage"] is NO_COVERAGE
+
+
+@pytest.mark.parametrize("band", ["facing", "overhead"])
+def test_one_voxel_obstruction_ends_clearance(band):
+    wall, *_ = _all_visible_setup()
+    vol = _slab_volume([(-0.3, 0.0)], 7.0)
+    if band == "facing":
+        # One 5 cm row at y=1 m, one step at z=1 m: under 20% of the facing slab.
+        vol.tsdf[:, 20, 30] = -1
+    else:
+        # One outward voxel at z=0.3 m, one height step at y=1.5 m.
+        vol.tsdf[:, 30, 16] = -1
+    fg, fc, og, oc = coverage.free_space(wall, vol, np.array([0.0]))
+    if band == "facing":
+        assert np.isfinite(fg[0]) and 0.8 < fg[0] < 1.0 and fc[0] < 1.0
+    else:
+        assert np.isfinite(og[0]) and 1.3 < og[0] < 1.5 and oc[0] < 1.5
+
+
+def test_lidar_without_confidence_is_refused_before_depth_read(tmp_path):
+    frames = _lidar_frames(tmp_path, {"a": True})
+    f = replace(frames[0], lidar=replace(frames[0].lidar, confidence=None))
+    f.lidar.file.unlink()
+    with pytest.raises(ValueError, match="requires its confidence map"):
+        depth.lidar(f)
+
+
+@pytest.mark.parametrize("orientation", [3, 6])
+def test_keyframe_jpeg_exif_does_not_rotate_sensor_pixels(tmp_path, orientation):
+    image = np.zeros((16, 24, 3), np.uint8)
+    image[:8, :12] = 255
+    ok, jpeg = cv2.imencode(".jpg", image)
+    assert ok
+    tiff = struct.pack("<2sHIH", b"II", 42, 8, 1)
+    tiff += struct.pack("<HHIHHI", 274, 3, 1, orientation, 0, 0)
+    exif = b"Exif\0\0" + tiff
+    raw = jpeg.tobytes()
+    tagged = raw[:2] + b"\xff\xe1" + struct.pack(">H", len(exif) + 2) + exif + raw[2:]
+    path = tmp_path / "k.jpg"
+    path.write_bytes(tagged)
+    frame = cap.Frame("k", path, 24, 16, np.array([24.0, 24, 12, 8]), np.eye(4))
+    sensor = cv2.imdecode(jpeg, cv2.IMREAD_COLOR)
+    np.testing.assert_array_equal(depth._image(frame), sensor)
+    default = cv2.imread(str(path), cv2.IMREAD_COLOR)
+    assert default.shape != sensor.shape or not np.array_equal(default, sensor)
+
+
+def corrupt_compressed_npz() -> bytes:
+    archive = io.BytesIO()
+    np.savez_compressed(archive, depth=np.ones((2, 2), np.float32))
+    raw = bytearray(archive.getvalue())
+    name_bytes, extra_bytes = struct.unpack_from("<HH", raw, 26)
+    # The reserved deflate block type fails during decompression rather than a ZIP CRC check.
+    raw[30 + name_bytes + extra_bytes] = 7
+    return bytes(raw)
+
+
+@pytest.mark.parametrize("bad", [b"PK\x03\x04truncated", b"not an npz", corrupt_compressed_npz()])
+def test_corrupt_moge_cache_is_recomputed(tmp_path, monkeypatch, bad):
+    capture = _capture_named_scan(tmp_path, 10)
+    work = tmp_path / "work"
+    cache = depth.moge_cache(capture, work)
+    (cache / "k.moge2.npz").write_bytes(bad)
+    calls = []
+    monkeypatch.setattr(depth.subprocess, "run", _fake_moge(calls))
+    assert np.allclose(depth.moge(capture, work)["k"].depth, 10)
+    assert calls == [1]
+
+
+def test_moge_holds_exclusive_cache_lock_through_inference(tmp_path, monkeypatch):
+    capture = _capture_named_scan(tmp_path, 10)
+    work = tmp_path / "work"
+    fake = _fake_moge([])
+
+    def run(*args, **kwargs):
+        with (work / ".moge.lock").open("a") as contender, pytest.raises(BlockingIOError):
+            fcntl.flock(contender, fcntl.LOCK_EX | fcntl.LOCK_NB)
+        return fake(*args, **kwargs)
+
+    monkeypatch.setattr(depth.subprocess, "run", run)
+    depth.moge(capture, work)
+    with (work / ".moge.lock").open("a") as contender:
+        fcntl.flock(contender, fcntl.LOCK_EX | fcntl.LOCK_NB)
+
+
+def test_failed_rerun_clears_all_old_generated_outputs(tmp_path, monkeypatch):
+    names = [
+        "model.glb",
+        "geometry.json",
+        "scene.json",
+        "coverage.json",
+        "report.md",
+        "result.json",
+        "site-plan.svg",
+    ]
+    for name in names:
+        (tmp_path / name).write_bytes(b"old output")
+    (tmp_path / "keep.txt").write_text("user file")
+
+    def refuse(*_):
+        raise ValueError("invalid capture")
+
+    monkeypatch.setattr(pipeline.cap, "load", refuse)
+    with pytest.raises(ValueError, match="invalid capture"):
+        pipeline.run(Path("bad"), tmp_path, tmp_path / "work", "auto", None, False)
+    assert not any((tmp_path / name).exists() for name in names)
+    assert (tmp_path / "keep.txt").read_text() == "user file"
+
+
+@pytest.mark.parametrize("kind", ["folder", "file"])
+def test_output_cleanup_refuses_input_overlap_before_deleting(tmp_path, kind):
+    name = "scene.json" if kind == "folder" else "model.glb"
+    source = tmp_path / name
+    source.write_bytes(b"capture input")
+    bundle = tmp_path if kind == "folder" else source
+    with pytest.raises(ValueError, match="overlaps capture input"):
+        pipeline.run(bundle, tmp_path, tmp_path / "work", "auto", None, False)
+    assert source.read_bytes() == b"capture input"
+
+
+def test_atomic_model_depth_write_keeps_old_cache_on_failed_write(tmp_path, monkeypatch):
+    spec = importlib.util.spec_from_file_location("moge_depth", depth.MOGE_SCRIPT)
+    module = importlib.util.module_from_spec(spec)
+    monkeypatch.setenv("HF_HOME", str(tmp_path))
+    monkeypatch.setenv("TORCH_HOME", str(tmp_path))
+    spec.loader.exec_module(module)
+    target = tmp_path / "k.moge2.npz"
+    np.savez(target, depth=np.ones((2, 2), np.float32))
+    original = target.read_bytes()
+    save = np.savez
+
+    def interrupted(file, **_):
+        file.write(b"partial archive")
+        raise OSError("interrupted write")
+
+    monkeypatch.setattr(np, "savez", interrupted)
+    with pytest.raises(OSError, match="interrupted write"):
+        module.write_depth(target, np.full((2, 2), 2.0))
+    assert target.read_bytes() == original and list(tmp_path.iterdir()) == [target]
+    monkeypatch.setattr(np, "savez", save)
+    module.write_depth(target, np.full((2, 2), 2.0))
+    with np.load(target) as archive:
+        np.testing.assert_array_equal(archive["depth"], np.full((2, 2), 2.0))
+
+
+@pytest.mark.parametrize("kind", ["file", "expanded", "entries"])
+def test_zip_resource_limits_refuse_before_extraction(tmp_path, monkeypatch, kind):
+    path = tmp_path / "bundle.zip"
+    if kind == "file":
+        path.write_bytes(b"x" * 401)
+        monkeypatch.setattr(cap, "MAX_BUNDLE_BYTES", 400)
+    else:
+        with zipfile.ZipFile(path, "w", zipfile.ZIP_DEFLATED) as z:
+            for i in range(3 if kind == "entries" else 1):
+                z.writestr(str(i), b"x" * 1000)
+        if kind == "entries":
+            monkeypatch.setattr(cap, "MAX_BUNDLE_ENTRIES", 2)
+        else:
+            assert path.stat().st_size < 400
+            monkeypatch.setattr(cap, "MAX_BUNDLE_BYTES", 400)
+    with pytest.raises(ValueError, match=r"exceeds|entries, limit"):
+        cap.unpack(path, tmp_path / "work")
+    assert not (tmp_path / "work").exists()
+
+
+def test_zip_digest_streams_and_completed_bundle_is_reused(tmp_path, monkeypatch):
+    path = tmp_path / "bundle.zip"
+    with zipfile.ZipFile(path, "w") as z:
+        z.writestr("scan/scene.json", json.dumps({"schema_version": "1.0"}))
+    monkeypatch.setattr(Path, "read_bytes", lambda _: pytest.fail("whole ZIP read into memory"))
+    out = cap.unpack(path, tmp_path / "work")
+    assert json.loads((out / "scan/scene.json").read_text()) == {"schema_version": "1.0"}
+    assert cap.unpack(path, tmp_path / "work") == out
+
+
+def test_zip_entry_count_is_checked_before_metadata_allocation(tmp_path, monkeypatch):
+    path = tmp_path / "bundle.zip"
+    with zipfile.ZipFile(path, "w") as z:
+        for i in range(3):
+            z.writestr(str(i), b"x")
+    # A false EOCD count must not bypass the streamed central-record count.
+    data = bytearray(path.read_bytes())
+    pos = data.rfind(b"PK\x05\x06")
+    struct.pack_into("<HH", data, pos + 8, 1, 1)
+    path.write_bytes(data)
+    monkeypatch.setattr(cap, "MAX_BUNDLE_ENTRIES", 2)
+    monkeypatch.setattr(zipfile, "ZipFile", lambda *_: pytest.fail("allocated ZIP metadata"))
+    with pytest.raises(ValueError, match="3 entries, limit 2"):
+        cap.unpack(path, tmp_path / "work")
+
+
+def test_failed_zip_extraction_does_not_publish_partial_bundle(tmp_path, monkeypatch):
+    path = tmp_path / "bundle.zip"
+    with zipfile.ZipFile(path, "w") as z:
+        z.writestr("one", b"one")
+        z.writestr("two", b"two")
+    real = zipfile.ZipFile.open
+
+    def open_member(z, info, *args, **kwargs):
+        if info.filename == "two":
+            raise zipfile.BadZipFile("CRC failure")
+        return real(z, info, *args, **kwargs)
+
+    monkeypatch.setattr(zipfile.ZipFile, "open", open_member)
+    work = tmp_path / "work"
+    with pytest.raises(zipfile.BadZipFile, match="CRC failure"):
+        cap.unpack(path, work)
+    assert list((work / "bundles").iterdir()) == []
diff --git a/recon/tests/test_worker.py b/recon/tests/test_worker.py
index e4b639cdf..8794dbcbd 100644
--- a/recon/tests/test_worker.py
+++ b/recon/tests/test_worker.py
@@ -410,7 +410,8 @@ def _lidar_frames(root: Path, with_depth: dict[str, bool]) -> list[cap.Frame]:
         lid = None
         if has:
             np.full((2, 2), 2.0, "<f4").tofile(root / f"{fid}.f32")
-            lid = cap.LidarDepth(root / f"{fid}.f32", None, 2, 2)
+            np.full((2, 2), 2, np.uint8).tofile(root / f"{fid}.u8")
+            lid = cap.LidarDepth(root / f"{fid}.f32", root / f"{fid}.u8", 2, 2)
         frames.append(
             cap.Frame(fid, root / f"{fid}.jpg", 8, 6, np.array([8.0, 8, 4, 3]), np.eye(4), lid)
         )
@@ -513,7 +514,7 @@ def test_facing_gap_and_clear_space_start_at_a_proud_wall_face():
     cells = np.array([0.0])
     flat = coverage.free_space(wall, _slab_volume([(-0.3, 0.0), (1.0, 1.4)], 7.0), cells)
     proud = coverage.free_space(wall, _slab_volume([(-0.3, 0.3), (1.3, 1.7)], 7.0), cells)
-    assert proud[0][0] == pytest.approx(flat[0][0]) == pytest.approx(0.95, abs=0.01)
+    assert proud[0][0] == pytest.approx(flat[0][0]) == pytest.approx(0.90, abs=0.01)
     # Nothing faces it, and the volume was seen empty to 2.0 m from the plane: 1.7 m from the face.
     clear = coverage.free_space(wall, _slab_volume([(-0.3, 0.3)], 2.0), cells)
     assert np.isnan(clear[0][0]) and 1.6 <= clear[1][0] <= 1.7

From 1194523580bcaf53042488f70f72b495eeda5c33 Mon Sep 17 00:00:00 2001
From: Sam Gu <127461594+SamGu-NRX@users.noreply.github.com>
Date: Tue, 13 Oct 2026 18:06:09 -0500
Subject: [PATCH 07/62] fix(recon): rebuild caches with unsupported ZIP
 compression

https://github.com/SamGu-NRX/BaseScanning/pull/240#discussion_r4264960688
---
 recon/recon/depth.py            |  2 ++
 recon/tests/test_review_debt.py | 24 +++++++++++++++++++++++-
 2 files changed, 25 insertions(+), 1 deletion(-)

diff --git a/recon/recon/depth.py b/recon/recon/depth.py
index 82a87419a..70c49b2c2 100644
--- a/recon/recon/depth.py
+++ b/recon/recon/depth.py
@@ -217,6 +217,8 @@ def _moge_locked(capture: Capture, work: Path) -> dict[str, Depth]:
                 KeyError,
                 EOFError,
                 TypeError,
+                # ZIP corruption can name an unsupported compression method.
+                NotImplementedError,
                 zipfile.BadZipFile,
                 zlib.error,
             ):
diff --git a/recon/tests/test_review_debt.py b/recon/tests/test_review_debt.py
index 65b6ac0a9..e1c951e3a 100644
--- a/recon/tests/test_review_debt.py
+++ b/recon/tests/test_review_debt.py
@@ -195,7 +195,27 @@ def corrupt_compressed_npz() -> bytes:
     return bytes(raw)
 
 
-@pytest.mark.parametrize("bad", [b"PK\x03\x04truncated", b"not an npz", corrupt_compressed_npz()])
+def unsupported_compression_npz() -> bytes:
+    archive = io.BytesIO()
+    np.savez(archive, depth=np.ones((2, 2), np.float32))
+    raw = bytearray(archive.getvalue())
+    central = raw.index(b"PK\x01\x02")
+    # Both ZIP headers agree on an unsupported method, so the failure occurs on member read.
+    struct.pack_into("<H", raw, 8, 99)
+    struct.pack_into("<H", raw, central + 10, 99)
+    return bytes(raw)
+
+
+@pytest.mark.parametrize(
+    "bad",
+    [
+        b"PK\x03\x04truncated",
+        b"not an npz",
+        corrupt_compressed_npz(),
+        unsupported_compression_npz(),
+    ],
+    ids=["truncated_zip", "not_npz", "damaged_deflate", "unsupported_compression"],
+)
 def test_corrupt_moge_cache_is_recomputed(tmp_path, monkeypatch, bad):
     capture = _capture_named_scan(tmp_path, 10)
     work = tmp_path / "work"
@@ -205,6 +225,8 @@ def test_corrupt_moge_cache_is_recomputed(tmp_path, monkeypatch, bad):
     monkeypatch.setattr(depth.subprocess, "run", _fake_moge(calls))
     assert np.allclose(depth.moge(capture, work)["k"].depth, 10)
     assert calls == [1]
+    assert np.allclose(depth.moge(capture, work)["k"].depth, 10)
+    assert calls == [1]
 
 
 def test_moge_holds_exclusive_cache_lock_through_inference(tmp_path, monkeypatch):

From aec1d012eec90db8c75fed9886b58a1f74fc755d Mon Sep 17 00:00:00 2001
From: Sam Gu <127461594+SamGu-NRX@users.noreply.github.com>
Date: Tue, 13 Oct 2026 18:15:08 -0500
Subject: [PATCH 08/62] experiments(drift-anatomy): test A3 on wall-parallel
 windows; say A4's meter is each window's start

A3 split error along and across each window's travel, but a wall plane
removes error along the wall's normal, which is the across axis only while
the walk runs straight along the wall. Windows whose reference path stays
within 0.25 m or 0.5 m of its start-to-end line now get their own table.
On MARViN at 20 ft along is 0.98 and 0.95 of the p90 there, so the
conclusion holds on the windows that test it. Graded rows are unchanged.

A4 already ranges from a fixed meter: each window is one session that
starts at the meter, and the range runs from that start to the window's
end. METHODS, README and the generated report now say so.

https://github.com/SamGu-NRX/BaseScanning/pull/59#discussion_r4113839737
https://github.com/SamGu-NRX/BaseScanning/pull/59#discussion_r4115917036
https://github.com/SamGu-NRX/BaseScanning/pull/59#discussion_r4113839728
https://github.com/SamGu-NRX/BaseScanning/pull/59#discussion_r4115917030

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 experiments/drift-anatomy/METHODS.md          |   4 +-
 experiments/drift-anatomy/README.md           |   4 +-
 experiments/drift-anatomy/metrics.py          |  19 +++
 .../drift-anatomy/results/drift_anatomy.json  | 108 +++++++++++++++++-
 .../drift-anatomy/results/drift_anatomy.md    |  19 ++-
 experiments/drift-anatomy/run.py              |  72 ++++++++++--
 .../drift-anatomy/tests/test_metrics.py       |  16 +++
 7 files changed, 219 insertions(+), 23 deletions(-)

diff --git a/experiments/drift-anatomy/METHODS.md b/experiments/drift-anatomy/METHODS.md
index 7fba32f7e..e5d4a588f 100644
--- a/experiments/drift-anatomy/METHODS.md
+++ b/experiments/drift-anatomy/METHODS.md
@@ -9,7 +9,7 @@ The server allows 0.16 ft of error per foot along the wall. That allowance domin
 - **A1, return to the meter.** When a walk comes back within 0.3 m of an earlier point more than 30 s later, ARKit's closure residual r is the error in the displacement between the two visits. Does r bound the largest error between the visits?
 - **A2, scale.** Is ARKit's scale one number per walk? This measures the spread of scale over sliding 5 m windows within a walk.
 - **A3, the wall plane.** What share of the error runs across the direction of travel, which a wall plane would remove, compared with along it?
-- **A4, a range to the meter.** A second phone left at the meter ranges the walking phone by UWB (σ 10 cm, simulated) at every window end. What is the p90 left over?
+- **A4, a range to the meter.** A second phone left at the meter ranges the walking phone by UWB (σ 10 cm, simulated) at every window end. What is the p90 left over? Each window is one session that starts at the meter: the walking phone leaves the meter at the window's start, the second phone stays there, and the range runs from that start to the window's end. Sliding the start along a walk samples many meter placements; the error depends on the path walked from the meter, not on where in the dataset the meter sits.
 
 ## Pass criteria, fixed before the run
 
@@ -24,7 +24,7 @@ All four fail. Tables: [results/drift_anatomy.md](results/drift_anatomy.md).
 
 - **A1.** 30 of 56 MARViN loops (54%). ADVIO has no revisit under 0.3 m while ARKit tracks. Scale and heading error cancel on return, so r misses them.
 - **A2.** 5.7% SD on MARViN, 19% on ADVIO: drop. A few outlier windows inflate MARViN's SD; its robust SD is 1.8%.
-- **A3.** At 20 ft, along is 0.92 of the p90 on MARViN and 0.76 on ADVIO.
+- **A3.** At 20 ft, along is 0.92 of the p90 on MARViN and 0.76 on ADVIO. Added after review: across-travel is a wall's normal only while the walk runs straight along the wall, and the walks have no wall annotations. On windows whose path stays within 0.25 m of its start-to-end line, along is 0.98 of the p90 on MARViN and 0.75 on ADVIO at 20 ft; within 0.5 m, 0.95 and 0.75. The conclusion holds on the windows that test it.
 - **A4.** MARViN goes from 10.4 and 13.6 in to 7.7 and 8.5 in. At σ 10 cm the range's own p90 is 6.5 in, so the bar was nearly out of reach. At 5 cm: 4.9 and 6.1 in.
 
 **Run:** `uv run python run.py`. Needs the evals checkout at 190ed33 (`EVALS_HARNESS`) and MARViN and ADVIO in `~/house-scanning-data`.
diff --git a/experiments/drift-anatomy/README.md b/experiments/drift-anatomy/README.md
index e745d756f..1ae0e79f6 100644
--- a/experiments/drift-anatomy/README.md
+++ b/experiments/drift-anatomy/README.md
@@ -2,7 +2,7 @@
 
 ## Question
 
-The server allows 0.16 ft of error per foot along the wall, which dominates a check's error bar beyond a few feet. Which part of ARKit's error is worth attacking? A1 asks whether returning to the meter bounds it, A2 whether scale is one number per walk, A3 how much runs across travel, where a wall plane would help, and A4 what a UWB range to the meter leaves. The data is MARViN (iPhone 14 Pro Max) and ADVIO (iPhone 6s); [METHODS.md](METHODS.md) has the details.
+The server allows 0.16 ft of error per foot along the wall, which dominates a check's error bar beyond a few feet. Which part of ARKit's error is worth attacking? A1 asks whether returning to the meter bounds it, A2 whether scale is one number per walk, A3 how much runs across travel, where a wall plane would help, and A4 what a UWB range to the meter leaves. Each window stands for a session that starts at the meter, so in A4 the second phone sits at the window's start. The data is MARViN (iPhone 14 Pro Max) and ADVIO (iPhone 6s); [METHODS.md](METHODS.md) has the details.
 
 ## Pass criteria, fixed before the run (397507f)
 
@@ -17,7 +17,7 @@ All four fail ([tables](results/drift_anatomy.md)).
 
 - **A1.** The closure residual bounds the peak error in 30 of 56 loops. Scale and heading error cancel on return.
 - **A2.** Scale spread within a walk is 1.8% robust SD (5.7% SD) on MARViN.
-- **A3.** At 20 ft, the along-travel p90 is 9.6 of 10.4 in.
+- **A3.** At 20 ft, the along-travel p90 is 9.6 of 10.4 in. On the windows that walk straight, which is where across-travel is a wall's normal, along is 0.95 to 0.98 of the total on MARViN (added after review).
 - **A4.** UWB cuts 20 ft from 10.4 to 7.7 in at σ 10 cm, and to 4.9 in at σ 5 cm.
 
 **Run:** `uv run python run.py`: 20 s. Needs the evals checkout at 190ed33 and MARViN and ADVIO in `~/house-scanning-data`.
diff --git a/experiments/drift-anatomy/metrics.py b/experiments/drift-anatomy/metrics.py
index 1107729a4..f329e769a 100644
--- a/experiments/drift-anatomy/metrics.py
+++ b/experiments/drift-anatomy/metrics.py
@@ -167,6 +167,25 @@ def along_across(err: np.ndarray, ref_disp: np.ndarray) -> tuple[np.ndarray, np.
     return along, across
 
 
+def chord_deviation(ref: np.ndarray, i: np.ndarray, j: np.ndarray) -> np.ndarray:
+    """Per window, the largest horizontal distance of the reference path from the straight line
+    through its start ref[i] and its (fractional) end at(ref, j). A wall plane removes the error
+    along the wall's normal, which is the across-travel axis only while the walk runs straight
+    along the wall; this measures how far a window strays from that."""
+    out = np.empty(len(i))
+    for k, (a, b) in enumerate(zip(i, j, strict=True)):
+        start = ref[a, [0, 2]]
+        end = at(ref, np.array([b]))[0, [0, 2]]
+        pts = np.vstack([ref[a : int(np.floor(b)) + 1, [0, 2]], end]) - start
+        chord = end - start
+        n = np.linalg.norm(chord)
+        if n == 0:
+            raise ValueError(f"window {a}..{b} ends where it starts and has no travel line")
+        u = chord / n
+        out[k] = np.abs(u[1] * pts[:, 0] - u[0] * pts[:, 1]).max()
+    return out
+
+
 # A4: a range to the meter
 
 
diff --git a/experiments/drift-anatomy/results/drift_anatomy.json b/experiments/drift-anatomy/results/drift_anatomy.json
index 73d0a8375..edd2313e4 100644
--- a/experiments/drift-anatomy/results/drift_anatomy.json
+++ b/experiments/drift-anatomy/results/drift_anatomy.json
@@ -1357,30 +1357,78 @@
     "p90_along_in": 5.93244053666383,
     "p90_across_in": 2.383144858716218,
     "p90_horizontal_in": 6.356644425002893,
+    "along_share_of_total_p90": 0.9332660661857188,
     "median_horizontal_in": 2.6181875496018105,
     "p90_vertical_in": 1.9654002913094888,
     "p90_3d_in": 6.796782660764225,
-    "along_share_of_total_p90": 0.9332660661857188
+    "wall_parallel": {
+     "0.25": {
+      "windows": 3601,
+      "p90_along_in": 5.826966988094975,
+      "p90_across_in": 2.111570110459862,
+      "p90_horizontal_in": 6.152786774170161,
+      "along_share_of_total_p90": 0.9470451686310665
+     },
+     "0.50": {
+      "windows": 4489,
+      "p90_along_in": 5.877316441113764,
+      "p90_across_in": 2.256740731176376,
+      "p90_horizontal_in": 6.281388835683555,
+      "along_share_of_total_p90": 0.9356714884016857
+     }
+    }
    },
    "20": {
     "windows": 4956,
     "p90_along_in": 9.614029066697613,
     "p90_across_in": 3.8201651149007376,
     "p90_horizontal_in": 10.416259256830854,
+    "along_share_of_total_p90": 0.9229828895044881,
     "median_horizontal_in": 4.395873486077264,
     "p90_vertical_in": 2.9551007554751285,
     "p90_3d_in": 10.87021034634674,
-    "along_share_of_total_p90": 0.9229828895044881
+    "wall_parallel": {
+     "0.25": {
+      "windows": 1416,
+      "p90_along_in": 9.604249774006092,
+      "p90_across_in": 2.6576477424629545,
+      "p90_horizontal_in": 9.791322826235511,
+      "along_share_of_total_p90": 0.9808939960872128
+     },
+     "0.50": {
+      "windows": 2735,
+      "p90_along_in": 9.735246181368389,
+      "p90_across_in": 2.9849409636746014,
+      "p90_horizontal_in": 10.254954545799945,
+      "along_share_of_total_p90": 0.9493212415412987
+     }
+    }
    },
    "30": {
     "windows": 4866,
     "p90_along_in": 12.50959372814818,
     "p90_across_in": 5.464582640836947,
     "p90_horizontal_in": 13.628585737497145,
+    "along_share_of_total_p90": 0.917893754282206,
     "median_horizontal_in": 6.016112751925093,
     "p90_vertical_in": 3.6388989773814653,
     "p90_3d_in": 14.139117730080716,
-    "along_share_of_total_p90": 0.917893754282206
+    "wall_parallel": {
+     "0.25": {
+      "windows": 556,
+      "p90_along_in": 11.52265233012735,
+      "p90_across_in": 3.0105234637262224,
+      "p90_horizontal_in": 11.707672299015773,
+      "along_share_of_total_p90": 0.9841966904980782
+     },
+     "0.50": {
+      "windows": 1506,
+      "p90_along_in": 12.273519598588699,
+      "p90_across_in": 3.6974588667790194,
+      "p90_horizontal_in": 12.509892612405189,
+      "along_share_of_total_p90": 0.981105112478576
+     }
+    }
    }
   },
   "advio": {
@@ -1389,30 +1437,78 @@
     "p90_along_in": 40.16740160527824,
     "p90_across_in": 41.217205108912495,
     "p90_horizontal_in": 55.603313400377814,
+    "along_share_of_total_p90": 0.7223922307659694,
     "median_horizontal_in": 26.202438486533016,
     "p90_vertical_in": 3.697033252704125,
     "p90_3d_in": 55.7048750882303,
-    "along_share_of_total_p90": 0.7223922307659694
+    "wall_parallel": {
+     "0.25": {
+      "windows": 1831,
+      "p90_along_in": 38.817104640899515,
+      "p90_across_in": 40.40824203776524,
+      "p90_horizontal_in": 54.051646176045516,
+      "along_share_of_total_p90": 0.7181484263119888
+     },
+     "0.50": {
+      "windows": 1905,
+      "p90_along_in": 39.71706496159873,
+      "p90_across_in": 40.95345003105173,
+      "p90_horizontal_in": 55.31558133196048,
+      "along_share_of_total_p90": 0.7180086334670921
+     }
+    }
    },
    "20": {
     "windows": 1903,
     "p90_along_in": 72.05520337403567,
     "p90_across_in": 77.9870905225656,
     "p90_horizontal_in": 94.28551696290192,
+    "along_share_of_total_p90": 0.76422345334742,
     "median_horizontal_in": 50.231545101074694,
     "p90_vertical_in": 6.375715770353499,
     "p90_3d_in": 94.60404389848367,
-    "along_share_of_total_p90": 0.76422345334742
+    "wall_parallel": {
+     "0.25": {
+      "windows": 1572,
+      "p90_along_in": 66.36786396952603,
+      "p90_across_in": 73.94467380934859,
+      "p90_horizontal_in": 88.94005061866382,
+      "along_share_of_total_p90": 0.7462089745606566
+     },
+     "0.50": {
+      "windows": 1720,
+      "p90_along_in": 70.01436124445905,
+      "p90_across_in": 77.12953122417956,
+      "p90_horizontal_in": 93.0226402125133,
+      "along_share_of_total_p90": 0.7526593642634624
+     }
+    }
    },
    "30": {
     "windows": 1889,
     "p90_along_in": 97.37446063335635,
     "p90_across_in": 110.39001216955775,
     "p90_horizontal_in": 132.53687138322834,
+    "along_share_of_total_p90": 0.7346971421394095,
     "median_horizontal_in": 73.64854529941651,
     "p90_vertical_in": 9.174807119748339,
     "p90_3d_in": 132.57989402774612,
-    "along_share_of_total_p90": 0.7346971421394095
+    "wall_parallel": {
+     "0.25": {
+      "windows": 1421,
+      "p90_along_in": 93.12387571665461,
+      "p90_across_in": 102.7530290645741,
+      "p90_horizontal_in": 124.45301489257115,
+      "along_share_of_total_p90": 0.7482653256495223
+     },
+     "0.50": {
+      "windows": 1549,
+      "p90_along_in": 99.08655440233662,
+      "p90_across_in": 107.2678362551467,
+      "p90_horizontal_in": 129.17438173809424,
+      "along_share_of_total_p90": 0.7670758943769378
+     }
+    }
    }
   }
  },
diff --git a/experiments/drift-anatomy/results/drift_anatomy.md b/experiments/drift-anatomy/results/drift_anatomy.md
index bece27d8d..1f7bebdde 100644
--- a/experiments/drift-anatomy/results/drift_anatomy.md
+++ b/experiments/drift-anatomy/results/drift_anatomy.md
@@ -132,9 +132,26 @@ The evals' windows: from every image (MARViN) or every 0.5 s (ADVIO) until the r
 
 Criterion at 20 ft: along p90 at most 0.60 of the horizontal total p90. MARViN 0.92, FAIL; ADVIO 0.76, FAIL.
 
+Added after review: a wall plane removes the error along the wall's normal, and that is the across-travel axis only while the walk runs straight along the wall. In windows that turn, across holds some along-wall error and along holds some error a plane would remove, so the graded split above cannot by itself say whether a plane helps. The walks have no wall annotations, so the windows below stand in for a walk along a wall: those whose reference path stays within the given distance of its own start-to-end line. The widths are untuned and not pre-registered.
+
+| Data | Walked | Within | Windows | Along | Across | Horizontal total | Along / total |
+| --- | --- | --- | --- | --- | --- | --- | --- |
+| MARViN | 10 ft | 0.25 m | 3601 | 5.8 | 2.1 | 6.2 | 0.95 |
+| MARViN | 10 ft | 0.50 m | 4489 | 5.9 | 2.3 | 6.3 | 0.94 |
+| MARViN | 20 ft | 0.25 m | 1416 | 9.6 | 2.7 | 9.8 | 0.98 |
+| MARViN | 20 ft | 0.50 m | 2735 | 9.7 | 3.0 | 10.3 | 0.95 |
+| MARViN | 30 ft | 0.25 m | 556 | 11.5 | 3.0 | 11.7 | 0.98 |
+| MARViN | 30 ft | 0.50 m | 1506 | 12.3 | 3.7 | 12.5 | 0.98 |
+| ADVIO | 10 ft | 0.25 m | 1831 | 38.8 | 40.4 | 54.1 | 0.72 |
+| ADVIO | 10 ft | 0.50 m | 1905 | 39.7 | 41.0 | 55.3 | 0.72 |
+| ADVIO | 20 ft | 0.25 m | 1572 | 66.4 | 73.9 | 88.9 | 0.75 |
+| ADVIO | 20 ft | 0.50 m | 1720 | 70.0 | 77.1 | 93.0 | 0.75 |
+| ADVIO | 30 ft | 0.25 m | 1421 | 93.1 | 102.8 | 124.5 | 0.75 |
+| ADVIO | 30 ft | 0.50 m | 1549 | 99.1 | 107.3 | 129.2 | 0.77 |
+
 ## A4, a range to the meter
 
-A simulated range from each window's start to its end: the reference's 3-D distance plus N(0, sigma), 20 draws per window (seed 0). ARKit's end moves radially in the horizontal plane about the start, keeping its height, onto the range. p90 horizontal error, inches. sigma 0.10 m is graded; 0.05 and 0.20 m are not.
+Each window is a session that starts at the meter, where the second phone stays. A simulated range from each window's start to its end: the reference's 3-D distance plus N(0, sigma), 20 draws per window (seed 0). ARKit's end moves radially in the horizontal plane about the start, keeping its height, onto the range. p90 horizontal error, inches. sigma 0.10 m is graded; 0.05 and 0.20 m are not.
 
 | Data | Walked | Before | After, 0.05 m | After, 0.10 m | After, 0.20 m |
 | --- | --- | --- | --- | --- | --- |
diff --git a/experiments/drift-anatomy/run.py b/experiments/drift-anatomy/run.py
index 51556068c..396e4a777 100644
--- a/experiments/drift-anatomy/run.py
+++ b/experiments/drift-anatomy/run.py
@@ -17,6 +17,7 @@
 from metrics import (
     along_across,
     at,
+    chord_deviation,
     find_loops,
     local_scale,
     loop_errors,
@@ -56,6 +57,11 @@
 RANGE_SIGMAS_M = (0.05, 0.10, 0.20)
 GRADED_SIGMA_M = 0.10
 RANGE_DRAWS = 20
+# A3, added after review: the across-travel axis is a wall's normal only while the walk runs
+# straight along the wall, and the walks carry no wall annotations. Windows whose reference path
+# stays within this distance of its own start-to-end line stand in for a walk along a wall. Both
+# widths are untuned guesses at how straight a homeowner keeps to a wall, reported side by side.
+WALL_PARALLEL_M = (0.25, 0.5)
 SEED = 0
 
 
@@ -236,15 +242,31 @@ def a2(walks: list[Walk]) -> dict:
 # A3 and A4
 
 
-def window_errors(ws: list[Walk], ft: int, window_pairs) -> tuple[np.ndarray, np.ndarray]:
-    """ARKit's displacement turned by the heading offset at each window's start, and the
-    reference's, pooled over walks; the evals' windows (every start sample, exactly ft of path)."""
-    est, ref = [], []
+def window_errors(
+    ws: list[Walk], ft: int, window_pairs
+) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
+    """ARKit's displacement turned by the heading offset at each window's start, the reference's,
+    and how far the reference path strays from its start-to-end line, pooled over walks; the
+    evals' windows (every start sample, exactly ft of path)."""
+    est, ref, dev = [], [], []
     for w in ws:
         i, j = window_pairs(w.ref, ft * FEET, w.start_step)
         est.append(turn(at(w.ark, j) - w.ark[i], w.delta[i]))
         ref.append(at(w.ref, j) - w.ref[i])
-    return np.concatenate(est), np.concatenate(ref)
+        dev.append(chord_deviation(w.ref, i, j))
+    return np.concatenate(est), np.concatenate(ref), np.concatenate(dev)
+
+
+def split_p90(err: np.ndarray, ref: np.ndarray) -> dict:
+    along, across = along_across(err, ref)
+    horiz = np.hypot(along, across)
+    return {
+        "windows": len(err),
+        "p90_along_in": p90(np.abs(along)) / INCH,
+        "p90_across_in": p90(np.abs(across)) / INCH,
+        "p90_horizontal_in": p90(horiz) / INCH,
+        "along_share_of_total_p90": p90(np.abs(along)) / p90(horiz),
+    }
 
 
 def a3_a4(walks: list[Walk]) -> tuple[dict, dict]:
@@ -254,19 +276,21 @@ def a3_a4(walks: list[Walk]) -> tuple[dict, dict]:
     for dataset, ws in by_dataset(walks).items():
         a3[dataset], a4[dataset] = {}, {}
         for ft in WINDOW_FT:
-            est, ref = window_errors(ws, ft, drift.window_pairs)
+            est, ref, dev = window_errors(ws, ft, drift.window_pairs)
             err = est - ref
             along, across = along_across(err, ref)
             horiz = np.hypot(along, across)
             a3[dataset][ft] = {
-                "windows": len(err),
-                "p90_along_in": p90(np.abs(along)) / INCH,
-                "p90_across_in": p90(np.abs(across)) / INCH,
-                "p90_horizontal_in": p90(horiz) / INCH,
+                **split_p90(err, ref),
                 "median_horizontal_in": float(np.median(horiz)) / INCH,
                 "p90_vertical_in": p90(np.abs(err[:, 1])) / INCH,
                 "p90_3d_in": p90(np.linalg.norm(err, axis=1)) / INCH,
-                "along_share_of_total_p90": p90(np.abs(along)) / p90(horiz),
+                "wall_parallel": {
+                    f"{m:.2f}": split_p90(err[dev <= m], ref[dev <= m])
+                    if (dev <= m).any()
+                    else None
+                    for m in WALL_PARALLEL_M
+                },
             }
             true_range = np.linalg.norm(ref, axis=1)
             a4[dataset][ft] = {"before_p90_in": p90(horiz) / INCH}
@@ -457,10 +481,34 @@ def markdown(meta: dict, r1: dict, r2: dict, r3: dict, r4: dict, r5: dict) -> st
             for d, x in r3.items()
         )
         + ".",
+        "",
+        "Added after review: a wall plane removes the error along the wall's normal, and that is "
+        "the across-travel axis only while the walk runs straight along the wall. In windows that "
+        "turn, across holds some along-wall error and along holds some error a plane would remove, "
+        "so the graded split above cannot by itself say whether a plane helps. The walks have no "
+        "wall annotations, so the windows below stand in for a walk along a wall: those whose "
+        "reference path stays within the given distance of its own start-to-end line. The widths "
+        "are untuned and not pre-registered.",
+        "",
+        "| Data | Walked | Within | Windows | Along | Across | Horizontal total | Along / total |",
+        "| --- | --- | --- | --- | --- | --- | --- | --- |",
+    ]
+    for d, x in r3.items():
+        for ft, y in x.items():
+            for m, z in y["wall_parallel"].items():
+                if z is None:
+                    L.append(f"| {names[d]} | {ft} ft | {m} m | 0 | | | | |")
+                    continue
+                L.append(
+                    f"| {names[d]} | {ft} ft | {m} m | {z['windows']} | {z['p90_along_in']:.1f} | "
+                    f"{z['p90_across_in']:.1f} | {z['p90_horizontal_in']:.1f} | "
+                    f"{z['along_share_of_total_p90']:.2f} |"
+                )
+    L += [
         "",
         "## A4, a range to the meter",
         "",
-        f"A simulated range from each window's start to its end: the reference's 3-D distance plus "
+        f"Each window is a session that starts at the meter, where the second phone stays. A simulated range from each window's start to its end: the reference's 3-D distance plus "
         f"N(0, sigma), {RANGE_DRAWS} draws per window (seed {SEED}). ARKit's end moves radially in "
         "the horizontal plane about the start, keeping its height, onto the range. p90 horizontal "
         "error, inches. sigma 0.10 m is graded; 0.05 and 0.20 m are not.",
diff --git a/experiments/drift-anatomy/tests/test_metrics.py b/experiments/drift-anatomy/tests/test_metrics.py
index 3b49b968e..6a607e373 100644
--- a/experiments/drift-anatomy/tests/test_metrics.py
+++ b/experiments/drift-anatomy/tests/test_metrics.py
@@ -6,6 +6,7 @@
 from metrics import (
     along_across,
     at,
+    chord_deviation,
     find_loops,
     local_scale,
     loop_errors,
@@ -189,6 +190,21 @@ def test_along_across_is_pythagorean_and_turn_invariant():
     np.testing.assert_allclose(c2, across, atol=1e-12)
 
 
+def test_chord_deviation_is_zero_on_a_straight_walk_and_the_corner_offset_on_a_turn():
+    lap = square_lap(side_m=15.0)  # 1 m samples: corners at 15, 30, 45
+    i, j = np.array([0, 10]), np.array([12.5, 20.0])
+    dev = chord_deviation(lap, i, j)
+    assert dev[0] == pytest.approx(0.0, abs=1e-12)  # 12.5 m along the first side
+    # From (10, 0) round the corner to (15, 5): the corner is 5 / sqrt(2) off the chord.
+    assert dev[1] == pytest.approx(5 / np.sqrt(2), abs=1e-12)
+
+
+def test_chord_deviation_refuses_a_window_with_no_travel():
+    p = np.c_[np.zeros(5), np.ones(5), np.zeros(5)]
+    with pytest.raises(ValueError, match="no travel line"):
+        chord_deviation(p, np.array([0]), np.array([3.0]))
+
+
 # Range to the meter
 
 

From bfb6c19150fb1515fcea1f4e7d3c54805d2c4bda Mon Sep 17 00:00:00 2001
From: Sam Gu <127461594+SamGu-NRX@users.noreply.github.com>
Date: Tue, 13 Oct 2026 18:16:20 -0500
Subject: [PATCH 09/62] experiments(meter-closeup): drop a saved review verdict
 once its number changes

The review page restored browser answers from a fixed localStorage key by
photo id, so after a label correction or dataset update a stale Keep showed
as done and was exported for a number nobody had checked. Each saved
answer now records the number it was given for, and startingAnswers keeps
it only while the page still shows that number; otherwise the ingested
answer, if any, applies and the photo is open again. Answers saved before
this change carry no number and are dropped the same way.

https://github.com/SamGu-NRX/BaseScanning/pull/16#discussion_r4114120267

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 experiments/meter-closeup/METHODS.md          |  2 +-
 .../meter-closeup/src/meter_eval/review.py    | 17 +++++++----
 .../meter-closeup/tests/test_review_keep.py   | 30 +++++++++++++++++++
 3 files changed, 43 insertions(+), 6 deletions(-)

diff --git a/experiments/meter-closeup/METHODS.md b/experiments/meter-closeup/METHODS.md
index 666b52599..22c203395 100644
--- a/experiments/meter-closeup/METHODS.md
+++ b/experiments/meter-closeup/METHODS.md
@@ -17,7 +17,7 @@ Two AI models, not people, read every photo, so every number is only as good as
 - **Loose** (73 photos, used for the headline): reader 1's number equals any number reader 2 listed, or one contains the other and the shorter has at least 6 characters, and neither reader doubted a character.
 - **Strict** (62 photos): both readers' main numbers are identical and both were sure. Reading and ranking results are reported under both rules.
 
-To confirm the labels by hand, run `make review` and open `~/house-scanning-data/meter-closeup/review.html`. Each photo shows whole, beside the agreed number. Press K to keep the number, or F to type a correction. Then run `uv run python -m meter_eval.review ingest <downloaded csv>` and rebuild with `uv run python -m meter_eval.labels`. A kept number counts as agreed under both rules; a corrected one does not until someone keeps it. Ingest merges new answers into earlier ones, and a rebuilt page shows each earlier correction in place of the readers' number, so Keep confirms the correction even in a new browser.
+To confirm the labels by hand, run `make review` and open `~/house-scanning-data/meter-closeup/review.html`. Each photo shows whole, beside the agreed number. Press K to keep the number, or F to type a correction. Then run `uv run python -m meter_eval.review ingest <downloaded csv>` and rebuild with `uv run python -m meter_eval.labels`. A kept number counts as agreed under both rules; a corrected one does not until someone keeps it. A verdict saved in the browser stays only while the page shows the number it was given for, so after a label correction that photo opens again. Ingest merges new answers into earlier ones, and a rebuilt page shows each earlier correction in place of the readers' number, so Keep confirms the correction even in a new browser.
 
 ## Keeping meter numbers out of the repository
 
diff --git a/experiments/meter-closeup/src/meter_eval/review.py b/experiments/meter-closeup/src/meter_eval/review.py
index 6eb71c770..7c318f55a 100644
--- a/experiments/meter-closeup/src/meter_eval/review.py
+++ b/experiments/meter-closeup/src/meter_eval/review.py
@@ -222,12 +222,19 @@ def ingest(path: str) -> None:
 <script type="application/json" id="items">__ITEMS__</script>
 <script>
 const items = JSON.parse(document.getElementById("items").textContent);
-// Answers already ingested ship with the page, so a new browser starts from them; answers
-// saved in this browser since then take precedence.
+// Answers already ingested ship with the page, so a new browser starts from them. An answer
+// saved in this browser since then takes precedence only while the page still shows the number
+// it was given for: after a label correction or dataset update the photo is open again, so a
+// stale Keep is neither shown as done nor exported. Answers saved before `shown` was recorded
+// cannot be checked and are dropped the same way.
 function startingAnswers(items, stored) {
   const answers = {};
-  for (const item of items) if (item.answer) answers[item.id] = item.answer;
-  return Object.assign(answers, stored);
+  for (const item of items) {
+    const mine = stored[item.id];
+    if (mine && mine.shown === item.number) answers[item.id] = mine;
+    else if (item.answer) answers[item.id] = item.answer;
+  }
+  return answers;
 }
 
 const saved = startingAnswers(items, JSON.parse(localStorage.getItem("meter-check") || "{}"));
@@ -304,7 +311,7 @@ def ingest(path: str) -> None:
 }
 
 function store(i, answer) {
-  saved[items[i].id] = answer;
+  saved[items[i].id] = { ...answer, shown: items[i].number };
   localStorage.setItem("meter-check", JSON.stringify(saved));
   const el = document.getElementById(items[i].id);
   el.dataset.verdict = answer.verdict;
diff --git a/experiments/meter-closeup/tests/test_review_keep.py b/experiments/meter-closeup/tests/test_review_keep.py
index 204d612cd..319f9fb05 100644
--- a/experiments/meter-closeup/tests/test_review_keep.py
+++ b/experiments/meter-closeup/tests/test_review_keep.py
@@ -46,6 +46,36 @@ def test_keep_in_a_new_browser_confirms_an_ingested_correction():
     assert keep_answer(None, item) == {"verdict": "keep", "number": "7654321"}
 
 
+def test_a_browser_keep_given_for_a_number_the_page_no_longer_shows_is_dropped():
+    items = [
+        {
+            "id": "m01",
+            "number": "7654321",
+            "corrected": True,
+            "answer": {"verdict": "fix", "number": "7654321"},
+        },
+        {"id": "m02", "number": "2222222", "corrected": False, "answer": None},
+        {"id": "m03", "number": "3333333", "corrected": False, "answer": None},
+    ]
+    stored = {
+        # Kept while the page showed the readers' 1111111, before the correction was ingested.
+        "m01": {"verdict": "keep", "number": "", "shown": "1111111"},
+        # Kept for a number the dataset update changed.
+        "m02": {"verdict": "keep", "number": "", "shown": "2220000"},
+        # Kept for the number still shown.
+        "m03": {"verdict": "keep", "number": "", "shown": "3333333"},
+        # Saved before answers recorded what they were given for.
+        "m04": {"verdict": "keep", "number": ""},
+    }
+    saved = on_page("startingAnswers(items, stored)", items=items, stored=stored)
+    assert saved == {
+        "m01": {"verdict": "fix", "number": "7654321"},
+        "m03": {"verdict": "keep", "number": "", "shown": "3333333"},
+    }
+    rows = on_page("answerRows(items, startingAnswers(items, stored))", items=items, stored=stored)
+    assert rows[1:] == [["m01", "fix", "7654321"], ["m02", "", ""], ["m03", "keep", ""]]
+
+
 def write(path, rows):
     with path.open("w", newline="") as handle:
         writer = csv.DictWriter(handle, fieldnames=list(rows[0]))

From 5595a06f957744f18e41cbffd18905c83a50ef89 Mon Sep 17 00:00:00 2001
From: Sam Gu <127461594+SamGu-NRX@users.noreply.github.com>
Date: Tue, 13 Oct 2026 18:18:27 -0500
Subject: [PATCH 10/62] experiments(meter-closeup): join OCR boxes in a row
 only across a small gap

rows_of_text joined every box sharing a row, so digits from an unrelated
field further along the row could complete a labelled number and union its
box with that field. Boxes now join only across a gap of at most three
character widths (box width over its characters, in the image's own x
units, so no aspect ratio is needed); a row splits into chains at wider
gaps.

Checked on the cached Vision reads of the labelled photos (clean.jsonl and
scan.jsonl, every configuration, strict and lenient): limits from 2 to 6
widths change no number match and 1.5 loses three, so the committed
results stand without a rerun. The sweep's degraded reads were not
rescored. The limit does split unrelated fields on these photos, but no read depended on those joins.

https://github.com/SamGu-NRX/BaseScanning/pull/16#discussion_r4114120264

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 .../meter-closeup/src/meter_eval/match.py     | 36 ++++++++++++++++---
 .../meter-closeup/tests/test_metrics.py       | 19 ++++++++--
 2 files changed, 48 insertions(+), 7 deletions(-)

diff --git a/experiments/meter-closeup/src/meter_eval/match.py b/experiments/meter-closeup/src/meter_eval/match.py
index 13aaf85f2..86a9bb354 100644
--- a/experiments/meter-closeup/src/meter_eval/match.py
+++ b/experiments/meter-closeup/src/meter_eval/match.py
@@ -10,6 +10,7 @@
 import functools
 import hashlib
 import hmac
+import itertools
 import os
 import re
 from collections.abc import Sequence
@@ -64,11 +65,28 @@ def digest(normalized: str) -> str:
     return hmac.new(key(), normalized.encode(), hashlib.sha256).hexdigest()
 
 
+# Boxes in one row join only across a horizontal gap of at most this many character widths
+# (a box's width over its non-space characters, averaged over the two boxes). It is measured in
+# the image's own x units, so it needs no aspect ratio. On the cached Vision reads of the 75
+# labelled photos (clean and locate runs, every configuration), a limit of 2 to 6 widths leaves
+# every number match as it was and 1.5 loses three; 3 keeps a margin. The limit does split
+# unrelated fields there (a model code from a serial on the same row), but no read depended on
+# that join, so these photos show no false read it prevents.
+MAX_JOIN_GAP_CHARS = 3.0
+
+
+def _char_width(line: dict) -> float:
+    return line["box"][2] / max(1, len(line["text"].replace(" ", "")))
+
+
 def rows_of_text(lines: Sequence[dict]) -> list[tuple[str, list[list[float]]]]:
-    """Each line's (text, [box]), plus lines sharing a row joined left to right.
+    """Each line's (text, [box]), plus neighbouring lines in one row joined left to right.
 
     Vision sometimes splits one printed number into two observations ("123 45" and "678").
-    Two boxes share a row when their vertical overlap is at least half the shorter box.
+    Two boxes share a row when their vertical overlap is at least half the shorter box, and
+    they join only when the gap between them is at most MAX_JOIN_GAP_CHARS character widths,
+    so digits from an unrelated field further along the same row are not read as part of the
+    number.
     """
     texts = [(line["text"], [line["box"]]) for line in lines]
     rows: list[list[dict]] = []
@@ -83,9 +101,17 @@ def rows_of_text(lines: Sequence[dict]) -> list[tuple[str, list[list[float]]]]:
         else:
             rows.append([line])
     for row in rows:
-        if len(row) > 1:
-            ordered = sorted(row, key=lambda item: item["box"][0])
-            texts.append((" ".join(item["text"] for item in ordered), [i["box"] for i in ordered]))
+        ordered = sorted(row, key=lambda item: item["box"][0])
+        chains = [[ordered[0]]]
+        for left, right in itertools.pairwise(ordered):
+            gap = right["box"][0] - (left["box"][0] + left["box"][2])
+            if gap <= MAX_JOIN_GAP_CHARS * (_char_width(left) + _char_width(right)) / 2:
+                chains[-1].append(right)
+            else:
+                chains.append([right])
+        for chain in chains:
+            if len(chain) > 1:
+                texts.append((" ".join(i["text"] for i in chain), [i["box"] for i in chain]))
     return texts
 
 
diff --git a/experiments/meter-closeup/tests/test_metrics.py b/experiments/meter-closeup/tests/test_metrics.py
index d6e1b7493..47090ab53 100644
--- a/experiments/meter-closeup/tests/test_metrics.py
+++ b/experiments/meter-closeup/tests/test_metrics.py
@@ -80,12 +80,27 @@ def test_number_with_one_wrong_digit_is_not_read():
 
 
 def test_number_split_across_two_boxes_on_one_row_is_joined():
-    lines = [line("5678", 0.5, 0.52), line("123", 0.3, 0.5)]
+    lines = [line("5678", 0.45, 0.52), line("123", 0.3, 0.5)]
     joined = dict(rows_of_text(lines))
-    assert joined["123 5678"] == [[0.3, 0.5, 0.1, 0.05], [0.5, 0.52, 0.1, 0.05]]
+    assert joined["123 5678"] == [[0.3, 0.5, 0.1, 0.05], [0.45, 0.52, 0.1, 0.05]]
     assert number_boxes(lines, digest("1235678"), 7, lenient=False) == joined["123 5678"]
 
 
+def test_a_field_further_along_the_row_is_not_joined_to_the_number():
+    # Same row, but the second field starts 0.4 to the right: about ten character widths of
+    # these 0.1-wide boxes, where a printed space is about one.
+    lines = [line("123", 0.1, 0.5), line("5678", 0.6, 0.5)]
+    assert "123 5678" not in dict(rows_of_text(lines))
+    assert not number_read(lines, digest("1235678"), 7, lenient=False)
+
+
+def test_a_far_field_does_not_stop_the_adjacent_split_number_joining():
+    lines = [line("MM26", 0.0, 0.5), line("123", 0.5, 0.5), line("5678", 0.62, 0.5)]
+    joined = dict(rows_of_text(lines))
+    assert "123 5678" in joined and "MM26 123 5678" not in joined
+    assert number_read(lines, digest("1235678"), 7, lenient=False)
+
+
 def test_boxes_on_different_rows_are_not_joined():
     lines = [line("123", 0.3, 0.1), line("5678", 0.5, 0.5)]
     assert not number_read(lines, digest("1235678"), 7, lenient=False)

From 0cf5f48ec52b93147d7da00aa4dea2f7736f5624 Mon Sep 17 00:00:00 2001
From: Sam Gu <127461594+SamGu-NRX@users.noreply.github.com>
Date: Tue, 13 Oct 2026 18:19:39 -0500
Subject: [PATCH 11/62] research-handoff: record that the ground-replay patch
 loses evidence past a marked end

The unrun patch replays accepted cameras under the current marked ends, so
sightings recorded before an end was marked are dropped and clearEnd has
nothing to restore them from. The README now says so next to the patch's
other known gaps. The patch bytes are unchanged, so patch-identities.json
still holds. Alpha's in-app replay has the same shape; that is reported for
the iOS lane, not changed here.

https://github.com/SamGu-NRX/BaseScanning/pull/18#discussion_r4111600380

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 experiments/research-handoff/native-proposals/README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/experiments/research-handoff/native-proposals/README.md b/experiments/research-handoff/native-proposals/README.md
index 9f1589daa..3c28129b5 100644
--- a/experiments/research-handoff/native-proposals/README.md
+++ b/experiments/research-handoff/native-proposals/README.md
@@ -13,7 +13,7 @@ One Swift 6 host build and one run exercised nine paired cases: **18 observation
 
 The ground helper proposes synchronous recomputation from a caller-qualified camera ledger in original acceptance order, including observations whose original delta was zero. It retains latent skip flags and marked-end coordinates, discards photographic row state, replays existing geometry methods, and advances revision from the prior map. Unchanged samples and meter-y-only updates preserve current evidence/revision. Changed horizontal geometry, nonfinite heights or a nonzero residual cell shift are refused without mutation.
 
-**The ground helper is not a complete geometry fix.** Ordinary anchor refinement can leave a residual shift and prevent its use. Carrying that residual into freshly projected evidence, or dropping it while retaining rounded skip cells, would mix coordinate histories. Caller ledger admission, world/session provenance, refusal handling, coherent UI publication and export snapshot integration remain unresolved. This helper does not implement them. Nine source-prepared controls cover fresh-map equivalence, useful zero-delta observations, order dependence, latent skips/bounds and revision collisions; none was compiled or run. It makes no physical-accuracy, occlusion or phone-performance claim.
+**The ground helper is not a complete geometry fix.** Ordinary anchor refinement can leave a residual shift and prevent its use. Carrying that residual into freshly projected evidence, or dropping it while retaining rounded skip cells, would mix coordinate histories. Caller ledger admission, world/session provenance, refusal handling, coherent UI publication and export snapshot integration remain unresolved. This helper does not implement them. It also loses evidence across a marked end. `observe` skips cells past a marked end, so replaying cameras recorded before the end was marked drops what they saw beyond it, and `clearEnd` replays nothing to bring it back. A fix needs each observation's admission-time ends in the caller's ledger, or a replay when an end is cleared; the patch does neither ([review](https://github.com/SamGu-NRX/BaseScanning/pull/18#discussion_r4111600380)). Alpha's own `CoverageMap.replayObservedCameras` and `clearEnd` behave the same way. Nine source-prepared controls cover fresh-map equivalence, useful zero-delta observations, order dependence, latent skips/bounds and revision collisions; none was compiled or run. It makes no physical-accuracy, occlusion or phone-performance claim.
 
 To check applicability later, use a separate checkout already at the exact baseline and inspect the output of `git rev-parse HEAD` first. These commands only check whether the patches apply; they do not apply them:
 

From 2a337e385e881fbfacec48095b1b0e82c100cfe1 Mon Sep 17 00:00:00 2001
From: Sam Gu <127461594+SamGu-NRX@users.noreply.github.com>
Date: Tue, 13 Oct 2026 18:22:21 -0500
Subject: [PATCH 12/62] recon: free space needs two camera positions before it
 counts as seen

Facing and overhead clearance used the fused volume's weight as "observed",
and that weight only says some frame's ray reached a voxel. A capture with
many frames could still report clearance that a single view vouched for,
while wall and ground already need two positions 0.25 m apart.

compute() now hands free_space a SeenFromTwo view of the volume. Its
observed() also requires that two camera positions at least BASELINE_M
apart each had a ray reach the sample, judged by that frame's own depth at
the sample's pixel. free_space and _slab are unchanged, so this sits beside
#240's change to the march rather than on it. On a synthetic 66-cell wall
with 150 frames the free-space pass takes 8 s instead of 0.6 s.

https://github.com/SamGu-NRX/BaseScanning/pull/20#discussion_r4114128918
https://github.com/SamGu-NRX/BaseScanning/pull/20#discussion_r4115044065

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 recon/recon/coverage.py    | 67 ++++++++++++++++++++++++++++++++++++--
 recon/tests/test_worker.py | 29 +++++++++++++++++
 2 files changed, 93 insertions(+), 3 deletions(-)

diff --git a/recon/recon/coverage.py b/recon/recon/coverage.py
index a04d50d01..950a6a3c6 100644
--- a/recon/recon/coverage.py
+++ b/recon/recon/coverage.py
@@ -18,8 +18,9 @@
 otherwise, so a bush in front of the wall hides the wall instead of standing in for it.
 
 Facing and overhead space needs no surface: it is observed where the fused volume shows it seen
-empty (every voxel observed, none occupied), up to the first occupied voxel (a measured gap or
-clearance) or the first unobserved one (seen clear only that far).
+empty (every voxel observed, none occupied) and two camera positions at least 0.25 m apart each
+saw through it (`SeenFromTwo`), up to the first occupied voxel (a measured gap or clearance) or
+the first sample short of that (seen clear only that far).
 """
 
 from __future__ import annotations
@@ -106,6 +107,66 @@ def two_positions(saw: np.ndarray, centres: np.ndarray) -> np.ndarray:
     return ((s @ far) * s).sum(axis=-1) > 0
 
 
+class SeenFromTwo:
+    """The fused volume for free space, with `observed` narrowed to samples that two camera
+    positions at least BASELINE_M apart each saw: the frame's own depth at the sample's pixel
+    reaches the sample (lies no nearer than it, less the tolerance), so its ray passed through.
+
+    The volume's weight alone says only that some frame's ray reached a voxel, so one view could
+    vouch for a clearance; wall and ground already need two positions, and so does free space.
+    Frames are stacked so each query is one pass over all of them."""
+
+    def __init__(self, vol: Volume, frames: list[Frame], depths: dict[str, Depth]):
+        self.vol, self.voxel = vol, vol.voxel
+        self.centres = np.array([f.center for f in frames]).reshape(-1, 3)
+        T = np.array([f.cam_to_world for f in frames]).reshape(-1, 4, 4)
+        self.R, self.C = T[:, :3, :3], T[:, :3, 3]
+        self.K = np.array([f.intrinsics for f in frames], float).reshape(-1, 4)
+        self.size = np.array([(f.width, f.height) for f in frames], float).reshape(-1, 2)
+        self.groups: list[tuple[np.ndarray, np.ndarray, np.ndarray]] = []
+        by_shape: dict[tuple[int, int], list[int]] = {}
+        for j, f in enumerate(frames):
+            by_shape.setdefault(depths[f.id].depth.shape, []).append(j)
+        for idx in by_shape.values():
+            stack = np.stack([depths[frames[j].id].depth for j in idx])
+            scale = stack.shape[2] / self.size[idx, 0]
+            self.groups.append((np.array(idx), stack, scale))
+
+    def occupied(self, points: np.ndarray) -> np.ndarray:
+        return self.vol.occupied(points)
+
+    def seen_through(self, points: np.ndarray) -> np.ndarray:
+        """(N, frames) bool: frame j's ray reached point i."""
+        out = np.zeros((len(points), len(self.C)), bool)
+        for idx, stack, scale in self.groups:
+            d = points[None] - self.C[idx, None]  # (F, N, 3)
+            dist = np.linalg.norm(d, axis=2)
+            p = np.einsum("fnk,fkc->fnc", d, self.R[idx])  # camera axes, as in seen_by
+            z = -p[..., 2]
+            fx, fy, cx, cy = (self.K[idx, k, None] for k in range(4))
+            w, h = self.size[idx, 0, None], self.size[idx, 1, None]
+            with np.errstate(divide="ignore", invalid="ignore"):
+                u = cx + fx * p[..., 0] / z
+                v = cy - fy * p[..., 1] / z
+            ok = (dist > 0.1) & (dist <= MAX_RANGE_M) & (z > 0.05)
+            ok &= (u >= w * IMAGE_MARGIN) & (u <= w * (1 - IMAGE_MARGIN))
+            ok &= (v >= h * IMAGE_MARGIN) & (v <= h * (1 - IMAGE_MARGIN))
+            dh, dw = stack.shape[1:]
+            f_i, n_i = np.nonzero(ok)
+            du = np.clip((u[f_i, n_i] * scale[f_i]).astype(np.int64), 0, dw - 1)
+            dv = np.clip((v[f_i, n_i] * scale[f_i]).astype(np.int64), 0, dh - 1)
+            measured = stack[f_i, dv, du]
+            reached = np.isfinite(measured) & (measured >= z[f_i, n_i] - tolerance(dist[f_i, n_i]))
+            out[n_i[reached], idx[f_i[reached]]] = True
+        return out
+
+    def observed(self, points: np.ndarray) -> np.ndarray:
+        seen = self.vol.observed(points)
+        if not seen.any():
+            return seen
+        return seen & two_positions(self.seen_through(points), self.centres)
+
+
 def face_offsets(wall: WallFrame, mesh: Mesh, cells: np.ndarray) -> np.ndarray:
     """Per cell, how far a flat, full-height face stands in front of the fitted plane (0 if none).
     Flat: in at least 75% of the 10 cm height bins from 0.3 to 1.9 m, the front-most surface within
@@ -249,7 +310,7 @@ def compute(
     lo, hi = wall.s_range
     cells = np.arange(np.floor(lo / CELL_M) * CELL_M, hi - 1e-9, CELL_M)
     wall_ok, ground_out, _ = wall_and_ground(wall, frames, depths, vol, mesh, cells)
-    fg, fc, og, oc = free_space(wall, vol, cells)
+    fg, fc, og, oc = free_space(wall, SeenFromTwo(vol, frames, depths), cells)
     return CellCoverage(cells, wall_ok, ground_out, fg, fc, og, oc)
 
 
diff --git a/recon/tests/test_worker.py b/recon/tests/test_worker.py
index e4b639cdf..621859b36 100644
--- a/recon/tests/test_worker.py
+++ b/recon/tests/test_worker.py
@@ -519,6 +519,35 @@ def test_facing_gap_and_clear_space_start_at_a_proud_wall_face():
     assert np.isnan(clear[0][0]) and 1.6 <= clear[1][0] <= 1.7
 
 
+def _facing_clear_seen_from(xs: dict[str, float]) -> float:
+    """Facing clear distance in front of a wall at z = 0 (outward +z), its space seen empty in
+    the volume to z = 7, when only cameras at x = xs, 4 m out and 1 m up, looking at it see it."""
+    wall = WallFrame(
+        np.array([0.0, 1.0, 0.0]), np.array([1.0, 0, 0]), np.array([0, 0, 1.0]), 0.0, (0, 0.3)
+    )
+    frames = [
+        cap.Frame(f.id, f.image, f.width, f.height, f.intrinsics, f.cam_to_world + _AT_Z4)
+        for f in _frames_facing(xs, 1.0, np.eye(3))
+    ]
+    view = coverage.SeenFromTwo(_slab_volume([(-0.3, 0.0)], 7.0), frames, _flat_depths(frames, 4.0))
+    _, clear, _, _ = coverage.free_space(wall, view, np.array([0.0]))
+    return float(clear[0])
+
+
+_AT_Z4 = np.zeros((4, 4))
+_AT_Z4[2, 3] = 4.0
+
+
+def test_free_space_seen_from_one_position_is_not_clearance_evidence():
+    # The volume alone calls all of it observed; one camera, or two closer than 0.25 m, is not
+    # the two positions wall and ground need, so no clear distance may be claimed.
+    assert _facing_clear_seen_from({"a": 0.075}) == 0.0
+    assert _facing_clear_seen_from({"a": 0.025, "b": 0.125}) == 0.0
+    # Two positions 0.4 m apart see it clear until the facing band's foot leaves their view,
+    # 2.5 m out with this lens.
+    assert _facing_clear_seen_from({"a": -0.125, "b": 0.275}) == pytest.approx(2.5, abs=0.06)
+
+
 # --- The server call ------------------------------------------------------------------------
 
 

From 706c17ac9609f3684996cbc4b5339502bd6a79aa Mon Sep 17 00:00:00 2001
From: Sam Gu <127461594+SamGu-NRX@users.noreply.github.com>
Date: Tue, 13 Oct 2026 18:22:34 -0500
Subject: [PATCH 13/62] verification(eth3d-facade): probe overhead coverage at
 the rules' headroom

build_scene.py probed the overhead band at a hardcoded 6.5 ft. It now reads
headroom.min_ft from server/rules.yaml at --rules-ref (default
origin/t3/server, the e2e default) and records the ref, commit and value in
build_report.json.

case.json pins headroom 6.5 in rules_assumed. A server whose headroom check
reports another threshold, from changed rules or a private override that git
cannot show, is then marked "assumption mismatch" by the existing e2e check
instead of being judged against a scene probed at the old height.

Review thread: https://github.com/SamGu-NRX/BaseScanning/pull/13#discussion_r4114226410

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 verification/scenes/eth3d-facade/README.md    | 13 +++-
 .../scenes/eth3d-facade/build_scene.py        | 68 +++++++++++++++----
 verification/scenes/eth3d-facade/case.json    |  2 +-
 verification/tests/test_build_scene.py        | 41 ++++++++++-
 4 files changed, 105 insertions(+), 19 deletions(-)

diff --git a/verification/scenes/eth3d-facade/README.md b/verification/scenes/eth3d-facade/README.md
index 26fe14937..586cef340 100644
--- a/verification/scenes/eth3d-facade/README.md
+++ b/verification/scenes/eth3d-facade/README.md
@@ -17,12 +17,18 @@ Data: `facade_dslr_undistorted.7z` and `facade_dslr_scan_eval.7z` from eth3d.net
 `~/house-scanning-data/verify/eth3d/` (it creates `facade/`). Then, from `verification/`:
 
 ```
-uv run python scenes/eth3d-facade/build_scene.py [--schema path/to/scene.schema.json] [--overlays]
+uv run python scenes/eth3d-facade/build_scene.py [--schema path/to/scene.schema.json] [--overlays] [--rules-ref origin/t3/server]
 ```
 
 This writes `~/house-scanning-data/verify/scenes/eth3d-facade/`: `scene.json`, `scene.zip`
 (scene.json plus 7 keyframes at the top level), `bundle/`, and `build_report.json` with every fit
-statistic. `--overlays` also draws the wall chain and the annotations on each keyframe. The run
+statistic and the rules ref, commit and headroom the scene was built with. The overhead probe
+height is `headroom.min_ft` from `server/rules.yaml` at `--rules-ref` (default
+`origin/t3/server`, the e2e harness's default server). `case.json` pins that value in
+`rules_assumed.headroom`. When the server under test applies another headroom, because its
+rules changed or a private override sets one, its `headroom` check reports that threshold and
+the e2e run marks the case `assumption mismatch` instead of judging it. Rebuild the scene
+against that ref, then update the pin. `--overlays` also draws the wall chain and the annotations on each keyframe. The run
 takes about 10 s and is deterministic (fixed RANSAC seed). The output validates against
 `server/schemas/scene.schema.json` from `origin/t3/server` (44607e0).
 
@@ -64,7 +70,8 @@ takes about 10 s and is deterministic (fixed RANSAC seed). The output validates
   probe points. A point counts as seen when it is inside the image, on the camera side of its
   wall, not behind another wall of the chain, and within 75 degrees of the wall's normal. The
   75-degree limit is my judgement, not a measured value. The probes are: wall, ground line and
-  battery height (3.29 ft); ground, out to 6 ft; overhead, 6.5 ft up at 0 and 3 ft out; facing,
+  battery height (3.29 ft); ground, out to 6 ft; overhead, at the rules' headroom (6.5 ft at
+  `origin/t3/server` 1d1e7e1) at 0 and 3 ft out; facing,
   3 ft up, straight out. No camera sees w2 at better than grazing, so w2 is in no band.
 - **Overheads and facing** come from the scan. An overhead is anything within 3 ft of the wall,
   lower than 12 ft, whose underside is above 4 ft. With a 2 ft floor, the tops of the two bins by
diff --git a/verification/scenes/eth3d-facade/build_scene.py b/verification/scenes/eth3d-facade/build_scene.py
index a5cb9f841..bdd7b8c3a 100644
--- a/verification/scenes/eth3d-facade/build_scene.py
+++ b/verification/scenes/eth3d-facade/build_scene.py
@@ -20,6 +20,7 @@
 import math
 import re
 import shutil
+import subprocess
 import sys
 import zipfile
 from dataclasses import dataclass
@@ -27,6 +28,7 @@
 
 import jsonschema
 import numpy as np
+import yaml
 from PIL import Image, ImageDraw
 
 HERE = Path(__file__).resolve().parent
@@ -45,8 +47,9 @@
 COVERAGE_STEP_FT = 0.25
 # Base Core height, docs/04 (What Base does today); the wall band's top probe
 BATTERY_HEIGHT_FT = 39.5 / 12
-# NEC 110.26 headroom, docs/04 (Public rule values); the overhead band's top probe
-HEADROOM_FT = 6.5
+# The overhead band's top probe is the rules' headroom.min_ft, read from server/rules.yaml at
+# --rules-ref: a rule change then moves the probe instead of leaving it at an old height.
+DEFAULT_RULES_REF = "origin/t3/server"  # the e2e harness's default server ref
 GROUND_OUT_FT = 6.0  # how far out the ground band claims to have been seen
 OVERHEAD_OUT_FT = 3.0  # overhead search depth in front of the wall
 OVERHEAD_MAX_FT = 12.0  # anything higher than this is not reported as an overhead
@@ -445,7 +448,32 @@ def visible(kf: Keyframe, wall: Wall, X, walls) -> bool:
 FACING_PROBE_MAX_FT = 20.0  # the facing probe looks no further out than this
 
 
-def band_reach(band: str, facing_depth: float | None) -> float | None:
+def rules_headroom_ft(text: str, where: str) -> float:
+    """headroom.min_ft from the text of a rules.yaml."""
+    node = yaml.safe_load(text)
+    for key in ("headroom", "min_ft", "value"):
+        if not isinstance(node, dict) or key not in node:
+            raise SystemExit(f"{where} has no headroom.min_ft.value")
+        node = node[key]
+    return float(node)
+
+
+def read_rules_headroom(ref: str) -> tuple[str, float]:
+    """The commit `ref` names and the headroom.min_ft of its server/rules.yaml."""
+
+    def git(*args: str) -> str:
+        done = subprocess.run(["git", *args], cwd=HERE, capture_output=True, text=True)
+        if done.returncode != 0:
+            raise SystemExit(f"git {' '.join(args)}: {done.stderr.strip()}")
+        return done.stdout
+
+    sha = git("rev-parse", "--verify", f"{ref}^{{commit}}").strip()
+    return sha, rules_headroom_ft(git("show", f"{sha}:server/rules.yaml"), f"rules.yaml at {ref}")
+
+
+def band_reach(
+    band: str, facing_depth: float | None, headroom_ft: float | None = None
+) -> float | None:
     """How far a band's probes reach, and so the most a view that sees them all demonstrates:
     up the wall and up above the ground (wall, overhead), out from the wall (ground, facing).
     It becomes the entry's `out_ft`: without one, the server reads a wall view as reaching
@@ -455,16 +483,20 @@ def band_reach(band: str, facing_depth: float | None) -> float | None:
     if band == "ground":
         return GROUND_OUT_FT
     if band == "overhead":
-        return HEADROOM_FT
+        if headroom_ft is None:
+            raise ValueError("the overhead band is probed at the rules' headroom.min_ft")
+        return headroom_ft
     if band == "facing":
         return None if facing_depth is None else min(facing_depth, FACING_PROBE_MAX_FT)
     raise ValueError(band)
 
 
-def band_probes(band: str, wall: Wall, s: float, facing_depth: float | None):
+def band_probes(
+    band: str, wall: Wall, s: float, facing_depth: float | None, headroom_ft: float | None = None
+):
     q = wall.plan_at(s)
     o = wall.outward
-    reach = band_reach(band, facing_depth)
+    reach = band_reach(band, facing_depth, headroom_ft)
 
     def at(out, y):
         p = q + out * o
@@ -481,18 +513,19 @@ def at(out, y):
     return [at(0.0, 3.0), at(reach, 3.0)]
 
 
-def band_coverage(band, walls, facing, kfs, seen=visible):
+def band_coverage(band, walls, facing, kfs, seen=visible, headroom_ft=None):
     """Observed entries for one band: stretches where some keyframe sees every probe, merged
     across corners, each with the smallest reach demonstrated inside it as `out_ft`, rounded
-    down so it never claims more. `seen(kf, wall, X, walls)` is `visible`; tests replace it."""
+    down so it never claims more. `seen(kf, wall, X, walls)` is `visible`; tests replace it.
+    The overhead band needs `headroom_ft`, the rules' headroom.min_ft."""
     samples = []  # (s0, s1, reach) per sample seen
     for w in walls:
         for s in np.arange(w.s0 + COVERAGE_STEP_FT / 2, w.s0 + w.length, COVERAGE_STEP_FT):
             fd = next((v for (wid, a, b, v) in facing if wid == w.id and a <= s < b), None)
-            probes = band_probes(band, w, s, fd)
+            probes = band_probes(band, w, s, fd, headroom_ft)
             if probes is not None and any(all(seen(k, w, X, walls) for X in probes) for k in kfs):
                 half = COVERAGE_STEP_FT / 2
-                samples.append([s - half, s + half, band_reach(band, fd)])
+                samples.append([s - half, s + half, band_reach(band, fd, headroom_ft)])
     merged = []  # consecutive samples, also across a corner, keep the smaller reach
     for a, b, reach in samples:
         if merged and abs(merged[-1][1] - a) < 1e-6:
@@ -672,6 +705,11 @@ def main():
     ap.add_argument("--out", type=Path, default=DEFAULT_OUT)
     ap.add_argument("--annotations", type=Path, default=HERE / "annotations.json")
     ap.add_argument("--schema", type=Path, help="validate scene.json against this JSON Schema")
+    ap.add_argument(
+        "--rules-ref",
+        default=DEFAULT_RULES_REF,
+        help="git ref whose server/rules.yaml sets the overhead probe height (headroom.min_ft)",
+    )
     ap.add_argument(
         "--overlays",
         action="store_true",
@@ -681,7 +719,8 @@ def main():
 
     ann = json.loads(args.annotations.read_text())
     rng = np.random.default_rng(RNG_SEED)
-    report = {}
+    rules_sha, headroom_ft = read_rules_headroom(args.rules_ref)
+    report = {"rules": {"ref": args.rules_ref, "sha": rules_sha, "headroom_min_ft": headroom_ft}}
 
     # 1. Laser scan, ground plane, scene frame ---------------------------------------------
     P = load_scan_crop(args.data / "dslr_scan_eval", ann["roi_scan_xy_m"])
@@ -803,7 +842,7 @@ def main():
     observed = []
     per_band = {}
     for band in ("wall", "ground", "overhead", "facing"):
-        entries, per_band[band] = band_coverage(band, walls, facing, kfs)
+        entries, per_band[band] = band_coverage(band, walls, facing, kfs, headroom_ft=headroom_ft)
         observed += entries
 
     # 7. Assemble ----------------------------------------------------------------------------
@@ -914,7 +953,10 @@ def main():
 
     print(
         json.dumps(
-            {k: report[k] for k in ("ground", "walls", "arkit_projection_check", "reprojection")},
+            {
+                k: report[k]
+                for k in ("rules", "ground", "walls", "arkit_projection_check", "reprojection")
+            },
             indent=1,
             default=float,
         )
diff --git a/verification/scenes/eth3d-facade/case.json b/verification/scenes/eth3d-facade/case.json
index 9cffd67cd..e472c939b 100644
--- a/verification/scenes/eth3d-facade/case.json
+++ b/verification/scenes/eth3d-facade/case.json
@@ -4,7 +4,7 @@
   "scene_path": "~/house-scanning-data/verify/scenes/eth3d-facade/scene.zip",
   "source": "ETH3D 'facade' (dslr_undistorted + dslr_scan_eval, research-only license), south courtyard wing; built by verification/scenes/eth3d-facade/build_scene.py from annotations.json. Walls, windows and door are real; the electric meter is invented.",
   "description": "Three-wall chain: w1 (52.0 ft, five ground-floor windows), w2 (11.6 ft tower side, never observed), w3 (16.2 ft tower front with the entrance door). Meter invented on w1 between windows 4 and 5. No start position can pass: every w1 window gap (5.11-5.71 ft) is at least 2.87 ft short of the 8.58 ft a battery plus two 3 ft clearances needs, w2 is unobserved, and all of w3 is past the 20 ft route. Reject is also wrong because w2 is within reach and unseen. See README.md for the arithmetic.",
-  "rules_assumed": {"opening": 3.0, "route_length": 20.0, "corner_allowance": 0.5, "battery_width": 2.583333333333},
+  "rules_assumed": {"opening": 3.0, "route_length": 20.0, "corner_allowance": 0.5, "battery_width": 2.583333333333, "headroom": 6.5},
   "expect": {
     "decision_in": ["manual_review"],
     "sweep_runs": [
diff --git a/verification/tests/test_build_scene.py b/verification/tests/test_build_scene.py
index d2983bfb7..66798f28e 100644
--- a/verification/tests/test_build_scene.py
+++ b/verification/tests/test_build_scene.py
@@ -1,12 +1,15 @@
 """The ETH3D facade scene builder replaces only its own outputs."""
 
 import importlib.util
+import json
 import sys
 from pathlib import Path
 
 import numpy as np
 import pytest
 
+from hsverify.resultcheck import assumption_mismatches
+
 SCRIPT = Path(__file__).resolve().parents[1] / "scenes" / "eth3d-facade" / "build_scene.py"
 spec = importlib.util.spec_from_file_location("build_scene", SCRIPT)
 build_scene = importlib.util.module_from_spec(spec)
@@ -66,17 +69,51 @@ def seen_everywhere(kf, w, X, walls):
     [
         ("wall", 3.29),  # up to the battery's height, not the headroom an omitted view claims
         ("ground", build_scene.GROUND_OUT_FT),
-        ("overhead", build_scene.HEADROOM_FT),  # not clear all the way up
+        ("overhead", 7.25),  # the rules' headroom below, not clear all the way up
     ],
 )
 def test_every_band_claims_only_the_reach_its_probes_showed(band, out_ft):
     entries, spans = build_scene.band_coverage(
-        band, [wall("w", 0.0, 2.0)], [], ["kf"], seen_everywhere
+        band, [wall("w", 0.0, 2.0)], [], ["kf"], seen_everywhere, headroom_ft=7.25
     )
     assert entries == [{"band": band, "span_ft": [0.0, 2.0], "out_ft": out_ft}]
     assert spans == [[0.0, 2.0]]
 
 
+def test_the_overhead_band_is_probed_at_the_rules_headroom():
+    heights = set()
+
+    def record(kf, w, X, walls):
+        heights.add(round(float(X[1]), 6))
+        return True
+
+    build_scene.band_coverage("overhead", [wall("w", 0.0, 1.0)], [], ["kf"], record, 7.25)
+    assert max(heights) == 7.25
+    with pytest.raises(ValueError, match=r"headroom\.min_ft"):
+        build_scene.band_coverage("overhead", [wall("w", 0.0, 1.0)], [], ["kf"], record)
+
+
+def test_headroom_comes_from_rules_yaml_and_a_missing_one_is_loud():
+    text = 'headroom:\n  min_ft: {value: 7.0, source: "override"}\n'
+    assert build_scene.rules_headroom_ft(text, "rules.yaml") == 7.0
+    with pytest.raises(SystemExit, match=r"rules\.yaml has no headroom\.min_ft\.value"):
+        build_scene.rules_headroom_ft("battery: {}\n", "rules.yaml")
+
+
+def test_the_case_pins_the_headroom_the_scene_was_built_with():
+    """A server applying another headroom (changed rules or a private override) reports it as
+    the headroom check's threshold, and the case then stops judging a scene probed elsewhere."""
+    case = json.loads((SCRIPT.parent / "case.json").read_text())
+    assumed = case["rules_assumed"]
+    assert assumed["headroom"] == 6.5
+    same = {"checks": [{"id": "headroom", "threshold_ft": 6.5}]}
+    assert assumption_mismatches(assumed, same) == []
+    moved = {"checks": [{"id": "headroom", "threshold_ft": 7.0}]}
+    assert assumption_mismatches(assumed, moved) == [
+        "case assumes headroom threshold 6.5, server's headroom uses 7.0"
+    ]
+
+
 def test_facing_claims_the_smallest_depth_probed_and_nothing_past_20_ft():
     walls = [wall("a", 0.0, 1.0), wall("b", 1.0, 1.0)]  # meet at a corner: one merged entry
     facing = [("a", 0.0, 1.0, 35.0), ("b", 1.0, 1.5, 12.345), ("b", 1.5, 2.0, 30.0)]

From 8ed76abf315d94db1a884c4f570e0731247bc99f Mon Sep 17 00:00:00 2001
From: Sam Gu <127461594+SamGu-NRX@users.noreply.github.com>
Date: Tue, 13 Oct 2026 18:23:06 -0500
Subject: [PATCH 14/62] docs(readme): show still frames to readers who ask for
 reduced motion

The rebuild and unseen illustrations were animated WebPs in both colour
schemes, so they kept moving under prefers-reduced-motion. Each <picture>
now lists a still light and dark source first, gated on
(prefers-reduced-motion: reduce). The stills are the last frame of each
animation, the frame it holds longest, encoded as WebP at quality 85
(29 to 37 KB each).

Review thread: https://github.com/SamGu-NRX/BaseScanning/pull/134#discussion_r4115037528

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 README.md                            |   4 ++++
 docs/readme/rebuild-dark-still.webp  | Bin 0 -> 37350 bytes
 docs/readme/rebuild-light-still.webp | Bin 0 -> 37074 bytes
 docs/readme/unseen-dark-still.webp   | Bin 0 -> 30678 bytes
 docs/readme/unseen-light-still.webp  | Bin 0 -> 28712 bytes
 5 files changed, 4 insertions(+)
 create mode 100644 docs/readme/rebuild-dark-still.webp
 create mode 100644 docs/readme/rebuild-light-still.webp
 create mode 100644 docs/readme/unseen-dark-still.webp
 create mode 100644 docs/readme/unseen-light-still.webp

diff --git a/README.md b/README.md
index 4de84535d..281572e2f 100644
--- a/README.md
+++ b/README.md
@@ -52,6 +52,8 @@ The criteria (e.g. the distance the battery must be from the gas meter) exist in
 Below, one wall makes the whole trip, from photos to a checked spot. The models build the wall and name what's on it. The last step, the rule checks, is that deterministic evaluation.
 
 <picture>
+  <source media="(prefers-color-scheme: dark) and (prefers-reduced-motion: reduce)" srcset="docs/readme/rebuild-dark-still.webp">
+  <source media="(prefers-color-scheme: light) and (prefers-reduced-motion: reduce)" srcset="docs/readme/rebuild-light-still.webp">
   <source media="(prefers-color-scheme: dark)" srcset="docs/readme/rebuild-dark.webp">
   <img alt="An animated drawing of one wall in six steps. Photos arrive, each with the phone's position. Points are matched between them. A ruler marks feet out from the meter. Dots fill in the wall and the ground, while the left side nobody filmed stays hatched and reads Not seen. The window, meter, AC unit and gravel get labels. Last, a battery appears 12 ft right of the meter with its cable, beside a card where wall behind it, ground under it, open space in front and a 13.6 ft cable run all pass." src="docs/readme/rebuild-light.webp" width="100%">
 </picture>
@@ -75,6 +77,8 @@ Here's where each piece runs. The phone uploads the capture to Google Cloud Stor
 ## Unseen? Then Unsure
 
 <picture>
+  <source media="(prefers-color-scheme: dark) and (prefers-reduced-motion: reduce)" srcset="docs/readme/unseen-dark-still.webp">
+  <source media="(prefers-color-scheme: light) and (prefers-reduced-motion: reduce)" srcset="docs/readme/unseen-light-still.webp">
   <source media="(prefers-color-scheme: dark)" srcset="docs/readme/unseen-dark.webp">
   <img alt="A wall with the left side hazed over. Three checks read Not seen. The haze sweeps away, the checks turn Unsure, then settle: wall and ground pass, clear space fails, and the spot reads Not here." src="docs/readme/unseen-light.webp" width="100%">
 </picture>
diff --git a/docs/readme/rebuild-dark-still.webp b/docs/readme/rebuild-dark-still.webp
new file mode 100644
index 0000000000000000000000000000000000000000..5e9a0a4318968472a4ed862d306ab10ba4c9491c
GIT binary patch
literal 37350
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
VKmY&$0000000000000000050=D8c{$

literal 0
HcmV?d00001

diff --git a/docs/readme/rebuild-light-still.webp b/docs/readme/rebuild-light-still.webp
new file mode 100644
index 0000000000000000000000000000000000000000..4b3479148c1a175d28b1d4604bcdfed777e5d1a0
GIT binary patch
literal 37074
zcmZs>Q<P>ww<VgkZQHhO+qO|@+qR9Wv~9c6wr%Iv_4nyBy3ZXqp7!1k5wXUad#<@=
zgo?C;#AG56kfykZl7<o&QSZO!L?@6uV48X`CJ+H-sw4^0;$r$@mv!fQ7-&m})i3I2
z$EuVhr+hzXm<P<%x$jQzCQ3!1mJisrgI_S(fd2BbY@vXnPt~)b%Rj$rtry#Kb8mG3
zt6#Tze-b`0zX$@AXwP}S6DkeA<`e{qyf*vRf0jPme(ryE*Fe7`N^U<206)isivi1k
z_gBy#_U~5!phXg(XqNEM_t9h0_v{@Q@bL@;04ysW@7@Ate-wR=-UFTt4+TjCJ3dxV
zeU^Wg0)pSme^5UaDGFd;r_NR%5xWV)e_p>|e>`3basu209R<?9;Q*MApq~}vjEB3E
zfF6MR_u9|ygEP3pf(P#s>6&9nK<*FVNASn;T`>ue0)W0yd<5+EEd=;|pZ<)!Kz`kR
z7=Ak5^z|C<^)&j*{k;B6{oH;b1~MK4Rt5J0VgcHp@=x18n%{;`hPQn-J)M5a0M~EC
z55Oj4z2Pxnsc$R5A0YlI3ivm6H30xO!LEQGz_~Bo&pO}};0%b=rJw}WceDM2eP`Ca
zH{msq{1`%h3L!fSmywIj$i-sd^#AjjGxkwCjfC9h51aR1t63ekRrH|z2cx2!tx9Hm
zx41FIH=?IpUIpOH53$~mjU(%S&dD%dtMOFS{C^f08K@Wrevj9Bvutc)NU*ZkEL8pf
zEI)GF(lYDCL0$*X8ho$lm`(|*l(TYC+UC^1=vLT3^6QaUT&n8>tA5~t#}gwBj()=B
zLs_Q>;*~GqXVgpa%@tzor3t2H-<;=K&$qq82YBb3#i>;MQka<w=dwiKXzoAZ$`$`;
z<-)rmd((^A8loUmT-Q;_?#QLiXkN(KmX9CtEzAPpZaxi+Hw2Ugb-;RTL6ES!S>$|<
z-80i>UVRNtXUM?YEryp#*w>E%RY_>b!PI$xVR$qDz!HhH^vy(JZ}KWTfY!cQ&l#OO
znCA)*Q#;Q@w97U8_YNq#FsuK?r4J@s-OB{=YWx=FkK1{o*b84xaHfJrYwI~lX#O$q
z0VkvMi*WcMe<s2YR7;{VL@dNY%Lr#@`2|#$E=*cy)9|tl@0{s-R}!ile30%NqlQC`
zmxWxSdIM=EC(#Tw<iDep&3q3M{FiW(i{-1hNzgQiO`?TATp90a*J2ACL5ue|M6x3`
zd6$qCbRJkt=sO|>vnZAvl8~iZj2Ym(j3U)pgw+iGm(*4h6F8S=BX^WmIS6RDmJ<Q`
zCj9v{1eX6J-7J|}|FCtt>~)~imoFP}=k^=S5eQ^m-5essT!OZ^pz1^c!LT498Pn(}
zUExfyC`2Y|cGjS#<4dfNT+%lm5=1QeoHp$vwg?hnh$BvMq$rYMg?LzVIfVN0Vd5)6
z7I>X(9u(7na4rdB@!Hoi*mz+Iv&Ou==%z#*wnOoqCIW+@*=xQagHlKxXIY+wHn=H;
z5<gOGTef{0dKmEE&^PysO90h(ecfE`y^VI5nX?fB9fg9iNGWv7Jx#_xHkNzONFV&m
zkR|&W$M@skZa0ahRp!ghVhbS{_y_H?X}5&iuUpNB&=khC2Rqn3!>Z#c)Eo*Apa4fP
zr9t@BG}ku?-r~L9B}$#X_m|CYY(!*o#LGxTPi0r!@?gcI%DQN*9iM&Rd5#|ZOt89K
zLZ_b%!K?sLV!J?I#vx-H%VH3`=Y6e%fOa(8HIyvFl1*_1?(Kj7n)`2!@~|5?o&Hib
z-f?9r`MO1W^Zk8#?AT=0R1`y!Vc-T>aKbsxz;e_sfh(|hsN=oboLHz)tBN5(K?S^R
z$+p;M7r2fu(0Jp;2?7qE_u@~63;4$g?|YX*ZoG4CQHnlxbR5~;%rU2{j4+Qh$TGx+
zjAFJS&MFxDvm|8f|Gka>5J%67R@hpR0&ngHc`t!e;};&a0dvG8E4H-k{a-pQkZl29
zz+$M1bviamav>&?3?nJ`T0=q2VP}P0EX(FTkOPq;h+`E6KK60_Vyiy=LHX>AIco`s
znW7+a#LvLAi0u>$vs@cY96X0Tj`c;~#i?7@Xad9Q*}(f5NU><OQG3tAY_v2=myW_`
zZtyR}{#CZaM}hw$F@L%g)S#Y}z0uI$+VtyRiQUX_Mezx&l_koi3f7g+vrGBN1-+>H
z)4O#8&3V%iqe8Qq@_1oZ=rTjE*$Wf-VFG3AUq4(Vaa%r<<zkpgGrp}6g#hDBs8ta{
z)Wx5<h&Q}R<&}H(7Sy+S(R%eTO0#H0-r>H7b^})LyCf;PC~t}E<<;7Rbw~x4s~$}R
zM4~xj(?NcSzpn2;1O&cvyB$NR74v`DAaPsG#0$)`A1s?O%qJyLeUIqNqdogAOnSDk
zFTE(J7#bcd|BILfF{GpVTf&E$@h2YrUmrFzVVQ@Hg{k04)1Ok`)R=s&PU?Y)i(>t+
zoIZVQq2kncg$w~Ol$pJD<@|9c)c56#a~gW`xq>WnlBim|PqoQ08bM!CHa6XGWi~SN
zK$Sq1kBkt2#G^|DA8?-G%{^mqf8h>6$glMZC<{FYMGE(}t5J0lk<qTu-TFV<2S0g8
zRu_y_zzz#tD>C(^d$zT4?jZt%G355|%AgqmC{uP2R=Bk8r@i1-j#>BnF<V^*II}Ka
z2_qmOCZ1M#C#n@WRq^<VpL9lsUe^$7^GV1bL+)RaiOv~226Jb@#4<g*mPn^r?45+?
zP8YlAz&jT_Ow5^ORqs<woV`Yk<y1K{2g514z&-qhuT}cDgJ<5oSDycu+y7I_It_?y
znk35-oi?3p;)i-vL@@)n7dyM-kt9B(h>&}5lqw5WCKu-MA-;6eW8?+%bCFDS#58ur
zJFe=y4{?&Y{D97?2EEY!4)6Q+$m9&gnpf2==6>Ve$!T2dD~DajrDMNd6R&_sdj?|D
z>|gEKq&($7iONw?|0Zo&Jgs-!a=t@%;m>a$;=fJB%q6)=G0U1TUQI+`aOn)y8u1Bj
z6o_5vT*)A;E~B*aCxlPUlGU1z$gG<@`rk#8C81OhM8Xpuac_Pjm{M5M>!d?3;6%gU
zP~)8ALv4u!_k{V+lpZFY_Zq*i2dS(LwfsydC8%8jDZ5s9Sa-qd>+DzTZ8rMq+s-Ta
z-E#Gpt*1`_aoz4C1>q(GGjRmnMqzESb;Vs>@ZkYJ0qzymFHUNiWlk>9-squR58!T_
z%JOlVOBHNQh2NPsVa;ipTz@stvGDuT?Q&ZcNS&y=(V^-B8^zK<K27uC9}R@w(KE?2
z*jO4eZ1**IzSFKW?Zi~q0JzRnKYV}8ivwGCWpb!^AWv8%`h#ja|BFG+{njQVNe@<g
zzq1JS*!8=0n=4GneYOL8@XDp?BRvP%?m`DSc{>q+k%vbvD_wjFIFniz^9LZVGN|`^
zJ7j0{#iDxq(ZhD<N&BnR+E#)0Vvu&G@}ohRGZ-H_laHSLfq8Usm*=w=v6Mhr<(?3=
zL%{KlQ;<G4tSJc=GyMxS58+dX=n3kG0;v-)>==&S14i#!3?|?n{3K?);ti2WRel@_
z+}))*SVMAH|63mA^T2b7B-mQ)yhwN@r#8h1>a2Y1benO#*bCO(^s!%m6!C~w7doW+
z&Ud_lvwon1`G~d<B>nQal_WvBLhgw-wPODZWJ~DYwA%v0rP&6Bqrnlv=ZrbN<=|cc
zF5e}9=dKSKBm>qIHDPO3AK3m|^qm6fz>0{?Y74i+!1;?`7M6TuNMHrCHK8&20`aM!
zR9)^5I=z@YSF-lE#Dtnh4^u`!SzqCkElklBlO?!p?C7db*pkqyj;KD)C4}$)7I&9{
z!dgfYt7Cl|<|b6(Mppa1axQ=3n06>K{&F~%!ixs9{#8nrH&wtS1t7xfm#2nssT-`1
zy6BNN$8#?CE?`F4tB5T6MbcV6N1`C{Vi!s`N#QF)YN>Yevl)<;Kj9*C4CZ*pgK*Y2
z9PAJ&90r%5YKAqOByiwfk)i6xPB;oAXUVn}t^Q)ssB2YuHaJa~vLMGI=4!(|;}N}Z
zZN|{Qij^L_8U%`^e3g_@krnAYO|?uJ(IR&hMb+1LW<vLC9N|G642?(7K+)8D^cuON
z$}<`Jzp(P0$)&K%85eLl&<K!?b+=ROODD-zuRmdUL4lW@r}acYf>ahG<`N@qOji=y
zT!lY8UuU4O`}R?oAdZ&nthWk&JQPCyICmC1ADqywOeHrRNQRsSBb0*y`JB8A=*#n+
z&l~gvea;9e|A|v-=vI;}@ZYF+habp8zsK2ENb7ZA(XFH<cT5;G9OY|$M0J?^1cA+6
zSsE!d9tG8HHI}0eV=9L;z?Cic7ak~A)A^$s8x{UfoGpqT+qFEPyV|dxrc0Xb!4LKH
zVU7eZ>iuR;^`~rdVo=z-7-1%B7GkM-&#1t&;F~<&+WDIL4bB+knH>e<-zj@Q>MbS-
zuWj}?i0($2jleK)AG)i$1ZD*sd<-=K)!OU`GQBTj5yh%g!UR_0Pxy5T-bC&>C8mMm
zxZv$mqLVso36}eLRKY%D1R@mj6y2Z<j`_rqG@I@t>Mo90X5<WM;hy!dmnEnuR?pWA
z;Y>44MiE<vkNKz19DM%i9YtMI{1JYe5b>g;g;S|GU=9eS@lm!P-j(vnKNdPaFF6cV
zQXj~tpZd2eE_{b%x1yuXhOm-<^4={Sv6>YRQjI}>qr@+l5{2E-mn>JCa*!-|>4@`(
zpLgzEOA#E{JvGDs)2#TE{u7H7mMvic{ojwvHnV}y6r7wSg85QO0fx-s$sGd5;{nO}
zj>eq2ee3RL6!vP4u%HN#KdCV*>lcNQ(6$wvhst%GHd=jXHKmzjQ51K5fPO;QFYSC}
zo9{1ioV-YU*u4eU@2TsdQZ74>f~^c_y_k`Lrl;`dqlqixWJ>7VV6jn${DEid)169M
zXouUrfPN~o40KRpl4V09#2`vsw=pBIY?o%h_Yq98Eu9-vf#I&Z%YPN|PO+XFBRLS|
zxT<Muye)_NYyk1uZqEbIuLf<$@RUonO?fFhj}@b{s&Ccy7({6$h)7E?NzsGV#!%)s
z*@7CzCojdOcnKeeS4pcFZ2ZBthJ8>e&OuTc6a#J?Mm?~3fAam7b7u*Ss(?o@^!Tu3
z&xD)jR#Kc$7@wUi>&VOD|4w#to4(?=1O)MI?R0M5Hb^x=<2t<RgZ49QD`*Y&23qJL
zkJ728+N5W{T%I7SdB_I7Qn5a>WI7gq{*?nEaHnsRqj-Q#Vu4q}%Zx1u^5u(mtiZr0
zal3!rx-WCS-*zo7S92^^zwNK-|9~BBFjE!gAMPn&hL2*2yzLwp?_jw&J6=rDunh2=
zbvKB1?hw=pl~POi5V&{?Q7*9Y+VEDmD_$Yiy|bBK2f-Q#vdIEV^<or{*joz(HNwk{
zK7VLH6EW!WeRt_&iVBI?O4O6Yb%u%Y8q<URl#(P}03Xl{j_Nyjlx4XGLH8ta@<`kM
zdQai3U4>V^zv0hy;olR05**%3Q=Bl*KKvyqm?Eqk@IsNTdlc=*MzkhGMv<toB>B7J
zNdd`w5Hvyc91Q+A|Al%MBct{&1$BABLIBKPGHJnwYag4@+w_m%oGX%6hb4YU^4ni`
zib5m(&<4%NOwt5TJ}r+gHR-Hn!#bKt+ZA6zL4*JXPY}*$oINdNefcx|sYHRLGr;Z;
zcAJw#R1Oa5OrlbYieP{6C<(bC>filjHC*V(vSMxJjVgv3^L3WOU8t+UzfM+NN@0F2
zf2=4+fMFkOQX76s6ebTwD3P_J!Df^!2$23v%c$Y+Rpb*@ei4T3Lq52(y3wgXP;BPt
z>Yq#akdEGP4&Q_Y7hUMvP`npeWR{?!dfKt(J5I|qt;*+=l)nh_MoFwZ%A&)42_*ll
zhkar1-$c<pETjkfjZxO^d}^prL?d!tUa?x5^c>aEQui~<>{5r}NBZr-AGvgCp%OEo
z?Hl#5v2adX$nc%hurSE&P56`@Ky;pcUMnH|4B%RSm7Qla@uB*soNQZ{iZhXIR-6r|
z=zCu4o=~o=m-VjbLR$<06%#U}BSv`p4{yqN{#m<YUzO+_DEKFY347r-)4C@q7ul%Y
zRfKT5Qx9Qwk8zqj34mSBdBK4$`qlGkM)3$M6Ij2ZadHiUj-~{s(D#DtME|G3U>*Rb
ziVKR}hiLlA6L+qcIH6r2e>uitZsQ;fVr}-5O0L%+9^n14OZfQ+pTYaLin*!rKW2gZ
zLT&wjx4LgrOlcbi_(arfh*K{KyqEr3!6&<iai9GrV)m14GJQY$ckfK@S&VS+lKJAv
z|7pGdUsHu}=&)@0lw_=dlp=8Jss(5+BwI4d;cpIN&_Ykab6FIQO8Eb@V{Czmhnx^O
z{8K2Ricl5<em@x`RIU`><9q(IVctb0mu%8A<GYGuawKHR6oO+$JI_|NSpOeuXIUXz
z%}g(A8Z*Fv&ue9yIMynIrB4G0=;tGg2<ZPAAg?$e>3b*CX$a5QIXQor)&f3;^Oda}
zl{7OyTCAS|rDrqh4QTg?FSxEGTe`5UxA?&sjmXb#zeLVU4(eRVm|MKZ(JV!~3g?M&
zX@o-Usz8t%OQHUmfd6@o^wX}U%yl@0MuO)ptxTH-h119h{I|I1f($6KeVCQ>;e$Ec
zyAbR+P=V6W<dFZ7`<vF%G6%Gc9sgCFSrnF(0TCQ>$p(ljjg}q9T`l}35Z01TA@vk3
z{p|J2Ry#A^zqv?zYT%hM`N3yBA4}|nP`@(`0=mAjc7XcCc|#%z*Q6T`3F}rx>6iDM
zfJ?>S^WaTD0KO+jv7nAYea(*BgX`+ZatwS)N$^JL6MjA$hc-Hzl0XtxI-|DEu0e?p
z-vYMHCaO39fB6~9<u5&Vw7T81+U0bek3URk`&>64>x%Z1(*Ec@=Si{8?&p`Jb%Eaa
zlo!!kMHrOur=N2<fFDB{RAJ(;3D#-Bkyd~up9g5XLE(*+qs-KVqvVCfx)^R;rP4N9
ziP~Rl8U+jK&O#qTYw9UU>$5mb=hN;8<)y|KttH%__P#;njq>y<UWRkNP8Wo|$qMru
zRgFjLkhe$)la`~z2IRVT!f7_%atb;J1|@f-8JoEJ4=rds$E6Ons#^g`BhX%@l8Tp;
z01Ol7b;x_)zdD!!+P5cDQ4+V;1=t^Ro2v4^FigcE!5{Xa^0%th)D@%g{BuvJFU>(-
zRbG`rc<c^k63D_Q2={{(5Uar}cX%Vr<D~*plOP=Yf9v!{@WNt`hQpho-#MtRk%;i_
zULV^C!y3D;$#rnPw_+w6KS_{#-o@_bKl4GkBjtiR)7&5Y86J`w5T?NVE!vr2JnpG>
z&Bp(Icz!D>nDJAj@nDkQ)bSgxZz-;Cj~2A&2ys=_bzhep@|LOBQ;4DWkR6mJsA7kB
zliBh>3oquOBO4AzAe<IFYXAFs-!5E(|KToEo{O3=`AVD*rxLz{Cr0e%i=6ZLSABy^
zmc^b-J9hSuiUzOco2{bWR3`>Dx7(oK1m54>ymivWr}_;N!VmbF!v|$oXc&&2p@P0a
zo-5<3Ova>lH%D%pjE62~4@QoYpkT>_40ypu-k%FtVdDm=;a=tV2ysO4ZQ8ux;>?*o
zeZp(Kn2NjCu@<7ZQ&&rq#na({a_Qee1^mM)$@TZJb0nB!BemZK?Ww5y>Sp*i#aNgw
z|L|<m*ET<a)2har<X?VUnYJJa52M$ba_X6Hp+OSWj@?q8p=L@d6^1fqP#j`*a(;Sl
z!YUjf1%0Wg5MAd(It?X{&U^MIi^NKS2D3B|#R)Q8rhAt((+M@xAYhF8Vwrr|Gr_9g
zXr{S3(IO_eJ-&Y3=z{q*w#wW__sqQ?6j-G9{Iq4+f6skucCxr6h_KfbNL*}!881oh
z7){ZUeBaIvDs?41FzvD#a;C<HK1vSZ0)M>3+;COGxf+cx0&G@>+W@oYX1-cl2VB)C
z^w<6T3YSCEq||YKj)nA-%cVl=J;;%{e8{@?8`qJn-kPJWmNNUug@MOdE-5By2W52~
z;^KoghF=Gw5pO^wKHC3SqWscTP@fTk*N42l-Rl)uE%`|_YCfZkVpbvsBm>kgD_E8e
zLBLcAxW$3a9h@@7VXO4DC=$ge0{FT3hW9NJM?BbvUNJ%x0Lf_EXf7`NPjF;rvvb?y
z)!7c;^(7A(HHcNhs$pxNNbXm`>n9H50d1+(eS?h)+&*<!H2(E}s5K=08Mxtfz<H{n
zyc4(nBNsw~s=y9T|9G+6w|awB-%bW_keVE<g_w5Pb9s^mUfvYzCx~(?9zG|HOhxp}
zR8ik|Gmc5^-)_APy)2Ri3{d$vS?+}p>?9v8PNXq{(_oXysp|+40P_o0pvJgh2R6?Z
z>xgAld2-)*ui|%8*$;V_frNu$l3}$3<F06(HKc#NDF8Iyr}tB1W>b=YpPqNFciX8}
z>P5fr=TIhis$F^cn06^LS8Y#JcrMfS!ZCuUN0H2PH}V`+TktIownA0X!23ur9t#fN
z$312DF7S5dVK?5SCGkJp{h8}z{(^XS6N4kQY_ZCQwpru4^jiZ>fwt$zgl^t<bh;A3
zMDdM`XciWWT@p<5cnzs=usSXyhQL94ux%S+(dSx_RO_|$g0rh^*}{c6-#U`DCq;e`
zDb{;N9+~Xb4YXvC=ce8D7}9X>@`=+RP#apKVxT@21)H23OY-eZr+gwZH?P1fgbvU-
z53QX{+UTNih2+cdcN!n2niXgbCz)RS#L$MPn0*E=WfP?bu)}FZ=NTu{?Xme8g$ADp
z)hIGuzngZIl`Ca$`=2QJFf+&E3(~Ogu-T@oCS|^@z+YsJn0eA<fe0JhuOOFZSTk~w
zRc}3UZ@I)s7Lkdp{UMiVEveA<zDk&;Fw1NSjV-mnOMn=^duWrl?KRJitrXt#sdX$>
z0x$nUea~(7>M*D4fMsS;939g)AEaqQrqcCLm7Ww*Uk96fd@0&DAz0vKx@bKd3}+&@
z(g_~#DP%JMMXQX|oWpLI_<1Pud>#$988k~W;EtcLx3vMXs!tM#^3N1-kN(o{agHI1
z2RTGM0`H~JKFGq&Q++PQgFoaH)u{~23%@li@xDAetEif?cS>--pny_WhGT2(q%k2=
z%rJ^r_4feUEK){--eWDxpKywC&ryU0(UYEyWI}(_obV<NN$LLmBLoBlj3L*BHJq(H
z&{-kXG(dy?u)+^6PKL~CBEr6IBa)Wb194Xk65%vvap2U2M*Ig@l%Y3RJ@5}<?J(aE
zu0@3Us%&3nwpk^FsCQ&N)uVvDL26jNlIZ4um5ftV!4615BdVdsoE``;P7vv#f`G8t
zLM=D#*Oilur`mmi$;u~A|0!3yF4C=W<=3swq-0NRXbT@Lk8xfOnCKhNalc>O0c8K|
z;;`kKWrbNv3<Evh+JoT{*9#j(S$KU^#cC5&&@itX3S&a+SCce`AUwqjqsbdC*M`a`
z)tKORQzd)1v~8DRGRNp5(@`d*7Ed(w=uZ}~$vAcwH(Hs#0rEVED19ijCNSAqB&$t)
zr)&BtGy^rf`FAV28(!9%G1c@(&+y6958M~M-UwXfjYJ`SMWVp3Ip0e7iMP6SEII+8
zY{`%mbP0o^Qej{#=G}6-028J97v_+JA!q%iD~vr0B~^<YysoBTM1P3l2BIGOjSo!S
zqF)W!JvzdlRzH*n)<?8l!P-{xrF)zHnG}-JF>4u#4sC|G{^Ru2q9gZLS&>!u-eL5y
zWARkG@f>sclXlhf=%4r#Lya8T1`A#OwJ0!rybWECoQe!^706RL2qw;&<P%b6(4bOX
zBB3S~EhUuFzJ!Y5<_=JK8GzHldg*(;=s7r7;wk<k@WzC@(>#rO^Rln69Ns=ut4L^;
zv$?iFO)-WR+C}fw*yN*{(B?tnhneQ}aLG<k^35|A2;?eB)9z2yS{tumCIt+8q^9Uv
z0pEF|xnJ5uUrBq#7Tbt2><bh?It`+RGg0|G>Y>mH_1-!hElHGrwepyDymfy}Xk^R#
zE3K_z!`oC9dQc!id&UkUSH;`ZD`o?AIp(rdmkkQg>Q{L);Q9|D#9FYH*@J&k@kDTE
zq8QNMM(w{|>P%E$q;X@=N~XR5w6C?)h}D@FA_Q2YP0h+M(nZ8i*3#pIcsesHutdWN
zbG!3%OqH`6{S;z%M>AO1Se2ZTO6B5^b<tAEteopvpQ!x#G2R1#fCm~Mb~V?pMoVyX
zy-|d6{}p~x&x&>}p%W>I&vuD=F$63@Cg&$%cVx%&2rO_6Bp5---8!98I9tmgoYoP3
zUV1;b2lCL{JO3E|n@ojgWumd4--6A}hJ|%6CHNZb!xh#kiY;VIHQgIs>B0O0mn)}n
zp6eXN{i@FOj00v*aj&<sF`DZM<z99OUTbt68*B7$Vf~%<N^?nVt0yR3hcR|whOa&)
zReVvo|J+}q-&zy0`@_~9;Om%`7kZn`G-@2eU2|?re+XIy(dm(vLBX7ch+gazE3zZ@
z!_|?CGH0joF|^w{giluGl`uXvJ(2XhNZnW^Hc@rck$stloIQR`;ymnR$O~?j0enH%
zV)pWUy6PydGQ_VpTKOj88%9JGx3yLy<>MvqVAA}Z#*tKH6iFA1%`<r19Cy86Ng45d
zlTLNHx$OXt+4&c6#Aec0MvaQeTSL<m8*vB~Y(XC87zq6U#;2w66}NFae_K=>vAo9R
z#d}IB)P~k{jLGp?dR5J!&L<C@MVLwm<xx#rM1m2^$caiMb>!U0{Ps!HX$YA=u&o?h
zo<Asst~@_l*HvviU~&|tFF>QHqu#67-Sua4XL`cvwdO5V0~xQe@%PEDQl|0GWZ1ve
zzml8s{IL4o6Vi=JNQr<5)uY$Ci}|8&=}<s}zZI#cWS2agc;~=#aRql)HUs~uFd(4P
z6lZ3YTmH@+pMWTkP+^7;^AIWAm!kT&x;Pr;IJe2%B`!WB$j>%Xve`UXz~gMgu^%T2
z6j;Q_R7(Nz4e}qT;>o1HV)0<>B>BrPi&PBnD^&BZV{U)-avVJChFb&vTAgoXS}WX@
zOxNphu92Z{>5z^aNKy9`k&X~~2IB-Pg9Y)-FJuP`Y+(V&%+>buAD?tL4^0&uaANkB
zMP{LSU-n~V%K{7GYrBNqZS|8aWgPGrE555yxluuC5j(1hIM|I^h?g{RNEX2{VHVs|
zA5u3PwLgwv8|%l4Hh#$XmSnRUFmj7g(M24V=kTxl@}8$}D5Yy-ZjZuzR6UkE?ph?4
z+Zwj2RSN%dsSZg}s+cQzzX^0*(@NrNj~00i-V``9%V!onTyvC(YLzG$jtGmswwe(C
z4wwOIk(LLbUO2=2T>EB#%HofDUOeQqoOXgq;|KldBLB{+8atgjN)_#CkAm`uJbvPp
ztH{0Kc{6K8*dP%=YGNL?)x<mCcyE7K8|`^h*6?-;%1K>Xlh}B}K^alb$Oxx}UP}tI
z$`eQp5|npI{nl=@lSHW11(2<)M$i6M0JebL%C^A1L&cJ-Uyw$WVeNGqd9U$WZJV9g
zXmM!xx&x<AMVzJohF)Y%QW1qqOTIW3hK4XR#0UY>{E)~2Kh2}TzUlVoPspap@Zn_=
z0#2L(Hf2;=>~^z4$g#Rbg>1T{GOAHagGMDUk1YeJl_j$W#W<OmO}3M6flfT6VJZn-
z*qxF6pi>BXOuLDPg(uZkkIIE6deYX6Ryq1Gka<{zzWIWlV}=e5Gq1o@r}!wn@NVW2
z5E`>M^F$Ke9mT5WoE-P$>D+Q7vQ3z_3Z>+4by)4(>%nWdO#q=zcu03)JISWrSRlHa
zH;n$^Sf9Syt2Fju=sM5R2BP9aDmX~sbJ7Uz-eD?ei*mcaz?X~%@Y4FADWHhBFnerB
z&7GynRA?)LGGn;9bU%2{HK-D8StZOZkq?SN_)~IYbt(V!pvx&}TFAc##04q(jY_pF
z!@4g2X_y+)&D5pDe<KIfA+(o>rC)n*#p<Lz1&$4{N$0yb{TWAGKP+J2*8|`maozmA
zq5>2;;PX-;8aZr&8kBrVySWZBw5%kl=)Ip)m>#PBsNwUB3qSnm$KOa)y9LHYlY?w6
zR=QY`;|5#@6^P_x_H?gkP_VB@bf$lN&4DffjG`*ed3cVj%j?!d>x4t5XN>OtNcNbP
z9<K!I;^L&Zl^9&3p;;c|5obAF>DSWx9!O8>TP_(oZW{Db=nnUEwb^<R+(AI$w3Y8v
z7YXG+EqaUOB7S3JVrBX*5G^b2wj4MPsDt5EhEkb%r;~~^Qeh#ZhIoM@DqkDYE7(;z
z^0hm%FQ~hWZV3Jik4F8ys>It%bb32JhEWzAWJGT!n7p(cN}})#BcwAuM6c+jH(01Q
z9?18W-?J!3EkP_1rl*@BI(_JB{>BFBkLb+aF7ELb-N;YK&q@n7)a~$xKTHZQ4Uegv
zl1QSt?09A4wO#VD9Vnkjm8+J)8vaK}SVEX|`?i9=QR;Z@T0~}r_t<N|f$@A6V$*Se
z4F^-XApEIyf}+n!DK~7ofKNATa?7lp*kn3~IgmB)o+vy0R*JGG|9;6(H1LLCxb}gd
z-$}^`7~FZ!)F{SmtXY>$xl_a4fb727V6!biQh|)re@}lI@iEr;MVVa6LYn(gz*{4C
zin0<f6T|O;vL+9kTi;|jl(E4AMS^C4EY+%&EY`JY#f~|sBl2|j%TDCWWz@>%SJV)a
zw^3Z3#^B1p{_a4?SU9U%Dq07^iqR^-e$6~m(x(0ce=b$Hk+fw3-bmVCm_nknUo8+H
zgK1QaUP9-F8GRtaePG}-hByXoy%i_4mN_5>_0A@nz@y{V5P!av%6F*wD(8xPc+gn7
z(?aWA`&;<x^;cMOodE_*H-N<#X)Y<DON?V;484nFLov5S($Et=Nc#La4B&?|sck;G
zdXD&wz2_53w5ptcL=xuv_OwsSWDc|_C0fVJhk!V}BtG1=v=VlSdV0&lVeeI{<{G__
zpzy5puIDGM*7T)w(dQ+CWpQ0%oWzT`QaNw2$M0Nb^g0>dsF^#dDjbUO*Gs#TN5?e2
zDuXp>;^d7su)pSg$;z4(Ha71(Z?tH1cRefT*6aa4_t;fG_BavfvMM{_-&vUk&5puh
zdX=k+B(Z!)^mG-P?IWFK&vswx_31fRR=!ZY%w{7JSVlG5?<YUmCbnPk@0N{qfZx|c
zHy(luBk~*a@%3ytjD&@LE#Qgj?ozUzR|#tgk`|&f`72FMHYjhrrs_(NAtVz5MeXae
zr4ijIa&0qz<eQPD=T^}fjpZc>n2wo#JDE895{8am&<M<o>w_%!Emog0N0{q%aMj!^
z`Dgqgx!D9FKiu<(RfG}jO(((tPHbP5-$)8$fJo{$lKMUd;y;z`eL+@#J=@M<CI_KB
zlT`@8fI}OM%fMeZ82JzvboHLUW4AYu4|(^AUiR|EE7LQf*-oHT&VhnT#{YKXplZLR
z!_Z4)i*~jo-q~tUO*GH7!0l)k6geQPWq8FZ@*o++Sk0TR23b_paA62+wsOm2oKp-D
zatobaBMM*ikm*b6WszlQl?px;k}fX2fXs#cT#2E+XQVj0;OR7+<5Yb@rY10s$ZoO_
zHFy2yAFgAcaKu|8=Y+lthxj4rIE^8D*wd^ek!{Uu0B87#e4z*fWL=)HMuPZ|MxfHw
zcs!Sjak;PJUx@Lxotvw@XS99=OnyiSH)X>aYecp_^MYvN5B?D}>7~e5=^NpdqCmY<
zpOS}CkuMhZMp2PvPgFJJO4)U4B>J^YX8_N)+xQy+*Bv+G3m7hi*%}SpWX9n2>=xc#
zj~?ue`C$rI)gCDzWr}?rJp##nYKK-A?2irXf~MWt?am`y<XV7xoQ-c!@t5nW_}g>1
zl68E}HkZRI?O^&-)0`EJHCb^Y7r)O}hzWZh6}br-tI3wC2=<QwTzw=I4E&ndl+j6|
zD|YpK1z#1SD7lJb_31ipvDdssf%3aMoLcZp@e<W8vP3o#<#YyjcWl9EqHe=Eg9CWp
z)0I9-m@FQEIb|)sadv2CC<?lT1Yp;_tvC94#F*vJqQJKWub`j6Z--@b(piEhU<74#
z-a${bHezspj!l1nZztgWd<%|XBEMkTmi!Vuq#d=#W*vGXq>3MsawCP~mzn0s7+Cpo
zj8a=?dPTMRn_?Un(xkvwpJBGH)!g8Sm7zZBBxrf$s>b?c?;x_!&-LqIzQn$9qyY4(
z6dLKa?lVy-ihzsfQcXo)4mqWE*dK$M4hOW$$oru`>bkP28GvfTq-QPA|JG%n7X=(R
z);^zF7v^7NOqIK-w*eQw2LuEMcb;~6P>I7ML}aVJm&2Z{1FVjCUq)~9)w7kZ1C?aO
zoOTs%{I8R&dv8iB9aFnL^nOd3(sw3kJ_y)Eu2lg|HiFmRyYuv+PQum4=;!$1#?fc;
z81XoTx8Nrd7DKhtxWu6ub!Q%ma!E*V9E}21QOeemRlgOleY>TRIu~+^E~}F3;_H+H
z8La+;MV?DMU<^vYWHR}-i%5Crxg&`t)Aij*SAEp9I2B;J<uLg4P|??}K2#$BXI+Gi
zEDf&4Xj>!<B@JzyO$}jn-pPi}#%FP#E1PzDaKocUp&RXZ<cCOEEV3WfcRROnc?FU?
z=N04$`W{6tiP)OzJRQzZ2+vYgb6bWAZpIelEx5+;aCN?JFbzIX@GYr}5zYg(t~|}R
za^m$9nA<!~uTs%$Q+yq`BPb(zJiGklAkxHDfEbZq(;PzII>C?@G5q0G>FNIGDPZs|
zpC?72r=dJnlmUs*U}j_ttBa;X=P56J(^vmf&8<yA0YN3a4%9hD|Mq}Pzc~m*gB{gS
zpk68*`6*K&ID(4&$-Nuvj7a7QTytZtrnCAy=K^4OH}78YyMJso-<))~Y0FA!Cuc|M
z)c4(2LAO`dt`b6E0R;la1jPd0&$=h@+WiMvc@ibX29L1+lhR2pjbH*7*>97Gsuzpv
z$Hm<Fk@HR=lXH8~l!^+wyr)T4k0eorMe<s5=QjK|azDOE;PC>l=03CpRihbn++eaT
zQqVvtFpg|FlAlP3G#bR<hI>ljzoHEUDaQwd!lAnnRriMucN<t!m?&XT8D9*6p)J)e
zTP{6?&Sgh?I~yIY%n#4xC@Y}&u%Jeyc@Eb<2p3>qWeeXs1bhgl*qU{r+jWrgzV}uz
zNtNsQ;d_PqbVDRYtCZ-}-O@fBIeILf&{=^zSz((3>JT|nXWI?uL|s`g^7Xyy{O3G7
zDxhOEgi%`f^|FfSyJ=34%--E?kZq37M;v9>^~6_u4k`1!_Od#yAtRp${Y8KGQmz#3
zq<9a^k#$JdFna|FS~`|Y%mNh*6IJk>Y;9wc8LX1Uk-oDLKct=HzAFkrY{A-dF66^3
z65A54ST(yMn)hU9zq}zwiU8lG$y2+&bPf^t>brM6rE|IUK7VJ0ej$(-q3wS9);#;C
z%pBUuY({?@q825ucI*y3iXr1Nb$tgSZqX_RlIuW%Rf2TeKRmg8jnFy9*<R>;Cwt7b
zCTPlR#VUbkbU&y}X>U|uUDTCEh%wX#yc}9TK(7xa><%T0R~<h4hLx}r^C48<P*Rk9
zb+Z(DHrImUaz1-k13u?y?F_EB^ZcVT=QL<D%>MfV{DnG?C3&skp#v$ZwwCW&R>VH9
zHOSXRp;mA$ktawo9c|I1`?1+v@J_O*B#nY~okYr%0BSiBnw#R|#J}>yxST{%6#AGB
z7}=k`SG~#u>AQ9=x#iw^r(<kag$qVPNoe$O(fbRN<i@aDZf{hx|5f<7H6DyqVZ<24
zF*(#6z%dgyEj<K}gO#jGLK@a06;k+pAe3vPtdvuHBtp+ZUnzcGbJcGvZMH1zIbi)E
zwl~}v8WT#99@lZN{WxUUx4Dy}e>Pr~YHM7ZUvWdk&E<h^PxBXzu|c_N-1`J3jkZJ3
zCTPDHEmcXEH_3$^MSdNiJuQYt%XD@Bnh7QjlU%CZ$Ru`F#Y4Gegu!hnK8eh~`cBIy
zw0g$O0b`3i=tqbFylphFXir4l#+W~FO9K>Xxns0*COJ9Ef26tQOM->1mA`1i*;;)f
zRE*NbciH;@O+Drw2rF##NOpTlbNyJdg@Sw}<q}zag8K@o+S<CVmJMqdfq~RFLuddL
zp)|0HEHt|!W|%O+xa?v3wmf}q3Zb}e)FS{C>8sSyNJ6VBERR{4tne7;mMHU$LRO73
zL#h`Qj|=x}UMvKO^*tX!=oCFMc1(X>+v1*RMBMK~g`2nyd6d06e>w8bf-ABh0iC<a
z=R+Ur5#x-nk3upb>(r5yQR=$sqOB;&FB<ti&QvCjc^@us+a2y=3Q#OpZK=MbCXjjH
zIi*&Qe5QSGDLIvOeVq6H;9QY>2vN7zAr7G9RJUOOw%uQX2-9APXK|SIXt)fwe~)IJ
zsWvZ9&*LKKQd_*<tLT0pTs7KniQFQR|6L%)%RJ29RiQEqt|_5Z3ekjH&6!*FCP1}d
z4}yFuvpuTul$==_;t<Ccs@H4HJN5Cs8$s|L(y%LBt+J&N-m<CDWsp^o%p**tm^pQc
z+TJY~c?m-!qw;9xxeht5F91{$Yx!G3ne4TT`iv@7xWLCc1o0?gKQ`-Je}l#aAr)A#
z<|v_i*qX!x&ulp5!mY~*Gh&{ptsz=wQR&csSlR!0RnJj)WZS{Et)NgZ5C~KZI0oUQ
zxY3<pJG!#IpO9dX0n>|#LN2od&481E!~69iI?(x>)Njd!FhR>1E@U)Fhkcw}oEwH(
z8LDG<)qg%N^|+#ngdUup1o|DWvfU2sr*6siIjij?cmQeHIDXy?4(l%H*ji0p>enap
z5Y;VEb9|9xS&<#?W@`xkZL(*TkWIas`!!hqR}{5CJYP@M`p%MW=yp727H$4sl*vL8
znYu{wuNF=P0?TC|^ah8;CI&K$@tG*PV~DOnt%2^X`Z#J&SBUvpTs2vav&N=)Qarvp
zzvro8tH0=I(*y-QbTK_ZnrrNG7z=G$N)Mn9@!y#HhZNIX7O@%y-7SCuq=Xw#W}umw
zBWPkn_ca}H3yf{rsz==T=AKA(8n6dLThL{FA6pYsO~IqkUl>$|iO&qWu(2U^K^=7O
zu$mbi!q$o1)86V>Xntqsob0#(0^)Yq>;wqfD?JV^<0AO*g}k^~oh8Q%@A^KTUeev{
zyyZBrnT<M0f8*BJ;ybkTkf7OLVI(s{=1NArEMwA?MPzZ)P++r=w%iY@yIn6m-iLEf
z`5@58YkK>kCW^3ONEhgaNPY>>1~e3jaJfQhan7YQqE|xaE}SC;)*iV@y$EBM7qCGV
zERXkzbedNZZOwBL959%iC0@Rg_UDdT8fx5%uaoiIcoX}UQx>Ip-0$FF+K=I5#F<|1
zgop1Pztqh`EL7htrG$(AR>ja)`OQx(g=0VD1_8K}Z(xxDD|pL?V3ogM!4v5#FRULM
z`?V&N;AK#d*SqG94==H~f&2nSZ&JR8SWUhfhWC_$MPT~WQmUa+maBW-Y#`j~08YOa
zW)pRX1i7N^M~j%?qY1k-K<w9@wkoL)%Dksj_+d7@&_{~9Q2_Ac2rEo)*v<M)uS7U?
zW$&!lt{Q6pa?mzF$|1YNZ>Z4)R(9}HM$P-i?rn4nQzp8p|MvslaHfCadK+Q|TH7$q
z%Y?*>K9NrHnO#{R3};e9P}n#E=Pa}^B&XMM(KFl77`)u3pi~pVb5*G1Fd`1(_fNv!
zpokuhjphdg%#QpN#hnGdVhbrxSFTl0i^u}AW1I`CguW*H!)y~9B`Ovo_oDVs;U8M8
z%^z0x`+QTX(a8#){=ZvJ3`^N{_<a6Q({(&H48F%!R!KKhAL6DMd}_I}YN5`nsL?|a
zdZdA2QH2KhlH8O6ydB-213*Vn41m@e=@_qsvAl*9MPp;+K>N<z6C!UL0eqn`(aOKr
zNj0Jz4v|e2gz%-tz`TqeddcC&OMln9O=_TsD2W$^jkp=omIq7&_Q9>beYYV#hG^X&
z!NEqddBneoMCY(2jNb>M2YsV)58BhM1c;>Qe!;&lbjo^~FUV1ucJIBqhwAO#;~=N@
zRiuvW-C9o*&Z3R_D-XSK#v^t{4Le1ZzrV2@L};O!31aA)-t2O|e|wPjyvU5}pM`{z
z2Jsqp%ukI~0VH(tf9Est>e0X6#9J)xBWMhmiSgD9wK1(31Ye_*Qw$y+NT?*zlQ95s
zw$h%NB0o^CBUs7Zf6*01BRh-sr4E0UHyil`yb_Q8y@+45mcFX|ni0mk0Fd}869gP3
zkHou@%PEq|cKJs>vb!=L9D#-eDy&R>c>-|tC(Sf9Ncd|oUGy3pXrTB{ht&bhym}iq
z#nNZr`D9|ytB|tVBniq=t2hF!z6yl>KH;z*yQraymmmrTGdn88TXMkh;Tw1$Swx4B
zF6J(5a&bg!M+9f*F6Bfc3my_Ox3ZlKOAQdFfG;oqTrm7!j)#FTZyk0mTah>5L308V
zrRl(<VwaARl+HGZs*lNJ?}jy;z-AZ1CejjFPTf^c5bmXN{NCqcxc(KoS;mk32t!P`
zGY*+J?#FDWISE#jn0lBW?lwdoExTK@qanY5@%6AR%fdjwHcY=gn}5NuD;FXqK{+_;
z0ex##LDIdfC?W^v1Rp<lHY|rgR5|@gIrJ;3e;dQ34?=9sKs-HsX_$!5hM62p<Kb|{
zQYk@A8Eclpbj<|zmAJ708jt&T-(n~XXAn?Tuyl?u&vGt$e`p=2d*21sureRUEd~q~
zDxF~Pp;emqtfz85$)&@vTBlc14YYPOZa~A%+Br%0oaHbxCPUALdHOd&Tg!QAOJtRb
zc7DxsLeSYF@JLwAno1)NHB62+0#^qKD>}Og^|G*{B14b<k6Z+cIoQ8TJvug{vbPyU
zgOJK@GUoxKzmNh0-nSSMcZ4fMoft7dscnIkPSwzmD!XXegZ8w;C9@;5r`|CYlp>ap
zsg;?>&tPISYG+<rKfi1UNN^I-<N{Y_>nZQCQ3pA^(&acXjOI0V_mp5wJG?S6cXl+V
zjaAmVtFuF?O3Da?S(*vEf*Yr$=zq35v(F<|9gN`WOtfxxbJe(wfFO8)CPSG-%Vh@<
zg0jG&dnzsiB!|@~szON8q>TVt*R$EPvSvI8Xr<&Yp~y)qJ>N#5&On4%Z6uu+=?i<m
ztL!#QV=Qo8gkhWw>tEm`^MWy)I~@6+sV-AjVQ|9ihxDG(oLtXi^;kq3=;k$j=p0Uc
z9Ajxvq5{WJU#TC44k`@hz@aKSjQ5>@nK33{pzT3QX_Gd+`gzI@6o30C>I=~{w_67Q
zo2ZdD{nmCC<R11<oC=*KD;T8pa?xESdr2qj$`{a1*MbUuW?rsf7_bIZ>_2b0_;br2
zjVJsqyinHbMYB-M96mZ!&+E8`Fwx^Wp`JhUYe&#k06mFA=5kl0avZjt=!A^Bg_)mZ
znE_lOo1dmp==tOpZ%hqGZguVlQi{d0rJj<y1*O~0FKEnFQz6qruM@pgcF#{Hg!%&i
zf&aj$lSMeAT#W)5gJn%$`NBdNVv`-SIQzBGht;ye-CS40Uxw<wDz3-EGHikinKy>H
zz&AGg%-wK9>!;|HTT-cvUAv8!Ox}d@Ss}Y`;Y2@Xl!##{_>mu2*ny7ndZwZ#2Zj&V
z7KOOQ{?sgD$sk9Dw61@Z!Fr6(K;_2#*u-GInkLJhdd7eIyUtYRs(x3f{zrs)Yu|9Z
ze9-4ns$@LHcY}5%QGkSFlP5rz_-Wh_0ri}n>qXtO=G+-!_PyPPlDnZKL!eVAdG*$k
zB|$T2-=gN8cp$B=z0wHI_gs5L8Y2<f6*TQV+ouT3g-+vaD~0oO>{fe^bMF$=&I;L?
z_rt4f21VTqFL;>&PRODg^sk;vnur3ImePUJ>3WN&X@ip#FXnUJW^s)7nwjf@eAIG}
z_QyCbrC^JQX$9Qbo+`xktDl{or(L0R^6%Y^+zpKmZP`SN_lp!T>@j3pj3$Rid8mIK
zMks44Pb-EInSckf>wSn<7b}?5zVM>!NYd#8g(@l-MWwU1EAA;%UvAM~AxQhf!Gi{O
zjE`gsEV~)|sSbIW#qtR2J?<g=uQJ&YX9jtjrT3JAnkNh`UWiHs{3M^No(><%n}?Yi
z75-CWV0<F5ZyAv^IU3b!Ukz!zIBZmo@&E=tE!G_$W~HB8?d_#dQX5N=U}H;I2nNgC
zGVU<xu;D34Vxkj>L%u}HxvW!{q1)T}ZGgze<LW!?^j~+XEITg^xbaNAjsZE@(0l!T
z)8^*cT>)nI<a(N+((5pM({_{?XqW5k4x%_BgJK9N^x1GO!^w{-;CD8jLb<afZd5ju
z-^Shr*~3EaYov&v)_fo*rS{CeJI|huoAX856;vBl+!?;EB*`w}DeYhql&D0;s>~;^
z!12HIAWVioL(}sMJN(p+Nle$sc|1^<1I<k`{g_)(u_L6~!vGVLLYyWlH}n}qrovVm
zH9aY>70wC}IKOisXOg0ncfjUb`%Jyl8(8WI8%6AY)$Ppkx#u<~yz@!cGDM?#j^UH*
z2%r-2LES<!$0_QAGPc}JLW-6GOq#yr+1#N!ZMo1!G8vWwWwat6hu@HZfLNq5jqG4R
z4`S+pfWQHjUbFb|0oh;I!hIb%a-~)<QcfU1;B3nnEz+m^2zvqDUc93@cSiTQT}tPR
zHY~*pLd$VslFKW`<!7rn6NF%w?x}5@BNuHMf8W^X)DQhOAFG<>&J2DL9GjyuJ(}?h
zYqV#u?p(%q<AgNuSe8U&)kQAhk}}>P?d)5=piO~YU}gOR9}T;9#c_ETm3N_%Uiov1
z;sOsz(6tCAK19_Mbs}&QqOnKHD~g*AqhD@!gQiu8F+E9q(2(|Ew9`E<zqnEA2g%#x
zihRs%A|g)!+eu6j>g<_32JQRwgPOUf;hcICzNld#Ivrxu=)5&V4Ftio?`6@xY(=JH
zV!m#5pmh|d_xxpoDih#RQT)*B%wH6IGT!mG2J+XeAdJU%4s5ryVNdA=X~bz9chBJ8
zm(@lo+YsEC5r&?z2$OP>1k7tp&}1d^n}@aV<KE*Q!FPSz2o^*17>wiv6Iwg3+LxP0
z4Nxh*Dfz_%%8l6K#;`R)V`>&Rr$)R90-R%UATQs#<7H1B`t9}3P@lyY+y%Z3DXT|}
zyHo6*Z^NA2$XKXMlerA~!xajamay$P&R~N($KWeCIHSc6BT;yUpkL7swN3T($!K06
zdzPhe%ZW7FAU2x#7-r21Zkb`$SRmSXrW};srP*z<2)8mUzZW<<e1+ek?Dn9qxvw94
z(x<wcT?$GTIm^{{)g@r|O>-E45P|*d-m1^?MWul*Q=q4fTKw>4!E!`mT$lzd-*cof
z4-<O>Wy^v0PlDDYgOyO~=KpM9(&ABw!~F`*Z=842&};y$o%a-6&8*s$_@OLFUI9>-
zQMlW8_nE*`C@GbW=l#dn0x?GJ3tn%)4DQIl8FVCLYTEJtojN2>C}V`f=JC8)<7bV^
zo!V)rd%LMIo8JVN8QR`!&$8|tmD)njixc4QzKk@2yGVQQNhu2*?mmb<t3+<G6ZBWQ
zB>fe+8|&tI74ID3+en(y#Z8)OCF10<Rv%^Ru?)*v<J81dn><`XZsB%|Uxd3POZ@(a
zL2VHE{H)0Wd(31*&TP86aHpZbDZt(>(mzam2y&O1LUUM=u`%(iA{*>BL=?~-+1QLe
z*)pwH_dKmF1vAZ_S;0B@q&C_pal9uuW3SqSR50z2=T{Oyf)nh-oGG&(W(jgP6-JJO
zykMzrY7{@E^%Kkr9z#?GcV82aAP9Z8l_Mr)m=aLSZrH|M)Mg+YG@jf=?*nhPJ#H3_
z%Oegf^WfaK!3mII7fQGxqp#pzl$zZ5UjRfvyT5Rr4NxDxM!g2g71(Qo%fQ=Q-Q=<0
zU5m`{HNbh#SGekfU@n32U7H*eXPj@g(=6UdcIFSw?4)Vv0lpM{_lTsY)g<{_KY{_w
zS<O(Aqzu)A(=R#3X@(Wuc;atSXsQDFpr1ZB29yq<3kuU~Cj4tPyboxpB2V?*!uJ_F
zC8R%uyf*eW_+pd$i@tNi<Izj2`NfE-zVV|zn(EMuN%iU4D8u_+vZhihF<X~HxIM^1
z66=%bcPf`4VrC0;wblzWm!nm3nuSMIba(X=JlSMPKd`{=H<7LK8&oG$7PY$wq*Ek<
zhAqbYq6G{zrc<FdrK#UXWL>zQ^Bl4i!(yKE>t&#?+q!Q|**REv^Opl1X^R{LOm8y{
z$FF|e;W@FT0Fty#z<DNq^s;|sb#`*c#9Jj6*IW8NuznA>UxZ=(?QXDIGV}8UDHOT_
z{{XP;)@w;dtGX#+U1gn+&S)ySy!WkpgY<--HlKM+$yPB~Q&bn<evM?6Nct<aWLn=1
ztBv3uTN8s#g^1U_35x=Rw&vi}Y-K)-p<8WKkJgerqPZZL#_r$5g+#{8U9m2|69G3o
zYP3+=KByY@W6GZx9$EiZ7T-Nhp+wJKB%%H6had<_?q*S3kzvAZQgYB2Run;vlWkF|
zj&58JmhztoLdaE(aN(dFC@ODbk2a{zyb;q=WfF><qu4|fwGv>krE7RIqGPm+UqWkp
z_$BjJ$4K-+G&~3By#JRed_mZ9wTz~0DY1`LL+K@LyT)e^P0DI%50HHoCgUcgP4spJ
z1h7|>(OTV{`2J|raa~$0s87{r_m#K}$narB1;%lfQxQ!OhB32Yojwn#<A#b?c+G~K
zD8xx_JZChZuqPd_<<7HY+cXs|&N^{L(7jus<?~vracSH@q0c=FY*}Y4Tn%Db(O7T4
zX^*5)7bAlMHWy-1hK%KA{V;+7rp?V7Qzv#VWIrZfyAiaEGj664c`sq&!k8Tz;KeC|
zRNc8c!Dg_&lQWnj3=ekU+w~71KKlmaU~|Ey0u_#g-=UK7Dm1I!{cuRtivBsEjL4ky
zZf}A~FjNK%BHyf_F(t0tLRfgrHg6-fT@DnBa8%V6GTr+PGyip!N+nb=H9en>PnT)P
z4g1K9)(Uu7VGOdIqs*0R5XKwgLyd1g;m<D{r=o0>@xAcTt*5gSG=$LdhyQjolyP76
zH+1kMoxVH*FNw;k_Lmz2pg;Q}eV*mp?{LS370O==MpBBg&^6~E8!H(lnTuty<k_$Q
z0J`@&(7A(-LV+8kS?ih`Xw4gdfeBzD5rc{OtERt%blT*Aq+Car;79e2MI2$3hlpk)
zM*ax6d6oK`s%q(@K{BUxMN~o=>~9=(;}PP~3;7x*5fdY(F7?04p&#L2flU{xy?n9^
zsNZ<)kG#-^RgZgy^fz+LWp6EH4_h^~9`M7tMZtecRy!Kch?jn$w{!AsQWg3+H`02B
zBxW=m>?iv_=*jGPub!4^Kag=IONRLTGy1wR{D`sqK6wm3@O$~M1s1_6z+k7=-*+g;
zSJOq(aX9vh*ip0*G9pV>Ky`6<=O*c_?WY<AzwJ~0KVw)6_XaSe%}=phnLcFfKN{+_
zLScNWsskzm$5pl5E?wcErNSsshAa273s^6M8myS+<3?N7)u5_F&MW&y1*SemGx&n+
z-Wd}Beiu#MK~|2%M!7?Ap*UGh{L^kdyzc~sIK@MHhBQPH;gs$S%P3Oj{Ju>~RX7_4
zGW0b3vgv;tCqOrZM_+Vq@W37h^7V;d4Ljr5omcPSN`fLaXtTo~cV<b4f!9>Sj&$x4
zuJ)5v*Iy0v6o&x#_~fZYl$BFe*zd0paOncnyw&oqBIxeqx~ddPI;u+L8Yb)h3<{n`
zg}fXIRTNx^tof!_I@KOFotkd8=AMaV$+7~>W{p+`@{n~B&w8mcDzYo@6g)qW_!YaS
z@vUy|0%T|`x%ptgU&{^+aZ=jGV>SkO;;!@$WthG1^d$(6@-sS51JW#9*mvuz8{lZA
z=(^kCm*;kFJoi(paO_J*bv$^B<3W@T1^Nri{q3~U;EaIfSh`Q`GRV>Su*+6X(g~~0
z%vT03rdm2DpRgi&q;`72@>Kqwc-`Mp2b}KNe7Kqu$UDcj&53<taCS7WPgZ#2Gezd2
zC~YEUChj{He8o@ltv0&Hcp4u0I<O^$Q0bf9Ld@L>v?YcR7}4*O;i~&JJYZ*mCc1#n
zg0eRESonMCjmq|p0n^K02Q3bg*(qZ2@@&-QCD6XbmqO-L#nrUo-{G=r+6SixyU3-i
z$qt!7B0GE<KDf210|whxYXi<c+-4XlKjRNI;E&l6Eah)c>qN_v9=WlBljla-dPXY(
zk!Y8O?X!>yTv0vHHWHVjNcr!qHndqfbSQMkjww1(!!XO$567V(z=^7>;w@-=0*683
zjq#rjd@t+dFY^!4%BBL$jCdIHB57VOtp=U_UmrG8e>BBQDv(@nS~C8EJ89x0B7^6#
zditiVayOa+Mls=_)iQ7+GIS&S{nH{5R&=#Re>w1JQeb8fwlA~h5#~G=wu_L|IA^0N
zA&vEu9M^Rjf0wco+S3cfbI~VAMG+<H<TwN=!{&9XB~}y^%{N<a9hN?)DUUo3Tj}E?
z2r2P#X&aRe>rsHq4mS9Z2Z#w;Pfg;D&d?r`?ThG)Oo&TX?+AFRW!azjLiObp*!Ky^
z;6%vA>yKhP^^)QB0A6xwdK3*7W>5)DbM9rkkoXRH1$Io-Ypc-}BXOiX-3Gthj+3ad
z4C$hg_EHMMyjCGA?8F=)N?dt&ey)Lk&WgCa4u)r>gH0$I+co7aj2bpJKUyTNci^qF
z#g=fAJzI?$5-CN(k@pJeRAH>m*7RD9X0UX3+4*7@&4?3x(^s7LfCm(&PXSJX$0Ure
z*#j5ERal;|5FBNezn{=4*AhlMhPLaF7QEAm-lGce9~7!|u~=EKtX$kK)q}~3VLqw$
zQF6N^0MJzNEa}`EeEhq?PM+pELF?_C2xc2d{ckElTi&pBUH_{P8g`6fGp!}h^9xOh
zH?UX49Gsp6(UK7r%MCv8-_)bTkcJ^W_KrQrqpW)Ak_<5tja{3oWB=&bRr~}C;kblo
z;0ezd06dBEr7$N@AM1W!ON41{3!dW^TiZ-=%*rNlSNL-*XC>vJ$XXGH9&vRJYXkP3
z+TLfEO$B!W9T8cs&HAP(le?6DjQ|f$AYes(_`#EK5n_(AdCy`=W!wloa5UY{W2JRk
z^L*+yQt!LC+HK~&`jx6=g2fYXMqV`~Ux4g%W_W4WpQRU634Zo(DmM8+EoPu%rg(rq
zS+Bhyvb7>n3~>08&ap>B$|@W<y`guqRv5zB-x4LK^Rrs`+hTeP>aF}c*f~f50Fsww
zQU^s0w=F3Oyt&q_w94>gRK9mYa2Y-zmt}TcA(mg@17aXgKow-VXwgV#T(UkO&wO<b
z$`-5z%Q7QJmYU$QJ;FcP^?uWjelS3b(l2W2qw}!$AuQK_iAkU{@7R=a{T|KAK9?Tl
zgl7l|N<9oSK`Ri(<^S3K-H9|pLUOTm{+h!4`8q{iQR#9Bju)hV@Hj`4gTzt2%KRy?
z6eN-QyhxUEx;=XZxIJspov=Xz;GGlw8Zg(;phaHhQ{B0t&<-k47W}Jx>Fa!3zbF}5
z-w&@|nV!y7RdPh@$nV%9B>_LGAsJ3mDjh>PJqY|#$9gD3lt5i!t=H92o2r(_)G&rh
zg`y?QHhoeFq+_*OmSk5tF9^X3UmX1ndM65uqaKP6A6rWq)yG1pN$K+r$`U$=!w47i
zs0XskpNSLH$ZL@7z+YHod{@Qv^D{s({W*Z%$oAMIvIriw@{$gD*O8L8WZUbmBfp#f
zbcj~$1ZMDh*j_(XB<W&(-&s)9obeCYqbxYJh5O7zn+DLV0mfa+(Dg%GE}{yoca|C9
zY%}!{Y+qQ!Z^SUR)V)AR658MR@JxF?1rlnlO)w-u)_;2Over;niwrMa&T)ydIQ|t;
zxmhwqwQXFxV>M4a5FtIINtNy7o$?o}<gfzm-OfWE_Cv!G-j>4&)owRR$*tR{=|z|o
zdb#NAV1Y2RJjgc*mM<dXBfs-(+dJ4)bt2BT^74ejFu%g8=m09egV7K?G(tn*9(N^#
z071Uyek=aq5s4m7;xvO|6x5;~)Tj=DO?vd0C}|CU@JyDMY<!?JE<;KMp%h-8mAO?R
z<@<i`12rrM=eYN$KLmtLc@7rtzHEj*xJxJE$`Yl?gh@`opD{xDAoEcjElsmhBLLDH
z;M0(6BzqRS*}SK^sd!I7boGAb|Bd>K%&;OhqrYu9wc2$mz}fk`{z&%0n`%A3(y@?W
zv01KDe0N+hT=R>Apw2ih4^LcsOu}_!9Gz%!zgg}C3<Of7#-f$;{~;Qj?=3f|@_Uw_
zE|bGMT@5XG=}r{e)spJ9xChDzepHN(pVpj$*4Sy!4ZS;vW5rW3BPg^Q_;_bv+x8Y0
z9OCnJKOr<ziQLZL2Ne**YS`HJ3$q{5*RG?NZ~<8$NLGy0Y+ru5p+`MBjway6kL<&|
z-|E(Na8m8_$Y*2Izf=21#?2s+T7}FwedD@~$TR)%G@5ifJ(GW8%$Xz+^aQCe$iL#t
zucKn(r2#pSamS_Zj4?)e8;_ATpmVaY{)3DOA4GopaRKi83&V!@1se66Sd$-aJ#R-}
zBqd+Wot6zKr!D~OXhG6|QkGlCQGm#a2_^uety~O70lfX;2F#vSls*TXa&HWOVH8qr
zN7Z(`SO|FRk?Q>#doI)mVfU1hupEN!L|xY;bE}xUjB&8=P$?#n4yH+GuL3Ab?#FO0
z_pYf`19IkSXJ-742k+#VEKogiQMt3A^d#A}C1uBU{P29lx+;O~*whXBtQb&tWGTST
zoOC(DO|`Nv9}s1h0000007?#iW^O-e*GG+<D5;A^0q$beF}S!}P4k8XyU4HhF|!1}
zX(};NBPOU9+MEJ=|Dyo#Biv~IaAgyM?<CL$B$Mng;7cgh*Ba%=06TmD5~esl=XXw=
zPn6^wuFUR%O`Q=3!EsT-pM##6DS4RkxjUYjIeytS>cwwmqH1OJz{V;poL!R^!smSe
z%ui|W-wpJ#AY|!!(GH{ZNDzW!ccXhZ0wtRk_S-rHVmb<`<o+ZNC^mTWrP=oIZMV`6
zF^^d*?p>CP2+FJ&F6M*JFzO6+#Yj6rlWpA1K*`7hk6@vFk?;_57hh0np@1BS)dIEk
zEn*)OJX}95lm3lTU2JWVq7)^;4e5|pJ}5u)?(ib>DH@i^{eG4H2F{=SZO>L1O#X@E
zgkrbpUUv45KF2Pz-7aQO7SO$$(;gS(Pv&G0;ona5Y674ZVjnJSS%HN6+t?kl`vhe_
zt6Sx)X9=sqsXM2v&o5R=7T`z@k3^dDa#g&;JrjMNCXcI1w{(c}pqBN^LIQ(*v3M*_
zZb<mm{>1ii+OS%wL3((gQgr6T-soTjV5!;2^qw!F0Q>RzyT9eUerX`Z3pUDs4cb2l
zE7sCg#iPHn*U-kUPF>B8bbtdqyUHmvg!=gX)|r*<dO{zzN5~p)>rip1PcERZ_69}+
zR735^T@qb2`{maNS*-Mt+*XZcSSC;sIWE~49%?e{A^&UNHo*oUJ2NuIOXmP?u4LSr
zf;K+2W)_crlE}EUZ24XQ8weKiGI_?;E4SD%HpLTE)e@%{7V;>TGu$#Z?5M$we^a8+
z)~$@uJG;v@WqLKb0pbtktX0zU?><WZvUQ+2n$x}u`%m&{;1hzQX<^gjV)r2DLL(=~
zt(Zu9XCs?}BWfPHD_uXg7oGTj-Qgut0Ca^n4BI5jib08n$|A_DKzELQG!Hzv9H}l$
z`98H-c6mW|N%Q_)uDPmM3=dQMJs&LSh#a<(^><%(1qw{7<s&|1QUU}mt%Mo&Atl#z
z#YlfUA`V}q2ck_{Zk^mVlh`?tmI2O9vQF{oCWvh{HK5Odne-`iZ@p&C#^Jn=<oNQ<
zj8#N1duja4W8v!jSsUeH+g!L;S_Y|+&sSLVm*rS-cmtuQEccpOJODP0lf3bPS9joe
zwWNyhH~|z1BG;gGh2Y=lbbif2dNhNjG4O=2zitBYegf232h<FX0+=YqKU)wyS$oP%
zDkB_Fvi)~9urP+na3(@MSk<FraO{~*)v-k*Ai@SNmIs(J<vRcvP)?_zc>s5Ko$R@#
zS0BabW5^zGIVK9Fk_wNM)J{HmUIcdf5%~}S;SxNSqA)TOuPLE0AzAl|b5IbefuH~Y
zr||kw*b_VHTr6d8)|QKjp$rn!91sX%_wP$>_`|VQ2P1{Hbn1D5svzoZlZsz#bTs&D
zxmUM=qb(sUOv-LTLhx}?<jf773Xd9ng*1u%_{}BAc4dX;h}lb*wuxVrIQHW+yjUHN
zyjxo_ab$~(rP29QzT7gWx-yHp3V>ej;H1T|JO@{iDEX9V%+R+e)|57RVX2}!oC<<u
zqBnDDpW@KrM4m9DsE$g-{Ha=_<Ph)cxN8qbCSrOy)7~T@)&`-Wpyv}%C4+YRHDgAI
zU&C)ihR(Jd?Np5PEBvyC$s!Xq24hRkHU?UtkaHN`?q_Lrl^QWaV?rb$Xjx2mfi20h
zh3sL(4Uk3$0m(_ApB1E+r(NMA1Q1wmN4vw}V2^q(2nilKQdfi?&{A};#+_>*B9mth
zhk4o_IcB?0idC?8p0II!j#rF4n3Q{QKd$)nxG`L`C+7$C8?ac)w+5`L;VKEpEKZJe
zx#&wSW)<t|Pi%dVUL>>6gaPtRf0N5Rl-7y59|;6>))6_DBI6QnNV7ZFhtXXzYB^%M
ze>R{Xp!S!oihNQP9HinDLXEzO#c*RMf2t?-XciTErG^K0=q*WCbE3SDQ9KwjEptDG
zu`LwQlyaCCZrZNOM8o6R@sW4#x!^~K5{AyGWAeQ6RBMOq?4{aPJR-fODkq57F74#z
z#-w7%jIMPBUgHqN?PrryYB6Eyb}LDad~<>zDu9;<eaQULOoSob+mM<2yr|R7iAtrn
zM{qAz#Mwh_X3HSSYC6na6?zCgk~!60&U@JJvq;=o9&e7GZXdu8@>^<Kw9xkyl??bb
zy%j1rpZxd@AA#8+vvat5RkkAM6KcV7=Zr8dYWL(@4tJa-s9S>Equ~cDAFCh7MIH_Q
z=v{6TkFFU;GouI?a++S0U~e1I<|pAnD(yPe!P_k<X-d87XCWHd_~=bvpqU=hK?W!T
z>`(i!gV-Av;^D1BnZ1_ae-x%{s==!E)7#SY{!Q=Ye8Vl697hnE3bsc{MHd7STr<T2
zgHIMNVC!lTF_<t`qfR4u=PfMPV9t1tVeqhN?JIZli?Z1M6bffq$qZLM2B`u*->{tV
zRO#8cLLmZKZGUr1CgZ;%iERnE3zJ(0W2n8mH#fS+^Rn2}%Ae$TJ8nf49X@RIY?LpB
z8X<8Jo4z@R3R+51Vl$Y{!G<&5T|+hVLMt$#xv3u^sYIm=fm#|U$ca`4ljdemraiQQ
z<O{?|J$gee;RW-GBjrR$9;w$C(>ZU+CEHsm!VF`PUkc}j6tN5=^~4Fv8=mqaWf7;#
z<+z-Xe9|n)UIi?~Y43s|N*-pXitX>+kB?gT$)AK?aw;tl23DORz;rS*!-8sh7HO_%
zwP`F%k&A}2^7TVw71<^4fQw@m99H49NLVi;(T2+NKHgTzZc{ko`61RJ0ABV}^YcSU
z>XA1`QJcf1wXoC8(D1mS;)EM}sdi8Fds>Co-EXS)85bod5BO|E+Ia23<kA0_g*Lk*
zDGPBN={$ul_1%|^j+P#);6srAjhVknJ2cjW-K&G~oQstPh<SRQV$K%0B3k92pCMuw
zdf51T04*wpcx=e<dRXf!@<ZxoqRZoG&tO%vu533`@`XWDJ1E($Z=qlAyn_*E4br}9
zl^u-oB8PH#0G^W~q0H|^ZH0xWrwqQ@n^GBlIHQ02*KPMuz^g;U59fycLaMe!CH9Rk
z>rXaI{xnf*L(~<4;>IouaW7Lf->wG^ADHc>gUWt>X6t9-3pF;|SwDz9=iD82wp822
z6`F{Xs4N;#(mC`nd6qHWYT-+RVJ5^f_Sj9Ix8>d}!|peO!I;yXif6!MQy=iQZ$H*{
zB%S4S#jJ&2VVfM;7OL8Xye^cH{9UK0Za(?V@b|x$Ij?EEgC9Qs4Zqr+pDZRzr$g#7
zE@mR@H2sNaFjUHHt$98uP>M!``Z#tmCKptmISMbgwW3#_XyaZw-V;|F(w*$F_9r5t
zaw$f1iky+zYl!Hb7DGNpiAWB%1~bukfc#!T`m#j0{epvc_6~1B>sl7Mui@{e#H|Q#
zhAfwkvIPg-P<F|_tZ(IlZC5N~XBDg8cs$BLM9G2505@F*l7N9MdtH#re`FigI+nYE
zI-+4YpVm}(SwfEL`gu`fh<-nrZV{g^XY~Gb)ynQ=sgx0(M)as(ukGcg7&AD~gSqsI
z;55Ne&7yNy*(<A}=P9kpB;klR!7e%*WTnY@Js?-gzH$P}LIEi@kzY>H^NcoRq9SDQ
zw1Bj`w-0V7f?M6=r=4W=2Y|R+bdc7R*>KojPyfgBTbx-BRu|p2_XFu*TMZW!Shv>g
z{yG)I?S(lRmp4lRxZCfpaCnzB3z&PZ&N7XAxEiI(F>H-We8YMV^|8>xU7KBn=G2D7
zO2%Wug@BTC?_<ibA~x6ZQ95v(0007sr8>adi>9X_Bqa;%>XN!}oFNKdu7Q!rx-@pz
z@>EX;;2#HEY-*qB&Xe4P^3RM!pgS?PqIG%<W#yvnV!Md9uj}K7Qk{rIhXZre!FXJM
zsp~ClHosDqF%8ZADdQ_gE;V7K4YLje6Q<accke#KIl?@&mV&|;%K9y<$T7M2_iHU2
z3#*vgL7Lc1nAy=%BslZ9e)ueXwp!p>(dnaQJvwttfuanmJeK7=oWm<2=Y_}n)Lw8P
z?VeGpe?zYjy<Qq=k#8C1DsO-hsXINp&bDXmJ5r95^1P-Tlgg>nfN^2!pz^9-@Mr}1
z>{rLI5C_&M(*r5y!gpLK0`Wj>4>2phIWLW}pt6tCu%&3|-5`Xu(x?L{j66(QLMBZX
zj`=S)i3}jo#k{|}4LBi_szb)WQ;HPy{c&{{H$Q%<SY-{k6!)UC<4M}HH%XNPRkHiK
zCY!dv-tL{&9XnPqaKqq$Kn?l|CKKays|A}bs;d(}Ekd{(K%e<Jw3^=o$pc3T0U;qG
zKRnDJ-?fXDh{FujtVlJjbq(I{T@krk!`u>7U2PeMk5t(r{k5pK>R!p~+RZn|*6<My
z7(t1n!M^9wMCVpb_YF~4f?4PVv5DzQN{%O*Vx9$ab$rmZO!$^X7%EZqilkDn#UhkJ
zWSSK_i|pDb;{{mF{a$h|yn$z)24`SF4C3nD@^-aEIVqH%_?J2>ZMtW;6yDWy-{uXR
ze;>ph*Wl70#NVcr>K-0dhWHzLBEKYtF@fK%a4E^EZ%RPMwG&!rf-+;j^T-PDUIrNQ
zp?PvaRDM1@kOU~84-Pi^lAU~@nbA8a<OTQF#|hQs@AXBSY9L@ND|T+gm0=mfH&008
zvGYm#{P8L$S|TsD)t1yh=V-ro)wC2SDHe=ffjS^dbEEnoW9vMP69EfU$3uuGh~Qc#
zxOO&5vT8iK$!o#{W|?wi>e5Hl$SVSNnXn~@`aN7waJWGwR%@wH{H+L$2DrDhH+LY`
zvPy<?>}w;0sH*Wjv6Q`+V16DZ*-oN493jaHx%EVfd7g$Dz&%&91@KVP8&vy<23t`x
zMabQmIrPYadDKz$>auIAVu3zJVx)-XBy(fwlWBZU*U1uO9G20i6!LE)G}MM$jF;m0
zEy?cN|2`>Wslc4KY%~@$X6-_AFqDT}Cbu^G*%b8T7cqfxA&=o9plSf&5GKE`B$eP*
zCuGlZaMjw;)h^xP+_I~xq&(k@h#i<CH15Afr?V2xR(?a5Lm`T5ZaPJk)u(VnmQU&G
z2*1&JFg$h_lWy@B46j5Xoh)Tx=2tZ!BK8b`el-sj9z-nl3~MmdQ_=ZaOcaDzOh~RR
z_%T0dS0BItJwTrQqd$o7dyTYKq%_FLa@aG7C0yahGdDk$AHaM{OCKfI<;!x6_K0)f
zpAlVb6?z{e$lLU(pkzHd2i-!(1COYQFAGBeInlHL001Kc1Kbm$xr-oTi-dH&fX*f=
z`o);G2w7MW_;13eE{IICz7xV@l=2ifiMYoiM;S}DNkSJGV9cFnJy5?RQ*{~Bcoi8V
zS_l1ksilJs?a&#~YCObFCyzXHY(_|7p?i7R(j@_4NEXh|kPqCYgV|x46s{0|;y^X2
zYCPT5+M{PE51%n@2D@w-Aqq+p$*2lT7i+g0);~00>B$NOZswNMd#ry%rzZONCGSFd
z3(C7v>+O-3ihk8i{h9i2*ob}$T2-I>1O>)Vz+9NvUt~&^@i$<?Wb5@kxKoORW|Fnl
z>{Iz5onRg265$HSh=i8FJCASNvPh;DliuzN_=M_{O?FoU=0Ec75^YlyUm?IiQO$DL
zWx>IqHwWUJclZf?S(ovW-VT#-7H(K#TdnLG9&$-x89&Z-k!ymb^&Vs*u{cSQgoV}s
z!@xBg4(b8!WGf{lfl=-6F39=LCv`IYjmZ3;#45|^PdCJ$;!;UdFBi3UWrV51MV$G6
zFM_LcJ|cAV1O+|wVt4Y;HrXT#luVv1)8<y&$$L1IjeAA8jLTrT#dQZc84p|6Oi>!0
zsfXYO?FdlX@C*b$l0k@CIsO&`E6S=nE7$r)Y^B|%Rgr>B76X&wuMMTi-oo1GL|pfL
zg<&5p>6Y4A#@#PL(ukvTV)?f=B8jk$D1U8~*>IHG5VfEGW3%Ls48D+kS?l>8iG9Y`
z!#CNhsdC9$6b+%{A#&4(=7Z=O5uxNbzsu+J6=ke=v!W#qsT`(gv^RCoYhI$$L4KUH
zs@;C~2!Y757X%`W1gTU@3*D*Qx~T4jst;lL1{xFew!d4NCx;g6L*ddWrOMjfr9L&L
zRprRMQB1%H{u#H)<7u0i@8Wm>D`*HK$ev@nbKC@rAz4R1j`d;OrRB5$tWF9gS`!Fi
zZnfn_q~dKE7>pI|-YZSN4>}c9%<S=J*nZRmgKZ_)-TZw!gvcYp<biXhw<vw0rlqt;
z6I)uY1b7^Fp;>Fu+j{T37ajl!qVHRfqVkq|%7tH*T$v)(=LR}_{Fssb>{TVBr?hRE
zJihpP1C(nBU07rZZnDYTwu;OdLZM+V7SD(a_s#n-!OXUUfUbhxOPBAg#IGD8Kr)=K
zyXT4JSiTd{8*B@i`-Awtk}5djLc$bt#-Cygw(S1Sy<xyc;W|h<YhRSt@t2gOlrBDK
zaw5P>P`vJC#ywcb40D$z6iU^;yoN>kwXgQXo|jB^LY@+N0m@4BolUYJ3|N5b9l2qo
z7#R4+2zo>+bszx9YcS?5ycfx-!SfazX?ag>2{5WP4J1RGVNgP=P_I2##e|BuwC(G{
zS6?MuPwOS!KN^g<Qw=y9sGVm6nfXfi2=8{ds-Pa22Pw~s$!g&W-W-U$x#x$0gcgWG
zaex%0pjE<dre7@E;NI&_wDPDUgYtQwEY!9%n?M#^K~Q9nVZB06M$mxr4s()%Byvm1
z*>G6$OnxU17r@STgoSNAY-}Z;6PB4+@5H!}m%o5^rG54@JG_~v<`@kvC_f}oQiHNa
zYE2>BIb`4VLY|Yt4HHXOXa#b}M3mwUOQKz~zQD;pDj3QuAZMq~VDt)@3?V9PidTTD
zZN8Y01RNq)<K~b8FNn!*#}S(X)xX8II1|=2HWb-tnF_VCqKOnkbM{8i^9TJq?>;b+
zt`;6Zm2Qs4^y^PMK?A02KZs*z<gxLr7RdM_zxW(Ao_gEYF!vQVw}|9}7vs05t1b=t
z-&`}5T05a{Hpowxt(m>2=t4TUY@rRpfD{XTSgFg46hrl-e~@fj%x)8Nd77>)I2?cn
z!Jn_`VO@^V30yPh`w3Y^(Ws)R`_K8)NOY$JTSqQLZr0BKdip%<`vebf_`mX0L_)vh
zs0vc1MX>Q%C+gSahfi9|Z(fxC{|SL#9zVxK-+PmJo1l`21(s_hD7O&Rp>YCZjdoXX
z_BOxSWqvf%UxGlKLXF2`6=#^^QcN)c)=wpEhpdCgb7Gyv-B(B5C}V!x=+x6_7zBLQ
zJvBq+r>#JvWG?B|kD*`9-7y;=J^4^oP^krHl7!lEpi>F(UwGJZMbrngvpodEI%<Fl
z!IanQ9OO+IiN!7H`M%bj3I}BPXzjNTJ+26P844zI=6#wG*JZfJqc{Yn{ojH=l`q8^
zQ+VaqZ1aFEB(u0FSwoRRndxCoC((DFr1{18xaps`Fmbj_fB`HIXxS|^6VRzA6D=uP
zn4OS@_H_@*w-bg%a%QU3+(DPBh52JF%D?B}03!o_EQ*+A+c3()N?6T1`DyCy!^5p!
z;Iy1yii;cynSMK<LwZC`$4gW5CVx{sj^)e78wvgA*XS@@m*m^hmy-)4p4**<<VqO=
zCBmAfc2(Vh1-5RKMp7@?o?F#Wuilc=pnYbL%ouSWU7QP(!IPzD{MEji-18MQj~KeU
zn50_Q>i#=pVSol(WubP7=@$kfRQd%PA49U7N<A9?YjRprG5!+=Kfu$_?(Ge4(vc|d
z8!}OR#;3p8=You%lygM`J)tr<G(mFrqt$|%qTQ7LT5(e>@2Qx7`nFcyLBJHhP_W3k
ztwB~LFOY`^2^_)X6tklQ$%=2iTQz>=bauJ6H?F@l)x51*(H!<~!M5kXzZ!$%J|@%4
zV2~2V__bQ1X8n)eq=|4dnM@6$##?P*7L2_xS`=(PYEy>A5I4N48&<WJJgPWb{eQ+i
z|4B#xyR)z9TykelrclSjUzpKw9K;X`DZ&apbB?Kbn_uZ531rq?isAG?ltu~(<I8+R
zd-%1br+45h%{)6``FQ19o;(U3G{jFqsDn=F{lCX*58D*LX@EZ8Qwo2vvytd$7y3l=
zje8!%D*LWe%HKChgjk7Uz9Bf9XF!pT`7l@G1%7V-2VA^ml|{zIc0IrBZ<;~w6<?@J
z=z{7HSy>b<(34S~E6Q%s3j9J-Oejw8-gxMs0000U!7>1<02WaeY+FcAZgC%mTNe^q
z;AB$#cYA&xPWoiqOXU0SEnwe@uuSMOZpS01necivIFjAAgz%pnV|O1yx&XB2IJrPI
zeKnetr8pbhK?{>40?Zd<45mQc4HgMEXmCDTg-q|D$dEuiA>g)A%k(kX={Hx*|9&&I
zNScSTZ?t&N_&JjhtP2NV)Ck5tdxcTjr$Of^;f%yRMNvav1E65X636_u`-%drlQ0kV
z2O+*g+*^<i*4lXfrO;>ZrLCt}U}!b|ni?t!QitDpEZ7h%!ebIqp?O#ImzVfbDlwyh
zVW{Qu=N%&^!gJ|h>IQg<wq539^Y4c!yx;qs+`#S^1bsVg@D^W#_lrs5kd#EX`!;P_
z4v^IwG!MQQ&s_cJQGGGC#Q@Rej97WU-l3f4KyMAfmd4h)?5bN$0C@nY{|&p+tUd6D
zZ3u|Ik(@*--|nSZOt}(fd~{wRlX`C=MYWAAA^PMUA@t*33uTA()#Nut=-}eLw<S^<
z5XhEWDwM&KdeUhk&PK&OT&=whrwe5VFMVPr`~p*FW&Xp*wudFg97Olg%isKsI?=}O
za;HQdg2*;)+xg9Z4j32~L=~iUwW?Iu;Sm`hK9>r0zK-KfTPB_6*UerL@Lw@=PxNZs
zx#Gj8torblpelc(&qOUy`nlw%ez}|F;LK<*!)!u+dy?N1dJ+cxE>MkvMOq|-x}iY!
zMlW98_1cgueMXN`x4&?=7FAlCyF3@+$BUT1QC4GSp<W4ZYO$0KO$OBlRw)`))sLIF
zk`QixYGWDzo<t%EkeT$uY2Z&4_PEq>C?sGO=Vl(Y^~su@MFg*vzNr_g47}D3g>eHN
zyE3gf1NsaHmfOk%>gX{9)<fA8jUbHdtFRO9_0%6^L#n}hSRn^O*!PNm(%Y3ww%slh
zsN`w{(_YC<|0CkF8~uy=kF#N;O}Sq!e#SsaZ`ABQcgwxWmh=KQfzlyipBh1s>!wGY
zwJ)3`inC1w{6x=cJw{SQ0n-6wtiOl?$!TzlL`PV$bCye9(C}b^kgoC1`E|0p?}Jjq
z@6+(cIw*g|LyJsg2o-pvSMG~JEQLgOZ!m$xMN9HRp31H^X#!{5I;SFtXm}!#gLMXD
zh6-9@S!Ioa^}n3pkV<WKy-999YH`VeLOQ-uGU0Shj%$bSELPEJLE6iXkHWSJm7gpF
z!S|w~Go-(c@tH^rzpfT|I|M&Ub}=?2n(@c5t~;}qLci!;$gP`c;3X#wm)R(Q&?=p(
zD=>{G<4;Bdt?UxJ>I<C}ir_=>yO-P+b=L#S7>HNCv?&S-BtHDXi*L+~wf|D>@2n1&
z2tP`f9SWI6{bli(k2YjL{N>tUI_6bc{t-wNyLObsPbLW@*=jt_xcKutk;N%%b-dA(
zjuJVk3P+~o|G#tp`D{=L*=ET`X-MhZF-f&m-QJ2hIXm-pP|gA`Pg$93){*PEQiCLN
z(8wn`4E2fHo-7-4Y37lmRR^q#4^&9Y6CYvz=jX!yRMd@<E=r<{&=4sLMMS1}DY<u$
zuAOZ)0WinU2sYM~TqmncnH$v<mFw@l)|ZuS*|1utwvVc;g3=Yir3Z=sl!ji$&3$e9
zl}Pn>u|)dWbXpdI8uG$?5<xeDp`r4=1>hS9_CG#B)w{;uK@a$D2$utrirR_cALBin
z8WB3IQ>I^ZlZ`Zj$Y%mA({yqHHl5?(=5BZa7^m-T{D$0W1LO)A*vh$F%jAKn^EL0%
z_g0qj#8C_+G`LXmDYlfkI_7>$I%;gjO{G3Uv)Si^GX;L4_O$M4e@QpBs2ldH+{O?2
z-e;C8mo*z>?od(w%$r7E12MSfOhZby69OYoS7r2$8$8$!Sfv;+x!(#VI=$2}r$3b=
zz#c$FYJ9yRoSh(d|6wY4T)L0A3?{=xoNMfxYotG^LBQ@mUGWX~Lve3+EP?Iw;*`~O
zeB7_=3z_`>@(i++yTO1iBrz3Ic~X_S?3q`oW3o;*@{M7me+K)=r#L&TQ7a3X^Hzbf
z5Wz(~g7jKI00(DgusMTQO#?|Ib>u$0xnb$6c%hj>;HL5hUSEoQ;J2W5JurBz#0=e)
z=4#D$N<4VNMhj?x#)<h4BIS6$Z5Bx#K@>uTvoecs1>kI<F9U8}Sf5f>NC>0r>#3m(
z@8?7qfbtv)Yq>9O2yss9bX6LEOEpsnr%kZxE+adWU}+k@n#@HUFajJ#+|8VWQ`WvZ
zk-*LESRmpbnh1v3&@|#zVW(bHl35~5t5DM7C+T)ZXlOwvJOd*vGog^)VSnRfW3#V=
zQ$iWT$c?iU38tW0)2f!ODEj>gC6)YGw9%CusAz*=#u-XH`!))Kr40moM%ktf>u{zN
zF;{?Wp<Jci2v{VpKvN=8*mqr1<b&Vv%rd?DwM;JZp|p-}eMQ7yUhaEU+2eQidE`zb
z-9L+AN@Wl=>*E6cB8ZmGpEC3fZFJ2b5@@m*+pF<1Q9V490NYHse3YMYBQ901$t9pN
z**lS!Dpya`q97~s61zG-Eo>=vqmlA3vRyBO+3O=k(74jlVnXY8HjXINPRPjLNI930
zN*7pgyf-Wj&P|zxV2Yv!{ZB+?G^99wnyNT>fyqJR&RoA=7QLz92I?70R~6IqoSBJ^
zzo~oat&>h`&P?GEARr1GC)viaD2b)2N6IF<TqQBYu~jlj5Ig}`klSQUJY1TQe@Xr6
z!@E*$<x7~BesLMG*3pUZoo~aInGRkGCg`Z7AK<AM2Q84}{w^5I;Kp`e!1PobPo~5K
zP@DmivX=~-qH3xx0BBChiulG~0N1dftx9opp5hhIE8qAnnMC};3E7cdgNp3itH$I)
z3Vx{JVNP}N@xG9YmE9SNns~J8tj%f|g*y$il(R>w^mR4{00bApmDi8);p1tyg3Dxx
z=ca57%nN>^5fHyxJSQVaH~>%hPvFP5Q0KN6K%Qm<e|zzLHVRtf3%{KV(oh+(MHP4t
zS}Mb#qrgiAfga~CuW0$@tWWs;)c$4ehHl?ME(%I~i2~yo`vO}0NEgL%bIF<}`^+Ke
zeV(EScD(xG@RpHo3Hw*xv@y$*WM|=zlGA2i!n~Vl4x(OD_@*NC1z@a_K*I>IR!Ibo
zlmA`+$TXJv?FEiinNk1?(hz*S8<;PCpC|4x002my8g0}Edi$~s8S0vGsNQSasF5y8
zX)Q|MilbJ2c%Bn_E8SZsRBa$Zy9!xD)FFy+F~*j(jmw+~hh%;nxbTnAYdeG^EyHb6
z+I!(IEauHU@bTVB8Jk!i!N<ladd$yo?L^IjK-&qhFeX7*_mvU5HMT))d2Jo)oGe^o
zpDDo6;^=klM58#JNys1B!B8V`N*3rkaYS@U4+=Y>9hRr@X=&xww0*FcIQty0l4Hs8
zf;a`wye!BgB-!-}!=2Qipl^O+62AJ7!gZhR%kX?=C`1AJ4ac@PPJ*LbKx`c$P1ykN
zzN7OQk~=J?%<?+NAAn@JSY$HnRCTSVWoo=|b+hl27Sqc}AAAsq7_I}(h|`q=uY5Db
zFN<S(BM_7iSe!G1a@7Z8;UCJMH`Mb=PJLbuQCOO-$r#k0JC7U*uh%b@+y|3qG%y2v
zP#(N_eMEzwMM?zqEh&jn-XaMLZ4i05Ex(B*2Vp^6!f{!EkG-BeE*L#7S^zY*H;4{D
zv#Ue{?yAKzjvNf%(?o?c_=+-H=a_<MFX2#Nu;)5BIZ2+ON(VSc$c=Q*F^Yk0PI4J{
zDj?umT3tmuU9YVTUWYP+0MoVU_<BXO>K=<BLiME%tGxm#c-`?|CC$Ahip>h<c?Wg?
z2+yvgJ9afDV$y)M%ZZCM1eA^{JH#m)q|EqDFFdc>!Q}0$`OPuo(AOcriY|o1kk;;R
zCqBn>BuY$mY{`I-N%f0#<;KtztYNoO`%fLuIIY>!a%XSt)6Rf$kXC$Gx5zIEt1Bh=
z%za>}@R7YoAc{L-bT8*4AKMDXWLPbN{^YKmGIO);>gKvax*`-J)sUIq-1gRrqd+%$
z`_j_mgP=#8$^9Ak7O|6?qJgWs{BI*+%q8*`_}vyNR>J{>n{dE{p>>|pD-r4A6W5-1
zx7UK$OAi2MYd!O<rEa8=i%M9{NG#+@ez;Z*d#Io;QA#X-Wtq`+^OC7_`Mk@bkz{$a
zOj8_7(uh3=9~;`NI<5s*IwWBeBeN!vwk_9-)RPe{GFfKPTC93h@TbX(fB*mh02{4G
zWF3|#Cl(*>@19EvAuHj$XxCK>cQAqIQb<$<>v&90lhLM|M#%EbVkvaGw8%+3bXJ(<
zqZj%5Ss}Y+l6YC^Fe8Ovssh9E;;8`%zEvqhUy&Opdecu`d)5e+33!iz0}zpp8k7LK
zt4<6G=Xj*tf~=*zsWPRrXyPH~X**2Q*CfN%R~!8>uZt()rhzqBZcQq~_h0R&zSRdM
zdzyN`%5S$OosM(;V2_o4&jaiCmr;A2;+>rbtnL=Sede=_21(E;yB=gckS#|CC9LV5
zCWktEzMVd7KruPT*jM_o2SscC6-wt9V%chBTK7j42n})%(8nltrA|LNFdwqt*SFK!
z-ULbn4zaVsGUahq^)};|QR#HsWKG37f%bI5X{T<l<83EJgBflJ*C{L<J?u2;=bPmH
zPrG;W;vwiVQQrZ%0pT_=R7C=3*A>FfgNqttZgi}sVrn}5u^ToG5A0TUe}qd?i^}?Z
zaofp#j4uNfJSUJhBz}1^gRc|xr=nRbe|@bo2uNc*Dl6nCutGN3l*HItsr#TYau`hb
zVxP}s1VUO%)~-)EiaVQ*lWMzJ#N$lnV_&hV7h6W%8v@xbJfi4|l9ltBVnyaceo3_s
zrL<r|!q(5pBidekQnv#HR#$&6xwyE$#0q%F8IMBO4z>)-bT?O)3&<lLYVw|71$_e8
z>GT$XR3nS-=W}1uQBV*Dy1EE*I1SY`zx$JZ7g<m+oRN!GW2i$e9+8@_W?TALww6MS
z!i32S&H=I-!~PJ6Bc+(7eDgi$w^;}VESN16@Yqg#>SFb7C6~ayc)Tr8hg}4JWwi=H
z(5{q}oyv%u!++rZU7{sUeBBs_|IGj%by1B~=T%eL0nfBMO8E`|34sRJMXQrm7jK0{
z%>6;{P7J4A9psp1h*eS4N>3dIm4GNPyi`5otca2U{<gqt*4AFQCd~`SyWgla$WS8T
z(EerexFPQL*h>GQ@uMi79LI7RUDATFaU;-b*xENak=AvtE9bZ`n9T1U@>xwUfhM`s
zSW40YnT=ltHZ+kRfO4TDR%{upnl!nDSiaL~q(kNruoUirmtvmkRflZiO4HK7gthcl
zDREv($`FsMS#D&5Ep8-~Vk>T!h4Gg|gK$>tm_CFc*WNVwu)q~yb0xkkPNRLzSk@=J
z^v}`xV|w)aHvwli_%Jy#Tsf4pzrXTT=Wx_PAKV03Kc(=}0c+ze)HgJWCI)JzW#Ypc
zcRT0q_z^blzs^d}S+1$<Ii;U=#)e$YAP23ty?DF0NOUh5gWF55xFme@DuhqvVD`um
zemH{bS<P>0&0SJne+FeJ1kbz+i!xgN3#$WRS~&(-d&!IwOae35K{`;p-R~Rs<?5$g
zN1Sxf%g$Gw+uk$LwOhR3O6Z|#z3SR6k$oA&Xt9~2kgDSc^Q`1k%aZ3F=3gJ>yPwfx
zERiB(GW~z%4V;P(06pYBX|dZi<6=J9PGh@Xzy_;Gen%N|reXT3Rrv4Opw1LNNcW$A
zGWYXc5{1{B{_lx`_f_*2sTk{oC|UqmqM0Q60!@7hplWe;8EWK%mh~0-cBK><I2%8(
z%8jbmkrO4wZ`3;E2oExB%LjZ!YXrt@&CDWyFEn)&{wRw9(u<V_UB;Tb$CBkQ8kPL}
zFS(aTgtqbSK^2n)`l}W-f9s^V*iV?jxmTCx7JI(}RCEF&sf4>q#-`<>7dte_f%ET3
zgbvE%PW5DagC6reLh!%3+pCo1eRH0cPQeg?-?Em4v@J66x@+kwj9h){koV+Uw&xhR
zrkAju$-A%ei)@;7>Uv*$NwAZ7vkS&EB3EvP4Yk2^m=k)dJG7e*c!)bI_c7ODAL@)E
zU4Ea_Uvgbq60lwG>L4h~<|6Y;I3?iGUhSu%bzVqp3V+@wQpFjK7tVG#H<e@-Q4^G{
zKJ*qd^#guCXhi%k|A00CuW!zAy_xsy#XSCRIu6BO6JZkE^TRte2c*d=)Bfu0m7cC{
z!K1%W7)!#%t<dp=tS=rJk2!2AVwHT;>A_^%2@8@|xZQ--%>Mc#R{|T0d-N4WaEgpD
zt#+Bf!Uwl!>U-S8Lv<*)`;)bx!Mgg$<Rjha?WVc5gCR3g9$vieEYcUniAP?Ar)kQ!
zJ0S{jML&XopFx^X5pxV|ozbnU!tRWo6SgAIIr%I_Q8x3>a}AzWJS*`_wEb23W|mGS
zhCOIK;_OLY1u(kH{^cq;tZNz@^X-O4K`eEb`2m+yT<cV=jh|BFU;_e9nPh6#blx%3
z<-_e&+A-5rx&%g`=on8r_g@hOyNqU)U7WJY{<0SL-CeX~;0V1A45JcHQ}29*y88R~
z(ePw8S`fy@$jA<v6O`LE+kS60|BZgUO~_A#;O0G|v~uQqwrNojfFjzRGEv8WSerc2
z(YO(V(AucGNoO!^NvG~e!1Y7W7(^(e0ew4+lUz8+DhNBhHqe^OjO`~Y1oA0UZp=*B
z1yO|#;8?yDm#$a-NqP}N9x~{NhI5yTb?Q!h-(p4R`fk_v#P|Db8%32M%!NcF6nF>W
ztZQJ^v)&SVuzYWxT#KH>fHYI~qowSTt|tiEX=9r(;d}N@U-(7cRGQfW)YEv^cdM$^
z+OIxG>}Z=yCc!{!h-%|!^D;+;-GXzKl}sL5<HLCRxHsB(L$by(=84A^bmKTT0x!QT
z#40k~M0-WDqbRza>(ztXkKZhiz4{K9j^5;2k(x5(v3tUD_#J^?UXLQgK1vQ6nJxY;
zg-Kk!@fc$oo#SBJT4blg_o3Z#*@8&@C{LNHK?LnXee85=&Tw%}En)Jz3O;;>P|!o5
z<<>Fu-id)Twx5|a>mArMSl?LrErBIHzv7F(E?p<{&>H6_zZ)U=sPYqe>_^|?m8)EL
z(}j)udOX%N;wwoYC6wEtq`Cl1^V%dHkoA}+1Mh=myNF8-Ep?lXhmbn+L5SaGTfQZ5
z1(aQZ#YS0uj>yk~+L*#DnnvH0f8BTAT}za~!43tJ)bF(3z+!vfU$}@u+T`SI%RL2`
z&f5x>`^{aMR{^n)R~QE_%VYMf-^bwfeX!E$YdvNT_dNa#BSlp4r9Z6~+=2Tz49?b+
zlTl*!5Vj0UDykOutXvYPMhD77zC$FTi8`7`EU=|h_4liQ^p28j#S8ILkn&Y6e{{Jd
zYQZ*}`6hSgFDYX-4-et%l2{F9LKXUaLq#5mH3VkKz+jK%S^<6%I5=T>`&aM><;Fcc
z;(eg{IQ1jB{;qzAWqsFm4Pt7Ub1{<&aj3qd&rIwwj(C+gRFmncvpF(yzGB^nkLgu#
zPdf=`GTix!wq_>yuBGhzpa_qs$85d=`QTlQ?Yyv^3Bd-Fdrf#r-m2i*{##D$^?uMP
zqXQPMxKw%-)9Ro4-pZoB@$mXGyLC-EQxbJcZ%iQT?atwWy6@TOCGVx5pebMY8S)d*
z{~o?6;{lqoQczqc2uv-%3jpAo2EBm{^Im~Jj?=i@ri4@|wqgjvXv^C_R8P|Wg!cGO
zDkh<r!T|%t-kjWh+D0y@Fs%M&Vb(mnZl~|zN^UvP=V{GFw(Or(^>%B~-=`4#qIB(_
z8d*!_3-%<$LL+1i1k&8FxzzSa4Zi{iw0ze{r2w)abbRiBw3oBHf3eu@fyV1V&oDdS
zB=1>_(wW_-6+ehBx~M*fD&h^0KooWEfa^v=>Cbbj_A#K5Cl|;jit&r)gENV&JM?pM
zh=RnW0lf?u!5&p@qU@xYdsHLT9Pg!V+bes3rHBFE%NGqZtU@U|N6x)0PMtrSP)+V!
z6jKj;0^{X;Y;qchScyba9{vXA8(Qx}Qq5Aq$-PrpbP)x#w06giXi?&3^{M2g*gys3
z2HCJT^u~U<_uPd?t6waJSvG>E0i+*DTW0iVr$-oLa4Hn*l6YS24FmpQRd7qmVYct$
zp`*o|B5RV0bEXHvcm<%grw(IO8%f3M&bq@1<3Q-_J2wXlpM@5&$a-@Fx4WyNmNr-2
zv%W(vhu98|l3UfBPs~7V2il`b&LhPPoPPESbXgYVW{aD}p94P+e%h&ems0cUi_<}>
z$pGK~L}Z=>?nD|ZD%o8*8`d45hnQQGtWm&L<Pj=ER=ale5G&x++^ZGnTv1`s)b$4o
z61sP8Rqk<qsg8UO|C2E`Gig2I+CJNr<ggmR27$?k_-C9y529$e3Pou^glYid;M_!z
zH_8)200v2qD-|yX`%CR#1RCYNSBKAqkAh_e4#}cw)K>eW&rnm$S2Gz@mP84Y4J31_
z@bDK6b+D+&D-|k<5nAxHJb3*9Uvn|1a<LD8l6>v(&Pn?&=uXc$C362{X;F^vsI3(%
z^2xB9>gho<BYfE>z+{R)VDlwX2_=TSZJ@BhPng&ZgiLEA8LB+(@<lwXWxGG0hLizh
z51a7VQ>@5~P0Pl6rkiv~pIGsdOm!+j@G)5veuCPlz638vc~p;$!k6lLDA+we0LhdL
zpb;w6P>XZyavd~LPEAZ)KAERP)_ofcco=8-u9OYeN^*zG;BH_U)Xg(5*TgL4Zu>Jf
z;5nhXbd+WDDwA`$OTJO`uvBsRWl}$%M>a=ec4L{7$D#RETD-hP&4p3TT5J3B_FAr7
z6SJd46K29hO9bWA9;A=p1qUJ1!ZiYoH5v45w)5$$Y5A+=h$;A{0Rj{utQHW&A$r*r
zk&YOu=sIu10dfd?rOCL^OM04><!_FtpEgR<kBRr`{lz^KvU>ox9<83zL;YqLG>IrN
zm^R>7DKFGEyL-lVLOw;urqTisw;m|e+*J}t>yLbX;)#Mlig^-g0VRfP*zLl6ll7gd
zR7EM$I|Cpr?QEl;Rk?K`hASh(@<;q`e0p*wyMc!s=ADK}%`Q3VpC5)_cgz2d4G%Nv
zt{}oiBd(NR@!GUZ!-bw$l;14bf=zl&e8LT4CG(_d|F9Ugsprn|h{&3AW79IOOB>R_
zS%E@Q+Pr05axa95^}gV=x{B0n%{is!^QYtxZAf_~>g%XAi8RZqVCZgsI;Rd7i}3Qo
zEn~JisTxCN1Yn$I0YJOtS8MBwCjwe(yue78;3;MGA*0D~DMGWZTS;!Xv~p~L6~M`J
z4x)vP5f&pvObKlb3uYb%(Ow=LQOCqQI*{D=Ywaj^4-yU!vg=g-O*P`>X|uiD-};q5
zB^5d~XpCZ0N!u2BlqeITGi2mb_@?L5f#-<6>w1k6_=noyRU!(ln_^#q;}`du#MFiX
z!DyA5ermQ#aS9G~_f`mn^<7AF2>M3`!Z8;CacTUqlV`0$kyuu>fyb88{F~Bc>S2YP
zh|8;H3xt*G&p1($I7FK!*0rQV(rlq=pl56(01KYR3=O%@XjW=Ew!za;N%k-dUpRur
zY@h2pxu5?KF*$0_>weM~$3t?D$HH%H3&d#?R(1f7#uDl4?&}7@lPNOU<G6$Y@6-;F
zSBQRl(5ATGZjcZfY91g&|B7lwJtBq^fN8Ss_EQrl=Bgr><iy9FyP{))pkI7<RUL5O
z+Q;E5d#U?_BJd`j2}t(dMSbx<WIIu2U9;=V;adf9(6I8DWixZNAQJr&tnDmeZlqk6
zG=*!$6a#YNy|WjAQ+lqw_8K~F^-e1jbqzjY1{ERESyAP+7ap+;-e`Ivh}Y*psbvhF
zz5mmhUp>mJs~%-mF(m1kTq2SI)J}j(8NL!@P~;Vl+uLF_Ehk(R>zi-JfsrLf5}HTO
z9hluS3|VA8@OgRp`st%TUgiv)KpUcw75E~3gP~x%SA*1N$<|~U9d|v)m(b@Rv!@#c
z__xAakY|tyLT4w#lF3BeS?^9vZ^{3SWO3IW;s^v~hq6F=-MPc(uG}1fMXcv4-Z-X0
z3WwrS@Um+K8t>YaZv#6QiYhTPI4T!}34dSTl35FIIcMTK99Wo7>Ne=)H@nMxZB`qw
z15Or?k?=Z40lxuM^9WD%ih1b5{=D9YF3ay&!7tJrPaG4#ADx!3j%zFX;Sh1#<0DHt
z!+!F18y=E1Z0CbC`iP7{SpZCrdol(&%E{I=_kh6m3$ccnJiND6hMGr(96{WdVZV-k
zR5@ioNAwkN^(j5n7f0XoWDRhp#b)vlfxA$~u3BK(0odV=<yB=YNSYp=!0*D9=<M`o
z>f5-R;WN3xUupF~4pydO_2F*01<Sx7f!)hrLPW4`EmOVOnNz>~P@_bI=+jtSDls+_
z9XIgV-N%vUPF@fou?tIcHxICU1V)^3&uHH=#^V#RI6@eatq6w(GPM&)*4}6eQbGBY
zRG;D+OOA;l=QNgEX~rD7wIpNVfBzKR`hmY^JO+a2uJ2O7ey&UEafd`4XAUlunPMtr
z=lkFVp>uw=T<l6;*-c)TOfkWS8zMosH+c(cF=un;=4;wW=lq2yaUR2NVxMV0ftX04
zb?@!C3mPn-k@+s|{W43>du<3BK<5%SlA`T9+Kx`;^d*(zo*et-yL&&KOAePR|IX6(
z*Xi|($i>3#3t6P-Bs5a)ncQ`nzUb(*X<8I<jBuejU<)A8zQploH}Nk>e;9azZ7>!b
z`Oy{t9L|CYgw6q2;5nv0p$8}_n4;~@A`+O1h5EpIx(kT?8|(0CfNbIYv!7!$=)LLL
z-z9l8)!wIR{Ai{^oG@yNQ(ZUP-G+VIqF}f|IhT<eA$=>hN7#-S$Tf|jrjJ>H|5rvz
zT>mF%CfGFV*Z1Z8NRVpRw675Sr@_JZDkzo3^<yMyf7S!~r)E!mD#^=m*UG03?q&km
zcn0p+Sdgy;;O+6K+np0BdQHTCU`=DVR@vz?zK{hf1(3ZwkW`9$g*kdtx=!_LUQ*c~
zIR75xqF#V+f3aXHfQ{)4pvwcuE<@3KdumZ0pj{5+4Gs%?knCL4p^_+G9v?Q)Q?vh!
zE<O@w+O<lHo))*u3tE}WA}TXTr#6r0vaG3BhY??N-fb#Gcx!BIIMuH_T0_zFe%gET
zTY3T1w`6_a_g*{LBxjcY>wjR2gm2P$S{}djiJ}(0n$Ve7bv==+j6I<ba?oQ|M=X0>
zY$0-BeL+<Y@7bSA7c>pF{13!Ss7*Y|dhEi~^@TgoD9*T`{>upe9GJRKw6`lW9RjE5
z+2i+v1`#=e7J81>&~SD44A%0Lbv)pi0Y)qOIFb+ME)#RXmW#XiLNJn2_<gDmtbmHn
z$vCR`cwD`Yd2>@ZTYcGI{Dm;fBuP$-)$E<H!8n=ncxVnF`3ff}n!M*j2?@*)p?6Ln
z2-5(oU-g`l*(~Qwc67-*JjaXH5W?98gHT_73(-_)7?yz%F-Q#G#ipSzMcic)f}RFv
zG1~jHsj&A6@XLM^M4|@R*?Lsh=lT^UpiniS<4%Q6?L4zT7tqGR=EZd#MsV>n`ne=N
z7p6ZAZ<*ab?YOh8c2xe~!B=P-XY!iHh0+ynLy!p?g?%u!K2n<@Uo!NQ?#y*Bn&me>
z7V}Yh_2>XhpS{U1Vp)k)WOjKt`1E2m#GliSKBFvCtjESdXHNPuFnkvS?Z&|J>I1S|
zIzpQrn9D6=Kh4mSlSwj_#%g)GcolMO3=!y33(ta!s3b{A?vck-dGAHXE?y%5TRY8N
zJg1uCwCQt_YAbyUgS=JqY$QD}nBf0WAjBoC4Xnn9{g10C#4-fhe4hbG)2RR+tN9{>
z72br_B$12%6w`OFX;?;&WEkA0eTfCIKJ<%6{A)@N?|bx7a-qu_sx;S|s70J_Z%B$H
zy9G&8XZo-l#5^kfP!eK}ag`X)xpp>K1&>7bwzgCmZ#VB?fQz#I^z_hI)zUm$4dD1I
z!TQAMY@xsF^A_PB$A`Ondq{4O7wup-m;`Zup2$_750ask5cXH9|EW}wd2!}c$q(5Q
zFD6})!IglJ0)_4lDcsj({RqoW1B*(lKwB#cC2snt8dirDB*_Lx-cJdY@jya|6GBVB
zjI9-EYeG7Jrc#b<6N1^UZGkOh=${y{t_#i*RVDprQVZ8QLKKFkEcZB_5t3Rejj9hc
z3*0UM0000$cSisFzz|p~#CO2npb!|HvVdV--~dp?@fn1}&k>z}Ysa_?IIX-JVUsW%
z$Oj5>KPC!$R|7`@cmS8TOyu-FKC3Gp(npG&voA=GG^$dztt)SB#4i@XLAzUbzzv@e
zp!TOXHRxoHsP;N&gc$SP5?x`~-Pxku)n5jzZLKtFKxz`&ux&^(r>%t~O{>6gB;Bud
zWH4+d<vBnnWI_{+_sLY(n$nYTacuKs+|G<)@*kGrRv%^JmKtVaZnT?t7nM|CGpr%_
z5R1rZu=JKfgJ<$lG1<GTaq_)xf<i!W{x^|1J1HA6O!THL3dSxTho#BU*o{wrClln}
zidL~Gdp%Vs*&+4SQ`TDr`rA+ABCftiwgSq3gD8Sxk+`ETjlTX76bN-<A7&`A^8D@_
zAFrS@A0G;JvZG%>tKD8iD_65%j6%!9Q3(6RKoV?G1p?5lxq?f25TH26B!u54@DI66
zXGH+sA%FnHfB*mhc$5nC0Ie{(HG$(caCJP|eA)~cAcC1XoP<h{!Gr}|?bZoq8Yu^1
zLg46LC+IJ$+Zmy?fd4Kd!{dHCDO=Ul0B~%Rm|Bs1dj3~y^$i(F<kn4{VEiaw;3o~3
zmIx)<t0x3OTKH*0UpBe;F5;T*;<r`FJKJPhr&Dq#RK_=$HBCG2Ps}0v(EKJnRHsQF
zh_`p5YV_I+LT+gM+P#cTZw@-Qr$3p-g|J|qgC&KZ?xc@HzP)oJDt5@Oo}Mz3o*dfp
z^JJf$gk$ZtwE2=Rlk9HhpC~aXm2fNDqmIS-1{DTgIwY1DS@3*|9g>+124{=c>SEQg
z2CY9DZQ=%OHxi4j&3X|OZ5#nVJ&xcK%K!iX10EkCxGl&||F8W3FBBwU)H`$qM%*4E
zUiFoZbqdZ5fhf$EEDwi?nhx)M@Zr=WC$wHG2SfG~#ESR(k{=aIEOT=M_aq&-9ERif
zAW|(A^Vn9pr@T0h;PuZEp34)jvyRuSbE*e29qV*h_UOEzqH#Nd>Jll>i(x<sM-kZJ
zb4i0!>q0U+M&!l^RCHIP;QA457SW4zRD6nIvm`V{u6{T*@kL)J#MjZl4u$~&v4ul%
zfz(KsBrti!F?E`>hgUnUP}n0iYtL+-wU-_$p1<P^$w)W@VXQ9uY0P7BNJd^0Yo1@C
zY5~Sk1X@4<008|S=OaIut&0IWdd2o8Df6@BuL?jBe4F!VE>n;t&IJIM7;3AY;VCJh
z>deMv!<`3@ZFq1qCUZ7$u?oS~M@ihf*zxi*AwQIJlO~L9(6$iQSWcL1*P5(0u|yo<
z(a!xq%n+w!=|!;7Q-A@Lf6yy29;IxQ&ttX>*i0mx-P^ZD9t}_J)`ZGCP)2un`XC^}
zy+nA=ns$#)Y1GV30&}bZ5%Nq~AOHXW5*}e`_LF~q-X7uyidDKbIbA*jkD18e0+>{F
zaY<ijWV);`%91E3KW?sQiNnKMpHvH^3A}(@7$7B_Mw4VHlK21s003&~+DdScm)4!&
z8X&OiTv-T<VeSL8(nA<Eoy~IlM<3Q&%<D>pYIenAeaOJ3X~`RtIW*v7p3f@b%QXSU
uQL>Llh1V_s000000031WnL#py;fE9;X)~vbb3<KenX6Y?OMwle@Bje4gR{v1

literal 0
HcmV?d00001

diff --git a/docs/readme/unseen-dark-still.webp b/docs/readme/unseen-dark-still.webp
new file mode 100644
index 0000000000000000000000000000000000000000..8050be4e6ad251170cf9017fdc0597746fd4d1f5
GIT binary patch
literal 30678
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
GssI2Bzj^!s

literal 0
HcmV?d00001

diff --git a/docs/readme/unseen-light-still.webp b/docs/readme/unseen-light-still.webp
new file mode 100644
index 0000000000000000000000000000000000000000..be34045eee77633c4cdfd51e2f40868fb87dc88b
GIT binary patch
literal 28712
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
Bf}j8Z

literal 0
HcmV?d00001


From a4d10080712fea3aff7ee7fd403538dc615ee87f Mon Sep 17 00:00:00 2001
From: Sam Gu <127461594+SamGu-NRX@users.noreply.github.com>
Date: Tue, 13 Oct 2026 18:23:06 -0500
Subject: [PATCH 15/62] fix(integration-viewer): show batches that drew no
 marks once older marks land

When an older batch's count timer was pending and a later batch could not
animate (motion paused, animation clock stopped, mark cap reached), the
later batch skipped its immediate count update and the older timer wrote
only its own snapshot, so the newest files stayed off the counters until
some unrelated render. The last pending timer now writes the current
totals; earlier timers still write their own snapshot, so a counter never
runs ahead of marks still travelling.

The timer bookkeeping moves out of app.js into count-timers.js so a test
can drive it with fake timers. Two of its four tests fail when the timer
writes only its snapshot, as on alpha.

Review thread: https://github.com/SamGu-NRX/BaseScanning/pull/124#discussion_r4114688573

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 tools/integration-viewer/README.md            |  4 +-
 tools/integration-viewer/public/app.js        | 19 ++---
 .../integration-viewer/public/count-timers.js | 37 +++++++++
 .../test/count-timers.test.js                 | 83 +++++++++++++++++++
 4 files changed, 127 insertions(+), 16 deletions(-)
 create mode 100644 tools/integration-viewer/public/count-timers.js
 create mode 100644 tools/integration-viewer/test/count-timers.test.js

diff --git a/tools/integration-viewer/README.md b/tools/integration-viewer/README.md
index b7b1df1fe..e9f9095c8 100644
--- a/tools/integration-viewer/README.md
+++ b/tools/integration-viewer/README.md
@@ -75,7 +75,7 @@ Sources are fixed at startup. The relay refuses other methods and paths, and any
 | `public/live.js` | Long-poll loop: catch-up reads until history is drained, then long polls that end by the next 5 s status refresh, with a 1 s floor, backoff up to 5 s that honors `Retry-After`, result and preview reads when events call for them |
 | `public/replay.js`, `public/scenario.js` | Illustrative replay and the synthetic scenarios both sources share |
 | `public/ply.js`, `public/cloud.js` | PLY reader (ascii and binary) and the canvas renderer |
-| `public/conduit.js`, `public/app.js` | The file line and the page wiring. Counts update on timers, never on an animation finishing, and a probe turns motion and transitions off when the browser's animation clock is stopped. |
+| `public/conduit.js`, `public/count-timers.js`, `public/app.js` | The file line, the timers that update the counts, and the page wiring. Counts update on timers, never on an animation finishing, and a probe turns motion and transitions off when the browser's animation clock is stopped. |
 
 ## Tests
 
@@ -84,7 +84,7 @@ cd tools/integration-viewer
 node --test "test/*.test.js"
 ```
 
-The tests cover the reducer (duplicates, ordering, cursor, stale sessions, unknown events, offline, no claimed result), the PLY reader, the relay through real HTTP requests (allowlist, traversal, Host check, signed-URL handling), and the live loop against the relay and a sped-up synthetic API, including a dropped connection. CI does not run them yet, because no workflow covers `tools/`.
+The tests cover the reducer (duplicates, ordering, cursor, stale sessions, unknown events, offline, no claimed result), the PLY reader, the relay through real HTTP requests (allowlist, traversal, Host check, signed-URL handling), the count timers (a batch that draws no marks while older marks travel still reaches the counters), and the live loop against the relay and a sped-up synthetic API, including a dropped connection. CI does not run them yet, because no workflow covers `tools/`.
 
 `test/browser.test.js` runs the page in headless Chrome with the animation clock stopped and frames drawn only on request, which is how an embedded preview panel behaved. It checks that the file counts match the events drawn in the same frame and that finished stages show their marker. It skips when no Chrome is found; set `CHROME_PATH` to point at one.
 
diff --git a/tools/integration-viewer/public/app.js b/tools/integration-viewer/public/app.js
index ede7ae806..fd48b60d3 100644
--- a/tools/integration-viewer/public/app.js
+++ b/tools/integration-viewer/public/app.js
@@ -3,6 +3,7 @@
 
 import { CloudView } from "./cloud.js";
 import { Conduit } from "./conduit.js";
+import { createCountTimers } from "./count-timers.js";
 import { followCapture } from "./live.js";
 import { connectionView, hasPreview, initialState, reduce, stageRows, stageTimingUninterpretable, viewsToShow } from "./model.js";
 import { REPLAY_CAPTURE_ID, ReplayPlayer } from "./replay.js";
@@ -50,7 +51,7 @@ let follower = null;
 const reducedMotion = matchMedia("(prefers-reduced-motion: reduce)");
 let motionPaused = reducedMotion.matches;
 let shownArrival = 0;
-const countTimers = new Set();
+const countTimers = createCountTimers({ write: writeCounts, current: () => state });
 let shownCounts = { session: -1, value: 0 };
 let clockStalled = false;
 let renderQueued = false;
@@ -74,7 +75,6 @@ function dispatch(action) {
 // ---- modes ----
 
 function stopAll() {
-  for (const timer of countTimers) clearTimeout(timer);
   countTimers.clear();
   player?.stop();
   player = null;
@@ -226,19 +226,10 @@ function renderArrivals() {
   if (fresh.length > 0) {
     shownArrival = fresh.at(-1).id;
     const landsIn = Math.max(...fresh.map((a) => conduit.send(a, { motion: motionOn() })));
-    if (landsIn > 0) {
-      // The counts change as the marks land. A timer does the update, so the counts stay current
-      // even where the marks' animations cannot run.
-      // Each timer shows the totals as of its own batch, so a counter never runs ahead of its marks.
-      const snapshot = state;
-      const timer = setTimeout(() => {
-        countTimers.delete(timer);
-        writeCounts(snapshot);
-      }, landsIn);
-      countTimers.add(timer);
-    }
+    // The counts change as the marks land.
+    if (landsIn > 0) countTimers.afterMarks(landsIn);
   }
-  if (countTimers.size === 0) writeCounts();
+  countTimers.settle();
   const backlog = counts.backlog;
   const parts = [];
   if (counts.registered != null) parts.push(`of ${counts.registered} registered`);
diff --git a/tools/integration-viewer/public/count-timers.js b/tools/integration-viewer/public/count-timers.js
new file mode 100644
index 000000000..58ea61e2e
--- /dev/null
+++ b/tools/integration-viewer/public/count-timers.js
@@ -0,0 +1,37 @@
+// Decides when the acknowledged-file counters change. A batch that draws marks shows its totals
+// when its last mark lands; a batch that draws none shows them at once, unless older marks are
+// still travelling, in which case it waits for them. Timers do the work, never an animation
+// finishing, because an animation never finishes where the animation clock is stopped.
+
+/**
+ * @template S
+ * @param {{ write: (from: S) => void, current: () => S, setTimer?: typeof setTimeout, clearTimer?: typeof clearTimeout }} options
+ *   `write` shows the totals in a state; `current` returns the latest state.
+ */
+export function createCountTimers({ write, current, setTimer = setTimeout, clearTimer = clearTimeout }) {
+  const pending = new Set();
+  return {
+    /** Shows the current totals once marks that land in `landsIn` ms have arrived. */
+    afterMarks(landsIn) {
+      // Each timer shows the totals as of its own batch, so a counter never runs ahead of its marks.
+      const snapshot = current();
+      const timer = setTimer(() => {
+        pending.delete(timer);
+        // The last timer shows the latest totals: batches that drew no marks while it waited (motion
+        // paused, clock stopped, too many marks in flight) skipped their own update. Every batch
+        // that drew marks has its own timer, so with none pending, no mark is still on its way.
+        write(pending.size === 0 ? current() : snapshot);
+      }, landsIn);
+      pending.add(timer);
+    },
+    /** Shows the current totals now, unless marks are still travelling. */
+    settle() {
+      if (pending.size === 0) write(current());
+    },
+    /** Drops pending updates, for a capture switch. */
+    clear() {
+      for (const timer of pending) clearTimer(timer);
+      pending.clear();
+    },
+  };
+}
diff --git a/tools/integration-viewer/test/count-timers.test.js b/tools/integration-viewer/test/count-timers.test.js
new file mode 100644
index 000000000..7fc2bdb3d
--- /dev/null
+++ b/tools/integration-viewer/test/count-timers.test.js
@@ -0,0 +1,83 @@
+import assert from "node:assert/strict";
+import { test } from "node:test";
+import { createCountTimers } from "../public/count-timers.js";
+
+// Timers fire only when the test says so, in the order they were set.
+function harness() {
+  let state = { acknowledged: 0 };
+  const shown = [];
+  const queue = new Map();
+  let id = 0;
+  const timers = createCountTimers({
+    write: (from) => shown.push(from.acknowledged),
+    current: () => state,
+    setTimer: (fn) => {
+      id += 1;
+      queue.set(id, fn);
+      return id;
+    },
+    clearTimer: (t) => queue.delete(t),
+  });
+  return {
+    timers,
+    shown,
+    arrive(acknowledged) {
+      state = { acknowledged };
+    },
+    fire(t) {
+      const fn = queue.get(t);
+      queue.delete(t);
+      fn();
+    },
+    get pending() {
+      return [...queue.keys()];
+    },
+  };
+}
+
+test("a batch that drew no marks while older marks travelled reaches the counters when they land", () => {
+  const h = harness();
+  h.arrive(5);
+  h.timers.afterMarks(1100);
+  h.timers.settle();
+  // Motion is paused (or the mark cap is hit) for the next batch, so it schedules nothing.
+  h.arrive(8);
+  h.timers.settle();
+  assert.deepEqual(h.shown, [], "counters moved while marks were still travelling");
+  h.fire(h.pending[0]);
+  assert.deepEqual(h.shown, [8]);
+});
+
+test("an earlier timer shows only its own batch while a later batch's marks still travel", () => {
+  const h = harness();
+  h.arrive(5);
+  h.timers.afterMarks(1100);
+  h.arrive(8);
+  h.timers.afterMarks(1100);
+  const [first, second] = h.pending;
+  h.fire(first);
+  assert.deepEqual(h.shown, [5]);
+  h.arrive(9); // drew no marks
+  h.timers.settle();
+  assert.deepEqual(h.shown, [5]);
+  h.fire(second);
+  assert.deepEqual(h.shown, [5, 9]);
+});
+
+test("with nothing travelling, the counters update at once", () => {
+  const h = harness();
+  h.arrive(3);
+  h.timers.settle();
+  assert.deepEqual(h.shown, [3]);
+});
+
+test("clear drops pending updates", () => {
+  const h = harness();
+  h.arrive(5);
+  h.timers.afterMarks(1100);
+  h.timers.clear();
+  assert.deepEqual(h.pending, []);
+  h.arrive(0);
+  h.timers.settle();
+  assert.deepEqual(h.shown, [0]);
+});

From 50c9ec40f9a9971109d11cec8acae4ff6e3f9dbb Mon Sep 17 00:00:00 2001
From: Sam Gu <127461594+SamGu-NRX@users.noreply.github.com>
Date: Tue, 13 Oct 2026 18:23:15 -0500
Subject: [PATCH 16/62] perf(integration-viewer): pick a batch's marks without
 listing every file

Conduit.send built an array entry for every acknowledged file before
capping the animation at six marks, so a large batch allocated memory in
proportion to its size just to draw a few marks. markGroups now walks the
per-group totals and returns only the marks, with the same evenly spaced
picks as before. send() returns before reading the batch when motion is
off, the batch predates the connection, or the line is not laid out.

The tests compare markGroups with the old expansion over small batches,
and check that a 5e9-file batch sends six marks and that motion-off reads
nothing. On alpha, the send() tests fail (RangeError and a read with
motion off).

Review thread: https://github.com/SamGu-NRX/BaseScanning/pull/124#discussion_r4115036581

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 tools/integration-viewer/README.md            |  2 +-
 tools/integration-viewer/public/conduit.js    | 33 ++++++++--
 tools/integration-viewer/test/conduit.test.js | 65 +++++++++++++++++++
 3 files changed, 94 insertions(+), 6 deletions(-)
 create mode 100644 tools/integration-viewer/test/conduit.test.js

diff --git a/tools/integration-viewer/README.md b/tools/integration-viewer/README.md
index e9f9095c8..3b41e63b3 100644
--- a/tools/integration-viewer/README.md
+++ b/tools/integration-viewer/README.md
@@ -84,7 +84,7 @@ cd tools/integration-viewer
 node --test "test/*.test.js"
 ```
 
-The tests cover the reducer (duplicates, ordering, cursor, stale sessions, unknown events, offline, no claimed result), the PLY reader, the relay through real HTTP requests (allowlist, traversal, Host check, signed-URL handling), the count timers (a batch that draws no marks while older marks travel still reaches the counters), and the live loop against the relay and a sped-up synthetic API, including a dropped connection. CI does not run them yet, because no workflow covers `tools/`.
+The tests cover the reducer (duplicates, ordering, cursor, stale sessions, unknown events, offline, no claimed result), the PLY reader, the relay through real HTTP requests (allowlist, traversal, Host check, signed-URL handling), the count timers (a batch that draws no marks while older marks travel still reaches the counters), the marks a batch sends (at most six, picked without listing every file), and the live loop against the relay and a sped-up synthetic API, including a dropped connection. CI does not run them yet, because no workflow covers `tools/`.
 
 `test/browser.test.js` runs the page in headless Chrome with the animation clock stopped and frames drawn only on request, which is how an embedded preview panel behaved. It checks that the file counts match the events drawn in the same frame and that finished stages show their marker. It skips when no Chrome is found; set `CHROME_PATH` to point at one.
 
diff --git a/tools/integration-viewer/public/conduit.js b/tools/integration-viewer/public/conduit.js
index 721307359..69af1f3ff 100644
--- a/tools/integration-viewer/public/conduit.js
+++ b/tools/integration-viewer/public/conduit.js
@@ -50,14 +50,14 @@ export class Conduit {
    * stopped, such as a hidden embedded preview.
    */
   send(arrival, { motion }) {
-    const groups = Object.entries(arrival.groups).flatMap(([group, n]) => Array(n).fill(group));
-    const marks = Math.min(groups.length, MAX_MARKS_PER_ARRIVAL, Math.max(0, MAX_IN_FLIGHT - this.inFlight));
-    if (!motion || arrival.backlog || marks === 0 || this.samples.length === 0) return 0;
-    const step = groups.length / marks;
+    if (!motion || arrival.backlog || this.samples.length === 0) return 0;
+    const groups = markGroups(arrival.groups, Math.min(MAX_MARKS_PER_ARRIVAL, MAX_IN_FLIGHT - this.inFlight));
+    const marks = groups.length;
+    if (marks === 0) return 0;
     for (let i = 0; i < marks; i += 1) {
       const chip = document.createElement("span");
       chip.className = "chip";
-      chip.dataset.group = groups[Math.floor(i * step)];
+      chip.dataset.group = groups[i];
       this.layer.append(chip);
       this.inFlight += 1;
       const frames = this.samples.map((pt, k) => ({
@@ -83,3 +83,26 @@ export class Conduit {
     }
   }
 }
+
+/**
+ * The group of each mark for a batch with `counts` files per group, at most `max` marks. The
+ * marks sample the batch evenly: list every file in group order, then take every
+ * (files / marks)-th. This walks the group totals instead of building that list, so a batch of
+ * any size costs a handful of steps.
+ * @param {Record<string, number>} counts
+ * @param {number} max
+ * @returns {string[]}
+ */
+export function markGroups(counts, max) {
+  let files = 0;
+  for (const group in counts) files += counts[group];
+  const marks = Math.max(0, Math.min(files, max));
+  const picked = [];
+  const step = files / marks;
+  let end = 0;
+  for (const group in counts) {
+    end += counts[group];
+    while (picked.length < marks && Math.floor(picked.length * step) < end) picked.push(group);
+  }
+  return picked;
+}
diff --git a/tools/integration-viewer/test/conduit.test.js b/tools/integration-viewer/test/conduit.test.js
new file mode 100644
index 000000000..220ebf5b9
--- /dev/null
+++ b/tools/integration-viewer/test/conduit.test.js
@@ -0,0 +1,65 @@
+import assert from "node:assert/strict";
+import { test } from "node:test";
+import { Conduit, markGroups } from "../public/conduit.js";
+
+// The rule markGroups must keep, written the way send() used to: list every file, take every step-th.
+function expanded(counts, max) {
+  const files = Object.entries(counts).flatMap(([group, n]) => Array(n).fill(group));
+  const marks = Math.max(0, Math.min(files.length, max));
+  const step = files.length / marks;
+  return Array.from({ length: marks }, (_, i) => files[Math.floor(i * step)]);
+}
+
+test("marks match the evenly spaced picks from the full file list", () => {
+  for (let photo = 0; photo <= 9; photo += 1)
+    for (let depth = 0; depth <= 7; depth += 1)
+      for (const other of [0, 1, 13])
+        for (let max = 0; max <= 6; max += 1) {
+          const counts = { photo, depth, mesh: 0, other };
+          assert.deepEqual(markGroups(counts, max), expanded(counts, max), JSON.stringify({ counts, max }));
+        }
+});
+
+test("a batch of billions picks its marks without listing the files", () => {
+  // Array(5e9) throws at once (the limit is 2 ** 32 - 1), so expanding the batch fails fast here
+  // instead of filling memory.
+  assert.deepEqual(markGroups({ photo: 5e9, depth: 5e9, mesh: 0, other: 0 }, 6), ["photo", "photo", "photo", "depth", "depth", "depth"]);
+  assert.deepEqual(markGroups({ photo: 5, depth: 1 }, -3), []);
+});
+
+function conduit() {
+  globalThis.ResizeObserver ??= class {
+    observe() {}
+  };
+  const chips = [];
+  const c = new Conduit({}, [], { append: (chip) => chips.push(chip) });
+  c.samples = Array.from({ length: 25 }, (_, i) => ({ x: i, y: 0 }));
+  return { c, chips };
+}
+
+test("with motion off, send returns at once without reading the batch", () => {
+  const { c, chips } = conduit();
+  const arrival = {
+    backlog: false,
+    get groups() {
+      throw new Error("send read the batch with motion off");
+    },
+  };
+  assert.equal(c.send(arrival, { motion: false }), 0);
+  assert.equal(chips.length, 0);
+});
+
+test("a huge batch sends at most six marks", (t) => {
+  t.mock.timers.enable({ apis: ["setTimeout"] });
+  globalThis.document ??= { createElement: () => ({ dataset: {}, animate() {}, remove() {} }) };
+  const { c, chips } = conduit();
+  const landsIn = c.send({ backlog: false, groups: { photo: 5e9, depth: 1, mesh: 0, other: 0 } }, { motion: true });
+  assert.equal(chips.length, 6);
+  assert.equal(landsIn, 1100 + 5 * 70);
+  assert.deepEqual(
+    chips.map((chip) => chip.dataset.group),
+    Array(6).fill("photo"),
+  );
+  t.mock.timers.tick(landsIn + 50);
+  assert.equal(c.inFlight, 0);
+});

From a92333eb701021704fe00c3518c6f5c324999771 Mon Sep 17 00:00:00 2001
From: Sam Gu <127461594+SamGu-NRX@users.noreply.github.com>
Date: Tue, 13 Oct 2026 18:23:09 -0500
Subject: [PATCH 17/62] packet: propose the ground height in the meter anchor's
 frame

Proposal 2 put the ground at a raw world groundY. ARKit corrects the meter
anchor as tracking improves (proposal 10), so a world height recorded at
one time and an anchor pose read at another give the server a wrong
meter-to-ground offset, and with it wrong vertical placement and headroom.
The proposal now carries groundOffset along the anchor's +y, which moves
with the meter, as AGENTS.md asks of AR results.

https://github.com/SamGu-NRX/BaseScanning/pull/22#discussion_r4114080314

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 packet/README.md | 9 +++++++--
 1 file changed, 7 insertions(+), 2 deletions(-)

diff --git a/packet/README.md b/packet/README.md
index 541ce1982..383845322 100644
--- a/packet/README.md
+++ b/packet/README.md
@@ -38,9 +38,14 @@ performance.
    adding once a device study measures it.
 2. **The ground's height at the meter.** 0.4 notes that world y = 0 is the phone's height at
    session start, not the ground. The app measures the ground where it can: the horizontal plane
-   below the meter. Proposal: `meterAnchor.groundY` (world meters) with `groundSource`
+   below the meter. Proposal: `meterAnchor.groundOffset`, the ground's height in the meter
+   anchor's frame (meters along its +y, negative below the meter), with `groundSource`
    (`plane`, `mesh`, `assumed`), so headroom and "ground under the battery" start from a
-   measurement when there is one.
+   measurement when there is one. A raw world `groundY` would stay put when ARKit corrects the
+   anchor (proposal 10), and the server would derive a wrong meter-to-ground offset; held in
+   the anchor's frame, the ground moves with the meter. The app's local packet 1.1 already
+   writes it this way: `meter_anchor.ground_y_m` is the ground's world y minus the anchor's, and
+   with `.gravity` alignment the anchor's +y is world up.
 3. **What a marked end or feature is.** 0.4's tap labels name the point, not the answers the
    homeowner gave about it:
    - whether a wall end is a real end (something blocks it) or unexplored (it turns a corner,

From 1f418a2e77a890773fac15623a5f8881eb36ebea Mon Sep 17 00:00:00 2001
From: Sam Gu <127461594+SamGu-NRX@users.noreply.github.com>
Date: Tue, 13 Oct 2026 18:23:44 -0500
Subject: [PATCH 18/62] docs(how-it-works): give phone and server text 4.5:1
 contrast in light mode

Links used --phone (#2a78d6, 4.04:1 on --bg) and the blue and orange SVG
labels used --phone and --server (#eb6834, 3.20:1 on --card), under the
4.5:1 WCAG AA minimum for normal text. New --phone-ink (#1e6ecb) and
--server-ink (#c44400) carry text: same hue, OKLCH lightness lowered until
they clear 4.5:1 on both backgrounds (4.63/5.06 and 4.61/5.03). Diagram
fills, strokes and the focus ring keep the original tokens, which only
need 3:1. In dark mode the ink tokens equal the fills, which already pass
(4.69:1 and 5.26:1 on --card).

Review thread: https://github.com/SamGu-NRX/BaseScanning/pull/14#discussion_r4112033407

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 docs/how-it-works.html | 12 +++++++++---
 1 file changed, 9 insertions(+), 3 deletions(-)

diff --git a/docs/how-it-works.html b/docs/how-it-works.html
index c4eec8c2c..d2d06eb49 100644
--- a/docs/how-it-works.html
+++ b/docs/how-it-works.html
@@ -11,6 +11,10 @@
     --sky:#e2edf8; --wall:#e8dcc4; --eave:#6b5a4a; --ground:#c9dcb0; --bush:#6f9a52;
     --tape:#f3cf4b; --tape-ink:#3d3106;
     --phone:#2a78d6; --server:#eb6834; --fog:#8d8d86; --battery:#2f3e4e;
+    /* Text in the phone and server colours. The fills above are 4.0:1 and 2.9:1 on --bg, too
+       faint for small text; these keep the hue with OKLCH lightness lowered until text clears
+       4.5:1 on --bg (4.63 and 4.61) and on --card (5.06 and 5.03). */
+    --phone-ink:#1e6ecb; --server-ink:#c44400;
     --meterbox:#6f7680; --meter:#a9d3f2; --gas:#b9b3a6; --glass:#bfe0f5;
     --zone:rgba(208,59,59,.14); --zone-line:#d03b3b;
     --pass:#107a2a; --fail:#b83232; --fail-ink:#a12b2b; --unsure:#fab219;
@@ -24,6 +28,8 @@
       --sky:#1c2734; --wall:#4a4033; --eave:#8a7562; --ground:#2f4128; --bush:#5d8a45;
       --tape:#7a6016; --tape-ink:#fff3c4;
       --phone:#3987e5; --server:#e8683a; --fog:#6e6e68; --battery:#cfd8e3;
+      /* The dark fills already read as text: 4.69:1 and 5.26:1 on --card. */
+      --phone-ink:#3987e5; --server-ink:#e8683a;
       --meterbox:#8f97a3; --meter:#5c8fb8; --gas:#7d786d; --glass:#6f9fbf;
       --zone:rgba(230,103,103,.22); --zone-line:#e66767;
       --pass:#107a2a; --fail:#b83232; --fail-ink:#f28b8b; --unsure:#fab219;
@@ -42,7 +48,7 @@
   .prose{max-width:58ch}
   .meta{font-family:var(--sans);color:var(--muted);font-size:15px}
   .lede{font-size:20px;line-height:1.45;max-width:60ch}
-  a{color:var(--phone);text-underline-offset:3px}
+  a{color:var(--phone-ink);text-underline-offset:3px}
   a:focus-visible,summary:focus-visible{outline:2px solid var(--phone);outline-offset:3px;border-radius:2px}
   code{font-family:var(--mono);font-size:.86em;background:var(--code-bg);padding:1px 5px;border-radius:3px;overflow-wrap:anywhere}
   ul,ol{padding-left:1.3em}
@@ -99,8 +105,8 @@
   .lab.s{font-size:16px}
   .lab.b{font-weight:600}
   /* Colour utilities come after .lab and .t so they win at equal specificity. */
-  .lab.blue,.t.blue{fill:var(--phone)}
-  .lab.orange,.t.orange{fill:var(--server)}
+  .lab.blue,.t.blue{fill:var(--phone-ink)}
+  .lab.orange,.t.orange{fill:var(--server-ink)}
   .lab.red,.t.red{fill:var(--fail-ink)}
   .lab.mu,.t.mu{fill:var(--muted)}
   .tp{font-family:var(--sans);font-size:15px;fill:var(--tape-ink);font-weight:600}

From 9c95004a34c701742b672cf88736cdc18facd70c Mon Sep 17 00:00:00 2001
From: Sam Gu <127461594+SamGu-NRX@users.noreply.github.com>
Date: Tue, 13 Oct 2026 18:25:45 -0500
Subject: [PATCH 19/62] verification(e2e): bound every answer by bytes and an
 overall deadline

post() read success and HTTPError bodies with an unbounded read(), and
urllib's timeout applies per socket operation, so a server that trickled
headers or body could hold a run past its budget or fill the harness's
memory.

post() now speaks http.client directly. A timer shuts the socket down at
timeout_s, which ends any read in progress, and the body is read in 64 KB
chunks up to MAX_RESPONSE_BYTES (4 MB) for every status. Past either limit
the answer is status None with the reason as payload, and the callers report
that reason. Tests use a local server that floods or trickles, for both 200
and 500, with a 16 KB cap and a 0.5 s deadline.

One behaviour change: http.client does not read http_proxy/https_proxy as
urllib did.

Review thread: https://github.com/SamGu-NRX/BaseScanning/pull/13#discussion_r4114226421

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 verification/hsverify/e2e.py   | 80 ++++++++++++++++++++++++++++------
 verification/tests/test_e2e.py | 67 +++++++++++++++++++++++++++-
 2 files changed, 132 insertions(+), 15 deletions(-)

diff --git a/verification/hsverify/e2e.py b/verification/hsverify/e2e.py
index 87e8bde35..be34d296b 100644
--- a/verification/hsverify/e2e.py
+++ b/verification/hsverify/e2e.py
@@ -21,7 +21,9 @@
 decision and outcome lengths), without or with less coverage, with ground trimmed just short
 of the largest clearance, with more error or tape re-measured by tap (nothing improves), and
 with every requested view added, up to three rounds (no check left unsure for coverage). Five
-hostile inputs must be refused or answered within 10 s and 500 MB of server growth.
+hostile inputs must be refused or answered within 10 s and 500 MB of server growth. Every
+answer, a result or an error, must arrive whole within its deadline and within 4 MB, or it
+counts as no answer.
 
 A run claims the contract (`contract_ok`) only when at least one scene was answered and
 checked and none broke it, and real-scene latency only from an HTTP 200 result.
@@ -36,6 +38,7 @@
 import contextlib
 import datetime as dt
 import hashlib
+import http.client
 import io
 import json
 import os
@@ -44,6 +47,7 @@
 import socket
 import subprocess
 import sys
+import threading
 import time
 import urllib.error
 import urllib.parse
@@ -354,10 +358,22 @@ def bundle_zip(item: SceneInput) -> bytes:
     return buf.getvalue()
 
 
+# The most of any response body the harness reads, a result or an error. Not derived from any
+# requirement: the largest result in the 20260927-102101 run against t3/server 1d1e7e1 was 16 KB
+# (eth3d-facade), so this leaves room for 250 times that.
+MAX_RESPONSE_BYTES = 4 * 2**20
+READ_CHUNK_BYTES = 2**16
+
+
 def post(
     url: str, endpoint: Endpoint, item: SceneInput, timeout_s: float = 60
 ) -> tuple[int | None, bytes, float]:
-    """Send one scene. A timeout or a dropped connection comes back as status None."""
+    """Send one scene and read the whole answer within `timeout_s`, headers and body together.
+
+    Status None means no complete answer, and the payload then says why: the deadline passed,
+    the body ran past MAX_RESPONSE_BYTES, or the connection failed. A socket timeout alone bounds
+    each read, not the response, so a server trickling bytes would never trip it; a timer shuts
+    the socket down at the deadline instead, which wakes any read in progress."""
     if item.bundle is not None and endpoint.accepts_zip:
         body, ctype = item.bundle, "application/zip"
     elif endpoint.content_type == "application/json":
@@ -373,18 +389,54 @@ def post(
             + f"\r\n--{boundary}--\r\n".encode()
         )
         ctype = f"multipart/form-data; boundary={boundary}"
-    request = urllib.request.Request(
-        url + endpoint.path, data=body, headers={"Content-Type": ctype}, method="POST"
+    target = urllib.parse.urlsplit(url + endpoint.path)
+    https = target.scheme == "https"
+    conn = (http.client.HTTPSConnection if https else http.client.HTTPConnection)(
+        target.netloc, timeout=timeout_s
     )
+    expired = threading.Event()
+    # Held here, not read from conn.sock: http.client drops that once the headers say the
+    # connection will close, while the body is still being read from the same socket.
+    sockets: list[socket.socket] = []
+
+    def expire() -> None:
+        expired.set()
+        for sock in sockets:
+            with contextlib.suppress(OSError):
+                sock.shutdown(socket.SHUT_RDWR)
+
+    timer = threading.Timer(timeout_s, expire)
+    timer.daemon = True
     start = time.perf_counter()
+    timer.start()
+    status: int | None = None
+    payload = bytearray()
     try:
-        with urllib.request.urlopen(request, timeout=timeout_s) as response:
-            status, payload = response.status, response.read()
-    except urllib.error.HTTPError as exc:
-        status, payload = exc.code, exc.read()
-    except (urllib.error.URLError, TimeoutError, ConnectionError) as exc:
-        status, payload = None, str(exc).encode()
-    return status, payload, (time.perf_counter() - start) * 1000
+        conn.connect()
+        sockets.append(conn.sock)
+        if expired.is_set():  # the timer fired before there was a socket to shut down
+            raise TimeoutError
+        path = target.path + (f"?{target.query}" if target.query else "")
+        conn.request("POST", path, body=body, headers={"Content-Type": ctype})
+        response = conn.getresponse()
+        while len(payload) <= MAX_RESPONSE_BYTES and (chunk := response.read(READ_CHUNK_BYTES)):
+            payload += chunk
+        status = response.status
+    except TimeoutError:
+        # One socket operation waited the whole timeout_s, so the deadline has passed too.
+        expired.set()
+    except (OSError, http.client.HTTPException) as exc:
+        status, payload = None, bytearray(f"{type(exc).__name__}: {exc}".encode())
+    finally:
+        timer.cancel()
+        conn.close()
+    ms = (time.perf_counter() - start) * 1000
+    if expired.is_set():
+        # A read cut short by the shutdown can look like a complete body; the deadline decides.
+        return None, f"no answer within {timeout_s:g} s".encode(), ms
+    if len(payload) > MAX_RESPONSE_BYTES:
+        return None, f"HTTP {status} body over {MAX_RESPONSE_BYTES} bytes".encode(), ms
+    return status, bytes(payload), ms
 
 
 # --- Judging ---------------------------------------------------------------------------------
@@ -412,7 +464,7 @@ def answer(url: str, endpoint: Endpoint, item: SceneInput) -> tuple[dict | None,
     """The server's result for a scene, or why there is none."""
     status, payload, _ = post(url, endpoint, item)
     if status is None:
-        return None, f"no answer: {payload.decode(errors='replace')[:200]}"
+        return None, payload.decode(errors="replace")[:200]
     if status != 200:
         return None, f"HTTP {status}: {payload[:300]!r}"
     result = parse_result(payload)
@@ -450,7 +502,7 @@ def judge(
         failure = [
             f"HTTP {status} for a scene that validates: {payload[:500]!r}"
             if status is not None
-            else f"no answer within 60 s: {payload[:200]!r}"
+            else payload.decode(errors="replace")[:200]
         ]
         return record | {"status": "fail", "problems": failure, "contract_problems": failure}
     result = parse_result(payload)
@@ -673,7 +725,7 @@ def judge_hostile(
     if grew > HOSTILE_MEMORY_MB:
         failure = f"the server grew by {grew:.0f} MB, budget {HOSTILE_MEMORY_MB} MB"
     elif status is None:
-        failure = f"no answer within {HOSTILE_BUDGET_MS / 1000 + 5:.0f} s"
+        failure = payload.decode(errors="replace")[:200]
     elif ms > HOSTILE_BUDGET_MS:
         failure = f"answered HTTP {status} after {ms:.0f} ms, budget {HOSTILE_BUDGET_MS:.0f}"
     elif status in (400, 413, 422):
diff --git a/verification/tests/test_e2e.py b/verification/tests/test_e2e.py
index 13d70f552..3d6f25575 100644
--- a/verification/tests/test_e2e.py
+++ b/verification/tests/test_e2e.py
@@ -1,3 +1,4 @@
+import contextlib
 import hashlib
 import io
 import json
@@ -5,7 +6,7 @@
 import threading
 import time
 import zipfile
-from http.server import BaseHTTPRequestHandler, HTTPServer
+from http.server import BaseHTTPRequestHandler, HTTPServer, ThreadingHTTPServer
 from typing import ClassVar
 
 import pytest
@@ -358,6 +359,70 @@ def test_a_slow_refusal_or_a_hang_fails(refusing_url, monkeypatch):
     assert record["status"] == "fail" and record["problems"][0].startswith("no answer within")
 
 
+class UnendingServer(BaseHTTPRequestHandler):
+    """Answers `status` with a body that never ends: written as fast as the client takes it
+    (`flood`), one byte at a time (`trickle`), or never reached because the headers come one
+    byte at a time (`slow headers`). Each answer stops on its own after 5 s."""
+
+    status = 200
+    mode = "flood"
+
+    def do_POST(self):
+        self.rfile.read(int(self.headers["Content-Length"]))
+        head = f"HTTP/1.0 {self.status} X\r\nContent-Type: application/json\r\n".encode()
+        until = time.monotonic() + 5
+        with contextlib.suppress(OSError):
+            if self.mode == "slow headers":
+                self.wfile.write(head)
+                while time.monotonic() < until:
+                    for byte in b"X-Pad: a\r\n":
+                        self.wfile.write(bytes([byte]))
+                        self.wfile.flush()
+                        time.sleep(0.02)
+                return
+            self.wfile.write(head + b"\r\n")
+            while time.monotonic() < until:
+                self.wfile.write(b" " * 4096 if self.mode == "flood" else b" ")
+                self.wfile.flush()
+                if self.mode == "trickle":
+                    time.sleep(0.02)
+
+    def log_message(self, *args):
+        pass
+
+
+@pytest.fixture
+def unending_url():
+    class Server(ThreadingHTTPServer):
+        block_on_close = False  # an answer still running must not hold up the next test
+
+    server = Server(("127.0.0.1", 0), UnendingServer)
+    threading.Thread(target=server.serve_forever, daemon=True).start()
+    yield f"http://127.0.0.1:{server.server_port}"
+    server.shutdown()
+    server.server_close()
+
+
+@pytest.mark.parametrize("status", [200, 500])
+def test_an_endless_body_is_cut_at_the_byte_cap(unending_url, monkeypatch, status):
+    monkeypatch.setattr(e2e, "MAX_RESPONSE_BYTES", 2**14)
+    monkeypatch.setattr(UnendingServer, "status", status)
+    got, payload, ms = e2e.post(unending_url, Endpoint("/p", "application/json"), item(), 5)
+    assert got is None and payload == f"HTTP {status} body over 16384 bytes".encode()
+    assert ms < 4000
+
+
+@pytest.mark.parametrize("status", [200, 500])
+@pytest.mark.parametrize("mode", ["trickle", "slow headers"])
+def test_a_trickled_answer_stops_at_the_overall_deadline(unending_url, monkeypatch, status, mode):
+    """Every byte arrives well inside the 0.5 s socket timeout; only the deadline ends it."""
+    monkeypatch.setattr(UnendingServer, "status", status)
+    monkeypatch.setattr(UnendingServer, "mode", mode)
+    got, payload, ms = e2e.post(unending_url, Endpoint("/p", "application/json"), item(), 0.5)
+    assert (got, payload) == (None, b"no answer within 0.5 s")
+    assert 500 <= ms < 2500
+
+
 def test_hostile_inputs_are_small_to_send():
     items = hostile_inputs()
     assert all(i.hostile for i in items)

From 6ddd2297e7cae69d28136224925ed4b27b19152f Mon Sep 17 00:00:00 2001
From: Sam Gu <127461594+SamGu-NRX@users.noreply.github.com>
Date: Tue, 13 Oct 2026 18:25:48 -0500
Subject: [PATCH 20/62] experiments(edge-geometry): rerun M3 with the widest
 photo pair on request

M3 pairs each point's reference photo with the narrowest ray angle at or
above 5 degrees, which keeps the patches alike for matching but
triangulates worst. `--pair=widest` picks the widest qualifying angle and
writes results/edge_geometry_widest_pair.*, leaving the pre-registered
tables alone, so the two policies can be compared before M3's error is
treated as representative.

https://github.com/SamGu-NRX/BaseScanning/pull/59#discussion_r4115044359

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 experiments/edge-geometry/run.py | 24 +++++++++++++++++-------
 1 file changed, 17 insertions(+), 7 deletions(-)

diff --git a/experiments/edge-geometry/run.py b/experiments/edge-geometry/run.py
index 2d62dc943..45adbd688 100644
--- a/experiments/edge-geometry/run.py
+++ b/experiments/edge-geometry/run.py
@@ -2,6 +2,7 @@
 whether a ray to the wall plane, a snapped tap or a second photo places an edge better.
 
     uv run python run.py        # writes results/edge_geometry.json and results/edge_geometry.md
+    uv run python run.py --pair=widest   # M3 with the widest pair: results/edge_geometry_widest_pair.*
 
 Reads the evals harness read-only (EDGE_EVALS_DIR, default below) and its caches under
 ~/house-scanning-data/evals: the ETH3D scenes after `evals.recon prepare`, MoGe-2 predictions
@@ -81,6 +82,10 @@
 WORLD_PLANE_PX_PER_PHOTO = 3000
 MIN_BASELINE_M = 0.3
 MIN_RAY_ANGLE_DEG = 5.0
+# M3's second photo, pre-registered: the narrowest ray angle at or above MIN_RAY_ANGLE_DEG, which
+# keeps the two patches most alike for matching. A narrow pair triangulates worst, so after review
+# `--pair=widest` reruns M3 with the widest qualifying angle instead, into separate results files.
+PAIRING = "widest" if "--pair=widest" in sys.argv else "narrowest"
 NCC_MIN = 0.8
 NCC_PATCH = 15
 DEPTH_RANGE_M = (0.5, 10.0)
@@ -451,13 +456,14 @@ def multi_photo_methods(scene, ids, P, plane, planes, frames, names, vd, obs, up
         ref = min(flagged or range(len(members)), key=lambda i: dist[i])
         rn = members[ref][0]
         second = None
-        best_angle = np.inf
+        best_angle = np.inf if PAIRING == "narrowest" else -np.inf
         for n, r in members:
             if n == rn or np.linalg.norm(vd[n].C - vd[rn].C) < MIN_BASELINE_M:
                 continue
             a, b = p - vd[rn].C, p - vd[n].C
             ang = np.degrees(np.arccos(np.clip(a @ b / np.linalg.norm(a) / np.linalg.norm(b), -1, 1)))
-            if MIN_RAY_ANGLE_DEG <= ang < best_angle:
+            better = ang < best_angle if PAIRING == "narrowest" else ang > best_angle
+            if ang >= MIN_RAY_ANGLE_DEG and better:
                 second, best_angle = (n, r), ang
         plan[j] = (g, members, ref, second)
 
@@ -785,7 +791,9 @@ def pct(x: np.ndarray) -> dict:
 
 def main() -> None:
     RESULTS.mkdir(exist_ok=True)
+    suffix = "" if PAIRING == "narrowest" else "_widest_pair"
     report: dict = {
+        "m3_pairing": PAIRING,
         "evals_commit": evals_commit(),
         "evals_dir": str(EVALS_DIR).replace(str(Path.home()), "~"),
         "parameters": {k: v for k, v in globals().items() if k.isupper() and isinstance(v, (int, float, tuple))},
@@ -793,7 +801,7 @@ def main() -> None:
     }
     # `--from-raw` re-summarises the per-point records of the last full run (data/, git-ignored).
     for scene in SCENES:
-        raw = HERE / "data" / f"raw_{scene}.pkl"
+        raw = HERE / "data" / f"raw_{scene}{suffix}.pkl"
         if "--from-raw" in sys.argv:
             res = pickle.loads(raw.read_bytes())
         else:
@@ -807,9 +815,9 @@ def main() -> None:
         summary = {"meta": res["meta"], "single": summarise_single(single), "multi": summarise_multi(multi)}
         summary["criteria"] = grade(single, multi)
         report["scenes"][scene] = summary
-    (RESULTS / "edge_geometry.json").write_text(json.dumps(report, indent=1, default=float) + "\n")
-    (RESULTS / "edge_geometry.md").write_text(markdown(report))
-    print((RESULTS / "edge_geometry.md").read_text())
+    (RESULTS / f"edge_geometry{suffix}.json").write_text(json.dumps(report, indent=1, default=float) + "\n")
+    (RESULTS / f"edge_geometry{suffix}.md").write_text(markdown(report))
+    print((RESULTS / f"edge_geometry{suffix}.md").read_text())
 
 
 def p90_in(x: np.ndarray) -> float:
@@ -850,7 +858,9 @@ def markdown(report: dict) -> str:
     L = [
         "# Edge geometry (generated by `uv run python run.py`)",
         "",
-        f"Evals harness commit `{report['evals_commit']}`. Errors in inches, median / p90 (points).",
+        f"Evals harness commit `{report['evals_commit']}`. Errors in inches, median / p90 (points). "
+        f"M3 pairs each point's reference photo with the {report.get('m3_pairing', 'narrowest')} "
+        f"qualifying ray angle.",
     ]
     for scene, r in report["scenes"].items():
         L += ["", f"## {scene}", "", f"`{json.dumps(r['meta'])}`"]

From be450fde1c1fb71f25aebe21029719248474e654 Mon Sep 17 00:00:00 2001
From: Sam Gu <127461594+SamGu-NRX@users.noreply.github.com>
Date: Tue, 13 Oct 2026 18:27:02 -0500
Subject: [PATCH 21/62] live-dots: reset the fog mask when the view jumps

The fog's lagged reveal mask eased from the previous frame unless the
frame was settled. A scrub during playback, a LiDAR mode switch or the
fog coming back on therefore eased from another view's mask and briefly
left unmeasured regions clear. The renderer now snaps the mask unless the
frame continues the last fogged one (same mode, same or next keyframe).

Review thread: https://github.com/SamGu-NRX/BaseScanning/pull/86#discussion_r4115037778

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 .../live-dots/Sources/LiveDots/DotRenderer.swift     | 12 +++++++++++-
 .../live-dots/Sources/LiveDots/FogLayer.swift        |  2 +-
 2 files changed, 12 insertions(+), 2 deletions(-)

diff --git a/experiments/live-dots/Sources/LiveDots/DotRenderer.swift b/experiments/live-dots/Sources/LiveDots/DotRenderer.swift
index bb7ca2926..0ddfa72cf 100644
--- a/experiments/live-dots/Sources/LiveDots/DotRenderer.swift
+++ b/experiments/live-dots/Sources/LiveDots/DotRenderer.swift
@@ -60,6 +60,8 @@ final class DotRenderer {
     private var linkBuffer: MTLBuffer?
     private var linkVertexCount = 0
     private var cachedKey: (mode: CaptureMode, keyframe: Int, scheme: DotScheme)?
+    /// The view the fog mask was last built for; nil while the fog is not drawn.
+    private var fogView: (mode: CaptureMode, keyframe: Int)?
     /// Replaces the timeline's sprites, for the 6,000-dot benchmark.
     var spriteOverride: [DotSprite]? {
         didSet { cachedKey = nil }
@@ -121,10 +123,18 @@ final class DotRenderer {
 
         var clip = projection.clipMatrix
         if request.fog == .on {
+            // The lag eases the mask only between frames of one playback (same keyframe or the
+            // next). After a jump, a mode switch or the fog coming back on, the old mask belongs
+            // to another view and would leave unmeasured regions clear.
+            let continues = fogView.map { $0.mode == request.mode && (0...1).contains(request.keyframe - $0.keyframe) } ?? false
             fog.encodeMask(
                 into: commandBuffer, splats: splatBuffer, splatCount: splatCount, clip: clip,
                 pixelsPerMetre: keyframe.intrinsics.x * projection.scale * Float(FogLayer.maskWidth) / pixelSize.x,
-                time: request.time, dt: request.frameInterval, reduceMotion: request.reduceMotion, reset: request.isSettled)
+                time: request.time, dt: request.frameInterval, reduceMotion: request.reduceMotion,
+                reset: request.isSettled || !continues)
+            fogView = (request.mode, request.keyframe)
+        } else {
+            fogView = nil
         }
 
         guard let encoder = commandBuffer.makeRenderCommandEncoder(descriptor: pass) else { return }
diff --git a/experiments/live-dots/Sources/LiveDots/FogLayer.swift b/experiments/live-dots/Sources/LiveDots/FogLayer.swift
index 974a49111..83dc4598b 100644
--- a/experiments/live-dots/Sources/LiveDots/FogLayer.swift
+++ b/experiments/live-dots/Sources/LiveDots/FogLayer.swift
@@ -86,7 +86,7 @@ final class FogLayer {
     }
 
     /// Splats, blurs and eases the reveal mask. `reset` snaps the lag to the new mask (a scrub, a
-    /// still, the first frame).
+    /// mode switch, the fog turned back on, a still); the first frame always snaps.
     func encodeMask(
         into commandBuffer: MTLCommandBuffer, splats: MTLBuffer?, splatCount: Int, clip: simd_float4x4,
         pixelsPerMetre: Float, time: Float, dt: Float, reduceMotion: Bool, reset: Bool

From dd7691e49f0614079a031841e01dedd52ecc7dfa Mon Sep 17 00:00:00 2001
From: Sam Gu <127461594+SamGu-NRX@users.noreply.github.com>
Date: Tue, 13 Oct 2026 18:27:02 -0500
Subject: [PATCH 22/62] live-dots: carve free space only from confident depth

Surface fusion skips depth pixels below medium confidence, but free-space
carving read them anyway. A low-confidence zero or far reading could mark
a wall voxel's neighbour as seen-empty, and since free space and edges are
both sticky, that left a lasting false boundary edge. Carving now applies
the same confidence gate. The new tests build one keyframe of a flat wall
with a strip of bad depth and check that only a confident hole carves.

Review thread: https://github.com/SamGu-NRX/BaseScanning/pull/86#discussion_r4115037781

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 .../Sources/LiveDotsCore/DepthMap.swift       | 11 ++++-
 .../Sources/LiveDotsCore/DotField.swift       | 13 ++++--
 .../LiveDotsCoreTests/FieldRuleTests.swift    | 41 +++++++++++++++++++
 3 files changed, 60 insertions(+), 5 deletions(-)

diff --git a/experiments/live-dots/Sources/LiveDotsCore/DepthMap.swift b/experiments/live-dots/Sources/LiveDotsCore/DepthMap.swift
index 6fbb8ce9d..78a79704f 100644
--- a/experiments/live-dots/Sources/LiveDotsCore/DepthMap.swift
+++ b/experiments/live-dots/Sources/LiveDotsCore/DepthMap.swift
@@ -43,10 +43,19 @@ public struct DepthMap: Sendable {
 
     /// Depth at the pixel containing continuous coordinate (u, v), or nil outside the map.
     public func depth(atU u: Float, v: Float) -> Float? {
+        index(atU: u, v: v).map { meters[$0] }
+    }
+
+    /// Confidence at the pixel containing continuous coordinate (u, v), or nil outside the map.
+    public func confidence(atU u: Float, v: Float) -> UInt8? {
+        index(atU: u, v: v).map { confidence[$0] }
+    }
+
+    private func index(atU u: Float, v: Float) -> Int? {
         guard u >= 0, v >= 0 else { return nil }
         let i = Int(u), j = Int(v)
         guard i < width, j < height else { return nil }
-        return meters[j * width + i]
+        return j * width + i
     }
 }
 
diff --git a/experiments/live-dots/Sources/LiveDotsCore/DotField.swift b/experiments/live-dots/Sources/LiveDotsCore/DotField.swift
index 33836f984..324d16f49 100644
--- a/experiments/live-dots/Sources/LiveDotsCore/DotField.swift
+++ b/experiments/live-dots/Sources/LiveDotsCore/DotField.swift
@@ -13,8 +13,9 @@
 //   (a) a face neighbour's normal differs by more than 35 degrees (the wall-to-ground corner,
 //       the bin's corners);
 //   (b) it has surface along one side and seen-empty space along another (the wall's top against
-//       the sky, the bin's silhouette). Seen-empty means a depth ray passed the neighbour with
-//       10 cm to spare, so the edge of what has been scanned so far is never an edge; or
+//       the sky, the bin's silhouette). Seen-empty means a depth ray of medium or high confidence
+//       passed the neighbour with 10 cm to spare, so the edge of what has been scanned so far is
+//       never an edge; or
 //   (c) the colour gradient at its samples reaches 0.2 (painted outlines). The gradient is read
 //       from a pyramid level whose pixel spans about one voxel, and ignored near a depth
 //       silhouette, where the colour step is occlusion rather than paint. On the fixture
@@ -226,7 +227,9 @@ public struct VoxelField: Sendable {
     /// Tests the empty in-plane neighbours of occupied voxels against this keyframe's depth: a
     /// neighbour is seen-empty when the ray through it hit nothing or hit something farther by
     /// `Tuning.freeSpaceMargin`. A neighbour outside the view or behind something stays unknown,
-    /// which is why the edge of what has been scanned so far never counts as a boundary.
+    /// which is why the edge of what has been scanned so far never counts as a boundary. So does
+    /// one whose depth pixel is below `Tuning.minimumConfidence`: fusion ignores that pixel, and
+    /// free space is never forgotten, so one bad zero or far reading would leave a lasting edge.
     mutating func carveFreeSpace(_ frame: FrameInput) {
         let depth = frame.depth
         let worldToCamera = frame.keyframe.cameraToWorld.inverse
@@ -239,7 +242,9 @@ public struct VoxelField: Sendable {
                 let camera = CameraMath.transform(worldToCamera, centre(of: neighbour))
                 guard let pixel = CameraMath.project(camera, intrinsics: depth.intrinsics),
                       pixel.depth >= Tuning.depthRange.lowerBound,
-                      let measured = depth.depth(atU: pixel.u, v: pixel.v)
+                      let measured = depth.depth(atU: pixel.u, v: pixel.v),
+                      let confidence = depth.confidence(atU: pixel.u, v: pixel.v),
+                      confidence >= Tuning.minimumConfidence
                 else { continue }
                 if measured == 0 || measured > pixel.depth + Tuning.freeSpaceMargin { found.insert(neighbour) }
             }
diff --git a/experiments/live-dots/Tests/LiveDotsCoreTests/FieldRuleTests.swift b/experiments/live-dots/Tests/LiveDotsCoreTests/FieldRuleTests.swift
index 0bb451250..13f2d20bd 100644
--- a/experiments/live-dots/Tests/LiveDotsCoreTests/FieldRuleTests.swift
+++ b/experiments/live-dots/Tests/LiveDotsCoreTests/FieldRuleTests.swift
@@ -45,6 +45,47 @@ struct FieldRuleTests {
         #expect(!field.free.contains(VoxelKey(4, 4, 0)))
     }
 
+    /// One keyframe square on to a flat wall at z = 0 from 2.5 m, with depth columns 39 and 40
+    /// (the strip over voxel column x = 0) replaced by `stripDepth` at `stripConfidence`.
+    func wallWithStrip(stripDepth: Float, stripConfidence: UInt8) -> VoxelField {
+        let width = 80, height = 60
+        var meters = [Float](repeating: 2.5, count: width * height)
+        var confidence = [UInt8](repeating: 2, count: width * height)
+        for j in 0..<height {
+            for i in 39...40 {
+                meters[j * width + i] = stripDepth
+                confidence[j * width + i] = stripConfidence
+            }
+        }
+        // 100 px focal at 2.5 m puts two depth pixels in each 5 cm voxel.
+        let intrinsics = SIMD4<Float>(100, 100, 40, 30)
+        let depth = DepthMap(meters: meters, confidence: confidence, width: width, height: height, intrinsics: intrinsics)
+        let pose = simd_float4x4(columns: (SIMD4(1, 0, 0, 0), SIMD4(0, 1, 0, 0), SIMD4(0, 0, 1, 0), SIMD4(0, 0, 2.5, 1)))
+        let keyframe = Keyframe(
+            id: "k", imagePath: "k.jpg", width: width, height: height, intrinsics: intrinsics,
+            cameraToWorld: pose, timestamp: 0, depth: nil)
+        let image = RGBImage(width: width, height: height, rgba: [UInt8](repeating: 128, count: width * height * 4))
+        var field = VoxelField()
+        field.integrate(FrameInput(index: 0, keyframe: keyframe, depth: depth, gradient: GradientPyramid(image: image)))
+        return field
+    }
+
+    @Test func `a confident hole in the wall carves free space and makes boundary edges`() {
+        let field = wallWithStrip(stripDepth: 0, stripConfidence: 2)
+        #expect(field.voxels[VoxelKey(0, 0, 0)] == nil)
+        #expect(field.free.contains(VoxelKey(0, 0, 0)))
+        #expect(field.voxels[VoxelKey(1, 0, 0)]?.isEdge == true)
+        #expect(field.voxels[VoxelKey(-1, 0, 0)]?.isEdge == true)
+    }
+
+    @Test(arguments: [Float(0), 9])
+    func `low-confidence depth carves no free space`(stripDepth: Float) {
+        let field = wallWithStrip(stripDepth: stripDepth, stripConfidence: 0)
+        #expect(field.voxels[VoxelKey(0, 0, 0)] == nil, "fusion skips the strip")
+        #expect(!field.free.contains(VoxelKey(0, 0, 0)))
+        #expect(field.voxels.values.allSatisfy { !$0.isEdge }, "a flat wall with no confident hole has no edges")
+    }
+
     @Test func `the gradient threshold makes an image edge`() {
         var field = VoxelField()
         for x in Int32(0)..<3 {

From bccb4d63100c1389d5257e197ebead4b479f5473 Mon Sep 17 00:00:00 2001
From: Sam Gu <127461594+SamGu-NRX@users.noreply.github.com>
Date: Tue, 13 Oct 2026 18:27:03 -0500
Subject: [PATCH 23/62] live-dots: reject a --still offset that plays into the
 next keyframe

`--still 2 --at 0.3` rendered keyframe 3 while the log named keyframe 2
and printed its stats. Stills are named and compared by keyframe, so the
export now fails with the keyframe's on-screen time instead of writing a
mislabelled image. The last keyframe takes any offset, since it stays on
screen.

Review thread: https://github.com/SamGu-NRX/BaseScanning/pull/86#discussion_r4115037787

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 .../live-dots/Sources/LiveDots/Exporter.swift      | 14 +++++++++++---
 1 file changed, 11 insertions(+), 3 deletions(-)

diff --git a/experiments/live-dots/Sources/LiveDots/Exporter.swift b/experiments/live-dots/Sources/LiveDots/Exporter.swift
index 2e50429d8..e6f6ad043 100644
--- a/experiments/live-dots/Sources/LiveDots/Exporter.swift
+++ b/experiments/live-dots/Sources/LiveDots/Exporter.swift
@@ -51,14 +51,22 @@ enum Exporter {
     }
 
     /// One keyframe as a PNG. Without `at`, the keyframe settled: every animation finished and
-    /// the fog lag caught up. With `at`, the moment `at` seconds after the keyframe appears,
-    /// reached by playing the replay from the start at 30 fps, so the fog's lag is what the
-    /// video shows.
+    /// the fog lag caught up. With `at`, the moment `at` seconds after the keyframe appears, before
+    /// the next one replaces it, reached by playing the replay from the start at 30 fps, so the
+    /// fog's lag is what the video shows.
     static func exportStill(keyframe number: Int, at offset: Float?, to path: String, options: Command.RenderOptions) throws {
         let data = try ReplayData.loadNow(folder: FixtureLocator.folder(options.fixture))
         guard number <= data.keyframeCount else {
             throw Failure(description: "--still \(number) is past the last keyframe, \(data.keyframeCount)")
         }
+        // Stills are named and compared by keyframe, so an offset that plays into the next
+        // keyframe would label one keyframe's image with another's number.
+        if let offset, Schedule.keyframe(at: Schedule.start(of: number - 1) + offset, count: data.keyframeCount) != number - 1 {
+            let slot = Schedule.start(of: number) - Schedule.start(of: number - 1)
+            throw Failure(description: String(
+                format: "--at %g is past keyframe %d, which is on screen for %g s; use a smaller --at or --still %d",
+                offset, number, slot, number + 1))
+        }
         let renderer = try DotRenderer(data: data)
         let target = try OffscreenTarget(renderer: renderer)
         let state = data.timeline(options.mode).states[number - 1]

From 6284b5102c4a77af77db74cfca7e9a4e502143b3 Mon Sep 17 00:00:00 2001
From: Sam Gu <127461594+SamGu-NRX@users.noreply.github.com>
Date: Tue, 13 Oct 2026 18:27:03 -0500
Subject: [PATCH 24/62] live-dots: show feature points in the constellation
 scheme

Constellation delays a dot's birth to when it became an edge. Feature
points never do, so their edge time is the clamped 1e6 s and every
simulated no-LiDAR point stayed hidden. The delay now applies only to
voxel dots.

Review thread: https://github.com/SamGu-NRX/BaseScanning/pull/86#discussion_r4115916347

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 experiments/live-dots/Sources/LiveDots/Shaders.swift | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/experiments/live-dots/Sources/LiveDots/Shaders.swift b/experiments/live-dots/Sources/LiveDots/Shaders.swift
index 528c732f1..463efa25e 100644
--- a/experiments/live-dots/Sources/LiveDots/Shaders.swift
+++ b/experiments/live-dots/Sources/LiveDots/Shaders.swift
@@ -86,8 +86,9 @@ enum Shaders {
     constant float3 emberHalo = float3(0xFF, 0xC9, 0x78) / 255.0f;
 
     // Constellation hides flat dots, so a dot that turns edge is born then, not at its voxel's birth.
+    // Feature points never become edges, and their edge time of 1e6 s would hide them for good.
     static float visibleBirth(Sprite s, int scheme) {
-        return scheme == 1 ? max(s.b.x, s.c.x) : s.b.x;
+        return scheme == 1 && s.a.w < 0.5f ? max(s.b.x, s.c.x) : s.b.x;
     }
 
     struct DotOut {

From d2085b0d5ae17025456e40632ccb6f1ce0228e95 Mon Sep 17 00:00:00 2001
From: Sam Gu <127461594+SamGu-NRX@users.noreply.github.com>
Date: Tue, 13 Oct 2026 18:27:23 -0500
Subject: [PATCH 25/62] verification(sim-app): require the ordered capture and
 upload flow

make sim-app passed any run that reached STATE=result and logged a bundle,
so an app that showed a cached or prebuilt scan straight away passed too.

simrun gains --require-order (states that must appear in that order, others
allowed between) and --require-then FIRST:THEN (every FIRST must be followed
later by a THEN). sim-app now requires findMeter > meterCloseUp > wallWalk >
markFeatures > uploading > result, and gapRequest:uploading, so a recapture
round the app opens has to end in another upload. The names are ScanPhase on
t3/ios-mvf. A round the app never opens leaves no STATE behind, and these
checks cannot see it.

The tests read the flags from the Makefile recipe. They accept the state
sequences of recorded runs at a39d0a5, f14947e and c820cf1 and reject a jump
to the result, a result without an upload, an upload before the walk, and a
gap request that never led to an upload.

Review thread: https://github.com/SamGu-NRX/BaseScanning/pull/13#discussion_r4114865922

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 verification/Makefile                   | 13 +++--
 verification/hsverify/simrun.py         | 52 +++++++++++++++++-
 verification/tests/test_sim_app_flow.py | 72 +++++++++++++++++++++++++
 verification/tests/test_simrun.py       |  6 ---
 4 files changed, 132 insertions(+), 11 deletions(-)
 create mode 100644 verification/tests/test_sim_app_flow.py

diff --git a/verification/Makefile b/verification/Makefile
index de79d452a..b19381ff9 100644
--- a/verification/Makefile
+++ b/verification/Makefile
@@ -22,12 +22,17 @@ sim:
 	uv run python -m hsverify.simrun --ref $(REF) $(ARGS)
 
 # The app at REF on the real ADVIO replay (C3), driven by its autopilot, uploading to the server
-# started from SERVER_REF (or at SERVER_URL): a screenshot per STATE in ~/house-scanning-data/reports/sim/. Fails
-# unless the run reaches the result state; the scan bundle is copied into the report as scan.zip.
+# started from SERVER_REF (or at SERVER_URL): a screenshot per STATE in ~/house-scanning-data/reports/sim/.
+# Fails unless the run walks the flow in order (meter, close-up, wall walk, feature review,
+# upload, result) and uploads after every gap request it shows, so each recapture round ends in
+# an upload. Reaching `result` alone would also pass an app that showed a cached answer. A round
+# the app never opens leaves no STATE to check. The scan bundle is copied into the report as
+# scan.zip. State names are ScanPhase in ios/HouseScan/Contract/ScanContract.swift.
 sim-app:
 	uv run python -m hsverify.simrun --ref $(REF) --replay $(REPLAY) --autopilot \
-		$(SERVER) --extra-arg=-autopilotHold --extra-arg=3 \
-		--idle 60 --timeout 900 --require result --require-export --label replay $(ARGS)
+		$(SERVER) --extra-arg=-autopilotHold --extra-arg=3 --idle 60 --timeout 900 \
+		--require-order findMeter,meterCloseUp,wallWalk,markFeatures,uploading,result \
+		--require-then gapRequest:uploading --require-export --label replay $(ARGS)
 
 # Every case in e2e/cases/ plus the ETH3D facade scene through the server's API at SERVER_REF;
 # each result is validated against server/schemas/result.schema.json at the same ref.
diff --git a/verification/hsverify/simrun.py b/verification/hsverify/simrun.py
index 235d96d8e..56924aef8 100644
--- a/verification/hsverify/simrun.py
+++ b/verification/hsverify/simrun.py
@@ -8,7 +8,9 @@
 a screenshot once it has been on screen for `--settle` seconds; a state replaced sooner is
 captured immediately and flagged `transient`, because its image may already show the next
 state. The run ends at `--until`, after `--idle` seconds without a new state, or at
-`--timeout`. A state named with `--require` that never appeared makes the run fail. If the app
+`--timeout`. A state named with `--require` that never appeared makes the run fail, as do
+states missing from a `--require-order` sequence or out of its order, and a FIRST state of a
+`--require-then FIRST:THEN` pair that no THEN state came after. If the app
 logged a scan bundle, it is copied into the report as scan.zip (required with `--require-export`)
 and named in report.json's
 `app_export`, so the report folder can be replayed as an app export. Reports go outside git
@@ -329,6 +331,35 @@ def missing_required(required: list[str], states: list[ShotRecord]) -> list[str]
     return [f"required state {name} never appeared" for name in required if name not in seen]
 
 
+def out_of_order(order: list[str], states: list[ShotRecord]) -> list[str]:
+    """`order` must appear among the run's states in that order; other states may come between.
+    Reaching the last one is not enough: a run that skips the steps before it did not walk them."""
+    names = iter(s.state for s in states)
+    for i, want in enumerate(order):
+        if want not in names:  # consumes `names` up to the match, so order is enforced
+            after = f"after {order[i - 1]}" if i else "at all"
+            return [f"required order {' > '.join(order)}: no {want} {after}"]
+    return []
+
+
+def unanswered(pairs: list[tuple[str, str]], states: list[ShotRecord]) -> list[str]:
+    """For each (first, then): every `first` state must be followed later by a `then` state."""
+    names = [s.state for s in states]
+    return [
+        f"state {i + 1} {first} was never followed by {then}"
+        for first, then in pairs
+        for i, name in enumerate(names)
+        if name == first and then not in names[i + 1 :]
+    ]
+
+
+def state_pair(text: str) -> tuple[str, str]:
+    first, sep, then = text.partition(":")
+    if not (sep and first and then):
+        raise argparse.ArgumentTypeError(f"expected FIRST:THEN, got {text!r}")
+    return first, then
+
+
 def logged_message(line: str) -> str:
     """The message of one ndjson log line, or "" for the banner and anything unreadable."""
     try:
@@ -550,6 +581,22 @@ def main(argv: list[str] | None = None) -> int:
         metavar="STATE",
         help="a state the run must reach; one that never appears is a problem (exit 1)",
     )
+    parser.add_argument(
+        "--require-order",
+        action="append",
+        default=[],
+        type=lambda text: text.split(","),
+        metavar="STATE,STATE,...",
+        help="states the run must pass through in this order (others may come between)",
+    )
+    parser.add_argument(
+        "--require-then",
+        action="append",
+        default=[],
+        type=state_pair,
+        metavar="FIRST:THEN",
+        help="every FIRST state must be followed later in the run by a THEN state",
+    )
     parser.add_argument(
         "--require-export",
         action="store_true",
@@ -648,6 +695,9 @@ def main(argv: list[str] | None = None) -> int:
             print("Running...", flush=True)
             follow(args, udid, bundle_id, out, rep)
             rep.problems += missing_required(args.require, rep.states)
+            for order in args.require_order:
+                rep.problems += out_of_order(order, rep.states)
+            rep.problems += unanswered(args.require_then, rep.states)
             rep.app_export, export_problems = app_export(out, args.require_export)
             rep.problems += export_problems
         rep.crash_reports = collect_crashes(started, out)
diff --git a/verification/tests/test_sim_app_flow.py b/verification/tests/test_sim_app_flow.py
new file mode 100644
index 000000000..60b7e642b
--- /dev/null
+++ b/verification/tests/test_sim_app_flow.py
@@ -0,0 +1,72 @@
+"""`make sim-app` passes only a run that walked the capture flow to its result."""
+
+import argparse
+import re
+from pathlib import Path
+
+import pytest
+
+from hsverify.simrun import ShotRecord, out_of_order, state_pair, unanswered
+
+
+def shot(state: str) -> ShotRecord:
+    return ShotRecord(1, state, 0.0, "01.png", False, f"STATE={state}")
+
+
+def sim_app_problems(sequence: str) -> list[str]:
+    """What `make sim-app`'s state requirements say about a run that logged `sequence`."""
+    makefile = (Path(__file__).resolve().parents[1] / "Makefile").read_text()
+    recipe = makefile.split("\nsim-app:\n", 1)[1].split("\n\n", 1)[0]
+    orders = re.findall(r"--require-order (\S+)", recipe)
+    pairs = re.findall(r"--require-then (\S+)", recipe)
+    assert orders and pairs, recipe
+    states = [shot(name) for name in sequence.split(">")]
+    problems = [p for order in orders for p in out_of_order(order.split(","), states)]
+    return problems + unanswered([state_pair(p) for p in pairs], states)
+
+
+# State sequences of recorded `make sim-app` runs on t3/ios-mvf (report.json in
+# ~/house-scanning-data/reports/sim/): one upload at a39d0a5, a recapture round at f14947e, and
+# recapture plus spot checks at c820cf1.
+RECORDED_RUNS = [
+    "onboarding>findMeter>meterCloseUp>wallWalk>markFeatures>gapRequest>uploading>result>resultAR"
+    ">result",
+    "onboarding>findMeter>meterCloseUp>wallWalk>markFeatures>gapRequest>uploading>gapRequest"
+    ">uploading>result>resultAR>result",
+    "onboarding>findMeter>meterCloseUp>wallWalk>markFeatures>gapRequest>uploading>gapRequest"
+    ">uploading>spotConfirm>uploading>spotConfirm>uploading>spotConfirm>result>resultAR>result",
+]
+
+
+@pytest.mark.parametrize("sequence", RECORDED_RUNS)
+def test_the_recorded_flows_pass(sequence):
+    assert sim_app_problems(sequence) == []
+
+
+@pytest.mark.parametrize(
+    ("sequence", "problem"),
+    [
+        # A cached or prebuilt scan shown straight away: no capture, no upload.
+        ("onboarding>result>resultAR>result", "no findMeter at all"),
+        # Captured, then a result with no upload behind it.
+        ("onboarding>findMeter>meterCloseUp>wallWalk>markFeatures>result", "no uploading after"),
+        # Uploaded before the walk that should have produced the scan.
+        (
+            "onboarding>uploading>findMeter>meterCloseUp>wallWalk>markFeatures>result",
+            "no uploading after markFeatures",
+        ),
+        # The answer asked for more, the app showed the request, then the result without sending.
+        (
+            "onboarding>findMeter>meterCloseUp>wallWalk>markFeatures>uploading>gapRequest>result",
+            "state 7 gapRequest was never followed by uploading",
+        ),
+    ],
+)
+def test_a_shortcut_to_the_result_fails(sequence, problem):
+    problems = sim_app_problems(sequence)
+    assert any(problem in p for p in problems), problems
+
+
+def test_a_malformed_pair_is_refused():
+    with pytest.raises(argparse.ArgumentTypeError, match="FIRST:THEN"):
+        state_pair("gapRequest")
diff --git a/verification/tests/test_simrun.py b/verification/tests/test_simrun.py
index 515f29828..4059d78d1 100644
--- a/verification/tests/test_simrun.py
+++ b/verification/tests/test_simrun.py
@@ -105,12 +105,6 @@ def test_missing_required_state_is_a_problem():
     assert missing_required([], []) == []
 
 
-def test_sim_app_requires_the_result_state():
-    makefile = (Path(__file__).resolve().parents[1] / "Makefile").read_text()
-    recipe = makefile.split("\nsim-app:\n", 1)[1].split("\n\n", 1)[0]
-    assert "--require result" in recipe
-
-
 # --- app export ------------------------------------------------------------------------------
 
 

From 772defca80fb9a62cd7727d4ed8104addedf310c Mon Sep 17 00:00:00 2001
From: Sam Gu <127461594+SamGu-NRX@users.noreply.github.com>
Date: Tue, 13 Oct 2026 18:28:25 -0500
Subject: [PATCH 26/62] verification(resultcheck): compare a newly swept start
 with its neighbours

The less-coverage check skipped any start that the original sweep did not
contain, so a changed scene could add a passing start in a gap or on a wall
the original never swept. If the original already passed somewhere, the
decision guard missed it too. Failing every None-to-pass would be wrong:
coverage edges are evaluated starts, so moving them adds starts inside the
original's gaps between runs.

outcomes_near() reads such a start from the original's neighbouring runs on
that wall. The server evaluates every start where a check can change outcome,
plus the midpoints between them (solver.py docstring, t3/server 1d1e7e1), so
between two evaluated starts the outcome is one of theirs. A new pass is then
a violation only when neither neighbour passed, or when the original had no
run on that wall. The more-error check had the same skip and now reads gaps
the same way.

Regressions: a pass inside a fail/unsure gap, a pass on an unswept wall while
the original decision was already pass, and a pass past the last run all fail.
A boundary that moved into a fail/pass gap still passes.

Review thread: https://github.com/SamGu-NRX/BaseScanning/pull/13#discussion_r4114865928

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 verification/hsverify/resultcheck.py   | 53 ++++++++++++++++++++------
 verification/tests/test_resultcheck.py | 44 +++++++++++++++++++++
 2 files changed, 86 insertions(+), 11 deletions(-)

diff --git a/verification/hsverify/resultcheck.py b/verification/hsverify/resultcheck.py
index bb276281a..1071d8bb2 100644
--- a/verification/hsverify/resultcheck.py
+++ b/verification/hsverify/resultcheck.py
@@ -1298,28 +1298,59 @@ def probe_starts(*results: dict) -> list[tuple[str, float]]:
     return sorted(points)
 
 
+def outcomes_near(result: dict, wall_id: str, start_ft: float) -> tuple[set[str], str]:
+    """The outcomes a sweep allows at a start, and how they were read.
+
+    A run containing the start gives its outcome. A start no run contains, which a changed
+    scene's new boundary can land on, gets its neighbouring runs' outcomes on that wall: the
+    server evaluates every start where some check can change its outcome, plus the midpoints
+    between those (server/solver.py module docstring, t3/server 1d1e7e1), so between two
+    evaluated starts the outcome is the outcome at one of them. Past the last run on one side
+    only the nearest run is left; on a wall with no run there is nothing to compare with."""
+    if (inside := outcome_at(result, wall_id, start_ft)) is not None:
+        return {inside}, inside
+    runs = [run for run in result.get("sweep", []) if run["wall_id"] == wall_id]
+    left = max(
+        (r for r in runs if r["start_ft"][1] < start_ft),
+        key=lambda r: r["start_ft"][1],
+        default=None,
+    )
+    right = min(
+        (r for r in runs if r["start_ft"][0] > start_ft),
+        key=lambda r: r["start_ft"][0],
+        default=None,
+    )
+    near = [r["outcome"] for r in (left, right) if r is not None]
+    if not near:
+        return set(), "no run on its wall"
+    return set(near), f"unswept beside {' and '.join(near)}"
+
+
 def more_error_problems(before: dict, after: dict, change: str) -> list[str]:
     """With more error, a start may only move toward UNSURE: UNSURE stays, PASS and FAIL stay
-    or become UNSURE."""
+    or become UNSURE. A start the original sweep never evaluated is read as `outcomes_near`."""
     problems = []
     for wall_id, s in probe_starts(before, after):
-        a, b = outcome_at(before, wall_id, s), outcome_at(after, wall_id, s)
-        if a is None or b is None or a == b or b == "unsure":
+        b = outcome_at(after, wall_id, s)
+        allowed, was = outcomes_near(before, wall_id, s)
+        if b is None or b == "unsure" or b in allowed:
             continue
-        problems.append(f"{change}: start {wall_id} {s:.3f} went from {a} to {b}")
+        problems.append(f"{change}: start {wall_id} {s:.3f} went from {was} to {b}")
     if before["decision"] != "pass" and after["decision"] == "pass":
         problems.append(f"{change}: the decision became pass")
     return problems
 
 
 def less_coverage_problems(before: dict, after: dict, change: str) -> list[str]:
-    """With less observed, no start may newly PASS."""
-    problems = [
-        f"{change}: start {wall_id} {s:.3f} went from {outcome_at(before, wall_id, s)} to pass"
-        for wall_id, s in probe_starts(before, after)
-        if outcome_at(after, wall_id, s) == "pass"
-        and outcome_at(before, wall_id, s) not in (None, "pass")
-    ]
+    """With less observed, no start may newly PASS. A start the original sweep never evaluated
+    is read as `outcomes_near`, so a boundary that moved is not taken for a new pass."""
+    problems = []
+    for wall_id, s in probe_starts(before, after):
+        if outcome_at(after, wall_id, s) != "pass":
+            continue
+        allowed, was = outcomes_near(before, wall_id, s)
+        if "pass" not in allowed:
+            problems.append(f"{change}: start {wall_id} {s:.3f} went from {was} to pass")
     if before["decision"] != "pass" and after["decision"] == "pass":
         problems.append(f"{change}: the decision became pass")
     return problems
diff --git a/verification/tests/test_resultcheck.py b/verification/tests/test_resultcheck.py
index 5846b7a9a..fb32e40ee 100644
--- a/verification/tests/test_resultcheck.py
+++ b/verification/tests/test_resultcheck.py
@@ -620,6 +620,50 @@ def test_less_coverage_never_creates_a_pass():
     assert msgs and all("went from unsure to pass" in m for m in msgs)
 
 
+def split():
+    """An original sweep: fail up to 2.0, then pass from 2.1, nothing evaluated between."""
+    return swept(run(0.0, 2.0, "fail"), run(2.1, 5.0, "pass"))
+
+
+def test_less_coverage_may_move_a_boundary_into_an_unswept_gap():
+    """A coverage edge that moved adds evaluated starts; one inside the original's gap between
+    a fail run and a pass run may pass, because the original allows either outcome there."""
+    after = swept(run(0.0, 2.04, "fail"), run(2.05, 5.0, "pass"))
+    assert less_coverage_problems(split(), after, "x") == []
+
+
+def test_less_coverage_cannot_pass_a_gap_between_runs_that_did_not():
+    before = swept(run(0.0, 2.0, "fail"), run(2.1, 5.0, "unsure"))
+    after = swept(run(0.0, 2.0, "fail"), run(2.05, 2.05, "pass"), run(2.1, 5.0, "unsure"))
+    assert less_coverage_problems(before, after, "x") == [
+        "x: start w1 2.050 went from unswept beside fail and unsure to pass"
+    ]
+
+
+def test_less_coverage_cannot_pass_where_the_original_swept_nothing():
+    """The decision guard does not catch this when the original already passed elsewhere."""
+    before = swept(run(0.0, 4.0, "pass"), decision="pass")
+    after = swept(run(0.0, 4.0, "pass"), run(10.0, 12.0, "pass", wall="w2"), decision="pass")
+    assert less_coverage_problems(before, after, "x") == [
+        f"x: start w2 {s:.3f} went from no run on its wall to pass" for s in (10.0, 11.0, 12.0)
+    ]
+    past_end = swept(run(0.0, 4.0, "pass"), run(4.1, 6.0, "fail"), decision="pass")
+    longer = swept(run(0.0, 4.0, "pass"), run(4.1, 6.0, "fail"), run(6.1, 6.1, "pass"))
+    assert less_coverage_problems(past_end, longer, "x") == [
+        "x: start w1 6.100 went from unswept beside fail to pass"
+    ]
+
+
+def test_more_error_reads_an_unswept_start_from_its_neighbours():
+    moved = swept(run(0.0, 2.04, "fail"), run(2.05, 5.0, "pass"))
+    assert more_error_problems(split(), moved, "x") == []
+    flipped = swept(run(0.0, 2.0, "fail"), run(2.05, 2.05, "pass"), run(2.1, 5.0, "fail"))
+    before = swept(run(0.0, 2.0, "fail"), run(2.1, 5.0, "fail"))
+    assert more_error_problems(before, flipped, "x") == [
+        "x: start w1 2.050 went from unswept beside fail and fail to pass"
+    ]
+
+
 def test_transforms():
     scene = copy.deepcopy(SCENE)
     scene["objects"].append({"type": "ac", "wall_id": "w1", "span_ft": [5, 6], "source": "tape"})

From 61ab93771161b056386369c3912426dd6f2e733e Mon Sep 17 00:00:00 2001
From: Sam Gu <127461594+SamGu-NRX@users.noreply.github.com>
Date: Tue, 13 Oct 2026 18:29:27 -0500
Subject: [PATCH 27/62] verification(a11y-audit): identify a screen by its
 whole accessibility tree

The harness keyed screens on static-text and button labels only. A later
screen with the same labels plus a text field, toggle, image or link was
treated as already audited, so performAccessibilityAudit never ran on it.

The key now lists every element in tree order by type, identifier and
label. Unlabelled grouping containers are left out so view nesting does not
decide the key. Values (typed text, toggle state, slider position) and frames
are left out too, because they change while the screen stays the same and
each change would start another audit and reset the idle timer. The
A11Y_SCREEN labels the report shows are unchanged.

Checked with swiftc -typecheck against the iOS 27 simulator SDK and XCTest.
The UI-test fixture was not built or run.

Review threads:
https://github.com/SamGu-NRX/BaseScanning/pull/13#discussion_r4114865931
https://github.com/SamGu-NRX/BaseScanning/pull/13#discussion_r4115043215

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 .../AccessibilityAuditTests.swift             | 48 +++++++++++++------
 verification/hsverify/a11yaudit.py            |  5 +-
 2 files changed, 37 insertions(+), 16 deletions(-)

diff --git a/verification/fixtures/a11y-audit/AccessibilityAudit/AccessibilityAuditTests.swift b/verification/fixtures/a11y-audit/AccessibilityAudit/AccessibilityAuditTests.swift
index b2639d7e7..4fb333452 100644
--- a/verification/fixtures/a11y-audit/AccessibilityAudit/AccessibilityAuditTests.swift
+++ b/verification/fixtures/a11y-audit/AccessibilityAudit/AccessibilityAuditTests.swift
@@ -3,9 +3,10 @@ import XCTest
 /// Launches the app under test by bundle id with the launch arguments it is given, then runs
 /// `performAccessibilityAudit` once per distinct screen until the app stops changing.
 ///
-/// A screen is identified by the labels of its static texts and buttons, so a new instruction
-/// counts as a new screen. Each issue is printed as one `A11Y_ISSUE=<json>` line and each
-/// screen as `A11Y_SCREEN=<json>`, which hsverify.a11yaudit reads from the test output.
+/// A screen is identified by every element in its accessibility tree (see `screenIdentity`), so
+/// a new instruction or a new control counts as a new screen. Each issue is printed as one
+/// `A11Y_ISSUE=<json>` line and each screen as `A11Y_SCREEN=<json>`, which hsverify.a11yaudit
+/// reads from the test output.
 /// Screenshots go to AUDIT_OUT on the host.
 ///
 /// Inputs arrive as environment variables (set on the xcodebuild command line with the
@@ -34,39 +35,58 @@ final class AccessibilityAuditTests: XCTestCase {
                 emit("A11Y_SCREEN", ["index": seen.count + 1, "error": "app not running"])
                 break
             }
-            guard let labels = screenLabels(app) else {
+            guard let screen = screenIdentity(app) else {
                 RunLoop.current.run(until: Date().addingTimeInterval(0.5))
                 continue
             }
-            let key = labels.joined(separator: "\n")
-            if !seen.contains(key) {
-                seen.append(key)
+            if !seen.contains(screen.key) {
+                seen.append(screen.key)
                 lastChange = Date()
-                audit(app, index: seen.count, labels: labels, out: out,
+                audit(app, index: seen.count, labels: screen.labels, out: out,
                       at: Date().timeIntervalSince(start))
             }
             RunLoop.current.run(until: Date().addingTimeInterval(0.5))
         }
     }
 
-    /// Labels from one snapshot of the accessibility tree. Querying elements and then reading
-    /// each label is two round trips, and a button that disappears in between (the screen
-    /// changing) fails the whole test.
+    /// Containers that only group other elements. Without a label or identifier they show
+    /// nothing a person or the audit would notice, so they stay out of a screen's identity,
+    /// which then does not depend on how the views happen to be nested.
+    private static let grouping: Set<XCUIElement.ElementType> = [
+        .application, .window, .other, .group, .layoutArea, .layoutItem, .scrollView,
+    ]
+
+    /// One snapshot of the accessibility tree: the screen's identity, and the static-text and
+    /// button labels the report shows. Querying elements and then reading each label is two
+    /// round trips, and a button that disappears in between (the screen changing) fails the
+    /// whole test.
+    ///
+    /// The identity lists every element in tree order by type, identifier and label, so two
+    /// screens with the same texts and buttons still differ when one adds a text field, toggle,
+    /// image or link, labelled or not. It leaves out what changes while the screen stays the
+    /// same: values (typed text, a toggle's state, a slider's position) and frames (animations,
+    /// the keyboard). Each change of those would otherwise start another audit of one screen
+    /// and keep resetting the idle timer.
     @MainActor
-    private func screenLabels(_ app: XCUIApplication) -> [String]? {
+    private func screenIdentity(_ app: XCUIApplication) -> (key: String, labels: [String])? {
         guard let root = try? app.snapshot() else { return nil }
+        var elements: [String] = []
         var texts: [String] = []
         var buttons: [String] = []
         func walk(_ node: any XCUIElementSnapshot) {
-            switch node.elementType {
+            let type = node.elementType
+            switch type {
             case .staticText: texts.append("text:" + node.label)
             case .button: buttons.append("button:" + node.label)
             default: break
             }
+            if !Self.grouping.contains(type) || !node.label.isEmpty || !node.identifier.isEmpty {
+                elements.append("\(type.rawValue)|\(node.identifier)|\(node.label)")
+            }
             node.children.forEach(walk)
         }
         walk(root)
-        return texts + buttons
+        return (elements.joined(separator: "\n"), texts + buttons)
     }
 
     @MainActor
diff --git a/verification/hsverify/a11yaudit.py b/verification/hsverify/a11yaudit.py
index f02b604bb..37c48a1cc 100644
--- a/verification/hsverify/a11yaudit.py
+++ b/verification/hsverify/a11yaudit.py
@@ -6,8 +6,9 @@
 The app is built and installed exactly as `hsverify.simrun` does. Then the UI test bundle in
 `fixtures/a11y-audit` launches it by bundle id with the same launch arguments, and runs
 `performAccessibilityAudit(for: .all)` on each distinct screen: contrast, Dynamic Type, hit
-areas, clipped text, element descriptions and traits. A screen is new when the labels of its
-texts and buttons change.
+areas, clipped text, element descriptions and traits. A screen is new when any element in its
+accessibility tree is added, removed or relabelled; values and positions don't count. Each
+screen's `labels` in the report are still only its texts and buttons.
 
 Apple's audit accepts a button whose label SwiftUI took from an SF Symbol name, which
 VoiceOver then reads aloud ("gearshape"). Those labels are flagged here as well.

From d75e7a96dbad1b290905912cbbe35897ab29d83b Mon Sep 17 00:00:00 2001
From: Sam Gu <127461594+SamGu-NRX@users.noreply.github.com>
Date: Tue, 13 Oct 2026 18:32:51 -0500
Subject: [PATCH 28/62] docs(integration-viewer): leave the tests sentence for
 PR #238 to change

The previous two commits added the count-timer and mark tests to the
"The tests cover" line, which open PR #238 also rewrites. Restore alpha's
wording so the two branches merge without a conflict; the file table row
still names count-timers.js, and each test file describes its own cases.

Review threads: https://github.com/SamGu-NRX/BaseScanning/pull/124#discussion_r4114688573
https://github.com/SamGu-NRX/BaseScanning/pull/124#discussion_r4115036581

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 tools/integration-viewer/README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tools/integration-viewer/README.md b/tools/integration-viewer/README.md
index 3b41e63b3..65406597d 100644
--- a/tools/integration-viewer/README.md
+++ b/tools/integration-viewer/README.md
@@ -84,7 +84,7 @@ cd tools/integration-viewer
 node --test "test/*.test.js"
 ```
 
-The tests cover the reducer (duplicates, ordering, cursor, stale sessions, unknown events, offline, no claimed result), the PLY reader, the relay through real HTTP requests (allowlist, traversal, Host check, signed-URL handling), the count timers (a batch that draws no marks while older marks travel still reaches the counters), the marks a batch sends (at most six, picked without listing every file), and the live loop against the relay and a sped-up synthetic API, including a dropped connection. CI does not run them yet, because no workflow covers `tools/`.
+The tests cover the reducer (duplicates, ordering, cursor, stale sessions, unknown events, offline, no claimed result), the PLY reader, the relay through real HTTP requests (allowlist, traversal, Host check, signed-URL handling), and the live loop against the relay and a sped-up synthetic API, including a dropped connection. CI does not run them yet, because no workflow covers `tools/`.
 
 `test/browser.test.js` runs the page in headless Chrome with the animation clock stopped and frames drawn only on request, which is how an embedded preview panel behaved. It checks that the file counts match the events drawn in the same frame and that finished stages show their marker. It skips when no Chrome is found; set `CHROME_PATH` to point at one.
 

From 37218bfc11297f5687ad02a62ee95de7f541b397 Mon Sep 17 00:00:00 2001
From: Sam Gu <127461594+SamGu-NRX@users.noreply.github.com>
Date: Tue, 13 Oct 2026 18:33:09 -0500
Subject: [PATCH 29/62] docs(how-it-works): draw the coverage zone as every
 check's reach, not cable reach

The diagram drew the needed zone as a rectangle at the 20 ft cable reach
and labelled everything outside it "not needed", while the checks on a
spot near that edge look past it: 3 ft along the wall for gas meters, AC
units, doors and windows, 5 ft for a driveway, 10 ft for a pool, and up
for headroom. Under "treat unseen as unsure", ground those checks need is
needed even beyond the cable.

The redraw shows the candidate spots as an orange band under the cable
bracket, and the zone as that band grown by the checks' reach: ends past
the cable reach, front at the 13 ft of ground docs/00-overview.md gives
for the pool and driveway checks, rounded front corners. Outside it is
washed out, not hazed, because haze on this page means unseen and needed,
and is labelled "no check looks here". Prose, caption and the SVG
description follow the drawing.

Review thread: https://github.com/SamGu-NRX/BaseScanning/pull/14#discussion_r4112033409

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 docs/how-it-works.html | 57 +++++++++++++++++++++++-------------------
 1 file changed, 31 insertions(+), 26 deletions(-)

diff --git a/docs/how-it-works.html b/docs/how-it-works.html
index d2d06eb49..3e151e220 100644
--- a/docs/how-it-works.html
+++ b/docs/how-it-works.html
@@ -721,43 +721,48 @@ <h3>Unseen means unsure</h3>
 </figure>
 
 <h3>Coverage is a fixed zone</h3>
-<p class="prose">Not the whole house, just a zone around the meter. The app always knows exactly what's left.</p>
+<p class="prose">Not the whole house. The zone is every spot the cable can reach, plus everything the checks on those spots look at. The rules fix it before the scan starts, so the app always knows exactly what's left.</p>
 <figure class="narrow">
   <svg viewBox="0 0 480 300" role="img" aria-labelledby="cvt cvd">
     <title id="cvt">The zone a scan must cover, seen from above</title>
-    <desc id="cvd">A plan view of the house with the electric meter on its front wall. A dashed blue rectangle marks the zone the checks need: the wall 20 feet either side of the meter and the ground in front of it out to 13 feet. Everything outside it is grey haze labelled not needed. Inside, a bush stands in front of the wall, and the strip of wall behind it is unseen, so checks there are UNSURE. A dotted path shows the phone walking along the zone.</desc>
-    <!-- 1 ft = 8 px, meter at x=240, wall face at y=110 -->
+    <desc id="cvd">A plan view of the house with the electric meter on its front wall. An orange band along the wall marks the candidate battery spots, 20 feet of cable either side of the meter. A dashed blue outline marks the zone the checks need: that band grown by how far each check reaches, so it runs past the cable's reach at both ends and out over the ground in front, with rounded front corners. A bracket under it reads needed: all of it, past the cable's reach too. Everything outside is washed out and labelled no check looks here. Inside the zone, a bush stands in front of the wall, and the strip of wall behind it is unseen, so checks there are UNSURE. A dotted path shows the phone walking through the zone.</desc>
+    <!-- 1 ft = 7 px, meter at x=240, wall face at y=110. Candidate footprints (22 in deep, 13 px)
+         fill a band within 20 ft of cable, x 100 to 380. The zone is that band grown by the
+         farthest check. Its front sits at the 13 ft of ground the pool and driveway checks need
+         (docs/00-overview.md), y=201, so it grows the band by about 11 ft (78 px): the same
+         reach puts its ends at x 22 and 458 and rounds its front corners. -->
     <rect width="480" height="300" fill="var(--ground)"/>
-    <rect x="40" y="16" width="400" height="88" fill="var(--eave)"/>
-    <rect x="40" y="104" width="400" height="6" fill="var(--wall)"/>
-    <text class="lab b" x="240" y="48" text-anchor="middle">house, seen from above</text>
-    <!-- cable reach bracket -->
+    <rect x="0" y="16" width="480" height="88" fill="var(--eave)"/>
+    <rect x="0" y="104" width="480" height="6" fill="var(--wall)"/>
+    <text class="lab b" x="240" y="44" text-anchor="middle">house, seen from above</text>
+    <!-- candidate spots: cable reach bracket and the band of footprints -->
+    <g stroke="var(--server)" stroke-width="2.5">
+      <line x1="100" y1="88" x2="380" y2="88"/><line x1="100" y1="81" x2="100" y2="95"/><line x1="240" y1="81" x2="240" y2="95"/><line x1="380" y1="81" x2="380" y2="95"/>
+    </g>
+    <text class="lab s" x="240" y="74" text-anchor="middle">candidate spots: 20 ft of cable either side</text>
+    <rect x="100" y="110" width="280" height="13" fill="var(--server)" fill-opacity=".22" stroke="var(--server)" stroke-width="2"/>
+    <!-- outside the zone: washed out, not hazed, because haze means unseen and needed -->
+    <path d="M0 104 H480 V300 H0 Z M22 104 V123 A78 78 0 0 0 100 201 H380 A78 78 0 0 0 458 123 V104 Z" fill="var(--card)" fill-opacity=".6" fill-rule="evenodd"/>
+    <!-- the zone -->
+    <path d="M22 104 V123 A78 78 0 0 0 100 201 H380 A78 78 0 0 0 458 123 V104" fill="none" stroke="var(--phone)" stroke-width="2.5" stroke-dasharray="7 4"/>
     <g stroke="var(--phone)" stroke-width="2.5">
-      <line x1="80" y1="88" x2="400" y2="88"/><line x1="80" y1="81" x2="80" y2="95"/><line x1="240" y1="81" x2="240" y2="95"/><line x1="400" y1="81" x2="400" y2="95"/>
+      <line x1="22" y1="214" x2="458" y2="214"/><line x1="22" y1="207" x2="22" y2="221"/><line x1="458" y1="207" x2="458" y2="221"/>
     </g>
-    <text class="lab" x="240" y="76" text-anchor="middle">cable reach: 20 ft either side</text>
-    <!-- haze outside the needed zone -->
-    <rect x="0" y="102" width="80" height="198" fill="url(#fogpat)"/>
-    <rect x="400" y="102" width="80" height="198" fill="url(#fogpat)"/>
-    <rect x="80" y="214" width="320" height="86" fill="url(#fogpat)"/>
-    <text class="lab b" x="240" y="266" text-anchor="middle">not needed</text>
-    <!-- needed zone -->
-    <rect x="80" y="104" width="320" height="110" fill="none" stroke="var(--phone)" stroke-width="2.5" stroke-dasharray="7 4"/>
+    <text class="lab s b blue" x="240" y="238" text-anchor="middle">needed: all of it, past the cable's reach too</text>
+    <text class="lab mu" x="240" y="280" text-anchor="middle">no check looks here</text>
     <!-- meter -->
     <rect x="234" y="101" width="12" height="9" rx="1.5" fill="var(--meterbox)"/>
-    <text class="lab" x="252" y="130">meter</text>
+    <text class="lab" x="228" y="142" text-anchor="end">meter</text>
     <!-- bush hiding a strip of wall -->
-    <rect x="318" y="101" width="24" height="9" fill="url(#fogpat)" stroke="var(--fail-ink)" stroke-width="1.5"/>
-    <circle cx="330" cy="124" r="12" fill="var(--bush)"/>
-    <text class="lab" x="320" y="158" text-anchor="middle">wall behind the bush:</text>
-    <text class="lab" x="320" y="178" text-anchor="middle">unseen, so UNSURE</text>
+    <rect x="333" y="101" width="24" height="9" fill="url(#fogpat)" stroke="var(--fail-ink)" stroke-width="1.5"/>
+    <circle cx="345" cy="124" r="11" fill="var(--bush)"/>
+    <text class="lab s" x="345" y="152" text-anchor="middle">wall behind the bush:</text>
+    <text class="lab s" x="345" y="170" text-anchor="middle">unseen, so UNSURE</text>
     <!-- the phone's path -->
-    <line x1="96" y1="186" x2="384" y2="186" stroke="var(--phone)" stroke-width="3" stroke-dasharray="1 7" stroke-linecap="round"/>
-    <use href="#phone" x="140" y="173"/>
-    <text class="lab b blue" x="90" y="132">needed: all of it</text>
-    <text class="lab" x="392" y="208" text-anchor="end">ground out to 13 ft</text>
+    <line x1="70" y1="186" x2="410" y2="186" stroke="var(--phone)" stroke-width="3" stroke-dasharray="1 7" stroke-linecap="round"/>
+    <use href="#phone" x="150" y="173"/>
   </svg>
-  <figcaption>The zone: wall within 20 ft of cable each side, ground out to 6 to 13 ft, and headroom above. It reaches a little past 20 ft for clearances at the edge.</figcaption>
+  <figcaption>Each check reaches out from the spot it tests: 3 ft along the wall for gas meters, AC units, doors and windows, 5 ft for a driveway, 10 ft for a pool, and up for headroom and wall equipment. So the zone runs past the 20 ft of cable at both ends, and over the ground out to 13 ft. Any part of it nobody saw keeps its checks UNSURE.</figcaption>
 </figure>
 
 <h3>LiDAR helps but isn't required</h3>

From 44f81f822343e94dcbf89c501bc536b194432303 Mon Sep 17 00:00:00 2001
From: Sam Gu <127461594+SamGu-NRX@users.noreply.github.com>
Date: Tue, 13 Oct 2026 19:08:45 -0500
Subject: [PATCH 30/62] experiments(edge-geometry): match along epipolar
 segments longer than one remap

cv2.remap takes at most SHRT_MAX rows, and a wide photo pair's epipolar
segment can cross most of the second image, so the --pair=widest run
stopped on electro with an OpenCV assertion. The patches are now sampled
in chunks that fit. A segment that fit before is one chunk, so the
pre-registered narrow-pair numbers cannot change.

https://github.com/SamGu-NRX/BaseScanning/pull/59#discussion_r4115044359

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 experiments/edge-geometry/imagematch.py       | 20 +++++++++++++------
 .../edge-geometry/tests/test_imagematch.py    | 16 +++++++++++++++
 2 files changed, 30 insertions(+), 6 deletions(-)

diff --git a/experiments/edge-geometry/imagematch.py b/experiments/edge-geometry/imagematch.py
index 5fb90a19d..abb210c0b 100644
--- a/experiments/edge-geometry/imagematch.py
+++ b/experiments/edge-geometry/imagematch.py
@@ -109,12 +109,20 @@ def epipolar_match(
     samples = ends[0] + np.linspace(0.0, 1.0, n)[:, None] * (ends[1] - ends[0])
 
     offs = np.arange(patch, dtype=np.float32) - half
-    map_x = (samples[:, 0, None, None] + offs[None, None, :]).astype(np.float32)
-    map_y = (samples[:, 1, None, None] + offs[None, :, None]).astype(np.float32)
-    map_x = np.broadcast_to(map_x, (n, patch, patch)).reshape(n * patch, patch)
-    map_y = np.broadcast_to(map_y, (n, patch, patch)).reshape(n * patch, patch)
-    patches = cv2.remap(img2.astype(np.float32), map_x, map_y, cv2.INTER_LINEAR)
-    score = _ncc(template, patches.reshape(n, patch, patch))
+    image2 = img2.astype(np.float32)
+    # cv2.remap takes at most SHRT_MAX rows, and a wide photo pair's segment can cross most of
+    # img2, so the patches are cut in chunks that fit; shorter segments are one chunk, as before.
+    chunk = (np.iinfo(np.int16).max - 1) // patch
+    patches = []
+    for a in range(0, n, chunk):
+        part = samples[a : a + chunk]
+        m = len(part)
+        map_x = (part[:, 0, None, None] + offs[None, None, :]).astype(np.float32)
+        map_y = (part[:, 1, None, None] + offs[None, :, None]).astype(np.float32)
+        map_x = np.broadcast_to(map_x, (m, patch, patch)).reshape(m * patch, patch)
+        map_y = np.broadcast_to(map_y, (m, patch, patch)).reshape(m * patch, patch)
+        patches.append(cv2.remap(image2, map_x, map_y, cv2.INTER_LINEAR).reshape(m, patch, patch))
+    score = _ncc(template, np.concatenate(patches))
     i = int(np.argmax(score))
     off = 0.0
     if 0 < i < n - 1:
diff --git a/experiments/edge-geometry/tests/test_imagematch.py b/experiments/edge-geometry/tests/test_imagematch.py
index d6f1eac72..129aeb4f1 100644
--- a/experiments/edge-geometry/tests/test_imagematch.py
+++ b/experiments/edge-geometry/tests/test_imagematch.py
@@ -87,3 +87,19 @@ def test_epipolar_search_fails_cleanly_when_the_template_leaves_the_image():
     uv2, score = epipolar_match(img, img, np.array([3.0, 3.0]), K, T, K, T)
     assert np.isnan(uv2).all()
     assert score == -1.0
+
+
+def test_epipolar_search_longer_than_one_remap_still_matches():
+    # A 0.05 px step makes the segment's patches overflow cv2.remap's SHRT_MAX rows, as a wide
+    # photo pair's long segment does at the normal step.
+    rng = np.random.default_rng(3)
+    texture = cv2.GaussianBlur(rng.random((3000, 3000)).astype(np.float32), (0, 0), 3)
+    T1 = look_at(np.array([0.0, 0.0, 0.0]), np.array([0.0, 0.0, 3.0]))
+    T2 = look_at(np.array([0.4, 0.05, 0.1]), np.array([0.1, 0.0, 3.0]))
+    img1, img2 = render_plane(T1, texture, 0.002, 3.0), render_plane(T2, texture, 0.002, 3.0)
+    uv1 = np.array([300.3, 250.6])
+    o1, d1 = pixel_ray(K, T1, uv1)
+    truth = project(K, T2, (o1 + (3.0 - o1[2]) / d1[2] * d1)[None])[0][0]
+    uv2, score = epipolar_match(img1, img2, uv1, K, T1, K, T2, step_px=0.05)
+    assert score > 0.95
+    assert np.linalg.norm(uv2 - truth) < 0.3

From e020a155fd8c855ba7ecf1deb686faad846e4907 Mon Sep 17 00:00:00 2001
From: Sam Gu <127461594+SamGu-NRX@users.noreply.github.com>
Date: Tue, 13 Oct 2026 19:15:13 -0500
Subject: [PATCH 31/62] fix(integration-viewer): keep counters behind every
 mark still travelling

Review of a4d1008 found two ways the counters could run ahead of marks:

- The last timer wrote the reducer's current state. dispatch() updates
  that state at once but queues the render that starts the arrival's
  marks, so an arrival at 1449 ms was counted by a timer at 1450 ms
  before its mark left at 1456 ms.
- Timers could finish out of order. Six marks from 0 ms land by 1450 ms,
  one mark from 70 ms lands at 1170 ms, and its cumulative total showed
  while the six were still on the line. Alpha had this too.

count-timers.js now keeps a queue of renders. Each render hands over the
state it drew and when its marks land (0 for none), and totals show only
when that render's marks and every earlier render's marks have landed.
Unrendered reducer state never reaches the counters.

The tests run on a virtual clock that fires timers at their due time.
Against a4d1008's module the 1449/1450 ms test and the out-of-order test
fail; against alpha's rule the out-of-order test and the no-marks test
fail.

Review thread: https://github.com/SamGu-NRX/BaseScanning/pull/124#discussion_r4114688573

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 tools/integration-viewer/public/app.js        |  12 +-
 .../integration-viewer/public/count-timers.js |  67 +++++---
 .../test/count-timers.test.js                 | 150 +++++++++++-------
 3 files changed, 136 insertions(+), 93 deletions(-)

diff --git a/tools/integration-viewer/public/app.js b/tools/integration-viewer/public/app.js
index fd48b60d3..3a0a5cd99 100644
--- a/tools/integration-viewer/public/app.js
+++ b/tools/integration-viewer/public/app.js
@@ -51,7 +51,7 @@ let follower = null;
 const reducedMotion = matchMedia("(prefers-reduced-motion: reduce)");
 let motionPaused = reducedMotion.matches;
 let shownArrival = 0;
-const countTimers = createCountTimers({ write: writeCounts, current: () => state });
+const countTimers = createCountTimers({ write: writeCounts });
 let shownCounts = { session: -1, value: 0 };
 let clockStalled = false;
 let renderQueued = false;
@@ -223,13 +223,13 @@ function renderPhone() {
 function renderArrivals() {
   const { counts } = state;
   const fresh = state.arrivals.filter((a) => a.id > shownArrival);
+  let landsIn = 0;
   if (fresh.length > 0) {
     shownArrival = fresh.at(-1).id;
-    const landsIn = Math.max(...fresh.map((a) => conduit.send(a, { motion: motionOn() })));
-    // The counts change as the marks land.
-    if (landsIn > 0) countTimers.afterMarks(landsIn);
+    landsIn = Math.max(...fresh.map((a) => conduit.send(a, { motion: motionOn() })));
   }
-  countTimers.settle();
+  // The counts change as the marks land.
+  countTimers.rendered(state, landsIn);
   const backlog = counts.backlog;
   const parts = [];
   if (counts.registered != null) parts.push(`of ${counts.registered} registered`);
@@ -239,7 +239,7 @@ function renderArrivals() {
 }
 
 /** Shows the acknowledged-file totals from `from`; never goes back to a smaller total in a session. */
-function writeCounts(from = state) {
+function writeCounts(from) {
   if (from.session !== state.session) return;
   if (shownCounts.session === from.session && from.counts.acknowledged < shownCounts.value) return;
   shownCounts = { session: from.session, value: from.counts.acknowledged };
diff --git a/tools/integration-viewer/public/count-timers.js b/tools/integration-viewer/public/count-timers.js
index 58ea61e2e..f58efcc7b 100644
--- a/tools/integration-viewer/public/count-timers.js
+++ b/tools/integration-viewer/public/count-timers.js
@@ -1,37 +1,52 @@
-// Decides when the acknowledged-file counters change. A batch that draws marks shows its totals
-// when its last mark lands; a batch that draws none shows them at once, unless older marks are
-// still travelling, in which case it waits for them. Timers do the work, never an animation
-// finishing, because an animation never finishes where the animation clock is stopped.
+// Decides when the acknowledged-file counters change. Each render hands over the state it drew
+// and when that render's marks land. A render's totals show once its own marks and the marks of
+// every earlier render have landed, so the counters never run ahead of a mark still on the line,
+// even when a later, shorter batch lands first. Totals reach the counters only from a render: the
+// reducer's state can already hold an arrival whose marks have not started yet.
+// Timers do the work, never an animation finishing, because an animation never finishes where
+// the animation clock is stopped.
 
 /**
  * @template S
- * @param {{ write: (from: S) => void, current: () => S, setTimer?: typeof setTimeout, clearTimer?: typeof clearTimeout }} options
- *   `write` shows the totals in a state; `current` returns the latest state.
+ * @param {{ write: (from: S) => void, setTimer?: typeof setTimeout, clearTimer?: typeof clearTimeout }} options
+ *   `write` shows the totals in a state.
  */
-export function createCountTimers({ write, current, setTimer = setTimeout, clearTimer = clearTimeout }) {
-  const pending = new Set();
+export function createCountTimers({ write, setTimer = setTimeout, clearTimer = clearTimeout }) {
+  /** Renders not shown yet, oldest first: { from, landed, timer }. */
+  const queue = [];
+
+  function release() {
+    let latest = null;
+    while (queue.length > 0 && queue[0].landed) latest = queue.shift();
+    if (latest) write(latest.from);
+  }
+
   return {
-    /** Shows the current totals once marks that land in `landsIn` ms have arrived. */
-    afterMarks(landsIn) {
-      // Each timer shows the totals as of its own batch, so a counter never runs ahead of its marks.
-      const snapshot = current();
-      const timer = setTimer(() => {
-        pending.delete(timer);
-        // The last timer shows the latest totals: batches that drew no marks while it waited (motion
-        // paused, clock stopped, too many marks in flight) skipped their own update. Every batch
-        // that drew marks has its own timer, so with none pending, no mark is still on its way.
-        write(pending.size === 0 ? current() : snapshot);
-      }, landsIn);
-      pending.add(timer);
-    },
-    /** Shows the current totals now, unless marks are still travelling. */
-    settle() {
-      if (pending.size === 0) write(current());
+    /**
+     * Records the state a render drew. `landsIn` is the milliseconds until its last mark lands,
+     * or 0 when it sent no marks (motion paused, clock stopped, mark cap reached, nothing new).
+     */
+    rendered(from, landsIn) {
+      const tail = queue.at(-1);
+      if (landsIn > 0) {
+        const entry = { from, landed: false, timer: null };
+        entry.timer = setTimer(() => {
+          entry.landed = true;
+          release();
+        }, landsIn);
+        queue.push(entry);
+      } else if (tail?.landed) {
+        // Waiting behind the same marks as the previous render, so only the newest totals matter.
+        tail.from = from;
+      } else {
+        queue.push({ from, landed: true, timer: null });
+      }
+      release();
     },
     /** Drops pending updates, for a capture switch. */
     clear() {
-      for (const timer of pending) clearTimer(timer);
-      pending.clear();
+      for (const entry of queue) if (!entry.landed) clearTimer(entry.timer);
+      queue.length = 0;
     },
   };
 }
diff --git a/tools/integration-viewer/test/count-timers.test.js b/tools/integration-viewer/test/count-timers.test.js
index 7fc2bdb3d..6c63a61ac 100644
--- a/tools/integration-viewer/test/count-timers.test.js
+++ b/tools/integration-viewer/test/count-timers.test.js
@@ -2,82 +2,110 @@ import assert from "node:assert/strict";
 import { test } from "node:test";
 import { createCountTimers } from "../public/count-timers.js";
 
-// Timers fire only when the test says so, in the order they were set.
-function harness() {
-  let state = { acknowledged: 0 };
-  const shown = [];
-  const queue = new Map();
-  let id = 0;
-  const timers = createCountTimers({
-    write: (from) => shown.push(from.acknowledged),
-    current: () => state,
-    setTimer: (fn) => {
-      id += 1;
-      queue.set(id, fn);
-      return id;
+// The page's side of the counters, on a virtual clock. `dispatch` changes the reducer's state
+// at once, as app.js does; `render` is the queued frame that draws it and starts its marks.
+// Timers fire at their due time when the clock passes it.
+function page() {
+  let now = 0;
+  let reducer = { acknowledged: 0 };
+  let shown = 0;
+  const timers = [];
+  const counts = createCountTimers({
+    write: (from) => {
+      shown = from.acknowledged;
     },
-    clearTimer: (t) => queue.delete(t),
+    setTimer: (fn, ms) => {
+      const t = { due: now + ms, fn };
+      timers.push(t);
+      return t;
+    },
+    clearTimer: (t) => timers.splice(timers.indexOf(t), 1),
   });
   return {
-    timers,
-    shown,
-    arrive(acknowledged) {
-      state = { acknowledged };
+    counts,
+    dispatch(acknowledged) {
+      reducer = { acknowledged };
+    },
+    /** Draws the reducer's current state; `landsIn` is 0 when the render sends no marks. */
+    render(landsIn = 0) {
+      counts.rendered(reducer, landsIn);
+    },
+    at(t) {
+      for (;;) {
+        const next = timers.filter((x) => x.due <= t).sort((a, b) => a.due - b.due)[0];
+        if (!next) break;
+        timers.splice(timers.indexOf(next), 1);
+        now = next.due;
+        next.fn();
+      }
+      now = t;
     },
-    fire(t) {
-      const fn = queue.get(t);
-      queue.delete(t);
-      fn();
+    get shown() {
+      return shown;
     },
     get pending() {
-      return [...queue.keys()];
+      return timers.length;
     },
   };
 }
 
-test("a batch that drew no marks while older marks travelled reaches the counters when they land", () => {
-  const h = harness();
-  h.arrive(5);
-  h.timers.afterMarks(1100);
-  h.timers.settle();
-  // Motion is paused (or the mark cap is hit) for the next batch, so it schedules nothing.
-  h.arrive(8);
-  h.timers.settle();
-  assert.deepEqual(h.shown, [], "counters moved while marks were still travelling");
-  h.fire(h.pending[0]);
-  assert.deepEqual(h.shown, [8]);
+test("an arrival the reducer holds but no render has drawn stays off the counters", () => {
+  const p = page();
+  p.dispatch(6);
+  p.render(1450); // six marks, the last landing at 1450 ms
+  p.at(1449);
+  p.dispatch(7); // arrives; its frame is queued, so its mark has not started
+  p.at(1450);
+  assert.equal(p.shown, 6, "the counters counted a file whose mark had not started");
+  p.at(1456);
+  p.render(1100);
+  p.at(2555);
+  assert.equal(p.shown, 6);
+  p.at(2556);
+  assert.equal(p.shown, 7);
+});
+
+test("a later batch that lands first waits for the earlier batch's marks", () => {
+  const p = page();
+  p.dispatch(6);
+  p.render(1450); // six marks from 0 ms, landing by 1450 ms
+  p.at(70);
+  p.dispatch(7);
+  p.render(1100); // one mark from 70 ms, landing at 1170 ms
+  p.at(1170);
+  assert.equal(p.shown, 0, "the counters ran ahead of marks still travelling");
+  p.at(1450);
+  assert.equal(p.shown, 7);
 });
 
-test("an earlier timer shows only its own batch while a later batch's marks still travel", () => {
-  const h = harness();
-  h.arrive(5);
-  h.timers.afterMarks(1100);
-  h.arrive(8);
-  h.timers.afterMarks(1100);
-  const [first, second] = h.pending;
-  h.fire(first);
-  assert.deepEqual(h.shown, [5]);
-  h.arrive(9); // drew no marks
-  h.timers.settle();
-  assert.deepEqual(h.shown, [5]);
-  h.fire(second);
-  assert.deepEqual(h.shown, [5, 9]);
+test("a batch that drew no marks while older marks travelled shows when they land", () => {
+  const p = page();
+  p.dispatch(5);
+  p.render(1100);
+  p.at(300);
+  p.dispatch(8);
+  p.render(0); // motion paused, clock stopped or mark cap reached
+  assert.equal(p.shown, 0);
+  p.at(1100);
+  assert.equal(p.shown, 8);
 });
 
-test("with nothing travelling, the counters update at once", () => {
-  const h = harness();
-  h.arrive(3);
-  h.timers.settle();
-  assert.deepEqual(h.shown, [3]);
+test("with nothing travelling, a render shows its totals at once", () => {
+  const p = page();
+  p.dispatch(3);
+  p.render(0);
+  assert.equal(p.shown, 3);
 });
 
 test("clear drops pending updates", () => {
-  const h = harness();
-  h.arrive(5);
-  h.timers.afterMarks(1100);
-  h.timers.clear();
-  assert.deepEqual(h.pending, []);
-  h.arrive(0);
-  h.timers.settle();
-  assert.deepEqual(h.shown, [0]);
+  const p = page();
+  p.dispatch(5);
+  p.render(1100);
+  p.counts.clear();
+  assert.equal(p.pending, 0);
+  p.at(2000);
+  assert.equal(p.shown, 0);
+  p.dispatch(2);
+  p.render(0);
+  assert.equal(p.shown, 2);
 });

From e3165da2a5fab2a0f5b372700c15022534a6d602 Mon Sep 17 00:00:00 2001
From: Sam Gu <127461594+SamGu-NRX@users.noreply.github.com>
Date: Tue, 13 Oct 2026 19:15:13 -0500
Subject: [PATCH 32/62] docs(how-it-works): call the pool and driveway reaches
 placeholders

The coverage caption gave 5 ft and 10 ft as plain facts; the rules table
on the same page marks both as placeholders with no public value.

Review thread: https://github.com/SamGu-NRX/BaseScanning/pull/14#discussion_r4112033409

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 docs/how-it-works.html | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/how-it-works.html b/docs/how-it-works.html
index 3e151e220..4bb714da2 100644
--- a/docs/how-it-works.html
+++ b/docs/how-it-works.html
@@ -762,7 +762,7 @@ <h3>Coverage is a fixed zone</h3>
     <line x1="70" y1="186" x2="410" y2="186" stroke="var(--phone)" stroke-width="3" stroke-dasharray="1 7" stroke-linecap="round"/>
     <use href="#phone" x="150" y="173"/>
   </svg>
-  <figcaption>Each check reaches out from the spot it tests: 3 ft along the wall for gas meters, AC units, doors and windows, 5 ft for a driveway, 10 ft for a pool, and up for headroom and wall equipment. So the zone runs past the 20 ft of cable at both ends, and over the ground out to 13 ft. Any part of it nobody saw keeps its checks UNSURE.</figcaption>
+  <figcaption>Each check reaches out from the spot it tests: 3 ft along the wall for gas meters, AC units, doors and windows, 5 ft for a driveway and 10 ft for a pool (both placeholders, with no public value), and up for headroom and wall equipment. So the zone runs past the 20 ft of cable at both ends, and over the ground out to 13 ft. Any part of it nobody saw keeps its checks UNSURE.</figcaption>
 </figure>
 
 <h3>LiDAR helps but isn't required</h3>

From 188c1261992d207535b209199e24dd06b926b163 Mon Sep 17 00:00:00 2001
From: Sam Gu <127461594+SamGu-NRX@users.noreply.github.com>
Date: Tue, 13 Oct 2026 19:18:32 -0500
Subject: [PATCH 33/62] experiments(edge-geometry): M3 with the widest photo
 pair is no better

Ran run.py --pair=widest against the evals harness at 190ed33. On electro
with modern_assumed poses M3's 3-D p90 is 158.7 in against the narrow
pair's 154.6, and the match rate is 41% either way; with exact poses the
wide pair is worse (156.4 against 112.5 in) because fewer matches land
within 2 px. P4 fails under both policies, so the pre-registered narrow
pairing does not inflate the reported error. The single-photo tables
reproduce the committed ones exactly. METHODS and README say so.

https://github.com/SamGu-NRX/BaseScanning/pull/59#discussion_r4115044359

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 experiments/edge-geometry/METHODS.md          |    2 +
 experiments/edge-geometry/README.md           |    2 +-
 .../results/edge_geometry_widest_pair.json    | 4170 +++++++++++++++++
 .../results/edge_geometry_widest_pair.md      |  231 +
 4 files changed, 4404 insertions(+), 1 deletion(-)
 create mode 100644 experiments/edge-geometry/results/edge_geometry_widest_pair.json
 create mode 100644 experiments/edge-geometry/results/edge_geometry_widest_pair.md

diff --git a/experiments/edge-geometry/METHODS.md b/experiments/edge-geometry/METHODS.md
index cacfc3c06..c984b0091 100644
--- a/experiments/edge-geometry/METHODS.md
+++ b/experiments/edge-geometry/METHODS.md
@@ -37,6 +37,8 @@ Electro: 3,000 edge points on 21 laser wall planes, 2,258 in-plane and 742 proud
 
 Added after the run: M2 with the true pixel still gives 11.5. The MoGe-2 wall plane misses the edge point by 10.0 at p90, where the laser plane misses it by 1.4. A snap started at the true pixel moves 8.8 px on vertical edges, so the snap's pixel error is ill-posed for these points. M3 matches within 2 px give 2.9 with exact poses and 8.9 with `modern_assumed`. Facade has 866 points but no wall within 6 m, so only M0 runs there.
 
+Added after review: M3 pairs each point with the narrowest qualifying ray angle (at least 5°), which may triangulate worse than a wider pair. `uv run python run.py --pair=widest` reruns it with the widest angle ([results/edge_geometry_widest_pair.md](results/edge_geometry_widest_pair.md)). On electro it is no better: with `modern_assumed` poses M3's 3-D p90 is 158.7 in against 154.6, and 41% of points match either way. With exact poses the wide pair is worse, 156.4 in against 112.5, because fewer of its matches land within 2 px (35% against 49%). P4 fails under both, so the narrow pair is not what makes M3 look bad. The single-photo tables came out identical to the committed ones.
+
 Run: `uv run python run.py`. It takes 2 minutes and 0.9 GB. It needs the evals checkout at `190ed33` (`EDGE_EVALS_DIR`) and its ETH3D, MoGe-2 and pose caches.
 
 What it changes: the wall plane's depth error times tan(view angle) sets the edge error, so get the edge photo within 30° of head-on. A snapped tap can't beat the plane's error, and patch matching at edges fails on more than half the points.
diff --git a/experiments/edge-geometry/README.md b/experiments/edge-geometry/README.md
index 36d3563d8..7cc614a41 100644
--- a/experiments/edge-geometry/README.md
+++ b/experiments/edge-geometry/README.md
@@ -19,7 +19,7 @@ P1 passes; P2 to P4 fail ([tables](results/edge_geometry.md)).
 - **Angle.** In-plane edges are 0.9 in p90 along the wall within 15° of face-on and 24 in beyond 45°.
 - **Ray to plane (M1).** 6.7 in overall, 0.5 in within 15°.
 - **The app's plane (M1-anchor).** Its yaw error is 2.2° median and 6.7° p90.
-- **M2 and M3.** Tap, snap and median gives 12.6 in, because the learned plane's own error dominates. Two-photo matching finds 41% of points.
+- **M2 and M3.** Tap, snap and median gives 12.6 in, because the learned plane's own error dominates. Two-photo matching finds 41% of points. Pairing each point with the widest photo pair instead of the narrowest is no better (added after review).
 
 **Run:** `uv run python run.py`: 2 min, 0.9 GB. Needs the evals checkout at 190ed33 and its ETH3D and MoGe-2 caches.
 
diff --git a/experiments/edge-geometry/results/edge_geometry_widest_pair.json b/experiments/edge-geometry/results/edge_geometry_widest_pair.json
new file mode 100644
index 000000000..bb3fddb62
--- /dev/null
+++ b/experiments/edge-geometry/results/edge_geometry_widest_pair.json
@@ -0,0 +1,4170 @@
+{
+ "m3_pairing": "widest",
+ "evals_commit": "190ed339f41924ae0244e0b88c5ebe647ddd9eb4",
+ "evals_dir": "~/Programming Projects/review-debt/worktrees/evals-190ed33/experiments/evals",
+ "parameters": {
+  "NEAR_M": 6.0,
+  "TOLERANCE": 0.04,
+  "VERTICAL_MAX_UP": 0.3,
+  "WIDTH": 1024,
+  "SCENES": [
+   "electro",
+   "facade"
+  ],
+  "MIN_POINTS_TO_REPORT": 200,
+  "MAX_POINTS": 3000,
+  "PLANE_TOL_M": 0.03,
+  "MAX_TILT_DEG": 17.0,
+  "RANSAC_POINTS": 400000,
+  "JOIN_M": 0.6,
+  "MEMBER_REACH_M": 1.0,
+  "IN_PLANE_M": 0.05,
+  "EDGE_RADIUS_M": 0.15,
+  "VERTICAL_EDGE_DEG": 30.0,
+  "MIN_WALL_PX": 50,
+  "ANCHOR_ALONG_M": [
+   1.0,
+   3.0
+  ],
+  "ANCHOR_TARGET_M": 2.0,
+  "PATCH_RADIUS_M": 0.3,
+  "MIN_PATCH_PX": 20,
+  "ANCHOR_TRIES": 5,
+  "TAP_SIGMA_PX": 10.0,
+  "SNAP_RADIUS_PX": 25,
+  "SNAP_ROWS": 9,
+  "WORLD_PLANE_PX_PER_PHOTO": 3000,
+  "MIN_BASELINE_M": 0.3,
+  "MIN_RAY_ANGLE_DEG": 5.0,
+  "NCC_MIN": 0.8,
+  "NCC_PATCH": 15,
+  "DEPTH_RANGE_M": [
+   0.5,
+   10.0
+  ],
+  "SEED": 20260926
+ },
+ "scenes": {
+  "electro": {
+   "meta": {
+    "photos": 45,
+    "wall_planes": 21,
+    "edge_points_within_6m": 27436,
+    "edge_points_on_a_wall": 25492,
+    "points_sampled": 3000,
+    "in_plane": 2258,
+    "proud": 742,
+    "vertical_edges": 730,
+    "up_vs_camera_up_deg": 5.21,
+    "wall_tilt_deg_max": 3.14,
+    "oracle_scale_median": 0.9961415148011799,
+    "seconds": 53
+   },
+   "single": {
+    "m0": {
+     "all": {
+      "all angles": {
+       "along": {
+        "n": 7871,
+        "points": 2994,
+        "median_in": 2.13,
+        "p90_in": 15.64
+       },
+       "out": {
+        "n": 7871,
+        "points": 2994,
+        "median_in": 3.11,
+        "p90_in": 19.17
+       },
+       "3d": {
+        "n": 7871,
+        "points": 2994,
+        "median_in": 5.72,
+        "p90_in": 38.62
+       },
+       "missing": 23
+      },
+      "0-15": {
+       "along": {
+        "n": 647,
+        "points": 345,
+        "median_in": 0.19,
+        "p90_in": 1.35
+       },
+       "out": {
+        "n": 647,
+        "points": 345,
+        "median_in": 4.83,
+        "p90_in": 14.83
+       },
+       "3d": {
+        "n": 647,
+        "points": 345,
+        "median_in": 4.9,
+        "p90_in": 14.93
+       },
+       "missing": 0
+      },
+      "15-30": {
+       "along": {
+        "n": 1483,
+        "points": 912,
+        "median_in": 0.73,
+        "p90_in": 4.59
+       },
+       "out": {
+        "n": 1483,
+        "points": 912,
+        "median_in": 3.76,
+        "p90_in": 15.26
+       },
+       "3d": {
+        "n": 1483,
+        "points": 912,
+        "median_in": 4.15,
+        "p90_in": 16.98
+       },
+       "missing": 2
+      },
+      "30-45": {
+       "along": {
+        "n": 2460,
+        "points": 1430,
+        "median_in": 2.02,
+        "p90_in": 8.89
+       },
+       "out": {
+        "n": 2460,
+        "points": 1430,
+        "median_in": 4.17,
+        "p90_in": 20.37
+       },
+       "3d": {
+        "n": 2460,
+        "points": 1430,
+        "median_in": 5.25,
+        "p90_in": 24.91
+       },
+       "missing": 14
+      },
+      ">45": {
+       "along": {
+        "n": 3281,
+        "points": 1593,
+        "median_in": 5.09,
+        "p90_in": 24.36
+       },
+       "out": {
+        "n": 3281,
+        "points": 1593,
+        "median_in": 1.72,
+        "p90_in": 23.7
+       },
+       "3d": {
+        "n": 3281,
+        "points": 1593,
+        "median_in": 7.5,
+        "p90_in": 66.17
+       },
+       "missing": 7
+      }
+     },
+     "in_plane": {
+      "all angles": {
+       "along": {
+        "n": 6067,
+        "points": 2258,
+        "median_in": 2.0,
+        "p90_in": 14.56
+       },
+       "out": {
+        "n": 6067,
+        "points": 2258,
+        "median_in": 2.78,
+        "p90_in": 16.17
+       },
+       "3d": {
+        "n": 6067,
+        "points": 2258,
+        "median_in": 5.33,
+        "p90_in": 31.73
+       },
+       "missing": 9
+      },
+      "0-15": {
+       "along": {
+        "n": 547,
+        "points": 281,
+        "median_in": 0.19,
+        "p90_in": 0.91
+       },
+       "out": {
+        "n": 547,
+        "points": 281,
+        "median_in": 4.83,
+        "p90_in": 14.63
+       },
+       "3d": {
+        "n": 547,
+        "points": 281,
+        "median_in": 4.9,
+        "p90_in": 14.78
+       },
+       "missing": 0
+      },
+      "15-30": {
+       "along": {
+        "n": 1067,
+        "points": 708,
+        "median_in": 0.67,
+        "p90_in": 4.47
+       },
+       "out": {
+        "n": 1067,
+        "points": 708,
+        "median_in": 3.36,
+        "p90_in": 16.86
+       },
+       "3d": {
+        "n": 1067,
+        "points": 708,
+        "median_in": 3.64,
+        "p90_in": 18.19
+       },
+       "missing": 2
+      },
+      "30-45": {
+       "along": {
+        "n": 1835,
+        "points": 1077,
+        "median_in": 1.9,
+        "p90_in": 7.84
+       },
+       "out": {
+        "n": 1835,
+        "points": 1077,
+        "median_in": 3.85,
+        "p90_in": 15.95
+       },
+       "3d": {
+        "n": 1835,
+        "points": 1077,
+        "median_in": 4.91,
+        "p90_in": 19.86
+       },
+       "missing": 5
+      },
+      ">45": {
+       "along": {
+        "n": 2618,
+        "points": 1211,
+        "median_in": 4.78,
+        "p90_in": 24.06
+       },
+       "out": {
+        "n": 2618,
+        "points": 1211,
+        "median_in": 1.52,
+        "p90_in": 17.68
+       },
+       "3d": {
+        "n": 2618,
+        "points": 1211,
+        "median_in": 6.63,
+        "p90_in": 62.06
+       },
+       "missing": 2
+      }
+     },
+     "proud": {
+      "all angles": {
+       "along": {
+        "n": 1804,
+        "points": 736,
+        "median_in": 2.45,
+        "p90_in": 18.03
+       },
+       "out": {
+        "n": 1804,
+        "points": 736,
+        "median_in": 4.17,
+        "p90_in": 25.02
+       },
+       "3d": {
+        "n": 1804,
+        "points": 736,
+        "median_in": 7.34,
+        "p90_in": 57.26
+       },
+       "missing": 14
+      },
+      "0-15": {
+       "along": {
+        "n": 100,
+        "points": 64,
+        "median_in": 0.35,
+        "p90_in": 2.73
+       },
+       "out": {
+        "n": 100,
+        "points": 64,
+        "median_in": 4.85,
+        "p90_in": 16.17
+       },
+       "3d": {
+        "n": 100,
+        "points": 64,
+        "median_in": 4.93,
+        "p90_in": 16.4
+       },
+       "missing": 0
+      },
+      "15-30": {
+       "along": {
+        "n": 416,
+        "points": 204,
+        "median_in": 0.93,
+        "p90_in": 4.76
+       },
+       "out": {
+        "n": 416,
+        "points": 204,
+        "median_in": 4.22,
+        "p90_in": 12.73
+       },
+       "3d": {
+        "n": 416,
+        "points": 204,
+        "median_in": 4.6,
+        "p90_in": 14.1
+       },
+       "missing": 0
+      },
+      "30-45": {
+       "along": {
+        "n": 625,
+        "points": 353,
+        "median_in": 2.4,
+        "p90_in": 12.12
+       },
+       "out": {
+        "n": 625,
+        "points": 353,
+        "median_in": 5.44,
+        "p90_in": 24.81
+       },
+       "3d": {
+        "n": 625,
+        "points": 353,
+        "median_in": 6.87,
+        "p90_in": 30.17
+       },
+       "missing": 9
+      },
+      ">45": {
+       "along": {
+        "n": 663,
+        "points": 382,
+        "median_in": 6.76,
+        "p90_in": 27.06
+       },
+       "out": {
+        "n": 663,
+        "points": 382,
+        "median_in": 3.14,
+        "p90_in": 48.07
+       },
+       "3d": {
+        "n": 663,
+        "points": 382,
+        "median_in": 19.91,
+        "p90_in": 116.19
+       },
+       "missing": 5
+      }
+     }
+    },
+    "m1": {
+     "all": {
+      "all angles": {
+       "along": {
+        "n": 6257,
+        "points": 2712,
+        "median_in": 1.26,
+        "p90_in": 7.25
+       },
+       "out": {
+        "n": 6257,
+        "points": 2712,
+        "median_in": 3.11,
+        "p90_in": 10.49
+       },
+       "3d": {
+        "n": 6257,
+        "points": 2712,
+        "median_in": 4.19,
+        "p90_in": 15.1
+       },
+       "missing": 1637
+      },
+      "0-15": {
+       "along": {
+        "n": 615,
+        "points": 342,
+        "median_in": 0.16,
+        "p90_in": 0.58
+       },
+       "out": {
+        "n": 615,
+        "points": 342,
+        "median_in": 4.16,
+        "p90_in": 11.43
+       },
+       "3d": {
+        "n": 615,
+        "points": 342,
+        "median_in": 4.17,
+        "p90_in": 11.57
+       },
+       "missing": 32
+      },
+      "15-30": {
+       "along": {
+        "n": 1406,
+        "points": 898,
+        "median_in": 0.53,
+        "p90_in": 2.75
+       },
+       "out": {
+        "n": 1406,
+        "points": 898,
+        "median_in": 2.88,
+        "p90_in": 10.29
+       },
+       "3d": {
+        "n": 1406,
+        "points": 898,
+        "median_in": 3.17,
+        "p90_in": 11.11
+       },
+       "missing": 79
+      },
+      "30-45": {
+       "along": {
+        "n": 2358,
+        "points": 1376,
+        "median_in": 1.63,
+        "p90_in": 6.32
+       },
+       "out": {
+        "n": 2358,
+        "points": 1376,
+        "median_in": 3.31,
+        "p90_in": 8.87
+       },
+       "3d": {
+        "n": 2358,
+        "points": 1376,
+        "median_in": 4.16,
+        "p90_in": 11.35
+       },
+       "missing": 116
+      },
+      ">45": {
+       "along": {
+        "n": 1878,
+        "points": 1219,
+        "median_in": 3.49,
+        "p90_in": 21.69
+       },
+       "out": {
+        "n": 1878,
+        "points": 1219,
+        "median_in": 2.56,
+        "p90_in": 16.32
+       },
+       "3d": {
+        "n": 1878,
+        "points": 1219,
+        "median_in": 5.33,
+        "p90_in": 45.01
+       },
+       "missing": 1410
+      }
+     },
+     "in_plane": {
+      "all angles": {
+       "along": {
+        "n": 4920,
+        "points": 2097,
+        "median_in": 1.13,
+        "p90_in": 6.65
+       },
+       "out": {
+        "n": 4920,
+        "points": 2097,
+        "median_in": 2.7,
+        "p90_in": 9.16
+       },
+       "3d": {
+        "n": 4920,
+        "points": 2097,
+        "median_in": 3.77,
+        "p90_in": 12.0
+       },
+       "missing": 1156
+      },
+      "0-15": {
+       "along": {
+        "n": 516,
+        "points": 278,
+        "median_in": 0.13,
+        "p90_in": 0.45
+       },
+       "out": {
+        "n": 516,
+        "points": 278,
+        "median_in": 4.25,
+        "p90_in": 11.52
+       },
+       "3d": {
+        "n": 516,
+        "points": 278,
+        "median_in": 4.27,
+        "p90_in": 11.65
+       },
+       "missing": 31
+      },
+      "15-30": {
+       "along": {
+        "n": 1041,
+        "points": 699,
+        "median_in": 0.42,
+        "p90_in": 2.3
+       },
+       "out": {
+        "n": 1041,
+        "points": 699,
+        "median_in": 2.44,
+        "p90_in": 9.78
+       },
+       "3d": {
+        "n": 1041,
+        "points": 699,
+        "median_in": 2.7,
+        "p90_in": 10.67
+       },
+       "missing": 28
+      },
+      "30-45": {
+       "along": {
+        "n": 1787,
+        "points": 1044,
+        "median_in": 1.52,
+        "p90_in": 5.76
+       },
+       "out": {
+        "n": 1787,
+        "points": 1044,
+        "median_in": 3.01,
+        "p90_in": 7.64
+       },
+       "3d": {
+        "n": 1787,
+        "points": 1044,
+        "median_in": 3.74,
+        "p90_in": 10.11
+       },
+       "missing": 53
+      },
+      ">45": {
+       "along": {
+        "n": 1576,
+        "points": 998,
+        "median_in": 2.89,
+        "p90_in": 15.02
+       },
+       "out": {
+        "n": 1576,
+        "points": 998,
+        "median_in": 1.89,
+        "p90_in": 8.92
+       },
+       "3d": {
+        "n": 1576,
+        "points": 998,
+        "median_in": 4.49,
+        "p90_in": 36.17
+       },
+       "missing": 1044
+      }
+     },
+     "proud": {
+      "all angles": {
+       "along": {
+        "n": 1337,
+        "points": 615,
+        "median_in": 2.01,
+        "p90_in": 14.46
+       },
+       "out": {
+        "n": 1337,
+        "points": 615,
+        "median_in": 5.0,
+        "p90_in": 19.02
+       },
+       "3d": {
+        "n": 1337,
+        "points": 615,
+        "median_in": 6.29,
+        "p90_in": 27.46
+       },
+       "missing": 481
+      },
+      "0-15": {
+       "along": {
+        "n": 99,
+        "points": 64,
+        "median_in": 0.28,
+        "p90_in": 1.05
+       },
+       "out": {
+        "n": 99,
+        "points": 64,
+        "median_in": 3.82,
+        "p90_in": 7.23
+       },
+       "3d": {
+        "n": 99,
+        "points": 64,
+        "median_in": 3.88,
+        "p90_in": 7.34
+       },
+       "missing": 1
+      },
+      "15-30": {
+       "along": {
+        "n": 365,
+        "points": 199,
+        "median_in": 0.99,
+        "p90_in": 3.54
+       },
+       "out": {
+        "n": 365,
+        "points": 199,
+        "median_in": 4.62,
+        "p90_in": 11.83
+       },
+       "3d": {
+        "n": 365,
+        "points": 199,
+        "median_in": 5.02,
+        "p90_in": 12.83
+       },
+       "missing": 51
+      },
+      "30-45": {
+       "along": {
+        "n": 571,
+        "points": 332,
+        "median_in": 2.23,
+        "p90_in": 8.69
+       },
+       "out": {
+        "n": 571,
+        "points": 332,
+        "median_in": 4.54,
+        "p90_in": 15.93
+       },
+       "3d": {
+        "n": 571,
+        "points": 332,
+        "median_in": 5.83,
+        "p90_in": 20.66
+       },
+       "missing": 63
+      },
+      ">45": {
+       "along": {
+        "n": 302,
+        "points": 221,
+        "median_in": 12.09,
+        "p90_in": 31.95
+       },
+       "out": {
+        "n": 302,
+        "points": 221,
+        "median_in": 9.57,
+        "p90_in": 29.5
+       },
+       "3d": {
+        "n": 302,
+        "points": 221,
+        "median_in": 19.18,
+        "p90_in": 77.71
+       },
+       "missing": 366
+      }
+     }
+    },
+    "m1a": {
+     "all": {
+      "all angles": {
+       "along": {
+        "n": 3411,
+        "points": 1707,
+        "median_in": 2.04,
+        "p90_in": 12.18
+       },
+       "out": {
+        "n": 3411,
+        "points": 1707,
+        "median_in": 3.82,
+        "p90_in": 17.86
+       },
+       "3d": {
+        "n": 3411,
+        "points": 1707,
+        "median_in": 5.11,
+        "p90_in": 27.19
+       },
+       "missing": 4483
+      },
+      "0-15": {
+       "along": {
+        "n": 301,
+        "points": 199,
+        "median_in": 0.15,
+        "p90_in": 0.57
+       },
+       "out": {
+        "n": 301,
+        "points": 199,
+        "median_in": 3.72,
+        "p90_in": 12.65
+       },
+       "3d": {
+        "n": 301,
+        "points": 199,
+        "median_in": 3.77,
+        "p90_in": 12.77
+       },
+       "missing": 346
+      },
+      "15-30": {
+       "along": {
+        "n": 821,
+        "points": 592,
+        "median_in": 1.13,
+        "p90_in": 5.55
+       },
+       "out": {
+        "n": 821,
+        "points": 592,
+        "median_in": 3.92,
+        "p90_in": 14.03
+       },
+       "3d": {
+        "n": 821,
+        "points": 592,
+        "median_in": 4.26,
+        "p90_in": 15.65
+       },
+       "missing": 664
+      },
+      "30-45": {
+       "along": {
+        "n": 1411,
+        "points": 924,
+        "median_in": 2.16,
+        "p90_in": 10.46
+       },
+       "out": {
+        "n": 1411,
+        "points": 924,
+        "median_in": 4.28,
+        "p90_in": 19.67
+       },
+       "3d": {
+        "n": 1411,
+        "points": 924,
+        "median_in": 5.39,
+        "p90_in": 26.69
+       },
+       "missing": 1063
+      },
+      ">45": {
+       "along": {
+        "n": 878,
+        "points": 633,
+        "median_in": 5.12,
+        "p90_in": 27.12
+       },
+       "out": {
+        "n": 878,
+        "points": 633,
+        "median_in": 3.03,
+        "p90_in": 18.81
+       },
+       "3d": {
+        "n": 878,
+        "points": 633,
+        "median_in": 6.57,
+        "p90_in": 36.78
+       },
+       "missing": 2410
+      }
+     },
+     "in_plane": {
+      "all angles": {
+       "along": {
+        "n": 2755,
+        "points": 1360,
+        "median_in": 1.93,
+        "p90_in": 10.43
+       },
+       "out": {
+        "n": 2755,
+        "points": 1360,
+        "median_in": 3.38,
+        "p90_in": 13.62
+       },
+       "3d": {
+        "n": 2755,
+        "points": 1360,
+        "median_in": 4.66,
+        "p90_in": 21.04
+       },
+       "missing": 3321
+      },
+      "0-15": {
+       "along": {
+        "n": 278,
+        "points": 181,
+        "median_in": 0.15,
+        "p90_in": 0.5
+       },
+       "out": {
+        "n": 278,
+        "points": 181,
+        "median_in": 3.5,
+        "p90_in": 11.78
+       },
+       "3d": {
+        "n": 278,
+        "points": 181,
+        "median_in": 3.52,
+        "p90_in": 12.04
+       },
+       "missing": 269
+      },
+      "15-30": {
+       "along": {
+        "n": 633,
+        "points": 478,
+        "median_in": 1.02,
+        "p90_in": 5.83
+       },
+       "out": {
+        "n": 633,
+        "points": 478,
+        "median_in": 3.49,
+        "p90_in": 13.65
+       },
+       "3d": {
+        "n": 633,
+        "points": 478,
+        "median_in": 3.88,
+        "p90_in": 15.34
+       },
+       "missing": 436
+      },
+      "30-45": {
+       "along": {
+        "n": 1088,
+        "points": 727,
+        "median_in": 2.21,
+        "p90_in": 8.58
+       },
+       "out": {
+        "n": 1088,
+        "points": 727,
+        "median_in": 4.06,
+        "p90_in": 16.15
+       },
+       "3d": {
+        "n": 1088,
+        "points": 727,
+        "median_in": 5.05,
+        "p90_in": 19.5
+       },
+       "missing": 752
+      },
+      ">45": {
+       "along": {
+        "n": 756,
+        "points": 526,
+        "median_in": 4.54,
+        "p90_in": 27.69
+       },
+       "out": {
+        "n": 756,
+        "points": 526,
+        "median_in": 2.76,
+        "p90_in": 12.21
+       },
+       "3d": {
+        "n": 756,
+        "points": 526,
+        "median_in": 5.68,
+        "p90_in": 36.52
+       },
+       "missing": 1864
+      }
+     },
+     "proud": {
+      "all angles": {
+       "along": {
+        "n": 656,
+        "points": 347,
+        "median_in": 2.48,
+        "p90_in": 15.62
+       },
+       "out": {
+        "n": 656,
+        "points": 347,
+        "median_in": 6.29,
+        "p90_in": 42.42
+       },
+       "3d": {
+        "n": 656,
+        "points": 347,
+        "median_in": 7.99,
+        "p90_in": 64.13
+       },
+       "missing": 1162
+      },
+      "0-15": {
+       "along": {
+        "n": 23,
+        "points": 18,
+        "median_in": 2.13,
+        "p90_in": 154.09
+       },
+       "out": {
+        "n": 23,
+        "points": 18,
+        "median_in": 12.74,
+        "p90_in": 3149.65
+       },
+       "3d": {
+        "n": 23,
+        "points": 18,
+        "median_in": 12.98,
+        "p90_in": 3164.05
+       },
+       "missing": 77
+      },
+      "15-30": {
+       "along": {
+        "n": 188,
+        "points": 114,
+        "median_in": 1.69,
+        "p90_in": 5.06
+       },
+       "out": {
+        "n": 188,
+        "points": 114,
+        "median_in": 7.13,
+        "p90_in": 14.6
+       },
+       "3d": {
+        "n": 188,
+        "points": 114,
+        "median_in": 7.77,
+        "p90_in": 16.43
+       },
+       "missing": 228
+      },
+      "30-45": {
+       "along": {
+        "n": 323,
+        "points": 197,
+        "median_in": 1.99,
+        "p90_in": 15.69
+       },
+       "out": {
+        "n": 323,
+        "points": 197,
+        "median_in": 4.69,
+        "p90_in": 63.53
+       },
+       "3d": {
+        "n": 323,
+        "points": 197,
+        "median_in": 5.84,
+        "p90_in": 79.7
+       },
+       "missing": 311
+      },
+      ">45": {
+       "along": {
+        "n": 122,
+        "points": 107,
+        "median_in": 9.51,
+        "p90_in": 17.91
+       },
+       "out": {
+        "n": 122,
+        "points": 107,
+        "median_in": 7.42,
+        "p90_in": 41.02
+       },
+       "3d": {
+        "n": 122,
+        "points": 107,
+        "median_in": 14.5,
+        "p90_in": 63.92
+       },
+       "missing": 546
+      }
+     }
+    },
+    "m1a_yaw": {
+     "observations": 3411,
+     "abs_psi_deg": {
+      "median": 2.15,
+      "p90": 6.72
+     },
+     "abs_s_m_median": 2.0,
+     "all_added_after_the_run": {
+      "sign_agreement_where_prediction_over_1cm": 0.7,
+      "median_error_over_prediction_where_over_1cm": 0.73,
+      "view_angle_under_60": {
+       "n": 3080,
+       "slope": 0.36,
+       "r2": 0.01
+      },
+      "spearman_abs_error_vs_tan_angle_alone": 0.5
+     },
+     "all": {
+      "n": 3411,
+      "signed_first_order_slope": 0.05,
+      "signed_first_order_r2": 0.02,
+      "signed_r2_with_slope_1": -4.58,
+      "abs_error_over_s_psi_tan_median": 0.94,
+      "abs_error_over_s_psi_tan_n": 2811,
+      "spearman_abs_error_vs_s_psi_tan": 0.63,
+      "abs_error_p90_in": 12.18,
+      "residual_after_first_order_p90_in": 10.9
+     },
+     "in_plane_added_after_the_run": {
+      "sign_agreement_where_prediction_over_1cm": 0.74,
+      "median_error_over_prediction_where_over_1cm": 0.83,
+      "view_angle_under_60": {
+       "n": 2455,
+       "slope": 0.29,
+       "r2": 0.02
+      },
+      "spearman_abs_error_vs_tan_angle_alone": 0.54
+     },
+     "in_plane": {
+      "n": 2755,
+      "signed_first_order_slope": 0.05,
+      "signed_first_order_r2": 0.02,
+      "signed_r2_with_slope_1": -12.61,
+      "abs_error_over_s_psi_tan_median": 0.94,
+      "abs_error_over_s_psi_tan_n": 2231,
+      "spearman_abs_error_vs_s_psi_tan": 0.67,
+      "abs_error_p90_in": 10.43,
+      "residual_after_first_order_p90_in": 9.41
+     }
+    },
+    "added_after_the_run_edge_point_to_plane": {
+     "laser_plane_in_plane_edges": {
+      "n": 6076,
+      "points": 2258,
+      "median_in": 0.4,
+      "p90_in": 1.38
+     },
+     "m1_plane_in_plane_edges": {
+      "n": 4920,
+      "points": 2097,
+      "median_in": 2.54,
+      "p90_in": 9.81
+     }
+    }
+   },
+   "multi": {
+    "exact": {
+     "all": {
+      "M2": {
+       "span_along": {
+        "n": 1819,
+        "points": 1819,
+        "median_in": 4.01,
+        "p90_in": 14.46,
+        "p90_ci95_in": [
+         13.85,
+         15.72
+        ]
+       },
+       "span_3d": {
+        "n": 1819,
+        "points": 1819,
+        "median_in": 6.39,
+        "p90_in": 23.93
+       },
+       "frame_along": {
+        "n": 2617,
+        "points": 2617,
+        "median_in": 3.37,
+        "p90_in": 16.39
+       },
+       "frame_3d": {
+        "n": 2617,
+        "points": 2617,
+        "median_in": 6.08,
+        "p90_in": 27.83
+       }
+      },
+      "M2_added_after_the_run": {
+       "span_along_tap_no_snap": {
+        "n": 1819,
+        "points": 1819,
+        "median_in": 2.8,
+        "p90_in": 12.97
+       },
+       "span_along_true_pixel": {
+        "n": 1819,
+        "points": 1819,
+        "median_in": 2.55,
+        "p90_in": 12.57
+       },
+       "frame_along_true_pixel": {
+        "n": 2617,
+        "points": 2617,
+        "median_in": 1.31,
+        "p90_in": 13.11
+       },
+       "edge_point_to_fused_plane": {
+        "n": 2617,
+        "points": 2617,
+        "median_in": 2.69,
+        "p90_in": 13.87
+       },
+       "span_along_by_median_view_angle": {
+        "0-15": {
+         "n": 191,
+         "points": 191,
+         "median_in": 2.22,
+         "p90_in": 5.69
+        },
+        "15-30": {
+         "n": 343,
+         "points": 343,
+         "median_in": 3.28,
+         "p90_in": 11.66
+        },
+        "30-45": {
+         "n": 959,
+         "points": 959,
+         "median_in": 4.16,
+         "p90_in": 12.33
+        },
+        ">45": {
+         "n": 326,
+         "points": 326,
+         "median_in": 7.53,
+         "p90_in": 38.75
+        }
+       },
+       "span_along_true_pixel_by_median_view_angle": {
+        "0-15": {
+         "n": 191,
+         "points": 191,
+         "median_in": 0.17,
+         "p90_in": 4.53
+        },
+        "15-30": {
+         "n": 343,
+         "points": 343,
+         "median_in": 1.28,
+         "p90_in": 12.04
+        },
+        "30-45": {
+         "n": 959,
+         "points": 959,
+         "median_in": 2.58,
+         "p90_in": 11.79
+        },
+        ">45": {
+         "n": 326,
+         "points": 326,
+         "median_in": 5.95,
+         "p90_in": 51.18
+        }
+       }
+      },
+      "M3": {
+       "pairs": 2489,
+       "match_rate": 0.441,
+       "match_px": {
+        "n": 1097,
+        "median": 6.05,
+        "p90": 186.45
+       },
+       "frame_3d": {
+        "n": 1097,
+        "points": 1097,
+        "median_in": 4.92,
+        "p90_in": 101.76
+       },
+       "frame_along": {
+        "n": 1097,
+        "points": 1097,
+        "median_in": 1.43,
+        "p90_in": 49.88
+       },
+       "span_along": {
+        "n": 439,
+        "points": 439,
+        "median_in": 9.32,
+        "p90_in": 59.52,
+        "p90_ci95_in": [
+         54.35,
+         67.41
+        ]
+       },
+       "span_3d": {
+        "n": 439,
+        "points": 439,
+        "median_in": 43.87,
+        "p90_in": 156.35,
+        "p90_ci95_in": [
+         134.29,
+         161.35
+        ]
+       },
+       "anchor_matched": 439,
+       "added_after_the_run_frame_3d_where_match_within_2px": {
+        "n": 381,
+        "points": 381,
+        "median_in": 0.55,
+        "p90_in": 1.84
+       },
+       "added_after_the_run_share_of_matches_within_2px": 0.347
+      }
+     },
+     "in_plane": {
+      "M2": {
+       "span_along": {
+        "n": 1452,
+        "points": 1452,
+        "median_in": 3.74,
+        "p90_in": 13.02,
+        "p90_ci95_in": [
+         12.06,
+         14.18
+        ]
+       },
+       "span_3d": {
+        "n": 1452,
+        "points": 1452,
+        "median_in": 5.78,
+        "p90_in": 22.02
+       },
+       "frame_along": {
+        "n": 2028,
+        "points": 2028,
+        "median_in": 3.26,
+        "p90_in": 14.39
+       },
+       "frame_3d": {
+        "n": 2028,
+        "points": 2028,
+        "median_in": 5.85,
+        "p90_in": 19.3
+       }
+      },
+      "M2_added_after_the_run": {
+       "span_along_tap_no_snap": {
+        "n": 1452,
+        "points": 1452,
+        "median_in": 2.55,
+        "p90_in": 10.89
+       },
+       "span_along_true_pixel": {
+        "n": 1452,
+        "points": 1452,
+        "median_in": 2.15,
+        "p90_in": 10.93
+       },
+       "frame_along_true_pixel": {
+        "n": 2028,
+        "points": 2028,
+        "median_in": 1.23,
+        "p90_in": 10.19
+       },
+       "edge_point_to_fused_plane": {
+        "n": 2028,
+        "points": 2028,
+        "median_in": 2.26,
+        "p90_in": 10.04
+       },
+       "span_along_by_median_view_angle": {
+        "0-15": {
+         "n": 178,
+         "points": 178,
+         "median_in": 2.29,
+         "p90_in": 5.63
+        },
+        "15-30": {
+         "n": 245,
+         "points": 245,
+         "median_in": 2.68,
+         "p90_in": 6.78
+        },
+        "30-45": {
+         "n": 780,
+         "points": 780,
+         "median_in": 4.19,
+         "p90_in": 11.6
+        },
+        ">45": {
+         "n": 249,
+         "points": 249,
+         "median_in": 6.09,
+         "p90_in": 29.1
+        }
+       },
+       "span_along_true_pixel_by_median_view_angle": {
+        "0-15": {
+         "n": 178,
+         "points": 178,
+         "median_in": 0.15,
+         "p90_in": 4.27
+        },
+        "15-30": {
+         "n": 245,
+         "points": 245,
+         "median_in": 1.12,
+         "p90_in": 3.63
+        },
+        "30-45": {
+         "n": 780,
+         "points": 780,
+         "median_in": 2.54,
+         "p90_in": 10.5
+        },
+        ">45": {
+         "n": 249,
+         "points": 249,
+         "median_in": 5.06,
+         "p90_in": 13.8
+        }
+       }
+      },
+      "M3": {
+       "pairs": 1951,
+       "match_rate": 0.463,
+       "match_px": {
+        "n": 903,
+        "median": 6.44,
+        "p90": 185.54
+       },
+       "frame_3d": {
+        "n": 903,
+        "points": 903,
+        "median_in": 5.16,
+        "p90_in": 102.72
+       },
+       "frame_along": {
+        "n": 903,
+        "points": 903,
+        "median_in": 1.55,
+        "p90_in": 55.5
+       },
+       "span_along": {
+        "n": 368,
+        "points": 368,
+        "median_in": 9.16,
+        "p90_in": 61.2,
+        "p90_ci95_in": [
+         55.94,
+         69.41
+        ]
+       },
+       "span_3d": {
+        "n": 368,
+        "points": 368,
+        "median_in": 47.15,
+        "p90_in": 157.49,
+        "p90_ci95_in": [
+         132.58,
+         162.28
+        ]
+       },
+       "anchor_matched": 368,
+       "added_after_the_run_frame_3d_where_match_within_2px": {
+        "n": 296,
+        "points": 296,
+        "median_in": 0.57,
+        "p90_in": 1.98
+       },
+       "added_after_the_run_share_of_matches_within_2px": 0.328
+      }
+     },
+     "proud": {
+      "M2": {
+       "span_along": {
+        "n": 367,
+        "points": 367,
+        "median_in": 5.46,
+        "p90_in": 18.1,
+        "p90_ci95_in": [
+         17.13,
+         20.83
+        ]
+       },
+       "span_3d": {
+        "n": 367,
+        "points": 367,
+        "median_in": 11.71,
+        "p90_in": 43.59
+       },
+       "frame_along": {
+        "n": 589,
+        "points": 589,
+        "median_in": 3.95,
+        "p90_in": 24.87
+       },
+       "frame_3d": {
+        "n": 589,
+        "points": 589,
+        "median_in": 7.52,
+        "p90_in": 44.47
+       }
+      },
+      "M2_added_after_the_run": {
+       "span_along_tap_no_snap": {
+        "n": 367,
+        "points": 367,
+        "median_in": 4.91,
+        "p90_in": 17.96
+       },
+       "span_along_true_pixel": {
+        "n": 367,
+        "points": 367,
+        "median_in": 5.41,
+        "p90_in": 17.03
+       },
+       "frame_along_true_pixel": {
+        "n": 589,
+        "points": 589,
+        "median_in": 2.21,
+        "p90_in": 27.38
+       },
+       "edge_point_to_fused_plane": {
+        "n": 589,
+        "points": 589,
+        "median_in": 4.91,
+        "p90_in": 31.59
+       },
+       "span_along_by_median_view_angle": {
+        "0-15": {
+         "n": 13,
+         "points": 13,
+         "median_in": 1.56,
+         "p90_in": 7.34
+        },
+        "15-30": {
+         "n": 98,
+         "points": 98,
+         "median_in": 7.3,
+         "p90_in": 14.5
+        },
+        "30-45": {
+         "n": 179,
+         "points": 179,
+         "median_in": 4.14,
+         "p90_in": 15.66
+        },
+        ">45": {
+         "n": 77,
+         "points": 77,
+         "median_in": 13.7,
+         "p90_in": 103.07
+        }
+       },
+       "span_along_true_pixel_by_median_view_angle": {
+        "0-15": {
+         "n": 13,
+         "points": 13,
+         "median_in": 4.53,
+         "p90_in": 5.42
+        },
+        "15-30": {
+         "n": 98,
+         "points": 98,
+         "median_in": 5.98,
+         "p90_in": 13.97
+        },
+        "30-45": {
+         "n": 179,
+         "points": 179,
+         "median_in": 3.58,
+         "p90_in": 15.8
+        },
+        ">45": {
+         "n": 77,
+         "points": 77,
+         "median_in": 10.15,
+         "p90_in": 122.8
+        }
+       }
+      },
+      "M3": {
+       "pairs": 538,
+       "match_rate": 0.361,
+       "match_px": {
+        "n": 194,
+        "median": 2.77,
+        "p90": 191.71
+       },
+       "frame_3d": {
+        "n": 194,
+        "points": 194,
+        "median_in": 2.16,
+        "p90_in": 97.51
+       },
+       "frame_along": {
+        "n": 194,
+        "points": 194,
+        "median_in": 0.7,
+        "p90_in": 28.16
+       },
+       "span_along": {
+        "n": 71,
+        "points": 71,
+        "median_in": 10.2,
+        "p90_in": 41.75,
+        "p90_ci95_in": [
+         36.09,
+         117.05
+        ]
+       },
+       "span_3d": {
+        "n": 71,
+        "points": 71,
+        "median_in": 37.37,
+        "p90_in": 136.05,
+        "p90_ci95_in": [
+         120.08,
+         158.91
+        ]
+       },
+       "anchor_matched": 71,
+       "added_after_the_run_frame_3d_where_match_within_2px": {
+        "n": 85,
+        "points": 85,
+        "median_in": 0.49,
+        "p90_in": 1.57
+       },
+       "added_after_the_run_share_of_matches_within_2px": 0.438
+      }
+     },
+     "in_plane_vertical": {
+      "M2": {
+       "span_along": {
+        "n": 381,
+        "points": 381,
+        "median_in": 3.25,
+        "p90_in": 15.43,
+        "p90_ci95_in": [
+         13.66,
+         16.83
+        ]
+       },
+       "span_3d": {
+        "n": 381,
+        "points": 381,
+        "median_in": 5.92,
+        "p90_in": 24.14
+       },
+       "frame_along": {
+        "n": 529,
+        "points": 529,
+        "median_in": 2.96,
+        "p90_in": 12.86
+       },
+       "frame_3d": {
+        "n": 529,
+        "points": 529,
+        "median_in": 5.94,
+        "p90_in": 20.94
+       }
+      },
+      "M2_added_after_the_run": {
+       "span_along_tap_no_snap": {
+        "n": 381,
+        "points": 381,
+        "median_in": 2.91,
+        "p90_in": 11.88
+       },
+       "span_along_true_pixel": {
+        "n": 381,
+        "points": 381,
+        "median_in": 2.62,
+        "p90_in": 11.38
+       },
+       "frame_along_true_pixel": {
+        "n": 529,
+        "points": 529,
+        "median_in": 1.61,
+        "p90_in": 10.26
+       },
+       "edge_point_to_fused_plane": {
+        "n": 529,
+        "points": 529,
+        "median_in": 2.63,
+        "p90_in": 13.28
+       },
+       "span_along_by_median_view_angle": {
+        "0-15": {
+         "n": 43,
+         "points": 43,
+         "median_in": 1.47,
+         "p90_in": 3.45
+        },
+        "15-30": {
+         "n": 83,
+         "points": 83,
+         "median_in": 3.25,
+         "p90_in": 8.93
+        },
+        "30-45": {
+         "n": 165,
+         "points": 165,
+         "median_in": 5.12,
+         "p90_in": 13.6
+        },
+        ">45": {
+         "n": 90,
+         "points": 90,
+         "median_in": 4.17,
+         "p90_in": 23.98
+        }
+       },
+       "span_along_true_pixel_by_median_view_angle": {
+        "0-15": {
+         "n": 43,
+         "points": 43,
+         "median_in": 0.6,
+         "p90_in": 2.6
+        },
+        "15-30": {
+         "n": 83,
+         "points": 83,
+         "median_in": 1.99,
+         "p90_in": 6.95
+        },
+        "30-45": {
+         "n": 165,
+         "points": 165,
+         "median_in": 2.7,
+         "p90_in": 12.55
+        },
+        ">45": {
+         "n": 90,
+         "points": 90,
+         "median_in": 5.23,
+         "p90_in": 11.84
+        }
+       }
+      },
+      "M3": {
+       "pairs": 509,
+       "match_rate": 0.505,
+       "match_px": {
+        "n": 257,
+        "median": 24.35,
+        "p90": 200.48
+       },
+       "frame_3d": {
+        "n": 257,
+        "points": 257,
+        "median_in": 20.71,
+        "p90_in": 108.95
+       },
+       "frame_along": {
+        "n": 257,
+        "points": 257,
+        "median_in": 2.11,
+        "p90_in": 72.83
+       },
+       "span_along": {
+        "n": 106,
+        "points": 106,
+        "median_in": 7.05,
+        "p90_in": 64.42,
+        "p90_ci95_in": [
+         48.03,
+         90.2
+        ]
+       },
+       "span_3d": {
+        "n": 106,
+        "points": 106,
+        "median_in": 67.39,
+        "p90_in": 154.53,
+        "p90_ci95_in": [
+         109.0,
+         212.49
+        ]
+       },
+       "anchor_matched": 106,
+       "added_after_the_run_frame_3d_where_match_within_2px": {
+        "n": 67,
+        "points": 67,
+        "median_in": 0.77,
+        "p90_in": 2.34
+       },
+       "added_after_the_run_share_of_matches_within_2px": 0.261
+      }
+     }
+    },
+    "modern_assumed": {
+     "all": {
+      "M2": {
+       "span_along": {
+        "n": 9095,
+        "points": 1819,
+        "median_in": 3.92,
+        "p90_in": 14.33,
+        "p90_ci95_in": [
+         13.42,
+         15.32
+        ]
+       },
+       "span_3d": {
+        "n": 9095,
+        "points": 1819,
+        "median_in": 6.52,
+        "p90_in": 23.25
+       },
+       "frame_along": {
+        "n": 13085,
+        "points": 2617,
+        "median_in": 4.24,
+        "p90_in": 17.4
+       },
+       "frame_3d": {
+        "n": 13085,
+        "points": 2617,
+        "median_in": 6.93,
+        "p90_in": 28.87
+       }
+      },
+      "M2_added_after_the_run": {
+       "span_along_tap_no_snap": {
+        "n": 9090,
+        "points": 1818,
+        "median_in": 2.98,
+        "p90_in": 13.5
+       },
+       "span_along_true_pixel": {
+        "n": 9090,
+        "points": 1818,
+        "median_in": 2.87,
+        "p90_in": 12.74
+       },
+       "frame_along_true_pixel": {
+        "n": 13080,
+        "points": 2616,
+        "median_in": 1.66,
+        "p90_in": 14.48
+       },
+       "edge_point_to_fused_plane": {
+        "n": 13085,
+        "points": 2617,
+        "median_in": 2.79,
+        "p90_in": 13.8
+       },
+       "span_along_by_median_view_angle": {
+        "0-15": {
+         "n": 955,
+         "points": 191,
+         "median_in": 2.57,
+         "p90_in": 6.1
+        },
+        "15-30": {
+         "n": 1715,
+         "points": 343,
+         "median_in": 3.2,
+         "p90_in": 11.31
+        },
+        "30-45": {
+         "n": 4795,
+         "points": 959,
+         "median_in": 4.1,
+         "p90_in": 12.39
+        },
+        ">45": {
+         "n": 1630,
+         "points": 326,
+         "median_in": 6.28,
+         "p90_in": 37.39
+        }
+       },
+       "span_along_true_pixel_by_median_view_angle": {
+        "0-15": {
+         "n": 955,
+         "points": 191,
+         "median_in": 0.46,
+         "p90_in": 5.26
+        },
+        "15-30": {
+         "n": 1715,
+         "points": 343,
+         "median_in": 1.35,
+         "p90_in": 10.79
+        },
+        "30-45": {
+         "n": 4795,
+         "points": 959,
+         "median_in": 2.88,
+         "p90_in": 12.15
+        },
+        ">45": {
+         "n": 1625,
+         "points": 325,
+         "median_in": 6.34,
+         "p90_in": 46.74
+        }
+       }
+      },
+      "M3": {
+       "pairs": 12445,
+       "match_rate": 0.409,
+       "match_px": {
+        "n": 5089,
+        "median": 11.05,
+        "p90": 190.03
+       },
+       "frame_3d": {
+        "n": 5089,
+        "points": 1162,
+        "median_in": 9.93,
+        "p90_in": 102.85
+       },
+       "frame_along": {
+        "n": 5089,
+        "points": 1162,
+        "median_in": 3.47,
+        "p90_in": 54.49
+       },
+       "span_along": {
+        "n": 1663,
+        "points": 453,
+        "median_in": 13.14,
+        "p90_in": 64.34,
+        "p90_ci95_in": [
+         58.63,
+         75.75
+        ]
+       },
+       "span_3d": {
+        "n": 1663,
+        "points": 453,
+        "median_in": 51.37,
+        "p90_in": 158.68,
+        "p90_ci95_in": [
+         146.22,
+         169.18
+        ]
+       },
+       "anchor_matched": 1663,
+       "added_after_the_run_frame_3d_where_match_within_2px": {
+        "n": 789,
+        "points": 371,
+        "median_in": 3.51,
+        "p90_in": 6.76
+       },
+       "added_after_the_run_share_of_matches_within_2px": 0.155
+      }
+     },
+     "in_plane": {
+      "M2": {
+       "span_along": {
+        "n": 7260,
+        "points": 1452,
+        "median_in": 3.63,
+        "p90_in": 12.55,
+        "p90_ci95_in": [
+         11.74,
+         13.77
+        ]
+       },
+       "span_3d": {
+        "n": 7260,
+        "points": 1452,
+        "median_in": 5.87,
+        "p90_in": 21.37
+       },
+       "frame_along": {
+        "n": 10140,
+        "points": 2028,
+        "median_in": 4.32,
+        "p90_in": 16.03
+       },
+       "frame_3d": {
+        "n": 10140,
+        "points": 2028,
+        "median_in": 6.74,
+        "p90_in": 20.76
+       }
+      },
+      "M2_added_after_the_run": {
+       "span_along_tap_no_snap": {
+        "n": 7260,
+        "points": 1452,
+        "median_in": 2.68,
+        "p90_in": 11.52
+       },
+       "span_along_true_pixel": {
+        "n": 7260,
+        "points": 1452,
+        "median_in": 2.47,
+        "p90_in": 11.53
+       },
+       "frame_along_true_pixel": {
+        "n": 10140,
+        "points": 2028,
+        "median_in": 1.7,
+        "p90_in": 12.76
+       },
+       "edge_point_to_fused_plane": {
+        "n": 10140,
+        "points": 2028,
+        "median_in": 2.26,
+        "p90_in": 10.01
+       },
+       "span_along_by_median_view_angle": {
+        "0-15": {
+         "n": 890,
+         "points": 178,
+         "median_in": 2.6,
+         "p90_in": 6.0
+        },
+        "15-30": {
+         "n": 1225,
+         "points": 245,
+         "median_in": 2.72,
+         "p90_in": 6.89
+        },
+        "30-45": {
+         "n": 3900,
+         "points": 780,
+         "median_in": 4.04,
+         "p90_in": 11.78
+        },
+        ">45": {
+         "n": 1245,
+         "points": 249,
+         "median_in": 5.25,
+         "p90_in": 26.92
+        }
+       },
+       "span_along_true_pixel_by_median_view_angle": {
+        "0-15": {
+         "n": 890,
+         "points": 178,
+         "median_in": 0.43,
+         "p90_in": 4.88
+        },
+        "15-30": {
+         "n": 1225,
+         "points": 245,
+         "median_in": 1.17,
+         "p90_in": 3.77
+        },
+        "30-45": {
+         "n": 3900,
+         "points": 780,
+         "median_in": 2.83,
+         "p90_in": 10.95
+        },
+        ">45": {
+         "n": 1245,
+         "points": 249,
+         "median_in": 5.23,
+         "p90_in": 16.1
+        }
+       }
+      },
+      "M3": {
+       "pairs": 9755,
+       "match_rate": 0.426,
+       "match_px": {
+        "n": 4155,
+        "median": 11.91,
+        "p90": 189.43
+       },
+       "frame_3d": {
+        "n": 4155,
+        "points": 945,
+        "median_in": 10.72,
+        "p90_in": 104.22
+       },
+       "frame_along": {
+        "n": 4155,
+        "points": 945,
+        "median_in": 3.7,
+        "p90_in": 60.1
+       },
+       "span_along": {
+        "n": 1392,
+        "points": 381,
+        "median_in": 11.88,
+        "p90_in": 67.45,
+        "p90_ci95_in": [
+         59.33,
+         79.32
+        ]
+       },
+       "span_3d": {
+        "n": 1392,
+        "points": 381,
+        "median_in": 52.94,
+        "p90_in": 163.91,
+        "p90_ci95_in": [
+         144.62,
+         172.97
+        ]
+       },
+       "anchor_matched": 1392,
+       "added_after_the_run_frame_3d_where_match_within_2px": {
+        "n": 561,
+        "points": 276,
+        "median_in": 3.51,
+        "p90_in": 7.34
+       },
+       "added_after_the_run_share_of_matches_within_2px": 0.135
+      }
+     },
+     "proud": {
+      "M2": {
+       "span_along": {
+        "n": 1835,
+        "points": 367,
+        "median_in": 5.98,
+        "p90_in": 18.22,
+        "p90_ci95_in": [
+         16.42,
+         21.24
+        ]
+       },
+       "span_3d": {
+        "n": 1835,
+        "points": 367,
+        "median_in": 12.2,
+        "p90_in": 45.64
+       },
+       "frame_along": {
+        "n": 2945,
+        "points": 589,
+        "median_in": 4.01,
+        "p90_in": 26.32
+       },
+       "frame_3d": {
+        "n": 2945,
+        "points": 589,
+        "median_in": 7.98,
+        "p90_in": 51.54
+       }
+      },
+      "M2_added_after_the_run": {
+       "span_along_tap_no_snap": {
+        "n": 1830,
+        "points": 366,
+        "median_in": 5.53,
+        "p90_in": 18.13
+       },
+       "span_along_true_pixel": {
+        "n": 1830,
+        "points": 366,
+        "median_in": 5.54,
+        "p90_in": 17.16
+       },
+       "frame_along_true_pixel": {
+        "n": 2940,
+        "points": 588,
+        "median_in": 1.6,
+        "p90_in": 28.32
+       },
+       "edge_point_to_fused_plane": {
+        "n": 2945,
+        "points": 589,
+        "median_in": 5.38,
+        "p90_in": 30.69
+       },
+       "span_along_by_median_view_angle": {
+        "0-15": {
+         "n": 65,
+         "points": 13,
+         "median_in": 2.06,
+         "p90_in": 9.88
+        },
+        "15-30": {
+         "n": 490,
+         "points": 98,
+         "median_in": 8.12,
+         "p90_in": 13.94
+        },
+        "30-45": {
+         "n": 895,
+         "points": 179,
+         "median_in": 4.6,
+         "p90_in": 15.9
+        },
+        ">45": {
+         "n": 385,
+         "points": 77,
+         "median_in": 13.6,
+         "p90_in": 63.84
+        }
+       },
+       "span_along_true_pixel_by_median_view_angle": {
+        "0-15": {
+         "n": 65,
+         "points": 13,
+         "median_in": 5.07,
+         "p90_in": 7.76
+        },
+        "15-30": {
+         "n": 490,
+         "points": 98,
+         "median_in": 7.29,
+         "p90_in": 13.36
+        },
+        "30-45": {
+         "n": 895,
+         "points": 179,
+         "median_in": 4.06,
+         "p90_in": 15.56
+        },
+        ">45": {
+         "n": 380,
+         "points": 76,
+         "median_in": 10.0,
+         "p90_in": 73.08
+        }
+       }
+      },
+      "M3": {
+       "pairs": 2690,
+       "match_rate": 0.347,
+       "match_px": {
+        "n": 934,
+        "median": 4.46,
+        "p90": 195.18
+       },
+       "frame_3d": {
+        "n": 934,
+        "points": 217,
+        "median_in": 5.83,
+        "p90_in": 97.29
+       },
+       "frame_along": {
+        "n": 934,
+        "points": 217,
+        "median_in": 2.13,
+        "p90_in": 30.92
+       },
+       "span_along": {
+        "n": 271,
+        "points": 72,
+        "median_in": 15.65,
+        "p90_in": 48.62,
+        "p90_ci95_in": [
+         39.13,
+         74.07
+        ]
+       },
+       "span_3d": {
+        "n": 271,
+        "points": 72,
+        "median_in": 46.4,
+        "p90_in": 152.3,
+        "p90_ci95_in": [
+         122.03,
+         158.71
+        ]
+       },
+       "anchor_matched": 271,
+       "added_after_the_run_frame_3d_where_match_within_2px": {
+        "n": 228,
+        "points": 95,
+        "median_in": 3.48,
+        "p90_in": 5.51
+       },
+       "added_after_the_run_share_of_matches_within_2px": 0.244
+      }
+     },
+     "in_plane_vertical": {
+      "M2": {
+       "span_along": {
+        "n": 1905,
+        "points": 381,
+        "median_in": 3.36,
+        "p90_in": 15.22,
+        "p90_ci95_in": [
+         13.42,
+         16.5
+        ]
+       },
+       "span_3d": {
+        "n": 1905,
+        "points": 381,
+        "median_in": 6.45,
+        "p90_in": 22.94
+       },
+       "frame_along": {
+        "n": 2645,
+        "points": 529,
+        "median_in": 3.63,
+        "p90_in": 15.53
+       },
+       "frame_3d": {
+        "n": 2645,
+        "points": 529,
+        "median_in": 6.65,
+        "p90_in": 22.96
+       }
+      },
+      "M2_added_after_the_run": {
+       "span_along_tap_no_snap": {
+        "n": 1905,
+        "points": 381,
+        "median_in": 3.17,
+        "p90_in": 14.45
+       },
+       "span_along_true_pixel": {
+        "n": 1905,
+        "points": 381,
+        "median_in": 2.97,
+        "p90_in": 12.6
+       },
+       "frame_along_true_pixel": {
+        "n": 2645,
+        "points": 529,
+        "median_in": 2.47,
+        "p90_in": 14.19
+       },
+       "edge_point_to_fused_plane": {
+        "n": 2645,
+        "points": 529,
+        "median_in": 2.58,
+        "p90_in": 13.44
+       },
+       "span_along_by_median_view_angle": {
+        "0-15": {
+         "n": 215,
+         "points": 43,
+         "median_in": 1.55,
+         "p90_in": 3.68
+        },
+        "15-30": {
+         "n": 415,
+         "points": 83,
+         "median_in": 2.97,
+         "p90_in": 9.15
+        },
+        "30-45": {
+         "n": 825,
+         "points": 165,
+         "median_in": 4.59,
+         "p90_in": 13.03
+        },
+        ">45": {
+         "n": 450,
+         "points": 90,
+         "median_in": 5.83,
+         "p90_in": 22.66
+        }
+       },
+       "span_along_true_pixel_by_median_view_angle": {
+        "0-15": {
+         "n": 215,
+         "points": 43,
+         "median_in": 0.99,
+         "p90_in": 2.93
+        },
+        "15-30": {
+         "n": 415,
+         "points": 83,
+         "median_in": 1.79,
+         "p90_in": 6.92
+        },
+        "30-45": {
+         "n": 825,
+         "points": 165,
+         "median_in": 3.01,
+         "p90_in": 13.04
+        },
+        ">45": {
+         "n": 450,
+         "points": 90,
+         "median_in": 7.77,
+         "p90_in": 14.15
+        }
+       }
+      },
+      "M3": {
+       "pairs": 2545,
+       "match_rate": 0.496,
+       "match_px": {
+        "n": 1262,
+        "median": 32.46,
+        "p90": 208.58
+       },
+       "frame_3d": {
+        "n": 1262,
+        "points": 271,
+        "median_in": 21.49,
+        "p90_in": 110.39
+       },
+       "frame_along": {
+        "n": 1262,
+        "points": 271,
+        "median_in": 3.85,
+        "p90_in": 72.17
+       },
+       "span_along": {
+        "n": 474,
+        "points": 115,
+        "median_in": 8.73,
+        "p90_in": 77.67,
+        "p90_ci95_in": [
+         53.34,
+         93.21
+        ]
+       },
+       "span_3d": {
+        "n": 474,
+        "points": 115,
+        "median_in": 62.4,
+        "p90_in": 152.39,
+        "p90_ci95_in": [
+         129.39,
+         211.36
+        ]
+       },
+       "anchor_matched": 474,
+       "added_after_the_run_frame_3d_where_match_within_2px": {
+        "n": 167,
+        "points": 69,
+        "median_in": 3.03,
+        "p90_in": 7.9
+       },
+       "added_after_the_run_share_of_matches_within_2px": 0.132
+      }
+     }
+    },
+    "tap_px": {
+     "tap_abs_du": {
+      "n": 12581,
+      "median": 6.73,
+      "p90": 16.47
+     },
+     "snap_abs_du": {
+      "n": 12581,
+      "median": 11.34,
+      "p90": 27.79
+     },
+     "snap_within_1px": 0.058,
+     "added_after_the_run_snap_from_true_pixel_abs_du": {
+      "n": 12581,
+      "median": 11.66,
+      "p90": 23.29
+     },
+     "added_after_the_run_vertical_in_plane_edges": {
+      "tap_px": {
+       "n": 2511,
+       "median": 6.6,
+       "p90": 16.28
+      },
+      "snap_px": {
+       "n": 2511,
+       "median": 8.85,
+       "p90": 24.59
+      },
+      "snap_from_true_px": {
+       "n": 2511,
+       "median": 8.8,
+       "p90": 21.87
+      }
+     }
+    },
+    "plans": {
+     "points_with_2_photos_in_a_group": 2641,
+     "photos_per_point_median": 5.0,
+     "points_with_a_second_photo": 2489
+    }
+   },
+   "criteria": {
+    "P1": {
+     "m0_along_p90_in_0_15": 1.35,
+     "m0_along_p90_in_over_30": 19.8,
+     "pass": true
+    },
+    "P2": {
+     "m1_along_p90_in_in_plane": 6.65,
+     "pass": false
+    },
+    "P3": {
+     "m2_span_along_p90_in_in_plane_modern": 12.55,
+     "pass": false
+    },
+    "P4": {
+     "m3_span_3d_p90_in_modern": 158.68,
+     "match_rate": 0.409,
+     "pass": false
+    },
+    "kill": {
+     "m0_along_p90_in_per_bin": [
+      1.35,
+      4.59,
+      8.89,
+      24.36
+     ],
+     "triggered": false
+    }
+   }
+  },
+  "facade": {
+   "meta": {
+    "photos": 76,
+    "wall_planes": 2,
+    "edge_points_within_6m": 4734,
+    "edge_points_on_a_wall": 866,
+    "points_sampled": 866,
+    "in_plane": 12,
+    "proud": 854,
+    "vertical_edges": 19,
+    "up_vs_camera_up_deg": 10.52,
+    "wall_tilt_deg_max": 1.05,
+    "oracle_scale_median": 1.0735974441681835,
+    "seconds": 7
+   },
+   "single": {
+    "m0": {
+     "all": {
+      "all angles": {
+       "along": {
+        "n": 1446,
+        "points": 866,
+        "median_in": 13.89,
+        "p90_in": 29.41
+       },
+       "out": {
+        "n": 1446,
+        "points": 866,
+        "median_in": 7.3,
+        "p90_in": 12.66
+       },
+       "3d": {
+        "n": 1446,
+        "points": 866,
+        "median_in": 16.03,
+        "p90_in": 31.68
+       },
+       "missing": 0
+      },
+      "0-15": {
+       "along": {
+        "n": 0,
+        "points": 0
+       },
+       "out": {
+        "n": 0,
+        "points": 0
+       },
+       "3d": {
+        "n": 0,
+        "points": 0
+       },
+       "missing": 0
+      },
+      "15-30": {
+       "along": {
+        "n": 0,
+        "points": 0
+       },
+       "out": {
+        "n": 0,
+        "points": 0
+       },
+       "3d": {
+        "n": 0,
+        "points": 0
+       },
+       "missing": 0
+      },
+      "30-45": {
+       "along": {
+        "n": 19,
+        "points": 19,
+        "median_in": 4.89,
+        "p90_in": 17.16
+       },
+       "out": {
+        "n": 19,
+        "points": 19,
+        "median_in": 5.41,
+        "p90_in": 17.57
+       },
+       "3d": {
+        "n": 19,
+        "points": 19,
+        "median_in": 7.36,
+        "p90_in": 24.58
+       },
+       "missing": 0
+      },
+      ">45": {
+       "along": {
+        "n": 1427,
+        "points": 859,
+        "median_in": 13.97,
+        "p90_in": 29.65
+       },
+       "out": {
+        "n": 1427,
+        "points": 859,
+        "median_in": 7.32,
+        "p90_in": 12.55
+       },
+       "3d": {
+        "n": 1427,
+        "points": 859,
+        "median_in": 16.16,
+        "p90_in": 31.92
+       },
+       "missing": 0
+      }
+     },
+     "in_plane": {
+      "all angles": {
+       "along": {
+        "n": 49,
+        "points": 12,
+        "median_in": 15.03,
+        "p90_in": 31.74
+       },
+       "out": {
+        "n": 49,
+        "points": 12,
+        "median_in": 7.58,
+        "p90_in": 20.86
+       },
+       "3d": {
+        "n": 49,
+        "points": 12,
+        "median_in": 18.21,
+        "p90_in": 36.22
+       },
+       "missing": 0
+      },
+      "0-15": {
+       "along": {
+        "n": 0,
+        "points": 0
+       },
+       "out": {
+        "n": 0,
+        "points": 0
+       },
+       "3d": {
+        "n": 0,
+        "points": 0
+       },
+       "missing": 0
+      },
+      "15-30": {
+       "along": {
+        "n": 0,
+        "points": 0
+       },
+       "out": {
+        "n": 0,
+        "points": 0
+       },
+       "3d": {
+        "n": 0,
+        "points": 0
+       },
+       "missing": 0
+      },
+      "30-45": {
+       "along": {
+        "n": 8,
+        "points": 8,
+        "median_in": 5.23,
+        "p90_in": 18.45
+       },
+       "out": {
+        "n": 8,
+        "points": 8,
+        "median_in": 5.71,
+        "p90_in": 19.29
+       },
+       "3d": {
+        "n": 8,
+        "points": 8,
+        "median_in": 7.82,
+        "p90_in": 26.72
+       },
+       "missing": 0
+      },
+      ">45": {
+       "along": {
+        "n": 41,
+        "points": 11,
+        "median_in": 15.1,
+        "p90_in": 31.94
+       },
+       "out": {
+        "n": 41,
+        "points": 11,
+        "median_in": 7.63,
+        "p90_in": 20.72
+       },
+       "3d": {
+        "n": 41,
+        "points": 11,
+        "median_in": 18.22,
+        "p90_in": 36.89
+       },
+       "missing": 0
+      }
+     },
+     "proud": {
+      "all angles": {
+       "along": {
+        "n": 1397,
+        "points": 854,
+        "median_in": 13.67,
+        "p90_in": 29.35
+       },
+       "out": {
+        "n": 1397,
+        "points": 854,
+        "median_in": 7.2,
+        "p90_in": 12.5
+       },
+       "3d": {
+        "n": 1397,
+        "points": 854,
+        "median_in": 15.89,
+        "p90_in": 31.46
+       },
+       "missing": 0
+      },
+      "0-15": {
+       "along": {
+        "n": 0,
+        "points": 0
+       },
+       "out": {
+        "n": 0,
+        "points": 0
+       },
+       "3d": {
+        "n": 0,
+        "points": 0
+       },
+       "missing": 0
+      },
+      "15-30": {
+       "along": {
+        "n": 0,
+        "points": 0
+       },
+       "out": {
+        "n": 0,
+        "points": 0
+       },
+       "3d": {
+        "n": 0,
+        "points": 0
+       },
+       "missing": 0
+      },
+      "30-45": {
+       "along": {
+        "n": 11,
+        "points": 11,
+        "median_in": 4.66,
+        "p90_in": 5.43
+       },
+       "out": {
+        "n": 11,
+        "points": 11,
+        "median_in": 5.25,
+        "p90_in": 5.92
+       },
+       "3d": {
+        "n": 11,
+        "points": 11,
+        "median_in": 7.08,
+        "p90_in": 8.11
+       },
+       "missing": 0
+      },
+      ">45": {
+       "along": {
+        "n": 1386,
+        "points": 848,
+        "median_in": 13.81,
+        "p90_in": 29.41
+       },
+       "out": {
+        "n": 1386,
+        "points": 848,
+        "median_in": 7.25,
+        "p90_in": 12.5
+       },
+       "3d": {
+        "n": 1386,
+        "points": 848,
+        "median_in": 15.97,
+        "p90_in": 31.52
+       },
+       "missing": 0
+      }
+     }
+    },
+    "m1": {
+     "all": {
+      "all angles": {
+       "along": {
+        "n": 0,
+        "points": 0
+       },
+       "out": {
+        "n": 0,
+        "points": 0
+       },
+       "3d": {
+        "n": 0,
+        "points": 0
+       },
+       "missing": 1446
+      },
+      "0-15": {
+       "along": {
+        "n": 0,
+        "points": 0
+       },
+       "out": {
+        "n": 0,
+        "points": 0
+       },
+       "3d": {
+        "n": 0,
+        "points": 0
+       },
+       "missing": 0
+      },
+      "15-30": {
+       "along": {
+        "n": 0,
+        "points": 0
+       },
+       "out": {
+        "n": 0,
+        "points": 0
+       },
+       "3d": {
+        "n": 0,
+        "points": 0
+       },
+       "missing": 0
+      },
+      "30-45": {
+       "along": {
+        "n": 0,
+        "points": 0
+       },
+       "out": {
+        "n": 0,
+        "points": 0
+       },
+       "3d": {
+        "n": 0,
+        "points": 0
+       },
+       "missing": 19
+      },
+      ">45": {
+       "along": {
+        "n": 0,
+        "points": 0
+       },
+       "out": {
+        "n": 0,
+        "points": 0
+       },
+       "3d": {
+        "n": 0,
+        "points": 0
+       },
+       "missing": 1427
+      }
+     },
+     "in_plane": {
+      "all angles": {
+       "along": {
+        "n": 0,
+        "points": 0
+       },
+       "out": {
+        "n": 0,
+        "points": 0
+       },
+       "3d": {
+        "n": 0,
+        "points": 0
+       },
+       "missing": 49
+      },
+      "0-15": {
+       "along": {
+        "n": 0,
+        "points": 0
+       },
+       "out": {
+        "n": 0,
+        "points": 0
+       },
+       "3d": {
+        "n": 0,
+        "points": 0
+       },
+       "missing": 0
+      },
+      "15-30": {
+       "along": {
+        "n": 0,
+        "points": 0
+       },
+       "out": {
+        "n": 0,
+        "points": 0
+       },
+       "3d": {
+        "n": 0,
+        "points": 0
+       },
+       "missing": 0
+      },
+      "30-45": {
+       "along": {
+        "n": 0,
+        "points": 0
+       },
+       "out": {
+        "n": 0,
+        "points": 0
+       },
+       "3d": {
+        "n": 0,
+        "points": 0
+       },
+       "missing": 8
+      },
+      ">45": {
+       "along": {
+        "n": 0,
+        "points": 0
+       },
+       "out": {
+        "n": 0,
+        "points": 0
+       },
+       "3d": {
+        "n": 0,
+        "points": 0
+       },
+       "missing": 41
+      }
+     },
+     "proud": {
+      "all angles": {
+       "along": {
+        "n": 0,
+        "points": 0
+       },
+       "out": {
+        "n": 0,
+        "points": 0
+       },
+       "3d": {
+        "n": 0,
+        "points": 0
+       },
+       "missing": 1397
+      },
+      "0-15": {
+       "along": {
+        "n": 0,
+        "points": 0
+       },
+       "out": {
+        "n": 0,
+        "points": 0
+       },
+       "3d": {
+        "n": 0,
+        "points": 0
+       },
+       "missing": 0
+      },
+      "15-30": {
+       "along": {
+        "n": 0,
+        "points": 0
+       },
+       "out": {
+        "n": 0,
+        "points": 0
+       },
+       "3d": {
+        "n": 0,
+        "points": 0
+       },
+       "missing": 0
+      },
+      "30-45": {
+       "along": {
+        "n": 0,
+        "points": 0
+       },
+       "out": {
+        "n": 0,
+        "points": 0
+       },
+       "3d": {
+        "n": 0,
+        "points": 0
+       },
+       "missing": 11
+      },
+      ">45": {
+       "along": {
+        "n": 0,
+        "points": 0
+       },
+       "out": {
+        "n": 0,
+        "points": 0
+       },
+       "3d": {
+        "n": 0,
+        "points": 0
+       },
+       "missing": 1386
+      }
+     }
+    },
+    "m1a": {
+     "all": {
+      "all angles": {
+       "along": {
+        "n": 0,
+        "points": 0
+       },
+       "out": {
+        "n": 0,
+        "points": 0
+       },
+       "3d": {
+        "n": 0,
+        "points": 0
+       },
+       "missing": 1446
+      },
+      "0-15": {
+       "along": {
+        "n": 0,
+        "points": 0
+       },
+       "out": {
+        "n": 0,
+        "points": 0
+       },
+       "3d": {
+        "n": 0,
+        "points": 0
+       },
+       "missing": 0
+      },
+      "15-30": {
+       "along": {
+        "n": 0,
+        "points": 0
+       },
+       "out": {
+        "n": 0,
+        "points": 0
+       },
+       "3d": {
+        "n": 0,
+        "points": 0
+       },
+       "missing": 0
+      },
+      "30-45": {
+       "along": {
+        "n": 0,
+        "points": 0
+       },
+       "out": {
+        "n": 0,
+        "points": 0
+       },
+       "3d": {
+        "n": 0,
+        "points": 0
+       },
+       "missing": 19
+      },
+      ">45": {
+       "along": {
+        "n": 0,
+        "points": 0
+       },
+       "out": {
+        "n": 0,
+        "points": 0
+       },
+       "3d": {
+        "n": 0,
+        "points": 0
+       },
+       "missing": 1427
+      }
+     },
+     "in_plane": {
+      "all angles": {
+       "along": {
+        "n": 0,
+        "points": 0
+       },
+       "out": {
+        "n": 0,
+        "points": 0
+       },
+       "3d": {
+        "n": 0,
+        "points": 0
+       },
+       "missing": 49
+      },
+      "0-15": {
+       "along": {
+        "n": 0,
+        "points": 0
+       },
+       "out": {
+        "n": 0,
+        "points": 0
+       },
+       "3d": {
+        "n": 0,
+        "points": 0
+       },
+       "missing": 0
+      },
+      "15-30": {
+       "along": {
+        "n": 0,
+        "points": 0
+       },
+       "out": {
+        "n": 0,
+        "points": 0
+       },
+       "3d": {
+        "n": 0,
+        "points": 0
+       },
+       "missing": 0
+      },
+      "30-45": {
+       "along": {
+        "n": 0,
+        "points": 0
+       },
+       "out": {
+        "n": 0,
+        "points": 0
+       },
+       "3d": {
+        "n": 0,
+        "points": 0
+       },
+       "missing": 8
+      },
+      ">45": {
+       "along": {
+        "n": 0,
+        "points": 0
+       },
+       "out": {
+        "n": 0,
+        "points": 0
+       },
+       "3d": {
+        "n": 0,
+        "points": 0
+       },
+       "missing": 41
+      }
+     },
+     "proud": {
+      "all angles": {
+       "along": {
+        "n": 0,
+        "points": 0
+       },
+       "out": {
+        "n": 0,
+        "points": 0
+       },
+       "3d": {
+        "n": 0,
+        "points": 0
+       },
+       "missing": 1397
+      },
+      "0-15": {
+       "along": {
+        "n": 0,
+        "points": 0
+       },
+       "out": {
+        "n": 0,
+        "points": 0
+       },
+       "3d": {
+        "n": 0,
+        "points": 0
+       },
+       "missing": 0
+      },
+      "15-30": {
+       "along": {
+        "n": 0,
+        "points": 0
+       },
+       "out": {
+        "n": 0,
+        "points": 0
+       },
+       "3d": {
+        "n": 0,
+        "points": 0
+       },
+       "missing": 0
+      },
+      "30-45": {
+       "along": {
+        "n": 0,
+        "points": 0
+       },
+       "out": {
+        "n": 0,
+        "points": 0
+       },
+       "3d": {
+        "n": 0,
+        "points": 0
+       },
+       "missing": 11
+      },
+      ">45": {
+       "along": {
+        "n": 0,
+        "points": 0
+       },
+       "out": {
+        "n": 0,
+        "points": 0
+       },
+       "3d": {
+        "n": 0,
+        "points": 0
+       },
+       "missing": 1386
+      }
+     }
+    },
+    "m1a_yaw": {
+     "observations": 0
+    }
+   },
+   "multi": {
+    "exact": {
+     "all": {
+      "M2": {
+       "span_along": {
+        "n": 0,
+        "points": 0,
+        "p90_ci95_in": null
+       },
+       "span_3d": {
+        "n": 0,
+        "points": 0
+       },
+       "frame_along": {
+        "n": 0,
+        "points": 0
+       },
+       "frame_3d": {
+        "n": 0,
+        "points": 0
+       }
+      },
+      "M2_added_after_the_run": {
+       "span_along_tap_no_snap": {
+        "n": 0,
+        "points": 0
+       },
+       "span_along_true_pixel": {
+        "n": 0,
+        "points": 0
+       },
+       "frame_along_true_pixel": {
+        "n": 0,
+        "points": 0
+       },
+       "edge_point_to_fused_plane": {
+        "n": 0,
+        "points": 0
+       },
+       "span_along_by_median_view_angle": {
+        "0-15": {
+         "n": 0,
+         "points": 0
+        },
+        "15-30": {
+         "n": 0,
+         "points": 0
+        },
+        "30-45": {
+         "n": 0,
+         "points": 0
+        },
+        ">45": {
+         "n": 0,
+         "points": 0
+        }
+       },
+       "span_along_true_pixel_by_median_view_angle": {
+        "0-15": {
+         "n": 0,
+         "points": 0
+        },
+        "15-30": {
+         "n": 0,
+         "points": 0
+        },
+        "30-45": {
+         "n": 0,
+         "points": 0
+        },
+        ">45": {
+         "n": 0,
+         "points": 0
+        }
+       }
+      },
+      "M3": {
+       "pairs": 603,
+       "match_rate": 0.138,
+       "match_px": {
+        "n": 83,
+        "median": 1.42,
+        "p90": 28.68
+       },
+       "frame_3d": {
+        "n": 83,
+        "points": 83,
+        "median_in": 1.43,
+        "p90_in": 29.45
+       },
+       "frame_along": {
+        "n": 83,
+        "points": 83,
+        "median_in": 1.2,
+        "p90_in": 22.06
+       },
+       "span_along": {
+        "n": 0,
+        "points": 0,
+        "p90_ci95_in": null
+       },
+       "span_3d": {
+        "n": 0,
+        "points": 0,
+        "p90_ci95_in": null
+       },
+       "anchor_matched": 0,
+       "added_after_the_run_frame_3d_where_match_within_2px": {
+        "n": 51,
+        "points": 51,
+        "median_in": 0.78,
+        "p90_in": 1.76
+       },
+       "added_after_the_run_share_of_matches_within_2px": 0.614
+      }
+     },
+     "in_plane": {
+      "M2": {
+       "span_along": {
+        "n": 0,
+        "points": 0,
+        "p90_ci95_in": null
+       },
+       "span_3d": {
+        "n": 0,
+        "points": 0
+       },
+       "frame_along": {
+        "n": 0,
+        "points": 0
+       },
+       "frame_3d": {
+        "n": 0,
+        "points": 0
+       }
+      },
+      "M2_added_after_the_run": {
+       "span_along_tap_no_snap": {
+        "n": 0,
+        "points": 0
+       },
+       "span_along_true_pixel": {
+        "n": 0,
+        "points": 0
+       },
+       "frame_along_true_pixel": {
+        "n": 0,
+        "points": 0
+       },
+       "edge_point_to_fused_plane": {
+        "n": 0,
+        "points": 0
+       },
+       "span_along_by_median_view_angle": {
+        "0-15": {
+         "n": 0,
+         "points": 0
+        },
+        "15-30": {
+         "n": 0,
+         "points": 0
+        },
+        "30-45": {
+         "n": 0,
+         "points": 0
+        },
+        ">45": {
+         "n": 0,
+         "points": 0
+        }
+       },
+       "span_along_true_pixel_by_median_view_angle": {
+        "0-15": {
+         "n": 0,
+         "points": 0
+        },
+        "15-30": {
+         "n": 0,
+         "points": 0
+        },
+        "30-45": {
+         "n": 0,
+         "points": 0
+        },
+        ">45": {
+         "n": 0,
+         "points": 0
+        }
+       }
+      },
+      "M3": {
+       "pairs": 12,
+       "match_rate": 0.0,
+       "match_px": {
+        "n": 0
+       },
+       "frame_3d": {
+        "n": 0,
+        "points": 0
+       },
+       "frame_along": {
+        "n": 0,
+        "points": 0
+       },
+       "span_along": {
+        "n": 0,
+        "points": 0,
+        "p90_ci95_in": null
+       },
+       "span_3d": {
+        "n": 0,
+        "points": 0,
+        "p90_ci95_in": null
+       },
+       "anchor_matched": 0,
+       "added_after_the_run_frame_3d_where_match_within_2px": {
+        "n": 0,
+        "points": 0
+       },
+       "added_after_the_run_share_of_matches_within_2px": NaN
+      }
+     },
+     "proud": {
+      "M2": {
+       "span_along": {
+        "n": 0,
+        "points": 0,
+        "p90_ci95_in": null
+       },
+       "span_3d": {
+        "n": 0,
+        "points": 0
+       },
+       "frame_along": {
+        "n": 0,
+        "points": 0
+       },
+       "frame_3d": {
+        "n": 0,
+        "points": 0
+       }
+      },
+      "M2_added_after_the_run": {
+       "span_along_tap_no_snap": {
+        "n": 0,
+        "points": 0
+       },
+       "span_along_true_pixel": {
+        "n": 0,
+        "points": 0
+       },
+       "frame_along_true_pixel": {
+        "n": 0,
+        "points": 0
+       },
+       "edge_point_to_fused_plane": {
+        "n": 0,
+        "points": 0
+       },
+       "span_along_by_median_view_angle": {
+        "0-15": {
+         "n": 0,
+         "points": 0
+        },
+        "15-30": {
+         "n": 0,
+         "points": 0
+        },
+        "30-45": {
+         "n": 0,
+         "points": 0
+        },
+        ">45": {
+         "n": 0,
+         "points": 0
+        }
+       },
+       "span_along_true_pixel_by_median_view_angle": {
+        "0-15": {
+         "n": 0,
+         "points": 0
+        },
+        "15-30": {
+         "n": 0,
+         "points": 0
+        },
+        "30-45": {
+         "n": 0,
+         "points": 0
+        },
+        ">45": {
+         "n": 0,
+         "points": 0
+        }
+       }
+      },
+      "M3": {
+       "pairs": 591,
+       "match_rate": 0.14,
+       "match_px": {
+        "n": 83,
+        "median": 1.42,
+        "p90": 28.68
+       },
+       "frame_3d": {
+        "n": 83,
+        "points": 83,
+        "median_in": 1.43,
+        "p90_in": 29.45
+       },
+       "frame_along": {
+        "n": 83,
+        "points": 83,
+        "median_in": 1.2,
+        "p90_in": 22.06
+       },
+       "span_along": {
+        "n": 0,
+        "points": 0,
+        "p90_ci95_in": null
+       },
+       "span_3d": {
+        "n": 0,
+        "points": 0,
+        "p90_ci95_in": null
+       },
+       "anchor_matched": 0,
+       "added_after_the_run_frame_3d_where_match_within_2px": {
+        "n": 51,
+        "points": 51,
+        "median_in": 0.78,
+        "p90_in": 1.76
+       },
+       "added_after_the_run_share_of_matches_within_2px": 0.614
+      }
+     },
+     "in_plane_vertical": {
+      "M2": {
+       "span_along": {
+        "n": 0,
+        "points": 0,
+        "p90_ci95_in": null
+       },
+       "span_3d": {
+        "n": 0,
+        "points": 0
+       },
+       "frame_along": {
+        "n": 0,
+        "points": 0
+       },
+       "frame_3d": {
+        "n": 0,
+        "points": 0
+       }
+      },
+      "M2_added_after_the_run": {
+       "span_along_tap_no_snap": {
+        "n": 0,
+        "points": 0
+       },
+       "span_along_true_pixel": {
+        "n": 0,
+        "points": 0
+       },
+       "frame_along_true_pixel": {
+        "n": 0,
+        "points": 0
+       },
+       "edge_point_to_fused_plane": {
+        "n": 0,
+        "points": 0
+       },
+       "span_along_by_median_view_angle": {
+        "0-15": {
+         "n": 0,
+         "points": 0
+        },
+        "15-30": {
+         "n": 0,
+         "points": 0
+        },
+        "30-45": {
+         "n": 0,
+         "points": 0
+        },
+        ">45": {
+         "n": 0,
+         "points": 0
+        }
+       },
+       "span_along_true_pixel_by_median_view_angle": {
+        "0-15": {
+         "n": 0,
+         "points": 0
+        },
+        "15-30": {
+         "n": 0,
+         "points": 0
+        },
+        "30-45": {
+         "n": 0,
+         "points": 0
+        },
+        ">45": {
+         "n": 0,
+         "points": 0
+        }
+       }
+      },
+      "M3": {
+       "pairs": 0,
+       "match_rate": 0.0,
+       "match_px": {
+        "n": 0
+       },
+       "frame_3d": {
+        "n": 0,
+        "points": 0
+       },
+       "frame_along": {
+        "n": 0,
+        "points": 0
+       },
+       "span_along": {
+        "n": 0,
+        "points": 0,
+        "p90_ci95_in": null
+       },
+       "span_3d": {
+        "n": 0,
+        "points": 0,
+        "p90_ci95_in": null
+       },
+       "anchor_matched": 0,
+       "added_after_the_run_frame_3d_where_match_within_2px": {
+        "n": 0,
+        "points": 0
+       },
+       "added_after_the_run_share_of_matches_within_2px": NaN
+      }
+     }
+    },
+    "modern_assumed": {
+     "all": {
+      "M2": {
+       "span_along": {
+        "n": 0,
+        "points": 0,
+        "p90_ci95_in": null
+       },
+       "span_3d": {
+        "n": 0,
+        "points": 0
+       },
+       "frame_along": {
+        "n": 0,
+        "points": 0
+       },
+       "frame_3d": {
+        "n": 0,
+        "points": 0
+       }
+      },
+      "M2_added_after_the_run": {
+       "span_along_tap_no_snap": {
+        "n": 0,
+        "points": 0
+       },
+       "span_along_true_pixel": {
+        "n": 0,
+        "points": 0
+       },
+       "frame_along_true_pixel": {
+        "n": 0,
+        "points": 0
+       },
+       "edge_point_to_fused_plane": {
+        "n": 0,
+        "points": 0
+       },
+       "span_along_by_median_view_angle": {
+        "0-15": {
+         "n": 0,
+         "points": 0
+        },
+        "15-30": {
+         "n": 0,
+         "points": 0
+        },
+        "30-45": {
+         "n": 0,
+         "points": 0
+        },
+        ">45": {
+         "n": 0,
+         "points": 0
+        }
+       },
+       "span_along_true_pixel_by_median_view_angle": {
+        "0-15": {
+         "n": 0,
+         "points": 0
+        },
+        "15-30": {
+         "n": 0,
+         "points": 0
+        },
+        "30-45": {
+         "n": 0,
+         "points": 0
+        },
+        ">45": {
+         "n": 0,
+         "points": 0
+        }
+       }
+      },
+      "M3": {
+       "pairs": 3015,
+       "match_rate": 0.102,
+       "match_px": {
+        "n": 308,
+        "median": 5.12,
+        "p90": 35.04
+       },
+       "frame_3d": {
+        "n": 308,
+        "points": 105,
+        "median_in": 6.22,
+        "p90_in": 33.48
+       },
+       "frame_along": {
+        "n": 308,
+        "points": 105,
+        "median_in": 4.91,
+        "p90_in": 25.57
+       },
+       "span_along": {
+        "n": 0,
+        "points": 0,
+        "p90_ci95_in": null
+       },
+       "span_3d": {
+        "n": 0,
+        "points": 0,
+        "p90_ci95_in": null
+       },
+       "anchor_matched": 0,
+       "added_after_the_run_frame_3d_where_match_within_2px": {
+        "n": 62,
+        "points": 42,
+        "median_in": 3.71,
+        "p90_in": 11.14
+       },
+       "added_after_the_run_share_of_matches_within_2px": 0.201
+      }
+     },
+     "in_plane": {
+      "M2": {
+       "span_along": {
+        "n": 0,
+        "points": 0,
+        "p90_ci95_in": null
+       },
+       "span_3d": {
+        "n": 0,
+        "points": 0
+       },
+       "frame_along": {
+        "n": 0,
+        "points": 0
+       },
+       "frame_3d": {
+        "n": 0,
+        "points": 0
+       }
+      },
+      "M2_added_after_the_run": {
+       "span_along_tap_no_snap": {
+        "n": 0,
+        "points": 0
+       },
+       "span_along_true_pixel": {
+        "n": 0,
+        "points": 0
+       },
+       "frame_along_true_pixel": {
+        "n": 0,
+        "points": 0
+       },
+       "edge_point_to_fused_plane": {
+        "n": 0,
+        "points": 0
+       },
+       "span_along_by_median_view_angle": {
+        "0-15": {
+         "n": 0,
+         "points": 0
+        },
+        "15-30": {
+         "n": 0,
+         "points": 0
+        },
+        "30-45": {
+         "n": 0,
+         "points": 0
+        },
+        ">45": {
+         "n": 0,
+         "points": 0
+        }
+       },
+       "span_along_true_pixel_by_median_view_angle": {
+        "0-15": {
+         "n": 0,
+         "points": 0
+        },
+        "15-30": {
+         "n": 0,
+         "points": 0
+        },
+        "30-45": {
+         "n": 0,
+         "points": 0
+        },
+        ">45": {
+         "n": 0,
+         "points": 0
+        }
+       }
+      },
+      "M3": {
+       "pairs": 60,
+       "match_rate": 0.0,
+       "match_px": {
+        "n": 0
+       },
+       "frame_3d": {
+        "n": 0,
+        "points": 0
+       },
+       "frame_along": {
+        "n": 0,
+        "points": 0
+       },
+       "span_along": {
+        "n": 0,
+        "points": 0,
+        "p90_ci95_in": null
+       },
+       "span_3d": {
+        "n": 0,
+        "points": 0,
+        "p90_ci95_in": null
+       },
+       "anchor_matched": 0,
+       "added_after_the_run_frame_3d_where_match_within_2px": {
+        "n": 0,
+        "points": 0
+       },
+       "added_after_the_run_share_of_matches_within_2px": NaN
+      }
+     },
+     "proud": {
+      "M2": {
+       "span_along": {
+        "n": 0,
+        "points": 0,
+        "p90_ci95_in": null
+       },
+       "span_3d": {
+        "n": 0,
+        "points": 0
+       },
+       "frame_along": {
+        "n": 0,
+        "points": 0
+       },
+       "frame_3d": {
+        "n": 0,
+        "points": 0
+       }
+      },
+      "M2_added_after_the_run": {
+       "span_along_tap_no_snap": {
+        "n": 0,
+        "points": 0
+       },
+       "span_along_true_pixel": {
+        "n": 0,
+        "points": 0
+       },
+       "frame_along_true_pixel": {
+        "n": 0,
+        "points": 0
+       },
+       "edge_point_to_fused_plane": {
+        "n": 0,
+        "points": 0
+       },
+       "span_along_by_median_view_angle": {
+        "0-15": {
+         "n": 0,
+         "points": 0
+        },
+        "15-30": {
+         "n": 0,
+         "points": 0
+        },
+        "30-45": {
+         "n": 0,
+         "points": 0
+        },
+        ">45": {
+         "n": 0,
+         "points": 0
+        }
+       },
+       "span_along_true_pixel_by_median_view_angle": {
+        "0-15": {
+         "n": 0,
+         "points": 0
+        },
+        "15-30": {
+         "n": 0,
+         "points": 0
+        },
+        "30-45": {
+         "n": 0,
+         "points": 0
+        },
+        ">45": {
+         "n": 0,
+         "points": 0
+        }
+       }
+      },
+      "M3": {
+       "pairs": 2955,
+       "match_rate": 0.104,
+       "match_px": {
+        "n": 308,
+        "median": 5.12,
+        "p90": 35.04
+       },
+       "frame_3d": {
+        "n": 308,
+        "points": 105,
+        "median_in": 6.22,
+        "p90_in": 33.48
+       },
+       "frame_along": {
+        "n": 308,
+        "points": 105,
+        "median_in": 4.91,
+        "p90_in": 25.57
+       },
+       "span_along": {
+        "n": 0,
+        "points": 0,
+        "p90_ci95_in": null
+       },
+       "span_3d": {
+        "n": 0,
+        "points": 0,
+        "p90_ci95_in": null
+       },
+       "anchor_matched": 0,
+       "added_after_the_run_frame_3d_where_match_within_2px": {
+        "n": 62,
+        "points": 42,
+        "median_in": 3.71,
+        "p90_in": 11.14
+       },
+       "added_after_the_run_share_of_matches_within_2px": 0.201
+      }
+     },
+     "in_plane_vertical": {
+      "M2": {
+       "span_along": {
+        "n": 0,
+        "points": 0,
+        "p90_ci95_in": null
+       },
+       "span_3d": {
+        "n": 0,
+        "points": 0
+       },
+       "frame_along": {
+        "n": 0,
+        "points": 0
+       },
+       "frame_3d": {
+        "n": 0,
+        "points": 0
+       }
+      },
+      "M2_added_after_the_run": {
+       "span_along_tap_no_snap": {
+        "n": 0,
+        "points": 0
+       },
+       "span_along_true_pixel": {
+        "n": 0,
+        "points": 0
+       },
+       "frame_along_true_pixel": {
+        "n": 0,
+        "points": 0
+       },
+       "edge_point_to_fused_plane": {
+        "n": 0,
+        "points": 0
+       },
+       "span_along_by_median_view_angle": {
+        "0-15": {
+         "n": 0,
+         "points": 0
+        },
+        "15-30": {
+         "n": 0,
+         "points": 0
+        },
+        "30-45": {
+         "n": 0,
+         "points": 0
+        },
+        ">45": {
+         "n": 0,
+         "points": 0
+        }
+       },
+       "span_along_true_pixel_by_median_view_angle": {
+        "0-15": {
+         "n": 0,
+         "points": 0
+        },
+        "15-30": {
+         "n": 0,
+         "points": 0
+        },
+        "30-45": {
+         "n": 0,
+         "points": 0
+        },
+        ">45": {
+         "n": 0,
+         "points": 0
+        }
+       }
+      },
+      "M3": {
+       "pairs": 0,
+       "match_rate": 0.0,
+       "match_px": {
+        "n": 0
+       },
+       "frame_3d": {
+        "n": 0,
+        "points": 0
+       },
+       "frame_along": {
+        "n": 0,
+        "points": 0
+       },
+       "span_along": {
+        "n": 0,
+        "points": 0,
+        "p90_ci95_in": null
+       },
+       "span_3d": {
+        "n": 0,
+        "points": 0,
+        "p90_ci95_in": null
+       },
+       "anchor_matched": 0,
+       "added_after_the_run_frame_3d_where_match_within_2px": {
+        "n": 0,
+        "points": 0
+       },
+       "added_after_the_run_share_of_matches_within_2px": NaN
+      }
+     }
+    },
+    "tap_px": {
+     "tap_abs_du": {
+      "n": 3030,
+      "median": 6.75,
+      "p90": 16.18
+     },
+     "snap_abs_du": {
+      "n": 3030,
+      "median": 12.78,
+      "p90": 28.05
+     },
+     "snap_within_1px": 0.037,
+     "added_after_the_run_snap_from_true_pixel_abs_du": {
+      "n": 3030,
+      "median": 13.12,
+      "p90": 23.39
+     },
+     "added_after_the_run_vertical_in_plane_edges": {
+      "tap_px": {
+       "n": 0
+      },
+      "snap_px": {
+       "n": 0
+      },
+      "snap_from_true_px": {
+       "n": 0
+      }
+     }
+    },
+    "plans": {
+     "points_with_2_photos_in_a_group": 606,
+     "photos_per_point_median": 5.0,
+     "points_with_a_second_photo": 603
+    }
+   },
+   "criteria": {
+    "P1": {
+     "m0_along_p90_in_0_15": NaN,
+     "m0_along_p90_in_over_30": 29.41,
+     "pass": false
+    },
+    "P2": {
+     "m1_along_p90_in_in_plane": NaN,
+     "pass": false
+    },
+    "P3": {
+     "m2_span_along_p90_in_in_plane_modern": NaN,
+     "pass": false
+    },
+    "P4": {
+     "m3_span_3d_p90_in_modern": NaN,
+     "match_rate": 0.102,
+     "pass": false
+    },
+    "kill": {
+     "m0_along_p90_in_per_bin": [
+      NaN,
+      NaN,
+      17.16,
+      29.65
+     ],
+     "triggered": false
+    }
+   }
+  }
+ }
+}
diff --git a/experiments/edge-geometry/results/edge_geometry_widest_pair.md b/experiments/edge-geometry/results/edge_geometry_widest_pair.md
new file mode 100644
index 000000000..3ad019172
--- /dev/null
+++ b/experiments/edge-geometry/results/edge_geometry_widest_pair.md
@@ -0,0 +1,231 @@
+# Edge geometry (generated by `uv run python run.py`)
+
+Evals harness commit `190ed339f41924ae0244e0b88c5ebe647ddd9eb4`. Errors in inches, median / p90 (points). M3 pairs each point's reference photo with the widest qualifying ray angle.
+
+## electro
+
+`{"photos": 45, "wall_planes": 21, "edge_points_within_6m": 27436, "edge_points_on_a_wall": 25492, "points_sampled": 3000, "in_plane": 2258, "proud": 742, "vertical_edges": 730, "up_vs_camera_up_deg": 5.21, "wall_tilt_deg_max": 3.14, "oracle_scale_median": 0.9961415148011799, "seconds": 53}`
+
+### M0, depth at the pixel
+
+| Edges | View angle | Along the wall | Out of plane | 3-D |
+| --- | --- | --- | --- | --- |
+| all | all angles | 2.1 / 15.6 (2994) | 3.1 / 19.2 (2994) | 5.7 / 38.6 (2994) |
+| all | 0-15 | 0.2 / 1.4 (345) | 4.8 / 14.8 (345) | 4.9 / 14.9 (345) |
+| all | 15-30 | 0.7 / 4.6 (912) | 3.8 / 15.3 (912) | 4.2 / 17.0 (912) |
+| all | 30-45 | 2.0 / 8.9 (1430) | 4.2 / 20.4 (1430) | 5.2 / 24.9 (1430) |
+| all | >45 | 5.1 / 24.4 (1593) | 1.7 / 23.7 (1593) | 7.5 / 66.2 (1593) |
+| in_plane | all angles | 2.0 / 14.6 (2258) | 2.8 / 16.2 (2258) | 5.3 / 31.7 (2258) |
+| in_plane | 0-15 | 0.2 / 0.9 (281) | 4.8 / 14.6 (281) | 4.9 / 14.8 (281) |
+| in_plane | 15-30 | 0.7 / 4.5 (708) | 3.4 / 16.9 (708) | 3.6 / 18.2 (708) |
+| in_plane | 30-45 | 1.9 / 7.8 (1077) | 3.9 / 15.9 (1077) | 4.9 / 19.9 (1077) |
+| in_plane | >45 | 4.8 / 24.1 (1211) | 1.5 / 17.7 (1211) | 6.6 / 62.1 (1211) |
+| proud | all angles | 2.5 / 18.0 (736) | 4.2 / 25.0 (736) | 7.3 / 57.3 (736) |
+| proud | 0-15 | 0.3 / 2.7 (64) | 4.8 / 16.2 (64) | 4.9 / 16.4 (64) |
+| proud | 15-30 | 0.9 / 4.8 (204) | 4.2 / 12.7 (204) | 4.6 / 14.1 (204) |
+| proud | 30-45 | 2.4 / 12.1 (353) | 5.4 / 24.8 (353) | 6.9 / 30.2 (353) |
+| proud | >45 | 6.8 / 27.1 (382) | 3.1 / 48.1 (382) | 19.9 / 116.2 (382) |
+
+### M1, ray to this photo's wall plane
+
+| Edges | View angle | Along the wall | Out of plane | 3-D |
+| --- | --- | --- | --- | --- |
+| all | all angles | 1.3 / 7.2 (2712) | 3.1 / 10.5 (2712) | 4.2 / 15.1 (2712) |
+| all | 0-15 | 0.2 / 0.6 (342) | 4.2 / 11.4 (342) | 4.2 / 11.6 (342) |
+| all | 15-30 | 0.5 / 2.8 (898) | 2.9 / 10.3 (898) | 3.2 / 11.1 (898) |
+| all | 30-45 | 1.6 / 6.3 (1376) | 3.3 / 8.9 (1376) | 4.2 / 11.3 (1376) |
+| all | >45 | 3.5 / 21.7 (1219) | 2.6 / 16.3 (1219) | 5.3 / 45.0 (1219) |
+| in_plane | all angles | 1.1 / 6.7 (2097) | 2.7 / 9.2 (2097) | 3.8 / 12.0 (2097) |
+| in_plane | 0-15 | 0.1 / 0.5 (278) | 4.2 / 11.5 (278) | 4.3 / 11.7 (278) |
+| in_plane | 15-30 | 0.4 / 2.3 (699) | 2.4 / 9.8 (699) | 2.7 / 10.7 (699) |
+| in_plane | 30-45 | 1.5 / 5.8 (1044) | 3.0 / 7.6 (1044) | 3.7 / 10.1 (1044) |
+| in_plane | >45 | 2.9 / 15.0 (998) | 1.9 / 8.9 (998) | 4.5 / 36.2 (998) |
+| proud | all angles | 2.0 / 14.5 (615) | 5.0 / 19.0 (615) | 6.3 / 27.5 (615) |
+| proud | 0-15 | 0.3 / 1.1 (64) | 3.8 / 7.2 (64) | 3.9 / 7.3 (64) |
+| proud | 15-30 | 1.0 / 3.5 (199) | 4.6 / 11.8 (199) | 5.0 / 12.8 (199) |
+| proud | 30-45 | 2.2 / 8.7 (332) | 4.5 / 15.9 (332) | 5.8 / 20.7 (332) |
+| proud | >45 | 12.1 / 31.9 (221) | 9.6 / 29.5 (221) | 19.2 / 77.7 (221) |
+
+### M1-anchor, ray to a 0.3 m patch plane 1-3 m away
+
+| Edges | View angle | Along the wall | Out of plane | 3-D |
+| --- | --- | --- | --- | --- |
+| all | all angles | 2.0 / 12.2 (1707) | 3.8 / 17.9 (1707) | 5.1 / 27.2 (1707) |
+| all | 0-15 | 0.1 / 0.6 (199) | 3.7 / 12.7 (199) | 3.8 / 12.8 (199) |
+| all | 15-30 | 1.1 / 5.5 (592) | 3.9 / 14.0 (592) | 4.3 / 15.7 (592) |
+| all | 30-45 | 2.2 / 10.5 (924) | 4.3 / 19.7 (924) | 5.4 / 26.7 (924) |
+| all | >45 | 5.1 / 27.1 (633) | 3.0 / 18.8 (633) | 6.6 / 36.8 (633) |
+| in_plane | all angles | 1.9 / 10.4 (1360) | 3.4 / 13.6 (1360) | 4.7 / 21.0 (1360) |
+| in_plane | 0-15 | 0.1 / 0.5 (181) | 3.5 / 11.8 (181) | 3.5 / 12.0 (181) |
+| in_plane | 15-30 | 1.0 / 5.8 (478) | 3.5 / 13.7 (478) | 3.9 / 15.3 (478) |
+| in_plane | 30-45 | 2.2 / 8.6 (727) | 4.1 / 16.1 (727) | 5.0 / 19.5 (727) |
+| in_plane | >45 | 4.5 / 27.7 (526) | 2.8 / 12.2 (526) | 5.7 / 36.5 (526) |
+| proud | all angles | 2.5 / 15.6 (347) | 6.3 / 42.4 (347) | 8.0 / 64.1 (347) |
+| proud | 0-15 | 2.1 / 154.1 (18) | 12.7 / 3149.7 (18) | 13.0 / 3164.1 (18) |
+| proud | 15-30 | 1.7 / 5.1 (114) | 7.1 / 14.6 (114) | 7.8 / 16.4 (114) |
+| proud | 30-45 | 2.0 / 15.7 (197) | 4.7 / 63.5 (197) | 5.8 / 79.7 (197) |
+| proud | >45 | 9.5 / 17.9 (107) | 7.4 / 41.0 (107) | 14.5 / 63.9 (107) |
+
+### M1-anchor yaw
+
+`{"observations": 3411, "abs_psi_deg": {"median": 2.15, "p90": 6.72}, "abs_s_m_median": 2.0, "all_added_after_the_run": {"sign_agreement_where_prediction_over_1cm": 0.7, "median_error_over_prediction_where_over_1cm": 0.73, "view_angle_under_60": {"n": 3080, "slope": 0.36, "r2": 0.01}, "spearman_abs_error_vs_tan_angle_alone": 0.5}, "all": {"n": 3411, "signed_first_order_slope": 0.05, "signed_first_order_r2": 0.02, "signed_r2_with_slope_1": -4.58, "abs_error_over_s_psi_tan_median": 0.94, "abs_error_over_s_psi_tan_n": 2811, "spearman_abs_error_vs_s_psi_tan": 0.63, "abs_error_p90_in": 12.18, "residual_after_first_order_p90_in": 10.9}, "in_plane_added_after_the_run": {"sign_agreement_where_prediction_over_1cm": 0.74, "median_error_over_prediction_where_over_1cm": 0.83, "view_angle_under_60": {"n": 2455, "slope": 0.29, "r2": 0.02}, "spearman_abs_error_vs_tan_angle_alone": 0.54}, "in_plane": {"n": 2755, "signed_first_order_slope": 0.05, "signed_first_order_r2": 0.02, "signed_r2_with_slope_1": -12.61, "abs_error_over_s_psi_tan_median": 0.94, "abs_error_over_s_psi_tan_n": 2231, "spearman_abs_error_vs_s_psi_tan": 0.67, "abs_error_p90_in": 10.43, "residual_after_first_order_p90_in": 9.41}}`
+
+### M2 and M3
+
+| Poses | Edges | M2 span along | M2 p90 95% CI | M3 pairs | M3 match | M3 match px | M3 span along | M3 span 3-D | M3 3-D p90 95% CI | M3 frame 3-D |
+| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
+| exact | all | 4.0 / 14.5 (1819) | [13.85, 15.72] | 2489 | 44% | 6.05 / 186.45 | 9.3 / 59.5 (439) | 43.9 / 156.3 (439) | [134.29, 161.35] | 4.9 / 101.8 (1097) |
+| exact | in_plane | 3.7 / 13.0 (1452) | [12.06, 14.18] | 1951 | 46% | 6.44 / 185.54 | 9.2 / 61.2 (368) | 47.1 / 157.5 (368) | [132.58, 162.28] | 5.2 / 102.7 (903) |
+| exact | proud | 5.5 / 18.1 (367) | [17.13, 20.83] | 538 | 36% | 2.77 / 191.71 | 10.2 / 41.8 (71) | 37.4 / 136.1 (71) | [120.08, 158.91] | 2.2 / 97.5 (194) |
+| exact | in_plane_vertical | 3.2 / 15.4 (381) | [13.66, 16.83] | 509 | 50% | 24.35 / 200.48 | 7.0 / 64.4 (106) | 67.4 / 154.5 (106) | [109.0, 212.49] | 20.7 / 109.0 (257) |
+| modern_assumed | all | 3.9 / 14.3 (1819) | [13.42, 15.32] | 12445 | 41% | 11.05 / 190.03 | 13.1 / 64.3 (453) | 51.4 / 158.7 (453) | [146.22, 169.18] | 9.9 / 102.8 (1162) |
+| modern_assumed | in_plane | 3.6 / 12.6 (1452) | [11.74, 13.77] | 9755 | 43% | 11.91 / 189.43 | 11.9 / 67.5 (381) | 52.9 / 163.9 (381) | [144.62, 172.97] | 10.7 / 104.2 (945) |
+| modern_assumed | proud | 6.0 / 18.2 (367) | [16.42, 21.24] | 2690 | 35% | 4.46 / 195.18 | 15.7 / 48.6 (72) | 46.4 / 152.3 (72) | [122.03, 158.71] | 5.8 / 97.3 (217) |
+| modern_assumed | in_plane_vertical | 3.4 / 15.2 (381) | [13.42, 16.5] | 2545 | 50% | 32.46 / 208.58 | 8.7 / 77.7 (115) | 62.4 / 152.4 (115) | [129.39, 211.36] | 21.5 / 110.4 (271) |
+
+M3 match px is in pixels, not inches.
+
+### Added after the run
+
+| Poses | Edges | M2 with the true pixel | M2 tap, no snap | Edge point to fused MoGe-2 plane | M3 3-D where the match is within 2 px | Matches within 2 px |
+| --- | --- | --- | --- | --- | --- | --- |
+| exact | all | 2.5 / 12.6 (1819) | 2.8 / 13.0 (1819) | 2.7 / 13.9 (2617) | 0.6 / 1.8 (381) | 0.347 |
+| exact | in_plane | 2.1 / 10.9 (1452) | 2.5 / 10.9 (1452) | 2.3 / 10.0 (2028) | 0.6 / 2.0 (296) | 0.328 |
+| exact | proud | 5.4 / 17.0 (367) | 4.9 / 18.0 (367) | 4.9 / 31.6 (589) | 0.5 / 1.6 (85) | 0.438 |
+| exact | in_plane_vertical | 2.6 / 11.4 (381) | 2.9 / 11.9 (381) | 2.6 / 13.3 (529) | 0.8 / 2.3 (67) | 0.261 |
+| modern_assumed | all | 2.9 / 12.7 (1818) | 3.0 / 13.5 (1818) | 2.8 / 13.8 (2617) | 3.5 / 6.8 (371) | 0.155 |
+| modern_assumed | in_plane | 2.5 / 11.5 (1452) | 2.7 / 11.5 (1452) | 2.3 / 10.0 (2028) | 3.5 / 7.3 (276) | 0.135 |
+| modern_assumed | proud | 5.5 / 17.2 (366) | 5.5 / 18.1 (366) | 5.4 / 30.7 (589) | 3.5 / 5.5 (95) | 0.244 |
+| modern_assumed | in_plane_vertical | 3.0 / 12.6 (381) | 3.2 / 14.4 (381) | 2.6 / 13.4 (529) | 3.0 / 7.9 (69) | 0.132 |
+
+M2 along-wall span error by the point's median view angle (snap, then true pixel):
+
+- exact, in-plane, snapped: 0-15 2.3 / 5.6 (178), 15-30 2.7 / 6.8 (245), 30-45 4.2 / 11.6 (780), >45 6.1 / 29.1 (249)
+- exact, in-plane, true pixel: 0-15 0.1 / 4.3 (178), 15-30 1.1 / 3.6 (245), 30-45 2.5 / 10.5 (780), >45 5.1 / 13.8 (249)
+- modern_assumed, in-plane, snapped: 0-15 2.6 / 6.0 (178), 15-30 2.7 / 6.9 (245), 30-45 4.0 / 11.8 (780), >45 5.2 / 26.9 (249)
+- modern_assumed, in-plane, true pixel: 0-15 0.4 / 4.9 (178), 15-30 1.2 / 3.8 (245), 30-45 2.8 / 10.9 (780), >45 5.2 / 16.1 (249)
+
+Edge point to plane (single photo): `{"laser_plane_in_plane_edges": {"n": 6076, "points": 2258, "median_in": 0.4, "p90_in": 1.38}, "m1_plane_in_plane_edges": {"n": 4920, "points": 2097, "median_in": 2.54, "p90_in": 9.81}}`
+
+
+Tap and snap, horizontal pixel error: `{"tap_abs_du": {"n": 12581, "median": 6.73, "p90": 16.47}, "snap_abs_du": {"n": 12581, "median": 11.34, "p90": 27.79}, "snap_within_1px": 0.058, "added_after_the_run_snap_from_true_pixel_abs_du": {"n": 12581, "median": 11.66, "p90": 23.29}, "added_after_the_run_vertical_in_plane_edges": {"tap_px": {"n": 2511, "median": 6.6, "p90": 16.28}, "snap_px": {"n": 2511, "median": 8.85, "p90": 24.59}, "snap_from_true_px": {"n": 2511, "median": 8.8, "p90": 21.87}}}`
+
+`{"points_with_2_photos_in_a_group": 2641, "photos_per_point_median": 5.0, "points_with_a_second_photo": 2489}`
+
+### Criteria
+
+`{"P1": {"m0_along_p90_in_0_15": 1.35, "m0_along_p90_in_over_30": 19.8, "pass": true}, "P2": {"m1_along_p90_in_in_plane": 6.65, "pass": false}, "P3": {"m2_span_along_p90_in_in_plane_modern": 12.55, "pass": false}, "P4": {"m3_span_3d_p90_in_modern": 158.68, "match_rate": 0.409, "pass": false}, "kill": {"m0_along_p90_in_per_bin": [1.35, 4.59, 8.89, 24.36], "triggered": false}}`
+
+## facade
+
+`{"photos": 76, "wall_planes": 2, "edge_points_within_6m": 4734, "edge_points_on_a_wall": 866, "points_sampled": 866, "in_plane": 12, "proud": 854, "vertical_edges": 19, "up_vs_camera_up_deg": 10.52, "wall_tilt_deg_max": 1.05, "oracle_scale_median": 1.0735974441681835, "seconds": 7}`
+
+### M0, depth at the pixel
+
+| Edges | View angle | Along the wall | Out of plane | 3-D |
+| --- | --- | --- | --- | --- |
+| all | all angles | 13.9 / 29.4 (866) | 7.3 / 12.7 (866) | 16.0 / 31.7 (866) |
+| all | 0-15 | n/a | n/a | n/a |
+| all | 15-30 | n/a | n/a | n/a |
+| all | 30-45 | 4.9 / 17.2 (19) | 5.4 / 17.6 (19) | 7.4 / 24.6 (19) |
+| all | >45 | 14.0 / 29.6 (859) | 7.3 / 12.6 (859) | 16.2 / 31.9 (859) |
+| in_plane | all angles | 15.0 / 31.7 (12) | 7.6 / 20.9 (12) | 18.2 / 36.2 (12) |
+| in_plane | 0-15 | n/a | n/a | n/a |
+| in_plane | 15-30 | n/a | n/a | n/a |
+| in_plane | 30-45 | 5.2 / 18.4 (8) | 5.7 / 19.3 (8) | 7.8 / 26.7 (8) |
+| in_plane | >45 | 15.1 / 31.9 (11) | 7.6 / 20.7 (11) | 18.2 / 36.9 (11) |
+| proud | all angles | 13.7 / 29.4 (854) | 7.2 / 12.5 (854) | 15.9 / 31.5 (854) |
+| proud | 0-15 | n/a | n/a | n/a |
+| proud | 15-30 | n/a | n/a | n/a |
+| proud | 30-45 | 4.7 / 5.4 (11) | 5.2 / 5.9 (11) | 7.1 / 8.1 (11) |
+| proud | >45 | 13.8 / 29.4 (848) | 7.2 / 12.5 (848) | 16.0 / 31.5 (848) |
+
+### M1, ray to this photo's wall plane
+
+| Edges | View angle | Along the wall | Out of plane | 3-D |
+| --- | --- | --- | --- | --- |
+| all | all angles | n/a | n/a | n/a |
+| all | 0-15 | n/a | n/a | n/a |
+| all | 15-30 | n/a | n/a | n/a |
+| all | 30-45 | n/a | n/a | n/a |
+| all | >45 | n/a | n/a | n/a |
+| in_plane | all angles | n/a | n/a | n/a |
+| in_plane | 0-15 | n/a | n/a | n/a |
+| in_plane | 15-30 | n/a | n/a | n/a |
+| in_plane | 30-45 | n/a | n/a | n/a |
+| in_plane | >45 | n/a | n/a | n/a |
+| proud | all angles | n/a | n/a | n/a |
+| proud | 0-15 | n/a | n/a | n/a |
+| proud | 15-30 | n/a | n/a | n/a |
+| proud | 30-45 | n/a | n/a | n/a |
+| proud | >45 | n/a | n/a | n/a |
+
+### M1-anchor, ray to a 0.3 m patch plane 1-3 m away
+
+| Edges | View angle | Along the wall | Out of plane | 3-D |
+| --- | --- | --- | --- | --- |
+| all | all angles | n/a | n/a | n/a |
+| all | 0-15 | n/a | n/a | n/a |
+| all | 15-30 | n/a | n/a | n/a |
+| all | 30-45 | n/a | n/a | n/a |
+| all | >45 | n/a | n/a | n/a |
+| in_plane | all angles | n/a | n/a | n/a |
+| in_plane | 0-15 | n/a | n/a | n/a |
+| in_plane | 15-30 | n/a | n/a | n/a |
+| in_plane | 30-45 | n/a | n/a | n/a |
+| in_plane | >45 | n/a | n/a | n/a |
+| proud | all angles | n/a | n/a | n/a |
+| proud | 0-15 | n/a | n/a | n/a |
+| proud | 15-30 | n/a | n/a | n/a |
+| proud | 30-45 | n/a | n/a | n/a |
+| proud | >45 | n/a | n/a | n/a |
+
+### M1-anchor yaw
+
+`{"observations": 0}`
+
+### M2 and M3
+
+| Poses | Edges | M2 span along | M2 p90 95% CI | M3 pairs | M3 match | M3 match px | M3 span along | M3 span 3-D | M3 3-D p90 95% CI | M3 frame 3-D |
+| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
+| exact | all | n/a | None | 603 | 14% | 1.42 / 28.68 | n/a | n/a | None | 1.4 / 29.4 (83) |
+| exact | in_plane | n/a | None | 12 | 0% | n/a / n/a | n/a | n/a | None | n/a |
+| exact | proud | n/a | None | 591 | 14% | 1.42 / 28.68 | n/a | n/a | None | 1.4 / 29.4 (83) |
+| exact | in_plane_vertical | n/a | None | 0 | 0% | n/a / n/a | n/a | n/a | None | n/a |
+| modern_assumed | all | n/a | None | 3015 | 10% | 5.12 / 35.04 | n/a | n/a | None | 6.2 / 33.5 (105) |
+| modern_assumed | in_plane | n/a | None | 60 | 0% | n/a / n/a | n/a | n/a | None | n/a |
+| modern_assumed | proud | n/a | None | 2955 | 10% | 5.12 / 35.04 | n/a | n/a | None | 6.2 / 33.5 (105) |
+| modern_assumed | in_plane_vertical | n/a | None | 0 | 0% | n/a / n/a | n/a | n/a | None | n/a |
+
+M3 match px is in pixels, not inches.
+
+### Added after the run
+
+| Poses | Edges | M2 with the true pixel | M2 tap, no snap | Edge point to fused MoGe-2 plane | M3 3-D where the match is within 2 px | Matches within 2 px |
+| --- | --- | --- | --- | --- | --- | --- |
+| exact | all | n/a | n/a | n/a | 0.8 / 1.8 (51) | 0.614 |
+| exact | in_plane | n/a | n/a | n/a | n/a | nan |
+| exact | proud | n/a | n/a | n/a | 0.8 / 1.8 (51) | 0.614 |
+| exact | in_plane_vertical | n/a | n/a | n/a | n/a | nan |
+| modern_assumed | all | n/a | n/a | n/a | 3.7 / 11.1 (42) | 0.201 |
+| modern_assumed | in_plane | n/a | n/a | n/a | n/a | nan |
+| modern_assumed | proud | n/a | n/a | n/a | 3.7 / 11.1 (42) | 0.201 |
+| modern_assumed | in_plane_vertical | n/a | n/a | n/a | n/a | nan |
+
+M2 along-wall span error by the point's median view angle (snap, then true pixel):
+
+- exact, in-plane, snapped: 0-15 n/a, 15-30 n/a, 30-45 n/a, >45 n/a
+- exact, in-plane, true pixel: 0-15 n/a, 15-30 n/a, 30-45 n/a, >45 n/a
+- modern_assumed, in-plane, snapped: 0-15 n/a, 15-30 n/a, 30-45 n/a, >45 n/a
+- modern_assumed, in-plane, true pixel: 0-15 n/a, 15-30 n/a, 30-45 n/a, >45 n/a
+
+Edge point to plane (single photo): `null`
+
+
+Tap and snap, horizontal pixel error: `{"tap_abs_du": {"n": 3030, "median": 6.75, "p90": 16.18}, "snap_abs_du": {"n": 3030, "median": 12.78, "p90": 28.05}, "snap_within_1px": 0.037, "added_after_the_run_snap_from_true_pixel_abs_du": {"n": 3030, "median": 13.12, "p90": 23.39}, "added_after_the_run_vertical_in_plane_edges": {"tap_px": {"n": 0}, "snap_px": {"n": 0}, "snap_from_true_px": {"n": 0}}}`
+
+`{"points_with_2_photos_in_a_group": 606, "photos_per_point_median": 5.0, "points_with_a_second_photo": 603}`
+
+### Criteria
+
+`{"P1": {"m0_along_p90_in_0_15": NaN, "m0_along_p90_in_over_30": 29.41, "pass": false}, "P2": {"m1_along_p90_in_in_plane": NaN, "pass": false}, "P3": {"m2_span_along_p90_in_in_plane_modern": NaN, "pass": false}, "P4": {"m3_span_3d_p90_in_modern": NaN, "match_rate": 0.102, "pass": false}, "kill": {"m0_along_p90_in_per_bin": [NaN, NaN, 17.16, 29.65], "triggered": false}}`

From 1b89e2927ba5b83eb340ce3b6973717bbb0ab528 Mon Sep 17 00:00:00 2001
From: Sam Gu <127461594+SamGu-NRX@users.noreply.github.com>
Date: Tue, 13 Oct 2026 19:30:36 -0500
Subject: [PATCH 34/62] verification: treat an answer cut short of its
 Content-Length as no answer

post() reads the body in chunks with response.read(amt), and http.client
returns b"" when the server closes early even if Content-Length promised
more, so a truncated answer passed as complete. This came in with the
bounded-read change in this branch; alpha's single read() raised
IncompleteRead. post() now checks the length http.client still expected
and reports the answer as incomplete. A test server closes after 10 of 100
promised bytes, and partway through a chunked body, on 200 and 500.

https://github.com/SamGu-NRX/BaseScanning/pull/242

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 verification/hsverify/e2e.py   |  8 ++++++-
 verification/tests/test_e2e.py | 43 ++++++++++++++++++++++++++++++++++
 2 files changed, 50 insertions(+), 1 deletion(-)

diff --git a/verification/hsverify/e2e.py b/verification/hsverify/e2e.py
index be34d296b..f9071fff2 100644
--- a/verification/hsverify/e2e.py
+++ b/verification/hsverify/e2e.py
@@ -371,7 +371,8 @@ def post(
     """Send one scene and read the whole answer within `timeout_s`, headers and body together.
 
     Status None means no complete answer, and the payload then says why: the deadline passed,
-    the body ran past MAX_RESPONSE_BYTES, or the connection failed. A socket timeout alone bounds
+    the body ran past MAX_RESPONSE_BYTES, it ended short of its Content-Length or chunk framing,
+    or the connection failed. A socket timeout alone bounds
     each read, not the response, so a server trickling bytes would never trip it; a timer shuts
     the socket down at the deadline instead, which wakes any read in progress."""
     if item.bundle is not None and endpoint.accepts_zip:
@@ -421,6 +422,11 @@ def expire() -> None:
         response = conn.getresponse()
         while len(payload) <= MAX_RESPONSE_BYTES and (chunk := response.read(READ_CHUNK_BYTES)):
             payload += chunk
+        # read(amt) returns b"" when the server closes early, even short of Content-Length
+        # (http.client stays quiet there for compatibility), and `length` keeps what never came.
+        # A body cut short is not an answer, whatever its status says.
+        if len(payload) <= MAX_RESPONSE_BYTES and response.length:
+            raise http.client.IncompleteRead(bytes(payload), response.length)
         status = response.status
     except TimeoutError:
         # One socket operation waited the whole timeout_s, so the deadline has passed too.
diff --git a/verification/tests/test_e2e.py b/verification/tests/test_e2e.py
index 3d6f25575..cb66a5b68 100644
--- a/verification/tests/test_e2e.py
+++ b/verification/tests/test_e2e.py
@@ -423,6 +423,49 @@ def test_a_trickled_answer_stops_at_the_overall_deadline(unending_url, monkeypat
     assert 500 <= ms < 2500
 
 
+class ShortServer(BaseHTTPRequestHandler):
+    """Answers `status`, then closes before the body is done: 10 of a promised 100 bytes
+    (`length`), or partway through a chunked body (`chunked`)."""
+
+    status = 200
+    mode = "length"
+
+    def do_POST(self):
+        self.rfile.read(int(self.headers["Content-Length"]))
+        self.protocol_version = "HTTP/1.1"
+        self.send_response(self.status)
+        self.send_header("Content-Type", "application/json")
+        if self.mode == "length":
+            self.send_header("Content-Length", "100")
+            self.end_headers()
+            self.wfile.write(b'{"outcome"')
+        else:
+            self.send_header("Transfer-Encoding", "chunked")
+            self.end_headers()
+            self.wfile.write(b'a\r\n{"outcome"\r\n14\r\n: "pa')
+        self.wfile.flush()
+        self.close_connection = True
+
+    def log_message(self, *args):
+        pass
+
+
+@pytest.mark.parametrize("status", [200, 500])
+@pytest.mark.parametrize("mode", ["length", "chunked"])
+def test_an_answer_cut_short_is_no_answer(monkeypatch, status, mode):
+    monkeypatch.setattr(ShortServer, "status", status)
+    monkeypatch.setattr(ShortServer, "mode", mode)
+    server = ThreadingHTTPServer(("127.0.0.1", 0), ShortServer)
+    threading.Thread(target=server.serve_forever, daemon=True).start()
+    try:
+        url = f"http://127.0.0.1:{server.server_port}"
+        got, payload, _ = e2e.post(url, Endpoint("/p", "application/json"), item(), 5)
+    finally:
+        server.shutdown()
+        server.server_close()
+    assert got is None and payload.startswith(b"IncompleteRead")
+
+
 def test_hostile_inputs_are_small_to_send():
     items = hostile_inputs()
     assert all(i.hostile for i in items)

From cac5fa0212cd6bc161415008b12a665d47e3e229 Mon Sep 17 00:00:00 2001
From: Sam Gu <127461594+SamGu-NRX@users.noreply.github.com>
Date: Tue, 13 Oct 2026 19:47:21 -0500
Subject: [PATCH 35/62] experiments(meter-closeup): keep a browser correction
 when its number changes

The previous commit dropped every saved answer whose shown number no longer
matched, so a correction typed before the upgrade, or before a dataset
update, vanished from the page and the export. A Fix carries the reviewer's
own number and now stays whatever the page showed; only a Keep, which
confirms the number shown, is dropped when that number changes or was
never recorded. New test covers a pre-upgrade Fix and a Fix after a label
change.

https://github.com/SamGu-NRX/BaseScanning/pull/242

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 experiments/meter-closeup/METHODS.md          |  2 +-
 .../meter-closeup/src/meter_eval/review.py    | 13 +++++-----
 .../meter-closeup/tests/test_review_keep.py   | 25 +++++++++++++++++--
 3 files changed, 31 insertions(+), 9 deletions(-)

diff --git a/experiments/meter-closeup/METHODS.md b/experiments/meter-closeup/METHODS.md
index 22c203395..93dea94f5 100644
--- a/experiments/meter-closeup/METHODS.md
+++ b/experiments/meter-closeup/METHODS.md
@@ -17,7 +17,7 @@ Two AI models, not people, read every photo, so every number is only as good as
 - **Loose** (73 photos, used for the headline): reader 1's number equals any number reader 2 listed, or one contains the other and the shorter has at least 6 characters, and neither reader doubted a character.
 - **Strict** (62 photos): both readers' main numbers are identical and both were sure. Reading and ranking results are reported under both rules.
 
-To confirm the labels by hand, run `make review` and open `~/house-scanning-data/meter-closeup/review.html`. Each photo shows whole, beside the agreed number. Press K to keep the number, or F to type a correction. Then run `uv run python -m meter_eval.review ingest <downloaded csv>` and rebuild with `uv run python -m meter_eval.labels`. A kept number counts as agreed under both rules; a corrected one does not until someone keeps it. A verdict saved in the browser stays only while the page shows the number it was given for, so after a label correction that photo opens again. Ingest merges new answers into earlier ones, and a rebuilt page shows each earlier correction in place of the readers' number, so Keep confirms the correction even in a new browser.
+To confirm the labels by hand, run `make review` and open `~/house-scanning-data/meter-closeup/review.html`. Each photo shows whole, beside the agreed number. Press K to keep the number, or F to type a correction. Then run `uv run python -m meter_eval.review ingest <downloaded csv>` and rebuild with `uv run python -m meter_eval.labels`. A kept number counts as agreed under both rules; a corrected one does not until someone keeps it. A Keep saved in the browser stays only while the page shows the number it was given for, so after a label correction that photo opens again; a correction typed there stays. Ingest merges new answers into earlier ones, and a rebuilt page shows each earlier correction in place of the readers' number, so Keep confirms the correction even in a new browser.
 
 ## Keeping meter numbers out of the repository
 
diff --git a/experiments/meter-closeup/src/meter_eval/review.py b/experiments/meter-closeup/src/meter_eval/review.py
index 7c318f55a..3e29c7aa8 100644
--- a/experiments/meter-closeup/src/meter_eval/review.py
+++ b/experiments/meter-closeup/src/meter_eval/review.py
@@ -222,16 +222,17 @@ def ingest(path: str) -> None:
 <script type="application/json" id="items">__ITEMS__</script>
 <script>
 const items = JSON.parse(document.getElementById("items").textContent);
-// Answers already ingested ship with the page, so a new browser starts from them. An answer
-// saved in this browser since then takes precedence only while the page still shows the number
-// it was given for: after a label correction or dataset update the photo is open again, so a
-// stale Keep is neither shown as done nor exported. Answers saved before `shown` was recorded
-// cannot be checked and are dropped the same way.
+// Answers already ingested ship with the page, so a new browser starts from them; answers saved
+// in this browser since then take precedence. A Fix carries the reviewer's own number, so it
+// stands whatever the page showed. A Keep confirms the number shown, so it stands only while
+// the page still shows that number: after a label correction or dataset update the photo is
+// open again, and a stale Keep is neither shown as done nor exported. A Keep saved before
+// `shown` was recorded cannot be checked and is dropped the same way.
 function startingAnswers(items, stored) {
   const answers = {};
   for (const item of items) {
     const mine = stored[item.id];
-    if (mine && mine.shown === item.number) answers[item.id] = mine;
+    if (mine && (mine.verdict === "fix" || mine.shown === item.number)) answers[item.id] = mine;
     else if (item.answer) answers[item.id] = item.answer;
   }
   return answers;
diff --git a/experiments/meter-closeup/tests/test_review_keep.py b/experiments/meter-closeup/tests/test_review_keep.py
index 319f9fb05..dd71a28e2 100644
--- a/experiments/meter-closeup/tests/test_review_keep.py
+++ b/experiments/meter-closeup/tests/test_review_keep.py
@@ -56,6 +56,7 @@ def test_a_browser_keep_given_for_a_number_the_page_no_longer_shows_is_dropped()
         },
         {"id": "m02", "number": "2222222", "corrected": False, "answer": None},
         {"id": "m03", "number": "3333333", "corrected": False, "answer": None},
+        {"id": "m04", "number": "4444444", "corrected": False, "answer": None},
     ]
     stored = {
         # Kept while the page showed the readers' 1111111, before the correction was ingested.
@@ -64,7 +65,7 @@ def test_a_browser_keep_given_for_a_number_the_page_no_longer_shows_is_dropped()
         "m02": {"verdict": "keep", "number": "", "shown": "2220000"},
         # Kept for the number still shown.
         "m03": {"verdict": "keep", "number": "", "shown": "3333333"},
-        # Saved before answers recorded what they were given for.
+        # A Keep saved before answers recorded what they were given for.
         "m04": {"verdict": "keep", "number": ""},
     }
     saved = on_page("startingAnswers(items, stored)", items=items, stored=stored)
@@ -73,7 +74,27 @@ def test_a_browser_keep_given_for_a_number_the_page_no_longer_shows_is_dropped()
         "m03": {"verdict": "keep", "number": "", "shown": "3333333"},
     }
     rows = on_page("answerRows(items, startingAnswers(items, stored))", items=items, stored=stored)
-    assert rows[1:] == [["m01", "fix", "7654321"], ["m02", "", ""], ["m03", "keep", ""]]
+    assert rows[1:] == [
+        ["m01", "fix", "7654321"],
+        ["m02", "", ""],
+        ["m03", "keep", ""],
+        ["m04", "", ""],
+    ]
+
+
+def test_a_browser_correction_survives_a_label_change_and_the_upgrade():
+    items = [
+        {"id": "m01", "number": "1111111", "corrected": False, "answer": None},
+        {"id": "m02", "number": "2222222", "corrected": False, "answer": None},
+    ]
+    stored = {
+        # Saved by the page before `shown` existed and never ingested: the reviewer's own number.
+        "m01": {"verdict": "fix", "number": "ABC 7654321"},
+        # Typed while the page showed another number, which a dataset update has since changed.
+        "m02": {"verdict": "fix", "number": "2223333", "shown": "2220000"},
+    }
+    rows = on_page("answerRows(items, startingAnswers(items, stored))", items=items, stored=stored)
+    assert rows[1:] == [["m01", "fix", "ABC 7654321"], ["m02", "fix", "2223333"]]
 
 
 def write(path, rows):

From e4cc5518853586f34a730b19572c64978344d299 Mon Sep 17 00:00:00 2001
From: Sam Gu <127461594+SamGu-NRX@users.noreply.github.com>
Date: Tue, 13 Oct 2026 19:47:21 -0500
Subject: [PATCH 36/62] verification: a new pass past the original sweep's ends
 is unsupported

outcomes_near read a start past the original's last run from that run
alone, so a response that added a pass run beyond an original pass run
satisfied both ordering checks. Nothing brackets such a start: the sweep
stops where no battery fits or where the route fails the maximum length
whatever else is true (reach_limit, which more error only widens). FAIL is
now the only outcome consistent with the original there, so a pass is
flagged and a fail or unsure is not.

https://github.com/SamGu-NRX/BaseScanning/pull/242

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 verification/hsverify/resultcheck.py   | 16 +++++++++++-----
 verification/tests/test_resultcheck.py | 16 +++++++++++++++-
 2 files changed, 26 insertions(+), 6 deletions(-)

diff --git a/verification/hsverify/resultcheck.py b/verification/hsverify/resultcheck.py
index 1071d8bb2..8555b54fa 100644
--- a/verification/hsverify/resultcheck.py
+++ b/verification/hsverify/resultcheck.py
@@ -1305,8 +1305,11 @@ def outcomes_near(result: dict, wall_id: str, start_ft: float) -> tuple[set[str]
     scene's new boundary can land on, gets its neighbouring runs' outcomes on that wall: the
     server evaluates every start where some check can change its outcome, plus the midpoints
     between those (server/solver.py module docstring, t3/server 1d1e7e1), so between two
-    evaluated starts the outcome is the outcome at one of them. Past the last run on one side
-    only the nearest run is left; on a wall with no run there is nothing to compare with."""
+    evaluated starts the outcome is the outcome at one of them. Past the original's first or
+    last run on a wall nothing brackets the start: the sweep stops where no battery fits on the
+    wall or where its route fails the maximum length whatever else is true (solver.reach_limit,
+    which more error only widens), so FAIL is the only outcome consistent with the original
+    there. On a wall with no run there is nothing to compare with."""
     if (inside := outcome_at(result, wall_id, start_ft)) is not None:
         return {inside}, inside
     runs = [run for run in result.get("sweep", []) if run["wall_id"] == wall_id]
@@ -1320,10 +1323,13 @@ def outcomes_near(result: dict, wall_id: str, start_ft: float) -> tuple[set[str]
         key=lambda r: r["start_ft"][0],
         default=None,
     )
-    near = [r["outcome"] for r in (left, right) if r is not None]
-    if not near:
+    if left is None and right is None:
         return set(), "no run on its wall"
-    return set(near), f"unswept beside {' and '.join(near)}"
+    if left is None or right is None:
+        return {"fail"}, "past the original sweep"
+    return {left["outcome"], right["outcome"]}, (
+        f"unswept beside {left['outcome']} and {right['outcome']}"
+    )
 
 
 def more_error_problems(before: dict, after: dict, change: str) -> list[str]:
diff --git a/verification/tests/test_resultcheck.py b/verification/tests/test_resultcheck.py
index fb32e40ee..de6eef0df 100644
--- a/verification/tests/test_resultcheck.py
+++ b/verification/tests/test_resultcheck.py
@@ -650,10 +650,24 @@ def test_less_coverage_cannot_pass_where_the_original_swept_nothing():
     past_end = swept(run(0.0, 4.0, "pass"), run(4.1, 6.0, "fail"), decision="pass")
     longer = swept(run(0.0, 4.0, "pass"), run(4.1, 6.0, "fail"), run(6.1, 6.1, "pass"))
     assert less_coverage_problems(past_end, longer, "x") == [
-        "x: start w1 6.100 went from unswept beside fail to pass"
+        "x: start w1 6.100 went from past the original sweep to pass"
     ]
 
 
+def test_a_new_pass_past_the_original_sweep_is_not_read_from_its_last_run():
+    """The original ends on a pass run; nothing it evaluated brackets 4.1 to 6.0."""
+    before = swept(run(0.0, 4.0, "pass"), decision="pass")
+    after = swept(run(0.0, 4.0, "pass"), run(4.1, 6.0, "pass"), decision="pass")
+    expected = [
+        f"x: start w1 {s:.3f} went from past the original sweep to pass" for s in (4.1, 5.05, 6.0)
+    ]
+    assert less_coverage_problems(before, after, "x") == expected
+    assert more_error_problems(before, after, "x") == expected
+    # More error widens the reach limit, so a longer sweep may fail or turn unsure out there.
+    wider = swept(run(0.0, 4.0, "unsure"), run(4.1, 5.0, "fail"), run(5.1, 6.0, "unsure"))
+    assert more_error_problems(before, wider, "x") == []
+
+
 def test_more_error_reads_an_unswept_start_from_its_neighbours():
     moved = swept(run(0.0, 2.04, "fail"), run(2.05, 5.0, "pass"))
     assert more_error_problems(split(), moved, "x") == []

From d51c645fcf0668bec143755d75c785226904c36a Mon Sep 17 00:00:00 2001
From: Sam Gu <127461594+SamGu-NRX@users.noreply.github.com>
Date: Tue, 13 Oct 2026 19:47:21 -0500
Subject: [PATCH 37/62] verification: each gap request needs its own upload
 before the result

unanswered accepted an upload anywhere later in the run, so a run that
showed a result before uploading the requested views, or answered two
requests with one upload, passed `make sim-app`. A request's round now
ends at the next request or at the last state of a --require-order
sequence (the result), and its upload must come inside that round. The
recorded runs at a39d0a5, f14947e and c820cf1 still pass.

https://github.com/SamGu-NRX/BaseScanning/pull/242

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 verification/hsverify/simrun.py         | 40 ++++++++++++++++++-------
 verification/tests/test_sim_app_flow.py | 22 ++++++++++++--
 2 files changed, 49 insertions(+), 13 deletions(-)

diff --git a/verification/hsverify/simrun.py b/verification/hsverify/simrun.py
index 56924aef8..f0bc827a1 100644
--- a/verification/hsverify/simrun.py
+++ b/verification/hsverify/simrun.py
@@ -10,7 +10,8 @@
 state. The run ends at `--until`, after `--idle` seconds without a new state, or at
 `--timeout`. A state named with `--require` that never appeared makes the run fail, as do
 states missing from a `--require-order` sequence or out of its order, and a FIRST state of a
-`--require-then FIRST:THEN` pair that no THEN state came after. If the app
+`--require-then FIRST:THEN` pair that no THEN state answered before the next FIRST or the
+last state of a `--require-order` sequence. If the app
 logged a scan bundle, it is copied into the report as scan.zip (required with `--require-export`)
 and named in report.json's
 `app_export`, so the report folder can be replayed as an app export. Reports go outside git
@@ -342,15 +343,29 @@ def out_of_order(order: list[str], states: list[ShotRecord]) -> list[str]:
     return []
 
 
-def unanswered(pairs: list[tuple[str, str]], states: list[ShotRecord]) -> list[str]:
-    """For each (first, then): every `first` state must be followed later by a `then` state."""
+def unanswered(
+    pairs: list[tuple[str, str]], states: list[ShotRecord], closing: frozenset[str] = frozenset()
+) -> list[str]:
+    """For each (first, then): every `first` state must be followed by a `then` state within its
+    own round, which ends at the next `first` or at a `closing` state. A later upload therefore
+    cannot answer a request after the app showed a result, nor answer two requests at once."""
     names = [s.state for s in states]
-    return [
-        f"state {i + 1} {first} was never followed by {then}"
-        for first, then in pairs
-        for i, name in enumerate(names)
-        if name == first and then not in names[i + 1 :]
-    ]
+    problems = []
+    for first, then in pairs:
+        for i, name in enumerate(names):
+            if name != first:
+                continue
+            for later in names[i + 1 :]:
+                if later == then:
+                    break
+                if later == first or later in closing:
+                    problems.append(
+                        f"state {i + 1} {first} was not followed by {then} before {later}"
+                    )
+                    break
+            else:
+                problems.append(f"state {i + 1} {first} was never followed by {then}")
+    return problems
 
 
 def state_pair(text: str) -> tuple[str, str]:
@@ -595,7 +610,8 @@ def main(argv: list[str] | None = None) -> int:
         default=[],
         type=state_pair,
         metavar="FIRST:THEN",
-        help="every FIRST state must be followed later in the run by a THEN state",
+        help="every FIRST state must be followed by a THEN state before the next FIRST or the last "
+        "state of a --require-order sequence",
     )
     parser.add_argument(
         "--require-export",
@@ -697,7 +713,9 @@ def main(argv: list[str] | None = None) -> int:
             rep.problems += missing_required(args.require, rep.states)
             for order in args.require_order:
                 rep.problems += out_of_order(order, rep.states)
-            rep.problems += unanswered(args.require_then, rep.states)
+            # Each --require-order sequence ends at the state that closes a round (the result).
+            closing = frozenset(order[-1] for order in args.require_order)
+            rep.problems += unanswered(args.require_then, rep.states, closing)
             rep.app_export, export_problems = app_export(out, args.require_export)
             rep.problems += export_problems
         rep.crash_reports = collect_crashes(started, out)
diff --git a/verification/tests/test_sim_app_flow.py b/verification/tests/test_sim_app_flow.py
index 60b7e642b..45f5837ac 100644
--- a/verification/tests/test_sim_app_flow.py
+++ b/verification/tests/test_sim_app_flow.py
@@ -22,7 +22,8 @@ def sim_app_problems(sequence: str) -> list[str]:
     assert orders and pairs, recipe
     states = [shot(name) for name in sequence.split(">")]
     problems = [p for order in orders for p in out_of_order(order.split(","), states)]
-    return problems + unanswered([state_pair(p) for p in pairs], states)
+    closing = frozenset(order.split(",")[-1] for order in orders)
+    return problems + unanswered([state_pair(p) for p in pairs], states, closing)
 
 
 # State sequences of recorded `make sim-app` runs on t3/ios-mvf (report.json in
@@ -58,7 +59,24 @@ def test_the_recorded_flows_pass(sequence):
         # The answer asked for more, the app showed the request, then the result without sending.
         (
             "onboarding>findMeter>meterCloseUp>wallWalk>markFeatures>uploading>gapRequest>result",
-            "state 7 gapRequest was never followed by uploading",
+            "state 7 gapRequest was not followed by uploading before result",
+        ),
+        # The request's upload came only after the app had already shown a result.
+        (
+            "onboarding>findMeter>meterCloseUp>wallWalk>markFeatures>uploading>gapRequest>result"
+            ">uploading>result",
+            "state 7 gapRequest was not followed by uploading before result",
+        ),
+        # Two requests, one upload: the first request was never sent on its own.
+        (
+            "onboarding>findMeter>meterCloseUp>wallWalk>markFeatures>gapRequest>gapRequest"
+            ">uploading>result",
+            "state 6 gapRequest was not followed by uploading before gapRequest",
+        ),
+        # The request at the end of the run was never answered at all.
+        (
+            "onboarding>findMeter>meterCloseUp>wallWalk>markFeatures>uploading>result>gapRequest",
+            "state 8 gapRequest was never followed by uploading",
         ),
     ],
 )

From a0554c8321f24f661e5296700a5084ff50dd6a55 Mon Sep 17 00:00:00 2001
From: Sam Gu <127461594+SamGu-NRX@users.noreply.github.com>
Date: Tue, 13 Oct 2026 19:47:21 -0500
Subject: [PATCH 38/62] recon: build the camera-pair matrix once for free-space
 queries

SeenFromTwo.observed rebuilt the frames-by-frames distance matrix on every
slab query, and free_space makes thousands. It now builds it once per
reconstruction and passes it to two_positions. On a synthetic 20 m clear
wall with 150 frames the free-space pass drops from 16.0 s to 10.7 s with
identical clearances. The rest is projecting each slab into every frame;
batching that means reshaping free_space's march, which #240 rewrites.

https://github.com/SamGu-NRX/BaseScanning/pull/242

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 recon/recon/coverage.py | 18 +++++++++++++++---
 1 file changed, 15 insertions(+), 3 deletions(-)

diff --git a/recon/recon/coverage.py b/recon/recon/coverage.py
index 950a6a3c6..24b6b072f 100644
--- a/recon/recon/coverage.py
+++ b/recon/recon/coverage.py
@@ -99,10 +99,20 @@ def seen_by(
     return out
 
 
-def two_positions(saw: np.ndarray, centres: np.ndarray) -> np.ndarray:
-    far = (np.linalg.norm(centres[:, None] - centres[None], axis=-1) >= BASELINE_M).astype(
+def far_pairs(centres: np.ndarray) -> np.ndarray:
+    """(frames, frames) float32: 1 where two camera positions are at least BASELINE_M apart."""
+    return (np.linalg.norm(centres[:, None] - centres[None], axis=-1) >= BASELINE_M).astype(
         np.float32
     )
+
+
+def two_positions(
+    saw: np.ndarray, centres: np.ndarray, far: np.ndarray | None = None
+) -> np.ndarray:
+    """Per row of `saw` (N, frames), whether two frames at least BASELINE_M apart both saw it.
+    `far` is `far_pairs(centres)`, for a caller that asks many times about the same frames."""
+    if far is None:
+        far = far_pairs(centres)
     s = saw.astype(np.float32)
     return ((s @ far) * s).sum(axis=-1) > 0
 
@@ -119,6 +129,8 @@ class SeenFromTwo:
     def __init__(self, vol: Volume, frames: list[Frame], depths: dict[str, Depth]):
         self.vol, self.voxel = vol, vol.voxel
         self.centres = np.array([f.center for f in frames]).reshape(-1, 3)
+        # free_space asks once per slab, thousands of times, about the same frames.
+        self.far = far_pairs(self.centres)
         T = np.array([f.cam_to_world for f in frames]).reshape(-1, 4, 4)
         self.R, self.C = T[:, :3, :3], T[:, :3, 3]
         self.K = np.array([f.intrinsics for f in frames], float).reshape(-1, 4)
@@ -164,7 +176,7 @@ def observed(self, points: np.ndarray) -> np.ndarray:
         seen = self.vol.observed(points)
         if not seen.any():
             return seen
-        return seen & two_positions(self.seen_through(points), self.centres)
+        return seen & two_positions(self.seen_through(points), self.centres, self.far)
 
 
 def face_offsets(wall: WallFrame, mesh: Mesh, cells: np.ndarray) -> np.ndarray:

From d0dbed86c088b91288f18552b14ab371ab8034ee Mon Sep 17 00:00:00 2001
From: Sam Gu <127461594+SamGu-NRX@users.noreply.github.com>
Date: Tue, 13 Oct 2026 19:48:56 -0500
Subject: [PATCH 39/62] live-dots: bound a --still offset into the last
 keyframe by playback's end

The offset check asked Schedule.keyframe(at:count:) which keyframe was on
screen, and that function holds the last keyframe forever, so any --at
passed for it, including moments the replay never plays. Schedule now
says how long each keyframe stays on screen (onScreen), ending the last
one where playback stops (playbackEnd, which ReplayPlayer now shares), and
the exporter rejects an offset at or past that. ScheduleTests covers the
middle, hold and last keyframes. Negative offsets were already refused by
the --at parser.

https://github.com/SamGu-NRX/BaseScanning/pull/242

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 .../live-dots/Sources/LiveDots/Exporter.swift | 12 +++++----
 .../Sources/LiveDots/ReplayPlayer.swift       |  2 +-
 .../Sources/LiveDotsCore/Schedule.swift       | 12 +++++++++
 .../LiveDotsCoreTests/ScheduleTests.swift     | 25 +++++++++++++++++++
 4 files changed, 45 insertions(+), 6 deletions(-)
 create mode 100644 experiments/live-dots/Tests/LiveDotsCoreTests/ScheduleTests.swift

diff --git a/experiments/live-dots/Sources/LiveDots/Exporter.swift b/experiments/live-dots/Sources/LiveDots/Exporter.swift
index e6f6ad043..8c398a5cd 100644
--- a/experiments/live-dots/Sources/LiveDots/Exporter.swift
+++ b/experiments/live-dots/Sources/LiveDots/Exporter.swift
@@ -60,12 +60,14 @@ enum Exporter {
             throw Failure(description: "--still \(number) is past the last keyframe, \(data.keyframeCount)")
         }
         // Stills are named and compared by keyframe, so an offset that plays into the next
-        // keyframe would label one keyframe's image with another's number.
-        if let offset, Schedule.keyframe(at: Schedule.start(of: number - 1) + offset, count: data.keyframeCount) != number - 1 {
-            let slot = Schedule.start(of: number) - Schedule.start(of: number - 1)
+        // keyframe would label one keyframe's image with another's number, and one past the end
+        // of playback shows a moment the replay never reaches.
+        let shown = Schedule.onScreen(number - 1, count: data.keyframeCount)
+        if let offset, offset >= shown {
+            let next = number < data.keyframeCount ? " or --still \(number + 1)" : ""
             throw Failure(description: String(
-                format: "--at %g is past keyframe %d, which is on screen for %g s; use a smaller --at or --still %d",
-                offset, number, slot, number + 1))
+                format: "--at %g is past keyframe %d, which is on screen for %g s; use a smaller --at",
+                offset, number, shown) + next)
         }
         let renderer = try DotRenderer(data: data)
         let target = try OffscreenTarget(renderer: renderer)
diff --git a/experiments/live-dots/Sources/LiveDots/ReplayPlayer.swift b/experiments/live-dots/Sources/LiveDots/ReplayPlayer.swift
index 0b606dbd1..94962168e 100644
--- a/experiments/live-dots/Sources/LiveDots/ReplayPlayer.swift
+++ b/experiments/live-dots/Sources/LiveDots/ReplayPlayer.swift
@@ -23,7 +23,7 @@ final class ReplayPlayer {
     @ObservationIgnored private var frameInterval: Float = 1 / 60
 
     /// Playback runs this long past the last keyframe so its births finish.
-    private var end: Float { Schedule.end(count: keyframeCount) + Tuning.birthDuration }
+    private var end: Float { Schedule.playbackEnd(count: keyframeCount) }
 
     init(keyframeCount: Int, reduceMotion: Bool) {
         self.keyframeCount = keyframeCount
diff --git a/experiments/live-dots/Sources/LiveDotsCore/Schedule.swift b/experiments/live-dots/Sources/LiveDotsCore/Schedule.swift
index 2637afe10..ee329e9fb 100644
--- a/experiments/live-dots/Sources/LiveDotsCore/Schedule.swift
+++ b/experiments/live-dots/Sources/LiveDotsCore/Schedule.swift
@@ -23,4 +23,16 @@ public enum Schedule {
     public static func end(count: Int) -> Float {
         start(of: count)
     }
+
+    /// When playback stops: past the last keyframe's slot, long enough for its births to finish.
+    public static func playbackEnd(count: Int) -> Float {
+        end(count: count) + Tuning.birthDuration
+    }
+
+    /// Seconds keyframe `index` stays on screen: until the next keyframe appears, or for the last
+    /// one, until playback stops. `keyframe(at:count:)` holds the last keyframe forever, so it
+    /// cannot bound an offset into that one.
+    public static func onScreen(_ index: Int, count: Int) -> Float {
+        (index + 1 < count ? start(of: index + 1) : playbackEnd(count: count)) - start(of: index)
+    }
 }
diff --git a/experiments/live-dots/Tests/LiveDotsCoreTests/ScheduleTests.swift b/experiments/live-dots/Tests/LiveDotsCoreTests/ScheduleTests.swift
new file mode 100644
index 000000000..192eec18a
--- /dev/null
+++ b/experiments/live-dots/Tests/LiveDotsCoreTests/ScheduleTests.swift
@@ -0,0 +1,25 @@
+import Testing
+@testable import LiveDotsCore
+
+struct ScheduleTests {
+    func close(_ a: Float, _ b: Float) -> Bool { abs(a - b) < 1e-5 }
+
+    @Test func `a keyframe is on screen until the next one appears`() {
+        #expect(close(Schedule.onScreen(0, count: 31), 0.25))
+        // The hold keyframe stays for the ring fill and the bracket flash.
+        #expect(close(Schedule.onScreen(Schedule.holdIndex, count: 31), Schedule.holdDuration + Schedule.flashDuration))
+        for index in 0..<30 {
+            let shown = Schedule.onScreen(index, count: 31)
+            #expect(Schedule.keyframe(at: Schedule.start(of: index) + shown - 1e-3, count: 31) == index)
+            #expect(Schedule.keyframe(at: Schedule.start(of: index) + shown + 1e-3, count: 31) == index + 1)
+        }
+    }
+
+    @Test func `the last keyframe is on screen only until playback stops`() {
+        // keyframe(at:) holds the last keyframe at any time, so it cannot bound an offset into it.
+        #expect(Schedule.keyframe(at: 1e5, count: 31) == 30)
+        let shown = Schedule.onScreen(30, count: 31)
+        #expect(close(Schedule.start(of: 30) + shown, Schedule.playbackEnd(count: 31)))
+        #expect(close(shown, 0.25 + Tuning.birthDuration))
+    }
+}

From 856ffb0e74ab76f2bb683600d75f34c2cd80d32e Mon Sep 17 00:00:00 2001
From: Sam Gu <127461594+SamGu-NRX@users.noreply.github.com>
Date: Wed, 14 Oct 2026 06:58:24 -0500
Subject: [PATCH 40/62] verification: refuse a rules headroom at or above the
 scanned overhead range

scan_profiles drops laser returns at or above OVERHEAD_MAX_FT (12 ft), but
the overhead band probes up to the rules' headroom, which this PR made
configurable. A headroom of 12 ft or more would report the band seen to
that height while an obstruction between 12 ft and the headroom never
reached the scene, so it read as clear. read_rules_headroom now stops
with an error naming both values. No rule comes close today (6.5 ft). The
test feeds a 12 ft rule, which fails, and 6.5 ft, which still loads.

https://github.com/SamGu-NRX/BaseScanning/pull/242

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 verification/scenes/eth3d-facade/build_scene.py | 10 +++++++++-
 verification/tests/test_build_scene.py          | 17 +++++++++++++++++
 2 files changed, 26 insertions(+), 1 deletion(-)

diff --git a/verification/scenes/eth3d-facade/build_scene.py b/verification/scenes/eth3d-facade/build_scene.py
index bdd7b8c3a..5a9015148 100644
--- a/verification/scenes/eth3d-facade/build_scene.py
+++ b/verification/scenes/eth3d-facade/build_scene.py
@@ -468,7 +468,15 @@ def git(*args: str) -> str:
         return done.stdout
 
     sha = git("rev-parse", "--verify", f"{ref}^{{commit}}").strip()
-    return sha, rules_headroom_ft(git("show", f"{sha}:server/rules.yaml"), f"rules.yaml at {ref}")
+    headroom_ft = rules_headroom_ft(git("show", f"{sha}:server/rules.yaml"), f"rules.yaml at {ref}")
+    # scan_profiles drops returns at or above OVERHEAD_MAX_FT, so an overhead probe that high
+    # would read an obstruction above that height as clear space.
+    if headroom_ft >= OVERHEAD_MAX_FT:
+        raise SystemExit(
+            f"rules.yaml at {ref} sets headroom.min_ft to {headroom_ft:g} ft, but the scene only "
+            f"reports overheads below OVERHEAD_MAX_FT = {OVERHEAD_MAX_FT:g} ft"
+        )
+    return sha, headroom_ft
 
 
 def band_reach(
diff --git a/verification/tests/test_build_scene.py b/verification/tests/test_build_scene.py
index 66798f28e..10d7048fa 100644
--- a/verification/tests/test_build_scene.py
+++ b/verification/tests/test_build_scene.py
@@ -100,6 +100,23 @@ def test_headroom_comes_from_rules_yaml_and_a_missing_one_is_loud():
         build_scene.rules_headroom_ft("battery: {}\n", "rules.yaml")
 
 
+@pytest.mark.parametrize(("value", "ok"), [(6.5, True), (12.0, False)])
+def test_a_headroom_above_the_scanned_overheads_is_refused(monkeypatch, value, ok):
+    """Overhead returns stop at OVERHEAD_MAX_FT (12 ft), so a headroom there or above would
+    read an obstruction above 12 ft as clear."""
+
+    def fake_git(args, **_):
+        out = "abc123\n" if args[1] == "rev-parse" else f"headroom:\n  min_ft: {{value: {value}}}\n"
+        return build_scene.subprocess.CompletedProcess(args, 0, out, "")
+
+    monkeypatch.setattr(build_scene.subprocess, "run", fake_git)
+    if ok:
+        assert build_scene.read_rules_headroom("origin/t3/server") == ("abc123", value)
+        return
+    with pytest.raises(SystemExit, match=r"headroom\.min_ft to 12 ft.*OVERHEAD_MAX_FT = 12 ft"):
+        build_scene.read_rules_headroom("origin/t3/server")
+
+
 def test_the_case_pins_the_headroom_the_scene_was_built_with():
     """A server applying another headroom (changed rules or a private override) reports it as
     the headroom check's threshold, and the case then stops judging a scene probed elsewhere."""

From 739c26228ca71ba26748f6fa67affb9042d54ed2 Mon Sep 17 00:00:00 2001
From: Sam Gu <127461594+SamGu-NRX@users.noreply.github.com>
Date: Wed, 14 Oct 2026 07:59:00 -0500
Subject: [PATCH 41/62] experiments(meter-closeup): keep a confirmed correction
 when its label changes

A Keep pressed after a Fix carries the corrected number (keepAnswer), but
startingAnswers judged every Keep by the number the page had shown, so a
dataset update that changed the readers' number dropped the confirmed
correction from the page and the export. An answer that carries its own
number now stands whatever the page showed; only a Keep with no number,
which confirms the readers' number, depends on that number staying the
same. New test: Fix, Keep, then a label change.

https://github.com/SamGu-NRX/BaseScanning/pull/242

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 experiments/meter-closeup/METHODS.md                |  2 +-
 experiments/meter-closeup/src/meter_eval/review.py  | 11 ++++++-----
 experiments/meter-closeup/tests/test_review_keep.py | 11 +++++++++++
 3 files changed, 18 insertions(+), 6 deletions(-)

diff --git a/experiments/meter-closeup/METHODS.md b/experiments/meter-closeup/METHODS.md
index 93dea94f5..43109205d 100644
--- a/experiments/meter-closeup/METHODS.md
+++ b/experiments/meter-closeup/METHODS.md
@@ -17,7 +17,7 @@ Two AI models, not people, read every photo, so every number is only as good as
 - **Loose** (73 photos, used for the headline): reader 1's number equals any number reader 2 listed, or one contains the other and the shorter has at least 6 characters, and neither reader doubted a character.
 - **Strict** (62 photos): both readers' main numbers are identical and both were sure. Reading and ranking results are reported under both rules.
 
-To confirm the labels by hand, run `make review` and open `~/house-scanning-data/meter-closeup/review.html`. Each photo shows whole, beside the agreed number. Press K to keep the number, or F to type a correction. Then run `uv run python -m meter_eval.review ingest <downloaded csv>` and rebuild with `uv run python -m meter_eval.labels`. A kept number counts as agreed under both rules; a corrected one does not until someone keeps it. A Keep saved in the browser stays only while the page shows the number it was given for, so after a label correction that photo opens again; a correction typed there stays. Ingest merges new answers into earlier ones, and a rebuilt page shows each earlier correction in place of the readers' number, so Keep confirms the correction even in a new browser.
+To confirm the labels by hand, run `make review` and open `~/house-scanning-data/meter-closeup/review.html`. Each photo shows whole, beside the agreed number. Press K to keep the number, or F to type a correction. Then run `uv run python -m meter_eval.review ingest <downloaded csv>` and rebuild with `uv run python -m meter_eval.labels`. A kept number counts as agreed under both rules; a corrected one does not until someone keeps it. A Keep of the readers' number saved in the browser stays only while the page shows that number, so after a label correction that photo opens again; a correction typed there, and a Keep of that correction, stay. Ingest merges new answers into earlier ones, and a rebuilt page shows each earlier correction in place of the readers' number, so Keep confirms the correction even in a new browser.
 
 ## Keeping meter numbers out of the repository
 
diff --git a/experiments/meter-closeup/src/meter_eval/review.py b/experiments/meter-closeup/src/meter_eval/review.py
index 3e29c7aa8..7b6a9e683 100644
--- a/experiments/meter-closeup/src/meter_eval/review.py
+++ b/experiments/meter-closeup/src/meter_eval/review.py
@@ -223,16 +223,17 @@ def ingest(path: str) -> None:
 <script>
 const items = JSON.parse(document.getElementById("items").textContent);
 // Answers already ingested ship with the page, so a new browser starts from them; answers saved
-// in this browser since then take precedence. A Fix carries the reviewer's own number, so it
-// stands whatever the page showed. A Keep confirms the number shown, so it stands only while
-// the page still shows that number: after a label correction or dataset update the photo is
-// open again, and a stale Keep is neither shown as done nor exported. A Keep saved before
+// in this browser since then take precedence. An answer with a number states that number itself:
+// a Fix, or a Keep that confirmed a correction (`keepAnswer`), so it stands whatever the page
+// showed. A Keep without one confirms the readers' number shown, so it stands only while the
+// page still shows that number: after a label correction or dataset update the photo is open
+// again, and a stale Keep is neither shown as done nor exported. Such a Keep saved before
 // `shown` was recorded cannot be checked and is dropped the same way.
 function startingAnswers(items, stored) {
   const answers = {};
   for (const item of items) {
     const mine = stored[item.id];
-    if (mine && (mine.verdict === "fix" || mine.shown === item.number)) answers[item.id] = mine;
+    if (mine && (mine.number || mine.shown === item.number)) answers[item.id] = mine;
     else if (item.answer) answers[item.id] = item.answer;
   }
   return answers;
diff --git a/experiments/meter-closeup/tests/test_review_keep.py b/experiments/meter-closeup/tests/test_review_keep.py
index dd71a28e2..79bc1cf3f 100644
--- a/experiments/meter-closeup/tests/test_review_keep.py
+++ b/experiments/meter-closeup/tests/test_review_keep.py
@@ -97,6 +97,17 @@ def test_a_browser_correction_survives_a_label_change_and_the_upgrade():
     assert rows[1:] == [["m01", "fix", "ABC 7654321"], ["m02", "fix", "2223333"]]
 
 
+def test_a_kept_correction_survives_a_label_change():
+    """Fix, then Keep in the same browser, then a dataset update changes the readers' number."""
+    before = [{"id": "m01", "number": "1111111", "corrected": False, "answer": None}]
+    fixed = {"verdict": "fix", "number": "ABC 7654321", "shown": "1111111"}
+    kept = on_page("keepAnswer(previous, items[0])", previous=fixed, items=before)
+    stored = {"m01": {**kept, "shown": "1111111"}}
+    after = [{"id": "m01", "number": "1112222", "corrected": False, "answer": None}]
+    rows = on_page("answerRows(items, startingAnswers(items, stored))", items=after, stored=stored)
+    assert rows[1:] == [["m01", "keep", "ABC 7654321"]]
+
+
 def write(path, rows):
     with path.open("w", newline="") as handle:
         writer = csv.DictWriter(handle, fieldnames=list(rows[0]))

From 7ae364da90bb457eabe9db1b1937f424501ea70d Mon Sep 17 00:00:00 2001
From: SamGu-NRX <84697312+SamGu-NRX@users.noreply.github.com>
Date: Wed, 14 Oct 2026 10:02:58 -0500
Subject: [PATCH 42/62] test: keep facade tail probes inside wall extents

Guard the clipped midpoint retained when combining #240 and #242; a visibility predicate rejects any probe beyond the fitted wall.
---
 verification/tests/test_build_scene.py | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)

diff --git a/verification/tests/test_build_scene.py b/verification/tests/test_build_scene.py
index 1e0c6bfd4..9320b3ffc 100644
--- a/verification/tests/test_build_scene.py
+++ b/verification/tests/test_build_scene.py
@@ -101,3 +101,19 @@ def test_non_grid_wall_has_no_excess_or_missing_tail(length):
     )
     assert entries[0]["span_ft"] == [0.0, length]
     assert spans == [[0.0, length]]
+
+
+@pytest.mark.parametrize("length", [2.2, 2.3, 0.05])
+def test_clipped_tail_probes_stay_within_the_wall(length):
+    probes = []
+
+    def within_wall(kf, w, point, walls):
+        probes.append(float(point[0]))
+        return 0.0 <= point[0] <= length
+
+    entries, spans = build_scene.band_coverage(
+        "wall", [wall("w", 0.0, length)], [], ["kf"], within_wall
+    )
+    assert probes and all(0.0 <= p <= length for p in probes)
+    assert spans == [[0.0, length]]
+    assert entries[0]["span_ft"] == [0.0, length]

From b646b9a2c8c61940073bc2e6c377a04526ab59a1 Mon Sep 17 00:00:00 2001
From: Sam Gu <127461594+SamGu-NRX@users.noreply.github.com>
Date: Wed, 14 Oct 2026 10:09:35 -0500
Subject: [PATCH 43/62] fix: close pipeline follow-up review gaps

Reject early results, enforce the full HTTP deadline, reset fog on seeks and settled resumes, batch two-view clearance checks and keep wall-front sampling on the raw volume.

Describe drift windows as a straight-path check and distinguish Alpha limit-end replay from the unrun native proposal. Regressions preserve the combined facade and fitted-ground repairs.
---
 experiments/drift-anatomy/METHODS.md          |   6 +-
 experiments/drift-anatomy/README.md           |   6 +-
 experiments/drift-anatomy/metrics.py          |   8 +-
 .../drift-anatomy/results/drift_anatomy.json  |  12 +-
 .../drift-anatomy/results/drift_anatomy.md    |   6 +-
 experiments/drift-anatomy/run.py              |  29 ++--
 .../drift-anatomy/tests/test_report.py        |  32 ++++
 .../Sources/LiveDots/DotRenderer.swift        |  31 +---
 .../live-dots/Sources/LiveDots/FogLayer.swift |   9 -
 .../Sources/LiveDots/OffscreenTarget.swift    |   1 +
 .../Sources/LiveDots/ReplayPlayer.swift       |  57 ++----
 .../Sources/LiveDotsCore/FogContinuity.swift  |  21 +++
 .../Sources/LiveDotsCore/FrameRequest.swift   |  43 +++++
 .../Sources/LiveDotsCore/ReplayPlayback.swift |  70 ++++++++
 .../ReplayPlaybackTests.swift                 | 144 +++++++++++++++
 .../native-proposals/README.md                |   2 +-
 recon/recon/coverage.py                       | 157 ++++++++++++-----
 recon/tests/test_coverage_batches.py          | 142 +++++++++++++++
 recon/tests/test_coverage_views.py            | 119 +++++++++++++
 recon/tests/test_review_debt.py               |   2 +
 verification/hsverify/e2e.py                  | 140 ++++++++++-----
 verification/hsverify/simrun.py               |  18 +-
 verification/tests/test_build_scene.py        |  16 ++
 verification/tests/test_e2e.py                | 164 ++++++++++++++++++
 verification/tests/test_sim_app_flow.py       |   9 +-
 verification/tests/test_simrun.py             |  26 +++
 26 files changed, 1058 insertions(+), 212 deletions(-)
 create mode 100644 experiments/drift-anatomy/tests/test_report.py
 create mode 100644 experiments/live-dots/Sources/LiveDotsCore/FogContinuity.swift
 create mode 100644 experiments/live-dots/Sources/LiveDotsCore/FrameRequest.swift
 create mode 100644 experiments/live-dots/Sources/LiveDotsCore/ReplayPlayback.swift
 create mode 100644 experiments/live-dots/Tests/LiveDotsCoreTests/ReplayPlaybackTests.swift
 create mode 100644 recon/tests/test_coverage_batches.py
 create mode 100644 recon/tests/test_coverage_views.py

diff --git a/experiments/drift-anatomy/METHODS.md b/experiments/drift-anatomy/METHODS.md
index e5d4a588f..bfbbeb58d 100644
--- a/experiments/drift-anatomy/METHODS.md
+++ b/experiments/drift-anatomy/METHODS.md
@@ -8,7 +8,7 @@ The server allows 0.16 ft of error per foot along the wall. That allowance domin
 
 - **A1, return to the meter.** When a walk comes back within 0.3 m of an earlier point more than 30 s later, ARKit's closure residual r is the error in the displacement between the two visits. Does r bound the largest error between the visits?
 - **A2, scale.** Is ARKit's scale one number per walk? This measures the spread of scale over sliding 5 m windows within a walk.
-- **A3, the wall plane.** What share of the error runs across the direction of travel, which a wall plane would remove, compared with along it?
+- **A3, along and across travel.** What share of the error runs across the direction of travel, compared with along it? A wall plane removes the across component only when travel is parallel to that wall; these walks do not annotate that orientation.
 - **A4, a range to the meter.** A second phone left at the meter ranges the walking phone by UWB (σ 10 cm, simulated) at every window end. What is the p90 left over? Each window is one session that starts at the meter: the walking phone leaves the meter at the window's start, the second phone stays there, and the range runs from that start to the window's end. Sliding the start along a walk samples many meter placements; the error depends on the path walked from the meter, not on where in the dataset the meter sits.
 
 ## Pass criteria, fixed before the run
@@ -24,9 +24,9 @@ All four fail. Tables: [results/drift_anatomy.md](results/drift_anatomy.md).
 
 - **A1.** 30 of 56 MARViN loops (54%). ADVIO has no revisit under 0.3 m while ARKit tracks. Scale and heading error cancel on return, so r misses them.
 - **A2.** 5.7% SD on MARViN, 19% on ADVIO: drop. A few outlier windows inflate MARViN's SD; its robust SD is 1.8%.
-- **A3.** At 20 ft, along is 0.92 of the p90 on MARViN and 0.76 on ADVIO. Added after review: across-travel is a wall's normal only while the walk runs straight along the wall, and the walks have no wall annotations. On windows whose path stays within 0.25 m of its start-to-end line, along is 0.98 of the p90 on MARViN and 0.75 on ADVIO at 20 ft; within 0.5 m, 0.95 and 0.75. The conclusion holds on the windows that test it.
+- **A3.** At 20 ft, along is 0.92 of the p90 on MARViN and 0.76 on ADVIO. The straight-path check selects windows by reference-path deviation from their start-to-end line: within 0.25 m, along is 0.98 of the p90 on MARViN and 0.75 on ADVIO; within 0.5 m, 0.95 and 0.75. These untuned, non-pre-registered filters select straightness only. With no wall annotations, they cannot identify wall-parallel travel or establish a wall-plane constraint's benefit.
 - **A4.** MARViN goes from 10.4 and 13.6 in to 7.7 and 8.5 in. At σ 10 cm the range's own p90 is 6.5 in, so the bar was nearly out of reach. At 5 cm: 4.9 and 6.1 in.
 
 **Run:** `uv run python run.py`. Needs the evals checkout at 190ed33 (`EVALS_HARNESS`) and MARViN and ADVIO in `~/house-scanning-data`.
 
-**What it changes:** the error worth attacking runs along travel. A range to the meter reduces it, a wall plane wouldn't, and r can't bound a session.
+**What it changes:** the error worth attacking runs along travel. A range to the meter reduces it, and r cannot bound a session. These unannotated walks do not establish whether a wall-plane constraint helps.
diff --git a/experiments/drift-anatomy/README.md b/experiments/drift-anatomy/README.md
index 1ae0e79f6..612572a78 100644
--- a/experiments/drift-anatomy/README.md
+++ b/experiments/drift-anatomy/README.md
@@ -2,7 +2,7 @@
 
 ## Question
 
-The server allows 0.16 ft of error per foot along the wall, which dominates a check's error bar beyond a few feet. Which part of ARKit's error is worth attacking? A1 asks whether returning to the meter bounds it, A2 whether scale is one number per walk, A3 how much runs across travel, where a wall plane would help, and A4 what a UWB range to the meter leaves. Each window stands for a session that starts at the meter, so in A4 the second phone sits at the window's start. The data is MARViN (iPhone 14 Pro Max) and ADVIO (iPhone 6s); [METHODS.md](METHODS.md) has the details.
+The server allows 0.16 ft of error per foot along the wall, which dominates a check's error bar beyond a few feet. Which part of ARKit's error is worth attacking? A1 asks whether returning to the meter bounds it, A2 whether scale is one number per walk, A3 how much runs across travel, and A4 what a UWB range to the meter leaves. Each window stands for a session that starts at the meter, so in A4 the second phone sits at the window's start. The data is MARViN (iPhone 14 Pro Max) and ADVIO (iPhone 6s); [METHODS.md](METHODS.md) has the details.
 
 ## Pass criteria, fixed before the run (397507f)
 
@@ -17,9 +17,9 @@ All four fail ([tables](results/drift_anatomy.md)).
 
 - **A1.** The closure residual bounds the peak error in 30 of 56 loops. Scale and heading error cancel on return.
 - **A2.** Scale spread within a walk is 1.8% robust SD (5.7% SD) on MARViN.
-- **A3.** At 20 ft, the along-travel p90 is 9.6 of 10.4 in. On the windows that walk straight, which is where across-travel is a wall's normal, along is 0.95 to 0.98 of the total on MARViN (added after review).
+- **A3.** At 20 ft, the along-travel p90 is 9.6 of 10.4 in. In the straight-path check, along is 0.95 to 0.98 of the total on MARViN (added after review). The walks have no wall annotations, so this does not establish wall-parallel travel or the benefit of a wall-plane constraint.
 - **A4.** UWB cuts 20 ft from 10.4 to 7.7 in at σ 10 cm, and to 4.9 in at σ 5 cm.
 
 **Run:** `uv run python run.py`: 20 s. Needs the evals checkout at 190ed33 and MARViN and ADVIO in `~/house-scanning-data`.
 
-**What it changes:** the error worth attacking runs along travel. Measuring a span inside one photo avoids it. A wall plane, a return to the meter or one ruler at the meter don't.
+**What it changes:** the error worth attacking runs along travel. Measuring a span inside one photo avoids it. The return-to-meter and one-ruler criteria fail. These unannotated walks do not establish whether a wall-plane constraint helps.
diff --git a/experiments/drift-anatomy/metrics.py b/experiments/drift-anatomy/metrics.py
index f329e769a..af2d72e8d 100644
--- a/experiments/drift-anatomy/metrics.py
+++ b/experiments/drift-anatomy/metrics.py
@@ -168,10 +168,10 @@ def along_across(err: np.ndarray, ref_disp: np.ndarray) -> tuple[np.ndarray, np.
 
 
 def chord_deviation(ref: np.ndarray, i: np.ndarray, j: np.ndarray) -> np.ndarray:
-    """Per window, the largest horizontal distance of the reference path from the straight line
-    through its start ref[i] and its (fractional) end at(ref, j). A wall plane removes the error
-    along the wall's normal, which is the across-travel axis only while the walk runs straight
-    along the wall; this measures how far a window strays from that."""
+    """Largest horizontal distance from each window's start-to-end line.
+
+    This measures path straightness; it carries no information about wall orientation.
+    """
     out = np.empty(len(i))
     for k, (a, b) in enumerate(zip(i, j, strict=True)):
         start = ref[a, [0, 2]]
diff --git a/experiments/drift-anatomy/results/drift_anatomy.json b/experiments/drift-anatomy/results/drift_anatomy.json
index edd2313e4..4491e4e2d 100644
--- a/experiments/drift-anatomy/results/drift_anatomy.json
+++ b/experiments/drift-anatomy/results/drift_anatomy.json
@@ -1361,7 +1361,7 @@
     "median_horizontal_in": 2.6181875496018105,
     "p90_vertical_in": 1.9654002913094888,
     "p90_3d_in": 6.796782660764225,
-    "wall_parallel": {
+    "straight_path": {
      "0.25": {
       "windows": 3601,
       "p90_along_in": 5.826966988094975,
@@ -1387,7 +1387,7 @@
     "median_horizontal_in": 4.395873486077264,
     "p90_vertical_in": 2.9551007554751285,
     "p90_3d_in": 10.87021034634674,
-    "wall_parallel": {
+    "straight_path": {
      "0.25": {
       "windows": 1416,
       "p90_along_in": 9.604249774006092,
@@ -1413,7 +1413,7 @@
     "median_horizontal_in": 6.016112751925093,
     "p90_vertical_in": 3.6388989773814653,
     "p90_3d_in": 14.139117730080716,
-    "wall_parallel": {
+    "straight_path": {
      "0.25": {
       "windows": 556,
       "p90_along_in": 11.52265233012735,
@@ -1441,7 +1441,7 @@
     "median_horizontal_in": 26.202438486533016,
     "p90_vertical_in": 3.697033252704125,
     "p90_3d_in": 55.7048750882303,
-    "wall_parallel": {
+    "straight_path": {
      "0.25": {
       "windows": 1831,
       "p90_along_in": 38.817104640899515,
@@ -1467,7 +1467,7 @@
     "median_horizontal_in": 50.231545101074694,
     "p90_vertical_in": 6.375715770353499,
     "p90_3d_in": 94.60404389848367,
-    "wall_parallel": {
+    "straight_path": {
      "0.25": {
       "windows": 1572,
       "p90_along_in": 66.36786396952603,
@@ -1493,7 +1493,7 @@
     "median_horizontal_in": 73.64854529941651,
     "p90_vertical_in": 9.174807119748339,
     "p90_3d_in": 132.57989402774612,
-    "wall_parallel": {
+    "straight_path": {
      "0.25": {
       "windows": 1421,
       "p90_along_in": 93.12387571665461,
diff --git a/experiments/drift-anatomy/results/drift_anatomy.md b/experiments/drift-anatomy/results/drift_anatomy.md
index 1f7bebdde..475a4c8e0 100644
--- a/experiments/drift-anatomy/results/drift_anatomy.md
+++ b/experiments/drift-anatomy/results/drift_anatomy.md
@@ -132,9 +132,11 @@ The evals' windows: from every image (MARViN) or every 0.5 s (ADVIO) until the r
 
 Criterion at 20 ft: along p90 at most 0.60 of the horizontal total p90. MARViN 0.92, FAIL; ADVIO 0.76, FAIL.
 
-Added after review: a wall plane removes the error along the wall's normal, and that is the across-travel axis only while the walk runs straight along the wall. In windows that turn, across holds some along-wall error and along holds some error a plane would remove, so the graded split above cannot by itself say whether a plane helps. The walks have no wall annotations, so the windows below stand in for a walk along a wall: those whose reference path stays within the given distance of its own start-to-end line. The widths are untuned and not pre-registered.
+### Straight-path check
 
-| Data | Walked | Within | Windows | Along | Across | Horizontal total | Along / total |
+The windows below have reference paths within the given distance of their own start-to-end line. This checks the along/across split on straight paths. The walks have no wall annotations, so it cannot identify wall-parallel travel or measure the benefit of a wall-plane constraint. The widths are untuned and not pre-registered.
+
+| Data | Walked | Max chord deviation | Windows | Along | Across | Horizontal total | Along / total |
 | --- | --- | --- | --- | --- | --- | --- | --- |
 | MARViN | 10 ft | 0.25 m | 3601 | 5.8 | 2.1 | 6.2 | 0.95 |
 | MARViN | 10 ft | 0.50 m | 4489 | 5.9 | 2.3 | 6.3 | 0.94 |
diff --git a/experiments/drift-anatomy/run.py b/experiments/drift-anatomy/run.py
index 396e4a777..d472d8d9c 100644
--- a/experiments/drift-anatomy/run.py
+++ b/experiments/drift-anatomy/run.py
@@ -57,11 +57,9 @@
 RANGE_SIGMAS_M = (0.05, 0.10, 0.20)
 GRADED_SIGMA_M = 0.10
 RANGE_DRAWS = 20
-# A3, added after review: the across-travel axis is a wall's normal only while the walk runs
-# straight along the wall, and the walks carry no wall annotations. Windows whose reference path
-# stays within this distance of its own start-to-end line stand in for a walk along a wall. Both
-# widths are untuned guesses at how straight a homeowner keeps to a wall, reported side by side.
-WALL_PARALLEL_M = (0.25, 0.5)
+# Chord deviation selects straight paths; without wall annotations it cannot select paths
+# parallel to a wall. The widths are untuned and not pre-registered.
+STRAIGHT_PATH_M = (0.25, 0.5)
 SEED = 0
 
 
@@ -285,11 +283,11 @@ def a3_a4(walks: list[Walk]) -> tuple[dict, dict]:
                 "median_horizontal_in": float(np.median(horiz)) / INCH,
                 "p90_vertical_in": p90(np.abs(err[:, 1])) / INCH,
                 "p90_3d_in": p90(np.linalg.norm(err, axis=1)) / INCH,
-                "wall_parallel": {
+                "straight_path": {
                     f"{m:.2f}": split_p90(err[dev <= m], ref[dev <= m])
                     if (dev <= m).any()
                     else None
-                    for m in WALL_PARALLEL_M
+                    for m in STRAIGHT_PATH_M
                 },
             }
             true_range = np.linalg.norm(ref, axis=1)
@@ -482,20 +480,19 @@ def markdown(meta: dict, r1: dict, r2: dict, r3: dict, r4: dict, r5: dict) -> st
         )
         + ".",
         "",
-        "Added after review: a wall plane removes the error along the wall's normal, and that is "
-        "the across-travel axis only while the walk runs straight along the wall. In windows that "
-        "turn, across holds some along-wall error and along holds some error a plane would remove, "
-        "so the graded split above cannot by itself say whether a plane helps. The walks have no "
-        "wall annotations, so the windows below stand in for a walk along a wall: those whose "
-        "reference path stays within the given distance of its own start-to-end line. The widths "
-        "are untuned and not pre-registered.",
+        "### Straight-path check",
         "",
-        "| Data | Walked | Within | Windows | Along | Across | Horizontal total | Along / total |",
+        "The windows below have reference paths within the given distance of their own "
+        "start-to-end line. This checks the along/across split on straight paths. The walks have "
+        "no wall annotations, so it cannot identify wall-parallel travel or measure the benefit "
+        "of a wall-plane constraint. The widths are untuned and not pre-registered.",
+        "",
+        "| Data | Walked | Max chord deviation | Windows | Along | Across | Horizontal total | Along / total |",
         "| --- | --- | --- | --- | --- | --- | --- | --- |",
     ]
     for d, x in r3.items():
         for ft, y in x.items():
-            for m, z in y["wall_parallel"].items():
+            for m, z in y["straight_path"].items():
                 if z is None:
                     L.append(f"| {names[d]} | {ft} ft | {m} m | 0 | | | | |")
                     continue
diff --git a/experiments/drift-anatomy/tests/test_report.py b/experiments/drift-anatomy/tests/test_report.py
new file mode 100644
index 000000000..7c3ae974e
--- /dev/null
+++ b/experiments/drift-anatomy/tests/test_report.py
@@ -0,0 +1,32 @@
+"""The cached run must distinguish path straightness from wall orientation."""
+
+import json
+from pathlib import Path
+
+from run import markdown
+
+
+def test_straight_path_report_qualifies_the_filter():
+    def numeric_keys(pairs):
+        def key(value):
+            try:
+                return int(value) if value.isdigit() else float(value)
+            except ValueError:
+                return value
+
+        return {
+            key(k): ({f"{m:.2f}": z for m, z in v.items()} if k == "straight_path" else v)
+            for k, v in pairs
+        }
+
+    report = json.loads(
+        (Path(__file__).parents[1] / "results/drift_anatomy.json").read_text(),
+        object_pairs_hook=numeric_keys,
+    )
+    rendered = markdown(*(report[k] for k in ("meta", "a1", "a2", "a3", "a4", "a5")))
+    assert "### Straight-path check" in rendered
+    assert "Max chord deviation" in rendered
+    assert "cannot identify wall-parallel travel" in rendered
+    assert "measure the benefit of a wall-plane constraint" in rendered
+    assert "stand in for a walk along a wall" not in rendered
+    assert rendered == (Path(__file__).parents[1] / "results/drift_anatomy.md").read_text()
diff --git a/experiments/live-dots/Sources/LiveDots/DotRenderer.swift b/experiments/live-dots/Sources/LiveDots/DotRenderer.swift
index 0ddfa72cf..bb7439980 100644
--- a/experiments/live-dots/Sources/LiveDots/DotRenderer.swift
+++ b/experiments/live-dots/Sources/LiveDots/DotRenderer.swift
@@ -3,24 +3,6 @@ import Metal
 import MetalKit
 import simd
 
-/// What one frame shows: which keyframe, when on the playback clock, and the toggles.
-struct FrameRequest: Equatable {
-    var mode: CaptureMode
-    var keyframe: Int
-    /// Playback seconds; animations are evaluated at this time.
-    var time: Float
-    var reduceMotion: Bool
-    var fog: FogStyle
-    var scheme: DotScheme = .hologram
-    /// Seconds on a clock that keeps running while playback is paused, for the fog's drift.
-    var ambientTime: Float = 0
-    /// Seconds since the previous frame, for the fog's lag.
-    var frameInterval: Float = 1 / 60
-
-    /// A scrub or a still shows its keyframe settled; the renderer passes a far-future time.
-    var isSettled: Bool { time > 1e4 }
-}
-
 /// Draws a keyframe: the camera image, the optional fog veil, then the dots as additive point
 /// sprites from one vertex buffer. The buffer is rebuilt only when the keyframe or mode changes;
 /// between keyframes the shader animates births and evidence from the playback time.
@@ -60,8 +42,7 @@ final class DotRenderer {
     private var linkBuffer: MTLBuffer?
     private var linkVertexCount = 0
     private var cachedKey: (mode: CaptureMode, keyframe: Int, scheme: DotScheme)?
-    /// The view the fog mask was last built for; nil while the fog is not drawn.
-    private var fogView: (mode: CaptureMode, keyframe: Int)?
+    private var fogContinuity = FogContinuity()
     /// Replaces the timeline's sprites, for the 6,000-dot benchmark.
     var spriteOverride: [DotSprite]? {
         didSet { cachedKey = nil }
@@ -122,19 +103,13 @@ final class DotRenderer {
         let projection = ScreenProjection(keyframe: keyframe, viewSize: pixelSize)
 
         var clip = projection.clipMatrix
+        let resetFog = fogContinuity.consume(request)
         if request.fog == .on {
-            // The lag eases the mask only between frames of one playback (same keyframe or the
-            // next). After a jump, a mode switch or the fog coming back on, the old mask belongs
-            // to another view and would leave unmeasured regions clear.
-            let continues = fogView.map { $0.mode == request.mode && (0...1).contains(request.keyframe - $0.keyframe) } ?? false
             fog.encodeMask(
                 into: commandBuffer, splats: splatBuffer, splatCount: splatCount, clip: clip,
                 pixelsPerMetre: keyframe.intrinsics.x * projection.scale * Float(FogLayer.maskWidth) / pixelSize.x,
                 time: request.time, dt: request.frameInterval, reduceMotion: request.reduceMotion,
-                reset: request.isSettled || !continues)
-            fogView = (request.mode, request.keyframe)
-        } else {
-            fogView = nil
+                reset: resetFog)
         }
 
         guard let encoder = commandBuffer.makeRenderCommandEncoder(descriptor: pass) else { return }
diff --git a/experiments/live-dots/Sources/LiveDots/FogLayer.swift b/experiments/live-dots/Sources/LiveDots/FogLayer.swift
index 83dc4598b..a5e63f447 100644
--- a/experiments/live-dots/Sources/LiveDots/FogLayer.swift
+++ b/experiments/live-dots/Sources/LiveDots/FogLayer.swift
@@ -2,15 +2,6 @@ import LiveDotsCore
 import Metal
 import simd
 
-/// How the unmeasured world is shown.
-enum FogStyle: String, CaseIterable {
-    /// The fog layer: one continuous haze that dissolves where dots arrive.
-    case on
-    /// The old comparison: a flat 35% veil over 30 cm wall cells no dot has reached.
-    case veil
-    case off
-}
-
 /// The fog layer's GPU state: the 96 x 208 reveal mask, its blur, the lagged copy that carries
 /// from frame to frame, and each keyframe's depth for the depth term. The shaders and what they
 /// borrow are described at the fog section of Shaders.swift.
diff --git a/experiments/live-dots/Sources/LiveDots/OffscreenTarget.swift b/experiments/live-dots/Sources/LiveDots/OffscreenTarget.swift
index ded73f408..fabafd73e 100644
--- a/experiments/live-dots/Sources/LiveDots/OffscreenTarget.swift
+++ b/experiments/live-dots/Sources/LiveDots/OffscreenTarget.swift
@@ -1,3 +1,4 @@
+import LiveDotsCore
 import CoreGraphics
 import Metal
 
diff --git a/experiments/live-dots/Sources/LiveDots/ReplayPlayer.swift b/experiments/live-dots/Sources/LiveDots/ReplayPlayer.swift
index 94962168e..8ecf5cb14 100644
--- a/experiments/live-dots/Sources/LiveDots/ReplayPlayer.swift
+++ b/experiments/live-dots/Sources/LiveDots/ReplayPlayer.swift
@@ -13,65 +13,38 @@ final class ReplayPlayer {
     var fog: FogStyle = .on
     private(set) var isPlaying = false
     private(set) var keyframe = 0
-    /// Playback seconds. Keyframe k is on screen from k / 4 to (k + 1) / 4.
-    @ObservationIgnored private(set) var playhead: Float = 0
-    /// After a scrub the frame shows its settled state instead of replaying births.
-    @ObservationIgnored private var settled = false
-    @ObservationIgnored private var lastTick: CFTimeInterval?
-    @ObservationIgnored private var lastFrame: CFTimeInterval?
-    @ObservationIgnored private var ambient: Float = 0
-    @ObservationIgnored private var frameInterval: Float = 1 / 60
-
-    /// Playback runs this long past the last keyframe so its births finish.
-    private var end: Float { Schedule.playbackEnd(count: keyframeCount) }
+    var playhead: Float { playback.playhead }
+    @ObservationIgnored private var playback: ReplayPlayback
 
     init(keyframeCount: Int, reduceMotion: Bool) {
         self.keyframeCount = keyframeCount
+        self.playback = ReplayPlayback(keyframeCount: keyframeCount)
         self.reduceMotion = reduceMotion
     }
 
     var request: FrameRequest {
-        FrameRequest(
-            mode: mode, keyframe: keyframe, time: settled ? 1e5 : playhead,
-            reduceMotion: reduceMotion, fog: fog, scheme: scheme, ambientTime: ambient, frameInterval: frameInterval)
+        playback.frameRequest(mode: mode, reduceMotion: reduceMotion, fog: fog, scheme: scheme)
     }
 
     func togglePlayback() {
-        if isPlaying {
-            isPlaying = false
-            return
-        }
-        if playhead >= end - 1e-3 || (keyframe == keyframeCount - 1 && settled) { seek(to: 0, settle: false) }
-        settled = false
-        lastTick = nil
-        isPlaying = true
+        playback.togglePlayback()
+        updateControls()
     }
 
     /// Jumps to a keyframe and shows it settled. Scrubbing while playing keeps playing from there.
     func scrub(to index: Int) {
-        seek(to: index, settle: !isPlaying)
-    }
-
-    private func seek(to index: Int, settle: Bool) {
-        keyframe = min(max(index, 0), keyframeCount - 1)
-        playhead = Schedule.start(of: keyframe)
-        settled = settle
-        lastTick = nil
+        playback.scrub(to: index)
+        updateControls()
     }
 
     /// Advances the clock; the Metal view calls this once per display frame.
     func tick(now: CFTimeInterval) {
-        if let lastFrame { frameInterval = min(Float(now - lastFrame), 0.1) }
-        lastFrame = now
-        ambient += frameInterval
-        guard isPlaying else { return }
-        if let lastTick { playhead += Float(now - lastTick) }
-        lastTick = now
-        let index = Schedule.keyframe(at: playhead, count: keyframeCount)
-        if index != keyframe { keyframe = index }
-        if playhead >= end {
-            playhead = end
-            isPlaying = false
-        }
+        playback.tick(now: now)
+        updateControls()
+    }
+
+    private func updateControls() {
+        if isPlaying != playback.isPlaying { isPlaying = playback.isPlaying }
+        if keyframe != playback.keyframe { keyframe = playback.keyframe }
     }
 }
diff --git a/experiments/live-dots/Sources/LiveDotsCore/FogContinuity.swift b/experiments/live-dots/Sources/LiveDotsCore/FogContinuity.swift
new file mode 100644
index 000000000..256efb089
--- /dev/null
+++ b/experiments/live-dots/Sources/LiveDotsCore/FogContinuity.swift
@@ -0,0 +1,21 @@
+/// Keeps fog easing within one continuous playback, never across a seek or a settled preview.
+public struct FogContinuity {
+    private var previous: FrameRequest?
+
+    public init() {}
+
+    /// Returns whether the renderer must replace its lagged mask with the current frame's mask.
+    public mutating func consume(_ request: FrameRequest) -> Bool {
+        guard request.fog == .on else {
+            previous = nil
+            return false
+        }
+        defer { previous = request }
+        guard let previous else { return true }
+        return request.isSettled || previous.isSettled
+            || request.seekGeneration != previous.seekGeneration
+            || request.mode != previous.mode
+            || !(0...1).contains(request.keyframe - previous.keyframe)
+            || request.time < previous.time
+    }
+}
diff --git a/experiments/live-dots/Sources/LiveDotsCore/FrameRequest.swift b/experiments/live-dots/Sources/LiveDotsCore/FrameRequest.swift
new file mode 100644
index 000000000..ef5bb63d1
--- /dev/null
+++ b/experiments/live-dots/Sources/LiveDotsCore/FrameRequest.swift
@@ -0,0 +1,43 @@
+/// How the unmeasured world is shown.
+public enum FogStyle: String, CaseIterable, Sendable {
+    /// The fog layer: one continuous haze that dissolves where dots arrive.
+    case on
+    /// The old comparison: a flat 35% veil over 30 cm wall cells no dot has reached.
+    case veil
+    case off
+}
+
+/// What one frame shows: which keyframe, when on the playback clock, and the toggles.
+public struct FrameRequest: Equatable, Sendable {
+    public var mode: CaptureMode
+    public var keyframe: Int
+    /// Playback seconds; animations are evaluated at this time.
+    public var time: Float
+    public var reduceMotion: Bool
+    public var fog: FogStyle
+    public var scheme: DotScheme = .hologram
+    /// Seconds on a clock that keeps running while playback is paused, for the fog's drift.
+    public var ambientTime: Float = 0
+    /// Seconds since the previous frame, for the fog's lag.
+    public var frameInterval: Float = 1 / 60
+
+    /// Changes on explicit seeks and on resuming from a settled scrub.
+    public var seekGeneration: UInt64 = 0
+
+    public init(mode: CaptureMode, keyframe: Int, time: Float, reduceMotion: Bool, fog: FogStyle,
+                scheme: DotScheme = .hologram, ambientTime: Float = 0, frameInterval: Float = 1 / 60,
+                seekGeneration: UInt64 = 0) {
+        self.mode = mode
+        self.keyframe = keyframe
+        self.time = time
+        self.reduceMotion = reduceMotion
+        self.fog = fog
+        self.scheme = scheme
+        self.ambientTime = ambientTime
+        self.frameInterval = frameInterval
+        self.seekGeneration = seekGeneration
+    }
+
+    /// A scrub or a still shows its keyframe settled; the renderer passes a far-future time.
+    public var isSettled: Bool { time > 1e4 }
+}
diff --git a/experiments/live-dots/Sources/LiveDotsCore/ReplayPlayback.swift b/experiments/live-dots/Sources/LiveDotsCore/ReplayPlayback.swift
new file mode 100644
index 000000000..cb46a15da
--- /dev/null
+++ b/experiments/live-dots/Sources/LiveDotsCore/ReplayPlayback.swift
@@ -0,0 +1,70 @@
+/// The replay clock shared by the interactive player and its continuity tests.
+public struct ReplayPlayback {
+    public let keyframeCount: Int
+    public private(set) var isPlaying = false
+    public private(set) var keyframe = 0
+    public private(set) var playhead: Float = 0
+    public private(set) var seekGeneration: UInt64 = 0
+    private var settled = false
+    private var lastTick: Double?
+    private var lastFrame: Double?
+    private var ambient: Float = 0
+    private var frameInterval: Float = 1 / 60
+
+    private var end: Float { Schedule.playbackEnd(count: keyframeCount) }
+
+    public init(keyframeCount: Int) {
+        precondition(keyframeCount > 0, "replay playback needs at least one keyframe")
+        self.keyframeCount = keyframeCount
+    }
+
+    public func frameRequest(mode: CaptureMode, reduceMotion: Bool, fog: FogStyle,
+                             scheme: DotScheme = .hologram) -> FrameRequest {
+        FrameRequest(
+            mode: mode, keyframe: keyframe, time: settled ? 1e5 : playhead,
+            reduceMotion: reduceMotion, fog: fog, scheme: scheme, ambientTime: ambient,
+            frameInterval: frameInterval, seekGeneration: seekGeneration)
+    }
+
+    public mutating func togglePlayback() {
+        if isPlaying {
+            isPlaying = false
+            return
+        }
+        if playhead >= end - 1e-3 || (keyframe == keyframeCount - 1 && settled) {
+            seek(to: 0, settle: false)
+        } else if settled {
+            // Births restart at the scrubbed keyframe's start, not at its settled preview time.
+            seekGeneration &+= 1
+        }
+        settled = false
+        lastTick = nil
+        isPlaying = true
+    }
+
+    public mutating func scrub(to index: Int) {
+        seek(to: index, settle: !isPlaying)
+    }
+
+    private mutating func seek(to index: Int, settle: Bool) {
+        keyframe = min(max(index, 0), keyframeCount - 1)
+        playhead = Schedule.start(of: keyframe)
+        settled = settle
+        seekGeneration &+= 1
+        lastTick = nil
+    }
+
+    public mutating func tick(now: Double) {
+        if let lastFrame { frameInterval = min(Float(now - lastFrame), 0.1) }
+        lastFrame = now
+        ambient += frameInterval
+        guard isPlaying else { return }
+        if let lastTick { playhead += Float(now - lastTick) }
+        lastTick = now
+        keyframe = Schedule.keyframe(at: playhead, count: keyframeCount)
+        if playhead >= end {
+            playhead = end
+            isPlaying = false
+        }
+    }
+}
diff --git a/experiments/live-dots/Tests/LiveDotsCoreTests/ReplayPlaybackTests.swift b/experiments/live-dots/Tests/LiveDotsCoreTests/ReplayPlaybackTests.swift
new file mode 100644
index 000000000..9cd737469
--- /dev/null
+++ b/experiments/live-dots/Tests/LiveDotsCoreTests/ReplayPlaybackTests.swift
@@ -0,0 +1,144 @@
+import Testing
+@testable import LiveDotsCore
+
+struct ReplayPlaybackTests {
+    private func request(_ playback: ReplayPlayback, reduceMotion: Bool = false) -> FrameRequest {
+        playback.frameRequest(mode: .lidar, reduceMotion: reduceMotion, fog: .on)
+    }
+
+    @Test func `a seek within the playing keyframe resets the fog once`() {
+        var playback = ReplayPlayback(keyframeCount: 10)
+        var continuity = FogContinuity()
+        playback.togglePlayback()
+        playback.tick(now: 0)
+        #expect(continuity.consume(request(playback)))
+        playback.tick(now: 0.2)
+        let before = request(playback)
+        #expect(!continuity.consume(before))
+        playback.scrub(to: 0)
+        let after = request(playback)
+        #expect(after.keyframe == before.keyframe)
+        #expect(after.time == 0 && !after.isSettled)
+        #expect(after.seekGeneration == before.seekGeneration + 1)
+        #expect(continuity.consume(after))
+        playback.tick(now: 0.3)
+        #expect(!continuity.consume(request(playback)))
+    }
+
+    @Test func `natural playback eases across same and adjacent frames but explicit seeks reset`() {
+        var playback = ReplayPlayback(keyframeCount: 10)
+        var continuity = FogContinuity()
+        playback.togglePlayback()
+        playback.tick(now: 0)
+        #expect(continuity.consume(request(playback)))
+        playback.tick(now: 0.1)
+        #expect(!continuity.consume(request(playback)))
+        playback.tick(now: 0.3)
+        #expect(playback.keyframe == 1)
+        #expect(!continuity.consume(request(playback)))
+        playback.scrub(to: 2)
+        #expect(continuity.consume(request(playback)))
+        playback.scrub(to: 1)
+        #expect(continuity.consume(request(playback)))
+    }
+
+    @Test(arguments: [false, true]) func `resuming a settled scrub resets at the birth time`(reduceMotion: Bool) {
+        var playback = ReplayPlayback(keyframeCount: 10)
+        var continuity = FogContinuity()
+        playback.scrub(to: 2)
+        let preview = request(playback, reduceMotion: reduceMotion)
+        #expect(preview.isSettled)
+        #expect(continuity.consume(preview))
+        playback.togglePlayback()
+        let resumed = request(playback, reduceMotion: reduceMotion)
+        #expect(resumed.time == Schedule.start(of: 2) && !resumed.isSettled)
+        #expect(resumed.seekGeneration == preview.seekGeneration + 1)
+        #expect(resumed.reduceMotion == reduceMotion)
+        #expect(continuity.consume(resumed))
+        #expect(!continuity.consume(resumed))
+    }
+
+    @Test func `scrub and resume between rendered frames still invalidate the old mask`() {
+        var playback = ReplayPlayback(keyframeCount: 10)
+        var continuity = FogContinuity()
+        playback.togglePlayback()
+        playback.tick(now: 0)
+        #expect(continuity.consume(request(playback)))
+        playback.tick(now: 0.2)
+        #expect(!continuity.consume(request(playback)))
+        playback.togglePlayback()
+        playback.scrub(to: 0)
+        playback.togglePlayback()
+        #expect(continuity.consume(request(playback)))
+    }
+
+    @Test func `pause and resume without a scrub preserve the playhead and fog easing`() {
+        var playback = ReplayPlayback(keyframeCount: 10)
+        var continuity = FogContinuity()
+        playback.togglePlayback()
+        playback.tick(now: 0)
+        #expect(continuity.consume(request(playback)))
+        playback.tick(now: 0.2)
+        let before = request(playback)
+        #expect(!continuity.consume(before))
+        playback.togglePlayback()
+        playback.tick(now: 5)
+        playback.togglePlayback()
+        playback.tick(now: 10)
+        let resumed = request(playback)
+        #expect(resumed.time == before.time)
+        #expect(resumed.seekGeneration == before.seekGeneration)
+        #expect(!continuity.consume(resumed))
+        playback.tick(now: 10.02)
+        #expect(abs(playback.playhead - before.time - 0.02) < 1e-5)
+    }
+
+    @Test func `restarting completed playback seeks to the first frame`() {
+        var playback = ReplayPlayback(keyframeCount: 3)
+        var continuity = FogContinuity()
+        playback.togglePlayback()
+        playback.tick(now: 0)
+        playback.tick(now: 10)
+        #expect(!playback.isPlaying)
+        let final = request(playback)
+        #expect(continuity.consume(final))
+        playback.togglePlayback()
+        let restarted = request(playback)
+        #expect(restarted.keyframe == 0 && restarted.time == 0)
+        #expect(restarted.seekGeneration == final.seekGeneration + 1)
+        #expect(continuity.consume(restarted))
+    }
+
+    @Test func `mode changes fog reentry and settled previews invalidate continuity`() {
+        var playback = ReplayPlayback(keyframeCount: 10)
+        var continuity = FogContinuity()
+        playback.togglePlayback()
+        var frame = request(playback)
+        #expect(continuity.consume(frame))
+        #expect(!continuity.consume(frame))
+        frame.mode = .noLidar
+        #expect(continuity.consume(frame))
+        #expect(!continuity.consume(frame))
+        frame.fog = .off
+        #expect(!continuity.consume(frame))
+        frame.fog = .on
+        #expect(continuity.consume(frame))
+        frame.time = 1e5
+        #expect(continuity.consume(frame))
+        frame.time = 0
+        #expect(continuity.consume(frame))
+        #expect(!continuity.consume(frame))
+    }
+
+    @Test func `offscreen clock rewinds and nonadjacent jumps reset without a player`() {
+        var continuity = FogContinuity()
+        var frame = FrameRequest(mode: .lidar, keyframe: 0, time: 0.2, reduceMotion: false, fog: .on)
+        #expect(continuity.consume(frame))
+        frame.time = 0.1
+        #expect(continuity.consume(frame))
+        frame.keyframe = 3
+        frame.time = Schedule.start(of: 3)
+        #expect(continuity.consume(frame))
+        #expect(!continuity.consume(frame))
+    }
+}
diff --git a/experiments/research-handoff/native-proposals/README.md b/experiments/research-handoff/native-proposals/README.md
index 3c28129b5..0b358d004 100644
--- a/experiments/research-handoff/native-proposals/README.md
+++ b/experiments/research-handoff/native-proposals/README.md
@@ -13,7 +13,7 @@ One Swift 6 host build and one run exercised nine paired cases: **18 observation
 
 The ground helper proposes synchronous recomputation from a caller-qualified camera ledger in original acceptance order, including observations whose original delta was zero. It retains latent skip flags and marked-end coordinates, discards photographic row state, replays existing geometry methods, and advances revision from the prior map. Unchanged samples and meter-y-only updates preserve current evidence/revision. Changed horizontal geometry, nonfinite heights or a nonzero residual cell shift are refused without mutation.
 
-**The ground helper is not a complete geometry fix.** Ordinary anchor refinement can leave a residual shift and prevent its use. Carrying that residual into freshly projected evidence, or dropping it while retaining rounded skip cells, would mix coordinate histories. Caller ledger admission, world/session provenance, refusal handling, coherent UI publication and export snapshot integration remain unresolved. This helper does not implement them. It also loses evidence across a marked end. `observe` skips cells past a marked end, so replaying cameras recorded before the end was marked drops what they saw beyond it, and `clearEnd` replays nothing to bring it back. A fix needs each observation's admission-time ends in the caller's ledger, or a replay when an end is cleared; the patch does neither ([review](https://github.com/SamGu-NRX/BaseScanning/pull/18#discussion_r4111600380)). Alpha's own `CoverageMap.replayObservedCameras` and `clearEnd` behave the same way. Nine source-prepared controls cover fresh-map equivalence, useful zero-delta observations, order dependence, latent skips/bounds and revision collisions; none was compiled or run. It makes no physical-accuracy, occlusion or phone-performance claim.
+**The ground helper is not a complete geometry fix.** Ordinary anchor refinement can leave a residual shift and prevent its use. Carrying that residual into freshly projected evidence, or dropping it while retaining rounded skip cells, would mix coordinate histories. Caller ledger admission, world/session provenance, refusal handling, coherent UI publication and export snapshot integration remain unresolved. This helper does not implement them. It also loses evidence across a marked end. `observe` skips cells past a marked end, so replaying cameras recorded before the end was marked drops what they saw beyond it, and `clearEnd` replays nothing to bring it back. A fix needs each observation's admission-time ends in the caller's ledger, or a replay when an end is cleared; the patch does neither ([review](https://github.com/SamGu-NRX/BaseScanning/pull/18#discussion_r4111600380)). Alpha's `CoverageMap.replayObservedCameras` also loses regular wall and ground sightings past a marked end. When clearing a limit end, Alpha's `clearEnd` calls `replayPastLimits()` to rebuild past-limit ground state, but it does not replay those regular sightings to restore them. Nine source-prepared controls cover fresh-map equivalence, useful zero-delta observations, order dependence, latent skips/bounds and revision collisions; none was compiled or run. It makes no physical-accuracy, occlusion or phone-performance claim.
 
 To check applicability later, use a separate checkout already at the exact baseline and inspect the output of `git rev-parse HEAD` first. These commands only check whether the patches apply; they do not apply them:
 
diff --git a/recon/recon/coverage.py b/recon/recon/coverage.py
index ab894365f..cc83b68ad 100644
--- a/recon/recon/coverage.py
+++ b/recon/recon/coverage.py
@@ -124,25 +124,20 @@ class SeenFromTwo:
 
     The volume's weight alone says only that some frame's ray reached a voxel, so one view could
     vouch for a clearance; wall and ground already need two positions, and so does free space.
-    Frames are stacked so each query is one pass over all of them."""
+    Queries project one frame at a time in bounded point batches, without copying the depth maps."""
 
     def __init__(self, vol: Volume, frames: list[Frame], depths: dict[str, Depth]):
         self.vol, self.voxel = vol, vol.voxel
         self.centres = np.array([f.center for f in frames]).reshape(-1, 3)
-        # free_space asks once per slab, thousands of times, about the same frames.
+        # Camera separation and partner masks stay the same across every slab batch.
         self.far = far_pairs(self.centres)
         T = np.array([f.cam_to_world for f in frames]).reshape(-1, 4, 4)
         self.R, self.C = T[:, :3, :3], T[:, :3, 3]
         self.K = np.array([f.intrinsics for f in frames], float).reshape(-1, 4)
         self.size = np.array([(f.width, f.height) for f in frames], float).reshape(-1, 2)
-        self.groups: list[tuple[np.ndarray, np.ndarray, np.ndarray]] = []
-        by_shape: dict[tuple[int, int], list[int]] = {}
-        for j, f in enumerate(frames):
-            by_shape.setdefault(depths[f.id].depth.shape, []).append(j)
-        for idx in by_shape.values():
-            stack = np.stack([depths[frames[j].id].depth for j in idx])
-            scale = stack.shape[2] / self.size[idx, 0]
-            self.groups.append((np.array(idx), stack, scale))
+        self.depths = [depths[f.id].depth for f in frames]
+        self.partner_bits = np.packbits(self.far.astype(bool), axis=1)
+        self.partner_frames = np.flatnonzero(self.partner_bits.any(axis=1))
 
     def occupied(self, points: np.ndarray) -> np.ndarray:
         return self.vol.occupied(points)
@@ -150,33 +145,68 @@ def occupied(self, points: np.ndarray) -> np.ndarray:
     def seen_through(self, points: np.ndarray) -> np.ndarray:
         """(N, frames) bool: frame j's ray reached point i."""
         out = np.zeros((len(points), len(self.C)), bool)
-        for idx, stack, scale in self.groups:
-            d = points[None] - self.C[idx, None]  # (F, N, 3)
-            dist = np.linalg.norm(d, axis=2)
-            p = np.einsum("fnk,fkc->fnc", d, self.R[idx])  # camera axes, as in seen_by
-            z = -p[..., 2]
-            fx, fy, cx, cy = (self.K[idx, k, None] for k in range(4))
-            w, h = self.size[idx, 0, None], self.size[idx, 1, None]
+        for j, depth_map in enumerate(self.depths):
+            d = points - self.C[j]
+            dist = np.linalg.norm(d, axis=1)
+            p = d @ self.R[j]  # camera axes, as in seen_by
+            z = -p[:, 2]
+            fx, fy, cx, cy = self.K[j]
+            w, h = self.size[j]
             with np.errstate(divide="ignore", invalid="ignore"):
-                u = cx + fx * p[..., 0] / z
-                v = cy - fy * p[..., 1] / z
+                u = cx + fx * p[:, 0] / z
+                v = cy - fy * p[:, 1] / z
             ok = (dist > 0.1) & (dist <= MAX_RANGE_M) & (z > 0.05)
             ok &= (u >= w * IMAGE_MARGIN) & (u <= w * (1 - IMAGE_MARGIN))
             ok &= (v >= h * IMAGE_MARGIN) & (v <= h * (1 - IMAGE_MARGIN))
-            dh, dw = stack.shape[1:]
-            f_i, n_i = np.nonzero(ok)
-            du = np.clip((u[f_i, n_i] * scale[f_i]).astype(np.int64), 0, dw - 1)
-            dv = np.clip((v[f_i, n_i] * scale[f_i]).astype(np.int64), 0, dh - 1)
-            measured = stack[f_i, dv, du]
-            reached = np.isfinite(measured) & (measured >= z[f_i, n_i] - tolerance(dist[f_i, n_i]))
-            out[n_i[reached], idx[f_i[reached]]] = True
+            n_i = np.flatnonzero(ok)
+            dh, dw = depth_map.shape
+            scale = dw / w
+            du = np.clip((u[n_i] * scale).astype(np.int64), 0, dw - 1)
+            dv = np.clip((v[n_i] * scale).astype(np.int64), 0, dh - 1)
+            measured = depth_map[dv, du]
+            reached = np.isfinite(measured) & (measured >= z[n_i] - tolerance(dist[n_i]))
+            out[n_i[reached], j] = True
+
         return out
 
     def observed(self, points: np.ndarray) -> np.ndarray:
         seen = self.vol.observed(points)
-        if not seen.any():
-            return seen
-        return seen & two_positions(self.seen_through(points), self.centres, self.far)
+        if not seen.any() or not len(self.partner_frames):
+            return np.zeros_like(seen)
+        result = np.zeros_like(seen)
+        indices = np.flatnonzero(seen)
+        chunk = min(VIEW_POINTS_PER_BATCH, max(1, VIEW_SAMPLES_PER_BATCH // len(self.C)))
+        for start in range(0, len(indices), chunk):
+            idx = indices[start : start + chunk]
+            result[idx] = _two_positions_packed(
+                self.seen_through(points[idx]), self.partner_bits, self.partner_frames
+            )
+        return result
+
+
+# Bound each visibility matrix to 1 MiB and each per-frame projection to 4096 points, even when
+# a caller passes all points along a long wall. These are allocation limits, not measured tuning.
+VIEW_SAMPLES_PER_BATCH = 2**20
+VIEW_POINTS_PER_BATCH = 4096
+
+
+def _two_positions_packed(
+    saw: np.ndarray, partners: np.ndarray, partner_frames: np.ndarray | None = None
+) -> np.ndarray:
+    """Exact two-view test using packed partner masks instead of N x F by F x F multiplication.
+    A row stops once one visible frame has another visible, sufficiently separated partner."""
+    packed = np.packbits(saw, axis=1)
+    result = np.zeros(len(saw), bool)
+    eligible = np.count_nonzero(saw, axis=1) >= 2
+    if partner_frames is None:
+        partner_frames = np.flatnonzero(partners.any(axis=1))
+    for j in partner_frames:
+        idx = np.flatnonzero(eligible & ~result & saw[:, j])
+        if len(idx):
+            result[idx] = (packed[idx] & partners[j]).any(axis=1)
+        if np.all(result | ~eligible):
+            break
+    return result
 
 
 def face_offsets(wall: WallFrame, mesh: Mesh, cells: np.ndarray) -> np.ndarray:
@@ -281,7 +311,24 @@ def wall_front(wall: WallFrame, vol: Volume, across: np.ndarray) -> float:
     return front + vol.voxel
 
 
-def free_space(wall: WallFrame, vol: Volume, cells: np.ndarray):
+# At 5 cm voxels a facing batch has 3 x 31 x 16 = 1488 points, below the projection limit.
+# Keep short marches bounded too: a failed slab evaluates at most the rest of its 16-step batch.
+SLABS_PER_BATCH = 16
+
+
+def _slabs(wall: WallFrame, vol, across, heights, outs, *, axis: int):
+    """Occupied and observed flags per facing step (axis=2) or overhead step (axis=1)."""
+    if axis not in (1, 2):
+        raise ValueError("slab axis must be height (1) or outward distance (2)")
+    S, Hh, Oo = np.meshgrid(across, heights, outs, indexing="ij")
+    points = wall.world(S, Hh, Oo).reshape(-1, 3)
+    reduce = (0, 1) if axis == 2 else (0, 2)
+    occupied = vol.occupied(points).reshape(S.shape).any(axis=reduce)
+    seen = vol.observed(points).reshape(S.shape).all(axis=reduce)
+    return occupied, seen
+
+
+def free_space(wall: WallFrame, vol: Volume | SeenFromTwo, cells: np.ndarray):
     """Per cell: (facing gap or NaN, facing clear, overhead clearance or NaN, overhead clear).
     The facing gap and clear distance are measured out from the wall's reconstructed front, not
     from the fitted plane: in front of a pilaster 0.3 m proud, something 1.3 m out of the plane
@@ -294,27 +341,45 @@ def free_space(wall: WallFrame, vol: Volume, cells: np.ndarray):
     facing_gap, facing_clear = np.full(n, np.nan), np.zeros(n)
     over_gap, over_clear = np.full(n, np.nan), np.zeros(n)
     fh = np.arange(FACING_BAND_M[0], FACING_BAND_M[1] + 1e-9, step)
+    raw = vol.vol if isinstance(vol, SeenFromTwo) else vol
     for c in range(n):
         across = cells[c] + CELL_M * np.array([0.25, 0.5, 0.75])
-        front = wall_front(wall, vol, across)
-        for out in np.arange(front + step, front + FACING_MAX_M, step):
-            share, seen = _slab(wall, vol, across, fh, [out])
-            # Any reconstructed occupied voxel stops clearance, including one-step thin rails.
-            if share > 0:
-                facing_gap[c] = max(0.0, out - step - front)
-                break
-            if not seen:
+        front = wall_front(wall, raw, across)
+        outs = np.arange(front + step, front + FACING_MAX_M, step)
+        for start in range(0, len(outs), SLABS_PER_BATCH):
+            chunk = outs[start : start + SLABS_PER_BATCH]
+            occupied, seen = _slabs(wall, vol, across, fh, chunk, axis=2)
+            stopped = False
+            for out, hit, observed in zip(chunk, occupied, seen, strict=True):
+                # Any occupied sampled voxel stops clearance, including one-step thin rails.
+                if hit:
+                    facing_gap[c] = max(0.0, out - step - front)
+                    stopped = True
+                    break
+                if not observed:
+                    stopped = True
+                    break
+                facing_clear[c] = out - front
+            if stopped:
                 break
-            facing_clear[c] = out - front
         oo = front + np.arange(OVERHEAD_OUT_M[0], OVERHEAD_OUT_M[1] + 1e-9, step)
-        for h in np.arange(0.3, OVERHEAD_MAX_M, step):
-            share, seen = _slab(wall, vol, across, [h], oo)
-            if share > 0:
-                over_gap[c] = max(0.0, h - step)
+        heights = np.arange(0.3, OVERHEAD_MAX_M, step)
+        for start in range(0, len(heights), SLABS_PER_BATCH):
+            chunk = heights[start : start + SLABS_PER_BATCH]
+            occupied, seen = _slabs(wall, vol, across, chunk, oo, axis=1)
+            stopped = False
+            for h, hit, observed in zip(chunk, occupied, seen, strict=True):
+                if hit:
+                    over_gap[c] = max(0.0, h - step)
+                    stopped = True
+                    break
+                if not observed:
+                    stopped = True
+                    break
+                over_clear[c] = h
+            if stopped:
                 break
-            if not seen:
-                break
-            over_clear[c] = h
+
     return facing_gap, facing_clear, over_gap, over_clear
 
 
diff --git a/recon/tests/test_coverage_batches.py b/recon/tests/test_coverage_batches.py
new file mode 100644
index 000000000..c776f0533
--- /dev/null
+++ b/recon/tests/test_coverage_batches.py
@@ -0,0 +1,142 @@
+"""Compare the batched march with individual slab queries and count repeated work."""
+
+from dataclasses import replace
+
+import numpy as np
+import pytest
+from test_coverage_views import views
+from test_worker import _slab_volume
+
+from recon import coverage
+from recon.geometry import WallFrame
+
+WALL = WallFrame(
+    np.array([0.0, 1.0, 0.0]), np.array([1.0, 0, 0]), np.array([0, 0, 1.0]), 0.0, (0, 0.3)
+)
+
+
+def scalar_march(wall, volume, cells):
+    step = volume.voxel
+    raw = volume.vol if isinstance(volume, coverage.SeenFromTwo) else volume
+    arrays = [
+        np.full(len(cells), np.nan),
+        np.zeros(len(cells)),
+        np.full(len(cells), np.nan),
+        np.zeros(len(cells)),
+    ]
+    fg, fc, og, oc = arrays
+    heights = np.arange(coverage.FACING_BAND_M[0], coverage.FACING_BAND_M[1] + 1e-9, step)
+    for c, cell in enumerate(cells):
+        across = cell + coverage.CELL_M * np.array([0.25, 0.5, 0.75])
+        front = coverage.wall_front(wall, raw, across)
+        for out in np.arange(front + step, front + coverage.FACING_MAX_M, step):
+            share, seen = coverage._slab(wall, volume, across, heights, [out])
+            if share > 0:
+                fg[c] = max(0, out - step - front)
+                break
+            if not seen:
+                break
+            fc[c] = out - front
+        outs = front + np.arange(
+            coverage.OVERHEAD_OUT_M[0], coverage.OVERHEAD_OUT_M[1] + 1e-9, step
+        )
+        for height in np.arange(0.3, coverage.OVERHEAD_MAX_M, step):
+            share, seen = coverage._slab(wall, volume, across, [height], outs)
+            if share > 0:
+                og[c] = max(0, height - step)
+                break
+            if not seen:
+                break
+            oc[c] = height
+    return arrays
+
+
+@pytest.mark.parametrize("use_views", [False, True])
+@pytest.mark.parametrize("kind", ["clear", "proud", "thin", "unknown"])
+def test_batched_march_matches_scalar_stop_order(kind, use_views):
+    occupied = [(-0.3, 0.3), (1.3, 1.7)] if kind == "proud" else [(-0.3, 0.0)]
+    raw = _slab_volume(occupied, 1.1 if kind == "unknown" else 7.0)
+    if kind == "thin":
+        raw.tsdf[:, 20, 30] = -1.0
+        raw.tsdf[:, 30, 16] = -1.0
+    if use_views:
+        frames, depths = views(7)
+        volume = coverage.SeenFromTwo(raw, frames, depths)
+    else:
+        volume = raw
+    cells = np.array([0.0, coverage.CELL_M])
+    actual = coverage.free_space(WALL, volume, cells)
+    expected = scalar_march(WALL, volume, cells)
+    for a, b in zip(actual, expected, strict=True):
+        np.testing.assert_array_equal(a, b)
+
+
+def test_wall_front_gets_raw_volume_and_uses_no_visibility(monkeypatch):
+    raw = _slab_volume([(-0.3, 0.0)], 7.0)
+    frames, depths = views(2)
+    view = coverage.SeenFromTwo(raw, frames, depths)
+    calls = []
+    real_front = coverage.wall_front
+
+    def wall_front(wall, volume, across):
+        assert volume is raw
+        calls.append(len(across))
+        return real_front(wall, volume, across)
+
+    monkeypatch.setattr(coverage, "wall_front", wall_front)
+    coverage.free_space(WALL, view, np.array([0.0, coverage.CELL_M]))
+    assert calls == [3, 3]
+
+
+def test_clear_march_batches_queries_and_builds_pairs_once(monkeypatch):
+    raw = _slab_volume([(-0.3, 0.0)], 7.0)
+    frames, depths = views(9)
+    real_far = coverage.far_pairs
+    pair_calls, query_sizes = [], []
+
+    def far(centres):
+        pair_calls.append(len(centres))
+        return real_far(centres)
+
+    monkeypatch.setattr(coverage, "far_pairs", far)
+    view = coverage.SeenFromTwo(raw, frames, depths)
+
+    def seen(points):
+        query_sizes.append(len(points))
+        return np.ones((len(points), len(frames)), bool)
+
+    monkeypatch.setattr(view, "seen_through", seen)
+    monkeypatch.setattr(coverage, "two_positions", lambda *_: pytest.fail("dense pair multiply"))
+    cells = np.array([0.0, coverage.CELL_M])
+    coverage.free_space(WALL, view, cells)
+    facing_steps = len(np.arange(0.10, 0.05 + coverage.FACING_MAX_M, raw.voxel))
+    overhead_steps = len(np.arange(0.3, coverage.OVERHEAD_MAX_M, raw.voxel))
+    expected_calls = len(cells) * (
+        int(np.ceil(facing_steps / coverage.SLABS_PER_BATCH))
+        + int(np.ceil(overhead_steps / coverage.SLABS_PER_BATCH))
+    )
+    assert pair_calls == [len(frames)]
+    assert len(query_sizes) == expected_calls == 24
+    assert len(query_sizes) < (facing_steps + overhead_steps) * len(cells) // 10
+    assert max(query_sizes) <= coverage.VIEW_POINTS_PER_BATCH
+
+
+def test_compute_retains_ground_and_complete_cells_after_combining_prs(monkeypatch):
+    raw = _slab_volume([], 7.0)
+    frames, depths = views(2)
+    wall = replace(WALL, s_range=(0.9 * coverage.CELL_M, 2.1 * coverage.CELL_M))
+    ground = object()
+
+    def wall_and_ground(wall, frames, depths, volume, mesh, cells, fitted_ground):
+        assert fitted_ground is ground
+        np.testing.assert_allclose(cells, [coverage.CELL_M])
+        return np.zeros(len(cells), bool), np.zeros(len(cells)), np.zeros(len(cells))
+
+    monkeypatch.setattr(coverage, "wall_and_ground", wall_and_ground)
+    result = coverage.compute(wall, frames, depths, raw, None, ground)
+    np.testing.assert_allclose(result.cells, [coverage.CELL_M])
+
+
+def test_slab_batch_refuses_an_unsupported_march_axis():
+    with pytest.raises(ValueError, match="slab axis must be height"):
+        coverage._slabs(WALL, None, [0], [0], [0], axis=0)
diff --git a/recon/tests/test_coverage_views.py b/recon/tests/test_coverage_views.py
new file mode 100644
index 000000000..cace017df
--- /dev/null
+++ b/recon/tests/test_coverage_views.py
@@ -0,0 +1,119 @@
+"""Exact visibility and camera-pair checks across batching limits."""
+
+from pathlib import Path
+
+import numpy as np
+import pytest
+
+from recon import coverage
+from recon.capture import Frame
+from recon.depth import Depth
+
+
+class ClearVolume:
+    voxel = 0.05
+
+    def observed(self, points):
+        return np.ones(len(points), bool)
+
+    def occupied(self, points):
+        return np.zeros(len(points), bool)
+
+
+def views(count):
+    frames, depths = [], {}
+    for j in range(count):
+        pose = np.eye(4)
+        pose[:3, 3] = [j * 0.13 - 0.3, 1.0, 4.0]
+        angle = (j % 3 - 1) * 0.08
+        c, s = np.cos(angle), np.sin(angle)
+        pose[:3, :3] = [[c, 0, s], [0, 1, 0], [-s, 0, c]]
+        frame = Frame(str(j), Path("unused"), 64, 48, np.array([24, 24, 32, 24]), pose)
+        frames.append(frame)
+        shape = (24, 32) if j % 2 else (48, 64)
+        values = np.full(shape, 4.0, np.float32)
+        values[: shape[0] // 3, : shape[1] // 3] = np.nan
+        depths[frame.id] = Depth(values, frame.intrinsics, np.zeros((*shape, 3)), "lidar")
+    return frames, depths
+
+
+def scalar_visible(points, frames, depths):
+    result = np.zeros((len(points), len(frames)), bool)
+    for i, point in enumerate(points):
+        for j, frame in enumerate(frames):
+            delta = point - frame.center
+            distance = np.linalg.norm(delta)
+            if not 0.1 < distance <= coverage.MAX_RANGE_M:
+                continue
+            p = delta @ frame.cam_to_world[:3, :3]
+            z = -p[2]
+            if z <= 0.05:
+                continue
+            fx, fy, cx, cy = frame.intrinsics
+            u, v = cx + fx * p[0] / z, cy - fy * p[1] / z
+            margin = coverage.IMAGE_MARGIN
+            if not frame.width * margin <= u <= frame.width * (1 - margin):
+                continue
+            if not frame.height * margin <= v <= frame.height * (1 - margin):
+                continue
+            values = depths[frame.id].depth
+            h, w = values.shape
+            scale = w / frame.width
+            value = values[min(int(v * scale), h - 1), min(int(u * scale), w - 1)]
+            result[i, j] = np.isfinite(value) and value >= z - coverage.tolerance(distance)
+    return result
+
+
+@pytest.mark.parametrize("frames", [0, 1, 2, 7, 9, 33, 65])
+def test_packed_pair_test_matches_dense_relation(frames):
+    rng = np.random.default_rng(40 + frames)
+    centres = rng.normal(0, 0.2, (frames, 3))
+    saw = rng.random((113, frames)) > 0.45
+    far = coverage.far_pairs(centres)
+    expected = coverage.two_positions(saw, centres, far)
+    actual = coverage._two_positions_packed(saw, np.packbits(far.astype(bool), axis=1))
+    np.testing.assert_array_equal(actual, expected)
+
+
+def test_pair_test_does_not_require_first_view_to_have_a_far_partner():
+    centres = np.array([[0, 0, 0], [-0.2, 0, 0], [0.2, 0, 0]])
+    saw = np.array([[True, True, True], [True, True, False]])
+    partners = np.packbits(coverage.far_pairs(centres).astype(bool), axis=1)
+    np.testing.assert_array_equal(coverage._two_positions_packed(saw, partners), [True, False])
+
+
+def test_batched_projection_matches_independent_scalar_visibility():
+    frames, depths = views(9)
+    view = coverage.SeenFromTwo(ClearVolume(), frames, depths)
+    points = np.random.default_rng(5).uniform([-2, -1, -1], [3, 3, 5], (137, 3))
+    expected = scalar_visible(points, frames, depths)
+    np.testing.assert_array_equal(view.seen_through(points), expected)
+    np.testing.assert_array_equal(view.observed(points), coverage.two_positions(expected, view.C))
+    assert all(a is depths[f.id].depth for a, f in zip(view.depths, frames, strict=True))
+
+
+def test_projection_queries_and_matrix_memory_are_bounded(monkeypatch):
+    frames, depths = views(129)
+    view = coverage.SeenFromTwo(ClearVolume(), frames, depths)
+    monkeypatch.setattr(coverage, "VIEW_POINTS_PER_BATCH", 64)
+    monkeypatch.setattr(coverage, "VIEW_SAMPLES_PER_BATCH", 1032)
+    sizes = []
+
+    def seen(points):
+        sizes.append(len(points))
+        return np.ones((len(points), len(frames)), bool)
+
+    monkeypatch.setattr(view, "seen_through", seen)
+    points = np.zeros((257, 3))
+    assert view.observed(points).all()
+    assert len(sizes) == 33 and max(sizes) == 8
+    assert max(sizes) * len(frames) <= coverage.VIEW_SAMPLES_PER_BATCH
+
+
+def test_one_view_or_one_position_never_claims_free_space():
+    for count in (0, 1, 3):
+        frames, depths = views(count)
+        for frame in frames:
+            frame.cam_to_world[:3, 3] = [0, 1, 4]
+        view = coverage.SeenFromTwo(ClearVolume(), frames, depths)
+        assert not view.observed(np.array([[0, 1, 1]])).any()
diff --git a/recon/tests/test_review_debt.py b/recon/tests/test_review_debt.py
index e1c951e3a..d39f8b60b 100644
--- a/recon/tests/test_review_debt.py
+++ b/recon/tests/test_review_debt.py
@@ -61,6 +61,8 @@ def test_export_observations_refuses_contract_overflow_without_slicing(monkeypat
 def test_coverage_exports_only_cells_inside_fitted_extent(monkeypatch):
     wall, frames, depths, vol, surface, _ = _all_visible_setup()
     monkeypatch.setattr(coverage, "seen_by", lambda points, *_: np.ones((len(points), 2), bool))
+    # This test isolates cell bounds; the two-view wrapper has separate real-depth regressions.
+    monkeypatch.setattr(coverage, "SeenFromTwo", lambda vol, frames, depths: vol)
     monkeypatch.setattr(
         coverage, "free_space", lambda wall, vol, cells: (np.zeros(len(cells)),) * 4
     )
diff --git a/verification/hsverify/e2e.py b/verification/hsverify/e2e.py
index 75aa15952..fcc5be863 100644
--- a/verification/hsverify/e2e.py
+++ b/verification/hsverify/e2e.py
@@ -45,6 +45,7 @@
 import re
 import signal
 import socket
+import ssl
 import subprocess
 import sys
 import threading
@@ -376,8 +377,8 @@ def post(
     Status None means no complete answer, and the payload then says why: the deadline passed,
     the body ran past MAX_RESPONSE_BYTES, it ended short of its Content-Length or chunk framing,
     or the connection failed. A socket timeout alone bounds
-    each read, not the response, so a server trickling bytes would never trip it; a timer shuts
-    the socket down at the deadline instead, which wakes any read in progress."""
+    each read, not the response. A bounded worker wait covers DNS as well as TCP, TLS, headers
+    and body; deadline expiry shuts down sockets already owned by the worker."""
     if item.bundle is not None and endpoint.accepts_zip:
         body, ctype = item.bundle, "application/zip"
     elif endpoint.content_type == "application/json":
@@ -395,57 +396,108 @@ def post(
         ctype = f"multipart/form-data; boundary={boundary}"
     target = urllib.parse.urlsplit(url + endpoint.path)
     https = target.scheme == "https"
-    conn = (http.client.HTTPSConnection if https else http.client.HTTPConnection)(
-        target.netloc, timeout=timeout_s
+    conn = http.client.HTTPConnection(
+        target.hostname, port=target.port or (443 if https else 80), timeout=timeout_s
     )
+    start = time.perf_counter()
+    deadline = start + timeout_s
     expired = threading.Event()
-    # Held here, not read from conn.sock: http.client drops that once the headers say the
-    # connection will close, while the body is still being read from the same socket.
+    done = threading.Event()
+    lock = threading.Lock()
     sockets: list[socket.socket] = []
+    answer: list[tuple[int | None, bytes]] = []
 
-    def expire() -> None:
-        expired.set()
-        for sock in sockets:
-            with contextlib.suppress(OSError):
-                sock.shutdown(socket.SHUT_RDWR)
-
-    timer = threading.Timer(timeout_s, expire)
-    timer.daemon = True
-    start = time.perf_counter()
-    timer.start()
-    status: int | None = None
-    payload = bytearray()
-    try:
-        conn.connect()
-        sockets.append(conn.sock)
-        if expired.is_set():  # the timer fired before there was a socket to shut down
+    def remaining() -> float:
+        left = deadline - time.perf_counter()
+        if expired.is_set() or left <= 0:
             raise TimeoutError
-        path = target.path + (f"?{target.query}" if target.query else "")
-        conn.request("POST", path, body=body, headers={"Content-Type": ctype})
-        response = conn.getresponse()
-        while len(payload) <= MAX_RESPONSE_BYTES and (chunk := response.read(READ_CHUNK_BYTES)):
-            payload += chunk
-        # read(amt) returns b"" when the server closes early, even short of Content-Length
-        # (http.client stays quiet there for compatibility), and `length` keeps what never came.
-        # A body cut short is not an answer, whatever its status says.
-        if len(payload) <= MAX_RESPONSE_BYTES and response.length:
-            raise http.client.IncompleteRead(bytes(payload), response.length)
-        status = response.status
-    except TimeoutError:
-        # One socket operation waited the whole timeout_s, so the deadline has passed too.
-        expired.set()
-    except (OSError, http.client.HTTPException) as exc:
-        status, payload = None, bytearray(f"{type(exc).__name__}: {exc}".encode())
-    finally:
-        timer.cancel()
-        conn.close()
+        return left
+
+    def expire() -> None:
+        with lock:
+            expired.set()
+            for sock in sockets:
+                with contextlib.suppress(OSError):
+                    sock.shutdown(socket.SHUT_RDWR)
+                sock.close()
+
+    def connect() -> None:
+        # getaddrinfo has no cancellable stdlib deadline. The daemon worker bounds the caller's
+        # wait; a late DNS result must check the deadline before allocating or sending anything.
+        addresses = socket.getaddrinfo(conn.host, conn.port, type=socket.SOCK_STREAM)
+        error = None
+        for family, kind, proto, _, address in addresses:
+            with lock:
+                remaining()
+                sock = socket.socket(family, kind, proto)
+                sockets.append(sock)  # own it before a blocking TCP connect or TLS handshake
+            try:
+                sock.settimeout(remaining())
+                sock.connect(address)
+                if https:
+                    context = ssl.create_default_context()
+                    with lock:
+                        remaining()
+                        sock = context.wrap_socket(
+                            sock, server_hostname=conn.host, do_handshake_on_connect=False
+                        )
+                        sockets.append(sock)
+                    sock.settimeout(remaining())
+                    sock.do_handshake()
+                sock.settimeout(remaining())
+                conn.sock = sock
+                return
+            except OSError as exc:
+                sock.close()
+                error = exc
+                remaining()
+        if error is not None:
+            raise error
+        raise OSError("DNS returned no connection addresses")
+
+    def exchange() -> None:
+        status: int | None = None
+        payload = bytearray()
+        try:
+            connect()
+            path = target.path + (f"?{target.query}" if target.query else "")
+            conn.sock.settimeout(remaining())
+            conn.request("POST", path, body=body, headers={"Content-Type": ctype})
+            conn.sock.settimeout(remaining())
+            response = conn.getresponse()
+            while len(payload) <= MAX_RESPONSE_BYTES and (chunk := response.read(READ_CHUNK_BYTES)):
+                remaining()
+                payload += chunk
+            if len(payload) <= MAX_RESPONSE_BYTES and response.length:
+                raise http.client.IncompleteRead(bytes(payload), response.length)
+            remaining()
+            status = response.status
+        except TimeoutError:
+            expired.set()
+        except (OSError, http.client.HTTPException) as exc:
+            status, payload = None, bytearray(f"{type(exc).__name__}: {exc}".encode())
+        finally:
+            conn.close()
+            with lock:
+                for sock in sockets:
+                    sock.close()
+            answer.append((status, bytes(payload)))
+            done.set()
+
+    # DNS may remain blocked after this returns. The worker is a daemon and owns no socket
+    # during DNS; once lookup returns, remaining() prevents a late request from being sent.
+    worker = threading.Thread(target=exchange, daemon=True)
+    worker.start()
+    if not done.wait(max(0.0, deadline - time.perf_counter())):
+        expire()
     ms = (time.perf_counter() - start) * 1000
-    if expired.is_set():
-        # A read cut short by the shutdown can look like a complete body; the deadline decides.
+    if expired.is_set() or time.perf_counter() >= deadline:
+        expire()
         return None, f"no answer within {timeout_s:g} s".encode(), ms
+    status, payload = answer[0]
     if len(payload) > MAX_RESPONSE_BYTES:
         return None, f"HTTP {status} body over {MAX_RESPONSE_BYTES} bytes".encode(), ms
-    return status, bytes(payload), ms
+    return status, payload, ms
 
 
 # --- Judging ---------------------------------------------------------------------------------
diff --git a/verification/hsverify/simrun.py b/verification/hsverify/simrun.py
index 15e2cd012..fb770a65c 100644
--- a/verification/hsverify/simrun.py
+++ b/verification/hsverify/simrun.py
@@ -340,11 +340,19 @@ def missing_required(required: list[str], states: list[ShotRecord]) -> list[str]
 def out_of_order(order: list[str], states: list[ShotRecord]) -> list[str]:
     """`order` must appear among the run's states in that order; other states may come between.
     Reaching the last one is not enough: a run that skips the steps before it did not walk them."""
-    names = iter(s.state for s in states)
-    for i, want in enumerate(order):
-        if want not in names:  # consumes `names` up to the match, so order is enforced
-            after = f"after {order[i - 1]}" if i else "at all"
-            return [f"required order {' > '.join(order)}: no {want} {after}"]
+    next_required = 0
+    closing = order[-1] if order else None
+    for record in states:
+        if next_required == len(order):
+            return []
+        if record.state == order[next_required]:
+            next_required += 1
+        elif record.state == closing:
+            return [f"required order {' > '.join(order)}: {closing} before {order[next_required]}"]
+    if next_required < len(order):
+        want = order[next_required]
+        after = f"after {order[next_required - 1]}" if next_required else "at all"
+        return [f"required order {' > '.join(order)}: no {want} {after}"]
     return []
 
 
diff --git a/verification/tests/test_build_scene.py b/verification/tests/test_build_scene.py
index 698ce5ab2..39ebcdabd 100644
--- a/verification/tests/test_build_scene.py
+++ b/verification/tests/test_build_scene.py
@@ -171,3 +171,19 @@ def within_wall(kf, w, point, walls):
     assert probes and all(0.0 <= p <= length for p in probes)
     assert spans == [[0.0, length]]
     assert entries[0]["span_ft"] == [0.0, length]
+
+
+def test_clipped_overhead_tail_retains_the_active_headroom():
+    points = []
+
+    def within_wall(kf, w, point, walls):
+        points.append(point)
+        return 0.0 <= point[0] <= 2.2
+
+    entries, spans = build_scene.band_coverage(
+        "overhead", [wall("w", 0.0, 2.2)], [], ["kf"], within_wall, headroom_ft=7.25
+    )
+    assert max(float(point[1]) for point in points) == 7.25
+    assert all(0.0 <= point[0] <= 2.2 for point in points)
+    assert entries == [{"band": "overhead", "span_ft": [0.0, 2.2], "out_ft": 7.25}]
+    assert spans == [[0.0, 2.2]]
diff --git a/verification/tests/test_e2e.py b/verification/tests/test_e2e.py
index df55b97d7..4a5bbd069 100644
--- a/verification/tests/test_e2e.py
+++ b/verification/tests/test_e2e.py
@@ -657,3 +657,167 @@ def check_hash(scene, result, sent=None, rules=None):
     )
     assert calls and all(raw == json.dumps(scene, indent=1).encode() for scene, raw in calls)
     assert any("stale input hash" in p for p in failures)
+
+
+def test_connection_and_handshake_share_one_remaining_budget(monkeypatch):
+    import socket
+    import ssl
+
+    clock = [0.0]
+    phases = []
+
+    class FakeSocket:
+        def settimeout(self, timeout):
+            phases.append(timeout)
+
+        def connect(self, address):
+            clock[0] += 0.6
+
+        def do_handshake(self):
+            assert phases[-1] == pytest.approx(0.4)
+            clock[0] += 0.5
+            raise TimeoutError
+
+        def close(self):
+            pass
+
+        def shutdown(self, how):
+            pass
+
+    sock = FakeSocket()
+
+    class Context:
+        def wrap_socket(self, raw, *, server_hostname, do_handshake_on_connect):
+            assert raw is sock and not do_handshake_on_connect
+            return sock
+
+    monkeypatch.setattr(e2e.time, "perf_counter", lambda: clock[0])
+    monkeypatch.setattr(
+        socket,
+        "getaddrinfo",
+        lambda *args, **kwargs: [(socket.AF_INET, socket.SOCK_STREAM, 0, "", ("127.0.0.1", 443))],
+    )
+    monkeypatch.setattr(socket, "socket", lambda *args: sock)
+    monkeypatch.setattr(ssl, "create_default_context", Context)
+    status, payload, ms = e2e.post(
+        "https://localhost", Endpoint("/p", "application/json"), item(), 1
+    )
+    assert status is None and payload == b"no answer within 1 s"
+    assert phases[:2] == pytest.approx([1.0, 0.4])
+    assert ms == pytest.approx(1100)
+
+
+@pytest.mark.parametrize("phase", ["dns", "tcp", "tls"])
+def test_deadline_bounds_blocked_connection_phase_and_cleans_worker(monkeypatch, phase):
+    import socket
+    import ssl
+
+    entered, release, exited, closed = (threading.Event() for _ in range(4))
+
+    def block():
+        entered.set()
+        assert release.wait(2)
+        raise TimeoutError
+
+    class FakeSocket:
+        def settimeout(self, timeout):
+            assert 0 < timeout <= 0.1
+
+        def connect(self, address):
+            if phase == "tcp":
+                block()
+
+        def do_handshake(self):
+            block()
+
+        def shutdown(self, how):
+            release.set()
+
+        def close(self):
+            closed.set()
+
+    sock = FakeSocket()
+
+    def lookup(*args, **kwargs):
+        if phase == "dns":
+            entered.set()
+            assert release.wait(2)
+        return [(socket.AF_INET, socket.SOCK_STREAM, 0, "", ("127.0.0.1", 443))]
+
+    class Context:
+        def wrap_socket(self, raw, **kwargs):
+            assert not kwargs["do_handshake_on_connect"]
+            return raw
+
+    original_thread = threading.Thread
+    workers = []
+
+    def thread(*args, target, **kwargs):
+        def run():
+            try:
+                target()
+            finally:
+                exited.set()
+
+        worker = original_thread(*args, target=run, **kwargs)
+        workers.append(worker)
+        return worker
+
+    monkeypatch.setattr(e2e.threading, "Thread", thread)
+    monkeypatch.setattr(socket, "getaddrinfo", lookup)
+    monkeypatch.setattr(socket, "socket", lambda *args: sock)
+    monkeypatch.setattr(ssl, "create_default_context", Context)
+    try:
+        status, payload, ms = e2e.post(
+            "https://localhost", Endpoint("/p", "application/json"), item(), 0.1
+        )
+        assert entered.is_set()
+        assert status is None and payload == b"no answer within 0.1 s"
+        assert 90 <= ms < 500
+        if phase != "dns":
+            assert closed.is_set()
+    finally:
+        release.set()
+        for worker in workers:
+            worker.join(2)
+        assert exited.is_set() and all(not w.is_alive() for w in workers)
+    if phase == "dns":
+        assert not closed.is_set()  # no socket can be allocated after late DNS completes
+
+
+def test_stalled_local_tls_handshake_ends_with_overall_deadline():
+    import socket
+
+    listener = socket.socket()
+    listener.bind(("127.0.0.1", 0))
+    listener.listen(1)
+    listener.settimeout(2)
+    stopped, accepted, disconnected = (threading.Event() for _ in range(3))
+
+    def peer():
+        with listener:
+            conn, _ = listener.accept()
+            with conn:
+                conn.settimeout(2)
+                accepted.set()
+                while conn.recv(4096):
+                    pass  # read ClientHello but never answer with ServerHello
+                disconnected.set()
+        stopped.set()
+
+    server = threading.Thread(target=peer)
+    server.start()
+    try:
+        status, payload, ms = e2e.post(
+            f"https://127.0.0.1:{listener.getsockname()[1]}",
+            Endpoint("/p", "application/json"),
+            item(),
+            0.2,
+        )
+        assert accepted.is_set()
+        assert status is None and payload == b"no answer within 0.2 s"
+        assert 150 <= ms < 1000
+        assert disconnected.wait(2)
+    finally:
+        server.join(3)
+        assert not server.is_alive() and stopped.is_set()
diff --git a/verification/tests/test_sim_app_flow.py b/verification/tests/test_sim_app_flow.py
index 45f5837ac..c29de6ef7 100644
--- a/verification/tests/test_sim_app_flow.py
+++ b/verification/tests/test_sim_app_flow.py
@@ -48,13 +48,16 @@ def test_the_recorded_flows_pass(sequence):
     ("sequence", "problem"),
     [
         # A cached or prebuilt scan shown straight away: no capture, no upload.
-        ("onboarding>result>resultAR>result", "no findMeter at all"),
+        ("onboarding>result>resultAR>result", "result before findMeter"),
         # Captured, then a result with no upload behind it.
-        ("onboarding>findMeter>meterCloseUp>wallWalk>markFeatures>result", "no uploading after"),
+        (
+            "onboarding>findMeter>meterCloseUp>wallWalk>markFeatures>result",
+            "result before uploading",
+        ),
         # Uploaded before the walk that should have produced the scan.
         (
             "onboarding>uploading>findMeter>meterCloseUp>wallWalk>markFeatures>result",
-            "no uploading after markFeatures",
+            "result before uploading",
         ),
         # The answer asked for more, the app showed the request, then the result without sending.
         (
diff --git a/verification/tests/test_simrun.py b/verification/tests/test_simrun.py
index 453988e12..0de8f776c 100644
--- a/verification/tests/test_simrun.py
+++ b/verification/tests/test_simrun.py
@@ -257,3 +257,29 @@ def test_device_lock_excludes_another_runner_and_releases(tmp_path, monkeypatch)
     with simrun.device_lock():
         assert subprocess.run(cmd, timeout=5, check=False).returncode == 43
     assert subprocess.run(cmd, timeout=5, check=False).returncode == 0
+
+
+@pytest.mark.parametrize("prefix", [[], ["findMeter"], ["findMeter", "uploading"]])
+def test_early_result_cannot_be_hidden_by_a_later_complete_flow(prefix):
+    order = ["findMeter", "meterCloseUp", "wallWalk", "markFeatures", "uploading", "result"]
+    states = [shot(name) for name in [*prefix, "result", *order]]
+    assert simrun.out_of_order(order, states)
+    assert simrun.out_of_order(order, [shot(name) for name in order]) == []
+
+
+def test_order_still_allows_intermediate_states_and_completed_recapture():
+    order = ["findMeter", "uploading", "result"]
+    states = [
+        shot(name)
+        for name in [
+            "onboarding",
+            "findMeter",
+            "wallWalk",
+            "uploading",
+            "gapRequest",
+            "markFeatures",
+            "uploading",
+            "result",
+        ]
+    ]
+    assert simrun.out_of_order(order, states) == []

From aa44d1f8b0444f4b0547cc72c28cca96de8b8a03 Mon Sep 17 00:00:00 2001
From: Sam Gu <127461594+SamGu-NRX@users.noreply.github.com>
Date: Wed, 14 Oct 2026 10:24:36 -0500
Subject: [PATCH 44/62] fix: retain reviewed meter labels across CSV ingest

Preserve shown and its presence in downloads and imports, and validate both browser and ingested Keeps against the current label before granting human confirmation. Unknown legacy Keeps cannot become known-empty answers or upgrade earlier corrections.

Round-trip regressions cover changed numeric, blank and NONE labels, fresh/stale browser state, repeated ingest and prior corrections. All 99 meter-closeup tests pass.
---
 .../meter-closeup/src/meter_eval/labels.py    |  14 +-
 .../meter-closeup/src/meter_eval/review.py    |  42 +++--
 .../meter-closeup/tests/test_review_keep.py   | 157 +++++++++++++++++-
 3 files changed, 193 insertions(+), 20 deletions(-)

diff --git a/experiments/meter-closeup/src/meter_eval/labels.py b/experiments/meter-closeup/src/meter_eval/labels.py
index d148175ac..d2150cc98 100644
--- a/experiments/meter-closeup/src/meter_eval/labels.py
+++ b/experiments/meter-closeup/src/meter_eval/labels.py
@@ -134,7 +134,19 @@ def build() -> list[dict]:
             "usable": usable,
             "notes": scrub(r1["notes"]),
         }
-        verdict = human.get(image_id, {}).get("verdict", "")
+        answer = human.get(image_id, {})
+        verdict = answer.get("verdict", "")
+        # A bare Keep confirms only the label shown at review, not a later reader update.
+        shown = "" if number == "NONE" else number
+        shown_known = answer.get("shown_known") == "yes" or (
+            "shown_known" not in answer and bool(answer.get("shown"))
+        )
+        if (
+            verdict == "keep"
+            and not answer.get("number")
+            and (not shown_known or answer.get("shown") != shown)
+        ):
+            verdict = ""
         # A person's number replaces the readers': typed with "fix", or confirmed with "keep"
         # after a fix. A "keep" with no number confirms the readers' own number.
         if verdict in ("fix", "keep") and human[image_id].get("number"):
diff --git a/experiments/meter-closeup/src/meter_eval/review.py b/experiments/meter-closeup/src/meter_eval/review.py
index 7b6a9e683..61c6e2a0d 100644
--- a/experiments/meter-closeup/src/meter_eval/review.py
+++ b/experiments/meter-closeup/src/meter_eval/review.py
@@ -96,30 +96,50 @@ def read_answers(path) -> dict[str, dict]:
         rows = list(csv.DictReader(handle))
     if rows and (missing := {"id", "verdict", "number"} - set(rows[0])):
         raise SystemExit(f"{path} lacks columns {sorted(missing)}; export it from review.html")
-    return {r["id"]: {"verdict": r["verdict"], "number": r["number"]} for r in rows if r["verdict"]}
+    return {
+        r["id"]: {
+            "verdict": r["verdict"],
+            "number": r["number"],
+            **(
+                {"shown": r["shown"]}
+                if r.get("shown_known") == "yes" or ("shown_known" not in r and r.get("shown"))
+                else {}
+            ),
+        }
+        for r in rows
+        if r["verdict"]
+    }
 
 
 def merge(earlier: dict[str, dict], new: dict[str, dict]) -> dict[str, dict]:
     """New answers replace earlier ones photo by photo; photos not answered again keep theirs.
 
-    A Keep that carries no number confirms what the page showed, which is the earlier
-    correction when there is one, so it keeps that number rather than dropping it.
+    A bare Keep confirms an earlier correction only when its recorded label matches.
+    An unbound legacy Keep retains the earlier correction without upgrading its verdict.
     """
     merged = dict(earlier)
     for image_id, answer in new.items():
         before = earlier.get(image_id, {})
         if answer["verdict"] == "keep" and not answer["number"] and before.get("number"):
-            answer = {"verdict": "keep", "number": before["number"]}
+            if "shown" not in answer:
+                # An unbound legacy Keep cannot confirm a new number or erase a prior correction.
+                answer = before
+            elif answer["shown"] == before["number"]:
+                answer = {**answer, "number": before["number"]}
         merged[image_id] = answer
     return merged
 
 
 def ingest(path: str) -> None:
     merged = merge(read_answers(HUMAN_LABELS), read_answers(Path(path)))
+    # CSV empty cells cannot distinguish a reviewed empty label from missing legacy metadata.
     with HUMAN_LABELS.open("w", newline="") as handle:
         writer = csv.writer(handle)
-        writer.writerow(["id", "verdict", "number"])
-        writer.writerows([i, a["verdict"], a["number"]] for i, a in sorted(merged.items()))
+        writer.writerow(["id", "verdict", "number", "shown", "shown_known"])
+        writer.writerows(
+            [i, a["verdict"], a["number"], a.get("shown", ""), "yes" if "shown" in a else ""]
+            for i, a in sorted(merged.items())
+        )
     fixed = [i for i, a in merged.items() if a["verdict"] == "fix"]
     print(f"{len(merged)} answers, {len(fixed)} corrections -> {HUMAN_LABELS}")
     for image_id in sorted(fixed):
@@ -233,8 +253,9 @@ def ingest(path: str) -> None:
   const answers = {};
   for (const item of items) {
     const mine = stored[item.id];
-    if (mine && (mine.number || mine.shown === item.number)) answers[item.id] = mine;
-    else if (item.answer) answers[item.id] = item.answer;
+    const valid = (answer) => answer && (answer.number || answer.shown === item.number);
+    if (valid(mine)) answers[item.id] = mine;
+    else if (valid(item.answer)) answers[item.id] = item.answer;
   }
   return answers;
 }
@@ -333,8 +354,9 @@ def ingest(path: str) -> None:
 function keep(i) { store(i, keepAnswer(saved[items[i].id], items[i])); select(i + 1); }
 
 function answerRows(items, saved) {
-  return [["id", "verdict", "number"]].concat(
-    items.map((item) => [item.id, saved[item.id]?.verdict || "", saved[item.id]?.number || ""])
+  return [["id", "verdict", "number", "shown", "shown_known"]].concat(
+    items.map((item) => [item.id, saved[item.id]?.verdict || "", saved[item.id]?.number || "",
+      saved[item.id]?.shown || "", saved[item.id]?.shown !== undefined ? "yes" : ""])
   );
 }
 
diff --git a/experiments/meter-closeup/tests/test_review_keep.py b/experiments/meter-closeup/tests/test_review_keep.py
index 79bc1cf3f..675cc94d1 100644
--- a/experiments/meter-closeup/tests/test_review_keep.py
+++ b/experiments/meter-closeup/tests/test_review_keep.py
@@ -3,6 +3,7 @@
 import re
 import subprocess
 
+import pytest
 from PIL import Image
 
 from meter_eval import labels, review
@@ -75,10 +76,10 @@ def test_a_browser_keep_given_for_a_number_the_page_no_longer_shows_is_dropped()
     }
     rows = on_page("answerRows(items, startingAnswers(items, stored))", items=items, stored=stored)
     assert rows[1:] == [
-        ["m01", "fix", "7654321"],
-        ["m02", "", ""],
-        ["m03", "keep", ""],
-        ["m04", "", ""],
+        ["m01", "fix", "7654321", "", ""],
+        ["m02", "", "", "", ""],
+        ["m03", "keep", "", "3333333", "yes"],
+        ["m04", "", "", "", ""],
     ]
 
 
@@ -94,7 +95,10 @@ def test_a_browser_correction_survives_a_label_change_and_the_upgrade():
         "m02": {"verdict": "fix", "number": "2223333", "shown": "2220000"},
     }
     rows = on_page("answerRows(items, startingAnswers(items, stored))", items=items, stored=stored)
-    assert rows[1:] == [["m01", "fix", "ABC 7654321"], ["m02", "fix", "2223333"]]
+    assert rows[1:] == [
+        ["m01", "fix", "ABC 7654321", "", ""],
+        ["m02", "fix", "2223333", "2220000", "yes"],
+    ]
 
 
 def test_a_kept_correction_survives_a_label_change():
@@ -105,7 +109,7 @@ def test_a_kept_correction_survives_a_label_change():
     stored = {"m01": {**kept, "shown": "1111111"}}
     after = [{"id": "m01", "number": "1112222", "corrected": False, "answer": None}]
     rows = on_page("answerRows(items, startingAnswers(items, stored))", items=after, stored=stored)
-    assert rows[1:] == [["m01", "keep", "ABC 7654321"]]
+    assert rows[1:] == [["m01", "keep", "ABC 7654321", "1111111", "yes"]]
 
 
 def write(path, rows):
@@ -209,7 +213,7 @@ def rebuild_manifest() -> dict:
         " saved.m01 = keepAnswer(saved.m01, items[0]); return answerRows(items, saved); })()",
         items=items,
     )
-    assert rows[1] == ["m01", "keep", "7654321"]
+    assert rows[1] == ["m01", "keep", "7654321", "", ""]
     download = tmp_path / "answers.csv"
     with download.open("w", newline="") as handle:
         csv.writer(handle).writerows(rows)
@@ -221,13 +225,148 @@ def rebuild_manifest() -> dict:
     assert row["human_check"] == "keep"
 
 
-def test_ingest_keeps_earlier_answers_and_a_bare_keep_keeps_the_correction():
+def test_unbound_legacy_keep_preserves_the_earlier_correction_verdict():
     earlier = {
         "m01": {"verdict": "fix", "number": "7654321"},
         "m02": {"verdict": "keep", "number": ""},
     }
     new = {"m01": {"verdict": "keep", "number": ""}}
     assert review.merge(earlier, new) == {
-        "m01": {"verdict": "keep", "number": "7654321"},
+        "m01": {"verdict": "fix", "number": "7654321"},
         "m02": {"verdict": "keep", "number": ""},
     }
+
+
+@pytest.mark.parametrize("legacy_csv", [False, True])
+@pytest.mark.parametrize("new_number", ["2222222", "", "NONE"])
+def test_download_ingest_label_change_and_reload_reopens_a_bare_keep(
+    tmp_path, monkeypatch, legacy_csv, new_number
+):
+    reader = {
+        "id": "m01",
+        "meter_number": "1111111",
+        "other_numbers": "",
+        "number_sure": "sure",
+        "class_label": "NONE",
+        "class_sure": "",
+        "notes": "",
+    }
+    source = {
+        "id": "m01",
+        "title": "t",
+        "page_url": "p",
+        "image_url": "i",
+        "license": "CC0",
+        "license_url": "",
+        "author": "a",
+    }
+    for name in ("labels_reader1.csv", "labels_reader2a.csv", "labels_reader2b.csv"):
+        write(tmp_path / name, [reader])
+    write(tmp_path / "src.csv", [source])
+    write(tmp_path / "clean_per_image.csv", [{"id": "m01", "number_box": ""}])
+    (tmp_path / "images").mkdir()
+    Image.new("RGB", (40, 30), "white").save(tmp_path / "images" / "m01.jpg")
+    human = tmp_path / "labels_human.csv"
+    monkeypatch.setattr(labels, "READER1", tmp_path / "labels_reader1.csv")
+    monkeypatch.setattr(labels, "READER2", [tmp_path / "labels_reader2a.csv"])
+    monkeypatch.setattr(labels, "SOURCES", tmp_path / "src.csv")
+    monkeypatch.setattr(labels, "HUMAN", human)
+    for name, value in {
+        "DATA_DIR": tmp_path,
+        "RESULTS_DIR": tmp_path,
+        "REVIEW_DIR": tmp_path / "review",
+        "MANIFEST": tmp_path / "manifest.csv",
+        "HUMAN_LABELS": human,
+    }.items():
+        monkeypatch.setattr(review, name, value)
+
+    def reload():
+        [row] = labels.build()
+        with (tmp_path / "manifest.csv").open("w", newline="") as handle:
+            writer = csv.DictWriter(handle, fieldnames=labels.FIELDS, restval="")
+            writer.writeheader()
+            writer.writerow(row)
+        review.build()
+        page = (tmp_path / "review" / "review.html").read_text()
+        items = json.loads(re.search(r'id="items">(.*?)</script>', page, re.DOTALL).group(1))
+        return row, items
+
+    _, items = reload()
+    stored = {"m01": {**keep_answer(None, items[0]), "shown": items[0]["number"]}}
+    rows = on_page("answerRows(items, stored)", items=items, stored=stored)
+    assert rows == [
+        ["id", "verdict", "number", "shown", "shown_known"],
+        ["m01", "keep", "", "1111111", "yes"],
+    ]
+    if legacy_csv:
+        rows = [row[:3] for row in rows]
+    download = tmp_path / "answers.csv"
+    with download.open("w", newline="") as handle:
+        csv.writer(handle).writerows(rows)
+    review.ingest(str(download))
+    imported = review.read_answers(human)["m01"]
+    assert imported.get("shown", "") == ("" if legacy_csv else "1111111")
+    if not legacy_csv:
+        before, items = reload()
+        assert before["human_check"] == "keep"
+        assert on_page("startingAnswers(items, {})", items=items) == {"m01": imported}
+
+    write(tmp_path / "labels_reader1.csv", [{**reader, "meter_number": new_number}])
+    after, items = reload()
+    assert items[0]["number"] == ("" if new_number == "NONE" else new_number)
+    assert after.get("human_check", "") == ""
+    assert after.get("number_agreed", "no") == after.get("number_agreed_strict", "no") == "no"
+    # Both a fresh browser and the stale original browser must reopen the changed label.
+    assert on_page("startingAnswers(items, {})", items=items) == {}
+    assert on_page("startingAnswers(items, stored)", items=items, stored=stored) == {}
+    assert on_page("answerRows(items, startingAnswers(items, stored))", items=items, stored=stored)[
+        1
+    ] == [
+        "m01",
+        "",
+        "",
+        "",
+        "",
+    ]
+
+
+def test_a_keep_for_a_different_shown_number_does_not_inherit_an_earlier_correction():
+    old = {"m01": {"verdict": "fix", "number": "1111111"}}
+    new = {"m01": {"verdict": "keep", "number": "", "shown": "2222222"}}
+    assert review.merge(old, new) == new
+
+
+@pytest.mark.parametrize("legacy_csv", [False, True])
+def test_csv_distinguishes_a_reviewed_empty_label_from_missing_binding(
+    tmp_path, monkeypatch, legacy_csv
+):
+    items = [{"id": "m01", "number": "", "corrected": False, "answer": None}]
+    kept = {"m01": {"verdict": "keep", "number": "", "shown": ""}}
+    rows = on_page("answerRows(items, kept)", items=items, kept=kept)
+    if legacy_csv:
+        rows = [row[:3] for row in rows]
+    download = tmp_path / "download.csv"
+    with download.open("w", newline="") as handle:
+        csv.writer(handle).writerows(rows)
+    human = tmp_path / "human.csv"
+    monkeypatch.setattr(review, "HUMAN_LABELS", human)
+    review.ingest(str(download))
+    imported = review.read_answers(human)
+    items[0]["answer"] = imported["m01"]
+    if legacy_csv:
+        assert "shown" not in imported["m01"]
+        assert on_page("startingAnswers(items, {})", items=items) == {}
+    else:
+        assert imported == kept
+        assert on_page("startingAnswers(items, {})", items=items) == kept
+    # Writing and re-ingesting the human file must not invent a binding on a second pass.
+    review.ingest(str(human))
+    assert review.read_answers(human) == imported
+
+
+def test_a_bound_keep_of_the_prior_correction_retains_its_label_binding():
+    old = {"m01": {"verdict": "fix", "number": "1111111"}}
+    new = {"m01": {"verdict": "keep", "number": "", "shown": "1111111"}}
+    assert review.merge(old, new) == {
+        "m01": {"verdict": "keep", "number": "1111111", "shown": "1111111"}
+    }

From 10f0fb14634a1c9aca57b2d52673c7fdc694cf84 Mon Sep 17 00:00:00 2001
From: Sam Gu <127461594+SamGu-NRX@users.noreply.github.com>
Date: Wed, 14 Oct 2026 11:10:51 -0500
Subject: [PATCH 45/62] fix: reject ambiguous archives and incomplete
 acceptance evidence

Bind ZIP admission to the footer stdlib will parse and refuse ZIP64 overrides before metadata allocation. S2-8 requires execution of all five hostile probes, and geometric fixtures declare the public rule values their expectations depend on.

The root verifier target now uses the locked dependency sync from CI. Tiny archive controls, shortened CLI reports, real-case overrides and dispatch failures cover the new review findings.
---
 Makefile                                      |  3 +-
 recon/recon/capture.py                        | 30 ++++--
 recon/tests/test_review_debt.py               | 43 +++++++++
 tests/makefile.sh                             |  5 +-
 verification/e2e/cases/c5-no-coverage.json    |  4 +-
 verification/e2e/cases/d-gas-drift.json       |  1 +
 .../e2e/cases/d-reach-drift-left.json         |  1 +
 .../e2e/cases/d-reach-drift-right.json        |  1 +
 .../e2e/cases/g01-unseen-beyond-garage.json   |  4 +-
 .../e2e/cases/g03-negative-s-near-edge.json   |  5 +-
 .../e2e/cases/g05-inside-corner-gas.json      |  4 +-
 .../e2e/cases/g06-regulator-footprint.json    |  1 +
 verification/e2e/cases/g07-headroom-fail.json |  1 +
 .../e2e/cases/g07-headroom-margin.json        |  1 +
 .../e2e/cases/g07-headroom-partial-span.json  |  1 +
 verification/e2e/cases/g07-headroom-pass.json |  1 +
 .../e2e/cases/g07-headroom-unobserved.json    |  1 +
 .../e2e/cases/g08a-garage-blocks-route.json   |  4 +-
 .../cases/g08b-missing-wall-blocks-route.json |  4 +-
 verification/e2e/cases/g09-reach-14.json      |  1 +
 verification/e2e/cases/g09-reach-15.json      |  1 +
 verification/e2e/cases/g09-reach-16.json      |  1 +
 verification/e2e/cases/g09-reach-20.json      |  1 +
 .../e2e/cases/g09-reach-20p2-pm03.json        |  1 +
 .../e2e/cases/g09-reach-20p4-pm03.json        |  1 +
 verification/e2e/cases/g09-reach-21.json      |  1 +
 verification/e2e/cases/g09-vertical-run.json  |  1 +
 .../e2e/cases/g10-derived-compound-error.json |  1 +
 verification/e2e/cases/g10-e03-fail.json      |  1 +
 .../e2e/cases/g10-e03-lower-edge.json         |  1 +
 verification/e2e/cases/g10-e03-pass.json      |  1 +
 .../e2e/cases/g10-e03-upper-edge.json         |  1 +
 verification/e2e/cases/g10-e05-fail.json      |  1 +
 .../e2e/cases/g10-e05-lower-edge.json         |  1 +
 verification/e2e/cases/g10-e05-pass.json      |  1 +
 .../e2e/cases/g10-e05-upper-edge.json         |  1 +
 verification/e2e/cases/g10-e15-fail.json      |  1 +
 .../e2e/cases/g10-e15-lower-edge.json         |  1 +
 verification/e2e/cases/g10-e15-pass.json      |  1 +
 .../e2e/cases/g10-e15-upper-edge.json         |  1 +
 .../e2e/cases/g11a-unexplored-corner.json     |  1 +
 .../cases/g11b-both-ends-real-all-fail.json   |  4 +-
 .../e2e/cases/g11c-unobserved-ground.json     |  1 +
 .../e2e/cases/g12a-subgrid-start.json         |  1 +
 .../e2e/cases/g12b-exact-fit-last-start.json  |  5 +-
 .../g13a-unsure-never-outranks-pass.json      |  1 +
 verification/e2e/cases/g13b-unsure-alone.json |  1 +
 verification/e2e/cases/generate.py            | 11 ++-
 verification/hsverify/e2e.py                  | 38 ++++++--
 verification/scoreboard/metrics.yaml          |  3 +-
 verification/tests/test_e2e.py                | 94 +++++++++++++++++++
 verification/tests/test_generate_cases.py     | 78 +++++++++++++++
 verification/tests/test_scoreboard.py         | 12 +++
 53 files changed, 351 insertions(+), 35 deletions(-)

diff --git a/Makefile b/Makefile
index 138e460e5..88a036e4b 100644
--- a/Makefile
+++ b/Makefile
@@ -87,9 +87,10 @@ meter-closeup:
 	$(call require,$(METER_CLOSEUP),#16)
 	$(MAKE) -C experiments/meter-closeup check
 
-# PR #13 added this suite; leaving it out lets `make check` skip the independent verifier.
+# Match verification CI's locked sync so a stale lockfile cannot pass the local check.
 verification:
 	$(call require,$(VERIFICATION),#13)
+	cd verification && uv sync --locked
 	$(MAKE) -C verification test
 
 # Posts each scene in server/examples to a placement server and prints its decision:
diff --git a/recon/recon/capture.py b/recon/recon/capture.py
index a585c1282..378a32320 100644
--- a/recon/recon/capture.py
+++ b/recon/recon/capture.py
@@ -182,16 +182,20 @@ def _zip_directory_limits(path: Path) -> None:
         size = path.stat().st_size
         f.seek(max(0, size - 22 - 65535))
         tail = f.read(22 + 65535)
-        end = len(tail)
-        while True:
-            pos = tail.rfind(b"PK\x05\x06", 0, end)
-            if pos < 0:
-                raise ValueError(f"{path}: missing ZIP end record")
-            if pos + 22 <= len(tail):
-                record = struct.unpack("<4s4H2IH", tail[pos : pos + 22])
-                if pos + 22 + record[-1] == len(tail):
-                    break
-            end = pos
+        # Match ZipFile's footer selection: a no-comment footer at EOF, otherwise the last
+        # signature. Backtracking past malformed signatures can validate a different directory
+        # from the one ZipFile later allocates. Refuse that ambiguity before constructing it.
+        if len(tail) >= 22 and tail[-22:-18] == b"PK\x05\x06" and tail[-2:] == b"\0\0":
+            pos = len(tail) - 22
+        else:
+            pos = tail.rfind(b"PK\x05\x06")
+        if pos < 0:
+            raise ValueError(f"{path}: missing ZIP end record")
+        if pos + 22 > len(tail):
+            raise ValueError(f"{path}: truncated ZIP end record")
+        record = struct.unpack("<4s4H2IH", tail[pos : pos + 22])
+        if pos + 22 + record[-1] != len(tail):
+            raise ValueError(f"{path}: ambiguous ZIP end record or invalid comment length")
         _, disk, central_disk, disk_entries, total_entries, length, offset, _ = record
         if disk or central_disk or disk_entries != total_entries:
             raise ValueError(f"{path}: split ZIP archives are not supported")
@@ -199,6 +203,12 @@ def _zip_directory_limits(path: Path) -> None:
             raise ValueError(f"{path}: {total_entries} entries, limit {MAX_BUNDLE_ENTRIES}")
         directory_end = offset + length
         end_offset = size - len(tail) + pos
+        # ZipFile checks this locator even when the ordinary footer has no ZIP64 sentinels.
+        # It must not replace the directory fields after the bounded scan below.
+        if end_offset >= 20:
+            f.seek(end_offset - 20)
+            if f.read(4) == b"PK\x06\x07":
+                raise ValueError(f"{path}: ZIP64 archive metadata is not supported")
         if length == 0xFFFFFFFF or offset == 0xFFFFFFFF or directory_end != end_offset:
             raise ValueError(f"{path}: ZIP64 or inconsistent ZIP directory")
         f.seek(offset)
diff --git a/recon/tests/test_review_debt.py b/recon/tests/test_review_debt.py
index e1c951e3a..372d6edf0 100644
--- a/recon/tests/test_review_debt.py
+++ b/recon/tests/test_review_debt.py
@@ -351,6 +351,49 @@ def test_zip_entry_count_is_checked_before_metadata_allocation(tmp_path, monkeyp
         cap.unpack(path, tmp_path / "work")
 
 
+@pytest.mark.parametrize("truncated", [False, True])
+def test_zip_comment_cannot_select_a_different_footer(tmp_path, monkeypatch, truncated):
+    path = tmp_path / "bundle.zip"
+    fake = struct.pack("<4s4H2IH", b"PK\x05\x06", 0, 0, 4, 4, 184, 0, 1)
+    comment = b"PK\x05\x06x" if truncated else fake + b"tail"
+    with zipfile.ZipFile(path, "w") as z:
+        z.writestr("one", b"one")
+        z.comment = comment
+    # The private stdlib parser reads only the bounded footer, without constructing ZipInfo
+    # objects. It chooses the later signature despite its claimed one-byte comment ending early.
+    if not truncated:
+        with path.open("rb") as f:
+            parsed = zipfile._EndRecData(f)
+        assert parsed[zipfile._ECD_ENTRIES_TOTAL] == 4
+        assert parsed[zipfile._ECD_LOCATION] == path.stat().st_size - len(comment)
+    monkeypatch.setattr(zipfile, "ZipFile", lambda *_: pytest.fail("allocated ZIP metadata"))
+    with pytest.raises(ValueError, match=r"ambiguous ZIP end record|truncated ZIP end record"):
+        cap.unpack(path, tmp_path / "work")
+    assert not (tmp_path / "work").exists()
+
+
+def test_zip_with_an_ordinary_comment_extracts(tmp_path):
+    path = tmp_path / "bundle.zip"
+    with zipfile.ZipFile(path, "w") as z:
+        z.writestr("scan/scene.json", '{"schema_version": "1.0"}')
+        z.comment = b"ordinary scan bundle comment"
+    out = cap.unpack(path, tmp_path / "work")
+    assert json.loads((out / "scan/scene.json").read_text()) == {"schema_version": "1.0"}
+
+
+def test_zip64_locator_cannot_override_a_checked_ordinary_footer(tmp_path, monkeypatch):
+    path = tmp_path / "bundle.zip"
+    info = zipfile.ZipInfo("one")
+    # A locator in the final central record's file comment is immediately before the footer,
+    # where stdlib probes for ZIP64 even without sentinel values in the ordinary footer.
+    info.comment = struct.pack("<4sIQI", b"PK\x06\x07", 0, 0, 1)
+    with zipfile.ZipFile(path, "w") as z:
+        z.writestr(info, b"one")
+    monkeypatch.setattr(zipfile, "ZipFile", lambda *_: pytest.fail("allocated ZIP metadata"))
+    with pytest.raises(ValueError, match="ZIP64 archive metadata is not supported"):
+        cap.unpack(path, tmp_path / "work")
+
+
 def test_failed_zip_extraction_does_not_publish_partial_bundle(tmp_path, monkeypatch):
     path = tmp_path / "bundle.zip"
     with zipfile.ZipFile(path, "w") as z:
diff --git a/tests/makefile.sh b/tests/makefile.sh
index 361870a41..d44bd7c51 100755
--- a/tests/makefile.sh
+++ b/tests/makefile.sh
@@ -106,7 +106,8 @@ expect_commands evals "experiments/evals uv sync --locked
 experiments/evals make test"
 expect_commands recon "recon make test"
 expect_commands meter-closeup "experiments/meter-closeup make check"
-expect_commands verification "verification make test"
+expect_commands verification "verification uv sync --locked
+verification make test"
 
 # 3. Naming a missing suite fails loudly and runs nothing.
 for suite in $suites; do
@@ -120,7 +121,7 @@ done
 
 # 4. A failing command inside a present suite fails `make check`, and nothing runs after it.
 for FAIL_AT in "experiments/scoring uv" "experiments/measure-lab make" "experiments/evals uv" \
-	"experiments/evals make" "recon make" "experiments/meter-closeup make" "verification make"; do
+	"experiments/evals make" "recon make" "experiments/meter-closeup make" "verification uv" "verification make"; do
 	make_tree $suites
 	if run_make check; then
 		fail "check passed although $FAIL_AT failed"
diff --git a/verification/e2e/cases/c5-no-coverage.json b/verification/e2e/cases/c5-no-coverage.json
index 29e9225b6..4777661c2 100644
--- a/verification/e2e/cases/c5-no-coverage.json
+++ b/verification/e2e/cases/c5-no-coverage.json
@@ -67,7 +67,9 @@
       }
     ]
   },
-  "rules_assumed": {},
+  "rules_assumed": {
+    "battery_width": 2.5833333333333335
+  },
   "expect": {
     "decision_in": [
       "manual_review"
diff --git a/verification/e2e/cases/d-gas-drift.json b/verification/e2e/cases/d-gas-drift.json
index e94419104..3beac4277 100644
--- a/verification/e2e/cases/d-gas-drift.json
+++ b/verification/e2e/cases/d-gas-drift.json
@@ -119,6 +119,7 @@
     }
   },
   "rules_assumed": {
+    "battery_width": 2.5833333333333335,
     "gas": 3.0,
     "route_length": 20.0
   },
diff --git a/verification/e2e/cases/d-reach-drift-left.json b/verification/e2e/cases/d-reach-drift-left.json
index 1f015c85b..2b03a1f4e 100644
--- a/verification/e2e/cases/d-reach-drift-left.json
+++ b/verification/e2e/cases/d-reach-drift-left.json
@@ -107,6 +107,7 @@
     }
   },
   "rules_assumed": {
+    "battery_width": 2.5833333333333335,
     "route_length": 20.0
   },
   "expect": {
diff --git a/verification/e2e/cases/d-reach-drift-right.json b/verification/e2e/cases/d-reach-drift-right.json
index 826109a2e..e8dd80374 100644
--- a/verification/e2e/cases/d-reach-drift-right.json
+++ b/verification/e2e/cases/d-reach-drift-right.json
@@ -107,6 +107,7 @@
     }
   },
   "rules_assumed": {
+    "battery_width": 2.5833333333333335,
     "route_length": 20.0
   },
   "expect": {
diff --git a/verification/e2e/cases/g01-unseen-beyond-garage.json b/verification/e2e/cases/g01-unseen-beyond-garage.json
index d382da71b..b11340fe9 100644
--- a/verification/e2e/cases/g01-unseen-beyond-garage.json
+++ b/verification/e2e/cases/g01-unseen-beyond-garage.json
@@ -124,7 +124,9 @@
       ]
     }
   },
-  "rules_assumed": {},
+  "rules_assumed": {
+    "battery_width": 2.5833333333333335
+  },
   "expect": {
     "missing_evidence_empty": true,
     "sweep_runs": [
diff --git a/verification/e2e/cases/g03-negative-s-near-edge.json b/verification/e2e/cases/g03-negative-s-near-edge.json
index c7d60170b..9b66fdccf 100644
--- a/verification/e2e/cases/g03-negative-s-near-edge.json
+++ b/verification/e2e/cases/g03-negative-s-near-edge.json
@@ -204,7 +204,10 @@
       ]
     }
   },
-  "rules_assumed": {},
+  "rules_assumed": {
+    "battery_width": 2.5833333333333335,
+    "corner_allowance": 0.5
+  },
   "expect": {
     "spot": {
       "wall_id": "w1",
diff --git a/verification/e2e/cases/g05-inside-corner-gas.json b/verification/e2e/cases/g05-inside-corner-gas.json
index 78e61e185..d9542b1ac 100644
--- a/verification/e2e/cases/g05-inside-corner-gas.json
+++ b/verification/e2e/cases/g05-inside-corner-gas.json
@@ -149,7 +149,9 @@
     }
   },
   "rules_assumed": {
-    "gas": 3.0
+    "battery_width": 2.5833333333333335,
+    "gas": 3.0,
+    "corner_allowance": 0.5
   },
   "expect": {
     "decision_not": [
diff --git a/verification/e2e/cases/g06-regulator-footprint.json b/verification/e2e/cases/g06-regulator-footprint.json
index 2d12e8c84..6d941c54e 100644
--- a/verification/e2e/cases/g06-regulator-footprint.json
+++ b/verification/e2e/cases/g06-regulator-footprint.json
@@ -150,6 +150,7 @@
     }
   },
   "rules_assumed": {
+    "battery_width": 2.5833333333333335,
     "gas": 3.0
   },
   "expect": {
diff --git a/verification/e2e/cases/g07-headroom-fail.json b/verification/e2e/cases/g07-headroom-fail.json
index 4cbbcc947..406c90015 100644
--- a/verification/e2e/cases/g07-headroom-fail.json
+++ b/verification/e2e/cases/g07-headroom-fail.json
@@ -120,6 +120,7 @@
     ]
   },
   "rules_assumed": {
+    "battery_width": 2.5833333333333335,
     "headroom": 6.5
   },
   "expect": {
diff --git a/verification/e2e/cases/g07-headroom-margin.json b/verification/e2e/cases/g07-headroom-margin.json
index 385c3d930..54126f030 100644
--- a/verification/e2e/cases/g07-headroom-margin.json
+++ b/verification/e2e/cases/g07-headroom-margin.json
@@ -120,6 +120,7 @@
     ]
   },
   "rules_assumed": {
+    "battery_width": 2.5833333333333335,
     "headroom": 6.5
   },
   "expect": {
diff --git a/verification/e2e/cases/g07-headroom-partial-span.json b/verification/e2e/cases/g07-headroom-partial-span.json
index 7da273f41..40166dffa 100644
--- a/verification/e2e/cases/g07-headroom-partial-span.json
+++ b/verification/e2e/cases/g07-headroom-partial-span.json
@@ -120,6 +120,7 @@
     ]
   },
   "rules_assumed": {
+    "battery_width": 2.5833333333333335,
     "headroom": 6.5
   },
   "expect": {
diff --git a/verification/e2e/cases/g07-headroom-pass.json b/verification/e2e/cases/g07-headroom-pass.json
index 5184547de..b817e2d94 100644
--- a/verification/e2e/cases/g07-headroom-pass.json
+++ b/verification/e2e/cases/g07-headroom-pass.json
@@ -120,6 +120,7 @@
     ]
   },
   "rules_assumed": {
+    "battery_width": 2.5833333333333335,
     "headroom": 6.5
   },
   "expect": {
diff --git a/verification/e2e/cases/g07-headroom-unobserved.json b/verification/e2e/cases/g07-headroom-unobserved.json
index 4f224cdd9..302eaaf85 100644
--- a/verification/e2e/cases/g07-headroom-unobserved.json
+++ b/verification/e2e/cases/g07-headroom-unobserved.json
@@ -102,6 +102,7 @@
     }
   },
   "rules_assumed": {
+    "battery_width": 2.5833333333333335,
     "headroom": 6.5
   },
   "expect": {
diff --git a/verification/e2e/cases/g08a-garage-blocks-route.json b/verification/e2e/cases/g08a-garage-blocks-route.json
index 8d44257c0..f405b0dbf 100644
--- a/verification/e2e/cases/g08a-garage-blocks-route.json
+++ b/verification/e2e/cases/g08a-garage-blocks-route.json
@@ -124,7 +124,9 @@
       ]
     }
   },
-  "rules_assumed": {},
+  "rules_assumed": {
+    "battery_width": 2.5833333333333335
+  },
   "expect": {
     "decision_not": [
       "pass"
diff --git a/verification/e2e/cases/g08b-missing-wall-blocks-route.json b/verification/e2e/cases/g08b-missing-wall-blocks-route.json
index 6b20e34a5..d72f7fff0 100644
--- a/verification/e2e/cases/g08b-missing-wall-blocks-route.json
+++ b/verification/e2e/cases/g08b-missing-wall-blocks-route.json
@@ -131,7 +131,9 @@
       ]
     }
   },
-  "rules_assumed": {},
+  "rules_assumed": {
+    "battery_width": 2.5833333333333335
+  },
   "expect": {
     "decision_not": [
       "pass"
diff --git a/verification/e2e/cases/g09-reach-14.json b/verification/e2e/cases/g09-reach-14.json
index c38cb8b27..3b02b7295 100644
--- a/verification/e2e/cases/g09-reach-14.json
+++ b/verification/e2e/cases/g09-reach-14.json
@@ -131,6 +131,7 @@
     }
   },
   "rules_assumed": {
+    "battery_width": 2.5833333333333335,
     "route_length": 20.0
   },
   "expect": {
diff --git a/verification/e2e/cases/g09-reach-15.json b/verification/e2e/cases/g09-reach-15.json
index 2a3beb2ff..515b99fd9 100644
--- a/verification/e2e/cases/g09-reach-15.json
+++ b/verification/e2e/cases/g09-reach-15.json
@@ -131,6 +131,7 @@
     }
   },
   "rules_assumed": {
+    "battery_width": 2.5833333333333335,
     "route_length": 20.0
   },
   "expect": {
diff --git a/verification/e2e/cases/g09-reach-16.json b/verification/e2e/cases/g09-reach-16.json
index 3d44710e6..b044445e2 100644
--- a/verification/e2e/cases/g09-reach-16.json
+++ b/verification/e2e/cases/g09-reach-16.json
@@ -131,6 +131,7 @@
     }
   },
   "rules_assumed": {
+    "battery_width": 2.5833333333333335,
     "route_length": 20.0
   },
   "expect": {
diff --git a/verification/e2e/cases/g09-reach-20.json b/verification/e2e/cases/g09-reach-20.json
index 74e3350cf..861f163ce 100644
--- a/verification/e2e/cases/g09-reach-20.json
+++ b/verification/e2e/cases/g09-reach-20.json
@@ -131,6 +131,7 @@
     }
   },
   "rules_assumed": {
+    "battery_width": 2.5833333333333335,
     "route_length": 20.0
   },
   "expect": {
diff --git a/verification/e2e/cases/g09-reach-20p2-pm03.json b/verification/e2e/cases/g09-reach-20p2-pm03.json
index b47ac4c51..22cefea9b 100644
--- a/verification/e2e/cases/g09-reach-20p2-pm03.json
+++ b/verification/e2e/cases/g09-reach-20p2-pm03.json
@@ -131,6 +131,7 @@
     }
   },
   "rules_assumed": {
+    "battery_width": 2.5833333333333335,
     "route_length": 20.0
   },
   "expect": {
diff --git a/verification/e2e/cases/g09-reach-20p4-pm03.json b/verification/e2e/cases/g09-reach-20p4-pm03.json
index 7ff4ecd72..2b8cfe85e 100644
--- a/verification/e2e/cases/g09-reach-20p4-pm03.json
+++ b/verification/e2e/cases/g09-reach-20p4-pm03.json
@@ -131,6 +131,7 @@
     }
   },
   "rules_assumed": {
+    "battery_width": 2.5833333333333335,
     "route_length": 20.0
   },
   "expect": {
diff --git a/verification/e2e/cases/g09-reach-21.json b/verification/e2e/cases/g09-reach-21.json
index 2ea2706f7..6cbbe2d8a 100644
--- a/verification/e2e/cases/g09-reach-21.json
+++ b/verification/e2e/cases/g09-reach-21.json
@@ -131,6 +131,7 @@
     }
   },
   "rules_assumed": {
+    "battery_width": 2.5833333333333335,
     "route_length": 20.0
   },
   "expect": {
diff --git a/verification/e2e/cases/g09-vertical-run.json b/verification/e2e/cases/g09-vertical-run.json
index ea0be5f32..b13ec63a0 100644
--- a/verification/e2e/cases/g09-vertical-run.json
+++ b/verification/e2e/cases/g09-vertical-run.json
@@ -144,6 +144,7 @@
     }
   },
   "rules_assumed": {
+    "battery_width": 2.5833333333333335,
     "route_length": 20.0
   },
   "expect": {
diff --git a/verification/e2e/cases/g10-derived-compound-error.json b/verification/e2e/cases/g10-derived-compound-error.json
index d17aeb721..164a591d7 100644
--- a/verification/e2e/cases/g10-derived-compound-error.json
+++ b/verification/e2e/cases/g10-derived-compound-error.json
@@ -139,6 +139,7 @@
     }
   },
   "rules_assumed": {
+    "battery_width": 2.5833333333333335,
     "gas": 3.0
   },
   "expect": {
diff --git a/verification/e2e/cases/g10-e03-fail.json b/verification/e2e/cases/g10-e03-fail.json
index 9fdef2f3d..99acb6e5d 100644
--- a/verification/e2e/cases/g10-e03-fail.json
+++ b/verification/e2e/cases/g10-e03-fail.json
@@ -139,6 +139,7 @@
     }
   },
   "rules_assumed": {
+    "battery_width": 2.5833333333333335,
     "gas": 3.0
   },
   "expect": {
diff --git a/verification/e2e/cases/g10-e03-lower-edge.json b/verification/e2e/cases/g10-e03-lower-edge.json
index 2596a533b..48452bea5 100644
--- a/verification/e2e/cases/g10-e03-lower-edge.json
+++ b/verification/e2e/cases/g10-e03-lower-edge.json
@@ -139,6 +139,7 @@
     }
   },
   "rules_assumed": {
+    "battery_width": 2.5833333333333335,
     "gas": 3.0
   },
   "expect": {
diff --git a/verification/e2e/cases/g10-e03-pass.json b/verification/e2e/cases/g10-e03-pass.json
index ecc3a6cd2..ad77a1311 100644
--- a/verification/e2e/cases/g10-e03-pass.json
+++ b/verification/e2e/cases/g10-e03-pass.json
@@ -139,6 +139,7 @@
     }
   },
   "rules_assumed": {
+    "battery_width": 2.5833333333333335,
     "gas": 3.0
   },
   "expect": {
diff --git a/verification/e2e/cases/g10-e03-upper-edge.json b/verification/e2e/cases/g10-e03-upper-edge.json
index b2014bcc3..5568ed123 100644
--- a/verification/e2e/cases/g10-e03-upper-edge.json
+++ b/verification/e2e/cases/g10-e03-upper-edge.json
@@ -139,6 +139,7 @@
     }
   },
   "rules_assumed": {
+    "battery_width": 2.5833333333333335,
     "gas": 3.0
   },
   "expect": {
diff --git a/verification/e2e/cases/g10-e05-fail.json b/verification/e2e/cases/g10-e05-fail.json
index b9e3050c5..39732668e 100644
--- a/verification/e2e/cases/g10-e05-fail.json
+++ b/verification/e2e/cases/g10-e05-fail.json
@@ -139,6 +139,7 @@
     }
   },
   "rules_assumed": {
+    "battery_width": 2.5833333333333335,
     "gas": 3.0
   },
   "expect": {
diff --git a/verification/e2e/cases/g10-e05-lower-edge.json b/verification/e2e/cases/g10-e05-lower-edge.json
index 95736f521..bfa44a8ef 100644
--- a/verification/e2e/cases/g10-e05-lower-edge.json
+++ b/verification/e2e/cases/g10-e05-lower-edge.json
@@ -139,6 +139,7 @@
     }
   },
   "rules_assumed": {
+    "battery_width": 2.5833333333333335,
     "gas": 3.0
   },
   "expect": {
diff --git a/verification/e2e/cases/g10-e05-pass.json b/verification/e2e/cases/g10-e05-pass.json
index 69f63c6be..9270ff2d4 100644
--- a/verification/e2e/cases/g10-e05-pass.json
+++ b/verification/e2e/cases/g10-e05-pass.json
@@ -139,6 +139,7 @@
     }
   },
   "rules_assumed": {
+    "battery_width": 2.5833333333333335,
     "gas": 3.0
   },
   "expect": {
diff --git a/verification/e2e/cases/g10-e05-upper-edge.json b/verification/e2e/cases/g10-e05-upper-edge.json
index f59d16188..b110ad62c 100644
--- a/verification/e2e/cases/g10-e05-upper-edge.json
+++ b/verification/e2e/cases/g10-e05-upper-edge.json
@@ -139,6 +139,7 @@
     }
   },
   "rules_assumed": {
+    "battery_width": 2.5833333333333335,
     "gas": 3.0
   },
   "expect": {
diff --git a/verification/e2e/cases/g10-e15-fail.json b/verification/e2e/cases/g10-e15-fail.json
index 1f3d62be4..c09577b41 100644
--- a/verification/e2e/cases/g10-e15-fail.json
+++ b/verification/e2e/cases/g10-e15-fail.json
@@ -139,6 +139,7 @@
     }
   },
   "rules_assumed": {
+    "battery_width": 2.5833333333333335,
     "gas": 3.0
   },
   "expect": {
diff --git a/verification/e2e/cases/g10-e15-lower-edge.json b/verification/e2e/cases/g10-e15-lower-edge.json
index a11fae0c5..920148f7c 100644
--- a/verification/e2e/cases/g10-e15-lower-edge.json
+++ b/verification/e2e/cases/g10-e15-lower-edge.json
@@ -139,6 +139,7 @@
     }
   },
   "rules_assumed": {
+    "battery_width": 2.5833333333333335,
     "gas": 3.0
   },
   "expect": {
diff --git a/verification/e2e/cases/g10-e15-pass.json b/verification/e2e/cases/g10-e15-pass.json
index b5ea1c602..6afe24d62 100644
--- a/verification/e2e/cases/g10-e15-pass.json
+++ b/verification/e2e/cases/g10-e15-pass.json
@@ -139,6 +139,7 @@
     }
   },
   "rules_assumed": {
+    "battery_width": 2.5833333333333335,
     "gas": 3.0
   },
   "expect": {
diff --git a/verification/e2e/cases/g10-e15-upper-edge.json b/verification/e2e/cases/g10-e15-upper-edge.json
index 5b4204ba3..36c014efa 100644
--- a/verification/e2e/cases/g10-e15-upper-edge.json
+++ b/verification/e2e/cases/g10-e15-upper-edge.json
@@ -139,6 +139,7 @@
     }
   },
   "rules_assumed": {
+    "battery_width": 2.5833333333333335,
     "gas": 3.0
   },
   "expect": {
diff --git a/verification/e2e/cases/g11a-unexplored-corner.json b/verification/e2e/cases/g11a-unexplored-corner.json
index d837ed903..d878a851e 100644
--- a/verification/e2e/cases/g11a-unexplored-corner.json
+++ b/verification/e2e/cases/g11a-unexplored-corner.json
@@ -138,6 +138,7 @@
     }
   },
   "rules_assumed": {
+    "battery_width": 2.5833333333333335,
     "gas": 3.0
   },
   "expect": {
diff --git a/verification/e2e/cases/g11b-both-ends-real-all-fail.json b/verification/e2e/cases/g11b-both-ends-real-all-fail.json
index 60fc39539..17a8379c2 100644
--- a/verification/e2e/cases/g11b-both-ends-real-all-fail.json
+++ b/verification/e2e/cases/g11b-both-ends-real-all-fail.json
@@ -197,7 +197,9 @@
     }
   },
   "rules_assumed": {
-    "gas": 3.0
+    "battery_width": 2.5833333333333335,
+    "gas": 3.0,
+    "corner_allowance": 0.5
   },
   "expect": {
     "decision_in": [
diff --git a/verification/e2e/cases/g11c-unobserved-ground.json b/verification/e2e/cases/g11c-unobserved-ground.json
index 6ddd3c15f..8018fa307 100644
--- a/verification/e2e/cases/g11c-unobserved-ground.json
+++ b/verification/e2e/cases/g11c-unobserved-ground.json
@@ -138,6 +138,7 @@
     }
   },
   "rules_assumed": {
+    "battery_width": 2.5833333333333335,
     "gas": 3.0
   },
   "expect": {
diff --git a/verification/e2e/cases/g12a-subgrid-start.json b/verification/e2e/cases/g12a-subgrid-start.json
index c05e3a148..bd75a484f 100644
--- a/verification/e2e/cases/g12a-subgrid-start.json
+++ b/verification/e2e/cases/g12a-subgrid-start.json
@@ -140,6 +140,7 @@
     }
   },
   "rules_assumed": {
+    "battery_width": 2.5833333333333335,
     "opening": 3.0
   },
   "expect": {
diff --git a/verification/e2e/cases/g12b-exact-fit-last-start.json b/verification/e2e/cases/g12b-exact-fit-last-start.json
index 6ad22a994..33e40ed14 100644
--- a/verification/e2e/cases/g12b-exact-fit-last-start.json
+++ b/verification/e2e/cases/g12b-exact-fit-last-start.json
@@ -168,7 +168,10 @@
       ]
     }
   },
-  "rules_assumed": {},
+  "rules_assumed": {
+    "battery_width": 2.5833333333333335,
+    "corner_allowance": 0.5
+  },
   "expect": {
     "spot": {
       "wall_id": "w1",
diff --git a/verification/e2e/cases/g13a-unsure-never-outranks-pass.json b/verification/e2e/cases/g13a-unsure-never-outranks-pass.json
index 90a65f0a7..9ed6d39e7 100644
--- a/verification/e2e/cases/g13a-unsure-never-outranks-pass.json
+++ b/verification/e2e/cases/g13a-unsure-never-outranks-pass.json
@@ -138,6 +138,7 @@
     }
   },
   "rules_assumed": {
+    "battery_width": 2.5833333333333335,
     "gas": 3.0
   },
   "expect": {
diff --git a/verification/e2e/cases/g13b-unsure-alone.json b/verification/e2e/cases/g13b-unsure-alone.json
index a92e83c01..b262a3323 100644
--- a/verification/e2e/cases/g13b-unsure-alone.json
+++ b/verification/e2e/cases/g13b-unsure-alone.json
@@ -138,6 +138,7 @@
     }
   },
   "rules_assumed": {
+    "battery_width": 2.5833333333333335,
     "gas": 3.0
   },
   "expect": {
diff --git a/verification/e2e/cases/generate.py b/verification/e2e/cases/generate.py
index e30079fec..1377f0924 100644
--- a/verification/e2e/cases/generate.py
+++ b/verification/e2e/cases/generate.py
@@ -17,6 +17,8 @@
 # Battery footprint from the lane C review's parameter table: 31 in wide, 22 in deep.
 W = 31 / 12
 D = 11 / 6
+# Public server/rules.yaml route.corner_allowance_ft, a day-1 placeholder, not measured.
+CORNER_ALLOWANCE = 0.5
 METER_Y = 4.0
 # Walls placed at z = -D put a flush battery's front edge at z = 0 exactly in floating point,
 # so a gas strip at z = d is measured as exactly d. The margin cases need that: 3.3 - 0.3 and
@@ -159,7 +161,8 @@ def case(cid, source, description, scene, expect, rules_assumed=None):
             "source": source,
             "description": description,
             "scene": scene,
-            "rules_assumed": rules_assumed or {},
+            # The fixed fixture spans and sweep ranges were derived with this battery width.
+            "rules_assumed": {"battery_width": W} | (rules_assumed or {}),
             "expect": expect,
         }
     )
@@ -230,6 +233,7 @@ def straight_scene(x0, x1, z=0.0, meter_x=0.0, objects=(), ground=None, cov=None
         "sweep_runs": [{"wall_id": "w1", "start_ft": [-8.4, 6.9], "outcome": "fail"}],
         "missing_evidence_empty": True,
     },
+    {"corner_allowance": CORNER_ALLOWANCE},
 )
 
 # g05: inside corner, gas meter on the return wall at [4, 4].
@@ -258,7 +262,7 @@ def straight_scene(x0, x1, z=0.0, meter_x=0.0, objects=(), ground=None, cov=None
             {"wall_id": "w1", "start_ft": [6, 7.4], "outcome": "fail", "failing_match": "gas"}
         ],
     },
-    {"gas": 3.0},
+    {"gas": 3.0, "corner_allowance": CORNER_ALLOWANCE},
 )
 
 # g06: gas meter body 10 ft out, regulator reaching [7, 23/6].
@@ -448,7 +452,7 @@ def g10_scene(d, e, wall_pm=0.0):
             {"wall_id": "w2", "start_ft": [8, 11.4], "outcome": "fail", "failing_match": "gas"},
         ],
     },
-    {"gas": 3.0},
+    {"gas": 3.0, "corner_allowance": CORNER_ALLOWANCE},
 )
 
 # g11c: observed starts fail gas; the ground right of s = 1 was never seen (closed gate).
@@ -531,6 +535,7 @@ def g10_scene(d, e, wall_pm=0.0):
         "coverage": full_coverage((-3, 6 + W)),
     },
     {"spot": {"wall_id": "w1", "span_within": [6, 6 + W]}, "missing_evidence_empty": True},
+    {"corner_allowance": CORNER_ALLOWANCE},
 )
 
 
diff --git a/verification/hsverify/e2e.py b/verification/hsverify/e2e.py
index 7d7321584..6ce9cf93b 100644
--- a/verification/hsverify/e2e.py
+++ b/verification/hsverify/e2e.py
@@ -577,6 +577,15 @@ def resend(name: str, scene: dict) -> dict | None:
 HOSTILE_BUDGET_MS = 10_000.0
 
 
+HOSTILE_PROBE_NAMES = (
+    "hostile: 150 objects, each its own error",
+    "hostile: coordinates of 1e300 ft",
+    "hostile: a 5000 ft wall",
+    "hostile: nested 5000 deep",
+    "hostile: 400 MB scene.json in a small zip",
+)
+
+
 def hostile_inputs() -> list[SceneInput]:
     """Small requests that cost a careless server a lot. Built here, not stored, so the
     repository carries no blobs; none takes the harness more than a few MB to build."""
@@ -620,13 +629,11 @@ def hostile_inputs() -> list[SceneInput]:
     }
     nested = ('{"meter": ' + "[" * 5000 + "]" * 5000 + "}").encode()
     items = [
-        SceneInput(
-            "hostile: 150 objects, each its own error", crowded, json.dumps(crowded).encode()
-        ),
-        SceneInput("hostile: coordinates of 1e300 ft", huge, json.dumps(huge).encode()),
-        SceneInput("hostile: a 5000 ft wall", long_wall, json.dumps(long_wall).encode()),
-        SceneInput("hostile: nested 5000 deep", {}, nested),
-        SceneInput("hostile: 400 MB scene.json in a small zip", {}, b"", bundle=zip_bomb(400)),
+        SceneInput(HOSTILE_PROBE_NAMES[0], crowded, json.dumps(crowded).encode()),
+        SceneInput(HOSTILE_PROBE_NAMES[1], huge, json.dumps(huge).encode()),
+        SceneInput(HOSTILE_PROBE_NAMES[2], long_wall, json.dumps(long_wall).encode()),
+        SceneInput(HOSTILE_PROBE_NAMES[3], {}, nested),
+        SceneInput(HOSTILE_PROBE_NAMES[4], {}, b"", bundle=zip_bomb(400)),
     ]
     for item in items:
         item.hostile = True
@@ -676,7 +683,7 @@ def judge_hostile(
         }
     before = limit.reset() if limit else 0.0
     status, payload, ms = post(url, endpoint, item, timeout_s=HOSTILE_BUDGET_MS / 1000 + 5)
-    record = {"http_status": status, "latency_ms": round(ms, 1)}
+    record = {"http_status": status, "latency_ms": round(ms, 1), "hostile_probe_executed": True}
     grew = limit.peak_mb - before if limit else 0.0
     if limit:
         record["server_growth_mb"] = round(grew, 1)
@@ -720,10 +727,16 @@ def write_report(out: Path, meta: dict, records: list[dict]) -> dict:
     exported = [r for r in records if r.get("app_export")]
     contract_problems = sum(len(r.get("contract_problems", [])) for r in records)
     killed = bool(meta["peak_memory"].get("server_killed"))
+    all_passed = all(r["status"] == "pass" for r in records) and bool(checked) and not killed
+    contract_ok = bool(checked) and contract_problems == 0 and not killed
+    executed = sorted(
+        {r["name"] for r in records if r.get("hostile") and r.get("hostile_probe_executed") is True}
+    )
+    hostile_complete = set(HOSTILE_PROBE_NAMES).issubset(executed)
     report = meta | {
         "counts": counts,
         # A missing listed scene leaves the run incomplete, even when other scenes passed.
-        "all_passed": all(r["status"] == "pass" for r in records) and bool(checked) and not killed,
+        "all_passed": all_passed,
         "latency_ms": max(real) if real else None,
         "scenes_answered": sum(1 for r in records if "decision" in r),
         "scenes_checked": len(checked),
@@ -733,7 +746,12 @@ def write_report(out: Path, meta: dict, records: list[dict]) -> dict:
         # expectations are counted separately because a case can be wrong itself.
         "contract_problem_count": contract_problems,
         # The contract holds only on evidence: at least one scene checked, none broken.
-        "contract_ok": bool(checked) and contract_problems == 0 and not killed,
+        "contract_ok": contract_ok,
+        "hostile_probes_required": list(HOSTILE_PROBE_NAMES),
+        "hostile_probes_executed": executed,
+        "hostile_probes_complete": hostile_complete,
+        # Local --no-hostile success proves only that shortened run, not S2-8's full guarantee.
+        "full_contract_ok": all_passed and contract_ok and hostile_complete,
         "expectation_problem_count": sum(len(r.get("expectation_problems", [])) for r in records),
         "real_scene_passed": any(r.get("real") and r["status"] == "pass" for r in records),
         # Null when the run had no app export, so the scoreboard looks for an older run.
diff --git a/verification/scoreboard/metrics.yaml b/verification/scoreboard/metrics.yaml
index 2013f8c08..9d93cd12f 100644
--- a/verification/scoreboard/metrics.yaml
+++ b/verification/scoreboard/metrics.yaml
@@ -161,7 +161,8 @@ metrics:
     report:
       glob: ~/house-scanning-data/reports/e2e/*/report.json
       # True only when at least one scene was answered and checked and none broke the contract.
-      key: contract_ok
+      # Requires every hostile probe; shortened --no-hostile runs cannot satisfy this field.
+      key: full_contract_ok
       # A failed or incomplete run cannot establish the advertised black-box acceptance.
       valid_key: all_passed
       equals: true
diff --git a/verification/tests/test_e2e.py b/verification/tests/test_e2e.py
index a7707e1ec..e4900ffcb 100644
--- a/verification/tests/test_e2e.py
+++ b/verification/tests/test_e2e.py
@@ -549,3 +549,97 @@ def check_hash(scene, result, sent=None, rules=None):
     )
     assert calls and all(raw == json.dumps(scene, indent=1).encode() for scene, raw in calls)
     assert any("stale input hash" in p for p in failures)
+
+
+def hostile_records():
+    return [
+        {
+            "name": name,
+            "hostile": True,
+            "hostile_probe_executed": True,
+            "http_status": 422,
+            "latency_ms": 1.0,
+            "status": "pass",
+            "contract_problems": [],
+        }
+        for name in e2e.HOSTILE_PROBE_NAMES
+    ]
+
+
+@pytest.mark.parametrize("missing", range(5))
+def test_every_required_hostile_probe_must_be_exercised(tmp_path, missing):
+    probes = hostile_records()
+    omitted = probes.pop(missing)
+    probes.append(probes[0].copy())  # duplicate evidence cannot replace the missing probe
+    report = e2e.write_report(tmp_path, META, [CHECKED, *probes])
+    assert report["all_passed"] and report["contract_ok"]
+    assert not report["hostile_probes_complete"] and not report["full_contract_ok"]
+    assert omitted["name"] not in report["hostile_probes_executed"]
+
+
+def test_probe_name_without_execution_is_not_full_evidence(tmp_path):
+    probes = hostile_records()
+    del probes[0]["hostile_probe_executed"]
+    assert not e2e.write_report(tmp_path, META, [CHECKED, *probes])["full_contract_ok"]
+    assert e2e.write_report(tmp_path, META, [CHECKED, *hostile_records()])["full_contract_ok"]
+
+
+def test_hostile_execution_is_recorded_only_after_sending(monkeypatch):
+    monkeypatch.setattr(e2e, "post", lambda *args, **kwargs: (422, b"{}", 1.0))
+    probe = SceneInput(e2e.HOSTILE_PROBE_NAMES[0], {}, b"{}", hostile=True)
+    record = judge("unused", Endpoint("/place", "application/json"), probe, SCHEMAS, RULES)
+    assert record["hostile_probe_executed"] is True
+    probe.bundle = b"archive"
+    record = judge("unused", Endpoint("/place", "application/json"), probe, SCHEMAS, RULES)
+    assert not record.get("hostile_probe_executed", False)
+
+
+@pytest.mark.parametrize("no_hostile", [False, True])
+def test_cli_shortened_run_cannot_claim_full_contract(tmp_path, monkeypatch, no_hostile):
+    from pathlib import Path
+
+    # Only public rules are read. All HTTP, git and hostile payload generation are mocked.
+    public_rules = (Path(__file__).resolve().parents[2] / "server" / "rules.yaml").read_text()
+    cases = tmp_path / "cases"
+    cases.mkdir()
+    (cases / "scene.json").write_text(json.dumps(SCENE))
+    monkeypatch.setattr(e2e.gitref, "fetch", lambda: None)
+    monkeypatch.setattr(e2e.gitref, "resolve", lambda _: "a" * 40)
+    monkeypatch.setattr(
+        e2e.gitref, "show", lambda sha, path: public_rules if path.endswith("rules.yaml") else "{}"
+    )
+    monkeypatch.setattr(
+        e2e.urllib.request,
+        "urlopen",
+        lambda *args, **kwargs: io.BytesIO(json.dumps(openapi({"/place": json_op()})).encode()),
+    )
+    monkeypatch.setattr(
+        e2e,
+        "hostile_inputs",
+        lambda: [SceneInput(name, {}, b"{}", hostile=True) for name in e2e.HOSTILE_PROBE_NAMES],
+    )
+
+    def fake_judge(url, endpoint, probe, *args):
+        if probe.hostile:
+            return next(r for r in hostile_records() if r["name"] == probe.name)
+        return CHECKED | {"name": probe.name}
+
+    monkeypatch.setattr(e2e, "judge", fake_judge)
+    monkeypatch.setattr(e2e, "peak_rss_mb", lambda: {})
+    out = tmp_path / "out"
+    args = ["--server-url", "http://unused", "--cases", str(cases), "--out", str(out)]
+    if no_hostile:
+        args.append("--no-hostile")
+    assert e2e.main(args) == 0
+    data = json.loads((out / "report.json").read_text())
+    assert data["all_passed"] and data["contract_ok"]
+    assert data["full_contract_ok"] is (not no_hostile)
+    assert data["hostile_probes_executed"] == (
+        [] if no_hostile else sorted(e2e.HOSTILE_PROBE_NAMES)
+    )
+    from hsverify import scoreboard
+
+    metric = next(m for m in scoreboard.load_metrics()[1] if m.id == "S2-8")
+    metric.probe["glob"] = str(out / "report.json")
+    status = scoreboard.probe_report(metric.probe, data["sha"]).status
+    assert status == ("gap" if no_hostile else "met")
diff --git a/verification/tests/test_generate_cases.py b/verification/tests/test_generate_cases.py
index 01c7cdfac..a37800816 100644
--- a/verification/tests/test_generate_cases.py
+++ b/verification/tests/test_generate_cases.py
@@ -39,3 +39,81 @@ def test_the_committed_cases_are_what_the_generator_writes(tmp_path):
     committed = SCRIPT.parent
     for f in tmp_path.glob("*.json"):
         assert f.read_text() == (committed / f.name).read_text(), f.name
+
+
+def test_fixture_geometric_baselines_match_public_rules():
+    import yaml
+
+    rules = yaml.safe_load((SCRIPT.parents[3] / "server" / "rules.yaml").read_text())
+    assert pytest.approx(rules["battery"]["width_ft"]["value"]) == generate.W
+    assert rules["route"]["corner_allowance_ft"]["value"] == generate.CORNER_ALLOWANCE
+    for case in generate.CASES:
+        assert case["rules_assumed"]["battery_width"] == generate.W
+    for cid in [
+        "g03-negative-s-near-edge",
+        "g05-inside-corner-gas",
+        "g11b-both-ends-real-all-fail",
+        "g12b-exact-fit-last-start",
+    ]:
+        case = next(c for c in generate.CASES if c["id"] == cid)
+        assert case["rules_assumed"]["corner_allowance"] == generate.CORNER_ALLOWANCE
+
+
+@pytest.mark.parametrize("origin", ["committed", "generated"])
+@pytest.mark.parametrize("override", ["width", "corner"])
+def test_real_case_rule_override_skips_stale_expectation(tmp_path, monkeypatch, origin, override):
+    from dataclasses import replace
+
+    from hsverify import e2e
+    from hsverify.resultcheck import RuleSet, expectation_problems
+
+    if origin == "generated":
+        generate.main(tmp_path)
+        folder = tmp_path
+    else:
+        folder = SCRIPT.parent
+    fixture = e2e.load_input(folder / "g12b-exact-fit-last-start.json")
+    public = (SCRIPT.parents[3] / "server" / "rules.yaml").read_text()
+    baseline = RuleSet.from_yaml(public)
+    rules = (
+        replace(baseline, width_ft=4.0)
+        if override == "width"
+        else replace(baseline, corner_allowance_ft=10.0)
+    )
+    # A wider battery cannot fit the exact-width segment; a high corner allowance loses reach.
+    answer = {"decision": "reject", "spot": None, "checks": [], "sweep": []}
+    assert expectation_problems(fixture.expect, answer)  # stale fit assertion would fail
+    monkeypatch.setattr(
+        e2e, "post", lambda *args, **kwargs: (200, json.dumps(answer).encode(), 1.0)
+    )
+    monkeypatch.setattr(e2e, "schema_errors", lambda *args: [])
+    monkeypatch.setattr(e2e, "invariant_problems", lambda *args, **kwargs: [])
+    monkeypatch.setattr(e2e, "property_problems", lambda *args: [])
+
+    def forbidden(*args):
+        pytest.fail("a mismatched case must not apply its stale expectations")
+
+    monkeypatch.setattr(e2e, "expectation_problems", forbidden)
+    record = e2e.judge(
+        "unused",
+        e2e.Endpoint("/place", "application/json"),
+        fixture,
+        {"scene": {}, "result": {}},
+        rules,
+    )
+    assert record["status"] == "assumption mismatch" and record["assumption_mismatches"]
+    assert record["expectation_problems"] == []
+    meta = {
+        "peak_memory": {},
+        "server_ref": "public",
+        "server_sha": "a" * 40,
+        "started_at": "test",
+        "endpoint": "mock",
+        "load_average_1_5_15": [],
+    }
+    probes = [
+        {"name": name, "hostile": True, "hostile_probe_executed": True, "status": "pass"}
+        for name in e2e.HOSTILE_PROBE_NAMES
+    ]
+    report = e2e.write_report(tmp_path, meta, [record, *probes])
+    assert not report["all_passed"] and not report["full_contract_ok"]
diff --git a/verification/tests/test_scoreboard.py b/verification/tests/test_scoreboard.py
index a67c7111b..f8b2f5e44 100644
--- a/verification/tests/test_scoreboard.py
+++ b/verification/tests/test_scoreboard.py
@@ -700,3 +700,15 @@ def test_s2_contract_credit_requires_successful_full_run(tmp_path):
         100,
     )
     assert sb.probe_report(metric.probe, SHA).status == "gap"
+
+
+@pytest.mark.parametrize("full", [None, False, True])
+def test_s2_requires_hostile_execution_evidence_from_report(tmp_path, full):
+    metric = real_metric("S2-8")
+    metric.probe["glob"] = str(tmp_path / "*" / "report.json")
+    data = {"sha": SHA, "contract_ok": True, "all_passed": True}
+    if full is not None:
+        data["full_contract_ok"] = full
+    write_report(tmp_path / "r" / "report.json", data, 100)
+    status = sb.probe_report(metric.probe, SHA).status
+    assert (status == "met") is (full is True)

From b6bc4adbe8da850816f518cc696fbc10a96fc790 Mon Sep 17 00:00:00 2001
From: SamGu-NRX <sgu07966@gmail.com>
Date: Wed, 14 Oct 2026 11:26:53 -0500
Subject: [PATCH 46/62] test(live-dots): evaluate fog mutations before
 assertions

---
 .../ReplayPlaybackTests.swift                 | 99 ++++++++++++-------
 1 file changed, 66 insertions(+), 33 deletions(-)

diff --git a/experiments/live-dots/Tests/LiveDotsCoreTests/ReplayPlaybackTests.swift b/experiments/live-dots/Tests/LiveDotsCoreTests/ReplayPlaybackTests.swift
index 9cd737469..c002be63e 100644
--- a/experiments/live-dots/Tests/LiveDotsCoreTests/ReplayPlaybackTests.swift
+++ b/experiments/live-dots/Tests/LiveDotsCoreTests/ReplayPlaybackTests.swift
@@ -11,18 +11,22 @@ struct ReplayPlaybackTests {
         var continuity = FogContinuity()
         playback.togglePlayback()
         playback.tick(now: 0)
-        #expect(continuity.consume(request(playback)))
+        var resetsFog = continuity.consume(request(playback))
+        #expect(resetsFog)
         playback.tick(now: 0.2)
         let before = request(playback)
-        #expect(!continuity.consume(before))
+        resetsFog = continuity.consume(before)
+        #expect(!resetsFog)
         playback.scrub(to: 0)
         let after = request(playback)
         #expect(after.keyframe == before.keyframe)
         #expect(after.time == 0 && !after.isSettled)
         #expect(after.seekGeneration == before.seekGeneration + 1)
-        #expect(continuity.consume(after))
+        resetsFog = continuity.consume(after)
+        #expect(resetsFog)
         playback.tick(now: 0.3)
-        #expect(!continuity.consume(request(playback)))
+        resetsFog = continuity.consume(request(playback))
+        #expect(!resetsFog)
     }
 
     @Test func `natural playback eases across same and adjacent frames but explicit seeks reset`() {
@@ -30,16 +34,21 @@ struct ReplayPlaybackTests {
         var continuity = FogContinuity()
         playback.togglePlayback()
         playback.tick(now: 0)
-        #expect(continuity.consume(request(playback)))
+        var resetsFog = continuity.consume(request(playback))
+        #expect(resetsFog)
         playback.tick(now: 0.1)
-        #expect(!continuity.consume(request(playback)))
+        resetsFog = continuity.consume(request(playback))
+        #expect(!resetsFog)
         playback.tick(now: 0.3)
         #expect(playback.keyframe == 1)
-        #expect(!continuity.consume(request(playback)))
+        resetsFog = continuity.consume(request(playback))
+        #expect(!resetsFog)
         playback.scrub(to: 2)
-        #expect(continuity.consume(request(playback)))
+        resetsFog = continuity.consume(request(playback))
+        #expect(resetsFog)
         playback.scrub(to: 1)
-        #expect(continuity.consume(request(playback)))
+        resetsFog = continuity.consume(request(playback))
+        #expect(resetsFog)
     }
 
     @Test(arguments: [false, true]) func `resuming a settled scrub resets at the birth time`(reduceMotion: Bool) {
@@ -48,14 +57,17 @@ struct ReplayPlaybackTests {
         playback.scrub(to: 2)
         let preview = request(playback, reduceMotion: reduceMotion)
         #expect(preview.isSettled)
-        #expect(continuity.consume(preview))
+        var resetsFog = continuity.consume(preview)
+        #expect(resetsFog)
         playback.togglePlayback()
         let resumed = request(playback, reduceMotion: reduceMotion)
         #expect(resumed.time == Schedule.start(of: 2) && !resumed.isSettled)
         #expect(resumed.seekGeneration == preview.seekGeneration + 1)
         #expect(resumed.reduceMotion == reduceMotion)
-        #expect(continuity.consume(resumed))
-        #expect(!continuity.consume(resumed))
+        resetsFog = continuity.consume(resumed)
+        #expect(resetsFog)
+        resetsFog = continuity.consume(resumed)
+        #expect(!resetsFog)
     }
 
     @Test func `scrub and resume between rendered frames still invalidate the old mask`() {
@@ -63,13 +75,16 @@ struct ReplayPlaybackTests {
         var continuity = FogContinuity()
         playback.togglePlayback()
         playback.tick(now: 0)
-        #expect(continuity.consume(request(playback)))
+        var resetsFog = continuity.consume(request(playback))
+        #expect(resetsFog)
         playback.tick(now: 0.2)
-        #expect(!continuity.consume(request(playback)))
+        resetsFog = continuity.consume(request(playback))
+        #expect(!resetsFog)
         playback.togglePlayback()
         playback.scrub(to: 0)
         playback.togglePlayback()
-        #expect(continuity.consume(request(playback)))
+        resetsFog = continuity.consume(request(playback))
+        #expect(resetsFog)
     }
 
     @Test func `pause and resume without a scrub preserve the playhead and fog easing`() {
@@ -77,10 +92,12 @@ struct ReplayPlaybackTests {
         var continuity = FogContinuity()
         playback.togglePlayback()
         playback.tick(now: 0)
-        #expect(continuity.consume(request(playback)))
+        var resetsFog = continuity.consume(request(playback))
+        #expect(resetsFog)
         playback.tick(now: 0.2)
         let before = request(playback)
-        #expect(!continuity.consume(before))
+        resetsFog = continuity.consume(before)
+        #expect(!resetsFog)
         playback.togglePlayback()
         playback.tick(now: 5)
         playback.togglePlayback()
@@ -88,7 +105,8 @@ struct ReplayPlaybackTests {
         let resumed = request(playback)
         #expect(resumed.time == before.time)
         #expect(resumed.seekGeneration == before.seekGeneration)
-        #expect(!continuity.consume(resumed))
+        resetsFog = continuity.consume(resumed)
+        #expect(!resetsFog)
         playback.tick(now: 10.02)
         #expect(abs(playback.playhead - before.time - 0.02) < 1e-5)
     }
@@ -101,12 +119,14 @@ struct ReplayPlaybackTests {
         playback.tick(now: 10)
         #expect(!playback.isPlaying)
         let final = request(playback)
-        #expect(continuity.consume(final))
+        var resetsFog = continuity.consume(final)
+        #expect(resetsFog)
         playback.togglePlayback()
         let restarted = request(playback)
         #expect(restarted.keyframe == 0 && restarted.time == 0)
         #expect(restarted.seekGeneration == final.seekGeneration + 1)
-        #expect(continuity.consume(restarted))
+        resetsFog = continuity.consume(restarted)
+        #expect(resetsFog)
     }
 
     @Test func `mode changes fog reentry and settled previews invalidate continuity`() {
@@ -114,31 +134,44 @@ struct ReplayPlaybackTests {
         var continuity = FogContinuity()
         playback.togglePlayback()
         var frame = request(playback)
-        #expect(continuity.consume(frame))
-        #expect(!continuity.consume(frame))
+        var resetsFog = continuity.consume(frame)
+        #expect(resetsFog)
+        resetsFog = continuity.consume(frame)
+        #expect(!resetsFog)
         frame.mode = .noLidar
-        #expect(continuity.consume(frame))
-        #expect(!continuity.consume(frame))
+        resetsFog = continuity.consume(frame)
+        #expect(resetsFog)
+        resetsFog = continuity.consume(frame)
+        #expect(!resetsFog)
         frame.fog = .off
-        #expect(!continuity.consume(frame))
+        resetsFog = continuity.consume(frame)
+        #expect(!resetsFog)
         frame.fog = .on
-        #expect(continuity.consume(frame))
+        resetsFog = continuity.consume(frame)
+        #expect(resetsFog)
         frame.time = 1e5
-        #expect(continuity.consume(frame))
+        resetsFog = continuity.consume(frame)
+        #expect(resetsFog)
         frame.time = 0
-        #expect(continuity.consume(frame))
-        #expect(!continuity.consume(frame))
+        resetsFog = continuity.consume(frame)
+        #expect(resetsFog)
+        resetsFog = continuity.consume(frame)
+        #expect(!resetsFog)
     }
 
     @Test func `offscreen clock rewinds and nonadjacent jumps reset without a player`() {
         var continuity = FogContinuity()
         var frame = FrameRequest(mode: .lidar, keyframe: 0, time: 0.2, reduceMotion: false, fog: .on)
-        #expect(continuity.consume(frame))
+        var resetsFog = continuity.consume(frame)
+        #expect(resetsFog)
         frame.time = 0.1
-        #expect(continuity.consume(frame))
+        resetsFog = continuity.consume(frame)
+        #expect(resetsFog)
         frame.keyframe = 3
         frame.time = Schedule.start(of: 3)
-        #expect(continuity.consume(frame))
-        #expect(!continuity.consume(frame))
+        resetsFog = continuity.consume(frame)
+        #expect(resetsFog)
+        resetsFog = continuity.consume(frame)
+        #expect(!resetsFog)
     }
 }

From df7b75d7e142f1b94eda469b4320b66e1fcdfbb2 Mon Sep 17 00:00:00 2001
From: SamGu-NRX <sgu07966@gmail.com>
Date: Wed, 14 Oct 2026 11:33:54 -0500
Subject: [PATCH 47/62] fix(verification): bound sweep sampling before geometry
 checks

---
 verification/hsverify/resultcheck.py   | 53 ++++++++++++++++++----
 verification/tests/test_resultcheck.py | 63 ++++++++++++++++++++++++--
 2 files changed, 105 insertions(+), 11 deletions(-)

diff --git a/verification/hsverify/resultcheck.py b/verification/hsverify/resultcheck.py
index e1ab5a718..2ea978f2a 100644
--- a/verification/hsverify/resultcheck.py
+++ b/verification/hsverify/resultcheck.py
@@ -29,7 +29,7 @@
 import hashlib
 import itertools
 import math
-from collections.abc import Callable
+from collections.abc import Callable, Iterator
 from dataclasses import dataclass
 from typing import Any
 
@@ -38,6 +38,8 @@
 
 EPS = 1e-6
 NUMBER_TOL_FT = 1e-5
+# Bound verifier work even when a server span or rules step requests billions of samples.
+MAX_SWEEP_SAMPLES = 10_000
 # Spot centres and offsets are rounded by the server; a hundredth of a foot is 1/8 inch.
 OFFSET_TOL_FT = 0.01
 
@@ -306,6 +308,8 @@ def margin_problem(check: dict) -> str | None:
 def invariant_problems(
     scene: dict, result: dict, sent: bytes | None = None, rules: RuleSet | None = None
 ) -> list[str]:
+    if rules is not None and (sampling := sweep_sampling_problems(scene, result, rules)):
+        return sampling
     problems: list[str] = []
     decision = result["decision"]
     spot = result.get("spot")
@@ -419,6 +423,8 @@ def footprint_problems(scene: dict, result: dict, rules: RuleSet) -> list[str]:
     """A battery that passes or is left to a person backs onto one straight stretch of scanned
     wall along its whole width; a footprint past the stretch's end (a corner, the end of the
     wall, a gap) can't sit flush, so the server fails it (server/solver.py check_backing)."""
+    if sampling := sweep_sampling_problems(scene, result, rules):
+        return sampling
     pieces = straight_pieces(scene, rules)
     if not pieces:
         return []
@@ -673,17 +679,44 @@ def measured_band_gap(
     return None
 
 
-def run_starts(span: list[float], step_ft: float | None) -> list[float]:
-    """Starts sampled from a sweep run: its first, every step after it, and its last.
+def run_starts(span: list[float], step_ft: float | None) -> Iterator[float]:
+    """Validate eagerly, then sample a run lazily: first, every step after it, and last.
 
     A sample, not the server's own list: the server also evaluates boundaries and midpoints
-    that a run reports only as its two ends."""
-    if step_ft is None or step_ft <= 0:
-        raise ValueError("checking a sweep run needs the rules' sweep.step_ft")
+    that a run reports only as its two ends. Oversized runs fail rather than lose coverage
+    through truncation."""
+    if step_ft is None or not math.isfinite(step_ft) or step_ft <= 0:
+        raise ValueError("checking a sweep run needs finite positive rules' sweep.step_ft")
     a, b = span
+    if not math.isfinite(a) or not math.isfinite(b) or a > b:
+        raise ValueError("sweep start_ft must be finite and ordered")
+    steps = (b - a) / step_ft
+    if not math.isfinite(steps) or steps > MAX_SWEEP_SAMPLES:
+        raise ValueError(f"sweep sampling exceeds the {MAX_SWEEP_SAMPLES} sample limit")
     # Every step strictly before the last start, the first included however short the run.
-    count = max(0, math.ceil((b - a) / step_ft - EPS))
-    return [a + k * step_ft for k in range(count)] + [b]
+    count = max(int(a < b), math.ceil(steps - EPS))
+    if count + 1 > MAX_SWEEP_SAMPLES:
+        raise ValueError(f"sweep sampling exceeds the {MAX_SWEEP_SAMPLES} sample limit")
+    return itertools.chain((a + k * step_ft for k in range(count)), (b,))
+
+
+def sweep_sampling_problems(scene: dict, result: dict, rules: RuleSet) -> list[str]:
+    """Reject invalid runs before footprint, coverage or height checks sample them."""
+    ends = chain_ends_s(scene, rules)
+    problems = []
+    for run in result.get("sweep", []):
+        if run["outcome"] not in ("pass", "unsure"):
+            continue
+        a, b = run["start_ft"]
+        prefix = f"sweep {run['outcome']} starts {run['start_ft']}: "
+        if ends is not None and (a < ends[0] - COLLINEAR_FT or b > ends[1] + COLLINEAR_FT):
+            problems.append(prefix + f"start_ft span exceeds scanned range [{ends[0]}, {ends[1]}]")
+            continue
+        try:
+            run_starts(run["start_ft"], rules.step_ft)
+        except ValueError as exc:
+            problems.append(prefix + str(exc))
+    return problems
 
 
 # Checks every result lists besides those with coverage needs (server README, "What settles
@@ -717,6 +750,8 @@ def coverage_problems(scene: dict, result: dict, rules: RuleSet) -> list[str]:
     check's area around that start's battery with that battery's own position error, and the
     wall and cable route back to the meter over the whole run. Checking the whole run as one
     battery at its farthest start's error would ask for more than any single start needs."""
+    if sampling := sweep_sampling_problems(scene, result, rules):
+        return sampling
     problems: list[str] = []
     route_wall = observed(
         scene, "wall", rules.route_height_ft, beyond=True, wall_default_ft=rules.headroom_ft
@@ -1048,6 +1083,8 @@ def declared_height_problems(scene: dict, result: dict, rules: RuleSet) -> list[
     it unsure for one within the battery's error of it (server/solver.py at 7133283,
     check_backing), so wall_backing passes only if every declared wall overlapping
     [s0 - e, s1 + e] is taller than battery.height_ft."""
+    if sampling := sweep_sampling_problems(scene, result, rules):
+        return sampling
     declared = {w["id"]: w["height_ft"] for w in scene.get("walls", []) if "height_ft" in w}
     if not declared or rules.battery_height_ft is None:
         return []
diff --git a/verification/tests/test_resultcheck.py b/verification/tests/test_resultcheck.py
index 08935bd3a..526a11bba 100644
--- a/verification/tests/test_resultcheck.py
+++ b/verification/tests/test_resultcheck.py
@@ -6,6 +6,7 @@
 import pytest
 
 from hsverify.resultcheck import (
+    MAX_SWEEP_SAMPLES,
     GroundPlan,
     Need,
     RuleSet,
@@ -875,8 +876,8 @@ def test_each_start_in_a_sweep_run_needs_only_its_own_reach():
 
 
 def test_sweep_run_starts_are_sampled_at_the_rules_step_plus_the_ends():
-    assert run_starts([1.0, 1.5], 1 / 6) == pytest.approx([1.0, 7 / 6, 8 / 6, 1.5])
-    assert run_starts([2.0, 2.0], 1 / 6) == [2.0]
+    assert list(run_starts([1.0, 1.5], 1 / 6)) == pytest.approx([1.0, 7 / 6, 8 / 6, 1.5])
+    assert list(run_starts([2.0, 2.0], 1 / 6)) == [2.0]
     with pytest.raises(ValueError, match=r"sweep\.step_ft"):
         run_starts([1.0, 2.0], None)
 
@@ -1083,7 +1084,7 @@ def test_a_captured_request_claims_only_the_reach_it_asked_for():
 
 def test_a_sweep_run_shorter_than_a_step_keeps_its_first_start():
     # Review 4114352251: run_starts([0, 0.4], 1) returned only 0.4.
-    assert run_starts([0.0, 0.4], 1.0) == [0.0, 0.4]
+    assert list(run_starts([0.0, 0.4], 1.0)) == [0.0, 0.4]
 
 
 def test_a_passing_spot_must_pass_in_the_sweep_too():
@@ -1508,3 +1509,59 @@ def test_geometric_assumptions_compare_active_rules():
         assumption_mismatches({"battery_width": rules.width_ft, "corner_allowance": 0.5}, {}, rules)
         == []
     )
+
+
+@pytest.mark.parametrize("outcome", ["pass", "unsure"])
+@pytest.mark.parametrize("span", [[0, 1e9], [-1e9, 0], [1e9, 1e9]])
+def test_out_of_scan_sweep_fails_before_sampling(monkeypatch, outcome, span):
+    def no_sampling(*args):
+        pytest.fail("out-of-scan sweep reached sampling")
+
+    monkeypatch.setattr("hsverify.resultcheck.run_starts", no_sampling)
+    r = result(spot=False, sweep=[pass_run(*span) | {"outcome": outcome}])
+    message = f"sweep {outcome} starts {span}: start_ft span exceeds scanned range [-12.0, 12.0]"
+    for judge in (
+        invariant_problems,
+        footprint_problems,
+        coverage_problems,
+        declared_height_problems,
+    ):
+        assert judge(SCENE, r, rules=RULES) == [message]
+
+
+def test_sweep_sampling_is_lazy_and_keeps_the_limit_endpoint():
+    samples = run_starts([0, MAX_SWEEP_SAMPLES - 1], 1)
+    assert iter(samples) is samples
+    assert next(samples) == 0
+    remaining = list(samples)
+    assert len(remaining) == MAX_SWEEP_SAMPLES - 1
+    assert remaining[-1] == MAX_SWEEP_SAMPLES - 1
+    assert list(run_starts([0, 1e-9], 1)) == [0, 1e-9]
+
+
+@pytest.mark.parametrize(
+    "span,step",
+    [([0, 1e9], 1 / 6), ([0, MAX_SWEEP_SAMPLES], 1), ([0, 1], 1e-300), ([-1e308, 1e308], 1)],
+)
+def test_sweep_sample_limit_is_checked_before_iteration(span, step):
+    with pytest.raises(ValueError, match="10000 sample limit"):
+        run_starts(span, step)
+
+
+@pytest.mark.parametrize("span", [[2, 1], [0, float("inf")], [float("nan"), 1]])
+def test_sweep_sampler_refuses_invalid_spans(span):
+    with pytest.raises(ValueError, match="finite and ordered"):
+        run_starts(span, 1)
+
+
+@pytest.mark.parametrize("step", [None, 0, -1, float("inf"), float("nan")])
+def test_sweep_sampler_refuses_invalid_steps(step):
+    with pytest.raises(ValueError, match="finite positive"):
+        run_starts([0, 1], step)
+
+
+def test_in_scan_sweep_with_tiny_rule_step_fails_loudly():
+    r = result(spot=False, sweep=[pass_run(0, 1) | {"outcome": "unsure"}])
+    assert invariant_problems(SCENE, r, rules=replace(RULES, step_ft=1e-300)) == [
+        "sweep unsure starts [0, 1]: sweep sampling exceeds the 10000 sample limit"
+    ]

From aaacc0fc0c5e50b94c7a461aa394dd06b8f8d42d Mon Sep 17 00:00:00 2001
From: SamGu-NRX <sgu07966@gmail.com>
Date: Wed, 14 Oct 2026 11:44:51 -0500
Subject: [PATCH 48/62] fix(verification): distinguish reported rules from
 public assumptions

---
 recon/HANDOFF.md                          |  5 +-
 verification/README.md                    |  8 ++
 verification/hsverify/e2e.py              | 65 +++++++++++++---
 verification/hsverify/resultcheck.py      | 73 ++++++++++++------
 verification/tests/test_e2e.py            | 94 +++++++++++++++++++++--
 verification/tests/test_generate_cases.py |  5 +-
 verification/tests/test_resultcheck.py    | 94 +++++++++++++++++++++--
 7 files changed, 298 insertions(+), 46 deletions(-)

diff --git a/recon/HANDOFF.md b/recon/HANDOFF.md
index b952169d2..0f26dd199 100644
--- a/recon/HANDOFF.md
+++ b/recon/HANDOFF.md
@@ -128,10 +128,13 @@ In `recon/` on this branch:
 
 These defects remain after the review-debt repairs. They can let the server settle a check on evidence the worker does not have. The saved ETH3D results above predate those repairs; dataset acceptance has not been rerun.
 
-- **One view can count as two for free space.** `recon/coverage.py:189-193, 208-246`: `_slab` treats a voxel as observed when its fused weight is above zero, and any single frame gives it weight. Repro: a capture in which one frame alone sees the space in front of a wall cell reports a facing clearance there. Wall and ground cells need two positions 0.25 m apart for the same claim. The server at 903d86f can settle a check on that clearance. A fix needs visibility kept per frame for free space, with the same two-position test as the wall and ground.
 - **The overhead strip is narrower than a battery.** `recon/coverage.py:42, 236-245`: overhead space is sampled only 0.10 to 0.56 m out from the wall front. Repro: an eave 0.05 m out from the wall, or 0.7 m out over a 3 ft deep battery, is not found, and the cell reports clearance above it. A fix needs the footprint of the battery the chosen rule places, passed from the server's rules or request.
 - **The photos-only clearance error is not calibrated.** `recon/pipeline.py:29-35`: facing gaps and overhead clearances from photos carry ±0.56 ft. That comes from the 95% interval of the evals' surface pair-error p90 over 1 to 3 m spans, not from any measurement of where the fused volume puts a boundary. The evals put surface p90 at 5.64 in [4.63, 6.66] and edges at 9.65 in [4.93, 15.01]. Repro: a photos-only overhead clearance measured at 7.10 ft passes the 6.5 ft headroom rule, since 7.10 − 0.56 = 6.54 > 6.5. A fix needs the clearance estimator's own measured uncertainty, or a gate that returns the check unresolved until that exists.
 
+### Fixed in the worker
+
+Free-space coverage now uses `SeenFromTwo` in `compute()`: facing and overhead samples need visibility from two camera positions at least 0.25 m apart. One-view and nearby-camera regressions are in `tests/test_coverage_views.py`.
+
 The worker now replaces the target wall's prior measurements, stops clearance at any occupied sampled voxel, and refuses LiDAR without a confidence map. Ground coverage follows the fitted slope, and only whole cells within the fitted wall extent are exported. The regressions are in `tests/test_review_debt.py`; they do not validate the remaining clearance policies above.
 
 ## 7. Data
diff --git a/verification/README.md b/verification/README.md
index b20d4031c..3862d5a14 100644
--- a/verification/README.md
+++ b/verification/README.md
@@ -19,6 +19,14 @@ Reports go to `~/house-scanning-data/reports/`, outside git, because replay fram
 non-commercial datasets. What each check asserts is in the docstrings of `hsverify/e2e.py`,
 `resultcheck.py` and `simrun.py`.
 
+When a case's battery width or corner allowance differs from public rules, e2e uses the
+value reported in the result's spot or rule-keyed check threshold. If the result omits it,
+the report says "assumed public rules; server may override" and marks the case
+`assumptions unverified`. It skips the rule-dependent checks and case expectations, while
+retaining rule-independent invariants. These records cannot establish acceptance. Exit
+code 2 means the run is inconclusive for this reason; exit code 1 still means another
+failure or incomplete check. The verifier does not read private backend files.
+
 **Result.** At `t3/server` `3baa338`, with the app's upload from `c820cf1` (#10's freeze, synthetic
 replay, hosted server), 49 of 50 scenes pass (45 answered and checked; slowest real scene 0.48 s).
 The ETH3D scene fails: after its one requested capture the server leaves pool unsure with no
diff --git a/verification/hsverify/e2e.py b/verification/hsverify/e2e.py
index 939a0d9d3..0c57c3540 100644
--- a/verification/hsverify/e2e.py
+++ b/verification/hsverify/e2e.py
@@ -72,6 +72,8 @@
     mirror_scene,
     more_error_problems,
     outcome_lengths,
+    public_assumption_warnings,
+    reported_rules,
     schema_errors,
     tape_to_tap,
     unobserved_checks,
@@ -575,23 +577,44 @@ def judge(
     if problems:
         return record | {"status": "fail", "problems": problems[:20], "contract_problems": problems}
 
-    # Contract problems hold for any scene; expectation problems depend on one case's geometry.
-    contract = invariant_problems(item.scene, result, sent=item.raw, rules=rules)
-    contract += property_problems(url, endpoint, item, result, schemas, rules)
+    # Unreported overrides cannot establish rule-dependent geometry or case expectations.
+    mismatches = assumption_mismatches(item.rules_assumed, result)
+    warnings = public_assumption_warnings(item.rules_assumed, result, rules)
+    active_rules = reported_rules(result, rules)
+    contract = invariant_problems(
+        item.scene, result, sent=item.raw, rules=None if warnings else active_rules
+    )
+    if not warnings:
+        contract += property_problems(url, endpoint, item, result, schemas, active_rules)
+    else:
+        record["rule_checks_unverified"] = True
     if item.real and ms > LATENCY_BUDGET_MS:
         contract.append(f"real-derived scene took {ms:.0f} ms, budget {LATENCY_BUDGET_MS:.0f}")
-    mismatches = assumption_mismatches(item.rules_assumed, result, rules)
-    expected = expectation_problems(item.expect, result) if item.expect and not mismatches else []
+    expected = (
+        expectation_problems(item.expect, result)
+        if item.expect and not mismatches and not warnings
+        else []
+    )
     problems = contract + expected
 
     record["decision"] = result["decision"]
     record["outcome_lengths_ft"] = outcome_lengths(result)
     if mismatches:
         record["assumption_mismatches"] = mismatches
+    if warnings:
+        record["assumption_warnings"] = warnings
     record["contract_problems"] = contract
     record["expectation_problems"] = expected
     record["problems"] = problems
-    record["status"] = "fail" if problems else "assumption mismatch" if mismatches else "pass"
+    record["status"] = (
+        "fail"
+        if problems
+        else "assumption mismatch"
+        if mismatches
+        else "assumptions unverified"
+        if warnings
+        else "pass"
+    )
     return record
 
 
@@ -615,7 +638,9 @@ def resend(name: str, scene: dict) -> dict | None:
             return None
         problems.extend(
             f"{name}: {p}"
-            for p in invariant_problems(scene, other, sent=transformed.raw, rules=rules)
+            for p in invariant_problems(
+                scene, other, sent=transformed.raw, rules=reported_rules(other, rules)
+            )
         )
         return other
 
@@ -838,7 +863,12 @@ def write_report(out: Path, meta: dict, records: list[dict]) -> dict:
     contract_problems = sum(len(r.get("contract_problems", [])) for r in records)
     killed = bool(meta["peak_memory"].get("server_killed"))
     all_passed = all(r["status"] == "pass" for r in records) and bool(checked) and not killed
-    contract_ok = bool(checked) and contract_problems == 0 and not killed
+    contract_ok = (
+        bool(checked)
+        and contract_problems == 0
+        and not killed
+        and not any(r.get("rule_checks_unverified") for r in checked)
+    )
     executed = sorted(
         {r["name"] for r in records if r.get("hostile") and r.get("hostile_probe_executed") is True}
     )
@@ -897,7 +927,11 @@ def write_report(out: Path, meta: dict, records: list[dict]) -> dict:
         "| --- | --- | --- | --- | --- |",
     ]
     for r in records:
-        issues = "; ".join(r.get("problems", []) + r.get("assumption_mismatches", []))
+        issues = "; ".join(
+            r.get("problems", [])
+            + r.get("assumption_mismatches", [])
+            + r.get("assumption_warnings", [])
+        )
         issues = issues or r.get("skip_reason", "")
         lines.append(
             f"| {r['name']}{' (real)' if r.get('real') else ''} | {r['status']} | "
@@ -996,7 +1030,7 @@ def main(argv: list[str] | None = None) -> int:
                     else ""
                 )
             )
-            for problem in record.get("problems", [])[:6]:
+            for problem in (record.get("problems", []) + record.get("assumption_warnings", []))[:6]:
                 print(f"      - {problem}")
 
     meta = {
@@ -1016,7 +1050,16 @@ def main(argv: list[str] | None = None) -> int:
     }
     report = write_report(out, meta, records)
     print(f"Report: {out / 'report.md'}")
-    return 0 if report["all_passed"] else 1
+    if report["all_passed"]:
+        return 0
+    # An unreported override is incomplete evidence, not a proven server failure.
+    if (
+        not meta["peak_memory"].get("server_killed")
+        and all(r["status"] in ("pass", "assumptions unverified") for r in records)
+        and any(r["status"] == "assumptions unverified" for r in records)
+    ):
+        return 2
+    return 1
 
 
 if __name__ == "__main__":
diff --git a/verification/hsverify/resultcheck.py b/verification/hsverify/resultcheck.py
index acc57cc74..d24120c73 100644
--- a/verification/hsverify/resultcheck.py
+++ b/verification/hsverify/resultcheck.py
@@ -30,7 +30,7 @@
 import itertools
 import math
 from collections.abc import Callable, Iterator
-from dataclasses import dataclass
+from dataclasses import dataclass, replace
 from typing import Any
 
 import yaml
@@ -1149,28 +1149,57 @@ def with_past_ends_asked(scene: dict, requests: list[dict], rules: RuleSet) -> d
 # --- Case expectations -----------------------------------------------------------------------
 
 
-def assumption_mismatches(
-    assumed: dict[str, float], result: dict, rules: RuleSet | None = None
+def reported_assumption_values(key: str, result: dict) -> list[tuple[str, float]]:
+    """Rule values carried by C2 spots or check thresholds, without reading server files."""
+    values = []
+    if key == "battery_width":
+        for name in ("spot", "nearest_considered"):
+            spot = result.get(name)
+            if spot is not None and "width_ft" in spot:
+                values.append((f"{name}.width_ft", spot["width_ft"]))
+    rule_key = {
+        "battery_width": "battery.width_ft",
+        "corner_allowance": "route.corner_allowance_ft",
+    }.get(key)
+    for check in result.get("checks", []):
+        threshold = check.get("threshold_ft")
+        matches = check.get("rule", {}).get("key") == rule_key if rule_key else key in check["id"]
+        if matches and threshold is not None:
+            values.append((check["id"], threshold))
+    return values
+
+
+def reported_rules(result: dict, rules: RuleSet) -> RuleSet:
+    """Use reported geometry for invariants too, so public defaults cannot reject an override."""
+    changes = {}
+    for key, field in (("battery_width", "width_ft"), ("corner_allowance", "corner_allowance_ft")):
+        if values := reported_assumption_values(key, result):
+            changes[field] = values[0][1]
+    return replace(rules, **changes)
+
+
+def assumption_mismatches(assumed: dict[str, float], result: dict) -> list[str]:
+    return [
+        f"case assumes {key} threshold {value}, server's {source} uses {actual}"
+        for key, value in assumed.items()
+        for source, actual in reported_assumption_values(key, result)
+        if abs(actual - value) > EPS
+    ]
+
+
+def public_assumption_warnings(
+    assumed: dict[str, float], result: dict, rules: RuleSet
 ) -> list[str]:
-    out = []
-    configured = (
-        {"battery_width": rules.width_ft, "corner_allowance": rules.corner_allowance_ft}
-        if rules
-        else {}
-    )
-    for key, value in assumed.items():
-        actual = configured.get(key)
-        if actual is not None and abs(actual - value) > EPS:
-            out.append(f"case assumes {key} {value}, rules use {actual}")
-    for key, value in assumed.items():
-        for check in result.get("checks", []):
-            threshold = check.get("threshold_ft")
-            if key in check["id"] and threshold is not None and abs(threshold - value) > EPS:
-                out.append(
-                    f"case assumes {key} threshold {value}, server's {check['id']} uses "
-                    f"{check['threshold_ft']}"
-                )
-    return out
+    configured = {"battery_width": rules.width_ft, "corner_allowance": rules.corner_allowance_ft}
+    return [
+        f"case assumes {key} {value}, public rules use {configured[key]}; "
+        "assumed public rules; server may override; result does not report this value, "
+        "so case expectations are unverified"
+        for key, value in assumed.items()
+        if configured.get(key) is not None
+        and not reported_assumption_values(key, result)
+        and abs(configured[key] - value) > EPS
+    ]
 
 
 def expectation_problems(expect: dict, result: dict) -> list[str]:
diff --git a/verification/tests/test_e2e.py b/verification/tests/test_e2e.py
index b7dddf81c..b7b9102e5 100644
--- a/verification/tests/test_e2e.py
+++ b/verification/tests/test_e2e.py
@@ -6,6 +6,7 @@
 import threading
 import time
 import zipfile
+from dataclasses import replace
 from http.server import BaseHTTPRequestHandler, HTTPServer, ThreadingHTTPServer
 from typing import ClassVar
 
@@ -867,7 +868,10 @@ def test_hostile_execution_is_recorded_only_after_sending(monkeypatch):
 
 
 @pytest.mark.parametrize("no_hostile", [False, True])
-def test_cli_shortened_run_cannot_claim_full_contract(tmp_path, monkeypatch, no_hostile):
+@pytest.mark.parametrize("unverified", [False, True])
+def test_cli_shortened_run_cannot_claim_full_contract(
+    tmp_path, monkeypatch, no_hostile, unverified
+):
     from pathlib import Path
 
     # Only public rules are read. All HTTP, git and hostile payload generation are mocked.
@@ -894,7 +898,19 @@ def test_cli_shortened_run_cannot_claim_full_contract(tmp_path, monkeypatch, no_
     def fake_judge(url, endpoint, probe, *args):
         if probe.hostile:
             return next(r for r in hostile_records() if r["name"] == probe.name)
-        return CHECKED | {"name": probe.name}
+        return (
+            CHECKED
+            | {"name": probe.name}
+            | (
+                {
+                    "status": "assumptions unverified",
+                    "rule_checks_unverified": True,
+                    "assumption_warnings": ["assumed public rules; server may override"],
+                }
+                if unverified
+                else {}
+            )
+        )
 
     monkeypatch.setattr(e2e, "judge", fake_judge)
     monkeypatch.setattr(e2e, "peak_rss_mb", lambda: {})
@@ -902,10 +918,11 @@ def fake_judge(url, endpoint, probe, *args):
     args = ["--server-url", "http://unused", "--cases", str(cases), "--out", str(out)]
     if no_hostile:
         args.append("--no-hostile")
-    assert e2e.main(args) == 0
+    assert e2e.main(args) == (2 if unverified else 0)
     data = json.loads((out / "report.json").read_text())
-    assert data["all_passed"] and data["contract_ok"]
-    assert data["full_contract_ok"] is (not no_hostile)
+    assert data["all_passed"] is (not unverified)
+    assert data["contract_ok"] is (not unverified)
+    assert data["full_contract_ok"] is (not no_hostile and not unverified)
     assert data["hostile_probes_executed"] == (
         [] if no_hostile else sorted(e2e.HOSTILE_PROBE_NAMES)
     )
@@ -914,4 +931,69 @@ def fake_judge(url, endpoint, probe, *args):
     metric = next(m for m in scoreboard.load_metrics()[1] if m.id == "S2-8")
     metric.probe["glob"] = str(out / "report.json")
     status = scoreboard.probe_report(metric.probe, data["sha"]).status
-    assert status == ("gap" if no_hostile else "met")
+    assert status == ("gap" if no_hostile or unverified else "met")
+
+
+@pytest.mark.parametrize("reported_width", [None, 31 / 12, 4])
+@pytest.mark.parametrize("contract_failure", [False, True])
+def test_judge_distinguishes_reported_override_mismatch_and_unverified_defaults(
+    tmp_path, monkeypatch, reported_width, contract_failure
+):
+    answer = {"decision": "manual_review", "spot": None, "checks": [], "sweep": []}
+    if reported_width is not None:
+        answer["checks"] = [
+            {
+                "id": "wall_backing",
+                "threshold_ft": reported_width,
+                "rule": {"key": "battery.width_ft"},
+            }
+        ]
+    monkeypatch.setattr(e2e, "post", lambda *args: (200, json.dumps(answer).encode(), 1))
+    monkeypatch.setattr(e2e, "schema_errors", lambda *args: [])
+    seen = []
+
+    def invariants(scene, result, sent=None, rules=None):
+        seen.append(None if rules is None else rules.width_ft)
+        return (
+            ["stats.input_sha256 does not match the scene bytes sent"] if contract_failure else []
+        )
+
+    monkeypatch.setattr(e2e, "invariant_problems", invariants)
+    properties = []
+    monkeypatch.setattr(
+        e2e, "property_problems", lambda *args: properties.append(args[-1].width_ft) or []
+    )
+    expectations = []
+    monkeypatch.setattr(e2e, "expectation_problems", lambda *args: expectations.append(True) or [])
+    item = SceneInput(
+        "override",
+        SCENE,
+        b"{}",
+        expect={"decision_in": ["manual_review"]},
+        rules_assumed={"battery_width": 31 / 12},
+    )
+    record = judge(
+        "unused", Endpoint("/place", "application/json"), item, SCHEMAS, replace(RULES, width_ft=4)
+    )
+    assert seen == [reported_width]
+    if contract_failure:
+        assert record["status"] == "fail" and record["contract_problems"]
+        assert record["problems"] == ["stats.input_sha256 does not match the scene bytes sent"]
+    else:
+        assert record["problems"] == []
+    if reported_width is None:
+        assert record["status"] == ("fail" if contract_failure else "assumptions unverified")
+        assert "assumed public rules; server may override" in record["assumption_warnings"][0]
+        assert not properties and not expectations
+    elif reported_width == 31 / 12:
+        assert record["status"] == ("fail" if contract_failure else "pass")
+        assert properties == [31 / 12] and expectations == [True]
+    else:
+        assert record["status"] == ("fail" if contract_failure else "assumption mismatch")
+        assert record["assumption_mismatches"] and not expectations
+    report = e2e.write_report(tmp_path, META, [record, *hostile_records()])
+    assert report["all_passed"] is (reported_width == 31 / 12 and not contract_failure)
+    assert report["full_contract_ok"] is (reported_width == 31 / 12 and not contract_failure)
+    if reported_width is None:
+        assert not report["contract_ok"]
+        assert "assumed public rules; server may override" in (tmp_path / "report.md").read_text()
diff --git a/verification/tests/test_generate_cases.py b/verification/tests/test_generate_cases.py
index a37800816..4e7a4b4fb 100644
--- a/verification/tests/test_generate_cases.py
+++ b/verification/tests/test_generate_cases.py
@@ -101,7 +101,10 @@ def forbidden(*args):
         {"scene": {}, "result": {}},
         rules,
     )
-    assert record["status"] == "assumption mismatch" and record["assumption_mismatches"]
+    assert record["status"] == "assumptions unverified" and record["assumption_warnings"]
+    assert "assumed public rules; server may override" in record["assumption_warnings"][0]
+    assert record["rule_checks_unverified"]
+    assert record["contract_problems"] == []
     assert record["expectation_problems"] == []
     meta = {
         "peak_memory": {},
diff --git a/verification/tests/test_resultcheck.py b/verification/tests/test_resultcheck.py
index 11826df86..2a16bc044 100644
--- a/verification/tests/test_resultcheck.py
+++ b/verification/tests/test_resultcheck.py
@@ -29,7 +29,9 @@
     observed,
     outcome_at,
     outcome_lengths,
+    public_assumption_warnings,
     reach_gaps,
+    reported_rules,
     run_starts,
     straight_pieces,
     tape_to_tap,
@@ -1558,17 +1560,89 @@ def test_ground_trimming_keeps_omitted_reach_at_zero():
     assert trimmed["coverage"]["observed"][0]["out_ft"] == 0
 
 
-def test_geometric_assumptions_compare_active_rules():
-    rules = replace(RULES, corner_allowance_ft=0.5)
+def test_geometric_assumptions_use_reported_override_instead_of_public_defaults():
+    public = replace(RULES, width_ft=4, corner_allowance_ft=10)
+    answer = result()
+    answer["checks"].append(
+        {
+            "id": "corner_allowance",
+            "threshold_ft": 0.5,
+            "rule": {"key": "route.corner_allowance_ft"},
+        }
+    )
+    assumed = {"battery_width": RULES.width_ft, "corner_allowance": 0.5}
+    assert assumption_mismatches(assumed, answer) == []
+    assert public_assumption_warnings(assumed, answer, public) == []
+    active = reported_rules(answer, public)
+    assert (active.width_ft, active.corner_allowance_ft) == (RULES.width_ft, 0.5)
+    assert (public.width_ft, public.corner_allowance_ft) == (4, 10)
+
+
+def test_geometric_assumptions_detect_a_real_reported_mismatch():
+    answer = {
+        "spot": {"width_ft": 4},
+        "checks": [
+            {
+                "id": "route_corner",
+                "threshold_ft": 10,
+                "rule": {"key": "route.corner_allowance_ft"},
+            }
+        ],
+    }
     assert (
-        len(assumption_mismatches({"battery_width": 100, "corner_allowance": 100}, {}, rules)) == 2
+        len(
+            assumption_mismatches(
+                {"battery_width": RULES.width_ft, "corner_allowance": 0.5}, answer
+            )
+        )
+        == 2
     )
+
+
+def test_unreported_geometric_override_is_a_warning_not_a_mismatch():
+    public = replace(RULES, width_ft=4, corner_allowance_ft=10)
+    assumed = {"battery_width": RULES.width_ft, "corner_allowance": 0.5}
+    assert assumption_mismatches(assumed, {}) == []
+    warnings = public_assumption_warnings(assumed, {}, public)
+    assert len(warnings) == 2
+    assert all("assumed public rules; server may override" in text for text in warnings)
     assert (
-        assumption_mismatches({"battery_width": rules.width_ft, "corner_allowance": 0.5}, {}, rules)
-        == []
+        public_assumption_warnings({"battery_width": 4, "corner_allowance": 10}, {}, public) == []
     )
 
 
+@pytest.mark.parametrize("source", ["spot", "nearest_considered", "check"])
+def test_reported_width_sources_override_public_width(source):
+    answer = (
+        {
+            "checks": [
+                {
+                    "id": "wall_backing",
+                    "threshold_ft": RULES.width_ft,
+                    "rule": {"key": "battery.width_ft"},
+                }
+            ]
+        }
+        if source == "check"
+        else {source: {"width_ft": RULES.width_ft}}
+    )
+    assert reported_rules(answer, replace(RULES, width_ft=4)).width_ft == RULES.width_ft
+    assert assumption_mismatches({"battery_width": RULES.width_ft}, answer) == []
+
+
+def test_other_width_thresholds_do_not_report_battery_width():
+    answer = {
+        "checks": [
+            {
+                "id": "meter_working_space",
+                "threshold_ft": 4,
+                "rule": {"key": "meter_working_space.width_ft"},
+            }
+        ]
+    }
+    assert reported_rules(answer, RULES).width_ft == RULES.width_ft
+
+
 @pytest.mark.parametrize("outcome", ["pass", "unsure"])
 @pytest.mark.parametrize("span", [[0, 1e9], [-1e9, 0], [1e9, 1e9]])
 def test_out_of_scan_sweep_fails_before_sampling(monkeypatch, outcome, span):
@@ -1623,3 +1697,13 @@ def test_in_scan_sweep_with_tiny_rule_step_fails_loudly():
     assert invariant_problems(SCENE, r, rules=replace(RULES, step_ft=1e-300)) == [
         "sweep unsure starts [0, 1]: sweep sampling exceeds the 10000 sample limit"
     ]
+
+
+def test_reported_override_prevents_a_false_footprint_failure():
+    public = replace(RULES, width_ft=4)
+    answer = result(spot=False, sweep=[pass_run(9, 9) | {"outcome": "unsure"}])
+    backing = next(c for c in answer["checks"] if c["id"] == "wall_backing")
+    backing["threshold_ft"] = RULES.width_ft
+    backing["rule"]["key"] = "battery.width_ft"
+    assert footprint_problems(SCENE, answer, public)
+    assert footprint_problems(SCENE, answer, reported_rules(answer, public)) == []

From 851814da763584f9c6b0309735dcf669ded024e2 Mon Sep 17 00:00:00 2001
From: SamGu-NRX <sgu07966@gmail.com>
Date: Wed, 14 Oct 2026 12:39:05 -0500
Subject: [PATCH 49/62] fix(pipeline): bound response geometry and preserve
 capture caches

---
 recon/recon/capture.py                   |  95 ++++++--
 recon/recon/coverage.py                  |   8 +-
 recon/recon/pipeline.py                  |   3 +
 recon/tests/test_vet_pipeline.py         | 108 +++++++++
 verification/hsverify/bundle_limits.py   |  61 +++++
 verification/hsverify/e2e.py             |  50 +++-
 verification/hsverify/resultcheck.py     | 293 +++++++++++++++++++++--
 verification/hsverify/simrun.py          |  16 +-
 verification/tests/test_bundle_limits.py |  94 ++++++++
 verification/tests/test_e2e.py           |  82 +++++++
 verification/tests/test_resultcheck.py   | 121 +++++++++-
 verification/tests/test_simrun.py        |  19 ++
 12 files changed, 886 insertions(+), 64 deletions(-)
 create mode 100644 recon/tests/test_vet_pipeline.py
 create mode 100644 verification/hsverify/bundle_limits.py
 create mode 100644 verification/tests/test_bundle_limits.py

diff --git a/recon/recon/capture.py b/recon/recon/capture.py
index 378a32320..e0733cd7c 100644
--- a/recon/recon/capture.py
+++ b/recon/recon/capture.py
@@ -23,6 +23,7 @@
 
 from __future__ import annotations
 
+import fcntl
 import hashlib
 import json
 import re
@@ -30,6 +31,7 @@
 import struct
 import tempfile
 import zipfile
+import zlib
 from dataclasses import dataclass, field
 from pathlib import Path
 
@@ -122,32 +124,78 @@ def outward_of(along: np.ndarray) -> np.ndarray:
     return np.array([-along[2], 0.0, along[0]])
 
 
-def unpack(path: Path, work: Path) -> Path:
-    """A folder as is; a zip extracted once under `work`, keyed by its sha256."""
+def bundle_root(path: Path, work: Path) -> Path:
+    """The capture folder, including a ZIP's cache path before extraction or cleanup."""
     if path.is_dir():
         return path
     if path.stat().st_size > MAX_BUNDLE_BYTES:
         raise ValueError(f"{path}: archive exceeds {MAX_BUNDLE_BYTES} bytes")
     with path.open("rb") as f:
         digest = hashlib.file_digest(f, "sha256").hexdigest()[:16]
-    out = work / "bundles" / digest
-    if not out.exists():
-        _zip_directory_limits(path)
-        with zipfile.ZipFile(path) as z:
-            infos = z.infolist()
-            if len(infos) > MAX_BUNDLE_ENTRIES:
-                raise ValueError(f"{path}: {len(infos)} entries, limit {MAX_BUNDLE_ENTRIES}")
-            if sum(i.file_size for i in infos) > MAX_BUNDLE_BYTES:
-                raise ValueError(f"{path}: expanded archive exceeds {MAX_BUNDLE_BYTES} bytes")
-            members = [i for i in infos if not i.filename.startswith("__MACOSX/")]
-            for info in members:
-                n = info.filename
-                if n.startswith("/") or ".." in Path(n).parts:
-                    raise ValueError(f"{path}: unsafe entry {n!r}")
-            out.parent.mkdir(parents=True, exist_ok=True)
+    return work / "bundles" / digest
+
+
+def _bundle_intact(root: Path, members: list[zipfile.ZipInfo]) -> bool:
+    """Check the extracted file set and each file's size and CRC against the archive."""
+    if root.is_symlink() or not root.is_dir():
+        return False
+    files = {Path(i.filename): i for i in members if not i.is_dir()}
+    directories = {Path(i.filename) for i in members if i.is_dir()}
+    for name in files.keys() | directories:
+        directories.update(p for p in name.parents if p != Path("."))
+    expected = files.keys() | directories
+    try:
+        for entry in root.rglob("*"):
+            name = entry.relative_to(root)
+            if entry.is_symlink() or name not in expected:
+                return False
+        if any(not (root / name).is_dir() for name in directories):
+            return False
+        for name, info in files.items():
+            entry = root / name
+            if not entry.is_file() or entry.stat().st_size != info.file_size:
+                return False
+            crc, size = 0, 0
+            with entry.open("rb") as source:
+                while chunk := source.read(2**20):
+                    size += len(chunk)
+                    if size > info.file_size:
+                        return False
+                    crc = zlib.crc32(chunk, crc)
+            if size != info.file_size or crc != info.CRC:
+                return False
+    except OSError:
+        return False
+    return True
+
+
+def unpack(path: Path, work: Path) -> Path:
+    """A folder as is; a ZIP cache reused only while its extracted members remain intact."""
+    out = bundle_root(path, work)
+    if path.is_dir():
+        return out
+    _zip_directory_limits(path)
+    with zipfile.ZipFile(path) as z:
+        infos = z.infolist()
+        if len(infos) > MAX_BUNDLE_ENTRIES:
+            raise ValueError(f"{path}: {len(infos)} entries, limit {MAX_BUNDLE_ENTRIES}")
+        if sum(i.file_size for i in infos) > MAX_BUNDLE_BYTES:
+            raise ValueError(f"{path}: expanded archive exceeds {MAX_BUNDLE_BYTES} bytes")
+        members = [i for i in infos if not i.filename.startswith("__MACOSX/")]
+        for info in members:
+            n = info.filename
+            if n.startswith("/") or ".." in Path(n).parts:
+                raise ValueError(f"{path}: unsafe entry {n!r}")
+        out.parent.mkdir(parents=True, exist_ok=True)
+        # Cache verification and replacement share a lock so one repair cannot delete another
+        # run's newly published extraction. The lock stays outside the replaceable directory.
+        with (work / f".bundle-{out.name}.lock").open("a") as lock:
+            fcntl.flock(lock, fcntl.LOCK_EX)
+            if _bundle_intact(out, members):
+                return out
             # Extraction stays private until every CRC-checked member finishes. Failed extraction
             # cannot leave a partial cache directory that a later run mistakes for a complete one.
-            stage = Path(tempfile.mkdtemp(dir=out.parent, prefix=f".{digest}-"))
+            stage = Path(tempfile.mkdtemp(dir=out.parent, prefix=f".{out.name}-"))
             try:
                 written = 0
                 for info in members:
@@ -162,12 +210,11 @@ def unpack(path: Path, work: Path) -> Path:
                             if written > MAX_BUNDLE_BYTES:
                                 raise ValueError(f"{path}: expanded archive exceeds byte limit")
                             dst.write(chunk)
-                try:
-                    stage.rename(out)
-                except OSError:
-                    # Another run of this exact content may have finished first.
-                    if not out.is_dir():
-                        raise
+                if out.is_symlink() or out.is_file():
+                    out.unlink()
+                elif out.exists():
+                    shutil.rmtree(out)
+                stage.rename(out)
             finally:
                 if stage.exists():
                     shutil.rmtree(stage)
diff --git a/recon/recon/coverage.py b/recon/recon/coverage.py
index a0a1eaa59..d40f9d1c8 100644
--- a/recon/recon/coverage.py
+++ b/recon/recon/coverage.py
@@ -39,7 +39,7 @@
 GROUND_MAX_M = 3.048  # 10 ft out
 FACING_MAX_M = 6.0
 FACING_BAND_M = (0.3, 1.8)
-OVERHEAD_OUT_M = (0.1, 0.56)  # above the battery's footprint (1.83 ft deep)
+OVERHEAD_OUT_M = (0.0, 0.56)  # the whole existing 1.83 ft footprint, from the first free wall step
 OVERHEAD_MAX_M = 3.0
 MAX_ANGLE = np.radians(65)  # the app's limit on how oblique a view may be
 IMAGE_MARGIN = 0.03
@@ -233,7 +233,11 @@ def free_space(wall: WallFrame, vol: Volume, cells: np.ndarray):
             if not seen:
                 break
             facing_clear[c] = out - front
-        oo = front + np.arange(OVERHEAD_OUT_M[0], OVERHEAD_OUT_M[1] + 1e-9, step)
+        # Include both footprint edges. Skipping the first 10 cm missed a 1.90 m eave in the
+        # full-depth regression, while a voxel step alone can end short of the outer edge.
+        oo = front + np.append(
+            np.arange(OVERHEAD_OUT_M[0], OVERHEAD_OUT_M[1], step), OVERHEAD_OUT_M[1]
+        )
         for h in np.arange(0.3, OVERHEAD_MAX_M, step):
             share, seen = _slab(wall, vol, across, [h], oo)
             if share > 0:
diff --git a/recon/recon/pipeline.py b/recon/recon/pipeline.py
index 2c0b5ded1..c27829686 100644
--- a/recon/recon/pipeline.py
+++ b/recon/recon/pipeline.py
@@ -138,6 +138,9 @@ def run(
         overlap = bundle_path.is_relative_to(out_path) or out_path.is_relative_to(bundle_path)
     else:
         overlap = bundle_path in {(out_path / name).resolve() for name in owned}
+        if not overlap and bundle.is_file():
+            capture_root = cap.bundle_root(bundle, work).resolve()
+            overlap = capture_root.is_relative_to(out_path) or out_path.is_relative_to(capture_root)
     if overlap:
         raise ValueError(
             f"output {out} overlaps capture input {bundle}; use a separate output folder"
diff --git a/recon/tests/test_vet_pipeline.py b/recon/tests/test_vet_pipeline.py
new file mode 100644
index 000000000..ab6fa05f0
--- /dev/null
+++ b/recon/tests/test_vet_pipeline.py
@@ -0,0 +1,108 @@
+"""Input preservation and full-depth footprint checks for the reconstruction worker."""
+
+import zipfile
+
+import numpy as np
+import pytest
+from test_worker import WALL
+
+from recon import capture as cap
+from recon import coverage, pipeline
+
+
+def _bundle(tmp_path):
+    path = tmp_path / "bundle.zip"
+    with zipfile.ZipFile(path, "w") as archive:
+        archive.writestr("scene.json", b"capture input")
+        archive.writestr("photos/frame.jpg", b"image bytes")
+    work = tmp_path / "work"
+    return path, work, cap.unpack(path, work)
+
+
+@pytest.mark.parametrize("relation", ["same", "ancestor", "descendant"])
+def test_zip_output_overlap_is_refused_before_cleanup(tmp_path, monkeypatch, relation):
+    bundle, work, root = _bundle(tmp_path)
+    out = {"same": root, "ancestor": root.parent, "descendant": root / "outputs"}[relation]
+    out.mkdir(exist_ok=True)
+    sentinel = out / "model.glb"
+    sentinel.write_bytes(b"previous output")
+
+    def load(*_):
+        pytest.fail("capture load reached before overlap rejection")
+
+    monkeypatch.setattr(pipeline.cap, "load", load)
+    with pytest.raises(ValueError, match="overlaps capture input"):
+        pipeline.run(bundle, out, work, "auto", None, False)
+    assert (root / "scene.json").read_bytes() == b"capture input"
+    assert sentinel.read_bytes() == b"previous output"
+
+
+@pytest.mark.parametrize("damage", ["missing", "truncated", "changed", "symlink", "extra"])
+def test_damaged_extracted_bundle_is_rebuilt(tmp_path, damage):
+    bundle, work, root = _bundle(tmp_path)
+    member = root / "photos/frame.jpg"
+    if damage == "missing":
+        member.unlink()
+    elif damage == "truncated":
+        member.write_bytes(b"image")
+    elif damage == "changed":
+        member.write_bytes(b"other bytes")
+    elif damage == "symlink":
+        outside = tmp_path / "outside.jpg"
+        outside.write_bytes(b"image bytes")
+        member.unlink()
+        member.symlink_to(outside)
+    else:
+        (root / "unexpected.json").write_bytes(b"foreign metadata")
+    assert cap.unpack(bundle, work) == root
+    assert member.is_file() and not member.is_symlink()
+    assert member.read_bytes() == b"image bytes"
+    assert not (root / "unexpected.json").exists()
+    if damage == "symlink":
+        assert outside.read_bytes() == b"image bytes"
+
+
+def test_intact_extracted_bundle_is_verified_without_reextracting(tmp_path, monkeypatch):
+    bundle, work, root = _bundle(tmp_path)
+    original = (root / "scene.json").stat().st_mtime_ns
+    monkeypatch.setattr(
+        zipfile.ZipFile, "open", lambda *_: pytest.fail("re-extracted intact cache")
+    )
+    assert cap.unpack(bundle, work) == root
+    assert (root / "scene.json").stat().st_mtime_ns == original
+
+
+class _FootprintVolume:
+    voxel = 0.05
+
+    def __init__(self, band, obstruction):
+        self.band = band
+        self.obstruction = obstruction
+
+    def occupied(self, points):
+        low, high = self.band
+        return (
+            self.obstruction
+            & (points[:, 2] >= low)
+            & (points[:, 2] <= high)
+            & (points[:, 1] >= 1.9 - 1e-9)
+        )
+
+    def observed(self, points):
+        low, high = self.band
+        missing = (points[:, 2] >= low) & (points[:, 2] <= high) & (points[:, 1] >= 1.9 - 1e-9)
+        return np.ones(len(points), bool) if self.obstruction else ~missing
+
+
+@pytest.mark.parametrize("band", [(0.05, 0.10), (0.609, 0.611)], ids=["near_wall", "far_edge"])
+@pytest.mark.parametrize("obstruction", [True, False], ids=["eave", "unobserved"])
+def test_overhead_checks_full_footprint_depth(band, obstruction):
+    # The first free step is 0.05 m out, so the 0.56 m footprint ends at z=0.61 m.
+    _, _, gap, clear = coverage.free_space(
+        WALL, _FootprintVolume(band, obstruction), np.array([0.0])
+    )
+    assert clear[0] < 1.9
+    if obstruction:
+        assert gap[0] == pytest.approx(1.85)
+    else:
+        assert np.isnan(gap[0])
diff --git a/verification/hsverify/bundle_limits.py b/verification/hsverify/bundle_limits.py
new file mode 100644
index 000000000..6f4eb3885
--- /dev/null
+++ b/verification/hsverify/bundle_limits.py
@@ -0,0 +1,61 @@
+"""Bound ZIP metadata before the verification harness constructs a ZipFile."""
+
+import struct
+from pathlib import Path
+
+
+def zip_directory_limits(path: Path, max_entries: int, max_bytes: int) -> None:
+    """Check central-directory records in bounded reads before ZipFile allocates their metadata.
+    ZIP64 and split archives exceed this worker's ordinary ZIP admission format and are refused.
+    The record layouts are PKWARE APPNOTE sections 4.3.12 and 4.3.16."""
+    with path.open("rb") as f:
+        size = path.stat().st_size
+        f.seek(max(0, size - 22 - 65535))
+        tail = f.read(22 + 65535)
+        # Match ZipFile's footer selection: a no-comment footer at EOF, otherwise the last
+        # signature. Backtracking past malformed signatures can validate a different directory
+        # from the one ZipFile later allocates. Refuse that ambiguity before constructing it.
+        if len(tail) >= 22 and tail[-22:-18] == b"PK\x05\x06" and tail[-2:] == b"\0\0":
+            pos = len(tail) - 22
+        else:
+            pos = tail.rfind(b"PK\x05\x06")
+        if pos < 0:
+            raise ValueError(f"{path}: missing ZIP end record")
+        if pos + 22 > len(tail):
+            raise ValueError(f"{path}: truncated ZIP end record")
+        record = struct.unpack("<4s4H2IH", tail[pos : pos + 22])
+        if pos + 22 + record[-1] != len(tail):
+            raise ValueError(f"{path}: ambiguous ZIP end record or invalid comment length")
+        _, disk, central_disk, disk_entries, total_entries, length, offset, _ = record
+        if disk or central_disk or disk_entries != total_entries:
+            raise ValueError(f"{path}: split ZIP archives are not supported")
+        if total_entries > max_entries:
+            raise ValueError(f"{path}: {total_entries} entries, limit {max_entries}")
+        directory_end = offset + length
+        end_offset = size - len(tail) + pos
+        # ZipFile checks this locator even when the ordinary footer has no ZIP64 sentinels.
+        # It must not replace the directory fields after the bounded scan below.
+        if end_offset >= 20:
+            f.seek(end_offset - 20)
+            if f.read(4) == b"PK\x06\x07":
+                raise ValueError(f"{path}: ZIP64 archive metadata is not supported")
+        if length == 0xFFFFFFFF or offset == 0xFFFFFFFF or directory_end != end_offset:
+            raise ValueError(f"{path}: ZIP64 or inconsistent ZIP directory")
+        f.seek(offset)
+        count, expanded = 0, 0
+        while f.tell() < directory_end:
+            header = f.read(46)
+            if len(header) != 46 or header[:4] != b"PK\x01\x02":
+                raise ValueError(f"{path}: invalid ZIP central-directory record")
+            fields = struct.unpack("<4s6H3I5H2I", header)
+            count += 1
+            expanded += fields[9]
+            if count > max_entries:
+                raise ValueError(f"{path}: {count} entries, limit {max_entries}")
+            if expanded > max_bytes:
+                raise ValueError(f"{path}: expanded archive exceeds {max_bytes} bytes")
+            f.seek(sum(fields[10:13]), 1)
+            if f.tell() > directory_end:
+                raise ValueError(f"{path}: ZIP central-directory record exceeds directory")
+        if count != total_entries:
+            raise ValueError(f"{path}: inconsistent ZIP entry count")
diff --git a/verification/hsverify/e2e.py b/verification/hsverify/e2e.py
index 6ce9cf93b..aa4194756 100644
--- a/verification/hsverify/e2e.py
+++ b/verification/hsverify/e2e.py
@@ -36,6 +36,7 @@
 import contextlib
 import datetime as dt
 import hashlib
+import http.client
 import io
 import json
 import os
@@ -55,6 +56,7 @@
 from pathlib import Path
 
 from hsverify import gitref, memory
+from hsverify.bundle_limits import zip_directory_limits
 from hsverify.memory import peak_rss_mb
 from hsverify.resultcheck import (
     RuleSet,
@@ -144,13 +146,20 @@ def read_bounded(bundle: zipfile.ZipFile, info: zipfile.ZipInfo, limit: int) ->
 
 def read_bundle(path: Path) -> tuple[bytes, dict[str, bytes]]:
     """scene.json and the JPEGs of a C1 zip bundle, within the limits above."""
+    if path.stat().st_size > MAX_BUNDLE_BYTES:
+        raise SystemExit(f"{path}: archive exceeds {MAX_BUNDLE_BYTES} bytes")
+    try:
+        zip_directory_limits(path, MAX_BUNDLE_ENTRIES, MAX_BUNDLE_BYTES)
+    except ValueError as exc:
+        raise SystemExit(str(exc)) from exc
     with zipfile.ZipFile(path) as bundle:
-        infos = [i for i in bundle.infolist() if not i.is_dir()]
+        infos = bundle.infolist()
         if len(infos) > MAX_BUNDLE_ENTRIES:
             raise SystemExit(f"{path}: {len(infos)} entries, limit {MAX_BUNDLE_ENTRIES}")
         declared = sum(i.file_size for i in infos)
         if declared > MAX_BUNDLE_BYTES:
             raise SystemExit(f"{path}: declares {declared} bytes, limit {MAX_BUNDLE_BYTES}")
+        infos = [i for i in infos if not i.is_dir()]
         scenes = [i for i in infos if i.filename == "scene.json"]
         if len(scenes) != 1:
             raise SystemExit(
@@ -357,6 +366,27 @@ def bundle_zip(item: SceneInput) -> bytes:
     return buf.getvalue()
 
 
+# Fixed harness admission limit to bound answers from a server under test. This is not a
+# measured maximum result size; it matches the 4 MiB transport policy in PR #242.
+MAX_RESPONSE_BYTES = 4 * 2**20
+
+
+def read_response(response) -> bytes:
+    declared = response.headers.get("Content-Length")
+    if declared is not None:
+        declared = int(declared)
+        if declared < 0:
+            raise ValueError("negative response Content-Length")
+        if declared > MAX_RESPONSE_BYTES:
+            raise ValueError(f"response exceeds {MAX_RESPONSE_BYTES} bytes")
+    payload = response.read(MAX_RESPONSE_BYTES + 1)
+    if len(payload) > MAX_RESPONSE_BYTES:
+        raise ValueError(f"response exceeds {MAX_RESPONSE_BYTES} bytes")
+    if declared is not None and len(payload) < declared:
+        raise ValueError(f"truncated response: {len(payload)} bytes, expected {declared}")
+    return payload
+
+
 def post(
     url: str, endpoint: Endpoint, item: SceneInput, timeout_s: float = 60
 ) -> tuple[int | None, bytes, float]:
@@ -381,11 +411,19 @@ def post(
     )
     start = time.perf_counter()
     try:
-        with urllib.request.urlopen(request, timeout=timeout_s) as response:
-            status, payload = response.status, response.read()
-    except urllib.error.HTTPError as exc:
-        status, payload = exc.code, exc.read()
-    except (urllib.error.URLError, TimeoutError, ConnectionError) as exc:
+        try:
+            response = urllib.request.urlopen(request, timeout=timeout_s)
+        except urllib.error.HTTPError as exc:
+            response = exc
+        with response:
+            status, payload = response.status, read_response(response)
+    except (
+        urllib.error.URLError,
+        TimeoutError,
+        ConnectionError,
+        http.client.HTTPException,
+        ValueError,
+    ) as exc:
         status, payload = None, str(exc).encode()
     return status, payload, (time.perf_counter() - start) * 1000
 
diff --git a/verification/hsverify/resultcheck.py b/verification/hsverify/resultcheck.py
index 2ea978f2a..a7a1eca77 100644
--- a/verification/hsverify/resultcheck.py
+++ b/verification/hsverify/resultcheck.py
@@ -28,9 +28,10 @@
 import copy
 import hashlib
 import itertools
+import json
 import math
 from collections.abc import Callable, Iterator
-from dataclasses import dataclass
+from dataclasses import dataclass, replace
 from typing import Any
 
 import yaml
@@ -40,6 +41,11 @@
 NUMBER_TOL_FT = 1e-5
 # Bound verifier work even when a server span or rules step requests billions of samples.
 MAX_SWEEP_SAMPLES = 10_000
+# The existing public-pool regression has 55 starts and a worst-case ground
+# reach of 14.15 ft: its conservative grid bound is below 50 million visits.
+# This cap retains that case while bounding aggregate work; it is a resource
+# policy, not a measured runtime or a physical scan limit.
+MAX_GEOMETRY_SAMPLES = 50_000_000
 # Spot centres and offsets are rounded by the server; a hundredth of a foot is 1/8 inch.
 OFFSET_TOL_FT = 0.01
 
@@ -308,8 +314,9 @@ def margin_problem(check: dict) -> str | None:
 def invariant_problems(
     scene: dict, result: dict, sent: bytes | None = None, rules: RuleSet | None = None
 ) -> list[str]:
-    if rules is not None and (sampling := sweep_sampling_problems(scene, result, rules)):
+    if sampling := geometry_admission_problems(scene, result, rules):
         return sampling
+    result = deduplicate_result_runs(result)
     problems: list[str] = []
     decision = result["decision"]
     spot = result.get("spot")
@@ -423,8 +430,9 @@ def footprint_problems(scene: dict, result: dict, rules: RuleSet) -> list[str]:
     """A battery that passes or is left to a person backs onto one straight stretch of scanned
     wall along its whole width; a footprint past the stretch's end (a corner, the end of the
     wall, a gap) can't sit flush, so the server fails it (server/solver.py check_backing)."""
-    if sampling := sweep_sampling_problems(scene, result, rules):
+    if sampling := geometry_admission_problems(scene, result, rules):
         return sampling
+    result = deduplicate_result_runs(result)
     pieces = straight_pieces(scene, rules)
     if not pieces:
         return []
@@ -679,7 +687,7 @@ def measured_band_gap(
     return None
 
 
-def run_starts(span: list[float], step_ft: float | None) -> Iterator[float]:
+def run_start_count(span: list[float], step_ft: float | None) -> int:
     """Validate eagerly, then sample a run lazily: first, every step after it, and last.
 
     A sample, not the server's own list: the server also evaluates boundaries and midpoints
@@ -697,25 +705,240 @@ def run_starts(span: list[float], step_ft: float | None) -> Iterator[float]:
     count = max(int(a < b), math.ceil(steps - EPS))
     if count + 1 > MAX_SWEEP_SAMPLES:
         raise ValueError(f"sweep sampling exceeds the {MAX_SWEEP_SAMPLES} sample limit")
-    return itertools.chain((a + k * step_ft for k in range(count)), (b,))
+    return count + 1
 
 
-def sweep_sampling_problems(scene: dict, result: dict, rules: RuleSet) -> list[str]:
-    """Reject invalid runs before footprint, coverage or height checks sample them."""
-    ends = chain_ends_s(scene, rules)
-    problems = []
+def run_starts(span: list[float], step_ft: float | None) -> Iterator[float]:
+    count = run_start_count(span, step_ft)
+    a, b = span
+    return itertools.chain((a + k * step_ft for k in range(count - 1)), (b,))
+
+
+def deduplicate_result_runs(result: dict) -> dict:
+    """Identical records cannot add geometry evidence or multiply sampling work."""
+    unique = {}
     for run in result.get("sweep", []):
-        if run["outcome"] not in ("pass", "unsure"):
+        unique.setdefault(json.dumps(run, sort_keys=True), run)
+    return result | {"sweep": list(unique.values())}
+
+
+def reported_dimension_problems(result: dict, rules: RuleSet | None) -> list[str]:
+    """Reject inconsistent C2 geometry before its dimensions can override public rules."""
+    problems = []
+
+    def finite(value: Any) -> bool:
+        try:
+            return (
+                isinstance(value, (int, float))
+                and not isinstance(value, bool)
+                and math.isfinite(value)
+            )
+        except OverflowError:
+            return False
+
+    spots = [(name, result.get(name)) for name in ("spot", "nearest_considered")]
+    for name, spot in spots:
+        if spot is None:
+            continue
+        for field in ("width_ft", "depth_ft", "height_ft"):
+            if field in spot and (not finite(spot[field]) or spot[field] <= 0):
+                problems.append(f"{name}.{field} must be finite and positive")
+        span = spot.get("span_ft")
+        if span is not None:
+            if len(span) != 2 or not all(finite(v) for v in span) or span[0] >= span[1]:
+                problems.append(f"{name}.span_ft must be finite and increasing")
+            elif (
+                finite(spot.get("width_ft"))
+                and abs(span[1] - span[0] - spot["width_ft"]) > OFFSET_TOL_FT
+            ):
+                problems.append(f"{name}.width_ft does not match span_ft")
+        corners = spot.get("footprint")
+        if corners is None:
             continue
+        if len(corners) != 4 or any(
+            len(point) != 2 or not all(finite(v) for v in point) for point in corners
+        ):
+            problems.append(f"{name}.footprint must have four finite plan corners")
+            continue
+        # C2 orders back-left, back-right, front-right, front-left. Use the verifier's existing
+        # hundredth-foot position tolerance when comparing its rounded plan edges and spans.
+        for field, edges in (("width_ft", ((0, 1), (2, 3))), ("depth_ft", ((1, 2), (3, 0)))):
+            if finite(spot.get(field)) and any(
+                abs(math.dist(corners[a], corners[b]) - spot[field]) > OFFSET_TOL_FT
+                for a, b in edges
+            ):
+                problems.append(f"{name}.{field} does not match footprint")
+
+    widths = [
+        (f"{name}.width_ft", spot["width_ft"])
+        for name, spot in spots
+        if spot is not None and "width_ft" in spot
+    ]
+    widths += [
+        (c["id"], c["threshold_ft"])
+        for c in result.get("checks", [])
+        if c.get("rule", {}).get("key") == "battery.width_ft" and c.get("threshold_ft") is not None
+    ]
+    for source, width in widths:
+        if not finite(width) or width <= 0:
+            message = f"{source} must be finite and positive"
+            if message not in problems:
+                problems.append(message)
+    valid_widths = [(source, width) for source, width in widths if finite(width) and width > 0]
+    if valid_widths and any(
+        abs(width - valid_widths[0][1]) > NUMBER_TOL_FT for _, width in valid_widths
+    ):
+        problems.append("reported battery widths disagree")
+    first, second = (spot for _, spot in spots)
+    if first is not None and second is not None:
+        for field in ("depth_ft", "height_ft"):
+            if (
+                finite(first.get(field))
+                and finite(second.get(field))
+                and abs(first[field] - second[field]) > NUMBER_TOL_FT
+            ):
+                problems.append(f"spot and nearest_considered {field} disagree")
+    return problems
+
+
+def geometry_admission_problems(scene: dict, result: dict, rules: RuleSet | None) -> list[str]:
+    """Bound all sampling before any footprint, coverage or height check runs.
+
+    Count sweep starts and a conservative upper bound for ground grid point visits,
+    including split-band edges. Bounds use whole runs, never enumerate their starts.
+    """
+    if problems := reported_dimension_problems(result, rules):
+        return problems
+    # Use validated reported dimensions only to estimate work, before the caller adopts them.
+    widths = [
+        c["threshold_ft"]
+        for c in result.get("checks", [])
+        if c.get("rule", {}).get("key") == "battery.width_ft" and c.get("threshold_ft") is not None
+    ]
+    widths += [
+        s["width_ft"]
+        for key in ("spot", "nearest_considered")
+        if (s := result.get(key)) is not None and "width_ft" in s
+    ]
+    depths = [
+        s["depth_ft"]
+        for key in ("spot", "nearest_considered")
+        if (s := result.get(key)) is not None and "depth_ft" in s
+    ]
+    if rules is not None:
+        rules = replace(
+            rules,
+            width_ft=max(widths, default=rules.width_ft),
+            depth_ft=max([rules.depth_ft, *depths]),
+        )
+    problems = []
+    bodies = []
+    ends = chain_ends_s(scene, rules) if rules is not None else None
+    for name in ("spot", "nearest_considered"):
+        if (spot := result.get(name)) is not None:
+            bodies.append((name, spot["span_ft"], spot["wall_id"], 1, True))
+    for run in deduplicate_result_runs(result)["sweep"]:
         a, b = run["start_ft"]
         prefix = f"sweep {run['outcome']} starts {run['start_ft']}: "
-        if ends is not None and (a < ends[0] - COLLINEAR_FT or b > ends[1] + COLLINEAR_FT):
-            problems.append(prefix + f"start_ft span exceeds scanned range [{ends[0]}, {ends[1]}]")
+        if not math.isfinite(a) or not math.isfinite(b) or a > b:
+            problems.append(prefix + "start_ft must be finite and ordered")
             continue
-        try:
-            run_starts(run["start_ft"], rules.step_ft)
-        except ValueError as exc:
-            problems.append(prefix + str(exc))
+        if run["outcome"] in ("pass", "unsure") and rules is not None:
+            if ends is not None and (a < ends[0] - COLLINEAR_FT or b > ends[1] + COLLINEAR_FT):
+                problems.append(
+                    prefix + f"start_ft span exceeds scanned range [{ends[0]}, {ends[1]}]"
+                )
+                continue
+            try:
+                count = run_start_count(run["start_ft"], rules.step_ft)
+            except ValueError as exc:
+                problems.append(prefix + str(exc))
+                continue
+            bodies.append(
+                (prefix, [a, b + rules.width_ft], run["wall_id"], count, run["outcome"] == "pass")
+            )
+    for name, span, _, _, _ in bodies:
+        if any(not math.isfinite(v) for v in span) or span[0] > span[1]:
+            problems.append(f"{name}: span_ft must be finite and ordered")
+    if problems or rules is None:
+        return problems
+    total = 0
+
+    def grid_count(length: float) -> int:
+        cells = length / GroundPlan.STEP_FT
+        if not math.isfinite(cells) or cells > MAX_GEOMETRY_SAMPLES:
+            return MAX_GEOMETRY_SAMPLES + 1
+        return 2 * max(1, math.ceil(max(0, cells))) + 1
+
+    for name, (lo, hi), wid, count, ground in bodies:
+        # Sweep ends name starts; footprints may extend beyond the chain and are checked below.
+        start_hi = hi - rules.width_ft if name.startswith("sweep") else hi
+        if ends is not None and (lo < ends[0] - COLLINEAR_FT or start_hi > ends[1] + COLLINEAR_FT):
+            label = "start_ft span" if name.startswith("sweep") else "span_ft"
+            problems.append(
+                f"{name}{'' if name.endswith(': ') else ': '}"
+                f"{label} exceeds scanned range [{ends[0]}, {ends[1]}]"
+            )
+            continue
+        total += count * (2 + (len(rules.needs) if ground else 0))
+        if ground and rules.wall_join_ft is not None:
+            segments = segments_s(scene, rules) or []
+            # Error changes at wall boundaries. Evaluate both sides and endpoints, not the grid.
+            width = rules.width_ft if name.startswith("sweep") else hi - lo
+            starts = {lo, max(lo, hi - width)}
+            boundaries = {edge for _, a, b, _, _ in segments for edge in (a, b)}
+            boundaries.update(
+                (left[2] + right[1]) / 2 for left, right in itertools.pairwise(segments)
+            )
+            for edge_at in boundaries:
+                for edge in (edge_at, edge_at - width, edge_at - width / 2):
+                    for offset in (-EPS, EPS):
+                        if lo <= edge + offset <= hi - width:
+                            starts.add(edge + offset)
+            for check, needs in rules.needs.items():
+                for need in needs:
+                    if need.band != "ground":
+                        continue
+                    error = (
+                        0.0
+                        if not need.widen
+                        else max(
+                            (along_error if need.along else battery_error)(
+                                scene, rules, wid, x, x + width
+                            )
+                            for x in starts
+                        )
+                    )
+                    radius = need.radius + error
+                    splits = 4 + 2 * sum(
+                        e["band"] == "ground" for e in scene.get("coverage", {}).get("observed", [])
+                    )
+                    along = grid_count(width + 2 * radius) + 3 * splits
+                    out = grid_count(rules.depth_ft + radius)
+                    # Spot coverage and missing-evidence checks can both visit the grid.
+                    repeats = (
+                        1
+                        if name.startswith("sweep")
+                        else 1
+                        + sum(
+                            c["id"] == check and c["outcome"] == "pass"
+                            for c in result.get("checks", [])
+                        )
+                    )
+                    total += count * along * out * repeats
+        if total > MAX_GEOMETRY_SAMPLES:
+            problems.append(
+                f"response geometry sample budget exceeds {MAX_GEOMETRY_SAMPLES} samples"
+            )
+            break
+    # A check-only reported width is still untrusted geometry, even without a chosen spot/run.
+    for width in [*widths, *depths]:
+        if not math.isfinite(width) or width <= 0:
+            problems.append("reported battery width must be finite and positive")
+            break
+        total += grid_count(width)
+    if total > MAX_GEOMETRY_SAMPLES and not any("sample budget" in p for p in problems):
+        problems.append(f"response geometry sample budget exceeds {MAX_GEOMETRY_SAMPLES} samples")
     return problems
 
 
@@ -750,8 +973,9 @@ def coverage_problems(scene: dict, result: dict, rules: RuleSet) -> list[str]:
     check's area around that start's battery with that battery's own position error, and the
     wall and cable route back to the meter over the whole run. Checking the whole run as one
     battery at its farthest start's error would ask for more than any single start needs."""
-    if sampling := sweep_sampling_problems(scene, result, rules):
+    if sampling := geometry_admission_problems(scene, result, rules):
         return sampling
+    result = deduplicate_result_runs(result)
     problems: list[str] = []
     route_wall = observed(
         scene, "wall", rules.route_height_ft, beyond=True, wall_default_ft=rules.headroom_ft
@@ -870,6 +1094,9 @@ def missing_evidence_problems(scene: dict, result: dict, rules: RuleSet | None =
     the reason and its requests; leaving both out would never ask the homeowner for the view
     that settles the check. Without a spot and without the reason, every position fails anyway,
     no photo would change the answer, and C2 lets missing_evidence stay empty."""
+    if sampling := geometry_admission_problems(scene, result, rules):
+        return sampling
+    result = deduplicate_result_runs(result)
     codes = {r["code"] for r in result.get("reasons", [])}
     spot = result.get("spot")
     unseen = unobserved_checks(result)
@@ -1054,19 +1281,34 @@ def covers(
             return False
         for s in self._samples(p, q):
             # Up to out_lo the stretch's own band already saw the ground.
-            deeper = [o for o in self._samples(out_lo, need(s)) if o > out_lo + SERVER_EPS]
-            for out in deeper:
+            for out in self._samples(out_lo, need(s)):
+                if out <= out_lo + SERVER_EPS:
+                    continue
                 x = self.point(s_mid, s, out)
                 if x is None or (self.required(x) and not self.seen(x)):
                     return False
         return True
 
     @classmethod
-    def _samples(cls, a: float, b: float) -> list[float]:
-        n = max(1, math.ceil((b - a) / cls.STEP_FT))
-        edges = [a + (b - a) * i / n for i in range(n + 1)]
-        centres = [a + (b - a) * (i + 0.5) / n for i in range(n)]
-        return sorted(edges + centres)
+    def _samples(cls, a: float, b: float) -> Iterator[float]:
+        cells = (b - a) / cls.STEP_FT
+        if not math.isfinite(cells) or cells > MAX_GEOMETRY_SAMPLES:
+            raise ValueError(
+                f"response geometry sample budget exceeds {MAX_GEOMETRY_SAMPLES} samples"
+            )
+        n = max(1, math.ceil(max(0, cells)))
+        if 2 * n + 1 > MAX_GEOMETRY_SAMPLES:
+            raise ValueError(
+                f"response geometry sample budget exceeds {MAX_GEOMETRY_SAMPLES} samples"
+            )
+
+        def points():
+            for i in range(n):
+                yield a + (b - a) * i / n
+                yield a + (b - a) * (i + 0.5) / n
+            yield b
+
+        return points()
 
 
 def chain_ends_s(scene: dict, rules: RuleSet) -> tuple[float, float] | None:
@@ -1083,8 +1325,9 @@ def declared_height_problems(scene: dict, result: dict, rules: RuleSet) -> list[
     it unsure for one within the battery's error of it (server/solver.py at 7133283,
     check_backing), so wall_backing passes only if every declared wall overlapping
     [s0 - e, s1 + e] is taller than battery.height_ft."""
-    if sampling := sweep_sampling_problems(scene, result, rules):
+    if sampling := geometry_admission_problems(scene, result, rules):
         return sampling
+    result = deduplicate_result_runs(result)
     declared = {w["id"]: w["height_ft"] for w in scene.get("walls", []) if "height_ft" in w}
     if not declared or rules.battery_height_ft is None:
         return []
diff --git a/verification/hsverify/simrun.py b/verification/hsverify/simrun.py
index 8d42bbeb1..bb5346cee 100644
--- a/verification/hsverify/simrun.py
+++ b/verification/hsverify/simrun.py
@@ -8,7 +8,7 @@
 a screenshot once it has been on screen for `--settle` seconds; a state replaced sooner is
 captured immediately and flagged `transient`, because its image may already show the next
 state. The run ends at `--until`, after `--idle` seconds without a new state, or at
-`--timeout`. A state named with `--require` that never appeared makes the run fail. If the app
+`--timeout`. States named with `--require` must appear in the order given. If the app
 logged a scan bundle, it is copied into the report as scan.zip (required with `--require-export`)
 and named in report.json's
 `app_export`, so the report folder can be replayed as an app export. Reports go outside git
@@ -331,7 +331,17 @@ def wait_for_log_stream(events: queue.Queue, timeout_s: float) -> str | None:
 
 def missing_required(required: list[str], states: list[ShotRecord]) -> list[str]:
     seen = {s.state for s in states}
-    return [f"required state {name} never appeared" for name in required if name not in seen]
+    missing = [f"required state {name} never appeared" for name in required if name not in seen]
+    if missing:
+        return missing
+    remaining = iter(required)
+    next_required = next(remaining, None)
+    for state in states:
+        if state.state == next_required:
+            next_required = next(remaining, None)
+    if next_required is not None:
+        return [f"required states did not appear in order: {' -> '.join(required)}"]
+    return []
 
 
 def logged_message(line: str) -> str:
@@ -563,7 +573,7 @@ def main(argv: list[str] | None = None) -> int:
         action="append",
         default=[],
         metavar="STATE",
-        help="a state the run must reach; one that never appears is a problem (exit 1)",
+        help="a state the run must reach; repeat in the required journey order (exit 1 on failure)",
     )
     parser.add_argument(
         "--require-export",
diff --git a/verification/tests/test_bundle_limits.py b/verification/tests/test_bundle_limits.py
new file mode 100644
index 000000000..cc3a8f1aa
--- /dev/null
+++ b/verification/tests/test_bundle_limits.py
@@ -0,0 +1,94 @@
+import ast
+import io
+import struct
+import zipfile
+from pathlib import Path
+
+import pytest
+
+from hsverify.bundle_limits import zip_directory_limits
+
+
+def recon_guard(max_entries, max_bytes):
+    # Execute only the stdlib guard so this parity check needs no recon model dependencies.
+    source = Path(__file__).resolve().parents[2] / "recon" / "recon" / "capture.py"
+    tree = ast.parse(source.read_text())
+    guard = next(
+        node
+        for node in tree.body
+        if isinstance(node, ast.FunctionDef) and node.name == "_zip_directory_limits"
+    )
+    namespace = {
+        "Path": Path,
+        "struct": struct,
+        "MAX_BUNDLE_ENTRIES": max_entries,
+        "MAX_BUNDLE_BYTES": max_bytes,
+    }
+    exec(compile(ast.Module(body=[guard], type_ignores=[]), str(source), "exec"), namespace)
+    return namespace["_zip_directory_limits"]
+
+
+def ordinary_zip():
+    data = io.BytesIO()
+    with zipfile.ZipFile(data, "w") as archive:
+        archive.writestr("scene.json", b"{}")
+        archive.writestr("frames/", b"")
+        archive.writestr("frames/a.jpg", b"image")
+    return bytearray(data.getvalue())
+
+
+@pytest.mark.parametrize(
+    "mutation",
+    [
+        "ordinary",
+        "entries",
+        "bytes",
+        "false_count",
+        "comment",
+        "footer_in_comment",
+        "split",
+        "directory_offset",
+        "directory_record",
+        "zip64_locator",
+        "truncated",
+    ],
+)
+def test_admission_matches_recon_guard(tmp_path, mutation):
+    data = ordinary_zip()
+    entries, expanded = 3, 7
+    footer = len(data) - 22
+    directory = struct.unpack_from("<I", data, footer + 16)[0]
+    if mutation == "entries":
+        entries = 2
+    elif mutation == "bytes":
+        expanded = 6
+    elif mutation == "false_count":
+        struct.pack_into("<HH", data, footer + 8, 1, 1)
+        entries = 2
+    elif mutation in ("comment", "footer_in_comment"):
+        comment = b"valid comment" if mutation == "comment" else b"PK\x05\x06"
+        struct.pack_into("<H", data, footer + 20, len(comment))
+        data.extend(comment)
+    elif mutation == "split":
+        struct.pack_into("<H", data, footer + 4, 1)
+    elif mutation == "directory_offset":
+        struct.pack_into("<I", data, footer + 16, directory + 1)
+    elif mutation == "directory_record":
+        data[directory : directory + 4] = b"bad!"
+    elif mutation == "zip64_locator":
+        data[footer:footer] = b"PK\x06\x07" + bytes(16)
+    elif mutation == "truncated":
+        data = data[:-5]
+    path = tmp_path / "bundle.zip"
+    path.write_bytes(data)
+
+    def outcome(guard):
+        try:
+            guard(path)
+        except ValueError as exc:
+            return str(exc)
+        return None
+
+    expected = outcome(recon_guard(entries, expanded))
+    assert outcome(lambda p: zip_directory_limits(p, entries, expanded)) == expected
+    assert (expected is None) == (mutation in ("ordinary", "comment"))
diff --git a/verification/tests/test_e2e.py b/verification/tests/test_e2e.py
index e4900ffcb..1bf3ca398 100644
--- a/verification/tests/test_e2e.py
+++ b/verification/tests/test_e2e.py
@@ -2,6 +2,7 @@
 import io
 import json
 import re
+import struct
 import threading
 import time
 import zipfile
@@ -475,6 +476,87 @@ def test_a_bundle_with_too_many_entries_is_refused(tmp_path, monkeypatch):
         load_input(archive)
 
 
+@pytest.mark.parametrize("false_footer_count", [False, True])
+def test_bundle_counts_directories_before_zipfile_allocation(
+    tmp_path, monkeypatch, false_footer_count
+):
+    monkeypatch.setattr(e2e, "MAX_BUNDLE_ENTRIES", 3)
+    archive = tmp_path / "directories.zip"
+    with zipfile.ZipFile(archive, "w") as z:
+        z.writestr("scene.json", b"{}")
+        for i in range(3):
+            z.writestr(f"directory{i}/", b"")
+    if false_footer_count:
+        data = bytearray(archive.read_bytes())
+        struct.pack_into("<HH", data, len(data) - 22 + 8, 1, 1)
+        archive.write_bytes(data)
+
+    def metadata_allocation_forbidden(*args, **kwargs):
+        pytest.fail("ZipFile allocated metadata before archive admission")
+
+    monkeypatch.setattr(e2e.zipfile, "ZipFile", metadata_allocation_forbidden)
+    with pytest.raises(SystemExit, match="4 entries, limit 3"):
+        e2e.read_bundle(archive)
+
+
+@pytest.mark.parametrize("status", [200, 413])
+def test_response_read_is_bounded_for_success_and_http_error(monkeypatch, status):
+    from urllib.error import HTTPError
+
+    class Response(io.BytesIO):
+        headers: ClassVar[dict] = {}
+
+        def read(self, size=-1):
+            assert 0 <= size <= 4 * 2**20 + 1, "response read must have a byte limit"
+            return super().read(size)
+
+    response = Response(b"x" * (4 * 2**20 + 1))
+    response.status = status
+
+    def urlopen(*args, **kwargs):
+        if status != 200:
+            raise HTTPError("http://unused", status, "too large", {}, response)
+        return response
+
+    monkeypatch.setattr(e2e.urllib.request, "urlopen", urlopen)
+    code, body, _ = e2e.post("http://unused", Endpoint("/place", "application/json"), item())
+    assert code is None
+    assert b"response exceeds" in body
+
+
+@pytest.mark.parametrize("status", [200, 413])
+def test_incomplete_response_is_a_clean_transport_failure(monkeypatch, status):
+    from http.client import IncompleteRead
+    from urllib.error import HTTPError
+
+    class Response(io.BytesIO):
+        headers: ClassVar[dict] = {}
+
+        def read(self, size=-1):
+            raise IncompleteRead(b"partial", 50)
+
+    response = Response()
+    response.status = status
+
+    def urlopen(*args, **kwargs):
+        if status != 200:
+            raise HTTPError("http://unused", status, "truncated", {}, response)
+        return response
+
+    monkeypatch.setattr(e2e.urllib.request, "urlopen", urlopen)
+    code, body, _ = e2e.post("http://unused", Endpoint("/place", "application/json"), item())
+    assert code is None and b"IncompleteRead" in body
+
+
+def test_short_content_length_response_is_a_clean_transport_failure(monkeypatch):
+    response = io.BytesIO(b"{}")
+    response.status = 200
+    response.headers = {"Content-Length": "10"}
+    monkeypatch.setattr(e2e.urllib.request, "urlopen", lambda *args, **kwargs: response)
+    code, body, _ = e2e.post("http://unused", Endpoint("/place", "application/json"), item())
+    assert code is None and b"truncated response" in body
+
+
 def test_a_200_that_is_not_a_json_object_is_a_failure_not_a_crash(monkeypatch):
     for body in (b"<html>oops</html>", b"[1, 2]"):
         monkeypatch.setattr(e2e, "post", lambda *args, body=body, **kwargs: (200, body, 5.0))
diff --git a/verification/tests/test_resultcheck.py b/verification/tests/test_resultcheck.py
index 526a11bba..11b8a5322 100644
--- a/verification/tests/test_resultcheck.py
+++ b/verification/tests/test_resultcheck.py
@@ -6,6 +6,7 @@
 import pytest
 
 from hsverify.resultcheck import (
+    MAX_GEOMETRY_SAMPLES,
     MAX_SWEEP_SAMPLES,
     GroundPlan,
     Need,
@@ -753,9 +754,9 @@ def test_an_overhead_seen_clear_all_the_way_up_settles_headroom():
 
 
 def test_battery_clearance_is_needed_when_its_rule_reaches_past_gas_or_a_battery_is_marked():
-    # BAND_RULES set battery_clearance's radius (100) above gas's (1): the server evaluates it,
+    # BAND_RULES set battery_clearance's radius (2) above gas's (1): the server evaluates it,
     # so a result that leaves it out is flagged and its coverage is needed anyway.
-    wide = replace(RULES, needs=RULES.needs | {"battery_clearance": (Need("ground", 100.0),)})
+    wide = replace(RULES, needs=RULES.needs | {"battery_clearance": (Need("ground", 2.0),)})
     r = result(checks=[check()], sweep=[PASS_RUN])
     msgs = invariant_problems(SCENE, r, rules=wide)
     assert "the result leaves out check battery_clearance, which the rules define" in msgs
@@ -1223,9 +1224,9 @@ def test_a_passing_spot_must_stand_on_the_scanned_wall():
         ],
     )
     r["spot"]["span_ft"] = [11.0, 11.0 + 31 / 12]
+    r["spot"]["footprint"] = [[11, 0], [11 + 31 / 12, 0], [11 + 31 / 12, 22 / 12], [11, 22 / 12]]
     msgs = invariant_problems(broadly_seen(), r, rules=RULES)
-    assert any("spot [11.00, 13.58] runs past its straight wall [-12.00, 12.00]" in m for m in msgs)
-    assert any("sweep pass start 11.00 runs past its straight wall" in m for m in msgs)
+    assert msgs == ["spot: span_ft exceeds scanned range [-12.0, 12.0]"]
 
 
 def test_walls_meeting_in_a_straight_line_are_one_stretch_and_a_corner_is_not():
@@ -1565,3 +1566,115 @@ def test_in_scan_sweep_with_tiny_rule_step_fails_loudly():
     assert invariant_problems(SCENE, r, rules=replace(RULES, step_ft=1e-300)) == [
         "sweep unsure starts [0, 1]: sweep sampling exceeds the 10000 sample limit"
     ]
+
+
+@pytest.mark.parametrize("outcome", ["pass", "unsure", "fail"])
+@pytest.mark.parametrize("span", [[float("nan"), 1], [0, float("inf")], [2, 1]])
+def test_vet_all_sweep_spans_are_validated_before_downstream(monkeypatch, outcome, span):
+    def no_downstream(*args):
+        pytest.fail("invalid geometry reached downstream sampling")
+
+    monkeypatch.setattr("hsverify.resultcheck.run_starts", no_downstream)
+    answer = result(spot=False, sweep=[pass_run(*span) | {"outcome": outcome}])
+    assert any("finite and ordered" in p for p in invariant_problems(SCENE, answer, rules=RULES))
+
+
+def test_vet_identical_unsure_runs_are_sampled_only_once(monkeypatch):
+    calls = []
+
+    def starts(*args):
+        calls.append(True)
+        return iter([1.0])
+
+    monkeypatch.setattr("hsverify.resultcheck.run_starts", starts)
+    run = pass_run(1, 9) | {"outcome": "unsure"}
+    answer = result(spot=False, sweep=[copy.deepcopy(run) for _ in range(10_000)])
+    assert footprint_problems(SCENE, answer, RULES) == []
+    assert len(calls) == 1
+
+
+def test_vet_many_distinct_admissible_runs_exceed_one_response_budget(monkeypatch):
+    def no_sampling(*args):
+        pytest.fail("over-budget response reached sampling")
+
+    monkeypatch.setattr("hsverify.resultcheck.run_starts", no_sampling)
+    scene = copy.deepcopy(SCENE)
+    scene["walls"][0]["baseline"] = [[-2000, 0], [2000, 0]]
+    runs = [pass_run(i / 1000, 1000 + i / 1000) | {"outcome": "unsure"} for i in range(5000)]
+    answer = result(spot=False, sweep=runs)
+    assert invariant_problems(scene, answer, rules=RULES) == [
+        f"response geometry sample budget exceeds {MAX_GEOMETRY_SAMPLES} samples"
+    ]
+
+
+def test_vet_huge_spot_with_empty_sweep_stops_before_geometry(monkeypatch):
+    def no_geometry(*args):
+        pytest.fail("invalid spot reached the ground grid")
+
+    monkeypatch.setattr(GroundPlan, "_samples", no_geometry)
+    answer = result(sweep=[])
+    answer["spot"]["span_ft"] = [1, 1e9]
+    problems = invariant_problems(SCENE, answer, rules=RULES)
+    assert problems and any("span_ft" in p for p in problems)
+
+
+def test_vet_geometry_budget_counts_spot_ground_grid_before_iteration(monkeypatch):
+    def no_geometry(*args):
+        pytest.fail("over-budget spot reached the ground grid")
+
+    monkeypatch.setattr(GroundPlan, "_samples", no_geometry)
+    answer = result(sweep=[])
+    huge_reach = replace(RULES, needs={"gas_clearance": (Need("ground", 1e9),)})
+    assert invariant_problems(SCENE, answer, rules=huge_reach) == [
+        f"response geometry sample budget exceeds {MAX_GEOMETRY_SAMPLES} samples"
+    ]
+
+
+def test_vet_geometry_budget_counts_check_only_reported_width(monkeypatch):
+    answer = result(spot=False, sweep=[])
+    answer["checks"].append(
+        {"id": "width", "threshold_ft": 1e9, "rule": {"key": "battery.width_ft"}}
+    )
+    assert invariant_problems(SCENE, answer, rules=RULES) == [
+        f"response geometry sample budget exceeds {MAX_GEOMETRY_SAMPLES} samples"
+    ]
+
+
+def test_vet_ground_samples_are_lazy_and_preserve_grid_edges_and_centres():
+    points = GroundPlan._samples(0, 0.1)
+    assert iter(points) is points
+    assert list(points) == pytest.approx([0, 0.025, 0.05, 0.075, 0.1])
+
+
+def test_vet_repeated_spot_checks_count_toward_the_shared_budget(monkeypatch):
+    def no_geometry(*args):
+        pytest.fail("repeated checks reached geometry sampling")
+
+    monkeypatch.setattr(GroundPlan, "_samples", no_geometry)
+    answer = result(sweep=[], checks=[passing("ground_surface") for _ in range(1000)])
+    broad = replace(RULES, needs={"ground_surface": (Need("ground", 10),)})
+    assert invariant_problems(SCENE, answer, rules=broad) == [
+        f"response geometry sample budget exceeds {MAX_GEOMETRY_SAMPLES} samples"
+    ]
+
+
+def test_vet_budget_includes_midpoint_direction_switches(monkeypatch):
+    scene = copy.deepcopy(SCENE)
+    scene["meter"]["plus_minus_ft"] = 8.8
+    scene["walls"] = [
+        {"id": "w1", "baseline": [[0, 0], [10, 0]], "plus_minus_ft": 0},
+        {"id": "w2", "baseline": [[10, 0], [9, 0]], "plus_minus_ft": 0},
+        {"id": "w3", "baseline": [[9, 0], [109, 0]], "plus_minus_ft": 0},
+    ]
+    broad = replace(
+        RULES, width_ft=10, depth_ft=2, step_ft=0.1, needs={"ground_surface": (Need("ground", 0),)}
+    )
+    answer = result(spot=False, sweep=[pass_run(0, 10)])
+
+    def no_sampling(*args):
+        pytest.fail("midpoint error exceeded budget after admission")
+
+    monkeypatch.setattr("hsverify.resultcheck.run_starts", no_sampling)
+    assert invariant_problems(scene, answer, rules=broad) == [
+        f"response geometry sample budget exceeds {MAX_GEOMETRY_SAMPLES} samples"
+    ]
diff --git a/verification/tests/test_simrun.py b/verification/tests/test_simrun.py
index b4981cecc..3f5fef6d2 100644
--- a/verification/tests/test_simrun.py
+++ b/verification/tests/test_simrun.py
@@ -109,6 +109,25 @@ def test_missing_required_state_is_a_problem():
     assert missing_required([], []) == []
 
 
+def test_required_states_reject_reversed_complete_journey():
+    required = ["onboarding", "capture", "uploading", "result"]
+    assert missing_required(required, [shot(name) for name in reversed(required)]) == [
+        "required states did not appear in order: onboarding -> capture -> uploading -> result"
+    ]
+
+
+def test_required_states_allow_other_states_and_a_repeated_journey():
+    required = ["capture", "uploading", "result"]
+    states = ["result", "capture", "capture", "review", "uploading", "result"]
+    assert missing_required(required, [shot(name) for name in states]) == []
+
+
+def test_repeated_required_state_needs_a_separate_occurrence():
+    assert missing_required(["capture", "capture"], [shot("capture")]) == [
+        "required states did not appear in order: capture -> capture"
+    ]
+
+
 def test_sim_app_requires_the_result_state():
     makefile = (Path(__file__).resolve().parents[1] / "Makefile").read_text()
     recipe = makefile.split("\nsim-app:\n", 1)[1].split("\n\n", 1)[0]

From 17425e7ac46ea6b304b0613a58099899682991f7 Mon Sep 17 00:00:00 2001
From: SamGu-NRX <sgu07966@gmail.com>
Date: Wed, 14 Oct 2026 12:39:13 -0500
Subject: [PATCH 50/62] fix(verification): reject invalid reported dimensions
 and allow new failures

---
 verification/hsverify/e2e.py           |  8 +++
 verification/hsverify/resultcheck.py   | 75 +++++++++++++++++++++++++-
 verification/tests/test_e2e.py         | 24 +++++++++
 verification/tests/test_resultcheck.py | 70 ++++++++++++++++++++++++
 4 files changed, 175 insertions(+), 2 deletions(-)

diff --git a/verification/hsverify/e2e.py b/verification/hsverify/e2e.py
index 0c57c3540..c9755475c 100644
--- a/verification/hsverify/e2e.py
+++ b/verification/hsverify/e2e.py
@@ -73,6 +73,7 @@
     more_error_problems,
     outcome_lengths,
     public_assumption_warnings,
+    reported_dimension_problems,
     reported_rules,
     schema_errors,
     tape_to_tap,
@@ -577,6 +578,10 @@ def judge(
     if problems:
         return record | {"status": "fail", "problems": problems[:20], "contract_problems": problems}
 
+    dimensions = reported_dimension_problems(result, rules)
+    if dimensions:
+        return record | {"status": "fail", "problems": dimensions, "contract_problems": dimensions}
+
     # Unreported overrides cannot establish rule-dependent geometry or case expectations.
     mismatches = assumption_mismatches(item.rules_assumed, result)
     warnings = public_assumption_warnings(item.rules_assumed, result, rules)
@@ -636,6 +641,9 @@ def resend(name: str, scene: dict) -> dict | None:
         if errors:
             problems.append(f"{name}: result schema: {errors[0]}")
             return None
+        if dimensions := reported_dimension_problems(other, rules):
+            problems.extend(f"{name}: {p}" for p in dimensions)
+            return None
         problems.extend(
             f"{name}: {p}"
             for p in invariant_problems(
diff --git a/verification/hsverify/resultcheck.py b/verification/hsverify/resultcheck.py
index d24120c73..1f3c729a7 100644
--- a/verification/hsverify/resultcheck.py
+++ b/verification/hsverify/resultcheck.py
@@ -308,6 +308,8 @@ def margin_problem(check: dict) -> str | None:
 def invariant_problems(
     scene: dict, result: dict, sent: bytes | None = None, rules: RuleSet | None = None
 ) -> list[str]:
+    if dimensions := reported_dimension_problems(result, rules):
+        return dimensions
     if rules is not None and (sampling := sweep_sampling_problems(scene, result, rules)):
         return sampling
     problems: list[str] = []
@@ -1171,6 +1173,8 @@ def reported_assumption_values(key: str, result: dict) -> list[tuple[str, float]
 
 def reported_rules(result: dict, rules: RuleSet) -> RuleSet:
     """Use reported geometry for invariants too, so public defaults cannot reject an override."""
+    if problems := reported_dimension_problems(result, rules):
+        raise ValueError("; ".join(problems))
     changes = {}
     for key, field in (("battery_width", "width_ft"), ("corner_allowance", "corner_allowance_ft")):
         if values := reported_assumption_values(key, result):
@@ -1178,6 +1182,71 @@ def reported_rules(result: dict, rules: RuleSet) -> RuleSet:
     return replace(rules, **changes)
 
 
+def reported_dimension_problems(result: dict, rules: RuleSet | None) -> list[str]:
+    """Reject inconsistent C2 geometry before its dimensions can override public rules."""
+    problems = []
+
+    def finite(value: Any) -> bool:
+        return (
+            isinstance(value, (int, float)) and not isinstance(value, bool) and math.isfinite(value)
+        )
+
+    spots = [(name, result.get(name)) for name in ("spot", "nearest_considered")]
+    for name, spot in spots:
+        if spot is None:
+            continue
+        for field in ("width_ft", "depth_ft", "height_ft"):
+            if field in spot and (not finite(spot[field]) or spot[field] <= 0):
+                problems.append(f"{name}.{field} must be finite and positive")
+        span = spot.get("span_ft")
+        if span is not None:
+            if len(span) != 2 or not all(finite(v) for v in span) or span[0] >= span[1]:
+                problems.append(f"{name}.span_ft must be finite and increasing")
+            elif (
+                finite(spot.get("width_ft"))
+                and abs(span[1] - span[0] - spot["width_ft"]) > OFFSET_TOL_FT
+            ):
+                problems.append(f"{name}.width_ft does not match span_ft")
+        corners = spot.get("footprint")
+        if corners is None:
+            continue
+        if len(corners) != 4 or any(
+            len(point) != 2 or not all(finite(v) for v in point) for point in corners
+        ):
+            problems.append(f"{name}.footprint must have four finite plan corners")
+            continue
+        # C2 orders back-left, back-right, front-right, front-left. Use the verifier's existing
+        # hundredth-foot position tolerance when comparing its rounded plan edges and spans.
+        for field, edges in (("width_ft", ((0, 1), (2, 3))), ("depth_ft", ((1, 2), (3, 0)))):
+            if finite(spot.get(field)) and any(
+                abs(math.dist(corners[a], corners[b]) - spot[field]) > OFFSET_TOL_FT
+                for a, b in edges
+            ):
+                problems.append(f"{name}.{field} does not match footprint")
+
+    widths = reported_assumption_values("battery_width", result)
+    for source, width in widths:
+        if not finite(width) or width <= 0:
+            message = f"{source} must be finite and positive"
+            if message not in problems:
+                problems.append(message)
+    valid_widths = [(source, width) for source, width in widths if finite(width) and width > 0]
+    if valid_widths and any(
+        abs(width - valid_widths[0][1]) > NUMBER_TOL_FT for _, width in valid_widths
+    ):
+        problems.append("reported battery widths disagree")
+    first, second = (spot for _, spot in spots)
+    if first is not None and second is not None:
+        for field in ("depth_ft", "height_ft"):
+            if (
+                finite(first.get(field))
+                and finite(second.get(field))
+                and abs(first[field] - second[field]) > NUMBER_TOL_FT
+            ):
+                problems.append(f"spot and nearest_considered {field} disagree")
+    return problems
+
+
 def assumption_mismatches(assumed: dict[str, float], result: dict) -> list[str]:
     return [
         f"case assumes {key} threshold {value}, server's {source} uses {actual}"
@@ -1414,12 +1483,14 @@ def outcomes_near(result: dict, wall_id: str, start_ft: float) -> tuple[set[str]
 
 def more_error_problems(before: dict, after: dict, change: str) -> list[str]:
     """With more error, a start may only move toward UNSURE: UNSURE stays, PASS and FAIL stay
-    or become UNSURE. A start the original sweep never evaluated is read as `outcomes_near`."""
+    or become UNSURE. A start the original sweep never evaluated is read as `outcomes_near`.
+    A wall with no original run has no outcome to contradict a new FAIL, but cannot newly PASS.
+    """
     problems = []
     for wall_id, s in probe_starts(before, after):
         b = outcome_at(after, wall_id, s)
         allowed, was = outcomes_near(before, wall_id, s)
-        if b is None or b == "unsure" or b in allowed:
+        if b is None or b == "unsure" or b in allowed or (not allowed and b == "fail"):
             continue
         problems.append(f"{change}: start {wall_id} {s:.3f} went from {was} to {b}")
     if before["decision"] != "pass" and after["decision"] == "pass":
diff --git a/verification/tests/test_e2e.py b/verification/tests/test_e2e.py
index b7b9102e5..63bbbc74e 100644
--- a/verification/tests/test_e2e.py
+++ b/verification/tests/test_e2e.py
@@ -997,3 +997,27 @@ def invariants(scene, result, sent=None, rules=None):
     if reported_width is None:
         assert not report["contract_ok"]
         assert "assumed public rules; server may override" in (tmp_path / "report.md").read_text()
+
+
+@pytest.mark.parametrize("width", [-1, 0, float("nan"), float("inf")])
+def test_vet_judge_rejects_invalid_width_before_rule_consumers(monkeypatch, width):
+    answer = {
+        "decision": "reject",
+        "spot": None,
+        "sweep": [],
+        "checks": [{"id": "width", "threshold_ft": width, "rule": {"key": "battery.width_ft"}}],
+    }
+    monkeypatch.setattr(e2e, "post", lambda *args: (200, json.dumps(answer).encode(), 1))
+    monkeypatch.setattr(e2e, "schema_errors", lambda *args: [])
+    consumers = []
+    monkeypatch.setattr(
+        e2e, "invariant_problems", lambda *args, **kwargs: consumers.append("invariants") or []
+    )
+    monkeypatch.setattr(
+        e2e, "property_problems", lambda *args: consumers.append("properties") or []
+    )
+    item = SceneInput("invalid-width", SCENE, b"{}")
+    record = judge("unused", Endpoint("/place", "application/json"), item, SCHEMAS, RULES)
+    assert record["status"] == "fail"
+    assert record["contract_problems"] == ["width must be finite and positive"]
+    assert consumers == []
diff --git a/verification/tests/test_resultcheck.py b/verification/tests/test_resultcheck.py
index 2a16bc044..1d1c20ec0 100644
--- a/verification/tests/test_resultcheck.py
+++ b/verification/tests/test_resultcheck.py
@@ -1707,3 +1707,73 @@ def test_reported_override_prevents_a_false_footprint_failure():
     backing["rule"]["key"] = "battery.width_ft"
     assert footprint_problems(SCENE, answer, public)
     assert footprint_problems(SCENE, answer, reported_rules(answer, public)) == []
+
+
+@pytest.mark.parametrize("field", ["width_ft", "depth_ft", "height_ft"])
+@pytest.mark.parametrize("value", [-1, 0, float("nan"), float("inf")])
+def test_vet_reported_dimensions_refuse_invalid_numbers(field, value):
+    answer = result()
+    answer["spot"][field] = value
+    with pytest.raises(ValueError, match=f"spot.{field} must be finite and positive"):
+        reported_rules(answer, RULES)
+
+
+@pytest.mark.parametrize("source", ["spot", "nearest_considered", "check"])
+def test_vet_reported_width_sources_must_agree(source):
+    answer = result()
+    answer["nearest_considered"] = copy.deepcopy(answer["spot"])
+    answer["checks"].append(
+        {"id": "width", "threshold_ft": RULES.width_ft, "rule": {"key": "battery.width_ft"}}
+    )
+    if source == "check":
+        answer["checks"][-1]["threshold_ft"] = 4
+    else:
+        answer[source]["width_ft"] = 4
+    with pytest.raises(ValueError, match="reported battery widths disagree"):
+        reported_rules(answer, RULES)
+
+
+@pytest.mark.parametrize("source", ["spot", "nearest_considered"])
+@pytest.mark.parametrize("value", [4, 1e9])
+def test_vet_reported_width_must_match_span_and_footprint(source, value):
+    answer = result()
+    answer[source] = copy.deepcopy(answer["spot"])
+    answer[source]["width_ft"] = value
+    if source == "nearest_considered":
+        answer["spot"] = None
+    with pytest.raises(ValueError, match="does not match"):
+        reported_rules(answer, RULES)
+
+
+def test_vet_reported_depth_must_match_footprint():
+    answer = result()
+    answer["spot"]["depth_ft"] = 4
+    with pytest.raises(ValueError, match="depth_ft does not match footprint"):
+        reported_rules(answer, RULES)
+
+
+@pytest.mark.parametrize("value", [-1, 0, float("nan"), float("inf")])
+def test_vet_reported_width_threshold_must_be_finite_positive(value):
+    answer = {
+        "checks": [{"id": "width", "threshold_ft": value, "rule": {"key": "battery.width_ft"}}]
+    }
+    with pytest.raises(ValueError, match="width must be finite and positive"):
+        reported_rules(answer, RULES)
+
+
+@pytest.mark.parametrize("outcome", ["fail", "unsure"])
+@pytest.mark.parametrize("old_wall_has_run", [False, True])
+def test_vet_more_error_may_add_nonpassing_run_on_previously_unswept_wall(
+    outcome, old_wall_has_run
+):
+    before = swept(run(0, 4, "fail")) if old_wall_has_run else swept()
+    after = swept(*before["sweep"], run(10, 12, outcome, wall="w2"))
+    assert more_error_problems(before, after, "more error") == []
+
+
+def test_vet_more_error_cannot_add_pass_on_previously_unswept_wall():
+    before = swept(run(0, 4, "pass"), decision="pass")
+    after = swept(*before["sweep"], run(10, 12, "pass", wall="w2"), decision="pass")
+    assert more_error_problems(before, after, "more error") == [
+        f"more error: start w2 {s:.3f} went from no run on its wall to pass" for s in (10, 11, 12)
+    ]

From 03b0f0e35e477bed74c6912fb5377f1f18f6576a Mon Sep 17 00:00:00 2001
From: SamGu-NRX <sgu07966@gmail.com>
Date: Wed, 14 Oct 2026 12:47:07 -0500
Subject: [PATCH 51/62] docs(recon): distinguish repaired footprint edges from
 depth policy

---
 recon/HANDOFF.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/recon/HANDOFF.md b/recon/HANDOFF.md
index b952169d2..68dc5d8a8 100644
--- a/recon/HANDOFF.md
+++ b/recon/HANDOFF.md
@@ -129,7 +129,7 @@ In `recon/` on this branch:
 These defects remain after the review-debt repairs. They can let the server settle a check on evidence the worker does not have. The saved ETH3D results above predate those repairs; dataset acceptance has not been rerun.
 
 - **One view can count as two for free space.** `recon/coverage.py:189-193, 208-246`: `_slab` treats a voxel as observed when its fused weight is above zero, and any single frame gives it weight. Repro: a capture in which one frame alone sees the space in front of a wall cell reports a facing clearance there. Wall and ground cells need two positions 0.25 m apart for the same claim. The server at 903d86f can settle a check on that clearance. A fix needs visibility kept per frame for free space, with the same two-position test as the wall and ground.
-- **The overhead strip is narrower than a battery.** `recon/coverage.py:42, 236-245`: overhead space is sampled only 0.10 to 0.56 m out from the wall front. Repro: an eave 0.05 m out from the wall, or 0.7 m out over a 3 ft deep battery, is not found, and the cell reports clearance above it. A fix needs the footprint of the battery the chosen rule places, passed from the server's rules or request.
+- **The overhead strip is narrower than a battery.** `recon/coverage.py:42, 236-245`: overhead space is sampled only 0.10 to 0.56 m out from the wall front. The worker now samples the rear edge and the full existing 0.56 m depth, including its outer edge. A 0.7 m eave over a 3 ft deep battery still lies beyond that assumed depth. A fix needs the footprint of the battery the chosen rule places, passed from the server's rules or request.
 - **The photos-only clearance error is not calibrated.** `recon/pipeline.py:29-35`: facing gaps and overhead clearances from photos carry ±0.56 ft. That comes from the 95% interval of the evals' surface pair-error p90 over 1 to 3 m spans, not from any measurement of where the fused volume puts a boundary. The evals put surface p90 at 5.64 in [4.63, 6.66] and edges at 9.65 in [4.93, 15.01]. Repro: a photos-only overhead clearance measured at 7.10 ft passes the 6.5 ft headroom rule, since 7.10 − 0.56 = 6.54 > 6.5. A fix needs the clearance estimator's own measured uncertainty, or a gate that returns the check unresolved until that exists.
 
 The worker now replaces the target wall's prior measurements, stops clearance at any occupied sampled voxel, and refuses LiDAR without a confidence map. Ground coverage follows the fitted slope, and only whole cells within the fitted wall extent are exported. The regressions are in `tests/test_review_debt.py`; they do not validate the remaining clearance policies above.

From 2d959c7dd800e71d94f92d2b82421b8c48b46bef Mon Sep 17 00:00:00 2001
From: SamGu-NRX <sgu07966@gmail.com>
Date: Wed, 14 Oct 2026 12:47:26 -0500
Subject: [PATCH 52/62] docs(recon): describe the remaining battery depth
 assumption

---
 recon/HANDOFF.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/recon/HANDOFF.md b/recon/HANDOFF.md
index 68dc5d8a8..2113681fd 100644
--- a/recon/HANDOFF.md
+++ b/recon/HANDOFF.md
@@ -129,7 +129,7 @@ In `recon/` on this branch:
 These defects remain after the review-debt repairs. They can let the server settle a check on evidence the worker does not have. The saved ETH3D results above predate those repairs; dataset acceptance has not been rerun.
 
 - **One view can count as two for free space.** `recon/coverage.py:189-193, 208-246`: `_slab` treats a voxel as observed when its fused weight is above zero, and any single frame gives it weight. Repro: a capture in which one frame alone sees the space in front of a wall cell reports a facing clearance there. Wall and ground cells need two positions 0.25 m apart for the same claim. The server at 903d86f can settle a check on that clearance. A fix needs visibility kept per frame for free space, with the same two-position test as the wall and ground.
-- **The overhead strip is narrower than a battery.** `recon/coverage.py:42, 236-245`: overhead space is sampled only 0.10 to 0.56 m out from the wall front. The worker now samples the rear edge and the full existing 0.56 m depth, including its outer edge. A 0.7 m eave over a 3 ft deep battery still lies beyond that assumed depth. A fix needs the footprint of the battery the chosen rule places, passed from the server's rules or request.
+- **Overhead sampling assumes one battery depth.** `recon/coverage.py`: the worker samples both edges of the existing 0.56 m footprint. A 0.7 m eave over a 3 ft deep battery still lies beyond that assumed depth. Other battery depths need the footprint passed from the server's rules or request.
 - **The photos-only clearance error is not calibrated.** `recon/pipeline.py:29-35`: facing gaps and overhead clearances from photos carry ±0.56 ft. That comes from the 95% interval of the evals' surface pair-error p90 over 1 to 3 m spans, not from any measurement of where the fused volume puts a boundary. The evals put surface p90 at 5.64 in [4.63, 6.66] and edges at 9.65 in [4.93, 15.01]. Repro: a photos-only overhead clearance measured at 7.10 ft passes the 6.5 ft headroom rule, since 7.10 − 0.56 = 6.54 > 6.5. A fix needs the clearance estimator's own measured uncertainty, or a gate that returns the check unresolved until that exists.
 
 The worker now replaces the target wall's prior measurements, stops clearance at any occupied sampled voxel, and refuses LiDAR without a confidence map. Ground coverage follows the fitted slope, and only whole cells within the fitted wall extent are exported. The regressions are in `tests/test_review_debt.py`; they do not validate the remaining clearance policies above.

From 6c0639e890dca08aed43131e18363abe859137ee Mon Sep 17 00:00:00 2001
From: SamGu-NRX <sgu07966@gmail.com>
Date: Wed, 14 Oct 2026 13:06:06 -0500
Subject: [PATCH 53/62] fix(pipeline): require two views for occupied clearance
 measurements

---
 experiments/drift-anatomy/METHODS.md   |  2 +-
 experiments/drift-anatomy/README.md    |  2 +-
 recon/recon/coverage.py                | 11 ++--
 recon/tests/test_coverage_batches.py   | 11 ++--
 recon/tests/test_coverage_views.py     | 69 ++++++++++++++++++++++++++
 verification/hsverify/resultcheck.py   |  5 ++
 verification/tests/test_e2e.py         | 34 +++++++++++++
 verification/tests/test_resultcheck.py | 32 ++++++++++++
 8 files changed, 156 insertions(+), 10 deletions(-)

diff --git a/experiments/drift-anatomy/METHODS.md b/experiments/drift-anatomy/METHODS.md
index bfbbeb58d..346076b6b 100644
--- a/experiments/drift-anatomy/METHODS.md
+++ b/experiments/drift-anatomy/METHODS.md
@@ -20,7 +20,7 @@ The server allows 0.16 ft of error per foot along the wall. That allowance domin
 
 ## Result
 
-All four fail. Tables: [results/drift_anatomy.md](results/drift_anatomy.md).
+A1, A2 and A4 fail their numeric criteria. A3 fails the 60% criterion for a travel-axis proxy; this is not evidence that a wall-plane experiment failed. Wall-plane benefit remains untested without wall annotations. Tables: [results/drift_anatomy.md](results/drift_anatomy.md).
 
 - **A1.** 30 of 56 MARViN loops (54%). ADVIO has no revisit under 0.3 m while ARKit tracks. Scale and heading error cancel on return, so r misses them.
 - **A2.** 5.7% SD on MARViN, 19% on ADVIO: drop. A few outlier windows inflate MARViN's SD; its robust SD is 1.8%.
diff --git a/experiments/drift-anatomy/README.md b/experiments/drift-anatomy/README.md
index 612572a78..c5c68944f 100644
--- a/experiments/drift-anatomy/README.md
+++ b/experiments/drift-anatomy/README.md
@@ -13,7 +13,7 @@ The server allows 0.16 ft of error per foot along the wall, which dominates a ch
 
 ## Result
 
-All four fail ([tables](results/drift_anatomy.md)).
+A1, A2 and A4 fail their numeric criteria. A3 fails the 60% criterion for a travel-axis proxy; the unannotated walks cannot test wall-plane benefit ([tables](results/drift_anatomy.md)).
 
 - **A1.** The closure residual bounds the peak error in 30 of 56 loops. Scale and heading error cancel on return.
 - **A2.** Scale spread within a walk is 1.8% robust SD (5.7% SD) on MARViN.
diff --git a/recon/recon/coverage.py b/recon/recon/coverage.py
index 4f4687016..1b2a0f314 100644
--- a/recon/recon/coverage.py
+++ b/recon/recon/coverage.py
@@ -19,8 +19,8 @@
 
 Facing and overhead space needs no surface: it is observed where the fused volume shows it seen
 empty (every voxel observed, none occupied) and two camera positions at least 0.25 m apart each
-saw through it (`SeenFromTwo`), up to the first occupied voxel (a measured gap or clearance) or
-the first sample short of that (seen clear only that far).
+saw through it (`SeenFromTwo`). An occupied slab always stops the march, but supports a measured
+gap or clearance only when that slab also passes the observation test.
 """
 
 from __future__ import annotations
@@ -353,7 +353,9 @@ def free_space(wall: WallFrame, vol: Volume | SeenFromTwo, cells: np.ndarray):
             for out, hit, observed in zip(chunk, occupied, seen, strict=True):
                 # Any occupied sampled voxel stops clearance, including one-step thin rails.
                 if hit:
-                    facing_gap[c] = max(0.0, out - step - front)
+                    # A fused hit alone does not establish a two-view measurement.
+                    if observed:
+                        facing_gap[c] = max(0.0, out - step - front)
                     stopped = True
                     break
                 if not observed:
@@ -374,7 +376,8 @@ def free_space(wall: WallFrame, vol: Volume | SeenFromTwo, cells: np.ndarray):
             stopped = False
             for h, hit, observed in zip(chunk, occupied, seen, strict=True):
                 if hit:
-                    over_gap[c] = max(0.0, h - step)
+                    if observed:
+                        over_gap[c] = max(0.0, h - step)
                     stopped = True
                     break
                 if not observed:
diff --git a/recon/tests/test_coverage_batches.py b/recon/tests/test_coverage_batches.py
index c776f0533..204d6b807 100644
--- a/recon/tests/test_coverage_batches.py
+++ b/recon/tests/test_coverage_batches.py
@@ -32,18 +32,21 @@ def scalar_march(wall, volume, cells):
         for out in np.arange(front + step, front + coverage.FACING_MAX_M, step):
             share, seen = coverage._slab(wall, volume, across, heights, [out])
             if share > 0:
-                fg[c] = max(0, out - step - front)
+                if seen:
+                    fg[c] = max(0, out - step - front)
                 break
             if not seen:
                 break
             fc[c] = out - front
-        outs = front + np.arange(
-            coverage.OVERHEAD_OUT_M[0], coverage.OVERHEAD_OUT_M[1] + 1e-9, step
+        outs = front + np.append(
+            np.arange(coverage.OVERHEAD_OUT_M[0], coverage.OVERHEAD_OUT_M[1], step),
+            coverage.OVERHEAD_OUT_M[1],
         )
         for height in np.arange(0.3, coverage.OVERHEAD_MAX_M, step):
             share, seen = coverage._slab(wall, volume, across, [height], outs)
             if share > 0:
-                og[c] = max(0, height - step)
+                if seen:
+                    og[c] = max(0, height - step)
                 break
             if not seen:
                 break
diff --git a/recon/tests/test_coverage_views.py b/recon/tests/test_coverage_views.py
index cace017df..306ece85e 100644
--- a/recon/tests/test_coverage_views.py
+++ b/recon/tests/test_coverage_views.py
@@ -8,6 +8,7 @@
 from recon import coverage
 from recon.capture import Frame
 from recon.depth import Depth
+from recon.geometry import WallFrame
 
 
 class ClearVolume:
@@ -117,3 +118,71 @@ def test_one_view_or_one_position_never_claims_free_space():
             frame.cam_to_world[:3, 3] = [0, 1, 4]
         view = coverage.SeenFromTwo(ClearVolume(), frames, depths)
         assert not view.observed(np.array([[0, 1, 1]])).any()
+
+
+class FirstSlabObstacle(ClearVolume):
+    def __init__(self, band):
+        self.band = band
+
+    def occupied(self, points):
+        if self.band == "facing":
+            # A thin hit in the first outward slab, too small to become the wall front.
+            return np.isclose(points[:, 2], 0.1) & np.isclose(points[:, 1], 1.0)
+        return np.isclose(points[:, 1], 0.3) & np.isclose(points[:, 2], 0.3)
+
+
+def free_space_from_positions(raw, xs):
+    frames, depths = views(len(xs))
+    for frame, x in zip(frames, xs, strict=True):
+        frame.cam_to_world[:3, :3] = np.eye(3)
+        frame.cam_to_world[:3, 3] = [x, 1.0, 4.0]
+        depths[frame.id].depth[:] = 4.0
+    wall = WallFrame(
+        np.array([0.0, 1.0, 0.0]), np.array([1.0, 0, 0]), np.array([0, 0, 1.0]), 0.0, (0, 0.3)
+    )
+    cells = np.array([0.0])
+    arrays = coverage.free_space(wall, coverage.SeenFromTwo(raw, frames, depths), cells)
+    return coverage.CellCoverage(cells, np.zeros(1, bool), np.zeros(1), *arrays)
+
+
+@pytest.mark.parametrize("band", ["facing", "overhead"])
+@pytest.mark.parametrize(
+    ("xs", "supported"),
+    [([0.075], False), ([0.025, 0.125], False), ([-0.125, 0.275], True)],
+    ids=["one_camera", "nearby_cameras", "separated_cameras"],
+)
+def test_first_occupied_slab_needs_two_views_before_exporting_measurement(band, xs, supported):
+    cov = free_space_from_positions(FirstSlabObstacle(band), xs)
+    gap = cov.facing_gap if band == "facing" else cov.overhead_clearance
+    clear = cov.facing_clear if band == "facing" else cov.overhead_clear
+    entries = [entry for entry in coverage.observed(cov) if entry["band"] == band]
+    measurements = coverage.measurements(cov, "wall", 0.5)[0 if band == "facing" else 1]
+    # An occupied first slab never counts as empty, even when its measurement is unsupported.
+    assert clear[0] == 0.0
+    if supported:
+        assert gap[0] == pytest.approx(0.0 if band == "facing" else 0.25)
+        assert entries == [{"band": band, "span_ft": [0.0, 0.5]}]
+        assert len(measurements) == 1
+    else:
+        assert np.isnan(gap[0])
+        assert entries == []
+        assert measurements == []
+
+
+@pytest.mark.parametrize(
+    ("xs", "supported"),
+    [([0.075], False), ([0.025, 0.125], False), ([-0.125, 0.275], True)],
+    ids=["one_camera", "nearby_cameras", "separated_cameras"],
+)
+def test_empty_volume_needs_two_views_before_exporting_clear_space(xs, supported):
+    cov = free_space_from_positions(ClearVolume(), xs)
+    assert np.isnan(cov.facing_gap[0]) and np.isnan(cov.overhead_clearance[0])
+    assert coverage.measurements(cov, "wall", 0.5) == ([], [])
+    entries = coverage.observed(cov)
+    if supported:
+        assert cov.facing_clear[0] > 0 and cov.overhead_clear[0] > 0
+        assert {entry["band"] for entry in entries} == {"facing", "overhead"}
+        assert all(entry["out_ft"] > 0 for entry in entries)
+    else:
+        assert cov.facing_clear[0] == cov.overhead_clear[0] == 0.0
+        assert entries == []
diff --git a/verification/hsverify/resultcheck.py b/verification/hsverify/resultcheck.py
index 1fe22cc41..5609bf3a2 100644
--- a/verification/hsverify/resultcheck.py
+++ b/verification/hsverify/resultcheck.py
@@ -784,6 +784,11 @@ def finite(value: Any) -> bool:
             message = f"{source} must be finite and positive"
             if message not in problems:
                 problems.append(message)
+    for check in result.get("checks", []):
+        if check.get("rule", {}).get("key") == "route.corner_allowance_ft":
+            allowance = check.get("threshold_ft")
+            if allowance is not None and (not finite(allowance) or allowance < 0):
+                problems.append(f"{check['id']} corner allowance must be finite and nonnegative")
     valid_widths = [(source, width) for source, width in widths if finite(width) and width > 0]
     if valid_widths and any(
         abs(width - valid_widths[0][1]) > NUMBER_TOL_FT for _, width in valid_widths
diff --git a/verification/tests/test_e2e.py b/verification/tests/test_e2e.py
index f0eb65990..276a5074b 100644
--- a/verification/tests/test_e2e.py
+++ b/verification/tests/test_e2e.py
@@ -1151,3 +1151,37 @@ def no_adoption(*args):
         else ["width must be finite and positive"]
     )
     assert consumers == []
+
+
+@pytest.mark.parametrize("allowance", [-1, float("nan"), float("inf")])
+def test_breadth_invalid_corner_allowance_stops_before_rule_adoption(monkeypatch, allowance):
+    answer = {
+        "decision": "reject",
+        "spot": None,
+        "sweep": [],
+        "checks": [
+            {
+                "id": "route_corner",
+                "threshold_ft": allowance,
+                "rule": {"key": "route.corner_allowance_ft"},
+            }
+        ],
+    }
+    monkeypatch.setattr(e2e, "post", lambda *args: (200, json.dumps(answer).encode(), 1))
+    monkeypatch.setattr(e2e, "schema_errors", lambda *args: [])
+
+    def no_adoption(*args):
+        pytest.fail("invalid corner allowance reached rule adoption")
+
+    monkeypatch.setattr(e2e, "reported_rules", no_adoption)
+    record = judge(
+        "unused",
+        Endpoint("/place", "application/json"),
+        SceneInput("corner", SCENE, b"{}"),
+        SCHEMAS,
+        RULES,
+    )
+    assert record["status"] == "fail"
+    assert record["contract_problems"] == [
+        "route_corner corner allowance must be finite and nonnegative"
+    ]
diff --git a/verification/tests/test_resultcheck.py b/verification/tests/test_resultcheck.py
index 52197525e..c3a21d21c 100644
--- a/verification/tests/test_resultcheck.py
+++ b/verification/tests/test_resultcheck.py
@@ -1890,3 +1890,35 @@ def no_sampling(*args):
     assert invariant_problems(scene, answer, rules=broad) == [
         f"response geometry sample budget exceeds {MAX_GEOMETRY_SAMPLES} samples"
     ]
+
+
+@pytest.mark.parametrize("allowance", [-1, float("nan"), float("inf"), -float("inf")])
+def test_breadth_corner_allowance_must_be_finite_nonnegative(allowance):
+    answer = {
+        "checks": [
+            {
+                "id": "route_corner",
+                "threshold_ft": allowance,
+                "rule": {"key": "route.corner_allowance_ft"},
+            }
+        ]
+    }
+    with pytest.raises(ValueError, match="corner allowance must be finite and nonnegative"):
+        reported_rules(answer, RULES)
+    assert invariant_problems(SCENE, answer, rules=RULES) == [
+        "route_corner corner allowance must be finite and nonnegative"
+    ]
+
+
+@pytest.mark.parametrize("allowance", [0, 0.5])
+def test_breadth_zero_or_positive_corner_allowance_is_valid(allowance):
+    answer = {
+        "checks": [
+            {
+                "id": "route_corner",
+                "threshold_ft": allowance,
+                "rule": {"key": "route.corner_allowance_ft"},
+            }
+        ]
+    }
+    assert reported_rules(answer, RULES).corner_allowance_ft == allowance

From 68cb6859ea6ee9ed09f8209ec7786c5cb0956f69 Mon Sep 17 00:00:00 2001
From: SamGu-NRX <sgu07966@gmail.com>
Date: Wed, 14 Oct 2026 13:55:25 -0500
Subject: [PATCH 54/62] fix(verification): meter actual geometry and comparison
 work

---
 verification/hsverify/e2e.py              | 144 +++--
 verification/hsverify/intervalindex.py    | 175 ++++++
 verification/hsverify/resultcheck.py      | 667 +++++++++++++---------
 verification/tests/test_e2e.py            |  10 +-
 verification/tests/test_generate_cases.py |   2 +-
 verification/tests/test_intervalindex.py  | 113 ++++
 verification/tests/test_judge_meter.py    | 294 ++++++++++
 verification/tests/test_resultcheck.py    |  70 +--
 verification/tests/test_runtime_meter.py  | 181 ++++++
 9 files changed, 1311 insertions(+), 345 deletions(-)
 create mode 100644 verification/hsverify/intervalindex.py
 create mode 100644 verification/tests/test_intervalindex.py
 create mode 100644 verification/tests/test_judge_meter.py
 create mode 100644 verification/tests/test_runtime_meter.py

diff --git a/verification/hsverify/e2e.py b/verification/hsverify/e2e.py
index aa4194756..6ef459931 100644
--- a/verification/hsverify/e2e.py
+++ b/verification/hsverify/e2e.py
@@ -51,7 +51,7 @@
 import urllib.request
 import uuid
 import zipfile
-from collections.abc import Iterator
+from collections.abc import Callable, Iterator
 from dataclasses import dataclass, field
 from pathlib import Path
 
@@ -60,10 +60,13 @@
 from hsverify.memory import peak_rss_mb
 from hsverify.resultcheck import (
     RuleSet,
+    WorkLimitExceeded,
+    WorkMeter,
     assumption_mismatches,
     comparable,
     coverage_blocks,
     expectation_problems,
+    geometry_admission_problems,
     invariant_problems,
     less_coverage_problems,
     mirror_scene,
@@ -469,7 +472,10 @@ def judge(
     schemas: dict,
     rules: RuleSet,
     limit: memory.TreeLimit | None = None,
+    *,
+    meter: WorkMeter | None = None,
 ) -> dict:
+    meter = meter if meter is not None else WorkMeter()
     record: dict = {
         "name": item.name,
         "source": item.source,
@@ -499,36 +505,92 @@ def judge(
         failure = [f"HTTP 200 with a body that is not a JSON object: {payload[:200]!r}"]
         return record | {"status": "fail", "problems": failure, "contract_problems": failure}
     record["result"] = result
-    problems = [f"result schema: {e}" for e in schema_errors(result, schemas["result"])]
+
+    def check(name: str, function: Callable[[], list[str]]) -> list[str]:
+        try:
+            return function()
+        except WorkLimitExceeded:
+            return [f"verification work limit exceeded ({meter.samples} samples)"]
+        except Exception as exc:
+            return [f"{name}: {type(exc).__name__}: {exc}"]
+
+    problems = check(
+        "result schema",
+        lambda: [f"result schema: {e}" for e in schema_errors(result, schemas["result"])],
+    )
     if problems:
         return record | {"status": "fail", "problems": problems[:20], "contract_problems": problems}
 
-    # Contract problems hold for any scene; expectation problems depend on one case's geometry.
-    contract = invariant_problems(item.scene, result, sent=item.raw, rules=rules)
-    contract += property_problems(url, endpoint, item, result, schemas, rules)
+    # Admission errors stop geometry, including report summaries that subtract spans.
+    contract = check(
+        "geometry admission",
+        lambda: geometry_admission_problems(item.scene, result, rules, meter=meter),
+    )
+    admitted = not contract
+    if admitted:
+        contract += check(
+            "invariants",
+            lambda: invariant_problems(item.scene, result, sent=item.raw, rules=rules, meter=meter),
+        )
+    if not contract:
+        contract += check(
+            "properties",
+            lambda: property_problems(url, endpoint, item, result, schemas, rules, meter=meter),
+        )
     if item.real and ms > LATENCY_BUDGET_MS:
         contract.append(f"real-derived scene took {ms:.0f} ms, budget {LATENCY_BUDGET_MS:.0f}")
-    mismatches = assumption_mismatches(item.rules_assumed, result, rules)
-    expected = expectation_problems(item.expect, result) if item.expect and not mismatches else []
-    problems = contract + expected
+    mismatches: list[str] = []
+    expected: list[str] = []
+    exhausted = any(p.startswith("verification work limit exceeded (") for p in contract)
+    if admitted and not exhausted:
+
+        def check_assumptions() -> list[str]:
+            mismatches.extend(assumption_mismatches(item.rules_assumed, result, rules))
+            return []
+
+        contract += check("assumptions", check_assumptions)
+        if item.expect and not mismatches:
+            expected = check(
+                "expectations", lambda: expectation_problems(item.expect, result, meter=meter)
+            )
+
+        def summarize() -> list[str]:
+            record["outcome_lengths_ft"] = outcome_lengths(result)
+            return []
 
-    record["decision"] = result["decision"]
-    record["outcome_lengths_ft"] = outcome_lengths(result)
+        contract += check("outcome lengths", summarize)
+    if "decision" in result:
+        record["decision"] = result["decision"]
     if mismatches:
         record["assumption_mismatches"] = mismatches
+    record["verification_samples"] = meter.samples
     record["contract_problems"] = contract
     record["expectation_problems"] = expected
-    record["problems"] = problems
-    record["status"] = "fail" if problems else "assumption mismatch" if mismatches else "pass"
+    record["problems"] = contract + expected
+    record["status"] = (
+        "fail" if record["problems"] else "assumption mismatch" if mismatches else "pass"
+    )
     return record
 
 
 def property_problems(
-    url: str, endpoint: Endpoint, item: SceneInput, result: dict, schemas: dict, rules: RuleSet
+    url: str,
+    endpoint: Endpoint,
+    item: SceneInput,
+    result: dict,
+    schemas: dict,
+    rules: RuleSet,
+    *,
+    meter: WorkMeter | None = None,
+    rule_checks: bool = True,
 ) -> list[str]:
     """The same scene resent unchanged and transformed. Every answer to a transformed scene must
     also satisfy the invariants, and the transforms that only lose information must not make
     the server surer."""
+    meter = meter if meter is not None else WorkMeter()
+    checked_rules = rules if rule_checks else None
+    if admission := geometry_admission_problems(item.scene, result, checked_rules, meter=meter):
+        return admission
     problems: list[str] = []
 
     def resend(name: str, scene: dict) -> dict | None:
@@ -537,14 +599,29 @@ def resend(name: str, scene: dict) -> dict | None:
         if failure:
             problems.append(f"{name}: {failure}")
             return None
-        errors = schema_errors(other, schemas["result"])
-        if errors:
-            problems.append(f"{name}: result schema: {errors[0]}")
+        check_name = "result schema"
+        try:
+            errors = schema_errors(other, schemas["result"])
+            if errors:
+                problems.append(f"{name}: result schema: {errors[0]}")
+                return None
+            check_name = "geometry admission"
+            admission = geometry_admission_problems(scene, other, checked_rules, meter=meter)
+            if admission:
+                problems.extend(f"{name}: {p}" for p in admission)
+                return None
+            check_name = "invariants"
+            invariants = invariant_problems(
+                scene, other, sent=transformed.raw, rules=checked_rules, meter=meter
+            )
+            if invariants:
+                problems.extend(f"{name}: {p}" for p in invariants)
+                return None
+        except WorkLimitExceeded:
+            raise
+        except Exception as exc:
+            problems.append(f"{name} {check_name}: {type(exc).__name__}: {exc}")
             return None
-        problems.extend(
-            f"{name}: {p}"
-            for p in invariant_problems(scene, other, sent=transformed.raw, rules=rules)
-        )
         return other
 
     # 1. Same input, same answer.
@@ -572,19 +649,22 @@ def resend(name: str, scene: dict) -> dict | None:
     if "coverage" in item.scene:
         bare = {k: v for k, v in item.scene.items() if k != "coverage"}
         if (other := resend("no coverage", bare)) is not None:
-            problems += less_coverage_problems(result, other, "no coverage")
-    for name, scene in (
-        ("less coverage", with_less_coverage(item.scene)),
-        ("ground short of the largest clearance", with_ground_short_of(item.scene, rules)),
-    ):
-        if scene is not None and (other := resend(name, scene)) is not None:
-            problems += less_coverage_problems(result, other, name)
-    for name, scene in (
-        ("more error", with_more_error(item.scene, rules)),
-        ("tape re-measured by tap", tape_to_tap(item.scene)),
-    ):
+            problems += less_coverage_problems(result, other, "no coverage", meter=meter)
+    coverage_variants = [("less coverage", with_less_coverage(item.scene))]
+    if rule_checks:
+        coverage_variants.append(
+            ("ground short of the largest clearance", with_ground_short_of(item.scene, rules))
+        )
+    for name, scene in coverage_variants:
         if scene is not None and (other := resend(name, scene)) is not None:
-            problems += more_error_problems(result, other, name)
+            problems += less_coverage_problems(result, other, name, meter=meter)
+    if rule_checks:
+        for name, scene in (
+            ("more error", with_more_error(item.scene, rules)),
+            ("tape re-measured by tap", tape_to_tap(item.scene)),
+        ):
+            if scene is not None and (other := resend(name, scene)) is not None:
+                problems += more_error_problems(result, other, name, meter=meter)
 
     # 4. Showing everything the result asked for settles every check that was unsure only
     # because an area was unobserved (the chosen spot may move; three rounds at most).
diff --git a/verification/hsverify/intervalindex.py b/verification/hsverify/intervalindex.py
new file mode 100644
index 000000000..0a2e596c9
--- /dev/null
+++ b/verification/hsverify/intervalindex.py
@@ -0,0 +1,175 @@
+"""Compare sweep outcomes without scanning every run for each sampled start."""
+
+from __future__ import annotations
+
+import heapq
+from dataclasses import dataclass
+from typing import Protocol
+
+
+class Meter(Protocol):
+    def charge(self, n: int = 1) -> None: ...
+
+
+def _charge(meter: Meter | None, n: int = 1) -> None:
+    if meter is not None:
+        meter.charge(n)
+
+
+def _bisect(values: list[float], value: float, meter: Meter | None, *, right=False) -> int:
+    lo, hi = 0, len(values)
+    while lo < hi:
+        _charge(meter)
+        mid = (lo + hi) // 2
+        if values[mid] < value or (right and values[mid] == value):
+            lo = mid + 1
+        else:
+            hi = mid
+    return lo
+
+
+@dataclass
+class _WallIndex:
+    endpoints: list[float]
+    at_endpoint: list[str | None]
+    after_endpoint: list[str | None]
+    starts: list[float]
+    start_outcomes: list[str]
+    ends: list[float]
+    end_outcomes: list[str]
+
+
+class SweepIndex:
+    """Index closed intervals, choosing the first original run when intervals overlap.
+
+    Endpoint outcomes and the outcomes between endpoints are stored separately. This keeps
+    an interval's inclusive endpoint, including EPS expansion, without changing overlap order.
+    """
+
+    def __init__(self, result: dict, meter: Meter | None = None, eps: float = 1e-6):
+        self.meter = meter
+        groups: dict[str, list[dict]] = {}
+        for run in result.get("sweep", []):
+            _charge(meter)
+            groups.setdefault(run["wall_id"], []).append(run)
+        self.walls = {wall: self._build(runs, eps) for wall, runs in groups.items()}
+
+    def _build(self, runs: list[dict], eps: float) -> _WallIndex:
+        events = []
+        starts, ends = {}, {}
+        for rank, run in enumerate(runs):
+            _charge(self.meter)
+            a, b = run["start_ft"]
+            events.extend(((a - eps, 0, rank), (b + eps, 1, rank)))
+            starts.setdefault(a, run["outcome"])
+            ends.setdefault(b, run["outcome"])
+        events.sort()
+        active = [False] * len(runs)
+        heap: list[int] = []
+        endpoints, at_endpoint, after_endpoint = [], [], []
+
+        def first() -> str | None:
+            while heap and not active[heap[0]]:
+                _charge(self.meter)
+                heapq.heappop(heap)
+            return runs[heap[0]]["outcome"] if heap else None
+
+        pos = 0
+        while pos < len(events):
+            value = events[pos][0]
+            ending = []
+            while pos < len(events) and events[pos][0] == value:
+                _charge(self.meter)
+                _, kind, rank = events[pos]
+                if kind == 0:
+                    active[rank] = True
+                    heapq.heappush(heap, rank)
+                else:
+                    ending.append(rank)
+                pos += 1
+            endpoints.append(value)
+            at_endpoint.append(first())
+            for rank in ending:
+                _charge(self.meter)
+                active[rank] = False
+            after_endpoint.append(first())
+        start_values, end_values = sorted(starts), sorted(ends)
+        return _WallIndex(
+            endpoints,
+            at_endpoint,
+            after_endpoint,
+            start_values,
+            [starts[a] for a in start_values],
+            end_values,
+            [ends[b] for b in end_values],
+        )
+
+    def outcome_at(self, wall_id: str, start_ft: float) -> str | None:
+        _charge(self.meter)
+        wall = self.walls.get(wall_id)
+        if wall is None:
+            return None
+        i = _bisect(wall.endpoints, start_ft, self.meter)
+        if i < len(wall.endpoints) and wall.endpoints[i] == start_ft:
+            return wall.at_endpoint[i]
+        return wall.after_endpoint[i - 1] if i else None
+
+    def outcomes_near(self, wall_id: str, start_ft: float) -> tuple[set[str], str]:
+        if (inside := self.outcome_at(wall_id, start_ft)) is not None:
+            return {inside}, inside
+        wall = self.walls.get(wall_id)
+        if wall is None:
+            return set(), "no run on its wall"
+        left = _bisect(wall.ends, start_ft, self.meter) - 1
+        right = _bisect(wall.starts, start_ft, self.meter, right=True)
+        if left < 0 or right == len(wall.starts):
+            return {"fail"}, "past the original sweep"
+        a, b = wall.end_outcomes[left], wall.start_outcomes[right]
+        return {a, b}, f"unswept beside {a} and {b}"
+
+
+def probe_starts(*results: dict, meter: Meter | None = None) -> list[tuple[str, float]]:
+    points = set()
+    for result in results:
+        for run in result.get("sweep", []):
+            _charge(meter, 3)
+            a, b = run["start_ft"]
+            # Halving first avoids overflowing the sum of two admitted finite endpoints.
+            points.update(
+                ((run["wall_id"], a), (run["wall_id"], b), (run["wall_id"], a / 2 + b / 2))
+            )
+    return sorted(points)
+
+
+def more_error_problems(
+    before: dict, after: dict, change: str, meter: Meter | None = None
+) -> list[str]:
+    original, changed = SweepIndex(before, meter), SweepIndex(after, meter)
+    problems = []
+    for wall_id, s in probe_starts(before, after, meter=meter):
+        _charge(meter)
+        b = changed.outcome_at(wall_id, s)
+        allowed, was = original.outcomes_near(wall_id, s)
+        if b is None or b == "unsure" or b in allowed or (not allowed and b == "fail"):
+            continue
+        problems.append(f"{change}: start {wall_id} {s:.3f} went from {was} to {b}")
+    if before["decision"] != "pass" and after["decision"] == "pass":
+        problems.append(f"{change}: the decision became pass")
+    return problems
+
+
+def less_coverage_problems(
+    before: dict, after: dict, change: str, meter: Meter | None = None
+) -> list[str]:
+    original, changed = SweepIndex(before, meter), SweepIndex(after, meter)
+    problems = []
+    for wall_id, s in probe_starts(before, after, meter=meter):
+        _charge(meter)
+        if changed.outcome_at(wall_id, s) != "pass":
+            continue
+        allowed, was = original.outcomes_near(wall_id, s)
+        if "pass" not in allowed:
+            problems.append(f"{change}: start {wall_id} {s:.3f} went from {was} to pass")
+    if before["decision"] != "pass" and after["decision"] == "pass":
+        problems.append(f"{change}: the decision became pass")
+    return problems
diff --git a/verification/hsverify/resultcheck.py b/verification/hsverify/resultcheck.py
index a7a1eca77..8212ad087 100644
--- a/verification/hsverify/resultcheck.py
+++ b/verification/hsverify/resultcheck.py
@@ -31,21 +31,96 @@
 import json
 import math
 from collections.abc import Callable, Iterator
-from dataclasses import dataclass, replace
+from dataclasses import dataclass
 from typing import Any
 
 import yaml
 from jsonschema import Draft202012Validator
 
+from .intervalindex import (
+    SweepIndex,
+)
+from .intervalindex import (
+    less_coverage_problems as indexed_less_coverage_problems,
+)
+from .intervalindex import (
+    more_error_problems as indexed_more_error_problems,
+)
+from .intervalindex import (
+    probe_starts as indexed_probe_starts,
+)
+
 EPS = 1e-6
 NUMBER_TOL_FT = 1e-5
 # Bound verifier work even when a server span or rules step requests billions of samples.
 MAX_SWEEP_SAMPLES = 10_000
-# The existing public-pool regression has 55 starts and a worst-case ground
-# reach of 14.15 ft: its conservative grid bound is below 50 million visits.
-# This cap retains that case while bounding aggregate work; it is a resource
-# policy, not a measured runtime or a physical scan limit.
-MAX_GEOMETRY_SAMPLES = 50_000_000
+# On 2026-10-14, 35 public fixture judgments without contract problems, including
+# property variants, peaked at 80,788 units for pass-clear-side-wall. Another 468
+# distinct saved responses matched to current fixtures peaked at 392,115 invariant
+# units for ETH3D facade. Allow 20 times that larger recorded peak for other scans
+# and their property variants. This is an operational bound, not a calibration of
+# measurement accuracy or evidence that the samples prove physical clearance.
+MAX_WORK_SAMPLES = 20 * 392_115
+
+
+class WorkLimitExceeded(Exception):
+    def __init__(self, samples: int) -> None:
+        self.samples = samples
+        super().__init__(f"verification work limit exceeded ({samples} samples)")
+
+
+class WorkMeter:
+    """Count actual geometry work across one response and its property comparisons."""
+
+    def __init__(self, limit: int | None = None) -> None:
+        self.limit = MAX_WORK_SAMPLES if limit is None else limit
+        self.samples = 0
+        self.cache: dict[tuple, Any] = {}
+        self.inputs: dict[int, tuple[Any, int]] = {}
+        self.input_values: dict[Any, int] = {}
+
+    def charge(self, n: int = 1) -> None:
+        if n < 0:
+            raise ValueError("verification work charge must be nonnegative")
+        self.samples += n
+        if self.samples > self.limit:
+            raise WorkLimitExceeded(self.samples)
+
+    def input_key(self, value: Any) -> Any:
+        # judge's scenes and rule sets are immutable during a response's checks. Keep the
+        # source alive so a later transformed scene cannot reuse its object id.
+        identity = id(value)
+        if identity not in self.inputs:
+            frozen = _input_key(value, self)
+            token = self.input_values.setdefault(frozen, len(self.input_values))
+            self.inputs[identity] = (value, token)
+        return self.inputs[identity][1]
+
+
+def finite(value: Any) -> bool:
+    """JSON integers may exceed the float range accepted by math.isfinite."""
+    try:
+        return (
+            isinstance(value, (int, float)) and not isinstance(value, bool) and math.isfinite(value)
+        )
+    except (OverflowError, TypeError, ValueError):
+        return False
+
+
+def _input_key(value: Any, meter: WorkMeter | None = None) -> Any:
+    if meter is not None:
+        meter.charge()
+    if isinstance(value, dict):
+        return tuple((key, _input_key(item, meter)) for key, item in sorted(value.items()))
+    if isinstance(value, (tuple, list)):
+        return tuple(_input_key(item, meter) for item in value)
+    if isinstance(value, RuleSet):
+        return _input_key(vars(value), meter)
+    if isinstance(value, Need):
+        return _input_key(vars(value), meter)
+    return value
+
+
 # Spot centres and offsets are rounded by the server; a hundredth of a foot is 1/8 inch.
 OFFSET_TOL_FT = 0.01
 
@@ -191,6 +266,7 @@ def observed(
     min_out_ft: float = 0.0,
     beyond: bool = False,
     wall_default_ft: float | None = None,
+    meter: WorkMeter | None = None,
 ) -> list[tuple[float, float]]:
     """Merged observed s-intervals for a band, counting only entries whose view reached
     `min_out_ft` (out from the wall for ground and facing, up for wall and overhead). With
@@ -201,8 +277,10 @@ def observed(
     headroom.min_ft) and settles any height up to it inclusively, `beyond` or not; S2 chose
     this category default at 6200098 (server/scene.py `observed_intervals`). None keeps the
     old reading, all the way up."""
+    meter = meter if meter is not None else WorkMeter()
     spans = []
     for entry in scene.get("coverage", {}).get("observed", []):
+        meter.charge()
         if entry["band"] != band:
             continue
         if band == "wall" and "out_ft" not in entry and wall_default_ft is not None:
@@ -220,6 +298,7 @@ def observed(
     spans.sort()
     merged: list[list[float]] = []
     for a, b in spans:
+        meter.charge()
         if merged and a <= merged[-1][1] + EPS:
             merged[-1][1] = max(merged[-1][1], b)
         else:
@@ -227,8 +306,19 @@ def observed(
     return [(a, b) for a, b in merged]
 
 
-def covers(intervals: list[tuple[float, float]], a: float, b: float, slack: float = 0.0) -> bool:
-    return any(lo - slack <= a + EPS and b - EPS <= hi + slack for lo, hi in intervals)
+def covers(
+    intervals: list[tuple[float, float]],
+    a: float,
+    b: float,
+    slack: float = 0.0,
+    meter: WorkMeter | None = None,
+) -> bool:
+    meter = meter if meter is not None else WorkMeter()
+    for lo, hi in intervals:
+        meter.charge()
+        if lo - slack <= a + EPS and b - EPS <= hi + slack:
+            return True
+    return False
 
 
 # A gap in a 1D band narrower than this is rounding between the capture's spans and the unrolled
@@ -237,12 +327,14 @@ def covers(intervals: list[tuple[float, float]], a: float, b: float, slack: floa
 
 
 def gaps_over(
-    intervals: list[tuple[float, float]], a: float, b: float
+    intervals: list[tuple[float, float]], a: float, b: float, meter: WorkMeter | None = None
 ) -> list[tuple[float, float]]:
     """The parts of [a, b] no interval covers, as the server's missing() finds them: gaps
     narrower than COVERAGE_TOLERANCE_FT don't count."""
+    meter = meter if meter is not None else WorkMeter()
     gaps, at = [], a
     for lo, hi in sorted(intervals):
+        meter.charge()
         if hi <= at:
             continue
         if lo > at:
@@ -312,9 +404,14 @@ def margin_problem(check: dict) -> str | None:
 
 
 def invariant_problems(
-    scene: dict, result: dict, sent: bytes | None = None, rules: RuleSet | None = None
+    scene: dict,
+    result: dict,
+    sent: bytes | None = None,
+    rules: RuleSet | None = None,
+    meter: WorkMeter | None = None,
 ) -> list[str]:
-    if sampling := geometry_admission_problems(scene, result, rules):
+    meter = meter if meter is not None else WorkMeter()
+    if sampling := geometry_admission_problems(scene, result, rules, meter=meter):
         return sampling
     result = deduplicate_result_runs(result)
     problems: list[str] = []
@@ -384,15 +481,27 @@ def invariant_problems(
         if max(abs(want[0] - got[0]), abs(want[1] - got[1])) > OFFSET_TOL_FT:
             problems.append(f"spot.meter_offset_ft {got} != centre - meter {want}")
 
-    problems += spot_sweep_problems(result)
+    def checked(name: str, run: Callable[[], list[str]]) -> None:
+        try:
+            problems.extend(run())
+        except WorkLimitExceeded:
+            raise
+        except Exception as exc:
+            problems.append(f"{name}: {type(exc).__name__}: {exc}")
+
+    checked("spot_sweep", lambda: spot_sweep_problems(result, meter=meter))
     if rules is not None:
-        problems += footprint_problems(scene, result, rules)
-        problems += spot_position_problems(scene, result, rules)
-    problems += missing_evidence_problems(scene, result, rules)
+        checked("footprint", lambda: footprint_problems(scene, result, rules, meter=meter))
+        checked("spot_position", lambda: spot_position_problems(scene, result, rules, meter=meter))
+    checked(
+        "missing_evidence", lambda: missing_evidence_problems(scene, result, rules, meter=meter)
+    )
     if rules is not None:
-        problems += coverage_problems(scene, result, rules)
-        problems += declared_height_problems(scene, result, rules)
-        problems += dropped_check_problems(scene, result, rules)
+        checked("coverage", lambda: coverage_problems(scene, result, rules, meter=meter))
+        checked(
+            "declared_height", lambda: declared_height_problems(scene, result, rules, meter=meter)
+        )
+        checked("dropped_checks", lambda: dropped_check_problems(scene, result, rules))
     return problems
 
 
@@ -406,12 +515,16 @@ def invariant_problems(
 COLLINEAR_FT = 0.05
 
 
-def straight_pieces(scene: dict, rules: RuleSet) -> list[tuple[float, float]]:
+def straight_pieces(
+    scene: dict, rules: RuleSet, meter: WorkMeter | None = None
+) -> list[tuple[float, float]]:
     """The s-extent of each straight stretch of scanned wall a battery can back onto: baseline
     segments joined where the next one starts at the previous one's end and continues its line,
     within a wall or across two walls that meet."""
+    meter = meter if meter is not None else WorkMeter()
     pieces: list[list] = []  # [s0, s1, start point, end point]
-    for _, s0, s1, a, b in segments_s(scene, rules) or []:
+    for _, s0, s1, a, b in segments_s(scene, rules, meter=meter) or []:
+        meter.charge()
         if pieces:
             prev = pieces[-1]
             length = math.dist(prev[2], prev[3])
@@ -426,23 +539,36 @@ def straight_pieces(scene: dict, rules: RuleSet) -> list[tuple[float, float]]:
     return [(p[0], p[1]) for p in pieces]
 
 
-def footprint_problems(scene: dict, result: dict, rules: RuleSet) -> list[str]:
+def footprint_problems(
+    scene: dict, result: dict, rules: RuleSet, meter: WorkMeter | None = None
+) -> list[str]:
     """A battery that passes or is left to a person backs onto one straight stretch of scanned
     wall along its whole width; a footprint past the stretch's end (a corner, the end of the
     wall, a gap) can't sit flush, so the server fails it (server/solver.py check_backing)."""
-    if sampling := geometry_admission_problems(scene, result, rules):
+    meter = meter if meter is not None else WorkMeter()
+    if sampling := geometry_admission_problems(scene, result, rules, meter=meter):
         return sampling
     result = deduplicate_result_runs(result)
-    pieces = straight_pieces(scene, rules)
+    pieces = straight_pieces(scene, rules, meter=meter)
     if not pieces:
         return []
 
     def off_wall(lo: float, hi: float, outcome: str, wall_id: str) -> str | None:
+        meter.charge()
         # The stretch it starts on, or else ends on: the one it would back onto. A start on a
         # boundary belongs to the stretch it runs onto, an end to the one it runs off.
-        piece = next((p for p in pieces if p[0] - EPS <= lo < p[1] - EPS), None) or next(
-            (p for p in pieces if p[0] + EPS < hi <= p[1] + EPS), None
-        )
+        piece = None
+        for candidate in pieces:
+            meter.charge()
+            if candidate[0] - EPS <= lo < candidate[1] - EPS:
+                piece = candidate
+                break
+        if piece is None:
+            for candidate in pieces:
+                meter.charge()
+                if candidate[0] + EPS < hi <= candidate[1] + EPS:
+                    piece = candidate
+                    break
         if piece is None:
             return "is not on any scanned wall"
         if lo < piece[0] - COLLINEAR_FT or hi > piece[1] + COLLINEAR_FT:
@@ -451,8 +577,9 @@ def off_wall(lo: float, hi: float, outcome: str, wall_id: str) -> str | None:
             return None
         # A pass also keeps its position error clear of the stretch's ends: within it the
         # battery may not sit flush, and the server leaves it unsure (check_backing).
-        e = battery_error(scene, rules, wall_id, lo, hi)
+        e = battery_error(scene, rules, wall_id, lo, hi, meter=meter)
         for end, clear in ((piece[0], lo - e - piece[0]), (piece[1], piece[1] - hi - e)):
+            meter.charge()
             if clear < -COLLINEAR_FT:
                 return f"ends within its error ({e:.2f} ft) of its straight wall's end at {end:.2f}"
         return None
@@ -467,6 +594,7 @@ def off_wall(lo: float, hi: float, outcome: str, wall_id: str) -> str | None:
         if run["outcome"] not in ("pass", "unsure"):
             continue
         for start in run_starts(run["start_ft"], rules.step_ft):
+            meter.charge()
             battery = (start, start + rules.width_ft)
             if (why := off_wall(*battery, run["outcome"], run["wall_id"])) is not None:
                 problems.append(f"sweep {run['outcome']} start {start:.2f} {why}")
@@ -474,11 +602,14 @@ def off_wall(lo: float, hi: float, outcome: str, wall_id: str) -> str | None:
     return problems
 
 
-def spot_position_problems(scene: dict, result: dict, rules: RuleSet) -> list[str]:
+def spot_position_problems(
+    scene: dict, result: dict, rules: RuleSet, meter: WorkMeter | None = None
+) -> list[str]:
     """Where the app places the battery must be where the result says it stands: spot.center is
     its footprint's centre, and that is the middle of span_ft on the wall, half the battery's
     depth out. meter_offset_ft is checked against center elsewhere, so a centre moved together
     with its offset is caught here."""
+    meter = meter if meter is not None else WorkMeter()
     spot = result.get("spot")
     if spot is None:
         return []
@@ -494,7 +625,7 @@ def spot_position_problems(scene: dict, result: dict, rules: RuleSet) -> list[st
                 f"[{fx:.2f}, {fz:.2f}]"
             )
     lo, hi = spot["span_ft"]
-    plan = GroundPlan(scene, rules)
+    plan = GroundPlan(scene, rules, meter=meter)
     want = plan.point((lo + hi) / 2, (lo + hi) / 2, rules.depth_ft / 2)
     if want is not None and math.dist((cx, cz), want) > COLLINEAR_FT:
         problems.append(
@@ -504,7 +635,7 @@ def spot_position_problems(scene: dict, result: dict, rules: RuleSet) -> list[st
     return problems
 
 
-def spot_sweep_problems(result: dict) -> list[str]:
+def spot_sweep_problems(result: dict, meter: WorkMeter | None = None) -> list[str]:
     """The chosen spot is one of the evaluated starts, so the sweep must give its start the
     spot's own outcome, and a passing spot must lie in a passing run. A result could otherwise
     report a pass at a start its own sweep says fails, with stats that agree with the sweep."""
@@ -512,7 +643,7 @@ def spot_sweep_problems(result: dict) -> list[str]:
     if spot is None:
         return []
     start = spot["span_ft"][0]
-    got = outcome_at(result, spot["wall_id"], start)
+    got = outcome_at(result, spot["wall_id"], start, meter=meter)
     if got == spot["outcome"]:
         return []
     verb = {"pass": "passes", "fail": "fails"}.get(spot["outcome"], "is unsure")
@@ -532,23 +663,31 @@ def required_span(lo: float, hi: float, radius: float) -> tuple[float, float]:
     return lo - radius, hi + radius
 
 
-def battery_error(scene: dict, rules: RuleSet, wall_id: str, lo: float, hi: float) -> float:
+def battery_error(
+    scene: dict, rules: RuleSet, wall_id: str, lo: float, hi: float, meter: WorkMeter | None = None
+) -> float:
     """Position error of a battery over [lo, hi] on `wall_id`, as server 3baa338 takes it for
     its checks (solver.py _errors): its wall's error at its far edge from the meter, plus the
     larger of the meter's error in plan and the battery's slide along the walls (slide)."""
+    meter = meter if meter is not None else WorkMeter()
     wall = next((w for w in scene["walls"] if w["id"] == wall_id), None)
     if wall is None:
         raise ValueError(f"the result names wall {wall_id!r}, which the scene does not have")
     return wall_error_at(wall, rules, max(abs(lo), abs(hi))) + max(
-        meter_error(scene, rules), slide(scene, rules, lo, hi)
+        meter_error(scene, rules), slide(scene, rules, lo, hi, meter=meter)
     )
 
 
-def along_error(scene: dict, rules: RuleSet, wall_id: str, lo: float, hi: float) -> float:
+def along_error(
+    scene: dict, rules: RuleSet, wall_id: str, lo: float, hi: float, meter: WorkMeter | None = None
+) -> float:
     """The battery's error against spans measured along the walls: its wall's at its far edge
     plus its slide, without the meter's plan error (server 3baa338 _errors, along_err)."""
+    meter = meter if meter is not None else WorkMeter()
     wall = next(w for w in scene["walls"] if w["id"] == wall_id)
-    return wall_error_at(wall, rules, max(abs(lo), abs(hi))) + slide(scene, rules, lo, hi)
+    return wall_error_at(wall, rules, max(abs(lo), abs(hi))) + slide(
+        scene, rules, lo, hi, meter=meter
+    )
 
 
 def wall_error_at(wall: dict, rules: RuleSet, s: float) -> float:
@@ -564,13 +703,16 @@ def meter_error(scene: dict, rules: RuleSet) -> float:
     return scene.get("meter", {}).get("plus_minus_ft", rules.errors["meter"])
 
 
-def slide(scene: dict, rules: RuleSet, lo: float, hi: float) -> float:
+def slide(
+    scene: dict, rules: RuleSet, lo: float, hi: float, meter: WorkMeter | None = None
+) -> float:
     """How far a battery over [lo, hi] can move along the walls against spans measured in s when
     the meter or a corner between them moves within its error (server 3baa338 _slide): the
     meter's error times the difference between its wall's direction and the battery's, plus each
     other wall between the meter and the battery's near edge, at its far end, times the same
     difference for that wall. 0 on the meter's own wall."""
-    segments = segments_s(scene, rules)
+    meter = meter if meter is not None else WorkMeter()
+    segments = segments_s(scene, rules, meter=meter)
     if not segments:
         return 0.0
     walls = {w["id"]: w for w in scene["walls"]}
@@ -581,7 +723,11 @@ def along(seg) -> Point:
         return ((q[0] - p[0]) / n, (q[1] - p[1]) / n)
 
     def under(s: float):
-        return min(segments, key=lambda g: max(g[1] - s, s - g[2], 0.0))
+        def distance(g):
+            meter.charge()
+            return max(g[1] - s, s - g[2], 0.0)
+
+        return min(segments, key=distance)
 
     battery = along(under((lo + hi) / 2))
 
@@ -590,6 +736,7 @@ def turn(seg) -> float:
         return math.hypot(battery[0] - a[0], battery[1] - a[1])
 
     meter_wall = scene["meter"]["wall_id"]
+    meter.charge(len(segments))
     meter_seg = min(
         (g for g in segments if g[0] == meter_wall), key=lambda g: max(g[1], -g[2], 0.0)
     )
@@ -597,6 +744,7 @@ def turn(seg) -> float:
     a0, b0 = min(0.0, near), max(0.0, near)
     total = meter_error(scene, rules) * turn(meter_seg)
     for seg in segments:
+        meter.charge()
         a, b = max(seg[1], a0), min(seg[2], b0)
         if b - a <= EPS:
             continue
@@ -610,7 +758,13 @@ def wall_error(wall: dict, rules: RuleSet) -> float:
 
 
 def reach_gaps(
-    scene: dict, rules: RuleSet, check: str, wall_id: str, lo: float, hi: float
+    scene: dict,
+    rules: RuleSet,
+    check: str,
+    wall_id: str,
+    lo: float,
+    hi: float,
+    meter: WorkMeter | None = None,
 ) -> list[tuple[str, str]]:
     """(band, what is missing) for each Need of `check` a battery over [lo, hi] does not have.
 
@@ -627,38 +781,57 @@ def reach_gaps(
     - facing and overhead bands: over [lo - e, hi + e], every place the battery may sit, beyond
       the check's distance unless measured.
     """
+    meter = meter if meter is not None else WorkMeter()
+    key = ("reach_gaps", meter.input_key(scene), meter.input_key(rules), check, wall_id, lo, hi)
+    if key in meter.cache:
+        return meter.cache[key]
     gaps = []
     for need in rules.needs[check]:
+        meter.charge()
         if not need.widen:
             error = 0.0
         elif need.along:
-            error = along_error(scene, rules, wall_id, lo, hi)
+            error = along_error(scene, rules, wall_id, lo, hi, meter=meter)
         else:
-            error = battery_error(scene, rules, wall_id, lo, hi)
+            error = battery_error(scene, rules, wall_id, lo, hi, meter=meter)
         reach = need.radius + error
         if need.band == "ground":
-            plan = GroundPlan(scene, rules) if rules.wall_join_ft is not None else None
-            gap = ground_gap(scene, lo, hi, rules.depth_ft, reach, plan)
+            plan = GroundPlan(scene, rules, meter=meter) if rules.wall_join_ft is not None else None
+            gap = ground_gap(scene, lo, hi, rules.depth_ft, reach, plan, meter=meter)
         elif need.band == "wall":
             a, b = required_span(lo, hi, reach)
             wall = observed(
-                scene, "wall", need.height, beyond=True, wall_default_ft=rules.headroom_ft
+                scene,
+                "wall",
+                need.height,
+                beyond=True,
+                wall_default_ft=rules.headroom_ft,
+                meter=meter,
             )
-            seen = not gaps_over(wall, a, b)
+            seen = not gaps_over(wall, a, b, meter=meter)
             gap = None if seen else f"wall [{a:.2f}, {b:.2f}] observed higher than {need.height} ft"
         else:
             a, b = required_span(lo, hi, reach)
-            gap = measured_band_gap(scene, need.band, wall_id, a, b, need.height)
+            gap = measured_band_gap(scene, need.band, wall_id, a, b, need.height, meter=meter)
         if gap:
             gaps.append((need.band, gap))
+    meter.cache[key] = gaps
     return gaps
 
 
 def measured_band_gap(
-    scene: dict, band: str, wall_id: str, lo: float, hi: float, need: float
+    scene: dict,
+    band: str,
+    wall_id: str,
+    lo: float,
+    hi: float,
+    need: float,
+    meter: WorkMeter | None = None,
 ) -> str | None:
     """The first stretch of [lo, hi] the facing or overhead band leaves unsettled: not observed,
     or observed short of `need` where no measurement covers it."""
+    meter = meter if meter is not None else WorkMeter()
+    meter.charge(len(scene.get("coverage", {}).get("observed", [])))
     entries = [
         (*sorted(e["span_ft"]), reached(e))
         for e in scene.get("coverage", {}).get("observed", [])
@@ -672,15 +845,22 @@ def measured_band_gap(
     edges = {x for e in entries for x in e[:2]} | {x for m in measured for x in m}
     cuts = sorted({lo, hi} | {x for x in edges if lo < x < hi})
     for p, q in itertools.pairwise(cuts):
+        meter.charge()
         if q - p <= EPS:
             continue
+        meter.charge(len(entries))
         seen = [out for x, y, out in entries if x <= p + EPS and q - EPS <= y]
         where = f"{band} [{p:.2f}, {q:.2f}] observed"
         if not seen:
             if q - p < COVERAGE_TOLERANCE_FT:
                 continue
             return f"{where}, none seen"
-        settled = any(x <= p + EPS and q - EPS <= y for x, y in measured)
+        settled = False
+        for x, y in measured:
+            meter.charge()
+            if x <= p + EPS and q - EPS <= y:
+                settled = True
+                break
         # Strictly beyond, as the server requires (server/solver.py at 6c7ca23).
         if not settled and max(seen) <= need:
             return f"{where} out to {need:.2f} ft or measured, seen {max(seen):.2f} ft"
@@ -693,13 +873,13 @@ def run_start_count(span: list[float], step_ft: float | None) -> int:
     A sample, not the server's own list: the server also evaluates boundaries and midpoints
     that a run reports only as its two ends. Oversized runs fail rather than lose coverage
     through truncation."""
-    if step_ft is None or not math.isfinite(step_ft) or step_ft <= 0:
+    if step_ft is None or not finite(step_ft) or step_ft <= 0:
         raise ValueError("checking a sweep run needs finite positive rules' sweep.step_ft")
     a, b = span
-    if not math.isfinite(a) or not math.isfinite(b) or a > b:
+    if not finite(a) or not finite(b) or a > b:
         raise ValueError("sweep start_ft must be finite and ordered")
     steps = (b - a) / step_ft
-    if not math.isfinite(steps) or steps > MAX_SWEEP_SAMPLES:
+    if not finite(steps) or steps > MAX_SWEEP_SAMPLES:
         raise ValueError(f"sweep sampling exceeds the {MAX_SWEEP_SAMPLES} sample limit")
     # Every step strictly before the last start, the first included however short the run.
     count = max(int(a < b), math.ceil(steps - EPS))
@@ -726,16 +906,6 @@ def reported_dimension_problems(result: dict, rules: RuleSet | None) -> list[str
     """Reject inconsistent C2 geometry before its dimensions can override public rules."""
     problems = []
 
-    def finite(value: Any) -> bool:
-        try:
-            return (
-                isinstance(value, (int, float))
-                and not isinstance(value, bool)
-                and math.isfinite(value)
-            )
-        except OverflowError:
-            return False
-
     spots = [(name, result.get(name)) for name in ("spot", "nearest_considered")]
     for name, spot in spots:
         if spot is None:
@@ -784,6 +954,11 @@ def finite(value: Any) -> bool:
             message = f"{source} must be finite and positive"
             if message not in problems:
                 problems.append(message)
+    for check in result.get("checks", []):
+        if check.get("rule", {}).get("key") == "route.corner_allowance_ft":
+            allowance = check.get("threshold_ft")
+            if allowance is not None and (not finite(allowance) or allowance < 0):
+                problems.append("reported corner allowance must be finite and nonnegative")
     valid_widths = [(source, width) for source, width in widths if finite(width) and width > 0]
     if valid_widths and any(
         abs(width - valid_widths[0][1]) > NUMBER_TOL_FT for _, width in valid_widths
@@ -801,46 +976,56 @@ def finite(value: Any) -> bool:
     return problems
 
 
-def geometry_admission_problems(scene: dict, result: dict, rules: RuleSet | None) -> list[str]:
-    """Bound all sampling before any footprint, coverage or height check runs.
-
-    Count sweep starts and a conservative upper bound for ground grid point visits,
-    including split-band edges. Bounds use whole runs, never enumerate their starts.
-    """
-    if problems := reported_dimension_problems(result, rules):
-        return problems
-    # Use validated reported dimensions only to estimate work, before the caller adopts them.
-    widths = [
-        c["threshold_ft"]
-        for c in result.get("checks", [])
-        if c.get("rule", {}).get("key") == "battery.width_ft" and c.get("threshold_ft") is not None
-    ]
-    widths += [
-        s["width_ft"]
-        for key in ("spot", "nearest_considered")
-        if (s := result.get(key)) is not None and "width_ft" in s
-    ]
-    depths = [
-        s["depth_ft"]
-        for key in ("spot", "nearest_considered")
-        if (s := result.get(key)) is not None and "depth_ft" in s
-    ]
-    if rules is not None:
-        rules = replace(
-            rules,
-            width_ft=max(widths, default=rules.width_ft),
-            depth_ft=max([rules.depth_ft, *depths]),
-        )
-    problems = []
-    bodies = []
-    ends = chain_ends_s(scene, rules) if rules is not None else None
+def geometry_admission_problems(
+    scene: dict, result: dict, rules: RuleSet | None, meter: WorkMeter | None = None
+) -> list[str]:
+    """Validate response numbers and references before geometry. Work is counted as it runs."""
+    meter = meter if meter is not None else WorkMeter()
+    problems = reported_dimension_problems(result, rules)
+
+    def numbers(value: Any, path: str) -> None:
+        if isinstance(value, dict):
+            for key, item in value.items():
+                numbers(item, f"{path}.{key}" if path else key)
+        elif isinstance(value, (tuple, list)):
+            for i, item in enumerate(value):
+                numbers(item, f"{path}[{i}]")
+        elif isinstance(value, (int, float)) and not isinstance(value, bool) and not finite(value):
+            problems.append(f"{path} must be finite")
+
+    numbers(result, "result")
+    numbers(scene, "scene")
+    wall_ids = {wall["id"] for wall in scene.get("walls", [])}
+    bodies = [(name, result.get(name)) for name in ("spot", "nearest_considered")]
+    bodies += [(f"sweep[{i}]", run) for i, run in enumerate(result.get("sweep", []))]
+    for name, body in bodies:
+        if body is not None and body.get("wall_id") not in wall_ids:
+            problems.append(f"{name} names unknown wall_id {body.get('wall_id')!r}")
+    for run in result.get("sweep", []):
+        a, b = run["start_ft"]
+        if not finite(a) or not finite(b) or a > b:
+            problems.append(
+                f"sweep {run['outcome']} starts {run['start_ft']}: "
+                "start_ft must be finite and ordered"
+            )
+        elif not finite(b - a):
+            problems.append(f"sweep {run['outcome']} start_ft span length must be finite")
+    if problems:
+        return list(dict.fromkeys(problems))
+    ends = (
+        chain_ends_s(scene, rules, meter=meter)
+        if rules is not None and rules.wall_join_ft is not None
+        else None
+    )
     for name in ("spot", "nearest_considered"):
         if (spot := result.get(name)) is not None:
-            bodies.append((name, spot["span_ft"], spot["wall_id"], 1, True))
+            lo, hi = spot["span_ft"]
+            if ends is not None and (lo < ends[0] - COLLINEAR_FT or hi > ends[1] + COLLINEAR_FT):
+                problems.append(f"{name}: span_ft exceeds scanned range [{ends[0]}, {ends[1]}]")
     for run in deduplicate_result_runs(result)["sweep"]:
         a, b = run["start_ft"]
         prefix = f"sweep {run['outcome']} starts {run['start_ft']}: "
-        if not math.isfinite(a) or not math.isfinite(b) or a > b:
+        if a > b:
             problems.append(prefix + "start_ft must be finite and ordered")
             continue
         if run["outcome"] in ("pass", "unsure") and rules is not None:
@@ -850,95 +1035,9 @@ def geometry_admission_problems(scene: dict, result: dict, rules: RuleSet | None
                 )
                 continue
             try:
-                count = run_start_count(run["start_ft"], rules.step_ft)
+                run_start_count(run["start_ft"], rules.step_ft)
             except ValueError as exc:
                 problems.append(prefix + str(exc))
-                continue
-            bodies.append(
-                (prefix, [a, b + rules.width_ft], run["wall_id"], count, run["outcome"] == "pass")
-            )
-    for name, span, _, _, _ in bodies:
-        if any(not math.isfinite(v) for v in span) or span[0] > span[1]:
-            problems.append(f"{name}: span_ft must be finite and ordered")
-    if problems or rules is None:
-        return problems
-    total = 0
-
-    def grid_count(length: float) -> int:
-        cells = length / GroundPlan.STEP_FT
-        if not math.isfinite(cells) or cells > MAX_GEOMETRY_SAMPLES:
-            return MAX_GEOMETRY_SAMPLES + 1
-        return 2 * max(1, math.ceil(max(0, cells))) + 1
-
-    for name, (lo, hi), wid, count, ground in bodies:
-        # Sweep ends name starts; footprints may extend beyond the chain and are checked below.
-        start_hi = hi - rules.width_ft if name.startswith("sweep") else hi
-        if ends is not None and (lo < ends[0] - COLLINEAR_FT or start_hi > ends[1] + COLLINEAR_FT):
-            label = "start_ft span" if name.startswith("sweep") else "span_ft"
-            problems.append(
-                f"{name}{'' if name.endswith(': ') else ': '}"
-                f"{label} exceeds scanned range [{ends[0]}, {ends[1]}]"
-            )
-            continue
-        total += count * (2 + (len(rules.needs) if ground else 0))
-        if ground and rules.wall_join_ft is not None:
-            segments = segments_s(scene, rules) or []
-            # Error changes at wall boundaries. Evaluate both sides and endpoints, not the grid.
-            width = rules.width_ft if name.startswith("sweep") else hi - lo
-            starts = {lo, max(lo, hi - width)}
-            boundaries = {edge for _, a, b, _, _ in segments for edge in (a, b)}
-            boundaries.update(
-                (left[2] + right[1]) / 2 for left, right in itertools.pairwise(segments)
-            )
-            for edge_at in boundaries:
-                for edge in (edge_at, edge_at - width, edge_at - width / 2):
-                    for offset in (-EPS, EPS):
-                        if lo <= edge + offset <= hi - width:
-                            starts.add(edge + offset)
-            for check, needs in rules.needs.items():
-                for need in needs:
-                    if need.band != "ground":
-                        continue
-                    error = (
-                        0.0
-                        if not need.widen
-                        else max(
-                            (along_error if need.along else battery_error)(
-                                scene, rules, wid, x, x + width
-                            )
-                            for x in starts
-                        )
-                    )
-                    radius = need.radius + error
-                    splits = 4 + 2 * sum(
-                        e["band"] == "ground" for e in scene.get("coverage", {}).get("observed", [])
-                    )
-                    along = grid_count(width + 2 * radius) + 3 * splits
-                    out = grid_count(rules.depth_ft + radius)
-                    # Spot coverage and missing-evidence checks can both visit the grid.
-                    repeats = (
-                        1
-                        if name.startswith("sweep")
-                        else 1
-                        + sum(
-                            c["id"] == check and c["outcome"] == "pass"
-                            for c in result.get("checks", [])
-                        )
-                    )
-                    total += count * along * out * repeats
-        if total > MAX_GEOMETRY_SAMPLES:
-            problems.append(
-                f"response geometry sample budget exceeds {MAX_GEOMETRY_SAMPLES} samples"
-            )
-            break
-    # A check-only reported width is still untrusted geometry, even without a chosen spot/run.
-    for width in [*widths, *depths]:
-        if not math.isfinite(width) or width <= 0:
-            problems.append("reported battery width must be finite and positive")
-            break
-        total += grid_count(width)
-    if total > MAX_GEOMETRY_SAMPLES and not any("sample budget" in p for p in problems):
-        problems.append(f"response geometry sample budget exceeds {MAX_GEOMETRY_SAMPLES} samples")
     return problems
 
 
@@ -967,18 +1066,26 @@ def dropped_check_problems(scene: dict, result: dict, rules: RuleSet) -> list[st
     ]
 
 
-def coverage_problems(scene: dict, result: dict, rules: RuleSet) -> list[str]:
+def coverage_problems(
+    scene: dict, result: dict, rules: RuleSet, meter: WorkMeter | None = None
+) -> list[str]:
     """Missing coverage is never a pass (C5), to the reach each check's rule looks out to (see
     reach_gaps). A sweep run that passes needs, at each start sampled from it (run_starts), every
     check's area around that start's battery with that battery's own position error, and the
     wall and cable route back to the meter over the whole run. Checking the whole run as one
     battery at its farthest start's error would ask for more than any single start needs."""
-    if sampling := geometry_admission_problems(scene, result, rules):
+    meter = meter if meter is not None else WorkMeter()
+    if sampling := geometry_admission_problems(scene, result, rules, meter=meter):
         return sampling
     result = deduplicate_result_runs(result)
     problems: list[str] = []
     route_wall = observed(
-        scene, "wall", rules.route_height_ft, beyond=True, wall_default_ft=rules.headroom_ft
+        scene,
+        "wall",
+        rules.route_height_ft,
+        beyond=True,
+        wall_default_ft=rules.headroom_ft,
+        meter=meter,
     )
     # Coverage is needed for every check the rules define for this scene, whether or not the
     # result lists it: a result that drops a check must not skip its coverage.
@@ -993,10 +1100,10 @@ def coverage_problems(scene: dict, result: dict, rules: RuleSet) -> list[str]:
         # The route starts at the meter, which may stand its error either side of s = 0
         # (server README, route_path), within the scanned chain.
         m = meter_error(scene, rules)
-        ends = chain_ends_s(scene, rules) or (-math.inf, math.inf)
+        ends = chain_ends_s(scene, rules, meter=meter) or (-math.inf, math.inf)
         route_lo = max(min(lo, -m), ends[0])
         route_hi = min(max(hi, m), ends[1])
-        if gaps_over(route_wall, route_lo, route_hi):
+        if gaps_over(route_wall, route_lo, route_hi, meter=meter):
             problems.append(
                 f"sweep pass for starts {run['start_ft']} but the wall and cable route "
                 f"[{route_lo:.2f}, {route_hi:.2f}] were not all observed higher than "
@@ -1005,8 +1112,11 @@ def coverage_problems(scene: dict, result: dict, rules: RuleSet) -> list[str]:
         for check in sorted(set(rules.needs) & evaluated):
             gaps = {}  # each gap once, at the first start that needs it
             for start in run_starts(run["start_ft"], rules.step_ft):
+                meter.charge()
                 battery = (start, start + rules.width_ft)
-                for _, gap in reach_gaps(scene, rules, check, run["wall_id"], *battery):
+                for _, gap in reach_gaps(
+                    scene, rules, check, run["wall_id"], *battery, meter=meter
+                ):
                     gaps.setdefault(gap, start)
             problems += [
                 f"sweep pass for starts {run['start_ft']} but at start {start:.2f} {check} "
@@ -1017,11 +1127,10 @@ def coverage_problems(scene: dict, result: dict, rules: RuleSet) -> list[str]:
     spot = result.get("spot")
     if spot is not None:
         lo, hi = spot["span_ft"]
-        for check in result.get("checks", []):
-            if check["outcome"] != "pass" or check["id"] not in rules.needs:
-                continue
-            for _, gap in reach_gaps(scene, rules, check["id"], spot["wall_id"], lo, hi):
-                problems.append(f"check {check['id']} passes but needs {gap}")
+        passing = {check["id"] for check in result.get("checks", []) if check["outcome"] == "pass"}
+        for check_id in sorted(passing & set(rules.needs)):
+            for _, gap in reach_gaps(scene, rules, check_id, spot["wall_id"], lo, hi, meter=meter):
+                problems.append(f"check {check_id} passes but needs {gap}")
 
     for request in result.get("missing_evidence", []):
         if request["kind"] != "band" or "span_ft" not in request or "band" not in request:
@@ -1033,8 +1142,8 @@ def coverage_problems(scene: dict, result: dict, rules: RuleSet) -> list[str]:
         # only where the band was seen all the way (no `out_ft`).
         default = GROUND_FAR_FT if request["band"] == "ground" else math.inf
         far = request.get("out_ft", default)
-        seen = observed(scene, request["band"], far, wall_default_ft=rules.headroom_ft)
-        if b - a > EPS and covers(seen, a, b):
+        seen = observed(scene, request["band"], far, wall_default_ft=rules.headroom_ft, meter=meter)
+        if b - a > EPS and covers(seen, a, b, meter=meter):
             problems.append(
                 f"missing_evidence asks for {request['band']} {request['span_ft']}, "
                 "which the scene lists as observed"
@@ -1049,10 +1158,13 @@ def ground_gap(
     depth: float,
     radius: float,
     plan: GroundPlan | None = None,
+    meter: WorkMeter | None = None,
 ) -> str | None:
     """The first stretch of ground seen less far out than a battery over [lo, hi] needs (see
     coverage_problems), or None. With `plan`, ground not seen in the battery's own wall's band
     still counts where it lies in another wall's observed band in plan (GroundPlan)."""
+    meter = meter if meter is not None else WorkMeter()
+    meter.charge(len(scene.get("coverage", {}).get("observed", [])))
     entries = [
         (*sorted(e["span_ft"]), e.get("out_ft", 0.0))
         for e in scene.get("coverage", {}).get("observed", [])
@@ -1061,6 +1173,7 @@ def ground_gap(
     a, b = lo - radius, hi + radius
     cuts = sorted({a, lo, hi, b} | {x for e in entries for x in e[:2] if a < x < b})
     for p, q in itertools.pairwise(cuts):
+        meter.charge()
         if q - p <= EPS:
             continue
 
@@ -1071,6 +1184,7 @@ def need_at(s: float) -> float:
             return depth + math.sqrt(max(0.0, radius**2 - d**2))
 
         need = need_at(q if q <= lo else p if p >= hi else (lo + hi) / 2)
+        meter.charge(len(entries))
         seen = max((out for x, y, out in entries if x <= p + EPS and q - EPS <= y), default=None)
         if seen is None or seen + SEEN_GROWTH_FT < need:
             if plan is not None and plan.covers((lo + hi) / 2, p, q, seen or 0.0, need_at):
@@ -1082,7 +1196,9 @@ def need_at(s: float) -> float:
     return None
 
 
-def missing_evidence_problems(scene: dict, result: dict, rules: RuleSet | None = None) -> list[str]:
+def missing_evidence_problems(
+    scene: dict, result: dict, rules: RuleSet | None = None, meter: WorkMeter | None = None
+) -> list[str]:
     """When coverage is what stands in the way (reason unobserved_area), every check left unsure
     for an unobserved area is named by a request, and a clearance check by a request of each
     band it lacks around the chosen spot: a check that forgets one band leaves the next capture
@@ -1094,12 +1210,13 @@ def missing_evidence_problems(scene: dict, result: dict, rules: RuleSet | None =
     the reason and its requests; leaving both out would never ask the homeowner for the view
     that settles the check. Without a spot and without the reason, every position fails anyway,
     no photo would change the answer, and C2 lets missing_evidence stay empty."""
-    if sampling := geometry_admission_problems(scene, result, rules):
+    meter = meter if meter is not None else WorkMeter()
+    if sampling := geometry_admission_problems(scene, result, rules, meter=meter):
         return sampling
     result = deduplicate_result_runs(result)
     codes = {r["code"] for r in result.get("reasons", [])}
     spot = result.get("spot")
-    unseen = unobserved_checks(result)
+    unseen = list(dict.fromkeys(unobserved_checks(result)))
     requests = result.get("missing_evidence", [])
     if "unobserved_area" not in codes:
         if spot is None or not unseen:
@@ -1112,13 +1229,13 @@ def missing_evidence_problems(scene: dict, result: dict, rules: RuleSet | None =
                 "but no reason unobserved_area and no missing_evidence"
             ]
         lo, hi = spot["span_ft"]
-        asked = with_past_ends_asked(scene, requests, rules)
+        asked = with_past_ends_asked(scene, requests, rules, meter=meter)
         return [
             f"check {c} is unsure and needs {gap}, not past an end the result asks to walk "
             f"past, but there is no reason unobserved_area and no {band} request"
             for c in unseen
             if c in rules.needs
-            for band, gap in reach_gaps(asked, rules, c, spot["wall_id"], lo, hi)
+            for band, gap in reach_gaps(asked, rules, c, spot["wall_id"], lo, hi, meter=meter)
         ]
     if not requests:
         return ["reason unobserved_area but missing_evidence is empty"]
@@ -1132,11 +1249,11 @@ def missing_evidence_problems(scene: dict, result: dict, rules: RuleSet | None =
     if rules is None or spot is None:
         return problems
     lo, hi = spot["span_ft"]
-    asked = with_past_ends_asked(scene, requests, rules)
-    for c in unobserved_checks(result):
+    asked = with_past_ends_asked(scene, requests, rules, meter=meter)
+    for c in unseen:
         if c not in rules.needs:
             continue
-        for band, gap in reach_gaps(asked, rules, c, spot["wall_id"], lo, hi):
+        for band, gap in reach_gaps(asked, rules, c, spot["wall_id"], lo, hi, meter=meter):
             if (band, c) not in named:
                 problems.append(
                     f"check {c} is unsure and needs {gap}, but no {band} request names it"
@@ -1151,7 +1268,9 @@ def missing_evidence_problems(scene: dict, result: dict, rules: RuleSet | None =
 Point = tuple[float, float]
 
 
-def segments_s(scene: dict, rules: RuleSet) -> list[tuple[str, float, float, Point, Point]] | None:
+def segments_s(
+    scene: dict, rules: RuleSet, meter: WorkMeter | None = None
+) -> list[tuple[str, float, float, Point, Point]] | None:
     """Each straight baseline segment as (wall id, s at its start, s at its end, start point,
     end point), with s measured from the meter's projection, or None without a meter wall.
 
@@ -1159,6 +1278,7 @@ def segments_s(scene: dict, rules: RuleSet) -> list[tuple[str, float, float, Poi
     when it is a gap: wider than both walls' own errors together (no drift), capped at
     sweep.wall_join_ft. Narrower, the walls meet and s skips the space (server/scene.py at
     7133283, `meets`)."""
+    meter = meter if meter is not None else WorkMeter()
     if rules.wall_join_ft is None:
         raise ValueError("laying out the walls needs the rules' sweep.wall_join_ft")
     walls = scene.get("walls", [])
@@ -1169,12 +1289,14 @@ def segments_s(scene: dict, rules: RuleSet) -> list[tuple[str, float, float, Poi
     mx, _, mz = scene["meter"]["pos"]
     s, prev = 0.0, None
     for wall in walls:
+        meter.charge(len(wall["baseline"]))
         pts = [(float(pt[0]), float(pt[1])) for pt in wall["baseline"]]
         if prev is not None:
             space = math.dist(prev[0], pts[0])
             meets = min(rules.wall_join_ft, max(prev[1] + wall_error(wall, rules), SERVER_EPS))
             s += space if space > meets else 0.0
         for p, q in itertools.pairwise(pts):
+            meter.charge()
             seg = math.dist(p, q)
             if wall["id"] == scene["meter"]["wall_id"] and seg > 0:
                 t = ((mx - p[0]) * (q[0] - p[0]) + (mz - p[1]) * (q[1] - p[1])) / seg**2
@@ -1190,13 +1312,17 @@ def segments_s(scene: dict, rules: RuleSet) -> list[tuple[str, float, float, Poi
     return [(wid, a - meter_s[1], b - meter_s[1], p, q) for wid, a, b, p, q in raw]
 
 
-def wall_spans_s(scene: dict, rules: RuleSet) -> dict[str, tuple[float, float]] | None:
+def wall_spans_s(
+    scene: dict, rules: RuleSet, meter: WorkMeter | None = None
+) -> dict[str, tuple[float, float]] | None:
     """Each wall's stretch of s (see segments_s), or None without a meter wall."""
-    segments = segments_s(scene, rules)
+    meter = meter if meter is not None else WorkMeter()
+    segments = segments_s(scene, rules, meter=meter)
     if segments is None:
         return None
     spans: dict[str, tuple[float, float]] = {}
     for wid, a, b, _, _ in segments:
+        meter.charge()
         lo, hi = spans.get(wid, (a, b))
         spans[wid] = (min(lo, a), max(hi, b))
     return spans
@@ -1212,14 +1338,17 @@ class GroundPlan:
     # point of a region was seen: a thin gap shaped to avoid them can still be missed.
     STEP_FT = 0.05
 
-    def __init__(self, scene: dict, rules: RuleSet) -> None:
-        self.segments = segments_s(scene, rules) or []
+    def __init__(self, scene: dict, rules: RuleSet, meter: WorkMeter | None = None) -> None:
+        self.meter = meter if meter is not None else WorkMeter()
+        self.segments = segments_s(scene, rules, meter=self.meter) or []
         self.strips = []  # (origin, along, outward, from s, to s, out)
         for e in scene.get("coverage", {}).get("observed", []):
+            self.meter.charge()
             if e["band"] != "ground":
                 continue
             a, b = sorted(e["span_ft"])
             for _, s0, s1, p, q in self.segments:
+                self.meter.charge()
                 if min(b, s1) - max(a, s0) > EPS and s1 - s0 > EPS:
                     along, outward = self._frame(p, q)
                     strip = (p, along, outward, max(a, s0) - s0, min(b, s1) - s0)
@@ -1233,7 +1362,12 @@ def _frame(p: Point, q: Point) -> tuple[Point, Point]:
 
     def point(self, s_mid: float, s: float, out: float) -> Point | None:
         """The plan point at s along the line of the segment under s_mid, `out` in front."""
-        seg = next((g for g in self.segments if g[1] - EPS <= s_mid <= g[2] + EPS), None)
+        seg = None
+        for candidate in self.segments:
+            self.meter.charge()
+            if candidate[1] - EPS <= s_mid <= candidate[2] + EPS:
+                seg = candidate
+                break
         if seg is None:
             return None
         _, s0, _, p, q = seg
@@ -1243,6 +1377,7 @@ def point(self, s_mid: float, s: float, out: float) -> Point | None:
 
     def seen(self, x: Point) -> bool:
         for origin, along, outward, t0, t1, out in self.strips:
+            self.meter.charge()
             dx, dz = x[0] - origin[0], x[1] - origin[1]
             t = dx * along[0] + dz * along[1]
             n = dx * outward[0] + dz * outward[1]
@@ -1256,6 +1391,7 @@ def required(self, x: Point) -> bool:
         front of some wall segment, or past either end of the chain. Past a corner, behind the
         next wall, is neither: the house."""
         for i, (_, _, _, p, q) in enumerate(self.segments):
+            self.meter.charge()
             along, outward = self._frame(p, q)
             dx, dz = x[0] - p[0], x[1] - p[1]
             t = dx * along[0] + dz * along[1]
@@ -1280,8 +1416,10 @@ def covers(
         if not self.strips:
             return False
         for s in self._samples(p, q):
+            self.meter.charge()
             # Up to out_lo the stretch's own band already saw the ground.
             for out in self._samples(out_lo, need(s)):
+                self.meter.charge()
                 if out <= out_lo + SERVER_EPS:
                     continue
                 x = self.point(s_mid, s, out)
@@ -1291,52 +1429,56 @@ def covers(
 
     @classmethod
     def _samples(cls, a: float, b: float) -> Iterator[float]:
+        if not finite(a) or not finite(b):
+            raise ValueError("ground sampling bounds must be finite")
         cells = (b - a) / cls.STEP_FT
-        if not math.isfinite(cells) or cells > MAX_GEOMETRY_SAMPLES:
-            raise ValueError(
-                f"response geometry sample budget exceeds {MAX_GEOMETRY_SAMPLES} samples"
-            )
+        if not finite(cells):
+            raise ValueError("ground sampling span must be finite")
         n = max(1, math.ceil(max(0, cells)))
-        if 2 * n + 1 > MAX_GEOMETRY_SAMPLES:
-            raise ValueError(
-                f"response geometry sample budget exceeds {MAX_GEOMETRY_SAMPLES} samples"
-            )
 
         def points():
             for i in range(n):
-                yield a + (b - a) * i / n
-                yield a + (b - a) * (i + 0.5) / n
+                yield a + (b - a) * (i / n)
+                yield a + (b - a) * ((i + 0.5) / n)
             yield b
 
         return points()
 
 
-def chain_ends_s(scene: dict, rules: RuleSet) -> tuple[float, float] | None:
+def chain_ends_s(
+    scene: dict, rules: RuleSet, meter: WorkMeter | None = None
+) -> tuple[float, float] | None:
     """s of the wall chain's left and right ends, or None without a meter wall."""
-    spans = wall_spans_s(scene, rules)
+    meter = meter if meter is not None else WorkMeter()
+    spans = wall_spans_s(scene, rules, meter=meter)
     if spans is None:
         return None
     return min(a for a, _ in spans.values()), max(b for _, b in spans.values())
 
 
-def declared_height_problems(scene: dict, result: dict, rules: RuleSet) -> list[str]:
+def declared_height_problems(
+    scene: dict, result: dict, rules: RuleSet, meter: WorkMeter | None = None
+) -> list[str]:
     """A battery backs onto a wall that declares `height_ft` only if the wall is taller than the
     battery. The server fails wall_backing for a lower wall surely behind the battery and leaves
     it unsure for one within the battery's error of it (server/solver.py at 7133283,
     check_backing), so wall_backing passes only if every declared wall overlapping
     [s0 - e, s1 + e] is taller than battery.height_ft."""
-    if sampling := geometry_admission_problems(scene, result, rules):
+    meter = meter if meter is not None else WorkMeter()
+    if sampling := geometry_admission_problems(scene, result, rules, meter=meter):
         return sampling
     result = deduplicate_result_runs(result)
     declared = {w["id"]: w["height_ft"] for w in scene.get("walls", []) if "height_ft" in w}
     if not declared or rules.battery_height_ft is None:
         return []
-    spans = wall_spans_s(scene, rules) or {}
+    spans = wall_spans_s(scene, rules, meter=meter) or {}
     height = rules.battery_height_ft
 
     def short_near(wall_id: str, lo: float, hi: float) -> str | None:
-        e = battery_error(scene, rules, wall_id, lo, hi)
+        meter.charge()
+        e = battery_error(scene, rules, wall_id, lo, hi, meter=meter)
         for wid, h in declared.items():
+            meter.charge()
             a, b = spans.get(wid, (math.inf, -math.inf))
             near = a < hi + e - SERVER_EPS and b > lo - e + SERVER_EPS
             if near and h - height <= SERVER_EPS:
@@ -1354,6 +1496,7 @@ def short_near(wall_id: str, lo: float, hi: float) -> str | None:
         if run["outcome"] != "pass":
             continue
         for start in run_starts(run["start_ft"], rules.step_ft):
+            meter.charge()
             short = short_near(run["wall_id"], start, start + rules.width_ft)
             if short:
                 problems.append(
@@ -1363,21 +1506,25 @@ def short_near(wall_id: str, lo: float, hi: float) -> str | None:
     return problems
 
 
-def with_past_ends_asked(scene: dict, requests: list[dict], rules: RuleSet) -> dict:
+def with_past_ends_asked(
+    scene: dict, requests: list[dict], rules: RuleSet, meter: WorkMeter | None = None
+) -> dict:
     """The scene as if everything past each end the result asks to walk past were observed.
 
     Past an unexplored end the wall may turn, so a view along the same line settles nothing; the
     server asks to keep walking (`past_end`) instead of for a band there, and that request covers
     every band beyond the end. Only a request at the chain's actual end, on a side not marked
     `limit`, earns that credit."""
+    meter = meter if meter is not None else WorkMeter()
     kinds = scene.get("coverage", {}).get("ends", {})
     past = [r for r in requests if r["kind"] == "past_end" and "span_ft" in r and "side" in r]
-    ends = chain_ends_s(scene, rules) if past else None
+    ends = chain_ends_s(scene, rules, meter=meter) if past else None
     if not past or ends is None:
         return scene
     m = copy.deepcopy(scene)
     observed_ = m.setdefault("coverage", {}).setdefault("observed", [])
     for r in past:
+        meter.charge()
         side = r["side"]
         end = ends[0] if side == "left" else ends[1]
         if kinds.get(side, {}).get("kind") == "limit" or abs(r["span_ft"][0] - end) > END_TOL_FT:
@@ -1416,7 +1563,7 @@ def assumption_mismatches(
     return out
 
 
-def expectation_problems(expect: dict, result: dict) -> list[str]:
+def expectation_problems(expect: dict, result: dict, meter: WorkMeter | None = None) -> list[str]:
     problems: list[str] = []
     decision = result["decision"]
     if "decision_in" in expect and decision not in expect["decision_in"]:
@@ -1486,8 +1633,10 @@ def expectation_problems(expect: dict, result: dict) -> list[str]:
                 if field in rule and (got is None or abs(got - rule[field]) > NUMBER_TOL_FT):
                     problems.append(f"check {check['id']}: {field} {got}, expected {rule[field]}")
 
-    for rule in expect.get("start_outcomes", []):
-        got = outcome_at(result, rule["wall_id"], rule["start_ft"])
+    starts = expect.get("start_outcomes", [])
+    index = SweepIndex(result, meter=meter) if starts else None
+    for rule in starts:
+        got = index.outcome_at(rule["wall_id"], rule["start_ft"])
         if got != rule["outcome"]:
             why = f" ({rule['why']})" if "why" in rule else ""
             problems.append(
@@ -1573,50 +1722,30 @@ def comparable(result: dict) -> dict:
 # numbers: more measurement error or less coverage can only make the server less sure.
 
 
-def outcome_at(result: dict, wall_id: str, start_ft: float) -> str | None:
-    """Outcome of the sweep run containing this battery start, or None if none contains it."""
-    for run in result.get("sweep", []):
-        a, b = run["start_ft"]
-        if run["wall_id"] == wall_id and a - EPS <= start_ft <= b + EPS:
-            return run["outcome"]
-    return None
+def outcome_at(
+    result: dict, wall_id: str, start_ft: float, meter: WorkMeter | None = None
+) -> str | None:
+    meter = meter if meter is not None else WorkMeter()
+    return SweepIndex(result, meter=meter).outcome_at(wall_id, start_ft)
 
 
-def probe_starts(*results: dict) -> list[tuple[str, float]]:
-    """Every run's ends and middle, from all results: where the outcomes can be compared."""
-    points = set()
-    for result in results:
-        for run in result.get("sweep", []):
-            a, b = run["start_ft"]
-            points |= {(run["wall_id"], a), (run["wall_id"], b), (run["wall_id"], (a + b) / 2)}
-    return sorted(points)
+def probe_starts(*results: dict, meter: WorkMeter | None = None) -> list[tuple[str, float]]:
+    meter = meter if meter is not None else WorkMeter()
+    return indexed_probe_starts(*results, meter=meter)
 
 
-def more_error_problems(before: dict, after: dict, change: str) -> list[str]:
-    """With more error, a start may only move toward UNSURE: UNSURE stays, PASS and FAIL stay
-    or become UNSURE."""
-    problems = []
-    for wall_id, s in probe_starts(before, after):
-        a, b = outcome_at(before, wall_id, s), outcome_at(after, wall_id, s)
-        if a is None or b is None or a == b or b == "unsure":
-            continue
-        problems.append(f"{change}: start {wall_id} {s:.3f} went from {a} to {b}")
-    if before["decision"] != "pass" and after["decision"] == "pass":
-        problems.append(f"{change}: the decision became pass")
-    return problems
+def more_error_problems(
+    before: dict, after: dict, change: str, meter: WorkMeter | None = None
+) -> list[str]:
+    meter = meter if meter is not None else WorkMeter()
+    return indexed_more_error_problems(before, after, change, meter=meter)
 
 
-def less_coverage_problems(before: dict, after: dict, change: str) -> list[str]:
-    """With less observed, no start may newly PASS."""
-    problems = [
-        f"{change}: start {wall_id} {s:.3f} went from {outcome_at(before, wall_id, s)} to pass"
-        for wall_id, s in probe_starts(before, after)
-        if outcome_at(after, wall_id, s) == "pass"
-        and outcome_at(before, wall_id, s) not in (None, "pass")
-    ]
-    if before["decision"] != "pass" and after["decision"] == "pass":
-        problems.append(f"{change}: the decision became pass")
-    return problems
+def less_coverage_problems(
+    before: dict, after: dict, change: str, meter: WorkMeter | None = None
+) -> list[str]:
+    meter = meter if meter is not None else WorkMeter()
+    return indexed_less_coverage_problems(before, after, change, meter=meter)
 
 
 def chain_length_ft(scene: dict) -> float:
diff --git a/verification/tests/test_e2e.py b/verification/tests/test_e2e.py
index 1bf3ca398..060f9156d 100644
--- a/verification/tests/test_e2e.py
+++ b/verification/tests/test_e2e.py
@@ -297,7 +297,8 @@ def test_server_breaking_coverage_rule_fails(fake_url):
     assert record["status"] == "fail"
     joined = "\n".join(record["problems"])
     assert "ruled out for this case" in joined
-    assert "no coverage: decision pass for a scene with no coverage at all" in joined
+    assert "decision pass without a passing spot" in joined
+    assert "no coverage:" not in joined  # Initial invariant failure stops transformed requests.
     assert re.search(r"needs ground \[.*\] observed, none seen", joined)
 
 
@@ -615,7 +616,7 @@ def test_transformed_answer_checks_its_own_hash(monkeypatch):
     monkeypatch.setattr(e2e, "answer", lambda *args: (original, None))
     monkeypatch.setattr(e2e, "schema_errors", lambda *args: [])
 
-    def check_hash(scene, result, sent=None, rules=None):
+    def check_hash(scene, result, sent=None, rules=None, *, meter=None):
         calls.append((scene, sent))
         return ["stale input hash"] if sent is not None else []
 
@@ -624,7 +625,10 @@ def check_hash(scene, result, sent=None, rules=None):
     monkeypatch.setattr(e2e, "with_more_error", lambda *args: None)
     monkeypatch.setattr(e2e, "tape_to_tap", lambda *args: None)
     monkeypatch.setattr(e2e, "with_less_coverage", lambda *args: None)
-    scene = {"walls": [{"id": "w1", "baseline": [[-1, 0], [1, 0]]}], "meter": {"pos": [0, 1, 0]}}
+    scene = {
+        "walls": [{"id": "w1", "baseline": [[-1, 0], [1, 0]]}],
+        "meter": {"pos": [0, 1, 0], "wall_id": "w1"},
+    }
     probe = SceneInput(name="test", scene=scene, raw=json.dumps(scene).encode(), source="test")
     failures = e2e.property_problems(
         "unused", Endpoint("/p", "application/json"), probe, original, {"result": {}}, RULES
diff --git a/verification/tests/test_generate_cases.py b/verification/tests/test_generate_cases.py
index a37800816..89228e128 100644
--- a/verification/tests/test_generate_cases.py
+++ b/verification/tests/test_generate_cases.py
@@ -88,7 +88,7 @@ def test_real_case_rule_override_skips_stale_expectation(tmp_path, monkeypatch,
     )
     monkeypatch.setattr(e2e, "schema_errors", lambda *args: [])
     monkeypatch.setattr(e2e, "invariant_problems", lambda *args, **kwargs: [])
-    monkeypatch.setattr(e2e, "property_problems", lambda *args: [])
+    monkeypatch.setattr(e2e, "property_problems", lambda *args, **kwargs: [])
 
     def forbidden(*args):
         pytest.fail("a mismatched case must not apply its stale expectations")
diff --git a/verification/tests/test_intervalindex.py b/verification/tests/test_intervalindex.py
new file mode 100644
index 000000000..36b6f327b
--- /dev/null
+++ b/verification/tests/test_intervalindex.py
@@ -0,0 +1,113 @@
+import random
+
+import pytest
+
+from hsverify.intervalindex import (
+    SweepIndex,
+    less_coverage_problems,
+    more_error_problems,
+    probe_starts,
+)
+
+
+class CountingMeter:
+    def __init__(self, limit=None):
+        self.samples = 0
+        self.limit = limit
+
+    def charge(self, n=1):
+        self.samples += n
+        if self.limit is not None and self.samples > self.limit:
+            raise WorkLimit
+
+
+class WorkLimit(Exception):
+    pass
+
+
+def result(*runs, decision="fail"):
+    return {"decision": decision, "sweep": list(runs)}
+
+
+def run(a, b, outcome="fail", wall_id="w1"):
+    return {"wall_id": wall_id, "start_ft": [a, b], "outcome": outcome}
+
+
+def test_thirty_thousand_runs_compare_with_linear_logarithmic_work():
+    answer = result(*(run(i / 1e4, i / 1e4) for i in range(30_000)))
+    meter = CountingMeter()
+    assert more_error_problems(answer, answer, "more error", meter) == []
+    assert 30_000 < meter.samples < 100 * 30_000
+
+
+def test_first_original_run_wins_overlaps_including_eps_endpoints():
+    answer = result(run(2, 4, "fail"), run(0, 6, "pass"), run(4, 4, "unsure"))
+    index = SweepIndex(answer)
+    for start in (2 - 1e-6, 2, 3, 4, 4 + 1e-6):
+        assert index.outcome_at("w1", start) == "fail"
+    assert index.outcome_at("w1", 2 - 2e-6) == "pass"
+    assert index.outcome_at("w1", 4 + 2e-6) == "pass"
+
+
+def test_index_agrees_with_original_linear_lookup_on_overlapping_runs():
+    rng = random.Random(731)
+    runs = [
+        run(
+            a := rng.randrange(-20, 20),
+            a + rng.randrange(0, 10),
+            rng.choice(["pass", "fail", "unsure"]),
+        )
+        for _ in range(200)
+    ]
+    index = SweepIndex(result(*runs))
+    points = {x for r in runs for edge in r["start_ft"] for x in (edge - 1e-6, edge, edge + 1e-6)}
+    points.update(rng.uniform(-30, 30) for _ in range(500))
+    for start in points:
+        expected = next(
+            (
+                r["outcome"]
+                for r in runs
+                if r["start_ft"][0] - 1e-6 <= start <= r["start_ft"][1] + 1e-6
+            ),
+            None,
+        )
+        assert index.outcome_at("w1", start) == expected
+
+
+def test_gap_neighbours_and_equal_endpoint_ties_preserve_original_order():
+    index = SweepIndex(result(run(0, 1, "fail"), run(0, 1, "pass"), run(3, 4, "unsure")))
+    assert index.outcomes_near("w1", 2) == ({"fail", "unsure"}, "unswept beside fail and unsure")
+    assert index.outcomes_near("w1", -1) == ({"fail"}, "past the original sweep")
+    assert index.outcomes_near("w1", 5) == ({"fail"}, "past the original sweep")
+    assert index.outcomes_near("missing", 0) == (set(), "no run on its wall")
+
+
+def test_newly_evaluated_wall_can_fail_but_cannot_pass():
+    before = result(run(0, 1))
+    assert more_error_problems(before, result(run(0, 1, "fail", "w2")), "error") == []
+    assert more_error_problems(before, result(run(0, 1, "pass", "w2")), "error")
+    assert less_coverage_problems(before, result(run(0, 1, "pass", "w2")), "coverage")
+
+
+def test_unswept_gap_can_keep_neighbour_pass_but_not_create_one():
+    after = result(run(2, 2, "pass"))
+    assert more_error_problems(result(run(0, 1, "pass"), run(3, 4)), after, "error") == []
+    assert less_coverage_problems(result(run(0, 1, "pass"), run(3, 4)), after, "coverage") == []
+    assert less_coverage_problems(result(run(0, 1), run(3, 4)), after, "coverage")
+
+
+@pytest.mark.parametrize("operation", [SweepIndex, probe_starts])
+def test_work_limit_propagates_from_index_or_probe_creation(operation):
+    with pytest.raises(WorkLimit):
+        operation(result(run(0, 1)), meter=CountingMeter(limit=0))
+
+
+@pytest.mark.parametrize("comparison", [more_error_problems, less_coverage_problems])
+def test_work_limit_propagates_from_comparison(comparison):
+    answer = result(run(0, 1, "pass"))
+    with pytest.raises(WorkLimit):
+        comparison(answer, answer, "change", meter=CountingMeter(limit=1))
+
+
+def test_probe_midpoint_does_not_overflow_finite_endpoints():
+    assert probe_starts(result(run(1e308, 1e308))) == [("w1", 1e308)]
diff --git a/verification/tests/test_judge_meter.py b/verification/tests/test_judge_meter.py
new file mode 100644
index 000000000..77fea4f18
--- /dev/null
+++ b/verification/tests/test_judge_meter.py
@@ -0,0 +1,294 @@
+"""Hostile answers must still produce a report, with bounded verification work."""
+
+import copy
+import hashlib
+import json
+from pathlib import Path
+
+import pytest
+
+from hsverify import e2e
+from hsverify.resultcheck import RuleSet, WorkMeter
+
+ROOT = Path(__file__).resolve().parents[2]
+RULES = RuleSet.from_yaml((ROOT / "server/rules.yaml").read_text())
+SCHEMAS = {
+    "scene": {},
+    "result": json.loads((ROOT / "server/schemas/result.schema.json").read_text()),
+}
+SCENE = {
+    "meter": {"pos": [0, 4, 0], "wall_id": "w1"},
+    "walls": [{"id": "w1", "baseline": [[-30, 0], [30, 0]]}],
+}
+ENDPOINT = e2e.Endpoint("/place", "application/json")
+META = {
+    "started_at": "2026-10-14",
+    "server_ref": "public test fixture",
+    "server_sha": "a" * 40,
+    "endpoint": "/place",
+    "load_average_1_5_15": [0, 0, 0],
+    "peak_memory": {},
+}
+
+
+def probe():
+    return e2e.SceneInput("hostile answer", SCENE, json.dumps(SCENE).encode())
+
+
+def response():
+    return {
+        "schema_version": "1.0",
+        "decision": "manual_review",
+        "summary": "No spot chosen",
+        "reasons": [],
+        "policy": {
+            "id": "demo",
+            "version": "1",
+            "auto_approve": False,
+            "sources": ["public"],
+            "rules_sha256": "a" * 64,
+        },
+        "spot": None,
+        "route": None,
+        "checks": [],
+        "missing_evidence": [],
+        "ends": {
+            side: {"kind": "limit", "s_ft": s, "point": [s, 0]}
+            for side, s in (("left", -30), ("right", 30))
+        },
+        "sweep": [],
+        "stats": {
+            "candidates": 0,
+            "pass": 0,
+            "unsure": 0,
+            "fail": 0,
+            "elapsed_ms": 1,
+            "input_sha256": hashlib.sha256(probe().raw).hexdigest(),
+        },
+    }
+
+
+def serve(monkeypatch, result):
+    assert not e2e.schema_errors(result, SCHEMAS["result"])
+    monkeypatch.setattr(e2e, "post", lambda *args: (200, json.dumps(result).encode(), 1))
+
+
+def forbid_properties(*args, **kwargs):
+    raise AssertionError("a rejected answer reached property comparisons")
+
+
+@pytest.mark.parametrize("exception", [OverflowError, ValueError, RuntimeError])
+def test_check_exception_is_written_to_report(monkeypatch, tmp_path, exception):
+    serve(monkeypatch, response())
+
+    def crash(*args, **kwargs):
+        raise exception("hostile response")
+
+    monkeypatch.setattr(e2e, "invariant_problems", crash)
+    monkeypatch.setattr(e2e, "property_problems", forbid_properties)
+    record = e2e.judge("unused", ENDPOINT, probe(), SCHEMAS, RULES)
+    assert record["status"] == "fail"
+    assert record["problems"] == [f"invariants: {exception.__name__}: hostile response"]
+    report = e2e.write_report(tmp_path, META, [record])
+    assert not report["contract_ok"]
+    assert json.loads((tmp_path / "report.json").read_text())["records"][0] == record
+
+
+def test_failed_invariants_skip_properties(monkeypatch):
+    serve(monkeypatch, response())
+    monkeypatch.setattr(e2e, "invariant_problems", lambda *args, **kwargs: ["bad invariant"])
+    monkeypatch.setattr(e2e, "property_problems", forbid_properties)
+    record = e2e.judge("unused", ENDPOINT, probe(), SCHEMAS, RULES)
+    assert record["contract_problems"] == ["bad invariant"]
+
+
+def test_original_and_properties_share_one_meter(monkeypatch):
+    serve(monkeypatch, response())
+    meters = []
+
+    def invariants(*args, meter, **kwargs):
+        meters.append(meter)
+        meter.charge(4)
+        return []
+
+    def properties(*args, meter, **kwargs):
+        meters.append(meter)
+        meter.charge(5)
+        return []
+
+    monkeypatch.setattr(e2e, "invariant_problems", invariants)
+    monkeypatch.setattr(e2e, "property_problems", properties)
+    monkeypatch.setattr(e2e, "geometry_admission_problems", lambda *args, **kwargs: [])
+    meter = WorkMeter(limit=9)
+    record = e2e.judge("unused", ENDPOINT, probe(), SCHEMAS, RULES, meter=meter)
+    assert record["status"] == "pass"
+    assert record["verification_samples"] == 9
+    assert meters == [meter, meter]
+
+
+def test_meter_limit_is_one_specific_report_problem(monkeypatch, tmp_path):
+    serve(monkeypatch, response())
+
+    def invariants(*args, meter, **kwargs):
+        meter.charge(4)
+        return []
+
+    monkeypatch.setattr(e2e, "invariant_problems", invariants)
+    monkeypatch.setattr(e2e, "property_problems", forbid_properties)
+    monkeypatch.setattr(e2e, "geometry_admission_problems", lambda *args, **kwargs: [])
+    record = e2e.judge("unused", ENDPOINT, probe(), SCHEMAS, RULES, meter=WorkMeter(limit=3))
+    assert record["problems"] == ["verification work limit exceeded (4 samples)"]
+    assert record["verification_samples"] == 4
+    assert not e2e.write_report(tmp_path, META, [record])["contract_ok"]
+
+
+def test_oversized_integer_is_an_admission_problem(monkeypatch, tmp_path):
+    result = response()
+    result["sweep"] = [
+        {"wall_id": "w1", "start_ft": [0, 10**400], "outcome": "fail", "failing": [], "unsure": []}
+    ]
+    serve(monkeypatch, result)
+    monkeypatch.setattr(e2e, "property_problems", forbid_properties)
+    record = e2e.judge("unused", ENDPOINT, probe(), SCHEMAS, RULES)
+    assert record["status"] == "fail"
+    assert any("finite" in p for p in record["problems"])
+    assert not any("OverflowError" in p for p in record["problems"])
+    assert record["verification_samples"] == 0
+    assert not e2e.write_report(tmp_path, META, [record])["contract_ok"]
+
+
+def spot(wall_id):
+    return {
+        "outcome": "fail",
+        "wall_id": wall_id,
+        "segment": 0,
+        "span_ft": [1, 1 + RULES.width_ft],
+        "width_ft": RULES.width_ft,
+        "depth_ft": RULES.depth_ft,
+        "height_ft": RULES.battery_height_ft,
+        "footprint": [
+            [1, 0],
+            [1 + RULES.width_ft, 0],
+            [1 + RULES.width_ft, RULES.depth_ft],
+            [1, RULES.depth_ft],
+        ],
+        "center": [1 + RULES.width_ft / 2, RULES.depth_ft / 2],
+        "along": [1, 0],
+        "outward": [0, 1],
+        "meter_offset_ft": [1 + RULES.width_ft / 2, RULES.depth_ft / 2],
+        "route_length_ft": None,
+    }
+
+
+@pytest.mark.parametrize("field", ["sweep", "spot", "nearest_considered"])
+def test_unknown_wall_is_rejected_before_geometry(monkeypatch, tmp_path, field):
+    result = response()
+    if field == "sweep":
+        result[field] = [
+            {
+                "wall_id": "missing",
+                "start_ft": [1, 2],
+                "outcome": "fail",
+                "failing": [],
+                "unsure": [],
+            }
+        ]
+    else:
+        result[field] = spot("missing")
+    serve(monkeypatch, result)
+    monkeypatch.setattr(e2e, "property_problems", forbid_properties)
+    record = e2e.judge("unused", ENDPOINT, probe(), SCHEMAS, RULES)
+    assert record["status"] == "fail"
+    assert any("unknown wall_id 'missing'" in p for p in record["problems"])
+    assert record["verification_samples"] == 0
+    assert not e2e.write_report(tmp_path, META, [record])["contract_ok"]
+
+
+@pytest.mark.parametrize("failure", ["admission", "invariants"])
+def test_invalid_variant_never_reaches_comparisons(monkeypatch, failure):
+    original = response()
+    other = copy.deepcopy(original)
+    if failure == "admission":
+        other["nearest_considered"] = spot("missing")
+    serve(monkeypatch, original)
+    monkeypatch.setattr(e2e, "answer", lambda *args: (other, None))
+    monkeypatch.setattr(e2e, "with_ground_short_of", lambda *args: None)
+    monkeypatch.setattr(e2e, "with_less_coverage", lambda *args: None)
+    monkeypatch.setattr(e2e, "with_more_error", lambda *args: copy.deepcopy(SCENE))
+    monkeypatch.setattr(e2e, "tape_to_tap", lambda *args: None)
+    monkeypatch.setattr(e2e, "more_error_problems", forbid_properties)
+    monkeypatch.setattr(e2e, "less_coverage_problems", forbid_properties)
+    if failure == "admission":
+        monkeypatch.setattr(e2e, "invariant_problems", forbid_properties)
+    else:
+        monkeypatch.setattr(e2e, "invariant_problems", lambda *args, **kwargs: ["bad variant hash"])
+    problems = e2e.property_problems("unused", ENDPOINT, probe(), original, SCHEMAS, RULES)
+    expected = "unknown wall_id" if failure == "admission" else "bad variant hash"
+    assert any(p.startswith("more error:") and expected in p for p in problems)
+
+
+def test_variants_and_comparisons_charge_the_judge_meter(monkeypatch):
+    original = response()
+    serve(monkeypatch, original)
+    monkeypatch.setattr(e2e, "answer", lambda *args: (original, None))
+    monkeypatch.setattr(e2e, "geometry_admission_problems", lambda *args, **kwargs: [])
+    monkeypatch.setattr(e2e, "with_ground_short_of", lambda *args: None)
+    monkeypatch.setattr(e2e, "with_less_coverage", lambda *args: None)
+    monkeypatch.setattr(e2e, "with_more_error", lambda *args: copy.deepcopy(SCENE))
+    monkeypatch.setattr(e2e, "tape_to_tap", lambda *args: None)
+    received = []
+
+    def invariants(*args, meter, **kwargs):
+        received.append(meter)
+        meter.charge()
+        return []
+
+    def compare(*args, meter):
+        received.append(meter)
+        meter.charge(2)
+        return []
+
+    monkeypatch.setattr(e2e, "invariant_problems", invariants)
+    monkeypatch.setattr(e2e, "more_error_problems", compare)
+    meter = WorkMeter(limit=4)
+    problems = e2e.property_problems(
+        "unused", ENDPOINT, probe(), original, SCHEMAS, RULES, meter=meter
+    )
+    assert not problems
+    assert received == [meter, meter, meter]
+    assert meter.samples == 4
+
+
+def test_unknown_rules_keep_rule_independent_properties(monkeypatch):
+    original = response()
+    changed = copy.deepcopy(original)
+    changed["summary"] = "Changed answer for the identical scene"
+    serve(monkeypatch, changed)
+    scene = copy.deepcopy(SCENE)
+    scene["coverage"] = {"observed": [{"band": "wall", "span_ft": [-30, 30]}]}
+    item = e2e.SceneInput("rule override", scene, json.dumps(scene).encode())
+    variants = []
+    checked_rules = []
+
+    def answer(url, endpoint, transformed):
+        variants.append(transformed.name.split("~")[-1])
+        return original, None
+
+    def invariants(*args, rules, **kwargs):
+        checked_rules.append(rules)
+        return []
+
+    def public_rule_transform(*args):
+        raise AssertionError("private override judged using a public-rule transform")
+
+    monkeypatch.setattr(e2e, "answer", answer)
+    monkeypatch.setattr(e2e, "invariant_problems", invariants)
+    monkeypatch.setattr(e2e, "with_ground_short_of", public_rule_transform)
+    monkeypatch.setattr(e2e, "with_more_error", public_rule_transform)
+    monkeypatch.setattr(e2e, "tape_to_tap", public_rule_transform)
+    problems = e2e.property_problems(
+        "unused", ENDPOINT, item, original, SCHEMAS, RULES, rule_checks=False
+    )
+    assert problems == ["sending the same scene twice gave different results"]
+    assert variants == ["mirrored", "no coverage", "less coverage"]
+    assert checked_rules == [None, None, None]
diff --git a/verification/tests/test_resultcheck.py b/verification/tests/test_resultcheck.py
index 11b8a5322..640a36e61 100644
--- a/verification/tests/test_resultcheck.py
+++ b/verification/tests/test_resultcheck.py
@@ -6,11 +6,12 @@
 import pytest
 
 from hsverify.resultcheck import (
-    MAX_GEOMETRY_SAMPLES,
     MAX_SWEEP_SAMPLES,
     GroundPlan,
     Need,
     RuleSet,
+    WorkLimitExceeded,
+    WorkMeter,
     assumption_mismatches,
     battery_error,
     chain_ends_s,
@@ -1593,18 +1594,15 @@ def starts(*args):
     assert len(calls) == 1
 
 
-def test_vet_many_distinct_admissible_runs_exceed_one_response_budget(monkeypatch):
-    def no_sampling(*args):
-        pytest.fail("over-budget response reached sampling")
-
-    monkeypatch.setattr("hsverify.resultcheck.run_starts", no_sampling)
+def test_vet_many_distinct_admissible_runs_exceed_one_response_budget():
     scene = copy.deepcopy(SCENE)
     scene["walls"][0]["baseline"] = [[-2000, 0], [2000, 0]]
     runs = [pass_run(i / 1000, 1000 + i / 1000) | {"outcome": "unsure"} for i in range(5000)]
     answer = result(spot=False, sweep=runs)
-    assert invariant_problems(scene, answer, rules=RULES) == [
-        f"response geometry sample budget exceeds {MAX_GEOMETRY_SAMPLES} samples"
-    ]
+    meter = WorkMeter(1000)
+    with pytest.raises(WorkLimitExceeded):
+        invariant_problems(scene, answer, rules=RULES, meter=meter)
+    assert meter.samples == 1001
 
 
 def test_vet_huge_spot_with_empty_sweep_stops_before_geometry(monkeypatch):
@@ -1618,26 +1616,23 @@ def no_geometry(*args):
     assert problems and any("span_ft" in p for p in problems)
 
 
-def test_vet_geometry_budget_counts_spot_ground_grid_before_iteration(monkeypatch):
-    def no_geometry(*args):
-        pytest.fail("over-budget spot reached the ground grid")
-
-    monkeypatch.setattr(GroundPlan, "_samples", no_geometry)
+def test_vet_unused_spot_grid_does_not_consume_predicted_work():
     answer = result(sweep=[])
     huge_reach = replace(RULES, needs={"gas_clearance": (Need("ground", 1e9),)})
-    assert invariant_problems(SCENE, answer, rules=huge_reach) == [
-        f"response geometry sample budget exceeds {MAX_GEOMETRY_SAMPLES} samples"
-    ]
+    meter = WorkMeter(1000)
+    problems = invariant_problems(SCENE, answer, rules=huge_reach, meter=meter)
+    assert any("check gas_clearance passes" in p for p in problems)
+    assert meter.samples < 1000
 
 
-def test_vet_geometry_budget_counts_check_only_reported_width(monkeypatch):
+def test_vet_check_only_width_does_not_predict_unused_geometry():
     answer = result(spot=False, sweep=[])
     answer["checks"].append(
-        {"id": "width", "threshold_ft": 1e9, "rule": {"key": "battery.width_ft"}}
+        {"id": "width", "outcome": "pass", "threshold_ft": 1e9, "rule": {"key": "battery.width_ft"}}
     )
-    assert invariant_problems(SCENE, answer, rules=RULES) == [
-        f"response geometry sample budget exceeds {MAX_GEOMETRY_SAMPLES} samples"
-    ]
+    meter = WorkMeter(1000)
+    assert invariant_problems(SCENE, answer, rules=RULES, meter=meter) == []
+    assert meter.samples < 1000
 
 
 def test_vet_ground_samples_are_lazy_and_preserve_grid_edges_and_centres():
@@ -1646,19 +1641,18 @@ def test_vet_ground_samples_are_lazy_and_preserve_grid_edges_and_centres():
     assert list(points) == pytest.approx([0, 0.025, 0.05, 0.075, 0.1])
 
 
-def test_vet_repeated_spot_checks_count_toward_the_shared_budget(monkeypatch):
-    def no_geometry(*args):
-        pytest.fail("repeated checks reached geometry sampling")
-
-    monkeypatch.setattr(GroundPlan, "_samples", no_geometry)
-    answer = result(sweep=[], checks=[passing("ground_surface") for _ in range(1000)])
+def test_vet_repeated_spot_checks_reuse_geometry():
+    one = result(sweep=[], checks=[passing("ground_surface")])
+    many = result(sweep=[], checks=[passing("ground_surface") for _ in range(1000)])
     broad = replace(RULES, needs={"ground_surface": (Need("ground", 10),)})
-    assert invariant_problems(SCENE, answer, rules=broad) == [
-        f"response geometry sample budget exceeds {MAX_GEOMETRY_SAMPLES} samples"
-    ]
+    one_meter, many_meter = WorkMeter(100_000), WorkMeter(100_000)
+    assert coverage_problems(SCENE, many, broad, meter=many_meter) == coverage_problems(
+        SCENE, one, broad, meter=one_meter
+    )
+    assert many_meter.samples == one_meter.samples
 
 
-def test_vet_budget_includes_midpoint_direction_switches(monkeypatch):
+def test_vet_runtime_samples_include_midpoint_direction_switches():
     scene = copy.deepcopy(SCENE)
     scene["meter"]["plus_minus_ft"] = 8.8
     scene["walls"] = [
@@ -1670,11 +1664,7 @@ def test_vet_budget_includes_midpoint_direction_switches(monkeypatch):
         RULES, width_ft=10, depth_ft=2, step_ft=0.1, needs={"ground_surface": (Need("ground", 0),)}
     )
     answer = result(spot=False, sweep=[pass_run(0, 10)])
-
-    def no_sampling(*args):
-        pytest.fail("midpoint error exceeded budget after admission")
-
-    monkeypatch.setattr("hsverify.resultcheck.run_starts", no_sampling)
-    assert invariant_problems(scene, answer, rules=broad) == [
-        f"response geometry sample budget exceeds {MAX_GEOMETRY_SAMPLES} samples"
-    ]
+    meter = WorkMeter(1000)
+    with pytest.raises(WorkLimitExceeded):
+        invariant_problems(scene, answer, rules=broad, meter=meter)
+    assert meter.samples == 1001
diff --git a/verification/tests/test_runtime_meter.py b/verification/tests/test_runtime_meter.py
new file mode 100644
index 000000000..991d8ec1c
--- /dev/null
+++ b/verification/tests/test_runtime_meter.py
@@ -0,0 +1,181 @@
+import copy
+import json
+from dataclasses import replace
+from pathlib import Path
+
+import pytest
+from test_resultcheck import RULES, SCENE, check, result
+
+import hsverify.resultcheck as checks
+from hsverify.resultcheck import (
+    GroundPlan,
+    Need,
+    RuleSet,
+    WorkLimitExceeded,
+    WorkMeter,
+    finite,
+    geometry_admission_problems,
+    invariant_problems,
+    missing_evidence_problems,
+    reach_gaps,
+    schema_errors,
+)
+
+
+def test_oversized_integer_fails_admission_before_geometry():
+    answer = result(
+        spot=False, sweep=[{"wall_id": "w1", "start_ft": [0, 10**400], "outcome": "fail"}]
+    )
+    assert not finite(10**400)
+    meter = WorkMeter(0)
+    problems = invariant_problems(SCENE, answer, rules=RULES, meter=meter)
+    assert any("start_ft must be finite and ordered" in problem for problem in problems)
+    assert meter.samples == 0
+
+
+def test_unknown_nearest_wall_is_rejected_before_geometry():
+    answer = result()
+    answer["nearest_considered"] = answer["spot"] | {"wall_id": "missing"}
+    meter = WorkMeter(0)
+    assert any(
+        "nearest_considered names unknown wall_id 'missing'" in problem
+        for problem in invariant_problems(SCENE, answer, rules=RULES, meter=meter)
+    )
+    assert meter.samples == 0
+
+
+def test_identical_unsure_checks_do_not_repeat_geometry():
+    unsure = check(outcome="unsure", measured=None, cause="unobserved") | {"id": "pool_clearance"}
+    answer = result(checks=[unsure], complete=False)
+    answer["spot"]["outcome"] = "unsure"
+    answer["reasons"] = [{"code": "unobserved_area"}]
+    answer["missing_evidence"] = [{"kind": "band", "band": "ground", "checks": ["pool_clearance"]}]
+    rules = replace(RULES, needs={"pool_clearance": (Need("ground", 10),)})
+    meter = WorkMeter(100_000)
+    once = missing_evidence_problems(SCENE, answer, rules, meter=meter)
+    many = copy.deepcopy(answer)
+    many["checks"] *= 10_000
+    duplicate_meter = WorkMeter(100_000)
+    assert missing_evidence_problems(SCENE, many, rules, meter=duplicate_meter) == once
+    assert duplicate_meter.samples == meter.samples
+    assert 0 < meter.samples < 100_000
+
+
+def test_reach_cache_includes_geometry_and_parameters():
+    meter = WorkMeter(10_000)
+    first = reach_gaps(SCENE, RULES, "gas_clearance", "w1", 1, 3, meter=meter)
+    count = meter.samples
+    assert reach_gaps(SCENE, RULES, "gas_clearance", "w1", 1, 3, meter=meter) == first
+    assert meter.samples == count
+    reach_gaps(SCENE, RULES, "gas_clearance", "w1", 1, 4, meter=meter)
+    assert meter.samples > count
+    count = meter.samples
+    changed = copy.deepcopy(SCENE)
+    changed["coverage"]["observed"][1]["out_ft"] = 0.1
+    reach_gaps(changed, RULES, "gas_clearance", "w1", 1, 3, meter=meter)
+    assert meter.samples > count
+
+
+def test_ground_grid_stops_at_shared_runtime_limit():
+    meter = WorkMeter(30)
+    plan = GroundPlan(SCENE, RULES, meter=meter)
+    with pytest.raises(WorkLimitExceeded) as caught:
+        plan.covers(2, 1, 3, 0, lambda _: 2)
+    assert caught.value.samples == meter.samples == 31
+    assert str(caught.value) == "verification work limit exceeded (31 samples)"
+
+
+def test_valid_wide_direct_coverage_uses_only_visited_work():
+    rules = RuleSet.from_yaml((Path(__file__).parents[2] / "server" / "rules.yaml").read_text())
+    scene = copy.deepcopy(SCENE)
+    scene["walls"][0]["baseline"] = [[-30, 0], [30, 0]]
+    scene["objects"] = []
+    scene["ground"] = [{"type": "concrete", "polygon": [[-30, 0], [30, 0], [30, 20], [-30, 20]]}]
+    scene["coverage"]["observed"] = [
+        {"band": band, "span_ft": [-30, 30], "out_ft": 20}
+        for band in ("ground", "wall", "facing", "overhead")
+    ]
+    answer = result(decision="pass")
+    answer["summary"] = "All public-rule checks pass with coverage beyond every required reach."
+    lo, hi = 2, 2 + rules.width_ft
+    answer["spot"].update(
+        span_ft=[lo, hi],
+        center=[(lo + hi) / 2, rules.depth_ft / 2],
+        meter_offset_ft=[(lo + hi) / 2, rules.depth_ft / 2],
+        footprint=[[lo, 0], [hi, 0], [hi, rules.depth_ft], [lo, rules.depth_ft]],
+        route_length_ft=2,
+    )
+    answer["sweep"][0]["start_ft"] = [2, 12]
+    answer["route"] = {
+        "outcome": "pass",
+        "length_ft": 2,
+        "plus_minus_ft": 0,
+        "height_ft": rules.route_height_ft,
+        "polyline": [[0, 0], [2, 0]],
+        "detours": [],
+        "crossings": [],
+    }
+    answer["ends"] = {
+        "left": {"kind": "limit", "s_ft": -30, "point": [-30, 0]},
+        "right": {"kind": "limit", "s_ft": 30, "point": [30, 0]},
+    }
+    for kind, value in (("scene", scene), ("result", answer)):
+        schema = json.loads(
+            (Path(__file__).parents[2] / "server" / "schemas" / f"{kind}.schema.json").read_text()
+        )
+        assert schema_errors(value, schema) == []
+    assert len(json.dumps(answer).encode()) == 4420
+    meter = WorkMeter(100_000)
+    assert geometry_admission_problems(scene, answer, rules) == []
+    assert invariant_problems(scene, answer, rules=rules, meter=meter) == []
+    assert 0 < meter.samples < 100_000
+
+
+def test_invariant_geometry_exception_names_its_check(monkeypatch):
+    def broken(*args, **kwargs):
+        raise RuntimeError("damaged geometry")
+
+    monkeypatch.setattr("hsverify.resultcheck.coverage_problems", broken)
+    problems = invariant_problems(SCENE, result(), rules=RULES)
+    assert "coverage: RuntimeError: damaged geometry" in problems
+
+
+def test_each_candidate_wall_piece_charges_the_shared_meter(monkeypatch):
+    monkeypatch.setattr(checks, "geometry_admission_problems", lambda *args, **kwargs: [])
+    monkeypatch.setattr(
+        checks,
+        "straight_pieces",
+        lambda *args, **kwargs: [(i * 10, i * 10 + 5) for i in range(1000)],
+    )
+    answer = result(
+        spot=False, sweep=[{"wall_id": "w1", "start_ft": [9991, 9991], "outcome": "unsure"}]
+    )
+    meter = WorkMeter(100)
+    with pytest.raises(WorkLimitExceeded):
+        checks.footprint_problems(SCENE, answer, RULES, meter=meter)
+    assert meter.samples == 101
+
+
+def test_finite_endpoints_with_overflowing_length_stop_admission():
+    answer = result(
+        spot=False, sweep=[{"wall_id": "w1", "start_ft": [-1e308, 1e308], "outcome": "fail"}]
+    )
+    meter = WorkMeter(0)
+    problems = invariant_problems(SCENE, answer, rules=RULES, meter=meter)
+    assert any("span length must be finite" in p for p in problems)
+    assert meter.samples == 0
+
+
+def test_equal_scene_copies_share_geometry_cache_keys():
+    meter = WorkMeter()
+    assert meter.input_key(SCENE) == meter.input_key(copy.deepcopy(SCENE))
+    assert isinstance(meter.input_key(SCENE), int)
+    before = meter.samples
+    for _ in range(10_000):
+        meter.input_key(SCENE)
+    assert meter.samples == before
+
+
+def test_ground_samples_do_not_overflow_finite_span():
+    points = GroundPlan._samples(0, 1e306)
+    assert all(finite(next(points)) for _ in range(1000))

From 67b10e568473df531a3295eb0802e4927e7cf566 Mon Sep 17 00:00:00 2001
From: SamGu-NRX <sgu07966@gmail.com>
Date: Wed, 14 Oct 2026 14:44:17 -0500
Subject: [PATCH 55/62] fix(verification): reject ambiguous capture scene paths

---
 verification/hsverify/e2e.py   | 13 ++++++++++---
 verification/tests/test_e2e.py | 23 +++++++++++++++++++----
 2 files changed, 29 insertions(+), 7 deletions(-)

diff --git a/verification/hsverify/e2e.py b/verification/hsverify/e2e.py
index 07458fde4..37406beb5 100644
--- a/verification/hsverify/e2e.py
+++ b/verification/hsverify/e2e.py
@@ -162,14 +162,21 @@ def read_bundle(path: Path) -> tuple[bytes, dict[str, bytes]]:
         declared = sum(i.file_size for i in infos)
         if declared > MAX_BUNDLE_BYTES:
             raise SystemExit(f"{path}: declares {declared} bytes, limit {MAX_BUNDLE_BYTES}")
-        infos = [i for i in infos if not i.is_dir() and not i.filename.startswith("__MACOSX/")]
+        capture_infos = [i for i in infos if not i.filename.startswith("__MACOSX/")]
+        infos = [i for i in capture_infos if not i.is_dir()]
+        # Mirror the public API layouts, but refuse competing scenes instead of
+        # preferring the root: the verifier must know which input it is testing.
+        candidates = [i for i in infos if i.filename.split("/")[-1] == "scene.json"]
+        if len({i.filename for i in candidates}) > 1:
+            raise SystemExit(f"{path}: ambiguous scene.json paths")
         scene_name = "scene.json"
         if not any(i.filename == scene_name for i in infos):
             # The public API also accepts a capture wrapped in one top-level folder.
-            tops = {i.filename.split("/", 1)[0] for i in infos}
+            tops = {i.filename.split("/", 1)[0] for i in capture_infos}
             if len(tops) == 1:
                 (top,) = tops
-                scene_name = f"{top}/scene.json"
+                if all(i.filename.startswith(f"{top}/") for i in capture_infos):
+                    scene_name = f"{top}/scene.json"
         scenes = [i for i in infos if i.filename == scene_name]
         if len(scenes) != 1:
             raise SystemExit(
diff --git a/verification/tests/test_e2e.py b/verification/tests/test_e2e.py
index 2f6bd5f9b..1691c42fa 100644
--- a/verification/tests/test_e2e.py
+++ b/verification/tests/test_e2e.py
@@ -608,23 +608,36 @@ def test_bundle_reads_one_wrapped_capture_and_ignores_macos_metadata(tmp_path):
     assert e2e.read_bundle(archive) == (b"canonical", {"frame.jpg": b"photo"})
 
 
-def test_bundle_root_scene_takes_precedence_over_wrapped_scene(tmp_path):
+def test_bundle_accepts_public_api_finder_fixture_shape(tmp_path):
+    archive = tmp_path / "scene.zip"
+    with zipfile.ZipFile(archive, "w") as z:
+        z.writestr("capture-2026-09-26/scene.json", b"canonical")
+        z.writestr("__MACOSX/capture-2026-09-26/._scene.json", b"resource fork")
+    assert e2e.read_bundle(archive) == (b"canonical", {})
+
+
+@pytest.mark.parametrize("wrapped_scene", ["capture/scene.json", "a/b/scene.json"])
+def test_bundle_rejects_root_and_wrapped_scene_together(tmp_path, wrapped_scene):
     archive = tmp_path / "scene.zip"
     with zipfile.ZipFile(archive, "w") as z:
         z.writestr("scene.json", b"canonical")
-        z.writestr("capture/scene.json", b"other")
-    assert e2e.read_bundle(archive)[0] == b"canonical"
+        z.writestr(wrapped_scene, b"other")
+    with pytest.raises(SystemExit, match=r"ambiguous scene\.json"):
+        e2e.read_bundle(archive)
 
 
 @pytest.mark.parametrize(
     "names",
     [
         ["old-scene.json"],
+        ["not-scene.json"],
         ["scene.json", "scene.json"],
         ["capture/scene.json", "capture/scene.json"],
         ["first/scene.json", "second/scene.json"],
         ["capture/scene.json", "other/frame.jpg"],
         ["capture/nested/scene.json"],
+        ["capture/scene.json", "other/"],
+        ["capture/scene.json", "capture"],
     ],
 )
 def test_bundle_rejects_missing_or_duplicate_canonical_scene(tmp_path, names):
@@ -632,7 +645,9 @@ def test_bundle_rejects_missing_or_duplicate_canonical_scene(tmp_path, names):
     with zipfile.ZipFile(archive, "w") as z:
         for name in names:
             z.writestr(name, b"{}")
-    with pytest.raises(SystemExit, match=r"exactly one canonical scene\.json"):
+    with pytest.raises(
+        SystemExit, match=r"exactly one canonical scene\.json|ambiguous scene\.json"
+    ):
         e2e.read_bundle(archive)
 
 

From 45645f084f53ec39e51b8ca55c869df86a7a6bd1 Mon Sep 17 00:00:00 2001
From: SamGu-NRX <sgu07966@gmail.com>
Date: Wed, 14 Oct 2026 15:23:08 -0500
Subject: [PATCH 56/62] fix(verification): cache scene geometry and bound
 metadata work

---
 verification/hsverify/e2e.py                  |   24 +-
 verification/hsverify/resultcheck.py          |  303 +-
 .../tests/fixtures/segmented-public-pass.json | 1383 +++++
 .../fixtures/segmented-public-workload.json   | 4565 +++++++++++++++++
 verification/tests/segmented_wall.py          |   27 +
 verification/tests/test_judge_scene_cache.py  |   73 +
 verification/tests/test_metadata_bounds.py    |  183 +
 verification/tests/test_runtime_meter.py      |    8 +-
 verification/tests/test_scene_cache.py        |   81 +
 9 files changed, 6590 insertions(+), 57 deletions(-)
 create mode 100644 verification/tests/fixtures/segmented-public-pass.json
 create mode 100644 verification/tests/fixtures/segmented-public-workload.json
 create mode 100644 verification/tests/segmented_wall.py
 create mode 100644 verification/tests/test_judge_scene_cache.py
 create mode 100644 verification/tests/test_metadata_bounds.py
 create mode 100644 verification/tests/test_scene_cache.py

diff --git a/verification/hsverify/e2e.py b/verification/hsverify/e2e.py
index 37406beb5..45e539244 100644
--- a/verification/hsverify/e2e.py
+++ b/verification/hsverify/e2e.py
@@ -63,10 +63,12 @@
     WorkLimitExceeded,
     WorkMeter,
     assumption_mismatches,
+    case_metadata_problems,
     comparable,
     coverage_blocks,
     expectation_problems,
     geometry_admission_problems,
+    ingestion_problems,
     invariant_problems,
     less_coverage_problems,
     mirror_scene,
@@ -501,7 +503,11 @@ def judge(
         return record | {"status": "skipped", "problems": [], "skip_reason": item.skip_reason}
     if item.hostile:
         return record | {"hostile": True} | judge_hostile(url, endpoint, item, schemas, limit)
-    input_errors = schema_errors(item.scene, schemas["scene"])
+    input_errors = (
+        case_metadata_problems(item.rules_assumed, item.expect)
+        or ingestion_problems(item.scene, "scene")
+        or schema_errors(item.scene, schemas["scene"])
+    )
     if input_errors:
         return record | {"status": "bad input", "problems": input_errors[:20]}
 
@@ -530,7 +536,12 @@ def check(name: str, function: Callable[[], list[str]]) -> list[str]:
 
     problems = check(
         "result schema",
-        lambda: [f"result schema: {e}" for e in schema_errors(result, schemas["result"])],
+        lambda: [
+            f"result schema: {e}"
+            for e in (
+                ingestion_problems(result, "result") or schema_errors(result, schemas["result"])
+            )
+        ],
     )
     if problems:
         return record | {"status": "fail", "problems": problems[:20], "contract_problems": problems}
@@ -608,6 +619,9 @@ def property_problems(
     problems: list[str] = []
 
     def resend(name: str, scene: dict) -> dict | None:
+        if admission := ingestion_problems(scene, "scene"):
+            problems.extend(f"{name}: scene ingestion: {p}" for p in admission)
+            return None
         transformed = variant(item, name, scene)
         other, failure = answer(url, endpoint, transformed)
         if failure:
@@ -615,7 +629,7 @@ def resend(name: str, scene: dict) -> dict | None:
             return None
         check_name = "result schema"
         try:
-            errors = schema_errors(other, schemas["result"])
+            errors = ingestion_problems(other, "result") or schema_errors(other, schemas["result"])
             if errors:
                 problems.append(f"{name}: result schema: {errors[0]}")
                 return None
@@ -641,7 +655,9 @@ def resend(name: str, scene: dict) -> dict | None:
     # 1. Same input, same answer.
     status, payload, _ = post(url, endpoint, item)
     again = parse_result(payload) if status == 200 else None
-    if again is None or comparable(again) != comparable(result):
+    if again is not None and (admission := ingestion_problems(again, "result")):
+        problems.extend(f"identical resend: {p}" for p in admission)
+    elif again is None or comparable(again) != comparable(result):
         problems.append("sending the same scene twice gave different results")
 
     # 2. Mirrored left to right: same decision, same amount of each outcome along the wall.
diff --git a/verification/hsverify/resultcheck.py b/verification/hsverify/resultcheck.py
index 8212ad087..8ca930ae9 100644
--- a/verification/hsverify/resultcheck.py
+++ b/verification/hsverify/resultcheck.py
@@ -52,15 +52,36 @@
 
 EPS = 1e-6
 NUMBER_TOL_FT = 1e-5
+# Geometry loops share WorkMeter. Metadata traversal, hashing, copying and interval
+# sorting are bounded separately before schema validation: 50 walls, 500 baseline
+# vertices per wall (C1's existing limits), 30,000 sweep runs, 16,000 checks and
+# 16,000 requests, 1,000,000 numeric leaves, 2,000,000 JSON nodes, depth 32, and
+# 4 MiB of string/key characters per document, and 64 case rule queries.
+# Case queries may scan the bounded response; their count is fixed. Other metadata
+# passes are linear or
+# O(n log n); geometry comparisons and samples charge the meter. These operational
+# limits retain the 30,000-run and 12,000-distinct-check regressions. They are not
+# measured scan maxima; the node/numeric limits also bound otherwise uncapped C2
+# arrays and C1's combined polygons/keyframes before recursive library traversal.
+MAX_RESULT_RUNS = 30_000
+MAX_RESULT_CHECKS = 16_000
+MAX_EVIDENCE_REQUESTS = 16_000
+MAX_NUMERIC_LEAVES = 1_000_000
+MAX_METADATA_NODES = 2_000_000
+MAX_METADATA_DEPTH = 32
+MAX_METADATA_CHARACTERS = 4 * 1024 * 1024
+MAX_SCHEMA_PROBLEMS = 100
+MAX_CASE_RULE_QUERIES = 64
 # Bound verifier work even when a server span or rules step requests billions of samples.
 MAX_SWEEP_SAMPLES = 10_000
-# On 2026-10-14, 35 public fixture judgments without contract problems, including
-# property variants, peaked at 80,788 units for pass-clear-side-wall. Another 468
-# distinct saved responses matched to current fixtures peaked at 392,115 invariant
-# units for ETH3D facade. Allow 20 times that larger recorded peak for other scans
-# and their property variants. This is an operational bound, not a calibration of
-# measurement accuracy or evidence that the samples prove physical clearance.
-MAX_WORK_SAMPLES = 20 * 392_115
+# On 2026-10-14, after caching scene derivatives and deferring ground fallback,
+# 35 valid public fixture judgments including property variants peaked at 30,913
+# units. Twenty measurements of 20 four-foot walls at 1/4/12/13/20 subdivisions,
+# original and mirrored, including full-judge resends, peaked at 87,427 units.
+# Another 468 distinct saved responses peaked at 391,700 invariant units on ETH3D
+# facade. Allow 20 times that largest measured valid workload for other scans and
+# their variants. This is an operational margin, not physical-error calibration.
+MAX_WORK_SAMPLES = 20 * 391_700
 
 
 class WorkLimitExceeded(Exception):
@@ -86,6 +107,14 @@ def charge(self, n: int = 1) -> None:
         if self.samples > self.limit:
             raise WorkLimitExceeded(self.samples)
 
+    def derived(
+        self, name: str, scene: dict, rules: RuleSet | None, build: Callable[[], Any]
+    ) -> Any:
+        key = (name, self.input_key(scene), self.input_key(rules))
+        if key not in self.cache:
+            self.cache[key] = build()
+        return self.cache[key]
+
     def input_key(self, value: Any) -> Any:
         # judge's scenes and rule sets are immutable during a response's checks. Keep the
         # source alive so a later transformed scene cannot reuse its object id.
@@ -238,9 +267,90 @@ def reach(key: str) -> Need:
         )
 
 
+def ingestion_problems(instance: Any, kind: str | None = None) -> list[str]:
+    """Bound metadata before validation or copies, using a depth-sized iterator stack."""
+    if kind is None and isinstance(instance, dict):
+        kind = "scene" if "walls" in instance else "result"
+    label = kind or "document"
+    if isinstance(instance, dict):
+        limits = (
+            {"walls": 50}
+            if kind == "scene"
+            else {
+                "sweep": MAX_RESULT_RUNS,
+                "checks": MAX_RESULT_CHECKS,
+                "missing_evidence": MAX_EVIDENCE_REQUESTS,
+            }
+        )
+        for field, limit in limits.items():
+            items = instance.get(field)
+            if isinstance(items, (list, tuple)) and len(items) > limit:
+                return [f"{label} ingestion limit exceeded: {field} exceeds {limit} entries"]
+        if kind == "scene":
+            for wall in (
+                instance.get("walls", []) if isinstance(instance.get("walls"), list) else []
+            ):
+                points = wall.get("baseline") if isinstance(wall, dict) else None
+                if isinstance(points, (list, tuple)) and len(points) > 500:
+                    return [f"{label} ingestion limit exceeded: baseline exceeds 500 vertices"]
+
+    nodes = numeric = characters = 0
+    stack = [iter((instance,))]
+    while stack:
+        try:
+            value = next(stack[-1])
+        except StopIteration:
+            stack.pop()
+            continue
+        nodes += 1
+        if nodes > MAX_METADATA_NODES:
+            return [f"{label} ingestion limit exceeded: more than {MAX_METADATA_NODES} JSON nodes"]
+        if isinstance(value, (int, float)) and not isinstance(value, bool):
+            numeric += 1
+            if numeric > MAX_NUMERIC_LEAVES:
+                return [
+                    f"{label} ingestion limit exceeded: more than "
+                    f"{MAX_NUMERIC_LEAVES} numeric leaves"
+                ]
+        elif isinstance(value, str):
+            characters += len(value)
+        elif isinstance(value, dict):
+            if len(value) > MAX_METADATA_NODES - nodes:
+                return [
+                    f"{label} ingestion limit exceeded: more than {MAX_METADATA_NODES} JSON nodes"
+                ]
+            characters += sum(len(key) for key in value if isinstance(key, str))
+            if len(stack) > MAX_METADATA_DEPTH:
+                return [f"{label} ingestion limit exceeded: nesting exceeds {MAX_METADATA_DEPTH}"]
+            stack.append(iter(value.values()))
+        elif isinstance(value, (list, tuple)):
+            if len(value) > MAX_METADATA_NODES - nodes:
+                return [
+                    f"{label} ingestion limit exceeded: more than {MAX_METADATA_NODES} JSON nodes"
+                ]
+            if len(stack) > MAX_METADATA_DEPTH:
+                return [f"{label} ingestion limit exceeded: nesting exceeds {MAX_METADATA_DEPTH}"]
+            stack.append(iter(value))
+        if characters > MAX_METADATA_CHARACTERS:
+            return [
+                f"{label} ingestion limit exceeded: strings/keys exceed "
+                f"{MAX_METADATA_CHARACTERS} characters"
+            ]
+    return []
+
+
 def schema_errors(instance: Any, schema: dict) -> list[str]:
+    properties = schema.get("properties", {})
+    kind = "scene" if "walls" in properties else "result" if "sweep" in properties else None
+    if problems := ingestion_problems(instance, kind):
+        return problems
     validator = Draft202012Validator(schema)
-    errors = sorted(validator.iter_errors(instance), key=lambda e: list(e.absolute_path))
+    # A malformed document may produce a diagnostic per node. Stop after enough
+    # diagnostics to fail it; valid documents still complete schema validation.
+    errors = sorted(
+        itertools.islice(validator.iter_errors(instance), MAX_SCHEMA_PROBLEMS),
+        key=lambda e: tuple(str(part) for part in e.absolute_path),
+    )
     return [f"{'/'.join(map(str, e.absolute_path)) or '(root)'}: {e.message}" for e in errors]
 
 
@@ -278,6 +388,9 @@ def observed(
     this category default at 6200098 (server/scene.py `observed_intervals`). None keeps the
     old reading, all the way up."""
     meter = meter if meter is not None else WorkMeter()
+    key = ("observed", meter.input_key(scene), band, min_out_ft, beyond, wall_default_ft)
+    if key in meter.cache:
+        return meter.cache[key]
     spans = []
     for entry in scene.get("coverage", {}).get("observed", []):
         meter.charge()
@@ -303,7 +416,8 @@ def observed(
             merged[-1][1] = max(merged[-1][1], b)
         else:
             merged.append([a, b])
-    return [(a, b) for a, b in merged]
+    meter.cache[key] = [(a, b) for a, b in merged]
+    return meter.cache[key]
 
 
 def covers(
@@ -522,6 +636,9 @@ def straight_pieces(
     segments joined where the next one starts at the previous one's end and continues its line,
     within a wall or across two walls that meet."""
     meter = meter if meter is not None else WorkMeter()
+    key = ("straight_pieces", meter.input_key(scene), meter.input_key(rules))
+    if key in meter.cache:
+        return meter.cache[key]
     pieces: list[list] = []  # [s0, s1, start point, end point]
     for _, s0, s1, a, b in segments_s(scene, rules, meter=meter) or []:
         meter.charge()
@@ -536,7 +653,8 @@ def straight_pieces(
                     prev[1], prev[3] = s1, b
                     continue
         pieces.append([s0, s1, a, b])
-    return [(p[0], p[1]) for p in pieces]
+    meter.cache[key] = [(p[0], p[1]) for p in pieces]
+    return meter.cache[key]
 
 
 def footprint_problems(
@@ -625,7 +743,7 @@ def spot_position_problems(
                 f"[{fx:.2f}, {fz:.2f}]"
             )
     lo, hi = spot["span_ft"]
-    plan = GroundPlan(scene, rules, meter=meter)
+    plan = ground_plan(scene, rules, meter)
     want = plan.point((lo + hi) / 2, (lo + hi) / 2, rules.depth_ft / 2)
     if want is not None and math.dist((cx, cz), want) > COLLINEAR_FT:
         problems.append(
@@ -670,7 +788,7 @@ def battery_error(
     its checks (solver.py _errors): its wall's error at its far edge from the meter, plus the
     larger of the meter's error in plan and the battery's slide along the walls (slide)."""
     meter = meter if meter is not None else WorkMeter()
-    wall = next((w for w in scene["walls"] if w["id"] == wall_id), None)
+    wall = wall_lookup(scene, meter).get(wall_id)
     if wall is None:
         raise ValueError(f"the result names wall {wall_id!r}, which the scene does not have")
     return wall_error_at(wall, rules, max(abs(lo), abs(hi))) + max(
@@ -684,7 +802,7 @@ def along_error(
     """The battery's error against spans measured along the walls: its wall's at its far edge
     plus its slide, without the meter's plan error (server 3baa338 _errors, along_err)."""
     meter = meter if meter is not None else WorkMeter()
-    wall = next(w for w in scene["walls"] if w["id"] == wall_id)
+    wall = wall_lookup(scene, meter)[wall_id]
     return wall_error_at(wall, rules, max(abs(lo), abs(hi))) + slide(
         scene, rules, lo, hi, meter=meter
     )
@@ -712,10 +830,13 @@ def slide(
     other wall between the meter and the battery's near edge, at its far end, times the same
     difference for that wall. 0 on the meter's own wall."""
     meter = meter if meter is not None else WorkMeter()
+    key = ("slide", meter.input_key(scene), meter.input_key(rules), lo, hi)
+    if key in meter.cache:
+        return meter.cache[key]
     segments = segments_s(scene, rules, meter=meter)
     if not segments:
         return 0.0
-    walls = {w["id"]: w for w in scene["walls"]}
+    walls = wall_lookup(scene, meter)
 
     def along(seg) -> Point:
         _, _, _, p, q = seg
@@ -749,6 +870,7 @@ def turn(seg) -> float:
         if b - a <= EPS:
             continue
         total += wall_error_at(walls[seg[0]], rules, max(abs(a), abs(b))) * turn(seg)
+    meter.cache[key] = total
     return total
 
 
@@ -796,7 +918,11 @@ def reach_gaps(
             error = battery_error(scene, rules, wall_id, lo, hi, meter=meter)
         reach = need.radius + error
         if need.band == "ground":
-            plan = GroundPlan(scene, rules, meter=meter) if rules.wall_join_ft is not None else None
+            plan = (
+                (lambda: ground_plan(scene, rules, meter))
+                if rules.wall_join_ft is not None
+                else None
+            )
             gap = ground_gap(scene, lo, hi, rules.depth_ft, reach, plan, meter=meter)
         elif need.band == "wall":
             a, b = required_span(lo, hi, reach)
@@ -831,17 +957,17 @@ def measured_band_gap(
     """The first stretch of [lo, hi] the facing or overhead band leaves unsettled: not observed,
     or observed short of `need` where no measurement covers it."""
     meter = meter if meter is not None else WorkMeter()
-    meter.charge(len(scene.get("coverage", {}).get("observed", [])))
-    entries = [
-        (*sorted(e["span_ft"]), reached(e))
-        for e in scene.get("coverage", {}).get("observed", [])
-        if e["band"] == band
-    ]
-    measured = [
-        tuple(sorted(m["span_ft"]))
-        for m in scene.get(MEASUREMENTS[band], [])
-        if m.get("wall_id", wall_id) == wall_id
-    ]
+    entries = band_entries(scene, band, meter)
+    measured = meter.derived(
+        f"measurements:{band}:{wall_id}",
+        scene,
+        None,
+        lambda: [
+            tuple(sorted(m["span_ft"]))
+            for m in scene.get(MEASUREMENTS[band], [])
+            if m.get("wall_id", wall_id) == wall_id
+        ],
+    )
     edges = {x for e in entries for x in e[:2]} | {x for m in measured for x in m}
     cuts = sorted({lo, hi} | {x for x in edges if lo < x < hi})
     for p, q in itertools.pairwise(cuts):
@@ -952,8 +1078,7 @@ def reported_dimension_problems(result: dict, rules: RuleSet | None) -> list[str
     for source, width in widths:
         if not finite(width) or width <= 0:
             message = f"{source} must be finite and positive"
-            if message not in problems:
-                problems.append(message)
+            problems.append(message)
     for check in result.get("checks", []):
         if check.get("rule", {}).get("key") == "route.corner_allowance_ft":
             allowance = check.get("threshold_ft")
@@ -973,7 +1098,12 @@ def reported_dimension_problems(result: dict, rules: RuleSet | None) -> list[str
                 and abs(first[field] - second[field]) > NUMBER_TOL_FT
             ):
                 problems.append(f"spot and nearest_considered {field} disagree")
-    return problems
+    return _unique_messages(problems)
+
+
+def _unique_messages(messages: list[str]) -> list[str]:
+    """Preserve diagnostic order without comparing each message to every predecessor."""
+    return list(dict.fromkeys(messages))
 
 
 def geometry_admission_problems(
@@ -981,6 +1111,8 @@ def geometry_admission_problems(
 ) -> list[str]:
     """Validate response numbers and references before geometry. Work is counted as it runs."""
     meter = meter if meter is not None else WorkMeter()
+    if problems := ingestion_problems(scene, "scene") + ingestion_problems(result, "result"):
+        return problems
     problems = reported_dimension_problems(result, rules)
 
     def numbers(value: Any, path: str) -> None:
@@ -1157,19 +1289,14 @@ def ground_gap(
     hi: float,
     depth: float,
     radius: float,
-    plan: GroundPlan | None = None,
+    plan: GroundPlan | Callable[[], GroundPlan] | None = None,
     meter: WorkMeter | None = None,
 ) -> str | None:
     """The first stretch of ground seen less far out than a battery over [lo, hi] needs (see
     coverage_problems), or None. With `plan`, ground not seen in the battery's own wall's band
     still counts where it lies in another wall's observed band in plan (GroundPlan)."""
     meter = meter if meter is not None else WorkMeter()
-    meter.charge(len(scene.get("coverage", {}).get("observed", [])))
-    entries = [
-        (*sorted(e["span_ft"]), e.get("out_ft", 0.0))
-        for e in scene.get("coverage", {}).get("observed", [])
-        if e["band"] == "ground"
-    ]
+    entries = band_entries(scene, "ground", meter)
     a, b = lo - radius, hi + radius
     cuts = sorted({a, lo, hi, b} | {x for e in entries for x in e[:2] if a < x < b})
     for p, q in itertools.pairwise(cuts):
@@ -1187,6 +1314,8 @@ def need_at(s: float) -> float:
         meter.charge(len(entries))
         seen = max((out for x, y, out in entries if x <= p + EPS and q - EPS <= y), default=None)
         if seen is None or seen + SEEN_GROWTH_FT < need:
+            if callable(plan):
+                plan = plan()
             if plan is not None and plan.covers((lo + hi) / 2, p, q, seen or 0.0, need_at):
                 continue
             where = f"ground [{p:.2f}, {q:.2f}] observed"
@@ -1241,10 +1370,11 @@ def missing_evidence_problems(
         return ["reason unobserved_area but missing_evidence is empty"]
     problems: list[str] = []
     named = {(r.get("band"), c) for r in requests for c in r.get("checks", [])}
+    requested_ids = {check for _, check in named}
     problems += [
         f"check {c} is unsure (unobserved) but no missing_evidence entry names it"
         for c in unseen
-        if not any(check == c for _, check in named)
+        if c not in requested_ids
     ]
     if rules is None or spot is None:
         return problems
@@ -1268,6 +1398,15 @@ def missing_evidence_problems(
 Point = tuple[float, float]
 
 
+def band_entries(scene: dict, band: str, meter: WorkMeter) -> list[tuple[float, float, float]]:
+    def build() -> list[tuple[float, float, float]]:
+        entries = scene.get("coverage", {}).get("observed", [])
+        meter.charge(len(entries))
+        return [(*sorted(e["span_ft"]), reached(e)) for e in entries if e["band"] == band]
+
+    return meter.derived(f"coverage_entries:{band}", scene, None, build)
+
+
 def segments_s(
     scene: dict, rules: RuleSet, meter: WorkMeter | None = None
 ) -> list[tuple[str, float, float, Point, Point]] | None:
@@ -1279,6 +1418,9 @@ def segments_s(
     sweep.wall_join_ft. Narrower, the walls meet and s skips the space (server/scene.py at
     7133283, `meets`)."""
     meter = meter if meter is not None else WorkMeter()
+    key = ("segments_s", meter.input_key(scene), meter.input_key(rules))
+    if key in meter.cache:
+        return meter.cache[key]
     if rules.wall_join_ft is None:
         raise ValueError("laying out the walls needs the rules' sweep.wall_join_ft")
     walls = scene.get("walls", [])
@@ -1309,7 +1451,26 @@ def segments_s(
         prev = (pts[-1], wall_error(wall, rules))
     if meter_s is None:
         return None
-    return [(wid, a - meter_s[1], b - meter_s[1], p, q) for wid, a, b, p, q in raw]
+    merged: list[tuple[str, float, float, Point, Point]] = []
+    # Only redundant vertices on the same straight wall are removed. Keep wall IDs,
+    # s distances and real turns, since wall errors and corner slides depend on them.
+    for wid, a, b, p, q in raw:
+        if b - a <= SERVER_EPS:
+            continue
+        if merged and merged[-1][0] == wid:
+            prev_wid, prev_a, _, start, end = merged[-1]
+            ux, uz = end[0] - start[0], end[1] - start[1]
+            vx, vz = q[0] - p[0], q[1] - p[1]
+            cross = abs(ux * vz - uz * vx)
+            if (
+                cross <= SERVER_EPS * math.hypot(ux, uz) * math.hypot(vx, vz)
+                and ux * vx + uz * vz > 0
+            ):
+                merged[-1] = (prev_wid, prev_a, b, start, q)
+                continue
+        merged.append((wid, a, b, p, q))
+    meter.cache[key] = [(wid, a - meter_s[1], b - meter_s[1], p, q) for wid, a, b, p, q in merged]
+    return meter.cache[key]
 
 
 def wall_spans_s(
@@ -1317,6 +1478,9 @@ def wall_spans_s(
 ) -> dict[str, tuple[float, float]] | None:
     """Each wall's stretch of s (see segments_s), or None without a meter wall."""
     meter = meter if meter is not None else WorkMeter()
+    key = ("wall_spans_s", meter.input_key(scene), meter.input_key(rules))
+    if key in meter.cache:
+        return meter.cache[key]
     segments = segments_s(scene, rules, meter=meter)
     if segments is None:
         return None
@@ -1325,9 +1489,18 @@ def wall_spans_s(
         meter.charge()
         lo, hi = spans.get(wid, (a, b))
         spans[wid] = (min(lo, a), max(hi, b))
+    meter.cache[key] = spans
     return spans
 
 
+def wall_lookup(scene: dict, meter: WorkMeter) -> dict[str, dict]:
+    return meter.derived("wall_lookup", scene, None, lambda: {w["id"]: w for w in scene["walls"]})
+
+
+def ground_plan(scene: dict, rules: RuleSet, meter: WorkMeter) -> GroundPlan:
+    return meter.derived("ground_plan", scene, rules, lambda: GroundPlan(scene, rules, meter=meter))
+
+
 class GroundPlan:
     """The observed ground in plan: each entry's stretch of every segment it runs along, out to
     its `out_ft` on the segment's outward side (the baseline turned 90 degrees clockwise seen
@@ -1341,18 +1514,29 @@ class GroundPlan:
     def __init__(self, scene: dict, rules: RuleSet, meter: WorkMeter | None = None) -> None:
         self.meter = meter if meter is not None else WorkMeter()
         self.segments = segments_s(scene, rules, meter=self.meter) or []
-        self.strips = []  # (origin, along, outward, from s, to s, out)
-        for e in scene.get("coverage", {}).get("observed", []):
-            self.meter.charge()
-            if e["band"] != "ground":
-                continue
-            a, b = sorted(e["span_ft"])
-            for _, s0, s1, p, q in self.segments:
+        self.scene = scene
+        self.rules = rules
+
+    @property
+    def strips(self) -> list:
+        # Direct s-coverage and spot positioning need no ground polygons. Construct
+        # these strips only when an uncovered reach actually needs the plan fallback.
+        def build() -> list:
+            strips = []  # (origin, along, outward, from s, to s, out)
+            for e in self.scene.get("coverage", {}).get("observed", []):
                 self.meter.charge()
-                if min(b, s1) - max(a, s0) > EPS and s1 - s0 > EPS:
-                    along, outward = self._frame(p, q)
-                    strip = (p, along, outward, max(a, s0) - s0, min(b, s1) - s0)
-                    self.strips.append((*strip, e.get("out_ft", 0.0)))
+                if e["band"] != "ground":
+                    continue
+                a, b = sorted(e["span_ft"])
+                for _, s0, s1, p, q in self.segments:
+                    self.meter.charge()
+                    if min(b, s1) - max(a, s0) > EPS and s1 - s0 > EPS:
+                        along, outward = self._frame(p, q)
+                        strip = (p, along, outward, max(a, s0) - s0, min(b, s1) - s0)
+                        strips.append((*strip, e.get("out_ft", 0.0)))
+            return strips
+
+        return self.meter.derived("ground_strips", self.scene, self.rules, build)
 
     @staticmethod
     def _frame(p: Point, q: Point) -> tuple[Point, Point]:
@@ -1450,10 +1634,14 @@ def chain_ends_s(
 ) -> tuple[float, float] | None:
     """s of the wall chain's left and right ends, or None without a meter wall."""
     meter = meter if meter is not None else WorkMeter()
+    key = ("chain_ends_s", meter.input_key(scene), meter.input_key(rules))
+    if key in meter.cache:
+        return meter.cache[key]
     spans = wall_spans_s(scene, rules, meter=meter)
     if spans is None:
         return None
-    return min(a for a, _ in spans.values()), max(b for _, b in spans.values())
+    meter.cache[key] = min(a for a, _ in spans.values()), max(b for _, b in spans.values())
+    return meter.cache[key]
 
 
 def declared_height_problems(
@@ -1539,9 +1727,22 @@ def with_past_ends_asked(
 # --- Case expectations -----------------------------------------------------------------------
 
 
+def case_metadata_problems(assumed: dict, expect: dict | None = None) -> list[str]:
+    """Bound local case queries too: substring expectations scan the response once each."""
+    expect = expect or {}
+    queries = len(assumed) + sum(
+        len(expect.get(field, [])) for field in ("sweep_runs", "checks", "start_outcomes")
+    )
+    if queries > MAX_CASE_RULE_QUERIES:
+        return [f"case ingestion limit exceeded: more than {MAX_CASE_RULE_QUERIES} rule queries"]
+    return ingestion_problems({"assumed": assumed, "expect": expect}, "case")
+
+
 def assumption_mismatches(
     assumed: dict[str, float], result: dict, rules: RuleSet | None = None
 ) -> list[str]:
+    if problems := case_metadata_problems(assumed):
+        return problems
     out = []
     configured = (
         {"battery_width": rules.width_ft, "corner_allowance": rules.corner_allowance_ft}
@@ -1564,6 +1765,8 @@ def assumption_mismatches(
 
 
 def expectation_problems(expect: dict, result: dict, meter: WorkMeter | None = None) -> list[str]:
+    if admission := case_metadata_problems({}, expect):
+        return admission
     problems: list[str] = []
     decision = result["decision"]
     if "decision_in" in expect and decision not in expect["decision_in"]:
diff --git a/verification/tests/fixtures/segmented-public-pass.json b/verification/tests/fixtures/segmented-public-pass.json
new file mode 100644
index 000000000..4190d2822
--- /dev/null
+++ b/verification/tests/fixtures/segmented-public-pass.json
@@ -0,0 +1,1383 @@
+{
+  "scene": {
+    "meter": {
+      "pos": [
+        0,
+        4,
+        0
+      ],
+      "wall_id": "w11",
+      "plus_minus_ft": 0
+    },
+    "walls": [
+      {
+        "id": "w1",
+        "baseline": [
+          [
+            -40.0,
+            0
+          ],
+          [
+            -36.0,
+            0
+          ]
+        ],
+        "height_ft": 9
+      },
+      {
+        "id": "w2",
+        "baseline": [
+          [
+            -36.0,
+            0
+          ],
+          [
+            -32.0,
+            0
+          ]
+        ],
+        "height_ft": 9
+      },
+      {
+        "id": "w3",
+        "baseline": [
+          [
+            -32.0,
+            0
+          ],
+          [
+            -28.0,
+            0
+          ]
+        ],
+        "height_ft": 9
+      },
+      {
+        "id": "w4",
+        "baseline": [
+          [
+            -28.0,
+            0
+          ],
+          [
+            -24.0,
+            0
+          ]
+        ],
+        "height_ft": 9
+      },
+      {
+        "id": "w5",
+        "baseline": [
+          [
+            -24.0,
+            0
+          ],
+          [
+            -20.0,
+            0
+          ]
+        ],
+        "height_ft": 9
+      },
+      {
+        "id": "w6",
+        "baseline": [
+          [
+            -20.0,
+            0
+          ],
+          [
+            -16.0,
+            0
+          ]
+        ],
+        "height_ft": 9
+      },
+      {
+        "id": "w7",
+        "baseline": [
+          [
+            -16.0,
+            0
+          ],
+          [
+            -12.0,
+            0
+          ]
+        ],
+        "height_ft": 9
+      },
+      {
+        "id": "w8",
+        "baseline": [
+          [
+            -12.0,
+            0
+          ],
+          [
+            -8.0,
+            0
+          ]
+        ],
+        "height_ft": 9
+      },
+      {
+        "id": "w9",
+        "baseline": [
+          [
+            -8.0,
+            0
+          ],
+          [
+            -4.0,
+            0
+          ]
+        ],
+        "height_ft": 9
+      },
+      {
+        "id": "w10",
+        "baseline": [
+          [
+            -4.0,
+            0
+          ],
+          [
+            0.0,
+            0
+          ]
+        ],
+        "height_ft": 9
+      },
+      {
+        "id": "w11",
+        "baseline": [
+          [
+            0.0,
+            0
+          ],
+          [
+            4.0,
+            0
+          ]
+        ],
+        "height_ft": 9
+      },
+      {
+        "id": "w12",
+        "baseline": [
+          [
+            4.0,
+            0
+          ],
+          [
+            8.0,
+            0
+          ]
+        ],
+        "height_ft": 9
+      },
+      {
+        "id": "w13",
+        "baseline": [
+          [
+            8.0,
+            0
+          ],
+          [
+            12.0,
+            0
+          ]
+        ],
+        "height_ft": 9
+      },
+      {
+        "id": "w14",
+        "baseline": [
+          [
+            12.0,
+            0
+          ],
+          [
+            16.0,
+            0
+          ]
+        ],
+        "height_ft": 9
+      },
+      {
+        "id": "w15",
+        "baseline": [
+          [
+            16.0,
+            0
+          ],
+          [
+            20.0,
+            0
+          ]
+        ],
+        "height_ft": 9
+      },
+      {
+        "id": "w16",
+        "baseline": [
+          [
+            20.0,
+            0
+          ],
+          [
+            24.0,
+            0
+          ]
+        ],
+        "height_ft": 9
+      },
+      {
+        "id": "w17",
+        "baseline": [
+          [
+            24.0,
+            0
+          ],
+          [
+            28.0,
+            0
+          ]
+        ],
+        "height_ft": 9
+      },
+      {
+        "id": "w18",
+        "baseline": [
+          [
+            28.0,
+            0
+          ],
+          [
+            32.0,
+            0
+          ]
+        ],
+        "height_ft": 9
+      },
+      {
+        "id": "w19",
+        "baseline": [
+          [
+            32.0,
+            0
+          ],
+          [
+            36.0,
+            0
+          ]
+        ],
+        "height_ft": 9
+      },
+      {
+        "id": "w20",
+        "baseline": [
+          [
+            36.0,
+            0
+          ],
+          [
+            40.0,
+            0
+          ]
+        ],
+        "height_ft": 9
+      }
+    ],
+    "objects": [],
+    "ground": [
+      {
+        "type": "concrete",
+        "polygon": [
+          [
+            -40,
+            0
+          ],
+          [
+            40,
+            0
+          ],
+          [
+            40,
+            30
+          ],
+          [
+            -40,
+            30
+          ]
+        ],
+        "plus_minus_ft": 0
+      }
+    ],
+    "overheads": [
+      {
+        "wall_id": "w1",
+        "span_ft": [
+          -40,
+          -36
+        ],
+        "clearance_ft": 9,
+        "plus_minus_ft": 0
+      },
+      {
+        "wall_id": "w2",
+        "span_ft": [
+          -36,
+          -32
+        ],
+        "clearance_ft": 9,
+        "plus_minus_ft": 0
+      },
+      {
+        "wall_id": "w3",
+        "span_ft": [
+          -32,
+          -28
+        ],
+        "clearance_ft": 9,
+        "plus_minus_ft": 0
+      },
+      {
+        "wall_id": "w4",
+        "span_ft": [
+          -28,
+          -24
+        ],
+        "clearance_ft": 9,
+        "plus_minus_ft": 0
+      },
+      {
+        "wall_id": "w5",
+        "span_ft": [
+          -24,
+          -20
+        ],
+        "clearance_ft": 9,
+        "plus_minus_ft": 0
+      },
+      {
+        "wall_id": "w6",
+        "span_ft": [
+          -20,
+          -16
+        ],
+        "clearance_ft": 9,
+        "plus_minus_ft": 0
+      },
+      {
+        "wall_id": "w7",
+        "span_ft": [
+          -16,
+          -12
+        ],
+        "clearance_ft": 9,
+        "plus_minus_ft": 0
+      },
+      {
+        "wall_id": "w8",
+        "span_ft": [
+          -12,
+          -8
+        ],
+        "clearance_ft": 9,
+        "plus_minus_ft": 0
+      },
+      {
+        "wall_id": "w9",
+        "span_ft": [
+          -8,
+          -4
+        ],
+        "clearance_ft": 9,
+        "plus_minus_ft": 0
+      },
+      {
+        "wall_id": "w10",
+        "span_ft": [
+          -4,
+          0
+        ],
+        "clearance_ft": 9,
+        "plus_minus_ft": 0
+      },
+      {
+        "wall_id": "w11",
+        "span_ft": [
+          0,
+          4
+        ],
+        "clearance_ft": 9,
+        "plus_minus_ft": 0
+      },
+      {
+        "wall_id": "w12",
+        "span_ft": [
+          4,
+          8
+        ],
+        "clearance_ft": 9,
+        "plus_minus_ft": 0
+      },
+      {
+        "wall_id": "w13",
+        "span_ft": [
+          8,
+          12
+        ],
+        "clearance_ft": 9,
+        "plus_minus_ft": 0
+      },
+      {
+        "wall_id": "w14",
+        "span_ft": [
+          12,
+          16
+        ],
+        "clearance_ft": 9,
+        "plus_minus_ft": 0
+      },
+      {
+        "wall_id": "w15",
+        "span_ft": [
+          16,
+          20
+        ],
+        "clearance_ft": 9,
+        "plus_minus_ft": 0
+      },
+      {
+        "wall_id": "w16",
+        "span_ft": [
+          20,
+          24
+        ],
+        "clearance_ft": 9,
+        "plus_minus_ft": 0
+      },
+      {
+        "wall_id": "w17",
+        "span_ft": [
+          24,
+          28
+        ],
+        "clearance_ft": 9,
+        "plus_minus_ft": 0
+      },
+      {
+        "wall_id": "w18",
+        "span_ft": [
+          28,
+          32
+        ],
+        "clearance_ft": 9,
+        "plus_minus_ft": 0
+      },
+      {
+        "wall_id": "w19",
+        "span_ft": [
+          32,
+          36
+        ],
+        "clearance_ft": 9,
+        "plus_minus_ft": 0
+      },
+      {
+        "wall_id": "w20",
+        "span_ft": [
+          36,
+          40
+        ],
+        "clearance_ft": 9,
+        "plus_minus_ft": 0
+      }
+    ],
+    "facing": [
+      {
+        "wall_id": "w1",
+        "span_ft": [
+          -40,
+          -36
+        ],
+        "depth_ft": 9,
+        "plus_minus_ft": 0
+      },
+      {
+        "wall_id": "w2",
+        "span_ft": [
+          -36,
+          -32
+        ],
+        "depth_ft": 9,
+        "plus_minus_ft": 0
+      },
+      {
+        "wall_id": "w3",
+        "span_ft": [
+          -32,
+          -28
+        ],
+        "depth_ft": 9,
+        "plus_minus_ft": 0
+      },
+      {
+        "wall_id": "w4",
+        "span_ft": [
+          -28,
+          -24
+        ],
+        "depth_ft": 9,
+        "plus_minus_ft": 0
+      },
+      {
+        "wall_id": "w5",
+        "span_ft": [
+          -24,
+          -20
+        ],
+        "depth_ft": 9,
+        "plus_minus_ft": 0
+      },
+      {
+        "wall_id": "w6",
+        "span_ft": [
+          -20,
+          -16
+        ],
+        "depth_ft": 9,
+        "plus_minus_ft": 0
+      },
+      {
+        "wall_id": "w7",
+        "span_ft": [
+          -16,
+          -12
+        ],
+        "depth_ft": 9,
+        "plus_minus_ft": 0
+      },
+      {
+        "wall_id": "w8",
+        "span_ft": [
+          -12,
+          -8
+        ],
+        "depth_ft": 9,
+        "plus_minus_ft": 0
+      },
+      {
+        "wall_id": "w9",
+        "span_ft": [
+          -8,
+          -4
+        ],
+        "depth_ft": 9,
+        "plus_minus_ft": 0
+      },
+      {
+        "wall_id": "w10",
+        "span_ft": [
+          -4,
+          0
+        ],
+        "depth_ft": 9,
+        "plus_minus_ft": 0
+      },
+      {
+        "wall_id": "w11",
+        "span_ft": [
+          0,
+          4
+        ],
+        "depth_ft": 9,
+        "plus_minus_ft": 0
+      },
+      {
+        "wall_id": "w12",
+        "span_ft": [
+          4,
+          8
+        ],
+        "depth_ft": 9,
+        "plus_minus_ft": 0
+      },
+      {
+        "wall_id": "w13",
+        "span_ft": [
+          8,
+          12
+        ],
+        "depth_ft": 9,
+        "plus_minus_ft": 0
+      },
+      {
+        "wall_id": "w14",
+        "span_ft": [
+          12,
+          16
+        ],
+        "depth_ft": 9,
+        "plus_minus_ft": 0
+      },
+      {
+        "wall_id": "w15",
+        "span_ft": [
+          16,
+          20
+        ],
+        "depth_ft": 9,
+        "plus_minus_ft": 0
+      },
+      {
+        "wall_id": "w16",
+        "span_ft": [
+          20,
+          24
+        ],
+        "depth_ft": 9,
+        "plus_minus_ft": 0
+      },
+      {
+        "wall_id": "w17",
+        "span_ft": [
+          24,
+          28
+        ],
+        "depth_ft": 9,
+        "plus_minus_ft": 0
+      },
+      {
+        "wall_id": "w18",
+        "span_ft": [
+          28,
+          32
+        ],
+        "depth_ft": 9,
+        "plus_minus_ft": 0
+      },
+      {
+        "wall_id": "w19",
+        "span_ft": [
+          32,
+          36
+        ],
+        "depth_ft": 9,
+        "plus_minus_ft": 0
+      },
+      {
+        "wall_id": "w20",
+        "span_ft": [
+          36,
+          40
+        ],
+        "depth_ft": 9,
+        "plus_minus_ft": 0
+      }
+    ],
+    "coverage": {
+      "ends": {
+        "left": {
+          "kind": "limit"
+        },
+        "right": {
+          "kind": "limit"
+        }
+      },
+      "observed": [
+        {
+          "band": "wall",
+          "span_ft": [
+            -40,
+            40
+          ]
+        },
+        {
+          "band": "ground",
+          "span_ft": [
+            -40,
+            40
+          ],
+          "out_ft": 30
+        },
+        {
+          "band": "overhead",
+          "span_ft": [
+            -40,
+            40
+          ]
+        },
+        {
+          "band": "facing",
+          "span_ft": [
+            -40,
+            40
+          ]
+        }
+      ]
+    }
+  },
+  "result": {
+    "schema_version": "1.0",
+    "decision": "pass",
+    "summary": "The battery fits 3 ft 8 in left of the meter with a 2 ft 4 in cable run: every check passes. Demo rules: public values and placeholders (pool 10 ft, drive 5 ft), not Base's.",
+    "reasons": [
+      {
+        "code": "all_checks_pass",
+        "message": "A fully observed spot passes every check."
+      }
+    ],
+    "policy": {
+      "id": "demo",
+      "version": "2026-09-26",
+      "auto_approve": true,
+      "sources": [
+        "public"
+      ],
+      "rules_sha256": "0df93f73b7c3176d33411888638189544a0848ffb51803219ab662a7ca51db66",
+      "notice": "Demo rules: public values and placeholders (pool 10 ft, drive 5 ft), not Base's."
+    },
+    "spot": {
+      "outcome": "pass",
+      "wall_id": "w10",
+      "segment": 0,
+      "span_ft": [
+        -4.958333,
+        -2.375
+      ],
+      "width_ft": 2.583333,
+      "depth_ft": 1.833333,
+      "height_ft": 3.291667,
+      "footprint": [
+        [
+          -4.958333,
+          0.0
+        ],
+        [
+          -2.375,
+          0.0
+        ],
+        [
+          -2.375,
+          1.833333
+        ],
+        [
+          -4.958333,
+          1.833333
+        ]
+      ],
+      "center": [
+        -3.666667,
+        0.916667
+      ],
+      "along": [
+        1.0,
+        0.0
+      ],
+      "outward": [
+        -0.0,
+        1.0
+      ],
+      "meter_offset_ft": [
+        -3.666667,
+        0.916667
+      ],
+      "route_length_ft": 2.375
+    },
+    "route": {
+      "outcome": "pass",
+      "length_ft": 2.375,
+      "plus_minus_ft": 1.093333,
+      "height_ft": 1.0,
+      "polyline": [
+        [
+          0.0,
+          0.0
+        ],
+        [
+          -2.375,
+          0.0
+        ]
+      ],
+      "detours": [],
+      "crossings": []
+    },
+    "checks": [
+      {
+        "id": "wall_backing",
+        "label": "Flush against one straight wall",
+        "outcome": "pass",
+        "reason": "The whole footprint backs onto one straight, observed wall segment.",
+        "measured_ft": null,
+        "plus_minus_ft": null,
+        "threshold_ft": null,
+        "comparison": null,
+        "subject": null,
+        "rule": {
+          "key": "battery.width_ft",
+          "source": "Base Core spec: 30.68 in wide, rounded up to 31 in (docs/04, What Base does today)",
+          "placeholder": false
+        }
+      },
+      {
+        "id": "ground_surface",
+        "label": "Ground under the battery",
+        "outcome": "pass",
+        "reason": "The whole footprint stands on an allowed surface.",
+        "measured_ft": null,
+        "plus_minus_ft": null,
+        "threshold_ft": null,
+        "comparison": null,
+        "subject": null,
+        "rule": {
+          "key": "ground.allowed",
+          "source": "Ground types from schemas/scene.schema.json; which surfaces are allowed is a demo choice",
+          "placeholder": true
+        }
+      },
+      {
+        "id": "meter_working_space",
+        "label": "Clear of the meter's working space",
+        "outcome": "pass",
+        "reason": "The battery is 1 ft 1 in clear of the meter's 2 ft 6 in wide by 3 ft 0 in deep working space.",
+        "measured_ft": 1.125,
+        "plus_minus_ft": 1.093333,
+        "threshold_ft": 0.0,
+        "comparison": "at_least",
+        "subject": "meter",
+        "rule": {
+          "key": "meter_working_space.width_ft",
+          "source": "NEC 110.26(A)(2): 30 in wide working space",
+          "placeholder": false
+        }
+      },
+      {
+        "id": "gas_clearance",
+        "label": "Distance from gas equipment",
+        "outcome": "pass",
+        "reason": "No gas meter or pipe within 3 ft 0 in of the battery, and that whole area was seen.",
+        "measured_ft": null,
+        "plus_minus_ft": null,
+        "threshold_ft": 3.0,
+        "comparison": "at_least",
+        "subject": null,
+        "rule": {
+          "key": "clearances.gas_ft",
+          "source": "Base help page: 3 ft from the gas meter; Austin Energy \u00a71.9; Texas Gas Service",
+          "placeholder": false
+        }
+      },
+      {
+        "id": "ac_clearance",
+        "label": "Distance from AC units",
+        "outcome": "pass",
+        "reason": "No AC unit within 3 ft 0 in of the battery, and that whole area was seen.",
+        "measured_ft": null,
+        "plus_minus_ft": null,
+        "threshold_ft": 3.0,
+        "comparison": "at_least",
+        "subject": null,
+        "rule": {
+          "key": "clearances.ac_ft",
+          "source": "Base help page: 3 ft from AC units, fences and other batteries",
+          "placeholder": false
+        }
+      },
+      {
+        "id": "drive_clearance",
+        "label": "Distance from the driveway",
+        "outcome": "pass",
+        "reason": "No drivable surface within 5 ft 0 in of the battery, and that whole area was seen.",
+        "measured_ft": null,
+        "plus_minus_ft": null,
+        "threshold_ft": 5.0,
+        "comparison": "at_least",
+        "subject": null,
+        "rule": {
+          "key": "clearances.drive_ft",
+          "source": "No public value (docs/04, Public rule values)",
+          "placeholder": true
+        }
+      },
+      {
+        "id": "pool_clearance",
+        "label": "Distance from a pool",
+        "outcome": "pass",
+        "reason": "No pool within 10 ft 0 in of the battery, and that whole area was seen.",
+        "measured_ft": null,
+        "plus_minus_ft": null,
+        "threshold_ft": 10.0,
+        "comparison": "at_least",
+        "subject": null,
+        "rule": {
+          "key": "clearances.pool_ft",
+          "source": "No public value (docs/04, Public rule values)",
+          "placeholder": true
+        }
+      },
+      {
+        "id": "opening_clearance",
+        "label": "Distance from doors and windows",
+        "outcome": "pass",
+        "reason": "No door or window within 3 ft 0 in of the battery, and that whole area was seen.",
+        "measured_ft": null,
+        "plus_minus_ft": null,
+        "threshold_ft": 3.0,
+        "comparison": "at_least",
+        "subject": null,
+        "rule": {
+          "key": "clearances.opening_ft",
+          "source": "IRC 2021 R328.4: 3 ft from doors and windows directly entering the dwelling. Applying it to garage doors (openings.types) is a demo choice the code does not require",
+          "placeholder": false
+        }
+      },
+      {
+        "id": "wall_equipment_above",
+        "label": "No box or vent above the battery",
+        "outcome": "pass",
+        "reason": "Nothing is mounted on the wall above the battery.",
+        "measured_ft": null,
+        "plus_minus_ft": null,
+        "threshold_ft": 0.0,
+        "comparison": "at_least",
+        "subject": null,
+        "rule": {
+          "key": "clearances.wall_equipment_ft",
+          "source": "No public value; 0 means only overlap fails",
+          "placeholder": true
+        }
+      },
+      {
+        "id": "facing_gap",
+        "label": "Open space in front",
+        "outcome": "pass",
+        "reason": "The gap in front of the battery is 7 ft 2 in (\u00b1 0 ft 0 in), clear of the 3 ft 0 in rule.",
+        "measured_ft": 7.166667,
+        "plus_minus_ft": 0.0,
+        "threshold_ft": 3.0,
+        "comparison": "at_least",
+        "subject": "facing[8]",
+        "rule": {
+          "key": "facing.min_ft",
+          "source": "Base help page: 3 ft from fences",
+          "placeholder": false
+        }
+      },
+      {
+        "id": "headroom",
+        "label": "Headroom above",
+        "outcome": "pass",
+        "reason": "The headroom is 9 ft 0 in (\u00b1 0 ft 0 in), clear of the 6 ft 6 in rule.",
+        "measured_ft": 9.0,
+        "plus_minus_ft": 0.0,
+        "threshold_ft": 6.5,
+        "comparison": "at_least",
+        "subject": "overheads[8]",
+        "rule": {
+          "key": "headroom.min_ft",
+          "source": "NEC 110.26(A)(3) working-space headroom, applied to the battery as a demo choice",
+          "placeholder": true
+        }
+      },
+      {
+        "id": "route_path",
+        "label": "Cable route along the wall",
+        "outcome": "pass",
+        "reason": "The cable runs along continuous, observed wall with nothing blocking it.",
+        "measured_ft": null,
+        "plus_minus_ft": null,
+        "threshold_ft": null,
+        "comparison": null,
+        "subject": null,
+        "rule": {
+          "key": "route.crossing",
+          "source": "Demo rule: the cable can't cross a door, a garage or a stretch with no wall",
+          "placeholder": false
+        }
+      },
+      {
+        "id": "route_length",
+        "label": "Cable run length",
+        "outcome": "pass",
+        "reason": "The cable run is 2 ft 4 in (\u00b1 1 ft 1 in), within the 15 ft 0 in confident reach.",
+        "measured_ft": 2.375,
+        "plus_minus_ft": 1.093333,
+        "threshold_ft": 20.0,
+        "comparison": "at_most",
+        "subject": null,
+        "rule": {
+          "key": "route.max_ft",
+          "source": "Base help page: within 20 ft of the meter. Review past 15 ft 0 in: No public value",
+          "placeholder": true
+        },
+        "review_threshold_ft": 15.0
+      }
+    ],
+    "nearest_considered": null,
+    "missing_evidence": [],
+    "objects_not_used": [],
+    "ends": {
+      "left": {
+        "kind": "limit",
+        "s_ft": -40.0,
+        "point": [
+          -40.0,
+          0.0
+        ],
+        "beyond_reach": true
+      },
+      "right": {
+        "kind": "limit",
+        "s_ft": 40.0,
+        "point": [
+          40.0,
+          0.0
+        ],
+        "beyond_reach": true
+      }
+    },
+    "sweep": [
+      {
+        "wall_id": "w1",
+        "segment": 0,
+        "start_ft": [
+          -40.0,
+          -27.242064
+        ],
+        "outcome": "fail",
+        "failing": [
+          "route_length"
+        ],
+        "unsure": []
+      },
+      {
+        "wall_id": "w4",
+        "segment": 0,
+        "start_ft": [
+          -27.242064,
+          -27.242064
+        ],
+        "outcome": "fail",
+        "failing": [
+          "route_length"
+        ],
+        "unsure": [
+          "pool_clearance"
+        ]
+      },
+      {
+        "wall_id": "w4",
+        "segment": 0,
+        "start_ft": [
+          -27.183532,
+          -25.625
+        ],
+        "outcome": "unsure",
+        "failing": [],
+        "unsure": [
+          "pool_clearance",
+          "route_length"
+        ]
+      },
+      {
+        "wall_id": "w4",
+        "segment": 0,
+        "start_ft": [
+          -25.541667,
+          -25.291667
+        ],
+        "outcome": "unsure",
+        "failing": [],
+        "unsure": [
+          "route_length"
+        ]
+      },
+      {
+        "wall_id": "w5",
+        "segment": 0,
+        "start_ft": [
+          -25.208333,
+          -21.291667
+        ],
+        "outcome": "unsure",
+        "failing": [],
+        "unsure": [
+          "route_length"
+        ]
+      },
+      {
+        "wall_id": "w6",
+        "segment": 0,
+        "start_ft": [
+          -21.208333,
+          -17.291667
+        ],
+        "outcome": "unsure",
+        "failing": [],
+        "unsure": [
+          "route_length"
+        ]
+      },
+      {
+        "wall_id": "w7",
+        "segment": 0,
+        "start_ft": [
+          -17.208333,
+          -14.958333
+        ],
+        "outcome": "unsure",
+        "failing": [],
+        "unsure": [
+          "route_length"
+        ]
+      },
+      {
+        "wall_id": "w7",
+        "segment": 0,
+        "start_ft": [
+          -14.875,
+          -13.291667
+        ],
+        "outcome": "pass",
+        "failing": [],
+        "unsure": []
+      },
+      {
+        "wall_id": "w8",
+        "segment": 0,
+        "start_ft": [
+          -13.208333,
+          -9.291667
+        ],
+        "outcome": "pass",
+        "failing": [],
+        "unsure": []
+      },
+      {
+        "wall_id": "w9",
+        "segment": 0,
+        "start_ft": [
+          -9.208333,
+          -5.291667
+        ],
+        "outcome": "pass",
+        "failing": [],
+        "unsure": []
+      },
+      {
+        "wall_id": "w10",
+        "segment": 0,
+        "start_ft": [
+          -5.208333,
+          -4.958333
+        ],
+        "outcome": "pass",
+        "failing": [],
+        "unsure": []
+      },
+      {
+        "wall_id": "w10",
+        "segment": 0,
+        "start_ft": [
+          -4.875,
+          -3.125
+        ],
+        "outcome": "unsure",
+        "failing": [],
+        "unsure": [
+          "meter_working_space"
+        ]
+      },
+      {
+        "wall_id": "w10",
+        "segment": 0,
+        "start_ft": [
+          -3.041667,
+          -1.291667
+        ],
+        "outcome": "fail",
+        "failing": [
+          "meter_working_space"
+        ],
+        "unsure": []
+      },
+      {
+        "wall_id": "w11",
+        "segment": 0,
+        "start_ft": [
+          -1.270833,
+          0.458333
+        ],
+        "outcome": "fail",
+        "failing": [
+          "meter_working_space"
+        ],
+        "unsure": []
+      },
+      {
+        "wall_id": "w11",
+        "segment": 0,
+        "start_ft": [
+          0.541667,
+          2.291667
+        ],
+        "outcome": "unsure",
+        "failing": [],
+        "unsure": [
+          "meter_working_space"
+        ]
+      },
+      {
+        "wall_id": "w11",
+        "segment": 0,
+        "start_ft": [
+          2.375,
+          2.708333
+        ],
+        "outcome": "pass",
+        "failing": [],
+        "unsure": []
+      },
+      {
+        "wall_id": "w12",
+        "segment": 0,
+        "start_ft": [
+          2.791667,
+          6.708333
+        ],
+        "outcome": "pass",
+        "failing": [],
+        "unsure": []
+      },
+      {
+        "wall_id": "w13",
+        "segment": 0,
+        "start_ft": [
+          6.791667,
+          10.708333
+        ],
+        "outcome": "pass",
+        "failing": [],
+        "unsure": []
+      },
+      {
+        "wall_id": "w14",
+        "segment": 0,
+        "start_ft": [
+          10.791667,
+          12.291667
+        ],
+        "outcome": "pass",
+        "failing": [],
+        "unsure": []
+      },
+      {
+        "wall_id": "w14",
+        "segment": 0,
+        "start_ft": [
+          12.375,
+          14.708333
+        ],
+        "outcome": "unsure",
+        "failing": [],
+        "unsure": [
+          "route_length"
+        ]
+      },
+      {
+        "wall_id": "w15",
+        "segment": 0,
+        "start_ft": [
+          14.791667,
+          18.708333
+        ],
+        "outcome": "unsure",
+        "failing": [],
+        "unsure": [
+          "route_length"
+        ]
+      },
+      {
+        "wall_id": "w16",
+        "segment": 0,
+        "start_ft": [
+          18.791667,
+          22.708333
+        ],
+        "outcome": "unsure",
+        "failing": [],
+        "unsure": [
+          "route_length"
+        ]
+      },
+      {
+        "wall_id": "w17",
+        "segment": 0,
+        "start_ft": [
+          22.791667,
+          22.958333
+        ],
+        "outcome": "unsure",
+        "failing": [],
+        "unsure": [
+          "route_length"
+        ]
+      },
+      {
+        "wall_id": "w17",
+        "segment": 0,
+        "start_ft": [
+          23.041667,
+          24.600198
+        ],
+        "outcome": "unsure",
+        "failing": [],
+        "unsure": [
+          "pool_clearance",
+          "route_length"
+        ]
+      },
+      {
+        "wall_id": "w17",
+        "segment": 0,
+        "start_ft": [
+          24.65873,
+          24.658731
+        ],
+        "outcome": "fail",
+        "failing": [
+          "route_length"
+        ],
+        "unsure": [
+          "pool_clearance"
+        ]
+      },
+      {
+        "wall_id": "w1",
+        "segment": 0,
+        "start_ft": [
+          24.658731,
+          37.416667
+        ],
+        "outcome": "fail",
+        "failing": [
+          "route_length"
+        ],
+        "unsure": []
+      }
+    ],
+    "stats": {
+      "candidates": 815,
+      "pass": 312,
+      "unsure": 444,
+      "fail": 59,
+      "elapsed_ms": 0,
+      "input_sha256": "429ef7a1eeb84485c6d19036bfb71a589501b08206fb9a5a34c1458f5a8791cf"
+    }
+  }
+}
diff --git a/verification/tests/fixtures/segmented-public-workload.json b/verification/tests/fixtures/segmented-public-workload.json
new file mode 100644
index 000000000..467ae56ab
--- /dev/null
+++ b/verification/tests/fixtures/segmented-public-workload.json
@@ -0,0 +1,4565 @@
+{
+  "surveyed wall": {
+    "schema_version": "1.0",
+    "decision": "pass",
+    "summary": "The battery fits 3 ft 8 in left of the meter with a 2 ft 4 in cable run: every check passes. Demo rules: public values and placeholders (pool 10 ft, drive 5 ft), not Base's.",
+    "reasons": [
+      {
+        "code": "all_checks_pass",
+        "message": "A fully observed spot passes every check."
+      }
+    ],
+    "policy": {
+      "id": "demo",
+      "version": "2026-09-26",
+      "auto_approve": true,
+      "sources": [
+        "public"
+      ],
+      "rules_sha256": "0df93f73b7c3176d33411888638189544a0848ffb51803219ab662a7ca51db66",
+      "notice": "Demo rules: public values and placeholders (pool 10 ft, drive 5 ft), not Base's."
+    },
+    "spot": {
+      "outcome": "pass",
+      "wall_id": "w10",
+      "segment": 0,
+      "span_ft": [
+        -4.958333,
+        -2.375
+      ],
+      "width_ft": 2.583333,
+      "depth_ft": 1.833333,
+      "height_ft": 3.291667,
+      "footprint": [
+        [
+          -4.958333,
+          0.0
+        ],
+        [
+          -2.375,
+          0.0
+        ],
+        [
+          -2.375,
+          1.833333
+        ],
+        [
+          -4.958333,
+          1.833333
+        ]
+      ],
+      "center": [
+        -3.666667,
+        0.916667
+      ],
+      "along": [
+        1.0,
+        0.0
+      ],
+      "outward": [
+        -0.0,
+        1.0
+      ],
+      "meter_offset_ft": [
+        -3.666667,
+        0.916667
+      ],
+      "route_length_ft": 2.375
+    },
+    "route": {
+      "outcome": "pass",
+      "length_ft": 2.375,
+      "plus_minus_ft": 1.093333,
+      "height_ft": 1.0,
+      "polyline": [
+        [
+          0.0,
+          0.0
+        ],
+        [
+          -2.375,
+          0.0
+        ]
+      ],
+      "detours": [],
+      "crossings": []
+    },
+    "checks": [
+      {
+        "id": "wall_backing",
+        "label": "Flush against one straight wall",
+        "outcome": "pass",
+        "reason": "The whole footprint backs onto one straight, observed wall segment.",
+        "measured_ft": null,
+        "plus_minus_ft": null,
+        "threshold_ft": null,
+        "comparison": null,
+        "subject": null,
+        "rule": {
+          "key": "battery.width_ft",
+          "source": "Base Core spec: 30.68 in wide, rounded up to 31 in (docs/04, What Base does today)",
+          "placeholder": false
+        }
+      },
+      {
+        "id": "ground_surface",
+        "label": "Ground under the battery",
+        "outcome": "pass",
+        "reason": "The whole footprint stands on an allowed surface.",
+        "measured_ft": null,
+        "plus_minus_ft": null,
+        "threshold_ft": null,
+        "comparison": null,
+        "subject": null,
+        "rule": {
+          "key": "ground.allowed",
+          "source": "Ground types from schemas/scene.schema.json; which surfaces are allowed is a demo choice",
+          "placeholder": true
+        }
+      },
+      {
+        "id": "meter_working_space",
+        "label": "Clear of the meter's working space",
+        "outcome": "pass",
+        "reason": "The battery is 1 ft 1 in clear of the meter's 2 ft 6 in wide by 3 ft 0 in deep working space.",
+        "measured_ft": 1.125,
+        "plus_minus_ft": 1.093333,
+        "threshold_ft": 0.0,
+        "comparison": "at_least",
+        "subject": "meter",
+        "rule": {
+          "key": "meter_working_space.width_ft",
+          "source": "NEC 110.26(A)(2): 30 in wide working space",
+          "placeholder": false
+        }
+      },
+      {
+        "id": "gas_clearance",
+        "label": "Distance from gas equipment",
+        "outcome": "pass",
+        "reason": "No gas meter or pipe within 3 ft 0 in of the battery, and that whole area was seen.",
+        "measured_ft": null,
+        "plus_minus_ft": null,
+        "threshold_ft": 3.0,
+        "comparison": "at_least",
+        "subject": null,
+        "rule": {
+          "key": "clearances.gas_ft",
+          "source": "Base help page: 3 ft from the gas meter; Austin Energy \u00a71.9; Texas Gas Service",
+          "placeholder": false
+        }
+      },
+      {
+        "id": "ac_clearance",
+        "label": "Distance from AC units",
+        "outcome": "pass",
+        "reason": "No AC unit within 3 ft 0 in of the battery, and that whole area was seen.",
+        "measured_ft": null,
+        "plus_minus_ft": null,
+        "threshold_ft": 3.0,
+        "comparison": "at_least",
+        "subject": null,
+        "rule": {
+          "key": "clearances.ac_ft",
+          "source": "Base help page: 3 ft from AC units, fences and other batteries",
+          "placeholder": false
+        }
+      },
+      {
+        "id": "drive_clearance",
+        "label": "Distance from the driveway",
+        "outcome": "pass",
+        "reason": "No drivable surface within 5 ft 0 in of the battery, and that whole area was seen.",
+        "measured_ft": null,
+        "plus_minus_ft": null,
+        "threshold_ft": 5.0,
+        "comparison": "at_least",
+        "subject": null,
+        "rule": {
+          "key": "clearances.drive_ft",
+          "source": "No public value (docs/04, Public rule values)",
+          "placeholder": true
+        }
+      },
+      {
+        "id": "pool_clearance",
+        "label": "Distance from a pool",
+        "outcome": "pass",
+        "reason": "No pool within 10 ft 0 in of the battery, and that whole area was seen.",
+        "measured_ft": null,
+        "plus_minus_ft": null,
+        "threshold_ft": 10.0,
+        "comparison": "at_least",
+        "subject": null,
+        "rule": {
+          "key": "clearances.pool_ft",
+          "source": "No public value (docs/04, Public rule values)",
+          "placeholder": true
+        }
+      },
+      {
+        "id": "opening_clearance",
+        "label": "Distance from doors and windows",
+        "outcome": "pass",
+        "reason": "No door or window within 3 ft 0 in of the battery, and that whole area was seen.",
+        "measured_ft": null,
+        "plus_minus_ft": null,
+        "threshold_ft": 3.0,
+        "comparison": "at_least",
+        "subject": null,
+        "rule": {
+          "key": "clearances.opening_ft",
+          "source": "IRC 2021 R328.4: 3 ft from doors and windows directly entering the dwelling. Applying it to garage doors (openings.types) is a demo choice the code does not require",
+          "placeholder": false
+        }
+      },
+      {
+        "id": "wall_equipment_above",
+        "label": "No box or vent above the battery",
+        "outcome": "pass",
+        "reason": "Nothing is mounted on the wall above the battery.",
+        "measured_ft": null,
+        "plus_minus_ft": null,
+        "threshold_ft": 0.0,
+        "comparison": "at_least",
+        "subject": null,
+        "rule": {
+          "key": "clearances.wall_equipment_ft",
+          "source": "No public value; 0 means only overlap fails",
+          "placeholder": true
+        }
+      },
+      {
+        "id": "facing_gap",
+        "label": "Open space in front",
+        "outcome": "pass",
+        "reason": "The gap in front of the battery is 7 ft 2 in (\u00b1 0 ft 0 in), clear of the 3 ft 0 in rule.",
+        "measured_ft": 7.166667,
+        "plus_minus_ft": 0.0,
+        "threshold_ft": 3.0,
+        "comparison": "at_least",
+        "subject": "facing[8]",
+        "rule": {
+          "key": "facing.min_ft",
+          "source": "Base help page: 3 ft from fences",
+          "placeholder": false
+        }
+      },
+      {
+        "id": "headroom",
+        "label": "Headroom above",
+        "outcome": "pass",
+        "reason": "The headroom is 9 ft 0 in (\u00b1 0 ft 0 in), clear of the 6 ft 6 in rule.",
+        "measured_ft": 9.0,
+        "plus_minus_ft": 0.0,
+        "threshold_ft": 6.5,
+        "comparison": "at_least",
+        "subject": "overheads[8]",
+        "rule": {
+          "key": "headroom.min_ft",
+          "source": "NEC 110.26(A)(3) working-space headroom, applied to the battery as a demo choice",
+          "placeholder": true
+        }
+      },
+      {
+        "id": "route_path",
+        "label": "Cable route along the wall",
+        "outcome": "pass",
+        "reason": "The cable runs along continuous, observed wall with nothing blocking it.",
+        "measured_ft": null,
+        "plus_minus_ft": null,
+        "threshold_ft": null,
+        "comparison": null,
+        "subject": null,
+        "rule": {
+          "key": "route.crossing",
+          "source": "Demo rule: the cable can't cross a door, a garage or a stretch with no wall",
+          "placeholder": false
+        }
+      },
+      {
+        "id": "route_length",
+        "label": "Cable run length",
+        "outcome": "pass",
+        "reason": "The cable run is 2 ft 4 in (\u00b1 1 ft 1 in), within the 15 ft 0 in confident reach.",
+        "measured_ft": 2.375,
+        "plus_minus_ft": 1.093333,
+        "threshold_ft": 20.0,
+        "comparison": "at_most",
+        "subject": null,
+        "rule": {
+          "key": "route.max_ft",
+          "source": "Base help page: within 20 ft of the meter. Review past 15 ft 0 in: No public value",
+          "placeholder": true
+        },
+        "review_threshold_ft": 15.0
+      }
+    ],
+    "nearest_considered": null,
+    "missing_evidence": [],
+    "objects_not_used": [],
+    "ends": {
+      "left": {
+        "kind": "limit",
+        "s_ft": -40.0,
+        "point": [
+          -40.0,
+          0.0
+        ],
+        "beyond_reach": true
+      },
+      "right": {
+        "kind": "limit",
+        "s_ft": 40.0,
+        "point": [
+          40.0,
+          0.0
+        ],
+        "beyond_reach": true
+      }
+    },
+    "sweep": [
+      {
+        "wall_id": "w1",
+        "segment": 0,
+        "start_ft": [
+          -40.0,
+          -27.242064
+        ],
+        "outcome": "fail",
+        "failing": [
+          "route_length"
+        ],
+        "unsure": []
+      },
+      {
+        "wall_id": "w4",
+        "segment": 0,
+        "start_ft": [
+          -27.242064,
+          -27.242064
+        ],
+        "outcome": "fail",
+        "failing": [
+          "route_length"
+        ],
+        "unsure": [
+          "pool_clearance"
+        ]
+      },
+      {
+        "wall_id": "w4",
+        "segment": 0,
+        "start_ft": [
+          -27.183532,
+          -25.625
+        ],
+        "outcome": "unsure",
+        "failing": [],
+        "unsure": [
+          "pool_clearance",
+          "route_length"
+        ]
+      },
+      {
+        "wall_id": "w4",
+        "segment": 0,
+        "start_ft": [
+          -25.541667,
+          -25.291667
+        ],
+        "outcome": "unsure",
+        "failing": [],
+        "unsure": [
+          "route_length"
+        ]
+      },
+      {
+        "wall_id": "w5",
+        "segment": 0,
+        "start_ft": [
+          -25.208333,
+          -21.291667
+        ],
+        "outcome": "unsure",
+        "failing": [],
+        "unsure": [
+          "route_length"
+        ]
+      },
+      {
+        "wall_id": "w6",
+        "segment": 0,
+        "start_ft": [
+          -21.208333,
+          -17.291667
+        ],
+        "outcome": "unsure",
+        "failing": [],
+        "unsure": [
+          "route_length"
+        ]
+      },
+      {
+        "wall_id": "w7",
+        "segment": 0,
+        "start_ft": [
+          -17.208333,
+          -14.958333
+        ],
+        "outcome": "unsure",
+        "failing": [],
+        "unsure": [
+          "route_length"
+        ]
+      },
+      {
+        "wall_id": "w7",
+        "segment": 0,
+        "start_ft": [
+          -14.875,
+          -13.291667
+        ],
+        "outcome": "pass",
+        "failing": [],
+        "unsure": []
+      },
+      {
+        "wall_id": "w8",
+        "segment": 0,
+        "start_ft": [
+          -13.208333,
+          -9.291667
+        ],
+        "outcome": "pass",
+        "failing": [],
+        "unsure": []
+      },
+      {
+        "wall_id": "w9",
+        "segment": 0,
+        "start_ft": [
+          -9.208333,
+          -5.291667
+        ],
+        "outcome": "pass",
+        "failing": [],
+        "unsure": []
+      },
+      {
+        "wall_id": "w10",
+        "segment": 0,
+        "start_ft": [
+          -5.208333,
+          -4.958333
+        ],
+        "outcome": "pass",
+        "failing": [],
+        "unsure": []
+      },
+      {
+        "wall_id": "w10",
+        "segment": 0,
+        "start_ft": [
+          -4.875,
+          -3.125
+        ],
+        "outcome": "unsure",
+        "failing": [],
+        "unsure": [
+          "meter_working_space"
+        ]
+      },
+      {
+        "wall_id": "w10",
+        "segment": 0,
+        "start_ft": [
+          -3.041667,
+          -1.291667
+        ],
+        "outcome": "fail",
+        "failing": [
+          "meter_working_space"
+        ],
+        "unsure": []
+      },
+      {
+        "wall_id": "w11",
+        "segment": 0,
+        "start_ft": [
+          -1.270833,
+          0.458333
+        ],
+        "outcome": "fail",
+        "failing": [
+          "meter_working_space"
+        ],
+        "unsure": []
+      },
+      {
+        "wall_id": "w11",
+        "segment": 0,
+        "start_ft": [
+          0.541667,
+          2.291667
+        ],
+        "outcome": "unsure",
+        "failing": [],
+        "unsure": [
+          "meter_working_space"
+        ]
+      },
+      {
+        "wall_id": "w11",
+        "segment": 0,
+        "start_ft": [
+          2.375,
+          2.708333
+        ],
+        "outcome": "pass",
+        "failing": [],
+        "unsure": []
+      },
+      {
+        "wall_id": "w12",
+        "segment": 0,
+        "start_ft": [
+          2.791667,
+          6.708333
+        ],
+        "outcome": "pass",
+        "failing": [],
+        "unsure": []
+      },
+      {
+        "wall_id": "w13",
+        "segment": 0,
+        "start_ft": [
+          6.791667,
+          10.708333
+        ],
+        "outcome": "pass",
+        "failing": [],
+        "unsure": []
+      },
+      {
+        "wall_id": "w14",
+        "segment": 0,
+        "start_ft": [
+          10.791667,
+          12.291667
+        ],
+        "outcome": "pass",
+        "failing": [],
+        "unsure": []
+      },
+      {
+        "wall_id": "w14",
+        "segment": 0,
+        "start_ft": [
+          12.375,
+          14.708333
+        ],
+        "outcome": "unsure",
+        "failing": [],
+        "unsure": [
+          "route_length"
+        ]
+      },
+      {
+        "wall_id": "w15",
+        "segment": 0,
+        "start_ft": [
+          14.791667,
+          18.708333
+        ],
+        "outcome": "unsure",
+        "failing": [],
+        "unsure": [
+          "route_length"
+        ]
+      },
+      {
+        "wall_id": "w16",
+        "segment": 0,
+        "start_ft": [
+          18.791667,
+          22.708333
+        ],
+        "outcome": "unsure",
+        "failing": [],
+        "unsure": [
+          "route_length"
+        ]
+      },
+      {
+        "wall_id": "w17",
+        "segment": 0,
+        "start_ft": [
+          22.791667,
+          22.958333
+        ],
+        "outcome": "unsure",
+        "failing": [],
+        "unsure": [
+          "route_length"
+        ]
+      },
+      {
+        "wall_id": "w17",
+        "segment": 0,
+        "start_ft": [
+          23.041667,
+          24.600198
+        ],
+        "outcome": "unsure",
+        "failing": [],
+        "unsure": [
+          "pool_clearance",
+          "route_length"
+        ]
+      },
+      {
+        "wall_id": "w17",
+        "segment": 0,
+        "start_ft": [
+          24.65873,
+          24.658731
+        ],
+        "outcome": "fail",
+        "failing": [
+          "route_length"
+        ],
+        "unsure": [
+          "pool_clearance"
+        ]
+      },
+      {
+        "wall_id": "w1",
+        "segment": 0,
+        "start_ft": [
+          24.658731,
+          37.416667
+        ],
+        "outcome": "fail",
+        "failing": [
+          "route_length"
+        ],
+        "unsure": []
+      }
+    ],
+    "stats": {
+      "candidates": 815,
+      "pass": 312,
+      "unsure": 444,
+      "fail": 59,
+      "elapsed_ms": 0,
+      "input_sha256": "d3a293f4c61b7fc3c40ac8275d32001c80425d0c774b155a06bc56724d77e71b"
+    }
+  },
+  "surveyed wall~mirrored": {
+    "schema_version": "1.0",
+    "decision": "pass",
+    "summary": "The battery fits 3 ft 8 in left of the meter with a 2 ft 4 in cable run: every check passes. Demo rules: public values and placeholders (pool 10 ft, drive 5 ft), not Base's.",
+    "reasons": [
+      {
+        "code": "all_checks_pass",
+        "message": "A fully observed spot passes every check."
+      }
+    ],
+    "policy": {
+      "id": "demo",
+      "version": "2026-09-26",
+      "auto_approve": true,
+      "sources": [
+        "public"
+      ],
+      "rules_sha256": "0df93f73b7c3176d33411888638189544a0848ffb51803219ab662a7ca51db66",
+      "notice": "Demo rules: public values and placeholders (pool 10 ft, drive 5 ft), not Base's."
+    },
+    "spot": {
+      "outcome": "pass",
+      "wall_id": "w11",
+      "segment": 0,
+      "span_ft": [
+        -4.958333,
+        -2.375
+      ],
+      "width_ft": 2.583333,
+      "depth_ft": 1.833333,
+      "height_ft": 3.291667,
+      "footprint": [
+        [
+          -4.958333,
+          0.0
+        ],
+        [
+          -2.375,
+          0.0
+        ],
+        [
+          -2.375,
+          1.833333
+        ],
+        [
+          -4.958333,
+          1.833333
+        ]
+      ],
+      "center": [
+        -3.666667,
+        0.916667
+      ],
+      "along": [
+        1.0,
+        0.0
+      ],
+      "outward": [
+        -0.0,
+        1.0
+      ],
+      "meter_offset_ft": [
+        -3.666667,
+        0.916667
+      ],
+      "route_length_ft": 2.375
+    },
+    "route": {
+      "outcome": "pass",
+      "length_ft": 2.375,
+      "plus_minus_ft": 1.093333,
+      "height_ft": 1.0,
+      "polyline": [
+        [
+          0.0,
+          0.0
+        ],
+        [
+          -2.375,
+          0.0
+        ]
+      ],
+      "detours": [],
+      "crossings": []
+    },
+    "checks": [
+      {
+        "id": "wall_backing",
+        "label": "Flush against one straight wall",
+        "outcome": "pass",
+        "reason": "The whole footprint backs onto one straight, observed wall segment.",
+        "measured_ft": null,
+        "plus_minus_ft": null,
+        "threshold_ft": null,
+        "comparison": null,
+        "subject": null,
+        "rule": {
+          "key": "battery.width_ft",
+          "source": "Base Core spec: 30.68 in wide, rounded up to 31 in (docs/04, What Base does today)",
+          "placeholder": false
+        }
+      },
+      {
+        "id": "ground_surface",
+        "label": "Ground under the battery",
+        "outcome": "pass",
+        "reason": "The whole footprint stands on an allowed surface.",
+        "measured_ft": null,
+        "plus_minus_ft": null,
+        "threshold_ft": null,
+        "comparison": null,
+        "subject": null,
+        "rule": {
+          "key": "ground.allowed",
+          "source": "Ground types from schemas/scene.schema.json; which surfaces are allowed is a demo choice",
+          "placeholder": true
+        }
+      },
+      {
+        "id": "meter_working_space",
+        "label": "Clear of the meter's working space",
+        "outcome": "pass",
+        "reason": "The battery is 1 ft 1 in clear of the meter's 2 ft 6 in wide by 3 ft 0 in deep working space.",
+        "measured_ft": 1.125,
+        "plus_minus_ft": 1.093333,
+        "threshold_ft": 0.0,
+        "comparison": "at_least",
+        "subject": "meter",
+        "rule": {
+          "key": "meter_working_space.width_ft",
+          "source": "NEC 110.26(A)(2): 30 in wide working space",
+          "placeholder": false
+        }
+      },
+      {
+        "id": "gas_clearance",
+        "label": "Distance from gas equipment",
+        "outcome": "pass",
+        "reason": "No gas meter or pipe within 3 ft 0 in of the battery, and that whole area was seen.",
+        "measured_ft": null,
+        "plus_minus_ft": null,
+        "threshold_ft": 3.0,
+        "comparison": "at_least",
+        "subject": null,
+        "rule": {
+          "key": "clearances.gas_ft",
+          "source": "Base help page: 3 ft from the gas meter; Austin Energy \u00a71.9; Texas Gas Service",
+          "placeholder": false
+        }
+      },
+      {
+        "id": "ac_clearance",
+        "label": "Distance from AC units",
+        "outcome": "pass",
+        "reason": "No AC unit within 3 ft 0 in of the battery, and that whole area was seen.",
+        "measured_ft": null,
+        "plus_minus_ft": null,
+        "threshold_ft": 3.0,
+        "comparison": "at_least",
+        "subject": null,
+        "rule": {
+          "key": "clearances.ac_ft",
+          "source": "Base help page: 3 ft from AC units, fences and other batteries",
+          "placeholder": false
+        }
+      },
+      {
+        "id": "drive_clearance",
+        "label": "Distance from the driveway",
+        "outcome": "pass",
+        "reason": "No drivable surface within 5 ft 0 in of the battery, and that whole area was seen.",
+        "measured_ft": null,
+        "plus_minus_ft": null,
+        "threshold_ft": 5.0,
+        "comparison": "at_least",
+        "subject": null,
+        "rule": {
+          "key": "clearances.drive_ft",
+          "source": "No public value (docs/04, Public rule values)",
+          "placeholder": true
+        }
+      },
+      {
+        "id": "pool_clearance",
+        "label": "Distance from a pool",
+        "outcome": "pass",
+        "reason": "No pool within 10 ft 0 in of the battery, and that whole area was seen.",
+        "measured_ft": null,
+        "plus_minus_ft": null,
+        "threshold_ft": 10.0,
+        "comparison": "at_least",
+        "subject": null,
+        "rule": {
+          "key": "clearances.pool_ft",
+          "source": "No public value (docs/04, Public rule values)",
+          "placeholder": true
+        }
+      },
+      {
+        "id": "opening_clearance",
+        "label": "Distance from doors and windows",
+        "outcome": "pass",
+        "reason": "No door or window within 3 ft 0 in of the battery, and that whole area was seen.",
+        "measured_ft": null,
+        "plus_minus_ft": null,
+        "threshold_ft": 3.0,
+        "comparison": "at_least",
+        "subject": null,
+        "rule": {
+          "key": "clearances.opening_ft",
+          "source": "IRC 2021 R328.4: 3 ft from doors and windows directly entering the dwelling. Applying it to garage doors (openings.types) is a demo choice the code does not require",
+          "placeholder": false
+        }
+      },
+      {
+        "id": "wall_equipment_above",
+        "label": "No box or vent above the battery",
+        "outcome": "pass",
+        "reason": "Nothing is mounted on the wall above the battery.",
+        "measured_ft": null,
+        "plus_minus_ft": null,
+        "threshold_ft": 0.0,
+        "comparison": "at_least",
+        "subject": null,
+        "rule": {
+          "key": "clearances.wall_equipment_ft",
+          "source": "No public value; 0 means only overlap fails",
+          "placeholder": true
+        }
+      },
+      {
+        "id": "facing_gap",
+        "label": "Open space in front",
+        "outcome": "pass",
+        "reason": "The gap in front of the battery is 7 ft 2 in (\u00b1 0 ft 0 in), clear of the 3 ft 0 in rule.",
+        "measured_ft": 7.166667,
+        "plus_minus_ft": 0.0,
+        "threshold_ft": 3.0,
+        "comparison": "at_least",
+        "subject": "facing[10]",
+        "rule": {
+          "key": "facing.min_ft",
+          "source": "Base help page: 3 ft from fences",
+          "placeholder": false
+        }
+      },
+      {
+        "id": "headroom",
+        "label": "Headroom above",
+        "outcome": "pass",
+        "reason": "The headroom is 9 ft 0 in (\u00b1 0 ft 0 in), clear of the 6 ft 6 in rule.",
+        "measured_ft": 9.0,
+        "plus_minus_ft": 0.0,
+        "threshold_ft": 6.5,
+        "comparison": "at_least",
+        "subject": "overheads[10]",
+        "rule": {
+          "key": "headroom.min_ft",
+          "source": "NEC 110.26(A)(3) working-space headroom, applied to the battery as a demo choice",
+          "placeholder": true
+        }
+      },
+      {
+        "id": "route_path",
+        "label": "Cable route along the wall",
+        "outcome": "pass",
+        "reason": "The cable runs along continuous, observed wall with nothing blocking it.",
+        "measured_ft": null,
+        "plus_minus_ft": null,
+        "threshold_ft": null,
+        "comparison": null,
+        "subject": null,
+        "rule": {
+          "key": "route.crossing",
+          "source": "Demo rule: the cable can't cross a door, a garage or a stretch with no wall",
+          "placeholder": false
+        }
+      },
+      {
+        "id": "route_length",
+        "label": "Cable run length",
+        "outcome": "pass",
+        "reason": "The cable run is 2 ft 4 in (\u00b1 1 ft 1 in), within the 15 ft 0 in confident reach.",
+        "measured_ft": 2.375,
+        "plus_minus_ft": 1.093333,
+        "threshold_ft": 20.0,
+        "comparison": "at_most",
+        "subject": null,
+        "rule": {
+          "key": "route.max_ft",
+          "source": "Base help page: within 20 ft of the meter. Review past 15 ft 0 in: No public value",
+          "placeholder": true
+        },
+        "review_threshold_ft": 15.0
+      }
+    ],
+    "nearest_considered": null,
+    "missing_evidence": [],
+    "objects_not_used": [],
+    "ends": {
+      "left": {
+        "kind": "limit",
+        "s_ft": -40.0,
+        "point": [
+          -40.0,
+          0.0
+        ],
+        "beyond_reach": true
+      },
+      "right": {
+        "kind": "limit",
+        "s_ft": 40.0,
+        "point": [
+          40.0,
+          0.0
+        ],
+        "beyond_reach": true
+      }
+    },
+    "sweep": [
+      {
+        "wall_id": "w20",
+        "segment": 0,
+        "start_ft": [
+          -40.0,
+          -27.242064
+        ],
+        "outcome": "fail",
+        "failing": [
+          "route_length"
+        ],
+        "unsure": []
+      },
+      {
+        "wall_id": "w17",
+        "segment": 0,
+        "start_ft": [
+          -27.242064,
+          -27.242064
+        ],
+        "outcome": "fail",
+        "failing": [
+          "route_length"
+        ],
+        "unsure": [
+          "pool_clearance"
+        ]
+      },
+      {
+        "wall_id": "w17",
+        "segment": 0,
+        "start_ft": [
+          -27.183532,
+          -25.625
+        ],
+        "outcome": "unsure",
+        "failing": [],
+        "unsure": [
+          "pool_clearance",
+          "route_length"
+        ]
+      },
+      {
+        "wall_id": "w17",
+        "segment": 0,
+        "start_ft": [
+          -25.541667,
+          -25.291667
+        ],
+        "outcome": "unsure",
+        "failing": [],
+        "unsure": [
+          "route_length"
+        ]
+      },
+      {
+        "wall_id": "w16",
+        "segment": 0,
+        "start_ft": [
+          -25.208333,
+          -21.291667
+        ],
+        "outcome": "unsure",
+        "failing": [],
+        "unsure": [
+          "route_length"
+        ]
+      },
+      {
+        "wall_id": "w15",
+        "segment": 0,
+        "start_ft": [
+          -21.208333,
+          -17.291667
+        ],
+        "outcome": "unsure",
+        "failing": [],
+        "unsure": [
+          "route_length"
+        ]
+      },
+      {
+        "wall_id": "w14",
+        "segment": 0,
+        "start_ft": [
+          -17.208333,
+          -14.958333
+        ],
+        "outcome": "unsure",
+        "failing": [],
+        "unsure": [
+          "route_length"
+        ]
+      },
+      {
+        "wall_id": "w14",
+        "segment": 0,
+        "start_ft": [
+          -14.875,
+          -13.291667
+        ],
+        "outcome": "pass",
+        "failing": [],
+        "unsure": []
+      },
+      {
+        "wall_id": "w13",
+        "segment": 0,
+        "start_ft": [
+          -13.208333,
+          -9.291667
+        ],
+        "outcome": "pass",
+        "failing": [],
+        "unsure": []
+      },
+      {
+        "wall_id": "w12",
+        "segment": 0,
+        "start_ft": [
+          -9.208333,
+          -5.291667
+        ],
+        "outcome": "pass",
+        "failing": [],
+        "unsure": []
+      },
+      {
+        "wall_id": "w11",
+        "segment": 0,
+        "start_ft": [
+          -5.208333,
+          -4.958333
+        ],
+        "outcome": "pass",
+        "failing": [],
+        "unsure": []
+      },
+      {
+        "wall_id": "w11",
+        "segment": 0,
+        "start_ft": [
+          -4.875,
+          -3.125
+        ],
+        "outcome": "unsure",
+        "failing": [],
+        "unsure": [
+          "meter_working_space"
+        ]
+      },
+      {
+        "wall_id": "w11",
+        "segment": 0,
+        "start_ft": [
+          -3.041667,
+          -1.291667
+        ],
+        "outcome": "fail",
+        "failing": [
+          "meter_working_space"
+        ],
+        "unsure": []
+      },
+      {
+        "wall_id": "w10",
+        "segment": 0,
+        "start_ft": [
+          -1.270833,
+          0.458333
+        ],
+        "outcome": "fail",
+        "failing": [
+          "meter_working_space"
+        ],
+        "unsure": []
+      },
+      {
+        "wall_id": "w10",
+        "segment": 0,
+        "start_ft": [
+          0.541667,
+          2.291667
+        ],
+        "outcome": "unsure",
+        "failing": [],
+        "unsure": [
+          "meter_working_space"
+        ]
+      },
+      {
+        "wall_id": "w10",
+        "segment": 0,
+        "start_ft": [
+          2.375,
+          2.708333
+        ],
+        "outcome": "pass",
+        "failing": [],
+        "unsure": []
+      },
+      {
+        "wall_id": "w9",
+        "segment": 0,
+        "start_ft": [
+          2.791667,
+          6.708333
+        ],
+        "outcome": "pass",
+        "failing": [],
+        "unsure": []
+      },
+      {
+        "wall_id": "w8",
+        "segment": 0,
+        "start_ft": [
+          6.791667,
+          10.708333
+        ],
+        "outcome": "pass",
+        "failing": [],
+        "unsure": []
+      },
+      {
+        "wall_id": "w7",
+        "segment": 0,
+        "start_ft": [
+          10.791667,
+          12.291667
+        ],
+        "outcome": "pass",
+        "failing": [],
+        "unsure": []
+      },
+      {
+        "wall_id": "w7",
+        "segment": 0,
+        "start_ft": [
+          12.375,
+          14.708333
+        ],
+        "outcome": "unsure",
+        "failing": [],
+        "unsure": [
+          "route_length"
+        ]
+      },
+      {
+        "wall_id": "w6",
+        "segment": 0,
+        "start_ft": [
+          14.791667,
+          18.708333
+        ],
+        "outcome": "unsure",
+        "failing": [],
+        "unsure": [
+          "route_length"
+        ]
+      },
+      {
+        "wall_id": "w5",
+        "segment": 0,
+        "start_ft": [
+          18.791667,
+          22.708333
+        ],
+        "outcome": "unsure",
+        "failing": [],
+        "unsure": [
+          "route_length"
+        ]
+      },
+      {
+        "wall_id": "w4",
+        "segment": 0,
+        "start_ft": [
+          22.791667,
+          22.958333
+        ],
+        "outcome": "unsure",
+        "failing": [],
+        "unsure": [
+          "route_length"
+        ]
+      },
+      {
+        "wall_id": "w4",
+        "segment": 0,
+        "start_ft": [
+          23.041667,
+          24.600198
+        ],
+        "outcome": "unsure",
+        "failing": [],
+        "unsure": [
+          "pool_clearance",
+          "route_length"
+        ]
+      },
+      {
+        "wall_id": "w4",
+        "segment": 0,
+        "start_ft": [
+          24.65873,
+          24.658731
+        ],
+        "outcome": "fail",
+        "failing": [
+          "route_length"
+        ],
+        "unsure": [
+          "pool_clearance"
+        ]
+      },
+      {
+        "wall_id": "w20",
+        "segment": 0,
+        "start_ft": [
+          24.658731,
+          37.416667
+        ],
+        "outcome": "fail",
+        "failing": [
+          "route_length"
+        ],
+        "unsure": []
+      }
+    ],
+    "stats": {
+      "candidates": 815,
+      "pass": 312,
+      "unsure": 444,
+      "fail": 59,
+      "elapsed_ms": 0,
+      "input_sha256": "4aee34ed47a051b645f3427c2ca421113b2b7441f8d70a4ac33a6e8a14b7d702"
+    }
+  },
+  "surveyed wall~no coverage": {
+    "schema_version": "1.0",
+    "decision": "manual_review",
+    "summary": "More views are needed around the best spot, 3 ft 8 in left of the meter: 11 checks depend on areas the scan did not see. Demo rules: public values and placeholders (pool 10 ft, drive 5 ft), not Base's.",
+    "reasons": [
+      {
+        "code": "unsure_checks",
+        "checks": [
+          "wall_backing",
+          "ground_surface",
+          "gas_clearance",
+          "ac_clearance",
+          "drive_clearance",
+          "pool_clearance",
+          "opening_clearance",
+          "wall_equipment_above",
+          "facing_gap",
+          "headroom",
+          "route_path"
+        ],
+        "message": "The best spot has checks nobody can settle from this scan: flush against one straight wall; ground under the battery; distance from gas equipment; distance from ac units; distance from the driveway; distance from a pool; distance from doors and windows; no box or vent above the battery; open space in front; headroom above; cable route along the wall."
+      },
+      {
+        "code": "unobserved_area",
+        "checks": [
+          "ac_clearance",
+          "drive_clearance",
+          "facing_gap",
+          "gas_clearance",
+          "ground_surface",
+          "headroom",
+          "opening_clearance",
+          "pool_clearance",
+          "route_path",
+          "wall_backing",
+          "wall_equipment_above"
+        ],
+        "message": "Part of the area the checks need was not seen."
+      }
+    ],
+    "policy": {
+      "id": "demo",
+      "version": "2026-09-26",
+      "auto_approve": true,
+      "sources": [
+        "public"
+      ],
+      "rules_sha256": "0df93f73b7c3176d33411888638189544a0848ffb51803219ab662a7ca51db66",
+      "notice": "Demo rules: public values and placeholders (pool 10 ft, drive 5 ft), not Base's."
+    },
+    "spot": {
+      "outcome": "unsure",
+      "wall_id": "w10",
+      "segment": 0,
+      "span_ft": [
+        -4.958333,
+        -2.375
+      ],
+      "width_ft": 2.583333,
+      "depth_ft": 1.833333,
+      "height_ft": 3.291667,
+      "footprint": [
+        [
+          -4.958333,
+          0.0
+        ],
+        [
+          -2.375,
+          0.0
+        ],
+        [
+          -2.375,
+          1.833333
+        ],
+        [
+          -4.958333,
+          1.833333
+        ]
+      ],
+      "center": [
+        -3.666667,
+        0.916667
+      ],
+      "along": [
+        1.0,
+        0.0
+      ],
+      "outward": [
+        -0.0,
+        1.0
+      ],
+      "meter_offset_ft": [
+        -3.666667,
+        0.916667
+      ],
+      "route_length_ft": 2.375
+    },
+    "route": {
+      "outcome": "unsure",
+      "length_ft": 2.375,
+      "plus_minus_ft": 1.093333,
+      "height_ft": 1.0,
+      "polyline": [
+        [
+          0.0,
+          0.0
+        ],
+        [
+          -2.375,
+          0.0
+        ]
+      ],
+      "detours": [],
+      "crossings": []
+    },
+    "checks": [
+      {
+        "id": "wall_backing",
+        "label": "Flush against one straight wall",
+        "outcome": "unsure",
+        "reason": "Part of the wall behind the battery was not seen.",
+        "measured_ft": null,
+        "plus_minus_ft": null,
+        "threshold_ft": null,
+        "comparison": null,
+        "subject": null,
+        "rule": {
+          "key": "battery.width_ft",
+          "source": "Base Core spec: 30.68 in wide, rounded up to 31 in (docs/04, What Base does today)",
+          "placeholder": false
+        },
+        "unsure_cause": "unobserved"
+      },
+      {
+        "id": "ground_surface",
+        "label": "Ground under the battery",
+        "outcome": "unsure",
+        "reason": "The ground under the footprint was not seen.",
+        "measured_ft": null,
+        "plus_minus_ft": null,
+        "threshold_ft": null,
+        "comparison": null,
+        "subject": null,
+        "rule": {
+          "key": "ground.allowed",
+          "source": "Ground types from schemas/scene.schema.json; which surfaces are allowed is a demo choice",
+          "placeholder": true
+        },
+        "unsure_cause": "unobserved"
+      },
+      {
+        "id": "meter_working_space",
+        "label": "Clear of the meter's working space",
+        "outcome": "pass",
+        "reason": "The battery is 1 ft 1 in clear of the meter's 2 ft 6 in wide by 3 ft 0 in deep working space.",
+        "measured_ft": 1.125,
+        "plus_minus_ft": 1.093333,
+        "threshold_ft": 0.0,
+        "comparison": "at_least",
+        "subject": "meter",
+        "rule": {
+          "key": "meter_working_space.width_ft",
+          "source": "NEC 110.26(A)(2): 30 in wide working space",
+          "placeholder": false
+        }
+      },
+      {
+        "id": "gas_clearance",
+        "label": "Distance from gas equipment",
+        "outcome": "unsure",
+        "reason": "Not everything within 3 ft 0 in of the battery was seen, so a gas meter or pipe could hide there.",
+        "measured_ft": null,
+        "plus_minus_ft": null,
+        "threshold_ft": 3.0,
+        "comparison": "at_least",
+        "subject": null,
+        "rule": {
+          "key": "clearances.gas_ft",
+          "source": "Base help page: 3 ft from the gas meter; Austin Energy \u00a71.9; Texas Gas Service",
+          "placeholder": false
+        },
+        "unsure_cause": "unobserved"
+      },
+      {
+        "id": "ac_clearance",
+        "label": "Distance from AC units",
+        "outcome": "unsure",
+        "reason": "Not everything within 3 ft 0 in of the battery was seen, so a AC unit could hide there.",
+        "measured_ft": null,
+        "plus_minus_ft": null,
+        "threshold_ft": 3.0,
+        "comparison": "at_least",
+        "subject": null,
+        "rule": {
+          "key": "clearances.ac_ft",
+          "source": "Base help page: 3 ft from AC units, fences and other batteries",
+          "placeholder": false
+        },
+        "unsure_cause": "unobserved"
+      },
+      {
+        "id": "drive_clearance",
+        "label": "Distance from the driveway",
+        "outcome": "unsure",
+        "reason": "Not everything within 5 ft 0 in of the battery was seen, so a drivable surface could hide there.",
+        "measured_ft": null,
+        "plus_minus_ft": null,
+        "threshold_ft": 5.0,
+        "comparison": "at_least",
+        "subject": null,
+        "rule": {
+          "key": "clearances.drive_ft",
+          "source": "No public value (docs/04, Public rule values)",
+          "placeholder": true
+        },
+        "unsure_cause": "unobserved"
+      },
+      {
+        "id": "pool_clearance",
+        "label": "Distance from a pool",
+        "outcome": "unsure",
+        "reason": "Not everything within 10 ft 0 in of the battery was seen, so a pool could hide there.",
+        "measured_ft": null,
+        "plus_minus_ft": null,
+        "threshold_ft": 10.0,
+        "comparison": "at_least",
+        "subject": null,
+        "rule": {
+          "key": "clearances.pool_ft",
+          "source": "No public value (docs/04, Public rule values)",
+          "placeholder": true
+        },
+        "unsure_cause": "unobserved"
+      },
+      {
+        "id": "opening_clearance",
+        "label": "Distance from doors and windows",
+        "outcome": "unsure",
+        "reason": "Not everything within 3 ft 0 in of the battery was seen, so a door or window could hide there.",
+        "measured_ft": null,
+        "plus_minus_ft": null,
+        "threshold_ft": 3.0,
+        "comparison": "at_least",
+        "subject": null,
+        "rule": {
+          "key": "clearances.opening_ft",
+          "source": "IRC 2021 R328.4: 3 ft from doors and windows directly entering the dwelling. Applying it to garage doors (openings.types) is a demo choice the code does not require",
+          "placeholder": false
+        },
+        "unsure_cause": "unobserved"
+      },
+      {
+        "id": "wall_equipment_above",
+        "label": "No box or vent above the battery",
+        "outcome": "unsure",
+        "reason": "The wall above the battery was not fully seen.",
+        "measured_ft": null,
+        "plus_minus_ft": null,
+        "threshold_ft": 0.0,
+        "comparison": "at_least",
+        "subject": null,
+        "rule": {
+          "key": "clearances.wall_equipment_ft",
+          "source": "No public value; 0 means only overlap fails",
+          "placeholder": true
+        },
+        "unsure_cause": "unobserved"
+      },
+      {
+        "id": "facing_gap",
+        "label": "Open space in front",
+        "outcome": "unsure",
+        "reason": "The gap in front of the battery over the battery's stretch of wall was not measured everywhere.",
+        "measured_ft": 7.166667,
+        "plus_minus_ft": 0.0,
+        "threshold_ft": 3.0,
+        "comparison": "at_least",
+        "subject": "facing[8]",
+        "rule": {
+          "key": "facing.min_ft",
+          "source": "Base help page: 3 ft from fences",
+          "placeholder": false
+        },
+        "unsure_cause": "unobserved"
+      },
+      {
+        "id": "headroom",
+        "label": "Headroom above",
+        "outcome": "unsure",
+        "reason": "The headroom over the battery's stretch of wall was not measured everywhere.",
+        "measured_ft": 9.0,
+        "plus_minus_ft": 0.0,
+        "threshold_ft": 6.5,
+        "comparison": "at_least",
+        "subject": "overheads[8]",
+        "rule": {
+          "key": "headroom.min_ft",
+          "source": "NEC 110.26(A)(3) working-space headroom, applied to the battery as a demo choice",
+          "placeholder": true
+        },
+        "unsure_cause": "unobserved"
+      },
+      {
+        "id": "route_path",
+        "label": "Cable route along the wall",
+        "outcome": "unsure",
+        "reason": "Part of the wall the cable would run along was not seen.",
+        "measured_ft": null,
+        "plus_minus_ft": null,
+        "threshold_ft": null,
+        "comparison": null,
+        "subject": null,
+        "rule": {
+          "key": "route.crossing",
+          "source": "Demo rule: the cable can't cross a door, a garage or a stretch with no wall",
+          "placeholder": false
+        },
+        "unsure_cause": "unobserved"
+      },
+      {
+        "id": "route_length",
+        "label": "Cable run length",
+        "outcome": "pass",
+        "reason": "The cable run is 2 ft 4 in (\u00b1 1 ft 1 in), within the 15 ft 0 in confident reach.",
+        "measured_ft": 2.375,
+        "plus_minus_ft": 1.093333,
+        "threshold_ft": 20.0,
+        "comparison": "at_most",
+        "subject": null,
+        "rule": {
+          "key": "route.max_ft",
+          "source": "Base help page: within 20 ft of the meter. Review past 15 ft 0 in: No public value",
+          "placeholder": true
+        },
+        "review_threshold_ft": 15.0
+      }
+    ],
+    "nearest_considered": null,
+    "missing_evidence": [
+      {
+        "kind": "band",
+        "band": "wall",
+        "span_ft": [
+          -9.056604,
+          1.72327
+        ],
+        "checks": [
+          "gas_clearance",
+          "opening_clearance",
+          "route_path",
+          "wall_backing",
+          "wall_equipment_above"
+        ],
+        "out_ft": 6.500001,
+        "message": "Show the wall from 9 ft 1 in left of the meter to 1 ft 9 in right of the meter, seen at least 6 ft 6 in up the wall."
+      },
+      {
+        "kind": "band",
+        "band": "ground",
+        "span_ft": [
+          -16.065046,
+          8.731712
+        ],
+        "checks": [
+          "ac_clearance",
+          "drive_clearance",
+          "gas_clearance",
+          "ground_surface",
+          "pool_clearance"
+        ],
+        "out_ft": 12.940046,
+        "message": "Show the ground in front of the wall from 16 ft 1 in left of the meter to 8 ft 9 in right of the meter, at least 12 ft 11 in out from the wall."
+      },
+      {
+        "kind": "band",
+        "band": "facing",
+        "span_ft": [
+          -4.958334,
+          -2.374999
+        ],
+        "checks": [
+          "facing_gap"
+        ],
+        "out_ft": 4.833334,
+        "message": "Show the gap in front of the wall from 4 ft 11 in left of the meter to 2 ft 4 in left of the meter, clear at least 4 ft 10 in out from the wall."
+      },
+      {
+        "kind": "band",
+        "band": "overhead",
+        "span_ft": [
+          -4.958334,
+          -2.374999
+        ],
+        "checks": [
+          "headroom"
+        ],
+        "out_ft": 6.500001,
+        "message": "Show the space overhead from 4 ft 11 in left of the meter to 2 ft 4 in left of the meter, clear at least 6 ft 6 in up."
+      }
+    ],
+    "objects_not_used": [],
+    "ends": {
+      "left": {
+        "kind": "unexplored",
+        "s_ft": -40.0,
+        "point": [
+          -40.0,
+          0.0
+        ],
+        "beyond_reach": true
+      },
+      "right": {
+        "kind": "unexplored",
+        "s_ft": 40.0,
+        "point": [
+          40.0,
+          0.0
+        ],
+        "beyond_reach": true
+      }
+    },
+    "sweep": [
+      {
+        "wall_id": "w1",
+        "segment": 0,
+        "start_ft": [
+          -40.0,
+          -27.242064
+        ],
+        "outcome": "fail",
+        "failing": [
+          "route_length"
+        ],
+        "unsure": []
+      },
+      {
+        "wall_id": "w4",
+        "segment": 0,
+        "start_ft": [
+          -27.242064,
+          -27.242064
+        ],
+        "outcome": "fail",
+        "failing": [
+          "route_length"
+        ],
+        "unsure": [
+          "ac_clearance",
+          "drive_clearance",
+          "facing_gap",
+          "gas_clearance",
+          "ground_surface",
+          "headroom",
+          "opening_clearance",
+          "pool_clearance",
+          "route_path",
+          "wall_backing",
+          "wall_equipment_above"
+        ]
+      },
+      {
+        "wall_id": "w4",
+        "segment": 0,
+        "start_ft": [
+          -27.183532,
+          -25.291667
+        ],
+        "outcome": "unsure",
+        "failing": [],
+        "unsure": [
+          "ac_clearance",
+          "drive_clearance",
+          "facing_gap",
+          "gas_clearance",
+          "ground_surface",
+          "headroom",
+          "opening_clearance",
+          "pool_clearance",
+          "route_length",
+          "route_path",
+          "wall_backing",
+          "wall_equipment_above"
+        ]
+      },
+      {
+        "wall_id": "w5",
+        "segment": 0,
+        "start_ft": [
+          -25.208333,
+          -21.291667
+        ],
+        "outcome": "unsure",
+        "failing": [],
+        "unsure": [
+          "ac_clearance",
+          "drive_clearance",
+          "facing_gap",
+          "gas_clearance",
+          "ground_surface",
+          "headroom",
+          "opening_clearance",
+          "pool_clearance",
+          "route_length",
+          "route_path",
+          "wall_backing",
+          "wall_equipment_above"
+        ]
+      },
+      {
+        "wall_id": "w6",
+        "segment": 0,
+        "start_ft": [
+          -21.208333,
+          -17.291667
+        ],
+        "outcome": "unsure",
+        "failing": [],
+        "unsure": [
+          "ac_clearance",
+          "drive_clearance",
+          "facing_gap",
+          "gas_clearance",
+          "ground_surface",
+          "headroom",
+          "opening_clearance",
+          "pool_clearance",
+          "route_length",
+          "route_path",
+          "wall_backing",
+          "wall_equipment_above"
+        ]
+      },
+      {
+        "wall_id": "w7",
+        "segment": 0,
+        "start_ft": [
+          -17.208333,
+          -14.958333
+        ],
+        "outcome": "unsure",
+        "failing": [],
+        "unsure": [
+          "ac_clearance",
+          "drive_clearance",
+          "facing_gap",
+          "gas_clearance",
+          "ground_surface",
+          "headroom",
+          "opening_clearance",
+          "pool_clearance",
+          "route_length",
+          "route_path",
+          "wall_backing",
+          "wall_equipment_above"
+        ]
+      },
+      {
+        "wall_id": "w7",
+        "segment": 0,
+        "start_ft": [
+          -14.875,
+          -13.291667
+        ],
+        "outcome": "unsure",
+        "failing": [],
+        "unsure": [
+          "ac_clearance",
+          "drive_clearance",
+          "facing_gap",
+          "gas_clearance",
+          "ground_surface",
+          "headroom",
+          "opening_clearance",
+          "pool_clearance",
+          "route_path",
+          "wall_backing",
+          "wall_equipment_above"
+        ]
+      },
+      {
+        "wall_id": "w8",
+        "segment": 0,
+        "start_ft": [
+          -13.208333,
+          -9.291667
+        ],
+        "outcome": "unsure",
+        "failing": [],
+        "unsure": [
+          "ac_clearance",
+          "drive_clearance",
+          "facing_gap",
+          "gas_clearance",
+          "ground_surface",
+          "headroom",
+          "opening_clearance",
+          "pool_clearance",
+          "route_path",
+          "wall_backing",
+          "wall_equipment_above"
+        ]
+      },
+      {
+        "wall_id": "w9",
+        "segment": 0,
+        "start_ft": [
+          -9.208333,
+          -5.291667
+        ],
+        "outcome": "unsure",
+        "failing": [],
+        "unsure": [
+          "ac_clearance",
+          "drive_clearance",
+          "facing_gap",
+          "gas_clearance",
+          "ground_surface",
+          "headroom",
+          "opening_clearance",
+          "pool_clearance",
+          "route_path",
+          "wall_backing",
+          "wall_equipment_above"
+        ]
+      },
+      {
+        "wall_id": "w10",
+        "segment": 0,
+        "start_ft": [
+          -5.208333,
+          -4.958333
+        ],
+        "outcome": "unsure",
+        "failing": [],
+        "unsure": [
+          "ac_clearance",
+          "drive_clearance",
+          "facing_gap",
+          "gas_clearance",
+          "ground_surface",
+          "headroom",
+          "opening_clearance",
+          "pool_clearance",
+          "route_path",
+          "wall_backing",
+          "wall_equipment_above"
+        ]
+      },
+      {
+        "wall_id": "w10",
+        "segment": 0,
+        "start_ft": [
+          -4.875,
+          -3.125
+        ],
+        "outcome": "unsure",
+        "failing": [],
+        "unsure": [
+          "ac_clearance",
+          "drive_clearance",
+          "facing_gap",
+          "gas_clearance",
+          "ground_surface",
+          "headroom",
+          "meter_working_space",
+          "opening_clearance",
+          "pool_clearance",
+          "route_path",
+          "wall_backing",
+          "wall_equipment_above"
+        ]
+      },
+      {
+        "wall_id": "w10",
+        "segment": 0,
+        "start_ft": [
+          -3.041667,
+          -2.604167
+        ],
+        "outcome": "fail",
+        "failing": [
+          "meter_working_space"
+        ],
+        "unsure": [
+          "ac_clearance",
+          "drive_clearance",
+          "facing_gap",
+          "gas_clearance",
+          "ground_surface",
+          "headroom",
+          "opening_clearance",
+          "pool_clearance",
+          "route_path",
+          "wall_backing",
+          "wall_equipment_above"
+        ]
+      },
+      {
+        "wall_id": "w10",
+        "segment": 0,
+        "start_ft": [
+          -2.583333,
+          -1.291667
+        ],
+        "outcome": "fail",
+        "failing": [
+          "meter_working_space"
+        ],
+        "unsure": [
+          "ac_clearance",
+          "drive_clearance",
+          "facing_gap",
+          "gas_clearance",
+          "ground_surface",
+          "headroom",
+          "opening_clearance",
+          "pool_clearance",
+          "wall_backing",
+          "wall_equipment_above"
+        ]
+      },
+      {
+        "wall_id": "w11",
+        "segment": 0,
+        "start_ft": [
+          -1.270833,
+          0.0
+        ],
+        "outcome": "fail",
+        "failing": [
+          "meter_working_space"
+        ],
+        "unsure": [
+          "ac_clearance",
+          "drive_clearance",
+          "facing_gap",
+          "gas_clearance",
+          "ground_surface",
+          "headroom",
+          "opening_clearance",
+          "pool_clearance",
+          "wall_backing",
+          "wall_equipment_above"
+        ]
+      },
+      {
+        "wall_id": "w11",
+        "segment": 0,
+        "start_ft": [
+          0.020833,
+          0.458333
+        ],
+        "outcome": "fail",
+        "failing": [
+          "meter_working_space"
+        ],
+        "unsure": [
+          "ac_clearance",
+          "drive_clearance",
+          "facing_gap",
+          "gas_clearance",
+          "ground_surface",
+          "headroom",
+          "opening_clearance",
+          "pool_clearance",
+          "route_path",
+          "wall_backing",
+          "wall_equipment_above"
+        ]
+      },
+      {
+        "wall_id": "w11",
+        "segment": 0,
+        "start_ft": [
+          0.541667,
+          2.291667
+        ],
+        "outcome": "unsure",
+        "failing": [],
+        "unsure": [
+          "ac_clearance",
+          "drive_clearance",
+          "facing_gap",
+          "gas_clearance",
+          "ground_surface",
+          "headroom",
+          "meter_working_space",
+          "opening_clearance",
+          "pool_clearance",
+          "route_path",
+          "wall_backing",
+          "wall_equipment_above"
+        ]
+      },
+      {
+        "wall_id": "w11",
+        "segment": 0,
+        "start_ft": [
+          2.375,
+          2.708333
+        ],
+        "outcome": "unsure",
+        "failing": [],
+        "unsure": [
+          "ac_clearance",
+          "drive_clearance",
+          "facing_gap",
+          "gas_clearance",
+          "ground_surface",
+          "headroom",
+          "opening_clearance",
+          "pool_clearance",
+          "route_path",
+          "wall_backing",
+          "wall_equipment_above"
+        ]
+      },
+      {
+        "wall_id": "w12",
+        "segment": 0,
+        "start_ft": [
+          2.791667,
+          6.708333
+        ],
+        "outcome": "unsure",
+        "failing": [],
+        "unsure": [
+          "ac_clearance",
+          "drive_clearance",
+          "facing_gap",
+          "gas_clearance",
+          "ground_surface",
+          "headroom",
+          "opening_clearance",
+          "pool_clearance",
+          "route_path",
+          "wall_backing",
+          "wall_equipment_above"
+        ]
+      },
+      {
+        "wall_id": "w13",
+        "segment": 0,
+        "start_ft": [
+          6.791667,
+          10.708333
+        ],
+        "outcome": "unsure",
+        "failing": [],
+        "unsure": [
+          "ac_clearance",
+          "drive_clearance",
+          "facing_gap",
+          "gas_clearance",
+          "ground_surface",
+          "headroom",
+          "opening_clearance",
+          "pool_clearance",
+          "route_path",
+          "wall_backing",
+          "wall_equipment_above"
+        ]
+      },
+      {
+        "wall_id": "w14",
+        "segment": 0,
+        "start_ft": [
+          10.791667,
+          12.291667
+        ],
+        "outcome": "unsure",
+        "failing": [],
+        "unsure": [
+          "ac_clearance",
+          "drive_clearance",
+          "facing_gap",
+          "gas_clearance",
+          "ground_surface",
+          "headroom",
+          "opening_clearance",
+          "pool_clearance",
+          "route_path",
+          "wall_backing",
+          "wall_equipment_above"
+        ]
+      },
+      {
+        "wall_id": "w14",
+        "segment": 0,
+        "start_ft": [
+          12.375,
+          14.708333
+        ],
+        "outcome": "unsure",
+        "failing": [],
+        "unsure": [
+          "ac_clearance",
+          "drive_clearance",
+          "facing_gap",
+          "gas_clearance",
+          "ground_surface",
+          "headroom",
+          "opening_clearance",
+          "pool_clearance",
+          "route_length",
+          "route_path",
+          "wall_backing",
+          "wall_equipment_above"
+        ]
+      },
+      {
+        "wall_id": "w15",
+        "segment": 0,
+        "start_ft": [
+          14.791667,
+          18.708333
+        ],
+        "outcome": "unsure",
+        "failing": [],
+        "unsure": [
+          "ac_clearance",
+          "drive_clearance",
+          "facing_gap",
+          "gas_clearance",
+          "ground_surface",
+          "headroom",
+          "opening_clearance",
+          "pool_clearance",
+          "route_length",
+          "route_path",
+          "wall_backing",
+          "wall_equipment_above"
+        ]
+      },
+      {
+        "wall_id": "w16",
+        "segment": 0,
+        "start_ft": [
+          18.791667,
+          22.708333
+        ],
+        "outcome": "unsure",
+        "failing": [],
+        "unsure": [
+          "ac_clearance",
+          "drive_clearance",
+          "facing_gap",
+          "gas_clearance",
+          "ground_surface",
+          "headroom",
+          "opening_clearance",
+          "pool_clearance",
+          "route_length",
+          "route_path",
+          "wall_backing",
+          "wall_equipment_above"
+        ]
+      },
+      {
+        "wall_id": "w17",
+        "segment": 0,
+        "start_ft": [
+          22.791667,
+          24.600198
+        ],
+        "outcome": "unsure",
+        "failing": [],
+        "unsure": [
+          "ac_clearance",
+          "drive_clearance",
+          "facing_gap",
+          "gas_clearance",
+          "ground_surface",
+          "headroom",
+          "opening_clearance",
+          "pool_clearance",
+          "route_length",
+          "route_path",
+          "wall_backing",
+          "wall_equipment_above"
+        ]
+      },
+      {
+        "wall_id": "w17",
+        "segment": 0,
+        "start_ft": [
+          24.65873,
+          24.658731
+        ],
+        "outcome": "fail",
+        "failing": [
+          "route_length"
+        ],
+        "unsure": [
+          "ac_clearance",
+          "drive_clearance",
+          "facing_gap",
+          "gas_clearance",
+          "ground_surface",
+          "headroom",
+          "opening_clearance",
+          "pool_clearance",
+          "route_path",
+          "wall_backing",
+          "wall_equipment_above"
+        ]
+      },
+      {
+        "wall_id": "w1",
+        "segment": 0,
+        "start_ft": [
+          24.658731,
+          37.416667
+        ],
+        "outcome": "fail",
+        "failing": [
+          "route_length"
+        ],
+        "unsure": []
+      }
+    ],
+    "stats": {
+      "candidates": 815,
+      "pass": 0,
+      "unsure": 756,
+      "fail": 59,
+      "elapsed_ms": 0,
+      "input_sha256": "266238d71d75c0edf27c1b2e720c616f0315ee4154d6f57250a7268f90e5f09d"
+    }
+  },
+  "surveyed wall~less coverage": {
+    "schema_version": "1.0",
+    "decision": "pass",
+    "summary": "The battery fits 3 ft 8 in left of the meter with a 2 ft 4 in cable run: every check passes. Demo rules: public values and placeholders (pool 10 ft, drive 5 ft), not Base's.",
+    "reasons": [
+      {
+        "code": "all_checks_pass",
+        "message": "A fully observed spot passes every check."
+      }
+    ],
+    "policy": {
+      "id": "demo",
+      "version": "2026-09-26",
+      "auto_approve": true,
+      "sources": [
+        "public"
+      ],
+      "rules_sha256": "0df93f73b7c3176d33411888638189544a0848ffb51803219ab662a7ca51db66",
+      "notice": "Demo rules: public values and placeholders (pool 10 ft, drive 5 ft), not Base's."
+    },
+    "spot": {
+      "outcome": "pass",
+      "wall_id": "w10",
+      "segment": 0,
+      "span_ft": [
+        -4.958333,
+        -2.375
+      ],
+      "width_ft": 2.583333,
+      "depth_ft": 1.833333,
+      "height_ft": 3.291667,
+      "footprint": [
+        [
+          -4.958333,
+          0.0
+        ],
+        [
+          -2.375,
+          0.0
+        ],
+        [
+          -2.375,
+          1.833333
+        ],
+        [
+          -4.958333,
+          1.833333
+        ]
+      ],
+      "center": [
+        -3.666667,
+        0.916667
+      ],
+      "along": [
+        1.0,
+        0.0
+      ],
+      "outward": [
+        -0.0,
+        1.0
+      ],
+      "meter_offset_ft": [
+        -3.666667,
+        0.916667
+      ],
+      "route_length_ft": 2.375
+    },
+    "route": {
+      "outcome": "pass",
+      "length_ft": 2.375,
+      "plus_minus_ft": 1.093333,
+      "height_ft": 1.0,
+      "polyline": [
+        [
+          0.0,
+          0.0
+        ],
+        [
+          -2.375,
+          0.0
+        ]
+      ],
+      "detours": [],
+      "crossings": []
+    },
+    "checks": [
+      {
+        "id": "wall_backing",
+        "label": "Flush against one straight wall",
+        "outcome": "pass",
+        "reason": "The whole footprint backs onto one straight, observed wall segment.",
+        "measured_ft": null,
+        "plus_minus_ft": null,
+        "threshold_ft": null,
+        "comparison": null,
+        "subject": null,
+        "rule": {
+          "key": "battery.width_ft",
+          "source": "Base Core spec: 30.68 in wide, rounded up to 31 in (docs/04, What Base does today)",
+          "placeholder": false
+        }
+      },
+      {
+        "id": "ground_surface",
+        "label": "Ground under the battery",
+        "outcome": "pass",
+        "reason": "The whole footprint stands on an allowed surface.",
+        "measured_ft": null,
+        "plus_minus_ft": null,
+        "threshold_ft": null,
+        "comparison": null,
+        "subject": null,
+        "rule": {
+          "key": "ground.allowed",
+          "source": "Ground types from schemas/scene.schema.json; which surfaces are allowed is a demo choice",
+          "placeholder": true
+        }
+      },
+      {
+        "id": "meter_working_space",
+        "label": "Clear of the meter's working space",
+        "outcome": "pass",
+        "reason": "The battery is 1 ft 1 in clear of the meter's 2 ft 6 in wide by 3 ft 0 in deep working space.",
+        "measured_ft": 1.125,
+        "plus_minus_ft": 1.093333,
+        "threshold_ft": 0.0,
+        "comparison": "at_least",
+        "subject": "meter",
+        "rule": {
+          "key": "meter_working_space.width_ft",
+          "source": "NEC 110.26(A)(2): 30 in wide working space",
+          "placeholder": false
+        }
+      },
+      {
+        "id": "gas_clearance",
+        "label": "Distance from gas equipment",
+        "outcome": "pass",
+        "reason": "No gas meter or pipe within 3 ft 0 in of the battery, and that whole area was seen.",
+        "measured_ft": null,
+        "plus_minus_ft": null,
+        "threshold_ft": 3.0,
+        "comparison": "at_least",
+        "subject": null,
+        "rule": {
+          "key": "clearances.gas_ft",
+          "source": "Base help page: 3 ft from the gas meter; Austin Energy \u00a71.9; Texas Gas Service",
+          "placeholder": false
+        }
+      },
+      {
+        "id": "ac_clearance",
+        "label": "Distance from AC units",
+        "outcome": "pass",
+        "reason": "No AC unit within 3 ft 0 in of the battery, and that whole area was seen.",
+        "measured_ft": null,
+        "plus_minus_ft": null,
+        "threshold_ft": 3.0,
+        "comparison": "at_least",
+        "subject": null,
+        "rule": {
+          "key": "clearances.ac_ft",
+          "source": "Base help page: 3 ft from AC units, fences and other batteries",
+          "placeholder": false
+        }
+      },
+      {
+        "id": "drive_clearance",
+        "label": "Distance from the driveway",
+        "outcome": "pass",
+        "reason": "No drivable surface within 5 ft 0 in of the battery, and that whole area was seen.",
+        "measured_ft": null,
+        "plus_minus_ft": null,
+        "threshold_ft": 5.0,
+        "comparison": "at_least",
+        "subject": null,
+        "rule": {
+          "key": "clearances.drive_ft",
+          "source": "No public value (docs/04, Public rule values)",
+          "placeholder": true
+        }
+      },
+      {
+        "id": "pool_clearance",
+        "label": "Distance from a pool",
+        "outcome": "pass",
+        "reason": "No pool within 10 ft 0 in of the battery, and that whole area was seen.",
+        "measured_ft": null,
+        "plus_minus_ft": null,
+        "threshold_ft": 10.0,
+        "comparison": "at_least",
+        "subject": null,
+        "rule": {
+          "key": "clearances.pool_ft",
+          "source": "No public value (docs/04, Public rule values)",
+          "placeholder": true
+        }
+      },
+      {
+        "id": "opening_clearance",
+        "label": "Distance from doors and windows",
+        "outcome": "pass",
+        "reason": "No door or window within 3 ft 0 in of the battery, and that whole area was seen.",
+        "measured_ft": null,
+        "plus_minus_ft": null,
+        "threshold_ft": 3.0,
+        "comparison": "at_least",
+        "subject": null,
+        "rule": {
+          "key": "clearances.opening_ft",
+          "source": "IRC 2021 R328.4: 3 ft from doors and windows directly entering the dwelling. Applying it to garage doors (openings.types) is a demo choice the code does not require",
+          "placeholder": false
+        }
+      },
+      {
+        "id": "wall_equipment_above",
+        "label": "No box or vent above the battery",
+        "outcome": "pass",
+        "reason": "Nothing is mounted on the wall above the battery.",
+        "measured_ft": null,
+        "plus_minus_ft": null,
+        "threshold_ft": 0.0,
+        "comparison": "at_least",
+        "subject": null,
+        "rule": {
+          "key": "clearances.wall_equipment_ft",
+          "source": "No public value; 0 means only overlap fails",
+          "placeholder": true
+        }
+      },
+      {
+        "id": "facing_gap",
+        "label": "Open space in front",
+        "outcome": "pass",
+        "reason": "The gap in front of the battery is 7 ft 2 in (\u00b1 0 ft 0 in), clear of the 3 ft 0 in rule.",
+        "measured_ft": 7.166667,
+        "plus_minus_ft": 0.0,
+        "threshold_ft": 3.0,
+        "comparison": "at_least",
+        "subject": "facing[8]",
+        "rule": {
+          "key": "facing.min_ft",
+          "source": "Base help page: 3 ft from fences",
+          "placeholder": false
+        }
+      },
+      {
+        "id": "headroom",
+        "label": "Headroom above",
+        "outcome": "pass",
+        "reason": "The headroom is 9 ft 0 in (\u00b1 0 ft 0 in), clear of the 6 ft 6 in rule.",
+        "measured_ft": 9.0,
+        "plus_minus_ft": 0.0,
+        "threshold_ft": 6.5,
+        "comparison": "at_least",
+        "subject": "overheads[8]",
+        "rule": {
+          "key": "headroom.min_ft",
+          "source": "NEC 110.26(A)(3) working-space headroom, applied to the battery as a demo choice",
+          "placeholder": true
+        }
+      },
+      {
+        "id": "route_path",
+        "label": "Cable route along the wall",
+        "outcome": "pass",
+        "reason": "The cable runs along continuous, observed wall with nothing blocking it.",
+        "measured_ft": null,
+        "plus_minus_ft": null,
+        "threshold_ft": null,
+        "comparison": null,
+        "subject": null,
+        "rule": {
+          "key": "route.crossing",
+          "source": "Demo rule: the cable can't cross a door, a garage or a stretch with no wall",
+          "placeholder": false
+        }
+      },
+      {
+        "id": "route_length",
+        "label": "Cable run length",
+        "outcome": "pass",
+        "reason": "The cable run is 2 ft 4 in (\u00b1 1 ft 1 in), within the 15 ft 0 in confident reach.",
+        "measured_ft": 2.375,
+        "plus_minus_ft": 1.093333,
+        "threshold_ft": 20.0,
+        "comparison": "at_most",
+        "subject": null,
+        "rule": {
+          "key": "route.max_ft",
+          "source": "Base help page: within 20 ft of the meter. Review past 15 ft 0 in: No public value",
+          "placeholder": true
+        },
+        "review_threshold_ft": 15.0
+      }
+    ],
+    "nearest_considered": null,
+    "missing_evidence": [],
+    "objects_not_used": [],
+    "ends": {
+      "left": {
+        "kind": "limit",
+        "s_ft": -40.0,
+        "point": [
+          -40.0,
+          0.0
+        ],
+        "beyond_reach": true
+      },
+      "right": {
+        "kind": "limit",
+        "s_ft": 40.0,
+        "point": [
+          40.0,
+          0.0
+        ],
+        "beyond_reach": true
+      }
+    },
+    "sweep": [
+      {
+        "wall_id": "w1",
+        "segment": 0,
+        "start_ft": [
+          -40.0,
+          -27.242064
+        ],
+        "outcome": "fail",
+        "failing": [
+          "route_length"
+        ],
+        "unsure": []
+      },
+      {
+        "wall_id": "w4",
+        "segment": 0,
+        "start_ft": [
+          -27.242064,
+          -27.242064
+        ],
+        "outcome": "fail",
+        "failing": [
+          "route_length"
+        ],
+        "unsure": [
+          "pool_clearance"
+        ]
+      },
+      {
+        "wall_id": "w4",
+        "segment": 0,
+        "start_ft": [
+          -27.183532,
+          -25.291667
+        ],
+        "outcome": "unsure",
+        "failing": [],
+        "unsure": [
+          "pool_clearance",
+          "route_length"
+        ]
+      },
+      {
+        "wall_id": "w5",
+        "segment": 0,
+        "start_ft": [
+          -25.208333,
+          -25.208333
+        ],
+        "outcome": "unsure",
+        "failing": [],
+        "unsure": [
+          "pool_clearance",
+          "route_length"
+        ]
+      },
+      {
+        "wall_id": "w5",
+        "segment": 0,
+        "start_ft": [
+          -25.125,
+          -21.291667
+        ],
+        "outcome": "unsure",
+        "failing": [],
+        "unsure": [
+          "route_length"
+        ]
+      },
+      {
+        "wall_id": "w6",
+        "segment": 0,
+        "start_ft": [
+          -21.208333,
+          -17.291667
+        ],
+        "outcome": "unsure",
+        "failing": [],
+        "unsure": [
+          "route_length"
+        ]
+      },
+      {
+        "wall_id": "w7",
+        "segment": 0,
+        "start_ft": [
+          -17.208333,
+          -14.958333
+        ],
+        "outcome": "unsure",
+        "failing": [],
+        "unsure": [
+          "route_length"
+        ]
+      },
+      {
+        "wall_id": "w7",
+        "segment": 0,
+        "start_ft": [
+          -14.875,
+          -13.291667
+        ],
+        "outcome": "pass",
+        "failing": [],
+        "unsure": []
+      },
+      {
+        "wall_id": "w8",
+        "segment": 0,
+        "start_ft": [
+          -13.208333,
+          -9.291667
+        ],
+        "outcome": "pass",
+        "failing": [],
+        "unsure": []
+      },
+      {
+        "wall_id": "w9",
+        "segment": 0,
+        "start_ft": [
+          -9.208333,
+          -5.291667
+        ],
+        "outcome": "pass",
+        "failing": [],
+        "unsure": []
+      },
+      {
+        "wall_id": "w10",
+        "segment": 0,
+        "start_ft": [
+          -5.208333,
+          -4.958333
+        ],
+        "outcome": "pass",
+        "failing": [],
+        "unsure": []
+      },
+      {
+        "wall_id": "w10",
+        "segment": 0,
+        "start_ft": [
+          -4.875,
+          -3.125
+        ],
+        "outcome": "unsure",
+        "failing": [],
+        "unsure": [
+          "meter_working_space"
+        ]
+      },
+      {
+        "wall_id": "w10",
+        "segment": 0,
+        "start_ft": [
+          -3.041667,
+          -1.291667
+        ],
+        "outcome": "fail",
+        "failing": [
+          "meter_working_space"
+        ],
+        "unsure": []
+      },
+      {
+        "wall_id": "w11",
+        "segment": 0,
+        "start_ft": [
+          -1.270833,
+          0.458333
+        ],
+        "outcome": "fail",
+        "failing": [
+          "meter_working_space"
+        ],
+        "unsure": []
+      },
+      {
+        "wall_id": "w11",
+        "segment": 0,
+        "start_ft": [
+          0.541667,
+          2.291667
+        ],
+        "outcome": "unsure",
+        "failing": [],
+        "unsure": [
+          "meter_working_space"
+        ]
+      },
+      {
+        "wall_id": "w11",
+        "segment": 0,
+        "start_ft": [
+          2.375,
+          2.708333
+        ],
+        "outcome": "pass",
+        "failing": [],
+        "unsure": []
+      },
+      {
+        "wall_id": "w12",
+        "segment": 0,
+        "start_ft": [
+          2.791667,
+          6.708333
+        ],
+        "outcome": "pass",
+        "failing": [],
+        "unsure": []
+      },
+      {
+        "wall_id": "w13",
+        "segment": 0,
+        "start_ft": [
+          6.791667,
+          10.708333
+        ],
+        "outcome": "pass",
+        "failing": [],
+        "unsure": []
+      },
+      {
+        "wall_id": "w14",
+        "segment": 0,
+        "start_ft": [
+          10.791667,
+          12.291667
+        ],
+        "outcome": "pass",
+        "failing": [],
+        "unsure": []
+      },
+      {
+        "wall_id": "w14",
+        "segment": 0,
+        "start_ft": [
+          12.375,
+          14.708333
+        ],
+        "outcome": "unsure",
+        "failing": [],
+        "unsure": [
+          "route_length"
+        ]
+      },
+      {
+        "wall_id": "w15",
+        "segment": 0,
+        "start_ft": [
+          14.791667,
+          18.708333
+        ],
+        "outcome": "unsure",
+        "failing": [],
+        "unsure": [
+          "route_length"
+        ]
+      },
+      {
+        "wall_id": "w16",
+        "segment": 0,
+        "start_ft": [
+          18.791667,
+          22.541667
+        ],
+        "outcome": "unsure",
+        "failing": [],
+        "unsure": [
+          "route_length"
+        ]
+      },
+      {
+        "wall_id": "w16",
+        "segment": 0,
+        "start_ft": [
+          22.625,
+          22.708333
+        ],
+        "outcome": "unsure",
+        "failing": [],
+        "unsure": [
+          "pool_clearance",
+          "route_length"
+        ]
+      },
+      {
+        "wall_id": "w17",
+        "segment": 0,
+        "start_ft": [
+          22.791667,
+          24.600198
+        ],
+        "outcome": "unsure",
+        "failing": [],
+        "unsure": [
+          "pool_clearance",
+          "route_length"
+        ]
+      },
+      {
+        "wall_id": "w17",
+        "segment": 0,
+        "start_ft": [
+          24.65873,
+          24.658731
+        ],
+        "outcome": "fail",
+        "failing": [
+          "route_length"
+        ],
+        "unsure": [
+          "pool_clearance"
+        ]
+      },
+      {
+        "wall_id": "w1",
+        "segment": 0,
+        "start_ft": [
+          24.658731,
+          37.416667
+        ],
+        "outcome": "fail",
+        "failing": [
+          "route_length"
+        ],
+        "unsure": []
+      }
+    ],
+    "stats": {
+      "candidates": 815,
+      "pass": 312,
+      "unsure": 444,
+      "fail": 59,
+      "elapsed_ms": 0,
+      "input_sha256": "45f4346323d5517919839411fecc8c95bf07a62f2b08990f6b0b765e03fa9fc5"
+    }
+  },
+  "surveyed wall~ground short of the largest clearance": {
+    "schema_version": "1.0",
+    "decision": "manual_review",
+    "summary": "More views are needed around the best spot, 3 ft 8 in left of the meter: 1 check depends on areas the scan did not see. Demo rules: public values and placeholders (pool 10 ft, drive 5 ft), not Base's.",
+    "reasons": [
+      {
+        "code": "unsure_checks",
+        "checks": [
+          "pool_clearance"
+        ],
+        "message": "The best spot has checks nobody can settle from this scan: distance from a pool."
+      },
+      {
+        "code": "unobserved_area",
+        "checks": [
+          "pool_clearance"
+        ],
+        "message": "Part of the area the checks need was not seen."
+      }
+    ],
+    "policy": {
+      "id": "demo",
+      "version": "2026-09-26",
+      "auto_approve": true,
+      "sources": [
+        "public"
+      ],
+      "rules_sha256": "0df93f73b7c3176d33411888638189544a0848ffb51803219ab662a7ca51db66",
+      "notice": "Demo rules: public values and placeholders (pool 10 ft, drive 5 ft), not Base's."
+    },
+    "spot": {
+      "outcome": "unsure",
+      "wall_id": "w10",
+      "segment": 0,
+      "span_ft": [
+        -4.958333,
+        -2.375
+      ],
+      "width_ft": 2.583333,
+      "depth_ft": 1.833333,
+      "height_ft": 3.291667,
+      "footprint": [
+        [
+          -4.958333,
+          0.0
+        ],
+        [
+          -2.375,
+          0.0
+        ],
+        [
+          -2.375,
+          1.833333
+        ],
+        [
+          -4.958333,
+          1.833333
+        ]
+      ],
+      "center": [
+        -3.666667,
+        0.916667
+      ],
+      "along": [
+        1.0,
+        0.0
+      ],
+      "outward": [
+        -0.0,
+        1.0
+      ],
+      "meter_offset_ft": [
+        -3.666667,
+        0.916667
+      ],
+      "route_length_ft": 2.375
+    },
+    "route": {
+      "outcome": "pass",
+      "length_ft": 2.375,
+      "plus_minus_ft": 1.093333,
+      "height_ft": 1.0,
+      "polyline": [
+        [
+          0.0,
+          0.0
+        ],
+        [
+          -2.375,
+          0.0
+        ]
+      ],
+      "detours": [],
+      "crossings": []
+    },
+    "checks": [
+      {
+        "id": "wall_backing",
+        "label": "Flush against one straight wall",
+        "outcome": "pass",
+        "reason": "The whole footprint backs onto one straight, observed wall segment.",
+        "measured_ft": null,
+        "plus_minus_ft": null,
+        "threshold_ft": null,
+        "comparison": null,
+        "subject": null,
+        "rule": {
+          "key": "battery.width_ft",
+          "source": "Base Core spec: 30.68 in wide, rounded up to 31 in (docs/04, What Base does today)",
+          "placeholder": false
+        }
+      },
+      {
+        "id": "ground_surface",
+        "label": "Ground under the battery",
+        "outcome": "pass",
+        "reason": "The whole footprint stands on an allowed surface.",
+        "measured_ft": null,
+        "plus_minus_ft": null,
+        "threshold_ft": null,
+        "comparison": null,
+        "subject": null,
+        "rule": {
+          "key": "ground.allowed",
+          "source": "Ground types from schemas/scene.schema.json; which surfaces are allowed is a demo choice",
+          "placeholder": true
+        }
+      },
+      {
+        "id": "meter_working_space",
+        "label": "Clear of the meter's working space",
+        "outcome": "pass",
+        "reason": "The battery is 1 ft 1 in clear of the meter's 2 ft 6 in wide by 3 ft 0 in deep working space.",
+        "measured_ft": 1.125,
+        "plus_minus_ft": 1.093333,
+        "threshold_ft": 0.0,
+        "comparison": "at_least",
+        "subject": "meter",
+        "rule": {
+          "key": "meter_working_space.width_ft",
+          "source": "NEC 110.26(A)(2): 30 in wide working space",
+          "placeholder": false
+        }
+      },
+      {
+        "id": "gas_clearance",
+        "label": "Distance from gas equipment",
+        "outcome": "pass",
+        "reason": "No gas meter or pipe within 3 ft 0 in of the battery, and that whole area was seen.",
+        "measured_ft": null,
+        "plus_minus_ft": null,
+        "threshold_ft": 3.0,
+        "comparison": "at_least",
+        "subject": null,
+        "rule": {
+          "key": "clearances.gas_ft",
+          "source": "Base help page: 3 ft from the gas meter; Austin Energy \u00a71.9; Texas Gas Service",
+          "placeholder": false
+        }
+      },
+      {
+        "id": "ac_clearance",
+        "label": "Distance from AC units",
+        "outcome": "pass",
+        "reason": "No AC unit within 3 ft 0 in of the battery, and that whole area was seen.",
+        "measured_ft": null,
+        "plus_minus_ft": null,
+        "threshold_ft": 3.0,
+        "comparison": "at_least",
+        "subject": null,
+        "rule": {
+          "key": "clearances.ac_ft",
+          "source": "Base help page: 3 ft from AC units, fences and other batteries",
+          "placeholder": false
+        }
+      },
+      {
+        "id": "drive_clearance",
+        "label": "Distance from the driveway",
+        "outcome": "pass",
+        "reason": "No drivable surface within 5 ft 0 in of the battery, and that whole area was seen.",
+        "measured_ft": null,
+        "plus_minus_ft": null,
+        "threshold_ft": 5.0,
+        "comparison": "at_least",
+        "subject": null,
+        "rule": {
+          "key": "clearances.drive_ft",
+          "source": "No public value (docs/04, Public rule values)",
+          "placeholder": true
+        }
+      },
+      {
+        "id": "pool_clearance",
+        "label": "Distance from a pool",
+        "outcome": "unsure",
+        "reason": "Not everything within 10 ft 0 in of the battery was seen, so a pool could hide there.",
+        "measured_ft": null,
+        "plus_minus_ft": null,
+        "threshold_ft": 10.0,
+        "comparison": "at_least",
+        "subject": null,
+        "rule": {
+          "key": "clearances.pool_ft",
+          "source": "No public value (docs/04, Public rule values)",
+          "placeholder": true
+        },
+        "unsure_cause": "unobserved"
+      },
+      {
+        "id": "opening_clearance",
+        "label": "Distance from doors and windows",
+        "outcome": "pass",
+        "reason": "No door or window within 3 ft 0 in of the battery, and that whole area was seen.",
+        "measured_ft": null,
+        "plus_minus_ft": null,
+        "threshold_ft": 3.0,
+        "comparison": "at_least",
+        "subject": null,
+        "rule": {
+          "key": "clearances.opening_ft",
+          "source": "IRC 2021 R328.4: 3 ft from doors and windows directly entering the dwelling. Applying it to garage doors (openings.types) is a demo choice the code does not require",
+          "placeholder": false
+        }
+      },
+      {
+        "id": "wall_equipment_above",
+        "label": "No box or vent above the battery",
+        "outcome": "pass",
+        "reason": "Nothing is mounted on the wall above the battery.",
+        "measured_ft": null,
+        "plus_minus_ft": null,
+        "threshold_ft": 0.0,
+        "comparison": "at_least",
+        "subject": null,
+        "rule": {
+          "key": "clearances.wall_equipment_ft",
+          "source": "No public value; 0 means only overlap fails",
+          "placeholder": true
+        }
+      },
+      {
+        "id": "facing_gap",
+        "label": "Open space in front",
+        "outcome": "pass",
+        "reason": "The gap in front of the battery is 7 ft 2 in (\u00b1 0 ft 0 in), clear of the 3 ft 0 in rule.",
+        "measured_ft": 7.166667,
+        "plus_minus_ft": 0.0,
+        "threshold_ft": 3.0,
+        "comparison": "at_least",
+        "subject": "facing[8]",
+        "rule": {
+          "key": "facing.min_ft",
+          "source": "Base help page: 3 ft from fences",
+          "placeholder": false
+        }
+      },
+      {
+        "id": "headroom",
+        "label": "Headroom above",
+        "outcome": "pass",
+        "reason": "The headroom is 9 ft 0 in (\u00b1 0 ft 0 in), clear of the 6 ft 6 in rule.",
+        "measured_ft": 9.0,
+        "plus_minus_ft": 0.0,
+        "threshold_ft": 6.5,
+        "comparison": "at_least",
+        "subject": "overheads[8]",
+        "rule": {
+          "key": "headroom.min_ft",
+          "source": "NEC 110.26(A)(3) working-space headroom, applied to the battery as a demo choice",
+          "placeholder": true
+        }
+      },
+      {
+        "id": "route_path",
+        "label": "Cable route along the wall",
+        "outcome": "pass",
+        "reason": "The cable runs along continuous, observed wall with nothing blocking it.",
+        "measured_ft": null,
+        "plus_minus_ft": null,
+        "threshold_ft": null,
+        "comparison": null,
+        "subject": null,
+        "rule": {
+          "key": "route.crossing",
+          "source": "Demo rule: the cable can't cross a door, a garage or a stretch with no wall",
+          "placeholder": false
+        }
+      },
+      {
+        "id": "route_length",
+        "label": "Cable run length",
+        "outcome": "pass",
+        "reason": "The cable run is 2 ft 4 in (\u00b1 1 ft 1 in), within the 15 ft 0 in confident reach.",
+        "measured_ft": 2.375,
+        "plus_minus_ft": 1.093333,
+        "threshold_ft": 20.0,
+        "comparison": "at_most",
+        "subject": null,
+        "rule": {
+          "key": "route.max_ft",
+          "source": "Base help page: within 20 ft of the meter. Review past 15 ft 0 in: No public value",
+          "placeholder": true
+        },
+        "review_threshold_ft": 15.0
+      }
+    ],
+    "nearest_considered": null,
+    "missing_evidence": [
+      {
+        "kind": "band",
+        "band": "ground",
+        "span_ft": [
+          -9.961945,
+          2.628612
+        ],
+        "checks": [
+          "pool_clearance"
+        ],
+        "out_ft": 12.940046,
+        "message": "Show the ground in front of the wall from 10 ft 0 in left of the meter to 2 ft 8 in right of the meter, at least 12 ft 11 in out from the wall."
+      }
+    ],
+    "objects_not_used": [],
+    "ends": {
+      "left": {
+        "kind": "limit",
+        "s_ft": -40.0,
+        "point": [
+          -40.0,
+          0.0
+        ],
+        "beyond_reach": true
+      },
+      "right": {
+        "kind": "limit",
+        "s_ft": 40.0,
+        "point": [
+          40.0,
+          0.0
+        ],
+        "beyond_reach": true
+      }
+    },
+    "sweep": [
+      {
+        "wall_id": "w1",
+        "segment": 0,
+        "start_ft": [
+          -40.0,
+          -27.242064
+        ],
+        "outcome": "fail",
+        "failing": [
+          "route_length"
+        ],
+        "unsure": []
+      },
+      {
+        "wall_id": "w4",
+        "segment": 0,
+        "start_ft": [
+          -27.242064,
+          -27.242064
+        ],
+        "outcome": "fail",
+        "failing": [
+          "route_length"
+        ],
+        "unsure": [
+          "pool_clearance"
+        ]
+      },
+      {
+        "wall_id": "w4",
+        "segment": 0,
+        "start_ft": [
+          -27.183532,
+          -25.291667
+        ],
+        "outcome": "unsure",
+        "failing": [],
+        "unsure": [
+          "pool_clearance",
+          "route_length"
+        ]
+      },
+      {
+        "wall_id": "w5",
+        "segment": 0,
+        "start_ft": [
+          -25.208333,
+          -21.291667
+        ],
+        "outcome": "unsure",
+        "failing": [],
+        "unsure": [
+          "pool_clearance",
+          "route_length"
+        ]
+      },
+      {
+        "wall_id": "w6",
+        "segment": 0,
+        "start_ft": [
+          -21.208333,
+          -17.291667
+        ],
+        "outcome": "unsure",
+        "failing": [],
+        "unsure": [
+          "pool_clearance",
+          "route_length"
+        ]
+      },
+      {
+        "wall_id": "w7",
+        "segment": 0,
+        "start_ft": [
+          -17.208333,
+          -14.958333
+        ],
+        "outcome": "unsure",
+        "failing": [],
+        "unsure": [
+          "pool_clearance",
+          "route_length"
+        ]
+      },
+      {
+        "wall_id": "w7",
+        "segment": 0,
+        "start_ft": [
+          -14.875,
+          -13.291667
+        ],
+        "outcome": "unsure",
+        "failing": [],
+        "unsure": [
+          "pool_clearance"
+        ]
+      },
+      {
+        "wall_id": "w8",
+        "segment": 0,
+        "start_ft": [
+          -13.208333,
+          -9.291667
+        ],
+        "outcome": "unsure",
+        "failing": [],
+        "unsure": [
+          "pool_clearance"
+        ]
+      },
+      {
+        "wall_id": "w9",
+        "segment": 0,
+        "start_ft": [
+          -9.208333,
+          -5.291667
+        ],
+        "outcome": "unsure",
+        "failing": [],
+        "unsure": [
+          "pool_clearance"
+        ]
+      },
+      {
+        "wall_id": "w10",
+        "segment": 0,
+        "start_ft": [
+          -5.208333,
+          -4.958333
+        ],
+        "outcome": "unsure",
+        "failing": [],
+        "unsure": [
+          "pool_clearance"
+        ]
+      },
+      {
+        "wall_id": "w10",
+        "segment": 0,
+        "start_ft": [
+          -4.875,
+          -3.125
+        ],
+        "outcome": "unsure",
+        "failing": [],
+        "unsure": [
+          "meter_working_space",
+          "pool_clearance"
+        ]
+      },
+      {
+        "wall_id": "w10",
+        "segment": 0,
+        "start_ft": [
+          -3.041667,
+          -1.291667
+        ],
+        "outcome": "fail",
+        "failing": [
+          "meter_working_space"
+        ],
+        "unsure": [
+          "pool_clearance"
+        ]
+      },
+      {
+        "wall_id": "w11",
+        "segment": 0,
+        "start_ft": [
+          -1.270833,
+          0.458333
+        ],
+        "outcome": "fail",
+        "failing": [
+          "meter_working_space"
+        ],
+        "unsure": [
+          "pool_clearance"
+        ]
+      },
+      {
+        "wall_id": "w11",
+        "segment": 0,
+        "start_ft": [
+          0.541667,
+          2.291667
+        ],
+        "outcome": "unsure",
+        "failing": [],
+        "unsure": [
+          "meter_working_space",
+          "pool_clearance"
+        ]
+      },
+      {
+        "wall_id": "w11",
+        "segment": 0,
+        "start_ft": [
+          2.375,
+          2.708333
+        ],
+        "outcome": "unsure",
+        "failing": [],
+        "unsure": [
+          "pool_clearance"
+        ]
+      },
+      {
+        "wall_id": "w12",
+        "segment": 0,
+        "start_ft": [
+          2.791667,
+          6.708333
+        ],
+        "outcome": "unsure",
+        "failing": [],
+        "unsure": [
+          "pool_clearance"
+        ]
+      },
+      {
+        "wall_id": "w13",
+        "segment": 0,
+        "start_ft": [
+          6.791667,
+          10.708333
+        ],
+        "outcome": "unsure",
+        "failing": [],
+        "unsure": [
+          "pool_clearance"
+        ]
+      },
+      {
+        "wall_id": "w14",
+        "segment": 0,
+        "start_ft": [
+          10.791667,
+          12.291667
+        ],
+        "outcome": "unsure",
+        "failing": [],
+        "unsure": [
+          "pool_clearance"
+        ]
+      },
+      {
+        "wall_id": "w14",
+        "segment": 0,
+        "start_ft": [
+          12.375,
+          14.708333
+        ],
+        "outcome": "unsure",
+        "failing": [],
+        "unsure": [
+          "pool_clearance",
+          "route_length"
+        ]
+      },
+      {
+        "wall_id": "w15",
+        "segment": 0,
+        "start_ft": [
+          14.791667,
+          18.708333
+        ],
+        "outcome": "unsure",
+        "failing": [],
+        "unsure": [
+          "pool_clearance",
+          "route_length"
+        ]
+      },
+      {
+        "wall_id": "w16",
+        "segment": 0,
+        "start_ft": [
+          18.791667,
+          22.708333
+        ],
+        "outcome": "unsure",
+        "failing": [],
+        "unsure": [
+          "pool_clearance",
+          "route_length"
+        ]
+      },
+      {
+        "wall_id": "w17",
+        "segment": 0,
+        "start_ft": [
+          22.791667,
+          24.600198
+        ],
+        "outcome": "unsure",
+        "failing": [],
+        "unsure": [
+          "pool_clearance",
+          "route_length"
+        ]
+      },
+      {
+        "wall_id": "w17",
+        "segment": 0,
+        "start_ft": [
+          24.65873,
+          24.658731
+        ],
+        "outcome": "fail",
+        "failing": [
+          "route_length"
+        ],
+        "unsure": [
+          "pool_clearance"
+        ]
+      },
+      {
+        "wall_id": "w1",
+        "segment": 0,
+        "start_ft": [
+          24.658731,
+          37.416667
+        ],
+        "outcome": "fail",
+        "failing": [
+          "route_length"
+        ],
+        "unsure": []
+      }
+    ],
+    "stats": {
+      "candidates": 815,
+      "pass": 0,
+      "unsure": 756,
+      "fail": 59,
+      "elapsed_ms": 0,
+      "input_sha256": "11e367e90218bfe3b8663e25f78640d62daed9192d959bb8a599877aa7729684"
+    }
+  },
+  "surveyed wall~more error": {
+    "schema_version": "1.0",
+    "decision": "manual_review",
+    "summary": "A person needs to check the best spot, 2 ft 6 in left of the meter: clear of the meter's working space; cable run length. Demo rules: public values and placeholders (pool 10 ft, drive 5 ft), not Base's.",
+    "reasons": [
+      {
+        "code": "unsure_checks",
+        "checks": [
+          "meter_working_space",
+          "route_length"
+        ],
+        "message": "The best spot has checks nobody can settle from this scan: clear of the meter's working space; cable run length."
+      }
+    ],
+    "policy": {
+      "id": "demo",
+      "version": "2026-09-26",
+      "auto_approve": true,
+      "sources": [
+        "public"
+      ],
+      "rules_sha256": "0df93f73b7c3176d33411888638189544a0848ffb51803219ab662a7ca51db66",
+      "notice": "Demo rules: public values and placeholders (pool 10 ft, drive 5 ft), not Base's."
+    },
+    "spot": {
+      "outcome": "unsure",
+      "wall_id": "w10",
+      "segment": 0,
+      "span_ft": [
+        -3.833333,
+        -1.25
+      ],
+      "width_ft": 2.583333,
+      "depth_ft": 1.833333,
+      "height_ft": 3.291667,
+      "footprint": [
+        [
+          -3.833333,
+          0.0
+        ],
+        [
+          -1.25,
+          0.0
+        ],
+        [
+          -1.25,
+          1.833333
+        ],
+        [
+          -3.833333,
+          1.833333
+        ]
+      ],
+      "center": [
+        -2.541667,
+        0.916667
+      ],
+      "along": [
+        1.0,
+        0.0
+      ],
+      "outward": [
+        -0.0,
+        1.0
+      ],
+      "meter_offset_ft": [
+        -2.541667,
+        0.916667
+      ],
+      "route_length_ft": 1.25
+    },
+    "route": {
+      "outcome": "unsure",
+      "length_ft": 1.25,
+      "plus_minus_ft": 14.1,
+      "height_ft": 1.0,
+      "polyline": [
+        [
+          0.0,
+          0.0
+        ],
+        [
+          -1.25,
+          0.0
+        ]
+      ],
+      "detours": [],
+      "crossings": []
+    },
+    "checks": [
+      {
+        "id": "wall_backing",
+        "label": "Flush against one straight wall",
+        "outcome": "pass",
+        "reason": "The whole footprint backs onto one straight, observed wall segment.",
+        "measured_ft": null,
+        "plus_minus_ft": null,
+        "threshold_ft": null,
+        "comparison": null,
+        "subject": null,
+        "rule": {
+          "key": "battery.width_ft",
+          "source": "Base Core spec: 30.68 in wide, rounded up to 31 in (docs/04, What Base does today)",
+          "placeholder": false
+        }
+      },
+      {
+        "id": "ground_surface",
+        "label": "Ground under the battery",
+        "outcome": "pass",
+        "reason": "The whole footprint stands on an allowed surface.",
+        "measured_ft": null,
+        "plus_minus_ft": null,
+        "threshold_ft": null,
+        "comparison": null,
+        "subject": null,
+        "rule": {
+          "key": "ground.allowed",
+          "source": "Ground types from schemas/scene.schema.json; which surfaces are allowed is a demo choice",
+          "placeholder": true
+        }
+      },
+      {
+        "id": "meter_working_space",
+        "label": "Clear of the meter's working space",
+        "outcome": "unsure",
+        "reason": "The battery is within measurement error of the meter's 2 ft 6 in wide by 3 ft 0 in deep working space.",
+        "measured_ft": -0.0,
+        "plus_minus_ft": 14.1,
+        "threshold_ft": 0.0,
+        "comparison": "at_least",
+        "subject": "meter",
+        "rule": {
+          "key": "meter_working_space.width_ft",
+          "source": "NEC 110.26(A)(2): 30 in wide working space",
+          "placeholder": false
+        },
+        "unsure_cause": "margin"
+      },
+      {
+        "id": "gas_clearance",
+        "label": "Distance from gas equipment",
+        "outcome": "pass",
+        "reason": "No gas meter or pipe within 3 ft 0 in of the battery, and that whole area was seen.",
+        "measured_ft": null,
+        "plus_minus_ft": null,
+        "threshold_ft": 3.0,
+        "comparison": "at_least",
+        "subject": null,
+        "rule": {
+          "key": "clearances.gas_ft",
+          "source": "Base help page: 3 ft from the gas meter; Austin Energy \u00a71.9; Texas Gas Service",
+          "placeholder": false
+        }
+      },
+      {
+        "id": "ac_clearance",
+        "label": "Distance from AC units",
+        "outcome": "pass",
+        "reason": "No AC unit within 3 ft 0 in of the battery, and that whole area was seen.",
+        "measured_ft": null,
+        "plus_minus_ft": null,
+        "threshold_ft": 3.0,
+        "comparison": "at_least",
+        "subject": null,
+        "rule": {
+          "key": "clearances.ac_ft",
+          "source": "Base help page: 3 ft from AC units, fences and other batteries",
+          "placeholder": false
+        }
+      },
+      {
+        "id": "drive_clearance",
+        "label": "Distance from the driveway",
+        "outcome": "pass",
+        "reason": "No drivable surface within 5 ft 0 in of the battery, and that whole area was seen.",
+        "measured_ft": null,
+        "plus_minus_ft": null,
+        "threshold_ft": 5.0,
+        "comparison": "at_least",
+        "subject": null,
+        "rule": {
+          "key": "clearances.drive_ft",
+          "source": "No public value (docs/04, Public rule values)",
+          "placeholder": true
+        }
+      },
+      {
+        "id": "pool_clearance",
+        "label": "Distance from a pool",
+        "outcome": "pass",
+        "reason": "No pool within 10 ft 0 in of the battery, and that whole area was seen.",
+        "measured_ft": null,
+        "plus_minus_ft": null,
+        "threshold_ft": 10.0,
+        "comparison": "at_least",
+        "subject": null,
+        "rule": {
+          "key": "clearances.pool_ft",
+          "source": "No public value (docs/04, Public rule values)",
+          "placeholder": true
+        }
+      },
+      {
+        "id": "opening_clearance",
+        "label": "Distance from doors and windows",
+        "outcome": "pass",
+        "reason": "No door or window within 3 ft 0 in of the battery, and that whole area was seen.",
+        "measured_ft": null,
+        "plus_minus_ft": null,
+        "threshold_ft": 3.0,
+        "comparison": "at_least",
+        "subject": null,
+        "rule": {
+          "key": "clearances.opening_ft",
+          "source": "IRC 2021 R328.4: 3 ft from doors and windows directly entering the dwelling. Applying it to garage doors (openings.types) is a demo choice the code does not require",
+          "placeholder": false
+        }
+      },
+      {
+        "id": "wall_equipment_above",
+        "label": "No box or vent above the battery",
+        "outcome": "pass",
+        "reason": "Nothing is mounted on the wall above the battery.",
+        "measured_ft": null,
+        "plus_minus_ft": null,
+        "threshold_ft": 0.0,
+        "comparison": "at_least",
+        "subject": null,
+        "rule": {
+          "key": "clearances.wall_equipment_ft",
+          "source": "No public value; 0 means only overlap fails",
+          "placeholder": true
+        }
+      },
+      {
+        "id": "facing_gap",
+        "label": "Open space in front",
+        "outcome": "pass",
+        "reason": "The gap in front of the battery is 7 ft 2 in (\u00b1 0 ft 0 in), clear of the 3 ft 0 in rule.",
+        "measured_ft": 7.166667,
+        "plus_minus_ft": 0.0,
+        "threshold_ft": 3.0,
+        "comparison": "at_least",
+        "subject": "facing[5]",
+        "rule": {
+          "key": "facing.min_ft",
+          "source": "Base help page: 3 ft from fences",
+          "placeholder": false
+        }
+      },
+      {
+        "id": "headroom",
+        "label": "Headroom above",
+        "outcome": "pass",
+        "reason": "The headroom is 9 ft 0 in (\u00b1 0 ft 0 in), clear of the 6 ft 6 in rule.",
+        "measured_ft": 9.0,
+        "plus_minus_ft": 0.0,
+        "threshold_ft": 6.5,
+        "comparison": "at_least",
+        "subject": "overheads[5]",
+        "rule": {
+          "key": "headroom.min_ft",
+          "source": "NEC 110.26(A)(3) working-space headroom, applied to the battery as a demo choice",
+          "placeholder": true
+        }
+      },
+      {
+        "id": "route_path",
+        "label": "Cable route along the wall",
+        "outcome": "pass",
+        "reason": "The cable runs along continuous, observed wall with nothing blocking it.",
+        "measured_ft": null,
+        "plus_minus_ft": null,
+        "threshold_ft": null,
+        "comparison": null,
+        "subject": null,
+        "rule": {
+          "key": "route.crossing",
+          "source": "Demo rule: the cable can't cross a door, a garage or a stretch with no wall",
+          "placeholder": false
+        }
+      },
+      {
+        "id": "route_length",
+        "label": "Cable run length",
+        "outcome": "unsure",
+        "reason": "The cable run is 1 ft 3 in (\u00b1 14 ft 1 in), within its error of the 15 ft 0 in confident reach or the 20 ft 0 in maximum: too close to call.",
+        "measured_ft": 1.25,
+        "plus_minus_ft": 14.1,
+        "threshold_ft": 20.0,
+        "comparison": "at_most",
+        "subject": null,
+        "rule": {
+          "key": "route.max_ft",
+          "source": "Base help page: within 20 ft of the meter. Review past 15 ft 0 in: No public value",
+          "placeholder": true
+        },
+        "review_threshold_ft": 15.0,
+        "unsure_cause": "margin"
+      }
+    ],
+    "nearest_considered": null,
+    "missing_evidence": [],
+    "objects_not_used": [],
+    "ends": {
+      "left": {
+        "kind": "limit",
+        "s_ft": -40.0,
+        "point": [
+          -40.0,
+          0.0
+        ],
+        "beyond_reach": true
+      },
+      "right": {
+        "kind": "limit",
+        "s_ft": 40.0,
+        "point": [
+          40.0,
+          0.0
+        ],
+        "beyond_reach": true
+      }
+    },
+    "sweep": [
+      {
+        "wall_id": "w1",
+        "segment": 0,
+        "start_ft": [
+          -40.0,
+          -36.683334
+        ],
+        "outcome": "fail",
+        "failing": [
+          "route_length"
+        ],
+        "unsure": []
+      },
+      {
+        "wall_id": "w2",
+        "segment": 0,
+        "start_ft": [
+          -36.683334,
+          -36.683334
+        ],
+        "outcome": "fail",
+        "failing": [
+          "route_length"
+        ],
+        "unsure": [
+          "ac_clearance",
+          "drive_clearance",
+          "gas_clearance",
+          "ground_surface",
+          "opening_clearance",
+          "pool_clearance"
+        ]
+      },
+      {
+        "wall_id": "w2",
+        "segment": 0,
+        "start_ft": [
+          -36.683333,
+          -33.291667
+        ],
+        "outcome": "unsure",
+        "failing": [],
+        "unsure": [
+          "ac_clearance",
+          "drive_clearance",
+          "gas_clearance",
+          "ground_surface",
+          "opening_clearance",
+          "pool_clearance",
+          "route_length"
+        ]
+      },
+      {
+        "wall_id": "w3",
+        "segment": 0,
+        "start_ft": [
+          -33.208333,
+          -29.291667
+        ],
+        "outcome": "unsure",
+        "failing": [],
+        "unsure": [
+          "ac_clearance",
+          "drive_clearance",
+          "gas_clearance",
+          "ground_surface",
+          "opening_clearance",
+          "pool_clearance",
+          "route_length"
+        ]
+      },
+      {
+        "wall_id": "w4",
+        "segment": 0,
+        "start_ft": [
+          -29.208333,
+          -26.429167
+        ],
+        "outcome": "unsure",
+        "failing": [],
+        "unsure": [
+          "ac_clearance",
+          "drive_clearance",
+          "gas_clearance",
+          "ground_surface",
+          "opening_clearance",
+          "pool_clearance",
+          "route_length"
+        ]
+      },
+      {
+        "wall_id": "w4",
+        "segment": 0,
+        "start_ft": [
+          -26.4,
+          -25.291667
+        ],
+        "outcome": "unsure",
+        "failing": [],
+        "unsure": [
+          "ac_clearance",
+          "drive_clearance",
+          "gas_clearance",
+          "opening_clearance",
+          "pool_clearance",
+          "route_length"
+        ]
+      },
+      {
+        "wall_id": "w5",
+        "segment": 0,
+        "start_ft": [
+          -25.208333,
+          -23.458333
+        ],
+        "outcome": "unsure",
+        "failing": [],
+        "unsure": [
+          "ac_clearance",
+          "drive_clearance",
+          "gas_clearance",
+          "opening_clearance",
+          "pool_clearance",
+          "route_length"
+        ]
+      },
+      {
+        "wall_id": "w5",
+        "segment": 0,
+        "start_ft": [
+          -23.375,
+          -21.458333
+        ],
+        "outcome": "unsure",
+        "failing": [],
+        "unsure": [
+          "drive_clearance",
+          "pool_clearance",
+          "route_length"
+        ]
+      },
+      {
+        "wall_id": "w5",
+        "segment": 0,
+        "start_ft": [
+          -21.375,
+          -21.291667
+        ],
+        "outcome": "unsure",
+        "failing": [],
+        "unsure": [
+          "pool_clearance",
+          "route_length"
+        ]
+      },
+      {
+        "wall_id": "w6",
+        "segment": 0,
+        "start_ft": [
+          -21.208333,
+          -17.958333
+        ],
+        "outcome": "unsure",
+        "failing": [],
+        "unsure": [
+          "pool_clearance",
+          "route_length"
+        ]
+      },
+      {
+        "wall_id": "w6",
+        "segment": 0,
+        "start_ft": [
+          -17.875,
+          -17.291667
+        ],
+        "outcome": "unsure",
+        "failing": [],
+        "unsure": [
+          "meter_working_space",
+          "pool_clearance",
+          "route_length"
+        ]
+      },
+      {
+        "wall_id": "w7",
+        "segment": 0,
+        "start_ft": [
+          -17.208333,
+          -16.458333
+        ],
+        "outcome": "unsure",
+        "failing": [],
+        "unsure": [
+          "meter_working_space",
+          "pool_clearance",
+          "route_length"
+        ]
+      },
+      {
+        "wall_id": "w7",
+        "segment": 0,
+        "start_ft": [
+          -16.375,
+          -13.291667
+        ],
+        "outcome": "unsure",
+        "failing": [],
+        "unsure": [
+          "meter_working_space",
+          "route_length"
+        ]
+      },
+      {
+        "wall_id": "w8",
+        "segment": 0,
+        "start_ft": [
+          -13.208333,
+          -9.291667
+        ],
+        "outcome": "unsure",
+        "failing": [],
+        "unsure": [
+          "meter_working_space",
+          "route_length"
+        ]
+      },
+      {
+        "wall_id": "w9",
+        "segment": 0,
+        "start_ft": [
+          -9.208333,
+          -5.291667
+        ],
+        "outcome": "unsure",
+        "failing": [],
+        "unsure": [
+          "meter_working_space",
+          "route_length"
+        ]
+      },
+      {
+        "wall_id": "w10",
+        "segment": 0,
+        "start_ft": [
+          -5.208333,
+          -3.483333
+        ],
+        "outcome": "unsure",
+        "failing": [],
+        "unsure": [
+          "meter_working_space",
+          "route_length"
+        ]
+      },
+      {
+        "wall_id": "w10",
+        "segment": 0,
+        "start_ft": [
+          -3.470833,
+          -1.291667
+        ],
+        "outcome": "unsure",
+        "failing": [],
+        "unsure": [
+          "meter_working_space"
+        ]
+      },
+      {
+        "wall_id": "w11",
+        "segment": 0,
+        "start_ft": [
+          -1.270833,
+          0.8875
+        ],
+        "outcome": "unsure",
+        "failing": [],
+        "unsure": [
+          "meter_working_space"
+        ]
+      },
+      {
+        "wall_id": "w11",
+        "segment": 0,
+        "start_ft": [
+          0.9,
+          2.708333
+        ],
+        "outcome": "unsure",
+        "failing": [],
+        "unsure": [
+          "meter_working_space",
+          "route_length"
+        ]
+      },
+      {
+        "wall_id": "w12",
+        "segment": 0,
+        "start_ft": [
+          2.791667,
+          6.708333
+        ],
+        "outcome": "unsure",
+        "failing": [],
+        "unsure": [
+          "meter_working_space",
+          "route_length"
+        ]
+      },
+      {
+        "wall_id": "w13",
+        "segment": 0,
+        "start_ft": [
+          6.791667,
+          10.708333
+        ],
+        "outcome": "unsure",
+        "failing": [],
+        "unsure": [
+          "meter_working_space",
+          "route_length"
+        ]
+      },
+      {
+        "wall_id": "w14",
+        "segment": 0,
+        "start_ft": [
+          10.791667,
+          13.791667
+        ],
+        "outcome": "unsure",
+        "failing": [],
+        "unsure": [
+          "meter_working_space",
+          "route_length"
+        ]
+      },
+      {
+        "wall_id": "w14",
+        "segment": 0,
+        "start_ft": [
+          13.875,
+          14.708333
+        ],
+        "outcome": "unsure",
+        "failing": [],
+        "unsure": [
+          "meter_working_space",
+          "pool_clearance",
+          "route_length"
+        ]
+      },
+      {
+        "wall_id": "w15",
+        "segment": 0,
+        "start_ft": [
+          14.779167,
+          15.291667
+        ],
+        "outcome": "unsure",
+        "failing": [],
+        "unsure": [
+          "meter_working_space",
+          "pool_clearance",
+          "route_length"
+        ]
+      },
+      {
+        "wall_id": "w15",
+        "segment": 0,
+        "start_ft": [
+          15.375,
+          18.708333
+        ],
+        "outcome": "unsure",
+        "failing": [],
+        "unsure": [
+          "pool_clearance",
+          "route_length"
+        ]
+      },
+      {
+        "wall_id": "w16",
+        "segment": 0,
+        "start_ft": [
+          18.791667,
+          18.791667
+        ],
+        "outcome": "unsure",
+        "failing": [],
+        "unsure": [
+          "pool_clearance",
+          "route_length"
+        ]
+      },
+      {
+        "wall_id": "w16",
+        "segment": 0,
+        "start_ft": [
+          18.875,
+          20.791667
+        ],
+        "outcome": "unsure",
+        "failing": [],
+        "unsure": [
+          "drive_clearance",
+          "pool_clearance",
+          "route_length"
+        ]
+      },
+      {
+        "wall_id": "w16",
+        "segment": 0,
+        "start_ft": [
+          20.875,
+          22.708333
+        ],
+        "outcome": "unsure",
+        "failing": [],
+        "unsure": [
+          "ac_clearance",
+          "drive_clearance",
+          "gas_clearance",
+          "opening_clearance",
+          "pool_clearance",
+          "route_length"
+        ]
+      },
+      {
+        "wall_id": "w17",
+        "segment": 0,
+        "start_ft": [
+          22.791667,
+          23.816667
+        ],
+        "outcome": "unsure",
+        "failing": [],
+        "unsure": [
+          "ac_clearance",
+          "drive_clearance",
+          "gas_clearance",
+          "opening_clearance",
+          "pool_clearance",
+          "route_length"
+        ]
+      },
+      {
+        "wall_id": "w17",
+        "segment": 0,
+        "start_ft": [
+          23.845833,
+          26.708333
+        ],
+        "outcome": "unsure",
+        "failing": [],
+        "unsure": [
+          "ac_clearance",
+          "drive_clearance",
+          "gas_clearance",
+          "ground_surface",
+          "opening_clearance",
+          "pool_clearance",
+          "route_length"
+        ]
+      },
+      {
+        "wall_id": "w18",
+        "segment": 0,
+        "start_ft": [
+          26.791667,
+          30.708333
+        ],
+        "outcome": "unsure",
+        "failing": [],
+        "unsure": [
+          "ac_clearance",
+          "drive_clearance",
+          "gas_clearance",
+          "ground_surface",
+          "opening_clearance",
+          "pool_clearance",
+          "route_length"
+        ]
+      },
+      {
+        "wall_id": "w19",
+        "segment": 0,
+        "start_ft": [
+          30.791667,
+          34.1
+        ],
+        "outcome": "unsure",
+        "failing": [],
+        "unsure": [
+          "ac_clearance",
+          "drive_clearance",
+          "gas_clearance",
+          "ground_surface",
+          "opening_clearance",
+          "pool_clearance",
+          "route_length"
+        ]
+      },
+      {
+        "wall_id": "w19",
+        "segment": 0,
+        "start_ft": [
+          34.100001,
+          34.100001
+        ],
+        "outcome": "fail",
+        "failing": [
+          "route_length"
+        ],
+        "unsure": [
+          "ac_clearance",
+          "drive_clearance",
+          "gas_clearance",
+          "ground_surface",
+          "opening_clearance",
+          "pool_clearance"
+        ]
+      },
+      {
+        "wall_id": "w1",
+        "segment": 0,
+        "start_ft": [
+          34.100001,
+          37.416667
+        ],
+        "outcome": "fail",
+        "failing": [
+          "route_length"
+        ],
+        "unsure": []
+      }
+    ],
+    "stats": {
+      "candidates": 1095,
+      "pass": 0,
+      "unsure": 1093,
+      "fail": 2,
+      "elapsed_ms": 0,
+      "input_sha256": "89f16e3ba80ea5576ec49bca3db348b343d1a8f713417af402614a4ac1761505"
+    }
+  }
+}
diff --git a/verification/tests/segmented_wall.py b/verification/tests/segmented_wall.py
new file mode 100644
index 000000000..a46904f2d
--- /dev/null
+++ b/verification/tests/segmented_wall.py
@@ -0,0 +1,27 @@
+"""Equivalent surveyed straight walls for verifier representation regressions."""
+
+import copy
+import json
+from pathlib import Path
+
+
+def segmented_wall_scene(segments_per_wall: int) -> dict:
+    fixture = json.loads((Path(__file__).parent / "fixtures/wide-public-pass.json").read_text())
+    scene = copy.deepcopy(fixture["scene"])
+    scene["walls"] = [
+        {
+            "id": f"w{i + 1}",
+            "baseline": [
+                [-40 + 4 * i + 4 * j / segments_per_wall, 0] for j in range(segments_per_wall + 1)
+            ],
+            "height_ft": 9,
+        }
+        for i in range(20)
+    ]
+    scene["meter"]["wall_id"] = "w11"
+    for key in ("facing", "overheads"):
+        scene[key] = [
+            dict(fixture["scene"][key][0], wall_id=f"w{i + 1}", span_ft=[-40 + 4 * i, -36 + 4 * i])
+            for i in range(20)
+        ]
+    return scene
diff --git a/verification/tests/test_judge_scene_cache.py b/verification/tests/test_judge_scene_cache.py
new file mode 100644
index 000000000..b4e711770
--- /dev/null
+++ b/verification/tests/test_judge_scene_cache.py
@@ -0,0 +1,73 @@
+"""Recorded public responses exercise the complete judge without a server dependency."""
+
+import copy
+import hashlib
+import json
+from pathlib import Path
+
+import pytest
+from segmented_wall import segmented_wall_scene
+
+from hsverify import e2e
+from hsverify.resultcheck import MAX_RESULT_CHECKS, RuleSet, WorkMeter, ingestion_problems
+
+ROOT = Path(__file__).parents[2]
+RULES = RuleSet.from_yaml((ROOT / "server/rules.yaml").read_text())
+SCHEMAS = {
+    kind: json.loads((ROOT / f"server/schemas/{kind}.schema.json").read_text())
+    for kind in ("scene", "result")
+}
+
+
+def workload(monkeypatch, segments):
+    responses = json.loads(
+        (Path(__file__).parent / "fixtures/segmented-public-workload.json").read_text()
+    )
+    calls = []
+
+    def post(url, endpoint, item):
+        calls.append(item.name)
+        answer = copy.deepcopy(responses[item.name])
+        answer["stats"]["input_sha256"] = hashlib.sha256(item.raw).hexdigest()
+        return 200, json.dumps(answer).encode(), 0
+
+    monkeypatch.setattr(e2e, "post", post)
+    scene = segmented_wall_scene(segments)
+    item = e2e.SceneInput("surveyed wall", scene, json.dumps(scene).encode())
+    meter = WorkMeter()
+    record = e2e.judge(
+        "unused", e2e.Endpoint("/place", "application/json"), item, SCHEMAS, RULES, meter=meter
+    )
+    assert record["status"] == "pass", record["problems"]
+    assert calls.count("surveyed wall") == 2
+    assert "surveyed wall~mirrored" in calls
+    return meter.samples
+
+
+@pytest.mark.parametrize("segments", [13, 20])
+def test_full_judge_accepts_equivalent_segmented_walls(monkeypatch, segments):
+    baseline = workload(monkeypatch, 1)
+    actual = workload(monkeypatch, segments)
+    assert actual < baseline * 1.2
+
+
+def test_identical_resend_counts_are_checked_before_comparison(monkeypatch):
+    responses = json.loads(
+        (Path(__file__).parent / "fixtures/segmented-public-workload.json").read_text()
+    )
+    original = copy.deepcopy(responses["surveyed wall"])
+    oversized = original | {"checks": [None] * (MAX_RESULT_CHECKS + 1)}
+    replies = iter((original, oversized))
+    scene = segmented_wall_scene(1)
+    item = e2e.SceneInput("surveyed wall", scene, json.dumps(scene).encode())
+    original["stats"]["input_sha256"] = hashlib.sha256(item.raw).hexdigest()
+    monkeypatch.setattr(e2e, "post", lambda *args: (200, json.dumps(next(replies)).encode(), 0))
+    # Other transforms are immaterial to the identical-resend admission control.
+    monkeypatch.setattr(e2e, "mirror_scene", lambda value: value)
+    monkeypatch.setattr(e2e, "answer", lambda *args: (None, "transform omitted by test"))
+    record = e2e.judge("unused", e2e.Endpoint("/place", "application/json"), item, SCHEMAS, RULES)
+    assert any(
+        "identical resend: result ingestion limit exceeded: checks" in problem
+        for problem in record["problems"]
+    )
+    assert ingestion_problems(oversized, "result")
diff --git a/verification/tests/test_metadata_bounds.py b/verification/tests/test_metadata_bounds.py
new file mode 100644
index 000000000..e88cc657e
--- /dev/null
+++ b/verification/tests/test_metadata_bounds.py
@@ -0,0 +1,183 @@
+"""Metadata admission and lookup costs for large, schema-shaped responses."""
+
+import ast
+import copy
+import inspect
+import json
+from pathlib import Path
+
+import pytest
+from test_resultcheck import RULES, SCENE, check, result
+
+import hsverify.resultcheck as checks
+
+
+class ComparedName(str):
+    comparisons = 0
+
+    def __eq__(self, other):
+        type(self).comparisons += 1
+        if type(self).comparisons > 100_000:
+            raise AssertionError("metadata lookup performed more than 100,000 comparisons")
+        return super().__eq__(other)
+
+    __hash__ = str.__hash__
+
+
+def test_distinct_evidence_ids_use_linear_name_lookups():
+    names = [ComparedName(f"clearance_{i}") for i in range(12_000)]
+    answer = result(spot=False, checks=[], complete=False)
+    answer["reasons"] = [{"code": "unobserved_area", "message": ""}]
+    answer["checks"] = [
+        check(outcome="unsure", measured=None, cause="unobserved") | {"id": name} for name in names
+    ]
+    answer["missing_evidence"] = [
+        {"kind": "band", "band": "ground", "checks": [name], "message": ""} for name in names
+    ]
+    ComparedName.comparisons = 0
+    assert checks.missing_evidence_problems(SCENE, answer) == []
+    assert ComparedName.comparisons < 4 * len(names)
+
+
+def test_invalid_width_message_deduplication_is_linear():
+    # Instrument only the diagnostic buffer. The old list-membership search calls
+    # ComparedName.__eq__ for every previous diagnostic; hash deduplication does not.
+    class DiagnosticBuffer(list):
+        def append(self, message):
+            super().append(ComparedName(message))
+
+    class InstrumentBuffer(ast.NodeTransformer):
+        def visit_Assign(self, node):
+            if any(isinstance(t, ast.Name) and t.id == "problems" for t in node.targets):
+                node.value = ast.Call(
+                    func=ast.Name(id="DiagnosticBuffer", ctx=ast.Load()), args=[], keywords=[]
+                )
+            return node
+
+    source = ast.parse(inspect.getsource(checks.reported_dimension_problems))
+    source = ast.fix_missing_locations(InstrumentBuffer().visit(source))
+    scope = checks.reported_dimension_problems.__globals__ | {"DiagnosticBuffer": DiagnosticBuffer}
+    exec(compile(source, "<instrumented dimension validation>", "exec"), scope)
+    answer = result(spot=False, checks=[], complete=False)
+    answer["checks"] = [
+        check(threshold=-1) | {"id": f"width_{i}", "rule": {"key": "battery.width_ft"}}
+        for i in range(4_000)
+    ]
+    ComparedName.comparisons = 0
+    problems = scope["reported_dimension_problems"](answer, RULES)
+    assert len(problems) == 4_000
+    assert problems[0] == "width_0 must be finite and positive"
+    assert problems[-1] == "width_3999 must be finite and positive"
+    assert ComparedName.comparisons < 4 * len(problems)
+
+
+@pytest.mark.parametrize(
+    ("field", "limit"),
+    [
+        ("sweep", checks.MAX_RESULT_RUNS),
+        ("checks", checks.MAX_RESULT_CHECKS),
+        ("missing_evidence", checks.MAX_EVIDENCE_REQUESTS),
+    ],
+)
+def test_result_count_caps_accept_boundary_and_reject_next(field, limit):
+    answer = {field: [None] * limit}
+    assert checks.ingestion_problems(answer, "result") == []
+    answer[field].append(None)
+    assert checks.ingestion_problems(answer, "result") == [
+        f"result ingestion limit exceeded: {field} exceeds {limit} entries"
+    ]
+
+
+@pytest.mark.parametrize("field", ["sweep", "checks", "missing_evidence"])
+def test_named_result_caps_allow_schema_valid_responses(field):
+    fixture = json.loads((Path(__file__).parent / "fixtures/wide-public-pass.json").read_text())
+    answer = copy.deepcopy(fixture["result"])
+    request = {"kind": "band", "message": "", "band": "ground", "checks": ["ground_surface"]}
+    first_check = answer["checks"][0]
+    first_check.update(label="", reason="", rule={"key": "", "source": "", "placeholder": False})
+    entries = {
+        "sweep": (answer["sweep"][0], checks.MAX_RESULT_RUNS),
+        "checks": (first_check, checks.MAX_RESULT_CHECKS),
+        "missing_evidence": (request, checks.MAX_EVIDENCE_REQUESTS),
+    }
+    entry, limit = entries[field]
+    answer[field] = (
+        answer[field] + [entry] * (limit - len(answer[field]))
+        if field == "checks"
+        else [entry] * limit
+    )
+    schema = json.loads(
+        (Path(__file__).parents[2] / "server/schemas/result.schema.json").read_text()
+    )
+    assert checks.schema_errors(answer, schema) == []
+    rules = checks.RuleSet.from_yaml((Path(__file__).parents[2] / "server/rules.yaml").read_text())
+    assert checks.invariant_problems(fixture["scene"], answer, rules=rules) == []
+
+
+def test_scene_geometry_counts_keep_existing_schema_caps():
+    wall = {"id": "wall", "baseline": [[0, 0]] * 500}
+    scene = {"walls": [wall] * 50}
+    assert checks.ingestion_problems(scene, "scene") == []
+    scene["walls"].append(wall)
+    assert "walls exceeds 50 entries" in checks.ingestion_problems(scene, "scene")[0]
+    assert (
+        "baseline exceeds 500 vertices"
+        in checks.ingestion_problems({"walls": [wall | {"baseline": [[0, 0]] * 501}]}, "scene")[0]
+    )
+
+
+@pytest.mark.parametrize(
+    ("value", "message"),
+    [
+        ([0] * checks.MAX_NUMERIC_LEAVES, "numeric leaves"),
+        ([None] * (checks.MAX_METADATA_NODES - 1), "JSON nodes"),
+        ("x" * checks.MAX_METADATA_CHARACTERS, "characters"),
+    ],
+)
+def test_generic_metadata_caps_accept_boundary_and_reject_next(value, message):
+    assert checks.ingestion_problems(value) == []
+    over = value + ("x" if isinstance(value, str) else [value[0]])
+    assert message in checks.ingestion_problems(over)[0]
+
+
+def test_nesting_cap_precedes_recursive_schema_validation(monkeypatch):
+    nested = 0
+    for _ in range(checks.MAX_METADATA_DEPTH):
+        nested = [nested]
+    assert checks.ingestion_problems(nested) == []
+
+    def unexpected_validator(*args):
+        pytest.fail("oversized metadata reached recursive schema validation")
+
+    monkeypatch.setattr(checks, "Draft202012Validator", unexpected_validator)
+    assert checks.schema_errors([nested], {}) == [
+        f"document ingestion limit exceeded: nesting exceeds {checks.MAX_METADATA_DEPTH}"
+    ]
+
+
+def test_ingestion_failure_precedes_geometry(monkeypatch):
+    def unexpected_dimensions(*args):
+        pytest.fail("oversized metadata reached dimension validation")
+
+    monkeypatch.setattr(checks, "reported_dimension_problems", unexpected_dimensions)
+    answer = {"checks": [None] * (checks.MAX_RESULT_CHECKS + 1)}
+    assert checks.geometry_admission_problems(SCENE, answer, RULES) == [
+        f"result ingestion limit exceeded: checks exceeds {checks.MAX_RESULT_CHECKS} entries"
+    ]
+
+
+def test_invalid_schema_stops_after_bounded_diagnostics():
+    errors = checks.schema_errors([None] * 10_000, {"type": "array", "items": {"type": "number"}})
+    assert len(errors) == checks.MAX_SCHEMA_PROBLEMS
+
+
+def test_case_queries_have_a_fixed_scan_bound():
+    at_cap = {f"rule_{i}": 0 for i in range(checks.MAX_CASE_RULE_QUERIES)}
+    assert checks.case_metadata_problems(at_cap) == []
+    at_cap["one_more"] = 0
+    assert checks.case_metadata_problems(at_cap) == [
+        "case ingestion limit exceeded: more than 64 rule queries"
+    ]
+    assert checks.expectation_problems(
+        {"checks": [{"match": "gas"}] * (checks.MAX_CASE_RULE_QUERIES + 1)}, {}
+    ) == ["case ingestion limit exceeded: more than 64 rule queries"]
diff --git a/verification/tests/test_runtime_meter.py b/verification/tests/test_runtime_meter.py
index 43132a99f..cc7cef084 100644
--- a/verification/tests/test_runtime_meter.py
+++ b/verification/tests/test_runtime_meter.py
@@ -78,12 +78,14 @@ def test_reach_cache_includes_geometry_and_parameters():
 
 
 def test_ground_grid_stops_at_shared_runtime_limit():
-    meter = WorkMeter(30)
+    meter = WorkMeter()
     plan = GroundPlan(SCENE, RULES, meter=meter)
+    setup = meter.samples
+    meter.limit = setup + 30
     with pytest.raises(WorkLimitExceeded) as caught:
         plan.covers(2, 1, 3, 0, lambda _: 2)
-    assert caught.value.samples == meter.samples == 31
-    assert str(caught.value) == "verification work limit exceeded (31 samples)"
+    assert caught.value.samples == meter.samples == setup + 31
+    assert str(caught.value) == f"verification work limit exceeded ({setup + 31} samples)"
 
 
 def test_valid_wide_direct_coverage_uses_only_visited_work():
diff --git a/verification/tests/test_scene_cache.py b/verification/tests/test_scene_cache.py
new file mode 100644
index 000000000..af18ea263
--- /dev/null
+++ b/verification/tests/test_scene_cache.py
@@ -0,0 +1,81 @@
+import copy
+import json
+from dataclasses import replace
+from pathlib import Path
+
+import pytest
+from segmented_wall import segmented_wall_scene
+from test_resultcheck import RULES, SCENE
+
+from hsverify.resultcheck import (
+    RuleSet,
+    WorkMeter,
+    ground_plan,
+    invariant_problems,
+    schema_errors,
+    segments_s,
+    slide,
+    wall_spans_s,
+)
+
+
+@pytest.mark.parametrize("segments_per_wall", [13, 20])
+def test_public_pass_is_independent_of_redundant_baseline_vertices(segments_per_wall):
+    # Public solve(parse_scene(...), rules_from_dict(public YAML)) produced this
+    # 815-candidate, 26-run response. The geometry is unchanged by extra vertices.
+    fixture = json.loads(
+        (Path(__file__).parent / "fixtures/segmented-public-pass.json").read_text()
+    )
+    rules = RuleSet.from_yaml((Path(__file__).parents[2] / "server/rules.yaml").read_text())
+    answer = fixture["result"]
+    baseline_meter = WorkMeter()
+    assert invariant_problems(fixture["scene"], answer, rules=rules, meter=baseline_meter) == []
+    scene = segmented_wall_scene(segments_per_wall)
+    for kind, value in (("scene", scene), ("result", answer)):
+        schema = json.loads(
+            (Path(__file__).parents[2] / f"server/schemas/{kind}.schema.json").read_text()
+        )
+        assert schema_errors(value, schema) == []
+    meter = WorkMeter()
+    assert invariant_problems(scene, answer, rules=rules, meter=meter) == []
+    # Metadata grows with the input, but actual geometry work must not multiply
+    # with redundant baseline vertices. Leave room for the bounded input scan.
+    assert meter.samples < baseline_meter.samples * 1.2
+    assert all(key[0] != "ground_strips" for key in meter.cache)
+
+
+def test_scene_derivatives_are_built_once_per_judgment():
+    scene = segmented_wall_scene(20)
+    meter = WorkMeter()
+    segments = segments_s(scene, RULES, meter=meter)
+    spans = wall_spans_s(scene, RULES, meter=meter)
+    plan = ground_plan(scene, RULES, meter)
+    once = meter.samples
+    assert segments_s(scene, RULES, meter=meter) is segments
+    assert wall_spans_s(scene, RULES, meter=meter) is spans
+    assert ground_plan(scene, RULES, meter) is plan
+    assert meter.samples == once
+    assert len(segments) == 20
+    assert len({segment[0] for segment in segments}) == 20
+    assert all(key[0] != "ground_strips" for key in meter.cache)
+
+
+def test_collinear_merge_keeps_actual_turns_and_wall_error_sources():
+    scene = copy.deepcopy(SCENE)
+    scene["walls"] = [
+        {"id": "w1", "baseline": [[0, 0], [2, 0], [4, 0], [4, 4]], "plus_minus_ft": 0.1},
+        {"id": "w2", "baseline": [[4, 4], [4, 6], [4, 8]], "plus_minus_ft": 0.2},
+    ]
+    scene["meter"].update(pos=[0, 4, 0], wall_id="w1", plus_minus_ft=0)
+    rules = replace(RULES, wall_join_ft=0.1)
+    meter = WorkMeter()
+    segments = segments_s(scene, rules, meter=meter)
+    assert [(wid, a, b) for wid, a, b, _, _ in segments] == [
+        ("w1", 0, 4),
+        ("w1", 4, 8),
+        ("w2", 8, 12),
+    ]
+    assert slide(scene, rules, 9, 10, meter=meter) == pytest.approx(0.1 * 2**0.5)
+    once = meter.samples
+    assert slide(scene, rules, 9, 10, meter=meter) == pytest.approx(0.1 * 2**0.5)
+    assert meter.samples == once

From a7b3169fefce72375f868e51565d30b000889941 Mon Sep 17 00:00:00 2001
From: SamGu-NRX <sgu07966@gmail.com>
Date: Wed, 14 Oct 2026 15:37:38 -0500
Subject: [PATCH 57/62] fix(pipeline): verify reported rules and repair
 encrypted caches

---
 recon/recon/depth.py                       |   2 +
 recon/tests/test_review_debt.py            |  21 +++-
 verification/hsverify/e2e.py               |  87 +++++++++++++---
 verification/hsverify/resultcheck.py       | 112 +++++++++++++++-----
 verification/tests/test_generate_cases.py  |   2 +-
 verification/tests/test_metadata_bounds.py |   5 +
 verification/tests/test_reported_rules.py  | 114 +++++++++++++++++++++
 verification/tests/test_resultcheck.py     |  11 +-
 8 files changed, 306 insertions(+), 48 deletions(-)
 create mode 100644 verification/tests/test_reported_rules.py

diff --git a/recon/recon/depth.py b/recon/recon/depth.py
index 70c49b2c2..7635a6afe 100644
--- a/recon/recon/depth.py
+++ b/recon/recon/depth.py
@@ -217,6 +217,8 @@ def _moge_locked(capture: Capture, work: Path) -> dict[str, Depth]:
                 KeyError,
                 EOFError,
                 TypeError,
+                # A damaged ZIP encryption flag makes NumPy request a password.
+                RuntimeError,
                 # ZIP corruption can name an unsupported compression method.
                 NotImplementedError,
                 zipfile.BadZipFile,
diff --git a/recon/tests/test_review_debt.py b/recon/tests/test_review_debt.py
index 372d6edf0..cda455e42 100644
--- a/recon/tests/test_review_debt.py
+++ b/recon/tests/test_review_debt.py
@@ -206,6 +206,18 @@ def unsupported_compression_npz() -> bytes:
     return bytes(raw)
 
 
+def encrypted_flag_npz() -> bytes:
+    archive = io.BytesIO()
+    np.savez(archive, depth=np.ones((2, 2), np.float32))
+    raw = bytearray(archive.getvalue())
+    central = raw.index(b"PK\x01\x02")
+    # Corrupt only the directory's encryption bit. zipfile uses that bit when
+    # NumPy reads depth.npy, so a normal cache read now asks for a password.
+    flags = struct.unpack_from("<H", raw, central + 8)[0]
+    struct.pack_into("<H", raw, central + 8, flags | 1)
+    return bytes(raw)
+
+
 @pytest.mark.parametrize(
     "bad",
     [
@@ -213,8 +225,15 @@ def unsupported_compression_npz() -> bytes:
         b"not an npz",
         corrupt_compressed_npz(),
         unsupported_compression_npz(),
+        encrypted_flag_npz(),
+    ],
+    ids=[
+        "truncated_zip",
+        "not_npz",
+        "damaged_deflate",
+        "unsupported_compression",
+        "encrypted_flag",
     ],
-    ids=["truncated_zip", "not_npz", "damaged_deflate", "unsupported_compression"],
 )
 def test_corrupt_moge_cache_is_recomputed(tmp_path, monkeypatch, bad):
     capture = _capture_named_scan(tmp_path, 10)
diff --git a/verification/hsverify/e2e.py b/verification/hsverify/e2e.py
index 45e539244..593cb9b5a 100644
--- a/verification/hsverify/e2e.py
+++ b/verification/hsverify/e2e.py
@@ -74,6 +74,8 @@
     mirror_scene,
     more_error_problems,
     outcome_lengths,
+    public_assumption_warnings,
+    reported_rules,
     schema_errors,
     tape_to_tap,
     unobserved_checks,
@@ -517,7 +519,7 @@ def judge(
         failure = [
             f"HTTP {status} for a scene that validates: {payload[:500]!r}"
             if status is not None
-            else f"no answer within 60 s: {payload[:200]!r}"
+            else payload.decode(errors="replace")[:200]
         ]
         return record | {"status": "fail", "problems": failure, "contract_problems": failure}
     result = parse_result(payload)
@@ -552,29 +554,53 @@ def check(name: str, function: Callable[[], list[str]]) -> list[str]:
         lambda: geometry_admission_problems(item.scene, result, rules, meter=meter),
     )
     admitted = not contract
+    mismatches: list[str] = []
+    warnings: list[str] = []
+    active_rules = rules
+    expected: list[str] = []
+    if admitted:
+
+        def check_reported_rules() -> list[str]:
+            nonlocal active_rules
+            mismatches.extend(assumption_mismatches(item.rules_assumed, result))
+            warnings.extend(public_assumption_warnings(item.rules_assumed, result, rules))
+            active_rules = reported_rules(result, rules)
+            return []
+
+        contract += check("reported rules", check_reported_rules)
+        admitted = not contract
+    if warnings:
+        record["rule_checks_unverified"] = True
     if admitted:
         contract += check(
             "invariants",
-            lambda: invariant_problems(item.scene, result, sent=item.raw, rules=rules, meter=meter),
+            lambda: invariant_problems(
+                item.scene,
+                result,
+                sent=item.raw,
+                rules=None if warnings else active_rules,
+                meter=meter,
+            ),
         )
     if not contract:
         contract += check(
             "properties",
-            lambda: property_problems(url, endpoint, item, result, schemas, rules, meter=meter),
+            lambda: property_problems(
+                url,
+                endpoint,
+                item,
+                result,
+                schemas,
+                active_rules,
+                meter=meter,
+                rule_checks=not warnings,
+            ),
         )
     if item.real and ms > LATENCY_BUDGET_MS:
         contract.append(f"real-derived scene took {ms:.0f} ms, budget {LATENCY_BUDGET_MS:.0f}")
-    mismatches: list[str] = []
-    expected: list[str] = []
     exhausted = any(p.startswith("verification work limit exceeded (") for p in contract)
     if admitted and not exhausted:
-
-        def check_assumptions() -> list[str]:
-            mismatches.extend(assumption_mismatches(item.rules_assumed, result, rules))
-            return []
-
-        contract += check("assumptions", check_assumptions)
-        if item.expect and not mismatches:
+        if item.expect and not mismatches and not warnings:
             expected = check(
                 "expectations", lambda: expectation_problems(item.expect, result, meter=meter)
             )
@@ -588,12 +614,20 @@ def summarize() -> list[str]:
         record["decision"] = result["decision"]
     if mismatches:
         record["assumption_mismatches"] = mismatches
+    if warnings:
+        record["assumption_warnings"] = warnings
     record["verification_samples"] = meter.samples
     record["contract_problems"] = contract
     record["expectation_problems"] = expected
     record["problems"] = contract + expected
     record["status"] = (
-        "fail" if record["problems"] else "assumption mismatch" if mismatches else "pass"
+        "fail"
+        if record["problems"]
+        else "assumption mismatch"
+        if mismatches
+        else "assumptions unverified"
+        if warnings
+        else "pass"
     )
     return record
 
@@ -639,8 +673,9 @@ def resend(name: str, scene: dict) -> dict | None:
                 problems.extend(f"{name}: {p}" for p in admission)
                 return None
             check_name = "invariants"
+            variant_rules = reported_rules(other, rules) if rule_checks else None
             invariants = invariant_problems(
-                scene, other, sent=transformed.raw, rules=checked_rules, meter=meter
+                scene, other, sent=transformed.raw, rules=variant_rules, meter=meter
             )
             if invariants:
                 problems.extend(f"{name}: {p}" for p in invariants)
@@ -876,7 +911,12 @@ def write_report(out: Path, meta: dict, records: list[dict]) -> dict:
     contract_problems = sum(len(r.get("contract_problems", [])) for r in records)
     killed = bool(meta["peak_memory"].get("server_killed"))
     all_passed = all(r["status"] == "pass" for r in records) and bool(checked) and not killed
-    contract_ok = bool(checked) and contract_problems == 0 and not killed
+    contract_ok = (
+        bool(checked)
+        and contract_problems == 0
+        and not killed
+        and not any(r.get("rule_checks_unverified") for r in checked)
+    )
     executed = sorted(
         {r["name"] for r in records if r.get("hostile") and r.get("hostile_probe_executed") is True}
     )
@@ -935,7 +975,11 @@ def write_report(out: Path, meta: dict, records: list[dict]) -> dict:
         "| --- | --- | --- | --- | --- |",
     ]
     for r in records:
-        issues = "; ".join(r.get("problems", []) + r.get("assumption_mismatches", []))
+        issues = "; ".join(
+            r.get("problems", [])
+            + r.get("assumption_mismatches", [])
+            + r.get("assumption_warnings", [])
+        )
         issues = issues or r.get("skip_reason", "")
         lines.append(
             f"| {r['name']}{' (real)' if r.get('real') else ''} | {r['status']} | "
@@ -1054,7 +1098,16 @@ def main(argv: list[str] | None = None) -> int:
     }
     report = write_report(out, meta, records)
     print(f"Report: {out / 'report.md'}")
-    return 0 if report["all_passed"] else 1
+    if report["all_passed"]:
+        return 0
+    # An unreported override is incomplete evidence, not a proven server failure.
+    if (
+        not meta["peak_memory"].get("server_killed")
+        and all(r["status"] in ("pass", "assumptions unverified") for r in records)
+        and any(r["status"] == "assumptions unverified" for r in records)
+    ):
+        return 2
+    return 1
 
 
 if __name__ == "__main__":
diff --git a/verification/hsverify/resultcheck.py b/verification/hsverify/resultcheck.py
index 8ca930ae9..07ffd4c77 100644
--- a/verification/hsverify/resultcheck.py
+++ b/verification/hsverify/resultcheck.py
@@ -31,7 +31,7 @@
 import json
 import math
 from collections.abc import Callable, Iterator
-from dataclasses import dataclass
+from dataclasses import dataclass, replace
 from typing import Any
 
 import yaml
@@ -75,9 +75,9 @@
 # Bound verifier work even when a server span or rules step requests billions of samples.
 MAX_SWEEP_SAMPLES = 10_000
 # On 2026-10-14, after caching scene derivatives and deferring ground fallback,
-# 35 valid public fixture judgments including property variants peaked at 30,913
+# 35 valid public fixture judgments including property variants peaked at 31,649
 # units. Twenty measurements of 20 four-foot walls at 1/4/12/13/20 subdivisions,
-# original and mirrored, including full-judge resends, peaked at 87,427 units.
+# original and mirrored, including full-judge resends, peaked at 88,999 units.
 # Another 468 distinct saved responses peaked at 391,700 invariant units on ETH3D
 # facade. Allow 20 times that largest measured valid workload for other scans and
 # their variants. This is an operational margin, not physical-error calibration.
@@ -144,7 +144,7 @@ def _input_key(value: Any, meter: WorkMeter | None = None) -> Any:
     if isinstance(value, (tuple, list)):
         return tuple(_input_key(item, meter) for item in value)
     if isinstance(value, RuleSet):
-        return _input_key(vars(value), meter)
+        return _input_key({k: v for k, v in vars(value).items() if k != "rules_sha256"}, meter)
     if isinstance(value, Need):
         return _input_key(vars(value), meter)
     return value
@@ -204,6 +204,7 @@ class RuleSet:
     # the rules' headroom.min_ft: how high a wall view without out_ft reached
     headroom_ft: float | None = None
     corner_allowance_ft: float | None = None
+    rules_sha256: str | None = None
 
     @classmethod
     def from_yaml(cls, text: str) -> RuleSet:
@@ -264,9 +265,33 @@ def reach(key: str) -> Need:
             value("battery", "height_ft"),
             headroom,
             value("route", "corner_allowance_ft"),
+            public_rules_fingerprint(data),
         )
 
 
+def public_rules_fingerprint(data: dict) -> str:
+    """Mirror public rules_from_dict's normalized JSON hash without importing the server."""
+
+    def normalize(value: Any) -> Any:
+        if isinstance(value, dict):
+            normalized = {key: normalize(item) for key, item in value.items()}
+            if "value" in normalized and "source" in normalized:
+                normalized["value"] = float(normalized["value"])
+                normalized.setdefault("placeholder", False)
+            return normalized
+        if isinstance(value, list):
+            return [normalize(item) for item in value]
+        return value
+
+    canonical = normalize(data)
+    canonical.get("policy", {}).setdefault("notice", None)
+    openings = canonical.get("openings", {})
+    if openings.get("exempt_bottom_above_ft") is not None:
+        openings["exempt_bottom_above_ft"] = float(openings["exempt_bottom_above_ft"])
+    payload = json.dumps(canonical, sort_keys=True, separators=(",", ":"))
+    return hashlib.sha256(payload.encode()).hexdigest()
+
+
 def ingestion_problems(instance: Any, kind: str | None = None) -> list[str]:
     """Bound metadata before validation or copies, using a depth-sized iterator stack."""
     if kind is None and isinstance(instance, dict):
@@ -1738,30 +1763,69 @@ def case_metadata_problems(assumed: dict, expect: dict | None = None) -> list[st
     return ingestion_problems({"assumed": assumed, "expect": expect}, "case")
 
 
-def assumption_mismatches(
-    assumed: dict[str, float], result: dict, rules: RuleSet | None = None
+def reported_assumption_values(key: str, result: dict) -> list[tuple[str, float]]:
+    """Rule values carried by C2 spots or check thresholds, without reading server files."""
+    values = []
+    if key == "battery_width":
+        for name in ("spot", "nearest_considered"):
+            spot = result.get(name)
+            if spot is not None and "width_ft" in spot:
+                values.append((f"{name}.width_ft", spot["width_ft"]))
+    rule_key = {
+        "battery_width": "battery.width_ft",
+        "corner_allowance": "route.corner_allowance_ft",
+    }.get(key)
+    for check in result.get("checks", []):
+        threshold = check.get("threshold_ft")
+        matches = check.get("rule", {}).get("key") == rule_key if rule_key else key in check["id"]
+        if matches and threshold is not None:
+            values.append((check["id"], threshold))
+    return values
+
+
+def reported_rules(result: dict, rules: RuleSet) -> RuleSet:
+    """Use reported geometry for invariants too, so public defaults cannot reject an override."""
+    if problems := reported_dimension_problems(result, rules):
+        raise ValueError("; ".join(problems))
+    changes = {}
+    for key, field in (("battery_width", "width_ft"), ("corner_allowance", "corner_allowance_ft")):
+        if values := reported_assumption_values(key, result):
+            changes[field] = values[0][1]
+    return replace(rules, **changes)
+
+
+def assumption_mismatches(assumed: dict[str, float], result: dict) -> list[str]:
+    if problems := case_metadata_problems(assumed):
+        return problems
+    return [
+        f"case assumes {key} threshold {value}, server's {source} uses {actual}"
+        for key, value in assumed.items()
+        for source, actual in reported_assumption_values(key, result)
+        if abs(actual - value) > EPS
+    ]
+
+
+def public_assumption_warnings(
+    assumed: dict[str, float], result: dict, rules: RuleSet
 ) -> list[str]:
     if problems := case_metadata_problems(assumed):
         return problems
-    out = []
-    configured = (
-        {"battery_width": rules.width_ft, "corner_allowance": rules.corner_allowance_ft}
-        if rules
-        else {}
+    configured = {"battery_width": rules.width_ft, "corner_allowance": rules.corner_allowance_ft}
+    policy = result.get("policy", {})
+    nonpublic = "private" in policy.get("sources", []) or (
+        rules.rules_sha256 is not None
+        and policy.get("rules_sha256") is not None
+        and policy["rules_sha256"] != rules.rules_sha256
     )
-    for key, value in assumed.items():
-        actual = configured.get(key)
-        if actual is not None and abs(actual - value) > EPS:
-            out.append(f"case assumes {key} {value}, rules use {actual}")
-    for key, value in assumed.items():
-        for check in result.get("checks", []):
-            threshold = check.get("threshold_ft")
-            if key in check["id"] and threshold is not None and abs(threshold - value) > EPS:
-                out.append(
-                    f"case assumes {key} threshold {value}, server's {check['id']} uses "
-                    f"{check['threshold_ft']}"
-                )
-    return out
+    return [
+        f"case assumes {key} {value}, public rules use {configured[key]}; "
+        "assumed public rules; server may override; result does not report this value, "
+        "so case expectations are unverified"
+        for key, value in assumed.items()
+        if configured.get(key) is not None
+        and not reported_assumption_values(key, result)
+        and (nonpublic or abs(configured[key] - value) > EPS)
+    ]
 
 
 def expectation_problems(expect: dict, result: dict, meter: WorkMeter | None = None) -> list[str]:
diff --git a/verification/tests/test_generate_cases.py b/verification/tests/test_generate_cases.py
index 89228e128..3cab47a0d 100644
--- a/verification/tests/test_generate_cases.py
+++ b/verification/tests/test_generate_cases.py
@@ -101,7 +101,7 @@ def forbidden(*args):
         {"scene": {}, "result": {}},
         rules,
     )
-    assert record["status"] == "assumption mismatch" and record["assumption_mismatches"]
+    assert record["status"] == "assumptions unverified" and record["assumption_warnings"]
     assert record["expectation_problems"] == []
     meta = {
         "peak_memory": {},
diff --git a/verification/tests/test_metadata_bounds.py b/verification/tests/test_metadata_bounds.py
index e88cc657e..12fd16e4a 100644
--- a/verification/tests/test_metadata_bounds.py
+++ b/verification/tests/test_metadata_bounds.py
@@ -110,6 +110,11 @@ def test_named_result_caps_allow_schema_valid_responses(field):
         (Path(__file__).parents[2] / "server/schemas/result.schema.json").read_text()
     )
     assert checks.schema_errors(answer, schema) == []
+    if field == "sweep":
+        answer["spot"] = answer["route"] = None
+        answer["decision"] = "reject"
+    elif field == "missing_evidence":
+        answer["decision"] = "manual_review"
     rules = checks.RuleSet.from_yaml((Path(__file__).parents[2] / "server/rules.yaml").read_text())
     assert checks.invariant_problems(fixture["scene"], answer, rules=rules) == []
 
diff --git a/verification/tests/test_reported_rules.py b/verification/tests/test_reported_rules.py
new file mode 100644
index 000000000..f09e6cd39
--- /dev/null
+++ b/verification/tests/test_reported_rules.py
@@ -0,0 +1,114 @@
+"""Reported geometry and policy identity determine whether rule assumptions are verified."""
+
+import copy
+import hashlib
+import json
+from dataclasses import replace
+from pathlib import Path
+
+import pytest
+from segmented_wall import segmented_wall_scene
+from test_judge_meter import META
+
+from hsverify import e2e
+from hsverify.resultcheck import RuleSet, public_assumption_warnings
+
+ROOT = Path(__file__).parents[2]
+RULES = RuleSet.from_yaml((ROOT / "server/rules.yaml").read_text())
+SCHEMAS = {
+    kind: json.loads((ROOT / f"server/schemas/{kind}.schema.json").read_text())
+    for kind in ("scene", "result")
+}
+
+
+def test_public_fingerprint_matches_recorded_public_solver():
+    fixture = json.loads(
+        (Path(__file__).parent / "fixtures/segmented-public-pass.json").read_text()
+    )
+    assert RULES.rules_sha256 == fixture["result"]["policy"]["rules_sha256"]
+
+
+@pytest.mark.parametrize("identity", ["private source", "different fingerprint"])
+def test_unreported_override_is_unverified_even_when_case_matches_public(identity):
+    answer = {"policy": {"sources": ["public"], "rules_sha256": RULES.rules_sha256}}
+    if identity == "private source":
+        answer["policy"]["sources"].append("private")
+    else:
+        answer["policy"]["rules_sha256"] = "f" * 64
+    warnings = public_assumption_warnings({"battery_width": RULES.width_ft}, answer, RULES)
+    assert len(warnings) == 1
+    assert "assumed public rules; server may override" in warnings[0]
+
+
+@pytest.mark.parametrize("matches", [True, False])
+def test_judge_compares_reported_width_with_case_assumption(monkeypatch, matches):
+    answers = json.loads(
+        (Path(__file__).parent / "fixtures/segmented-public-workload.json").read_text()
+    )
+
+    def post(url, endpoint, item):
+        answer = copy.deepcopy(answers[item.name])
+        answer["stats"]["input_sha256"] = hashlib.sha256(item.raw).hexdigest()
+        return 200, json.dumps(answer).encode(), 0
+
+    monkeypatch.setattr(e2e, "post", post)
+    scene = segmented_wall_scene(1)
+    item = e2e.SceneInput(
+        "surveyed wall",
+        scene,
+        json.dumps(scene).encode(),
+        rules_assumed={"battery_width": RULES.width_ft if matches else 4},
+    )
+    record = e2e.judge(
+        "unused",
+        e2e.Endpoint("/place", "application/json"),
+        item,
+        SCHEMAS,
+        replace(RULES, width_ft=4),
+    )
+    assert record["status"] == ("pass" if matches else "assumption mismatch")
+    assert bool(record.get("assumption_mismatches")) is not matches
+
+
+@pytest.mark.parametrize("identity", ["private source", "different fingerprint"])
+def test_unreported_private_width_cannot_claim_contract(monkeypatch, tmp_path, identity):
+    fixture = json.loads(
+        (Path(__file__).parent / "fixtures/segmented-public-pass.json").read_text()
+    )
+    answer = copy.deepcopy(fixture["result"])
+    answer.update(decision="reject", spot=None, route=None)
+    answer["reasons"] = [{"code": "policy_not_approved", "message": "Private rules reject"}]
+    answer["sweep"] = [
+        {
+            "wall_id": "w1",
+            "start_ft": [1, 1],
+            "outcome": "fail",
+            "failing": ["route_length"],
+            "unsure": [],
+        }
+    ]
+    answer["stats"].update(candidates=1, fail=1, unsure=0, **{"pass": 0})
+    for check in answer["checks"]:
+        check.update(outcome="fail", measured_ft=None, plus_minus_ft=None)
+    if identity == "private source":
+        answer["policy"]["sources"].append("private")
+    else:
+        answer["policy"]["rules_sha256"] = "f" * 64
+
+    def post(url, endpoint, item):
+        value = copy.deepcopy(answer)
+        value["stats"]["input_sha256"] = hashlib.sha256(item.raw).hexdigest()
+        return 200, json.dumps(value).encode(), 0
+
+    monkeypatch.setattr(e2e, "post", post)
+    scene = segmented_wall_scene(1)
+    item = e2e.SceneInput(
+        "private reject",
+        scene,
+        json.dumps(scene).encode(),
+        rules_assumed={"battery_width": RULES.width_ft},
+    )
+    record = e2e.judge("unused", e2e.Endpoint("/place", "application/json"), item, SCHEMAS, RULES)
+    assert record["status"] == "assumptions unverified", record["problems"]
+    assert record["rule_checks_unverified"]
+    assert not e2e.write_report(tmp_path, META, [record])["contract_ok"]
diff --git a/verification/tests/test_resultcheck.py b/verification/tests/test_resultcheck.py
index 640a36e61..962b53541 100644
--- a/verification/tests/test_resultcheck.py
+++ b/verification/tests/test_resultcheck.py
@@ -1502,13 +1502,14 @@ def test_ground_trimming_keeps_omitted_reach_at_zero():
     assert trimmed["coverage"]["observed"][0]["out_ft"] == 0
 
 
-def test_geometric_assumptions_compare_active_rules():
-    rules = replace(RULES, corner_allowance_ft=0.5)
-    assert (
-        len(assumption_mismatches({"battery_width": 100, "corner_allowance": 100}, {}, rules)) == 2
+def test_geometric_assumptions_compare_reported_rules():
+    answer = result()
+    answer["checks"].append(
+        {"id": "route_corner", "threshold_ft": 0.5, "rule": {"key": "route.corner_allowance_ft"}}
     )
+    assert len(assumption_mismatches({"battery_width": 100, "corner_allowance": 100}, answer)) == 2
     assert (
-        assumption_mismatches({"battery_width": rules.width_ft, "corner_allowance": 0.5}, {}, rules)
+        assumption_mismatches({"battery_width": RULES.width_ft, "corner_allowance": 0.5}, answer)
         == []
     )
 

From db1e4c2f931711fc3bf12af7e49c3364e27d8bc8 Mon Sep 17 00:00:00 2001
From: Sam Gu <127461594+SamGu-NRX@users.noreply.github.com>
Date: Wed, 14 Oct 2026 16:02:21 -0500
Subject: [PATCH 58/62] fix(verification): enforce public policy and validate
 case metadata

Keep loaded dimensions when the response claims the tested public fingerprint, including transformed responses. Reject malformed local case fields without losing the report.

Reviews: https://github.com/SamGu-NRX/BaseScanning/pull/240#discussion_r4276092143 https://github.com/SamGu-NRX/BaseScanning/pull/240#discussion_r4276060760
---
 verification/hsverify/e2e.py                |  11 +-
 verification/hsverify/resultcheck.py        |  70 ++++++++-
 verification/tests/test_policy_admission.py | 163 ++++++++++++++++++++
 verification/tests/test_reported_rules.py   |   1 +
 4 files changed, 241 insertions(+), 4 deletions(-)
 create mode 100644 verification/tests/test_policy_admission.py

diff --git a/verification/hsverify/e2e.py b/verification/hsverify/e2e.py
index 593cb9b5a..d9bf7e920 100644
--- a/verification/hsverify/e2e.py
+++ b/verification/hsverify/e2e.py
@@ -75,6 +75,7 @@
     more_error_problems,
     outcome_lengths,
     public_assumption_warnings,
+    public_dimension_problems,
     reported_rules,
     schema_errors,
     tape_to_tap,
@@ -569,6 +570,8 @@ def check_reported_rules() -> list[str]:
 
         contract += check("reported rules", check_reported_rules)
         admitted = not contract
+        if admitted:
+            contract += check("public dimensions", lambda: public_dimension_problems(result, rules))
     if warnings:
         record["rule_checks_unverified"] = True
     if admitted:
@@ -594,6 +597,7 @@ def check_reported_rules() -> list[str]:
                 active_rules,
                 meter=meter,
                 rule_checks=not warnings,
+                public_rules=rules,
             ),
         )
     if item.real and ms > LATENCY_BUDGET_MS:
@@ -642,11 +646,13 @@ def property_problems(
     *,
     meter: WorkMeter | None = None,
     rule_checks: bool = True,
+    public_rules: RuleSet | None = None,
 ) -> list[str]:
     """The same scene resent unchanged and transformed. Every answer to a transformed scene must
     also satisfy the invariants, and the transforms that only lose information must not make
     the server surer."""
     meter = meter if meter is not None else WorkMeter()
+    public_rules = public_rules if public_rules is not None else rules
     checked_rules = rules if rule_checks else None
     if admission := geometry_admission_problems(item.scene, result, checked_rules, meter=meter):
         return admission
@@ -673,8 +679,9 @@ def resend(name: str, scene: dict) -> dict | None:
                 problems.extend(f"{name}: {p}" for p in admission)
                 return None
             check_name = "invariants"
-            variant_rules = reported_rules(other, rules) if rule_checks else None
-            invariants = invariant_problems(
+            variant_rules = reported_rules(other, public_rules) if rule_checks else None
+            dimensions = public_dimension_problems(other, public_rules) if rule_checks else []
+            invariants = dimensions + invariant_problems(
                 scene, other, sent=transformed.raw, rules=variant_rules, meter=meter
             )
             if invariants:
diff --git a/verification/hsverify/resultcheck.py b/verification/hsverify/resultcheck.py
index 07ffd4c77..1c030d6a0 100644
--- a/verification/hsverify/resultcheck.py
+++ b/verification/hsverify/resultcheck.py
@@ -1754,7 +1754,15 @@ def with_past_ends_asked(
 
 def case_metadata_problems(assumed: dict, expect: dict | None = None) -> list[str]:
     """Bound local case queries too: substring expectations scan the response once each."""
-    expect = expect or {}
+    if not isinstance(assumed, dict):
+        return ["case rules_assumed must be an object"]
+    if expect is None:
+        expect = {}
+    if not isinstance(expect, dict):
+        return ["case expect must be an object"]
+    for field in ("sweep_runs", "checks", "start_outcomes"):
+        if field in expect and not isinstance(expect[field], list):
+            return [f"case expect.{field} must be an array"]
     queries = len(assumed) + sum(
         len(expect.get(field, [])) for field in ("sweep_runs", "checks", "start_outcomes")
     )
@@ -1783,10 +1791,68 @@ def reported_assumption_values(key: str, result: dict) -> list[tuple[str, float]
     return values
 
 
+def reported_policy_overrides(result: dict, rules: RuleSet) -> bool:
+    """A reported fingerprint must identify a policy other than the loaded public rules."""
+    policy = result.get("policy", {})
+    fingerprint = policy.get("rules_sha256")
+    if not isinstance(fingerprint, str):
+        return False
+    if rules.rules_sha256 is not None:
+        return fingerprint != rules.rules_sha256
+    return "private" in policy.get("sources", [])
+
+
+def public_dimension_problems(result: dict, rules: RuleSet) -> list[str]:
+    if reported_policy_overrides(result, rules):
+        return []
+    values = []
+    for name in ("spot", "nearest_considered"):
+        spot = result.get(name)
+        if spot is not None:
+            for field, expected in (
+                ("width_ft", rules.width_ft),
+                ("depth_ft", rules.depth_ft),
+                ("height_ft", rules.battery_height_ft),
+            ):
+                if field in spot and expected is not None:
+                    values.append((f"{name}.{field}", spot[field], expected))
+    for key, expected in (
+        ("battery_width", rules.width_ft),
+        ("corner_allowance", rules.corner_allowance_ft),
+    ):
+        if expected is not None:
+            values.extend(
+                (source, actual, expected)
+                for source, actual in reported_assumption_values(key, result)
+            )
+    if result.get("route") is not None and "height_ft" in result["route"]:
+        values.append(("route.height_ft", result["route"]["height_ft"], rules.route_height_ft))
+    configured = {
+        "battery.depth_ft": rules.depth_ft,
+        "battery.height_ft": rules.battery_height_ft,
+        "route.height_ft": rules.route_height_ft,
+    }
+    for check in result.get("checks", []):
+        expected = configured.get(check.get("rule", {}).get("key"))
+        actual = check.get("threshold_ft")
+        if expected is not None and actual is not None:
+            values.append((check["id"], actual, expected))
+    # C2 rounds dimensions to six decimals; preserve that representation tolerance.
+    return _unique_messages(
+        [
+            f"{source} {actual} does not match loaded public rules {expected}"
+            for source, actual, expected in values
+            if abs(actual - expected) > NUMBER_TOL_FT
+        ]
+    )
+
+
 def reported_rules(result: dict, rules: RuleSet) -> RuleSet:
-    """Use reported geometry for invariants too, so public defaults cannot reject an override."""
+    """Use validated reported geometry only for an explicitly different policy."""
     if problems := reported_dimension_problems(result, rules):
         raise ValueError("; ".join(problems))
+    if not reported_policy_overrides(result, rules):
+        return rules
     changes = {}
     for key, field in (("battery_width", "width_ft"), ("corner_allowance", "corner_allowance_ft")):
         if values := reported_assumption_values(key, result):
diff --git a/verification/tests/test_policy_admission.py b/verification/tests/test_policy_admission.py
new file mode 100644
index 000000000..c09f9859f
--- /dev/null
+++ b/verification/tests/test_policy_admission.py
@@ -0,0 +1,163 @@
+import copy
+import hashlib
+import json
+from dataclasses import replace
+from pathlib import Path
+
+import pytest
+from segmented_wall import segmented_wall_scene
+from test_judge_meter import META
+
+from hsverify import e2e
+from hsverify.resultcheck import RuleSet, public_dimension_problems, reported_rules
+
+ROOT = Path(__file__).parents[2]
+RULES = RuleSet.from_yaml((ROOT / "server/rules.yaml").read_text())
+SCHEMAS = {
+    kind: json.loads((ROOT / f"server/schemas/{kind}.schema.json").read_text())
+    for kind in ("scene", "result")
+}
+
+
+def replies():
+    return json.loads(
+        (Path(__file__).parent / "fixtures/segmented-public-workload.json").read_text()
+    )
+
+
+@pytest.mark.parametrize("field", ["width_ft", "depth_ft", "height_ft"])
+def test_matching_public_policy_keeps_loaded_dimensions(field):
+    answer = replies()["surveyed wall"]
+    answer["spot"].pop("footprint")
+    answer["spot"].pop("span_ft")
+    answer["spot"][field] = 1
+    assert reported_rules(answer, RULES) is RULES
+
+
+@pytest.mark.parametrize("wrong", [False, True])
+def test_public_policy_width_is_checked_without_case_assumptions(monkeypatch, wrong):
+    answers = replies()
+    if wrong:
+        spot = answers["surveyed wall"]["spot"]
+        lo = spot["span_ft"][0]
+        spot.update(
+            width_ft=1,
+            span_ft=[lo, lo + 1],
+            footprint=[[lo, 0], [lo + 1, 0], [lo + 1, RULES.depth_ft], [lo, RULES.depth_ft]],
+            center=[lo + 0.5, RULES.depth_ft / 2],
+            meter_offset_ft=[lo + 0.5, RULES.depth_ft / 2],
+        )
+    seen_rules = []
+    original = e2e.invariant_problems
+
+    def invariant(*args, rules=None, **kwargs):
+        seen_rules.append(rules)
+        return original(*args, rules=rules, **kwargs)
+
+    def post(url, endpoint, item):
+        answer = copy.deepcopy(answers[item.name])
+        answer["stats"]["input_sha256"] = hashlib.sha256(item.raw).hexdigest()
+        return 200, json.dumps(answer).encode(), 0
+
+    monkeypatch.setattr(e2e, "post", post)
+    monkeypatch.setattr(e2e, "invariant_problems", invariant)
+    scene = segmented_wall_scene(1)
+    item = e2e.SceneInput("surveyed wall", scene, json.dumps(scene).encode())
+    record = e2e.judge("unused", e2e.Endpoint("/place", "application/json"), item, SCHEMAS, RULES)
+    assert record["status"] == ("fail" if wrong else "pass"), record["problems"]
+    assert seen_rules[0] is RULES
+    if wrong:
+        assert any("width_ft" in p and "public rules" in p for p in record["contract_problems"])
+
+
+@pytest.mark.parametrize("sources", [["public", "private"], ["public"]])
+def test_different_policy_keeps_validated_reported_width(sources):
+    answer = replies()["surveyed wall"]
+    answer["policy"].update(sources=sources, rules_sha256="f" * 64)
+    loaded = replace(RULES, width_ft=4)
+    assert reported_rules(answer, loaded).width_ft == answer["spot"]["width_ft"]
+
+
+def test_malformed_cases_are_reported_and_next_case_runs(monkeypatch, tmp_path):
+    scene = segmented_wall_scene(1)
+    cases = []
+    for name, metadata in (
+        ("null-assumptions", {"rules_assumed": None}),
+        ("null-checks", {"expect": {"checks": None}}),
+    ):
+        path = tmp_path / f"{name}.json"
+        path.write_text(json.dumps({"id": name, "scene": scene, "expect": {}, **metadata}))
+        cases.append(e2e.load_input(path))
+    cases.append(e2e.SceneInput("surveyed wall", scene, json.dumps(scene).encode()))
+    answers = replies()
+
+    def post(url, endpoint, item):
+        assert item.name.startswith("surveyed wall")
+        answer = copy.deepcopy(answers[item.name])
+        answer["stats"]["input_sha256"] = hashlib.sha256(item.raw).hexdigest()
+        return 200, json.dumps(answer).encode(), 0
+
+    monkeypatch.setattr(e2e, "post", post)
+    records = [
+        e2e.judge("unused", e2e.Endpoint("/place", "application/json"), item, SCHEMAS, RULES)
+        for item in cases
+    ]
+    assert [r["status"] for r in records] == ["bad input", "bad input", "pass"]
+    assert "rules_assumed" in records[0]["problems"][0]
+    assert "expect.checks" in records[1]["problems"][0]
+    (tmp_path / "report").mkdir()
+    e2e.write_report(tmp_path / "report", META, records)
+    saved = json.loads((tmp_path / "report/report.json").read_text())
+    assert len(saved["records"]) == 3
+    assert not saved["all_passed"]
+
+
+@pytest.mark.parametrize("name", ["spot", "nearest_considered"])
+@pytest.mark.parametrize("field", ["width_ft", "depth_ft", "height_ft"])
+def test_every_public_spot_dimension_is_compared(name, field):
+    answer = {"policy": {"rules_sha256": RULES.rules_sha256}, name: {field: 1}}
+    assert any(f"{name}.{field}" in p for p in public_dimension_problems(answer, RULES))
+
+
+def test_public_corner_allowance_and_route_height_are_compared():
+    answer = {
+        "policy": {"rules_sha256": RULES.rules_sha256},
+        "route": {"height_ft": 100},
+        "checks": [
+            {"id": "corner", "rule": {"key": "route.corner_allowance_ft"}, "threshold_ft": 100}
+        ],
+    }
+    problems = public_dimension_problems(answer, RULES)
+    assert any("route.height_ft" in p for p in problems)
+    assert any("corner" in p for p in problems)
+
+
+def test_private_marker_cannot_override_matching_fingerprint():
+    answer = replies()["surveyed wall"]
+    answer["policy"]["sources"].append("private")
+    assert reported_rules(answer, RULES) is RULES
+
+
+def test_missing_policy_cannot_override_loaded_dimensions():
+    answer = replies()["surveyed wall"]
+    answer.pop("policy")
+    assert reported_rules(answer, RULES) is RULES
+
+
+def test_transformed_public_response_uses_original_loaded_rules(monkeypatch):
+    answers = replies()
+    loaded = replace(RULES, width_ft=4)
+
+    def post(url, endpoint, item):
+        answer = copy.deepcopy(answers[item.name])
+        answer["stats"]["input_sha256"] = hashlib.sha256(item.raw).hexdigest()
+        if not item.name.endswith("mirrored"):
+            answer["policy"].update(sources=["public", "private"], rules_sha256="f" * 64)
+        return 200, json.dumps(answer).encode(), 0
+
+    monkeypatch.setattr(e2e, "post", post)
+    scene = segmented_wall_scene(1)
+    item = e2e.SceneInput("surveyed wall", scene, json.dumps(scene).encode())
+    record = e2e.judge("unused", e2e.Endpoint("/place", "application/json"), item, SCHEMAS, loaded)
+    assert record["status"] == "fail"
+    assert any("mirrored" in p and "public rules" in p for p in record["contract_problems"])
diff --git a/verification/tests/test_reported_rules.py b/verification/tests/test_reported_rules.py
index f09e6cd39..64442f0e2 100644
--- a/verification/tests/test_reported_rules.py
+++ b/verification/tests/test_reported_rules.py
@@ -49,6 +49,7 @@ def test_judge_compares_reported_width_with_case_assumption(monkeypatch, matches
     def post(url, endpoint, item):
         answer = copy.deepcopy(answers[item.name])
         answer["stats"]["input_sha256"] = hashlib.sha256(item.raw).hexdigest()
+        answer["policy"].update(sources=["public", "private"], rules_sha256="f" * 64)
         return 200, json.dumps(answer).encode(), 0
 
     monkeypatch.setattr(e2e, "post", post)

From c557e3af387816f5ef5f3a430dacddf4311383ee Mon Sep 17 00:00:00 2001
From: Sam Gu <127461594+SamGu-NRX@users.noreply.github.com>
Date: Wed, 14 Oct 2026 16:05:55 -0500
Subject: [PATCH 59/62] test(verification): identify private override fixtures
 explicitly

---
 verification/tests/test_e2e.py         | 8 +++++++-
 verification/tests/test_resultcheck.py | 4 ++++
 2 files changed, 11 insertions(+), 1 deletion(-)

diff --git a/verification/tests/test_e2e.py b/verification/tests/test_e2e.py
index 96cc59631..f1dad3a4b 100644
--- a/verification/tests/test_e2e.py
+++ b/verification/tests/test_e2e.py
@@ -1105,7 +1105,13 @@ def fake_judge(url, endpoint, probe, *args):
 def test_judge_distinguishes_reported_override_mismatch_and_unverified_defaults(
     tmp_path, monkeypatch, reported_width, contract_failure
 ):
-    answer = {"decision": "manual_review", "spot": None, "checks": [], "sweep": []}
+    answer = {
+        "decision": "manual_review",
+        "spot": None,
+        "checks": [],
+        "sweep": [],
+        "policy": {"sources": ["private"], "rules_sha256": "f" * 64},
+    }
     if reported_width is not None:
         answer["checks"] = [
             {
diff --git a/verification/tests/test_resultcheck.py b/verification/tests/test_resultcheck.py
index 60cf16757..503b5ec01 100644
--- a/verification/tests/test_resultcheck.py
+++ b/verification/tests/test_resultcheck.py
@@ -1565,6 +1565,7 @@ def test_ground_trimming_keeps_omitted_reach_at_zero():
 def test_geometric_assumptions_use_reported_override_instead_of_public_defaults():
     public = replace(RULES, width_ft=4, corner_allowance_ft=10)
     answer = result()
+    answer["policy"] = {"sources": ["private"], "rules_sha256": "f" * 64}
     answer["checks"].append(
         {
             "id": "corner_allowance",
@@ -1628,6 +1629,7 @@ def test_reported_width_sources_override_public_width(source):
         if source == "check"
         else {source: {"width_ft": RULES.width_ft}}
     )
+    answer["policy"] = {"sources": ["private"], "rules_sha256": "f" * 64}
     assert reported_rules(answer, replace(RULES, width_ft=4)).width_ft == RULES.width_ft
     assert assumption_mismatches({"battery_width": RULES.width_ft}, answer) == []
 
@@ -1704,6 +1706,7 @@ def test_in_scan_sweep_with_tiny_rule_step_fails_loudly():
 def test_reported_override_prevents_a_false_footprint_failure():
     public = replace(RULES, width_ft=4)
     answer = result(spot=False, sweep=[pass_run(9, 9) | {"outcome": "unsure"}])
+    answer["policy"] = {"sources": ["private"], "rules_sha256": "f" * 64}
     backing = next(c for c in answer["checks"] if c["id"] == "wall_backing")
     backing["threshold_ft"] = RULES.width_ft
     backing["rule"]["key"] = "battery.width_ft"
@@ -1911,4 +1914,5 @@ def test_breadth_zero_or_positive_corner_allowance_is_valid(allowance):
             }
         ]
     }
+    answer["policy"] = {"sources": ["private"], "rules_sha256": "f" * 64}
     assert reported_rules(answer, RULES).corner_allowance_ft == allowance

From c32ee975f10ba75df9eb5e88f01aa2743fa648d3 Mon Sep 17 00:00:00 2001
From: Sam Gu <127461594+SamGu-NRX@users.noreply.github.com>
Date: Wed, 14 Oct 2026 16:26:39 -0500
Subject: [PATCH 60/62] fix(verification): bound diagnostics and harden numeric
 cache keys

Aggregate expectation failures with bounded examples and cap serialized diagnostic text across the report. Use exact string keys instead of adversarial numeric hashes. Make the pre-end sampling count explicit while preserving sampled starts.

Reviews: Astra resource addendum; https://github.com/SamGu-NRX/BaseScanning/pull/242#discussion_r4276295872 https://github.com/SamGu-NRX/BaseScanning/pull/242#discussion_r4276295884
---
 verification/hsverify/diagnostics.py          |  85 +++++++++
 verification/hsverify/e2e.py                  |   6 +
 verification/hsverify/intervalindex.py        |  34 +++-
 verification/hsverify/resultcheck.py          | 180 +++++++++++++-----
 verification/tests/test_diagnostic_limits.py  | 135 +++++++++++++
 verification/tests/test_numeric_cache_keys.py |  72 +++++++
 verification/tests/test_resultcheck.py        |   3 +-
 .../tests/test_sweep_sampling_contract.py     |  47 +++++
 8 files changed, 502 insertions(+), 60 deletions(-)
 create mode 100644 verification/hsverify/diagnostics.py
 create mode 100644 verification/tests/test_diagnostic_limits.py
 create mode 100644 verification/tests/test_numeric_cache_keys.py
 create mode 100644 verification/tests/test_sweep_sampling_contract.py

diff --git a/verification/hsverify/diagnostics.py b/verification/hsverify/diagnostics.py
new file mode 100644
index 000000000..ebdbec387
--- /dev/null
+++ b/verification/hsverify/diagnostics.py
@@ -0,0 +1,85 @@
+"""Bound diagnostic output independently of geometry work and input size."""
+
+import json
+
+# Operational output limits, not measured scan maxima: 1,000 messages and 256 KiB
+# leave a readable report without multiplying input-sized strings across cases.
+# Reserve one message and 128 characters for the omitted-message count.
+MAX_DIAGNOSTIC_COUNT = 1_000
+MAX_DIAGNOSTIC_CHARACTERS = 256 * 1024
+SUMMARY_RESERVE = 128
+MAX_EXPECTATION_EXAMPLES = 3
+
+
+class DiagnosticBudget:
+    def __init__(self) -> None:
+        self.count = 0
+        self.characters = 0
+        self.omitted = 0
+
+    def accept(self, message: str) -> bool:
+        prefix = "further problems omitted ("
+        if message.startswith(prefix) and message.endswith(")"):
+            count = message[len(prefix) : -1]
+            if len(count) <= 20 and count.isdecimal():
+                self.omitted += int(count)
+                return False
+        if (
+            self.omitted
+            or self.count >= MAX_DIAGNOSTIC_COUNT - 1
+            or self.characters + len(message) > MAX_DIAGNOSTIC_CHARACTERS - SUMMARY_RESERVE
+        ):
+            self.omitted += 1
+            return False
+        # JSON escapes control and non-ASCII characters; budget the saved text,
+        # not only the shorter Python string. The raw-length check above bounds
+        # this temporary encoding too.
+        characters = len(json.dumps(message))
+        if self.characters + characters > MAX_DIAGNOSTIC_CHARACTERS - SUMMARY_RESERVE:
+            self.omitted += 1
+            return False
+        self.count += 1
+        self.characters += characters
+        return True
+
+    def summary(self) -> list[str]:
+        return [f"further problems omitted ({self.omitted})"] if self.omitted else []
+
+
+class DiagnosticMessages:
+    def __init__(self) -> None:
+        self.budget = DiagnosticBudget()
+        self.messages: list[str] = []
+
+    def append(self, message: str, *values: object) -> None:
+        if self.budget.omitted:
+            self.budget.omitted += 1
+            return
+        if values:
+            message = message.format(*values)
+        if self.budget.accept(message):
+            self.messages.append(message)
+
+    def finish(self) -> list[str]:
+        return self.messages + self.budget.summary()
+
+
+def bounded_report_records(records: list[dict]) -> tuple[list[dict], list[str]]:
+    """Use one budget across cases and duplicate diagnostic fields in the JSON report."""
+    budget = DiagnosticBudget()
+    bounded = []
+    for record in records:
+        copy = dict(record)
+        for field in (
+            "contract_problems",
+            "expectation_problems",
+            "problems",
+            "assumption_mismatches",
+            "assumption_warnings",
+        ):
+            if field in copy:
+                copy[field] = [message for message in copy[field] if budget.accept(message)]
+        if copy.get("skip_reason") and not budget.accept(copy["skip_reason"]):
+            copy["skip_reason"] = ""
+        bounded.append(copy)
+    return bounded, budget.summary()
diff --git a/verification/hsverify/e2e.py b/verification/hsverify/e2e.py
index d9bf7e920..f5ebfa8b1 100644
--- a/verification/hsverify/e2e.py
+++ b/verification/hsverify/e2e.py
@@ -57,6 +57,7 @@
 
 from hsverify import gitref, memory
 from hsverify.bundle_limits import zip_directory_limits
+from hsverify.diagnostics import bounded_report_records
 from hsverify.memory import peak_rss_mb
 from hsverify.resultcheck import (
     RuleSet,
@@ -962,6 +963,10 @@ def write_report(out: Path, meta: dict, records: list[dict]) -> dict:
         "app_export_source": [r["source"] for r in exported],
         "records": records,
     }
+    records, omitted = bounded_report_records(records)
+    report["records"] = records
+    if omitted:
+        report["diagnostic_summary"] = omitted
     (out / "report.json").write_text(json.dumps(report, indent=2) + "\n")
     lines = [
         f"# End-to-end run against `{meta['server_ref']}` at `{meta['server_sha'][:12]}`",
@@ -992,6 +997,7 @@ def write_report(out: Path, meta: dict, records: list[dict]) -> dict:
             f"| {r['name']}{' (real)' if r.get('real') else ''} | {r['status']} | "
             f"{r.get('decision', '')} | {r.get('latency_ms', '')} | {issues.replace('|', '/')} |"
         )
+    lines.extend(omitted)
     (out / "report.md").write_text("\n".join(lines) + "\n")
     return report
 
diff --git a/verification/hsverify/intervalindex.py b/verification/hsverify/intervalindex.py
index 0a2e596c9..ced4e9ddd 100644
--- a/verification/hsverify/intervalindex.py
+++ b/verification/hsverify/intervalindex.py
@@ -3,10 +3,24 @@
 from __future__ import annotations
 
 import heapq
+import itertools
+import math
 from dataclasses import dataclass
 from typing import Protocol
 
 
+def numeric_key(value: int | float) -> str:
+    """Hash numbers as exact strings so adversarial JSON integers cannot collide cheaply.
+
+    Python hashes integers modulo a public prime. Rational form also keeps equal integer
+    and float inputs in one cache entry without rounding distinct large integers together.
+    """
+    if isinstance(value, float) and not math.isfinite(value):
+        return repr(value)
+    numerator, denominator = value.as_integer_ratio()
+    return f"{numerator}/{denominator}"
+
+
 class Meter(Protocol):
     def charge(self, n: int = 1) -> None: ...
 
@@ -61,8 +75,8 @@ def _build(self, runs: list[dict], eps: float) -> _WallIndex:
             _charge(self.meter)
             a, b = run["start_ft"]
             events.extend(((a - eps, 0, rank), (b + eps, 1, rank)))
-            starts.setdefault(a, run["outcome"])
-            ends.setdefault(b, run["outcome"])
+            starts.setdefault(numeric_key(a), (a, run["outcome"]))
+            ends.setdefault(numeric_key(b), (b, run["outcome"]))
         events.sort()
         active = [False] * len(runs)
         heap: list[int] = []
@@ -93,15 +107,15 @@ def first() -> str | None:
                 _charge(self.meter)
                 active[rank] = False
             after_endpoint.append(first())
-        start_values, end_values = sorted(starts), sorted(ends)
+        start_entries, end_entries = sorted(starts.values()), sorted(ends.values())
         return _WallIndex(
             endpoints,
             at_endpoint,
             after_endpoint,
-            start_values,
-            [starts[a] for a in start_values],
-            end_values,
-            [ends[b] for b in end_values],
+            [value for value, _ in start_entries],
+            [outcome for _, outcome in start_entries],
+            [value for value, _ in end_entries],
+            [outcome for _, outcome in end_entries],
         )
 
     def outcome_at(self, wall_id: str, start_ft: float) -> str | None:
@@ -129,16 +143,16 @@ def outcomes_near(self, wall_id: str, start_ft: float) -> tuple[set[str], str]:
 
 
 def probe_starts(*results: dict, meter: Meter | None = None) -> list[tuple[str, float]]:
-    points = set()
+    points = []
     for result in results:
         for run in result.get("sweep", []):
             _charge(meter, 3)
             a, b = run["start_ft"]
             # Halving first avoids overflowing the sum of two admitted finite endpoints.
-            points.update(
+            points.extend(
                 ((run["wall_id"], a), (run["wall_id"], b), (run["wall_id"], a / 2 + b / 2))
             )
-    return sorted(points)
+    return [point for point, _ in itertools.groupby(sorted(points))]
 
 
 def more_error_problems(
diff --git a/verification/hsverify/resultcheck.py b/verification/hsverify/resultcheck.py
index 1c030d6a0..4798990c0 100644
--- a/verification/hsverify/resultcheck.py
+++ b/verification/hsverify/resultcheck.py
@@ -37,8 +37,10 @@
 import yaml
 from jsonschema import Draft202012Validator
 
+from .diagnostics import MAX_EXPECTATION_EXAMPLES, DiagnosticMessages
 from .intervalindex import (
     SweepIndex,
+    numeric_key,
 )
 from .intervalindex import (
     less_coverage_problems as indexed_less_coverage_problems,
@@ -57,6 +59,7 @@
 # vertices per wall (C1's existing limits), 30,000 sweep runs, 16,000 checks and
 # 16,000 requests, 1,000,000 numeric leaves, 2,000,000 JSON nodes, depth 32, and
 # 4 MiB of string/key characters per document, and 64 case rule queries.
+# Diagnostic output has a separate shared report budget in diagnostics.py.
 # Case queries may scan the bounded response; their count is fixed. Other metadata
 # passes are linear or
 # O(n log n); geometry comparisons and samples charge the meter. These operational
@@ -147,6 +150,8 @@ def _input_key(value: Any, meter: WorkMeter | None = None) -> Any:
         return _input_key({k: v for k, v in vars(value).items() if k != "rules_sha256"}, meter)
     if isinstance(value, Need):
         return _input_key(vars(value), meter)
+    if isinstance(value, (int, float)) and not isinstance(value, bool):
+        return numeric_key(value).encode("ascii")
     return value
 
 
@@ -413,7 +418,14 @@ def observed(
     this category default at 6200098 (server/scene.py `observed_intervals`). None keeps the
     old reading, all the way up."""
     meter = meter if meter is not None else WorkMeter()
-    key = ("observed", meter.input_key(scene), band, min_out_ft, beyond, wall_default_ft)
+    key = (
+        "observed",
+        meter.input_key(scene),
+        band,
+        numeric_key(min_out_ft),
+        beyond,
+        None if wall_default_ft is None else numeric_key(wall_default_ft),
+    )
     if key in meter.cache:
         return meter.cache[key]
     spans = []
@@ -855,7 +867,13 @@ def slide(
     other wall between the meter and the battery's near edge, at its far end, times the same
     difference for that wall. 0 on the meter's own wall."""
     meter = meter if meter is not None else WorkMeter()
-    key = ("slide", meter.input_key(scene), meter.input_key(rules), lo, hi)
+    key = (
+        "slide",
+        meter.input_key(scene),
+        meter.input_key(rules),
+        numeric_key(lo),
+        numeric_key(hi),
+    )
     if key in meter.cache:
         return meter.cache[key]
     segments = segments_s(scene, rules, meter=meter)
@@ -929,7 +947,15 @@ def reach_gaps(
       the check's distance unless measured.
     """
     meter = meter if meter is not None else WorkMeter()
-    key = ("reach_gaps", meter.input_key(scene), meter.input_key(rules), check, wall_id, lo, hi)
+    key = (
+        "reach_gaps",
+        meter.input_key(scene),
+        meter.input_key(rules),
+        check,
+        wall_id,
+        numeric_key(lo),
+        numeric_key(hi),
+    )
     if key in meter.cache:
         return meter.cache[key]
     gaps = []
@@ -993,8 +1019,11 @@ def measured_band_gap(
             if m.get("wall_id", wall_id) == wall_id
         ],
     )
-    edges = {x for e in entries for x in e[:2]} | {x for m in measured for x in m}
-    cuts = sorted({lo, hi} | {x for x in edges if lo < x < hi})
+    edges = itertools.chain((x for e in entries for x in e[:2]), (x for m in measured for x in m))
+    cuts = [
+        value
+        for value, _ in itertools.groupby(sorted([lo, hi, *(x for x in edges if lo < x < hi)]))
+    ]
     for p, q in itertools.pairwise(cuts):
         meter.charge()
         if q - p <= EPS:
@@ -1019,7 +1048,7 @@ def measured_band_gap(
 
 
 def run_start_count(span: list[float], step_ft: float | None) -> int:
-    """Validate eagerly, then sample a run lazily: first, every step after it, and last.
+    """Count pre-end starts; run_starts appends the final endpoint separately.
 
     A sample, not the server's own list: the server also evaluates boundaries and midpoints
     that a run reports only as its two ends. Oversized runs fail rather than lose coverage
@@ -1036,13 +1065,13 @@ def run_start_count(span: list[float], step_ft: float | None) -> int:
     count = max(int(a < b), math.ceil(steps - EPS))
     if count + 1 > MAX_SWEEP_SAMPLES:
         raise ValueError(f"sweep sampling exceeds the {MAX_SWEEP_SAMPLES} sample limit")
-    return count + 1
+    return count
 
 
 def run_starts(span: list[float], step_ft: float | None) -> Iterator[float]:
     count = run_start_count(span, step_ft)
     a, b = span
-    return itertools.chain((a + k * step_ft for k in range(count - 1)), (b,))
+    return itertools.chain((a + k * step_ft for k in range(count)), (b,))
 
 
 def deduplicate_result_runs(result: dict) -> dict:
@@ -1323,7 +1352,12 @@ def ground_gap(
     meter = meter if meter is not None else WorkMeter()
     entries = band_entries(scene, "ground", meter)
     a, b = lo - radius, hi + radius
-    cuts = sorted({a, lo, hi, b} | {x for e in entries for x in e[:2] if a < x < b})
+    cuts = [
+        value
+        for value, _ in itertools.groupby(
+            sorted([a, lo, hi, b, *(x for e in entries for x in e[:2] if a < x < b)])
+        )
+    ]
     for p, q in itertools.pairwise(cuts):
         meter.charge()
         if q - p <= EPS:
@@ -1897,17 +1931,17 @@ def public_assumption_warnings(
 def expectation_problems(expect: dict, result: dict, meter: WorkMeter | None = None) -> list[str]:
     if admission := case_metadata_problems({}, expect):
         return admission
-    problems: list[str] = []
+    problems = DiagnosticMessages()
     decision = result["decision"]
     if "decision_in" in expect and decision not in expect["decision_in"]:
-        problems.append(f"decision {decision}, expected one of {expect['decision_in']}")
+        problems.append("decision {}, expected one of {}", decision, expect["decision_in"])
     if decision in expect.get("decision_not", []):
-        problems.append(f"decision {decision} is ruled out for this case")
+        problems.append("decision {} is ruled out for this case", decision)
 
     if "spot" in expect:
         want, spot = expect["spot"], result.get("spot")
         if want is None and spot is not None:
-            problems.append(f"expected no spot, got {spot['wall_id']} {spot['span_ft']}")
+            problems.append("expected no spot, got {} {}", spot["wall_id"], spot["span_ft"])
         if want is not None:
             if spot is None:
                 problems.append("expected a spot, got none")
@@ -1916,8 +1950,11 @@ def expectation_problems(expect: dict, result: dict, meter: WorkMeter | None = N
                 s0, s1 = spot["span_ft"]
                 if spot["wall_id"] != want["wall_id"] or s0 < a - 1 / 12 or s1 > b + 1 / 12:
                     problems.append(
-                        f"spot {spot['wall_id']} {spot['span_ft']} outside expected "
-                        f"{want['wall_id']} {want['span_within']}"
+                        "spot {} {} outside expected {} {}",
+                        spot["wall_id"],
+                        spot["span_ft"],
+                        want["wall_id"],
+                        want["span_within"],
                     )
 
     for rule in expect.get("sweep_runs", []):
@@ -1928,43 +1965,84 @@ def expectation_problems(expect: dict, result: dict, meter: WorkMeter | None = N
             if r["wall_id"] == rule["wall_id"] and r["start_ft"][0] < b and r["start_ft"][1] > a
         ]
         if not runs and "outcome" in rule:
-            problems.append(f"no sweep run overlaps {rule['wall_id']} starts ({a}, {b})")
+            problems.append("no sweep run overlaps {} starts ({}, {})", rule["wall_id"], a, b)
+        failed = 0
+        examples = []
         for run in runs:
-            if "outcome" in rule and run["outcome"] != rule["outcome"]:
-                problems.append(
-                    f"sweep {run['wall_id']} starts {run['start_ft']} is {run['outcome']}, "
-                    f"expected {rule['outcome']}"
+            wrong = (
+                ("outcome" in rule and run["outcome"] != rule["outcome"])
+                or ("outcome_not" in rule and run["outcome"] == rule["outcome_not"])
+                or any(
+                    key in rule and not any(rule[key] in check for check in run[field])
+                    for field, key in (("failing", "failing_match"), ("unsure", "unsure_match"))
                 )
-            if "outcome_not" in rule and run["outcome"] == rule["outcome_not"]:
-                why = f" ({rule['reason']})" if "reason" in rule else ""
-                problems.append(
-                    f"sweep {run['wall_id']} starts {run['start_ft']} is {run['outcome']}, "
-                    f"which this case rules out{why}"
-                )
-            for field, key in (("failing", "failing_match"), ("unsure", "unsure_match")):
-                if key in rule and not any(rule[key] in c for c in run[field]):
-                    problems.append(
-                        f"sweep {run['wall_id']} starts {run['start_ft']}: no {field} check "
-                        f"matching {rule[key]!r} (has {run[field]})"
+            )
+            if wrong:
+                failed += 1
+                if len(examples) < MAX_EXPECTATION_EXAMPLES:
+                    examples.append(
+                        f"{run['wall_id']} starts {run['start_ft']} is {run['outcome']}"
                     )
+        if failed:
+            required = {
+                key: rule[key]
+                for key in ("outcome", "outcome_not", "failing_match", "unsure_match")
+                if key in rule
+            }
+            why = f"; reason: {rule['reason']}" if "reason" in rule else ""
+            problems.append(
+                "sweep expectation {} starts ({}, {}) failed for {} runs; "
+                "expected {}; examples: {}{}",
+                rule["wall_id"],
+                a,
+                b,
+                failed,
+                required,
+                "; ".join(examples),
+                why,
+            )
 
     for rule in expect.get("checks", []):
         matching = [c for c in result.get("checks", []) if rule["match"] in c["id"]]
         if not matching:
-            problems.append(f"no check matching {rule['match']!r}")
+            problems.append("no check matching {!r}", rule["match"])
+        failed = 0
+        examples = []
         for check in matching:
-            for field in ("outcome", "unsure_cause"):
-                if field in rule and check.get(field) != rule[field]:
-                    problems.append(
-                        f"check {check['id']}: {field} {check.get(field)}, expected {rule[field]}"
+            wrong = [
+                field
+                for field in ("outcome", "unsure_cause")
+                if field in rule and check.get(field) != rule[field]
+            ]
+            # The public solver rounds measurements to six decimals.
+            wrong += [
+                field
+                for field in ("measured_ft", "plus_minus_ft")
+                if field in rule
+                and (check.get(field) is None or abs(check[field] - rule[field]) > NUMBER_TOL_FT)
+            ]
+            if wrong:
+                failed += 1
+                if len(examples) < MAX_EXPECTATION_EXAMPLES:
+                    examples.append(
+                        "; ".join(
+                            f"check {check['id']}: {field} {check.get(field)}, "
+                            f"expected {rule[field]}"
+                            for field in wrong
+                        )
                     )
-            # Pinned numbers catch a server that measures from somewhere else (for example
-            # another battery depth) and lands on the right outcome by accident. The server
-            # rounds to 6 decimals.
-            for field in ("measured_ft", "plus_minus_ft"):
-                got = check.get(field)
-                if field in rule and (got is None or abs(got - rule[field]) > NUMBER_TOL_FT):
-                    problems.append(f"check {check['id']}: {field} {got}, expected {rule[field]}")
+        if failed:
+            why = f"; reason: {rule['reason']}" if "reason" in rule else ""
+            if failed == 1:
+                problems.append("{}{}", examples[0], why)
+            else:
+                problems.append(
+                    "check expectation {!r} failed for {} checks; examples: {}{}",
+                    rule["match"],
+                    failed,
+                    "; ".join(examples),
+                    why,
+                )
 
     starts = expect.get("start_outcomes", [])
     index = SweepIndex(result, meter=meter) if starts else None
@@ -1973,19 +2051,23 @@ def expectation_problems(expect: dict, result: dict, meter: WorkMeter | None = N
         if got != rule["outcome"]:
             why = f" ({rule['why']})" if "why" in rule else ""
             problems.append(
-                f"start {rule['wall_id']} {rule['start_ft']} is {got or 'not evaluated'}, "
-                f"expected {rule['outcome']}{why}"
+                "start {} {} is {}, expected {}{}",
+                rule["wall_id"],
+                rule["start_ft"],
+                got or "not evaluated",
+                rule["outcome"],
+                why,
             )
 
     if "missing_evidence_empty" in expect:
         empty = not result.get("missing_evidence")
         if empty != expect["missing_evidence_empty"]:
             problems.append(
-                "missing_evidence "
-                + ("is empty" if empty else "is not empty")
-                + f", expected {'empty' if expect['missing_evidence_empty'] else 'requests'}"
+                "missing_evidence {}, expected {}",
+                "is empty" if empty else "is not empty",
+                "empty" if expect["missing_evidence_empty"] else "requests",
             )
-    return problems
+    return problems.finish()
 
 
 # --- Transforms for black-box properties -----------------------------------------------------
diff --git a/verification/tests/test_diagnostic_limits.py b/verification/tests/test_diagnostic_limits.py
new file mode 100644
index 000000000..7e3f16592
--- /dev/null
+++ b/verification/tests/test_diagnostic_limits.py
@@ -0,0 +1,135 @@
+import json
+
+import pytest
+from test_judge_meter import META
+
+from hsverify import e2e
+from hsverify.diagnostics import (
+    MAX_DIAGNOSTIC_CHARACTERS,
+    MAX_DIAGNOSTIC_COUNT,
+    MAX_EXPECTATION_EXAMPLES,
+    DiagnosticMessages,
+)
+from hsverify.resultcheck import expectation_problems
+
+
+def rejected_runs(count):
+    return {
+        "decision": "reject",
+        "sweep": [
+            {
+                "wall_id": "w1",
+                "start_ft": [i, i + 1],
+                "outcome": "fail",
+                "failing": [],
+                "unsure": [],
+            }
+            for i in range(count)
+        ],
+    }
+
+
+def test_repeated_sweep_failures_report_reason_once(tmp_path):
+    reason = "r" * 4_096
+    expected = {
+        "sweep_runs": [
+            {"wall_id": "w1", "start_ft": [0, 1001], "outcome_not": "fail", "reason": reason}
+        ]
+    }
+    problems = expectation_problems(expected, rejected_runs(1_000))
+    assert len(problems) == 1
+    assert "failed for 1000 runs" in problems[0]
+    assert problems[0].count(reason) == 1
+    assert problems[0].count(" is fail") == MAX_EXPECTATION_EXAMPLES
+    records = [
+        {
+            "name": "many runs",
+            "status": "fail",
+            "expectation_problems": problems,
+            "problems": problems,
+        }
+    ]
+    report = e2e.write_report(tmp_path, META, records)
+    assert len((tmp_path / "report.json").read_text()) < MAX_DIAGNOSTIC_CHARACTERS
+    assert len((tmp_path / "report.md").read_text()) < MAX_DIAGNOSTIC_CHARACTERS
+    assert not report["all_passed"]
+
+
+@pytest.mark.parametrize(
+    "message",
+    ["bad", "x" * 4_096, "\0" * 4_000, "🦉" * 4_000],
+    ids=["count", "ascii", "controls", "unicode"],
+)
+def test_one_report_budget_covers_every_case_and_duplicate_field(tmp_path, message):
+    records = [
+        {
+            "name": str(i),
+            "status": "fail",
+            "decision": "reject",
+            "problems": [message],
+            "contract_problems": [message],
+        }
+        for i in range(MAX_DIAGNOSTIC_COUNT)
+    ]
+    report = e2e.write_report(tmp_path, META, records)
+    messages = [
+        m for r in report["records"] for key in ("problems", "contract_problems") for m in r[key]
+    ]
+    messages += report["diagnostic_summary"]
+    assert len(messages) <= MAX_DIAGNOSTIC_COUNT
+    assert sum(len(json.dumps(message)) for message in messages) <= MAX_DIAGNOSTIC_CHARACTERS
+    kept = len(messages) - 1
+    assert report["diagnostic_summary"] == [f"further problems omitted ({2 * len(records) - kept})"]
+    assert (tmp_path / "report.md").read_text().count("further problems omitted (") == 1
+    assert (tmp_path / "report.json").read_text().count("further problems omitted (") == 1
+    assert report["contract_problem_count"] == len(records)
+    assert not report["contract_ok"]
+    assert all(r["problems"] == [message] for r in records)
+
+
+def test_oversized_reason_is_omitted_before_accumulating_output():
+    expected = {
+        "sweep_runs": [
+            {
+                "wall_id": "w1",
+                "start_ft": [0, 1001],
+                "outcome_not": "fail",
+                "reason": "r" * (3 * 1024 * 1024),
+            }
+        ]
+    }
+    assert expectation_problems(expected, rejected_runs(1_000)) == ["further problems omitted (1)"]
+
+
+def test_repeated_check_failures_are_aggregated_per_expectation():
+    result = {
+        "decision": "reject",
+        "checks": [{"id": f"check-{i}", "outcome": "fail"} for i in range(2_000)],
+    }
+    problems = expectation_problems({"checks": [{"match": "check", "outcome": "pass"}]}, result)
+    assert len(problems) <= MAX_DIAGNOSTIC_COUNT
+    assert sum(map(len, problems)) <= MAX_DIAGNOSTIC_CHARACTERS
+    assert len(problems) == 1
+    assert "failed for 2000 checks" in problems[0]
+    assert problems[0].count("expected pass") == MAX_EXPECTATION_EXAMPLES
+
+
+def test_report_coalesces_preexisting_omission_summaries(tmp_path):
+    collector = DiagnosticMessages()
+    collector.append("x" * MAX_DIAGNOSTIC_CHARACTERS)
+    records = [{"name": str(i), "status": "fail", "problems": collector.finish()} for i in range(3)]
+    report = e2e.write_report(tmp_path, META, records)
+    assert report["diagnostic_summary"] == ["further problems omitted (3)"]
+    assert json.dumps(report).count("further problems omitted (") == 1
+
+
+def test_diagnostic_budget_stops_formatting_after_exhaustion():
+    messages = DiagnosticMessages()
+    messages.append("x" * MAX_DIAGNOSTIC_CHARACTERS)
+
+    class ForbiddenFormat:
+        def __format__(self, spec):
+            raise AssertionError("formatting continued after diagnostic budget exhaustion")
+
+    messages.append("{}", ForbiddenFormat())
+    assert messages.finish() == ["further problems omitted (2)"]
diff --git a/verification/tests/test_numeric_cache_keys.py b/verification/tests/test_numeric_cache_keys.py
new file mode 100644
index 000000000..d9cc49c0f
--- /dev/null
+++ b/verification/tests/test_numeric_cache_keys.py
@@ -0,0 +1,72 @@
+import sys
+
+import pytest
+
+from hsverify.intervalindex import SweepIndex, numeric_key, probe_starts
+from hsverify.resultcheck import WorkMeter, observed
+
+
+class ComparedInt(int):
+    """Count equality work while retaining the hash of the JSON integer it represents."""
+
+    comparisons = 0
+    __hash__ = int.__hash__
+
+    def __eq__(self, other):
+        type(self).comparisons += 1
+        if type(self).comparisons > 100_000:
+            raise AssertionError("numeric keys exceeded 100,000 equality comparisons")
+        return super().__eq__(other)
+
+
+def values(colliding, count=2_000):
+    step = sys.hash_info.modulus if colliding else 1
+    return [ComparedInt(step * i) for i in range(1, count + 1)]
+
+
+def equality_work(operation, colliding):
+    numbers = values(colliding)
+    ComparedInt.comparisons = 0
+    operation(numbers)
+    return ComparedInt.comparisons
+
+
+def test_numeric_keys_preserve_exact_numeric_equivalence():
+    assert numeric_key(1) == numeric_key(1.0)
+    assert numeric_key(0) == numeric_key(-0.0)
+    assert numeric_key(2**60) == numeric_key(float(2**60))
+    assert numeric_key(2**53 + 1) != numeric_key(float(2**53 + 1))
+    assert numeric_key(0.1) != numeric_key(1)
+
+
+@pytest.mark.parametrize("operation", ["observed", "input", "index", "probes"])
+def test_modulus_multiple_response_numbers_do_not_multiply_equality_work(operation):
+    def exercise(numbers):
+        meter = WorkMeter()
+        if operation == "observed":
+            scene = {"coverage": {"observed": []}}
+            for number in numbers:
+                assert observed(scene, "ground", number, meter=meter) == []
+            assert len(meter.cache) == len(numbers)
+        elif operation == "input":
+            for number in numbers:
+                meter.input_key({"out_ft": number})
+            assert len(meter.input_values) == len(numbers)
+        else:
+            result = {
+                "sweep": [
+                    {"wall_id": "w1", "start_ft": [number, number], "outcome": "fail"}
+                    for number in numbers
+                ]
+            }
+            if operation == "index":
+                index = SweepIndex(result)
+                assert len(index.walls["w1"].starts) == len(numbers)
+            else:
+                assert len(probe_starts(result)) >= len(numbers)
+
+    ordinary = equality_work(exercise, False)
+    colliding = equality_work(exercise, True)
+    # Count comparisons rather than wall time: sorting/deduplication may do a small
+    # multiple of the ordinary workload, but a numeric hash table does millions.
+    assert colliding <= 4 * ordinary + 20 * 2_000
diff --git a/verification/tests/test_resultcheck.py b/verification/tests/test_resultcheck.py
index 962b53541..1467f8298 100644
--- a/verification/tests/test_resultcheck.py
+++ b/verification/tests/test_resultcheck.py
@@ -508,7 +508,8 @@ def test_outcome_not_rules_out_one_outcome_and_tolerates_no_runs():
         ]
     }
     assert expectation_problems(bad, r) == [
-        "sweep w1 starts [2.1, 3.0] is pass, which this case rules out (window)"
+        "sweep expectation w1 starts (0.5, 2.5) failed for 1 runs; "
+        "expected {'outcome_not': 'pass'}; examples: w1 starts [2.1, 3.0] is pass; reason: window"
     ]
 
 
diff --git a/verification/tests/test_sweep_sampling_contract.py b/verification/tests/test_sweep_sampling_contract.py
new file mode 100644
index 000000000..852eed588
--- /dev/null
+++ b/verification/tests/test_sweep_sampling_contract.py
@@ -0,0 +1,47 @@
+import copy
+from dataclasses import replace
+
+import pytest
+from test_resultcheck import RULES, SCENE, pass_run, result
+
+from hsverify import resultcheck as checks
+
+
+@pytest.mark.parametrize(
+    "span,expected", [([0, 2.4], [0, 1, 2, 2.4]), ([0, 0.4], [0, 0.4]), ([2, 2], [2])]
+)
+def test_pre_end_count_plus_endpoint_matches_every_yield(span, expected):
+    samples = list(checks.run_starts(span, 1))
+    assert samples == expected
+    assert len(samples) == checks.run_start_count(span, 1) + 1
+
+
+@pytest.mark.parametrize("span,failing_start", [([0, 2.4], 2), ([0, 0.4], 0)])
+def test_coverage_rejects_a_failure_at_the_required_pre_end_start(monkeypatch, span, failing_start):
+    rules = replace(RULES, needs={"ground_surface": ()}, step_ft=1)
+    scene = copy.deepcopy(SCENE)
+    seen = []
+
+    def gap(scene, rules, check, wall_id, lo, hi, meter=None):
+        seen.append(lo)
+        return [(None, "unobserved at required pre-end start")] if lo == failing_start else []
+
+    monkeypatch.setattr(checks, "reach_gaps", gap)
+    answer = result(spot=False, sweep=[pass_run(*span)])
+    problems = checks.coverage_problems(scene, answer, rules)
+    assert seen == list(checks.run_starts(span, 1))
+    assert any("unobserved at required pre-end start" in problem for problem in problems)
+
+
+def test_coverage_charges_once_for_each_yielded_start(monkeypatch):
+    rules = replace(RULES, needs={"ground_surface": ()}, step_ft=1)
+    sampled = []
+
+    def gap(scene, rules, check, wall_id, lo, hi, meter=None):
+        sampled.append((lo, meter.samples))
+        return []
+
+    monkeypatch.setattr(checks, "reach_gaps", gap)
+    checks.coverage_problems(SCENE, result(spot=False, sweep=[pass_run(0, 2.4)]), rules)
+    assert [start for start, _ in sampled] == [0, 1, 2, 2.4]
+    assert [count - sampled[0][1] for _, count in sampled] == [0, 1, 2, 3]

From 1ed45b65b5ba8599c5204f919aee336f81375b13 Mon Sep 17 00:00:00 2001
From: Sam Gu <127461594+SamGu-NRX@users.noreply.github.com>
Date: Wed, 14 Oct 2026 16:27:27 -0500
Subject: [PATCH 61/62] fix(recon): reject free-space rays blocked by fused
 geometry

Use the regular visibility path stop-short tolerance before crediting a camera ray. Preserve support for the target surface itself and require two unobstructed views.

Review: https://github.com/SamGu-NRX/BaseScanning/pull/242#discussion_r4276295897
---
 recon/recon/coverage.py            | 10 +++++--
 recon/tests/test_coverage_views.py | 44 +++++++++++++++++++++++++++---
 2 files changed, 48 insertions(+), 6 deletions(-)

diff --git a/recon/recon/coverage.py b/recon/recon/coverage.py
index a9b35533f..ffff18b72 100644
--- a/recon/recon/coverage.py
+++ b/recon/recon/coverage.py
@@ -164,8 +164,14 @@ def seen_through(self, points: np.ndarray) -> np.ndarray:
             du = np.clip((u[n_i] * scale).astype(np.int64), 0, dw - 1)
             dv = np.clip((v[n_i] * scale).astype(np.int64), 0, dh - 1)
             measured = depth_map[dv, du]
-            reached = np.isfinite(measured) & (measured >= z[n_i] - tolerance(dist[n_i]))
-            out[n_i[reached], j] = True
+            tol = tolerance(dist[n_i])
+            reached = np.isfinite(measured) & (measured >= z[n_i] - tol)
+            keep = n_i[reached]
+            if len(keep):
+                # A depth map may miss an obstruction retained by fusion. Ignore only the
+                # sample's own surface, using the same stop-short distance as seen_by.
+                blocked = self.vol.blocked(self.C[j], points[keep], tol[reached] + self.voxel)
+                out[keep[~blocked], j] = True
 
         return out
 
diff --git a/recon/tests/test_coverage_views.py b/recon/tests/test_coverage_views.py
index 306ece85e..a1a764321 100644
--- a/recon/tests/test_coverage_views.py
+++ b/recon/tests/test_coverage_views.py
@@ -8,17 +8,19 @@
 from recon import coverage
 from recon.capture import Frame
 from recon.depth import Depth
+from recon.fusion import Volume
 from recon.geometry import WallFrame
 
 
 class ClearVolume:
     voxel = 0.05
+    blocked = Volume.blocked
 
     def observed(self, points):
-        return np.ones(len(points), bool)
+        return np.ones(points.shape[:-1], bool)
 
     def occupied(self, points):
-        return np.zeros(len(points), bool)
+        return np.zeros(points.shape[:-1], bool)
 
 
 def views(count):
@@ -127,8 +129,8 @@ def __init__(self, band):
     def occupied(self, points):
         if self.band == "facing":
             # A thin hit in the first outward slab, too small to become the wall front.
-            return np.isclose(points[:, 2], 0.1) & np.isclose(points[:, 1], 1.0)
-        return np.isclose(points[:, 1], 0.3) & np.isclose(points[:, 2], 0.3)
+            return np.isclose(points[..., 2], 0.1) & np.isclose(points[..., 1], 1.0)
+        return np.isclose(points[..., 1], 0.3) & np.isclose(points[..., 2], 0.3)
 
 
 def free_space_from_positions(raw, xs):
@@ -186,3 +188,37 @@ def test_empty_volume_needs_two_views_before_exporting_clear_space(xs, supported
     else:
         assert cov.facing_clear[0] == cov.overhead_clear[0] == 0.0
         assert entries == []
+
+
+@pytest.mark.parametrize(
+    ("obstruction_z", "visible"),
+    [(2.0, False), (None, True), (0.0, True)],
+    ids=["fused_obstruction", "clear_ray", "supported_surface"],
+)
+def test_free_space_rays_respect_fused_obstructions_but_not_the_sample_surface(
+    obstruction_z, visible
+):
+    frames, depths = views(2)
+    for frame, x in zip(frames, [-0.2, 0.2], strict=True):
+        frame.cam_to_world[:3, :3] = np.eye(3)
+        frame.cam_to_world[:3, 3] = [x, 1.0, 4.0]
+        depths[frame.id].depth[:] = 4.0
+    shape = (21, 31, 51)
+    tsdf = np.ones(shape, np.float32)
+    if obstruction_z is not None:
+        tsdf[:, :, round(obstruction_z / 0.1)] = -1.0
+    raw = Volume(
+        origin=np.array([-1.0, 0.0, 0.0]),
+        voxel=0.1,
+        shape=shape,
+        tsdf=tsdf,
+        weight=np.ones(shape, np.float32),
+        color=np.zeros((*shape, 3), np.float32),
+        color_n=np.zeros(shape, np.float32),
+    )
+    view = coverage.SeenFromTwo(raw, frames, depths)
+    points = np.array([[0.0, 1.0, 0.0]])
+    # Both depth maps put the sample on a surface. Fusion independently retains a
+    # nearer obstacle in the failing case; a hit on the sample itself remains supported.
+    np.testing.assert_array_equal(view.seen_through(points), [[visible, visible]])
+    np.testing.assert_array_equal(view.observed(points), [visible])

From 1428d04732e5bef97629eecc2d7620abe0e6a342 Mon Sep 17 00:00:00 2001
From: Sam Gu <127461594+SamGu-NRX@users.noreply.github.com>
Date: Wed, 14 Oct 2026 16:37:48 -0500
Subject: [PATCH 62/62] fix(verification): preserve Markdown explanations
 within output budget

Prioritize the Markdown-visible problems array before duplicate JSON classifications. Regressions retain the first explanation for 1,000 contract or expectation failures without exceeding the shared diagnostic budget.

Review: https://github.com/SamGu-NRX/BaseScanning/pull/240#discussion_r4276493597
---
 verification/hsverify/diagnostics.py         |  3 +-
 verification/tests/test_diagnostic_limits.py | 29 ++++++++++++++++++++
 2 files changed, 31 insertions(+), 1 deletion(-)

diff --git a/verification/hsverify/diagnostics.py b/verification/hsverify/diagnostics.py
index ebdbec387..3c81ed8ee 100644
--- a/verification/hsverify/diagnostics.py
+++ b/verification/hsverify/diagnostics.py
@@ -70,10 +70,11 @@ def bounded_report_records(records: list[dict]) -> tuple[list[dict], list[str]]:
     bounded = []
     for record in records:
         copy = dict(record)
+        # Markdown renders problems; retain its explanations before their JSON duplicates.
         for field in (
+            "problems",
             "contract_problems",
             "expectation_problems",
-            "problems",
             "assumption_mismatches",
             "assumption_warnings",
         ):
diff --git a/verification/tests/test_diagnostic_limits.py b/verification/tests/test_diagnostic_limits.py
index 7e3f16592..0e0ca7e1f 100644
--- a/verification/tests/test_diagnostic_limits.py
+++ b/verification/tests/test_diagnostic_limits.py
@@ -133,3 +133,32 @@ def __format__(self, spec):
 
     messages.append("{}", ForbiddenFormat())
     assert messages.finish() == ["further problems omitted (2)"]
+
+
+@pytest.mark.parametrize("field", ["contract_problems", "expectation_problems"])
+def test_markdown_keeps_first_explanation_when_duplicate_fields_fill_budget(tmp_path, field):
+    problems = [f"explanation {i}" for i in range(1_000)]
+    record = {
+        "name": "many failures",
+        "status": "fail",
+        "decision": "reject",
+        "problems": problems,
+        field: problems,
+    }
+    report = e2e.write_report(tmp_path, META, [record])
+    row = next(
+        line
+        for line in (tmp_path / "report.md").read_text().splitlines()
+        if line.startswith("| many failures |")
+    )
+    assert "explanation 0" in row
+    retained = [
+        message
+        for item in report["records"]
+        for key in ("problems", field)
+        for message in item[key]
+    ]
+    retained += report["diagnostic_summary"]
+    assert len(retained) <= MAX_DIAGNOSTIC_COUNT
+    assert sum(len(json.dumps(message)) for message in retained) <= MAX_DIAGNOSTIC_CHARACTERS
+    assert not report["all_passed"]