Add files using upload-large-folder tool

README.md

@@ -24,7 +24,7 @@ data/                VSI-Bench videos, spatial codes (encoder output), caches
 encoder/              builds spatial codes (compact + explicit, perceived + ground truth)
 inference/             SAM3 + Depth Anything 3 raw-model runners (encoder's inputs)
 symbolic/              formula-driven solver -- answers questions from a spatial code, no VLM
-harness/A, B, C, D      VLM-based answering, one harness per input configuration
+harness/A, B, C, D, E   VLM-based answering, one harness per input configuration
 analysis/               per-category scoring, cross-harness comparison, CSV export
 experiments/            separate, concluded track: geometry-formula tuning for encoder/
 results/                every harness's + symbolic's output, one JSON per question
@@ -87,6 +87,11 @@ annotations don't carry — per-object "first visible time," a property of a spe
 camera walkthrough, not of a static 3D scan — is sourced from VSI-Bench's own real
 `obj_appearance_order` question answers where available (topologically merged across
 every such question for a scene) and left `null`, never fabricated, where it isn't.
+**Known circularity**: because that field is reconstructed from the answer keys of the
+very `obj_appearance_order` questions being scored, every D and symbolic-ground-truth
+result on that category is contaminated by construction — exclude
+`obj_appearance_order` from any ceiling or perception-error claim built on
+ground-truth codes, and report it separately with this caveat.
 Rebuild with `python -m encoder.ground_truth`.
 
 ### `symbolic/` — the formula-driven solver (no VLM)
@@ -110,9 +115,9 @@ is documented with its measured before/after numbers in
 the VLM-harness hypotheses below, and its findings are already baked into
 `encoder/geometric.py` and `symbolic/solver.py` as shipped.
 
-### `harness/A`, `B`, `C`, `D` — VLM-based answering
+### `harness/A`, `B`, `C`, `D`, `E` — VLM-based answering
 
-All four harnesses answer the same real VSI-Bench questions with one of three VLMs
+All five harnesses answer the same real VSI-Bench questions with one of three VLMs
 (Qwen3.5-4B, Qwen3.5-2B, InternVL3.5-4B), greedy-decoded, and write one untruncated JSON
 result per question in the identical record shape (so any of them can be pointed at
 `analysis.aggregate` with no per-harness special-casing). They differ only in what's
@@ -124,6 +129,11 @@ shown to the model:
 | **B** | spatial code as text only | perceived (`encoder/`, SAM3+DA3) |
 | **C** | video frames **and** spatial code, sourced from the identical `(depth, tracking, input, frames)` config so they can never mismatch | perceived (`encoder/`, SAM3+DA3) |
 | **D** | spatial code as text only | **ground truth** (`encoder/ground_truth.py`) |
+| **E** | question text only — the **blind floor** (no frames, no code, no scene input at all) | — |
+
+E exists because VSI-Bench's own paper shows blind LLMs beat chance on several
+categories through pure priors (typical room/object sizes) — without this floor, a
+B-over-A gain could partly be prior-shifting rather than actual geometry use.
 
 Every harness's prompt (`prompts.py`) uses the same context-line → code-JSON →
 question → post-prompt structure, reusing harness A's exact question-type split and
@@ -133,14 +143,20 @@ table and appearance order; only compact has per-instance orientation vectors)
 never over- or under-claims either format; the code's own embedded schema legend is
 what actually documents every field present in a given call.
 
