Add files using upload-large-folder tool

tests/test_C/test_C.py

@@ -0,0 +1,27 @@
+"""Tests for harness/C/__init__.py -- shared config constants."""
+
+from pathlib import Path
+
+from harness import A, B, C
+
+
+def test_input_selections_are_one_shared_vocabulary_with_a_and_b():
+    assert B.INPUT_SELECTIONS == A.FRAME_SELECTIONS
+
+
+def test_reuses_harness_a_model_paths_and_generation_protocol():
+    assert C.MODEL_PATHS is A.MODEL_PATHS
+    assert C.MAX_NEW_TOKENS == A.MAX_NEW_TOKENS
+    assert C.DO_SAMPLE == A.DO_SAMPLE
+    assert C.TEMPERATURE == A.TEMPERATURE
+
+
+def test_results_dir_defaults_under_root_results():
+    assert C.RESULTS_DIR == Path("/root/results/C")
+
+
+def test_depth_and_tracking_reuse_encoder_config_vocabulary():
+    from encoder.config import DEPTH_VARIANTS, TRACKING_MODES
+
+    assert C.DEPTH_VARIANTS == DEPTH_VARIANTS
+    assert C.TRACKING_MODES == TRACKING_MODES

tests/test_C/test_overlay.py

@@ -0,0 +1,209 @@
+"""Tests for harness/C/overlay.py -- overlay labels, cache, and stamping."""
+
+import json
+from pathlib import Path
+
+import pytest
+from PIL import Image
+
+from harness.C import overlay
+
+_EXPLICIT_CODE = {
+    "objects": {
+        "chair": {
+            "instances": [
+                {
+                    "position": {
+                        "x coordinate": "1.5 m",
+                        "y coordinate": "-2 m",
+                        "height above floor": "0.25 m",
+                    },
+                    "longest dimension": "0.80 m",
+                }
+            ]
+        },
+        "table": {
+            "instances": [
+                {
+                    "position": {
+                        "x coordinate": "3 m",
+                        "y coordinate": "4 m",
+                        "height above floor": "0 m",
+                    },
+                    "longest dimension": "1.20 m",
+                }
+            ]
+        },
+    }
+}
+
+
+def test_instance_ids_adds_stable_one_based_labels_without_mutating_input():
+    original = {"objects": {"chair": {"instances": [{"position": {}}]}}}
+
+    labeled = overlay.instance_ids(original)
+
+    assert labeled["objects"]["chair"]["instances"][0]["instance id"] == "chair 1"
+    assert "instance id" not in original["objects"]["chair"]["instances"][0]
+
+
+def test_overlay_spatial_code_path_lives_under_overlay_root(monkeypatch, tmp_path):
+    monkeypatch.setattr(
+        overlay.encoder_config, "CODES_ROOT", tmp_path / "data" / "spatial codes"
+    )
+    monkeypatch.setattr(overlay.encoder_config, "MODEL", "sam3+depth-anything-3")
+
+    path = overlay.overlay_spatial_code_path(
+        "scene", "metric", "uniform", "tracking", 32
+    )
+
+    assert path == (
+        tmp_path
+        / "data"
+        / "spatial codes"
+        / "overlay"
+        / "sam3+depth-anything-3"
+        / "metric"
+        / "tracking"
+        / "uniform"
+        / "32"
+        / "explicit"
+        / "scene.json"
+    )
+
+
+def test_load_or_create_overlay_code_saves_missing_file(monkeypatch, tmp_path):
+    monkeypatch.setattr(overlay.encoder_config, "CODES_ROOT", tmp_path / "codes")
+    monkeypatch.setattr(overlay.encoder_config, "MODEL", "model")
+
+    code, path = overlay.load_or_create_overlay_code(
+        _EXPLICIT_CODE, "scene", "metric", "uniform", "tracking", 32
+    )
+
+    path = Path(path)
+    assert path.is_file()
+    assert json.loads(path.read_text()) == code
+    assert code["objects"]["chair"]["instances"][0]["instance id"] == "chair 1"
+
+
+def test_load_or_create_overlay_code_reuses_existing_file(monkeypatch, tmp_path):
+    monkeypatch.setattr(overlay.encoder_config, "CODES_ROOT", tmp_path / "codes")
+    monkeypatch.setattr(overlay.encoder_config, "MODEL", "model")
+    path = overlay.overlay_spatial_code_path(
+        "scene", "metric", "uniform", "tracking", 32
+    )
+    path.parent.mkdir(parents=True)
+    existing = {"objects": {"saved": {"instances": []}}, "sentinel": True}
+    path.write_text(json.dumps(existing))
+
+    code, returned = overlay.load_or_create_overlay_code(
+        _EXPLICIT_CODE, "scene", "metric", "uniform", "tracking", 32
+    )
+
+    assert returned == str(path)
+    assert code == existing
+    assert json.loads(path.read_text()) == existing
+
+
+def test_label_positions_parse_meter_strings_in_code_order():
+    assert overlay.label_positions(_EXPLICIT_CODE) == [
+        ("chair 1", 1.5, -2.0, 0.25, 0.8),
+        ("table 1", 3.0, 4.0, 0.0, 1.2),
+    ]
+
+
+def test_load_cached_frames_requires_complete_png_set_and_labels(tmp_path):
+    assert overlay._load_cached_frames(tmp_path, 2) is None
+    (tmp_path / "labels.json").write_text(json.dumps([["chair 1"], []]))
+    Image.new("RGB", (4, 4), "white").save(tmp_path / "0.png")
+    assert overlay._load_cached_frames(tmp_path, 2) is None
+
+    Image.new("RGB", (4, 4), "black").save(tmp_path / "1.png")
+    images, visible = overlay._load_cached_frames(tmp_path, 2)
+
+    assert [image.mode for image in images] == ["RGB", "RGB"]
+    assert visible == [["chair 1"], []]
+
+
+def test_save_cached_frames_writes_pngs_and_labels(tmp_path):
+    frames = [Image.new("RGB", (2, 2), color) for color in ("white", "black")]
+
+    overlay._save_cached_frames(tmp_path, frames, [["a"], ["b"]])
+
+    assert (tmp_path / "0.png").is_file()
+    assert (tmp_path / "1.png").is_file()
+    assert json.loads((tmp_path / "labels.json").read_text()) == [["a"], ["b"]]
+
+
+def test_stamp_frames_uses_raw_sam3_boxes_and_does_not_mutate_inputs(
+    monkeypatch, tmp_path
+):
+    monkeypatch.setattr(
+        overlay, "overlay_frame_cache_dir", lambda *args: tmp_path / "cache"
+    )
+    monkeypatch.setattr(
+        overlay.perceive,
+        "cache_or_load",
+        lambda *args: ({"geometry": "fake"}, "cache"),
+    )
+    monkeypatch.setattr(
+        overlay.gm,
+        "instance_source_track_ids",
+        lambda geometry: {"chair": [[10]], "table": [[20]]},
+    )
+    monkeypatch.setattr(
+        overlay,
+        "_load_raw_sam3_boxes",
+        lambda *args: {
+            "chair": {0: {10: (0.10, 0.10, 0.30, 0.30)}},
+            "table": {1: {20: (0.50, 0.50, 0.25, 0.25)}},
+        },
+    )
+    frames = [Image.new("RGB", (40, 40), "white"), Image.new("RGB", (40, 40), "white")]
+    before = frames[0].copy()
+
+    stamped, visible = overlay.stamp_frames(
+        frames,
+        _EXPLICIT_CODE,
+        "scene",
+        "metric",
+        "uniform",
+        "tracking",
+        2,
+        use_cache=True,
+    )
+
+    assert visible == [["chair 1"], ["table 1"]]
+    assert stamped[0].getpixel((8, 8)) != before.getpixel((8, 8))
+    assert frames[0].tobytes() == before.tobytes()
+    cached = overlay._load_cached_frames(tmp_path / "cache", 2)
+    assert cached is not None
+    assert cached[1] == visible
+
+
+def test_stamp_frames_serves_complete_cache_without_loading_dependencies(
+    monkeypatch, tmp_path
+):
+    cache_dir = tmp_path / "cache"
+    overlay._save_cached_frames(
+        cache_dir, [Image.new("RGB", (2, 2), "red")], [["cached"]]
+    )
+    monkeypatch.setattr(overlay, "overlay_frame_cache_dir", lambda *args: cache_dir)
+    monkeypatch.setattr(
+        overlay.perceive,
+        "cache_or_load",
+        lambda *args: pytest.fail("cache hit should not touch perception"),
+    )
+
+    stamped, visible = overlay.stamp_frames(
+        [Image.new("RGB", (2, 2), "white")],
+        {},
+        "scene",
+        "metric",
+        "uniform",
+        "tracking",
+        1,
+    )
+
+    assert visible == [["cached"]]
+    assert stamped[0].getpixel((0, 0)) == (255, 0, 0)

