Add files using upload-large-folder tool

.gitattributes

@@ -58,3 +58,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 # Video files - compressed
 *.mp4 filter=lfs diff=lfs merge=lfs -text
 *.webm filter=lfs diff=lfs merge=lfs -text
+encoder/__pycache__/geometric.cpython-311.pyc filter=lfs diff=lfs merge=lfs -text

.pytest_cache/.gitignore

@@ -0,0 +1,2 @@
+# Created by pytest automatically.
+*

.pytest_cache/CACHEDIR.TAG

@@ -0,0 +1,4 @@
+Signature: 8a477f597d28d172789f06886806bc55
+# This file is a cache directory tag created by pytest.
+# For information about cache directory tags, see:
+#	https://bford.info/cachedir/spec.html

.pytest_cache/README.md

@@ -0,0 +1,8 @@
+# pytest cache directory #
+
+This directory contains data from the pytest's cache plugin,
+which provides the `--lf` and `--ff` options, as well as the `cache` fixture.
+
+**Do not** commit this to version control.
+
+See [the docs](https://docs.pytest.org/en/stable/how-to/cache.html) for more information.

.pytest_cache/v/cache/lastfailed

@@ -0,0 +1 @@
+{}

.pytest_cache/v/cache/nodeids

@@ -0,0 +1,39 @@
+[
+  "tests/encoder_tests/test_adapters.py::test_adapt_segvggt_reads_flat_npz",
+  "tests/encoder_tests/test_adapters.py::test_adapt_segvggt_requires_cache_or_video",
+  "tests/encoder_tests/test_adapters.py::test_validate_normalizes_canonical_geometry",
+  "tests/encoder_tests/test_adapters.py::test_validate_rejects_invalid_geometry[scene0-TypeError]",
+  "tests/encoder_tests/test_adapters.py::test_validate_rejects_invalid_geometry[scene1-ValueError]",
+  "tests/encoder_tests/test_adapters.py::test_validate_rejects_invalid_geometry[scene2-ValueError]",
+  "tests/encoder_tests/test_config.py::test_cache_and_code_paths_are_flat",
+  "tests/encoder_tests/test_config.py::test_video_path_rejects_unknown_dataset",
+  "tests/encoder_tests/test_config.py::test_video_path_requires_unique_match",
+  "tests/encoder_tests/test_config.py::test_video_path_searches_dataset_folders",
+  "tests/encoder_tests/test_geometric.py::test_dump_spatial_code",
+  "tests/encoder_tests/test_geometric.py::test_exact_math_is_integrated_into_geometric_module",
+  "tests/encoder_tests/test_geometric.py::test_raw_bundle_dispatches_to_integrated_exact_path",
+  "tests/encoder_tests/test_launch.py::test_scenes_deduplicates_manifest_in_order",
+  "tests/encoder_tests/test_launch.py::test_visible_gpus_falls_back_to_nvidia_smi",
+  "tests/encoder_tests/test_launch.py::test_visible_gpus_uses_environment",
+  "tests/encoder_tests/test_render.py::test_build_spatial_code_uses_cached_geometry",
+  "tests/encoder_tests/test_render.py::test_write_spatial_code_uses_scene_json",
+  "tests/encoder_tests/test_run.py::test_cache_or_load_builds_and_writes_cache",
+  "tests/encoder_tests/test_run.py::test_cache_or_load_reads_flat_cache",
+  "tests/encoder_tests/test_schema.py::test_dumped_json_preserves_schema",
+  "tests/encoder_tests/test_schema.py::test_spatial_code_matches_reference_schema",
+  "tests/symbolic_tests/test_launch.py::test_error_analysis_rejects_non_numeric_question_type",
+  "tests/symbolic_tests/test_launch.py::test_error_analysis_summarizes_numeric_errors",
+  "tests/symbolic_tests/test_launch.py::test_mca_answer_breakdown_distinguishes_outcomes",
+  "tests/symbolic_tests/test_launch.py::test_scenes_with_spatial_codes_returns_sorted_stems",
+  "tests/symbolic_tests/test_run.py::test_fetch_spatial_code_reads_flat_json",
+  "tests/symbolic_tests/test_run.py::test_fetch_spatial_code_reports_missing_file",
+  "tests/symbolic_tests/test_run.py::test_find_workspace_root_uses_spatial_codes_folder",
+  "tests/symbolic_tests/test_run.py::test_real_questions_for_scene_filters_jsonl",
+  "tests/symbolic_tests/test_run.py::test_write_scene_results_uses_one_file_per_question",
+  "tests/symbolic_tests/test_solver.py::test_direct_numeric_answers",
+  "tests/symbolic_tests/test_solver.py::test_direction_answers_use_floor_coordinates",
+  "tests/symbolic_tests/test_solver.py::test_dispatch_returns_none_for_unknown_or_missing_data",
+  "tests/symbolic_tests/test_solver.py::test_multiple_choice_distance_and_order_answers",
+  "tests/symbolic_tests/test_solver.py::test_route_planning_chains_turns",
+  "tests/symbolic_tests/test_solver.py::test_unit_parsers_accept_strings_and_numbers"
+]

.ruff_cache/.gitignore

@@ -0,0 +1,2 @@
+# Automatically created by ruff.
+*

.ruff_cache/CACHEDIR.TAG

@@ -0,0 +1 @@
+Signature: 8a477f597d28d172789f06886806bc55

data/caches/segvggt/42897538.npz

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

data/caches/segvggt/42897564.npz

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

data/caches/segvggt/42897688.npz

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

data/caches/segvggt/42898486.npz

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

encoder/__pycache__/geometric.cpython-311.pyc

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

encoder/config.py.orig

@@ -0,0 +1,69 @@
+"""Configuration and path helpers for the VSI spatial-code encoder."""
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+MODEL = os.environ.get("VSI_GEOMETRY_MODEL", "segvggt")
+FPS = float(os.environ.get("VSI_FPS", "6"))
+
+DATA_ROOT = Path(os.environ.get("VSI_DATA_ROOT", "/workspace/data"))
+VSI_ROOT = Path(os.environ.get("VSI_ROOT", DATA_ROOT / "VSI-Bench"))
+JSONL = Path(os.environ.get("VSI_JSONL", VSI_ROOT / "test.jsonl"))
+CACHE_ROOT = Path(os.environ.get("VSI_CACHE_ROOT", DATA_ROOT / "caches"))
+CODES_ROOT = Path(os.environ.get("VSI_CODES", DATA_ROOT / "spatial codes"))
+SEGVGGT_ROOT = Path(os.environ.get("VSI_SEGVGGT_ROOT", "/root/models/SegVGGT"))
+SEGVGGT_CHECKPOINT = Path(os.environ.get(
+    "VSI_SEGVGGT_CHECKPOINT", SEGVGGT_ROOT / "checkpoint/segvggt_scannet200.pt"))
+
+VIDEO_DATASETS = ("scannet", "scannetpp", "arkitscenes")
+
+ADAPTERS = {
+    "da3_sam3": "adapt_da3_sam3",
+    "segvggt": "adapt_segvggt",
+}
+
+
+def video_path(scene: str, dataset: str | None = None) -> str:
+    """Return the unique MP4 for ``scene`` from the VSI-Bench dataset folders."""
+    scene = str(scene)
+    datasets = (dataset,) if dataset else VIDEO_DATASETS
+    matches: list[Path] = []
+    for name in datasets:
+        if name not in VIDEO_DATASETS:
+            raise ValueError(f"unknown VSI dataset {name!r}; expected one of {VIDEO_DATASETS}")
+        candidate = VSI_ROOT / name / f"{scene}.mp4"
+        if candidate.is_file():
+            matches.append(candidate)
+    if not matches:
+        searched = ", ".join(str(VSI_ROOT / d / f"{scene}.mp4") for d in datasets)
+        raise FileNotFoundError(f"video for scene {scene!r} not found; searched: {searched}")
+    if len(matches) > 1:
+        raise RuntimeError(f"scene {scene!r} exists in multiple datasets: {matches}")
+    return str(matches[0])
+
+
+def model_cache_dir(model: str | None = None) -> str:
+    """Flat cache directory for one model. Scene IDs are filenames, never folders."""
+    return str(CACHE_ROOT / (model or MODEL))
+
+
+def cache_file(scene: str, model: str | None = None) -> str:
+    """Canonical cached model output used by the encoder."""
+    return str(Path(model_cache_dir(model)) / f"{scene}.pkl.gz")
+
+
+def segvggt_cache_file(scene: str, model: str | None = None) -> str:
+    return str(Path(model_cache_dir(model or "segvggt")) / f"{scene}.npz")
+
+
+def da3_cache_file(scene: str, model: str | None = None) -> str:
+    return str(Path(model_cache_dir(model or "da3_sam3")) / f"{scene}.da3.npz")
+
+
+def sam3_cache_file(scene: str, model: str | None = None) -> str:
+    return str(Path(model_cache_dir(model or "da3_sam3")) / f"{scene}.sam3.pkl.gz")
+
+
+def spatial_code_path(scene: str) -> str:
+    return str(CODES_ROOT / f"{scene}.json")

encoder/geometric.py

@@ -0,0 +1,1507 @@
+"""Geometric assembler (runs in the pipeline venv). Imported by encoder/render.py.
+
+Pure math/assembly -- builds the per-instance spatial code (object positions/sizes, pairwise
+distances, closeness ranks, room outline, camera trajectory, appearance order) FROM
+already-computed depth/pose/masks. Does NOT run DA3 or SAM3, and does not call cache_or_load()
+-- that's run.py's job entirely (the only file that calls the actual model-inference functions).
+Callers may provide raw depth/intr/c2w/conf/ftimes/per inputs or canonical world-space
+geometry. Both paths emit the same compact spatial-code schema.
+
+Formerly this file called into perceptual.py (as a dynamically-loaded `pl` module) for its own
+geometry helpers -- build_instances, room_gravity, compute_floor_area, answer_closest_distance,
+to_spatial_code, and everything else in this file below _room_outline(). Those functions are
+now merged in directly, verbatim, since they were never DA3/SAM3 calls -- they're geometric
+computations over already-extracted depth/masks, which is exactly this file's job.
+perceptual.py's OTHER half (the actual model-calling functions) moved to run.py instead;
+perceptual.py itself no longer exists.
+
+The spatial code is the sole spatial representation the downstream VLM sees; no answer engine
+is computed here (the harness runs the model).
+"""
+
+import os
+import json
+import numpy as np
+import cv2
+
+
+# ==========================================================================================
+# CONSTANTS -- geometry-cleanup knobs, merged in from perceptual.py. Env-tunable levers that
+# affect only the math below (build_instances/backproject_frame/etc.), never model inference.
+# ==========================================================================================
+
+SCHEMA = [
+    "x",
+    "y",
+    "z",
+    "e1",
+    "e2",
+    "e3",
+    "px",
+    "pz",
+    "size_median",
+    "size_IQR",
+    "time",
+    "n",
+]  # legacy row schema, see to_labeled()
+KD_WORKERS = 4  # KD-tree query threads. Queries here are on small capped (<=4000 pt) clouds, so scipy's
+# workers=-1 ("use all cores") is pathological on a many-core box: it spawns one thread
+# per core (e.g. 256) per tiny query and the thread-spawn overhead dwarfs the work.
+MIN_INSTANCE_PTS = (
+    1  # bare geometry floor only: need >=1 valid depth pixel to place a 3D point.
+)
+# NO quality filtering / dedup -- count = exactly SAM3's tracked masklets (honest)
+FLOOR_BAND = (
+    0.15  # m above the floor to count as floor-level (LEGACY -- currently unreferenced;
+)
+# compute_floor_area now uses the RANSAC gravity plane directly instead)
+# ---- geometry-cleanup levers (improve abs_distance etc.; env-tunable) ----
+# DEPTH_COHERENCE (Tukey-fence bleed removal): SAFE + helpful everywhere -> default ON.
+#   ablation: ARKit abs_distance 0.757->0.729 (no harm), ScanNet++ d755 0.443->0.486 (helps).
+# CONF_PCT (per-frame confidence percentile): noisy-dataset ONLY -> default OFF.
+#   helps ScanNet++ distance more (~0.56) but DESTROYS clean ARKit (0.757->0.429). Opt in via VSI_CONF_PCT=55.
+CONF_PCT = float(os.environ.get("VSI_CONF_PCT", "0"))
+DEPTH_COHERENCE = os.environ.get("VSI_DEPTH_COHERENCE", "1") == "1"
+# cut mask-bleed at per-frame depth edges. Default OFF: it's a NO-OP on the dominant failure (same-depth bleed
+# -- adjacent objects at similar range have no depth edge), and only helps depth-SEPARATED bleed. Enable per-need.
+DEPTH_EDGE_REFINE = os.environ.get("VSI_DEPTH_EDGE_REFINE", "0") == "1"
+# MASK_REFINE (appearance-guided boundary snap): uses the RGB color edge to clip same-depth mask bleed that
+#   depth can't see. Principled + cheap (CPU, no model). Default OFF until validated; enable via VSI_MASK_REFINE=1.
+MASK_REFINE = os.environ.get("VSI_MASK_REFINE", "0") == "1"
+
+
+# ==========================================================================================
+# ROOM/OBJECT GEOMETRY -- gravity, floor basis, per-instance spatial-code records. Merged in
+# from perceptual.py, verbatim.
+# ==========================================================================================
+
+
+def to_labeled(objects, floor_area):
+    """LEGACY per-class summary (kept for --format array-compat). Superseded by to_spatial_code."""
+    out = {"objects": {}}
+    for cls, row in objects.items():
+        d = dict(zip(SCHEMA, row))
+        out["objects"][cls] = {
+            "count": int(d["n"]),
+            "centroid_meters": {"x": d["x"], "y": d["y"], "z": d["z"]},
+            "longest_dimension_meters": {
+                "median": d["size_median"],
+                "iqr": d["size_IQR"],
+            },
+            "centroid_spread": {
+                "eigenvalues": [d["e1"], d["e2"], d["e3"]],
+                "principal_axis_xz": [d["px"], d["pz"]],
+            },
+            "first_seen_seconds": d["time"],
+        }
+    out["room"] = {"floor_area_square_meters": floor_area}
+    return out
+
+
+def room_up_axis(instances, c2w):
+    """up axis = smallest-extent axis of all object points; sign from gravity (floor->camera).
+    Floor = densest horizontal slab; cameras are always above it, which fixes the sign.
+    Returns (axis_index, signed_unit_vector)."""
+    P = np.concatenate([i["pts"] for v in instances.values() for i in v], 0)
+    ext = np.percentile(P, 98, 0) - np.percentile(P, 2, 0)
+    up = int(np.argmin(ext))
+    h, edges = np.histogram(P[:, up], bins=80)
+    floor = 0.5 * (edges[h.argmax()] + edges[h.argmax() + 1])  # densest slab = floor
+    cam_up = c2w[:, :3, 3][:, up].mean()
+    e = np.zeros(3, np.float32)
+    e[up] = 1.0 if cam_up > floor else -1.0
+    return up, e
+
+
+def room_gravity(
+    depth, intr, c2w, conf, conf_pct=40, stride=12, fstride=15, iters=300, thr=0.05
+):
+    """Robust UP vector = normal of the RANSAC floor plane (a real physical plane), oriented toward
+    the cameras. Works when the reconstruction is tilted/drifted (ScanNet++) where argmin-extent fails.
+    Floor = large planar support with most non-inlier mass on ONE side. Returns (gravity_unit_vec, axis)."""
+    P = []
+    for f in range(0, len(depth), fstride):
+        Hd, Wd = depth[f].shape
+        ys, xs = np.mgrid[0:Hd:stride, 0:Wd:stride]
+        ys = ys.ravel()
+        xs = xs.ravel()
+        z = depth[f][ys, xs]
+        ok = (z > 0) & np.isfinite(z)
+        if conf is not None and conf_pct > 0:
+            ok &= conf[f][ys, xs] >= np.percentile(conf[f], conf_pct)
+        ys, xs, z = ys[ok], xs[ok], z[ok]
+        if not len(z):
+            continue
+        K = intr[f]
+        Xc = np.stack(
+            [(xs - K[0, 2]) * z / K[0, 0], (ys - K[1, 2]) * z / K[1, 1], z], 1
+        )
+        P.append((c2w[f][:3, :3] @ Xc.T).T + c2w[f][:3, 3])
+    P = np.concatenate(P).astype(np.float64) if P else np.zeros((0, 3))
+    cam = c2w[:, :3, 3].mean(0)
+    if len(P) < 100:  # fallback to axis-extent
+        ext = np.percentile(P, 98, 0) - np.percentile(P, 2, 0) if len(P) else np.ones(3)
+        ax = int(np.argmin(ext))
+        g = np.zeros(3)
+        g[ax] = 1.0
+        return g, ax
+    rng = np.random.RandomState(0)
+    best = None
+    best_score = -1
+    for _ in range(iters):
+        a, b, c = P[rng.choice(len(P), 3, False)]
+        nrm = np.cross(b - a, c - a)
+        ln = np.linalg.norm(nrm)
+        if ln < 1e-6:
+            continue
+        nrm /= ln
+        d = -nrm @ a
+        side = P @ nrm + d
+        ninl = int((np.abs(side) < thr).sum())
+        if ninl < 50:
+            continue
+        score = ninl * max(
+            np.mean(side > thr), np.mean(side < -thr)
+        )  # big + one-sided = floor
+        if score > best_score:
+            best_score = score
+            best = (nrm, d)
+    if best is None:
+        ext = np.percentile(P, 98, 0) - np.percentile(P, 2, 0)
+        ax = int(np.argmin(ext))
+        g = np.zeros(3)
+        g[ax] = 1.0
+        return g, ax
+    nrm, d = best
+    if (cam @ nrm + d) < 0:
+        nrm = -nrm  # orient toward cameras (up)
+    return nrm.astype(np.float32), int(np.argmax(np.abs(nrm)))
+
+
+def pos3(rec):
+    """[floor_x, floor_y, height_above_floor] from a spatial-code instance record's named position."""
+    p = rec.get("position") or {}
+    return [
+        p.get("floor_x_meters", 0.0),
+        p.get("floor_y_meters", 0.0),
+        p.get("height_above_floor_meters", 0.0),
+    ]
+
+
+def _floor_basis(up_vec):
+    """Orthonormal floor basis (u, v horizontal; g = up) from the gravity vector. u is the OLD
+    floor_x world axis projected onto the gravity plane (v the old floor_y axis), so this frame
+    differs from the old axis-drop frame ONLY by the tilt correction -- NO arbitrary in-plane
+    rotation (aligned scenes stay put; only tilt gets corrected). Objects / camera / room_outline
+    all share this one gravity-plane frame; floor_area is rotation-invariant so it matches too."""
+    g = np.asarray(up_vec, np.float64)
+    g = g / (np.linalg.norm(g) + 1e-12)
+    up_ax = int(np.argmax(np.abs(g)))
+    floor_axes = [
+        a for a in range(3) if a != up_ax
+    ]  # the two world axes the old frame used
+    e0 = np.zeros(3)
+    e0[floor_axes[0]] = 1.0  # old floor_x world axis
+    u = e0 - (e0 @ g) * g
+    u = u / (np.linalg.norm(u) + 1e-12)  # project it into the gravity plane
+    v = np.cross(g, u)
+    if v[floor_axes[1]] < 0:
+        v = -v  # keep floor_y sign aligned with the old axis
+    return u, v, g
+
+
+def _object_records(insts, count, u, v, g, floor_level):
+    """Up to `count` instances, strongest-evidence first (most observed points = best-segmented,
+    closest, most geometry). `count` (peak co-visibility) decides HOW MANY; total observed points
+    decide WHICH -- no threshold. Positions are projected onto the shared gravity floor basis
+    (u, v horizontal; g up; height 0 = floor_level) and emitted directly in THE final spatial
+    code shape: unit-strings ("1.4 meters"), spaced keys ("x coordinate"), and exactly two
+    fields per instance (position + longest dimension) -- there is no separate raw form.
+
+    Deliberately does NOT report a per-instance first_seen_seconds: the reported instances are
+    chosen by STRONGEST evidence (most points/frames), but the class's true first appearance can
+    come from a weaker, earlier masklet that never makes this cut (confirmed empirically -- e.g. a
+    brief early detection with few points, superseded here by a longer later observation of
+    presumably the same object). A per-instance timestamp here would silently describe a DIFFERENT
+    detection than the class-level "first seen" a reader would assume it means. appearance_order
+    (built below in build_spatial_code() from min(first_time) over ALL detected masklets, not just
+    the reported ones) is the sole reliable source for first-appearance timing."""
+    ranked = sorted(insts, key=lambda i: (i["n"], i.get("nframes", 0)), reverse=True)[
+        : max(count, 1)
+    ]
+    recs = []
+    for it in ranked:
+        c = np.asarray(it["centroid"], np.float64)
+        recs.append(
+            {
+                "position": {
+                    "x coordinate": f"{round(float(c @ u), 2)} meters",
+                    "y coordinate": f"{round(float(c @ v), 2)} meters",
+                    "height above floor": f"{round(float(c @ g - floor_level), 2)} meters",
+                },
+                "longest dimension": f"{round(float(it['size']), 2)} meters",
+            }
+        )
+    return recs
+
+
+def to_spatial_code(instances, stats, floor_area, up_axis, up_vec, floor_level):
+    """Per-instance spatial code, emitted directly in THE final shape: class -> {count (peak
+    co-visibility), instances:[{position, longest dimension}]} plus room -> {"floor area"}.
+    Positions are projected onto the GRAVITY floor plane (u, v horizontal via _floor_basis -- the
+    SAME frame as compute_floor_area); "height above floor" is along gravity with 0 = on the
+    floor. floor_level is the gravity-height of the floor. (up_axis is retained for signature
+    compatibility; the frame now derives from up_vec.)"""
+    u, v, g = _floor_basis(up_vec)
+    out = {"objects": {}}
+    for cls, insts in instances.items():
+        cnt = int(stats[cls]["peak"])
+        out["objects"][cls] = {
+            "count": cnt,
+            "instances": _object_records(insts, cnt, u, v, g, floor_level),
+        }
+    out["room"] = {"floor area": f"{floor_area} square meters"}
+    return out
+
+
+# ==========================================================================================
+# DETERMINISTIC ANSWER LAYER (parameter-free; validated on VSI GT). Reads the in-memory
+# instances (pos for direction/route, point clouds for distance). Merged in from
+# perceptual.py, verbatim.
+# ==========================================================================================
+
+
+def _find_cls(name, classes):
+    name = name.strip().lower()
+    for c in classes:
+        if c == name or c.replace(" ", "") == name.replace(" ", ""):
+            return c
+    for c in classes:
+        if name in c or c in name:
+            return c
+    return None
+
+
+def _rep(insts):
+    """representative instance = most observed points (best-segmented, validated 8/8 on direction)."""
+    return max(insts, key=lambda i: i["n"])
+
+
+def answer_rel_direction(pA, pB, pC, up_vec, up_ax, mode="hard"):
+    """Standing at A facing B, where is C? front/back=dot(C-A,fwd); left/right=dot(C-A, up x fwd).
+    Right-handed world (OpenCV cam frame + det+1 c2w) makes up x fwd = left a fixed identity.
+    Projection uses the gravity VECTOR (v-(v.g)g), so a tilted floor (ScanNet++) is handled; for an
+    axis-aligned up this reduces to zeroing that axis (ARKit unchanged)."""
+    g = np.asarray(up_vec, np.float64)
+    g = g / (np.linalg.norm(g) + 1e-12)
+
+    def fl(v):
+        w = v.astype(np.float64)
+        return w - (w @ g) * g
+
+    fwd = fl(pB - pA)
+    n = np.linalg.norm(fwd)
+    if n < 1e-6:
+        return None
+    fwd /= n
+    left = np.cross(g, fwd)
+    left /= np.linalg.norm(left) + 1e-9
+    d = fl(pC - pA)
+    f = float(d @ fwd)
+    lateral = float(d @ left)
+    if mode == "medium":
+        if abs(np.degrees(np.arctan2(lateral, f))) >= 135:
+            return "back"
+        return "left" if lateral > 0 else "right"
+    return f"{'front' if f > 0 else 'back'}-{'left' if lateral > 0 else 'right'}"
+
+
+def _classify_turn(h_in, h_out, up_vec, up_ax):
+    """rotation h_in->h_out in floor plane -> turn left/right/back (135deg = VSI's own 'back' cutoff)."""
+    g = np.asarray(up_vec, np.float64)
+    g = g / (np.linalg.norm(g) + 1e-12)
+
+    def fl(v):
+        w = v.astype(np.float64)
+        return w - (w @ g) * g
+
+    a, b = fl(h_in), fl(h_out)
+    na, nb = np.linalg.norm(a), np.linalg.norm(b)
+    if na < 1e-6 or nb < 1e-6:
+        return None
+    a /= na
+    b /= nb
+    ang = np.degrees(np.arctan2(float(up_vec @ np.cross(a, b)), float(a @ b)))
+    if abs(ang) >= 135:
+        return "turn back"
+    return "turn left" if ang > 0 else "turn right"
+
+
+def answer_route(ql, cents, up_vec, up_ax):
+    """Chain the turn primitive over the waypoint sequence -> ordered ['turn left/right/back', ...]."""
+    import re as _re
+
+    m = _re.search(r"beginning at the (.+?) (?:and )?facing the (.+?)\.", ql)
+    if not m:
+        return None
+
+    def position(name):
+        class_name = _find_cls(name, cents)
+        return cents[class_name] if class_name else None
+
+    steps_txt = ql.split(":", 1)[1] if ":" in ql else ql
+    steps = _re.findall(
+        r"\d+\.\s*(\[please fill in\]|Go forward until the [^0-9\[]+?)(?=\s*\d+\.|$)",
+        steps_txt,
+    )
+    cur_pos = position(m.group(1).strip())
+    if cur_pos is None:
+        return None
+    fac = position(m.group(2).strip())
+    cur_head = (fac - cur_pos) if fac is not None else None
+    turns = []
+    i = 0
+    while i < len(steps):
+        s = steps[i].strip()
+        if s.startswith("Go forward"):
+            tp = position(_re.sub(r"^Go forward until the ", "", s).strip().rstrip("."))
+            if tp is not None:
+                cur_head = tp - cur_pos
+                cur_pos = tp
+        else:
+            nxt = next(
+                (
+                    _re.sub(r"^Go forward until the ", "", steps[j].strip())
+                    .strip()
+                    .rstrip(".")
+                    for j in range(i + 1, len(steps))
+                    if steps[j].strip().startswith("Go forward")
+                ),
+                None,
+            )
+            tp = position(nxt) if nxt else None
+            if tp is None or cur_head is None:
+                turns.append(None)
+            else:
+                turns.append(_classify_turn(cur_head, tp - cur_pos, up_vec, up_ax))
+                cur_head = tp - cur_pos
+        i += 1
+    return turns
+
+
+# ==========================================================================================
+# POINT-CLOUD CLEANING + DISTANCE ANSWERS -- outlier removal, closest-distance queries. Merged
+# in from perceptual.py, verbatim.
+# ==========================================================================================
+
+
+def _sor(pts, k=16, std=2.0, cap=4000):
+    """Statistical outlier removal: drop points whose mean distance to their k nearest neighbors exceeds
+    mean + std*sigma. Removes mask-bleed / depth-speckle points that corrupt a literal closest-point min.
+    k=16 and std=2 are universal robust-statistics defaults -- NOT tuned to VSI (no benchmark-fit knob)."""
+    from scipy.spatial import cKDTree
+
+    if len(pts) < k + 2:
+        return pts
+    rs = np.random.RandomState(0)
+    P = pts if len(pts) <= cap else pts[rs.choice(len(pts), cap, False)]
+    d, _ = cKDTree(P).query(P, k=k + 1, workers=KD_WORKERS)
+    md = d[:, 1:].mean(1)
+    return P[md <= md.mean() + std * md.std()]
+
+
+def _main_cluster(pts):
+    """Keep the object's dominant spatial cluster. Coherent mask-bleed onto a SPATIALLY-SEPARATED adjacent
+    object forms a disconnected component (a gap separates two objects); the true object is the largest one.
+    Linkage scale self-calibrates from the cloud's own nearest-neighbor spacing -- no fixed distance."""
+    from scipy.spatial import cKDTree
+
+    if len(pts) < 30:
+        return pts
+    tree = cKDTree(pts)
+    nn, _ = tree.query(pts, k=2)
+    eps = 3.0 * float(np.median(nn[:, 1]))  # 3x median NN gap (data-derived)
+    pairs = tree.query_pairs(eps, output_type="ndarray")
+    if len(pairs) == 0:
+        return pts
+    parent = np.arange(len(pts))
+
+    def find(x):
+        r = x
+        while parent[r] != r:
+            r = parent[r]
+        while parent[x] != r:
+            parent[x], x = r, parent[x]
+        return r
+
+    for a, b in pairs:
+        ra, rb = find(int(a)), find(int(b))
+        if ra != rb:
+            parent[ra] = rb
+    roots = np.array([find(i) for i in range(len(pts))])
+    v, cnt = np.unique(roots, return_counts=True)
+    return pts[roots == v[cnt.argmax()]]
+
+
+def _clean(inst, cap=4000):
+    """Outlier removal self-calibrated from the pipeline's OWN per-object signals -- no universal constant,
+    no benchmark knob. Cached on the instance so the O(classes^2) distance table cleans each object once.
+      (1) per-point DA3 confidence: boundary mask-bleed = depth discontinuity = LOW conf -> drop below the
+          object's OWN median confidence (data-derived cut);
+      (2) statistical density outlier removal on the survivors;
+      (3) dominant spatial cluster: coherent bleed onto a separated adjacent object is a disconnected cluster."""
+    if inst.get("_cleanpts") is not None:
+        return inst["_cleanpts"]
+    pts = inst["pts"]
+    conf = inst.get("conf")
+    rs = np.random.RandomState(0)
+    if len(pts) > cap:
+        idx = rs.choice(len(pts), cap, False)
+        pts = pts[idx]
+        conf = conf[idx] if conf is not None else None
+    if conf is not None and len(conf) > 20:  # self-calibrating: object's OWN median
+        keep = conf >= np.median(conf)
+        if keep.sum() >= 10:
+            pts = pts[keep]
+    pts = _sor(pts, cap=cap)  # density outlier removal on the survivors
+    # NOTE: spatial de-bleeding (_main_cluster) was tried and REVERTED -- "largest cluster = the object" is
+    # not guaranteed; when an object's near edge splits off it drops the true closest part (overshoot). You
+    # cannot post-hoc recover the true object from a bleeding mask in 3D -- that needs better SOURCE masks.
+    inst["_cleanpts"] = pts
+    return pts
+
+
+def answer_closest_distance(instsA, instsB, k=4000):
+    """Closest distance between the two objects' point clouds ('closest point of each object'). Points are
+    cleaned by _clean (self-calibrated per-object confidence + density) then exact nearest-neighbor min via
+    KD-tree, so mask-bleed/speckle can't collapse the answer. NOTE: VSI's GT is box-to-box on CLEAN annotation
+    boxes; the residual gap is object-segmentation quality (bleed), not this formula -- see _clean docstring."""
+    A = _clean(_rep(instsA), cap=k)
+    B = _clean(_rep(instsB), cap=k)
+    if len(A) == 0 or len(B) == 0:
+        return float("inf")
+    from scipy.spatial import cKDTree
+
+    if len(A) <= len(B):
+        d, _ = cKDTree(A).query(B, k=1, workers=KD_WORKERS)
+    else:
+        d, _ = cKDTree(B).query(A, k=1, workers=KD_WORKERS)
+    return float(d.min())
+
+
+def answer_rel_distance(anchor_insts, option_insts):
+    """'which option is closest to the anchor?' -> index of the option with min closest-point distance."""
+    dists = [
+        answer_closest_distance(anchor_insts, oi) if oi is not None else float("inf")
+        for oi in option_insts
+    ]
+    return int(np.argmin(dists)), dists
+
+
+# ==========================================================================================
+# MASK/DEPTH CLEANUP + BACK-PROJECTION -- per-frame refinement before points enter an
+# instance's point cloud. Merged in from perceptual.py, verbatim.
+# ==========================================================================================
+
+
+def depth_edges(depth_f, valid_f):
+    """Per-frame depth-DISCONTINUITY map: gradient magnitude above median + 3*MAD over the valid pixels.
+    The threshold is data-derived (robust, universal statistical cut -- NOT benchmark-tuned). These edges are
+    where mask-bleed crosses onto an adjacent object at a different depth."""
+    if valid_f.sum() < 100:
+        return np.zeros_like(depth_f, bool)
+    d = np.where(valid_f, depth_f, np.median(depth_f[valid_f]))
+    gy, gx = np.gradient(d)
+    grad = np.hypot(gx, gy)
+    g = grad[valid_f]
+    med = np.median(g)
+    mad = np.median(np.abs(g - med)) + 1e-9
+    return (grad > med + 3.0 * 1.4826 * mad) & valid_f
+
+
+try:
+    _GUIDED = (
+        cv2.ximgproc.guidedFilter
+    )  # opencv-contrib; appearance-guided boundary snap
+except AttributeError:
+    _GUIDED = None
+
+
+def refine_mask(mask, rgb):
+    """Snap a coarse SAM3 mask boundary to the RGB color edge (appearance-guided). This clips the same-depth
+    bleed that depth CANNOT see: where the halo crosses onto a differently-colored neighbor, the color edge
+    cuts it. Params are DERIVED, not tuned -- radius from frame scale, smoothness from the image's own color
+    variance (same MAD-style principle as depth_edges). No model, no GPU. Falls back to grabCut, then erode."""
+    if mask.shape[:2] != rgb.shape[:2]:
+        mask = cv2.resize(
+            mask.astype(np.uint8),
+            (rgb.shape[1], rgb.shape[0]),
+            interpolation=cv2.INTER_NEAREST,
+        ).astype(bool)
+    a = int(mask.sum())
+    if a < 60:  # too small to refine meaningfully -> 1px erode as before
+        me = cv2.erode(mask.astype(np.uint8), np.ones((3, 3), np.uint8), 1).astype(bool)
+        return me if me.any() else mask
+    if _GUIDED is not None:
+        r = max(
+            4, int(round(0.02 * float(np.hypot(*mask.shape[:2]))))
+        )  # radius ~2% of frame diagonal
+        eps = (
+            float(np.var(rgb.astype(np.float32) / 255.0)) * 0.01 + 1e-6
+        )  # smoothness ~ image color variance
+        soft = _GUIDED(rgb, mask.astype(np.float32), r, eps)
+        out = soft > 0.5
+        return out if out.sum() >= 0.4 * a else mask  # majority guard: don't over-carve
+    # fallback (base opencv, no ximgproc): grabCut seeded FG=mask, PR_FG=dilated ring, BG=far exterior
+    try:
+        gc = np.full(mask.shape[:2], cv2.GC_PR_BGD, np.uint8)
+        dil = cv2.dilate(mask.astype(np.uint8), np.ones((15, 15), np.uint8), 1).astype(
+            bool
+        )
+        er = cv2.erode(mask.astype(np.uint8), np.ones((5, 5), np.uint8), 1).astype(bool)
+        gc[dil] = cv2.GC_PR_FGD
+        gc[er] = cv2.GC_FGD
+        bgm = np.zeros((1, 65), np.float64)
+        fgm = np.zeros((1, 65), np.float64)
+        cv2.grabCut(rgb, gc, None, bgm, fgm, 3, cv2.GC_INIT_WITH_MASK)
+        out = (gc == cv2.GC_FGD) | (gc == cv2.GC_PR_FGD)
+        return out if 0.4 * a <= out.sum() <= 1.5 * a else mask
+    except Exception:
+        me = cv2.erode(mask.astype(np.uint8), np.ones((3, 3), np.uint8), 1).astype(bool)
+        return me if me.any() else mask
+
+
+def backproject_frame(
+    depth_f,
+    K,
+    c2w_f,
+    mask_f,
+    conf_f=None,
+    conf_thr=0.0,
+    valid_f=None,
+    return_conf=False,
+    edges_f=None,
+):
+    """Return (M,3) world points for the masked pixels of one frame (c2w_f = cam->world 4x4).
+    valid_f: optional precomputed (isfinite & >0) depth mask, reused across all masks of a frame.
+    return_conf: also return the (M,) DA3 confidence of each kept point (for per-point noise-aware cleaning).
+    edges_f: optional per-frame depth-edge map; if given, keep the mask's largest depth-coherent component
+             (cuts mask-bleed onto adjacent objects at the depth boundary, per frame, before back-projection)."""
+    Hd, Wd = depth_f.shape
+    empty = (
+        (np.empty((0, 3), np.float32), np.empty((0,), np.float32))
+        if return_conf
+        else np.empty((0, 3), np.float32)
+    )
+    if mask_f.shape != (Hd, Wd):
+        mask_f = cv2.resize(
+            mask_f.astype(np.uint8), (Wd, Hd), interpolation=cv2.INTER_NEAREST
+        ).astype(bool)
+    if valid_f is None:
+        valid_f = np.isfinite(depth_f) & (depth_f > 0)
+    m = mask_f & valid_f
+    if conf_f is not None and conf_thr > 0:
+        m &= conf_f >= conf_thr
+    if (
+        edges_f is not None and m.sum() >= 30
+    ):  # keep the largest depth-coherent piece of the mask
+        from scipy import ndimage
+
+        lab, nlab = ndimage.label(m & ~edges_f)
+        if nlab >= 1:
+            sizes = np.bincount(lab.ravel())
+            sizes[0] = 0
+            big = int(sizes.argmax())
+            if (
+                sizes[big] >= 0.5 * m.sum()
+            ):  # object is the MAJORITY piece (bleed is a minority)
+                m = lab == big
+    if not m.any():
+        return empty
+    ys, xs = np.nonzero(m)
+    z = depth_f[ys, xs]
+    if DEPTH_COHERENCE and len(z) >= 8:
+        # an object is a coherent depth surface; floor/background BLEED pixels are depth outliers.
+        # Drop them via the standard Tukey fence (1.5*IQR) on the masked region's depths -- parameter-free.
+        q1, q3 = np.percentile(z, [25, 75])
+        iqr = q3 - q1
+        keep = (z >= q1 - 1.5 * iqr) & (z <= q3 + 1.5 * iqr)
+        if keep.sum() >= 1:
+            ys, xs, z = ys[keep], xs[keep], z[keep]
+    fx, fy, cx, cy = K[0, 0], K[1, 1], K[0, 2], K[1, 2]
+    Xc = np.stack([(xs - cx) * z / fx, (ys - cy) * z / fy, z], axis=1)  # camera coords
+    Xw = (c2w_f[:3, :3] @ Xc.T).T + c2w_f[:3, 3]  # -> world
+    if return_conf:
+        cw = (
+            conf_f[ys, xs].astype(np.float32)
+            if conf_f is not None
+            else np.ones(len(ys), np.float32)
+        )
+        return Xw.astype(np.float32), cw
+    return Xw.astype(np.float32)
+
+
+# ==========================================================================================
+# INSTANCE BUILDING -- oriented extent, 3D box-overlap re-identification, and the main
+# build_instances() driver that turns per-frame masks into per-class 3D instances. Merged in
+# from perceptual.py, verbatim.
+# ==========================================================================================
+
+
+def robust_centroid_extent(pts, up_axis=None):
+    """median centroid + ORIENTED robust extent.
+    If up_axis is given: YAW-ONLY oriented extent -- rotation is found by 2D PCA on the
+    floor-projected points only, with the up axis left untouched. This matches VSI-Bench's
+    own annotation convention for indoor scans (ScanNet/ARKitScenes OrientedBoundingBox
+    objects follow a Manhattan-world assumption: rotated only around the vertical axis,
+    never tilted). Unconstrained 3D PCA (the previous behavior) can chase noise on the
+    vertical axis for flat/elongated objects and drift away from the true yaw.
+    If up_axis is None (unknown at the call site): falls back to unconstrained 3D PCA.
+    Either way: parameter-free, rotation-invariant in-plane, p2..p98 robust extent."""
+    c = np.median(pts, axis=0)
+    X = pts - c
+    if len(X) > 5000:  # PCA on a sample (deterministic)
+        X = X[np.random.RandomState(0).choice(len(X), 5000, False)]
+    if up_axis is not None:
+        floor_axes = [i for i in range(3) if i != up_axis]
+        F = X[:, floor_axes]
+        try:
+            _, _, Vt2 = np.linalg.svd(F - F.mean(0), full_matrices=False)
+            proj_floor = F @ Vt2.T  # (N,2) along the object's own floor-plane axes
+        except np.linalg.LinAlgError:
+            proj_floor = F
+        up_col = X[:, up_axis : up_axis + 1]  # up axis untouched (yaw-only)
+        proj = np.concatenate([proj_floor, up_col], axis=1)
+    else:
+        try:
+            _, _, Vt = np.linalg.svd(X - X.mean(0), full_matrices=False)
+            proj = X @ Vt.T  # coordinates along principal axes
+        except np.linalg.LinAlgError:
+            proj = X
+    lo = np.percentile(proj, 2, axis=0)
+    hi = np.percentile(proj, 98, axis=0)
+    ext = np.maximum(hi - lo, 0.0)
+    dims = np.sort(ext)[::-1]  # the object's 3 oriented side lengths, longest first
+    return c.astype(np.float32), float(dims[0]), dims
+
+
+def _aabb(pts):
+    """robust (p2..p98) axis-aligned 3D box of an instance's world points."""
+    return np.percentile(pts, 2, axis=0), np.percentile(pts, 98, axis=0)
+
+
+def merge_by_box_overlap(insts, up_axis=None):
+    """Parameter-free 3D re-identification, with a temporal-exclusion gate.
+
+    SAM3 (a 2D tracker) emits a NEW masklet each time the camera revisits an object, so one
+    physical object -> several masklets at the same 3D location. We fuse two same-class masklets
+    iff BOTH:
+      (a) their measured 3D boxes overlap (or one centroid is inside the other) -- same volume, and
+      (b) they NEVER appear in the same frame -- temporal exclusion.
+    (b) is the key parameter-free invariant: two masklets co-visible in one frame were tracked by
+    SAM3 as distinct objects in that frame, so they ARE distinct (e.g. two chairs around a table);
+    we must never merge them, even if depth noise makes their boxes overlap. A revisit-duplicate,
+    by contrast, lives in DISJOINT frames. Both tests are exact/measured -- NO tuned threshold.
+    """
+    n = len(insts)
+    if n <= 1:
+        return insts
+    # Precompute the FULL pairwise box-match as one vectorized boolean matrix. With the per-frame
+    # batched detector a class can have 100+ raw instances; the old O(n^3) loop called np.all-based
+    # box_match millions of times. Here every pairwise test is one broadcast -> O(1) lookups below.
+    lo = np.stack([_aabb(i["pts"])[0] for i in insts]).astype(np.float32)  # (n,3)
+    hi = np.stack([_aabb(i["pts"])[1] for i in insts]).astype(np.float32)  # (n,3)
+    cents = np.stack([i["centroid"] for i in insts]).astype(np.float32)  # (n,3)
+    overlap = (hi[:, None, :] >= lo[None, :, :]).all(-1) & (
+        hi[None, :, :] >= lo[:, None, :]
+    ).all(-1)
+    ins = (cents[:, None, :] >= lo[None, :, :]).all(-1) & (
+        cents[:, None, :] <= hi[None, :, :]
+    ).all(-1)
+    match = (
+        overlap | ins | ins.T
+    )  # box_match[i,j]: same 3D volume (identical semantics to old code)
+    # group-level agglomeration: merge two groups only if their COMBINED frame sets are disjoint
+    # (so no two co-visible masklets ever land in one object) AND some cross-pair shares a 3D volume.
+    groups = [
+        {"members": [i], "frames": set(insts[i].get("frames", set()))} for i in range(n)
+    ]
+    changed = True
+    while changed:
+        changed = False
+        for a in range(len(groups)):
+            for b in range(a + 1, len(groups)):
+                if (
+                    groups[a]["frames"] & groups[b]["frames"]
+                ):  # co-visible -> distinct objects
+                    continue
+                if match[np.ix_(groups[a]["members"], groups[b]["members"])].any():
+                    groups[a]["members"] += groups[b]["members"]
+                    groups[a]["frames"] |= groups[b]["frames"]
+                    groups.pop(b)
+                    changed = True
+                    break
+            if changed:
+                break
+    merged = []
+    for g in groups:
+        idxs = g["members"]
+        pts = np.concatenate([insts[k]["pts"] for k in idxs], 0)
+        cpts = np.concatenate(
+            [
+                insts[k].get("conf", np.ones(len(insts[k]["pts"]), np.float32))
+                for k in idxs
+            ],
+            0,
+        )
+        best = max(
+            (insts[k]["best_pts"] for k in idxs), key=len
+        )  # largest single obs in the group
+        c, longest, dims = robust_centroid_extent(
+            best, up_axis
+        )  # size+pos+3 oriented dims from best view (#2/#4)
+        merged.append(
+            {
+                "centroid": c,
+                "size": longest,
+                "dims": dims,
+                "first_time": min(insts[k]["first_time"] for k in idxs),
+                "pts": pts,
+                "conf": cpts,
+                "best_pts": best,
+                "n": sum(insts[k]["n"] for k in idxs),
+                "nframes": len(g["frames"]),
+            }
+        )  # track persistence (evidence strength)
+    return merged
+
+
+def build_instances(
+    per_class, depth, intr, c2w, conf, frame_times, frame_paths=None, up_axis=None
+):
+    """-> {class: [ {centroid(3), size(longest dim), first_time, npts} ]}
+    up_axis: if known (from room_gravity, computed BEFORE this call), threads through to
+    robust_centroid_extent for yaw-only oriented sizing. If None, size falls back to
+    unconstrained 3D PCA."""
+    out = {}
+    stats = {}
+    nframes = len(depth)
+    # precompute each frame's valid-depth mask ONCE (was recomputed per mask -> per class).
+    valid = {}
+    edges = {}
+    rgb = {}
+    used_frames = {fi for frames in per_class.values() for fi in frames if fi < nframes}
+    for fi in used_frames:
+        valid[fi] = np.isfinite(depth[fi]) & (depth[fi] > 0)
+        edges[fi] = depth_edges(depth[fi], valid[fi]) if DEPTH_EDGE_REFINE else None
+        if MASK_REFINE and frame_paths and fi < len(frame_paths):
+            im = cv2.imread(frame_paths[fi])  # BGR; guidedFilter/grabCut want 3ch uint8
+            rgb[fi] = (
+                cv2.resize(im, (depth[fi].shape[1], depth[fi].shape[0]))
+                if im is not None
+                else None
+            )
+    for cls, frames in per_class.items():
+        # peak co-visibility: max distinct masklets SAM3 tracks SIMULTANEOUSLY in any one frame.
+        # geometry-free, parameter-free, immune to revisit over-count; provable lower bound on count.
+        peak = max((len(objs) for objs in frames.values()), default=0)
+        # gather world points + first-seen time + frame set per obj_id (SAM3 track id = masklet)
+        pts_by_id, conf_by_id, first_t, frames_by_id = {}, {}, {}, {}
+        # px_by_id: (fidx, frame_time, mask_pixel_count) per obj_id, for appearance-order timing.
+        # VSI-Bench's own GT defines "first appearance" as the timestamp where an object's pixel
+        # count crosses a threshold (paper appendix B.1) -- NOT the first frame with any pixel at
+        # all. A single stray mask-bleed/false-positive pixel would otherwise register as "first
+        # seen" far too early. The threshold is self-calibrated per instance (that instance's OWN
+        # median observed pixel count across its frames), same convention as _clean's median cut.
+        px_by_id = {}
+        for fidx, objs in frames.items():
+            if fidx >= nframes:  # guard: SAM3 frame idx vs DA3 frames
+                continue
+            for oid, mask in objs.items():
+                if MASK_REFINE and rgb.get(fidx) is not None:
+                    me = (
+                        mask
+                        if os.environ.get("VSI_NO_REFINE") == "1"
+                        else refine_mask(mask, rgb[fidx])
+                    )  # appearance-guided boundary snap (clips same-depth bleed)
+                else:
+                    # erode 1px to drop mask-edge / background depth bleed
+                    me = cv2.erode(
+                        mask.astype(np.uint8), np.ones((3, 3), np.uint8), 1
+                    ).astype(bool)
+                    if not me.any():
+                        me = mask
+                conf_f = conf[fidx] if conf is not None else None
+                conf_thr = (
+                    np.percentile(conf_f, CONF_PCT)
+                    if (conf_f is not None and CONF_PCT > 0)
+                    else 0.0
+                )
+                Xw, cw = backproject_frame(
+                    depth[fidx],
+                    intr[fidx],
+                    c2w[fidx],
+                    me,
+                    conf_f,
+                    conf_thr=conf_thr,
+                    valid_f=valid.get(fidx),
+                    return_conf=True,
+                    edges_f=edges.get(fidx),
+                )
+                if len(Xw):
+                    pts_by_id.setdefault(oid, []).append(Xw)
+                    conf_by_id.setdefault(oid, []).append(
+                        cw
+                    )  # per-point DA3 confidence (for _clean)
+                    frames_by_id.setdefault(oid, set()).add(
+                        fidx
+                    )  # for co-occurrence gate
+                    t = frame_times[fidx]
+                    px_by_id.setdefault(oid, []).append((fidx, t, int(me.sum())))
+        # appearance_order timing: per instance, first frame at/above its OWN median pixel count
+        for oid, obs in px_by_id.items():
+            counts = [c for _, _, c in obs]
+            thresh = float(np.median(counts))
+            crossing = [t for _, t, c in obs if c >= thresh]
+            first_t[oid] = min(crossing) if crossing else min(t for _, t, c in obs)
+        insts = []
+        for oid, plist in pts_by_id.items():
+            pts = np.concatenate(plist, 0)
+            cpts = np.concatenate(conf_by_id[oid], 0)
+            if len(pts) < MIN_INSTANCE_PTS:
+                continue
+            best = max(
+                plist, key=len
+            )  # #2/#4: largest single-frame observation (closest/most pixels)
+            bc, bsize, bdims = robust_centroid_extent(
+                best, up_axis
+            )  # size + position + 3 oriented dims from best view
+            insts.append(
+                {
+                    "centroid": bc,
+                    "size": bsize,
+                    "dims": bdims,
+                    "first_time": first_t[oid],
+                    "pts": pts,
+                    "conf": cpts,
+                    "best_pts": best,
+                    "n": len(pts),
+                    "frames": frames_by_id[oid],
+                }
+            )
+        raw = len(insts)
+        # 3D re-ID: fuse same-class masklets that occupy the same measured 3D volume (parameter-free).
+        insts = merge_by_box_overlap(insts, up_axis)
+        if insts:
+            out[cls] = insts
+            stats[cls] = {"raw": raw, "merged": len(insts), "peak": peak}
+    return out, stats
+
+
+# ==========================================================================================
+# PER-CLASS SUMMARY + FLOOR AREA -- legacy array-schema row builder, and the room-scale floor
+# area calculation. Merged in from perceptual.py, verbatim.
+# ==========================================================================================
+
+
+# ---- Per-class spatial code (legacy array-schema row) -------------------------------------
+def class_spatial_code(insts, peak=0):
+    cents = np.stack([i["centroid"] for i in insts], 0)  # (n,3)
+    sizes = np.array([i["size"] for i in insts], np.float32)
+    n = len(insts)  # merged centroids (for spatial stats)
+    count = peak if peak else n  # reported count = peak co-visibility
+    x, y, z = cents.mean(0)
+    if n == 1:
+        e1 = e2 = e3 = px = pz = 0.0
+        size_iqr = 0.0
+    else:
+        cov = np.cov(cents.T)  # 3x3
+        vals, vecs = np.linalg.eigh(cov)  # ascending
+        order = np.argsort(vals)[::-1]
+        vals = np.clip(vals[order], 0, None)
+        vecs = vecs[:, order]
+        e1, e2, e3 = vals.tolist()
+        pv = vecs[:, 0]  # principal eigenvector
+        px, pz = float(pv[0]), float(pv[2])
+        q1, q3 = np.percentile(sizes, [25, 75])
+        size_iqr = float(q3 - q1)
+    size_median = float(np.median(sizes))
+    first_time = float(min(i["first_time"] for i in insts))
+    row = [x, y, z, e1, e2, e3, px, pz, size_median, size_iqr, first_time, count]
+    row = [
+        (lambda r: 0.0 if r == 0 else r)(round(float(v), 1)) for v in row
+    ]  # kill -0.0
+    row[-1] = int(count)
+    return row
+
+
+# ---- floor_area (full-scene min-Y points -> XZ convex hull) -------------------------------
+def compute_floor_area(depth, intr, c2w, conf, sky, stride=8, up_vec=None):
+    pts = []
+    for f in range(depth.shape[0]):
+        Hd, Wd = depth[f].shape
+        ys, xs = np.mgrid[0:Hd:stride, 0:Wd:stride]
+        ys = ys.ravel()
+        xs = xs.ravel()
+        z = depth[f][ys, xs]
+        ok = np.isfinite(z) & (z > 0)
+        if sky is not None:
+            ok &= ~sky[f][ys, xs].astype(bool)
+        if conf is not None:
+            ok &= conf[f][ys, xs] >= np.percentile(conf[f], 40)
+        ys, xs, z = ys[ok], xs[ok], z[ok]
+        if not len(z):
+            continue
+        K = intr[f]
+        fx, fy, cx, cy = K[0, 0], K[1, 1], K[0, 2], K[1, 2]
+        Xc = np.stack([(xs - cx) * z / fx, (ys - cy) * z / fy, z], 1)
+        Xw = (c2w[f][:3, :3] @ Xc.T).T + c2w[f][:3, 3]
+        pts.append(Xw.astype(np.float32))
+    if not pts:
+        return 0.0
+    P = np.concatenate(pts, 0)
+    if up_vec is not None:
+        # VSI-faithful: area in the plane orthogonal to GRAVITY (RANSAC floor normal), like the
+        # benchmark's gravity-aligned GT meshes. Build an orthonormal in-plane basis (u, v).
+        g = np.asarray(up_vec, np.float64)
+        g /= np.linalg.norm(g) + 1e-12
+        a = np.array([1.0, 0.0, 0.0]) if abs(g[0]) < 0.9 else np.array([0.0, 1.0, 0.0])
+        u = np.cross(g, a)
+        u /= np.linalg.norm(u)
+        v = np.cross(g, u)
+        F_full = np.stack([P @ u, P @ v], 1)
+    else:
+        up = int(
+            np.argmin(P.max(0) - P.min(0))
+        )  # legacy: vertical = smallest-extent axis
+        floor_axes = [i for i in range(3) if i != up]
+        F_full = P[:, floor_axes]
+    # VSI-Bench room-size definition = alpha-shape of the floor-plane point cloud (confirmed in their
+    # paper appendix). VSI does not publish the alpha value they use for their own GT mesh, so alpha=2
+    # here is NOT a matched/verified constant -- it was chosen empirically for this pipeline's own
+    # (sparser) reconstructed point density. This is the one disclosed benchmark-adjacent tuned constant
+    # in the whole file; everything else is exact/derived or a generic, non-tuned statistical convention.
+    # (Falls back to enclosed-fill below if the alphashape package isn't available.)
+    F = F_full
+    lo = np.percentile(F, 0.5, 0)
+    hi = np.percentile(F, 99.5, 0)  # gentle clip (preserve room extent)
+    F = F[
+        (F[:, 0] >= lo[0])
+        & (F[:, 0] <= hi[0])
+        & (F[:, 1] >= lo[1])
+        & (F[:, 1] <= hi[1])
+    ]
+    if len(F) < 10:
+        return 0.0
+    try:
+        import alphashape
+
+        idx = np.random.RandomState(0).choice(len(F), min(10000, len(F)))
+        return round(
+            float(alphashape.alphashape(F[idx], alpha=2).area), 1
+        )  # alpha=2 tuned for recon density
+    except Exception:
+        from scipy import ndimage
+
+        res = 0.10
+        ai = ((F[:, 0] - F[:, 0].min()) / res).astype(int)
+        bi = ((F[:, 1] - F[:, 1].min()) / res).astype(int)
+        grid = np.zeros((ai.max() + 3, bi.max() + 3), np.uint8)
+        grid[ai + 1, bi + 1] = 1
+        grid = cv2.morphologyEx(grid, cv2.MORPH_CLOSE, np.ones((7, 7), np.uint8))
+        grid = ndimage.binary_fill_holes(grid).astype(np.uint8)
+        return round(float(grid.sum()) * res * res, 1)
+
+
+# ---------------------------------------------------------------------------
+
+# ==========================================================================================
+# SPATIAL CODE ASSEMBLY -- the top-level entry point this whole file exists for:
+# build_spatial_code() calls everything above to turn already-computed depth/pose/masks into
+# the final spatial code dict. Room outline + JSON writer. This section was already in
+# geometric.py before the perceptual.py merge; build_spatial_code() below is updated to call
+# the geometry functions above DIRECTLY (no `pl.` prefix -- they're plain local functions now
+# that everything is in one file), same logic, unchanged otherwise.
+# ==========================================================================================
+
+
+def _room_outline(depth, intr, c2w, conf, bu, bv):
+    """(Currently unemitted -- the one spatial code shape has no room outline field; this
+    math is kept intact for reuse.) Room floor-boundary polygon from the SAME grid as
+    compute_floor_area: floor points
+    projected onto the shared gravity plane (bu, bv), 10cm grid, close 7x7, fill holes,
+    largest contour, 0.2m polygon simplification. Same (bu, bv) as objects/camera, so the
+    outline, object positions, and floor_area all live in one consistent frame."""
+    from scipy import ndimage
+
+    pts, stride = [], 8
+    for f in range(0, depth.shape[0], 3):
+        Hd, Wd = depth[f].shape
+        ys, xs = np.mgrid[0:Hd:stride, 0:Wd:stride]
+        ys = ys.ravel()
+        xs = xs.ravel()
+        z = depth[f][ys, xs]
+        ok = np.isfinite(z) & (z > 0)
+        if conf is not None:
+            ok &= conf[f][ys, xs] >= np.percentile(conf[f], 40)
+        ys, xs, z = ys[ok], xs[ok], z[ok]
+        if not len(z):
+            continue
+        K = intr[f]
+        Xc = np.stack(
+            [(xs - K[0, 2]) * z / K[0, 0], (ys - K[1, 2]) * z / K[1, 1], z], 1
+        )
+        pts.append(((c2w[f][:3, :3] @ Xc.T).T + c2w[f][:3, 3]).astype(np.float32))
+    if not pts:
+        return []
+    Pw = np.concatenate(pts, 0)
+    P = np.stack(
+        [Pw @ bu, Pw @ bv], 1
+    )  # gravity-plane projection (same bu,bv as objects/area)
+    lo = np.percentile(P, 0.5, 0)
+    hi = np.percentile(P, 99.5, 0)
+    P = P[
+        (P[:, 0] >= lo[0])
+        & (P[:, 0] <= hi[0])
+        & (P[:, 1] >= lo[1])
+        & (P[:, 1] <= hi[1])
+    ]
+    if len(P) < 10:
+        return []
+    res = 0.10
+    x0, y0 = P[:, 0].min(), P[:, 1].min()
+    ai = ((P[:, 0] - x0) / res).astype(int)
+    bi = ((P[:, 1] - y0) / res).astype(int)
+    grid = np.zeros((ai.max() + 3, bi.max() + 3), np.uint8)
+    grid[ai + 1, bi + 1] = 1
+    grid = cv2.morphologyEx(grid, cv2.MORPH_CLOSE, np.ones((7, 7), np.uint8))
+    grid = ndimage.binary_fill_holes(grid).astype(np.uint8)
+    cs, _ = cv2.findContours(grid, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+    if not cs:
+        return []
+    poly = cv2.approxPolyDP(max(cs, key=cv2.contourArea), 0.2 / res, True)[:, 0, :]
+    # cv2 contour points are (col=bi, row=ai) -> (floor_y, floor_x)
+    return [
+        {
+            "floor_x_meters": round(float((r - 1) * res + x0), 1),
+            "floor_y_meters": round(float((c - 1) * res + y0), 1),
+        }
+        for c, r in poly
+    ]
+
+
+def build_spatial_code_raw(depth, intr, c2w, conf, ftimes, per):
+    """Builds THE spatial code -- the one and only shape a spatial code has, everywhere
+    (on disk, in prompts, in this pipeline): unit-strings ("1.4 meters"), spaced keys
+    ("x coordinate"), per-instance position + longest dimension only, room "floor area",
+    "closest classes distance meters from" (rooted per class, distance + closeness rank),
+    and a flat earliest-first "appearance order" list of class names. There is no separate
+    raw/rendered split and no schema flag -- the old v1/v2 branching (VSI_CODE_V2) and the
+    raw intermediate form (floor_x_meters keys, bounding_box, dimensions_meters,
+    seen_in_video_frames, camera_trajectory, room.outline) are gone; every underlying VALUE
+    that survives is computed by exactly the same math as before, only the emitted fields
+    and their formatting changed."""
+    # emission-time class rename: VSI's questions say 'coat rack' while their annotations
+    # (and hence the SAM3 prompt + caches) say 'coat hanger' -- same object, their naming
+    # seam. The model sees questions, so emitted codes follow the question vocabulary.
+    _ALIAS = {"coat hanger": "coat rack"}
+    per = {_ALIAS.get(k, k): v for k, v in per.items()}
+    inst, stats = build_instances(per, depth, intr, c2w, conf, ftimes)
+    up_vec, up_ax = room_gravity(
+        depth, intr, c2w, conf
+    )  # gravity = RANSAC floor normal (VSI-faithful)
+    bu, bv, bg = _floor_basis(
+        up_vec
+    )  # shared gravity floor frame (bu,bv horizontal, bg up)
+    P = np.concatenate([i["pts"] for cl in inst.values() for i in cl], 0)
+    # floor = robust bottom of observed geometry along gravity (low percentile).
+    floor_level = float(np.percentile(P @ bg, 2))
+    fa = compute_floor_area(depth, intr, c2w, conf, None, up_vec=up_vec)
+    code = to_spatial_code(inst, stats, fa, up_ax, up_vec, floor_level)
+    cls = list(inst.keys())
+    class_first = {c: min(i["first_time"] for i in v) for c, v in inst.items()}
+
+    # Keyed dict + integer ranks (not a sorted list): each question option becomes ONE
+    # direct key access, and "which is closest" = min over small integers -- the filtered
+    # list-scan and decimal comparison were the observed failure modes even on GT data.
+    # 2-decimal distances: 0.1m rounding costs up to ~17% relative error on sub-meter
+    # answers, which fails the strictest MRA thresholds even with perfect values.
+    ccf = {}
+    for a in cls:
+        ds = sorted(
+            (round(answer_closest_distance(inst[a], inst[b]), 2), b)
+            for b in cls
+            if b != a
+        )
+        ccf[a] = {
+            b: {"distance": f"{d} meters", "closeness rank": i + 1}
+            for i, (d, b) in enumerate(ds)
+        }
+    code["closest classes distance meters from"] = ccf
+
+    # Class names only, no first_seen_seconds value -- a reader only ever needs the ORDER
+    # (which appearance order already sorts for them), never the raw timestamp; showing the
+    # timestamp invited re-deriving/re-sorting instead of just reading the given order (observed
+    # empirically), and it duplicated per-instance timing that lives nowhere else in the code now.
+    code["appearance order"] = [
+        c for c, t in sorted(class_first.items(), key=lambda kv: kv[1])
+    ]
+    return code, inst, stats, up_ax, up_vec, fa
+
+
+def dump_spatial_code(code, path):
+    """Save a spatial_code.json exactly like json.dump(code, f, indent=1), EXCEPT
+    "appearance order" is written as one compact line instead of one line per entry -- it's a
+    single ordered sequence meant to be scanned, not structured data meant to be read field by
+    field like the rest of the code. Every writer of spatial_code.json should go through this
+    (not a bare json.dump) so the on-disk format and the prompt-time format never drift apart."""
+    body = dict(code)
+    ao = body.pop("appearance order", None)
+    text = json.dumps(body, indent=1).rstrip()
+    if ao is not None:
+        assert text.endswith("}")
+        text = text[:-1].rstrip() + ',\n "appearance order": ' + json.dumps(ao) + "\n}"
+    with open(path, "w") as f:
+        f.write(text)
+
+
+# Canonical world-space fallback used by SegVGGT and similar adapters.
+def _canonical_room_gravity(P, cameras=None, iters=300, thr=0.05):
+    """Robust UP vector = normal of the RANSAC floor plane, oriented toward the cameras."""
+    P = np.asarray(P, np.float64)
+    P = P[np.isfinite(P).all(1)]
+    if len(P) > 100000:
+        P = P[np.random.RandomState(0).choice(len(P), 100000, False)]
+    cam = (
+        np.asarray(cameras, np.float64).mean(0)
+        if cameras is not None and len(cameras)
+        else None
+    )
+    if len(P) < 100:
+        ext = np.percentile(P, 98, 0) - np.percentile(P, 2, 0) if len(P) else np.ones(3)
+        ax = int(np.argmin(ext))
+        g = np.zeros(3)
+        g[ax] = 1.0
+        return (g, ax)
+    rng = np.random.RandomState(0)
+    best = None
+    best_score = -1
+    for _ in range(iters):
+        a, b, c = P[rng.choice(len(P), 3, False)]
+        nrm = np.cross(b - a, c - a)
+        ln = np.linalg.norm(nrm)
+        if ln < 1e-06:
+            continue
+        nrm /= ln
+        d = -nrm @ a
+        side = P @ nrm + d
+        ninl = int((np.abs(side) < thr).sum())
+        if ninl < 50:
+            continue
+        score = ninl * max(np.mean(side > thr), np.mean(side < -thr))
+        if score > best_score:
+            best_score = score
+            best = (nrm, d)
+    if best is None:
+        ext = np.percentile(P, 98, 0) - np.percentile(P, 2, 0)
+        ax = int(np.argmin(ext))
+        g = np.zeros(3)
+        g[ax] = 1.0
+        return (g, ax)
+    nrm, d = best
+    if cam is not None and cam @ nrm + d < 0:
+        nrm = -nrm
+    return (nrm.astype(np.float32), int(np.argmax(np.abs(nrm))))
+
+
+def _canonical_floor_basis(up_vec):
+    """Orthonormal floor basis (u, v horizontal; g = up), unchanged from the old file."""
+    g = np.asarray(up_vec, np.float64)
+    g = g / (np.linalg.norm(g) + 1e-12)
+    up_ax = int(np.argmax(np.abs(g)))
+    floor_axes = [a for a in range(3) if a != up_ax]
+    e0 = np.zeros(3)
+    e0[floor_axes[0]] = 1.0
+    u = e0 - e0 @ g * g
+    u = u / (np.linalg.norm(u) + 1e-12)
+    v = np.cross(g, u)
+    if v[floor_axes[1]] < 0:
+        v = -v
+    return (u, v, g)
+
+
+def _canonical_robust_centroid_extent(pts, up_axis=None):
+    c = np.median(pts, axis=0)
+    X = pts - c
+    if len(X) > 5000:
+        X = X[np.random.RandomState(0).choice(len(X), 5000, False)]
+    if up_axis is not None:
+        floor_axes = [i for i in range(3) if i != up_axis]
+        F = X[:, floor_axes]
+        try:
+            _, _, Vt2 = np.linalg.svd(F - F.mean(0), full_matrices=False)
+            proj_floor = F @ Vt2.T
+        except np.linalg.LinAlgError:
+            proj_floor = F
+        proj = np.concatenate([proj_floor, X[:, up_axis : up_axis + 1]], 1)
+    else:
+        try:
+            _, _, Vt = np.linalg.svd(X - X.mean(0), full_matrices=False)
+            proj = X @ Vt.T
+        except np.linalg.LinAlgError:
+            proj = X
+    ext = np.maximum(np.percentile(proj, 98, 0) - np.percentile(proj, 2, 0), 0.0)
+    dims = np.sort(ext)[::-1]
+    return (c.astype(np.float32), float(dims[0]), dims)
+
+
+def _canonical_aabb(pts):
+    return (np.percentile(pts, 2, 0), np.percentile(pts, 98, 0))
+
+
+def _canonical_merge_by_box_overlap(insts, up_axis=None):
+    """Parameter-free 3D re-identification with temporal exclusion, unchanged."""
+    n = len(insts)
+    if n <= 1:
+        return insts
+    lo = np.stack([_canonical_aabb(i["pts"])[0] for i in insts])
+    hi = np.stack([_canonical_aabb(i["pts"])[1] for i in insts])
+    cents = np.stack([i["centroid"] for i in insts])
+    overlap = (hi[:, None] >= lo[None]).all(-1) & (hi[None] >= lo[:, None]).all(-1)
+    ins = (cents[:, None] >= lo[None]).all(-1) & (cents[:, None] <= hi[None]).all(-1)
+    match = overlap | ins | ins.T
+    groups = [
+        {"members": [i], "frames": set(insts[i].get("frames", ()))} for i in range(n)
+    ]
+    changed = True
+    while changed:
+        changed = False
+        for a in range(len(groups)):
+            for b in range(a + 1, len(groups)):
+                if groups[a]["frames"] & groups[b]["frames"]:
+                    continue
+                if match[np.ix_(groups[a]["members"], groups[b]["members"])].any():
+                    groups[a]["members"] += groups[b]["members"]
+                    groups[a]["frames"] |= groups[b]["frames"]
+                    groups.pop(b)
+                    changed = True
+                    break
+            if changed:
+                break
+    out = []
+    for g in groups:
+        ii = g["members"]
+        pts = np.concatenate([insts[k]["pts"] for k in ii], 0)
+        best = max((insts[k]["best_pts"] for k in ii), key=len)
+        c, size, dims = _canonical_robust_centroid_extent(best, up_axis)
+        confs = [insts[k].get("conf") for k in ii]
+        conf = (
+            np.concatenate([x for x in confs if x is not None], 0)
+            if any((x is not None for x in confs))
+            else None
+        )
+        out.append(
+            {
+                "centroid": c,
+                "size": size,
+                "dims": dims,
+                "pts": pts,
+                "best_pts": best,
+                "conf": conf,
+                "frames": g["frames"],
+                "nframes": len(g["frames"]),
+                "n": sum((insts[k]["n"] for k in ii)),
+                "first_time": min((insts[k]["first_time"] for k in ii)),
+            }
+        )
+    return out
+
+
+def _canonical_sor(pts, k=16, std=2.0, cap=4000):
+    from scipy.spatial import cKDTree
+
+    if len(pts) < k + 2:
+        return pts
+    P = (
+        pts
+        if len(pts) <= cap
+        else pts[np.random.RandomState(0).choice(len(pts), cap, False)]
+    )
+    d, _ = cKDTree(P).query(P, k=k + 1, workers=KD_WORKERS)
+    md = d[:, 1:].mean(1)
+    return P[md <= md.mean() + std * md.std()]
+
+
+def _canonical_clean(inst, cap=4000):
+    if inst.get("_cleanpts") is not None:
+        return inst["_cleanpts"]
+    pts, conf = (inst["pts"], inst.get("conf"))
+    if len(pts) > cap:
+        idx = np.random.RandomState(0).choice(len(pts), cap, False)
+        pts = pts[idx]
+        if conf is not None:
+            conf = conf[idx]
+    if conf is not None and len(conf) > 20:
+        keep = conf >= np.median(conf)
+        if keep.sum() >= 10:
+            pts = pts[keep]
+    inst["_cleanpts"] = _canonical_sor(pts, cap=cap)
+    return inst["_cleanpts"]
+
+
+def _canonical_rep(insts):
+    return max(insts, key=lambda i: (i.get("n", len(i["pts"])), i.get("nframes", 0)))
+
+
+def _canonical_answer_closest_distance(instsA, instsB, k=4000):
+    from scipy.spatial import cKDTree
+
+    A, B = (
+        _canonical_clean(_canonical_rep(instsA), k),
+        _canonical_clean(_canonical_rep(instsB), k),
+    )
+    if not len(A) or not len(B):
+        return float("inf")
+    d, _ = (
+        cKDTree(A).query(B, workers=KD_WORKERS)
+        if len(A) <= len(B)
+        else cKDTree(B).query(A, workers=KD_WORKERS)
+    )
+    return float(d.min())
+
+
+def _canonical_compute_floor_area(P, up_vec):
+    P = np.asarray(P, np.float32)
+    P = P[np.isfinite(P).all(1)]
+    if not len(P):
+        return 0.0
+    g = np.asarray(up_vec, np.float64)
+    g /= np.linalg.norm(g) + 1e-12
+    a = np.array([1.0, 0.0, 0.0]) if abs(g[0]) < 0.9 else np.array([0.0, 1.0, 0.0])
+    u = np.cross(g, a)
+    u /= np.linalg.norm(u)
+    v = np.cross(g, u)
+    F = np.stack([P @ u, P @ v], 1)
+    lo, hi = (np.percentile(F, 0.5, 0), np.percentile(F, 99.5, 0))
+    F = F[
+        (F[:, 0] >= lo[0])
+        & (F[:, 0] <= hi[0])
+        & (F[:, 1] >= lo[1])
+        & (F[:, 1] <= hi[1])
+    ]
+    if len(F) < 10:
+        return 0.0
+    try:
+        import alphashape
+
+        idx = np.random.RandomState(0).choice(len(F), min(10000, len(F)))
+        return round(float(alphashape.alphashape(F[idx], alpha=2).area), 1)
+    except Exception:
+        from scipy import ndimage
+
+        res = 0.1
+        ai = ((F[:, 0] - F[:, 0].min()) / res).astype(int)
+        bi = ((F[:, 1] - F[:, 1].min()) / res).astype(int)
+        grid = np.zeros((ai.max() + 3, bi.max() + 3), np.uint8)
+        grid[ai + 1, bi + 1] = 1
+        grid = cv2.morphologyEx(grid, cv2.MORPH_CLOSE, np.ones((7, 7), np.uint8))
+        grid = ndimage.binary_fill_holes(grid)
+        return round(float(grid.sum()) * res * res, 1)
+
+
+def _canonical_object_records(insts, count, u, v, g, floor_level):
+    ranked = sorted(insts, key=lambda i: (i["n"], i.get("nframes", 0)), reverse=True)[
+        : max(count, 1)
+    ]
+    return [
+        {
+            "position": {
+                "x coordinate": f"{round(float(i['centroid'] @ u), 2)} meters",
+                "y coordinate": f"{round(float(i['centroid'] @ v), 2)} meters",
+                "height above floor": f"{round(float(i['centroid'] @ g - floor_level), 2)} meters",
+            },
+            "longest dimension": f"{round(float(i['size']), 2)} meters",
+        }
+        for i in ranked
+    ]
+
+
+# ==========================================================================================
+# MODEL-AGNOSTIC ENTRY POINT
+# ==========================================================================================
+
+
+def build_spatial_code(scene):
+    """Build the unchanged compact spatial-code schema.
+
+    Raw depth/pose/confidence/mask bundles use the exact reference path above. Canonical
+    world-space bundles (for SegVGGT and models with different native outputs) use the same
+    downstream formulas wherever equivalent inputs exist.
+    """
+    raw_inputs = scene.get("raw_inputs")
+    if raw_inputs is not None:
+        return build_spatial_code_raw(
+            raw_inputs["depth"],
+            raw_inputs["intr"],
+            raw_inputs["c2w"],
+            raw_inputs.get("conf"),
+            raw_inputs["ftimes"],
+            raw_inputs["per"],
+        )
+
+    alias = {"coat hanger": "coat rack"}
+    raw = {alias.get(k, k): v for k, v in scene["instances"].items()}
+    stats = {alias.get(k, k): dict(v) for k, v in scene["stats"].items()}
+    up_vec, up_ax = _canonical_room_gravity(scene["scene_pts"], scene.get("cameras"))
+    u, v, g = _canonical_floor_basis(up_vec)
+
+    inst = {}
+    for cls, items in raw.items():
+        measured = []
+        for item in items:
+            centroid, size, dims = _canonical_robust_centroid_extent(
+                item["best_pts"], up_ax
+            )
+            record = dict(item)
+            record.update({"centroid": centroid, "size": size, "dims": dims})
+            measured.append(record)
+        inst[cls] = _canonical_merge_by_box_overlap(measured, up_ax)
+        stats.setdefault(cls, {})
+        stats[cls]["merged"] = len(inst[cls])
+        stats[cls].setdefault("peak", len(inst[cls]))
+
+    all_points = np.concatenate(
+        [i["pts"] for values in inst.values() for i in values], 0
+    )
+    floor_level = float(np.percentile(all_points @ g, 2))
+    objects = {}
+    for cls, items in inst.items():
+        requested_count = max(0, int(stats[cls].get("peak", len(items))))
+        emitted_count = min(requested_count, len(items))
+        records = (
+            _canonical_object_records(items, emitted_count, u, v, g, floor_level)
+            if emitted_count
+            else []
+        )
+        objects[cls] = {"count": len(records), "instances": records}
+
+    floor_area = _canonical_compute_floor_area(scene["scene_pts"], up_vec)
+    code = {"objects": objects, "room": {"floor area": f"{floor_area} square meters"}}
+    classes = list(inst)
+    closest = {}
+    for a in classes:
+        distances = sorted(
+            (round(_canonical_answer_closest_distance(inst[a], inst[b]), 2), b)
+            for b in classes
+            if b != a
+        )
+        closest[a] = {
+            b: {"distance": f"{distance} meters", "closeness rank": rank + 1}
+            for rank, (distance, b) in enumerate(distances)
+        }
+    code["closest classes distance meters from"] = closest
+    first = {cls: min(i["first_time"] for i in values) for cls, values in inst.items()}
+    code["appearance order"] = [
+        cls for cls, _ in sorted(first.items(), key=lambda kv: kv[1])
+    ]
+    return code, inst, stats, up_ax, up_vec, floor_area

results/symbolic/.ipynb_checkpoints/_summary-checkpoint.json

@@ -0,0 +1,16 @@
+{
+ "scenes_run": [
+  "41069025"
+ ],
+ "scenes_skipped_no_questions": [],
+ "combined_aggregate": {
+  "overall": 5.333333333333333,
+  "object_counting_MRA:.5:.95:.05": 0.0,
+  "object_abs_distance_MRA:.5:.95:.05": 26.666666666666668,
+  "object_size_estimation_MRA:.5:.95:.05": 0.0,
+  "room_size_estimation_MRA:.5:.95:.05": 0.0,
+  "object_rel_direction_accuracy": 0.0,
+  "tabulated_keys": "overall, object_counting_MRA:.5:.95:.05, object_abs_distance_MRA:.5:.95:.05, object_size_estimation_MRA:.5:.95:.05, room_size_estimation_MRA:.5:.95:.05, object_rel_direction_accuracy",
+  "tabulated_results": "5.333, 0.000, 26.667, 0.000, 0.000, 0.000"
+ }
+}

results/symbolic/41069025/0.json

@@ -0,0 +1,16 @@
+{
+ "model": "symbolic",
+ "condition": "symbolic",
+ "number_of_frames": null,
+ "scene": "41069025",
+ "dataset": "arkitscenes",
+ "question_id": 0,
+ "question_type": "object_counting",
+ "question": "How many table(s) are in this room?",
+ "options": null,
+ "full_prompt": null,
+ "answer_expected": "4",
+ "answer_given": "1",
+ "answer_raw": "1",
+ "score": 0.0
+}

results/symbolic/41069025/1.json

@@ -0,0 +1,16 @@
+{
+ "model": "symbolic",
+ "condition": "symbolic",
+ "number_of_frames": null,
+ "scene": "41069025",
+ "dataset": "arkitscenes",
+ "question_id": 1,
+ "question_type": "object_counting",
+ "question": "How many chair(s) are in this room?",
+ "options": null,
+ "full_prompt": null,
+ "answer_expected": "2",
+ "answer_given": "28",
+ "answer_raw": "28",
+ "score": 0.0
+}

results/symbolic/41069025/1100.json

@@ -0,0 +1,20 @@
+{
+ "model": "symbolic",
+ "condition": "symbolic",
+ "number_of_frames": null,
+ "scene": "41069025",
+ "dataset": "arkitscenes",
+ "question_id": 1100,
+ "question_type": "object_rel_direction_medium",
+ "question": "If I am standing by the stove and facing the sofa, is the tv to my left, right, or back?\nAn object is to my back if I would have to turn at least 135 degrees in order to face it.",
+ "options": [
+  "A. back",
+  "B. right",
+  "C. left"
+ ],
+ "full_prompt": null,
+ "answer_expected": "C",
+ "answer_given": "B",
+ "answer_raw": "B",
+ "score": 0.0
+}

results/symbolic/41069025/1101.json

@@ -0,0 +1,20 @@
+{
+ "model": "symbolic",
+ "condition": "symbolic",
+ "number_of_frames": null,
+ "scene": "41069025",
+ "dataset": "arkitscenes",
+ "question_id": 1101,
+ "question_type": "object_rel_direction_medium",
+ "question": "If I am standing by the stove and facing the tv, is the sofa to my left, right, or back?\nAn object is to my back if I would have to turn at least 135 degrees in order to face it.",
+ "options": [
+  "A. right",
+  "B. left",
+  "C. back"
+ ],
+ "full_prompt": null,
+ "answer_expected": "A",
+ "answer_given": "B",
+ "answer_raw": "B",
+ "score": 0.0
+}

results/symbolic/41069025/1102.json

@@ -0,0 +1,20 @@
+{
+ "model": "symbolic",
+ "condition": "symbolic",
+ "number_of_frames": null,
+ "scene": "41069025",
+ "dataset": "arkitscenes",
+ "question_id": 1102,
+ "question_type": "object_rel_direction_medium",
+ "question": "If I am standing by the sofa and facing the stove, is the tv to my left, right, or back?\nAn object is to my back if I would have to turn at least 135 degrees in order to face it.",
+ "options": [
+  "A. back",
+  "B. right",
+  "C. left"
+ ],
+ "full_prompt": null,
+ "answer_expected": "B",
+ "answer_given": "C",
+ "answer_raw": "C",
+ "score": 0.0
+}

results/symbolic/41069025/1236.json

@@ -0,0 +1,19 @@
+{
+ "model": "symbolic",
+ "condition": "symbolic",
+ "number_of_frames": null,
+ "scene": "41069025",
+ "dataset": "arkitscenes",
+ "question_id": 1236,
+ "question_type": "object_rel_direction_easy",
+ "question": "If I am standing by the stove and facing the sofa, is the tv to the left or the right of the sofa?",
+ "options": [
+  "A. left",
+  "B. right"
+ ],
+ "full_prompt": null,
+ "answer_expected": "A",
+ "answer_given": "B",
+ "answer_raw": "B",
+ "score": 0.0
+}

results/symbolic/41069025/1237.json

@@ -0,0 +1,19 @@
+{
+ "model": "symbolic",
+ "condition": "symbolic",
+ "number_of_frames": null,
+ "scene": "41069025",
+ "dataset": "arkitscenes",
+ "question_id": 1237,
+ "question_type": "object_rel_direction_easy",
+ "question": "If I am standing by the stove and facing the tv, is the sofa to the left or the right of the tv?",
+ "options": [
+  "A. left",
+  "B. right"
+ ],
+ "full_prompt": null,
+ "answer_expected": "B",
+ "answer_given": "A",
+ "answer_raw": "A",
+ "score": 0.0
+}

results/symbolic/41069025/1238.json

@@ -0,0 +1,19 @@
+{
+ "model": "symbolic",
+ "condition": "symbolic",
+ "number_of_frames": null,
+ "scene": "41069025",
+ "dataset": "arkitscenes",
+ "question_id": 1238,
+ "question_type": "object_rel_direction_easy",
+ "question": "If I am standing by the sofa and facing the stove, is the tv to the left or the right of the stove?",
+ "options": [
+  "A. left",
+  "B. right"
+ ],
+ "full_prompt": null,
+ "answer_expected": "B",
+ "answer_given": "A",
+ "answer_raw": "A",
+ "score": 0.0
+}

results/symbolic/41069025/167.json

@@ -0,0 +1,16 @@
+{
+ "model": "symbolic",
+ "condition": "symbolic",
+ "number_of_frames": null,
+ "scene": "41069025",
+ "dataset": "arkitscenes",
+ "question_id": 167,
+ "question_type": "object_size_estimation",
+ "question": "What is the length of the longest dimension (length, width, or height) of the stove, measured in centimeters?",
+ "options": null,
+ "full_prompt": null,
+ "answer_expected": "62",
+ "answer_given": "24.0",
+ "answer_raw": "24.0",
+ "score": 0.0
+}

results/symbolic/41069025/168.json

@@ -0,0 +1,16 @@
+{
+ "model": "symbolic",
+ "condition": "symbolic",
+ "number_of_frames": null,
+ "scene": "41069025",
+ "dataset": "arkitscenes",
+ "question_id": 168,
+ "question_type": "object_size_estimation",
+ "question": "What is the length of the longest dimension (length, width, or height) of the sofa, measured in centimeters?",
+ "options": null,
+ "full_prompt": null,
+ "answer_expected": "173",
+ "answer_given": "11.0",
+ "answer_raw": "11.0",
+ "score": 0.0
+}

results/symbolic/41069025/169.json

@@ -0,0 +1,16 @@
+{
+ "model": "symbolic",
+ "condition": "symbolic",
+ "number_of_frames": null,
+ "scene": "41069025",
+ "dataset": "arkitscenes",
+ "question_id": 169,
+ "question_type": "object_size_estimation",
+ "question": "What is the length of the longest dimension (length, width, or height) of the tv, measured in centimeters?",
+ "options": null,
+ "full_prompt": null,
+ "answer_expected": "91",
+ "answer_given": "23.0",
+ "answer_raw": "23.0",
+ "score": 0.0
+}

results/symbolic/41069025/530.json

@@ -0,0 +1,16 @@
+{
+ "model": "symbolic",
+ "condition": "symbolic",
+ "number_of_frames": null,
+ "scene": "41069025",
+ "dataset": "arkitscenes",
+ "question_id": 530,
+ "question_type": "room_size_estimation",
+ "question": "What is the size of this room (in square meters)? \nIf multiple rooms are shown, estimate the size of the combined space.",
+ "options": null,
+ "full_prompt": null,
+ "answer_expected": "26.4",
+ "answer_given": "3.5",
+ "answer_raw": "3.5",
+ "score": 0.0
+}

results/symbolic/41069025/680.json

@@ -0,0 +1,16 @@
+{
+ "model": "symbolic",
+ "condition": "symbolic",
+ "number_of_frames": null,
+ "scene": "41069025",
+ "dataset": "arkitscenes",
+ "question_id": 680,
+ "question_type": "object_abs_distance",
+ "question": "Measuring from the closest point of each object, what is the distance between the sofa and the stove (in meters)?",
+ "options": null,
+ "full_prompt": null,
+ "answer_expected": "2.9",
+ "answer_given": "0.93",
+ "answer_raw": "0.93",
+ "score": 0.0
+}

results/symbolic/41069025/681.json

@@ -0,0 +1,16 @@
+{
+ "model": "symbolic",
+ "condition": "symbolic",
+ "number_of_frames": null,
+ "scene": "41069025",
+ "dataset": "arkitscenes",
+ "question_id": 681,
+ "question_type": "object_abs_distance",
+ "question": "Measuring from the closest point of each object, what is the distance between the tv and the stove (in meters)?",
+ "options": null,
+ "full_prompt": null,
+ "answer_expected": "2.9",
+ "answer_given": "1.01",
+ "answer_raw": "1.01",
+ "score": 0.0
+}

results/symbolic/41069025/682.json

@@ -0,0 +1,16 @@
+{
+ "model": "symbolic",
+ "condition": "symbolic",
+ "number_of_frames": null,
+ "scene": "41069025",
+ "dataset": "arkitscenes",
+ "question_id": 682,
+ "question_type": "object_abs_distance",
+ "question": "Measuring from the closest point of each object, what is the distance between the tv and the sofa (in meters)?",
+ "options": null,
+ "full_prompt": null,
+ "answer_expected": "2.1",
+ "answer_given": "1.88",
+ "answer_raw": "1.88",
+ "score": 0.8
+}