Add files using upload-large-folder tool

analysis/letters_reports.py

@@ -19,7 +19,7 @@ from itertools import combinations
 from pathlib import Path
 
 ROOT = Path(__file__).resolve().parent.parent
-DEFAULT_DIRS = {h: Path("/root/results") / h for h in "ABC"}
+DEFAULT_DIRS = {h: Path("/root/results") / h for h in "ABCE"}
 NUMERIC_FIELDS = (
     "input_token_count",
     "output_token_count",
@@ -249,6 +249,14 @@ def summarize_cell(records, code_cache):
                 if records
                 else None
             ),
+            "reasoning_present": (
+                statistics.mean(
+                    bool(r.get("reasoning_text") or r.get("reasoning_raw"))
+                    for r in records
+                )
+                if records
+                else None
+            ),
             "forced": (
                 statistics.mean(bool(r.get("forced")) for r in records)
                 if records
@@ -414,7 +422,7 @@ def main():
         "--protocol",
         action="append",
         default=[],
-        help="repeatable; family 'truncated' includes truncated/<budget>",
+        help="repeatable; select base or thinking protocol families",
     )
     parser.add_argument(
         "--output-dir",
@@ -485,13 +493,6 @@ BUILTINS = {
         ],
         "capabilities": ["tokens", "latency", "reasoning", "frames", "spatial_code"],
     },
-    "D": {
-        "letter": "D",
-        "kind": "vlm",
-        "input_source": "ground_truth",
-        "axes": ["model", "protocol", "format", "selection", "frames"],
-        "capabilities": ["tokens", "latency", "reasoning", "frames", "spatial_code"],
-    },
     "F": {
         "letter": "F",
         "kind": "solver",
@@ -515,8 +516,6 @@ def validate_profile(profile):
     letter = str(p.get("letter", "")).upper()
     if len(letter) != 1 or not letter.isalpha():
         raise ValueError("profile letter must be one alphabetic character")
-    if letter == "E":
-        raise ValueError("E is explicitly excluded")
     p["letter"] = letter
     p.setdefault("kind", "generic")
     p.setdefault("input_source", "unknown")
@@ -528,8 +527,6 @@ def validate_profile(profile):
 
 def load_profile(letter, path=None):
     letter = letter.upper()
-    if letter == "E":
-        raise ValueError("E is explicitly excluded")
     if path:
         p = json.loads(Path(path).read_text())
         p.setdefault("letter", letter)
@@ -623,35 +620,25 @@ def _normalize_record(letter, r, profile):
     if letter == "F":
         parts = list(r.get("_relative_path", ()))
         top = parts[0].lower() if parts else ""
-        if top in ("ground truth", "ground_truth"):
-            r.update(
-                source="ground_truth",
-                depth=None,
-                tracking=None,
-                selection=None,
-                frames=None,
-            )
-            r["format"] = r.get("format") or (parts[1] if len(parts) > 1 else None)
-        else:
-            r["source"] = "perceived"
-            offset = 1
-            if top == "perceived":
-                r["depth"] = r.get("depth") or (parts[1] if len(parts) > 1 else None)
-                offset = 2
-            elif top in ("metric", "relative"):
-                r["depth"] = r.get("depth") or top
-            r["tracking"] = r.get("tracking") or (
-                parts[offset] if len(parts) > offset else None
-            )
-            r["selection"] = r.get("selection") or (
-                parts[offset + 1] if len(parts) > offset + 1 else None
-            )
-            r["frames"] = r.get("frames") or (
-                parts[offset + 2] if len(parts) > offset + 2 else None
-            )
-            candidate = parts[offset + 3] if len(parts) > offset + 3 else None
-            if candidate and not candidate.startswith("scene") and len(candidate) != 10:
-                r["format"] = r.get("format") or candidate
+        r["source"] = "perceived"
+        offset = 1
+        if top == "perceived":
+            r["depth"] = r.get("depth") or (parts[1] if len(parts) > 1 else None)
+            offset = 2
+        elif top in ("metric", "relative"):
+            r["depth"] = r.get("depth") or top
+        r["tracking"] = r.get("tracking") or (
+            parts[offset] if len(parts) > offset else None
+        )
+        r["selection"] = r.get("selection") or (
+            parts[offset + 1] if len(parts) > offset + 1 else None
+        )
+        r["frames"] = r.get("frames") or (
+            parts[offset + 2] if len(parts) > offset + 2 else None
+        )
+        candidate = parts[offset + 3] if len(parts) > offset + 3 else None
+        if candidate and not candidate.startswith("scene") and len(candidate) != 10:
+            r["format"] = r.get("format") or candidate
         r["spatial_code_model"] = r.get("spatial_code_model")
         r["protocol"] = None
     return r
@@ -687,11 +674,7 @@ def _compatible(a, b, profiles):
     f = x if lx == "F" else y if ly == "F" else None
     other = y if lx == "F" else x
     if f:
-        expected = (
-            "ground_truth"
-            if other["harness"] == "D"
-            else "perceived" if other["harness"] in ("B", "C") else None
-        )
+        expected = "perceived" if other["harness"] in ("B", "C") else None
         if expected and f.get("source") != expected:
             return False, [], ["incompatible_F_source"]
     shared = []
@@ -806,9 +789,9 @@ def parse_assignment(value, option):
         raise argparse.ArgumentTypeError(f"{option} must be LETTER=PATH")
     letter, path = value.split("=", 1)
     letter = letter.upper()
-    if len(letter) != 1 or not letter.isalpha() or letter == "E":
+    if len(letter) != 1 or not letter.isalpha() or letter == "D":
         raise argparse.ArgumentTypeError(
-            "letter must be one alphabetic character other than E"
+            "letter must be one alphabetic character other than D"
         )
     return letter, path
 
@@ -835,7 +818,7 @@ def main():
         "--cell",
         action="append",
         default=[],
-        help="repeatable LETTER=PATH; E is excluded",
+        help="repeatable LETTER=PATH; D is removed",
     )
     parser.add_argument(
         "--profile", action="append", default=[], help="optional LETTER=profile.json"
@@ -850,7 +833,7 @@ def main():
         "--protocol",
         action="append",
         default=[],
-        help="repeatable; truncated includes truncated/<budget>",
+        help="repeatable; select base or thinking protocol families",
     )
     parser.add_argument("--output-dir", default=str(ROOT / "reports"))
     parser.add_argument(
@@ -858,11 +841,11 @@ def main():
         default=None,
         help="optional local root used to rebase stale recorded code paths",
     )
-    for h in "abc":
+    for h in "abce":
         parser.add_argument(f"--{h}-results-dir", default=None, help=argparse.SUPPRESS)
     args = parser.parse_args()
     cells = dict(parse_assignment(v, "--cell") for v in args.cell)
-    for h in "abc":
+    for h in "abce":
         value = getattr(args, f"{h}_results_dir")
         if value:
             cells[h.upper()] = value
@@ -1100,8 +1083,6 @@ def generate(
     spatial_codes_dir=None,
 ):
     normalized = {str(k).upper(): Path(v) for k, v in cells.items()}
-    if "E" in normalized:
-        raise ValueError("E is explicitly excluded")
     profile_paths = {str(k).upper(): v for k, v in (profile_paths or {}).items()}
     profiles = {l: load_profile(l, profile_paths.get(l)) for l in normalized}
     pairs = []
