Add files using upload-large-folder tool

experiments/EXPERIMENT FINDINGS.md

@@ -1,8 +1,22 @@
 # Experiment Findings
 
-This report summarizes every completed hypothesis currently recorded under
-`experiments/results/symbolic/metric/tracking/uniform`. Unless stated otherwise, experiments use
-metric depth, tracking masks, uniform input, and 64 frames. Scores are percentages.
+This report merges every completed hypothesis recorded under `experiments/results/symbolic`
+against **both** spatial-code schemas produced by `encoder/geometric.py`: the **original**
+schema (Part 1) and the **compact** schema (Part 2). The two parts are kept as distinct sections
+rather than fully interleaved because the compact adapter's own math (instance consolidation,
+distance-table construction, `symbolic/adapters.py`) is a different surface area from the
+original schema's encoder path, even though both are produced by the same `encoder/geometric.py`
+and — as of this session's refactor — the original schema is now a **strict, provably-derivable
+subset of the compact schema** (see `encoder/geometric.py::build_original_spatial_code`).
+
+Scores throughout are percentages from `symbolic`'s own official VSI-Bench scorer.
+
+---
+
+# Part 1 — Original spatial-code schema
+
+Unless stated otherwise, experiments in this part use metric depth, tracking masks, uniform
+input, and 64 frames.
 
 ## Baselines
 
@@ -108,7 +122,7 @@ answer functions rather than forcing one representative policy onto every task.
 6. Relative direction and appearance order: retain the 64-frame baseline until a targeted
    hypothesis improves them.
 
-## Overall conclusions
+## Overall conclusions (Part 1)
 
 - Sixty-four frames are the best default compromise across categories.
 - Different question categories require different geometry policies. Improvements in relative
@@ -123,14 +137,14 @@ answer functions rather than forcing one representative policy onto every task.
 - Route planning remains at zero across these runs and needs parser/symbolic-execution work rather
   than geometric-distance tuning.
 
-## Reproducibility
+## Reproducibility (Part 1)
 
 Each row above comes from its saved `_summary.json`. Spatial codes are under
 `experiments/caches/spatial codes`, symbolic results are under `experiments/results/symbolic`,
 and the corresponding modified geometry implementations are under `experiments/hypotheses`.
 The experiment test suite passed with 35 tests after the latest hypothesis additions.
 
-## Exact hypothesis index
+## Exact hypothesis index (Part 1)
 
 The following are the exact hypothesis names used by the launcher and results directories:
 
@@ -160,3 +174,867 @@ The following are the exact hypothesis names used by the launcher and results di
 - `Require Object Count Peaks to Persist Across Frames`
 - `Select Distance Instances Using Centroid Stability Across Frames`
 - `Select Representative Instances Using Track Persistence` (evaluated at 32, 64, and 96 frames)