tests/test_C/test_overlay_launch.py

@@ -0,0 +1,144 @@
+"""Tests for harness/C/overlay_launch.py -- cache pregeneration orchestration."""
+
+import pytest
+
+from harness.C import overlay_launch
+
+
+def test_available_cpu_count_honors_positive_environment(monkeypatch):
+    monkeypatch.setenv("VSI_CPU_WORKERS", "3")
+    assert overlay_launch._available_cpu_count() == 3
+    monkeypatch.setenv("VSI_CPU_WORKERS", "0")
+    with pytest.raises(ValueError, match="positive"):
+        overlay_launch._available_cpu_count()
+
+
+def test_has_dependencies_requires_spatial_code_and_sam3_cache(monkeypatch, tmp_path):
+    cache = tmp_path / "sam3.pt"
+    monkeypatch.setattr(
+        overlay_launch.spatial_codes,
+        "load_spatial_code",
+        lambda *args: ({"objects": {}}, "code.json"),
+    )
+    monkeypatch.setattr(
+        "encoder.config.sam3_cache_file",
+        lambda *args: cache,
+    )
+
+    assert (
+        overlay_launch._has_dependencies("scene", "metric", "uniform", "tracking", 32)
+        is False
+    )
+    cache.write_text("cache")
+    assert (
+        overlay_launch._has_dependencies("scene", "metric", "uniform", "tracking", 32)
+        is True
+    )
+
+
+def test_has_dependencies_treats_missing_code_as_ineligible(monkeypatch):
+    def missing(*args):
+        raise FileNotFoundError("missing code")
+
+    monkeypatch.setattr(overlay_launch.spatial_codes, "load_spatial_code", missing)
+    assert (
+        overlay_launch._has_dependencies("scene", "metric", "uniform", "tracking", 32)
+        is False
+    )
+
+
+def test_launch_skips_missing_and_already_cached_without_pool(
+    monkeypatch, tmp_path, capsys
+):
+    monkeypatch.setattr(
+        overlay_launch,
+        "_has_dependencies",
+        lambda scene, *args: scene != "missing",
+    )
+    monkeypatch.setattr(
+        overlay_launch.overlay,
+        "overlay_frame_cache_dir",
+        lambda scene, *args: tmp_path / scene,
+    )
+    monkeypatch.setattr(
+        overlay_launch.overlay,
+        "_load_cached_frames",
+        lambda cache_dir, frame_count: (
+            ([object()], [[]]) if cache_dir.name == "cached" else None
+        ),
+    )
+    monkeypatch.setattr(
+        overlay_launch.overlay,
+        "overlay_spatial_code_path",
+        lambda scene, *args: tmp_path / scene / "overlay-code.json",
+    )
+    (tmp_path / "cached").mkdir()
+    (tmp_path / "cached" / "overlay-code.json").write_text("{}")
+    monkeypatch.setattr(
+        overlay_launch.mp,
+        "get_context",
+        lambda *_: pytest.fail("no pending scenes should avoid multiprocessing"),
+    )
+
+    succeeded, failed, missing = overlay_launch.launch(
+        "metric", "uniform", "tracking", 32, ["missing", "cached"]
+    )
+
+    assert succeeded == []
+    assert failed == []
+    assert missing == ["missing"]
+    output = capsys.readouterr().out
+    assert "missing a code or SAM3 cache" in output
+    assert "already cached" in output
+
+
+def test_launch_does_not_skip_frames_cache_when_overlay_code_is_missing(
+    monkeypatch, tmp_path
+):
+    monkeypatch.setattr(overlay_launch, "_has_dependencies", lambda scene, *args: True)
+    monkeypatch.setattr(
+        overlay_launch.overlay,
+        "overlay_frame_cache_dir",
+        lambda scene, *args: tmp_path / scene,
+    )
+    monkeypatch.setattr(
+        overlay_launch.overlay,
+        "_load_cached_frames",
+        lambda cache_dir, frame_count: ([object()], [[]]),
+    )
+    monkeypatch.setattr(
+        overlay_launch.overlay,
+        "overlay_spatial_code_path",
+        lambda scene, *args: tmp_path / scene / "missing-overlay-code.json",
+    )
+
+    calls = []
+
+    class FakePool:
+        def __init__(self, workers):
+            self.workers = workers
+
+        def __enter__(self):
+            return self
+
+        def __exit__(self, *exc):
+            return False
+
+        def map(self, fn, tasks):
+            calls.extend(tasks)
+            return [(task[0], True, None) for task in tasks]
+
+    class FakeContext:
+        def Pool(self, workers):
+            return FakePool(workers)
+
+    monkeypatch.setattr(overlay_launch.mp, "get_context", lambda *_: FakeContext())
+
+    succeeded, failed, missing = overlay_launch.launch(
+        "metric", "uniform", "tracking", 32, ["frames_only"], workers=1
+    )
+
+    assert calls == [("frames_only", "metric", "uniform", "tracking", 32)]
+    assert succeeded == ["frames_only"]
+    assert failed == []
+    assert missing == []