-A uses the VSI-Bench paper's own protocol by default (greedy decoding, 16-token output
-cap — the exact `lmms_eval` generation config). B, C, and D default to an *extended*
-protocol instead (`answer_extended`: a large 2048-token reasoning budget, with a short
-forced `"Final answer:"` continuation only if the model doesn't conclude on its own,
-via literal generation continuation, not a new chat turn) — A can opt into the same via
-`--extended`. Every record logs `reasoning_token_count`, `hit_token_limit`, and
-`forced`, whether or not the extended protocol was used, so protocol effects can always
-be measured after the fact.
+The generation protocol is a real, first-class axis on EVERY harness — "base" (the
+VSI-Bench paper's own protocol: greedy decoding, 16-token output cap, the exact
+`lmms_eval` generation config) or "extended" (`answer_extended`: a large 2048-token
+reasoning budget, with a short forced `"Final answer:"` continuation only if the model
+doesn't conclude on its own, via literal generation continuation, not a new chat turn).
+A and E default to base and opt into extended via `--extended`; B, C, and D default to
+extended and opt into base via `--base-protocol`. Both directions run the IDENTICAL
+generation mechanism (`answer()` / `answer_extended()`, shared by every harness), so
+the protocol × representation grid (H7) is measured with the same code in every cell —
+and the protocol is a results-path segment (`results/<harness>/<model>/<protocol>/...`)
+plus a `"protocol"` record field, so the two protocols' records can never collide on
+disk. Every record logs `reasoning_token_count`, `hit_token_limit`, and `forced`,
+whether or not the extended protocol was used, so protocol effects can always be
+measured after the fact.
 
 D additionally has `harness/D/symbolic_eval.py`, which runs the real symbolic solver
 (no VLM at all) directly on ground-truth codes — the perfect-information ceiling,
@@ -166,6 +182,7 @@ depth/tracking runs of the same scene/model/format can never collide on disk.
 python -m harness.A.sweep --models all --frame-selections all --frames 16,32,64
 python -m harness.B.sweep --models all --spatial-code-formats all --input-selections selective --frames 32
 python -m harness.D.sweep --models all   # both spatial_code_formats always -- see "Plan D" below
+python -m harness.E.sweep --models all   # blind floor, base protocol
 python -m harness.D.symbolic_eval --spatial-code-format explicit   # perfect-information ceiling
 ```
 
@@ -173,10 +190,11 @@ python -m harness.D.symbolic_eval --spatial-code-format explicit   # perfect-inf
 
 | Harness | Path |
 |---|---|
-| A | `results/A/<model>/<frame_selection>/<frame_count>/<scene>/<question_id>.json` |
-| B | `results/B/<model>/<format>/<depth>/<tracking>/<input_selection>/<frame_count>/<scene>/<question_id>.json` |
-| C | `results/C/<model>/<format>/<depth>/<tracking>/<input_selection>/<frame_count>/<scene>/<question_id>.json` |
-| D | `results/D/<model>/<format>/<scene>/<question_id>.json` (VLM path only — `symbolic_eval` writes to `results/symbolic/ground truth/...` below, not here) |
+| A | `results/A/<model>/<protocol>/<frame_selection>/<frame_count>/<scene>/<question_id>.json` |
+| B | `results/B/<model>/<protocol>/<format>/<depth>/<tracking>/<input_selection>/<frame_count>/<scene>/<question_id>.json` |
+| C | `results/C/<model>/<protocol>/<format>/<depth>/<tracking>/<input_selection>/<frame_count>/<scene>/<question_id>.json` |
+| D | `results/D/<model>/<protocol>/<format>/<scene>/<question_id>.json` (VLM path only — `symbolic_eval` writes to `results/symbolic/ground truth/...` below, not here) |
+| E | `results/E/<model>/<protocol>/<scene>/<question_id>.json` |
 | symbolic (production) | `results/symbolic/<depth>/<tracking>/<input_selection>/<frame_count>/<format>/<scene>/<question_id>.json` |
 | symbolic (ground truth) | `results/symbolic/ground truth/<format>/<scene>/<question_id>.json` |
 
@@ -190,11 +208,17 @@ harness's per-question record already shares the same shape):
 - `analysis/aggregate.py` — per-category MRA/accuracy scores via the *real* official
   VSI-Bench aggregator (never reimplemented, imported directly from
   `thinking-in-space`), plus latency/token/forced-answer telemetry. `--harness
-  {A,B,C,D}` or `--results-dir`; `--csv <path>` to export.
-- `analysis/compare.py` — joins A vs B vs C's aggregates on their shared `(model,
-  selection, frame_count)` dimensions into one side-by-side table (A has no
-  spatial_code_format axis, so its score is shown once per row against every B/C
-  format at that row). `--csv <path>` to export.
+  {A,B,C,D,E}` or `--results-dir`; `--csv <path>` to export.
+- `analysis/compare.py` — joins every harness (A/B/C, plus D and E on their
+  `(model, protocol)` axes) into one side-by-side table, scored on the EXACT
+  question-id intersection of every cell in a row — never on mismatched question sets
+  (a harness that covered fewer scenes is compared only on the shared questions, with
+  each cell's full count reported alongside so coverage loss is a visible result).
+  `--csv <path>` to export.
+- `analysis/stats.py` — scene-clustered paired bootstrap for any two result cells:
+  observed mean-score delta plus a reproducible (fixed-seed) confidence interval over
+  the exact question intersection, resampling scenes (not questions, which are
+  correlated within a scene).
 
 ```bash
 python -m analysis.aggregate --harness B --csv b_scores.csv
@@ -315,7 +339,7 @@ python -m harness.A.launch --model NAME --frame-selection {uniform,selective} --
   [scene | --scenes a,b,c]
 
 python -m harness.A.sweep --models {NAME,...|all} --frame-selections {uniform,selective|all} \
-  --frames N,N,... [--results-dir DIR] [--rebuild] [scene | --scenes a,b,c]
+  --frames N,N,... [--results-dir DIR] [--rebuild] [--extended] [scene | --scenes a,b,c]
 ```
 
 ### `harness/B` — spatial code only (text)
@@ -336,8 +360,9 @@ python -m harness.B.sweep --models {NAME,...|all} --spatial-code-formats {explic
   [--depths {relative,metric|all}] [--trackings {tracking,"no tracking"|all}] \
   [--results-dir DIR] [--rebuild] [scene | --scenes a,b,c]
 ```
-B always runs the extended protocol (`answer_extended`) — there's no `--extended` flag
-because it's the standing default, not opt-in.
+B defaults to the extended protocol (`answer_extended`); pass `--base-protocol` (on
+`run`/`launch`/`sweep`) to run harness.A's exact fixed 16-token protocol instead —
+needed for the protocol × representation cells of H7/H11/H18.
 
 ### `harness/C` — frames + spatial code
 
@@ -364,7 +389,7 @@ python -m harness.D.launch --model NAME --spatial-code-format {explicit,compact}
   [--results-dir DIR] [--rebuild] [scene | --scenes a,b,c]
 
 python -m harness.D.sweep --models {NAME,...|all} [--spatial-code-formats {explicit,compact|all}] \
-  [--results-dir DIR] [--rebuild] [scene | --scenes a,b,c]
+  [--results-dir DIR] [--rebuild] [--base-protocol] [scene | --scenes a,b,c]
 
 # perfect-information ceiling: real symbolic solver directly on ground-truth codes, no VLM
 # writes into results/symbolic/ground truth/<format>/... (not results/D/...)
@@ -372,15 +397,82 @@ python -m harness.D.symbolic_eval --spatial-code-format {explicit,compact} \
   [--limit N] [--results-dir DIR] [--no-write] [scene | --scenes a,b,c]
 ```
 
+### `harness/E` — the blind floor (question only)
+
+No scene input of any kind — question (and options) plus the standard post-prompt is
+the entire prompt. Base 16-token protocol by default, `--extended` opt-in, same as A:
+
+```bash
+python -m harness.E.run --model NAME [--scene ID] [--limit N] [--device cuda] \
+  [--results-dir DIR] [--no-write] [--extended] [--reasoning-budget N] [--force-budget N]
+
+python -m harness.E.launch --model NAME [--results-dir DIR] [--rebuild] [--extended] \
+  [scene | --scenes a,b,c]
+
+python -m harness.E.sweep --models {NAME,...|all} [--results-dir DIR] [--rebuild] \
+  [--extended] [scene | --scenes a,b,c]
+```
+
 ### `analysis/` — aggregation and comparison
 
 ```bash
-python -m analysis.aggregate --harness {A,B,C,D} [--csv PATH] [--json]
+python -m analysis.aggregate --harness {A,B,C,D,E} [--csv PATH] [--json]
 python -m analysis.aggregate --results-dir DIR [--csv PATH] [--json]   # explicit path instead
 python -m analysis.compare [--a-results-dir DIR] [--b-results-dir DIR] [--c-results-dir DIR] \
-  [--csv PATH] [--json]
+  [--d-results-dir DIR] [--e-results-dir DIR] [--csv PATH] [--json]
+
+# scene-clustered paired bootstrap: delta, CI, and two-sided p-value; the primary
+# hypothesis family is corrected with analysis.stats.holm_bonferroni
+python -m analysis.stats --x-dir <baseline cell dir> --y-dir <comparison cell dir> \
+  [--iterations N] [--seed N] [--confidence 0.95]
+
+# H26: solver-certified sufficiency decomposition of one VLM cell
+python -m analysis.sufficiency --vlm-dir <B cell> --solver-dir <matching symbolic cell> \
+  [--threshold 1.0] [--exclude obj_appearance_order,route_planning] [--json]
+
+# H23: deterministic chain-of-thought audit (no LLM judge) over B/D extended records
+python -m analysis.cot_audit --results-dir <B or D cell> [--tolerance 0.01] [--json]
+
+# H19 (exploratory): solved-set overlap across cells, exact question intersection
+python -m analysis.solvability --cell A=<dir> --cell B=<dir> [--threshold 1.0] [--json]
+
+# H25: solver computation-depth vs VLM accuracy (pass base + extended cells to read
+# the depth x protocol interaction)
+python -m analysis.depth --results-dir <cell> [--results-dir <cell2>] [--json]
 ```
 
+### `corruption/` — perception-error mechanics (Theme 8)
+
+Transforms always act on the COMPACT ground-truth code; the requested format is then
+derived through encoder's own `_explicit_from_compact`, so corrupted formats can
+never disagree. The VLM arm reuses `harness.D.run` unmodified (its `code_transform`
+hook); the solver arm is free (CPU). `--sample` enforces the pre-registered
+question sample:
+
+```bash
+# one condition, either arm
+python -m corruption.run --arm {vlm,solver} --transform NAME --magnitude M \
+  [--model NAME] [--spatial-code-format {explicit,compact}] [--scenes a,b,c] \
+  [--sample analysis/corruption_sample.json] [--results-dir DIR]
+
+# H24's certification gate: only (scene, transform, magnitude) triples the solver
+# certifies answer-preserving enter the invariance analysis
+python -m corruption.run --arm certify --transform {translate,rotate-z,reorder,round-precision} \
+  --magnitude M --scenes a,b,c
+
+# grid looper (Step 6.5): solver arm always, VLM arm per model
+python -m corruption.launch --arm both --models qwen3.5-4b,internvl3.5-4b \
+  --transforms position-jitter,dimension-noise,drop-objects,hallucinate-objects \
+  --magnitudes 0.1,0.25,0.5,1.0 --sample analysis/corruption_sample.json
+```
+
+Transform names: noise = `position-jitter`, `dimension-noise`, `drop-objects`,
+`hallucinate-objects`, `class-swap`, `empirical` (sampled from the measured SAM3+DA3
+residual distribution; magnitude = scale, 1.0 = the real operating point); chimera =
+`chimera-gt-inventory`, `chimera-perceived-inventory` (H22); probes = `single-object`
+(H6), `wrong-scene`; invariance (H24) = `translate`, `rotate-z`, `reorder`,
+`round-precision`.
+
 ### `tests/`
 
 ```bash
@@ -427,6 +519,28 @@ that makes it a *measurable* claim rather than a plausible-sounding one — a re
 control, a shared record schema, an already-logged telemetry field, or a provable
 derivation — not just an assertion resting on the experiment "probably" working.
 
+Not every hypothesis below has equal standing, and the run plan says so explicitly.
+The full frozen classification (with directions, exclusions, and the corruption-arm
+sample definition) lives in [`analysis/preregistration.md`](analysis/preregistration.md),
+committed and backed up BEFORE any scheduled run executes. Summary:
+
+- **Novel primary (Holm–Bonferroni-corrected family, all cells scheduled)**: H7 (the
+  protocol × representation interaction) and Theme 8's H21–H26 below. These six are
+  the program's literature-checked novel claims.
+- **Confirmatory (rigorously tested, but extensions of the two source papers)**:
+  H1–H5, H10–H13. H1's headline read is E-corrected (gain over the blind floor, not
+  over zero) and every cross-harness delta is computed on matched question sets
+  (`analysis.compare`) with scene-clustered bootstrap CIs (`analysis.stats`).
+- **Supporting**: H27 (format-flip brittleness under certified sufficiency).
+- **Exploratory (reported as observations, not tests)**: H8, H9 (telemetry,
+  difficulty-confounded), H17, H18 (two families / one scale pair), H19 (solved-set
+  overlap — established methodology applied here), H20.
+- **Out of scope by design**: H14, H16 (secondary sweeps, unscheduled); H15 (Step 2
+  builds codes for the winning frame selection only — the second perception cache is
+  deliberately not funded); H6 runs as a corruption-module probe but its topic
+  (text-over-vision anchoring) is established literature, so it is reported as an
+  instantiation, not a novel claim.
+
 Anchor findings the hypotheses are grounded in: VSI-Bench's own manual error analysis
 attributes ~71% of MLLM errors to spatial reasoning (40% relational, 31%
 egocentric-allocentric transform), ~15% to perception, ~14% to language; chain-of-thought
@@ -500,15 +614,18 @@ reasoning capacity, was their binding constraint.
   harness with a single `--spatial-code-format` flag, at identical scenes/questions.
 - **H12 — verbosity × capacity.** Compact's fuller schema helps 4B, hurts 2B.
   *Justified by*: same mechanism as H11, cut by model instead of protocol.
-- **H13 — schema-grounding (the cleanest control in this whole program).** Any
-  B(explicit) vs. B(compact) gap is *purely presentational*, because explicit is now a
-  provable, mechanical derivation of compact — same shared `_explicit_from_compact`
-  function regardless of source. *Justified by*: this isn't an assumption; it was
-  empirically verified (0 mismatches across every measured field: positions,
-  dimensions, distance table, floor area, appearance order) after fixing a real
-  orientation-vector renormalization bug that briefly broke the guarantee. With
-  information content mathematically pinned equal, any residual B(explicit)-vs-B(compact)
-  gap can *only* be a presentation effect — a control neither source paper could run.
+- **H13 — consistency-by-construction (the cleanest control in this program).** The
+  two formats can never *disagree* about a scene's geometry: explicit is a provable,
+  mechanical derivation of compact — the same shared `_explicit_from_compact` function
+  regardless of source, empirically verified (0 mismatches across every measured
+  field: positions, dimensions, distance table, floor area, appearance order) after
+  fixing a real orientation-vector renormalization bug that briefly broke the
+  guarantee. Note what this does NOT claim: the formats are not informationally
+  equal — compact carries per-instance orientation vectors explicit drops, and
+  explicit carries precomputed derivations (distance table, floor area, appearance
+  order) compact leaves implicit. A B(explicit)-vs-B(compact) gap is therefore
+  presentation + computation-offloading + that field difference — with *inconsistency*
+  ruled out by construction, which is the part neither source paper could rule out.
 
 ### Theme 5 — Perception inputs (frame selection and count)
 
@@ -549,17 +666,74 @@ reasoning capacity, was their binding constraint.
   directly comparable because B is evaluated by the exact same official scorer and
   category breakdown the source paper itself used.
 
-### Plan D and the perfect-information ceiling (cross-cutting)
+### Theme 8 — Perception-error mechanics and solver-certified analysis (novel core)
+
+These ride on the `corruption/` module (parameterized transformations of spatial
+codes fed through harness.D's unmodified prompt path) and on the deterministic
+solver's unique role as a per-question certification instrument. All corruption arms
+use one shared, pre-registered ~600-question sample (7 categories, appearance order
+excluded for circularity; see `analysis/preregistration.md`).
+
+- **H21 — perception-requirements curve.** VLM accuracy vs. calibrated corruption of
+  ground-truth codes (position jitter, dimension noise, dropped/hallucinated
+  objects, class swaps), with one corruption mode sampled from the REAL SAM3+DA3
+  residual distribution (measured per class from perceived-vs-GT code pairs), not
+  just iid Gaussian. *Validation*: the synthetic curve must predict B's real
+  measured accuracy at the pipeline's measured error level — a held-out test, since
+  B's numbers are never used in fitting. Inverted, the curves give per-category
+  perception tolerance specs. The solver runs the same corrupted codes for free, so
+  soft (VLM) vs. brittle (formula) degradation is compared on identical input.
+- **H22 — chimera decomposition.** Hybrid codes — ground-truth object inventory with
+  perceived geometry, and the reverse — causally split the B→D gap into detection-
+  error cost vs. geometric-error cost, per category. Interventional, where existing
+  error taxonomies are observational.
+- **H23 — deterministic chain-of-thought audit.** Every number in B/D's logged
+  ``reasoning_text`` is mechanically checked against the exact code the model was
+  given — no LLM judge — decomposing wrong answers into retrieval errors (cited a
+  value not in the code), transcription errors (right field, wrong value), and
+  computation errors (correct values, wrong arithmetic). Impossible with pixel
+  input; pure post-hoc analysis over records the scheduled runs already produce.
+- **H24 — coordinate-frame invariance.** Solver-certified answer-preserving
+  re-parameterizations (origin translation, frame rotation, unit conversion, object
+  reorder, precision rounding) change ZERO information; any accuracy drop is
+  measured representation-frame brittleness. The solver's identical answers on the
+  transformed code are the proof the transformation was truly null.
+- **H25 — computation-depth transfer.** The solver logs its per-question operation
+  count (an executable difficulty metric, not a human annotation); prediction: VLM
+  accuracy declines with depth, and H7's extended-protocol benefit concentrates in
+  high-depth questions. Zero new runs.
+- **H26 — sufficiency-certificate decomposition.** The solver, run on the identical
+  perceived code B saw (free, CPU), certifies per question whether the answer is
+  derivably present. Conditioning every B comparison on that certificate separates
+  PROVEN reasoning failures (solver-correct, VLM-wrong) from PROVEN information
+  failures (solver-wrong) — a per-question certified split no correlational error
+  analysis can make.
+- **H27 (supporting) — format-flip brittleness.** Restricted to questions the solver
+  answers correctly from BOTH formats (information certified sufficient in both
+  presentations), any B(explicit)-vs-B(compact) answer flip is pure presentation
+  sensitivity with semantics held provably fixed.
+
+### Plan D and the deterministic-solver ceiling (cross-cutting)
 
 Every hypothesis above that concerns *encoder* error rather than *reasoning* error (H1,
 H4, H6, H7, H11, H13) gets an additional, sharper cross-check for free: D re-answers B's
-same questions with a **ground-truth** spatial code instead of a perceived one, and
-`harness/D/symbolic_eval.py` additionally answers them with the deterministic solver —
-the perfect-geometry-and-perfect-reasoning ceiling. Any B→D gap at matched format is
-attributable to perception error, not reasoning error, because nothing else changes
-between the two runs (same prompt structure, same model, same questions) — this is the
-concrete mechanism behind "how much of the gap is imperfect perception" in this
-project's opening claim.
+same questions with a **ground-truth** spatial code instead of a perceived one (B and
+D's prompts are byte-identical — only the file loaded changes), and
+`harness/D/symbolic_eval.py` additionally answers them with the deterministic solver:
+perfect geometry plus deterministic, formula-driven reasoning. Any B→D gap at matched
+format is attributable to perception error, not reasoning error, because nothing else
+changes between the two runs — this is the concrete mechanism behind "how much of the
+gap is imperfect perception" in this project's opening claim.
+
+Two caveats bound what the solver run may be called: it is a *deterministic solver*
+ceiling, not a perfect-reasoning one — its route_planning parser scores ~3% on
+ground-truth codes (far below even option-guessing), so per-category it is only a
+valid ceiling where the solver actually performs — and its `obj_appearance_order`
+score is circular (see the ground-truth circularity note in the `encoder/` section)
+and must be excluded from ceiling claims. Chained with E (the blind floor) and B, the
+valid categories give a fully measured per-category error budget:
+E → B → D → solver = priors → +perceived geometry → +perfect geometry → +deterministic
+reasoning.
 
 ---
 
@@ -572,6 +746,8 @@ selection, and spatial-code format would otherwise multiply the run count far be
 what's needed to answer the hypotheses above.
 
 **Step 1 — Plan A decides frame count and input selection.**
+*Hypotheses fed*: baseline arm of H1/H3/H7/H19; the selective-vs-uniform readout is a
+within-benchmark check of the known keyframe-selection effect (confirmatory).
 
 ```bash
 python -m harness.A.sweep --models all --frame-selections all --frames 16,32,64
@@ -590,6 +766,17 @@ better than 32-frame ones for the encoder side either — the tie-break isn't a
 coin-flip, it's backed by evidence already in hand from a different part of this
 project.
 
+**Step 1.5 — Blind floor, any time (near-free).**
+
+```bash
+python -m harness.E.sweep --models all
+```
+
+*Hypotheses fed*: the prior-knowledge floor every gain claim is corrected against,
+and the contamination probe (E far above the paper's published blind baselines =
+leakage evidence). Run it FIRST — it is the cheapest run in the program and its
+contamination readout is worth having before burning the big sweeps.
+
 **Step 2 — Regenerate spatial codes at the winning config, immediately after Step 1.**
 
 This has to happen right after Plan A, *before* Plan B, not later: only 72 of
@@ -601,6 +788,13 @@ to be `uniform` (not `selective`), this step is gated on building the SAM3 raw
 masklet cache for uniform-mode sampling first, since that cache currently only exists
 for `selective`.
 
+Immediately after Step 2, also run the ZERO-GPU solver pass over the regenerated
+perceived codes (`symbolic.launch` at the frozen config, both formats) — this is
+H26's sufficiency certificate and H27's dual-sufficiency filter, and it must exist
+before B's results are analyzed. Commit the realized corruption-arm question sample
+to `analysis/preregistration.md` at this point (procedure and seed are already
+frozen there).
+
 **Step 3 — Plan B decides spatial-code format.**
 
 ```bash
@@ -611,6 +805,10 @@ python -m harness.B.sweep --models all --spatial-code-formats all \
 6 configs (3 models × {explicit, compact}), input selection and frame count fixed from
 Step 1. Aggregate with `analysis.aggregate --harness B`; average "overall" per format
 across the 3 models — the argmax format is `format*`.
+*Hypotheses fed*: H1–H3 (vs A and E), H11–H13, H12; B's extended traces are H23's
+audit corpus and H25's depth-transfer corpus; B's real accuracy at the pipeline's
+measured error level is H21's held-out prediction target; every B comparison is
+conditioned on H26's certificate.
 
 **Step 4 — Plan C runs the fully-fixed config.**
 
@@ -620,6 +818,7 @@ python -m harness.C.sweep --models all --spatial-code-formats <format*> \
 ```
 
 3 configs (one per model) — every non-model axis is now fixed by Steps 1–3.
+*Hypotheses fed*: H4, H5; C's cells complete H7's representation axis.
 
 **Step 5 — Plan D: the ground-truth ceiling, run any time after Step 1.**
 
@@ -636,21 +835,71 @@ annotation-only). Running both is the only way to see whether B's real-perceptio
 format ranking still holds under perfect information. D has no dependency on Steps 2–4
 completing — it can run in parallel with them, since ground truth needs no perceived
 spatial code at all.
+*Hypotheses fed*: the B→D perception-error split (byte-identical prompts) and the
+solver ceiling; D's traces join H23's audit corpus. `obj_appearance_order` is
+excluded from every D/ceiling claim (circularity — see `encoder/` section).
+
+**Step 6 — Protocol controls and the blind floor, after Steps 3–4, at the frozen
+config.** These 15 runs de-confound the headline comparisons (they are what makes H1 a
+single-manipulation comparison and H7 a complete 2×2, and they establish the
+prior-knowledge floor E):
+
+```bash
+# A under the extended protocol (3 runs) -- so A-vs-B/C can be compared at MATCHED
+# protocol, not 16-token-A vs extended-B
+python -m harness.A.sweep --models all --frame-selections <selection*> --frames <frames*> --extended
+
+# B under the base 16-token protocol, BOTH formats (6 runs) -- completes H7's
+# protocol x representation grid and H11's 16-token cell
+python -m harness.B.sweep --models all --spatial-code-formats all \
+  --input-selections <selection*> --frames <frames*> --base-protocol
+
+# C under the base 16-token protocol, winning format (3 runs)
+python -m harness.C.sweep --models all --spatial-code-formats <format*> \
+  --input-selections <selection*> --frames <frames*> --base-protocol
+
+# The blind floor's extended arm (3 runs) -- the E-base runs happened at Step 1.5;
+# extended-E is the "does reasoning help with nothing but priors" control for H7
+python -m harness.E.sweep --models all --extended
+```
 
-**Step 6 — Analysis, after every stage, not gated on the whole plan finishing.**
+*Hypotheses fed*: these cells complete H7's 2×2 (the headline novel interaction),
+H10, H11's 16-token half, and H18's base-protocol read.
+
+**Step 6.5 — Corruption arms, after Step 2 (sample) and alongside Step 6.**
+
+All on the one pre-registered ~600-question sample, extended protocol, ground-truth
+base codes; the solver runs every arm at zero GPU cost as the second reasoner:
+
+```bash
+# H21: 4 corruption types x 4 magnitudes, BOTH 4B models (~19k generations),
+#      including the empirical-residual noise mode calibrated from Step 2's codes
+# H22: 2 chimera conditions (GT inventory x perceived geometry, and the reverse)
+# H24: 5 solver-certified answer-preserving re-parameterizations
+# H6 probe + wrong-scene control + serialization/wording robustness: 1 model each
+python -m corruption.launch ...   # see corruption/ docs once built
+```
+
+*Hypotheses fed*: H21, H22, H24 (novel primary); H6 instantiation; the wrong-code
+and robustness controls that close the "does the model even read the code" and
+"is it a prompt artifact" objections.
+
+**Step 7 — Analysis, after every stage, not gated on the whole plan finishing.**
 
 ```bash
 python -m analysis.compare --csv comparison.csv
 ```
 
+*Hypotheses fed here with ZERO new runs*: H23 (`analysis/cot_audit.py` over B/D
+traces), H25 (solver depth vs. VLM accuracy), H26 (certificate conditioning), H27
+(dual-sufficiency format flips), H8/H9/H17–H20 (exploratory).
+
 Cross-harness comparison (A vs. B vs. C at the frozen config) plus every telemetry-only
 hypothesis (H8, H9, H19, H20) that needs no new runs, just the JSONs already on disk.
 
-**Optional follow-ons**, pursued only if the headline results above warrant it:
+**Optional follow-ons**, pursued only if the headline results above warrant it (the
+16-token-vs-extended comparison itself is NOT optional anymore — Step 6 schedules it):
 
-- Re-run Steps 3–4 a second time under the *extended* protocol at the same frozen
-  config, to get the 16-token-vs-extended comparison (H7, H10) without reopening the
-  config-selection question.
 - The H6 perturbation probe: clone harness C's prompt path with one object's
   position/size perturbed in the injected code, on a sample of questions from the
   frozen C config.

analysis/aggregate.py

@@ -27,12 +27,14 @@ from harness.A.run import vsi_official_eval  # noqa: E402
 from harness.B import RESULTS_DIR as HARNESS_B_RESULTS_DIR  # noqa: E402
 from harness.C import RESULTS_DIR as HARNESS_C_RESULTS_DIR  # noqa: E402
 from harness.D import RESULTS_DIR as HARNESS_D_RESULTS_DIR  # noqa: E402
+from harness.E import RESULTS_DIR as HARNESS_E_RESULTS_DIR  # noqa: E402
 
 RESULTS_DIRS = {
     "A": HARNESS_A_RESULTS_DIR,
     "B": HARNESS_B_RESULTS_DIR,
     "C": HARNESS_C_RESULTS_DIR,
     "D": HARNESS_D_RESULTS_DIR,
+    "E": HARNESS_E_RESULTS_DIR,
 }
 
 
@@ -200,7 +202,7 @@ def main():
     group = parser.add_mutually_exclusive_group(required=True)
     group.add_argument(
         "--harness", choices=sorted(RESULTS_DIRS),
-        help="aggregate one harness's default results directory (A, B, or C)",
+        help="aggregate one harness's default results directory (A, B, C, D, or E)",
     )
     group.add_argument("--results-dir", default=None, help="aggregate an explicit directory")
     parser.add_argument(

analysis/compare.py

@@ -1,10 +1,18 @@
-"""Join harness.A/B/C's aggregated results on the dimensions they share -- model,
-frame/input selection, frame count -- into one side-by-side comparison: frames only (A)
-vs spatial-code text only (B, per format) vs both together (C, per format).
-
-harness.A has no spatial_code_format axis (it never touches a spatial code at all), so
-its score is shown once per (model, selection, frame_count) row and compared against
-every spatial_code_format column harness.B/C have results for at that same row.
+"""Join every harness's per-question results into one side-by-side comparison, on the
+EXACT INTERSECTION of answered questions -- never on mismatched question sets.
+
+Rows are keyed by (model, protocol, input/frame selection, frame count) -- the axes
+harness.A and harness.B/C share. harness.D (ground truth) has no selection/frame axis
+and harness.E (blind floor) has no scene input at all, so their scores join each row on
+(model, protocol) alone. Every score in a row is recomputed over only the question_ids
+answered by EVERY cell present in that row, so a harness that covered fewer scenes
+(e.g. B, gated on which scenes have a spatial code on disk) can never be compared
+against a different, easier or harder question mix -- the row also reports how many
+questions that shared set holds versus each cell's full count, so coverage loss is a
+visible result, not a silent one.
+
+Column labels for B/C carry the full format:depth:tracking identity, so two different
+depth/tracking runs of the same format never silently merge.
 """
 
 from __future__ import annotations
@@ -13,94 +21,143 @@ import argparse
 import csv
 import json
 import sys
+from collections import defaultdict
 from pathlib import Path
 
 WORKSPACE_ROOT = Path(__file__).resolve().parent.parent
 if str(WORKSPACE_ROOT) not in sys.path:
     sys.path.insert(0, str(WORKSPACE_ROOT))
 
-from analysis.aggregate import RESULTS_DIRS, aggregate, iter_records  # noqa: E402
-
-
-def _parse_a_key(key):
-    """"<model>/<frame_selection>:<frame_count>" -> (model, selection, frame_count)."""
-    model, condition = key.split("/", 1)
-    selection, frame_count = condition.split(":")
-    return model, selection, frame_count
-
-
-def _parse_bc_key(key):
-    """"<model>/<format>:<selection>:<frame_count>" -> (model, format, selection, frame_count)."""
-    model, condition = key.split("/", 1)
-    spatial_code_format, selection, frame_count = condition.split(":")
-    return model, spatial_code_format, selection, frame_count
-
-
-def compare(a_results_dir=None, b_results_dir=None, c_results_dir=None):
-    """Return {(model, selection, frame_count): {"A": overall_or_None,
-    "B": {format: overall}, "C": {format: overall}}} for every row any of the three
-    harnesses has results for."""
-    a_aggregated = aggregate(iter_records(a_results_dir or RESULTS_DIRS["A"]))
-    b_aggregated = aggregate(iter_records(b_results_dir or RESULTS_DIRS["B"]))
-    c_aggregated = aggregate(iter_records(c_results_dir or RESULTS_DIRS["C"]))
+from analysis.aggregate import RESULTS_DIRS, _official_scores, iter_records  # noqa: E402
+
+
+def _cells(records):
+    """Group records into {(model, condition): {question_id: record}} cells."""
+    cells = defaultdict(dict)
+    for record in records:
+        cells[(record["model"], record["condition"])][record["question_id"]] = record
+    return dict(cells)
+
+
+def _parse_a_condition(condition):
+    """"<protocol>:<selection>:<frames>" -> (protocol, selection, frames)."""
+    protocol, selection, frames = condition.split(":")
+    return protocol, selection, frames
+
+
+def _parse_bc_condition(condition):
+    """"<protocol>:<format>:<depth>:<tracking>:<input>:<frames>" ->
+    (protocol, format, depth, tracking, input_selection, frames)."""
+    protocol, fmt, depth, tracking, input_selection, frames = condition.split(":")
+    return protocol, fmt, depth, tracking, input_selection, frames
+
+
+def _parse_d_condition(condition):
+    """"<protocol>:<format>" -> (protocol, format)."""
+    protocol, fmt = condition.split(":")
+    return protocol, fmt
+
+
+def compare(
+    a_results_dir=None,
+    b_results_dir=None,
+    c_results_dir=None,
+    d_results_dir=None,
+    e_results_dir=None,
+):
+    """Return {(model, protocol, selection, frames): row} where every row holds, for
+    every cell present, {"overall": score-on-shared-questions, "full_count": that
+    cell's own total} under "A", "E", and per-column "B"/"C"/"D" dicts, plus
+    "common_count" (the shared question-intersection size every overall was computed
+    on). Cells are matched on question_id intersection across ALL cells in the row."""
+    a_cells = _cells(iter_records(a_results_dir or RESULTS_DIRS["A"]))
+    b_cells = _cells(iter_records(b_results_dir or RESULTS_DIRS["B"]))
+    c_cells = _cells(iter_records(c_results_dir or RESULTS_DIRS["C"]))
+    d_cells = _cells(iter_records(d_results_dir or RESULTS_DIRS["D"]))
+    e_cells = _cells(iter_records(e_results_dir or RESULTS_DIRS["E"]))
+
+    # Assemble each row's member cells first; scores only get computed after the row's
+    # shared question set is known.
+    rows_members = defaultdict(dict)  # row_key -> {column_name: question_map}
+
+    for (model, condition), questions in a_cells.items():
+        protocol, selection, frames = _parse_a_condition(condition)
+        rows_members[(model, protocol, selection, frames)]["A"] = questions
+
+    for harness, cells in (("B", b_cells), ("C", c_cells)):
+        for (model, condition), questions in cells.items():
+            protocol, fmt, depth, tracking, input_selection, frames = _parse_bc_condition(
+                condition
+            )
+            row_key = (model, protocol, input_selection, frames)
+            rows_members[row_key][f"{harness}_{fmt}:{depth}:{tracking}"] = questions
+
+    # D and E have no selection/frame axis: join them onto every row sharing their
+    # (model, protocol).
+    for row_key in list(rows_members):
+        model, protocol, _selection, _frames = row_key
+        for (d_model, condition), questions in d_cells.items():
+            d_protocol, fmt = _parse_d_condition(condition)
+            if (d_model, d_protocol) == (model, protocol):
+                rows_members[row_key][f"D_{fmt}"] = questions
+        for (e_model, condition), questions in e_cells.items():
+            if (e_model, condition) == (model, protocol):
+                rows_members[row_key]["E"] = questions
 
     rows = {}
-
-    def _row(row_key):
-        return rows.setdefault(row_key, {"A": None, "B": {}, "C": {}})
-
-    for key, stats in a_aggregated.items():
-        model, selection, frame_count = _parse_a_key(key)
-        _row((model, selection, frame_count))["A"] = stats["official"].get("overall")
-
-    for key, stats in b_aggregated.items():
-        model, spatial_code_format, selection, frame_count = _parse_bc_key(key)
-        _row((model, selection, frame_count))["B"][spatial_code_format] = (
-            stats["official"].get("overall")
-        )
-
-    for key, stats in c_aggregated.items():
-        model, spatial_code_format, selection, frame_count = _parse_bc_key(key)
-        _row((model, selection, frame_count))["C"][spatial_code_format] = (
-            stats["official"].get("overall")
-        )
-
+    for row_key, members in rows_members.items():
+        common_ids = None
+        for questions in members.values():
+            ids = set(questions)
+            common_ids = ids if common_ids is None else common_ids & ids
+        common_ids = common_ids or set()
+        row = {"common_count": len(common_ids), "cells": {}}
+        for column, questions in members.items():
+            shared = [questions[qid] for qid in common_ids]
+            row["cells"][column] = {
+                "overall": _official_scores(shared).get("overall") if shared else None,
+                "full_count": len(questions),
+            }
+        rows[row_key] = row
     return rows
 
 
 def flatten_rows(rows):
-    """Flatten compare()'s {(model, selection, frame_count): {...}} into one flat dict
-    per row -- "model", "selection", "frames", "A", and "B_<format>"/"C_<format>" for
-    every spatial_code_format any row has a B or C score for -- for csv.DictWriter."""
-    formats = sorted({fmt for row in rows.values() for fmt in {*row["B"], *row["C"]}})
+    """Flatten compare()'s output into one flat dict per row for csv.DictWriter --
+    "model", "protocol", "selection", "frames", "common_count", then one score column
+    per cell name plus a matching "<cell>_full_count" coverage column."""
+    columns = sorted({column for row in rows.values() for column in row["cells"]})
     flat = []
-    for (model, selection, frame_count), row in rows.items():
+    for (model, protocol, selection, frames), row in rows.items():
         flat_row = {
             "model": model,
+            "protocol": protocol,
             "selection": selection,
-            "frames": frame_count,
-            "A": row["A"],
+            "frames": frames,
+            "common_count": row["common_count"],
         }
-        for fmt in formats:
-            flat_row[f"B_{fmt}"] = row["B"].get(fmt)
-            flat_row[f"C_{fmt}"] = row["C"].get(fmt)
+        for column in columns:
+            cell = row["cells"].get(column)
+            flat_row[column] = cell["overall"] if cell else None
+            flat_row[f"{column}_full_count"] = cell["full_count"] if cell else None
         flat.append(flat_row)
     return flat
 
 
 def write_csv(rows, path):
-    """Write compare()'s output to ``path`` as CSV, one row per (model, selection,
-    frame_count), columns "model", "selection", "frames", "A", then "B_<format>" and
-    "C_<format>" for every spatial_code_format present."""
+    """Write compare()'s output to ``path`` as CSV, one row per (model, protocol,
+    selection, frames)."""
     flat = flatten_rows(rows)
-    formats = sorted({fmt for row in rows.values() for fmt in {*row["B"], *row["C"]}})
-    fieldnames = ["model", "selection", "frames", "A"]
-    for fmt in formats:
-        fieldnames += [f"B_{fmt}", f"C_{fmt}"]
+    columns = sorted({column for row in rows.values() for column in row["cells"]})
+    fieldnames = ["model", "protocol", "selection", "frames", "common_count"]
+    for column in columns:
+        fieldnames += [column, f"{column}_full_count"]
     with open(path, "w", newline="", encoding="utf-8") as stream:
         writer = csv.DictWriter(stream, fieldnames=fieldnames, restval="")
         writer.writeheader()
-        for row in sorted(flat, key=lambda r: (r["model"], r["selection"], r["frames"])):
+        for row in sorted(
+            flat, key=lambda r: (r["model"], r["protocol"], r["selection"], r["frames"])
+        ):
             writer.writerow(row)
 
 
@@ -109,16 +166,15 @@ def _format_score(value):
 
 
 def _print_report(rows):
-    formats = sorted({fmt for row in rows.values() for fmt in {*row["B"], *row["C"]}})
-    header = ["model", "selection", "frames", "A(frames)"]
-    for fmt in formats:
-        header += [f"B({fmt})", f"C({fmt})"]
+    columns = sorted({column for row in rows.values() for column in row["cells"]})
+    header = ["model", "protocol", "selection", "frames", "common_n"] + columns
     print(" | ".join(header))
-    for (model, selection, frame_count), row in sorted(rows.items()):
-        line = [model, selection, frame_count, _format_score(row["A"])]
-        for fmt in formats:
-            line.append(_format_score(row["B"].get(fmt)))
-            line.append(_format_score(row["C"].get(fmt)))
+    for row_key in sorted(rows):
+        row = rows[row_key]
+        line = list(row_key) + [str(row["common_count"])]
+        for column in columns:
+            cell = row["cells"].get(column)
+            line.append(_format_score(cell["overall"]) if cell else "-")
         print(" | ".join(line))
 
 
@@ -127,6 +183,8 @@ def main():
     parser.add_argument("--a-results-dir", default=None)
     parser.add_argument("--b-results-dir", default=None)
     parser.add_argument("--c-results-dir", default=None)
+    parser.add_argument("--d-results-dir", default=None)
+    parser.add_argument("--e-results-dir", default=None)
     parser.add_argument(
         "--json", action="store_true", help="print the full comparison dict as JSON instead"
     )
@@ -134,18 +192,18 @@ def main():
         "--csv", default=None, help="also write the comparison table to this CSV path"
     )
     args = parser.parse_args()
-    rows = compare(args.a_results_dir, args.b_results_dir, args.c_results_dir)
+    rows = compare(
+        args.a_results_dir, args.b_results_dir, args.c_results_dir,
+        args.d_results_dir, args.e_results_dir,
+    )
     if not rows:
-        print("no result records found in any of harness.A/B/C's results directories")
+        print("no result records found in any harness's results directory")
         return
     if args.csv:
         write_csv(rows, args.csv)
         print(f"wrote {args.csv}")
     if args.json:
-        json_rows = {
-            f"{model}/{selection}/{frame_count}": value
-            for (model, selection, frame_count), value in rows.items()
-        }
+        json_rows = {"/".join(row_key): value for row_key, value in rows.items()}
         print(json.dumps(json_rows, indent=1))
     else:
         _print_report(rows)

analysis/cot_audit.py

@@ -0,0 +1,171 @@
+"""H23: the deterministic chain-of-thought audit -- no LLM judge anywhere.
+
+Because B/D's input is a symbolic code, every number the model writes in its logged
+``reasoning_text`` can be mechanically checked against the exact code it was given
+(re-read from each record's own ``spatial_code_path``). Per record this yields:
+
+- cited_numbers: every numeric literal in the reasoning trace
+- grounded: cited numbers that appear in the code (within rounding tolerance), the
+  question/options text, or the trivial-arithmetic whitelist (small integers 0-12,
+  which are usually counts/steps the model computed, not values it retrieved)
+- fabricated: cited numbers appearing in NONE of those sources -- the model asserted
+  a quantity its input never contained
+
+Aggregated over wrong answers, the fabrication rate separates retrieval/transcription
+failure (the trace itself cites values not in the input) from computation/other
+failure (every cited value was real; the model combined them wrongly). This
+decomposition needs zero new runs -- it reads records the scheduled B/D extended runs
+already produce -- and involves no learned judge, so it cannot itself hallucinate.
+
+Usage:
+    python -m analysis.cot_audit --results-dir "results/B/qwen3.5-4b/extended/..." \\
+        [--tolerance 0.01] [--json]
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import re
+import sys
+from pathlib import Path
+
+WORKSPACE_ROOT = Path(__file__).resolve().parent.parent
+if str(WORKSPACE_ROOT) not in sys.path:
+    sys.path.insert(0, str(WORKSPACE_ROOT))
+
+from analysis.aggregate import iter_records  # noqa: E402
+
+_NUMBER_RE = re.compile(r"[-+]?\d+(?:\.\d+)?")
+_TRIVIAL_MAX = 12  # small integers are usually derived counts/steps, not retrievals
+
+
+def numbers_in(text):
+    """Every numeric literal in ``text`` as floats."""
+    return [float(match) for match in _NUMBER_RE.findall(text or "")]
+
+
+def _json_numbers(value, out):
+    if isinstance(value, bool):
+        return
+    if isinstance(value, (int, float)):
+        out.append(float(value))
+    elif isinstance(value, str):
+        out.extend(numbers_in(value))
+    elif isinstance(value, list):
+        for item in value:
+            _json_numbers(item, out)
+    elif isinstance(value, dict):
+        for key, item in value.items():
+            _json_numbers(key, out)
+            _json_numbers(item, out)
+
+
+def code_numbers(code):
+    """Every numeric value anywhere in a spatial-code dict (keys and unit strings
+    included -- a model quoting "4.98 meters" cites the number inside the string)."""
+    out = []
+    _json_numbers(code, out)
+    return out
+
+
+def _grounded(cited, sources, tolerance):
+    if abs(cited) <= _TRIVIAL_MAX and float(cited).is_integer():
+        return True
+    return any(
+        abs(cited - source) <= tolerance * max(1.0, abs(source)) for source in sources
+    )
+
+
+def audit_record(record, tolerance=0.01, code_cache=None):
+    """Audit one record's reasoning trace. Returns None when the record has no
+    reasoning text or its code file is unreadable; otherwise a dict with cited /
+    grounded / fabricated counts and the fabricated values themselves."""
+    reasoning = record.get("reasoning_text")
+    code_path = record.get("spatial_code_path")
+    if not reasoning or not code_path:
+        return None
+    code_cache = code_cache if code_cache is not None else {}
+    if code_path not in code_cache:
+        try:
+            with open(code_path, encoding="utf-8") as stream:
+                code_cache[code_path] = code_numbers(json.load(stream))
+        except OSError:
+            return None
+    sources = list(code_cache[code_path])
+    sources.extend(numbers_in(record.get("question")))
+    for option in record.get("options") or []:
+        sources.extend(numbers_in(option))
+    cited = numbers_in(reasoning)
+    fabricated = [
+        value for value in cited if not _grounded(value, sources, tolerance)
+    ]
+    return {
+        "question_id": record["question_id"],
+        "question_type": record["question_type"],
+        "score": record["score"],
+        "cited": len(cited),
+        "fabricated": len(fabricated),
+        "fabricated_values": fabricated,
+    }
+
+
+def audit(records, tolerance=0.01):
+    """Audit every auditable record; returns (per_record_audits, summary). The
+    summary splits wrong answers (score < 1) into fabrication-present vs
+    all-values-grounded -- H23's retrieval-vs-computation decomposition."""
+    code_cache = {}
+    audits = []
+    for record in records:
+        result = audit_record(record, tolerance, code_cache)
+        if result is not None:
+            audits.append(result)
+    wrong = [a for a in audits if a["score"] is not None and a["score"] < 1.0]
+    wrong_with_fabrication = [a for a in wrong if a["fabricated"] > 0]
+    summary = {
+        "audited": len(audits),
+        "wrong": len(wrong),
+        "wrong_with_fabrication": len(wrong_with_fabrication),
+        "fabrication_share_of_wrong": (
+            len(wrong_with_fabrication) / len(wrong) if wrong else None
+        ),
+        "mean_cited": (
+            sum(a["cited"] for a in audits) / len(audits) if audits else None
+        ),
+        "mean_fabricated": (
+            sum(a["fabricated"] for a in audits) / len(audits) if audits else None
+        ),
+    }
+    return audits, summary
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--results-dir", required=True)
+    parser.add_argument("--tolerance", type=float, default=0.01)
+    parser.add_argument("--json", action="store_true")
+    args = parser.parse_args()
+    audits, summary = audit(iter_records(args.results_dir), tolerance=args.tolerance)
+    if args.json:
+        print(json.dumps({"summary": summary, "audits": audits}, indent=1))
+        return
+    print(f"audited records (with reasoning + readable code): {summary['audited']}")
+    print(f"wrong answers: {summary['wrong']}")
+    print(
+        f"wrong WITH fabricated citations (retrieval/transcription failure): "
+        f"{summary['wrong_with_fabrication']}"
+    )
+    if summary["fabrication_share_of_wrong"] is not None:
+        print(
+            f"fabrication share of wrong answers: "
+            f"{summary['fabrication_share_of_wrong']:.3f}"
+        )
+    if summary["mean_cited"] is not None:
+        print(
+            f"mean cited numbers per trace: {summary['mean_cited']:.1f} "
+            f"(mean fabricated: {summary['mean_fabricated']:.2f})"
+        )
+
+
+if __name__ == "__main__":
+    main()

analysis/depth.py

@@ -0,0 +1,108 @@
+"""H25: computation-depth transfer -- the solver's per-question operation count as
+an executable difficulty metric, joined against VLM accuracy.
+
+For each VLM record, the solver re-answers the identical question from the identical
+code (re-read from the record's own ``spatial_code_path``) with operation counting
+on (symbolic.solver.LAST_ANSWER_OPS), then buckets VLM accuracy by solver depth.
+Prediction (analysis/preregistration.md): accuracy declines with depth, and the
+extended protocol's benefit concentrates in high-depth questions -- pass two
+--results-dir cells (base and extended) to read the interaction directly.
+
+Zero new GPU runs: this consumes records the scheduled runs already produce.
+
+Usage:
+    python -m analysis.depth --results-dir <cell> [--results-dir <cell2>] [--json]
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from collections import defaultdict
+from pathlib import Path
+
+WORKSPACE_ROOT = Path(__file__).resolve().parent.parent
+if str(WORKSPACE_ROOT) not in sys.path:
+    sys.path.insert(0, str(WORKSPACE_ROOT))
+
+from analysis.aggregate import iter_records  # noqa: E402
+from symbolic import adapters, solver  # noqa: E402
+
+DEPTH_BUCKETS = ((0, 2), (3, 8), (9, 20), (21, None))  # ops -> shallow..deep
+
+
+def question_depth(record, code_cache):
+    """Solver operation count for one record's (question, code) pair, or None when
+    the code file is unreadable."""
+    code_path = record.get("spatial_code_path")
+    if not code_path:
+        return None
+    if code_path not in code_cache:
+        try:
+            with open(code_path, encoding="utf-8") as stream:
+                code_cache[code_path] = adapters.adapt_spatial_code(json.load(stream))
+        except OSError:
+            code_cache[code_path] = None
+    adapted = code_cache[code_path]
+    if adapted is None:
+        return None
+    solver.answer(record["question_type"], record["question"], record.get("options"), adapted)
+    return solver.LAST_ANSWER_OPS.get("total")
+
+
+def _bucket(depth):
+    for low, high in DEPTH_BUCKETS:
+        if depth >= low and (high is None or depth <= high):
+            return f"{low}-{'inf' if high is None else high}"
+    return "unbucketed"
+
+
+def depth_table(records):
+    """{bucket: {"count", "mean_score", "mean_depth"}} plus per-record pairs."""
+    code_cache = {}
+    pairs = []
+    for record in records:
+        depth = question_depth(record, code_cache)
+        if depth is None or record["score"] is None:
+            continue
+        pairs.append((depth, record["score"]))
+    buckets = defaultdict(list)
+    for depth, score in pairs:
+        buckets[_bucket(depth)].append((depth, score))
+    table = {}
+    for bucket, values in sorted(buckets.items()):
+        table[bucket] = {
+            "count": len(values),
+            "mean_depth": sum(depth for depth, _ in values) / len(values),
+            "mean_score": sum(score for _, score in values) / len(values),
+        }
+    return table, pairs
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "--results-dir", action="append", required=True,
+        help="repeatable: one bucketed table per cell (e.g. base and extended)",
+    )
+    parser.add_argument("--json", action="store_true")
+    args = parser.parse_args()
+    output = {}
+    for directory in args.results_dir:
+        table, pairs = depth_table(iter_records(directory))
+        output[directory] = {"buckets": table, "questions": len(pairs)}
+    if args.json:
+        print(json.dumps(output, indent=1))
+        return
+    for directory, result in output.items():
+        print(f"=== {directory} ({result['questions']} questions) ===")
+        for bucket, stats in result["buckets"].items():
+            print(
+                f"  ops {bucket}: n={stats['count']} "
+                f"mean_depth={stats['mean_depth']:.1f} mean_score={stats['mean_score']:.3f}"
+            )
+
+
+if __name__ == "__main__":
+    main()

analysis/preregistration.md

@@ -0,0 +1,102 @@
+# Pre-registration — spatial-code VSI-Bench program
+
+Frozen BEFORE any scheduled experiment run executes; committed to this repository and
+backed up to the Hugging Face dataset repo so its timestamp precedes every result.
+Any deviation from this plan must be reported as a deviation, not silently absorbed.
+
+## Models
+
+qwen3.5-4b, qwen3.5-2b, internvl3.5-4b (all core sweeps). Corruption-module arms:
+H21 runs BOTH 4B models (qwen3.5-4b + internvl3.5-4b; the 2B is excluded to avoid
+confounding capacity with tolerance); all single-model arms (H22, H24, H6,
+wrong-scene, robustness) run qwen3.5-4b, swapped to Plan B's winning model if that
+differs (decision rule fixed here, before results).
+
+## Primary hypotheses (novel; confirmatory test, directional, Holm-Bonferroni
+## corrected as a family)
+
+- **H7 (interaction)**: extended reasoning (2048-token) helps B and C but is flat or
+  harmful for A, relative to the base 16-token protocol. Direction: (B_ext - B_base)
+  > (A_ext - A_base), same for C.
+- **H21 (perception-requirements curve)**: VLM accuracy on corrupted ground-truth
+  codes falls monotonically with corruption magnitude, and the curve fitted on
+  synthetic corruption predicts B's real measured accuracy at the pipeline's
+  empirically measured error level (prediction within the curve's bootstrap CI).
+- **H22 (chimera decomposition)**: geometric error (perceived geometry, GT inventory)
+  and detection error (perceived inventory, GT geometry) cost accuracy in different
+  categories -- geometry errors hurt metric categories, detection errors hurt
+  counting/order categories.
+- **H23 (deterministic CoT audit)**: in B/D extended reasoning traces, cited-number
+  errors (retrieval/transcription, checked mechanically against the provided code)
+  account for a nonzero, measurable share of wrong answers, and that share is higher
+  for the 2B model than the 4B models.
+- **H24 (coordinate-frame invariance)**: solver-certified answer-preserving
+  re-parameterizations (translation, rotation, unit conversion, list reorder,
+  precision rounding) reduce VLM accuracy; any statistically significant drop is
+  representation-frame brittleness, since zero information changed.
+- **H25 (computation-depth transfer)**: VLM accuracy on code-as-text declines with
+  the solver's per-question operation count, and H7's extended-protocol benefit
+  concentrates in high-depth questions.
+- **H26 (sufficiency-conditioned decomposition)**: conditioning every B comparison on
+  the solver's per-question sufficiency certificate (solver answers correctly from
+  the identical code B saw) splits B's errors into proven information failures vs
+  proven reasoning failures; prediction: the majority of B's errors on
+  solver-correct questions persist in D (they are reasoning failures, not
+  perception artifacts).
+
+## Supporting (directional but secondary)
+
+- **H27 (format-flip brittleness)**: on questions where the solver answers correctly
+  from BOTH formats of the same scene's code, B(explicit) and B(compact) still
+  disagree on a nonzero fraction -- pure presentation sensitivity under certified
+  informational sufficiency.
+- H1-H5, H10-H13 as stated in README (confirmatory, extensions of the two source
+  papers; H1's headline read is blind-floor-corrected and matched-protocol).
+
+## Exploratory (reported as observations; no confirmatory claim)
+
+H8, H9 (telemetry, difficulty-confounded), H17, H18 (n=2 families / one scale pair),
+H19 (per-question solved-set overlap -- established methodology applied here, with
+guess-noise caveats), H20 (cross-paper comparability is weak), E-base vs E-extended.
+
+## Out of scope by design
+
+H6 runs as a corruption-module probe (single-object perturbation) but its topic
+(text-over-vision anchoring) is established literature -- reported as an
+instantiation, not a novel claim. H14, H16 (secondary frame-count sweeps) are not
+scheduled. H15 (upstream-vs-downstream frame selection) is out of scope: Step 2
+builds spatial codes for the winning selection only; the second perception cache is
+deliberately not funded (encoder-side frame-choice gains were already measured as
+marginal in the concluded geometry track).
+
+## Known contaminations and exclusions (fixed in advance)
+
+- `obj_appearance_order` is EXCLUDED from every ground-truth-code-based analysis
+  (D, solver ceiling, all corruption arms): the GT field is reconstructed from that
+  category's own answer keys (circular). It is reported for A/B/C/E only.
+- route_planning is excluded from solver-side ceiling/certificate claims (documented
+  solver parser limitation, ~3% on GT codes); VLM-side results are reported.
+- Harness E doubles as the contamination probe: E scores materially above the
+  VSI-Bench paper's published blind baselines are treated as evidence of
+  training-data leakage and reported prominently.
+- "Ground truth" codes are annotation-derived and inherit VSI-Bench's documented
+  annotation-to-video drift (ReVSI, arXiv:2604.24300) -- stated as a limitation.
+
+## Corruption-module sample (procedure frozen now; realized list committed at Step 2)
+
+One shared sample for every corruption arm: ~600 questions, balanced across the 7
+non-appearance-order categories (~85 each), drawn only from scenes having BOTH
+perceived (Step 2) and ground-truth codes, spread over >= 100 distinct scenes,
+sampled with RNG seed 20260725. The realized question-id list is committed to this
+file, unmodified, immediately after Step 2 completes and before any corruption run.
+All corruption arms run the extended protocol on ground-truth codes (chimera arms
+use both code sources by construction). The solver runs every arm as the zero-cost
+second reasoner.
+
+## Analysis plan
+
+Every cross-harness delta: exact question-id intersection (analysis.compare), scene-
+clustered paired bootstrap with fixed seed (analysis.stats), 95% CIs. The primary
+family (H7, H21-H26) is Holm-Bonferroni corrected; supporting and exploratory results
+are reported with CIs but no corrected significance claims. Aggregate category scores
+use only the real, unmodified official VSI-Bench aggregator.

analysis/solvability.py

@@ -0,0 +1,115 @@
+"""H19 (exploratory): solved-set overlap across cells -- established error-overlap
+methodology (cf. Mixed Signals, arXiv:2504.08974) applied to this program's cells;
+deliberately NOT claimed as novel (see analysis/preregistration.md).
+
+Given two or more result cells (e.g. A vs B vs C for one model at the frozen
+config), computes -- on the exact question-id intersection -- each cell's solved set
+(score >= threshold), pairwise Jaccard overlap, per-pair exclusive counts, and the
+all/none partition. The interesting readout: similar aggregate scores with LOW
+overlap means the representations solve DIFFERENT questions, which no aggregate
+table can reveal. MCA guess-noise caveat applies (a solved MCA question may be a
+lucky guess); interpret cell-level rates, not individual questions.
+
+Usage:
+    python -m analysis.solvability --cell A=results/A/qwen3.5-4b/extended/selective/32 \\
+        --cell B="results/B/qwen3.5-4b/extended/explicit/relative/tracking/selective/32"
+"""
+
+from __future__ import annotations
+
+import argparse
+import itertools
+import json
+import sys
+from pathlib import Path
+
+WORKSPACE_ROOT = Path(__file__).resolve().parent.parent
+if str(WORKSPACE_ROOT) not in sys.path:
+    sys.path.insert(0, str(WORKSPACE_ROOT))
+
+from analysis.aggregate import iter_records  # noqa: E402
+
+
+def solved_sets(cells, threshold=1.0):
+    """{name: set(question_id solved)} restricted to the exact intersection of every
+    cell's answered questions. Returns (sets, common_ids)."""
+    answered = {}
+    scores = {}
+    for name, records in cells.items():
+        by_id = {record["question_id"]: record["score"] for record in records}
+        answered[name] = set(by_id)
+        scores[name] = by_id
+    common = set.intersection(*answered.values()) if answered else set()
+    return (
+        {
+            name: {
+                qid for qid in common
+                if scores[name][qid] is not None and scores[name][qid] >= threshold
+            }
+            for name in cells
+        },
+        common,
+    )
+
+
+def overlap(cells, threshold=1.0):
+    """Full overlap report: per-cell solved counts, pairwise Jaccard + exclusives,
+    and the solved-by-all / solved-by-none partition, all on the intersection."""
+    sets, common = solved_sets(cells, threshold)
+    if not common:
+        return {"questions": 0}
+    names = sorted(sets)
+    pairs = {}
+    for first, second in itertools.combinations(names, 2):
+        a, b = sets[first], sets[second]
+        union = a | b
+        pairs[f"{first}|{second}"] = {
+            "jaccard": len(a & b) / len(union) if union else None,
+            f"only_{first}": len(a - b),
+            f"only_{second}": len(b - a),
+            "both": len(a & b),
+        }
+    return {
+        "questions": len(common),
+        "solved": {name: len(sets[name]) for name in names},
+        "pairs": pairs,
+        "solved_by_all": len(set.intersection(*sets.values())),
+        "solved_by_none": len(common - set.union(*sets.values())),
+    }
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "--cell", action="append", required=True,
+        help="name=results_dir; repeat for each cell (at least two)",
+    )
+    parser.add_argument("--threshold", type=float, default=1.0)
+    parser.add_argument("--json", action="store_true")
+    args = parser.parse_args()
+    cells = {}
+    for spec in args.cell:
+        if "=" not in spec:
+            parser.error(f"--cell must be name=dir, got {spec!r}")
+        name, directory = spec.split("=", 1)
+        cells[name] = list(iter_records(directory))
+    if len(cells) < 2:
+        parser.error("need at least two --cell entries")
+
+    report = overlap(cells, threshold=args.threshold)
+    if args.json:
+        print(json.dumps(report, indent=1))
+        return
+    if not report["questions"]:
+        print("no shared question_ids across the given cells")
+        return
+    print(f"shared questions: {report['questions']}")
+    for name, count in report["solved"].items():
+        print(f"  {name}: solved {count}")
+    for pair, stats in report["pairs"].items():
+        print(f"  {pair}: jaccard={stats['jaccard']:.3f} {stats}")
+    print(f"  solved by all: {report['solved_by_all']}; by none: {report['solved_by_none']}")
+
+
+if __name__ == "__main__":
+    main()

analysis/stats.py

@@ -0,0 +1,144 @@
+"""Scene-clustered paired bootstrap for cross-harness deltas.
+
+Compares two result cells (e.g. one B run vs one A run) on their exact
+question-intersection, resampling SCENES with replacement -- questions within a scene
+share the same video/geometry and are correlated, so resampling questions directly
+would understate the interval.
+
+The bootstrapped statistic is the mean per-question vsibench score (each question's
+own official per-question score, unweighted), NOT the category-weighted official
+"overall": a scene resample can drop a whole category (or a rel_direction subtype the
+official aggregator refuses to score alone), which would crash or bias the
+category-weighted rollup. The paired question-level delta is the quantity every
+paired hypothesis here (H1, H7, B-vs-D, ...) is actually about; the category-weighted
+"overall" remains analysis.aggregate/compare's job on the full (non-resampled) sets.
+
+Deterministic by default (fixed --seed), so a reported interval is reproducible.
+
+Usage:
+    python -m analysis.stats --x-dir results/A/qwen3.5-4b/extended/selective/32 \\
+        --y-dir "results/B/qwen3.5-4b/extended/explicit/relative/tracking/selective/32"
+"""
+
+from __future__ import annotations
+
+import argparse
+import random
+import statistics
+import sys
+from collections import defaultdict
+from pathlib import Path
+
+WORKSPACE_ROOT = Path(__file__).resolve().parent.parent
+if str(WORKSPACE_ROOT) not in sys.path:
+    sys.path.insert(0, str(WORKSPACE_ROOT))
+
+from analysis.aggregate import iter_records  # noqa: E402
+
+
+def paired_questions(x_records, y_records):
+    """Return {scene: [(x_score, y_score), ...]} over the exact question-id
+    intersection of the two record sets."""
+    x_by_id = {record["question_id"]: record for record in x_records}
+    y_by_id = {record["question_id"]: record for record in y_records}
+    common = sorted(set(x_by_id) & set(y_by_id))
+    by_scene = defaultdict(list)
+    for question_id in common:
+        x = x_by_id[question_id]
+        by_scene[x["scene"]].append((x["score"], y_by_id[question_id]["score"]))
+    return dict(by_scene)
+
+
+def paired_bootstrap(x_records, y_records, iterations=2000, seed=0, confidence=0.95):
+    """Return the observed y-minus-x mean-score delta plus a scene-clustered bootstrap
+    confidence interval over the two record sets' exact question intersection.
+
+    Output dict: "delta" (observed), "ci_low"/"ci_high", "confidence", "iterations",
+    "questions" (intersection size), "scenes" (cluster count). Returns None when the
+    intersection is empty."""
+    by_scene = paired_questions(x_records, y_records)
+    if not by_scene:
+        return None
+    scenes = sorted(by_scene)
+    pairs = [pair for scene in scenes for pair in by_scene[scene]]
+    observed = statistics.mean(y - x for x, y in pairs)
+
+    rng = random.Random(seed)
+    deltas = []
+    for _ in range(iterations):
+        resampled = [
+            pair
+            for _ in range(len(scenes))
+            for pair in by_scene[rng.choice(scenes)]
+        ]
+        deltas.append(statistics.mean(y - x for x, y in resampled))
+    deltas.sort()
+    tail = (1.0 - confidence) / 2.0
+    low_index = int(tail * iterations)
+    high_index = min(iterations - 1, int((1.0 - tail) * iterations))
+    # Two-sided bootstrap p-value: twice the smaller tail proportion, floored at
+    # 1/iterations (a resampling p can never claim more precision than its resamples).
+    at_most = sum(1 for delta in deltas if delta <= 0.0) / iterations
+    at_least = sum(1 for delta in deltas if delta >= 0.0) / iterations
+    p_value = max(1.0 / iterations, min(1.0, 2.0 * min(at_most, at_least)))
+    return {
+        "delta": observed,
+        "ci_low": deltas[low_index],
+        "ci_high": deltas[high_index],
+        "p_value": p_value,
+        "confidence": confidence,
+        "iterations": iterations,
+        "questions": len(pairs),
+        "scenes": len(scenes),
+    }
+
+
+def holm_bonferroni(p_values):
+    """Holm-Bonferroni step-down adjustment for one hypothesis family (the primary
+    family in analysis/preregistration.md). Input {name: p}; returns {name:
+    adjusted_p}, monotone and clipped to 1.0."""
+    ordered = sorted(p_values.items(), key=lambda item: item[1])
+    total = len(ordered)
+    adjusted = {}
+    running_max = 0.0
+    for rank, (name, p) in enumerate(ordered):
+        value = min(1.0, (total - rank) * p)
+        running_max = max(running_max, value)
+        adjusted[name] = running_max
+    return adjusted
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--x-dir", required=True, help="baseline cell's results directory")
+    parser.add_argument("--y-dir", required=True, help="comparison cell's results directory")
+    parser.add_argument("--iterations", type=int, default=2000)
+    parser.add_argument("--seed", type=int, default=0)
+    parser.add_argument("--confidence", type=float, default=0.95)
+    args = parser.parse_args()
+    if args.iterations < 1:
+        parser.error("--iterations must be positive")
+    if not 0.0 < args.confidence < 1.0:
+        parser.error("--confidence must be between 0 and 1")
+
+    result = paired_bootstrap(
+        list(iter_records(args.x_dir)),
+        list(iter_records(args.y_dir)),
+        iterations=args.iterations,
+        seed=args.seed,
+        confidence=args.confidence,
+    )
+    if result is None:
+        print("no shared question_ids between the two results directories")
+        raise SystemExit(1)
+    print(
+        f"delta (y - x, mean per-question score): {result['delta']:+.4f}\n"
+        f"{int(result['confidence'] * 100)}% scene-clustered bootstrap CI: "
+        f"[{result['ci_low']:+.4f}, {result['ci_high']:+.4f}]\n"
+        f"paired questions: {result['questions']} across {result['scenes']} scene(s); "
+        f"{result['iterations']} resamples (seed {args.seed})"
+    )
+
+
+if __name__ == "__main__":
+    main()

analysis/sufficiency.py

@@ -0,0 +1,131 @@
+"""H26: the solver-certified sufficiency decomposition.
+
+The deterministic solver, run on the IDENTICAL code a VLM cell saw, certifies per
+question whether the answer is derivably present in that code. Conditioning the VLM
+cell on that certificate splits its errors into:
+
+- PROVEN reasoning failures: solver-certified questions (answer derivably present)
+  the VLM still got wrong -- the information was there; the model failed to use it.
+- PROVEN information failures: solver-uncertified questions -- no reasoner, however
+  perfect, could have derived the expected answer from this code (perception error
+  or representation insufficiency), so the VLM's failure there is not evidence about
+  its reasoning.
+
+The certificate is ``solver_score >= threshold`` (default 1.0: the solver's derived
+answer scored perfectly). Exclusions from analysis/preregistration.md apply: pass
+--exclude to drop obj_appearance_order (circular on ground-truth codes) and/or
+route_planning (documented solver parser limitation -- an uncertified route question
+may be solver weakness, not information absence, so H26 claims skip that category).
+
+Usage:
+    python -m analysis.sufficiency \\
+        --vlm-dir "results/B/qwen3.5-4b/extended/explicit/relative/tracking/selective/32" \\
+        --solver-dir "results/symbolic/relative/tracking/selective/32/explicit" \\
+        --exclude obj_appearance_order,route_planning
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from collections import defaultdict
+from pathlib import Path
+
+WORKSPACE_ROOT = Path(__file__).resolve().parent.parent
+if str(WORKSPACE_ROOT) not in sys.path:
+    sys.path.insert(0, str(WORKSPACE_ROOT))
+
+from analysis.aggregate import iter_records  # noqa: E402
+
+
+def certificates(solver_records, threshold=1.0):
+    """{question_id: bool} -- True iff the solver derived a >= threshold answer."""
+    return {
+        record["question_id"]: record["score"] is not None and record["score"] >= threshold
+        for record in solver_records
+    }
+
+
+def decompose(vlm_records, solver_records, threshold=1.0, exclude=()):
+    """Split one VLM cell by the solver certificate over the shared question set.
+
+    Returns {"certified": stats, "uncertified": stats, "questions": n} where each
+    stats dict has "count", "mean_score", "vlm_correct", "vlm_wrong" -- the
+    "certified"/"vlm_wrong" cell is the PROVEN-reasoning-failure count."""
+    certificate = certificates(solver_records, threshold)
+    excluded = set(exclude)
+    split = {
+        "certified": defaultdict(list),
+        "uncertified": defaultdict(list),
+    }
+    matched = 0
+    for record in vlm_records:
+        if record["question_type"] in excluded:
+            continue
+        question_id = record["question_id"]
+        if question_id not in certificate:
+            continue
+        matched += 1
+        bucket = "certified" if certificate[question_id] else "uncertified"
+        split[bucket]["scores"].append(record["score"])
+        split[bucket]["types"].append(record["question_type"])
+
+    def stats(bucket):
+        scores = split[bucket]["scores"]
+        if not scores:
+            return {"count": 0, "mean_score": None, "vlm_correct": 0, "vlm_wrong": 0}
+        correct = sum(1 for score in scores if score is not None and score >= threshold)
+        return {
+            "count": len(scores),
+            "mean_score": sum(scores) / len(scores),
+            "vlm_correct": correct,
+            "vlm_wrong": len(scores) - correct,
+        }
+
+    return {
+        "certified": stats("certified"),
+        "uncertified": stats("uncertified"),
+        "questions": matched,
+        "threshold": threshold,
+    }
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--vlm-dir", required=True)
+    parser.add_argument("--solver-dir", required=True)
+    parser.add_argument("--threshold", type=float, default=1.0)
+    parser.add_argument(
+        "--exclude", default="",
+        help="comma-separated question_types to drop (see analysis/preregistration.md)",
+    )
+    parser.add_argument("--json", action="store_true")
+    args = parser.parse_args()
+    exclude = tuple(t.strip() for t in args.exclude.split(",") if t.strip())
+
+    result = decompose(
+        list(iter_records(args.vlm_dir)),
+        list(iter_records(args.solver_dir)),
+        threshold=args.threshold,
+        exclude=exclude,
+    )
+    if args.json:
+        print(json.dumps(result, indent=1))
+        return
+    certified, uncertified = result["certified"], result["uncertified"]
+    print(f"matched questions: {result['questions']} (threshold {result['threshold']})")
+    print(
+        f"certified (answer derivably present): {certified['count']} -- "
+        f"VLM correct {certified['vlm_correct']}, "
+        f"PROVEN reasoning failures {certified['vlm_wrong']}"
+    )
+    print(
+        f"uncertified (information failure): {uncertified['count']} -- "
+        f"VLM 'correct' {uncertified['vlm_correct']} (not evidence of reasoning), "
+        f"wrong {uncertified['vlm_wrong']}"
+    )
+
+
+if __name__ == "__main__":
+    main()

corruption/__init__.py

@@ -0,0 +1,34 @@
+"""Corruption module: parameterized transformations of spatial codes, feeding
+harness.D's unmodified prompt path (VLM arm) and the symbolic solver (free CPU arm).
+
+Every transform operates on the COMPACT code -- the pure geometric primitives -- and
+the requested format is then derived through the exact same `_explicit_from_compact`
+the encoder uses, so a corrupted explicit code can never disagree with its corrupted
+compact sibling (the same consistency-by-construction guarantee the clean pipeline
+has; see README Theme 8 / H21-H24 and analysis/preregistration.md).
+
+Transform families:
+- noise (H21): position jitter, dimension noise, dropped objects, hallucinated
+  objects, class swaps, plus empirical noise sampled from the REAL measured
+  SAM3+DA3 residual distribution (corruption/empirical.py)
+- chimera (H22): ground-truth inventory x perceived geometry hybrids
+  (corruption/chimera.py), plus the single-object H6 probe and wrong-scene control
+- invariance (H24): solver-certified answer-preserving re-parameterizations
+  (translation, rotation, reorder, precision)
+"""
+
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+from harness.A import WORKSPACE_ROOT
+
+# One JSON per question:
+# results/corruption/<arm>/<transform>/<magnitude>/<model-or-solver>/<scene>/<question_id>.json
+RESULTS_DIR = Path(
+    os.environ.get("VSI_CORRUPTION_RESULTS_DIR", WORKSPACE_ROOT / "results" / "corruption")
+)
+
+# The pre-registered corruption-arm sampling seed (analysis/preregistration.md).
+SAMPLE_SEED = 20260725

corruption/chimera.py

@@ -0,0 +1,99 @@
+"""Chimera codes (H22) and the single-object probe (H6): interventional hybrids of
+ground-truth and perceived COMPACT codes for the same scene.
+
+The B-to-D gap confounds two perception failure modes: DETECTION error (which
+objects exist, how many) and GEOMETRIC error (where they are, how big). The two
+chimeras isolate them causally:
+
+- gt_inventory_perceived_geometry: ground truth decides which classes/instances
+  exist; each instance's box is replaced by its nearest perceived box of the same
+  class where one exists (geometry becomes perceived; inventory stays perfect).
+- perceived_inventory_gt_geometry: perception decides the inventory; each perceived
+  instance's box is replaced by its nearest ground-truth box of the same class where
+  one exists (inventory stays flawed; geometry becomes perfect).
+
+Both return (code, coverage) -- coverage reports how many instances actually got a
+swapped box vs. kept their own (a class the other source lacks has nothing to swap
+with), so every chimera result can be conditioned on real swap coverage instead of
+silently diluting the manipulation.
+"""
+
+from __future__ import annotations
+
+import json
+import math
+
+
+def _copy(code):
+    return json.loads(json.dumps(code))
+
+
+def _center(instance):
+    return instance["3D oriented bounding box"]["3D oriented bounding box center coordinates"]
+
+
+def _distance(a, b):
+    return math.dist(a, b)
+
+
+def _swap_boxes(target_code, source_code):
+    """For every instance in ``target_code``, replace its box with the nearest
+    unused same-class box from ``source_code`` (greedy nearest-center matching).
+    Returns (new_code, coverage) without mutating either input."""
+    code = _copy(target_code)
+    swapped = 0
+    total = 0
+    for class_name, items in code["objects"].items():
+        available = [
+            _copy(item) for item in source_code["objects"].get(class_name, [])
+        ]
+        for item in items:
+            total += 1
+            if not available:
+                continue
+            best = min(
+                range(len(available)),
+                key=lambda index: _distance(_center(item), _center(available[index])),
+            )
+            source = available.pop(best)
+            item["3D oriented bounding box"] = source["3D oriented bounding box"]
+            swapped += 1
+    coverage = {"instances": total, "swapped": swapped}
+    return code, coverage
+
+
+def gt_inventory_perceived_geometry(gt_code, perceived_code):
+    """Ground-truth inventory, perceived geometry: isolates GEOMETRIC error cost."""
+    return _swap_boxes(gt_code, perceived_code)
+
+
+def perceived_inventory_gt_geometry(gt_code, perceived_code):
+    """Perceived inventory, ground-truth geometry: isolates DETECTION error cost."""
+    return _swap_boxes(perceived_code, gt_code)
+
+
+def perturb_single_object(code, rng, position_offset_meters=1.0, size_scale=2.0):
+    """The H6 probe: displace and rescale exactly ONE randomly chosen instance,
+    leaving everything else untouched. Returns (code, perturbed) where ``perturbed``
+    names the class/instance changed, so the conflict question set can be selected."""
+    code = _copy(code)
+    candidates = [
+        (class_name, index)
+        for class_name, items in code["objects"].items()
+        for index in range(len(items))
+    ]
+    if not candidates:
+        return code, None
+    class_name, index = candidates[rng.randrange(len(candidates))]
+    box = code["objects"][class_name][index]["3D oriented bounding box"]
+    center = box["3D oriented bounding box center coordinates"]
+    angle = rng.uniform(0.0, 2.0 * math.pi)
+    box["3D oriented bounding box center coordinates"] = [
+        round(center[0] + position_offset_meters * math.cos(angle), 2),
+        round(center[1] + position_offset_meters * math.sin(angle), 2),
+        center[2],
+    ]
+    box["3D oriented bounding box dimensions"] = [
+        round(value * size_scale, 2) for value in box["3D oriented bounding box dimensions"]
+    ]
+    return code, {"class": class_name, "instance": index}

corruption/empirical.py

@@ -0,0 +1,131 @@
+"""Measure the REAL SAM3+DA3 residual distribution and sample corruption from it.
+
+H21's central methodological check: iid Gaussian noise is the field's default proxy
+for perception error, but real perception error is structured (per-class biases,
+correlated axis errors, class-dependent miss rates). This module measures the actual
+residuals -- perceived vs. ground-truth compact codes for the same scenes -- and
+provides an ``empirical`` corruption mode that samples from those measured residuals
+instead of a parametric distribution. Comparing the empirical-noise curve against
+the Gaussian curve at matched aggregate magnitude answers: is iid noise even a valid
+proxy for real perception error?
+
+Matching is greedy nearest-center within each class (the same convention
+corruption/chimera.py uses), which is deliberate: both modules should agree on what
+"the corresponding instance" means.
+"""
+
+from __future__ import annotations
+
+import json
+import math
+
+
+def _center(instance):
+    return instance["3D oriented bounding box"]["3D oriented bounding box center coordinates"]
+
+
+def _dimensions(instance):
+    return instance["3D oriented bounding box"]["3D oriented bounding box dimensions"]
+
+
+def measure_residuals(code_pairs):
+    """Measure per-class residuals over (perceived_code, gt_code) compact pairs.
+
+    Returns {"position_residuals": [[dx, dy, dz], ...], "dimension_ratios":
+    [[rx, ry, rz], ...], "matched": n, "missed": n (GT instances with no perceived
+    match), "hallucinated": n (perceived instances with no GT match), "miss_rate",
+    "hallucination_rate"} pooled across classes -- per-class pooling keeps the
+    sample usable at this dataset's per-class instance counts.
+    """
+    position_residuals = []
+    dimension_ratios = []
+    matched = missed = hallucinated = 0
+    for perceived_code, gt_code in code_pairs:
+        classes = set(perceived_code["objects"]) | set(gt_code["objects"])
+        for class_name in classes:
+            perceived = list(perceived_code["objects"].get(class_name, []))
+            ground_truth = list(gt_code["objects"].get(class_name, []))
+            unmatched = list(range(len(perceived)))
+            for gt_item in ground_truth:
+                if not unmatched:
+                    missed += 1
+                    continue
+                best = min(
+                    unmatched,
+                    key=lambda index: math.dist(_center(perceived[index]), _center(gt_item)),
+                )
+                unmatched.remove(best)
+                matched += 1
+                p_center, g_center = _center(perceived[best]), _center(gt_item)
+                position_residuals.append(
+                    [round(p - g, 4) for p, g in zip(p_center, g_center)]
+                )
+                dimension_ratios.append(
+                    [
+                        round(p / g, 4) if g else 1.0
+                        for p, g in zip(_dimensions(perceived[best]), _dimensions(gt_item))
+                    ]
+                )
+            hallucinated += len(unmatched)
+    gt_total = matched + missed
+    perceived_total = matched + hallucinated
+    return {
+        "position_residuals": position_residuals,
+        "dimension_ratios": dimension_ratios,
+        "matched": matched,
+        "missed": missed,
+        "hallucinated": hallucinated,
+        "miss_rate": missed / gt_total if gt_total else 0.0,
+        "hallucination_rate": hallucinated / perceived_total if perceived_total else 0.0,
+    }
+
+
+def empirical_noise(code, residuals, rng, scale=1.0):
+    """Corrupt a compact code by sampling from MEASURED residuals: each surviving
+    instance gets a sampled position residual and dimension ratio (both scaled by
+    ``scale`` -- scale=1.0 is the pipeline's real operating point, the anchor H21's
+    prediction test uses); instances are dropped at ``scale`` x the measured miss
+    rate and duplicated at ``scale`` x the measured hallucination rate."""
+    code = json.loads(json.dumps(code))
+    positions = residuals["position_residuals"]
+    ratios = residuals["dimension_ratios"]
+    miss_rate = min(1.0, residuals["miss_rate"] * scale)
+    hallucination_rate = min(1.0, residuals["hallucination_rate"] * scale)
+    kept = {}
+    for class_name, items in code["objects"].items():
+        survivors = []
+        for item in items:
+            if rng.random() < miss_rate:
+                continue
+            box = item["3D oriented bounding box"]
+            if positions:
+                residual = positions[rng.randrange(len(positions))]
+                box["3D oriented bounding box center coordinates"] = [
+                    round(value + delta * scale, 2)
+                    for value, delta in zip(
+                        box["3D oriented bounding box center coordinates"], residual
+                    )
+                ]
+            if ratios:
+                ratio = ratios[rng.randrange(len(ratios))]
+                box["3D oriented bounding box dimensions"] = [
+                    round(max(0.01, value * (1.0 + (factor - 1.0) * scale)), 2)
+                    for value, factor in zip(
+                        box["3D oriented bounding box dimensions"], ratio
+                    )
+                ]
+            survivors.append(item)
+            if rng.random() < hallucination_rate:
+                ghost = json.loads(json.dumps(item))
+                ghost_box = ghost["3D oriented bounding box"]
+                center = ghost_box["3D oriented bounding box center coordinates"]
+                ghost_box["3D oriented bounding box center coordinates"] = [
+                    round(center[0] + rng.gauss(0.0, 0.5), 2),
+                    round(center[1] + rng.gauss(0.0, 0.5), 2),
+                    center[2],
+                ]
+                survivors.append(ghost)
+        if survivors:
+            kept[class_name] = survivors
+    code["objects"] = kept
+    return code

corruption/launch.py

@@ -0,0 +1,84 @@
+"""Grid looper for corruption conditions (Step 6.5).
+
+Runs every (transform, magnitude) pair in a grid through corruption.run, one
+condition at a time -- solver arm always (free), VLM arm per requested model. The
+question sample comes from the pre-registered sample file (see
+analysis/preregistration.md); pass --sample to enforce it.
+
+Example (H21's grid, both 4B models):
+    python -m corruption.launch --arm both --models qwen3.5-4b,internvl3.5-4b \\
+        --transforms position-jitter,dimension-noise,drop-objects,hallucinate-objects \\
+        --magnitudes 0.1,0.25,0.5,1.0 --sample analysis/corruption_sample.json
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from pathlib import Path
+
+WORKSPACE_ROOT = Path(__file__).resolve().parent.parent
+if str(WORKSPACE_ROOT) not in sys.path:
+    sys.path.insert(0, str(WORKSPACE_ROOT))
+
+from corruption.run import ALL_CONDITIONS, run_solver, run_vlm  # noqa: E402
+from harness.A import models as vlm_models  # noqa: E402
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--arm", default="both", choices=("vlm", "solver", "both"))
+    parser.add_argument(
+        "--models", default=None, help="comma-separated (required unless --arm solver)"
+    )
+    parser.add_argument("--transforms", required=True, help="comma-separated transform names")
+    parser.add_argument("--magnitudes", required=True, help="comma-separated magnitudes")
+    parser.add_argument(
+        "--spatial-code-format", default="explicit", choices=("explicit", "compact"),
+        dest="spatial_code_format",
+    )
+    parser.add_argument("--scenes", default=None, help="comma-separated scenes")
+    parser.add_argument("--sample", default=None, help="JSON list of question ids")
+    args = parser.parse_args()
+
+    transforms = [t.strip() for t in args.transforms.split(",") if t.strip()]
+    unknown = [t for t in transforms if t not in ALL_CONDITIONS]
+    if unknown:
+        parser.error(f"unknown transform(s) {unknown}; expected one of {ALL_CONDITIONS}")
+    magnitudes = [float(m.strip()) for m in args.magnitudes.split(",") if m.strip()]
+    models = []
+    if args.arm in ("vlm", "both"):
+        if not args.models:
+            parser.error(f"--arm {args.arm} requires --models")
+        models = [m.strip() for m in args.models.split(",") if m.strip()]
+        bad = [m for m in models if m not in vlm_models.available_models()]
+        if bad:
+            parser.error(f"unknown model(s) {bad}")
+    scenes = None
+    if args.scenes:
+        scenes = list(dict.fromkeys(s.strip() for s in args.scenes.split(",") if s.strip()))
+    question_ids = None
+    if args.sample:
+        with open(args.sample, encoding="utf-8") as stream:
+            question_ids = set(json.load(stream))
+
+    conditions = [(t, m) for t in transforms for m in magnitudes]
+    for index, (transform, magnitude) in enumerate(conditions, start=1):
+        print(f"=== corruption {index}/{len(conditions)}: {transform}@{magnitude} ===", flush=True)
+        if args.arm in ("solver", "both"):
+            results = run_solver(
+                transform, magnitude, args.spatial_code_format,
+                scenes=scenes, question_ids=question_ids,
+            )
+            print(f"  [solver] {len(results)} questions", flush=True)
+        for model in models:
+            results = run_vlm(
+                model, transform, magnitude, args.spatial_code_format,
+                scenes=scenes, question_ids=question_ids,
+            )
+            print(f"  [{model}] {len(results)} questions", flush=True)
+
+
+if __name__ == "__main__":
+    main()

corruption/run.py

@@ -0,0 +1,286 @@
+"""Run one corruption condition -- (transform, magnitude) -- through both reasoners.
+
+The VLM arm reuses ``harness.D.run.run`` completely unmodified via its
+``code_transform`` hook, so a corrupted code goes through the byte-identical prompt/
+adapter path clean D runs use. The solver arm answers the same corrupted codes with
+``symbolic.solver`` at zero GPU cost. Both write one JSON per question under:
+
+    results/corruption/<arm>/<transform>/<magnitude>/<model-or-'symbolic'>/<scene>/<question_id>.json
+
+Corruption always happens on the COMPACT ground-truth code; the requested format is
+then derived through encoder's own ``_explicit_from_compact``, so corrupted explicit
+and compact codes can never disagree (the clean pipeline's consistency guarantee,
+preserved under corruption).
+
+Chimera conditions (H22) additionally load the scene's PERCEIVED compact code (the
+frozen Step-2 config) and are exposed as transform names "chimera-gt-inventory" /
+"chimera-perceived-inventory"; "single-object" is the H6 probe; "wrong-scene" swaps
+in another scene's ground-truth code entirely; "empirical" samples from the measured
+SAM3+DA3 residual distribution (magnitude = scale, 1.0 = the real operating point).
+
+``certify_invariant`` is H24's gate: a (scene, transform, magnitude) triple enters
+the invariance analysis only if the solver returns identical answers on the original
+and transformed code for every sampled question of that scene.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import random
+import sys
+import zlib
+from pathlib import Path
+
+WORKSPACE_ROOT = Path(__file__).resolve().parent.parent
+if str(WORKSPACE_ROOT) not in sys.path:
+    sys.path.insert(0, str(WORKSPACE_ROOT))
+
+from corruption import RESULTS_DIR, SAMPLE_SEED  # noqa: E402
+from corruption import chimera as chimera_mod  # noqa: E402
+from corruption import empirical as empirical_mod  # noqa: E402
+from corruption.transforms import INVARIANCE_TRANSFORMS, TRANSFORMS  # noqa: E402
+from encoder.geometric import _explicit_from_compact  # noqa: E402
+from harness.A.run import _scalar_score, load_questions, vsi_official_eval  # noqa: E402
+from harness.B import spatial_codes as perceived_spatial_codes  # noqa: E402
+from harness.D import run as harness_d_run  # noqa: E402
+from harness.D import spatial_codes as gt_spatial_codes  # noqa: E402
+from symbolic import adapters, solver  # noqa: E402
+
+CHIMERA_CONDITIONS = ("chimera-gt-inventory", "chimera-perceived-inventory")
+SPECIAL_CONDITIONS = CHIMERA_CONDITIONS + ("single-object", "wrong-scene", "empirical")
+ALL_CONDITIONS = tuple(TRANSFORMS) + SPECIAL_CONDITIONS
+
+
+def _seed_for(scene, transform, magnitude):
+    """One deterministic seed per (scene, transform, magnitude): reproducible codes,
+    different randomness across scenes and conditions. crc32, NOT builtin hash() --
+    string hashing is randomized per process (PYTHONHASHSEED), which would silently
+    break cross-run reproducibility and the pre-registration's guarantee."""
+    key = repr((SAMPLE_SEED, scene, transform, magnitude)).encode("utf-8")
+    return zlib.crc32(key) & 0x7FFFFFFF
+
+
+def load_ground_truth_compact(scene):
+    """Load one scene's ground-truth COMPACT code -- the base every corruption acts on."""
+    code, _path = gt_spatial_codes.load_spatial_code(scene, "compact")
+    return code
+
+
+def corrupted_compact(
+    scene, transform, magnitude, perceived_config=None, residuals=None, wrong_scene=None
+):
+    """Return the corrupted COMPACT code for one (scene, transform, magnitude)."""
+    rng = random.Random(_seed_for(scene, transform, magnitude))
+    if transform == "wrong-scene":
+        if wrong_scene is None:
+            raise ValueError("wrong-scene requires the substitute scene id")
+        return load_ground_truth_compact(wrong_scene)
+    code = load_ground_truth_compact(scene)
+    if transform in TRANSFORMS:
+        return TRANSFORMS[transform](code, magnitude, rng)
+    if transform == "single-object":
+        perturbed, _info = chimera_mod.perturb_single_object(code, rng)
+        return perturbed
+    if transform == "empirical":
+        if residuals is None:
+            raise ValueError("empirical requires measured residuals (corruption.empirical)")
+        return empirical_mod.empirical_noise(code, residuals, rng, scale=magnitude)
+    if transform in CHIMERA_CONDITIONS:
+        if perceived_config is None:
+            raise ValueError("chimera conditions require the perceived-code config")
+        perceived, _path = perceived_spatial_codes.load_spatial_code(
+            scene,
+            perceived_config["depth"],
+            perceived_config["input_selection"],
+            perceived_config["tracking"],
+            perceived_config["frame_count"],
+            "compact",
+        )
+        if transform == "chimera-gt-inventory":
+            hybrid, _coverage = chimera_mod.gt_inventory_perceived_geometry(code, perceived)
+        else:
+            hybrid, _coverage = chimera_mod.perceived_inventory_gt_geometry(code, perceived)
+        return hybrid
+    raise ValueError(f"unknown transform {transform!r}; expected one of {ALL_CONDITIONS}")
+
+
+def corrupted_code(scene, transform, magnitude, spatial_code_format, **kwargs):
+    """Corrupt the compact code, then derive the requested format from it -- the same
+    derivation path the encoder uses, so both formats stay consistent under corruption."""
+    compact = corrupted_compact(scene, transform, magnitude, **kwargs)
+    if spatial_code_format == "compact":
+        return compact
+    explicit, _floor_area = _explicit_from_compact(compact)
+    return explicit
+
+
+def results_dir_for(arm, transform, magnitude, model):
+    """Return the result root isolated by arm + transform + magnitude + model."""
+    return RESULTS_DIR / arm / transform / str(magnitude) / model
+
+
+def make_code_transform(transform, magnitude, **kwargs):
+    """Build the ``harness.D.run.run(code_transform=...)`` hook for one condition."""
+
+    def hook(_loaded_code, scene_id, spatial_code_format):
+        return corrupted_code(scene_id, transform, magnitude, spatial_code_format, **kwargs)
+
+    return hook
+
+
+def run_vlm(
+    model, transform, magnitude, spatial_code_format="explicit", scenes=None, limit=None,
+    question_ids=None, results_dir=None, **kwargs
+):
+    """Answer the sampled questions with one VLM on corrupted codes, through
+    harness.D's unmodified path. Returns harness.D-shape records."""
+    root = results_dir or results_dir_for("vlm", transform, magnitude, model)
+    results = harness_d_run.run(
+        model,
+        spatial_code_format=spatial_code_format,
+        scenes=scenes,
+        limit=limit,
+        results_dir=root,
+        code_transform=make_code_transform(transform, magnitude, **kwargs),
+    )
+    if question_ids is not None:
+        results = [r for r in results if r["question_id"] in question_ids]
+    return results
+
+
+def run_solver(
+    transform, magnitude, spatial_code_format="explicit", scenes=None, limit=None,
+    question_ids=None, write_results=True, results_dir=None, **kwargs
+):
+    """Answer the sampled questions with the symbolic solver on the SAME corrupted
+    codes -- the zero-GPU second reasoner for every corruption arm."""
+    rows = load_questions(None, None, scenes, limit)
+    if question_ids is not None:
+        rows = [row for row in rows if row["id"] in question_ids]
+    root = Path(results_dir or results_dir_for("solver", transform, magnitude, "symbolic"))
+    code_cache = {}
+    results = []
+    for row in rows:
+        scene = row["scene_name"]
+        if scene not in code_cache:
+            code = corrupted_code(scene, transform, magnitude, spatial_code_format, **kwargs)
+            code_cache[scene] = adapters.adapt_spatial_code(code)
+        answer = solver.answer(
+            row["question_type"], row["question"], row["options"], code_cache[scene]
+        )
+        pred = "" if answer is None else str(answer)
+        doc = {"question_type": row["question_type"], "ground_truth": row["ground_truth"]}
+        score_doc = vsi_official_eval.vsibench_process_results(doc, [pred])["vsibench_score"]
+        metric_name, score = _scalar_score(row["question_type"], score_doc)
+        record = {
+            "model": "symbolic",
+            "condition": f"{transform}:{magnitude}:{spatial_code_format}",
+            "transform": transform,
+            "magnitude": magnitude,
+            "spatial_code_format": spatial_code_format,
+            "scene": scene,
+            "dataset": row.get("dataset"),
+            "question_id": row["id"],
+            "question_type": row["question_type"],
+            "question": row["question"],
+            "options": row.get("options"),
+            "answer_expected": row["ground_truth"],
+            "answer_given": pred,
+            "metric": metric_name,
+            "score": score,
+        }
+        if write_results:
+            scene_dir = root / scene
+            scene_dir.mkdir(parents=True, exist_ok=True)
+            path = scene_dir / f"{row['id']}.json"
+            with path.open("w", encoding="utf-8") as stream:
+                json.dump(record, stream, indent=1)
+            record["result_path"] = str(path)
+        else:
+            record["result_path"] = None
+        results.append(record)
+    return results
+
+
+def certify_invariant(scene, transform, magnitude, spatial_code_format="explicit"):
+    """H24's gate: True iff the solver returns identical answers on the original and
+    transformed code for EVERY question of this scene. Only certified triples enter
+    the invariance analysis -- this is the proof the transformation was truly null."""
+    if transform not in INVARIANCE_TRANSFORMS:
+        raise ValueError(f"{transform!r} is not an invariance transform")
+    rows = load_questions(None, scene, None, None)
+    original, _path = gt_spatial_codes.load_spatial_code(scene, spatial_code_format)
+    transformed = corrupted_code(scene, transform, magnitude, spatial_code_format)
+    adapted_original = adapters.adapt_spatial_code(original)
+    adapted_transformed = adapters.adapt_spatial_code(transformed)
+    for row in rows:
+        before = solver.answer(
+            row["question_type"], row["question"], row["options"], adapted_original
+        )
+        after = solver.answer(
+            row["question_type"], row["question"], row["options"], adapted_transformed
+        )
+        if before != after:
+            return False
+    return True
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--arm", required=True, choices=("vlm", "solver", "certify"))
+    parser.add_argument("--transform", required=True, choices=ALL_CONDITIONS)
+    parser.add_argument("--magnitude", type=float, required=True)
+    parser.add_argument("--model", default=None, help="required for --arm vlm")
+    parser.add_argument(
+        "--spatial-code-format", default="explicit", choices=("explicit", "compact"),
+        dest="spatial_code_format",
+    )
+    parser.add_argument("--scenes", default=None, help="comma-separated scenes")
+    parser.add_argument("--limit", type=int, default=None)
+    parser.add_argument(
+        "--sample", default=None,
+        help="path to a JSON list of question ids (the pre-registered sample)",
+    )
+    parser.add_argument("--results-dir", default=None)
+    args = parser.parse_args()
+
+    scenes = None
+    if args.scenes:
+        scenes = list(dict.fromkeys(s.strip() for s in args.scenes.split(",") if s.strip()))
+    question_ids = None
+    if args.sample:
+        with open(args.sample, encoding="utf-8") as stream:
+            question_ids = set(json.load(stream))
+
+    if args.arm == "certify":
+        if not scenes:
+            parser.error("--arm certify requires --scenes")
+        for scene in scenes:
+            ok = certify_invariant(
+                scene, args.transform, args.magnitude, args.spatial_code_format
+            )
+            print(f"{scene}: {'CERTIFIED' if ok else 'NOT invariant'}")
+        return
+
+    if args.arm == "vlm":
+        if not args.model:
+            parser.error("--arm vlm requires --model")
+        results = run_vlm(
+            args.model, args.transform, args.magnitude, args.spatial_code_format,
+            scenes=scenes, limit=args.limit, question_ids=question_ids,
+            results_dir=args.results_dir,
+        )
+    else:
+        results = run_solver(
+            args.transform, args.magnitude, args.spatial_code_format,
+            scenes=scenes, limit=args.limit, question_ids=question_ids,
+            results_dir=args.results_dir,
+        )
+    if results:
+        mean_score = sum(r["score"] for r in results) / len(results)
+        print(f"{len(results)} questions, mean vsibench_score={mean_score:.4f}")
+
+
+if __name__ == "__main__":
+    main()

corruption/transforms.py

@@ -0,0 +1,251 @@
+"""Parameterized transformations of COMPACT spatial codes.
+
+Two families with opposite intent:
+
+- NOISE transforms (H21) change the geometry by a controlled magnitude -- they are
+  meant to destroy information, and the dose is the experimental variable.
+- INVARIANCE transforms (H24) provably change NOTHING any question depends on
+  (translation/rotation act on absolute coordinates no VSI-Bench question type asks
+  about; reorder/precision are surface form). "Provably" is enforced downstream:
+  corruption.run.certify_invariant() checks the solver returns identical answers on
+  the transformed code, and only certified (scene, transform) pairs enter H24.
+
+Every transform is a pure function: it deep-copies its input (via JSON round-trip,
+which also guarantees the result is exactly what would be serialized into a prompt)
+and never mutates the original. Randomized transforms take a seeded
+``random.Random`` so every corrupted code is reproducible from
+(scene, transform, magnitude, seed).
+"""
+
+from __future__ import annotations
+
+import json
+import math
+
+
+def _copy(code):
+    return json.loads(json.dumps(code))
+
+
+def _instances(code):
+    """Yield every (class_name, instance) pair in a compact code."""
+    for class_name, items in code["objects"].items():
+        for item in items:
+            yield class_name, item
+
+
+def _box(instance):
+    return instance["3D oriented bounding box"]
+
+
+def _polygons(code):
+    return code["room"].get("floor boundary polygons", [])
+
+
+# ==========================================================================================
+# NOISE FAMILY (H21) -- magnitude is the dose.
+# ==========================================================================================
+
+
+def position_jitter(code, sigma_meters, rng):
+    """Add iid Gaussian noise (std ``sigma_meters``) to every box center coordinate."""
+    code = _copy(code)
+    for _name, instance in _instances(code):
+        box = _box(instance)
+        center = box["3D oriented bounding box center coordinates"]
+        box["3D oriented bounding box center coordinates"] = [
+            round(value + rng.gauss(0.0, sigma_meters), 2) for value in center
+        ]
+    return code
+
+
+def dimension_noise(code, relative_sigma, rng):
+    """Scale every box dimension by (1 + Gaussian(0, relative_sigma)), floored at 5%
+    of the original so no dimension collapses to zero or goes negative."""
+    code = _copy(code)
+    for _name, instance in _instances(code):
+        box = _box(instance)
+        dimensions = box["3D oriented bounding box dimensions"]
+        box["3D oriented bounding box dimensions"] = [
+            round(value * max(0.05, 1.0 + rng.gauss(0.0, relative_sigma)), 2)
+            for value in dimensions
+        ]
+    return code
+
+
+def drop_objects(code, fraction, rng):
+    """Delete each instance independently with probability ``fraction`` (simulated
+    missed detections). A class whose instances are all dropped disappears entirely,
+    exactly as an undetected class would."""
+    code = _copy(code)
+    kept = {}
+    for class_name, items in code["objects"].items():
+        remaining = [item for item in items if rng.random() >= fraction]
+        if remaining:
+            kept[class_name] = remaining
+    code["objects"] = kept
+    return code
+
+
+def hallucinate_objects(code, fraction, rng):
+    """Duplicate each instance with probability ``fraction`` (simulated duplicate/
+    phantom detections), displacing the copy by ~0.5 m so it reads as a distinct
+    object rather than an exact double."""
+    code = _copy(code)
+    for class_name, items in code["objects"].items():
+        extras = []
+        for item in items:
+            if rng.random() < fraction:
+                ghost = _copy(item)
+                box = _box(ghost)
+                center = box["3D oriented bounding box center coordinates"]
+                box["3D oriented bounding box center coordinates"] = [
+                    round(center[0] + rng.gauss(0.0, 0.5), 2),
+                    round(center[1] + rng.gauss(0.0, 0.5), 2),
+                    center[2],
+                ]
+                extras.append(ghost)
+        items.extend(extras)
+    return code
+
+
+def class_swap(code, fraction, rng):
+    """Swap the labels of ~``fraction`` of class pairs (simulated misclassification):
+    the geometry stays exactly where it is, but it is attributed to the wrong class."""
+    code = _copy(code)
+    names = sorted(code["objects"])
+    if len(names) < 2:
+        return code
+    shuffled = list(names)
+    rng.shuffle(shuffled)
+    swap_count = max(1, int(round(len(names) * fraction / 2.0))) if fraction > 0 else 0
+    objects = code["objects"]
+    for index in range(swap_count):
+        first, second = shuffled[2 * index], shuffled[2 * index + 1]
+        if 2 * index + 1 >= len(shuffled):
+            break
+        objects[first], objects[second] = objects[second], objects[first]
+    return code
+
+
+# ==========================================================================================
+# INVARIANCE FAMILY (H24) -- provably answer-preserving; certified by the solver.
+# ==========================================================================================
+
+
+def translate(code, offset_meters, rng=None):
+    """Shift the whole scene's x/y origin by ``offset_meters`` in both axes: box
+    centers and floor polygons move together; heights and all relative geometry are
+    untouched. No VSI-Bench question type references absolute coordinates."""
+    code = _copy(code)
+    for _name, instance in _instances(code):
+        box = _box(instance)
+        center = box["3D oriented bounding box center coordinates"]
+        box["3D oriented bounding box center coordinates"] = [
+            round(center[0] + offset_meters, 2),
+            round(center[1] + offset_meters, 2),
+            center[2],
+        ]
+    for polygon in _polygons(code):
+        for key in ("outer boundary coordinates", "interior hole boundary coordinates"):
+            if key not in polygon:
+                continue
+            if key == "outer boundary coordinates":
+                polygon[key] = [
+                    [round(x + offset_meters, 2), round(y + offset_meters, 2)]
+                    for x, y in polygon[key]
+                ]
+            else:
+                polygon[key] = [
+                    [[round(x + offset_meters, 2), round(y + offset_meters, 2)] for x, y in hole]
+                    for hole in polygon[key]
+                ]
+    return code
+
+
+def rotate_z(code, angle_degrees, rng=None):
+    """Rotate the whole scene about the vertical axis: box centers, box orientation
+    vectors, and floor polygons rotate together, so every relative relationship is
+    exactly preserved."""
+    code = _copy(code)
+    theta = math.radians(angle_degrees)
+    cos, sin = math.cos(theta), math.sin(theta)
+
+    def rotate_xy(x, y):
+        return x * cos - y * sin, x * sin + y * cos
+
+    for _name, instance in _instances(code):
+        box = _box(instance)
+        center = box["3D oriented bounding box center coordinates"]
+        x, y = rotate_xy(center[0], center[1])
+        box["3D oriented bounding box center coordinates"] = [round(x, 2), round(y, 2), center[2]]
+        vectors = box["3D oriented bounding box orientation unit vectors"]
+        box["3D oriented bounding box orientation unit vectors"] = [
+            [round(v, 2) for v in (*rotate_xy(vector[0], vector[1]), vector[2])]
+            for vector in vectors
+        ]
+    for polygon in _polygons(code):
+        if "outer boundary coordinates" in polygon:
+            polygon["outer boundary coordinates"] = [
+                [round(v, 2) for v in rotate_xy(x, y)]
+                for x, y in polygon["outer boundary coordinates"]
+            ]
+        if "interior hole boundary coordinates" in polygon:
+            polygon["interior hole boundary coordinates"] = [
+                [[round(v, 2) for v in rotate_xy(x, y)] for x, y in hole]
+                for hole in polygon["interior hole boundary coordinates"]
+            ]
+    return code
+
+
+def reorder(code, _magnitude, rng):
+    """Shuffle class order and instance order (surface form only -- JSON object order
+    is what the model reads, but no geometry changes at all)."""
+    code = _copy(code)
+    names = list(code["objects"])
+    rng.shuffle(names)
+    reordered = {}
+    for name in names:
+        items = list(code["objects"][name])
+        rng.shuffle(items)
+        reordered[name] = items
+    code["objects"] = reordered
+    return code
+
+
+def round_precision(code, decimals, rng=None):
+    """Re-round every numeric geometry value to ``decimals`` places. NOT guaranteed
+    answer-preserving a priori (aggressive rounding can flip a borderline answer) --
+    which is exactly why the solver certification step exists: only (scene, decimals)
+    pairs the solver certifies unchanged enter H24."""
+    code = _copy(code)
+    decimals = int(decimals)
+    for _name, instance in _instances(code):
+        box = _box(instance)
+        for key in (
+            "3D oriented bounding box center coordinates",
+            "3D oriented bounding box dimensions",
+        ):
+            box[key] = [round(value, decimals) for value in box[key]]
+        box["3D oriented bounding box orientation unit vectors"] = [
+            [round(value, decimals) for value in vector]
+            for vector in box["3D oriented bounding box orientation unit vectors"]
+        ]
+    return code
+
+
+# name -> (callable, family); every callable takes (code, magnitude, rng).
+NOISE_TRANSFORMS = {
+    "position-jitter": position_jitter,
+    "dimension-noise": dimension_noise,
+    "drop-objects": drop_objects,
+    "hallucinate-objects": hallucinate_objects,
+    "class-swap": class_swap,
+}
+INVARIANCE_TRANSFORMS = {
+    "translate": translate,
+    "rotate-z": rotate_z,
+    "reorder": reorder,
+    "round-precision": round_precision,
+}
+TRANSFORMS = {**NOISE_TRANSFORMS, **INVARIANCE_TRANSFORMS}

harness/C/sweep.py

@@ -52,20 +52,23 @@ def build_plan(models, spatial_code_formats, input_selections, frame_counts, dep
 def sweep(
     models, spatial_code_formats, input_selections, frame_counts, selected_scenes,
     depths=(DEFAULT_DEPTH,), trackings=(DEFAULT_TRACKING,), results_dir=None, rebuild=False,
+    extended=True,
 ):
     """Run every sweep combination across all visible GPUs."""
     plan = build_plan(models, spatial_code_formats, input_selections, frame_counts, depths, trackings)
+    protocol = "extended" if extended else "base"
     for index, (model, spatial_code_format, depth, tracking, input_selection, frame_count) in enumerate(
         plan, start=1
     ):
         print(
-            f"=== sweep {index}/{len(plan)}: "
-            f"{model}/{spatial_code_format}/{depth}/{tracking}/{input_selection}/{frame_count} ===",
+            f"=== sweep {index}/{len(plan)}: {model}/{protocol}/"
+            f"{spatial_code_format}/{depth}/{tracking}/{input_selection}/{frame_count} ===",
             flush=True,
         )
         harness_launch.launch(
             model, spatial_code_format, input_selection, frame_count, selected_scenes,
             depth=depth, tracking=tracking, results_dir=results_dir, rebuild=rebuild,
+            extended=extended,
         )
 
 
@@ -100,6 +103,11 @@ 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 2048-token default",
+    )
     args = parser.parse_args()
     if args.scene and args.scenes:
         parser.error("positional scene and --scenes cannot be used together")
@@ -132,6 +140,7 @@ def main():
         models, spatial_code_formats, input_selections, frame_counts, selected,
         depths=depths, trackings=trackings,
         results_dir=args.results_dir, rebuild=args.rebuild,
+        extended=not args.base_protocol,
     )
 
 

harness/D/launch.py

@@ -39,7 +39,7 @@ def _load_run_module():
 
 
 def _worker(tasks, results, model, spatial_code_format, results_dir, gpu, cpu_threads,
-            reasoning_budget, force_budget):
+            extended, reasoning_budget, force_budget):
     if gpu is not None:
         os.environ["CUDA_VISIBLE_DEVICES"] = str(gpu)
     for variable in ("OMP_NUM_THREADS", "MKL_NUM_THREADS", "OPENBLAS_NUM_THREADS"):
@@ -66,6 +66,7 @@ def _worker(tasks, results, model, spatial_code_format, results_dir, gpu, cpu_th
                 scene=scene,
                 results_dir=results_dir,
                 adapter=adapter,
+                extended=extended,
                 reasoning_budget=reasoning_budget,
                 force_budget=force_budget,
             )
@@ -81,12 +82,13 @@ def _worker(tasks, results, model, spatial_code_format, results_dir, gpu, cpu_th
 
 def launch(
     model, spatial_code_format, selected, results_dir=None, rebuild=False,
-    reasoning_budget=EXTENDED_MAX_NEW_TOKENS, force_budget=MAX_NEW_TOKENS,
+    extended=True, reasoning_budget=EXTENDED_MAX_NEW_TOKENS, force_budget=MAX_NEW_TOKENS,
 ):
     """Answer every question for ``selected`` scenes, sharded across every visible GPU."""
-    condition = f"{model}/{spatial_code_format}"
+    protocol = "extended" if extended else "base"
+    condition = f"{model}/{protocol}/{spatial_code_format}"
     run = _load_run_module()
-    root = run.results_dir_for(model, spatial_code_format, results_dir)
+    root = run.results_dir_for(model, protocol, spatial_code_format, results_dir)
     pending = []
     completed = 0
     for scene in selected:
@@ -123,7 +125,7 @@ def launch(
             target=_worker,
             args=(
                 tasks, results, model, spatial_code_format, results_dir, gpu, cpu_threads,
-                reasoning_budget, force_budget,
+                extended, reasoning_budget, force_budget,
             ),
         )
         for gpu in assignments
@@ -174,6 +176,10 @@ 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 harness.A's exact fixed 16-token protocol instead of the extended default",
+    )
     parser.add_argument("--reasoning-budget", type=int, default=EXTENDED_MAX_NEW_TOKENS)
     parser.add_argument("--force-budget", type=int, default=MAX_NEW_TOKENS)
     args = parser.parse_args()
@@ -193,6 +199,7 @@ def main():
     launch(
         args.model, args.spatial_code_format, selected,
         results_dir=args.results_dir, rebuild=args.rebuild,
+        extended=not args.base_protocol,
         reasoning_budget=args.reasoning_budget, force_budget=args.force_budget,
     )
 

harness/D/sweep.py

@@ -37,14 +37,21 @@ def build_plan(models, spatial_code_formats):
     ]
 
 