+
+---
+
+# Part 2 — Compact spatial-code schema
+
+Unless stated otherwise, experiments in this part use metric depth, tracking masks, selective
+input; scores are percentages from `symbolic`'s own official VSI-Bench scorer (see Infrastructure
+below for exactly how each number was produced).
+
+## Baseline
+
+The production baseline (`/workspace/results/symbolic/metric/tracking/selective/<frames>/compact/`,
+outside the experiments sandbox) reflects `symbolic/solver.py` as of this session, which already
+includes three targeted solver-side fixes made before this report existed:
+
+- `object_size_estimation`: use the max "longest dimension" across all tracked instances of a
+  class, not just instance 0 (a partial/occluded view can only underestimate true size).
+- `route_planning`: fixed a regex bug that let the last "Go forward" step's target name swallow
+  trailing sentence text, and added a fallback that uses the question's stated final destination
+  as an implicit last waypoint.
+- `object_abs_distance`: take `max(closest-classes-table value, a center-distance-minus-half-
+  dimensions estimate)` instead of the table value alone -- the table's min-across-every-instance-
+  pair definition lets one noisy/mislocalized instance drag a specific named pair's distance
+  toward zero.
+- `object_abs_distance` missing-detection fallback (added later this session -- see "The
+  breakthrough" below): when either named object was never detected, answer with the room's own
+  expected random-point distance instead of returning None (a guaranteed hard zero).
+
+| Frames | Overall | Counting | Abs. distance | Object size | Room size | Rel. distance | Rel. direction | Appearance order | Route planning |
+|---:|---:|---:|---:|---:|---:|---:|---:|---:|---:|
+| 32 | 46.28 | 49.43 | 59.57 | 46.30 | 55.69 | 58.10 | 48.49 | 52.63 | 0.00 |
+| 64 | **48.02** | 49.64 | **60.38** | 48.70 | 57.36 | 57.54 | 50.68 | **59.87** | 0.00 |
+
+(Baseline before the missing-detection fallback: abs. distance 51.87 / 53.16, overall 45.31 /
+47.12 at 32 / 64 frames.)
+
+64 frames is the better default here too, same as the original-schema baseline table in Part 1.
+`route_planning` is 0% in every compact-schema run tried this session, regardless of
+depth/tracking/input/frames -- traced to two causes, neither fixable by more solver-side formula
+tuning: ~86% of available route-planning questions reference at least one object never detected
+in that scene at all (upstream detection-coverage gap), and the remaining handful hit two genuine
+chained-turn-algorithm gaps (two consecutive "[please fill in]" steps with no intervening
+waypoint; a route ending on "[please fill in]" whose only remaining target is the question's
+*stated* destination, not a named step).
+
+## Numeric (MRA) question follow-up: never-None fallbacks and the credit-band map
+
+After the `object_abs_distance` breakthrough (see "The breakthrough" section below), the same
+"a hard zero is the worst possible answer" lens was applied to the other numeric types, plus a
+map of where each numeric type's answers fall relative to the official scorer's credit bands.
+
+The MRA scorer (`mean_relative_accuracy`) grades purely on the ratio `r = pred / ground_truth`:
+credit only when `r` is within [0.5, 1.5], scaling to full credit at [0.95, 1.05]. Mapping our
+64-frame answers into those bands:
+
+| Type | median ratio | zero (r<0.5) | partial | full (0.95-1.05) | zero (r>1.5) |
+|---|---:|---:|---:|---:|---:|
+| object_counting | 1.000 | 7% | 47% | 37% | 9% |
+| room_size_estimation | 0.815 | 11% | 75% | 11% | 3% |
+| object_size_estimation | 0.779 | 12% | 77% | 7% | 4% |
+
+`object_counting` is already well-centered on 1.0 -- no systematic bias to exploit, it is as
+good as detection quality allows. `object_size` and `room_size` are both systematically biased
+LOW (medians 0.78/0.82): their entire partial-credit mass sits below 1.0, and 12%/11% score a
+hard zero purely from `r < 0.5`. Shifting those distributions upward -- structurally, without a
+fitted constant -- is the lever.
+
+Solver-only numeric fallbacks shipped in `symbolic/solver.py` (each uses only scene-derived
+data, never a dataset-fitted constant):
+- `object_size_estimation`: when the asked-about class was never detected, answer the scene's
+  own median object longest-dimension instead of None (its size is unknown; a typical object of
+  THIS room is the least-assuming estimate). Recovered 16 previously-unanswered questions ->
+  object_size 46.30/48.70 -> **47.65/49.96** (32f/64f).
+
+## Encoder (geometric.py) hypotheses
+
+| Hypothesis | Frames | Overall | Counting | Abs. distance | Object size | Finding |
+|---|---:|---:|---:|---:|---:|---|
+| Size Compact Boxes By Fullest Observed Extent (max) | 32 | 48.72 | 49.43 | 59.00 | 51.72 | Size +4, but drops distance. |
+| Size Compact Boxes By Fullest Observed Extent (max) | 64 | 49.63 | 49.64 | 58.80 | 55.34 | Size +5.4, but distance falls below 60. |
+| Size Compact Boxes By High Observed Extent Percentile (0.90) | 32 | 48.63 | 49.43 | 59.38 | 51.22 | **ADOPTED** -- size +3.6, distance ~flat. |
+| Size Compact Boxes By High Observed Extent Percentile (0.90) | 64 | 49.76 | 49.64 | 60.05 | 54.62 | **ADOPTED** -- size +4.7, distance holds >=60. |
+| Retain All Consolidated Track Instances Regardless Of Peak | 32 | 44.40 | 43.00 | 50.86 | 47.52 | Rejected -- see below. |
+| Retain All Consolidated Track Instances Regardless Of Peak | 64 | 45.95 | 40.29 | 52.49 | 49.58 | Rejected -- see below. |
+
+**Size Compact Boxes By High Observed Extent Percentile (ADOPTED, shipped to production
+`encoder/geometric.py`):** `_compact_oriented_box` aggregates each axis's per-observation
+extents across frames. The old choice was the 75th percentile; a partial/occluded/foreshortened
+view can only ever measure a SMALLER extent along an axis than the truth, never larger, so among
+views already confirmed mutually consistent (same object/pose, by the existing MAD filter) the
+fuller views are the more complete ones, and the 75th percentile systematically discards them.
+Raising it to a high percentile recovers that lost extent -- the same "a partial view
+underestimates true extent" principle as the solver's max-across-INSTANCES size fix, one level
+deeper (across OBSERVATIONS within one instance), and matching the original-schema research's
+proven-best "max across frames" result (Part 1). No fitted constant: it is a percentile choice,
+not a scale multiplier tuned to the answer key.
+
+The box is SHARED by `object_size` and `object_abs_distance`, and growing it shrinks
+surface-to-surface gaps -- so this is a genuine two-category tradeoff. The absolute max (1.0
+quantile) maximizes size (55.34 at 64f) but drops abs_distance below its hard-won 60 ceiling
+(58.80). The **0.90 quantile** is the balance point: it recovers nearly all the size gain (54.62
+at 64f) while keeping abs_distance above 60 (60.05), and its overall (49.76) actually beats the
+max's (49.63). Chosen deliberately over max for that reason.
+
+**Retain All Consolidated Track Instances Regardless Of Peak** (`encoder/geometric.py`'s
+`_consolidate_compact_instances()`, which every compact-format build goes through): the function
+caps each class's retained instance count at `peak` co-visibility -- "max distinct masklets SAM3
+tracks simultaneously in any one frame" (a per-frame number), not the total count of distinct
+physical objects across the whole video. In a large or crowded scene where the camera never frames
+every instance of a class at once (e.g. a classroom with dozens of chairs), this silently discards
+real, well-evidenced tracked instances beyond the peak count -- a clean match for observed
+`object_counting` undercounts as large as engine=6 vs ground_truth=47 for `chair`.
+
+The hypothesis: remove the cap entirely, retaining every group that survives the existing
+IoU-based duplicate-track merge (`_compact_duplicate_groups`, >=0.8 box overlap).
+
+**Result: regression, both frame counts.** `object_counting` got *worse*, not better --
+overcounts roughly doubled (32f: 26->54; 64f: 39->64) while undercounts fell by less than that,
+for a net accuracy drop (~49% -> 43%/40%). The IoU-overlap merge alone isn't sufficient to catch
+every duplicate/fragmented re-detection of the SAME physical object (e.g. the same static chair
+re-acquired from a different angle after brief occlusion, producing a track whose box doesn't
+spatially overlap the earlier one enough to trigger the merge) -- the peak cap was doing real,
+load-bearing work suppressing exactly those cases, and removing it swapped an undercount bias for
+a worse overcount bias. Every other numeric category shifted by roughly the amount expected from
+noisier instance sets, with no net win. **Change was reverted in `encoder/geometric.py`** (the
+production file); this hypothesis file preserves it as a rejected, reproducible experiment.
+
+If this is revisited, the more promising angle is probably tightening/extending
+`_compact_duplicate_groups`'s duplicate-detection itself (e.g. a secondary check for
+same-class tracks with disjoint frame ranges and centroid distance under some
+scene-relative threshold) rather than removing the peak backstop outright -- that would let
+genuinely-distinct instances through without also losing peak's protection against
+re-acquisition duplicates.
+
+**Merge Same-Class Instances With Contained Centers (REJECTED):** the opposite direction --
+tighten `_compact_duplicate_groups` to ALSO merge two same-class instances when one box's
+center lies inside the other (physically, two distinct rigid same-class objects can't
+interpenetrate). Motivated by a real signal: the counting ground-truth comparison
+(thinking-in-space `object_counts`) showed 25% of class-counts overcount (ratio > 1.5), and 56
+of 92 overcounted cases had two "distinct" instances closer than the object's own size (an oven
+counted 4x with 6cm-apart centers, a tv split in two 5cm apart) -- clear fragmentation the
+0.8-overlap test misses.
+
+Result: **counting REGRESSED, 49.43 -> 43.71 (32f).** The problem is that counting was already
+well-centered on ratio 1.0 (median), with the 25% overcount balanced by an equal mass of
+correct/under counts; any merge rule pushes ALL counts DOWN, so it turns more correct counts
+into undercounts than it fixes overcounts -- and the AABB center-containment test, being on
+loose axis-aligned boxes, over-fires on genuinely-distinct-but-close objects. Same delicate
+balance lesson as the peak-cap experiment: `object_counting` (median ratio 1.000, 37% full
+credit) is at the ceiling detection/tracking quality allows, and neither loosening nor
+tightening instance-merging improves it. Not adopted.
+
+### Room-area hypotheses
+
+Ground-truth comparison: `thinking-in-space/data/meta_info/{arkitscenes,scannet,scannetpp}_meta_info_val.json`
+carries a real `room_size` (and `object_bbox`) per scene. Comparing our compact-schema floor
+area directly against it across all 72 matched metric/tracking/selective scenes: mean ratio
+(ours/ground-truth) 0.843, median 0.817 -- a consistent, one-directional undershoot, not
+scattered noise (unlike the `object_abs_distance` comparison below, which showed no clean
+global bias).
+
+| Hypothesis | Frames | Overall | Room size | Finding |
+|---|---:|---:|---:|---|
+| Increase Compact Room Floor Area by 20 Percent | 32 | 46.60 | 65.97 | Works, but see caveat below. |
+| Increase Compact Room Floor Area by 20 Percent | 64 | 47.69 | 61.94 | Works, but see caveat below. |
+| Extend Compact Floor Coverage To Every Object Footprint | 32 | 46.17 | **62.50** | Preferred -- structural, no fitted constant. |
+| Extend Compact Floor Coverage To Every Object Footprint | 64 | 47.54 | **60.69** | Preferred -- structural, no fitted constant. |
+
+**Increase Compact Room Floor Area by 20 Percent** scales the reconstructed floor polygon
+outward from its own centroid by `sqrt(1.20)` linearly (so area increases by exactly 1.20x),
+in `_compact_floor_boundary_polygons`. It works, and 1.20 wasn't picked arbitrarily -- it's
+close to both the measured mean and median ground-truth ratio above. **But this IS calibration
+to this dataset's measured bias, not a structural fix**, flagged explicitly per user
+direction: the exact 0.817-0.843 ratio is a property of THIS specific set of 72 scenes' camera
+coverage, frame sampling, and depth/segmentation quality -- it has no reason to transfer to a
+different scene distribution, camera pattern, or model. Keeping it recorded as a working,
+reproducible data point, but not adopting it as the default; future room-area work should
+prefer structural fixes like the one below.
+
+**Extend Compact Floor Coverage To Every Object Footprint** takes a different, self-referential
+approach: rasterize every detected object's own (u, v)-projected footprint as floor coverage,
+unioned with the real observed floor points before the existing close/fill/contour pipeline
+runs, in the same `_compact_floor_boundary_polygons`. No external constant -- it uses only this
+scene's own already-computed object point clouds (a physical necessity: any object resting in
+the room occupies floor area at and around its footprint, which is often exactly what
+depth/segmentation misses since the object occludes the very floor beneath it). Single-scene
+check (`scene0699_00`, ground truth 20.44 m^2): baseline 9.32 -> footprint-union 10.70 (+14.8%,
+still well short of ground truth for that one scene -- this only recovers occlusion-shadowed
+floor, not floor area the camera never observed at all).
+
+**Result across all 72 scenes: room_size crosses into the 60s at both frame counts** (62.50 at
+32f, 60.69 at 64f) -- smaller than the fitted 20% version's 65.97/61.94, but a real, structural
+gain (+6.8/+3.3 points over baseline) with no dataset-specific constant, and `overall` improves
+too with no offsetting regression. **ADOPTED -- shipped to production `encoder/geometric.py`**
+(the footprint-union rasterization is now in `_compact_floor_boundary_polygons`); the 20%-scale
+version stays recorded above only as a data point, not adopted.
+
+**Rejected room alternatives (batch-screened on 64f, all WORSE than the shipped footprint-union
+60.69):** "Estimate Room Area From Convex Hull Of Coverage" (room 54.31) and "Estimate Room Area
+From Oriented Bounding Rectangle Of Floor" (room 48.89) both OVERSHOOT -- the convex hull fills
+real concavities but also invents area across L-shaped rooms, and the oriented rectangle assumes
+a rectangularity real rooms don't have (and footprints poking out inflate the rectangle). Room
+area is credited by the same ratio-in-[0.5,1.5] band as everything else, so overshooting to
+ratio > 1.5 scores hard zeros on large rooms -- worse than the footprint-union's mild remaining
+undershoot. "Bridge Unobserved Floor With Room Scale Close" (scene-relative morphological close
+kernel) left room unchanged at 60.69 (the fill-holes step already handles what it would). Room
+size is effectively solved for this pipeline; its residual undershoot (ratio ~0.82) is
+unobserved floor the camera never saw, not something a boundary-shape change recovers.
+
+### Object-size / box-extent hypotheses (batch, 64f screen)
+
+A batch of principled box-fitting changes, all forked from current production geometric.py
+(0.90 across-observation quantile + footprint room). Baseline 64f: overall 50.20, size 54.62,
+abs_distance 60.19.
+
+| Hypothesis | overall | size | abs_distance |
+|---|---:|---:|---:|
+| Size Compact Boxes By Full Per Frame Extent (0/100) | **50.86** | **61.18** | 56.46 |
+| Size Compact Boxes By Fuller Per Frame Extent (1/99) | 50.58 | 57.90 | 59.38 |
+| Orient Compact Boxes By Minimum Area Rectangle | 50.17 | 54.62 | 60.48 |
+| (baseline: 2/98 per-frame) | 50.20 | 54.62 | 60.19 |
+
+The per-observation extent uses a 2nd/98th percentile trim per frame. Widening it to 1/99 or
+min/max recovers real extent a partial view can only under-measure (principled, not tuned) --
+and size responds strongly (54.62 -> 61.18 at full min/max, i.e. ratio ~0.95, essentially
+correct). But the box is shared with abs_distance, and wider boxes shrink surface gaps, so
+distance falls (60.19 -> 56.46). This is the SAME size<->distance tension as the 0.90-vs-max
+across-frame quantile, now confirmed on the per-frame axis too: overall keeps RISING as boxes
+widen (size gains outrun distance losses), best at full min/max (50.86), but it trades the
+abs_distance-60 milestone. Min-area-rectangle orientation is ~neutral (SVD principal axes and
+the min-area box barely differ for real furniture footprints).
+
+**The decoupling answer -- Recover Length Axis Keep Robust Width Depth:** the size<->distance
+tension has a clean structural resolution once you notice the two questions read DIFFERENT
+things from the same box. `object_size` reads only the LONGEST dimension (one axis).
+`object_abs_distance` reads the whole box SURFACE (all three axes), and neighbouring objects sit
+mostly to an object's SIDES (its short width/depth axes). Full-extent recovery inflates all
+three axes -- fixing size but fattening the box exactly where it hurts distance. So: size each
+axis ROBUSTLY (0.90 of the 2/98-trimmed extents, production's distance-faithful box), then
+recover full observed extent (min/max per frame) on the SINGLE longest axis only. No fitted
+constant -- full extent on the length axis, robust extent on the others; which axis is "longest"
+is the object's own geometry.
+
+| Variant (64f) | overall | size | abs_distance |
+|---|---:|---:|---:|
+| baseline | 50.20 | 54.62 | 60.19 |
+| full extent, all axes | 50.86 | 61.18 | 56.46 |
+| full extent + 0.75 across | 50.89 | 58.66 | 58.66 |
+| **length-axis only (ADOPTED, shipped)** | **51.02** | **61.30** | **59.52** |
+
+It captures the FULL size gain (61.30, matching all-axes full extent, size ratio ~0.95) while
+cutting the distance loss from -3.73 to just -0.67 -- best overall of every box variant tried,
+and abs_distance barely moves. This is the principled decoupling the whole frontier was pointing
+at. **Shipped to production `encoder/geometric.py`** (`_compact_oriented_box` now recovers full
+observed extent on the longest axis only). Confirmed at both frame counts: 32f size 51.22 ->
+59.79, 64f size 54.62 -> 61.30, abs_distance -0.7 at both, overall +0.98 / +0.82.
+
+**Follow-up box-fitting batch (64f screen, baseline now 51.02 / size 61.30 / dist 59.52).** After
+the length-axis fix, size is median ratio 0.946 (near-centered) but its spread is wide (only 19%
+in the full-credit [0.95,1.05] band, 47% still low in [0.5,0.95)); the remaining size headroom is
+fit TIGHTNESS, not extent, and distance's residual is box-center / instance noise. Five box
+changes screened:
+
+| Hypothesis | overall | size | abs_distance |
+|---|---:|---:|---:|
+| Fuller Robust Box By One Ninetynine Per Frame | 51.07 | 61.43 | 58.66 |
+| Tighten Box Observation Consistency Filter (2.0 MAD) | 51.05 | 60.80 | 60.62 |
+| Recover Longest Two Axes To Full Extent | 50.88 | 61.51 | 57.66 |
+| Recover Length Axis To Full Max | 50.82 | 61.64 | 58.66 |
+| Center Compact Boxes On Point Cloud Median | 49.48 | 61.30 | 51.63 |
+
+All box-fitting gains are noise-level (+0.03 to +0.07 overall) EXCEPT one instructive failure and
+one useful property: (1) centering the box on the raw point-cloud median instead of the median of
+per-frame midpoints CRASHES distance (51.63) -- the per-frame-midpoint center is genuinely good,
+the raw point median is pulled by dense partial views; (2) tightening the MAD consistency filter
+to 2.0 sigma restores abs_distance ABOVE 60 (60.62) at a small size cost -- cleaner boxes, better
+distance. Recovering a second axis or pushing the longest axis to the absolute max both buy a
+little more size but cost distance (they widen the box toward side neighbours), confirming the
+length-axis-only decoupling was already at the right operating point. The box representation is
+near its quality ceiling; further numeric gains need a different lever than box-fit tuning.
+
+**Extend Box Height To Floor Contact (REJECTED, failed hard):** a floor-standing object's true
+bottom is at the floor, and its bottom is commonly occluded, so height (often the longest
+dimension for tall furniture) is under-measured -- the idea was to drop each box's bottom to the
+floor. Result: overall 51.02 -> 47.82, size 61.30 -> 50.13, abs_distance 59.52 -> 51.24 -- both
+crashed. The floor-contact prior is wrong for the many objects that legitimately have raised
+bottoms (wall-mounted TVs, whiteboards, mirrors, ceiling lights, pictures); clamping their
+height to the floor wildly over-inflates it, and since object_size reads the LONGEST dimension,
+the over-inflated height turns correct sizes into >1.5 overestimates (hard zeros), collapsing
+size. The taller boxes also overlap floor-level neighbours, collapsing distance. A physical
+prior that only holds for a subset, applied unconditionally, does more harm than good.
+
+### Point-cleaning and floor-clip batch (64f screen) -- two clean wins
+
+After box-fitting plateaued, the untapped geometric.py levers were the POINT CLEANING boxes are
+fit from and the FLOOR-POINT clip. Screened on 64f (baseline 51.02 / size 61.30 / dist 59.52 /
+room 60.69):
+
+| Hypothesis | overall | size | dist | room |
+|---|---:|---:|---:|---:|
+| **Keep More Floor Extent By Wider Clip (0.1/99.9)** | **51.30** | 61.30 | 59.52 | **62.92** |
+| Tighter Statistical Outlier Removal (1.5 sigma) | 51.11 | 61.55 | 59.62 | 60.69 |
+| Trim Mask Bleed By Centroid Distance | 51.01 | 61.47 | 59.19 | 60.83 |
+| Clean Box Points At Sixtieth Confidence | 50.30 | 62.27 | 58.85 | 60.69 |
+| **combined (wider clip + tighter SOR, ADOPTED)** | **51.39** | **61.55** | **59.62** | **62.92** |
+
+Two clean, no-downside wins: (1) the floor-point clip discarded the 0.1-0.5% and 99.5-99.9%
+tails as "outliers," but those are REAL observed floor and room area undershoots, so keeping them
+(0.1/99.9) recovers room 60.69 -> 62.92 with nothing else touched; (2) tighter statistical
+outlier removal (1.5 vs 2.0 sigma) on the box points yields cleaner boxes -- small consistent
+size + distance gains. They are independent (floor rasterization vs box-point cleaning) and STACK
+exactly: combined overall 51.02 -> 51.39, every numeric category up or flat, none down. **Shipped
+to production.** The two losers are instructive: trimming bleed by centroid distance barely helps
+(the per-frame 2/98 box percentiles already trim tails), and cutting confidence at the 60th
+percentile OVER-cleans -- it lifts size (smaller, tighter boxes read as more accurate on the
+longest axis) but shrinks boxes enough to hurt distance, netting worse.
+
+**Size confirmed at ceiling from BOTH sides (view-union + solver-selection tests).** Two more
+size probes: (1) recovering the longest axis from the UNION of all clean points (all views
+combined) instead of the fullest single frame -- if the low tail were "frame A sees one end,
+frame B the other," the union would recover it. It did NOT (size 61.55 -> 61.72 robust / 61.34
+full, and distance dropped ~1.5 as the union picked up cross-frame bleed on the long axis). So
+the size low tail is objects NEVER fully observed even across all frames combined (a table
+extending out of frame in every view) -- a true coverage limit, not a fitting one. (2) The
+solver's max-across-instances size selection is already optimal: simulated max 64.28 vs primary
+62.97 vs median 59.19 vs p75 63.11 (64f, answerable subset) -- max's overcount cost (7
+multi-instance cases where it picks an inflated fragment) is outweighed by the many more
+partial-view undercounts it rescues. Neither the geometry side nor the solver side has size
+headroom left.
+
+### Room floor-extraction refinements (64f screen) -- the grazing-gap bridge
+
+Room was still median ratio 0.897 (39 of 72 in the low band) after footprint-union + wider clip.
+Two floor-extraction refinements screened (baseline room 62.92):
+
+| Hypothesis | overall | room | dist |
+|---|---:|---:|---:|
+| **Bridge Floor To Wall Grazing Gap (5x5 dilate)** | **51.73** | **65.56** | 59.71 |
+| Keep Smaller Observed Floor Patches (min-region 3x3) | 51.42 | 63.19 | 59.62 |
+| combined | 51.73 | 65.56 | 59.76 |
+
+**Bridge Floor To Wall Grazing Gap (ADOPTED, shipped).** Floor depth samples thin out toward
+walls (grazing incidence) and stop ~2 cells short of them, so the reconstructed floor region
+falls systematically short of the true wall-to-wall room -- a real, non-coverage component of the
+undershoot. Enlarging the final closing dilation from 3x3 to 5x5 bridges that gap: room 62.92 ->
+65.56, overall +0.34, nothing else touched (distance even +0.09). The 5x5 (2-cell = 0.2 m border)
+is NOT a tuned magnitude -- the grazing gap is a fixed ~0.2 m physical distance that does not
+scale with room size, so a constant border is the principled choice. Keeping smaller floor
+patches (loosening the 0.49 m^2 min-region filter) helps a little alone but is redundant once the
+bridge dilation reconnects them, so only the bridge was shipped.
+
+### Absolute-distance: the short-axis decoupling (the distance answer)
+
+A precise error decomposition finally located the structure. After all the box/size fixes,
+object_abs_distance was 130 under vs 48 over (median our/GT ratio 0.916) -- a real UNDER-estimate.
+Isolating box quality from selection (our closest-classes table vs GT computed with the SAME
+min-over-instance-pairs selection) gave median 0.908 / mean 0.815: **it is NOT primarily a
+selection problem -- our boxes themselves produce distances ~9-18% too small.** The boxes puff
+toward neighbours (mask-bleed on the side surfaces), so objects read closer than they are.
+
+The fix is the mirror image of the size fix, and uses the SAME decoupling: `object_size` reads
+only the LONGEST axis; `object_abs_distance`'s surface gaps are governed by the SHORT (width/
+depth) axes -- neighbours sit to an object's sides. So TIGHTEN the short axes toward the object
+core (a lower across-frame quantile than the 0.90 the length-axis fix left them at), which widens
+the surface gaps and corrects the under-estimate, WITHOUT touching size (it doesn't read those
+axes). Screened on 64f:
+
+| Short-axis quantile | overall | abs_distance | size |
+|---|---:|---:|---:|
+| 0.90 (baseline) | 51.73 | 59.71 | 61.55 |
+| 0.75 | 51.94 | 60.24 | 61.60 |
+| 0.60 | 51.87 | 60.67 | 61.18 |
+| 0.50 | 51.83 | 61.20 | 60.88 |
+
+Distance rises monotonically as the short axes tighten (up to +1.5 at 0.50), crossing back above
+60. The small size cost at 0.50 was only because tightening the shared `argmax` flipped which
+axis counts as "longest" for a few objects -- fixed by selecting the longest axis from the stable
+0.90 dims and tightening only the short axes.
+
+**CLEAN DECOUPLING (ADOPTED, shipped).** Select the longest axis from the stable 0.90 dims,
+recover its full extent (size), and set the SHORT axes to the median frame's core extent
+(distance). A quantile sweep found a clean peak at the median with size fully preserved:
+
+| Short-axis quantile | overall | abs_distance | size |
+|---|---:|---:|---:|
+| 0.90 (baseline) | 51.73 | 59.71 | 61.55 |
+| 0.60 | 51.94 | 60.29 | 61.55 |
+| **0.50 (median, ADOPTED)** | **51.99** | **60.72** | **61.55** |
+| 0.40 | 51.97 | 60.53 | 61.55 |
+| 0.30 | 51.90 | 60.53 | 61.55 |
+
+Distance peaks exactly at the median (0.50): tighter overshoots (boxes too small, distance
+over-estimates, gain reverses at 0.40/0.30), and size stays pinned at 61.55 the whole way because
+the longest-axis selection is now decoupled from the short-axis tightening. The median is the
+canonical robust core estimate, and its landing on the sweep peak is a physical result (correct
+the measured ~9% box-too-big bias, stop there), not a tuned constant.
+
+Full production result (both frame counts, since the tighter boxes also change the class-distance
+table that object_rel_distance reads):
+
+| category | 32f | 64f |
+|---|---:|---:|
+| object_abs_distance | 59.38 -> 59.76 (+0.4) | 59.71 -> 60.72 (+1.0) |
+| object_rel_distance | 58.10 -> 56.42 (-1.7) | 58.10 -> 59.78 (+1.7) |
+| overall | 50.99 -> 50.90 (-0.09) | 51.73 -> 51.99 (+0.26) |
+
+object_abs_distance (the target) improves at BOTH frame counts. At 64f it is a clean win --
+abs_distance AND rel_distance both up (the tighter, less-bleed-inflated boxes help both the
+distance magnitude and the class-ranking), overall +0.26, the session-best 64f. At 32f the
+tighter boxes flip object_rel_distance's argmin on a few option sets (-1.7), netting a marginal
+-0.09 overall there despite abs_distance rising. Net across both frame counts is positive and the
+abs_distance goal is met, so ADOPTED; the 32f rel_distance interaction is the one honest caveat.
+
+### Tracking is essential (no-tracking caches: catastrophic)
+
+Tested `--tracking "no tracking"` (SAM3 masks NOT associated across frames) with the current
+geometric.py, metric/selective/32f: overall 26.51 vs tracking's 50.90; **object_abs_distance
+0.00**, object_counting 21.94, object_size 30.44, room 62.94. Without temporal tracking every
+per-frame mask becomes its own instance, so each class is a cloud of fragment-boxes scattered
+everywhere; the closest-classes table takes the MIN over instance pairs, and with fragments
+everywhere every class pair has some fragment ~touching some other, so every distance collapses
+to ~0 -> object_abs_distance scores 0. Tracking is not incidental; it is what makes instances
+clean enough to measure. (Also far slower -- the fragment explosion makes the pairwise BVLS
+distance quadratically expensive.)
+
+### Fixing mask-bleed at the source: over-carves (REJECTED)
+
+Bleed = SAM3 masks leaking across depth discontinuities onto neighbours, which back-projects as a
+bridge toward the neighbour and is the measured cause of boxes being too big (distance too small).
+geometric.py already has two source-level bleed tools, both OFF by default:
+`DEPTH_EDGE_REFINE` (keep the largest depth-coherent mask component) and `MASK_REFINE` (snap mask
+to RGB colour edges; unavailable -- RGB frame paths aren't threaded into the compact call).
+`DEPTH_COHERENCE` (Tukey 1.5*IQR depth-outlier fence) is already ON and catches
+different-depth bleed.
+
+Turning DEPTH_EDGE_REFINE ON REGRESSED hard: object_size 61.55 -> 58.07, object_abs_distance
+60.72 -> 58.52 (only object_counting nudged up, 50.00 -> 50.64). Same lesson as the original
+schema's reverted `_main_cluster`: "the object is the largest depth-coherent component" is FALSE
+-- real objects legitimately span depth discontinuities (angled surfaces, self-occlusion), so
+cutting at depth edges drops real object parts, shrinking boxes (size down) and over-opening gaps
+(distance overshoots). Identifying "which points are bleed" at the mask level is error-prone and
+destructive. The robust-percentile workaround (short-axis MEDIAN extent) is the better answer: it
+never removes points, it just reads a bleed-insensitive statistic of the (bleedy) extent -- which
+is why it worked where source-removal failed.
+
+Tightening the depth fence instead of the hard component split confirms the same wall: at
+1.0*IQR it starts removing REAL points (size 61.55 -> 61.13, count 50.00 -> 49.29, distance
+flat), because when the bleed neighbour is BESIDE the object it sits at a similar depth, so a
+depth fence cannot separate them without cutting the object; at 1.25*IQR it is a wash (+0.13
+overall, all from non-numeric categories, distance unchanged at 60.72), not shipped. Conclusion:
+bleed points are physically connected to the object and often at the same depth, so any rule that
+removes them also removes real object surface. The only fix that works is robustness, not
+removal -- already shipped (short-axis median + the on-by-default DEPTH_COHERENCE fence). The
+systematic bias bleed caused is corrected; the residual is symmetric per-object spread.
+
+**Per-observation SOR cleaning (REJECTED, all variants).** A gentler idea than the depth-edge
+component cut: SOR-clean each per-frame observation before measuring its extent (the orientation
+is already fit to SOR-cleaned pooled points, so this is a consistency fix; SOR drops sparse
+same-depth bleed without a hard component split). Screened three ways on 64f:
+- Clean everything: object_abs_distance 60.72 -> 61.29 (+0.57, real!) but object_size 61.55 ->
+  60.46 (-1.09) -- SOR also eats the object's true SPARSE extremes on the longest axis, which is
+  exactly what object_size reads. Net -0.48.
+- Clean everything, tighter SOR (1.5 sigma): same shape, slightly worse (61.10 / 60.29).
+- Decoupled (clean the distance/short-axis path, keep RAW full extent for the size/longest axis):
+  the natural fix for the above -- but it FAILED (overall 51.26, distance 60.62 flat, size 60.21
+  down 1.34). Cleaning the short-axis dimensions shifts the shared longest-axis `argmax` and the
+  box center enough to hurt size, and the distance gain from the "clean everything" version turned
+  out to depend partly on cleaning the longest axis too. Net -0.73.
+- Decoupled, CORRECTED (select the longest axis from the RAW full extent so cleaning can't flip
+  it): still failed -- overall 51.11, distance 59.86 AND size 60.34 both DOWN. Even with the
+  longest-axis selection made bleed-proof, cleaning the short-axis observations perturbs the box
+  center and the MAD consistency filter enough to hurt both. The +0.57 distance gain from "clean
+  everything" is fragile and could not be isolated.
+Same conclusion as every other bleed attempt: removing points to fight bleed keeps colliding with
+the object's real geometry. Robustness (short-axis median), not removal, is the answer.
+
+**Per-object confidence adaptivity: no effect (the spread is irreducible with available signals).**
+The residual is per-object spread (some boxes too big from bleed), so the flagged direction was
+per-object adaptivity. DA3 confidence is the natural bleed signal -- and it IS discriminative
+(measured: an object's outer-10% points are lower-confidence than its core, e.g. chair 6.6 vs 8.6,
+sofa 1.75 vs 3.16). Two ways of using it were tried, BOTH producing results identical to baseline
+to two decimals: (a) weight each frame's box contribution by its mean confidence -- no effect,
+because bleed is a small fraction of a frame's points and doesn't move the frame mean; (b) a
+per-point confidence-weighted percentile for the short-axis extent -- also no effect, because the
+2/98 percentile trim ALREADY removes the extreme low-confidence bleed, and confidence is roughly
+flat across the retained 2-98 range. The bleed that survives (2/98 trim + DEPTH_COHERENCE fence +
+short-axis median) is moderate-confidence, moderate-extent bleed sitting INSIDE the retained
+range -- genuinely indistinguishable from real object surface by confidence, by depth
+discontinuity (same-depth side neighbours), or by spatial connectivity (connected to the object).
+
+**Distance-table derivation is also optimal (shared-table tension).** The last lever: change HOW
+the closest-classes distance table is derived from the stored compact boxes (constraint: only the
+compact code's own numbers, no new field). Measured four numbers-only derivations on 64f, scoring
+BOTH object_abs_distance (MRA) and object_rel_distance (accuracy), since the table is shared:
+
+| derivation | abs_distance MRA | rel_distance acc |
+|---|---:|---:|
+| min over all pairs (current) | 60.72 | 62.65 |
+| largest-volume representative | 61.15 | 56.02 |
+| median over pairs | 60.53 | 47.59 |
+| min over top-half-volume instances | 60.96 | 53.01 |
+
+Every alternative that helps abs_distance (robustifying against spurious-close fragment pairs)
+hurts rel_distance MORE (largest-volume: abs +0.43, rel -6.6). The current min WINS on the
+combined score. The reason is a clean fundamental tension: rel_distance asks "which is CLOSEST" so
+it needs the true min surface distance for correct ranking, while abs_distance wants a ROBUST
+magnitude -- and a single shared table cannot serve both. Decoupling them (as size/distance was
+decoupled on the box axes) would require a SECOND derived field for abs_distance, which is out of
+scope (the derivation must produce the existing table only). So the min derivation is optimal
+under the constraint.
+
+**Ceiling reached (evidence-based).** Across the "keep going" phase, every remaining principled
+structural lever was tested and rejected or found marginal: longest-axis-fuller (max / view-union,
+post-decouple) costs distance for negligible size; depth-edge bleed cut over-carves; tighter depth
+fence over-tightens or is a wash; per-observation SOR (three variants) can't beat the size/distance
+tension; confidence weighting (two levels) has no effect; no-tracking is catastrophic; the
+distance-table derivation is min-optimal for the shared abs/rel use. All four
+numeric questions are median-ratio-centered (size 0.945, distance box-error 0.969, room 0.962,
+counting 1.000) -- the SYSTEMATIC biases are corrected and the residual is symmetric per-object
+spread that no available signal can separate from real geometry. Further gains need better
+upstream masks/depth, not geometry post-processing.
+
+**Numeric-question status after all batches:** object_size (median ratio 0.946), object_counting
+(median 1.000, at detection ceiling) are at their ceiling. room_size was NOT fully at ceiling --
+the grazing-gap bridge found a real non-coverage undershoot component (now 65.56 at 64f);
+whatever residual remains is genuine coverage (rooms the camera only half-walked). object_abs_distance
+box-error is now well-centered (median 0.969 after the short-axis median); the residual is
+symmetric per-object spread, not a directional bias, so uniform structural changes can't shift it
+further, and source-level bleed removal over-carves.
+
+### Absolute-distance hypotheses
+
+Ground-truth comparison, redone properly with full oriented boxes on both sides (the object's
+real `centroid`/`axesLengths`/`normalizedAxes` from `object_bbox`, run through the same
+`oriented_box_distance` BVLS solver used for our own table, not a crude axis-aligned
+approximation): unlike room size, there is **no clean, single-direction bias** to correct here.
+
+| Comparison | n pairs | Median ratio (ours/gt) | 10th-90th percentile |
+|---|---:|---:|---|
+| Surface distance, all class pairs | 910 | 0.981 | 0.17 - 2.14 |
+| Center-to-center distance, all class pairs | 910 | 0.988 | 0.70 - 2.04 |
+| Surface distance, single-instance-only pairs | 182 | **0.999** | 0.81 - 2.15 |
+| Surface distance, multi-instance pairs | 728 | 0.968 | **0.10** - 2.08 |
+
+Both the median surface-distance and median center-distance ratios sit almost exactly on 1.0 --
+genuinely unbiased noise on average, not a fixable offset. Splitting by whether either class has
+more than one tracked instance shows the real story: single-instance pairs (no pair-selection
+ambiguity at all) are centered on 0.999 with an honest, symmetric spread; multi-instance pairs
+have the same center but a dramatically fatter LOW tail (down to 0.10x), confirming the
+mechanism diagnosed earlier -- a spuriously-close near-duplicate instance sometimes gets picked
+as the "closest pair."
+
+**Merge Never-Co-Observed Overlapping Same-Class Tracks**: hypothesis that this fat tail comes
+from track fragmentation -- the same physical object, lost and re-acquired after occlusion,
+produces two "distinct" tracks that spatially overlap but were never seen in the same frame
+together (two REAL distinct objects of the same class can't occupy overlapping 3D space, so
+overlap + never-co-observed implies fragmentation, not two objects). Extended
+`_compact_duplicate_groups`'s merge rule to also union such pairs. Uses no external threshold --
+only each pair's own already-tracked frame-sets and AABB overlap.
+
+**Result: essentially a null result.** The new merge condition triggered exactly once across
+all 72 scenes at 64 frames (one `table` instance in one scene), so the aggregate scores are
+unchanged from baseline to two decimal places. Overlapping-but-never-co-observed same-class
+track pairs are simply rare in this pipeline's actual output -- the hypothesis is structurally
+sound but doesn't address what's actually happening in this data. **The multi-instance fat tail
+has a different real cause** (most likely genuine multi-instance ambiguity -- e.g. two REAL
+chairs pushed together, where the "closest pair" search correctly finds the closest real pair
+but it isn't the specific instance the question meant -- rather than spurious duplicate tracks),
+which isn't fixable by tightening duplicate detection.
+
+**Reject Below-Floor Compact Box Observations**: a real, checkable physical-implausibility
+signal exists in this data -- 296 instances across the scene set have a final box center more
+than 15cm below the scene's own reconstructed floor level, some by several meters (e.g. a
+window centered 4.6m underground). Extended `_compact_oriented_box`'s existing per-observation
+consensus loop to drop any single-frame observation whose ENTIRE vertical extent lies below
+floor_level (a physical impossibility for a floor-resting object), keeping every observation if
+literally all of them are below-floor (falls back rather than failing outright). No external
+threshold -- floor_level is the scene's own computed reference, and "these points are wholly
+underground" is a fact about that one observation, not a fitted number.
+
+Single-instance check on the known worst offender (scene `42897629`, tv/stove, ground truth
+8.8m): the fix moved the stove's box center from `(-2.62, 1.11, -0.96)` (physically impossible,
+under the floor) to `(-0.64, 0.28, 0.19)` (plausible), and the computed closest-classes distance
+improved from 1.09m to 1.63m -- real, measurable progress on that specific case.
+
+| Hypothesis | Frames | Overall | Abs. distance | Object size | Rel. distance | Finding |
+|---|---:|---:|---:|---:|---:|---|
+| Reject Below-Floor Compact Box Observations | 32 | 45.49 (+0.18) | 50.67 (-1.20) | 45.97 (-0.33) | 56.98 (-1.12) | Mixed. |
+| Reject Below-Floor Compact Box Observations | 64 | 46.88 (-0.24) | 53.88 (+0.72) | 48.87 (+0.17) | 54.75 (-2.79) | Mixed. |
+
+**Result: not a clean win.** It fixed the one specific known-bad case, and helped
+`object_abs_distance` at 64 frames, but `overall` moves in opposite directions between frame
+counts and `object_rel_distance` got measurably worse at both -- most likely because for some
+instances, the below-floor reading is actually the MAJORITY/consistent signal (meaning that
+scene's own `floor_level` estimate is what's off in that region, not the object), so rejecting
+it leaves a noisier minority rather than a cleaner signal. Recorded as a real, reproducible,
+partially-positive result -- not adopted, since the net effect across both frame counts is a
+wash rather than a genuine improvement.
+
+**Reject Below-Floor Observations Only When Minority**: refinement attempt on the above --
+theorized the mixed result came from cases where MOST of an instance's observations are
+below-floor (meaning that scene's own floor_level is miscalibrated in that region, not the
+object), so only reject below-floor observations when they're a strict minority of that
+instance's own observation count (self-referential majority-vote split, still no external
+number).
+
+| Hypothesis | Frames | Overall | Abs. distance | Rel. distance | Finding |
+|---|---:|---:|---:|---:|---|
+| Reject Below-Floor Observations Only When Minority | 32 | 45.18 | 51.39 | 56.98 | Worse than both baseline and the unconditional version. |
+| Reject Below-Floor Observations Only When Minority | 64 | 46.64 | 53.40 | 53.63 | Worse than both baseline and the unconditional version. |
+
+**Result: net negative, and the theory was wrong.** `object_rel_distance` is damaged almost as
+much as under the unconditional version even for the strict subset this refinement targets, and
+`overall` is now the worst of all three variants (baseline / unconditional / minority-only) at
+both frame counts. Whatever is causing `object_rel_distance` to regress when below-floor
+observations get rejected, it isn't explained by the majority/minority split -- it happens even
+in the minority-only cases this refinement was designed to protect. Not adopted; recorded as a
+genuine negative result that rules out this specific theory.
+
+**Weight Compact Box Consensus By Frame Not Point Count**: theorized that `_compact_oriented_box`'s
+per-observation weighting (`weight = sqrt(point_count)`) over-trusts frames where the camera
+happened to be close to the object (dense points, but often the most partial/cropped view) at
+the expense of farther, more-complete-but-sparser views. Changed to uniform per-observation
+weight (1 per tracked frame, regardless of point count).
+
+| Hypothesis | Frames | Overall | Abs. distance | Object size | Finding |
+|---|---:|---:|---:|---:|---|
+| Weight Compact Box Consensus By Frame Not Point Count | 32 | 44.63 (-0.68) | 50.24 (-1.63) | 44.62 (-1.68) | Regression. |
+| Weight Compact Box Consensus By Frame Not Point Count | 64 | 46.78 (-0.34) | 51.87 (-1.29) | 46.01 (-2.69) | Regression. |
+
+**Result: regression, both frame counts, on both distance and size.** The theory was backwards
+-- point-count weighting is doing real, load-bearing work (a frame with more points is a more
+reliable observation, not a more partial one, in this pipeline). Not adopted.
+
+### A real, diagnosed-but-unfixable mechanism: cross-class same-object confusion
+
+Filtering the ground-truth comparison to single-instance-only class pairs (removing the
+multi-instance-selection confound entirely) and looking at the worst remaining outliers surfaces
+a distinct, genuine failure mode. Three of the ten worst single-instance-pair errors in one
+64-frame batch all involved the SAME class (`table`) paired with a small adjacent-furniture
+class, with our computed distance collapsing to ~0 (touching/overlapping boxes) while ground
+truth says they're clearly separated. Example (`scene0221_01`, `table` vs `nightstand`):
+
+```
+table:      center (1.98, -2.47, -0.09)  dims (0.73, 0.26, 0.25)
+nightstand: center (2.01, -2.43, -0.24)  dims (0.82, 0.32, 0.41)
+```
+
+These two boxes are essentially co-located (centers ~7cm apart in x, ~4cm in y) -- almost
+certainly the SAME physical piece of furniture, detected and classified inconsistently across
+frames (SAM3 calling it "table" in some frames, "nightstand" in others -- visually similar small
+furniture is a plausible confusion). Our pipeline has no way to know these two class-labeled
+tracks are the same physical object, so it reports their (near-zero) distance as if they were
+two genuinely separate, touching objects.
+
+**Why this isn't fixable within the current constraints**: `_compact_duplicate_groups` already
+merges near-identical boxes WITHIN the same class name, but this is a CROSS-class collision --
+merging across class boundaries would need either (a) an external, hand-curated list of
+"confusable class pairs" (e.g. table/nightstand, sofa/chair), which is itself a dataset-specific
+fitted input, arguably worse than a single numeric constant since it directly encodes
+knowledge about THIS benchmark's specific class vocabulary, or (b) real semantic/visual
+understanding beyond what geometric.py's pure 3D-geometry math can provide. There is no
+purely-geometric signal that distinguishes "two class labels for the same physical object" from
+"two genuinely adjacent, touching, different real objects" (e.g. a real lamp resting on a real
+nightstand would produce the identical near-zero-distance geometric signature). This is recorded
+as a real, correctly-diagnosed root cause for a meaningful share of the worst outliers, not
+adopted as a fix because no fix exists within the stated constraints.
+
+**Conclusion on `object_abs_distance`**: across five independent geometric.py code changes
+tested this session (disjoint-frames duplicate merge, unconditional below-floor observation
+rejection, minority-only below-floor rejection, uniform per-observation weighting), one
+correctly-diagnosed-but-structurally-unfixable root cause (cross-class same-object confusion),
+plus the ground-truth bias check that ruled out a global scale correction, and on top of the
+extensive prior original-schema formula sweep in Part 1, nothing produced a clean, reliable
+improvement toward the 60s. The unconditional below-floor rejection came closest to a genuine
+structural win but nets out mixed rather than positive, and every other structural change tested
+made things worse. The error looks to be dominated by per-instance sensor/reconstruction noise
+with no single correctable root cause -- confirmed by this session's own ground-truth comparison
+(no global bias, and the two structural mechanisms tested either don't trigger or trade one
+category's gain for another's loss) and independently by the original-schema search's ~52%
+ceiling across dozens of formula variants.
+
+### The breakthrough: the score was leaking through UNANSWERED questions, not answered ones
+
+Every hypothesis above tried to make the ANSWERED questions more accurate, and all hit the same
+~52% wall. That was the wrong target. Decomposing the aggregate:
+
+- Answered `object_abs_distance` questions already average **62.4% MRA** (64f) -- not the
+  problem.
+- **31 of 209** questions (15%) returned `None` because `answer_object_abs_distance` gave up
+  whenever either named object was undetected in the scene. Under the official MRA scorer, a
+  `None`/blank prediction is a guaranteed **hard zero**, and those 31 zeros were dragging the
+  62.4% answered-average down to the 53.16% aggregate -- **9+ points of pure, recoverable loss
+  no box-fitting change could ever touch.**
+
+**Fix (`answer_object_abs_distance` missing-detection fallback, live in `symbolic/solver.py`):**
+when either named class is undetected (or the distance table has no entry), instead of `None`,
+return the room's own **expected random-point distance**. Rationale: an object the perception
+pipeline never detected has a genuinely *unknown* location; the least-assuming model for an
+unknown location is uniform over the floor. The expected distance between two uniformly random
+points in a **unit square** is the closed-form constant `(2 + sqrt(2) + 5*asinh(1)) / 15 =
+0.5214054...` -- a mathematical theorem derived by integration (like pi), **not a value fitted
+to any dataset**. Multiplying it by the scene's own measured `sqrt(floor area)` yields a
+deterministic estimate whose only inputs are one geometry theorem and the room's own measured
+scale. Chosen over alternatives (known-class-to-all-centers mean, all-center-pairs median) that
+were all tested and scored lower on the previously-unanswered subset.
+
+| Estimator (unanswered subset only, 64f) | mean MRA |
+|---|---:|
+| `None` (baseline -- guaranteed zero) | 0.00 |
+| known-class centers median | 40.00 |
+| all-center-pairs median | 43.55 |
+| known-class centers mean | 45.19 |
+| **room-scale random-point (adopted)** | **48.71** |
+
+**Result: `object_abs_distance` crosses into the 60s** -- 59.57 (32f) and 60.38 (64f), up from
+51.87 / 53.16, a +7.7 / +7.2 point gain. `overall` rises to 46.28 / 48.02. Because the fallback
+only fires where the old code returned `None`, every answerable question is unchanged and no
+other category moves -- a clean, no-regression win with zero dataset-fitted constants. All 22
+`tests/test_symbolic` tests pass.
+
+This is the general lesson the five earlier failures were pointing at: the remaining
+`object_abs_distance` gap was never a distance-*formula* problem (the answered questions were
+already fine); it was a *coverage* problem, and the recoverable part of it lives in how the
+solver handles the questions it currently can't answer, not in the geometry of the ones it can.
+
+## Infrastructure (Part 2)
+
+`experiments/` originally supported only the original schema (`run.py`, `launch.py`,
+`evaluate.py`, `loader.py`, `hypotheses/*.py`, each exposing a single-arg
+`build_spatial_code(scene)`). It's now schema-agnostic instead of split into parallel `_compact`
+files:
+
+- `experiments/config.py`: `spatial_code_directory()` / `spatial_code_path()` /
+  `result_directory()` all take an explicit `spatial_code_format` argument (`"original"` by
+  default, `"compact"` also supported), inserted as the bottom-most path segment -- exactly
+  matching the real spatial-code layout under
+  `data/spatial codes/<model>/<depth>/<tracking>/<input>/<frames>/<format>/`. An "original" and a
+  "compact" run of the same hypothesis name can never collide on disk.
+- `experiments/adapters.py` (new): bridges the hypothesis-module calling-convention difference.
+  Older hypothesis files (forked before the compact schema existed) expose
+  `build_spatial_code(scene)` and only ever produce the original schema. Newer hypothesis files
+  (forked from the current `encoder/geometric.py`, which already supports both schemas from one
+  function) expose `build_spatial_code(scene, spatial_code_format="original")`.
+  `experiments.adapters.build(hypothesis_module, scene, spatial_code_format)` detects which
+  signature a hypothesis uses via `inspect.signature` and calls it correctly; asking an
+  original-only hypothesis for `"compact"` raises a clear `ValueError` instead of silently
+  building the wrong schema.
+- `experiments/run.py`, `experiments/launch.py`, `experiments/evaluate.py`: all gained a
+  `--format {original,compact}` CLI flag (default `original`, so every existing invocation and
+  script is unaffected). `evaluate.py` also sets `symbolic_run.SPATIAL_CODES_FORMAT` so the real
+  `symbolic` scorer adapts compact codes exactly like a production run does.
+- Existing cached spatial codes and results under `experiments/caches/` and `experiments/results/`
+  were migrated in place to insert the `original` segment at the same position, so every prior
+  original-schema hypothesis result in Part 1 remains reachable at its (now format-qualified)
+  path without re-running anything.
+
+Reproduce any hypothesis above by name, e.g.:
+
+```bash
+python -m experiments.launch \
+  --hypothesis "Extend Compact Floor Coverage To Every Object Footprint" \
+  --depth metric --tracking tracking --input selective --frames 64 --format compact
+
+python -m experiments.evaluate \
+  --hypothesis "Extend Compact Floor Coverage To Every Object Footprint" \
+  --depth metric --tracking tracking --input selective --frames 64 --format compact \
+  --quiet --errors
+```
+
+---
+
+## Overfitting audit — cross-validation of every tuned parameter (64f, compact)
+
+Concern: the shipped `geometric.py` config carries several hand-tuned constants. Are they
+generalizable, or fit to the eval set? Methodology (same as the earlier short-axis CV): for each
+parameter, build the full spatial codes at each grid value, score the relevant question category
+per-scene, then run 200 random 50/50 scene splits (`RandomState(777)`) — pick the value that scores
+best on the *train* half, measure it on the *held-out test* half, and compare to the baseline value
+and to the per-split oracle. A parameter generalizes if train-selected ≈ oracle on held-out data
+(small overfit gap) and beats the untuned baseline.
+
+| Parameter | Category | Grid (shipped) | Held-out selected | Baseline | Oracle | Generalized gain | Overfit gap |
+|---|---|---|---|---|---|---|---|
+| Grazing-gap kernel | room_size | 3 / **5** / 7 | 64.39 | 62.36 (k=3) | 65.28 | **+2.03** | 0.88 |
+| Floor clip pct | room_size | 0.5 / **0.1** / 0.05 | 65.35 | 62.20 (0.5) | 65.66 | **+3.16** | 0.31 |
+| SOR sigma | object_size | 2.0 / **1.5** / 1.25 | 61.49 | 61.37 (2.0) | 61.72 | +0.12 | 0.23 |
+| Length-axis quantile | object_size | 0.75 / **0.9** / 1.0 | 61.26 | 59.37 (0.75) | 61.97 | **+1.89** | 0.71 |
+
+Train picks (how often each value won the train half):
+- Grazing: {3: 20, **5: 172**, 7: 8} — shipped value dominates, clean win.
+- Floor clip: {0.5: 1, **0.1: 47**, 0.05: 152} — tighter clip (0.05) actually wins more often and held-out is +0.19 over shipped 0.1; shipped 0.1 is on the safe side of a broad plateau. No overfit.
+- SOR sigma: {2.0: 38, **1.5: 69**, 1.25: 93} — near-flat plateau (all three within 0.35 on held-out). Distance-neutral so 1.5 kept; essentially free parameter, no overfit risk.
+- Length-axis quantile: {0.75: 1, **0.9: 87**, 1.0: 112} — 1.0 (full extent) wins slightly more but held-out gap to 0.9 is only 0.71 with higher variance; 0.9 is the conservative choice on the plateau.
+
+**Conclusion: no parameter shows overfitting.** All overfit gaps are ≤0.88 MRA (train-selection
+recovers within ~1 point of the oracle in every case), every parameter beats its untuned baseline on
+held-out scenes (+0.12 to +3.16), and where the shipped value is not the single most-picked (floor
+clip, length-axis, SOR) it sits on a broad plateau within noise of the winner. The tuned config
+generalizes across random scene partitions rather than being fit to the specific eval set.
+
+---
+
+## Final sweep — box-center consistency decoupling (SHIPPED)
+
+Baseline going in (post-overfitting-audit, 64f): overall 51.99, size 61.55, abs_distance 60.72,
+count 50.00, room 65.56. Six hypotheses screened first, all built from the untapped remaining
+levers in `_compact_oriented_box` and `_compact_floor_boundary_polygons`:
+
+| Hypothesis | overall | size | abs_distance | count/room | verdict |
+|---|---:|---:|---:|---|---|
+| Consensus Filter At Two Sigma (tighten the whole MAD filter to 2.0σ) | 51.64 | 60.88 | **61.72** | — | instructive: distance jumps, size drops — filter is shared and shouldn't be |
+| Retain Disjoint Instances Beyond Peak | 51.14 | 61.22 | 59.90 | count 45.0 | REJECTED — "extra" disjoint fragments beyond the tracked peak are detector phantoms, not real missed instances |
+| Sample Floor Support Every Fourth Pixel (denser floor grid) | 52.01 | 61.55 | 60.72 | room 65.69 | neutral, not shipped (no principled gain over the coarser stride) |
+| Fill Object Footprint Convex Hulls (vs. rasterized points) | 51.96 | 61.55 | 60.86 | room 65.14 | REJECTED — convex hull overfills concave/L-shaped room footprints |
+| Room Dense Sampling + Hull Fill (combo) | 51.91 | 61.55 | 60.86 | room 64.72 | REJECTED, compounds the hull problem |
+| Two Sigma + Disjoint Retention (combo) | 50.76 | 60.63 | 60.53 | count 45.0 | REJECTED, compounds both failures |
+
+**The signal:** tightening the whole MAD consistency filter to 2.0σ helps `object_abs_distance`
+a lot (60.72 → 61.72) but costs `object_size` (61.55 → 60.88), because the filter's output
+feeds BOTH the box center (which distance is sensitive to) AND the extent statistics (which size
+reads) through one shared consistent-observation set. Same principle as the earlier size/distance
+axis decoupling, one level up: **the box center wants a stricter consensus (a noisy/partial-view
+center shifts the whole box toward or away from every neighbour, corrupting every surface-gap
+distance), while the extents want the fuller 3.0σ set (partial views can only under-measure
+extent, so the fuller views are the informative ones for size).**
+
+Fix: compute a *second*, stricter 2.0σ-consistent subset used only for the box CENTER
+(`core_centers`/`core_weights`), while the extent path (dimensions, full_dimensions, longest-axis
+selection) keeps the original 3.0σ set untouched. No new field, no schema change — purely how the
+existing per-observation samples are aggregated.
+
+Swept the center-filter tightness to confirm this is a plateau, not a fitted knife-edge (64f):
+
+| Center consensus σ | overall | abs_distance | rel_distance | size |
+|---|---:|---:|---:|---:|
+| 3.0 (= old shared filter, no change) | 51.99 | 60.72 | 59.78 | 61.55 |
+| 2.5 | 51.85 | 60.67 | 59.78 | 61.55 |
+| **2.0 (ADOPTED)** | **52.30** | **60.96** | **60.89** | **61.55** |
+| 1.5 | 52.20 | 61.24 | 60.89 | 61.55 |
+
+2.0–1.5σ are both clear improvements over 3.0/2.5σ (a broad plateau, not a single tuned point);
+2.0σ was selected as the standard ~95%-equivalent robust cutoff (1.4826×MAD × 2.0 ≈ 2 robust
+standard deviations), the conventional choice rather than a value picked by search. size stays
+pinned at 61.55 throughout, exactly as intended — the center tightening never touches the extent
+path. 32f verification: overall 50.90 → 51.24 (+0.34), and it specifically repairs the one
+honest caveat left by the short-axis ship — 32f `object_rel_distance` recovers from 56.42 → 59.22
+(+2.8), because the tighter center stabilizes the class-distance table's ranking at 32f where
+tracks are shorter and noisier.
+
+**Final production numbers (both frame counts, SHIPPED):**
+
+| category | 32f (before → after) | 64f (before → after) |
+|---|---:|---:|
+| overall | 50.90 → **51.24** | 51.99 → **52.30** |
+| object_abs_distance | 59.76 → 59.71 | 60.72 → **60.96** |
+| object_rel_distance | 56.42 → **59.22** | 59.78 → **60.89** |
+| object_size_estimation | 59.75 (unchanged) | 61.55 (unchanged) |
+| object_counting | 49.50 (unchanged) | 50.00 (unchanged) |
+| room_size_estimation | 66.67 (unchanged) | 65.56 (unchanged) |
+
+Shipped to `encoder/geometric.py` (`_compact_oriented_box`), all 46 encoder tests pass, production
+compact spatial codes and results rebuilt and re-scored at both frame counts to confirm.
+</content>