tests/test_C/test_prompts.py

@@ -7,7 +7,10 @@ import pytest
 from harness.A.prompts import MCA_QUESTION_TYPES, NA_QUESTION_TYPES
 from harness.C import prompts as combined_prompts
 
-_CODE = {"objects": {"chair": {"count": 1}}, "room": {"floor area": "10.0 square meters"}}
+_CODE = {
+    "objects": {"chair": {"count": 1}},
+    "room": {"floor area": "10.0 square meters"},
+}
 
 
 def test_pre_prompt_mentions_both_frames_and_spatial_code():

tests/test_C/test_run.py

@@ -58,22 +58,65 @@ def test_results_dir_for_matches_established_dimension_nesting():
         "qwen3.5-4b", "extended", "compact", "metric", "tracking", "uniform", 32
     )
     assert root == (
-        C.RESULTS_DIR / "qwen3.5-4b" / "extended" / "compact" / "metric" / "tracking"
-        / "uniform" / "32"
+        C.RESULTS_DIR
+        / "qwen3.5-4b"
+        / "extended"
+        / "compact"
+        / "metric"
+        / "tracking"
+        / "uniform"
+        / "32"
     )
 
 
 def test_results_dir_for_honors_explicit_override(tmp_path):
     root = harness_run.results_dir_for(
-        "qwen3.5-4b", "base", "explicit", "relative", "no tracking", "selective", 16, tmp_path
+        "qwen3.5-4b",
+        "base",
+        "explicit",
+        "relative",
+        "no tracking",
+        "selective",
+        16,
+        tmp_path,
     )
     assert root == tmp_path
 
 
+def test_results_dir_for_places_overlay_under_C_results():
+    root = harness_run.results_dir_for(
+        "qwen3.5-4b",
+        "extended",
+        "explicit",
+        "metric",
+        "tracking",
+        "uniform",
+        32,
+        overlay=True,
+    )
+    assert root == (
+        C.RESULTS_DIR
+        / "overlay"
+        / "qwen3.5-4b"
+        / "extended"
+        / "explicit"
+        / "metric"
+        / "tracking"
+        / "uniform"
+        / "32"
+    )
+
+
 def test_build_record_carries_both_frame_and_spatial_code_provenance():
     record = harness_run._build_record(
-        _FAKE_ROW, "full prompt text", _FAKE_ANSWER, "MRA:.5:.95:.05", 1.0,
-        "qwen3.5-4b", "/root/models/qwen3.5-4b", _FAKE_SOURCE_INFO,
+        _FAKE_ROW,
+        "full prompt text",
+        _FAKE_ANSWER,
+        "MRA:.5:.95:.05",
+        1.0,
+        "qwen3.5-4b",
+        "/root/models/qwen3.5-4b",
+        _FAKE_SOURCE_INFO,
     )
     # Spatial-code provenance (shared with harness.B).
     assert record["spatial_code_format"] == "explicit"
@@ -97,14 +140,51 @@ def test_build_record_carries_both_frame_and_spatial_code_provenance():
 
 def test_write_question_result_writes_one_json_file_per_question(tmp_path):
     path, record = harness_run.write_question_result(
-        _FAKE_ROW, "full prompt text", _FAKE_ANSWER, "MRA:.5:.95:.05", 1.0,
-        "qwen3.5-4b", "/root/models/qwen3.5-4b", _FAKE_SOURCE_INFO, results_dir=tmp_path,
+        _FAKE_ROW,
+        "full prompt text",
+        _FAKE_ANSWER,
+        "MRA:.5:.95:.05",
+        1.0,
+        "qwen3.5-4b",
+        "/root/models/qwen3.5-4b",
+        _FAKE_SOURCE_INFO,
+        results_dir=tmp_path,
     )
     assert path == tmp_path / "scene0001_00" / "7.json"
     on_disk = json.loads(path.read_text())
     assert on_disk == record
 
 
+def test_write_question_result_routes_overlay_default_to_overlay_tree(
+    tmp_path, monkeypatch
+):
+    monkeypatch.setattr(harness_run, "RESULTS_DIR", tmp_path)
+    source_info = {**_FAKE_SOURCE_INFO, "overlay": True}
+    path, _record = harness_run.write_question_result(
+        _FAKE_ROW,
+        "full prompt text",
+        _FAKE_ANSWER,
+        "MRA:.5:.95:.05",
+        1.0,
+        "qwen3.5-4b",
+        "/root/models/qwen3.5-4b",
+        source_info,
+    )
+    assert path == (
+        tmp_path
+        / "overlay"
+        / "qwen3.5-4b"
+        / "extended"
+        / "explicit"
+        / "metric"
+        / "tracking"
+        / "selective"
+        / "64"
+        / "scene0001_00"
+        / "7.json"
+    )
+
+
 def test_build_record_carries_reasoning_fields_when_forced():
     extended_answer = {
         **_FAKE_ANSWER,
@@ -117,9 +197,17 @@ def test_build_record_carries_reasoning_fields_when_forced():
         "forced_input_token_count": 22300,
     }
     record = harness_run._build_record(
-        _FAKE_ROW, "full prompt text", extended_answer, "MRA:.5:.95:.05", 1.0,
-        "qwen3.5-4b", "/root/models/qwen3.5-4b", _FAKE_SOURCE_INFO,
+        _FAKE_ROW,
+        "full prompt text",
+        extended_answer,
+        "MRA:.5:.95:.05",
+        1.0,
+        "qwen3.5-4b",
+        "/root/models/qwen3.5-4b",
+        _FAKE_SOURCE_INFO,
+    )
+    assert (
+        record["reasoning_text"] == "long reasoning about the frames and spatial code"
     )
-    assert record["reasoning_text"] == "long reasoning about the frames and spatial code"
     assert record["forced"] is True
     assert record["forced_input_token_count"] == 22300

tests/test_C/test_sweep.py