-def sweep(models, spatial_code_formats, selected_scenes, results_dir=None, rebuild=False):
+def sweep(
+    models, spatial_code_formats, selected_scenes, results_dir=None, rebuild=False,
+    extended=True,
+):
     """Run every (model, spatial_code_format) pair across all visible GPUs."""
     plan = build_plan(models, spatial_code_formats)
+    protocol = "extended" if extended else "base"
     for index, (model, spatial_code_format) in enumerate(plan, start=1):
-        print(f"=== sweep {index}/{len(plan)}: {model}/{spatial_code_format} ===", flush=True)
+        print(
+            f"=== sweep {index}/{len(plan)}: {model}/{protocol}/{spatial_code_format} ===",
+            flush=True,
+        )
         harness_launch.launch(
             model, spatial_code_format, selected_scenes,
-            results_dir=results_dir, rebuild=rebuild,
+            results_dir=results_dir, rebuild=rebuild, extended=extended,
         )
 
 
@@ -64,6 +71,11 @@ 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 2048-token default",
+    )
     args = parser.parse_args()
     if args.scene and args.scenes:
         parser.error("positional scene and --scenes cannot be used together")
@@ -84,7 +96,11 @@ def main():
     else:
         selected = [args.scene] if args.scene else harness_launch.scenes()
 