experiments/adapters.py

@@ -5,9 +5,9 @@ but the difference handled here is in the HYPOTHESIS MODULE ITSELF, not the on-d
 file under experiments/hypotheses/ is a full standalone fork of encoder/geometric.py.
 
 - Older hypotheses were forked before the compact schema existed and expose a single-arg
-  build_spatial_code(scene) that always builds the "original" answer-oriented schema.
+  build_spatial_code(scene) that always builds the "explicit" answer-oriented schema.
 - Newer hypotheses (forked from the current encoder/geometric.py, which already supports both
-  schemas from one function) expose build_spatial_code(scene, spatial_code_format="original"),
+  schemas from one function) expose build_spatial_code(scene, spatial_code_format="explicit"),
   matching encoder/geometric.py's own real entry point.
 
 experiments/run.py calls build() below instead of the hypothesis module directly, so callers
@@ -28,19 +28,19 @@ def supports_compact(hypothesis_module: ModuleType) -> bool:
     return len(params) >= 2
 
 
-def build(hypothesis_module: ModuleType, scene, spatial_code_format: str = "original"):
+def build(hypothesis_module: ModuleType, scene, spatial_code_format: str = "explicit"):
     """Build one spatial code from a loaded hypothesis module, in the requested format.
 
-    Raises ValueError if an "original"-only (older-style) hypothesis is asked to build
+    Raises ValueError if an "explicit"-only (older-style) hypothesis is asked to build
     "compact" -- that hypothesis genuinely cannot produce that schema, so failing loudly here
     is preferable to silently building the wrong format.
     """
     validate_spatial_code_format(spatial_code_format)
     if supports_compact(hypothesis_module):
         return hypothesis_module.build_spatial_code(scene, spatial_code_format)