@@ -8,8 +8,12 @@ from harness.C import sweep
 
 def test_build_plan_covers_every_combination():
     plan = sweep.build_plan(
-        ["qwen3.5-2b", "qwen3.5-4b"], ["explicit", "compact"], ["uniform", "selective"],
-        [16, 32], ["metric"], ["tracking"],
+        ["qwen3.5-2b", "qwen3.5-4b"],
+        ["explicit", "compact"],
+        ["uniform", "selective"],
+        [16, 32],
+        ["metric"],
+        ["tracking"],
     )
     assert len(plan) == 2 * 2 * 2 * 2
     assert ("qwen3.5-2b", "explicit", "metric", "tracking", "uniform", 16) in plan
@@ -18,8 +22,12 @@ def test_build_plan_covers_every_combination():
 
 def test_build_plan_sweeps_depth_and_tracking_too():
     plan = sweep.build_plan(
-        ["qwen3.5-2b"], ["explicit"], ["uniform"], [16],
-        ["metric", "relative"], ["tracking", "no tracking"],
+        ["qwen3.5-2b"],
+        ["explicit"],
+        ["uniform"],
+        [16],
+        ["metric", "relative"],
+        ["tracking", "no tracking"],
     )
     assert len(plan) == 4
     assert ("qwen3.5-2b", "explicit", "relative", "no tracking", "uniform", 16) in plan
@@ -27,22 +35,54 @@ def test_build_plan_sweeps_depth_and_tracking_too():
 
 def test_build_plan_orders_by_frame_count_first():
     plan = sweep.build_plan(
-        ["qwen3.5-2b"], ["explicit"], ["uniform"], [64, 16, 32], ["metric"], ["tracking"]
+        ["qwen3.5-2b"],
+        ["explicit"],
+        ["uniform"],
+        [64, 16, 32],
+        ["metric"],
+        ["tracking"],
     )
     assert [frame_count for *_rest, frame_count in plan] == [16, 32, 64]
 
 
 def test_build_plan_with_all_registered_models():
     plan = sweep.build_plan(
-        list(vlm_models.available_models()), ["explicit"], ["uniform"], [16],
-        ["metric"], ["tracking"],
+        list(vlm_models.available_models()),
+        ["explicit"],
+        ["uniform"],
+        [16],
+        ["metric"],
+        ["tracking"],
     )
     assert len(plan) == len(vlm_models.available_models())
 
 
+def test_sweep_forwards_overlay_to_each_launch(monkeypatch):
+    calls = []
+    monkeypatch.setattr(
+        sweep.harness_launch, "launch", lambda *args, **kwargs: calls.append(kwargs)
+    )
+
+    sweep.sweep(
+        ["qwen3.5-2b"],
+        ["explicit"],
+        ["uniform"],
+        [32],
+        ["scene"],
+        overlay=True,
+        strip_schema_legend=True,
+    )
+
+    assert len(calls) == 1
+    assert calls[0]["overlay"] is True
+    assert calls[0]["results_dir"] is None
+
+
 def test_sweep_parser_rejects_unknown_spatial_code_format():
     with pytest.raises(ValueError):
-        sweep._parse_csv_choice("bogus", ("explicit", "compact"), "--spatial-code-formats")
+        sweep._parse_csv_choice(
+            "bogus", ("explicit", "compact"), "--spatial-code-formats"
+        )
 
 
 def test_sweep_parser_rejects_unknown_depth():

tests/test_D/test_launch.py

@@ -1,6 +1,5 @@
 """Tests for harness/D/launch.py -- multi-GPU scene sharding across workers."""
 
-from harness.A.run import load_questions as harness_a_load_questions
 from harness.D import launch
 
 
@@ -8,14 +7,25 @@ def test_launcher_imports():
     assert callable(launch.main)
 
 
-def test_launch_skips_scene_already_fully_answered(tmp_path, capsys):
-    scene = "13c3e046d7"
-    rows = harness_a_load_questions(scene=scene)
-    assert rows, "fixture scene must have real questions in the VSI-Bench manifest"
+class _FakeRun:
+    rows = [{"id": 2}, {"id": 5}]
+
+    @staticmethod
+    def results_dir_for(*args, **kwargs):
+        return args[3]
+
+    @classmethod
+    def load_questions(cls, scene=None):
+        return list(cls.rows)
+
+
+def test_launch_skips_scene_already_fully_answered(tmp_path, capsys, monkeypatch):
+    scene = "scene-d"
+    monkeypatch.setattr(launch, "_load_run_module", lambda: _FakeRun)
 
     scene_dir = tmp_path / scene
     scene_dir.mkdir()
-    for row in rows:
+    for row in _FakeRun.rows:
         (scene_dir / f"{row['id']}.json").write_text("{}")
 
     launch.launch("qwen3.5-2b", "explicit", [scene], results_dir=tmp_path)
@@ -26,20 +36,25 @@ def test_launch_skips_scene_already_fully_answered(tmp_path, capsys):
 
 
 def test_launch_rebuild_forces_pending_even_when_answered(tmp_path, monkeypatch):
-    scene = "13c3e046d7"
-    rows = harness_a_load_questions(scene=scene)
+    scene = "scene-d"
+    monkeypatch.setattr(launch, "_load_run_module", lambda: _FakeRun)
     scene_dir = tmp_path / scene
     scene_dir.mkdir()
-    for row in rows:
+    for row in _FakeRun.rows:
         (scene_dir / f"{row['id']}.json").write_text("{}")
 
     monkeypatch.setattr(launch, "visible_gpus", lambda: [])
     monkeypatch.setattr(
-        launch.mp, "get_context",
-        lambda *_: (_ for _ in ()).throw(RuntimeError("rebuild correctly reached worker dispatch")),
+        launch.mp,
+        "get_context",
+        lambda *_: (_ for _ in ()).throw(
+            RuntimeError("rebuild correctly reached worker dispatch")
+        ),
     )
     try:
-        launch.launch("qwen3.5-2b", "explicit", [scene], results_dir=tmp_path, rebuild=True)
+        launch.launch(
+            "qwen3.5-2b", "explicit", [scene], results_dir=tmp_path, rebuild=True
+        )
     except RuntimeError as exc:
         assert "rebuild correctly reached worker dispatch" in str(exc)
     else:
@@ -47,9 +62,6 @@ def test_launch_rebuild_forces_pending_even_when_answered(tmp_path, monkeypatch)
 
 
 def test_scenes_is_subset_of_vsi_bench_scenes_with_ground_truth_coverage(monkeypatch):