-    sweep(models, spatial_code_formats, selected, results_dir=args.results_dir, rebuild=args.rebuild)
+    sweep(
+        models, spatial_code_formats, selected,
+        results_dir=args.results_dir, rebuild=args.rebuild,
+        extended=not args.base_protocol,
+    )
 
 
 if __name__ == "__main__":

harness/E/__init__.py

@@ -0,0 +1,33 @@
+"""Harness E: the BLIND floor -- question (and options) only, no video frames, no
+spatial code, no scene information of any kind.
+
+VSI-Bench's own paper shows blind LLMs beat chance on several categories through pure
+priors (typical room sizes, typical object sizes), so a question-only floor is what
+separates "the model used the geometry it was given" from "the prompt shifted its
+priors." Every harness A/B/C/D delta is only interpretable against this floor.
+
+Reuses harness.A's models, generation protocols (base 16-token by default, --extended
+opt-in, exactly like harness.A), question-type split, and post-prompts. Results are
+written in the identical per-question record shape as every other harness:
+results/E/<model>/<protocol>/<scene>/<question_id>.json.
+"""
+
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+from harness.A import (
+    DO_SAMPLE,
+    JSONL,
+    MAX_NEW_TOKENS,
+    MODEL_PATHS,
+    PROTOCOLS,
+    TEMPERATURE,
+    WORKSPACE_ROOT,
+)
+
+# One JSON per question: results/E/<model>/<protocol>/<scene>/<question_id>.json
+RESULTS_DIR = Path(
+    os.environ.get("VSI_HARNESS_E_RESULTS_DIR", WORKSPACE_ROOT / "results" / "E")
+)