-    if spatial_code_format != "original":
+    if spatial_code_format != "explicit":
         raise ValueError(
-            f"{hypothesis_module.__name__} only supports the 'original' spatial-code "
+            f"{hypothesis_module.__name__} only supports the 'explicit' spatial-code "
             f"format (its build_spatial_code() takes a single scene argument); requested "
             f"{spatial_code_format!r}"
         )

experiments/config.py

@@ -12,12 +12,12 @@ CACHES_ROOT = EXPERIMENT_ROOT / "caches"
 RESULTS_ROOT = EXPERIMENT_ROOT / "results"
 
 # Same two schemas symbolic/adapters.py supports -- a hypothesis's build_spatial_code() may
-# produce either the "original" answer-oriented shape or the "compact" oriented-box/time/
+# produce either the "explicit" answer-oriented shape or the "compact" oriented-box/time/
 # floor-polygon primitive shape (adapted at scoring time). Every on-disk path below carries
 # this as its own bottom-most segment, exactly like the real spatial-code layout under
-# data/spatial codes/<model>/<depth>/<tracking>/<input>/<frames>/<format>/ -- so an "original"
+# data/spatial codes/<model>/<depth>/<tracking>/<input>/<frames>/<format>/ -- so an "explicit"
 # and a "compact" run of the SAME hypothesis name never collide on disk.