-    from harness.A.launch import scenes as vsi_scenes
-
-    all_scenes = set(vsi_scenes())
-    monkeypatch.setattr(launch, "ground_truth_scenes", lambda: sorted(all_scenes))
-    d_scenes = launch.scenes()
-    assert set(d_scenes) <= all_scenes
+    monkeypatch.setattr("harness.A.launch.scenes", lambda: ["a", "b", "c"])
+    monkeypatch.setattr(launch, "ground_truth_scenes", lambda: ["b", "c", "z"])
+    assert launch.scenes() == ["b", "c"]

tests/test_D/test_spatial_codes.py

@@ -14,7 +14,9 @@ def test_load_spatial_code_rejects_unknown_format():
 
 def test_load_spatial_code_raises_clearly_when_missing(tmp_path, monkeypatch):
     monkeypatch.setattr(
-        spatial_codes, "ground_truth_spatial_code_path", lambda *a, **k: str(tmp_path / "missing.json")
+        spatial_codes,
+        "ground_truth_spatial_code_path",
+        lambda *a, **k: str(tmp_path / "missing.json"),
     )
     with pytest.raises(FileNotFoundError):
         spatial_codes.load_spatial_code("scene", "explicit")

tests/test_calibration/conftest.py

@@ -0,0 +1,12 @@
+"""Shared import setup for this test package."""
+
+from pathlib import Path
+import sys
+
+ROOT = Path(__file__).resolve().parents[2]
+if str(ROOT) not in sys.path:
+    sys.path.insert(0, str(ROOT))
+
+
+def pytest_configure(config):
+    config.option.importmode = "importlib"

tests/test_calibration/test_calibration.py

@@ -0,0 +1,18 @@
+"""Tests for calibration package configuration."""
+
+import importlib
+from pathlib import Path
+
+import calibration
+
+
+def test_results_dir_defaults_to_root_results():
+    assert calibration.RESULTS_DIR == Path("/root/results/calibration")
+
+
+def test_results_dir_can_be_overridden_by_environment(monkeypatch, tmp_path):
+    monkeypatch.setenv("VSI_CALIBRATION_RESULTS_DIR", str(tmp_path / "calibration"))
+    reloaded = importlib.reload(calibration)
+    assert reloaded.RESULTS_DIR == tmp_path / "calibration"
+    monkeypatch.delenv("VSI_CALIBRATION_RESULTS_DIR")
+    importlib.reload(calibration)

tests/test_calibration/test_run.py

@@ -9,8 +9,13 @@ def test_results_dir_isolates_every_pilot_axis():
     base = ("qwen3.5-4b", "explicit", "metric", "tracking", "selective", 32, 512)
     variants = {calibration_run.results_dir_for(*base)}
     for index, value in [
-        (0, "qwen3.5-2b"), (1, "compact"), (2, "relative"), (3, "no tracking"),
-        (4, "uniform"), (5, 64), (6, 1024),
+        (0, "qwen3.5-2b"),
+        (1, "compact"),
+        (2, "relative"),
+        (3, "no tracking"),
+        (4, "uniform"),
+        (5, 64),
+        (6, 1024),
     ]:
         changed = list(base)
         changed[index] = value
@@ -39,18 +44,32 @@ def test_run_grid_passes_budget_questions_and_isolated_dir(monkeypatch):
     launched = []
     monkeypatch.setattr(calibration_run, "scenes_for", lambda ids: ["scene_a"])
     monkeypatch.setattr(
-        calibration_run.harness_b_launch, "launch",
+        calibration_run.harness_b_launch,
+        "launch",
         lambda model, fmt, sel, frames, scenes, **kwargs: launched.append(
-            (model, fmt, kwargs["reasoning_budget"], str(kwargs["results_dir"]),
-             kwargs["question_ids"], scenes)
+            (
+                model,
+                fmt,
+                kwargs["reasoning_budget"],
+                str(kwargs["results_dir"]),
+                kwargs["question_ids"],
+                scenes,
+            )
         ),
     )
     calibration_run.run_grid(
-        ["qwen3.5-2b"], [256, 512], [1, 2], "compact",
-        "metric", "tracking", "selective", 64,
+        ["qwen3.5-2b"],
+        [256, 512],
+        [1, 2],
+        "compact",
+        "metric",
+        "tracking",
+        "selective",
+        64,
     )
     assert [(m, f, b) for m, f, b, _, _, _ in launched] == [
-        ("qwen3.5-2b", "compact", 256), ("qwen3.5-2b", "compact", 512),
+        ("qwen3.5-2b", "compact", 256),
+        ("qwen3.5-2b", "compact", 512),
     ]
     assert launched[0][3] != launched[1][3]
     assert launched[0][4] == {1, 2}
@@ -60,9 +79,23 @@ def test_run_grid_passes_budget_questions_and_isolated_dir(monkeypatch):
 def test_cli_requires_exactly_one_question_source(monkeypatch, capsys):
     monkeypatch.setattr(
         "sys.argv",
-        ["run", "--models", "qwen3.5-2b", "--budgets", "256",
-         "--spatial-code-format", "explicit", "--depth", "metric",
-         "--tracking", "tracking", "--input-selection", "selective", "--frames", "32"],
+        [
+            "run",
+            "--models",
+            "qwen3.5-2b",
+            "--budgets",
+            "256",
+            "--spatial-code-format",
+            "explicit",
+            "--depth",
+            "metric",
+            "--tracking",
+            "tracking",
+            "--input-selection",
+            "selective",
+            "--frames",
+            "32",
+        ],
     )
     with pytest.raises(SystemExit):
         calibration_run.main()
@@ -72,9 +105,25 @@ def test_cli_requires_exactly_one_question_source(monkeypatch, capsys):
 def test_cli_rejects_nonpositive_budget(monkeypatch, capsys):
     monkeypatch.setattr(
         "sys.argv",
-        ["run", "--models", "qwen3.5-2b", "--budgets", "0", "--questions", "1",
-         "--spatial-code-format", "explicit", "--depth", "metric",
-         "--tracking", "tracking", "--input-selection", "selective", "--frames", "32"],
+        [
+            "run",
+            "--models",
+            "qwen3.5-2b",
+            "--budgets",
+            "0",
+            "--questions",
+            "1",
+            "--spatial-code-format",
+            "explicit",
+            "--depth",
+            "metric",
+            "--tracking",
+            "tracking",
+            "--input-selection",
+            "selective",
+            "--frames",
+            "32",
+        ],
     )
     with pytest.raises(SystemExit):
         calibration_run.main()

tests/test_corruption/conftest.py

@@ -0,0 +1,12 @@
+"""Shared import setup for this test package."""
+
+from pathlib import Path
+import sys
+
+ROOT = Path(__file__).resolve().parents[2]
+if str(ROOT) not in sys.path:
+    sys.path.insert(0, str(ROOT))
+
+
+def pytest_configure(config):
+    config.option.importmode = "importlib"