harness/E/launch.py

@@ -0,0 +1,188 @@
+"""Keep every visible GPU busy with persistent harness-E (blind floor) workers.
+
+Same shape as ``harness.A.launch``: one persistent worker process per visible GPU,
+pulling scenes off a shared queue, each loading its model exactly once and reusing it
+for every scene it's assigned (via ``run.run(..., adapter=...)``). One invocation
+covers one (model, protocol) pair across every requested scene.
+"""
+
+from __future__ import annotations
+
+import argparse
+import importlib.util
+import multiprocessing as mp
+import os
+from pathlib import Path
+import sys
+import traceback
+
+HERE = Path(__file__).resolve().parent
+WORKSPACE_ROOT = HERE.parent.parent
+if str(WORKSPACE_ROOT) not in sys.path:
+    sys.path.insert(0, str(WORKSPACE_ROOT))
+
+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.launch import scenes  # noqa: E402
+from inference.launch import available_cpu_count, visible_gpus  # noqa: E402
+
+
+def _load_run_module():
+    spec = importlib.util.spec_from_file_location("_harness_E_run", HERE / "run.py")
+    module = importlib.util.module_from_spec(spec)
+    sys.modules[spec.name] = module
+    spec.loader.exec_module(module)
+    return module
+
+
+def _worker(tasks, results, model, results_dir, gpu, cpu_threads, extended,
+            reasoning_budget, force_budget):
+    if gpu is not None:
+        os.environ["CUDA_VISIBLE_DEVICES"] = str(gpu)
+    for variable in ("OMP_NUM_THREADS", "MKL_NUM_THREADS", "OPENBLAS_NUM_THREADS"):
+        os.environ[variable] = str(cpu_threads)
+    run = _load_run_module()
+    adapter = None
+    load_error = None
+    try:
+        adapter = vlm_models.get_adapter(model)
+        adapter.load_model("cuda:0" if gpu is not None else "cpu")
+    except Exception:
+        load_error = traceback.format_exc()
+    while True:
+        scene = tasks.get()
+        if scene is None:
+            return
+        if load_error is not None:
+            results.put((scene, False, load_error))
+            continue
+        try:
+            answered = run.run(
+                model,
+                scene=scene,
+                results_dir=results_dir,
+                adapter=adapter,
+                extended=extended,
+                reasoning_budget=reasoning_budget,
+                force_budget=force_budget,
+            )
+            mean_score = (
+                sum(r["score"] for r in answered) / len(answered) if answered else None
+            )
+            results.put(
+                (scene, True, f"{len(answered)} question(s), mean_score={mean_score}")
+            )
+        except Exception:
+            results.put((scene, False, traceback.format_exc()))
+
+
+def launch(
+    model, selected, results_dir=None, rebuild=False, extended=False,
+    reasoning_budget=EXTENDED_MAX_NEW_TOKENS, force_budget=MAX_NEW_TOKENS,
+):
+    """Answer every question for ``selected`` scenes, sharded across every visible GPU."""
+    protocol = "extended" if extended else "base"
+    condition = f"{model}/{protocol}"
+    run = _load_run_module()
+    root = run.results_dir_for(model, protocol, results_dir)
+    pending = []
+    completed = 0
+    for scene in selected:
+        rows = run.load_questions(scene=scene)
+        answered = all((root / scene / f"{row['id']}.json").is_file() for row in rows)
+        if answered and not rebuild:
+            completed += 1
+            print(f"[{condition} {completed}/{len(selected)}] {scene}: skipped", flush=True)
+        else:
+            pending.append(scene)
+    if not pending:
+        print(f"[{condition}] DONE: {len(selected)} ok, 0 failed")
+        return
+
+    gpus = visible_gpus()
+    worker_count = min(len(pending), len(gpus) if gpus else 1)
+    assignments = gpus[:worker_count] if gpus else [None]
+    cpu_count = available_cpu_count()
+    cpu_threads = max(1, cpu_count // worker_count)
+    print(
+        f"[{condition}] starting {worker_count} persistent worker(s); "
+        f"GPUs={assignments}; CPU threads/worker={cpu_threads}",
+        flush=True,
+    )
+
+    context = mp.get_context("spawn")
+    tasks, results = context.Queue(), context.Queue()
+    for scene in pending:
+        tasks.put(scene)
+    for _ in range(worker_count):
+        tasks.put(None)
+    workers = [
+        context.Process(
+            target=_worker,
+            args=(
+                tasks, results, model, results_dir, gpu, cpu_threads, extended,
+                reasoning_budget, force_budget,
+            ),
+        )
+        for gpu in assignments
+    ]
+    for worker in workers:
+        worker.start()
+    failed = []
+    for finished in range(1, len(pending) + 1):
+        scene, ok, detail = results.get()
+        if not ok:
+            failed.append(scene)
+        print(
+            f"[{condition} {completed + finished}/{len(selected)}] {scene}: "
+            f"{'done' if ok else 'FAILED'}\n{detail}",
+            flush=True,
+        )
+    for worker in workers:
+        worker.join()
+    print(
+        f"[{condition}] DONE: {len(pending) - len(failed)} answered, {completed} skipped, "
+        f"{len(failed)} failed"
+    )
+    if failed:
+        raise SystemExit(1)
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("scene", nargs="?")
+    parser.add_argument(
+        "--scenes", help="comma-separated scenes (cannot be combined with positional scene)"
+    )
+    parser.add_argument("--model", required=True, choices=vlm_models.available_models())
+    parser.add_argument("--results-dir", default=None)
+    parser.add_argument("--rebuild", action="store_true")
+    parser.add_argument(
+        "--extended", action="store_true",
+        help="use the extended 2048-token protocol instead of the fixed 16-token default",
+    )
+    parser.add_argument("--reasoning-budget", type=int, default=EXTENDED_MAX_NEW_TOKENS)
+    parser.add_argument("--force-budget", type=int, default=MAX_NEW_TOKENS)
+    args = parser.parse_args()
+    if args.scene and args.scenes:
+        parser.error("positional scene and --scenes cannot be used together")
+    if args.scenes is not None:
+        selected = [scene.strip() for scene in args.scenes.split(",") if scene.strip()]
+        if not selected:
+            parser.error("--scenes must contain at least one scene")
+        selected = list(dict.fromkeys(selected))
+    else:
+        selected = [args.scene] if args.scene else scenes()
+    if args.reasoning_budget < 1:
+        parser.error("--reasoning-budget must be positive")
+    if args.force_budget < 1:
+        parser.error("--force-budget must be positive")
+    launch(
+        args.model, selected, results_dir=args.results_dir, rebuild=args.rebuild,
+        extended=args.extended, reasoning_budget=args.reasoning_budget,
+        force_budget=args.force_budget,
+    )
+
+
+if __name__ == "__main__":
+    main()

harness/E/prompts.py

@@ -0,0 +1,28 @@
+"""VSI-Bench prompt construction with NO scene input at all -- the blind floor.
+
+Reuses harness.A.prompts's exact question-type split and post-prompts verbatim. There
+is deliberately NO context line: there are no frames and no spatial code to describe,
+and inventing one ("answer from your general knowledge") would itself be an
+uncontrolled prompt manipulation. The prompt is exactly the question (and options)
+plus the same post-prompt every other harness uses for that question type.
+"""
+
+from __future__ import annotations
+
+from harness.A.prompts import MCA_POST_PROMPT, MCA_QUESTION_TYPES, NA_POST_PROMPT, NA_QUESTION_TYPES
+
+
+def build_prompt(question_type, question, options=None):
+    """Return the blind text prompt: the question, options (for MCA types), and the
+    same VSI-Bench post-prompt harness.A uses for the same question_type."""
+    if question_type in NA_QUESTION_TYPES:
+        return question + "\n" + NA_POST_PROMPT
+    if question_type in MCA_QUESTION_TYPES:
+        if not options:
+            raise ValueError(f"question_type {question_type!r} requires options")
+        options_block = "Options:\n" + "\n".join(options)
+        return "\n".join([question, options_block, MCA_POST_PROMPT])
+    raise ValueError(
+        f"unknown question_type {question_type!r}; "
+        f"expected one of {MCA_QUESTION_TYPES + NA_QUESTION_TYPES}"
+    )

harness/E/sweep.py

@@ -0,0 +1,78 @@
+"""Sweep any set of models over the blind floor (question-only, no scene input).
+
+Every model in the sweep is run through ``harness.E.launch.launch`` in turn, so each
+model individually saturates every visible GPU before the next one starts. The only
+other axis is the generation protocol (--extended), matching harness.A's flag.
+"""
+
+from __future__ import annotations
+
+import argparse
+from pathlib import Path
+import sys
+
+HERE = Path(__file__).resolve().parent
+WORKSPACE_ROOT = HERE.parent.parent
+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.sweep import _parse_csv_choice  # noqa: E402
+from harness.E import launch as harness_launch  # noqa: E402
+
+
+def sweep(models, selected_scenes, results_dir=None, rebuild=False, extended=False):
+    """Run every model across all visible GPUs."""
+    protocol = "extended" if extended else "base"
+    for index, model in enumerate(models, start=1):
+        print(f"=== sweep {index}/{len(models)}: {model}/{protocol} ===", flush=True)
+        harness_launch.launch(
+            model, selected_scenes, results_dir=results_dir, rebuild=rebuild,
+            extended=extended,
+        )
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("scene", nargs="?")
+    parser.add_argument(
+        "--scenes", help="comma-separated scenes (cannot be combined with positional scene)"
+    )
+    parser.add_argument(
+        "--models", required=True,
+        help=f"comma-separated models (or 'all'); one of {vlm_models.available_models()}",
+    )
+    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 2048-token protocol instead of "
+        "the fixed 16-token default",
+    )
+    args = parser.parse_args()
+    if args.scene and args.scenes:
+        parser.error("positional scene and --scenes cannot be used together")
+
+    try:
+        models = _parse_csv_choice(args.models, vlm_models.available_models(), "--models")
+    except ValueError as exc:
+        parser.error(str(exc))
+
+    if args.scenes is not None:
+        selected = [scene.strip() for scene in args.scenes.split(",") if scene.strip()]
+        if not selected:
+            parser.error("--scenes must contain at least one scene")
+        selected = list(dict.fromkeys(selected))
+    else:
+        from harness.A.launch import scenes
+
+        selected = [args.scene] if args.scene else scenes()
+
+    sweep(
+        models, selected, results_dir=args.results_dir, rebuild=args.rebuild,
+        extended=args.extended,
+    )
+
+
+if __name__ == "__main__":
+    main()