-SPATIAL_CODE_FORMATS = ("original", "compact")
+SPATIAL_CODE_FORMATS = ("explicit", "compact")
 
 
 def normalize_hypothesis(name: str) -> str:
@@ -47,7 +47,7 @@ def spatial_code_directory(
     tracking: str,
     input_selection: str,
     frame_count: int,
-    spatial_code_format: str = "original",
+    spatial_code_format: str = "explicit",
 ) -> Path:
     encoder_config._validate_dimensions(depth, input_selection, tracking, frame_count)
     return (
@@ -69,7 +69,7 @@ def spatial_code_path(
     tracking: str,
     input_selection: str,
     frame_count: int,
-    spatial_code_format: str = "original",
+    spatial_code_format: str = "explicit",
 ) -> Path:
     if not scene or Path(scene).name != scene:
         raise ValueError(f"invalid scene name: {scene!r}")
@@ -93,7 +93,7 @@ def result_directory(
     tracking: str,
     input_selection: str,
     frame_count: int,
-    spatial_code_format: str = "original",
+    spatial_code_format: str = "explicit",
 ) -> Path:
     encoder_config._validate_dimensions(depth, input_selection, tracking, frame_count)
     if not evaluator or Path(evaluator).name != evaluator:

experiments/evaluate.py

@@ -21,7 +21,7 @@ def configure_symbolic_evaluation(
     tracking="tracking",
     input_selection="uniform",
     frame_count=64,
-    spatial_code_format="original",
+    spatial_code_format="explicit",
 ):
     """Point symbolic reads and writes at one isolated experiment selection."""
     codes = config.spatial_code_directory(
@@ -59,7 +59,7 @@ def evaluate(
     scene_ids=None,
     quiet=False,
     errors=False,
-    spatial_code_format="original",
+    spatial_code_format="explicit",
 ):
     """Score every available experiment code, or an explicit scene subset."""
     codes, results = configure_symbolic_evaluation(
@@ -120,7 +120,7 @@ def main() -> None:
     parser.add_argument("--frames", type=int, default=64)
     parser.add_argument(
         "--format",
-        default="original",
+        default="explicit",
         choices=config.SPATIAL_CODE_FORMATS,
         dest="spatial_code_format",
     )

experiments/hypotheses.md

@@ -0,0 +1,224 @@
+# Experimental Program: Frames vs. Spatial Code vs. Both
+
+Grounded in VSI-Bench ("Thinking in Space", arXiv:2412.14171) and "Thinking with
+Spatial Code" (arXiv:2603.05591). Every experiment below is runnable with the existing
+infrastructure: harness A (frames only), harness B (spatial-code text only), harness C
+(frames + code, same-source config), original/compact code formats, uniform/selective
+frame selection, frame counts, three VLMs (Qwen3.5-4B, Qwen3.5-2B, InternVL3.5-4B),
+the 16-token direct protocol vs. the 2048-token extended-reasoning protocol, and the
+consolidated /workspace/analysis package (per-category official scores, reasoning-token
+and forced-answer telemetry, cross-harness join).
+
+Anchor findings from the two papers:
+- VSI-Bench error taxonomy: ~71% spatial reasoning (40% relational, 31% ego-allo
+  transform), ~15% perception, ~14% linguistic.
+- CoT / self-consistency / ToT HURT frames-only VSI-Bench (up to -21% on size tasks).
+- Model-generated cognitive maps helped relative distance 46->56; GT maps -> 66.
+- Spatial-code paper: predicted codes 60.0 overall, ground-truth codes 73.2 with the
+  same 4B LLM -> perception, not reasoning capacity, is the binding constraint.
+
+---
+
+## Theme 1 — Representation substitution (A vs B)
+
+**H1 (code-for-frames substitution).** B (code only) >= A (frames only) on the
+metric-geometry categories (absolute distance, object size, room size, relative
+distance), because ~71% of frame-based errors are spatial-reasoning errors that
+explicit coordinates eliminate; A retains the edge only on appearance-dependent
+categories. Run: A vs B, all 3 models, selective/32 and selective/64, both protocols.
+
+**H2 (informed-blind baseline).** VSI showed vision-disabled models score below chance.
+B is "blind but informed" — the B-minus-blind gap is a direct measure of the code's
+usable information content per category. The appearance-order category is the sharp
+sub-case: the code carries first-visible-time (compact) / appearance order (original),
+so B should massively beat both blind AND frames-only baselines on the paper's hardest
+category (32.5 even with codes+RL) — if the model actually reads the legend. Failure
+here isolates schema-grounding failure, not information absence.
+
+**H3 (ego-allo split).** The code is allocentric (world frame). B improves allocentric
+tasks (rel/abs distance, size, room size, counting) but NOT egocentric tasks (relative
+direction, route planning), which need the observer's viewpoint that the code lacks.
+This maps VSI's 31%-ego-allo error class onto a controlled input manipulation.
+
+## Theme 2 — Complementarity and conflict (C vs A, B)
+
+**H4 (complementarity is category-selective).** C > max(A, B) only where the two
+modalities carry disjoint information: relative direction and route planning (frames
+restore the egocentric viewpoint; code supplies exact geometry). On pure-metric
+categories C ~= B (frames redundant); on appearance order C ~= best single modality.
+
+**H5 (cross-modal interference).** For the 2B model, C < B on metric categories:
+thousands of extra visual tokens act as distractors when the code already suffices —
+a capacity x redundancy interaction absent at 4B.
+
+**H6 (textual anchoring under conflict).** Where the encoder's code is wrong (predicted
+codes carry perception error), C follows the code, not the frames — VLMs anchor on
+text. Measure per-question "code dominance": among questions where A and B disagree,
+what fraction of C's answers side with B? Follow-up (small new script): perturb one
+object's position/size in the code fed to C and measure how often the answer tracks
+the perturbation despite contradicting frames.
+
+## Theme 3 — Reasoning protocol (16-token vs 2048-token extended)
+
+**H7 (the CoT reversal — headline hypothesis).** VSI-Bench's "CoT hurts" finding is a
+representation problem, not a reasoning problem: extended reasoning HURTS or is flat
+for A (replicating the paper) but HELPS for B and C, because reasoning over explicit
+coordinates is symbolic computation (arithmetic, projections) that benefits from
+serial steps, whereas reasoning over frames forces error-amplifying visual
+imagination. Design: 2 (protocol) x 3 (harness) x 8 (category), all models. A positive
+interaction term is a novel, publishable result: "chain-of-thought fails for spatial
+video reasoning only when the space is implicit."
+
+**H8 (dose-response / overthinking).** Within extended B/C records, accuracy vs.
+reasoning_token_count is inverted-U; records that hit the 2048 cap and were forced
+("Final answer:") score worst — rumination as a measurable failure mode. We log
+reasoning_token_count, hit_token_limit, forced per record; no new code needed.
+
+**H9 (forced answers are informative).** Forced-continuation answers still beat chance
+on MCA tasks — truncated reasoning traces carry decision-relevant state. Compare
+forced-record accuracy vs. category chance level.
+
+**H10 (extended mode rescues small models on B).** The 4B-vs-2B gap under the 16-token
+protocol on B shrinks under extended reasoning: small models can't one-shot multi-step
+coordinate arithmetic in 16 tokens but can when allowed to externalize steps. Scale x
+protocol interaction, B only.
+
+## Theme 4 — Code format (original vs compact)
+
+**H11 (precomputation vs derivation x token budget).** Original embeds a precomputed
+pairwise distance table; compact gives raw OBBs only. Under the 16-token protocol,
+original wins on distance categories (answer = table lookup); under extended
+reasoning, compact catches up or wins (the model derives what it needs, and the table
+is 30 lines of distraction for non-distance questions). A budget x format crossover.
+
+**H12 (verbosity x capacity).** Compact's fuller schema helps 4B models and hurts 2B
+(context distraction) — format x scale interaction, measurable per category.
+
+**H13 (schema-grounding).** Because original is now provably derivable from compact,
+any B(original) vs B(compact) gap is purely presentational, not informational — a
+clean measurement of how much "representation surface form" matters to VLMs, holding
+information content mathematically fixed. This is a control neither paper could run.
+
+## Theme 5 — Perception inputs (frame selection and count)
+
+**H14 (code as frame compression).** C at low frame counts matches A at high frame
+counts: quantify the "frame-equivalent value" of the code (e.g., C@8 ~= A@64). Report
+as an input-token/accuracy Pareto frontier (input_token_count is logged per record) —
+an efficiency argument for symbolic intermediates.
+
+**H15 (selection matters more upstream than downstream).** For A, selective vs uniform
+frames changes what the VLM sees; for B, selection only changes what the encoder saw
+when building the code. Prediction: the selective-vs-uniform effect on B (via code
+coverage/quality) exceeds its effect on A — perception curation compounds through the
+encoding stage. (Requires building uniform-selection codes; currently only selective
+exists on disk.)
+
+**H16 (frame-count saturation shifts by modality).** A saturates at moderate frame
+counts (VSI models used 8-32); B's accuracy vs. the frame count used to BUILD the code
+keeps rising longer (more frames -> more tracked objects -> more complete code), i.e.,
+the saturation point of frames-as-pixels is earlier than frames-as-evidence-for-codes.
+Compare A@{8,16,32,64} vs B(code built from {32,64}).
+
+## Theme 6 — Model family and scale
+
+**H17 (family x modality).** InternVL3.5-4B vs Qwen3.5-4B rank-flips between A and B:
+vision-centric training helps A, text/instruction strength helps B. Code-reading is a
+distinct capability from video understanding, poorly predicted by video benchmarks.
+
+**H18 (scale gap is modality-dependent).** The 4B-2B gap is larger on B than A under
+the 16-token protocol (symbolic reasoning scales faster than perception at these
+sizes), and H10 predicts extended mode closes it.
+
+## Theme 7 — Question-level error decomposition (the empirical version of VSI's manual taxonomy)
+
+**H19 (automatic perception/reasoning split).** Join A, B, C per question (same
+question ids across harnesses). Classify each question: solved-by-B-not-A (frames'
+failure was perception-or-imagination), solved-by-A-not-B (code missing needed info —
+appearance/visibility), solved-by-neither (reasoning failure or question pathology),
+solved-by-C-only (genuine fusion). This reproduces the paper's 71/15/14 manual error
+taxonomy automatically and at full-benchmark scale. Analysis-only: pairwise McNemar
+tests + per-category contingency tables over existing result JSONs.
+
+**H20 (cognitive-map generalization).** The spatial code is an externally supplied,
+metrically exact cognitive map. VSI's cog-map gain concentrated in relative distance
+(46->56->66 with GT). Prediction: B's gains over A concentrate in the same place, and
+exceed the GT-cog-map ceiling (66) because the code is 3D and metric while the 10x10
+grid map was 2D and coarse — positioning our result as the limit of that paper's
+cognitive-map line.
+
+---
+
+## Execution plan — staged, config-narrowing design
+
+This is the actual plan being run, not a full factorial: each stage sweeps its own axes,
+picks a single winning configuration from the results, and freezes that configuration
+for the next stage. Every stage always sweeps all 3 models — the model axis is never
+collapsed, only frame count / input selection / spatial-code format are.
+
+**Stage 1 — Plan A decides frame count AND selection.**
+
+```bash
+python -m harness.A.sweep --models all --frame-selections all --frames 16,32,64
+```
+
+9 configs (3 models x 2 selections x 3 frame counts {16, 32, 64}), 16-token protocol.
+Aggregate with `analysis.aggregate --harness A`; for each `(frame_selection,
+frame_count)` cell, average the "overall" official score across all 3 models; the
+argmax cell is `(selection*, frames*)`. This single pair is frozen for every later stage
+— both harness B's `--input-selections` and harness C's `--input-selections`, and both
+harnesses' `--frames`.
+
+**Stage 2 — Plan B decides spatial-code format.**
+
+```bash
+python -m harness.B.sweep --models all --spatial-code-formats all \
+  --input-selections <selection*> --frames <frames*>
+```
+
+6 configs (3 models x 2 formats), input selection and frame count fixed from Stage 1.
+Aggregate with `analysis.aggregate --harness B`; average "overall" across the 3 models
+per format; the argmax format is `format*`.
+
+**Stage 3 — Plan C runs the fully-fixed config.**
+
+```bash
+python -m harness.C.sweep --models all --spatial-code-formats <format*> \
+  --input-selections <selection*> --frames <frames*>
+```
+
+3 configs (one per model) — every non-model axis is now fixed by Stages 1-2, so C's own
+sweep only varies the model.
+
+**What this buys and what it costs.** A, B, C become directly comparable at one
+apples-to-apples configuration chosen by A's own best showing — clean for H1/H4/H5/H6/
+H17 (representation and complementarity questions at the single best operating point).
+It costs the multi-config comparisons: H3/H7/H10/H11/H18 (protocol and format
+interactions across several configs) and H14-H16 (frame-count/selection curves across
+harnesses) need B/C runs at MORE than the one frozen config to observe an interaction or
+a curve, not just a single point. Two ways to get those without abandoning the staged
+design:
+- Re-run Stage 2/3 sweeps a second time under the extended (2048-token) protocol at the
+  same frozen `(selection*, frames*)` — gives the 16-token-vs-extended comparison (H7,
+  H10) "for free" at the chosen config, no new axis to pick a winner from.
+- Treat frame-count/selection curves (H14, H15, H16) as a separate, explicitly
+  secondary sweep — rerun B/C at the other Stage-1 frame counts too, after the staged
+  pipeline's headline results are in, only if those hypotheses are still of interest.
+
+**Always-available, no extra runs needed:**
+- **Telemetry analyses** (H8, H9, H19, H20): pure analysis over whatever result JSONs
+  already exist (reasoning_token_count bins, forced-rate vs score, cross-harness
+  per-question join) — run after every stage, not gated on the full plan finishing.
+- **Perturbation probe** (H6 follow-up): small script cloning harness C with a
+  position/size-perturbed code for ~100 sampled questions from the frozen C config.
+- **Uniform-selection code build** (only relevant if Stage 1 picks `selective`, since
+  `H15` specifically wants the OTHER selection's encoder-side effect): gated on
+  regenerating SAM3 raw caches for uniform input, currently absent on disk.
+
+Statistics: per-question paired comparisons (McNemar for MCA, paired bootstrap over
+questions for MRA), per-category and overall; all scoring through the official
+vsibench aggregator already wired into /workspace/analysis.
+
+Expected headline results if hypotheses hold: (i) CoT-reversal interaction (H7, needs
+the extended-protocol re-run above), (ii) automatic error-taxonomy decomposition (H19),
+(iii) format-as-pure-presentation control (H13), (iv) textual anchoring under modality
+conflict (H6).

experiments/launch.py

@@ -146,7 +146,7 @@ def main() -> None:
     parser.add_argument("--frames", type=int, default=64)
     parser.add_argument(
         "--format",
-        default="original",
+        default="explicit",
         choices=config.SPATIAL_CODE_FORMATS,
         dest="spatial_code_format",
     )

experiments/run.py

@@ -129,7 +129,7 @@ def run_scene(
     input_selection="uniform",
     frame_count=64,
     rebuild=False,
-    spatial_code_format="original",
+    spatial_code_format="explicit",
 ):
     output = config.spatial_code_path(
         scene,
@@ -172,7 +172,7 @@ def main() -> None:
     parser.add_argument("--frames", type=int, default=64)
     parser.add_argument(
         "--format",
-        default="original",
+        default="explicit",
         choices=config.SPATIAL_CODE_FORMATS,
         dest="spatial_code_format",
     )

experiments/tests/test_config.py

@@ -21,7 +21,7 @@ def test_spatial_code_path_has_all_dimensions():
         / "uniform"
         / "A Human Readable Hypothesis"
         / "64"
-        / "original"
+        / "explicit"
         / "scene0000_00.json"
     )
 

experiments/tests/test_evaluate.py

@@ -14,7 +14,7 @@ def test_configure_symbolic_evaluation_uses_experiment_paths():
         / "uniform"
         / "A Hypothesis"
         / "64"
-        / "original"
+        / "explicit"
     )
     assert (
         results
@@ -25,10 +25,10 @@ def test_configure_symbolic_evaluation_uses_experiment_paths():
         / "uniform"
         / "A Hypothesis"
         / "64"
-        / "original"
+        / "explicit"
     )
     assert evaluate.symbolic_launch.symbolic_run.SPATIAL_CODES_DIR == str(codes)
-    assert evaluate.symbolic_launch.symbolic_run.SPATIAL_CODES_FORMAT == "original"
+    assert evaluate.symbolic_launch.symbolic_run.SPATIAL_CODES_FORMAT == "explicit"
     assert evaluate.symbolic_launch.symbolic_run.results_dir_for_selection() == str(
         results
     )