tests/test_corruption/test_chimera.py

@@ -11,7 +11,9 @@ def _instance(x, y, dims=(1.0, 1.0, 1.0), time=0.0):
             "3D oriented bounding box center coordinates": [x, y, 0.5],
             "3D oriented bounding box dimensions": list(dims),
             "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],
+                [1.0, 0.0, 0.0],
+                [0.0, 0.0, 1.0],
+                [0.0, -1.0, 0.0],
             ],
         },
         "first visible time": time,
@@ -19,7 +21,11 @@ def _instance(x, y, dims=(1.0, 1.0, 1.0), time=0.0):
 
 
 def _code(objects):
-    return {"spatial code schema": {}, "objects": objects, "room": {"floor boundary polygons": []}}
+    return {
+        "spatial code schema": {},
+        "objects": objects,
+        "room": {"floor boundary polygons": []},
+    }
 
 
 def test_gt_inventory_keeps_gt_counts_but_takes_perceived_boxes():
@@ -39,7 +45,10 @@ def test_gt_inventory_keeps_gt_counts_but_takes_perceived_boxes():
 def test_perceived_inventory_keeps_perceived_counts_but_takes_gt_boxes():
     gt = _code({"chair": [_instance(0.0, 0.0, dims=(2.0, 2.0, 2.0))]})
     perceived = _code(
-        {"chair": [_instance(0.4, 0.0), _instance(8.0, 8.0)], "ghost": [_instance(1.0, 1.0)]}
+        {
+            "chair": [_instance(0.4, 0.0), _instance(8.0, 8.0)],
+            "ghost": [_instance(1.0, 1.0)],
+        }
     )
     hybrid, coverage = chimera.perceived_inventory_gt_geometry(gt, perceived)
     # Perceived inventory preserved: 2 chairs + the hallucinated "ghost" class.
@@ -65,7 +74,10 @@ def test_chimeras_do_not_mutate_inputs():
 
 def test_perturb_single_object_changes_exactly_one_instance():
     code = _code(
-        {"chair": [_instance(0.0, 0.0), _instance(5.0, 5.0)], "table": [_instance(2.0, 2.0)]}
+        {
+            "chair": [_instance(0.0, 0.0), _instance(5.0, 5.0)],
+            "table": [_instance(2.0, 2.0)],
+        }
     )
     out, info = chimera.perturb_single_object(code, random.Random(0))
     changed = 0

tests/test_corruption/test_corruption.py

@@ -0,0 +1,19 @@
+"""Tests for corruption package configuration."""
+
+import importlib
+from pathlib import Path
+
+import corruption
+
+
+def test_corruption_defaults_are_explicit():
+    assert corruption.RESULTS_DIR == Path("/root/results/corruption")
+    assert corruption.SAMPLE_SEED == 20260725
+
+
+def test_results_dir_can_be_overridden_by_environment(monkeypatch, tmp_path):
+    monkeypatch.setenv("VSI_CORRUPTION_RESULTS_DIR", str(tmp_path / "corruption"))
+    reloaded = importlib.reload(corruption)
+    assert reloaded.RESULTS_DIR == tmp_path / "corruption"
+    monkeypatch.delenv("VSI_CORRUPTION_RESULTS_DIR")
+    importlib.reload(corruption)

tests/test_corruption/test_empirical.py

@@ -11,7 +11,9 @@ def _instance(x, y, dims=(1.0, 1.0, 1.0)):
             "3D oriented bounding box center coordinates": [x, y, 0.5],
             "3D oriented bounding box dimensions": list(dims),
             "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],
+                [1.0, 0.0, 0.0],
+                [0.0, 0.0, 1.0],
+                [0.0, -1.0, 0.0],
             ],
         },
         "first visible time": 0.0,
@@ -19,15 +21,21 @@ def _instance(x, y, dims=(1.0, 1.0, 1.0)):
 
 
 def _code(objects):
-    return {"spatial code schema": {}, "objects": objects, "room": {"floor boundary polygons": []}}
+    return {
+        "spatial code schema": {},
+        "objects": objects,
+        "room": {"floor boundary polygons": []},
+    }
 
 
 def test_measure_residuals_matches_missed_and_hallucinated():
     gt = _code({"chair": [_instance(0.0, 0.0), _instance(5.0, 5.0)]})
-    perceived = _code({"chair": [_instance(0.5, 0.0)], "phantom": [_instance(9.0, 9.0)]})
+    perceived = _code(
+        {"chair": [_instance(0.5, 0.0)], "phantom": [_instance(9.0, 9.0)]}
+    )
     residuals = empirical.measure_residuals([(perceived, gt)])
     assert residuals["matched"] == 1
-    assert residuals["missed"] == 1       # second GT chair unmatched
+    assert residuals["missed"] == 1  # second GT chair unmatched
     assert residuals["hallucinated"] == 1  # the phantom class
     assert residuals["miss_rate"] == 0.5
     assert residuals["position_residuals"] == [[0.5, 0.0, 0.0]]
@@ -45,8 +53,11 @@ def test_empirical_noise_at_zero_scale_is_identity():
     residuals = {
         "position_residuals": [[0.5, 0.5, 0.0]],
         "dimension_ratios": [[2.0, 2.0, 2.0]],
-        "matched": 1, "missed": 1, "hallucinated": 1,
-        "miss_rate": 0.5, "hallucination_rate": 0.5,
+        "matched": 1,
+        "missed": 1,
+        "hallucinated": 1,
+        "miss_rate": 0.5,
+        "hallucination_rate": 0.5,
     }
     out = empirical.empirical_noise(code, residuals, random.Random(0), scale=0.0)
     assert out == code
@@ -57,8 +68,11 @@ def test_empirical_noise_applies_sampled_residuals():
     residuals = {
         "position_residuals": [[0.5, -0.5, 0.0]],
         "dimension_ratios": [[2.0, 1.0, 1.0]],
-        "matched": 1, "missed": 0, "hallucinated": 0,
-        "miss_rate": 0.0, "hallucination_rate": 0.0,
+        "matched": 1,
+        "missed": 0,
+        "hallucinated": 0,
+        "miss_rate": 0.0,
+        "hallucination_rate": 0.0,
     }
     out = empirical.empirical_noise(code, residuals, random.Random(0), scale=1.0)
     box = out["objects"]["chair"][0]["3D oriented bounding box"]