tests/test_A/test_run.py

@@ -41,6 +41,7 @@ _FAKE_ROW = {
 }
 
 _FAKE_FRAME_INFO = {
+    "protocol": "base",
     "video_path": "/root/data/VSI-Bench/scannet/scene0001_00.mp4",
     "frame_timestamps": [0.0, 1.0, 2.0],
     "frame_indices": [0, 30, 60],
@@ -100,12 +101,18 @@ 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", "selective", 32)
-    assert root == A.RESULTS_DIR / "qwen3.5-4b" / "selective" / "32"
+    root = harness_run.results_dir_for("qwen3.5-4b", "base", "selective", 32)
+    assert root == A.RESULTS_DIR / "qwen3.5-4b" / "base" / "selective" / "32"
+
+
+def test_results_dir_for_isolates_the_two_protocols():
+    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
 
 
 def test_results_dir_for_honors_explicit_override(tmp_path):
-    assert harness_run.results_dir_for("qwen3.5-4b", "uniform", 16, tmp_path) == tmp_path
+    assert harness_run.results_dir_for("qwen3.5-4b", "base", "uniform", 16, tmp_path) == tmp_path
 
 
 def test_build_record_preserves_every_field_untruncated():

tests/test_symbolic/test_solver.py

@@ -121,3 +121,58 @@ def test_dispatch_returns_none_for_unknown_or_missing_data(spatial_code):
     )
     assert solver.pairwise_swap_distance(["a", "b", "c"], ["b", "a", "c"]) == 1
     assert solver.pairwise_swap_distance(["a"], ["b"]) is None