@@ -1121,7 +1102,7 @@ def generate(
 
 def main():
     parser = argparse.ArgumentParser(
-        description="Generate arbitrary mixed letter reports; E is excluded."
+        description="Generate arbitrary mixed letter reports; D is removed."
     )
     parser.add_argument("--cell", action="append", required=True)
     parser.add_argument("--profile", action="append", default=[])

data/spatial codes/sam3+depth-anything-3/metric/tracking/uniform/32/compact/42898826.json

@@ -0,0 +1,282 @@
+{
+ "spatial code schema": {
+  "objects": {
+   "<object class>": [
+    {
+     "3D oriented bounding box": {
+      "3D oriented bounding box center coordinates": {
+       "components": [
+        "x",
+        "y",
+        "height above floor"
+       ],
+       "unit": "meters",
+       "description": "center of the 3D oriented bounding box in the shared room coordinate system"
+      },
+      "3D oriented bounding box dimensions": {
+       "components": [
+        "dimension 1",
+        "dimension 2",
+        "dimension 3"
+       ],
+       "unit": "meters",
+       "description": "full lengths of the 3D oriented bounding box along the corresponding orientation unit vectors"
+      },
+      "3D oriented bounding box orientation unit vectors": {
+       "components": [
+        [
+         "x",
+         "y",
+         "height"
+        ],
+        [
+         "x",
+         "y",
+         "height"
+        ],
+        [
+         "x",
+         "y",
+         "height"
+        ]
+       ],
+       "unit": null,
+       "description": "three perpendicular directions corresponding in order to the three 3D oriented bounding box dimensions"
+      }
+     },
+     "first visible time": {
+      "unit": "seconds",
+      "description": "earliest time at which this object instance is visibly observed"
+     }
+    }
+   ]
+  },
+  "room": {
+   "floor boundary polygons": [
+    {
+     "outer boundary coordinates": {
+      "components": [
+       [
+        "x",
+        "y"
+       ],
+       [
+        "x",
+        "y"
+       ]
+      ],
+      "unit": "meters",
+      "description": "ordered vertices enclosing one floor region"
+     },
+     "interior hole boundary coordinates": {
+      "components": [
+       [
+        [
+         "x",
+         "y"
+        ],
+        [
+         "x",
+         "y"
+        ]
+       ]
+      ],
+      "unit": "meters",
+      "description": "ordered boundaries enclosing regions excluded from the floor area"
+     }
+    }
+   ]
+  }
+ },
+ "objects": {
+  "bathtub": [
+   {
+    "3D oriented bounding box": {
+     "3D oriented bounding box center coordinates": [
+      0.46,
+      -0.1,
+      -0.21
+     ],
+     "3D oriented bounding box dimensions": [
+      1.21,
+      0.92,
+      0.5
+     ],
+     "3D oriented bounding box orientation unit vectors": [
+      [
+       0.66,
+       0.75,
+       0.0
+      ],
+      [
+       -0.75,
+       0.66,
+       0.0
+      ],
+      [
+       0.0,
+       0.0,
+       1.0
+      ]
+     ]
+    },
+    "first visible time": 1.0
+   }
+  ],
+  "toilet": [
+   {
+    "3D oriented bounding box": {
+     "3D oriented bounding box center coordinates": [
+      -0.64,
+      -1.26,
+      -0.35
+     ],
+     "3D oriented bounding box dimensions": [
+      0.36,
+      0.34,
+      0.39
+     ],
+     "3D oriented bounding box orientation unit vectors": [
+      [
+       0.76,
+       0.65,
+       0.0
+      ],
+      [
+       -0.65,
+       0.76,
+       0.0
+      ],
+      [
+       0.0,
+       0.0,
+       1.0
+      ]
+     ]
+    },
+    "first visible time": 2.5
+   }
+  ]
+ },
+ "room": {
+  "floor boundary polygons": [
+   {
+    "outer boundary coordinates": [
+     [
+      -2.22,
+      -0.7
+     ],
+     [
+      -1.82,
+      -0.7
+     ],
+     [
+      -1.72,
+      -0.8
+     ],
+     [
+      -1.52,
+      -0.8
+     ],
+     [
+      -1.32,
+      -1.0
+     ],
+     [
+      -1.32,
+      -1.9
+     ],
+     [
+      0.58,
+      -1.9
+     ],
+     [
+      0.58,
+      -1.6
+     ],
+     [
+      0.68,
+      -1.5
+     ],
+     [
+      0.68,
+      -1.3
+     ],
+     [
+      0.78,
+      -1.2
+     ],
+     [
+      0.78,
+      -1.1
+     ],
+     [
+      0.88,
+      -1.0
+     ],
+     [
+      0.88,
+      -0.8
+     ],
+     [
+      0.98,
+      -0.7
+     ],
+     [
+      0.98,
+      -0.5
+     ],
+     [
+      1.08,
+      -0.4
+     ],
+     [
+      1.38,
+      -0.4
+     ],
+     [
+      1.38,
+      1.9
+     ],
+     [
+      -0.62,
+      1.9
+     ],
+     [
+      -0.62,
+      1.7
+     ],
+     [
+      -0.72,
+      1.6
+     ],
+     [
+      -0.72,
+      1.5
+     ],
+     [
+      -0.92,
+      1.3
+     ],
+     [
+      -1.52,
+      1.3
+     ],
+     [
+      -1.62,
+      1.4
+     ],
+     [
+      -1.62,
+      1.6
+     ],
+     [
+      -2.22,
+      1.6
+     ]
+    ],
+    "interior hole boundary coordinates": []
+   }
+  ]
+ }
+}

encoder/.ipynb_checkpoints/geometric-checkpoint.py

@@ -0,0 +1,2333 @@
+"""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 feed build_compact_spatial_code() (see its own docstring for how it handles
+that duality). The explicit schema is no longer built independently: it is a strict derivation
+of the compact schema (build_explicit_spatial_code() calls build_compact_spatial_code() first,
+then reads every explicit value directly off compact's own oriented boxes and floor polygons --
+positions/dimensions/counts/appearance-order are direct subsets, and the distance table is
+computed purely from compact's 3D oriented boxes). This guarantees the two schemas can never
+silently disagree about the same scene's geometry.
+
+Formerly this file called into perceptual.py (as a dynamically-loaded `pl` module) for its own
+geometry helpers -- build_instances, room_gravity, answer_closest_distance, 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).
+"""
+
+from __future__ import annotations
+
+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 = max(1, int(os.environ.get("VSI_KD_WORKERS", "4")))
+# Batch workers set VSI_KD_WORKERS from their per-process CPU budget. Keeping a
+# bounded default avoids pathological all-core thread spawning for small queries.
+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)."""
+    points = np.concatenate([i["pts"] for v in instances.values() for i in v], 0)
+    ext = np.percentile(points, 98, 0) - np.percentile(points, 2, 0)
+    up = int(np.argmin(ext))
+    h, edges = np.histogram(points[:, 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).
+    """
+    points = []
+    for f in range(0, len(depth), fstride):
+        height, width = depth[f].shape
+        ys, xs = np.mgrid[0:height:stride, 0:width: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
+        intrinsics = intr[f]
+        camera_points = np.stack(
+            [
+                (xs - intrinsics[0, 2]) * z / intrinsics[0, 0],
+                (ys - intrinsics[1, 2]) * z / intrinsics[1, 1],
+                z,
+            ],
+            1,
+        )
+        points.append((c2w[f][:3, :3] @ camera_points.T).T + c2w[f][:3, 3])
+    points = np.concatenate(points).astype(np.float64) if points else np.zeros((0, 3))
+    cam = c2w[:, :3, 3].mean(0)
+    if len(points) < 100:  # fallback to axis-extent
+        ext = (
+            np.percentile(points, 98, 0) - np.percentile(points, 2, 0)
+            if len(points)
+            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 = points[rng.choice(len(points), 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 = points @ 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(points, 98, 0) - np.percentile(points, 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):
+    """Read either legacy numeric or current unit-string position formatting."""
+    p = rec.get("position") or {}
+
+    def meters(current, legacy):
+        value = p.get(current, p.get(legacy, 0.0))
+        if isinstance(value, str):
+            if value.endswith(" meters"):
+                value = value[: -len(" meters")]
+            value = value.strip()
+        return float(value)
+
+    return [
+        meters("x coordinate", "floor_x_meters"),
+        meters("y coordinate", "floor_y_meters"),
+        meters("height above floor", "height_above_floor_meters"),
+    ]
+
+
+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 _floor_level(points, gravity, v2=None):
+    """Reference floor estimator shared by every model representation.
+
+    The supplied geometry uses the densest gravity-height slab for its reproducible v1
+    behavior and the robust second percentile for v2.  Keep that switch here, after model
+    adapters have produced world points, so it cannot become model-specific.
+    """
+    heights = np.asarray(points, np.float64) @ np.asarray(gravity, np.float64)
+    heights = heights[np.isfinite(heights)]
+    if not len(heights):
+        return 0.0
+    if v2 is None:
+        v2 = os.environ.get("VSI_CODE_V2") == "1"
+    if v2:
+        return float(np.percentile(heights, 2))
+    counts, edges = np.histogram(heights, bins=80)
+    index = int(counts.argmax())
+    return float(0.5 * (edges[index] + edges[index + 1]))
+
+
+# ==========================================================================================
+# 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):
+    """Mirrors symbolic/solver.py's _find_class exactly (see its docstring): word-TOKEN
+    subset, not raw character substring -- "washer" must not match "dishwasher" just
+    because the characters appear inside it (2026-07-26 fix, found via the citation-
+    fidelity audit)."""
+    name = name.strip().lower()
+    for c in classes:
+        if c == name or c.replace(" ", "") == name.replace(" ", ""):
+            return c
+    name_tokens = set(name.split())
+    for c in classes:
+        class_tokens = set(c.split())
+        if (
+            name_tokens
+            and class_tokens
+            and (name_tokens <= class_tokens or class_tokens <= name_tokens)
+        ):
+            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(point_a, point_b, point_c, 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(point_b - point_a)
+    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(point_c - point_a)
+    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)
+    points = pts if len(pts) <= cap else pts[rs.choice(len(pts), cap, False)]
+    d, _ = cKDTree(points).query(points, k=k + 1, workers=KD_WORKERS)
+    md = d[:, 1:].mean(1)
+    return points[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(instances_a, instances_b, 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.
+    """
+    points_a = _clean(_rep(instances_a), cap=k)
+    points_b = _clean(_rep(instances_b), cap=k)
+    if len(points_a) == 0 or len(points_b) == 0:
+        return float("inf")
+    from scipy.spatial import cKDTree
+
+    if len(points_a) <= len(points_b):
+        d, _ = cKDTree(points_a).query(points_b, k=1, workers=KD_WORKERS)
+    else:
+        d, _ = cKDTree(points_b).query(points_a, k=1, workers=KD_WORKERS)
+    return float(d.min())
+
+
+# ==========================================================================================
+# 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,
+    intrinsics,
+    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).
+    """
+    height, width = 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 != (height, width):
+        mask_f = cv2.resize(
+            mask_f.astype(np.uint8), (width, height), 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 = (
+        intrinsics[0, 0],
+        intrinsics[1, 1],
+        intrinsics[0, 2],
+        intrinsics[1, 2],
+    )
+    camera_points = np.stack(
+        [(xs - cx) * z / fx, (ys - cy) * z / fy, z], axis=1
+    )  # camera coords
+    world_points = (c2w_f[:3, :3] @ camera_points.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 world_points.astype(np.float32), cw
+    return world_points.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)
+    centered = pts - c
+    if len(centered) > 5000:  # PCA on a sample (deterministic)
+        centered = centered[np.random.RandomState(0).choice(len(centered), 5000, False)]
+    if up_axis is not None:
+        floor_axes = [i for i in range(3) if i != up_axis]
+        floor_points = centered[:, floor_axes]
+        try:
+            _, _, floor_rotation = np.linalg.svd(
+                floor_points - floor_points.mean(0), full_matrices=False
+            )
+            proj_floor = (
+                floor_points @ floor_rotation.T
+            )  # (N,2) along the object's own floor-plane axes
+        except np.linalg.LinAlgError:
+            proj_floor = floor_points
+        up_col = centered[:, up_axis : up_axis + 1]  # up axis untouched (yaw-only)
+        proj = np.concatenate([proj_floor, up_col], axis=1)
+    else:
+        try:
+            _, _, rotation = np.linalg.svd(
+                centered - centered.mean(0), full_matrices=False
+            )
+            proj = centered @ rotation.T  # coordinates along principal axes
+        except np.linalg.LinAlgError:
+            proj = centered
+    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,
+                "observations": [
+                    observation
+                    for k in idxs
+                    for observation in insts[k].get("observations", [insts[k]["pts"]])
+                ],
+                "frames": g["frames"],
+                "n": sum(insts[k]["n"] for k in idxs),
+                "nframes": len(g["frames"]),
+                "oids": [oid for k in idxs for oid in insts[k].get("oids", [])],
+            }
+        )  # 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
+                )
+                world_points, 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(world_points):
+                    pts_by_id.setdefault(oid, []).append(world_points)
+                    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,
+                    "observations": list(plist),
+                    "n": len(pts),
+                    "frames": frames_by_id[oid],
+                    # Raw SAM3 masklet id this fragment came from -- carried through every
+                    # later merge/consolidation step (never emitted in the JSON schema) so
+                    # a strong-correspondence overlay can draw SAM3's OWN per-frame
+                    # box/mask for a code instance instead of re-deriving one via 3D
+                    # projection. See encoder.geometric.instance_source_track_ids.
+                    "oids": [int(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 -- legacy array-schema row builder. Merged in from perceptual.py, verbatim.
+# (The room-scale floor area calculation that used to live here is gone -- the explicit
+# schema's floor area is now a direct derivation of the compact schema's floor boundary
+# polygons; see build_explicit_spatial_code() near build_compact_spatial_code().)
+# ==========================================================================================
+
+
+# ---- 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
+
+
+def _reference_object_records(insts, count, u, v, g, floor_level):
+    """Object record formatter used by the original V2 spatial-code builder."""
+    ranked = sorted(insts, key=lambda i: (i["n"], i.get("nframes", 0)), reverse=True)[
+        : max(int(count), 1)
+    ]
+    recs = []
+    for it in ranked:
+        center = np.asarray(it["centroid"], np.float64)
+        points = np.asarray(it["pts"], np.float64)
+        floor_x = points @ u
+        floor_y = points @ v
+        height = points @ g - floor_level
+        recs.append(
+            {
+                "position": {
+                    "floor_x_meters": round(float(center @ u), 2),
+                    "floor_y_meters": round(float(center @ v), 2),
+                    "height_above_floor_meters": round(
+                        float(center @ g - floor_level), 2
+                    ),
+                },
+                "longest_dimension_meters": round(float(it["size"]), 2),
+                "bounding_box": {
+                    "floor_x_meters": [
+                        round(float(np.percentile(floor_x, 2)), 2),
+                        round(float(np.percentile(floor_x, 98)), 2),
+                    ],
+                    "floor_y_meters": [
+                        round(float(np.percentile(floor_y, 2)), 2),
+                        round(float(np.percentile(floor_y, 98)), 2),
+                    ],
+                    "height_above_floor_meters": [
+                        round(float(np.percentile(height, 2)), 2),
+                        round(float(np.percentile(height, 98)), 2),
+                    ],
+                },
+                "dimensions_meters": [round(float(d), 2) for d in it["dims"]],
+            }
+        )
+    return recs
+
+
+def _reference_to_spatial_code(
+    instances, stats, floor_area, up_axis, up_vec, floor_level
+):
+    """Per-instance spatial code shape from the original geometric V2 pipeline."""
+    u, v, g = _floor_basis(up_vec)
+    out = {"objects": {}}
+    for class_name, insts in instances.items():
+        count = int(stats[class_name]["peak"])
+        out["objects"][class_name] = {
+            "count": count,
+            "instances": _reference_object_records(insts, count, u, v, g, floor_level),
+        }
+    out["room"] = {"floor_area_square_meters": floor_area}
+    return out
+
+
+def compute_floor_area(depth, intr, c2w, conf, sky, stride=8, up_vec=None):
+    """Reference floor-area computation from the original geometric pipeline."""
+    points = []
+    for frame_index in range(depth.shape[0]):
+        height, width = depth[frame_index].shape
+        rows, columns = np.mgrid[0:height:stride, 0:width:stride]
+        rows = rows.ravel()
+        columns = columns.ravel()
+        values = depth[frame_index][rows, columns]
+        keep = np.isfinite(values) & (values > 0)
+        if sky is not None:
+            keep &= ~sky[frame_index][rows, columns].astype(bool)
+        if conf is not None:
+            keep &= conf[frame_index][rows, columns] >= np.percentile(
+                conf[frame_index], 40
+            )
+        rows, columns, values = rows[keep], columns[keep], values[keep]
+        if not len(values):
+            continue
+        current = intr[frame_index]
+        camera = np.stack(
+            [
+                (columns - current[0, 2]) * values / current[0, 0],
+                (rows - current[1, 2]) * values / current[1, 1],
+                values,
+            ],
+            1,
+        )
+        world = (c2w[frame_index][:3, :3] @ camera.T).T + c2w[frame_index][:3, 3]
+        points.append(world.astype(np.float32))
+    if not points:
+        return 0.0
+    scene_points = np.concatenate(points, 0)
+    if up_vec is not None:
+        gravity = np.asarray(up_vec, np.float64)
+        gravity /= np.linalg.norm(gravity) + 1e-12
+        axis = (
+            np.array([1.0, 0.0, 0.0])
+            if abs(gravity[0]) < 0.9
+            else np.array([0.0, 1.0, 0.0])
+        )
+        u = np.cross(gravity, axis)
+        u /= np.linalg.norm(u)
+        v = np.cross(gravity, u)
+        floor_points = np.stack([scene_points @ u, scene_points @ v], 1)
+    else:
+        up_axis = int(np.argmin(scene_points.max(0) - scene_points.min(0)))
+        floor_axes = [axis for axis in range(3) if axis != up_axis]
+        floor_points = scene_points[:, floor_axes]
+    lower = np.percentile(floor_points, 0.5, 0)
+    upper = np.percentile(floor_points, 99.5, 0)
+    floor_points = floor_points[
+        (floor_points[:, 0] >= lower[0])
+        & (floor_points[:, 0] <= upper[0])
+        & (floor_points[:, 1] >= lower[1])
+        & (floor_points[:, 1] <= upper[1])
+    ]
+    if len(floor_points) < 10:
+        return 0.0
+    try:
+        import alphashape
+
+        sample = np.random.RandomState(0).choice(
+            len(floor_points), min(10000, len(floor_points))
+        )
+        return round(
+            float(alphashape.alphashape(floor_points[sample], alpha=2).area), 1
+        )
+    except Exception:
+        from scipy import ndimage
+
+        resolution = 0.10
+        rows = ((floor_points[:, 0] - floor_points[:, 0].min()) / resolution).astype(
+            int
+        )
+        columns = ((floor_points[:, 1] - floor_points[:, 1].min()) / resolution).astype(
+            int
+        )
+        grid = np.zeros((rows.max() + 3, columns.max() + 3), np.uint8)
+        grid[rows + 1, columns + 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()) * resolution * resolution, 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):
+    """(Unemitted by explicit format; compact format derives its boundary separately. 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):
+        height, width = depth[f].shape
+        ys, xs = np.mgrid[0:height:stride, 0:width: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
+        intrinsics = intr[f]
+        camera_points = np.stack(
+            [
+                (xs - intrinsics[0, 2]) * z / intrinsics[0, 0],
+                (ys - intrinsics[1, 2]) * z / intrinsics[1, 1],
+                z,
+            ],
+            1,
+        )
+        pts.append(
+            ((c2w[f][:3, :3] @ camera_points.T).T + c2w[f][:3, 3]).astype(np.float32)
+        )
+    if not pts:
+        return []
+    world_points = np.concatenate(pts, 0)
+    points = np.stack(
+        [world_points @ bu, world_points @ bv], 1
+    )  # gravity-plane projection (same bu,bv as objects/area)
+    lo = np.percentile(points, 0.5, 0)
+    hi = np.percentile(points, 99.5, 0)
+    points = points[
+        (points[:, 0] >= lo[0])
+        & (points[:, 0] <= hi[0])
+        & (points[:, 1] >= lo[1])
+        & (points[:, 1] <= hi[1])
+    ]
+    if len(points) < 10:
+        return []
+    res = 0.10
+    x0, y0 = points[:, 0].min(), points[:, 1].min()
+    ai = ((points[:, 0] - x0) / res).astype(int)
+    bi = ((points[:, 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 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(points, cameras=None, iters=300, thr=0.05):
+    """Robust UP vector = normal of the RANSAC floor plane, oriented toward the cameras."""
+    points = np.asarray(points, np.float64)
+    points = points[np.isfinite(points).all(1)]
+    if len(points) > 100000:
+        points = points[np.random.RandomState(0).choice(len(points), 100000, False)]
+    cam = (
+        np.asarray(cameras, np.float64).mean(0)
+        if cameras is not None and len(cameras)
+        else None
+    )
+    if len(points) < 100:
+        ext = (
+            np.percentile(points, 98, 0) - np.percentile(points, 2, 0)
+            if len(points)
+            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 = points[rng.choice(len(points), 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 = points @ 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(points, 98, 0) - np.percentile(points, 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)
+    centered = pts - c
+    if len(centered) > 5000:
+        centered = centered[np.random.RandomState(0).choice(len(centered), 5000, False)]
+    if up_axis is not None:
+        floor_axes = [i for i in range(3) if i != up_axis]
+        floor_points = centered[:, floor_axes]
+        try:
+            _, _, floor_rotation = np.linalg.svd(
+                floor_points - floor_points.mean(0), full_matrices=False
+            )
+            proj_floor = floor_points @ floor_rotation.T
+        except np.linalg.LinAlgError:
+            proj_floor = floor_points
+        proj = np.concatenate([proj_floor, centered[:, up_axis : up_axis + 1]], 1)
+    else:
+        try:
+            _, _, rotation = np.linalg.svd(
+                centered - centered.mean(0), full_matrices=False
+            )
+            proj = centered @ rotation.T
+        except np.linalg.LinAlgError:
+            proj = centered
+    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,
+                "observations": [
+                    observation
+                    for k in ii
+                    for observation in insts[k].get("observations", [insts[k]["pts"]])
+                ],
+                "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
+    points = (
+        pts
+        if len(pts) <= cap
+        else pts[np.random.RandomState(0).choice(len(pts), cap, False)]
+    )
+    d, _ = cKDTree(points).query(points, k=k + 1, workers=KD_WORKERS)
+    md = d[:, 1:].mean(1)
+    return points[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"]
+
+
+# ==========================================================================================
+# COMPACT SPATIAL CODE -- reusable geometry and time primitives, with no derived answers.
+# ==========================================================================================
+
+
+COMPACT_SPATIAL_CODE_SCHEMA = {
+    "objects": {
+        "<object class>": [
+            {
+                "3D oriented bounding box": {
+                    "3D oriented bounding box center coordinates": {
+                        "components": ["x", "y", "height above floor"],
+                        "unit": "meters",
+                        "description": (
+                            "center of the 3D oriented bounding box in the shared room "
+                            "coordinate system"
+                        ),
+                    },
+                    "3D oriented bounding box dimensions": {
+                        "components": ["dimension 1", "dimension 2", "dimension 3"],
+                        "unit": "meters",
+                        "description": (
+                            "full lengths of the 3D oriented bounding box along the "
+                            "corresponding orientation unit vectors"
+                        ),
+                    },
+                    "3D oriented bounding box orientation unit vectors": {
+                        "components": [
+                            ["x", "y", "height"],
+                            ["x", "y", "height"],
+                            ["x", "y", "height"],
+                        ],
+                        "unit": None,
+                        "description": (
+                            "three perpendicular directions corresponding in order to the "
+                            "three 3D oriented bounding box dimensions"
+                        ),
+                    },
+                },
+                "first visible time": {
+                    "unit": "seconds",
+                    "description": (
+                        "earliest time at which this object instance is visibly observed"
+                    ),
+                },
+            }
+        ]
+    },
+    "room": {
+        "floor boundary polygons": [
+            {
+                "outer boundary coordinates": {
+                    "components": [["x", "y"], ["x", "y"]],
+                    "unit": "meters",
+                    "description": "ordered vertices enclosing one floor region",
+                },
+                "interior hole boundary coordinates": {
+                    "components": [[["x", "y"], ["x", "y"]]],
+                    "unit": "meters",
+                    "description": (
+                        "ordered boundaries enclosing regions excluded from the floor area"
+                    ),
+                },
+            }
+        ]
+    },
+}
+
+
+def _rounded_list(values):
+    """Round one numeric vector to stable JSON values without negative zero."""
+    return [0.0 if (value := round(float(x), 2)) == 0 else value for x in values]
+
+
+def _weighted_quantile(values, weights, quantile):
+    """Return one deterministic weighted quantile for observation consensus."""
+    values = np.asarray(values, np.float64)
+    weights = np.asarray(weights, np.float64)
+    order = np.argsort(values)
+    values, weights = values[order], weights[order]
+    cumulative = np.cumsum(weights) - 0.5 * weights
+    cumulative /= weights.sum()
+    return float(np.interp(quantile, cumulative, values))
+
+
+def _compact_oriented_box(instance, u, v, g, floor_level):
+    """Fit one floor-aligned OBB from the same per-instance math as the reference code."""
+    center = np.asarray(instance["centroid"], np.float64)
+    points = np.asarray(instance["best_pts"], np.float64)
+    room_points = np.stack([points @ u, points @ v, points @ g - floor_level], axis=1)
+    centered = room_points[:, :2] - np.median(room_points[:, :2], axis=0)
+    if len(centered) > 5000:
+        centered = centered[np.random.RandomState(0).choice(len(centered), 5000, False)]
+    try:
+        _, _, rotation = np.linalg.svd(
+            centered - centered.mean(axis=0), full_matrices=False
+        )
+    except np.linalg.LinAlgError:
+        rotation = np.eye(2)
+    first = rotation[0]
+    dominant = int(np.argmax(np.abs(first)))
+    if first[dominant] < 0:
+        first = -first
+    second = np.array([-first[1], first[0]])
+    orientation = np.array(
+        [[first[0], first[1], 0.0], [second[0], second[1], 0.0], [0.0, 0.0, 1.0]]
+    )
+    box_center = np.array([center @ u, center @ v, center @ g - floor_level])
+    box_dimensions = np.asarray(instance["dims"], np.float64)
+    return {
+        "3D oriented bounding box center coordinates": _rounded_list(box_center),
+        "3D oriented bounding box dimensions": _rounded_list(box_dimensions),
+        "3D oriented bounding box orientation unit vectors": [
+            _rounded_list(axis) for axis in orientation
+        ],
+    }
+
+
+def _contour_coordinates(contour, x_origin, y_origin, resolution):
+    """Translate one OpenCV grid contour to ordered shared-room coordinates."""
+    return [
+        _rounded_list(
+            [x_origin + (row - 1) * resolution, y_origin + (column - 1) * resolution]
+        )
+        for column, row in contour[:, 0, :]
+    ]
+
+
+def _compact_scene_points(scene):
+    """Return the same dense floor-support sample used by explicit room-area math."""
+    raw_inputs = scene.get("raw_inputs")
+    if raw_inputs is None:
+        return scene["scene_pts"]
+    depth = raw_inputs["depth"]
+    intrinsics = raw_inputs["intr"]
+    poses = raw_inputs["c2w"]
+    confidence = raw_inputs.get("conf")
+    points = []
+    for frame_index in range(len(depth)):
+        height, width = depth[frame_index].shape
+        rows, columns = np.mgrid[0:height:8, 0:width:8]
+        rows, columns = rows.ravel(), columns.ravel()
+        values = depth[frame_index][rows, columns]
+        keep = np.isfinite(values) & (values > 0)
+        if confidence is not None:
+            threshold = np.percentile(confidence[frame_index], 40)
+            keep &= confidence[frame_index][rows, columns] >= threshold
+        rows, columns, values = rows[keep], columns[keep], values[keep]
+        if not len(values):
+            continue
+        current = intrinsics[frame_index]
+        camera = np.stack(
+            [
+                (columns - current[0, 2]) * values / current[0, 0],
+                (rows - current[1, 2]) * values / current[1, 1],
+                values,
+            ],
+            axis=1,
+        )
+        world = poses[frame_index][:3, :3] @ camera.T
+        points.append((world.T + poses[frame_index][:3, 3]).astype(np.float32))
+    return np.concatenate(points, axis=0) if points else scene["scene_pts"]
+
+
+def _compact_floor_boundary_polygons(points, u, v, object_points=None):
+    """Extract the reference room outline as a compact floor-boundary polygon."""
+    from scipy import ndimage
+
+    points = np.asarray(points, np.float64)
+    floor_points = np.stack([points @ u, points @ v], axis=1)
+    floor_points = floor_points[np.isfinite(floor_points).all(axis=1)]
+    if len(floor_points) < 3:
+        return []
+    lower = np.percentile(floor_points, 0.5, axis=0)
+    upper = np.percentile(floor_points, 99.5, axis=0)
+    floor_points = floor_points[
+        (floor_points[:, 0] >= lower[0])
+        & (floor_points[:, 0] <= upper[0])
+        & (floor_points[:, 1] >= lower[1])
+        & (floor_points[:, 1] <= upper[1])
+    ]
+    if len(floor_points) < 3:
+        return []
+    resolution = 0.1
+    x_origin, y_origin = floor_points.min(axis=0)
+    x_max, y_max = floor_points.max(axis=0)
+    row_count = int((x_max - x_origin) / resolution) + 3
+    column_count = int((y_max - y_origin) / resolution) + 3
+    grid = np.zeros((row_count, column_count), np.uint8)
+    rows = ((floor_points[:, 0] - x_origin) / resolution).astype(int)
+    columns = ((floor_points[:, 1] - y_origin) / resolution).astype(int)
+    grid[rows + 1, columns + 1] = 1
+    grid = cv2.morphologyEx(grid, cv2.MORPH_CLOSE, np.ones((7, 7), np.uint8))
+    grid = ndimage.binary_fill_holes(grid).astype(np.uint8)
+    contours, _ = cv2.findContours(grid, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+    if not contours:
+        return []
+    contour = cv2.approxPolyDP(
+        max(contours, key=cv2.contourArea), 0.2 / resolution, True
+    )
+    return [
+        {
+            "outer boundary coordinates": _contour_coordinates(
+                contour, x_origin, y_origin, resolution
+            ),
+            "interior hole boundary coordinates": [],
+        }
+    ]
+
+
+def _compact_duplicate_groups(instances):
+    """Group near-identical co-visible boxes that represent duplicate mask tracks."""
+    count = len(instances)
+    parent = list(range(count))
+
+    def root(index):
+        while parent[index] != index:
+            parent[index] = parent[parent[index]]
+            index = parent[index]
+        return index
+
+    def union(first, second):
+        first, second = root(first), root(second)
+        if first != second:
+            parent[second] = first
+
+    bounds = [_canonical_aabb(_canonical_clean(instance)) for instance in instances]
+    for first in range(count):
+        lower_a, upper_a = bounds[first]
+        extent_a = np.maximum(upper_a - lower_a, 1e-6)
+        volume_a = float(np.prod(extent_a))
+        for second in range(first + 1, count):
+            lower_b, upper_b = bounds[second]
+            extent_b = np.maximum(upper_b - lower_b, 1e-6)
+            volume_b = float(np.prod(extent_b))
+            intersection = np.maximum(
+                np.minimum(upper_a, upper_b) - np.maximum(lower_a, lower_b), 0.0
+            )
+            overlap = float(np.prod(intersection)) / min(volume_a, volume_b)
+            if overlap >= 0.8:
+                union(first, second)
+    groups = {}
+    for index in range(count):
+        groups.setdefault(root(index), []).append(index)
+    return list(groups.values())
+
+
+def _combine_compact_instances(instances, members, up_axis):
+    """Combine one duplicate group while retaining all evidence and earliest timing."""
+    selected = [instances[index] for index in members]
+    points = np.concatenate([instance["pts"] for instance in selected], axis=0)
+    best = max((instance["best_pts"] for instance in selected), key=len)
+    confidence = [instance.get("conf") for instance in selected]
+    confidence = (
+        np.concatenate(confidence, axis=0)
+        if all(value is not None for value in confidence)
+        else None
+    )
+    centroid, size, dimensions = _canonical_robust_centroid_extent(points, up_axis)
+    frames = set().union(*(set(instance.get("frames", ())) for instance in selected))
+    return {
+        "centroid": centroid,
+        "size": size,
+        "dims": dimensions,
+        "first_time": min(instance["first_time"] for instance in selected),
+        "pts": points,
+        "conf": confidence,
+        "best_pts": best,
+        "observations": [
+            observation
+            for instance in selected
+            for observation in instance.get("observations", [instance["pts"]])
+        ],
+        "frames": frames,
+        "n": sum(instance.get("n", len(instance["pts"])) for instance in selected),
+        "nframes": len(frames),
+        "oids": [oid for instance in selected for oid in instance.get("oids", [])],
+    }
+
+
+def _compact_instance_evidence(instance):
+    """Rank one physical-instance hypothesis by persistence and geometric support."""
+    observations = instance.get("observations", [instance["pts"]])
+    observed_points = np.array([len(observation) for observation in observations])
+    return (
+        instance.get("nframes", len(instance.get("frames", ()))),
+        len(observations),
+        float(np.median(observed_points)) if len(observed_points) else 0.0,
+        instance.get("n", len(instance["pts"])),
+    )
+
+
+def _consolidate_compact_instances(instances, stats, up_axis):
+    """Suppress duplicate tracks and retain the strongest co-visible instance set."""
+    consolidated = {}
+    for class_name, items in instances.items():
+        combined = [
+            _combine_compact_instances(items, members, up_axis)
+            for members in _compact_duplicate_groups(items)
+        ]
+        peak = int(stats.get(class_name, {}).get("peak", 0))
+        limit = min(len(combined), max(peak, 1))
+        ranked = sorted(combined, key=_compact_instance_evidence, reverse=True)
+        retained = ranked[:limit]
+        for fragment in ranked[limit:]:
+            nearest = min(
+                retained,
+                key=lambda instance: np.linalg.norm(
+                    instance["centroid"] - fragment["centroid"]
+                ),
+            )
+            nearest["first_time"] = min(nearest["first_time"], fragment["first_time"])
+        consolidated[class_name] = retained
+    return consolidated
+
+
+def _compact_instances(scene, up_axis):
+    """Return consolidated physical instances for raw or canonical adapter geometry."""
+    raw_inputs = scene.get("raw_inputs")
+    if raw_inputs is not None:
+        instances, stats = build_instances(
+            raw_inputs["per"],
+            raw_inputs["depth"],
+            raw_inputs["intr"],
+            raw_inputs["c2w"],
+            raw_inputs.get("conf"),
+            raw_inputs["ftimes"],
+            up_axis=up_axis,
+        )
+    else:
+        instances = {}
+        stats = {
+            class_name: dict(values) for class_name, values in scene["stats"].items()
+        }
+        for class_name, items in scene["instances"].items():
+            measured = []
+            for item in items:
+                points = _canonical_clean(item)
+                if not len(points):
+                    points = item["pts"]
+                centroid, size, dimensions = _canonical_robust_centroid_extent(
+                    points, up_axis
+                )
+                record = dict(item)
+                record.update({"centroid": centroid, "size": size, "dims": dimensions})
+                measured.append(record)
+            instances[class_name] = _canonical_merge_by_box_overlap(measured, up_axis)
+    for class_name, items in instances.items():
+        stats.setdefault(class_name, {})
+        stats[class_name]["merged"] = len(items)
+    return instances, stats
+
+
+def instance_source_track_ids(scene):
+    """Return {emitted_class_name: [oids_for_instance_1, oids_for_instance_2, ...]},
+    one ordered list of raw SAM3 masklet ids per FINAL consolidated instance -- in
+    EXACTLY the rank order build_compact_spatial_code() emits instances in (same
+    (n, nframes)-descending sort, same class-name aliasing), so index i here IS the
+    "<class> {i+1}" instance id the strong correspondence overlay stamps. A raw-only
+    lookup: reruns nothing but the consolidation build_compact_spatial_code() already
+    does, just exposing the "oids" field that pipeline discards before emission (the
+    on-disk schema never carries SAM3 ids -- this function is the only place that does).
+    """
+    alias = {"coat hanger": "coat rack"}
+    raw_inputs = scene.get("raw_inputs")
+    if raw_inputs is None:
+        raise ValueError(
+            "instance_source_track_ids needs raw depth/intr/c2w inputs; this geometry "
+            "cache carries only canonical points (no SAM3 track ids to recover)"
+        )
+    up_vec, up_ax = room_gravity(
+        raw_inputs["depth"],
+        raw_inputs["intr"],
+        raw_inputs["c2w"],
+        raw_inputs.get("conf"),
+    )
+    instances, _stats = _compact_instances(scene, up_ax)
+    out = {}
+    for class_name, items in instances.items():
+        emitted_name = alias.get(class_name, class_name)
+        ranked = sorted(
+            items,
+            key=lambda item: (item.get("n", 0), item.get("nframes", 0)),
+            reverse=True,
+        )
+        out.setdefault(emitted_name, []).extend(item.get("oids", []) for item in ranked)
+    return out
+
+
+def build_compact_spatial_code(scene):
+    """Build reusable OBB, visibility-time, and floor-boundary primitives."""
+    alias = {"coat hanger": "coat rack"}
+    raw_inputs = scene.get("raw_inputs")
+    if raw_inputs is not None:
+        up_vec, up_ax = room_gravity(
+            raw_inputs["depth"],
+            raw_inputs["intr"],
+            raw_inputs["c2w"],
+            raw_inputs.get("conf"),
+        )
+        u, v, g = _floor_basis(up_vec)
+    else:
+        up_vec, up_ax = _canonical_room_gravity(
+            scene["scene_pts"], scene.get("cameras")
+        )
+        u, v, g = _canonical_floor_basis(up_vec)
+    instances, stats = _compact_instances(scene, up_ax)
+    all_points = np.concatenate(
+        [item["pts"] for values in instances.values() for item in values], axis=0
+    )
+    floor_level = _floor_level(all_points, g)
+    objects = {}
+    for class_name, items in instances.items():
+        emitted_name = alias.get(class_name, class_name)
+        ranked = sorted(
+            items,
+            key=lambda item: (item.get("n", 0), item.get("nframes", 0)),
+            reverse=True,
+        )
+        count = int(stats.get(class_name, {}).get("peak", 0))
+        ranked = ranked[: max(count, 1)]
+        objects.setdefault(emitted_name, []).extend(
+            {
+                "3D oriented bounding box": _compact_oriented_box(
+                    item, u, v, g, floor_level
+                ),
+                "first visible time": round(float(item["first_time"]), 2),
+            }
+            for item in ranked
+        )
+    code = {
+        "objects": objects,
+        "room": {
+            "floor boundary polygons": _compact_floor_boundary_polygons(
+                _compact_scene_points(scene), u, v
+            )
+        },
+    }
+    return code, instances, stats, up_ax, up_vec, None
+
+
+# ==========================================================================================
+# EXPLICIT SPATIAL CODE -- a strict derivation of the compact schema above. Every object
+# position/dimension/count/appearance-order value is read directly off compact's own oriented
+# boxes and "first visible time" (a direct subset, not independently recomputed); the distance
+# table is the one thing compact never stores, so it is computed here purely from compact's own
+# 3D oriented boxes -- exact surface-to-surface separation via bounded least squares (same
+# convex, closed-form-adjacent optimization symbolic/adapters.py's solver-side derivation
+# already used for compact input, now the ACTUAL on-disk construction for explicit too, so the
+# two schemas can never independently disagree about the same scene's geometry).
+# ==========================================================================================
+
+
+EXPLICIT_SPATIAL_CODE_SCHEMA = {
+    "objects": {
+        "<object class>": {
+            "count": {
+                "unit": None,
+                "description": (
+                    "number of instances of this class in the compact spatial code "
+                    "(that schema's per-class oriented-box list length)"
+                ),
+            },
+            "instances": [
+                {
+                    "position": {
+                        "x coordinate": {
+                            "unit": "meters",
+                            "description": (
+                                "x coordinate of this instance's compact 3D oriented "
+                                "bounding box center"
+                            ),
+                        },
+                        "y coordinate": {
+                            "unit": "meters",
+                            "description": (
+                                "y coordinate of this instance's compact 3D oriented "
+                                "bounding box center"
+                            ),
+                        },
+                        "height above floor": {
+                            "unit": "meters",
+                            "description": (
+                                "height coordinate of this instance's compact 3D oriented "
+                                "bounding box center"
+                            ),
+                        },
+                    },
+                    "longest dimension": {
+                        "unit": "meters",
+                        "description": (
+                            "longest of this instance's compact 3D oriented bounding box "
+                            "dimensions"
+                        ),
+                    },
+                }
+            ],
+        }
+    },
+    "room": {
+        "floor area": {
+            "unit": "square meters",
+            "description": (
+                "shoelace area of the compact spatial code's floor boundary polygons, "
+                "with every interior hole subtracted"
+            ),
+        }
+    },
+    "closest classes distance meters from": {
+        "<object class>": {
+            "<other object class>": {
+                "distance": {
+                    "unit": "meters",
+                    "description": (
+                        "estimated distance in meters between an object of this class "
+                        "and an object of the other class"
+                    ),
+                },
+                "closeness rank": {
+                    "unit": None,
+                    "description": (
+                        "1 = the nearest other class to this one, 2 = second-nearest, "
+                        "and so on; ranked by nearest-instance proximity, so use the "
+                        "rank (not the distance values) to compare which class is "
+                        "closest"
+                    ),
+                },
+            }
+        }
+    },
+    "appearance order": {
+        "unit": None,
+        "description": (
+            "class names ordered by earliest compact 'first visible time' across all of "
+            "that class's instances"
+        ),
+    },
+}
+
+
+def _compact_box_distance(box_a, box_b):
+    """Return the true minimum Euclidean separation of two compact 3D oriented boxes.
+
+    Verbatim derivation from symbolic/adapters.py's oriented_box_distance(): the six box
+    coefficients form one convex bounded least-squares problem, solved exactly by BVLS -- no
+    center, corner, or longest-dimension shortcut, so touching/intersecting boxes return zero.
+
+    Orientation vectors are renormalized to unit length before use, exactly like
+    symbolic/adapters.py's _oriented_box() -- compact's on-disk vectors are rounded to 2
+    decimals, so they are no longer *exactly* unit length, and the matrix below implicitly
+    assumes they are (each column is dimension/2 along that axis). Skipping this step is a
+    real source of error, not just a rounding artifact: it measurably shifted computed
+    distances in testing (up to ~0.01 m on real scenes), and would make explicit silently
+    disagree with what the solver derives from the identical compact box at read time.
+    """
+    from scipy.optimize import lsq_linear
+
+    center_a = np.asarray(
+        box_a["3D oriented bounding box center coordinates"], np.float64
+    )
+    dimensions_a = np.asarray(box_a["3D oriented bounding box dimensions"], np.float64)
+    orientation_a = np.asarray(
+        box_a["3D oriented bounding box orientation unit vectors"], np.float64
+    )
+    orientation_a = orientation_a / np.linalg.norm(orientation_a, axis=1, keepdims=True)
+    center_b = np.asarray(
+        box_b["3D oriented bounding box center coordinates"], np.float64
+    )
+    dimensions_b = np.asarray(box_b["3D oriented bounding box dimensions"], np.float64)
+    orientation_b = np.asarray(
+        box_b["3D oriented bounding box orientation unit vectors"], np.float64
+    )
+    orientation_b = orientation_b / np.linalg.norm(orientation_b, axis=1, keepdims=True)
+    matrix = np.column_stack(
+        [
+            *(dimensions_a[index] * orientation_a[index] / 2 for index in range(3)),
+            *(-dimensions_b[index] * orientation_b[index] / 2 for index in range(3)),
+        ]
+    )
+    result = lsq_linear(
+        matrix,
+        center_b - center_a,
+        bounds=(-1, 1),
+        method="bvls",
+        lsq_solver="exact",
+        tol=1e-12,
+        max_iter=200,
+    )
+    if not result.success:
+        raise RuntimeError(
+            f"oriented-box distance optimization failed: {result.message}"
+        )
+    distance = float(np.linalg.norm(matrix @ result.x + center_a - center_b))
+    return 0.0 if distance < 1e-10 else distance
+
+
+def _compact_class_distance(instances_a, instances_b):
+    """Return the minimum compact oriented-box distance across every cross-class instance pair."""
+    return min(
+        _compact_box_distance(
+            a["3D oriented bounding box"], b["3D oriented bounding box"]
+        )
+        for a in instances_a
+        for b in instances_b
+    )
+
+
+def _primary_instance_distance_floor(instances_a, instances_b):
+    """A sphere-approximation floor on the two classes' PRIMARY (instance[0]) distance:
+    3D center-to-center distance minus each primary box's longest dimension / 2, floored
+    at 0. Mirrors symbolic/solver.py's _primary_instance_distance_estimate exactly (the
+    same correction, applied at ENCODING time so the table value a reader looks up
+    already carries it -- see _corrected_class_distance below)."""
+    box_a = instances_a[0]["3D oriented bounding box"]
+    box_b = instances_b[0]["3D oriented bounding box"]
+    center_a = box_a["3D oriented bounding box center coordinates"]
+    center_b = box_b["3D oriented bounding box center coordinates"]
+    center_distance = (
+        sum((float(a) - float(b)) ** 2 for a, b in zip(center_a, center_b)) ** 0.5
+    )
+    radius_a = max(box_a["3D oriented bounding box dimensions"]) / 2
+    radius_b = max(box_b["3D oriented bounding box dimensions"]) / 2
+    return max(0.0, center_distance - (radius_a + radius_b))
+
+
+def _corrected_class_distance(instances_a, instances_b):
+    """max(min-across-pairs surface distance, primary-instance sphere floor) -- the
+    combination symbolic/solver.py applies at ANSWER time for ABSOLUTE-distance
+    questions. TRIED AND REVERTED as the table's stored value (2026-07-25, see
+    preregistration.md): baking it in re-derived the closeness RANKS from
+    corrected distances, and closest-of-class ranking is exactly where the raw
+    min-across-instances is the semantically correct quantity -- solver relative-
+    distance accuracy fell 59.2 -> 47.5 on real perceived codes and the VLM pilot
+    dropped in the same direction.
+
+    REINSTATED (2026-07-25, second amendment, see preregistration.md) as the
+    table's PRINTED distance only, with the fix the first attempt lacked: closeness
+    ranks stay computed from the raw min-across-instances distance (the correct
+    closest-of-class quantity), and the solver's relative-distance answer reads the
+    rank field rather than comparing printed values. The printed value IS the solver's
+    absolute-distance answer, making abs-distance a pure lookup for any reader."""
+    return max(
+        _compact_class_distance(instances_a, instances_b),
+        _primary_instance_distance_floor(instances_a, instances_b),
+    )
+
+
+def _compact_polygon_area(coordinates):
+    """Return the unsigned shoelace area of one ordered compact floor-boundary polygon."""
+    if len(coordinates) < 3:
+        return 0.0
+    return abs(
+        sum(
+            coordinates[index][0] * coordinates[(index + 1) % len(coordinates)][1]
+            - coordinates[(index + 1) % len(coordinates)][0] * coordinates[index][1]
+            for index in range(len(coordinates))
+        )
+        / 2
+    )
+
+
+def _compact_room_floor_area(polygons):
+    """Sum outer areas and subtract every interior hole across compact's floor regions."""
+    area = 0.0
+    for polygon in polygons:
+        area += _compact_polygon_area(polygon.get("outer boundary coordinates", []))
+        area -= sum(
+            _compact_polygon_area(hole)
+            for hole in polygon.get("interior hole boundary coordinates", [])
+        )
+    return max(0.0, area)
+
+
+def _compact_box_axis_bounds(box):
+    center = np.asarray(box["3D oriented bounding box center coordinates"], np.float64)
+    dimensions = np.asarray(box["3D oriented bounding box dimensions"], np.float64)
+    orientation = np.asarray(
+        box["3D oriented bounding box orientation unit vectors"], np.float64
+    )
+    orientation = orientation / np.linalg.norm(orientation, axis=1, keepdims=True)
+    offsets = []
+    for sx in (-1.0, 1.0):
+        for sy in (-1.0, 1.0):
+            for sz in (-1.0, 1.0):
+                offsets.append(
+                    sx * dimensions[0] * orientation[0] / 2
+                    + sy * dimensions[1] * orientation[1] / 2
+                    + sz * dimensions[2] * orientation[2] / 2
+                )
+    corners = center + np.asarray(offsets)
+    return [
+        [
+            round(float(corners[:, axis].min()), 2),
+            round(float(corners[:, axis].max()), 2),
+        ]
+        for axis in range(3)
+    ]
+
+
+def _compact_outline_for_v2(compact_code):
+    polygons = compact_code.get("room", {}).get("floor boundary polygons", [])
+    if not polygons:
+        return []
+    outline = []
+    for x, y in polygons[0].get("outer boundary coordinates", []):
+        outline.append(
+            {"floor_x_meters": round(float(x), 1), "floor_y_meters": round(float(y), 1)}
+        )
+    return outline
+
+
+def _explicit_from_compact(compact_code):
+    """Derive a V2 explicit spatial code from an already-built compact spatial code.
+
+    This is used for canonical adapter geometry and ground truth. It mirrors the V2 envelope
+    used by the raw encoder path: no embedded legend, numeric closest-class table, V2 room
+    keys, and compact "appearance order".
+    """
+    compact_objects = compact_code["objects"]
+
+    objects = {}
+    first_visible = {}
+    for class_name, items in compact_objects.items():
+        rendered = []
+        for item in items:
+            box = item["3D oriented bounding box"]
+            center = box["3D oriented bounding box center coordinates"]
+            dimensions = box["3D oriented bounding box dimensions"]
+            bounds = _compact_box_axis_bounds(box)
+            rendered.append(
+                {
+                    "position": {
+                        "floor_x_meters": round(float(center[0]), 2),
+                        "floor_y_meters": round(float(center[1]), 2),
+                        "height_above_floor_meters": round(float(center[2]), 2),
+                    },
+                    "longest_dimension_meters": round(float(max(dimensions)), 2),
+                    "bounding_box": {
+                        "floor_x_meters": bounds[0],
+                        "floor_y_meters": bounds[1],
+                        "height_above_floor_meters": bounds[2],
+                    },
+                    "dimensions_meters": [
+                        round(float(value), 2) for value in dimensions
+                    ],
+                }
+            )
+            time = item["first visible time"]
+            if time is not None:
+                first_visible[class_name] = min(
+                    first_visible.get(class_name, float("inf")), float(time)
+                )
+        objects[class_name] = {"count": len(items), "instances": rendered}
+
+    classes = [name for name, items in compact_objects.items() if items]
+    raw_distances = {class_name: {} for class_name in classes}
+    printed_distances = {class_name: {} for class_name in classes}
+    for index, class_name in enumerate(classes):
+        for other in classes[index + 1 :]:
+            raw = _compact_class_distance(
+                compact_objects[class_name], compact_objects[other]
+            )
+            printed = _corrected_class_distance(
+                compact_objects[class_name], compact_objects[other]
+            )
+            raw_distances[class_name][other] = raw
+            raw_distances[other][class_name] = raw
+            printed_distances[class_name][other] = printed
+            printed_distances[other][class_name] = printed
+    closest = {}
+    for class_name, distances in raw_distances.items():
+        ranked = sorted(distances.items(), key=lambda item: (item[1], item[0]))
+        closest[class_name] = {
+            other: {
+                "closeness_rank": rank + 1,
+                "distance_meters": round(printed_distances[class_name][other], 2),
+            }
+            for rank, (other, _raw) in enumerate(ranked)
+        }
+
+    floor_area = round(
+        _compact_room_floor_area(
+            compact_code["room"].get("floor boundary polygons", [])
+        ),
+        1,
+    )
+
+    return {
+        "objects": objects,
+        "room": {
+            "outline": _compact_outline_for_v2(compact_code),
+            "floor_area_square_meters": floor_area,
+        },
+        "closest_classes_from": closest,
+        "appearance order": sorted(
+            classes, key=lambda name: first_visible.get(name, float("inf"))
+        ),
+    }, floor_area
+
+
+def _build_reference_v2_spatial_code(raw_inputs):
+    """Build the raw encoder spatial code exactly like the reference V2 branch."""
+    alias = {"coat hanger": "coat rack"}
+    per = {
+        alias.get(class_name, class_name): frames
+        for class_name, frames in raw_inputs["per"].items()
+    }
+    depth = raw_inputs["depth"]
+    intr = raw_inputs["intr"]
+    c2w = raw_inputs["c2w"]
+    conf = raw_inputs.get("conf")
+    frame_times = raw_inputs["ftimes"]
+
+    up_vec, up_axis = room_gravity(depth, intr, c2w, conf)
+    instances, stats = build_instances(
+        per, depth, intr, c2w, conf, frame_times, up_axis=up_axis
+    )
+    u, v, g = _floor_basis(up_vec)
+    all_points = np.concatenate(
+        [item["pts"] for values in instances.values() for item in values], axis=0
+    )
+    floor_level = float(np.percentile(all_points @ g, 2))
+    floor_area = compute_floor_area(depth, intr, c2w, conf, None, up_vec=up_vec)
+    code = _reference_to_spatial_code(
+        instances, stats, floor_area, up_axis, up_vec, floor_level
+    )
+    classes = list(instances.keys())
+    class_first = {
+        class_name: min(item["first_time"] for item in values)
+        for class_name, values in instances.items()
+    }
+
+    for class_name in classes:
+        ranked = sorted(
+            instances[class_name],
+            key=lambda item: (item["n"], item.get("nframes", 0)),
+            reverse=True,
+        )
+        for record, item in zip(code["objects"][class_name]["instances"], ranked):
+            record["seen_in_video_frames"] = int(
+                item.get("nframes", len(item.get("frames", ())))
+            )
+
+    closest = {}
+    for class_name in classes:
+        distances = sorted(
+            (
+                round(
+                    answer_closest_distance(instances[class_name], instances[other]), 2
+                ),
+                other,
+            )
+            for other in classes
+            if other != class_name
+        )
+        closest[class_name] = {
+            other: {"closeness_rank": rank + 1, "distance_meters": distance}
+            for rank, (distance, other) in enumerate(distances)
+        }
+    code["closest_classes_from"] = closest
+
+    waypoints = []
+    next_time = 0.0
+    for index, time_seconds in enumerate(np.asarray(frame_times, np.float64)):
+        if time_seconds + 1e-9 < next_time:
+            continue
+        next_time = float(time_seconds) + 5.0
+        position = c2w[index][:3, 3]
+        forward = c2w[index][:3, 2]
+        waypoints.append(
+            {
+                "time_seconds": round(float(time_seconds), 1),
+                "floor_x_meters": round(float(position @ u), 2),
+                "floor_y_meters": round(float(position @ v), 2),
+                "heading_degrees": round(
+                    float(np.degrees(np.arctan2(forward @ v, forward @ u)))
+                ),
+            }
+        )
+    code["camera_trajectory"] = {
+        "sample_interval_seconds": 5,
+        "waypoints": waypoints,
+    }
+    code["room"] = {
+        "outline": _room_outline(depth, intr, c2w, conf, u, v),
+        "floor_area_square_meters": code["room"]["floor_area_square_meters"],
+    }
+    code["appearance order"] = [
+        class_name
+        for class_name, _time in sorted(class_first.items(), key=lambda item: item[1])
+    ]
+    return code, instances, stats, up_axis, up_vec, floor_area
+
+
+def build_explicit_spatial_code(scene):
+    """Build the selected explicit code.
+
+    Raw encoder inputs follow the original geometric V2 spatial-code construction. Canonical
+    geometry keeps the compact-derived schema used by ground-truth and non-raw adapters.
+    """
+    raw_inputs = scene.get("raw_inputs")
+    if raw_inputs is not None:
+        return _build_reference_v2_spatial_code(raw_inputs)
+
+    compact_code, instances, stats, up_ax, up_vec, _ = build_compact_spatial_code(scene)
+    code, floor_area = _explicit_from_compact(compact_code)
+    return code, instances, stats, up_ax, up_vec, floor_area
+
+
+# ==========================================================================================
+# MODEL-AGNOSTIC ENTRY POINT
+# ==========================================================================================
+
+
+def build_spatial_code(scene, spatial_code_format="explicit"):
+    """Build one selected spatial-code schema from canonical scene geometry.
+
+    Compact is built directly from raw depth/pose/mask bundles or canonical world-space
+    geometry (build_compact_spatial_code() handles that duality). Explicit is always a
+    derivation of compact (build_explicit_spatial_code() calls build_compact_spatial_code()
+    first), so there is no separate raw/canonical branch for explicit any more.
+    """
+    if spatial_code_format == "compact":
+        return build_compact_spatial_code(scene)
+    if spatial_code_format != "explicit":
+        raise ValueError(f"unknown spatial-code format {spatial_code_format!r}")
+    return build_explicit_spatial_code(scene)

encoder/launch.py

@@ -28,18 +28,20 @@ def _scenes():
         return list(dict.fromkeys(str(json.loads(line)["scene_name"]) for line in f))
 
 
-def _video_cache_files(scene):
-    """Return full-video perception-cache files for one scene."""
+def _video_cache_files(scene, depth, tracking):
+    """Return full-video perception-cache files for the selected axes."""
     return (
-        Path(config.video_da3_cache_file(scene)),
-        Path(config.video_sam3_cache_file(scene)),
+        Path(config.video_da3_cache_file(scene, depth)),
+        Path(config.video_sam3_cache_file(scene, tracking)),
     )
 
 
-def _has_required_caches(scene, depth, input_selection, tracking, frame_count, videos=False):
+def _has_required_caches(
+    scene, depth, input_selection, tracking, frame_count, video=False
+):
     """Return whether all inference caches needed for encoding exist."""
-    if videos:
-        paths = _video_cache_files(scene)
+    if video:
+        paths = _video_cache_files(scene, depth, tracking)
     else:
         paths = (
             config.sam3_cache_file(scene, input_selection, tracking, frame_count),
@@ -48,12 +50,16 @@ def _has_required_caches(scene, depth, input_selection, tracking, frame_count, v
     return all(os.path.isfile(path) for path in paths)
 
 
-def _scenes_with_required_caches(depth, input_selection, tracking, frame_count, videos=False):
+def _scenes_with_required_caches(
+    depth, input_selection, tracking, frame_count, video=False
+):
     """Return manifest scenes having every cache required by this encoder run."""
     return [
         scene
         for scene in _scenes()
-        if _has_required_caches(scene, depth, input_selection, tracking, frame_count, videos)
+        if _has_required_caches(
+            scene, depth, input_selection, tracking, frame_count, video
+        )
     ]
 
 
@@ -97,8 +103,7 @@ def _worker(
     frame_count,
     rebuild,
     cpu_threads,
-    spatial_code_format,
-    videos,
+    video,
 ):
     for variable in ("OMP_NUM_THREADS", "MKL_NUM_THREADS", "OPENBLAS_NUM_THREADS"):
         os.environ[variable] = str(cpu_threads)
@@ -133,8 +138,7 @@ def _worker(
                 tracking,
                 frame_count,
                 rebuild,
-                spatial_code_format,
-                videos,
+                video,
             )
             result_queue.put((scene, "done", f"{how} -> {path}"))
         except EmptySceneError:
@@ -145,11 +149,9 @@ def _worker(
 
 def _launch(args, selected):
     label = (
-        f"{args.depth}/{args.tracking}/{args.input_selection}/"
-        f"{args.spatial_code_format}"
-        if args.videos
-        else f"{args.depth}/{args.tracking}/{args.input_selection}/{args.frames}/"
-        f"{args.spatial_code_format}"
+        f"{args.depth}/{args.tracking}/video"
+        if args.video
+        else f"{args.depth}/{args.tracking}/{args.input_selection}/{args.frames}"
     )
     pending = []
     completed = 0
@@ -160,8 +162,8 @@ def _launch(args, selected):
                 args.depth,
                 args.input_selection,
                 args.tracking,
-                args.frames,
-                args.spatial_code_format,
+                args.frame_count,
+                "explicit",
             )
         )
         if output_exists and not args.rebuild:
@@ -202,11 +204,10 @@ def _launch(args, selected):
                 args.depth,
                 args.input_selection,
                 args.tracking,
-                args.frames,
+                args.frame_count,
                 args.rebuild,
                 cpu_threads,
-                args.spatial_code_format,
-                args.videos,
+                args.video,
             ),
         )
         for _ in range(worker_count)
@@ -248,19 +249,14 @@ def main():
         choices=config.INPUT_SELECTIONS,
         dest="input_selection",
     )
-    parser.add_argument("--frames", type=int, default=config.FRAMES_PER_VIDEO)
-    parser.add_argument("--tracking", choices=config.TRACKING_MODES)
-    parser.add_argument(
-        "--format",
-        choices=config.SPATIAL_CODE_FORMATS,
-        default="explicit",
-        dest="spatial_code_format",
-    )
-    parser.add_argument(
-        "--videos",
+    input_mode = parser.add_mutually_exclusive_group(required=True)
+    input_mode.add_argument("--frames", type=int)
+    input_mode.add_argument(
+        "--video",
         action="store_true",
-        help="use full-video caches from caches/depth-anything-3/metric/uniform/video and caches/sam3/tracking/uniform/video",
+        help="use full-video DA3 and SAM3 caches",
     )
+    parser.add_argument("--tracking", choices=config.TRACKING_MODES)
     parser.add_argument(
         "--workers",
         type=int,
@@ -269,19 +265,19 @@ def main():
     )
     parser.add_argument("--rebuild", action="store_true")
     args = parser.parse_args()
-    if args.videos:
-        args.depth = "metric"
+    if args.depth is None:
+        parser.error("--depth is required")
+    if args.tracking is None:
+        parser.error("--tracking is required")
+    if args.video:
+        if args.input_selection is not None:
+            parser.error("--input cannot be used with --video")
         args.input_selection = config.VIDEO_INPUT_SELECTION
-        args.tracking = "no tracking"
-    else:
-        if args.depth is None:
-            parser.error("--depth is required unless --videos is used")
-        if args.input_selection is None:
-            parser.error("--input is required unless --videos is used")
-        if args.tracking is None:
-            parser.error("--tracking is required unless --videos is used")
-    if args.frames < 1:
+    elif args.input_selection is None:
+        parser.error("--input is required with --frames")
+    if args.frames is not None and args.frames < 1:
         parser.error("--frames must be positive")
+    args.frame_count = args.frames
     if args.workers < 0:
         parser.error("--workers must be positive or zero for automatic")
     selected = (
@@ -291,8 +287,8 @@ def main():
             args.depth,
             args.input_selection,
             args.tracking,
-            args.frames,
-            args.videos,
+            args.frame_count,
+            args.video,
         )
     )
     if not selected:

encoder/render.py

@@ -16,20 +16,14 @@ def build_spatial_code_for(
     tracking,
     frame_count=config.FRAMES_PER_VIDEO,
     rebuild=False,
-    spatial_code_format="explicit",
-    videos=False,
+    video=False,
     da3_path=None,
     sam3_path=None,
 ):
     """Build a spatial code from cached or newly adapted scene geometry."""
-    spatial_code_format = perceive.adapters.validate_spatial_code_format(
-        spatial_code_format
-    )
-    if videos:
-        depth = "metric"
+    if video:
         input_selection = config.VIDEO_INPUT_SELECTION
-        tracking = "no tracking"
-    kwargs = {"videos": videos}
+    kwargs = {"video": video}
     if da3_path is not None:
         kwargs["da3_path"] = da3_path
     if sam3_path is not None:
@@ -37,7 +31,7 @@ def build_spatial_code_for(
     geometry, how = perceive.cache_or_load(
         scene, depth, input_selection, tracking, frame_count, rebuild, **kwargs
     )
-    code, *_ = geometry_math.build_spatial_code(geometry, spatial_code_format)
+    code, *_ = geometry_math.build_spatial_code(geometry, "explicit")
     return code, how
 
 
@@ -48,16 +42,13 @@ def write_spatial_code_for(
     tracking,
     frame_count=config.FRAMES_PER_VIDEO,
     rebuild=False,
-    spatial_code_format="explicit",
-    videos=False,
+    video=False,
     da3_path=None,
     sam3_path=None,
 ):
     """Build and write one scene's spatial-code JSON."""
-    if videos:
-        depth = "metric"
+    if video:
         input_selection = config.VIDEO_INPUT_SELECTION
-        tracking = "no tracking"
     code, how = build_spatial_code_for(
         scene,
         depth,
@@ -65,8 +56,7 @@ def write_spatial_code_for(
         tracking,
         frame_count,
         rebuild,
-        spatial_code_format,
-        videos,
+        video,
         da3_path,
         sam3_path,
     )
@@ -76,7 +66,7 @@ def write_spatial_code_for(
         input_selection,
         tracking,
         frame_count,
-        spatial_code_format,
+        "explicit",
     )
     os.makedirs(os.path.dirname(path), exist_ok=True)
     geometry_math.dump_spatial_code(code, path)

encoder/run.py

@@ -29,6 +29,7 @@ from encoder import config  # noqa: E402
 PROVENANCE_KEY = "source_provenance"
 PROVENANCE_VERSION = 1
 
+
 def _source_record(path):
     """Describe one native cache without copying its payload."""
     source = Path(path)
@@ -77,27 +78,27 @@ def _verify_source_provenance(provenance):
             )
 
 
-def _video_cache_files(scene):
-    """Return the full-video DA3 + SAM3 cache pair."""
+def _video_cache_files(scene, depth, tracking):
+    """Return the full-video DA3 + SAM3 cache pair for the selected axes."""
     return (
-        config.video_da3_cache_file(scene),
-        config.video_sam3_cache_file(scene),
+        config.video_da3_cache_file(scene, depth),
+        config.video_sam3_cache_file(scene, tracking),
     )
 
 
-def _effective_dimensions(depth, input_selection, tracking, videos):
-    """Map full-video perception caches onto their fixed output branch."""
-    if videos:
-        return "metric", config.VIDEO_INPUT_SELECTION, "no tracking"
+def _effective_dimensions(depth, input_selection, tracking, video):
+    """Map video input onto its path branch without changing other axes."""
+    if video:
+        return depth, config.VIDEO_INPUT_SELECTION, tracking
     return depth, input_selection, tracking
 
 
 def _cache_source_paths(
-    scene, depth, input_selection, tracking, frame_count, videos, da3_path, sam3_path
+    scene, depth, input_selection, tracking, frame_count, video, da3_path, sam3_path
 ):
     """Resolve the selected DA3/SAM3 source pair without changing adapter semantics."""
-    if videos:
-        default_da3, default_sam3 = _video_cache_files(scene)
+    if video:
+        default_da3, default_sam3 = _video_cache_files(scene, depth, tracking)
     else:
         default_da3 = config.da3_cache_file(scene, depth, input_selection, frame_count)
         default_sam3 = config.sam3_cache_file(
@@ -107,12 +108,12 @@ def _cache_source_paths(
 
 
 def _combined_cache_file(
-    scene, depth, input_selection, tracking, frame_count, videos, da3_path, sam3_path
+    scene, depth, input_selection, tracking, frame_count, video, da3_path, sam3_path
 ):
     """Return a combined-cache path isolated by source cache format and explicit paths."""
-    if not videos and da3_path is None and sam3_path is None:
+    if da3_path is None and sam3_path is None:
         return config.cache_file(scene, depth, input_selection, tracking, frame_count)
-    label = config.VIDEO_INPUT_SELECTION if videos else "custom"
+    label = config.VIDEO_INPUT_SELECTION if video else "custom"
     if da3_path is not None or sam3_path is not None:
         digest = hashlib.sha256()
         digest.update(str(da3_path or "").encode())
@@ -120,7 +121,7 @@ def _combined_cache_file(
         digest.update(str(sam3_path or "").encode())
         label = f"{label}-{digest.hexdigest()[:12]}"
     directory = config.CACHE_ROOT / config.MODEL / depth / tracking / label
-    if label != config.VIDEO_INPUT_SELECTION:
+    if not video:
         directory = directory / str(frame_count)
     return str(directory / f"{scene}.pkl.gz")
 
@@ -132,16 +133,16 @@ def cache_or_load(
     tracking,
     frame_count=config.FRAMES_PER_VIDEO,
     rebuild=False,
-    videos=False,
+    video=False,
     da3_path=None,
     sam3_path=None,
 ):
     """Return canonical geometry for one specific set of input dimensions."""
     depth, input_selection, tracking = _effective_dimensions(
-        depth, input_selection, tracking, videos
+        depth, input_selection, tracking, video
     )
     path = _combined_cache_file(
-        scene, depth, input_selection, tracking, frame_count, videos, da3_path, sam3_path
+        scene, depth, input_selection, tracking, frame_count, video, da3_path, sam3_path
     )
     if os.path.exists(path) and not rebuild:
         with gzip.open(path, "rb") as stream:
@@ -153,7 +154,7 @@ def cache_or_load(
         # Legacy combined caches are rebuilt to attach exact source provenance.
 
     selected_da3_path, selected_sam3_path = _cache_source_paths(
-        scene, depth, input_selection, tracking, frame_count, videos, da3_path, sam3_path
+        scene, depth, input_selection, tracking, frame_count, video, da3_path, sam3_path
     )
     raw_cache = {
         "scene": scene,
@@ -178,7 +179,7 @@ def cache_or_load(
             "input": input_selection,
             "tracking": tracking,
             "frames": frame_count,
-            "videos": bool(videos),
+            "video": bool(video),
         }
     )
     _verify_source_provenance(geometry[PROVENANCE_KEY])
@@ -197,36 +198,35 @@ def main():
         choices=config.INPUT_SELECTIONS,
         dest="input_selection",
     )
-    parser.add_argument("--frames", type=int, default=config.FRAMES_PER_VIDEO)
+    input_mode = parser.add_mutually_exclusive_group(required=True)
+    input_mode.add_argument("--frames", type=int)
+    input_mode.add_argument(
+        "--video",
+        action="store_true",
+        help="use full-video DA3 and SAM3 caches",
+    )
     parser.add_argument("--tracking", choices=config.TRACKING_MODES)
     parser.add_argument(
-        "--format",
-        choices=config.SPATIAL_CODE_FORMATS,
-        default="explicit",
-        dest="spatial_code_format",
+        "--da3-path", default=None, help="override the selected DA3 cache path"
     )
     parser.add_argument(
-        "--videos",
-        action="store_true",
-        help="use full-video caches from caches/depth-anything-3/metric/uniform/video and caches/sam3/tracking/uniform/video",
+        "--sam3-path", default=None, help="override the selected SAM3 cache path"
     )
-    parser.add_argument("--da3-path", default=None, help="override the selected DA3 cache path")
-    parser.add_argument("--sam3-path", default=None, help="override the selected SAM3 cache path")
     parser.add_argument("--rebuild", action="store_true")
     args = parser.parse_args()
-    if args.videos:
-        args.depth = "metric"
+    if args.depth is None:
+        parser.error("--depth is required")
+    if args.tracking is None:
+        parser.error("--tracking is required")
+    if args.video:
+        if args.input_selection is not None:
+            parser.error("--input cannot be used with --video")
         args.input_selection = config.VIDEO_INPUT_SELECTION
-        args.tracking = "no tracking"
-    else:
-        if args.depth is None:
-            parser.error("--depth is required unless --videos is used")
-        if args.input_selection is None:
-            parser.error("--input is required unless --videos is used")
-        if args.tracking is None:
-            parser.error("--tracking is required unless --videos is used")
-    if args.frames < 1:
+    elif args.input_selection is None:
+        parser.error("--input is required with --frames")
+    if args.frames is not None and args.frames < 1:
         parser.error("--frames must be positive")
+    frame_count = args.frames
     from encoder import render
 
     import cv2
@@ -246,16 +246,16 @@ def main():
         args.depth,
         args.input_selection,
         args.tracking,
-        args.frames,
+        frame_count,
         args.rebuild,
-        args.videos,
+        args.video,
         args.da3_path,
         args.sam3_path,
     )
     count = sum(len(values) for values in geometry["instances"].values())
     print(
         f"[{args.scene}] depth={args.depth} input={args.input_selection} "
-        f"frames={args.frames} tracking={args.tracking} videos={args.videos} cache={how} "
+        f"frames={args.frames} tracking={args.tracking} video={args.video} cache={how} "
         f"classes={len(geometry['instances'])} instances={count}"
     )
     _, _, path = render.write_spatial_code_for(
@@ -263,10 +263,9 @@ def main():
         args.depth,
         args.input_selection,
         args.tracking,
-        args.frames,
+        frame_count,
         False,
-        args.spatial_code_format,
-        args.videos,
+        args.video,
         args.da3_path,
         args.sam3_path,
     )

harness/A/launch.py

@@ -33,6 +33,7 @@ from harness.A import (  # noqa: E402
     MAX_NEW_TOKENS,
 )
 from harness.A import models as vlm_models  # noqa: E402
+from harness.A import resolve_protocol_budgets  # noqa: E402
 from inference.launch import available_cpu_count, visible_gpus  # noqa: E402
 
 
@@ -58,14 +59,13 @@ def _worker(
     model,
     frame_selection,
     frame_count,
+    video,
     results_dir,
     gpu,
     cpu_threads,
     extended,
     reasoning_budget,
     force_budget,
-    truncated_budget,
-    thinking,
 ):
     if gpu is not None:
         os.environ["CUDA_VISIBLE_DEVICES"] = str(gpu)
@@ -79,8 +79,6 @@ def _worker(
     load_error = None
     try:
         adapter = vlm_models.get_adapter(model)
-        if thinking and not adapter.set_thinking(True):
-            raise ValueError(f"{model} has no native thinking mode to enable")
         adapter.load_model("cuda:0" if gpu is not None else "cpu")
     except Exception:
         load_error = traceback.format_exc()
@@ -96,14 +94,13 @@ def _worker(
                 model,
                 frame_selection=frame_selection,
                 frame_count=frame_count,
+                video=video,
                 scene=scene,
                 results_dir=results_dir,
                 adapter=adapter,
                 extended=extended,
                 reasoning_budget=reasoning_budget,
                 force_budget=force_budget,
-                raw_budget=truncated_budget,
-                thinking=thinking,
             )
             mean_score = (
                 sum(r["score"] for r in answered) / len(answered) if answered else None
@@ -120,31 +117,23 @@ def launch(
     frame_selection,
     frame_count,
     selected,
+    video=False,
     results_dir=None,
     rebuild=False,
-    extended=False,
+    extended=True,
     reasoning_budget=EXTENDED_MAX_NEW_TOKENS,
     force_budget=MAX_NEW_TOKENS,
-    truncated_budget=None,
-    thinking=False,
 ):
-    """Answer every question for ``selected`` scenes, sharded across every visible GPU.
-
-    ``truncated_budget`` (mutually exclusive with ``extended``) runs the raw-budget
-    arm: base-protocol mechanics (single generation, no forced rescue) at this token
-    cap, under its own "truncated/<budget>" path segment -- see harness.A.run.run."""
-    if extended and truncated_budget is not None:
-        raise ValueError("extended and truncated_budget are mutually exclusive")
-    protocol = (
-        f"{reasoning_budget}"
-        if extended
-        else f"truncated/{truncated_budget}" if truncated_budget is not None else "base"
-    )
-    condition = f"{model}/{protocol}/{frame_selection}/{frame_count}"
+    """Answer every question for ``selected`` scenes, sharded across visible GPUs."""
+    if video:
+        frame_selection = "video"
+        frame_count = None
+    elif frame_count is None or frame_count < 1:
+        raise ValueError("frame_count must be positive in frames mode")
+    mode = "video" if video else f"{frame_selection}/{frame_count}"
+    condition = f"{model}/{mode}"
     run = _load_run_module()
-    root = run.results_dir_for(
-        model, protocol, frame_selection, frame_count, results_dir
-    )
+    root = run.results_dir_for(model, None, frame_selection, frame_count, results_dir)
     pending = []
     completed = 0
     for scene in selected:
@@ -192,14 +181,13 @@ def launch(
                 model,
                 frame_selection,
                 frame_count,
+                video,
                 results_dir,
                 gpu,
                 cpu_threads,
                 extended,
                 reasoning_budget,
                 force_budget,
-                truncated_budget,
-                thinking,
             ),
         )
         for gpu in assignments
@@ -236,36 +224,26 @@ def main():
     parser.add_argument("--model", required=True, choices=vlm_models.available_models())
     parser.add_argument(
         "--frame-selection",
-        default=DEFAULT_FRAME_SELECTION,
+        default=None,
         choices=FRAME_SELECTIONS,
         dest="frame_selection",
     )
-    parser.add_argument("--frames", type=int, default=FRAMES_PER_VIDEO)
+    input_mode = parser.add_mutually_exclusive_group(required=True)
+    input_mode.add_argument("--frames", type=int)
+    input_mode.add_argument("--video", action="store_true")
     parser.add_argument("--results-dir", default=None)
     parser.add_argument("--rebuild", action="store_true")
     parser.add_argument(
-        "--extended",
-        action="store_true",
-        help=(
-            f"use a {EXTENDED_MAX_NEW_TOKENS}-token reasoning budget instead of the fixed "
-            f"{MAX_NEW_TOKENS}-token VSI-Bench protocol, with a short forced second call "
-            "only if the model doesn't conclude within it"
-        ),
-    )
-    parser.add_argument(
-        "--thinking",
-        action="store_true",
-        help="enable the model's native thinking mode where supported; errors on models without the switch",
+        "--reasoning-budget",
+        type=int,
+        default=None,
+        help="thinking mode only (default: 2048)",
     )
-    parser.add_argument("--reasoning-budget", type=int, default=EXTENDED_MAX_NEW_TOKENS)
-    parser.add_argument("--force-budget", type=int, default=MAX_NEW_TOKENS)
     parser.add_argument(
-        "--truncated-budget",
+        "--force-budget",
         type=int,
         default=None,
-        help="raw-budget arm: base-protocol mechanics (single generation, no forced "
-        "rescue) at this token cap, under its own truncated/<budget> path segment "
-        "(mutually exclusive with --extended)",
+        help="thinking mode only (default: 16)",
     )
     args = parser.parse_args()
     if args.scene and args.scenes:
@@ -277,28 +255,26 @@ def main():
         selected = list(dict.fromkeys(selected))
     else:
         selected = [args.scene] if args.scene else scenes()
-    if args.frames < 1:
-        parser.error("--frames must be positive")
-    if args.reasoning_budget < 1:
-        parser.error("--reasoning-budget must be positive")
-    if args.force_budget < 1:
-        parser.error("--force-budget must be positive")
-    if args.truncated_budget is not None and args.truncated_budget < 1:
-        parser.error("--truncated-budget must be positive")
-    if args.extended and args.truncated_budget is not None:
-        parser.error("--extended and --truncated-budget are mutually exclusive")
+    if args.video:
+        if args.frame_selection is not None:
+            parser.error("--frame-selection cannot be used with --video")
+    else:
+        if args.frame_selection is None:
+            parser.error("--frame-selection is required with --frames")
+        if args.frames < 1:
+            parser.error("--frames must be positive")
+    resolve_protocol_budgets(parser, args)
     launch(
         args.model,
         args.frame_selection,
         args.frames,
         selected,
+        video=args.video,
         results_dir=args.results_dir,
         rebuild=args.rebuild,
-        extended=args.extended,
-        thinking=args.thinking,
+        extended=True,
         reasoning_budget=args.reasoning_budget,
         force_budget=args.force_budget,
-        truncated_budget=args.truncated_budget,
     )
 
 

harness/A/sweep.py

@@ -22,6 +22,7 @@ if str(WORKSPACE_ROOT) not in sys.path:
 from harness.A import EXTENDED_MAX_NEW_TOKENS, FRAME_SELECTIONS  # noqa: E402
 from harness.A import launch as harness_launch  # noqa: E402
 from harness.A import models as vlm_models  # noqa: E402
+from harness.A import resolve_protocol_budgets  # noqa: E402
 
 
 def _parse_csv_choice(value, valid, flag):
@@ -72,23 +73,23 @@ def sweep(
     frame_selections,
     frame_counts,
     selected_scenes,
+    video=False,
     results_dir=None,
     rebuild=False,
-    thinking=False,
-    extended=False,
+    extended=True,
     reasoning_budget=EXTENDED_MAX_NEW_TOKENS,
-    truncated_budget=None,
 ):
     """Run every (model, frame_selection, frame_count) triple across all visible GPUs."""
-    plan = build_plan(models, frame_selections, frame_counts)
-    protocol = (
-        f"{reasoning_budget}"
-        if extended
-        else f"truncated/{truncated_budget}" if truncated_budget is not None else "base"
+    plan = (
+        [(model, "video", None) for model in models]
+        if video
+        else build_plan(models, frame_selections, frame_counts)
     )
     for index, (model, frame_selection, frame_count) in enumerate(plan, start=1):
         print(
-            f"=== sweep {index}/{len(plan)}: {model}/{protocol}/{frame_selection}/{frame_count} ===",
+            f"=== sweep {index}/{len(plan)}: {model}/"
+            + ("video" if video else f"{frame_selection}/{frame_count}")
+            + " ===",
             flush=True,
         )
         harness_launch.launch(
@@ -96,12 +97,11 @@ def sweep(
             frame_selection,
             frame_count,
             selected_scenes,
+            video=video,
             results_dir=results_dir,
             rebuild=rebuild,
-            thinking=thinking,
             extended=extended,
             reasoning_budget=reasoning_budget,
-            truncated_budget=truncated_budget,
         )
 
 
@@ -119,57 +119,46 @@ def main():
     )
     parser.add_argument(
         "--frame-selections",
-        required=True,
+        required=False,
         dest="frame_selections",
         help=f"comma-separated selections (or 'all'); one of {FRAME_SELECTIONS}",
     )
-    parser.add_argument(
-        "--frames",
-        required=True,
-        help="comma-separated frame counts, e.g. 16,32,64",
+    input_mode = parser.add_mutually_exclusive_group(required=True)
+    input_mode.add_argument(
+        "--frames", help="comma-separated frame counts, e.g. 16,32,64"
     )
+    input_mode.add_argument("--video", action="store_true")
     parser.add_argument("--results-dir", default=None)
     parser.add_argument("--rebuild", action="store_true")
-    parser.add_argument(
-        "--extended",
-        action="store_true",
-        help="run the whole sweep under the extended protocol instead of the fixed "
-        "16-token VSI-Bench protocol (the same flag harness.A.run/launch take)",
-    )
-    parser.add_argument(
-        "--thinking",
-        action="store_true",
-        help="enable the model's native thinking mode where supported; errors on models without the switch",
-    )
     parser.add_argument(
         "--reasoning-budget",
         type=int,
-        default=EXTENDED_MAX_NEW_TOKENS,
+        default=None,
         dest="reasoning_budget",
-        help="extended-protocol first-pass budget (the calibrated value from "
+        help="thinking-protocol first-pass budget (the calibrated value from "
         "analysis/preregistration.md, e.g. 512)",
     )
-    parser.add_argument(
-        "--truncated-budget",
-        type=int,
-        default=None,
-        help="raw-budget arm: base-protocol mechanics (single generation, no forced "
-        "rescue) at this token cap (mutually exclusive with --extended)",
-    )
     args = parser.parse_args()
+    resolve_protocol_budgets(parser, args)
     if args.scene and args.scenes:
         parser.error("positional scene and --scenes cannot be used together")
-    if args.extended and args.truncated_budget is not None:
-        parser.error("--extended and --truncated-budget are mutually exclusive")
 
     try:
         models = _parse_csv_choice(
             args.models, vlm_models.available_models(), "--models"
         )
-        frame_selections = _parse_csv_choice(
-            args.frame_selections, FRAME_SELECTIONS, "--frame-selections"
-        )
-        frame_counts = _parse_frame_counts(args.frames)
+        if args.video:
+            if args.frame_selections is not None:
+                raise ValueError("--frame-selections cannot be used with --video")
+            frame_selections = ["video"]
+            frame_counts = [None]
+        else:
+            if args.frame_selections is None:
+                raise ValueError("--frame-selections is required with --frames")
+            frame_selections = _parse_csv_choice(
+                args.frame_selections, FRAME_SELECTIONS, "--frame-selections"
+            )
+            frame_counts = _parse_frame_counts(args.frames)
     except ValueError as exc:
         parser.error(str(exc))
 
@@ -186,12 +175,11 @@ def main():
         frame_selections,
         frame_counts,
         selected,
+        video=args.video,
         results_dir=args.results_dir,
         rebuild=args.rebuild,
-        thinking=args.thinking,
-        extended=args.extended,
+        extended=True,
         reasoning_budget=args.reasoning_budget,
-        truncated_budget=args.truncated_budget,
     )
 
 

harness/B/__init__.py

@@ -1,4 +1,4 @@
-"""Harness B: route a scene's on-disk spatial code (explicit or compact) -- as TEXT,
+"""Harness B: route a scene's on-disk explicit spatial code -- as TEXT,
 no video frames -- to all three models, for every VSI-Bench question.
 
 Reuses harness.A's model registry/adapters and fixed generation protocol exactly; only
@@ -24,8 +24,8 @@ from harness.A import (
     WORKSPACE_ROOT,
 )
 
-# Same two on-disk spatial-code schemas encoder/geometric.py can build.
-SPATIAL_CODE_FORMATS = ("explicit", "compact")
+# The harness consumes the encoder's fixed explicit spatial-code output.
+SPATIAL_CODE_FORMATS = ("explicit",)
 DEFAULT_SPATIAL_CODE_FORMAT = "explicit"
 
 # Same vocabulary as inference.SAM3_FRAME_SELECTIONS / harness.A.FRAME_SELECTIONS --

harness/B/launch.py

@@ -25,6 +25,7 @@ if str(WORKSPACE_ROOT) not in sys.path:
 
 from harness.A import EXTENDED_MAX_NEW_TOKENS, MAX_NEW_TOKENS  # noqa: E402
 from harness.A import models as vlm_models  # noqa: E402
+from harness.A import resolve_protocol_budgets  # noqa: E402
 from harness.A.launch import scenes  # noqa: E402
 from harness.B import (  # noqa: E402
     DEFAULT_DEPTH,
@@ -34,7 +35,6 @@ from harness.B import (  # noqa: E402
     DEPTH_VARIANTS,
     FRAMES_PER_VIDEO,
     INPUT_SELECTIONS,
-    SPATIAL_CODE_FORMATS,
     TRACKING_MODES,
 )
 from inference.launch import available_cpu_count, visible_gpus  # noqa: E402
@@ -55,6 +55,7 @@ def _worker(
     spatial_code_format,
     input_selection,
     frame_count,
+    video,
     depth,
     tracking,
     results_dir,
@@ -64,8 +65,6 @@ def _worker(
     reasoning_budget,
     force_budget,
     question_ids,
-    thinking,
-    raw_budget,
 ):
     if gpu is not None:
         os.environ["CUDA_VISIBLE_DEVICES"] = str(gpu)
@@ -76,8 +75,6 @@ def _worker(
     load_error = None
     try:
         adapter = vlm_models.get_adapter(model)
-        if thinking and not adapter.set_thinking(True):
-            raise ValueError(f"{model} has no native thinking mode to enable")
         adapter.load_model("cuda:0" if gpu is not None else "cpu")
     except Exception:
         load_error = traceback.format_exc()
@@ -94,6 +91,7 @@ def _worker(
                 spatial_code_format=spatial_code_format,
                 input_selection=input_selection,
                 frame_count=frame_count,
+                video=video,
                 depth=depth,
                 tracking=tracking,
                 scene=scene,
@@ -103,7 +101,6 @@ def _worker(
                 reasoning_budget=reasoning_budget,
                 force_budget=force_budget,
                 question_ids=question_ids,
-                raw_budget=raw_budget,
             )
             # thinking is applied on the adapter above, not passed to run() -- the
             # worker owns the adapter, run() must not re-toggle it.
@@ -123,6 +120,7 @@ def launch(
     input_selection,
     frame_count,
     selected,
+    video=False,
     depth=DEFAULT_DEPTH,
     tracking=DEFAULT_TRACKING,
     results_dir=None,
@@ -131,31 +129,20 @@ def launch(
     reasoning_budget=EXTENDED_MAX_NEW_TOKENS,
     force_budget=MAX_NEW_TOKENS,
     question_ids=None,
-    thinking=False,
-    raw_budget=None,
 ):
     """Answer every question for ``selected`` scenes, sharded across every visible GPU.
-    ``question_ids``, when given, restricts every scene to that question subset (the
-    calibration pilot's per-category sample) -- the skip check honors the same subset.
-
-    ``raw_budget`` (mutually exclusive with ``extended``) runs the raw-budget arm:
-    base-protocol mechanics at this token cap, under its own truncated/<budget> path
-    segment -- see harness.B.run.run."""
-    if extended and raw_budget is not None:
-        raise ValueError("extended and raw_budget are mutually exclusive")
-    protocol = (
-        f"{reasoning_budget}"
-        if extended
-        else f"truncated/{raw_budget}" if raw_budget is not None else "base"
-    )
-    condition = (
-        f"{model}/{protocol}/{spatial_code_format}/{depth}/{tracking}"
-        f"/{input_selection}/{frame_count}"
-    )
+    ``question_ids``, when given, restricts every scene to that question subset."""
+    if video:
+        input_selection = "video"
+        frame_count = None
+    elif frame_count is None or frame_count < 1:
+        raise ValueError("frame_count must be positive in frames mode")
+    mode = "video" if video else f"{input_selection}/{frame_count}"
+    condition = f"{model}/{spatial_code_format}/{depth}/{tracking}/{mode}"
     run = _load_run_module()
     root = run.results_dir_for(
         model,
-        protocol,
+        None,
         spatial_code_format,
         depth,
         tracking,
@@ -213,6 +200,7 @@ def launch(
                 spatial_code_format,
                 input_selection,
                 frame_count,
+                video,
                 depth,
                 tracking,
                 results_dir,
@@ -222,8 +210,6 @@ def launch(
                 reasoning_budget,
                 force_budget,
                 question_ids,
-                thinking,
-                raw_budget,
             ),
         )
         for gpu in assignments
@@ -258,43 +244,30 @@ def main():
         help="comma-separated scenes (cannot be combined with positional scene)",
     )
     parser.add_argument("--model", required=True, choices=vlm_models.available_models())
-    parser.add_argument(
-        "--spatial-code-format",
-        default=DEFAULT_SPATIAL_CODE_FORMAT,
-        choices=SPATIAL_CODE_FORMATS,
-        dest="spatial_code_format",
-    )
     parser.add_argument(
         "--input-selection",
-        default=DEFAULT_INPUT_SELECTION,
+        default=None,
         choices=INPUT_SELECTIONS,
         dest="input_selection",
     )
-    parser.add_argument("--frames", type=int, default=FRAMES_PER_VIDEO)
+    input_mode = parser.add_mutually_exclusive_group(required=True)
+    input_mode.add_argument("--frames", type=int)
+    input_mode.add_argument("--video", action="store_true")
     parser.add_argument("--depth", default=DEFAULT_DEPTH, choices=DEPTH_VARIANTS)
     parser.add_argument("--tracking", default=DEFAULT_TRACKING, choices=TRACKING_MODES)
     parser.add_argument("--results-dir", default=None)
     parser.add_argument("--rebuild", action="store_true")
     parser.add_argument(
-        "--base-protocol",
-        action="store_true",
-        help="run harness.A's exact fixed 16-token protocol instead of the extended default",
-    )
-    parser.add_argument(
-        "--thinking",
-        action="store_true",
-        help="enable native thinking mode (Qwen only; pair with an explicit "
-        "--results-dir)",
+        "--reasoning-budget",
+        type=int,
+        default=None,
+        help="thinking mode only (default: 2048)",
     )
-    parser.add_argument("--reasoning-budget", type=int, default=EXTENDED_MAX_NEW_TOKENS)
-    parser.add_argument("--force-budget", type=int, default=MAX_NEW_TOKENS)
     parser.add_argument(
-        "--truncated-budget",
+        "--force-budget",
         type=int,
         default=None,
-        help="raw-budget arm: base-protocol mechanics (single generation, no forced "
-        "rescue) at this token cap instead of the hardcoded 16 (mutually exclusive "
-        "with --base-protocol)",
+        help="thinking mode only (default: 16)",
     )
     args = parser.parse_args()
     if args.scene and args.scenes:
@@ -306,31 +279,29 @@ def main():
         selected = list(dict.fromkeys(selected))
     else:
         selected = [args.scene] if args.scene else scenes()
-    if args.frames < 1:
-        parser.error("--frames must be positive")
-    if args.reasoning_budget < 1:
-        parser.error("--reasoning-budget must be positive")
-    if args.force_budget < 1:
-        parser.error("--force-budget must be positive")
-    if args.truncated_budget is not None and args.truncated_budget < 1:
-        parser.error("--truncated-budget must be positive")
-    if args.base_protocol and args.truncated_budget is not None:
-        parser.error("--base-protocol and --truncated-budget are mutually exclusive")
+    if args.video:
+        if args.input_selection is not None:
+            parser.error("--input-selection cannot be used with --video")
+    else:
+        if args.input_selection is None:
+            parser.error("--input-selection is required with --frames")
+        if args.frames < 1:
+            parser.error("--frames must be positive")
+    resolve_protocol_budgets(parser, args)
     launch(
         args.model,
-        args.spatial_code_format,
+        DEFAULT_SPATIAL_CODE_FORMAT,
         args.input_selection,
         args.frames,
         selected,
+        video=args.video,
         depth=args.depth,
         tracking=args.tracking,
         results_dir=args.results_dir,
         rebuild=args.rebuild,
-        extended=not args.base_protocol and args.truncated_budget is None,
-        raw_budget=args.truncated_budget,
+        extended=True,
         reasoning_budget=args.reasoning_budget,
         force_budget=args.force_budget,
-        thinking=args.thinking,
     )
 
 

harness/B/run.py

@@ -21,6 +21,11 @@ if str(WORKSPACE_ROOT) not in sys.path:
 
 from harness.A import EXTENDED_MAX_NEW_TOKENS, MAX_NEW_TOKENS  # noqa: E402
 from harness.A import models as vlm_models  # noqa: E402
+from harness.A import (
+    protocol_for_question,
+    question_group,
+    resolve_protocol_budgets,
+)  # noqa: E402
 from harness.A.run import _scalar_score, load_questions, vsi_official_eval  # noqa: E402
 from harness.B import (  # noqa: E402
     DEFAULT_DEPTH,
@@ -31,7 +36,6 @@ from harness.B import (  # noqa: E402
     FRAMES_PER_VIDEO,
     INPUT_SELECTIONS,
     RESULTS_DIR,
-    SPATIAL_CODE_FORMATS,
     TRACKING_MODES,
 )
 from harness.B import prompts as code_prompts  # noqa: E402
@@ -48,23 +52,17 @@ def results_dir_for(
     frame_count,
     results_dir=None,
 ):
-    """Return the result root isolated by model + protocol + spatial-code-format +
+    """Return the result root isolated by model + protocol + fixed explicit spatial code +
     depth + tracking + input + frames. ``protocol`` is "base" (16-token) or
     "extended-<reasoning budget>" (e.g. "extended-512") -- a real path segment, so
     records from different protocols OR different reasoning budgets can never collide
     on disk."""
     if results_dir is not None:
         return Path(results_dir)
-    return (
-        RESULTS_DIR
-        / model
-        / protocol
-        / spatial_code_format
-        / depth
-        / tracking
-        / input_selection
-        / str(frame_count)
-    )
+    root = RESULTS_DIR / model / spatial_code_format / depth / tracking
+    if input_selection == "video":
+        return root / "video"
+    return root / input_selection / str(frame_count)
 
 
 def _build_record(
@@ -80,9 +78,14 @@ def _build_record(
         "condition": (
             f"{code_info['protocol']}:{code_info['spatial_code_format']}:"
             f"{code_info['depth']}:{code_info['tracking']}:"
-            f"{code_info['input_selection']}:{code_info['frame_count']}"
+            + (
+                "video"
+                if code_info["input_selection"] == "video"
+                else f"{code_info['input_selection']}:{code_info['frame_count']}"
+            )
         ),
         "protocol": code_info["protocol"],
+        "question_group": question_group(row["question_type"]),
         "spatial_code_format": code_info["spatial_code_format"],
         "input_selection": code_info["input_selection"],
         "frame_count": code_info["frame_count"],
@@ -158,6 +161,7 @@ def run(
     spatial_code_format=DEFAULT_SPATIAL_CODE_FORMAT,
     input_selection=DEFAULT_INPUT_SELECTION,
     frame_count=FRAMES_PER_VIDEO,
+    video=False,
     depth=DEFAULT_DEPTH,
     tracking=DEFAULT_TRACKING,
     scene=None,
@@ -172,8 +176,6 @@ def run(
     reasoning_budget=EXTENDED_MAX_NEW_TOKENS,
     force_budget=MAX_NEW_TOKENS,
     question_ids=None,
-    thinking=False,
-    raw_budget=None,
 ):
     """Answer every matching question with one model, given its scene's spatial code as
     text (no video frames). Each question's full record is written to its own JSON file
@@ -187,17 +189,15 @@ def run(
     (plain ``adapter.answer``), so the protocol x representation grid can be measured
     with the identical generation mechanism in every cell.
 
-    ``raw_budget`` (mutually exclusive with ``extended``) runs the raw-budget arm
-    (analysis/preregistration.md): base-protocol mechanics (single generation, no
-    forced rescue) at this token cap instead of the hardcoded 16, under its own
-    "truncated/<budget>" path segment.
-
     Pass a pre-loaded ``adapter`` (as harness.B.launch's persistent per-GPU workers do)
     to reuse one already-loaded model across many calls; the caller then owns unloading
     it. Without one, ``run`` loads and unloads its own adapter, same as harness.A.
     """
-    if extended and raw_budget is not None:
-        raise ValueError("extended and raw_budget are mutually exclusive")
+    if video:
+        input_selection = "video"
+        frame_count = None
+    elif frame_count is None or frame_count < 1:
+        raise ValueError("frame_count must be positive in frames mode")
     rows = load_questions(jsonl_path, scene, scenes, limit)
     if question_ids is not None:
         rows = [row for row in rows if row["id"] in question_ids]
@@ -206,13 +206,12 @@ def run(
     owns_adapter = adapter is None
     if owns_adapter:
         adapter = vlm_models.get_adapter(model)
-        if thinking and not adapter.set_thinking(True):
-            raise ValueError(f"{model} has no native thinking mode to enable")
         adapter.load_model(device)
     code_cache = {}
     results = []
     try:
         for row in rows:
+            protocol = protocol_for_question(row["question_type"])
             scene_id = row["scene_name"]
             if scene_id not in code_cache:
                 code, path = spatial_codes.load_spatial_code(
@@ -238,8 +237,8 @@ def run(
                     reasoning_budget=reasoning_budget,
                     force_budget=force_budget,
                 )
-                if extended
-                else adapter.answer([], prompt, max_new_tokens=raw_budget)
+                if protocol == "thinking"
+                else adapter.answer([], prompt, max_new_tokens=MAX_NEW_TOKENS)
             )
             doc = {
                 "question_type": row["question_type"],
@@ -250,11 +249,7 @@ def run(
             )["vsibench_score"]
             metric_name, score = _scalar_score(row["question_type"], score_doc)
             code_info = {
-                "protocol": (
-                    f"{reasoning_budget}"
-                    if extended
-                    else f"truncated/{raw_budget}" if raw_budget is not None else "base"
-                ),
+                "protocol": protocol,
                 "spatial_code_format": spatial_code_format,
                 "input_selection": input_selection,
                 "frame_count": frame_count,
@@ -298,19 +293,15 @@ def main():
     parser = argparse.ArgumentParser()
     parser.add_argument("--model", required=True, choices=vlm_models.available_models())
     parser.add_argument("--scene", default=None, help="restrict to one VSI-Bench scene")
-    parser.add_argument(
-        "--spatial-code-format",
-        default=DEFAULT_SPATIAL_CODE_FORMAT,
-        choices=SPATIAL_CODE_FORMATS,
-        dest="spatial_code_format",
-    )
     parser.add_argument(
         "--input-selection",
-        default=DEFAULT_INPUT_SELECTION,
+        default=None,
         choices=INPUT_SELECTIONS,
         dest="input_selection",
     )
-    parser.add_argument("--frames", type=int, default=FRAMES_PER_VIDEO)
+    input_mode = parser.add_mutually_exclusive_group(required=True)
+    input_mode.add_argument("--frames", type=int)
+    input_mode.add_argument("--video", action="store_true")
     parser.add_argument("--depth", default=DEFAULT_DEPTH, choices=DEPTH_VARIANTS)
     parser.add_argument("--tracking", default=DEFAULT_TRACKING, choices=TRACKING_MODES)
     parser.add_argument(
@@ -320,8 +311,8 @@ def main():
     parser.add_argument(
         "--results-dir",
         default=None,
-        help="override the default results/B/<model>/<protocol>/<format>/"
-        "<depth>/<tracking>/<input>/<frames> root",
+        help="override the default results/B/<model>/explicit/"
+        "<depth>/<tracking>/{<input>/<frames>|video} root",
     )
     parser.add_argument(
         "--no-write",
@@ -329,44 +320,33 @@ def main():
         help="skip writing per-question JSON files; print/score only",
     )
     parser.add_argument(
-        "--thinking",
-        action="store_true",
-        help="enable the model's native thinking mode (Qwen only; errors on models "
-        "without the switch; pair with an explicit --results-dir)",
-    )
-    parser.add_argument(
-        "--base-protocol",
-        action="store_true",
-        help="run harness.A's exact fixed 16-token protocol (plain answer()) instead of "
-        "the extended 2048-token default",
+        "--reasoning-budget",
+        type=int,
+        default=None,
+        help="thinking questions only (default: 2048)",
     )
-    parser.add_argument("--reasoning-budget", type=int, default=EXTENDED_MAX_NEW_TOKENS)
-    parser.add_argument("--force-budget", type=int, default=MAX_NEW_TOKENS)
     parser.add_argument(
-        "--truncated-budget",
+        "--force-budget",
         type=int,
         default=None,
-        help="raw-budget arm: base-protocol mechanics (single generation, no forced "
-        "rescue) at this token cap instead of the hardcoded 16 (mutually exclusive "
-        "with --base-protocol)",
+        help="thinking questions only (default: 16)",
     )
     args = parser.parse_args()
-    if args.frames < 1:
-        parser.error("--frames must be positive")
-    if args.reasoning_budget < 1:
-        parser.error("--reasoning-budget must be positive")
-    if args.force_budget < 1:
-        parser.error("--force-budget must be positive")
-    if args.truncated_budget is not None and args.truncated_budget < 1:
-        parser.error("--truncated-budget must be positive")
-    if args.base_protocol and args.truncated_budget is not None:
-        parser.error("--base-protocol and --truncated-budget are mutually exclusive")
-
+    if args.video:
+        if args.input_selection is not None:
+            parser.error("--input-selection cannot be used with --video")
+    else:
+        if args.input_selection is None:
+            parser.error("--input-selection is required with --frames")
+        if args.frames < 1:
+            parser.error("--frames must be positive")
+    resolve_protocol_budgets(parser, args)
     results = run(
         args.model,
-        spatial_code_format=args.spatial_code_format,
+        spatial_code_format=DEFAULT_SPATIAL_CODE_FORMAT,
         input_selection=args.input_selection,
         frame_count=args.frames,
+        video=args.video,
         depth=args.depth,
         tracking=args.tracking,
         scene=args.scene,
@@ -374,9 +354,7 @@ def main():
         device=args.device,
         results_dir=args.results_dir,
         write_results=not args.no_write,
-        extended=not args.base_protocol and args.truncated_budget is None,
-        raw_budget=args.truncated_budget,
-        thinking=args.thinking,
+        extended=True,
         reasoning_budget=args.reasoning_budget,
         force_budget=args.force_budget,
     )

harness/B/spatial_codes.py

@@ -1,4 +1,4 @@
-"""Load one scene's on-disk spatial code (explicit or compact) as plain JSON.
+"""Load one scene's on-disk explicit spatial code as plain JSON.
 
 No solver-side adaptation (symbolic.adapters.adapt_spatial_code): the model is shown
 literally the same file encoder/geometric.py wrote to disk -- schema legend included --

harness/B/sweep.py

@@ -1,4 +1,4 @@
-"""Sweep any set of models x spatial-code-formats x depths x trackings x
+"""Sweep any set of models x depths x trackings x
 input-selections x frame-counts.
 
 Every (model, spatial_code_format, depth, tracking, input_selection, frame_count)
@@ -22,14 +22,15 @@ if str(WORKSPACE_ROOT) not in sys.path:
     sys.path.insert(0, str(WORKSPACE_ROOT))
 
 from harness.A import models as vlm_models  # noqa: E402
+from harness.A import resolve_protocol_budgets  # noqa: E402
 from harness.A import EXTENDED_MAX_NEW_TOKENS  # noqa: E402
 from harness.A.sweep import _parse_csv_choice, _parse_frame_counts  # noqa: E402
 from harness.B import (  # noqa: E402
     DEFAULT_DEPTH,
+    DEFAULT_SPATIAL_CODE_FORMAT,
     DEFAULT_TRACKING,
     DEPTH_VARIANTS,
     INPUT_SELECTIONS,
-    SPATIAL_CODE_FORMATS,
     TRACKING_MODES,
 )
 from harness.B import launch as harness_launch  # noqa: E402
@@ -58,24 +59,18 @@ def sweep(
     input_selections,
     frame_counts,
     selected_scenes,
+    video=False,
     depths=(DEFAULT_DEPTH,),
     trackings=(DEFAULT_TRACKING,),
     results_dir=None,
     rebuild=False,
-    thinking=False,
     extended=True,
     reasoning_budget=EXTENDED_MAX_NEW_TOKENS,
-    raw_budget=None,
 ):
     """Run every sweep combination across all visible GPUs."""
     plan = build_plan(
         models, spatial_code_formats, input_selections, frame_counts, depths, trackings
     )
-    protocol = (
-        f"{reasoning_budget}"
-        if extended
-        else f"truncated/{raw_budget}" if raw_budget is not None else "base"
-    )
     for index, (
         model,
         spatial_code_format,
@@ -85,8 +80,10 @@ def sweep(
         frame_count,
     ) in enumerate(plan, start=1):
         print(
-            f"=== sweep {index}/{len(plan)}: {model}/{protocol}/"
-            f"{spatial_code_format}/{depth}/{tracking}/{input_selection}/{frame_count} ===",
+            f"=== sweep {index}/{len(plan)}: {model}/"
+            f"{spatial_code_format}/{depth}/{tracking}/"
+            + ("video" if video else f"{input_selection}/{frame_count}")
+            + " ===",
             flush=True,
         )
         harness_launch.launch(
@@ -95,14 +92,13 @@ def sweep(
             input_selection,
             frame_count,
             selected_scenes,
+            video=video,
             depth=depth,
             tracking=tracking,
             results_dir=results_dir,
             rebuild=rebuild,
-            thinking=thinking,
             extended=extended,
             reasoning_budget=reasoning_budget,
-            raw_budget=raw_budget,
         )
 
 
@@ -118,21 +114,17 @@ def main():
         required=True,
         help=f"comma-separated models (or 'all'); one of {vlm_models.available_models()}",
     )
-    parser.add_argument(
-        "--spatial-code-formats",
-        required=True,
-        dest="spatial_code_formats",
-        help=f"comma-separated formats (or 'all'); one of {SPATIAL_CODE_FORMATS}",
-    )
     parser.add_argument(
         "--input-selections",
-        required=True,
+        required=False,
         dest="input_selections",
         help=f"comma-separated selections (or 'all'); one of {INPUT_SELECTIONS}",
     )
-    parser.add_argument(
-        "--frames", required=True, help="comma-separated frame counts, e.g. 16,32,64"
+    input_mode = parser.add_mutually_exclusive_group(required=True)
+    input_mode.add_argument(
+        "--frames", help="comma-separated frame counts, e.g. 16,32,64"
     )
+    input_mode.add_argument("--video", action="store_true")
     parser.add_argument(
         "--depths",
         default=DEFAULT_DEPTH,
@@ -145,51 +137,38 @@ def main():
     )
     parser.add_argument("--results-dir", default=None)
     parser.add_argument("--rebuild", action="store_true")
-    parser.add_argument(
-        "--base-protocol",
-        action="store_true",
-        help="run the whole sweep under harness.A's exact fixed 16-token protocol "
-        "instead of the extended default",
-    )
-    parser.add_argument(
-        "--thinking",
-        action="store_true",
-        help="enable the model's native thinking mode where supported; errors on models without the switch",
-    )
     parser.add_argument(
         "--reasoning-budget",
         type=int,
-        default=EXTENDED_MAX_NEW_TOKENS,
+        default=None,
         dest="reasoning_budget",
-        help="extended-protocol first-pass budget (the calibrated value from "
+        help="thinking-protocol first-pass budget (the calibrated value from "
         "analysis/preregistration.md, e.g. 512)",
     )
-    parser.add_argument(
-        "--truncated-budget",
-        type=int,
-        default=None,
-        help="raw-budget arm: base-protocol mechanics (single generation, no forced "
-        "rescue) at this token cap (mutually exclusive with --base-protocol)",
-    )
     args = parser.parse_args()
+    resolve_protocol_budgets(parser, args)
     if args.scene and args.scenes:
         parser.error("positional scene and --scenes cannot be used together")
-    if args.base_protocol and args.truncated_budget is not None:
-        parser.error("--base-protocol and --truncated-budget are mutually exclusive")
 
     try:
         models = _parse_csv_choice(
             args.models, vlm_models.available_models(), "--models"
         )
-        spatial_code_formats = _parse_csv_choice(
-            args.spatial_code_formats, SPATIAL_CODE_FORMATS, "--spatial-code-formats"
-        )
-        input_selections = _parse_csv_choice(
-            args.input_selections, INPUT_SELECTIONS, "--input-selections"
-        )
+        spatial_code_formats = (DEFAULT_SPATIAL_CODE_FORMAT,)
+        if args.video:
+            if args.input_selections is not None:
+                raise ValueError("--input-selections cannot be used with --video")
+            input_selections = ["video"]
+            frame_counts = [None]
+        else:
+            if args.input_selections is None:
+                raise ValueError("--input-selections is required with --frames")
+            input_selections = _parse_csv_choice(
+                args.input_selections, INPUT_SELECTIONS, "--input-selections"
+            )
+            frame_counts = _parse_frame_counts(args.frames)
         depths = _parse_csv_choice(args.depths, DEPTH_VARIANTS, "--depths")
         trackings = _parse_csv_choice(args.trackings, TRACKING_MODES, "--trackings")
-        frame_counts = _parse_frame_counts(args.frames)
     except ValueError as exc:
         parser.error(str(exc))
 
@@ -209,14 +188,13 @@ def main():
         input_selections,
         frame_counts,
         selected,
+        video=args.video,
         depths=depths,
         trackings=trackings,
         results_dir=args.results_dir,
         rebuild=args.rebuild,
-        thinking=args.thinking,
-        extended=not args.base_protocol and args.truncated_budget is None,
+        extended=True,
         reasoning_budget=args.reasoning_budget,
-        raw_budget=args.truncated_budget,
     )
 
 

harness/C/__init__.py

@@ -1,5 +1,5 @@
 """Harness C: route BOTH a scene's video frames AND its on-disk spatial code (explicit
-or compact) to all three models, for every VSI-Bench question.
+explicit) to all three models, for every VSI-Bench question.
 
 Frames and spatial code are sourced from the exact same (depth, tracking,
 input_selection, frame_count) config -- the same parameters drive both
@@ -35,7 +35,6 @@ from harness.B import (
     DEFAULT_TRACKING,
     DEPTH_VARIANTS,
     INPUT_SELECTIONS,
-    SPATIAL_CODE_FORMATS,
     TRACKING_MODES,
 )
 

harness/C/launch.py

@@ -25,6 +25,7 @@ if str(WORKSPACE_ROOT) not in sys.path:
 
 from harness.A import EXTENDED_MAX_NEW_TOKENS, MAX_NEW_TOKENS  # noqa: E402
 from harness.A import models as vlm_models  # noqa: E402
+from harness.A import resolve_protocol_budgets  # noqa: E402
 from harness.A.launch import scenes  # noqa: E402
 from harness.B import (  # noqa: E402
     DEFAULT_DEPTH,
@@ -33,7 +34,6 @@ from harness.B import (  # noqa: E402
     DEFAULT_TRACKING,
     DEPTH_VARIANTS,
     INPUT_SELECTIONS,
-    SPATIAL_CODE_FORMATS,
     TRACKING_MODES,
 )
 from harness.C import FRAMES_PER_VIDEO  # noqa: E402
@@ -55,6 +55,7 @@ def _worker(
     spatial_code_format,
     input_selection,
     frame_count,
+    video,
     depth,
     tracking,
     results_dir,
@@ -63,10 +64,6 @@ def _worker(
     extended,
     reasoning_budget,
     force_budget,
-    frame_linked,
-    overlay,
-    raw_budget,
-    thinking,
 ):
     if gpu is not None:
         os.environ["CUDA_VISIBLE_DEVICES"] = str(gpu)
@@ -80,8 +77,6 @@ def _worker(
     load_error = None
     try:
         adapter = vlm_models.get_adapter(model)
-        if thinking and not adapter.set_thinking(True):
-            raise ValueError(f"{model} has no native thinking mode to enable")
         adapter.load_model("cuda:0" if gpu is not None else "cpu")
     except Exception:
         load_error = traceback.format_exc()
@@ -98,6 +93,7 @@ def _worker(
                 spatial_code_format=spatial_code_format,
                 input_selection=input_selection,
                 frame_count=frame_count,
+                video=video,
                 depth=depth,
                 tracking=tracking,
                 scene=scene,
@@ -106,10 +102,6 @@ def _worker(
                 extended=extended,
                 reasoning_budget=reasoning_budget,
                 force_budget=force_budget,
-                frame_linked=frame_linked,
-                overlay=overlay,
-                raw_budget=raw_budget,
-                thinking=thinking,
             )
             mean_score = (
                 sum(r["score"] for r in answered) / len(answered) if answered else None
@@ -127,6 +119,7 @@ def launch(
     input_selection,
     frame_count,
     selected,
+    video=False,
     depth=DEFAULT_DEPTH,
     tracking=DEFAULT_TRACKING,
     results_dir=None,
@@ -134,38 +127,25 @@ def launch(
     extended=True,
     reasoning_budget=EXTENDED_MAX_NEW_TOKENS,
     force_budget=MAX_NEW_TOKENS,
-    frame_linked=False,
-    overlay=False,
-    raw_budget=None,
-    thinking=False,
 ):
-    """Answer every question for ``selected`` scenes, sharded across every visible GPU.
-
-    ``raw_budget`` (mutually exclusive with ``extended``) runs the raw-budget arm:
-    base-protocol mechanics at this token cap, under its own truncated/<budget> path
-    segment -- see harness.C.run.run."""
-    if extended and raw_budget is not None:
-        raise ValueError("extended and raw_budget are mutually exclusive")
-    protocol = (
-        f"{reasoning_budget}"
-        if extended
-        else f"truncated/{raw_budget}" if raw_budget is not None else "base"
-    )
-    condition = (
-        f"{model}/{protocol}/{spatial_code_format}/{depth}/{tracking}"
-        f"/{input_selection}/{frame_count}"
-    )
+    """Answer every question for ``selected`` scenes, sharded across every visible GPU."""
+    if video:
+        input_selection = "video"
+        frame_count = None
+    elif frame_count is None or frame_count < 1:
+        raise ValueError("frame_count must be positive in frames mode")
+    mode = "video" if video else f"{input_selection}/{frame_count}"
+    condition = f"{model}/{spatial_code_format}/{depth}/{tracking}/{mode}"
     run = _load_run_module()
     root = run.results_dir_for(
         model,
-        protocol,
+        None,
         spatial_code_format,
         depth,
         tracking,
         input_selection,
         frame_count,
         results_dir,
-        overlay=overlay,
     )
     pending = []
     completed = 0
@@ -215,6 +195,7 @@ def launch(
                 spatial_code_format,
                 input_selection,
                 frame_count,
+                video,
                 depth,
                 tracking,
                 results_dir,
@@ -223,10 +204,6 @@ def launch(
                 extended,
                 reasoning_budget,
                 force_budget,
-                frame_linked,
-                overlay,
-                raw_budget,
-                thinking,
             ),
         )
         for gpu in assignments
@@ -261,56 +238,30 @@ def main():
         help="comma-separated scenes (cannot be combined with positional scene)",
     )
     parser.add_argument("--model", required=True, choices=vlm_models.available_models())
-    parser.add_argument(
-        "--spatial-code-format",
-        default=DEFAULT_SPATIAL_CODE_FORMAT,
-        choices=SPATIAL_CODE_FORMATS,
-        dest="spatial_code_format",
-    )
     parser.add_argument(
         "--input-selection",
-        default=DEFAULT_INPUT_SELECTION,
+        default=None,
         choices=INPUT_SELECTIONS,
         dest="input_selection",
     )
-    parser.add_argument("--frames", type=int, default=FRAMES_PER_VIDEO)
+    input_mode = parser.add_mutually_exclusive_group(required=True)
+    input_mode.add_argument("--frames", type=int)
+    input_mode.add_argument("--video", action="store_true")
     parser.add_argument("--depth", default=DEFAULT_DEPTH, choices=DEPTH_VARIANTS)
     parser.add_argument("--tracking", default=DEFAULT_TRACKING, choices=TRACKING_MODES)
     parser.add_argument("--results-dir", default=None)
     parser.add_argument("--rebuild", action="store_true")
     parser.add_argument(
-        "--base-protocol",
-        action="store_true",
-        help="run harness.A's exact fixed 16-token protocol instead of the extended default",
-    )
-    parser.add_argument(
-        "--overlay-ids",
-        action="store_true",
-        dest="overlay",
-        help="strong correspondence arm: stamp instance ids onto the frames at each "
-        "instance's projected position and add matching ids to the code",
-    )
-    parser.add_argument(
-        "--frame-linked-code",
-        action="store_true",
-        dest="frame_linked",
-        help="correspondence arm: add per-instance 'first visible in: frame N' pointers "
-        "(pair with an explicit --results-dir)",
-    )
-    parser.add_argument(
-        "--thinking",
-        action="store_true",
-        help="enable the model's native thinking mode where supported; errors on models without the switch",
+        "--reasoning-budget",
+        type=int,
+        default=None,
+        help="thinking mode only (default: 2048)",
     )
-    parser.add_argument("--reasoning-budget", type=int, default=EXTENDED_MAX_NEW_TOKENS)
-    parser.add_argument("--force-budget", type=int, default=MAX_NEW_TOKENS)
     parser.add_argument(
-        "--truncated-budget",
+        "--force-budget",
         type=int,
         default=None,
-        help="raw-budget arm: base-protocol mechanics (single generation, no forced "
-        "rescue) at this token cap instead of the hardcoded 16 (mutually exclusive "
-        "with --base-protocol)",
+        help="thinking mode only (default: 16)",
     )
     args = parser.parse_args()
     if args.scene and args.scenes:
@@ -322,33 +273,29 @@ def main():
         selected = list(dict.fromkeys(selected))
     else:
         selected = [args.scene] if args.scene else scenes()
-    if args.frames < 1:
-        parser.error("--frames must be positive")
-    if args.reasoning_budget < 1:
-        parser.error("--reasoning-budget must be positive")
-    if args.force_budget < 1:
-        parser.error("--force-budget must be positive")
-    if args.truncated_budget is not None and args.truncated_budget < 1:
-        parser.error("--truncated-budget must be positive")
-    if args.base_protocol and args.truncated_budget is not None:
-        parser.error("--base-protocol and --truncated-budget are mutually exclusive")
+    if args.video:
+        if args.input_selection is not None:
+            parser.error("--input-selection cannot be used with --video")
+    else:
+        if args.input_selection is None:
+            parser.error("--input-selection is required with --frames")
+        if args.frames < 1:
+            parser.error("--frames must be positive")
+    resolve_protocol_budgets(parser, args)
     launch(
         args.model,
-        args.spatial_code_format,
+        DEFAULT_SPATIAL_CODE_FORMAT,
         args.input_selection,
         args.frames,
         selected,
+        video=args.video,
         depth=args.depth,
         tracking=args.tracking,
         results_dir=args.results_dir,
         rebuild=args.rebuild,
-        extended=not args.base_protocol and args.truncated_budget is None,
-        raw_budget=args.truncated_budget,
-        thinking=args.thinking,
+        extended=True,
         reasoning_budget=args.reasoning_budget,
         force_budget=args.force_budget,
-        frame_linked=args.frame_linked,
-        overlay=args.overlay,
     )
 
 

harness/C/prompts.py

@@ -5,41 +5,10 @@ from __future__ import annotations
 from harness.B import prompts as code_prompts
 
 FRAMES_NOTE = "These are frames of a video."
-OVERLAY_NOTE = (
-    'Each object instance in the code has an "instance id", and the same id is marked '
-    "in red on the frames at that instance's location."
-)
+VIDEO_NOTE = "This is a video."
 
 
-def frame_linked_code(explicit_code, compact_code, frame_timestamps):
-    """Add a per-instance nearest-frame pointer for the frame-linked correspondence arm."""
-    if not frame_timestamps:
-        raise ValueError("frame_timestamps must be a non-empty sequence")
-    code = dict(explicit_code)
-    objects = {}
-    for class_name, rendered in code.get("objects", {}).items():
-        compact_instances = compact_code.get("objects", {}).get(class_name, [])
-        instances = []
-        for index, instance in enumerate(rendered.get("instances", [])):
-            instance = dict(instance)
-            time = (
-                compact_instances[index].get("first visible time")
-                if index < len(compact_instances)
-                else None
-            )
-            if time is not None:
-                nearest = min(
-                    range(len(frame_timestamps)),
-                    key=lambda i: abs(frame_timestamps[i] - float(time)),
-                )
-                instance["first visible in"] = f"frame {nearest + 1}"
-            instances.append(instance)
-        objects[class_name] = {**rendered, "instances": instances}
-    code["objects"] = objects
-    return code
-
-
-def build_prompt(spatial_code, question_type, question, options=None, overlay=False):
+def build_prompt(spatial_code, question_type, question, options=None, video=False):
     """Return the trailing text block for frames + spatial code.
 
     The actual frame images are prepended separately by harness.A.models. The text uses
@@ -52,7 +21,4 @@ def build_prompt(spatial_code, question_type, question, options=None, overlay=Fa
         options,
         frames_note=True,
     )
-    prefix = FRAMES_NOTE
-    if overlay:
-        prefix += " " + OVERLAY_NOTE
-    return prefix + "\n" + prompt
+    return (VIDEO_NOTE if video else FRAMES_NOTE) + "\n" + prompt

harness/C/run.py

@@ -1,5 +1,5 @@
 """Run one VLM over VSI-Bench questions with BOTH video frames and the scene's on-disk
-spatial code (explicit or compact), sourced from the exact same (depth, tracking,
+explicit spatial code, sourced from the exact same (depth, tracking,
 input_selection, frame_count) config.
 
 Writes one JSON file per question in the identical shape harness.A/B use -- carrying
@@ -23,6 +23,11 @@ import inference as inference_config  # noqa: E402
 from harness.A import EXTENDED_MAX_NEW_TOKENS, MAX_NEW_TOKENS  # noqa: E402
 from harness.A import frames as frame_sampling  # noqa: E402
 from harness.A import models as vlm_models  # noqa: E402
+from harness.A import (
+    protocol_for_question,
+    question_group,
+    resolve_protocol_budgets,
+)  # noqa: E402
 from harness.A.run import _scalar_score, load_questions, vsi_official_eval  # noqa: E402
 from harness.B import (  # noqa: E402
     DEFAULT_DEPTH,
@@ -31,7 +36,6 @@ from harness.B import (  # noqa: E402
     DEFAULT_TRACKING,
     DEPTH_VARIANTS,
     INPUT_SELECTIONS,
-    SPATIAL_CODE_FORMATS,
     TRACKING_MODES,
 )
 from harness.B import spatial_codes  # noqa: E402
@@ -48,25 +52,17 @@ def results_dir_for(
     input_selection,
     frame_count,
     results_dir=None,
-    overlay=False,
 ):
-    """Return the result root isolated by model + protocol + spatial-code-format +
+    """Return the result root isolated by model + protocol + fixed explicit spatial code +
     depth + tracking + input + frames. ``protocol`` is "base" (16-token) or
     "<reasoning budget>" (e.g. "512") -- a real path segment, so records from
     different protocols OR different reasoning budgets can never collide on disk."""
     if results_dir is not None:
         return Path(results_dir)
-    root = RESULTS_DIR / "overlay" if overlay else RESULTS_DIR
-    return (
-        root
-        / model
-        / protocol
-        / spatial_code_format
-        / depth
-        / tracking
-        / input_selection
-        / str(frame_count)
-    )
+    root = RESULTS_DIR / model / spatial_code_format / depth / tracking
+    if input_selection == "video":
+        return root / "video"
+    return root / input_selection / str(frame_count)
 
 
 def _build_record(
@@ -82,9 +78,14 @@ def _build_record(
         "condition": (
             f"{source_info['protocol']}:{source_info['spatial_code_format']}:"
             f"{source_info['depth']}:{source_info['tracking']}:"
-            f"{source_info['input_selection']}:{source_info['frame_count']}"
+            + (
+                "video"
+                if source_info["input_selection"] == "video"
+                else f"{source_info['input_selection']}:{source_info['frame_count']}"
+            )
         ),
         "protocol": source_info["protocol"],
+        "question_group": question_group(row["question_type"]),
         "spatial_code_format": source_info["spatial_code_format"],
         "input_selection": source_info["input_selection"],
         "frame_count": source_info["frame_count"],
@@ -149,7 +150,6 @@ def write_question_result(
         source_info["input_selection"],
         source_info["frame_count"],
         results_dir,
-        overlay=source_info.get("overlay", False),
     )
     scene_dir = root / record["scene"]
     scene_dir.mkdir(parents=True, exist_ok=True)
@@ -164,6 +164,7 @@ def run(
     spatial_code_format=DEFAULT_SPATIAL_CODE_FORMAT,
     input_selection=DEFAULT_INPUT_SELECTION,
     frame_count=FRAMES_PER_VIDEO,
+    video=False,
     depth=DEFAULT_DEPTH,
     tracking=DEFAULT_TRACKING,
     scene=None,
@@ -174,27 +175,14 @@ def run(
     results_dir=None,
     write_results=True,
     adapter=None,
-    thinking=False,
     extended=True,
     reasoning_budget=EXTENDED_MAX_NEW_TOKENS,
     force_budget=MAX_NEW_TOKENS,
-    frame_linked=False,
-    overlay=False,
-    raw_budget=None,
 ):
     """Answer every matching question with one model, given both its scene's video
     frames AND its spatial code as text -- both sourced from the same (depth, tracking,
     input_selection, frame_count) config, so they never mismatch.
 
-    ``frame_linked=True`` runs the WEAK correspondence arm (analysis/
-    preregistration.md): each code instance gains a '"first visible in": "frame N"'
-    pointer into the prompt's numbered frames (see harness.C.prompts.frame_linked_code).
-    ``overlay=True`` runs the STRONG correspondence arm: every instance gets an
-    "instance id" in the code AND that id stamped into each frame at its projected
-    position (see harness.C.overlay; requires the scene's perception caches on disk).
-    Overlay results default under ``results/C/overlay`` so they cannot mix with the
-    main C condition. An explicit ``results_dir`` still overrides that default.
-
     Uses ``adapter.answer_extended`` (a large ``reasoning_budget`` first pass, with a
     short forced second call only if the model doesn't conclude within it) as the
     standing default protocol, same as harness.B, since C combines the same complex
@@ -207,18 +195,14 @@ def run(
     to reuse one already-loaded model across many calls; the caller then owns unloading
     it. Without one, ``run`` loads and unloads its own adapter, same as harness.A/B.
     """
-    if extended and raw_budget is not None:
-        raise ValueError("extended and raw_budget are mutually exclusive")
-    if (frame_linked or overlay) and spatial_code_format != "explicit":
-        raise ValueError(
-            "the correspondence arms are defined for the explicit format only (their "
-            "transforms annotate explicit-shaped instances)"
-        )
-    protocol = (
-        f"{reasoning_budget}"
-        if extended
-        else f"truncated/{raw_budget}" if raw_budget is not None else "base"
-    )
+    if video:
+        input_selection = "video"
+        frame_count = None
+    elif frame_count is None or frame_count < 1:
+        raise ValueError("frame_count must be positive in frames mode")
+    if spatial_code_format != "explicit":
+        raise ValueError("Harness C supports explicit spatial codes only")
+    protocol = "mixed"
     results_dir = results_dir_for(
         model,
         protocol,
@@ -228,7 +212,6 @@ def run(
         input_selection,
         frame_count,
         results_dir,
-        overlay=overlay,
     )
     rows = load_questions(jsonl_path, scene, scenes, limit)
     if not rows:
@@ -236,21 +219,25 @@ def run(
     owns_adapter = adapter is None
     if owns_adapter:
         adapter = vlm_models.get_adapter(model)
-        if thinking and not adapter.set_thinking(True):
-            raise ValueError(f"{model} has no native thinking mode to enable")
         adapter.load_model(device)
     source_cache = {}
     results = []
     try:
         for row in rows:
+            protocol = protocol_for_question(row["question_type"])
             scene_id = row["scene_name"]
             if scene_id not in source_cache:
                 video_path = inference_config.video_path(scene_id, row.get("dataset"))
-                frame_images, frame_timestamps, frame_indices = (
-                    frame_sampling.sample_frames(
-                        video_path, frame_count, input_selection
+                if video:
+                    frame_images = video_path
+                    frame_timestamps = None
+                    frame_indices = None
+                else:
+                    frame_images, frame_timestamps, frame_indices = (
+                        frame_sampling.sample_frames(
+                            video_path, frame_count, input_selection
+                        )
                     )
-                )
                 code, code_path = spatial_codes.load_spatial_code(
                     scene_id,
                     depth,
@@ -259,33 +246,6 @@ def run(
                     frame_count,
                     spatial_code_format,
                 )
-                if frame_linked:
-                    compact_code, _ = spatial_codes.load_spatial_code(
-                        scene_id,
-                        depth,
-                        input_selection,
-                        tracking,
-                        frame_count,
-                        "compact",
-                    )
-                    code = combined_prompts.frame_linked_code(
-                        code, compact_code, frame_timestamps
-                    )
-                if overlay:
-                    from harness.C import overlay as overlay_module
-
-                    frame_images, _visible = overlay_module.stamp_frames(
-                        frame_images,
-                        code,
-                        scene_id,
-                        depth,
-                        input_selection,
-                        tracking,
-                        frame_count,
-                    )
-                    code, code_path = overlay_module.load_or_create_overlay_code(
-                        code, scene_id, depth, input_selection, tracking, frame_count
-                    )
                 source_cache[scene_id] = {
                     "video_path": video_path,
                     "frame_images": frame_images,
@@ -300,7 +260,7 @@ def run(
                 row["question_type"],
                 row["question"],
                 row.get("options"),
-                overlay=overlay,
+                video=video,
             )
             answer = (
                 adapter.answer_extended(
@@ -309,9 +269,9 @@ def run(
                     reasoning_budget=reasoning_budget,
                     force_budget=force_budget,
                 )
-                if extended
+                if protocol == "thinking"
                 else adapter.answer(
-                    cached["frame_images"], prompt, max_new_tokens=raw_budget
+                    cached["frame_images"], prompt, max_new_tokens=MAX_NEW_TOKENS
                 )
             )
             doc = {
@@ -333,7 +293,6 @@ def run(
                 "video_path": cached["video_path"],
                 "frame_indices": cached["frame_indices"],
                 "frame_timestamps": cached["frame_timestamps"],
-                "overlay": overlay,
             }
             if write_results:
                 path, record = write_question_result(
@@ -371,19 +330,15 @@ def main():
     parser = argparse.ArgumentParser()
     parser.add_argument("--model", required=True, choices=vlm_models.available_models())
     parser.add_argument("--scene", default=None, help="restrict to one VSI-Bench scene")
-    parser.add_argument(
-        "--spatial-code-format",
-        default=DEFAULT_SPATIAL_CODE_FORMAT,
-        choices=SPATIAL_CODE_FORMATS,
-        dest="spatial_code_format",
-    )
     parser.add_argument(
         "--input-selection",
-        default=DEFAULT_INPUT_SELECTION,
+        default=None,
         choices=INPUT_SELECTIONS,
         dest="input_selection",
     )
-    parser.add_argument("--frames", type=int, default=FRAMES_PER_VIDEO)
+    input_mode = parser.add_mutually_exclusive_group(required=True)
+    input_mode.add_argument("--frames", type=int)
+    input_mode.add_argument("--video", action="store_true")
     parser.add_argument("--depth", default=DEFAULT_DEPTH, choices=DEPTH_VARIANTS)
     parser.add_argument("--tracking", default=DEFAULT_TRACKING, choices=TRACKING_MODES)
     parser.add_argument(
@@ -393,8 +348,8 @@ def main():
     parser.add_argument(
         "--results-dir",
         default=None,
-        help="override the default results/C/<model>/<protocol>/<format>/"
-        "<depth>/<tracking>/<input>/<frames> root",
+        help="override the default results/C/<model>/explicit/"
+        "<depth>/<tracking>/{<input>/<frames>|video} root",
     )
     parser.add_argument(
         "--no-write",
@@ -402,57 +357,33 @@ def main():
         help="skip writing per-question JSON files; print/score only",
     )
     parser.add_argument(
-        "--base-protocol",
-        action="store_true",
-        help="run harness.A's exact fixed 16-token protocol (plain answer()) instead of "
-        "the extended 2048-token default",
-    )
-    parser.add_argument(
-        "--overlay-ids",
-        action="store_true",
-        dest="overlay",
-        help="strong correspondence arm: stamp instance ids onto the frames at each "
-        "instance's projected position and add matching ids to the code",
-    )
-    parser.add_argument(
-        "--frame-linked-code",
-        action="store_true",
-        dest="frame_linked",
-        help="correspondence arm: add per-instance 'first visible in: frame N' pointers "
-        "(pair with an explicit --results-dir)",
-    )
-    parser.add_argument(
-        "--thinking",
-        action="store_true",
-        help="enable the model's native thinking mode where supported; errors on models without the switch",
+        "--reasoning-budget",
+        type=int,
+        default=None,
+        help="thinking questions only (default: 2048)",
     )
-    parser.add_argument("--reasoning-budget", type=int, default=EXTENDED_MAX_NEW_TOKENS)
-    parser.add_argument("--force-budget", type=int, default=MAX_NEW_TOKENS)
     parser.add_argument(
-        "--truncated-budget",
+        "--force-budget",
         type=int,
         default=None,
-        help="raw-budget arm: base-protocol mechanics (single generation, no forced "
-        "rescue) at this token cap instead of the hardcoded 16 (mutually exclusive "
-        "with --base-protocol)",
+        help="thinking questions only (default: 16)",
     )
     args = parser.parse_args()
-    if args.frames < 1:
-        parser.error("--frames must be positive")
-    if args.reasoning_budget < 1:
-        parser.error("--reasoning-budget must be positive")
-    if args.force_budget < 1:
-        parser.error("--force-budget must be positive")
-    if args.truncated_budget is not None and args.truncated_budget < 1:
-        parser.error("--truncated-budget must be positive")
-    if args.base_protocol and args.truncated_budget is not None:
-        parser.error("--base-protocol and --truncated-budget are mutually exclusive")
-
+    if args.video:
+        if args.input_selection is not None:
+            parser.error("--input-selection cannot be used with --video")
+    else:
+        if args.input_selection is None:
+            parser.error("--input-selection is required with --frames")
+        if args.frames < 1:
+            parser.error("--frames must be positive")
+    resolve_protocol_budgets(parser, args)
     results = run(
         args.model,
-        spatial_code_format=args.spatial_code_format,
+        spatial_code_format=DEFAULT_SPATIAL_CODE_FORMAT,
         input_selection=args.input_selection,
         frame_count=args.frames,
+        video=args.video,
         depth=args.depth,
         tracking=args.tracking,
         scene=args.scene,
@@ -460,11 +391,7 @@ def main():
         device=args.device,
         results_dir=args.results_dir,
         write_results=not args.no_write,
-        extended=not args.base_protocol and args.truncated_budget is None,
-        raw_budget=args.truncated_budget,
-        frame_linked=args.frame_linked,
-        overlay=args.overlay,
-        thinking=args.thinking,
+        extended=True,
         reasoning_budget=args.reasoning_budget,
         force_budget=args.force_budget,
     )

harness/C/sweep.py

@@ -1,4 +1,4 @@
-"""Sweep any set of models x spatial-code-formats x depths x trackings x
+"""Sweep any set of models x depths x trackings x
 input-selections x frame-counts.
 
 Every (model, spatial_code_format, depth, tracking, input_selection, frame_count)
@@ -22,14 +22,15 @@ if str(WORKSPACE_ROOT) not in sys.path:
     sys.path.insert(0, str(WORKSPACE_ROOT))
 
 from harness.A import models as vlm_models  # noqa: E402
+from harness.A import resolve_protocol_budgets  # noqa: E402
 from harness.A import EXTENDED_MAX_NEW_TOKENS  # noqa: E402
 from harness.A.sweep import _parse_csv_choice, _parse_frame_counts  # noqa: E402
 from harness.B import (  # noqa: E402
     DEFAULT_DEPTH,
+    DEFAULT_SPATIAL_CODE_FORMAT,
     DEFAULT_TRACKING,
     DEPTH_VARIANTS,
     INPUT_SELECTIONS,
-    SPATIAL_CODE_FORMATS,
     TRACKING_MODES,
 )
 from harness.C import launch as harness_launch  # noqa: E402
@@ -58,26 +59,18 @@ def sweep(
     input_selections,
     frame_counts,
     selected_scenes,
+    video=False,
     depths=(DEFAULT_DEPTH,),
     trackings=(DEFAULT_TRACKING,),
     results_dir=None,
     rebuild=False,
-    thinking=False,
     extended=True,
     reasoning_budget=EXTENDED_MAX_NEW_TOKENS,
-    frame_linked=False,
-    overlay=False,
-    raw_budget=None,
 ):
     """Run every sweep combination across all visible GPUs."""
     plan = build_plan(
         models, spatial_code_formats, input_selections, frame_counts, depths, trackings
     )
-    protocol = (
-        f"{reasoning_budget}"
-        if extended
-        else f"truncated/{raw_budget}" if raw_budget is not None else "base"
-    )
     for index, (
         model,
         spatial_code_format,
@@ -87,8 +80,10 @@ def sweep(
         frame_count,
     ) in enumerate(plan, start=1):
         print(
-            f"=== sweep {index}/{len(plan)}: {model}/{protocol}/"
-            f"{spatial_code_format}/{depth}/{tracking}/{input_selection}/{frame_count} ===",
+            f"=== sweep {index}/{len(plan)}: {model}/"
+            f"{spatial_code_format}/{depth}/{tracking}/"
+            + ("video" if video else f"{input_selection}/{frame_count}")
+            + " ===",
             flush=True,
         )
         harness_launch.launch(
@@ -97,16 +92,13 @@ def sweep(
             input_selection,
             frame_count,
             selected_scenes,
+            video=video,
             depth=depth,
             tracking=tracking,
             results_dir=results_dir,
             rebuild=rebuild,
-            thinking=thinking,
             extended=extended,
             reasoning_budget=reasoning_budget,
-            frame_linked=frame_linked,
-            overlay=overlay,
-            raw_budget=raw_budget,
         )
 
 
@@ -122,21 +114,17 @@ def main():
         required=True,
         help=f"comma-separated models (or 'all'); one of {vlm_models.available_models()}",
     )
-    parser.add_argument(
-        "--spatial-code-formats",
-        required=True,
-        dest="spatial_code_formats",
-        help=f"comma-separated formats (or 'all'); one of {SPATIAL_CODE_FORMATS}",
-    )
     parser.add_argument(
         "--input-selections",
-        required=True,
+        required=False,
         dest="input_selections",
         help=f"comma-separated selections (or 'all'); one of {INPUT_SELECTIONS}",
     )
-    parser.add_argument(
-        "--frames", required=True, help="comma-separated frame counts, e.g. 16,32,64"
+    input_mode = parser.add_mutually_exclusive_group(required=True)
+    input_mode.add_argument(
+        "--frames", help="comma-separated frame counts, e.g. 16,32,64"
     )
+    input_mode.add_argument("--video", action="store_true")
     parser.add_argument(
         "--depths",
         default=DEFAULT_DEPTH,
@@ -149,65 +137,38 @@ def main():
     )
     parser.add_argument("--results-dir", default=None)
     parser.add_argument("--rebuild", action="store_true")
-    parser.add_argument(
-        "--base-protocol",
-        action="store_true",
-        help="run the whole sweep under harness.A's exact fixed 16-token protocol "
-        "instead of the extended default",
-    )
-    parser.add_argument(
-        "--thinking",
-        action="store_true",
-        help="enable the model's native thinking mode where supported; errors on models without the switch",
-    )
     parser.add_argument(
         "--reasoning-budget",
         type=int,
-        default=EXTENDED_MAX_NEW_TOKENS,
+        default=None,
         dest="reasoning_budget",
-        help="extended-protocol first-pass budget (the calibrated value from "
+        help="thinking-protocol first-pass budget (the calibrated value from "
         "preregistration.md, e.g. 512)",
     )
-    parser.add_argument(
-        "--overlay-ids",
-        action="store_true",
-        dest="overlay",
-        help="strong correspondence arm: stamp instance ids onto the frames at each "
-        "instance's projected position and add matching ids to the code",
-    )
-    parser.add_argument(
-        "--frame-linked-code",
-        action="store_true",
-        dest="frame_linked",
-        help="correspondence arm: add per-instance 'first visible in: frame N' pointers "
-        "(pair with an explicit --results-dir)",
-    )
-    parser.add_argument(
-        "--truncated-budget",
-        type=int,
-        default=None,
-        help="raw-budget arm: base-protocol mechanics (single generation, no forced "
-        "rescue) at this token cap (mutually exclusive with --base-protocol)",
-    )
     args = parser.parse_args()
+    resolve_protocol_budgets(parser, args)
     if args.scene and args.scenes:
         parser.error("positional scene and --scenes cannot be used together")
-    if args.base_protocol and args.truncated_budget is not None:
-        parser.error("--base-protocol and --truncated-budget are mutually exclusive")
 
     try:
         models = _parse_csv_choice(
             args.models, vlm_models.available_models(), "--models"
         )
-        spatial_code_formats = _parse_csv_choice(
-            args.spatial_code_formats, SPATIAL_CODE_FORMATS, "--spatial-code-formats"
-        )
-        input_selections = _parse_csv_choice(
-            args.input_selections, INPUT_SELECTIONS, "--input-selections"
-        )
+        spatial_code_formats = (DEFAULT_SPATIAL_CODE_FORMAT,)
+        if args.video:
+            if args.input_selections is not None:
+                raise ValueError("--input-selections cannot be used with --video")
+            input_selections = ["video"]
+            frame_counts = [None]
+        else:
+            if args.input_selections is None:
+                raise ValueError("--input-selections is required with --frames")
+            input_selections = _parse_csv_choice(
+                args.input_selections, INPUT_SELECTIONS, "--input-selections"
+            )
+            frame_counts = _parse_frame_counts(args.frames)
         depths = _parse_csv_choice(args.depths, DEPTH_VARIANTS, "--depths")
         trackings = _parse_csv_choice(args.trackings, TRACKING_MODES, "--trackings")
-        frame_counts = _parse_frame_counts(args.frames)
     except ValueError as exc:
         parser.error(str(exc))
 
@@ -227,16 +188,13 @@ def main():
         input_selections,
         frame_counts,
         selected,
+        video=args.video,
         depths=depths,
         trackings=trackings,
         results_dir=args.results_dir,
         rebuild=args.rebuild,
-        thinking=args.thinking,
-        extended=not args.base_protocol and args.truncated_budget is None,
+        extended=True,
         reasoning_budget=args.reasoning_budget,
-        frame_linked=args.frame_linked,
-        overlay=args.overlay,
-        raw_budget=args.truncated_budget,
     )
 
 

harness/F/__init__.py

@@ -1,8 +1,8 @@
-"""Harness F: deterministic symbolic reasoning over perceived or ground-truth spatial codes."""
+"""Harness F: deterministic symbolic reasoning over perceived spatial codes."""
 
 from pathlib import Path
 import os
 
 RESULTS_DIR = Path(os.environ.get("VSI_HARNESS_F_RESULTS_DIR", "/root/results/F"))
-SOURCES = ("perceived", "ground truth")
+SOURCES = ("perceived",)
 DEFAULT_SOURCE = "perceived"

harness/F/run.py

@@ -26,17 +26,10 @@ def results_dir_for(
 ):
     if results_dir is not None:
         return Path(results_dir)
-    if source == "ground truth":
-        return RESULTS_DIR / "ground truth" / spatial_code_format
-    return (
-        RESULTS_DIR
-        / "perceived"
-        / depth
-        / tracking
-        / input_selection
-        / str(frame_count)
-        / spatial_code_format
-    )
+    root = RESULTS_DIR / "perceived" / depth / tracking
+    if input_selection == "video":
+        return root / "video" / spatial_code_format
+    return root / input_selection / str(frame_count) / spatial_code_format
 
 
 def select_source(
@@ -49,8 +42,8 @@ def select_source(
 ):
     if source not in SOURCES:
         raise ValueError(f"unknown source {source!r}; expected one of {SOURCES}")
-    if source == "ground truth":
-        return symbolic_run.select_ground_truth_spatial_codes(spatial_code_format)
+    if spatial_code_format != "explicit":
+        raise ValueError("Harness F supports explicit spatial codes only")
     return symbolic_run.select_spatial_codes(
         depth, input_selection, tracking, frame_count, spatial_code_format
     )
@@ -70,6 +63,7 @@ def run(
     tracking="tracking",
     input_selection="uniform",
     frame_count=32,
+    video=False,
     scene=None,
     scenes=None,
     results_dir=None,
@@ -78,6 +72,11 @@ def run(
 ):
     if scene is not None and scenes is not None:
         raise ValueError("scene and scenes cannot both be given")
+    if video:
+        input_selection = "video"
+        frame_count = None
+    elif frame_count is None or frame_count < 1:
+        raise ValueError("frame_count must be positive in frames mode")
     select_source(
         source, spatial_code_format, depth, tracking, input_selection, frame_count
     )
@@ -135,12 +134,6 @@ def main():
         "--scenes", help="comma-separated scenes; default: every available scene"
     )
     p.add_argument("--source", choices=SOURCES, default=DEFAULT_SOURCE)
-    p.add_argument(
-        "--spatial-code-format",
-        choices=symbolic_run.SPATIAL_CODE_FORMATS,
-        default="explicit",
-        dest="spatial_code_format",
-    )
     p.add_argument("--depth", choices=symbolic_run.DEPTH_VARIANTS, default="metric")
     p.add_argument(
         "--tracking", choices=symbolic_run.TRACKING_MODES, default="tracking"
@@ -148,18 +141,26 @@ def main():
     p.add_argument(
         "--input-selection",
         choices=symbolic_run.INPUT_SELECTIONS,
-        default="uniform",
+        default=None,
         dest="input_selection",
     )
-    p.add_argument("--frames", type=int, default=32)
+    input_mode = p.add_mutually_exclusive_group(required=True)
+    input_mode.add_argument("--frames", type=int)
+    input_mode.add_argument("--video", action="store_true")
     p.add_argument("--results-dir", default=None)
     p.add_argument("--no-write", action="store_true")
     p.add_argument("--verbose", action="store_true")
     a = p.parse_args()
     if a.scene and a.scenes:
         p.error("scene and --scenes cannot be combined")
-    if a.frames < 1:
-        p.error("--frames must be positive")
+    if a.video:
+        if a.input_selection is not None:
+            p.error("--input-selection cannot be used with --video")
+    else:
+        if a.input_selection is None:
+            p.error("--input-selection is required with --frames")
+        if a.frames < 1:
+            p.error("--frames must be positive")
     selected = (
         None
         if not a.scenes
@@ -167,11 +168,12 @@ def main():
     )
     records = run(
         a.source,
-        a.spatial_code_format,
+        "explicit",
         a.depth,
         a.tracking,
         a.input_selection,
         a.frames,
+        a.video,
         a.scene,
         selected,
         a.results_dir,

harness/F/sweep.py

@@ -22,25 +22,34 @@ def _csv(value, valid):
 def main():
     p = argparse.ArgumentParser()
     p.add_argument("--sources", default="all")
-    p.add_argument("--spatial-code-formats", default="all")
     p.add_argument("--depths", default="metric")
     p.add_argument("--trackings", default="tracking")
-    p.add_argument("--input-selections", default="uniform")
-    p.add_argument("--frames", default="32")
+    p.add_argument("--input-selections", default=None)
+    input_mode = p.add_mutually_exclusive_group(required=True)
+    input_mode.add_argument("--frames")
+    input_mode.add_argument("--video", action="store_true")
     p.add_argument("--scenes", default=None)
     p.add_argument("--results-dir", default=None)
     a = p.parse_args()
     try:
         sources = _csv(a.sources, harness_run.SOURCES)
-        formats = _csv(a.spatial_code_formats, symbolic_run.SPATIAL_CODE_FORMATS)
+        formats = ("explicit",)
         depths = _csv(a.depths, symbolic_run.DEPTH_VARIANTS)
         trackings = _csv(a.trackings, symbolic_run.TRACKING_MODES)
-        selections = _csv(a.input_selections, symbolic_run.INPUT_SELECTIONS)
-        frames = list(
-            dict.fromkeys(int(x.strip()) for x in a.frames.split(",") if x.strip())
-        )
-        if not frames or any(x < 1 for x in frames):
-            raise ValueError("frames must be positive")
+        if a.video:
+            if a.input_selections is not None:
+                raise ValueError("--input-selections cannot be used with --video")
+            selections = ["video"]
+            frames = [None]
+        else:
+            if a.input_selections is None:
+                raise ValueError("--input-selections is required with --frames")
+            selections = _csv(a.input_selections, symbolic_run.INPUT_SELECTIONS)
+            frames = list(
+                dict.fromkeys(int(x.strip()) for x in a.frames.split(",") if x.strip())
+            )
+            if not frames or any(x < 1 for x in frames):
+                raise ValueError("frames must be positive")
     except ValueError as exc:
         p.error(str(exc))
     scenes = (
@@ -49,20 +58,17 @@ def main():
         else list(dict.fromkeys(x.strip() for x in a.scenes.split(",") if x.strip()))
     )
     for source, fmt in product(sources, formats):
-        configs = (
-            [(None, None, None, None)]
-            if source == "ground truth"
-            else product(depths, trackings, selections, frames)
-        )
+        configs = product(depths, trackings, selections, frames)
         for config in configs:
             depth, tracking, selection, count = config
             records = harness_run.run(
                 source,
                 fmt,
-                depth or "metric",
-                tracking or "tracking",
-                selection or "uniform",
-                count or 32,
+                depth,
+                tracking,
+                selection,
+                count,
+                video=a.video,
                 scenes=scenes,
                 results_dir=a.results_dir,
             )

inference/__init__.py

@@ -63,7 +63,7 @@ def model_cache_dir(
     root = CACHE_ROOT / model
     if model == "depth-anything-3":
         root /= depth
-    return str(root / input_selection / str(frame_count))
+    return str(root / "frames" / input_selection / str(frame_count))
 
 
 def sam3_cache_dir(tracking, input_selection, frame_count=FRAMES_PER_VIDEO):
@@ -78,7 +78,7 @@ def sam3_cache_dir(tracking, input_selection, frame_count=FRAMES_PER_VIDEO):
         )
     if frame_count < 1:
         raise ValueError("frame count must be positive")
-    return str(CACHE_ROOT / "sam3" / tracking / input_selection / str(frame_count))
+    return str(CACHE_ROOT / "sam3" / tracking / "frames" / input_selection / str(frame_count))
 
 
 def parse_sam3_frame_mode(mode):

symbolic/adapters.py

@@ -202,8 +202,7 @@ def _adapt_compact(code):
                     "longest dimension": float(dimensions.max()),
                 }
             )
-            # None means no ground truth timing is available for this instance (see
-            # encoder.ground_truth) -- excluded from the min rather than coerced to a
+            # None means no ground truth timing is available for this instance -- excluded from the min rather than coerced to a
             # fabricated time; a class with no timed instance at all falls through to the
             # math.inf default below and sorts after every timed class.
             if first_time is not None:

symbolic/launch.py

@@ -444,7 +444,7 @@ def _run_cli(args, requested_scene_ids):
         args.input_selection,
         args.tracking,
         args.frames,
-        args.spatial_code_format,
+        "explicit",
     )
     scene_ids = requested_scene_ids
     all_available = scenes_with_spatial_codes()
@@ -514,7 +514,7 @@ def _run_cli(args, requested_scene_ids):
         "input": args.input_selection,
         "tracking": args.tracking,
         "frames": args.frames,
-        "spatial_code_format": args.spatial_code_format,
+        "spatial_code_format": "explicit",
         "scenes_run": scenes_with_real_questions,
         "scenes_skipped_no_questions": [
             scene for scene in scene_ids if scene not in per_scene_results
@@ -538,21 +538,20 @@ def _run_cli(args, requested_scene_ids):
 
 def main():
     ap = argparse.ArgumentParser()
-    ap.add_argument("--depth", required=True, choices=symbolic_run.DEPTH_VARIANTS)
+    ap.add_argument("--depth", choices=symbolic_run.DEPTH_VARIANTS)
     ap.add_argument(
         "--input",
-        required=True,
         choices=symbolic_run.INPUT_SELECTIONS,
         dest="input_selection",
     )
-    ap.add_argument("--frames", type=int, default=32)
-    ap.add_argument(
-        "--format",
-        choices=symbolic_run.SPATIAL_CODE_FORMATS,
-        default="explicit",
-        dest="spatial_code_format",
+    input_mode = ap.add_mutually_exclusive_group(required=True)
+    input_mode.add_argument("--frames", type=int)
+    input_mode.add_argument(
+        "--video",
+        action="store_true",
+        help="use spatial codes built from full-video DA3 and SAM3 caches",
     )
-    ap.add_argument("--tracking", required=True, choices=symbolic_run.TRACKING_MODES)
+    ap.add_argument("--tracking", choices=symbolic_run.TRACKING_MODES)
     ap.add_argument(
         "--scenes",
         default="",
@@ -572,7 +571,17 @@ def main():
         "offenders) in addition to the combined aggregate",
     )
     a = ap.parse_args()
-    if a.frames < 1:
+    if a.depth is None:
+        ap.error("--depth is required")
+    if a.tracking is None:
+        ap.error("--tracking is required")
+    if a.video:
+        if a.input_selection is not None:
+            ap.error("--input cannot be used with --video")
+        a.input_selection = symbolic_run.VIDEO_INPUT_SELECTION
+    elif a.input_selection is None:
+        ap.error("--input is required with --frames")
+    if a.frames is not None and a.frames < 1:
         ap.error("--frames must be positive")
     requested_scene_ids = (
         [scene.strip() for scene in a.scenes.split(",") if scene.strip()]

symbolic/run.py

@@ -5,7 +5,7 @@ orchestrator (matching encoder/launch.py's single-scene-worker versus
 multi-scene-orchestrator split: this file never loops over more than one scene on its own).
 
 Fetches the spatial code from:
-    /workspace/data/spatial codes/<MODEL>/<DEPTH>/<TRACKING>/<INPUT>/<FRAMES>/<FORMAT>/<SCENE_ID>.json
+    /workspace/data/spatial codes/<MODEL>/<DEPTH>/<TRACKING>/{frames/<INPUT>/<FRAMES>|video}/explicit/<SCENE_ID>.json
 (the model- and format-specific on-disk layout). This file does NOT
 build spatial codes (that's encoder/render.py's job) and does NOT call any model -- it only
 reads an already-built spatial_code.json and answers/scores against it.
@@ -115,6 +115,7 @@ def _default_results_dir():
 
 DEPTH_VARIANTS = ("relative", "metric")
 INPUT_SELECTIONS = ("uniform", "selective")
+VIDEO_INPUT_SELECTION = "video"
 TRACKING_MODES = ("tracking", "no tracking")
 SPATIAL_CODE_FORMATS = adapters.SPATIAL_CODE_FORMATS
 SPATIAL_CODES_ROOT = os.environ.get(
@@ -133,22 +134,27 @@ def _validate_selection(depth, input_selection, tracking, frame_count):
     """Validate the dimensions shared by spatial-code and result paths."""
     if depth not in DEPTH_VARIANTS:
         raise ValueError(f"unknown depth variant {depth!r}; expected {DEPTH_VARIANTS}")
-    if input_selection not in INPUT_SELECTIONS:
+    selections = INPUT_SELECTIONS + (VIDEO_INPUT_SELECTION,)
+    if input_selection not in selections:
         raise ValueError(
-            f"unknown input selection {input_selection!r}; expected {INPUT_SELECTIONS}"
+            f"unknown input selection {input_selection!r}; expected {selections}"
         )
     if tracking not in TRACKING_MODES:
         raise ValueError(
             f"unknown tracking mode {tracking!r}; expected {TRACKING_MODES}"
         )
-    if frame_count < 1:
+    if input_selection != VIDEO_INPUT_SELECTION and (
+        frame_count is None or frame_count < 1
+    ):
         raise ValueError("frame count must be positive")
 
 
 def _selection_subdirectory(depth, input_selection, tracking, frame_count):
-    """Return the shared depth/tracking/input/frame-count hierarchy."""
+    """Return tracking/{frames/<selection>/<count>|video} for perceived codes."""
     _validate_selection(depth, input_selection, tracking, frame_count)
-    return os.path.join(depth, tracking, input_selection, str(frame_count))
+    if input_selection == VIDEO_INPUT_SELECTION:
+        return os.path.join(tracking, "video")
+    return os.path.join(tracking, "frames", input_selection, str(frame_count))
 
 
 def select_spatial_codes(
@@ -182,7 +188,7 @@ def select_spatial_codes(
 
 
 def select_ground_truth_spatial_codes(spatial_code_format="explicit"):
-    """Select the GROUND-TRUTH spatial codes (encoder.ground_truth's on-disk output,
+    """Select the GROUND-TRUTH spatial codes (prebuilt on-disk output,
     "data/spatial codes/ground truth/<format>/<scene>.json") instead of a perception-
     pipeline selection -- no depth/tracking/input/frame-count axis, since ground truth
     is built once per scene straight from dataset annotations. Results written while
@@ -528,8 +534,12 @@ def write_question_result(scene_id, pq, code, results_dir=None):
             if ground_truth
             else (
                 f"{SPATIAL_CODES_DEPTH}:{SPATIAL_CODES_TRACKING}:"
-                f"{SPATIAL_CODES_INPUT}:{SPATIAL_CODES_FRAMES}:"
-                f"{SPATIAL_CODES_FORMAT}"
+                + (
+                    "video"
+                    if SPATIAL_CODES_INPUT == VIDEO_INPUT_SELECTION
+                    else f"{SPATIAL_CODES_INPUT}:{SPATIAL_CODES_FRAMES}"
+                )
+                + f":{SPATIAL_CODES_FORMAT}"
             )
         ),
         "spatial_code_model": None if ground_truth else SPATIAL_CODES_MODEL,
@@ -590,27 +600,35 @@ def write_scene_results(scene_id, per_question, aggregate, code, results_dir=Non
 def main():
     parser = argparse.ArgumentParser()
     parser.add_argument("scene_id")
-    parser.add_argument("--depth", required=True, choices=DEPTH_VARIANTS)
-    parser.add_argument(
-        "--input", required=True, choices=INPUT_SELECTIONS, dest="input_selection"
-    )
-    parser.add_argument("--tracking", required=True, choices=TRACKING_MODES)
-    parser.add_argument("--frames", type=int, default=32)
-    parser.add_argument(
-        "--format",
-        choices=SPATIAL_CODE_FORMATS,
-        default="explicit",
-        dest="spatial_code_format",
+    parser.add_argument("--depth", choices=DEPTH_VARIANTS)
+    parser.add_argument("--input", choices=INPUT_SELECTIONS, dest="input_selection")
+    input_mode = parser.add_mutually_exclusive_group(required=True)
+    input_mode.add_argument("--frames", type=int)
+    input_mode.add_argument(
+        "--video",
+        action="store_true",
+        help="use a spatial code built from full-video DA3 and SAM3 caches",
     )
+    parser.add_argument("--tracking", choices=TRACKING_MODES)
     args = parser.parse_args()
-    if args.frames < 1:
+    if args.depth is None:
+        parser.error("--depth is required")
+    if args.tracking is None:
+        parser.error("--tracking is required")
+    if args.video:
+        if args.input_selection is not None:
+            parser.error("--input cannot be used with --video")
+        args.input_selection = VIDEO_INPUT_SELECTION
+    elif args.input_selection is None:
+        parser.error("--input is required with --frames")
+    if args.frames is not None and args.frames < 1:
         parser.error("--frames must be positive")
     select_spatial_codes(
         args.depth,
         args.input_selection,
         args.tracking,
         args.frames,
-        args.spatial_code_format,
+        "explicit",
     )
     per_question, aggregate = score_scene(args.scene_id)
     code = fetch_spatial_code(args.scene_id)

tests/test_A/test_A.py

@@ -1,10 +1,35 @@
 """Tests for harness/A/__init__.py -- shared config constants."""
 
+from argparse import ArgumentParser, Namespace
 from pathlib import Path
 
+import pytest
+
 from harness import A
 
 
+def test_thinking_mode_resolves_default_budgets():
+    args = Namespace(extended=True, reasoning_budget=None, force_budget=None)
+    A.resolve_protocol_budgets(ArgumentParser(), args)
+    assert args.reasoning_budget == A.EXTENDED_MAX_NEW_TOKENS
+    assert args.force_budget == A.MAX_NEW_TOKENS
+
+
+def test_base_mode_keeps_budgets_unset_without_budget_flags():
+    args = Namespace(extended=False, reasoning_budget=None, force_budget=None)
+    A.resolve_protocol_budgets(ArgumentParser(), args)
+    assert args.reasoning_budget is None
+    assert args.force_budget is None
+
+
+@pytest.mark.parametrize("flag", ["reasoning_budget", "force_budget"])
+def test_base_mode_rejects_thinking_budget_flags(flag):
+    args = Namespace(extended=False, reasoning_budget=None, force_budget=None)
+    setattr(args, flag, 8)
+    with pytest.raises(SystemExit):
+        A.resolve_protocol_budgets(ArgumentParser(), args)
+
+
 def test_generation_protocol_matches_vsibench_yaml():
     # thinking-in-space/lmms_eval/tasks/vsibench/vsibench.yaml generation_kwargs.
     assert A.MAX_NEW_TOKENS == 16
@@ -12,7 +37,7 @@ def test_generation_protocol_matches_vsibench_yaml():
     assert A.DO_SAMPLE is False
 
 
-def test_extended_generation_protocol():
+def test_thinking_generation_protocol():
     assert A.EXTENDED_MAX_NEW_TOKENS == 2048
     assert A.EXTENDED_MAX_NEW_TOKENS > A.MAX_NEW_TOKENS
     assert isinstance(A.FORCE_ANSWER_PROMPT, str) and A.FORCE_ANSWER_PROMPT.strip()

tests/test_A/test_init.py

@@ -10,7 +10,7 @@ def test_generation_protocol_matches_vsibench_yaml():
     assert A.DO_SAMPLE is False
 
 
-def test_extended_generation_protocol():
+def test_thinking_generation_protocol():
     assert A.EXTENDED_MAX_NEW_TOKENS == 2048
     assert A.EXTENDED_MAX_NEW_TOKENS > A.MAX_NEW_TOKENS
     assert isinstance(A.FORCE_ANSWER_PROMPT, str) and A.FORCE_ANSWER_PROMPT.strip()
@@ -28,7 +28,10 @@ def test_default_frame_selection_is_a_valid_selection():
 
 def test_model_paths_cover_every_registered_model():
     assert set(A.MODEL_PATHS) == {
-        "qwen3.5-4b", "qwen3.5-2b", "internvl3.5-4b", "internvl3.5-2b",
+        "qwen3.5-4b",
+        "qwen3.5-2b",
+        "internvl3.5-4b",
+        "internvl3.5-2b",
     }
     for path in A.MODEL_PATHS.values():
         assert path.parent == A.MODELS_ROOT
@@ -36,3 +39,22 @@ def test_model_paths_cover_every_registered_model():
 
 def test_results_dir_defaults_under_workspace_results():
     assert A.RESULTS_DIR == A.WORKSPACE_ROOT / "results" / "A"
+
+
+def test_question_protocol_policy_is_hardcoded_by_group():
+    assert A.question_group("object_counting") == "numerical"
+    assert A.protocol_for_question("object_counting") == "base"
+    assert A.question_group("route_planning") == "multiple_choice"
+    assert A.protocol_for_question("route_planning") == "thinking"
+
+
+def test_every_known_question_type_has_one_policy_group():
+    for question_type in A.NUMERICAL_QUESTION_TYPES:
+        assert (
+            A.protocol_for_question(question_type) == A.QUESTION_PROTOCOLS["numerical"]
+        )
+    for question_type in A.MULTIPLE_CHOICE_QUESTION_TYPES:
+        assert (
+            A.protocol_for_question(question_type)
+            == A.QUESTION_PROTOCOLS["multiple_choice"]
+        )

tests/test_A/test_models.py

@@ -38,12 +38,6 @@ def test_get_adapter_rejects_unknown_model():
         vlm_models.get_adapter("not-a-real-model")
 
 
-def test_qwen_adapter_disables_thinking_mode():
-    # Otherwise Qwen3.5's default template opens an unclosed <think> block that would
-    # consume the entire 16-token budget before ever emitting an answer.
-    assert vlm_models.QwenVLAdapter.chat_template_kwargs == {"enable_thinking": False}
-
-
 def test_internvl_adapter_disables_per_frame_tiling():
     # Otherwise InternVL's default per-image dynamic tiling (~3300 tokens/frame) blows
     # past this checkpoint's 40960-token context window at just 16 frames.
@@ -90,3 +84,11 @@ def test_unload_clears_model_and_processor():
     adapter.unload()
     assert adapter.model is None
     assert adapter.processor is None
+
+
+def test_native_video_content_uses_one_video_item():
+    content = vlm_models._numbered_content("/data/scene.mp4", "What is in the room?")
+    assert content == [
+        {"type": "video", "video": "/data/scene.mp4"},
+        {"type": "text", "text": "What is in the room?"},
+    ]

tests/test_A/test_prompts.py

@@ -48,3 +48,8 @@ def test_every_mca_question_type_builds_with_options(question_type):
     prompt = vsi_prompts.build_prompt(question_type, "q?", ["A. x", "B. y"])
     assert prompt.startswith(vsi_prompts.PRE_PROMPT)
     assert prompt.endswith(vsi_prompts.MCA_POST_PROMPT)
+
+
+def test_video_prompt_names_native_video():
+    prompt = vsi_prompts.build_prompt("object_counting", "How many chairs?", video=True)
+    assert prompt.startswith("This is a video.\n")

tests/test_A/test_run.py

@@ -102,13 +102,13 @@ def test_scalar_score_rejects_unknown_question_type():
 
 def test_results_dir_for_matches_established_dimension_nesting():
     root = harness_run.results_dir_for("qwen3.5-4b", "base", "selective", 32)
-    assert root == A.RESULTS_DIR / "qwen3.5-4b" / "base" / "selective" / "32"
+    assert root == A.RESULTS_DIR / "qwen3.5-4b" / "selective" / "32"
 
 
-def test_results_dir_for_isolates_the_two_protocols():
+def test_results_dir_for_keeps_protocols_together():
     base = harness_run.results_dir_for("qwen3.5-4b", "base", "selective", 32)
-    extended = harness_run.results_dir_for("qwen3.5-4b", "extended", "selective", 32)
-    assert base != extended
+    extended = harness_run.results_dir_for("qwen3.5-4b", "thinking", "selective", 32)
+    assert base == extended
 
 
 def test_results_dir_for_honors_explicit_override(tmp_path):
@@ -211,3 +211,19 @@ def test_build_record_carries_reasoning_fields_when_extended():
     assert record["reasoning_hit_limit"] is True
     assert record["forced"] is True
     assert record["forced_input_token_count"] == 2510
+
+
+def test_video_results_use_video_branch():
+    assert (
+        harness_run.results_dir_for("qwen3.5-4b", "thinking", "video", None)
+        == A.RESULTS_DIR / "qwen3.5-4b" / "video"
+    )
+
+
+def test_video_record_has_no_frame_count_in_condition():
+    info = dict(_FAKE_FRAME_INFO, frame_selection="video", frame_count=None)
+    record = harness_run._build_record(
+        _FAKE_ROW, "prompt", _FAKE_ANSWER, "metric", 1.0, "qwen3.5-4b", "/model", info
+    )
+    assert record["condition"] == "base:video"
+    assert record["frame_count"] is None

tests/test_B/test_B.py

@@ -5,8 +5,8 @@ from pathlib import Path
 from harness import A, B
 
 
-def test_spatial_code_formats_match_the_two_on_disk_schemas():
-    assert B.SPATIAL_CODE_FORMATS == ("explicit", "compact")
+def test_spatial_code_formats_is_explicit_only():
+    assert B.SPATIAL_CODE_FORMATS == ("explicit",)
     assert B.DEFAULT_SPATIAL_CODE_FORMAT in B.SPATIAL_CODE_FORMATS
 
 

tests/test_B/test_init.py

@@ -3,8 +3,8 @@
 from harness import A, B
 
 
-def test_spatial_code_formats_match_the_two_on_disk_schemas():
-    assert B.SPATIAL_CODE_FORMATS == ("explicit", "compact")
+def test_spatial_code_formats_is_explicit_only():
+    assert B.SPATIAL_CODE_FORMATS == ("explicit",)
     assert B.DEFAULT_SPATIAL_CODE_FORMAT in B.SPATIAL_CODE_FORMATS
 
 

tests/test_B/test_run.py

@@ -40,7 +40,7 @@ _FAKE_ROW = {
 }
 
 _FAKE_CODE_INFO = {
-    "protocol": "extended",
+    "protocol": "thinking",
     "spatial_code_format": "explicit",
     "input_selection": "selective",
     "frame_count": 64,
@@ -52,13 +52,12 @@ _FAKE_CODE_INFO = {
 
 def test_results_dir_for_matches_established_dimension_nesting():
     root = harness_run.results_dir_for(
-        "qwen3.5-4b", "extended", "compact", "metric", "tracking", "uniform", 32
+        "qwen3.5-4b", "thinking", "explicit", "metric", "tracking", "uniform", 32
     )
     assert root == (
         B.RESULTS_DIR
         / "qwen3.5-4b"
-        / "extended"
-        / "compact"
+        / "explicit"
         / "metric"
         / "tracking"
         / "uniform"
@@ -66,14 +65,14 @@ def test_results_dir_for_matches_established_dimension_nesting():
     )
 
 
-def test_results_dir_for_isolates_the_two_protocols():
+def test_results_dir_for_keeps_protocols_together():
     base = harness_run.results_dir_for(
-        "qwen3.5-4b", "base", "compact", "metric", "tracking", "uniform", 32
+        "qwen3.5-4b", "base", "explicit", "metric", "tracking", "uniform", 32
     )
     extended = harness_run.results_dir_for(
-        "qwen3.5-4b", "extended", "compact", "metric", "tracking", "uniform", 32
+        "qwen3.5-4b", "thinking", "explicit", "metric", "tracking", "uniform", 32
     )
-    assert base != extended
+    assert base == extended
 
 
 def test_results_dir_for_honors_explicit_override(tmp_path):
@@ -113,7 +112,7 @@ def test_build_record_preserves_every_field_untruncated():
     assert record["tracking"] == "tracking"
     assert record["spatial_code_path"] == _FAKE_CODE_INFO["spatial_code_path"]
     assert record["condition"] == "extended:explicit:metric:tracking:selective:64"
-    assert record["protocol"] == "extended"
+    assert record["protocol"] == "thinking"
     assert record["vision_input_shapes"] == {"mm_token_type_ids": [1, 2558]}
     assert record["generation_config"] == _FAKE_ANSWER["generation_config"]
     assert record["metric"] == "MRA:.5:.95:.05"
@@ -212,3 +211,21 @@ def test_run_strip_schema_legend_removes_only_the_legend(monkeypatch):
     assert results
     assert "spatial code schema" not in seen["prompt"]
     assert '"chair"' in seen["prompt"]
+
+
+def test_video_results_use_video_branch():
+    assert (
+        harness_run.results_dir_for(
+            "qwen3.5-4b", "thinking", "explicit", "metric", "tracking", "video", None
+        )
+        == B.RESULTS_DIR / "qwen3.5-4b" / "explicit" / "metric" / "tracking" / "video"
+    )
+
+
+def test_video_record_has_no_frame_count_in_condition():
+    info = dict(_FAKE_CODE_INFO, input_selection="video", frame_count=None)
+    record = harness_run._build_record(
+        _FAKE_ROW, "prompt", _FAKE_ANSWER, "metric", 1.0, "qwen3.5-4b", "/model", info
+    )
+    assert record["condition"] == "thinking:explicit:metric:tracking:video"
+    assert record["frame_count"] is None

tests/test_B/test_spatial_codes.py

@@ -33,16 +33,16 @@ def test_load_spatial_code_returns_dict_and_path(tmp_path, monkeypatch):
         spatial_codes, "spatial_code_path", lambda *a, **k: str(fixture)
     )
     code, path = spatial_codes.load_spatial_code(
-        "13c3e046d7", "metric", "selective", "tracking", 64, "compact"
+        "13c3e046d7", "metric", "selective", "tracking", 64, "explicit"
     )
     assert code == {"objects": {}, "room": {}}
     assert path == str(fixture)
 
 
-def test_spatial_code_path_includes_every_cache_axis():
+def test_spatial_code_path_uses_tracking_frames_hierarchy():
     path = spatial_codes.spatial_code_path(
         "scene-a", "metric", "selective", "tracking", 64, "explicit"
     )
     assert path.endswith(
-        "data/spatial codes/sam3+depth-anything-3/metric/tracking/selective/64/explicit/scene-a.json"
+        "data/spatial codes/sam3+depth-anything-3/tracking/frames/selective/64/explicit/scene-a.json"
     )

tests/test_B/test_sweep.py

@@ -9,15 +9,15 @@ from harness.B import sweep
 def test_build_plan_covers_every_combination():
     plan = sweep.build_plan(
         ["qwen3.5-2b", "qwen3.5-4b"],
-        ["explicit", "compact"],
+        ["explicit"],
         ["uniform", "selective"],
         [16, 32],
         ["metric"],
         ["tracking"],
     )
-    assert len(plan) == 2 * 2 * 2 * 2
+    assert len(plan) == 2 * 1 * 2 * 2
     assert ("qwen3.5-2b", "explicit", "metric", "tracking", "uniform", 16) in plan
-    assert ("qwen3.5-4b", "compact", "metric", "tracking", "selective", 32) in plan
+    assert ("qwen3.5-4b", "explicit", "metric", "tracking", "selective", 32) in plan
 
 
 def test_build_plan_sweeps_depth_and_tracking_too():
@@ -57,13 +57,6 @@ def test_build_plan_with_all_registered_models():
     assert len(plan) == len(vlm_models.available_models())
 
 
-def test_sweep_parser_rejects_unknown_spatial_code_format():
-    with pytest.raises(ValueError):
-        sweep._parse_csv_choice(
-            "bogus", ("explicit", "compact"), "--spatial-code-formats"
-        )
-
-
 def test_sweep_parser_rejects_unknown_depth():
     with pytest.raises(ValueError):
         sweep._parse_csv_choice("bogus", sweep.DEPTH_VARIANTS, "--depths")

tests/test_C/test_launch.py

@@ -37,39 +37,6 @@ def test_launch_skips_scene_already_fully_answered(tmp_path, capsys, monkeypatch
     assert "DONE: 1 ok, 0 failed" in output
 
 
-def test_launch_routes_overlay_to_overlay_result_tree(monkeypatch, capsys, tmp_path):
-    captured = {}
-
-    root = tmp_path / "unused-results"
-    scene_dir = root / "scene"
-    scene_dir.mkdir(parents=True, exist_ok=True)
-    (scene_dir / "1.json").write_text("{}")
-
-    class FakeRun:
-
-        def results_dir_for(*args, **kwargs):
-            captured["overlay"] = kwargs.get("overlay")
-            return root
-
-        def load_questions(scene=None):
-            return [{"id": 1}]
-
-    monkeypatch.setattr(launch, "_load_run_module", lambda: FakeRun)
-
-    launch.launch(
-        "qwen3.5-2b",
-        "explicit",
-        "uniform",
-        32,
-        ["scene"],
-        overlay=True,
-        strip_schema_legend=True,
-    )
-
-    assert captured["overlay"] is True
-    assert "DONE: 1 ok, 0 failed" in capsys.readouterr().out
-
-
 def test_launch_rebuild_forces_pending_even_when_answered(tmp_path, monkeypatch):
     scene = "scene-c"
     monkeypatch.setattr(launch, "_load_run_module", lambda: _FakeRun)

tests/test_C/test_prompts.py

@@ -57,3 +57,10 @@ def test_every_na_question_type_builds(question_type):
 def test_every_mca_question_type_builds(question_type):
     prompt = combined_prompts.build_prompt(_CODE, question_type, "q?", ["A. x", "B. y"])
     assert prompt.startswith(combined_prompts.PRE_PROMPT)
+
+
+def test_video_prompt_names_native_video():
+    prompt = combined_prompts.build_prompt(
+        _CODE, "object_counting", "How many chairs?", video=True
+    )
+    assert prompt.startswith("This is a video.\n")

tests/test_C/test_run.py

@@ -40,7 +40,7 @@ _FAKE_ROW = {
 }
 
 _FAKE_SOURCE_INFO = {
-    "protocol": "extended",
+    "protocol": "thinking",
     "spatial_code_format": "explicit",
     "input_selection": "selective",
     "frame_count": 64,
@@ -55,13 +55,12 @@ _FAKE_SOURCE_INFO = {
 
 def test_results_dir_for_matches_established_dimension_nesting():
     root = harness_run.results_dir_for(
-        "qwen3.5-4b", "extended", "compact", "metric", "tracking", "uniform", 32
+        "qwen3.5-4b", "thinking", "explicit", "metric", "tracking", "uniform", 32
     )
     assert root == (
         C.RESULTS_DIR
         / "qwen3.5-4b"
-        / "extended"
-        / "compact"
+        / "explicit"
         / "metric"
         / "tracking"
         / "uniform"
@@ -83,30 +82,6 @@ def test_results_dir_for_honors_explicit_override(tmp_path):
     assert root == tmp_path
 
 
-def test_results_dir_for_places_overlay_under_C_results():
-    root = harness_run.results_dir_for(
-        "qwen3.5-4b",
-        "extended",
-        "explicit",
-        "metric",
-        "tracking",
-        "uniform",
-        32,
-        overlay=True,
-    )
-    assert root == (
-        C.RESULTS_DIR
-        / "overlay"
-        / "qwen3.5-4b"
-        / "extended"
-        / "explicit"
-        / "metric"
-        / "tracking"
-        / "uniform"
-        / "32"
-    )
-
-
 def test_build_record_carries_both_frame_and_spatial_code_provenance():
     record = harness_run._build_record(
         _FAKE_ROW,
@@ -134,7 +109,7 @@ def test_build_record_carries_both_frame_and_spatial_code_provenance():
     assert record["answer_given"] == "4"
     assert record["vision_input_shapes"] == _FAKE_ANSWER["vision_input_shapes"]
     assert record["condition"] == "extended:explicit:metric:tracking:selective:64"
-    assert record["protocol"] == "extended"
+    assert record["protocol"] == "thinking"
     assert record["score"] == 1.0
 
 
@@ -155,36 +130,6 @@ def test_write_question_result_writes_one_json_file_per_question(tmp_path):
     assert on_disk == record
 
 
-def test_write_question_result_routes_overlay_default_to_overlay_tree(
-    tmp_path, monkeypatch
-):
-    monkeypatch.setattr(harness_run, "RESULTS_DIR", tmp_path)
-    source_info = {**_FAKE_SOURCE_INFO, "overlay": True}
-    path, _record = harness_run.write_question_result(
-        _FAKE_ROW,
-        "full prompt text",
-        _FAKE_ANSWER,
-        "MRA:.5:.95:.05",
-        1.0,
-        "qwen3.5-4b",
-        "/root/models/qwen3.5-4b",
-        source_info,
-    )
-    assert path == (
-        tmp_path
-        / "overlay"
-        / "qwen3.5-4b"
-        / "extended"
-        / "explicit"
-        / "metric"
-        / "tracking"
-        / "selective"
-        / "64"
-        / "scene0001_00"
-        / "7.json"
-    )
-
-
 def test_build_record_carries_reasoning_fields_when_forced():
     extended_answer = {
         **_FAKE_ANSWER,
@@ -211,3 +156,21 @@ def test_build_record_carries_reasoning_fields_when_forced():
     )
     assert record["forced"] is True
     assert record["forced_input_token_count"] == 22300
+
+
+def test_video_results_use_video_branch():
+    assert (
+        harness_run.results_dir_for(
+            "qwen3.5-4b", "thinking", "explicit", "metric", "tracking", "video", None
+        )
+        == C.RESULTS_DIR / "qwen3.5-4b" / "explicit" / "metric" / "tracking" / "video"
+    )
+
+
+def test_video_record_has_no_frame_count_in_condition():
+    info = dict(_FAKE_SOURCE_INFO, input_selection="video", frame_count=None)
+    record = harness_run._build_record(
+        _FAKE_ROW, "prompt", _FAKE_ANSWER, "metric", 1.0, "qwen3.5-4b", "/model", info
+    )
+    assert record["condition"] == "thinking:explicit:metric:tracking:video"
+    assert record["frame_count"] is None

tests/test_C/test_sweep.py

@@ -9,15 +9,15 @@ from harness.C import sweep
 def test_build_plan_covers_every_combination():
     plan = sweep.build_plan(
         ["qwen3.5-2b", "qwen3.5-4b"],
-        ["explicit", "compact"],
+        ["explicit"],
         ["uniform", "selective"],
         [16, 32],
         ["metric"],
         ["tracking"],
     )
-    assert len(plan) == 2 * 2 * 2 * 2
+    assert len(plan) == 2 * 1 * 2 * 2
     assert ("qwen3.5-2b", "explicit", "metric", "tracking", "uniform", 16) in plan
-    assert ("qwen3.5-4b", "compact", "metric", "tracking", "selective", 32) in plan
+    assert ("qwen3.5-4b", "explicit", "metric", "tracking", "selective", 32) in plan
 
 
 def test_build_plan_sweeps_depth_and_tracking_too():
@@ -57,34 +57,6 @@ def test_build_plan_with_all_registered_models():
     assert len(plan) == len(vlm_models.available_models())
 
 
-def test_sweep_forwards_overlay_to_each_launch(monkeypatch):
-    calls = []
-    monkeypatch.setattr(
-        sweep.harness_launch, "launch", lambda *args, **kwargs: calls.append(kwargs)
-    )
-
-    sweep.sweep(
-        ["qwen3.5-2b"],
-        ["explicit"],
-        ["uniform"],
-        [32],
-        ["scene"],
-        overlay=True,
-        strip_schema_legend=True,
-    )
-
-    assert len(calls) == 1
-    assert calls[0]["overlay"] is True
-    assert calls[0]["results_dir"] is None
-
-
-def test_sweep_parser_rejects_unknown_spatial_code_format():
-    with pytest.raises(ValueError):
-        sweep._parse_csv_choice(
-            "bogus", ("explicit", "compact"), "--spatial-code-formats"
-        )
-
-
 def test_sweep_parser_rejects_unknown_depth():
     with pytest.raises(ValueError):
         sweep._parse_csv_choice("bogus", sweep.DEPTH_VARIANTS, "--depths")

tests/test_F/test_sweep.py

@@ -12,38 +12,3 @@ def test_csv_expands_all_dedups_and_rejects_unknowns():
         sweep._csv("c", ("a", "b"))
 
 
-def test_main_routes_ground_truth_without_perception_axes(monkeypatch, capsys):
-    calls = []
-    monkeypatch.setattr(sweep.harness_run, "SOURCES", ("ground truth",))
-    monkeypatch.setattr(
-        sweep.symbolic_run, "SPATIAL_CODE_FORMATS", ("compact", "explicit")
-    )
-    monkeypatch.setattr(sweep.symbolic_run, "DEPTH_VARIANTS", ("metric",))
-    monkeypatch.setattr(sweep.symbolic_run, "TRACKING_MODES", ("tracking",))
-    monkeypatch.setattr(sweep.symbolic_run, "INPUT_SELECTIONS", ("uniform",))
-    monkeypatch.setattr(
-        sweep.harness_run,
-        "run",
-        lambda *args, **kwargs: calls.append((args, kwargs)) or [{"score": 1.0}],
-    )
-    monkeypatch.setattr(
-        "sys.argv",
-        [
-            "sweep",
-            "--sources",
-            "ground truth",
-            "--spatial-code-formats",
-            "all",
-            "--scenes",
-            "s1,s1,s2",
-        ],
-    )
-
-    sweep.main()
-
-    assert [call[0][:6] for call in calls] == [
-        ("ground truth", "compact", "metric", "tracking", "uniform", 32),
-        ("ground truth", "explicit", "metric", "tracking", "uniform", 32),
-    ]
-    assert all(call[1]["scenes"] == ["s1", "s2"] for call in calls)
-    assert "ground truth compact" in capsys.readouterr().out

tests/test_analysis/conftest.py

@@ -37,8 +37,6 @@ def vlm(letter, qid=1, score=1.0, protocol="base", model="m", frames=32):
             depth="metric",
             tracking="tracking",
         )
-    elif letter == "D":
-        r["spatial_code_format"] = "explicit"
     return r
 
 

tests/test_analysis/test_letters_reports.py

@@ -13,20 +13,6 @@ class TestLettersReports(ReportTestCase):
             {"A_report.json", "C_report.json", "AC_report.json"},
         )
 
-    def test_DF_and_BF_semantic_alignment(self):
-        d = self.directory("D", [vlm("D")])
-        f = self.ground_truth_symbolic()
-        result = letters_reports.generate(
-            {"D": d, "F": f}, ["base"], output_dir=self.root / "df"
-        )
-        self.assertEqual(len(result["combined_report"]["cross_harness_comparisons"]), 1)
-        b = self.directory("B", [vlm("B")])
-        perceived = self.symbolic(False)
-        result = letters_reports.generate(
-            {"B": b, "F": perceived}, ["base"], output_dir=self.root / "bf"
-        )
-        self.assertEqual(len(result["combined_report"]["cross_harness_comparisons"]), 1)
-
     def test_folded_statistical_and_solver_helpers(self):
         self.assertEqual(
             letters_reports.holm_bonferroni({"a": 0.01, "b": 0.04, "c": 0.03}),

tests/test_encoder/test_run.py

@@ -5,3 +5,20 @@ from encoder import run
 
 def test_cache_or_load_exposes_explicit_dimensions():
     assert "frame_count" in run.cache_or_load.__code__.co_varnames
+
+
+def test_video_mode_preserves_depth_and_tracking():
+    assert run._effective_dimensions("relative", None, "tracking", True) == (
+        "relative",
+        "video",
+        "tracking",
+    )
+
+
+def test_video_mode_selects_caches_for_requested_axes(tmp_path, monkeypatch):
+    monkeypatch.setattr(run.config, "CACHE_ROOT", tmp_path)
+    da3_path, sam3_path = run._cache_source_paths(
+        "scene", "relative", "video", "tracking", 32, True, None, None
+    )
+    assert da3_path.endswith("depth-anything-3/relative/video/scene.npz")
+    assert sam3_path.endswith("sam3/tracking/video/scene.pkl.gz")