@@ -71,8 +85,11 @@ def test_empirical_noise_is_reproducible():
     residuals = {
         "position_residuals": [[0.5, 0.0, 0.0], [-0.2, 0.1, 0.0]],
         "dimension_ratios": [[1.1, 0.9, 1.0]],
-        "matched": 2, "missed": 1, "hallucinated": 1,
-        "miss_rate": 0.3, "hallucination_rate": 0.3,
+        "matched": 2,
+        "missed": 1,
+        "hallucinated": 1,
+        "miss_rate": 0.3,
+        "hallucination_rate": 0.3,
     }
     first = empirical.empirical_noise(code, residuals, random.Random(7))
     second = empirical.empirical_noise(code, residuals, random.Random(7))

tests/test_corruption/test_launch.py

@@ -12,7 +12,15 @@ def test_launch_imports():
 def test_launch_rejects_unknown_transform(monkeypatch, capsys):
     monkeypatch.setattr(
         "sys.argv",
-        ["launch", "--transforms", "not-a-transform", "--magnitudes", "0.5", "--arm", "solver"],
+        [
+            "launch",
+            "--transforms",
+            "not-a-transform",
+            "--magnitudes",
+            "0.5",
+            "--arm",
+            "solver",
+        ],
     )
     with pytest.raises(SystemExit):
         launch.main()
@@ -32,17 +40,29 @@ def test_launch_vlm_arm_requires_models(monkeypatch, capsys):
 def test_launch_runs_the_full_grid_through_run_solver(monkeypatch):
     conditions = []
     monkeypatch.setattr(
-        launch, "run_solver",
-        lambda transform, magnitude, fmt, **kwargs: conditions.append((transform, magnitude)) or [],
+        launch,
+        "run_solver",
+        lambda transform, magnitude, fmt, **kwargs: conditions.append(
+            (transform, magnitude)
+        )
+        or [],
     )
     monkeypatch.setattr(
         "sys.argv",
         [
-            "launch", "--arm", "solver",
-            "--transforms", "translate,rotate-z", "--magnitudes", "10,90",
+            "launch",
+            "--arm",
+            "solver",
+            "--transforms",
+            "translate,rotate-z",
+            "--magnitudes",
+            "10,90",
         ],
     )
     launch.main()
     assert conditions == [
-        ("translate", 10.0), ("translate", 90.0), ("rotate-z", 10.0), ("rotate-z", 90.0),
+        ("translate", 10.0),
+        ("translate", 90.0),
+        ("rotate-z", 10.0),
+        ("rotate-z", 90.0),
     ]

tests/test_corruption/test_run.py

@@ -1,14 +1,83 @@
-"""Tests for corruption/run.py -- condition orchestration, determinism, and the
-certification gate, against real on-disk ground-truth codes."""
+"""Tests for corruption/run.py -- condition orchestration, determinism, and certification."""
+
+import copy
 
 import pytest
 
 from corruption import run as corruption_run
+from encoder.geometric import _explicit_from_compact
 
 _SCENE = "13c3e046d7"
 _OTHER_SCENE = "09c1414f1b"
 
 
+def _box(x, y, z=0.5, dims=(1.0, 1.0, 1.0)):
+    return {
+        "3D oriented bounding box center coordinates": [x, y, z],
+        "3D oriented bounding box dimensions": list(dims),
+        "3D oriented bounding box orientation unit vectors": [
+            [1.0, 0.0, 0.0],
+            [0.0, 1.0, 0.0],
+            [0.0, 0.0, 1.0],
+        ],
+    }
+
+
+def _compact(offset=0.0):
+    return {
+        "spatial code schema": {},
+        "objects": {
+            "chair": [
+                {
+                    "3D oriented bounding box": _box(offset, 0.0),
+                    "first visible time": 0.0,
+                }
+            ],
+            "table": [
+                {
+                    "3D oriented bounding box": _box(offset + 3.0, 0.0),
+                    "first visible time": 1.0,
+                }
+            ],
+        },
+        "room": {
+            "floor boundary polygons": [
+                {
+                    "outer boundary coordinates": [
+                        [-2.0, -2.0],
+                        [5.0, -2.0],
+                        [5.0, 2.0],
+                        [-2.0, 2.0],
+                    ],
+                    "interior hole boundary coordinates": [],
+                }
+            ]
+        },
+    }
+
+
+@pytest.fixture(autouse=True)
+def self_contained_ground_truth(monkeypatch):
+    codes = {_SCENE: _compact(), _OTHER_SCENE: _compact(offset=10.0)}
+
+    def load_compact(scene):
+        return copy.deepcopy(codes[scene])
+
+    def load_spatial_code(scene, spatial_code_format):
+        compact = load_compact(scene)
+        if spatial_code_format == "compact":
+            return compact, f"/fixture/{scene}.json"
+        if spatial_code_format == "explicit":
+            explicit, _floor_area = _explicit_from_compact(compact)
+            return explicit, f"/fixture/{scene}.json"
+        raise ValueError(spatial_code_format)
+
+    monkeypatch.setattr(corruption_run, "load_ground_truth_compact", load_compact)
+    monkeypatch.setattr(
+        corruption_run.gt_spatial_codes, "load_spatial_code", load_spatial_code
+    )
+
+
 def test_seed_is_deterministic_and_condition_specific():
     first = corruption_run._seed_for(_SCENE, "position-jitter", 0.25)
     second = corruption_run._seed_for(_SCENE, "position-jitter", 0.25)
@@ -25,7 +94,9 @@ def test_corrupted_code_is_reproducible():
 
 def test_corrupted_explicit_is_derived_from_the_corrupted_compact():
     compact = corruption_run.corrupted_code(_SCENE, "position-jitter", 0.25, "compact")
-    explicit = corruption_run.corrupted_code(_SCENE, "position-jitter", 0.25, "explicit")
+    explicit = corruption_run.corrupted_code(
+        _SCENE, "position-jitter", 0.25, "explicit"
+    )
     # Same corruption seed -> the explicit code's per-class counts must match the
     # corrupted compact's own instance counts (consistency-by-construction).
     for class_name, items in compact["objects"].items():
@@ -120,7 +191,9 @@ def test_run_solver_respects_the_question_sample(tmp_path):
 def test_make_code_transform_ignores_the_loaded_code():
     hook = corruption_run.make_code_transform("position-jitter", 0.25)
     out = hook({"not": "used"}, _SCENE, "compact")
-    assert out == corruption_run.corrupted_code(_SCENE, "position-jitter", 0.25, "compact")
+    assert out == corruption_run.corrupted_code(
+        _SCENE, "position-jitter", 0.25, "compact"
+    )
 
 
 def test_single_object_info_is_deterministic_and_recomputable():