+
+
+def test_answer_snapshots_operation_counts_per_question():
+    """H25 instrumentation: LAST_ANSWER_OPS reflects only the LAST question, and a
+    multi-step distance question costs strictly more operations than a pure count
+    lookup. Counting must never change any answer (every other test in this file
+    still passing is the guarantee)."""
+    from symbolic import adapters, solver
+
+    code = adapters.adapt_spatial_code(
+        {
+            "spatial code schema": {},
+            "objects": {
+                "chair": [
+                    {
+                        "3D oriented bounding box": {
+                            "3D oriented bounding box center coordinates": [0.0, 0.0, 0.5],
+                            "3D oriented bounding box dimensions": [1.0, 1.0, 1.0],
+                            "3D oriented bounding box orientation unit vectors": [
+                                [1.0, 0.0, 0.0], [0.0, 0.0, 1.0], [0.0, -1.0, 0.0],
+                            ],
+                        },
+                        "first visible time": 0.0,
+                    }
+                ],
+                "table": [
+                    {
+                        "3D oriented bounding box": {
+                            "3D oriented bounding box center coordinates": [3.0, 0.0, 0.5],
+                            "3D oriented bounding box dimensions": [2.0, 1.0, 1.0],
+                            "3D oriented bounding box orientation unit vectors": [
+                                [1.0, 0.0, 0.0], [0.0, 0.0, 1.0], [0.0, -1.0, 0.0],
+                            ],
+                        },
+                        "first visible time": 1.0,
+                    }
+                ],
+            },
+            "room": {"floor boundary polygons": []},
+        }
+    )
+
+    solver.answer("object_counting", "How many chair(s) are in this room?", None, code)
+    counting_ops = dict(solver.LAST_ANSWER_OPS)
+    assert counting_ops["total"] >= 1
+
+    solver.answer(
+        "object_abs_distance",
+        "Measuring from the closest point of each object, what is the direct distance "
+        "between the chair and the table (in meters)?",
+        None,
+        code,
+    )
+    distance_ops = dict(solver.LAST_ANSWER_OPS)
+    assert distance_ops["total"] > counting_ops["total"]