@@ -141,5 +214,7 @@ def test_single_object_solver_run_writes_perturbation_sidecar(tmp_path):
 
 
 def test_non_probe_runs_write_no_sidecar(tmp_path):
-    corruption_run.run_solver("position-jitter", 0.0, scenes=[_SCENE], results_dir=tmp_path)
+    corruption_run.run_solver(
+        "position-jitter", 0.0, scenes=[_SCENE], results_dir=tmp_path
+    )
     assert not (tmp_path / _SCENE / "_perturbation.json").exists()

tests/test_corruption/test_sample.py

@@ -8,8 +8,14 @@ def _rows(monkeypatch, rows):
 
 
 def test_budget_key_pools_direction_subtypes():
-    assert corruption_sample._budget_key("object_rel_direction_easy") == "object_rel_direction"
-    assert corruption_sample._budget_key("object_rel_direction_hard") == "object_rel_direction"
+    assert (
+        corruption_sample._budget_key("object_rel_direction_easy")
+        == "object_rel_direction"
+    )
+    assert (
+        corruption_sample._budget_key("object_rel_direction_hard")
+        == "object_rel_direction"
+    )
     assert corruption_sample._budget_key("object_counting") == "object_counting"
 
 
@@ -29,7 +35,11 @@ def test_draw_sample_is_deterministic_for_the_frozen_seed(monkeypatch):
 def test_draw_sample_spreads_across_scenes_round_robin(monkeypatch):
     # 5 scenes x 10 questions each; a 5-question budget must touch 5 DISTINCT scenes.
     rows = [
-        {"id": scene * 100 + i, "scene_name": f"scene{scene}", "question_type": "object_counting"}
+        {
+            "id": scene * 100 + i,
+            "scene_name": f"scene{scene}",
+            "question_type": "object_counting",
+        }
         for scene in range(5)
         for i in range(10)
     ]
@@ -46,7 +56,9 @@ def test_draw_sample_excludes_unlisted_categories_and_scenes(monkeypatch):
         {"id": 3, "scene_name": "scene_out", "question_type": "object_counting"},
     ]
     _rows(monkeypatch, rows)
-    sampled = corruption_sample.draw_sample({"scene_in"}, budgets={"object_counting": 10})
+    sampled = corruption_sample.draw_sample(
+        {"scene_in"}, budgets={"object_counting": 10}
+    )
     assert sampled == [1]
 
 

tests/test_corruption/test_transforms.py

@@ -15,11 +15,15 @@ def _compact(classes=("chair", "table"), instances_per_class=2):
                 {
                     "3D oriented bounding box": {
                         "3D oriented bounding box center coordinates": [
-                            float(class_index), float(index), 0.5,
+                            float(class_index),
+                            float(index),
+                            0.5,
                         ],
                         "3D oriented bounding box dimensions": [1.0, 2.0, 0.5],
                         "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],
+                            [1.0, 0.0, 0.0],
+                            [0.0, 0.0, 1.0],
+                            [0.0, -1.0, 0.0],
                         ],
                     },
                     "first visible time": float(index),
@@ -31,7 +35,14 @@ def _compact(classes=("chair", "table"), instances_per_class=2):
         "objects": objects,
         "room": {
             "floor boundary polygons": [
-                {"outer boundary coordinates": [[0.0, 0.0], [4.0, 0.0], [4.0, 4.0], [0.0, 4.0]]}
+                {
+                    "outer boundary coordinates": [
+                        [0.0, 0.0],
+                        [4.0, 0.0],
+                        [4.0, 4.0],
+                        [0.0, 4.0],
+                    ]
+                }
             ]
         },
     }
@@ -68,7 +79,9 @@ def test_dimension_noise_never_collapses_a_dimension():
     code = _compact()
     out = transforms.dimension_noise(code, 5.0, random.Random(0))
     for _name, instance in transforms._instances(out):
-        for value in instance["3D oriented bounding box"]["3D oriented bounding box dimensions"]:
+        for value in instance["3D oriented bounding box"][
+            "3D oriented bounding box dimensions"
+        ]:
             assert value > 0.0
 
 
@@ -96,7 +109,9 @@ def test_class_swap_keeps_geometry_but_relabels():
     out = transforms.class_swap(code, 1.0, random.Random(0))
     # Same set of class names, same total geometry, but at least one class's items moved.
     assert sorted(out["objects"]) == sorted(code["objects"])
-    assert any(out["objects"][name] != code["objects"][name] for name in code["objects"])
+    assert any(
+        out["objects"][name] != code["objects"][name] for name in code["objects"]
+    )
 
 
 def test_translate_shifts_centers_and_polygons_together():
@@ -107,7 +122,9 @@ def test_translate_shifts_centers_and_polygons_together():
     ]
     assert center[:2] == [10.0, 10.0]
     assert center[2] == 0.5  # height untouched
-    assert out["room"]["floor boundary polygons"][0]["outer boundary coordinates"][0] == [10.0, 10.0]
+    assert out["room"]["floor boundary polygons"][0]["outer boundary coordinates"][
+        0
+    ] == [10.0, 10.0]
 
 
 def test_rotate_z_preserves_pairwise_distances():
@@ -116,16 +133,21 @@ def test_rotate_z_preserves_pairwise_distances():
 
     def centers(c):
         return [
-            instance["3D oriented bounding box"]["3D oriented bounding box center coordinates"]
+            instance["3D oriented bounding box"][
+                "3D oriented bounding box center coordinates"
+            ]
             for _name, instance in transforms._instances(c)
         ]
 
     before, after = centers(code), centers(out)
     for i in range(len(before)):
         for j in range(i + 1, len(before)):
-            assert math.dist(before[i], before[j]) == round(
-                math.dist(after[i], after[j]), 10
-            ) or abs(math.dist(before[i], before[j]) - math.dist(after[i], after[j])) < 0.05
+            assert (
+                math.dist(before[i], before[j])
+                == round(math.dist(after[i], after[j]), 10)
+                or abs(math.dist(before[i], before[j]) - math.dist(after[i], after[j]))
+                < 0.05
+            )
 
 
 def test_reorder_changes_only_order():
@@ -133,7 +155,9 @@ def test_reorder_changes_only_order():
     out = transforms.reorder(code, None, random.Random(3))
     assert sorted(out["objects"]) == sorted(code["objects"])
     for name in code["objects"]:
-        assert sorted(map(str, out["objects"][name])) == sorted(map(str, code["objects"][name]))
+        assert sorted(map(str, out["objects"][name])) == sorted(
+            map(str, code["objects"][name])
+        )
 
 
 def test_round_precision_rounds_every_geometry_value():