Replace tests with local workspace contents

tests/conftest.py

@@ -0,0 +1,48 @@
+"""Global test setup that keeps unit tests independent of optional native packages."""
+
+from __future__ import annotations
+
+import importlib.util
+import sys
+import types
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[1]
+if str(ROOT) not in sys.path:
+    sys.path.insert(0, str(ROOT))
+
+
+class _FakeCapture:
+    def __init__(self, path):
+        self.path = path
+
+    def get(self, prop):
+        return 0.0
+
+    def release(self):
+        pass
+
+
+if importlib.util.find_spec("cv2") is None and "cv2" not in sys.modules:
+    cv2 = types.ModuleType("cv2")
+    cv2.CAP_PROP_FPS = 5
+    cv2.INTER_NEAREST = 0
+    cv2.MORPH_CLOSE = 3
+    cv2.RETR_EXTERNAL = 0
+    cv2.RETR_CCOMP = 2
+    cv2.CHAIN_APPROX_SIMPLE = 0
+    cv2.GC_PR_BGD = 2
+    cv2.GC_PR_FGD = 3
+    cv2.GC_FGD = 1
+    cv2.GC_INIT_WITH_MASK = 1
+    cv2.VideoCapture = _FakeCapture
+    cv2.resize = lambda image, size, interpolation=None: image
+    cv2.erode = lambda image, kernel, iterations=1: image
+    cv2.dilate = lambda image, kernel, iterations=1: image
+    cv2.morphologyEx = lambda image, op, kernel: image
+    cv2.findContours = lambda image, mode, method: ([], None)
+    cv2.approxPolyDP = lambda contour, epsilon, closed: contour
+    cv2.contourArea = lambda contour: 0
+    cv2.imread = lambda path: None
+    cv2.grabCut = lambda *args, **kwargs: None
+    sys.modules["cv2"] = cv2

tests/test_A/conftest.py

@@ -0,0 +1,12 @@
+"""Shared import setup for harness.A tests."""
+
+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_A/test_A.py

@@ -0,0 +1,68 @@
+"""Tests for harness/A/__init__.py -- shared config constants."""
+
+from argparse import ArgumentParser, Namespace
+from pathlib import Path
+
+import pytest
+
+from harness import A
+
+
+def test_thinking_mode_resolves_default_budgets():
+    args = Namespace(reasoning_budget=None, force_budget=None)
+    A.resolve_protocol_budgets(ArgumentParser(), args)
+    assert args.reasoning_budget == A.EXTENDED_MAX_NEW_TOKENS
+    assert args.force_budget == A.MAX_NEW_TOKENS
+
+
+def test_explicit_budget_overrides_are_preserved():
+    args = Namespace(reasoning_budget=1024, force_budget=8)
+    A.resolve_protocol_budgets(ArgumentParser(), args)
+    assert args.reasoning_budget == 1024
+    assert args.force_budget == 8
+
+
+@pytest.mark.parametrize("flag", ["reasoning_budget", "force_budget"])
+def test_nonpositive_budget_overrides_are_rejected(flag):
+    args = Namespace(reasoning_budget=None, force_budget=None)
+    setattr(args, flag, 0)
+    with pytest.raises(SystemExit):
+        A.resolve_protocol_budgets(ArgumentParser(), args)
+
+
+def test_generation_protocol_matches_vsibench_yaml():
+    # thinking-in-space/lmms_eval/tasks/vsibench/vsibench.yaml generation_kwargs.
+    assert A.MAX_NEW_TOKENS == 16
+    assert A.TEMPERATURE == 0.0
+    assert A.DO_SAMPLE is False
+
+
+def test_thinking_generation_protocol():
+    assert A.EXTENDED_MAX_NEW_TOKENS == 2048
+    assert A.EXTENDED_MAX_NEW_TOKENS > A.MAX_NEW_TOKENS
+    assert isinstance(A.FORCE_ANSWER_PROMPT, str) and A.FORCE_ANSWER_PROMPT.strip()
+
+
+def test_frame_selections_match_inference_vocabulary():
+    from inference import SAM3_FRAME_SELECTIONS
+
+    assert A.FRAME_SELECTIONS == SAM3_FRAME_SELECTIONS
+
+
+def test_default_frame_selection_is_a_valid_selection():
+    assert A.DEFAULT_FRAME_SELECTION in A.FRAME_SELECTIONS
+
+
+def test_model_paths_cover_every_registered_model():
+    assert set(A.MODEL_PATHS) == {
+        "qwen3.5-4b",
+        "qwen3.5-2b",
+        "internvl3.5-4b",
+        "internvl3.5-2b",
+    }
+    for path in A.MODEL_PATHS.values():
+        assert path.parent == A.MODELS_ROOT
+
+
+def test_results_dir_defaults_under_root_results():
+    assert A.RESULTS_DIR == Path("/root/results/A")

tests/test_A/test_frames.py

@@ -0,0 +1,79 @@
+"""Tests for harness/A/frames.py -- uniform/selective frame sampling."""
+
+import numpy as np
+import pytest
+
+from harness.A import frames as frame_sampling
+
+
+def test_sample_frames_rejects_unknown_selection(tmp_path):
+    video = tmp_path / "scene.mp4"
+    video.write_bytes(b"not a real video")
+    with pytest.raises(ValueError):
+        frame_sampling.sample_frames(str(video), 8, "random")
+
+
+def test_sample_frames_rejects_nonpositive_frame_count(tmp_path):
+    video = tmp_path / "scene.mp4"
+    video.write_bytes(b"not a real video")
+    with pytest.raises(ValueError):
+        frame_sampling.sample_frames(str(video), 0, "uniform")
+
+
+def test_sample_frames_rejects_missing_video(tmp_path):
+    with pytest.raises(FileNotFoundError):
+        frame_sampling.sample_frames(str(tmp_path / "missing.mp4"), 8, "uniform")
+
+
+def test_sample_frames_returns_pil_images_in_order(tmp_path, monkeypatch):
+    video = tmp_path / "scene.mp4"
+    video.write_bytes(b"not a real video")
+    fake_frames = np.stack(
+        [np.full((4, 4, 3), value, dtype=np.uint8) for value in (10, 20, 30)]
+    )
+    monkeypatch.setattr(
+        frame_sampling,
+        "_sample_video_frames",
+        lambda path, count, selection: (fake_frames, np.array([0.0, 1.0, 2.0])),
+    )
+
+    class _UnreadableCapture:
+        def get(self, prop):
+            return 0.0
+
+        def release(self):
+            pass
+
+    monkeypatch.setattr(
+        frame_sampling.cv2, "VideoCapture", lambda path: _UnreadableCapture()
+    )
+    result, timestamps, indices = frame_sampling.sample_frames(str(video), 3, "uniform")
+    assert len(result) == 3
+    assert np.array(result[0])[0, 0, 0] == 10
+    assert np.array(result[2])[0, 0, 0] == 30
+    assert timestamps == [0.0, 1.0, 2.0]
+    # fps falls back to 1.0 for the fake (unreadable) video, so index == round(t * 1.0) == t.
+    assert indices == [0, 1, 2]
+
+
+def test_sample_frames_derives_indices_from_real_fps(tmp_path, monkeypatch):
+    video = tmp_path / "scene.mp4"
+    video.write_bytes(b"not a real video")
+    fake_frames = np.stack([np.full((2, 2, 3), 1, dtype=np.uint8)] * 3)
+    monkeypatch.setattr(
+        frame_sampling,
+        "_sample_video_frames",
+        lambda path, count, selection: (fake_frames, np.array([0.0, 0.5, 1.0])),
+    )
+
+    class _FakeCapture:
+        def get(self, prop):
+            return 30.0
+
+        def release(self):
+            pass
+
+    monkeypatch.setattr(frame_sampling.cv2, "VideoCapture", lambda path: _FakeCapture())
+    _, timestamps, indices = frame_sampling.sample_frames(str(video), 3, "uniform")
+    assert timestamps == [0.0, 0.5, 1.0]
+    assert indices == [0, 15, 30]

tests/test_A/test_init.py

@@ -0,0 +1,62 @@
+"""Tests for harness/A/__init__.py -- shared config constants."""
+
+from pathlib import Path
+
+from harness import A
+
+
+def test_generation_protocol_matches_vsibench_yaml():
+    # thinking-in-space/lmms_eval/tasks/vsibench/vsibench.yaml generation_kwargs.
+    assert A.MAX_NEW_TOKENS == 16
+    assert A.TEMPERATURE == 0.0
+    assert A.DO_SAMPLE is False
+
+
+def test_thinking_generation_protocol():
+    assert A.EXTENDED_MAX_NEW_TOKENS == 2048
+    assert A.EXTENDED_MAX_NEW_TOKENS > A.MAX_NEW_TOKENS
+    assert isinstance(A.FORCE_ANSWER_PROMPT, str) and A.FORCE_ANSWER_PROMPT.strip()
+
+
+def test_frame_selections_match_inference_vocabulary():
+    from inference import SAM3_FRAME_SELECTIONS
+
+    assert A.FRAME_SELECTIONS == SAM3_FRAME_SELECTIONS
+
+
+def test_default_frame_selection_is_a_valid_selection():
+    assert A.DEFAULT_FRAME_SELECTION in A.FRAME_SELECTIONS
+
+
+def test_model_paths_cover_every_registered_model():
+    assert set(A.MODEL_PATHS) == {
+        "qwen3.5-4b",
+        "qwen3.5-2b",
+        "internvl3.5-4b",
+        "internvl3.5-2b",
+    }
+    for path in A.MODEL_PATHS.values():
+        assert path.parent == A.MODELS_ROOT
+
+
+def test_results_dir_defaults_under_root_results():
+    assert A.RESULTS_DIR == Path("/root/results/A")
+
+
+def test_question_protocol_policy_is_hardcoded_by_group():
+    assert A.question_group("object_counting") == "numerical"
+    assert A.protocol_for_question("object_counting") == "base"
+    assert A.question_group("route_planning") == "multiple_choice"
+    assert A.protocol_for_question("route_planning") == "thinking"
+
+
+def test_every_known_question_type_has_one_policy_group():
+    for question_type in A.NUMERICAL_QUESTION_TYPES:
+        assert (
+            A.protocol_for_question(question_type) == A.QUESTION_PROTOCOLS["numerical"]
+        )
+    for question_type in A.MULTIPLE_CHOICE_QUESTION_TYPES:
+        assert (
+            A.protocol_for_question(question_type)
+            == A.QUESTION_PROTOCOLS["multiple_choice"]
+        )

tests/test_A/test_launch.py

@@ -0,0 +1,90 @@
+"""Tests for harness/A/launch.py -- multi-GPU scene sharding across workers."""
+
+import pytest
+
+from harness.A import launch
+
+
+def test_launcher_imports():
+    assert callable(launch.main)
+
+
+def test_scenes_dedups_and_preserves_order(tmp_path, monkeypatch):
+    manifest = tmp_path / "questions.jsonl"
+    rows = [
+        '{"scene_name": "scene-a"}',
+        '{"scene_name": "scene-b"}',
+        '{"scene_name": "scene-a"}',
+    ]
+    manifest.write_text("\n".join(rows) + "\n")
+    monkeypatch.setattr(launch, "JSONL", manifest)
+    assert launch.scenes() == ["scene-a", "scene-b"]
+
+
+class _FakeRun:
+    rows = [{"id": 1}, {"id": 2}]
+
+    @staticmethod
+    def results_dir_for(
+        model, protocol, frame_selection, frame_count, results_dir=None
+    ):
+        return results_dir
+
+    @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-a"
+    monkeypatch.setattr(launch, "_load_run_module", lambda: _FakeRun)
+
+    scene_dir = tmp_path / scene
+    scene_dir.mkdir()
+    for row in _FakeRun.rows:
+        (scene_dir / f"{row['id']}.json").write_text("{}")
+
+    launch.launch("qwen3.5-2b", "uniform", 16, [scene], results_dir=tmp_path)
+
+    output = capsys.readouterr().out
+    assert "skipped" in output
+    assert "DONE: 1 ok, 0 failed" in output
+
+
+def test_launch_rebuild_forces_pending_even_when_answered(tmp_path, monkeypatch):
+    scene = "scene-a"
+    monkeypatch.setattr(launch, "_load_run_module", lambda: _FakeRun)
+    scene_dir = tmp_path / scene
+    scene_dir.mkdir()
+    for row in _FakeRun.rows:
+        (scene_dir / f"{row['id']}.json").write_text("{}")
+
+    monkeypatch.setattr(launch, "visible_gpus", lambda: [])
+
+    # Only assert it treats the scene as pending (doesn't take the all-skipped early
+    # return); actually spawning workers needs a real model/GPU, exercised by the live
+    # harness.A.launch smoke run instead of the unit suite.
+    monkeypatch.setattr(
+        launch.mp,
+        "get_context",
+        lambda *_: (_ for _ in ()).throw(
+            RuntimeError("rebuild correctly reached worker dispatch")
+        ),
+    )
+    try:
+        launch.launch(
+            "qwen3.5-2b", "uniform", 16, [scene], results_dir=tmp_path, rebuild=True
+        )
+    except RuntimeError as exc:
+        assert "rebuild correctly reached worker dispatch" in str(exc)
+    else:
+        raise AssertionError("expected rebuild to force scene into the pending path")
+
+
+def test_launch_rejects_scene_with_no_questions(monkeypatch, tmp_path):
+    class EmptyRun(_FakeRun):
+        rows = []
+
+    monkeypatch.setattr(launch, "_load_run_module", lambda: EmptyRun)
+    with pytest.raises(ValueError, match="no questions found"):
+        launch.launch("qwen3.5-2b", "uniform", 16, ["missing"], results_dir=tmp_path)

tests/test_A/test_models.py

@@ -0,0 +1,114 @@
+"""Tests for harness/A/models.py -- VLM adapter registry and prompt assembly.
+
+Deliberately excludes any test that loads real model weights or calls .generate() --
+those require the GPU and downloaded checkpoints and are exercised via harness.A.run
+smoke runs instead, not the unit suite.
+"""
+
+import numpy as np
+import pytest
+
+from harness import A
+from harness.A import models as vlm_models
+
+
+def test_all_four_models_are_registered():
+    assert vlm_models.available_models() == (
+        "internvl3.5-2b",
+        "internvl3.5-4b",
+        "qwen3.5-2b",
+        "qwen3.5-4b",
+    )
+
+
+def test_get_adapter_binds_the_correct_checkpoint_path():
+    adapter = vlm_models.get_adapter("qwen3.5-4b")
+    assert adapter.model_path == A.MODEL_PATHS["qwen3.5-4b"]
+    assert isinstance(adapter, vlm_models.QwenVLAdapter)
+
+
+def test_get_adapter_returns_the_right_class_per_model():
+    assert isinstance(vlm_models.get_adapter("qwen3.5-2b"), vlm_models.QwenVLAdapter)
+    assert isinstance(
+        vlm_models.get_adapter("internvl3.5-4b"), vlm_models.InternVLAdapter
+    )
+
+
+def test_get_adapter_rejects_unknown_model():
+    with pytest.raises(KeyError):
+        vlm_models.get_adapter("not-a-real-model")
+
+
+def test_internvl_adapter_disables_per_frame_tiling():
+    # Otherwise InternVL's default per-image dynamic tiling (~3300 tokens/frame) blows
+    # past this checkpoint's 40960-token context window at just 16 frames.
+    assert vlm_models.InternVLAdapter.chat_template_kwargs == {"crop_to_patches": False}
+
+
+def test_numbered_content_labels_every_frame_in_order():
+    frames = ["frame0", "frame1", "frame2"]
+    content = vlm_models._numbered_content(frames, "What is in the room?")
+    assert content[0] == {"type": "text", "text": "Frame 1:"}
+    assert content[1] == {"type": "image", "image": "frame0"}
+    assert content[-1] == {"type": "text", "text": "What is in the room?"}
+    image_items = [item for item in content if item["type"] == "image"]
+    assert [item["image"] for item in image_items] == frames
+
+
+def test_numbered_content_handles_zero_frames():
+    content = vlm_models._numbered_content([], "question only")
+    assert content == [{"type": "text", "text": "question only"}]
+
+
+def test_adapter_answer_before_load_model_raises():
+    adapter = vlm_models.get_adapter("qwen3.5-2b")
+    with pytest.raises(RuntimeError):
+        adapter.answer(["frame"], "question")
+
+
+def test_adapter_answer_extended_before_load_model_raises():
+    adapter = vlm_models.get_adapter("qwen3.5-2b")
+    with pytest.raises(RuntimeError):
+        adapter.answer_extended(["frame"], "question")
+
+
+def test_every_adapter_implements_answer_extended():
+    for model in vlm_models.available_models():
+        adapter = vlm_models.get_adapter(model)
+        assert callable(adapter.answer_extended)
+
+
+def test_decode_new_tokens_preserves_clean_and_raw_text():
+    adapter = vlm_models.get_adapter("qwen3.5-2b")
+
+    class Processor:
+        def decode(self, token_ids, skip_special_tokens):
+            if skip_special_tokens:
+                return "step one, step two, answer B"
+            return "<think>step one, step two</think>B<eos>"
+
+    adapter.processor = Processor()
+    token_ids, hit_limit, text, raw = adapter._decode_new_tokens(
+        np.array([[10, 11, 21, 22, 2]]), 2, 2048, [2]
+    )
+    assert token_ids == [21, 22, 2]
+    assert hit_limit is False
+    assert text == "step one, step two, answer B"
+    assert raw == "<think>step one, step two</think>B<eos>"
+
+
+def test_unload_clears_model_and_processor():
+    adapter = vlm_models.get_adapter("qwen3.5-2b")
+    adapter.model = object()
+    adapter.processor = object()
+    adapter.unload()
+    assert adapter.model is None
+    assert adapter.processor is None
+
+
+def test_native_video_content_uses_one_video_item():
+    content = vlm_models._numbered_content("/data/scene.mp4", "What is in the room?")
+    assert content == [
+        {"type": "video", "video": "/data/scene.mp4"},
+        {"type": "text", "text": "What is in the room?"},
+    ]

tests/test_A/test_prompts.py

@@ -0,0 +1,57 @@
+"""Tests for harness/A/prompts.py -- VSI-Bench prompt construction."""
+
+import pytest
+
+from harness.A import prompts as vsi_prompts
+
+
+def test_na_question_prompt_matches_vsibench_protocol():
+    prompt = vsi_prompts.build_prompt("object_counting", "How many chairs?")
+    assert prompt == (
+        "These are frames of a video.\n"
+        "How many chairs?\n"
+        "Please answer the question using a single word or phrase."
+    )
+
+
+def test_mca_question_prompt_matches_vsibench_protocol():
+    prompt = vsi_prompts.build_prompt(
+        "object_rel_distance", "Which is closest?", ["A. sofa", "B. table"]
+    )
+    assert prompt == (
+        "These are frames of a video.\n"
+        "Which is closest?\n"
+        "Options:\nA. sofa\nB. table\n"
+        "Answer with the option's letter from the given choices directly."
+    )
+
+
+def test_mca_question_requires_options():
+    with pytest.raises(ValueError):
+        vsi_prompts.build_prompt("route_planning", "Which way?", None)
+
+
+def test_unknown_question_type_rejected():
+    with pytest.raises(ValueError):
+        vsi_prompts.build_prompt("not_a_real_type", "?", None)
+
+
+@pytest.mark.parametrize("question_type", vsi_prompts.NA_QUESTION_TYPES)
+def test_every_na_question_type_builds_without_options(question_type):
+    prompt = vsi_prompts.build_prompt(question_type, "q?")
+    assert prompt.startswith(vsi_prompts.PRE_PROMPT)
+    assert vsi_prompts.STEP_BY_STEP_REASONING_PROMPT in prompt
+    assert prompt.endswith(vsi_prompts.NA_POST_PROMPT)
+
+
+@pytest.mark.parametrize("question_type", vsi_prompts.MCA_QUESTION_TYPES)
+def test_every_mca_question_type_builds_with_options(question_type):
+    prompt = vsi_prompts.build_prompt(question_type, "q?", ["A. x", "B. y"])
+    assert prompt.startswith(vsi_prompts.PRE_PROMPT)
+    assert vsi_prompts.STEP_BY_STEP_REASONING_PROMPT in prompt
+    assert prompt.endswith(vsi_prompts.MCA_POST_PROMPT)
+
+
+def test_video_prompt_names_native_video():
+    prompt = vsi_prompts.build_prompt("object_counting", "How many chairs?", video=True)
+    assert prompt.startswith("This is a video.\n")

tests/test_A/test_run.py

@@ -0,0 +1,231 @@
+"""Tests for harness/A/run.py -- question loading, scoring, and result-file writing."""
+
+import json
+
+import pytest
+
+from harness import A
+from harness.A import run as harness_run
+
+_FAKE_ANSWER = {
+    "prompt_text": "<rendered chat template>",
+    "answer_text": "4",
+    "answer_raw": "<|im_start|>assistant\n4<|im_end|>",
+    "input_token_count": 123,
+    "vision_input_shapes": {"pixel_values": [512, 1536]},
+    "output_token_ids": [19, 151645],
+    "output_token_count": 2,
+    "hit_token_limit": False,
+    "eos_token_ids": [151645],
+    "generation_seconds": 1.234,
+    "device": "cuda",
+    "dtype": "bfloat16",
+    "library_versions": {"transformers": "5.14.1", "torch": "2.13.0+cu130"},
+    "generation_config": {
+        "max_new_tokens": 16,
+        "do_sample": False,
+        "temperature": 0.0,
+        "top_p": None,
+        "top_k": None,
+    },
+}
+
+_FAKE_ROW = {
+    "id": 7,
+    "scene_name": "scene0001_00",
+    "dataset": "scannet",
+    "question_type": "object_counting",
+    "question": "How many chairs?",
+    "options": None,
+    "ground_truth": "4",
+}
+
+_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],
+    "frame_selection": "uniform",
+    "frame_count": 16,
+}
+
+
+def test_load_questions_reads_every_row(tmp_path):
+    jsonl = tmp_path / "test.jsonl"
+    jsonl.write_text(
+        "\n".join(
+            json.dumps({"id": i, "scene_name": f"scene{i}", "question": "q"})
+            for i in range(3)
+        )
+    )
+    rows = harness_run.load_questions(jsonl)
+    assert [r["id"] for r in rows] == [0, 1, 2]
+
+
+def test_load_questions_filters_by_scene(tmp_path):
+    jsonl = tmp_path / "test.jsonl"
+    jsonl.write_text(
+        "\n".join(
+            json.dumps({"id": i, "scene_name": "a" if i < 2 else "b", "question": "q"})
+            for i in range(4)
+        )
+    )
+    rows = harness_run.load_questions(jsonl, scene="b")
+    assert [r["id"] for r in rows] == [2, 3]
+
+
+def test_load_questions_respects_limit(tmp_path):
+    jsonl = tmp_path / "test.jsonl"
+    jsonl.write_text(
+        "\n".join(
+            json.dumps({"id": i, "scene_name": "a", "question": "q"}) for i in range(5)
+        )
+    )
+    rows = harness_run.load_questions(jsonl, limit=2)
+    assert [r["id"] for r in rows] == [0, 1]
+
+
+def test_scalar_score_returns_metric_name_and_value():
+    doc = {"question_type": "object_counting", "ground_truth": "4"}
+    score_doc = harness_run.vsi_official_eval.vsibench_process_results(doc, ["4"])[
+        "vsibench_score"
+    ]
+    metric_name, value = harness_run._scalar_score("object_counting", score_doc)
+    assert metric_name == "MRA:.5:.95:.05"
+    assert value == 1.0
+
+
+def test_scalar_score_rejects_unknown_question_type():
+    with pytest.raises(ValueError):
+        harness_run._scalar_score("not_a_real_type", {})
+
+
+def test_results_dir_for_matches_established_dimension_nesting():
+    root = harness_run.results_dir_for("qwen3.5-4b", "base", "selective", 32)
+    assert root == A.RESULTS_DIR / "qwen3.5-4b" / "selective" / "32"
+
+
+def test_results_dir_for_keeps_protocols_together():
+    base = harness_run.results_dir_for("qwen3.5-4b", "base", "selective", 32)
+    extended = harness_run.results_dir_for("qwen3.5-4b", "thinking", "selective", 32)
+    assert base == extended
+
+
+def test_results_dir_for_honors_explicit_override(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():
+    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_FRAME_INFO,
+    )
+    assert record["question"] == "How many chairs?"
+    assert record["full_prompt"] == "full prompt text"
+    assert record["rendered_prompt"] == _FAKE_ANSWER["prompt_text"]
+    assert record["answer_given"] == "4"
+    assert record["answer_raw"] == _FAKE_ANSWER["answer_raw"]
+    assert record["output_token_ids"] == [19, 151645]
+    assert record["output_token_count"] == 2
+    assert record["hit_token_limit"] is False
+    assert record["generation_config"] == _FAKE_ANSWER["generation_config"]
+    assert record["frame_timestamps_seconds"] == [0.0, 1.0, 2.0]
+    assert record["frame_indices"] == [0, 30, 60]
+    assert record["video_path"] == _FAKE_FRAME_INFO["video_path"]
+    assert record["device"] == "cuda"
+    assert record["dtype"] == "bfloat16"
+    assert record["library_versions"] == _FAKE_ANSWER["library_versions"]
+    assert record["vision_input_shapes"] == {"pixel_values": [512, 1536]}
+    assert record["generation_seconds"] == 1.234
+    assert record["metric"] == "MRA:.5:.95:.05"
+    assert record["score"] == 1.0
+    assert record["scene"] == "scene0001_00"
+    assert record["question_id"] == 7
+
+
+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_FRAME_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_build_record_defaults_reasoning_fields_when_not_extended():
+    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_FRAME_INFO,
+    )
+    assert record["reasoning_text"] is None
+    assert record["forced"] is False
+    assert record["forced_input_token_count"] is None
+
+
+def test_build_record_carries_reasoning_fields_when_extended():
+    extended_answer = {
+        **_FAKE_ANSWER,
+        "reasoning_text": "long reasoning about the scene",
+        "reasoning_raw": "long reasoning about the scene<|im_end|>",
+        "reasoning_token_ids": list(range(50)),
+        "reasoning_token_count": 50,
+        "reasoning_hit_limit": True,
+        "forced": True,
+        "forced_input_token_count": 2510,
+    }
+    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_FRAME_INFO,
+    )
+    assert record["reasoning_text"] == "long reasoning about the scene"
+    assert record["reasoning_raw"] == "long reasoning about the scene<|im_end|>"
+    assert record["reasoning_token_ids"] == list(range(50))
+    assert record["reasoning_token_count"] == 50
+    assert record["reasoning_hit_limit"] is True
+    assert record["forced"] is True
+    assert record["forced_input_token_count"] == 2510
+
+
+def test_video_results_use_video_branch():
+    assert (
+        harness_run.results_dir_for("qwen3.5-4b", "thinking", "video", None)
+        == A.RESULTS_DIR / "qwen3.5-4b" / "video"
+    )
+
+
+def test_video_record_has_no_frame_count_in_condition():
+    info = dict(_FAKE_FRAME_INFO, frame_selection="video", frame_count=None)
+    record = harness_run._build_record(
+        _FAKE_ROW, "prompt", _FAKE_ANSWER, "metric", 1.0, "qwen3.5-4b", "/model", info
+    )
+    assert record["condition"] == "base:video"
+    assert record["frame_count"] is None

tests/test_A/test_sweep.py

@@ -0,0 +1,69 @@
+"""Tests for harness/A/sweep.py -- multi-config sweep planning."""
+
+import pytest
+
+from harness.A import models as vlm_models
+from harness.A import sweep
+
+
+def test_parse_csv_choice_splits_and_dedups():
+    result = sweep._parse_csv_choice(
+        "uniform,selective,uniform", ("uniform", "selective"), "--x"
+    )
+    assert result == ["uniform", "selective"]
+
+
+def test_parse_csv_choice_expands_all():
+    result = sweep._parse_csv_choice("all", ("uniform", "selective"), "--x")
+    assert result == ["uniform", "selective"]
+
+
+def test_parse_csv_choice_rejects_unknown_value():
+    with pytest.raises(ValueError):
+        sweep._parse_csv_choice("uniform,bogus", ("uniform", "selective"), "--x")
+
+
+def test_parse_csv_choice_rejects_empty():
+    with pytest.raises(ValueError):
+        sweep._parse_csv_choice("", ("uniform", "selective"), "--x")
+
+
+def test_parse_frame_counts_splits_and_dedups():
+    assert sweep._parse_frame_counts("16,32,64,32") == [16, 32, 64]
+
+
+def test_parse_frame_counts_rejects_nonpositive():
+    with pytest.raises(ValueError):
+        sweep._parse_frame_counts("16,0,64")
+
+
+def test_parse_frame_counts_rejects_non_integer():
+    with pytest.raises(ValueError):
+        sweep._parse_frame_counts("16,abc")
+
+
+def test_build_plan_covers_every_combination():
+    plan = sweep.build_plan(
+        ["qwen3.5-2b", "qwen3.5-4b"], ["uniform", "selective"], [16, 32]
+    )
+    assert len(plan) == 2 * 2 * 2
+    assert set(plan) == {
+        ("qwen3.5-2b", "uniform", 16),
+        ("qwen3.5-2b", "uniform", 32),
+        ("qwen3.5-2b", "selective", 16),
+        ("qwen3.5-2b", "selective", 32),
+        ("qwen3.5-4b", "uniform", 16),
+        ("qwen3.5-4b", "uniform", 32),
+        ("qwen3.5-4b", "selective", 16),
+        ("qwen3.5-4b", "selective", 32),
+    }
+
+
+def test_build_plan_orders_by_frame_count_first():
+    plan = sweep.build_plan(["qwen3.5-2b"], ["uniform"], [64, 16, 32])
+    assert [frame_count for _model, _selection, frame_count in plan] == [16, 32, 64]
+
+
+def test_build_plan_with_all_registered_models():
+    plan = sweep.build_plan(list(vlm_models.available_models()), ["uniform"], [16])
+    assert len(plan) == len(vlm_models.available_models())

tests/test_B/conftest.py

@@ -0,0 +1,12 @@
+"""Shared import setup for harness.B tests."""
+
+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_B/test_B.py

@@ -0,0 +1,35 @@
+"""Tests for harness/B/__init__.py -- shared config constants."""
+
+from pathlib import Path
+
+from harness import A, B
+
+
+def test_spatial_code_formats_is_explicit_only():
+    assert B.SPATIAL_CODE_FORMATS == ("explicit",)
+    assert B.DEFAULT_SPATIAL_CODE_FORMAT in B.SPATIAL_CODE_FORMATS
+
+
+def test_input_selections_match_harness_a_vocabulary():
+    assert B.INPUT_SELECTIONS == A.FRAME_SELECTIONS
+    assert B.DEFAULT_INPUT_SELECTION in B.INPUT_SELECTIONS
+
+
+def test_reuses_harness_a_model_paths_and_generation_protocol():
+    assert B.MODEL_PATHS is A.MODEL_PATHS
+    assert B.MAX_NEW_TOKENS == A.MAX_NEW_TOKENS
+    assert B.DO_SAMPLE == A.DO_SAMPLE
+    assert B.TEMPERATURE == A.TEMPERATURE
+
+
+def test_results_dir_defaults_under_root_results():
+    assert B.RESULTS_DIR == Path("/root/results/B")
+
+
+def test_depth_and_tracking_reuse_encoder_config_vocabulary():
+    from encoder.config import DEPTH_VARIANTS, TRACKING_MODES
+
+    assert B.DEPTH_VARIANTS == DEPTH_VARIANTS
+    assert B.TRACKING_MODES == TRACKING_MODES
+    assert B.DEFAULT_DEPTH in B.DEPTH_VARIANTS
+    assert B.DEFAULT_TRACKING in B.TRACKING_MODES

tests/test_B/test_init.py

@@ -0,0 +1,35 @@
+"""Tests for harness/B/__init__.py -- shared config constants."""
+
+from pathlib import Path
+
+from harness import A, B
+
+
+def test_spatial_code_formats_is_explicit_only():
+    assert B.SPATIAL_CODE_FORMATS == ("explicit",)
+    assert B.DEFAULT_SPATIAL_CODE_FORMAT in B.SPATIAL_CODE_FORMATS
+
+
+def test_input_selections_match_harness_a_vocabulary():
+    assert B.INPUT_SELECTIONS == A.FRAME_SELECTIONS
+    assert B.DEFAULT_INPUT_SELECTION in B.INPUT_SELECTIONS
+
+
+def test_reuses_harness_a_model_paths_and_generation_protocol():
+    assert B.MODEL_PATHS is A.MODEL_PATHS
+    assert B.MAX_NEW_TOKENS == A.MAX_NEW_TOKENS
+    assert B.DO_SAMPLE == A.DO_SAMPLE
+    assert B.TEMPERATURE == A.TEMPERATURE
+
+
+def test_results_dir_defaults_under_root_results():
+    assert B.RESULTS_DIR == Path("/root/results/B")
+
+
+def test_depth_and_tracking_reuse_encoder_config_vocabulary():
+    from encoder.config import DEPTH_VARIANTS, TRACKING_MODES
+
+    assert B.DEPTH_VARIANTS == DEPTH_VARIANTS
+    assert B.TRACKING_MODES == TRACKING_MODES
+    assert B.DEFAULT_DEPTH in B.DEPTH_VARIANTS
+    assert B.DEFAULT_TRACKING in B.TRACKING_MODES

tests/test_B/test_launch.py

@@ -0,0 +1,85 @@
+"""Tests for harness/B/launch.py -- multi-GPU scene sharding across workers."""
+
+import pytest
+
+from harness.B import launch
+
+
+def test_launcher_imports():
+    assert callable(launch.main)
+
+
+class _FakeRun:
+    rows = [{"id": 1}, {"id": 3}]
+
+    @staticmethod
+    def results_dir_for(*args, **kwargs):
+        return args[-1]
+
+    @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-b"
+    monkeypatch.setattr(launch, "_load_run_module", lambda: _FakeRun)
+
+    scene_dir = tmp_path / scene
+    scene_dir.mkdir()
+    for row in _FakeRun.rows:
+        (scene_dir / f"{row['id']}.json").write_text("{}")
+
+    launch.launch(
+        "qwen3.5-2b", "explicit", "selective", 64, [scene], results_dir=tmp_path
+    )
+
+    output = capsys.readouterr().out
+    assert "skipped" in output
+    assert "DONE: 1 ok, 0 failed" in output
+
+
+def test_launch_rebuild_forces_pending_even_when_answered(tmp_path, monkeypatch):
+    scene = "scene-b"
+    monkeypatch.setattr(launch, "_load_run_module", lambda: _FakeRun)
+    scene_dir = tmp_path / scene
+    scene_dir.mkdir()
+    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")
+        ),
+    )
+    try:
+        launch.launch(
+            "qwen3.5-2b",
+            "explicit",
+            "selective",
+            64,
+            [scene],
+            results_dir=tmp_path,
+            rebuild=True,
+        )
+    except RuntimeError as exc:
+        assert "rebuild correctly reached worker dispatch" in str(exc)
+    else:
+        raise AssertionError("expected rebuild to force scene into the pending path")
+
+
+def test_launch_rejects_question_id_filter_that_matches_nothing(monkeypatch, tmp_path):
+    monkeypatch.setattr(launch, "_load_run_module", lambda: _FakeRun)
+    with pytest.raises(ValueError, match="no questions found"):
+        launch.launch(
+            "qwen3.5-2b",
+            "explicit",
+            "selective",
+            64,
+            ["scene-b"],
+            results_dir=tmp_path,
+            question_ids={999},
+        )

tests/test_B/test_prompts.py

@@ -0,0 +1,146 @@
+"""Tests for harness/B/prompts.py -- spatial-code-as-text prompt construction."""
+
+import json
+
+import pytest
+
+from harness.A.prompts import MCA_QUESTION_TYPES, NA_QUESTION_TYPES
+from harness.B import prompts as code_prompts
+
+_CODE = {
+    "objects": {"chair": {"count": 1}},
+    "room": {"floor area": "10.0 square meters"},
+}
+
+
+def test_na_question_prompt_embeds_the_spatial_code_as_text_and_a_post_prompt():
+    prompt = code_prompts.build_prompt(_CODE, "object_counting", "How many chairs?")
+    assert prompt.startswith(code_prompts._question_legend("object_counting"))
+    projected = code_prompts._project_for_question(
+        _CODE, "object_counting", "How many chairs?"
+    )
+    assert json.dumps(projected, indent=1) in prompt
+    assert prompt.endswith(code_prompts.NA_POST_PROMPT)
+
+
+def test_mca_question_prompt_includes_options_and_matches_harness_a_post_prompt():
+    prompt = code_prompts.build_prompt(
+        _CODE, "object_rel_distance", "Which is closest?", ["A. sofa", "B. table"]
+    )
+    assert "Options:\nA. sofa\nB. table" in prompt
+    assert prompt.endswith(code_prompts.MCA_POST_PROMPT)
+
+
+def test_mca_question_requires_options():
+    with pytest.raises(ValueError):
+        code_prompts.build_prompt(_CODE, "route_planning", "Which way?", None)
+
+
+def test_unknown_question_type_rejected():
+    with pytest.raises(ValueError):
+        code_prompts.build_prompt(_CODE, "not_a_real_type", "?", None)
+
+
+def test_no_frames_language_in_pre_prompt():
+    # B has no video frames -- the context line must not claim otherwise.
+    assert "frame" not in code_prompts.PRE_PROMPT.lower()
+
+
+@pytest.mark.parametrize("question_type", NA_QUESTION_TYPES)
+def test_every_na_question_type_builds(question_type):
+    prompt = code_prompts.build_prompt(_CODE, question_type, "q?")
+    assert prompt.startswith(code_prompts._question_legend(question_type))
+
+
+@pytest.mark.parametrize("question_type", MCA_QUESTION_TYPES)
+def test_every_mca_question_type_builds(question_type):
+    prompt = code_prompts.build_prompt(_CODE, question_type, "q?", ["A. x", "B. y"])
+    assert prompt.startswith(code_prompts._question_legend(question_type))
+
+
+_RICH_CODE = {
+    "spatial code schema": {"version": 2},
+    "objects": {
+        "chair": {
+            "count": 2,
+            "instances": [{
+                "longest_dimension_meters": 0.8,
+                "position": {"floor_x_meters": 1.0},
+                "irrelevant": "drop me",
+            }],
+        },
+        "table": {"count": 1, "instances": []},
+    },
+    "room": {"floor_area_square_meters": 12.5, "outline": [1, 2]},
+    "closest_classes_from": {"chair": {"table": {"distance_meters": 1.2}}},
+    "appearance_order": ["chair", "table"],
+    "camera_trajectory": {"waypoints": [1]},
+}
+
+
+def test_counting_projection_keeps_only_counts_for_every_class():
+    projected = code_prompts._project_for_question(
+        _RICH_CODE, "object_counting", "How many chairs?"
+    )
+    assert projected == {
+        "objects": {"chair": {"count": 2}, "table": {"count": 1}}
+    }
+
+
+def test_size_projection_keeps_only_instance_dimensions():
+    projected = code_prompts._project_for_question(
+        _RICH_CODE, "object_size_estimation", "How large is the chair?"
+    )
+    assert projected == {
+        "objects": {
+            "chair": {"instances": [{"longest_dimension_meters": 0.8}]},
+            "table": {"instances": []},
+        }
+    }
+
+
+def test_room_projection_keeps_only_floor_area():
+    projected = code_prompts._project_for_question(
+        _RICH_CODE, "room_size_estimation", "How large is the room?"
+    )
+    assert projected == {"room": {"floor_area_square_meters": 12.5}}
+
+
+@pytest.mark.parametrize(
+    "question_type", ["object_abs_distance", "object_rel_distance"]
+)
+def test_distance_projections_keep_only_the_complete_distance_matrix(question_type):
+    projected = code_prompts._project_for_question(
+        _RICH_CODE, question_type, "distance?", ["A. x", "B. y"]
+    )
+    assert projected == {
+        "closest_classes_from": _RICH_CODE["closest_classes_from"]
+    }
+
+
+@pytest.mark.parametrize(
+    "question_type",
+    [
+        "object_rel_direction_easy",
+        "object_rel_direction_medium",
+        "object_rel_direction_hard",
+        "route_planning",
+    ],
+)
+def test_direction_and_route_projections_keep_only_positions(question_type):
+    projected = code_prompts._project_for_question(
+        _RICH_CODE, question_type, "direction?", ["A. x", "B. y"]
+    )
+    assert projected == {
+        "objects": {
+            "chair": {"instances": [{"position": {"floor_x_meters": 1.0}}]},
+            "table": {"instances": []},
+        }
+    }
+
+
+def test_appearance_projection_keeps_only_appearance_order():
+    projected = code_prompts._project_for_question(
+        _RICH_CODE, "obj_appearance_order", "which appeared first?", ["A. x"]
+    )
+    assert projected == {"appearance_order": ["chair", "table"]}

tests/test_B/test_run.py

@@ -0,0 +1,191 @@
+"""Tests for harness/B/run.py -- result-record shape and result-file writing."""
+
+import json
+
+from harness import B
+from harness.B import run as harness_run
+
+_FAKE_ANSWER = {
+    "prompt_text": "<rendered chat template>",
+    "answer_text": "4",
+    "answer_raw": "<|im_start|>assistant\n4<|im_end|>",
+    "input_token_count": 2558,
+    "vision_input_shapes": {"mm_token_type_ids": [1, 2558]},
+    "output_token_ids": [19, 151645],
+    "output_token_count": 2,
+    "hit_token_limit": False,
+    "eos_token_ids": [151645],
+    "generation_seconds": 0.65,
+    "device": "cuda",
+    "dtype": "bfloat16",
+    "library_versions": {"transformers": "5.14.1", "torch": "2.13.0+cu130"},
+    "generation_config": {
+        "max_new_tokens": 16,
+        "do_sample": False,
+        "temperature": 0.0,
+        "top_p": None,
+        "top_k": None,
+        "enable_thinking": False,
+    },
+}
+
+_FAKE_ROW = {
+    "id": 7,
+    "scene_name": "scene0001_00",
+    "dataset": "scannet",
+    "question_type": "object_counting",
+    "question": "How many chairs?",
+    "options": None,
+    "ground_truth": "4",
+}
+
+_FAKE_CODE_INFO = {
+    "protocol": "thinking",
+    "spatial_code_format": "explicit",
+    "input_selection": "selective",
+    "frame_count": 64,
+    "depth": "metric",
+    "tracking": "tracking",
+    "spatial_code_path": "/workspace/data/spatial codes/.../scene0001_00.json",
+}
+
+
+def test_results_dir_for_matches_established_dimension_nesting():
+    root = harness_run.results_dir_for(
+        "qwen3.5-4b", "thinking", "explicit", "metric", "tracking", "uniform", 32
+    )
+    assert root == (
+        B.RESULTS_DIR
+        / "qwen3.5-4b"
+        / "explicit"
+        / "metric"
+        / "tracking"
+        / "uniform"
+        / "32"
+    )
+
+
+def test_results_dir_for_keeps_protocols_together():
+    base = harness_run.results_dir_for(
+        "qwen3.5-4b", "base", "explicit", "metric", "tracking", "uniform", 32
+    )
+    extended = harness_run.results_dir_for(
+        "qwen3.5-4b", "thinking", "explicit", "metric", "tracking", "uniform", 32
+    )
+    assert base == extended
+
+
+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,
+    )
+    assert root == tmp_path
+
+
+def test_build_record_preserves_every_field_untruncated():
+    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_CODE_INFO,
+    )
+    assert record["question"] == "How many chairs?"
+    assert record["full_prompt"] == "full prompt text"
+    assert record["rendered_prompt"] == _FAKE_ANSWER["prompt_text"]
+    assert record["answer_given"] == "4"
+    assert record["answer_raw"] == _FAKE_ANSWER["answer_raw"]
+    assert record["spatial_code_format"] == "explicit"
+    assert record["input_selection"] == "selective"
+    assert record["frame_count"] == 64
+    assert record["depth"] == "metric"
+    assert record["tracking"] == "tracking"
+    assert record["spatial_code_path"] == _FAKE_CODE_INFO["spatial_code_path"]
+    assert record["condition"] == "thinking:explicit:metric:tracking:selective:64"
+    assert record["protocol"] == "thinking"
+    assert record["vision_input_shapes"] == {"mm_token_type_ids": [1, 2558]}
+    assert record["generation_config"] == _FAKE_ANSWER["generation_config"]
+    assert record["metric"] == "MRA:.5:.95:.05"
+    assert record["score"] == 1.0
+    assert record["scene"] == "scene0001_00"
+    assert record["question_id"] == 7
+    # No frame-provenance fields -- B has no video frames.
+    assert "frame_selection" not in record
+    assert "video_path" not in record
+    assert "frame_indices" not in record
+
+
+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_CODE_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_build_record_carries_reasoning_fields_when_forced():
+    extended_answer = {
+        **_FAKE_ANSWER,
+        "reasoning_text": "long reasoning about the spatial code",
+        "reasoning_raw": "long reasoning about the spatial code<|im_end|>",
+        "reasoning_token_ids": list(range(50)),
+        "reasoning_token_count": 50,
+        "reasoning_hit_limit": True,
+        "forced": True,
+        "forced_input_token_count": 2510,
+    }
+    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_CODE_INFO,
+    )
+    assert record["reasoning_text"] == "long reasoning about the spatial code"
+    assert record["reasoning_raw"] == "long reasoning about the spatial code<|im_end|>"
+    assert record["reasoning_token_ids"] == list(range(50))
+    assert record["reasoning_token_count"] == 50
+    assert record["reasoning_hit_limit"] is True
+    assert record["forced"] is True
+    assert record["forced_input_token_count"] == 2510
+
+
+
+def test_video_results_use_video_branch():
+    assert (
+        harness_run.results_dir_for(
+            "qwen3.5-4b", "thinking", "explicit", "metric", "tracking", "video", None
+        )
+        == B.RESULTS_DIR / "qwen3.5-4b" / "explicit" / "metric" / "tracking" / "video"
+    )
+
+
+def test_video_record_has_no_frame_count_in_condition():
+    info = dict(_FAKE_CODE_INFO, input_selection="video", frame_count=None)
+    record = harness_run._build_record(
+        _FAKE_ROW, "prompt", _FAKE_ANSWER, "metric", 1.0, "qwen3.5-4b", "/model", info
+    )
+    assert record["condition"] == "thinking:explicit:metric:tracking:video"
+    assert record["frame_count"] is None

tests/test_B/test_spatial_codes.py

@@ -0,0 +1,48 @@
+"""Tests for harness/B/spatial_codes.py -- loading on-disk spatial codes as plain JSON."""
+
+import json
+
+import pytest
+
+from harness.B import spatial_codes
+
+
+def test_load_spatial_code_rejects_unknown_format():
+    with pytest.raises(ValueError):
+        spatial_codes.load_spatial_code(
+            "scene", "metric", "selective", "tracking", 64, "bogus"
+        )
+
+
+def test_load_spatial_code_raises_clearly_when_missing(tmp_path, monkeypatch):
+    monkeypatch.setattr(
+        spatial_codes,
+        "spatial_code_path",
+        lambda *a, **k: str(tmp_path / "missing.json"),
+    )
+    with pytest.raises(FileNotFoundError):
+        spatial_codes.load_spatial_code(
+            "scene", "metric", "selective", "tracking", 64, "explicit"
+        )
+
+
+def test_load_spatial_code_returns_dict_and_path(tmp_path, monkeypatch):
+    fixture = tmp_path / "13c3e046d7.json"
+    fixture.write_text(json.dumps({"objects": {}, "room": {}}))
+    monkeypatch.setattr(
+        spatial_codes, "spatial_code_path", lambda *a, **k: str(fixture)
+    )
+    code, path = spatial_codes.load_spatial_code(
+        "13c3e046d7", "metric", "selective", "tracking", 64, "explicit"
+    )
+    assert code == {"objects": {}, "room": {}}
+    assert path == str(fixture)
+
+
+def test_spatial_code_path_uses_tracking_frames_hierarchy():
+    path = spatial_codes.spatial_code_path(
+        "scene-a", "metric", "selective", "tracking", 64, "explicit"
+    )
+    assert path.endswith(
+        "data/spatial codes/sam3+depth-anything-3/tracking/frames/selective/64/explicit/scene-a.json"
+    )

tests/test_B/test_sweep.py

@@ -0,0 +1,67 @@
+"""Tests for harness/B/sweep.py -- multi-config sweep planning."""
+
+import pytest
+
+from harness.A import models as vlm_models
+from harness.B import sweep
+
+
+def test_build_plan_covers_every_combination():
+    plan = sweep.build_plan(
+        ["qwen3.5-2b", "qwen3.5-4b"],
+        ["explicit"],
+        ["uniform", "selective"],
+        [16, 32],
+        ["metric"],
+        ["tracking"],
+    )
+    assert len(plan) == 2 * 1 * 2 * 2
+    assert ("qwen3.5-2b", "explicit", "metric", "tracking", "uniform", 16) in plan
+    assert ("qwen3.5-4b", "explicit", "metric", "tracking", "selective", 32) in plan
+
+
+def test_build_plan_sweeps_depth_and_tracking_too():
+    plan = sweep.build_plan(
+        ["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
+
+
+def test_build_plan_orders_by_frame_count_first():
+    plan = sweep.build_plan(
+        ["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"],
+    )
+    assert len(plan) == len(vlm_models.available_models())
+
+
+def test_sweep_parser_rejects_unknown_depth():
+    with pytest.raises(ValueError):
+        sweep._parse_csv_choice("bogus", sweep.DEPTH_VARIANTS, "--depths")
+
+
+def test_sweep_parser_rejects_unknown_tracking():
+    with pytest.raises(ValueError):
+        sweep._parse_csv_choice("bogus", sweep.TRACKING_MODES, "--trackings")

tests/test_C/conftest.py

@@ -0,0 +1,12 @@
+"""Shared import setup for harness.C tests."""
+
+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_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_init.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_launch.py

@@ -0,0 +1,69 @@
+"""Tests for harness/C/launch.py -- multi-GPU scene sharding across workers."""
+
+from harness.C import launch
+
+
+def test_launcher_imports():
+    assert callable(launch.main)
+
+
+class _FakeRun:
+    rows = [{"id": 1}, {"id": 2}]
+
+    @staticmethod
+    def results_dir_for(*args, **kwargs):
+        return args[-1]
+
+    @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-c"
+    monkeypatch.setattr(launch, "_load_run_module", lambda: _FakeRun)
+
+    scene_dir = tmp_path / scene
+    scene_dir.mkdir()
+    for row in _FakeRun.rows:
+        (scene_dir / f"{row['id']}.json").write_text("{}")
+
+    launch.launch(
+        "qwen3.5-2b", "explicit", "selective", 64, [scene], results_dir=tmp_path
+    )
+
+    output = capsys.readouterr().out
+    assert "skipped" in output
+    assert "DONE: 1 ok, 0 failed" in output
+
+
+def test_launch_rebuild_forces_pending_even_when_answered(tmp_path, monkeypatch):
+    scene = "scene-c"
+    monkeypatch.setattr(launch, "_load_run_module", lambda: _FakeRun)
+    scene_dir = tmp_path / scene
+    scene_dir.mkdir()
+    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")
+        ),
+    )
+    try:
+        launch.launch(
+            "qwen3.5-2b",
+            "explicit",
+            "selective",
+            64,
+            [scene],
+            results_dir=tmp_path,
+            rebuild=True,
+        )
+    except RuntimeError as exc:
+        assert "rebuild correctly reached worker dispatch" in str(exc)
+    else:
+        raise AssertionError("expected rebuild to force scene into the pending path")

tests/test_C/test_prompts.py

@@ -0,0 +1,70 @@
+"""Tests for harness/C/prompts.py -- combined frames+spatial-code prompt construction."""
+
+import json
+
+import pytest
+
+from harness.A.prompts import MCA_QUESTION_TYPES, NA_QUESTION_TYPES
+from harness.B import prompts as code_prompts
+from harness.C import prompts as combined_prompts
+
+_CODE = {
+    "objects": {"chair": {"count": 1}},
+    "room": {"floor area": "10.0 square meters"},
+}
+
+
+def test_pre_prompt_mentions_both_frames_and_spatial_code():
+    lowered = combined_prompts.FRAMES_NOTE.lower()
+    assert "frame" in lowered
+    assert "spatial code" in lowered
+
+
+def test_na_question_prompt_layout_is_context_then_code_then_question_then_post_prompt():
+    prompt = combined_prompts.build_prompt(_CODE, "object_counting", "How many chairs?")
+    context_pos = prompt.find(combined_prompts.FRAMES_NOTE)
+    projected = code_prompts._project_for_question(
+        _CODE, "object_counting", "How many chairs?"
+    )
+    code_pos = prompt.find(json.dumps(projected, indent=1))
+    question_pos = prompt.find("How many chairs?")
+    post_pos = prompt.find(code_prompts.NA_POST_PROMPT)
+    assert context_pos == 0
+    assert context_pos < code_pos < question_pos < post_pos
+
+
+def test_mca_question_prompt_includes_options_and_post_prompt():
+    prompt = combined_prompts.build_prompt(
+        _CODE, "object_rel_distance", "Which is closest?", ["A. sofa", "B. table"]
+    )
+    assert "Options:\nA. sofa\nB. table" in prompt
+    assert prompt.endswith(code_prompts.MCA_POST_PROMPT)
+
+
+def test_mca_question_requires_options():
+    with pytest.raises(ValueError):
+        combined_prompts.build_prompt(_CODE, "route_planning", "Which way?", None)
+
+
+def test_unknown_question_type_rejected():
+    with pytest.raises(ValueError):
+        combined_prompts.build_prompt(_CODE, "not_a_real_type", "?", None)
+
+
+@pytest.mark.parametrize("question_type", NA_QUESTION_TYPES)
+def test_every_na_question_type_builds(question_type):
+    prompt = combined_prompts.build_prompt(_CODE, question_type, "q?")
+    assert prompt.startswith(combined_prompts.FRAMES_NOTE)
+
+
+@pytest.mark.parametrize("question_type", MCA_QUESTION_TYPES)
+def test_every_mca_question_type_builds(question_type):
+    prompt = combined_prompts.build_prompt(_CODE, question_type, "q?", ["A. x", "B. y"])
+    assert prompt.startswith(combined_prompts.FRAMES_NOTE)
+
+
+def test_video_prompt_names_native_video():
+    prompt = combined_prompts.build_prompt(
+        _CODE, "object_counting", "How many chairs?", video=True
+    )
+    assert prompt.startswith("This is a video.\n")

tests/test_C/test_run.py

@@ -0,0 +1,180 @@
+"""Tests for harness/C/run.py -- result-record shape and result-file writing."""
+
+import json
+
+from harness import C
+from harness.C import run as harness_run
+
+_FAKE_ANSWER = {
+    "prompt_text": "<rendered chat template>",
+    "answer_text": "4",
+    "answer_raw": "<|im_start|>assistant\n4<|im_end|>",
+    "input_token_count": 22205,
+    "vision_input_shapes": {"pixel_values": [76800, 1536], "image_grid_thw": [64, 3]},
+    "output_token_ids": [19, 151645],
+    "output_token_count": 2,
+    "hit_token_limit": False,
+    "eos_token_ids": [151645],
+    "generation_seconds": 5.6,
+    "device": "cuda",
+    "dtype": "bfloat16",
+    "library_versions": {"transformers": "5.14.1", "torch": "2.13.0+cu130"},
+    "generation_config": {
+        "max_new_tokens": 16,
+        "do_sample": False,
+        "temperature": 0.0,
+        "top_p": None,
+        "top_k": None,
+        "enable_thinking": False,
+    },
+}
+
+_FAKE_ROW = {
+    "id": 7,
+    "scene_name": "scene0001_00",
+    "dataset": "scannet",
+    "question_type": "object_counting",
+    "question": "How many chairs?",
+    "options": None,
+    "ground_truth": "4",
+}
+
+_FAKE_SOURCE_INFO = {
+    "protocol": "thinking",
+    "spatial_code_format": "explicit",
+    "input_selection": "selective",
+    "frame_count": 64,
+    "depth": "metric",
+    "tracking": "tracking",
+    "spatial_code_path": "/workspace/data/spatial codes/.../scene0001_00.json",
+    "video_path": "/root/data/VSI-Bench/scannet/scene0001_00.mp4",
+    "frame_indices": [0, 30, 60],
+    "frame_timestamps": [0.0, 1.0, 2.0],
+}
+
+
+def test_results_dir_for_matches_established_dimension_nesting():
+    root = harness_run.results_dir_for(
+        "qwen3.5-4b", "thinking", "explicit", "metric", "tracking", "uniform", 32
+    )
+    assert root == (
+        C.RESULTS_DIR
+        / "qwen3.5-4b"
+        / "explicit"
+        / "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,
+    )
+    assert root == tmp_path
+
+
+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,
+    )
+    # Spatial-code provenance (shared with harness.B).
+    assert record["spatial_code_format"] == "explicit"
+    assert record["input_selection"] == "selective"
+    assert record["frame_count"] == 64
+    assert record["depth"] == "metric"
+    assert record["tracking"] == "tracking"
+    assert record["spatial_code_path"] == _FAKE_SOURCE_INFO["spatial_code_path"]
+    # Frame provenance (shared with harness.A).
+    assert record["video_path"] == _FAKE_SOURCE_INFO["video_path"]
+    assert record["frame_indices"] == [0, 30, 60]
+    assert record["frame_timestamps_seconds"] == [0.0, 1.0, 2.0]
+    # Question/answer fields, same shape as A and B.
+    assert record["question"] == "How many chairs?"
+    assert record["answer_given"] == "4"
+    assert record["vision_input_shapes"] == _FAKE_ANSWER["vision_input_shapes"]
+    assert record["condition"] == "extended:explicit:metric:tracking:selective:64"
+    assert record["protocol"] == "thinking"
+    assert record["score"] == 1.0
+
+
+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,
+    )
+    assert path == tmp_path / "scene0001_00" / "7.json"
+    on_disk = json.loads(path.read_text())
+    assert on_disk == record
+
+
+def test_build_record_carries_reasoning_fields_when_forced():
+    extended_answer = {
+        **_FAKE_ANSWER,
+        "reasoning_text": "long reasoning about the frames and spatial code",
+        "reasoning_raw": "long reasoning about the frames and spatial code<|im_end|>",
+        "reasoning_token_ids": list(range(50)),
+        "reasoning_token_count": 50,
+        "reasoning_hit_limit": True,
+        "forced": True,
+        "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,
+    )
+    assert (
+        record["reasoning_text"] == "long reasoning about the frames and spatial code"
+    )
+    assert record["reasoning_raw"] == "long reasoning about the frames and spatial code<|im_end|>"
+    assert record["reasoning_token_ids"] == list(range(50))
+    assert record["reasoning_token_count"] == 50
+    assert record["reasoning_hit_limit"] is True
+    assert record["forced"] is True
+    assert record["forced_input_token_count"] == 22300
+
+
+def test_video_results_use_video_branch():
+    assert (
+        harness_run.results_dir_for(
+            "qwen3.5-4b", "thinking", "explicit", "metric", "tracking", "video", None
+        )
+        == C.RESULTS_DIR / "qwen3.5-4b" / "explicit" / "metric" / "tracking" / "video"
+    )
+
+
+def test_video_record_has_no_frame_count_in_condition():
+    info = dict(_FAKE_SOURCE_INFO, input_selection="video", frame_count=None)
+    record = harness_run._build_record(
+        _FAKE_ROW, "prompt", _FAKE_ANSWER, "metric", 1.0, "qwen3.5-4b", "/model", info
+    )
+    assert record["condition"] == "thinking:explicit:metric:tracking:video"
+    assert record["frame_count"] is None

tests/test_C/test_sweep.py

@@ -0,0 +1,67 @@
+"""Tests for harness/C/sweep.py -- multi-config sweep planning."""
+
+import pytest
+
+from harness.A import models as vlm_models
+from harness.C import sweep
+
+
+def test_build_plan_covers_every_combination():
+    plan = sweep.build_plan(
+        ["qwen3.5-2b", "qwen3.5-4b"],
+        ["explicit"],
+        ["uniform", "selective"],
+        [16, 32],
+        ["metric"],
+        ["tracking"],
+    )
+    assert len(plan) == 2 * 1 * 2 * 2
+    assert ("qwen3.5-2b", "explicit", "metric", "tracking", "uniform", 16) in plan
+    assert ("qwen3.5-4b", "explicit", "metric", "tracking", "selective", 32) in plan
+
+
+def test_build_plan_sweeps_depth_and_tracking_too():
+    plan = sweep.build_plan(
+        ["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
+
+
+def test_build_plan_orders_by_frame_count_first():
+    plan = sweep.build_plan(
+        ["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"],
+    )
+    assert len(plan) == len(vlm_models.available_models())
+
+
+def test_sweep_parser_rejects_unknown_depth():
+    with pytest.raises(ValueError):
+        sweep._parse_csv_choice("bogus", sweep.DEPTH_VARIANTS, "--depths")
+
+
+def test_sweep_parser_rejects_unknown_tracking():
+    with pytest.raises(ValueError):
+        sweep._parse_csv_choice("bogus", sweep.TRACKING_MODES, "--trackings")

tests/test_F/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_F/test_F.py

@@ -0,0 +1,20 @@
+"""Tests for harness/F package configuration."""
+
+import importlib
+from pathlib import Path
+
+from harness import F
+
+
+def test_sources_and_default_are_declared():
+    assert F.SOURCES == ("perceived",)
+    assert F.DEFAULT_SOURCE == "perceived"
+    assert F.RESULTS_DIR == Path("/root/results/F")
+
+
+def test_results_dir_can_be_overridden_by_environment(monkeypatch, tmp_path):
+    monkeypatch.setenv("VSI_HARNESS_F_RESULTS_DIR", str(tmp_path / "F"))
+    reloaded = importlib.reload(F)
+    assert reloaded.RESULTS_DIR == tmp_path / "F"
+    monkeypatch.delenv("VSI_HARNESS_F_RESULTS_DIR")
+    importlib.reload(F)

tests/test_F/test_launch.py

@@ -0,0 +1,7 @@
+"""Tests for harness/F/launch.py."""
+
+from harness.F import launch
+
+
+def test_launch_entrypoint_exposes_run_main():
+    assert callable(launch.main)

tests/test_F/test_run.py

@@ -0,0 +1,19 @@
+from pathlib import Path
+from harness import F
+from harness.F import run
+
+
+def test_results_default_under_root():
+    assert F.RESULTS_DIR == Path("/root/results/F")
+
+
+def test_perceived_layout_contains_every_input_axis():
+    assert run.results_dir_for(
+        "perceived", "explicit", "metric", "tracking", "uniform", 32
+    ) == Path("/root/results/F/perceived/metric/tracking/uniform/32/explicit")
+
+
+def test_video_results_use_video_branch():
+    assert run.results_dir_for(
+        "perceived", "explicit", "metric", "tracking", "video", None
+    ) == Path("/root/results/F/perceived/metric/tracking/video/explicit")

tests/test_F/test_sweep.py

@@ -0,0 +1,14 @@
+"""Tests for harness/F/sweep.py -- CLI cartesian product wiring."""
+
+import pytest
+
+from harness.F import sweep
+
+
+def test_csv_expands_all_dedups_and_rejects_unknowns():
+    assert sweep._csv("all", ("a", "b")) == ["a", "b"]
+    assert sweep._csv("b,a,b", ("a", "b")) == ["b", "a"]
+    with pytest.raises(ValueError, match="unknown values"):
+        sweep._csv("c", ("a", "b"))
+
+

tests/test_analysis/conftest.py

@@ -0,0 +1,118 @@
+"""Shared fixtures and helpers for report-export tests."""
+
+import json
+import tempfile
+import unittest
+from pathlib import Path
+from analysis.letters_reports import (
+    analyze_modular,
+    export_reports,
+    load_profile as load,
+)
+
+
+def vlm(letter, qid=1, score=1.0, protocol="base", model="m", frames=32):
+    r = {
+        "model": model,
+        "protocol": protocol,
+        "condition": protocol,
+        "question_id": qid,
+        "scene": "s",
+        "dataset": "d",
+        "question_type": "count",
+        "score": score,
+        "frame_count": frames,
+        "input_token_count": 10,
+        "output_token_count": 2,
+        "generation_seconds": 1.0,
+        "answer_given": "x",
+        "full_prompt": "p",
+    }
+    if letter == "A":
+        r["frame_selection"] = "uniform"
+    elif letter in "BC":
+        r.update(
+            input_selection="uniform",
+            spatial_code_format="explicit",
+            depth="metric",
+            tracking="tracking",
+        )
+    return r
+
+
+def put(root, relative, record):
+    p = root / relative
+    p.parent.mkdir(parents=True, exist_ok=True)
+    p.write_text(json.dumps(record))
+    return p
+
+
+class ReportTestCase(unittest.TestCase):
+    def setUp(self):
+        self.temp = tempfile.TemporaryDirectory()
+        self.root = Path(self.temp.name)
+
+    def tearDown(self):
+        self.temp.cleanup()
+
+    def directory(self, letter, records):
+        d = self.root / letter
+        d.mkdir()
+        for i, r in enumerate(records):
+            put(d, f"{i}.json", r)
+        return d
+
+    def symbolic(self, future=False):
+        d = self.root / ("F_future" if future else "F")
+        d.mkdir(exist_ok=True)
+        prefix = (
+            "perceived/metric/tracking/uniform/32/explicit"
+            if future
+            else "metric/tracking/uniform/32/explicit"
+        )
+        put(
+            d,
+            f"{prefix}/s/1.json",
+            {
+                "model": "symbolic",
+                "condition": "metric:tracking:uniform:32:explicit",
+                "question_id": 1,
+                "scene": "s",
+                "dataset": "d",
+                "question_type": "count",
+                "score": 1.0,
+                "spatial_code_format": "explicit",
+                "depth": "metric",
+                "tracking": "tracking",
+                "input": "uniform",
+                "number_of_frames": 32,
+            },
+        )
+        return d
+
+    def ground_truth_symbolic(self):
+        d = self.root / "F"
+        d.mkdir()
+        put(
+            d,
+            "ground truth/explicit/s/1.json",
+            {
+                "model": "symbolic",
+                "condition": "ground truth:explicit",
+                "question_id": 1,
+                "scene": "s",
+                "dataset": "d",
+                "question_type": "count",
+                "score": 1.0,
+                "spatial_code_format": "explicit",
+            },
+        )
+        return d
+
+    def analyze(self, letters, dirs, pairs=(), protocols=("base",)):
+        profiles = {l: load(l) for l in letters}
+        per, combined = analyze_modular(
+            {l: dirs[l] for l in letters}, profiles, protocols, pairs
+        )
+        paths = export_reports(per, combined, self.root / "reports")
+        return per, combined, {p.name for p in paths}

tests/test_analysis/test_A_reports.py

@@ -0,0 +1,11 @@
+from tests.test_analysis.conftest import ReportTestCase, vlm
+from analysis import A_reports
+
+
+class TestAReports(ReportTestCase):
+    def test_A_report_and_controlled_frame_comparison(self):
+        d = self.directory("A", [vlm("A", frames=32), vlm("A", frames=64)])
+        result = A_reports.generate(d, ["base"], self.root / "reports")
+        self.assertEqual(result["path"].name, "A_report.json")
+        self.assertEqual(len(result["report"]["cells"]), 2)
+        self.assertEqual(len(result["report"]["within_harness_comparisons"]), 1)

tests/test_analysis/test_B_reports.py

@@ -0,0 +1,11 @@
+from tests.test_analysis.conftest import ReportTestCase, vlm
+from analysis import B_reports
+
+
+class TestBReports(ReportTestCase):
+    def test_B_report_contains_spatial_cell(self):
+        result = B_reports.generate(
+            self.directory("B", [vlm("B")]), ["base"], self.root / "reports"
+        )
+        self.assertEqual(result["path"].name, "B_report.json")
+        self.assertEqual(len(result["report"]["cells"]), 1)

tests/test_analysis/test_C_reports.py

@@ -0,0 +1,11 @@
+from tests.test_analysis.conftest import ReportTestCase, vlm
+from analysis import C_reports
+
+
+class TestCReports(ReportTestCase):
+    def test_C_report_is_exported(self):
+        result = C_reports.generate(
+            self.directory("C", [vlm("C")]), ["base"], self.root / "reports"
+        )
+        self.assertEqual(result["path"].name, "C_report.json")
+        self.assertEqual(len(result["report"]["cells"]), 1)

tests/test_analysis/test_F_reports.py

@@ -0,0 +1,15 @@
+from tests.test_analysis.conftest import ReportTestCase
+from analysis import F_reports
+
+
+class TestFReports(ReportTestCase):
+    def test_F_legacy_and_future_perceived_layouts(self):
+        for future in (False, True):
+            result = F_reports.generate(
+                self.symbolic(future),
+                (),
+                self.root / ("future" if future else "legacy"),
+            )
+            self.assertEqual(result["path"].name, "F_report.json")
+            cell = next(iter(result["report"]["cells"].values()))
+            self.assertEqual(cell["identity"]["source"], "perceived")

tests/test_analysis/test_analysis.py

@@ -0,0 +1,12 @@
+import json
+from tests.test_analysis.conftest import ReportTestCase, vlm
+from analysis.letters_reports import load_profile as load
+
+
+class TestAnalysisDirectory(ReportTestCase):
+    def test_arbitrary_subset_exports_letter_and_combined_files(self):
+        dirs = {l: self.directory(l, [vlm(l)]) for l in "AC"}
+        _, _, names = self.analyze("AC", dirs)
+        self.assertEqual(names, {"A_report.json", "C_report.json", "AC_report.json"})
+        for name in names:
+            json.loads((self.root / "reports" / name).read_text())

tests/test_analysis/test_letters_reports.py

@@ -0,0 +1,55 @@
+from tests.test_analysis.conftest import ReportTestCase, vlm
+from analysis import letters_reports
+
+
+class TestLettersReports(ReportTestCase):
+    def test_arbitrary_subset_and_combined_name(self):
+        cells = {l: self.directory(l, [vlm(l)]) for l in "AC"}
+        result = letters_reports.generate(
+            cells, ["base"], output_dir=self.root / "reports"
+        )
+        self.assertEqual(
+            {p.name for p in result["paths"]},
+            {"A_report.json", "C_report.json", "AC_report.json"},
+        )
+
+    def test_folded_statistical_and_solver_helpers(self):
+        self.assertEqual(
+            letters_reports.holm_bonferroni({"a": 0.01, "b": 0.04, "c": 0.03}),
+            {"a": 0.03, "c": 0.06, "b": 0.06},
+        )
+        a = [{"question_id": 1, "score": 1.0}, {"question_id": 2, "score": 0.0}]
+        b = [{"question_id": 1, "score": 1.0}, {"question_id": 2, "score": 1.0}]
+        overlap = letters_reports.solved_set_overlap({"A": a, "B": b})
+        self.assertEqual(overlap["pairs"]["A|B"]["only_B"], 1)
+        vlm = [
+            {"question_id": 1, "question_type": "count", "score": 0.0},
+            {"question_id": 2, "question_type": "count", "score": 1.0},
+        ]
+        solver = [{"question_id": 1, "score": 1.0}, {"question_id": 2, "score": 0.0}]
+        split = letters_reports.sufficiency_decomposition(vlm, solver)
+        self.assertEqual(split["certified"]["vlm_wrong"], 1)
+
+    def test_pair_restriction(self):
+        cells = {l: self.directory(l, [vlm(l)]) for l in "ABC"}
+        result = letters_reports.generate(
+            cells, ["base"], ["A:B"], self.root / "reports"
+        )
+        self.assertTrue(
+            all(
+                v["letters"] == ("A", "B")
+                for v in result["combined_report"]["cross_harness_comparisons"].values()
+            )
+        )
+
+    def test_manifest_generated_at_is_deterministic_by_default(self):
+        cells = {"A": self.directory("A", [vlm("A")])}
+        first = letters_reports.generate(cells, ["base"], output_dir=self.root / "r1")
+        second = letters_reports.generate(cells, ["base"], output_dir=self.root / "r2")
+        self.assertEqual(
+            first["letter_reports"]["A"]["manifest"]["generated_at"], "reproducible"
+        )
+        self.assertEqual(
+            first["letter_reports"]["A"]["manifest"],
+            second["letter_reports"]["A"]["manifest"],
+        )

tests/test_backup.py

@@ -0,0 +1,47 @@
+"""Tests for backup.py -- target resolution and dry-run behavior without network."""
+
+import pytest
+
+import backup
+
+
+def test_resolve_targets_expands_all_without_uploading_unknowns():
+    assert backup._resolve_targets("A") == ["A"]
+    assert backup._resolve_targets("all") == list(backup.TARGETS)
+    with pytest.raises(ValueError, match="unknown target"):
+        backup._resolve_targets("missing")
+
+
+def test_local_paths_keep_results_under_results_host(monkeypatch, tmp_path):
+    workspace = tmp_path / "workspace"
+    host = tmp_path / "host"
+    monkeypatch.setattr(backup, "WORKSPACE_ROOT", workspace)
+    monkeypatch.setattr(backup, "RESULTS_HOST_ROOT", host)
+
+    assert backup._local_path("results/A") == host / "results/A"
+    assert backup._local_path("harness") == workspace / "harness"
+
+
+def test_backup_dry_run_skips_empty_targets_and_never_imports_hub(
+    monkeypatch, tmp_path, capsys
+):
+    workspace = tmp_path / "workspace"
+    host = tmp_path / "host"
+    (workspace / "harness").mkdir(parents=True)
+    (workspace / "harness" / "run.py").write_text("# source\n")
+    monkeypatch.setattr(backup, "WORKSPACE_ROOT", workspace)
+    monkeypatch.setattr(backup, "RESULTS_HOST_ROOT", host)
+    monkeypatch.setattr(backup, "TARGETS", {"code": ["harness"], "A": ["results/A"]})
+
+    uploaded = backup.backup("owner/dataset", "all", dry_run=True)
+
+    assert uploaded == ["code"]
+    output = capsys.readouterr().out
+    assert "[A] skipped" in output
+    assert "would upload" in output
+    assert str(workspace / "harness") in output
+
+
+def test_target_root_rejects_mixed_workspace_and_results_roots():
+    with pytest.raises(ValueError, match="mixes incompatible"):
+        backup._target_root(["results/A", "tests"])

tests/test_encoder/conftest.py

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

tests/test_encoder/test_adapters.py

@@ -0,0 +1,311 @@
+"""Tests for encoder/adapters.py -- model-output adapters and canonical geometry validation."""
+
+import gzip
+import pickle
+import sys
+import types
+
+import numpy as np
+import pytest
+
+from encoder import adapters
+
+
+def test_registry_decodes_native_segvggt_dictionary(tmp_path, monkeypatch):
+    torch = pytest.importorskip("torch")
+    evaluation = types.ModuleType("eval.instance_eval_common")
+    evaluation.predict_by_feat_instance = lambda *args, **kwargs: (
+        torch.tensor([[1, 0, 0, 0], [0, 1, 0, 0]], dtype=torch.bool),
+        torch.tensor([0, 2]),
+        torch.ones(2),
+    )
+    pose = types.ModuleType("segvggt.utils.pose_enc")
+    pose.pose_encoding_to_extri_intri = lambda value, size: (
+        torch.cat(
+            [
+                torch.eye(3).reshape(1, 1, 3, 3),
+                torch.zeros(1, 1, 3, 1),
+            ],
+            dim=-1,
+        ),
+        torch.eye(3).reshape(1, 1, 3, 3),
+    )
+    monkeypatch.setitem(sys.modules, "eval.instance_eval_common", evaluation)
+    monkeypatch.setitem(sys.modules, "segvggt.utils.pose_enc", pose)
+
+    path = tmp_path / "scene.pt"
+    torch.save(
+        {
+            "world_points": torch.zeros(1, 1, 2, 2, 3),
+            "instance_maps": torch.zeros(1, 2, 1, 2, 2),
+            "instance_labels": torch.zeros(1, 2, 4),
+            "pose_enc": torch.zeros(1, 1, 9),
+        },
+        path,
+    )
+    result = adapters.adapt("segvggt", path=path)
+    assert list(result["instances"]) == ["chair"]
+    assert result["instances"]["chair"][0]["n"] == 1
+
+
+def _scene():
+    return {
+        "instances": {"chair": [{"pts": [[0, 0, 0]], "best_pts": [[0, 0, 0]]}]},
+        "stats": {"chair": {"raw": 1, "merged": 1, "peak": 1}},
+        "scene_pts": [[0, 0, 0]],
+        "cameras": None,
+    }
+
+
+def test_validate_normalizes_canonical_geometry():
+    result = adapters.validate(_scene())
+    instance = result["instances"]["chair"][0]
+    assert instance["pts"].shape == (1, 3)
+    assert instance["frames"] == set()
+    assert instance["n"] == 1
+
+
+@pytest.mark.parametrize(
+    ("scene", "error"),
+    [
+        ([], TypeError),
+        ({"instances": {}}, ValueError),
+        (
+            {"instances": {"chair": [{"pts": [1, 2, 3]}]}, "scene_pts": [[0, 0, 0]]},
+            ValueError,
+        ),
+    ],
+)
+def test_validate_rejects_invalid_geometry(scene, error):
+    with pytest.raises(error):
+        adapters.validate(scene)
+
+
+def test_validate_identifies_empty_scene():
+    with pytest.raises(adapters.EmptySceneError, match="no instances"):
+        adapters.validate({"instances": {}})
+
+
+def test_adapt_segvggt_reads_flat_npz(tmp_path):
+    path = tmp_path / "scene.npz"
+    world = np.array([[[[0, 0, 1], [1, 0, 1]]]], np.float32)
+    masks = np.array([[[[True, False]]]])
+    np.savez(
+        path,
+        world_points=world,
+        instance_masks=masks,
+        labels=np.array(["chair"], dtype=object),
+        frame_times=np.array([0], np.float32),
+    )
+
+    result = adapters.adapt_segvggt(path=str(path))
+
+    instance = result["instances"]["chair"][0]
+    assert list(result["instances"]) == ["chair"]
+    assert instance["frames"] == {0}
+    assert result["stats"]["chair"] == {"raw": 1, "merged": 1, "peak": 1}
+
+
+def test_adapt_segvggt_requires_existing_cache(tmp_path):
+    with pytest.raises(FileNotFoundError, match="raw cache does not exist"):
+        adapters.adapt_segvggt(path=str(tmp_path / "missing.npz"))
+
+
+def test_adapter_owned_raw_cache_locations(tmp_path, monkeypatch):
+    seen = {}
+    raw_path = tmp_path / "segvggt" / "scene1.pt"
+    raw_path.parent.mkdir()
+    raw_path.touch()
+
+    def fake_segvggt(path):
+        seen["segvggt"] = str(path)
+        return {
+            "world_points": np.zeros((1, 1, 1, 3), np.float32),
+            "instance_masks": np.ones((1, 1, 1, 1), bool),
+            "labels": np.array(["chair"], dtype=object),
+            "camera_positions": np.zeros((1, 3), np.float32),
+        }
+
+    monkeypatch.setattr(adapters, "_decode_segvggt_raw", fake_segvggt)
+    adapters.adapt_segvggt(root=str(tmp_path), scene="scene1")
+    assert seen["segvggt"] == str(raw_path)
+
+
+def test_fusion_adapter_resolves_two_native_model_directories(tmp_path, monkeypatch):
+    seen = {}
+    depth = np.ones((1, 1, 1), np.float32)
+    intr = np.eye(3, dtype=np.float32)[None]
+    c2w = np.eye(4, dtype=np.float32)[None]
+
+    def fake_da3(path):
+        seen["da3"] = str(path)
+        return depth, intr, c2w, None
+
+    def fake_sam3(path):
+        seen["sam3"] = str(path)
+        return {"object": {0: {0: np.ones((1, 1), bool)}}}
+
+    monkeypatch.setattr(adapters, "_load_native_da3", fake_da3)
+    monkeypatch.setattr(adapters, "_load_native_sam3", fake_sam3)
+    adapters.adapt_sam3_depth_anything_3(root=str(tmp_path), scene="scene1")
+    assert seen == {
+        "da3": str(tmp_path / "depth-anything-3" / "scene1.pkl"),
+        "sam3": str(tmp_path / "sam3" / "scene1.pt"),
+    }
+
+
+def test_adapters_default_to_root_data_caches(monkeypatch, tmp_path):
+    monkeypatch.delenv("VSI_CACHE_ROOT", raising=False)
+    seen = {}
+
+    def fake_da3(path):
+        seen["da3"] = str(path)
+        return (
+            np.ones((1, 1, 1), np.float32),
+            np.eye(3, dtype=np.float32)[None],
+            np.eye(4, dtype=np.float32)[None],
+            None,
+        )
+
+    def fake_sam3(path):
+        seen["sam3"] = str(path)
+        return {"object": {0: {0: np.ones((1, 1), bool)}}}
+
+    monkeypatch.setattr(adapters, "_load_native_da3", fake_da3)
+    monkeypatch.setattr(adapters, "_load_native_sam3", fake_sam3)
+    adapters.adapt_sam3_depth_anything_3(scene="scene1")
+    assert seen == {
+        "da3": "/root/data/caches/depth-anything-3/scene1.pkl",
+        "sam3": "/root/data/caches/sam3/scene1.pt",
+    }
+
+
+def test_adapt_segvggt_rejects_missing_npz_fields(tmp_path):
+    path = tmp_path / "broken.npz"
+    np.savez(path, labels=np.array(["chair"], dtype=object))
+    with pytest.raises(KeyError):
+        adapters.adapt_segvggt(path=str(path))
+
+
+def test_adapt_sam3_depth_anything_3_decodes_masks_and_backprojects(tmp_path):
+    da3_path = tmp_path / "scene.da3.npz"
+    depth = np.full((1, 2, 2), 2.0, np.float32)
+    intrinsics = np.eye(3, dtype=np.float32)[None]
+    poses = np.eye(4, dtype=np.float32)[None]
+    np.savez(
+        da3_path,
+        depth=depth,
+        intr=intrinsics,
+        c2w=poses,
+        frame_times=np.array([1.5], np.float32),
+    )
+    mask = np.array([[True, False], [False, True]])
+    packed = {"chair": {0: {7: (np.packbits(mask), mask.shape)}}}
+    mask_path = tmp_path / "scene.sam3.pkl.gz"
+    with gzip.open(mask_path, "wb") as cache:
+        pickle.dump(packed, cache)
+
+    result = adapters.adapt_sam3_depth_anything_3(
+        da3_path=str(da3_path), sam3_path=str(mask_path)
+    )
+
+    instance = result["instances"]["chair"][0]
+    assert instance["frames"] == {0}
+    assert instance["first_time"] == pytest.approx(1.5)
+    np.testing.assert_allclose(instance["pts"], [[0, 0, 2], [2, 2, 2]])
+    assert result["stats"]["chair"] == {"raw": 1, "merged": 1, "peak": 1}
+    assert result["raw_inputs"]["per"]["chair"][0][7].dtype == bool
+
+
+def test_backproject_resizes_sam3_mask_to_da3_depth_shape():
+    depth = np.full((2, 2), 2.0, np.float32)
+    mask = np.zeros((4, 4), bool)
+    mask[0, 0] = True
+    mask[2, 2] = True
+
+    points, confidence = adapters._backproject(
+        depth,
+        np.eye(3, dtype=np.float32),
+        np.eye(4, dtype=np.float32),
+        mask,
+    )
+
+    assert confidence is None
+    np.testing.assert_allclose(points, [[0, 0, 2], [2, 2, 2]])
+
+
+def test_native_sam3_decodes_prompt_keyed_independent_frames(monkeypatch):
+    responses = {"chair": [{"masks": np.array([[[1, 0], [0, 0]]], dtype=np.uint8)}, {}]}
+    monkeypatch.setitem(
+        sys.modules,
+        "torch",
+        types.SimpleNamespace(load=lambda *args, **kwargs: responses),
+    )
+    result = adapters._load_native_sam3("scene.pt")
+    assert result["chair"][0][0].dtype == bool
+    assert result["chair"][1] == {}
+
+
+def test_native_sam3_preserves_tracked_object_ids(monkeypatch):
+    responses = [{"out_obj_ids": np.array([7]), "out_binary_masks": np.ones((1, 2, 2))}]
+    monkeypatch.setitem(
+        sys.modules,
+        "torch",
+        types.SimpleNamespace(load=lambda *args, **kwargs: responses),
+    )
+    monkeypatch.setenv("VSI_SAM3_PROMPT", "chair")
+    result = adapters._load_native_sam3("scene.pt")
+    assert list(result["chair"][0]) == [7]
+
+
+def test_native_sam3_decodes_lossless_tracking_cache(monkeypatch):
+    responses = {
+        "chair": {
+            "start_session": {"session_id": "session"},
+            "add_prompt": {"is_success": True},
+            "stream": [
+                {
+                    "frame_index": 3,
+                    "stream_metadata": "preserved",
+                    "outputs": {
+                        "out_obj_ids": np.array([7]),
+                        "out_binary_masks": np.ones((1, 2, 2), bool),
+                    },
+                }
+            ],
+            "close_session": {"is_success": True},
+        }
+    }
+    monkeypatch.setitem(
+        sys.modules,
+        "torch",
+        types.SimpleNamespace(load=lambda *args, **kwargs: responses),
+    )
+
+    result = adapters._load_native_sam3("scene.pt")
+
+    assert list(result["chair"][3]) == [7]
+
+
+def test_spatial_code_format_validation():
+    assert adapters.validate_spatial_code_format("compact") == "compact"
+    assert adapters.validate_spatial_code_format("explicit") == "explicit"
+    with pytest.raises(ValueError, match="unknown spatial-code format"):
+        adapters.validate_spatial_code_format("unknown")
+
+
+def test_native_fusion_times_are_measured_in_seconds(monkeypatch):
+    monkeypatch.setattr(adapters, "FPS", 4.0)
+    monkeypatch.setattr(
+        adapters,
+        "_load_native_da3",
+        lambda path: (
+            np.ones((3, 1, 1), np.float32),
+            np.repeat(np.eye(3, dtype=np.float32)[None], 3, axis=0),
+            np.repeat(np.eye(4, dtype=np.float32)[None], 3, axis=0),
+            None,
+        ),
+    )
+    monkeypatch.setattr(adapters, "_load_native_sam3", lambda path: {})
+    *_, frame_times, _ = adapters._load_fusion_inputs("scene.pkl", "scene.pt")
+    np.testing.assert_allclose(frame_times, [0.0, 0.25, 0.5])

tests/test_encoder/test_config.py

@@ -0,0 +1,44 @@
+"""Tests for encoder/config.py -- cache and spatial-code path helpers."""
+
+import pytest
+
+from encoder import config
+
+
+def test_encoder_paths_mirror_all_dimensions(tmp_path, monkeypatch):
+    monkeypatch.setattr(config, "CACHE_ROOT", tmp_path / "caches")
+    monkeypatch.setattr(config, "CODES_ROOT", tmp_path / "codes")
+    assert config.cache_file("scene", "metric", "uniform", "no tracking", 64).endswith(
+        "no tracking/frames/uniform/64/scene.pkl.gz"
+    )
+    assert config.da3_cache_file("scene", "relative", "uniform", 32).endswith(
+        "depth-anything-3/relative/frames/uniform/32/scene.pkl"
+    )
+    assert config.video_da3_cache_file("scene").endswith(
+        "depth-anything-3/metric/video/scene.npz"
+    )
+    assert config.video_da3_cache_file("scene", "relative").endswith(
+        "depth-anything-3/relative/video/scene.npz"
+    )
+    assert config.video_sam3_cache_file("scene").endswith(
+        "sam3/no tracking/video/scene.pkl.gz"
+    )
+    assert config.video_sam3_cache_file("scene", "tracking").endswith(
+        "sam3/tracking/video/scene.pkl.gz"
+    )
+    assert config.spatial_code_path(
+        "scene", "metric", "selective", "tracking", 64
+    ).endswith("tracking/frames/selective/64/explicit/scene.json")
+    assert config.spatial_code_path(
+        "scene", "relative", "uniform", "no tracking", 96, "compact"
+    ).endswith("no tracking/frames/uniform/96/compact/scene.json")
+    assert config.spatial_code_path(
+        "scene", "metric", config.VIDEO_INPUT_SELECTION, "no tracking", None, "explicit"
+    ).endswith("no tracking/video/explicit/scene.json")
+
+
+def test_encoder_paths_reject_unknown_spatial_code_format():
+    with pytest.raises(ValueError, match="unknown spatial-code format"):
+        config.spatial_code_path(
+            "scene", "metric", "uniform", "tracking", 32, "unknown"
+        )

tests/test_encoder/test_encoder.py

@@ -0,0 +1,73 @@
+"""Tests for encoder/geometric.py's low-level geometry primitives (backprojection,
+direction/turn classification, distance, centroid/extent math)."""
+
+import numpy as np
+import pytest
+
+import geometric
+
+
+def test_backproject_frame_applies_intrinsics_pose_and_confidence():
+    depth = np.array([[2.0, 2.0], [2.0, np.nan]], np.float32)
+    mask = np.ones((2, 2), bool)
+    intrinsics = np.eye(3, dtype=np.float32)
+    pose = np.eye(4, dtype=np.float32)
+    pose[0, 3] = 1.0
+    confidence = np.array([[0.9, 0.8], [0.1, 1.0]], np.float32)
+
+    points, kept_confidence = geometric.backproject_frame(
+        depth, intrinsics, pose, mask, confidence, conf_thr=0.5, return_conf=True
+    )
+
+    np.testing.assert_allclose(points, [[1.0, 0.0, 2.0], [3.0, 0.0, 2.0]])
+    np.testing.assert_allclose(kept_confidence, [0.9, 0.8])
+
+
+def test_backproject_frame_returns_typed_empty_array():
+    points = geometric.backproject_frame(
+        np.zeros((2, 2), np.float32), np.eye(3), np.eye(4), np.ones((2, 2), bool)
+    )
+    assert points.shape == (0, 3)
+    assert points.dtype == np.float32
+
+
+def test_relative_direction_modes():
+    origin = np.array([0.0, 0.0, 0.0])
+    forward = np.array([0.0, 1.0, 0.0])
+    front_left = np.array([-1.0, 1.0, 0.0])
+    up = np.array([0.0, 0.0, 1.0])
+    assert (
+        geometric.answer_rel_direction(origin, forward, front_left, up, 2)
+        == "front-left"
+    )
+    assert (
+        geometric.answer_rel_direction(origin, forward, front_left, up, 2, "medium")
+        == "left"
+    )
+    assert geometric.answer_rel_direction(origin, origin, front_left, up, 2) is None
+
+
+def test_closest_distance_uses_point_cloud_distance():
+    first = [{"pts": np.array([[0.0, 0.0, 0.0]], np.float32), "n": 1}]
+    second = [{"pts": np.array([[0.0, 3.0, 4.0]], np.float32), "n": 1}]
+    assert geometric.answer_closest_distance(first, second) == pytest.approx(5.0)
+
+
+def test_robust_centroid_extent_returns_sorted_dimensions():
+    points = np.array(
+        [[x, y, z] for x in (-2.0, 2.0) for y in (-1.0, 1.0) for z in (-0.5, 0.5)],
+        np.float32,
+    )
+    centroid, longest, dimensions = geometric.robust_centroid_extent(points, up_axis=2)
+    np.testing.assert_allclose(centroid, [0.0, 0.0, 0.0])
+    assert longest > 3.0
+    assert np.all(dimensions[:-1] >= dimensions[1:])
+
+
+def test_depth_edges_handles_small_and_discontinuous_frames():
+    small = np.ones((5, 5), np.float32)
+    assert not geometric.depth_edges(small, np.ones_like(small, bool)).any()
+    depth = np.ones((20, 20), np.float32)
+    depth[:, 10:] = 10.0
+    edges = geometric.depth_edges(depth, np.ones_like(depth, bool))
+    assert edges[:, 9:11].any()

tests/test_encoder/test_geometric.py

@@ -0,0 +1,387 @@
+"""Tests for encoder/geometric.py -- spatial-code schema construction and derivation."""
+
+import json
+import re
+
+import numpy as np
+
+import geometric
+
+
+def test_dump_spatial_code(tmp_path):
+    path = tmp_path / "scene.json"
+    geometric.dump_spatial_code({"objects": {}, "appearance order": []}, path)
+    assert path.exists()
+    assert '"appearance order"' in path.read_text()
+
+
+def test_raw_bundle_dispatches_to_explicit_derivation(monkeypatch):
+    expected = (
+        {
+            "spatial code schema": geometric.EXPLICIT_SPATIAL_CODE_SCHEMA,
+            "objects": {},
+            "room": {"floor area": "0.0 square meters"},
+            "closest classes distance meters from": {},
+            "appearance order": [],
+        },
+        {},
+        {},
+        1,
+        np.array([0, 1, 0], dtype=np.float32),
+        0.0,
+    )
+    seen = {}
+
+    def fake(scene):
+        seen["scene"] = scene
+        return expected
+
+    monkeypatch.setattr(geometric, "build_explicit_spatial_code", fake)
+    raw = {
+        "depth": np.ones((1, 2, 2), np.float32),
+        "intr": np.eye(3, dtype=np.float32)[None],
+        "c2w": np.eye(4, dtype=np.float32)[None],
+        "conf": None,
+        "ftimes": np.array([0.0], np.float32),
+        "per": {"chair": {}},
+    }
+    scene = {"raw_inputs": raw}
+    assert geometric.build_spatial_code(scene) is expected
+    assert seen["scene"] is scene
+
+
+def test_explicit_is_a_derivation_of_compact(monkeypatch):
+    """build_explicit_spatial_code() must always build compact FIRST and derive from it --
+    not measure geometry independently."""
+    compact_expected = (
+        {
+            "spatial code schema": geometric.COMPACT_SPATIAL_CODE_SCHEMA,
+            "objects": {},
+            "room": {},
+        },
+        {},
+        {},
+        1,
+        np.array([0, 1, 0], dtype=np.float32),
+        None,
+    )
+    seen = {}
+
+    def fake_compact(scene):
+        seen["scene"] = scene
+        return compact_expected
+
+    monkeypatch.setattr(geometric, "build_compact_spatial_code", fake_compact)
+    scene = {"raw_inputs": None}
+    code, *_ = geometric.build_explicit_spatial_code(scene)
+    assert seen["scene"] is scene
+    assert code["objects"] == {}
+
+
+def test_exact_math_is_integrated_into_geometric_module():
+    assert callable(geometric.build_explicit_spatial_code)
+    assert callable(geometric.dump_spatial_code)
+    assert not hasattr(geometric, "_reference")
+
+
+def test_position_reader_accepts_current_and_legacy_formatting():
+    assert geometric.pos3(
+        {
+            "position": {
+                "x coordinate": "1.25 meters",
+                "y coordinate": "-2.0 meters",
+                "height above floor": "0.5 meters",
+            }
+        }
+    ) == [1.25, -2.0, 0.5]
+    assert geometric.pos3(
+        {
+            "position": {
+                "floor_x_meters": 1.25,
+                "floor_y_meters": -2.0,
+                "height_above_floor_meters": 0.5,
+            }
+        }
+    ) == [1.25, -2.0, 0.5]
+
+
+def test_floor_level_v1_v2_math_is_shared(monkeypatch):
+    points = np.array([[0, 0, z] for z in [0, 0, 0, 1, 10]], np.float32)
+    gravity = np.array([0, 0, 1], np.float32)
+    monkeypatch.delenv("VSI_CODE_V2", raising=False)
+    v1 = geometric._floor_level(points, gravity)
+    monkeypatch.setenv("VSI_CODE_V2", "1")
+    v2 = geometric._floor_level(points, gravity)
+    assert 0 <= v1 < 0.2
+    assert v2 == 0.0
+
+
+METERS = re.compile(r"^-?\d+(?:\.\d+)? meters$")
+SQUARE_METERS = re.compile(r"^\d+(?:\.\d+)? square meters$")
+
+
+def _schema_instance(x, y, z, size, first_time=0.0):
+    pts = np.array(
+        [
+            [x - size / 2, y, z],
+            [x + size / 2, y, z],
+            [x, y - size / 2, z],
+            [x, y + size / 2, z],
+        ],
+        dtype=np.float32,
+    )
+    return {
+        "pts": pts,
+        "best_pts": pts,
+        "n": len(pts),
+        "nframes": 1,
+        "first_time": first_time,
+        "frames": {0},
+    }
+
+
+def _schema_scene():
+    chair = _schema_instance(0.0, 0.0, 0.5, 0.8, first_time=0.0)
+    table = _schema_instance(1.0, 0.0, 0.7, 1.2, first_time=1.0)
+    floor = np.array(
+        [[x, y, 0.0] for x in np.linspace(-1, 2, 5) for y in np.linspace(-1, 1, 5)],
+        dtype=np.float32,
+    )
+    return {
+        "instances": {"chair": [chair], "table": [table]},
+        "stats": {"chair": {"peak": 1}, "table": {"peak": 3}},
+        "scene_pts": np.concatenate([chair["pts"], table["pts"], floor], axis=0),
+        "cameras": None,
+    }
+
+
+def test_spatial_code_matches_reference_schema():
+    code, *_ = geometric.build_spatial_code(_schema_scene())
+    assert list(code) == [
+        "spatial code schema",
+        "objects",
+        "room",
+        "closest classes distance meters from",
+        "appearance order",
+    ]
+    assert code["spatial code schema"] == geometric.EXPLICIT_SPATIAL_CODE_SCHEMA
+    assert code["appearance order"] == ["chair", "table"]
+    assert SQUARE_METERS.match(code["room"]["floor area"])
+    for class_data in code["objects"].values():
+        assert set(class_data) == {"count", "instances"}
+        assert class_data["count"] == len(class_data["instances"])
+        for instance in class_data["instances"]:
+            assert set(instance) == {"position", "longest dimension"}
+            assert set(instance["position"]) == {
+                "x coordinate",
+                "y coordinate",
+                "height above floor",
+            }
+            assert all(METERS.match(value) for value in instance["position"].values())
+            assert METERS.match(instance["longest dimension"])
+    assert code["objects"]["table"]["count"] == 1
+    chair_to_table = code["closest classes distance meters from"]["chair"]["table"]
+    assert set(chair_to_table) == {"distance", "closeness rank"}
+    assert METERS.match(chair_to_table["distance"])
+    assert chair_to_table["closeness rank"] == 1
+
+
+def test_dumped_json_preserves_schema(tmp_path):
+    code, *_ = geometric.build_spatial_code(_schema_scene())
+    path = tmp_path / "scene.json"
+    geometric.dump_spatial_code(code, path)
+    assert json.loads(path.read_text()) == code
+
+
+def test_compact_spatial_code_exposes_only_reusable_primitives():
+    code, *_ = geometric.build_spatial_code(_schema_scene(), "compact")
+    assert list(code) == ["spatial code schema", "objects", "room"]
+    assert set(code["objects"]) == {"chair", "table"}
+    assert len(code["objects"]["chair"]) == 1
+    instance = code["objects"]["chair"][0]
+    assert set(instance) == {"3D oriented bounding box", "first visible time"}
+    box = instance["3D oriented bounding box"]
+    assert set(box) == {
+        "3D oriented bounding box center coordinates",
+        "3D oriented bounding box dimensions",
+        "3D oriented bounding box orientation unit vectors",
+    }
+    assert len(box["3D oriented bounding box center coordinates"]) == 3
+    assert len(box["3D oriented bounding box dimensions"]) == 3
+    orientation = np.asarray(
+        box["3D oriented bounding box orientation unit vectors"], dtype=np.float64
+    )
+    np.testing.assert_allclose(orientation @ orientation.T, np.eye(3), atol=0.02)
+    assert instance["first visible time"] == 0.0
+    polygons = code["room"]["floor boundary polygons"]
+    assert len(polygons) == 1
+    assert len(polygons[0]["outer boundary coordinates"]) >= 3
+    for hole in polygons[0]["interior hole boundary coordinates"]:
+        assert len(hole) >= 3
+        assert all(len(coordinate) == 2 for coordinate in hole)
+    assert "closest classes distance meters from" not in code
+    assert "appearance order" not in code
+
+
+def test_explicit_spatial_code_remains_the_default():
+    default, *_ = geometric.build_spatial_code(_schema_scene())
+    code, *_ = geometric.build_spatial_code(_schema_scene(), "explicit")
+    assert default == code
+
+
+def test_compact_spatial_code_merges_revisit_instances_and_keeps_earliest_time():
+    scene = _schema_scene()
+    revisit = dict(scene["instances"]["chair"][0])
+    revisit.update({"frames": {1}, "first_time": -1.0})
+    scene["instances"]["chair"].append(revisit)
+    scene["stats"]["chair"] = {"raw": 2, "merged": 2, "peak": 1}
+
+    code, instances, *_ = geometric.build_spatial_code(scene, "compact")
+
+    assert len(instances["chair"]) == 1
+    assert len(code["objects"]["chair"]) == 1
+    assert code["objects"]["chair"][0]["first visible time"] == -1.0
+
+
+def test_compact_oriented_box_uses_accumulated_instance_points():
+    xs = np.linspace(-2.0, 2.0, 80)
+    points = np.stack([xs, np.zeros_like(xs), np.full_like(xs, 0.5)], axis=1)
+    instance = {
+        "pts": points.astype(np.float32),
+        "best_pts": points[38:42].astype(np.float32),
+        "conf": None,
+    }
+
+    box = geometric._compact_oriented_box(
+        instance,
+        np.array([1.0, 0.0, 0.0]),
+        np.array([0.0, 1.0, 0.0]),
+        np.array([0.0, 0.0, 1.0]),
+        0.0,
+    )
+
+    assert max(box["3D oriented bounding box dimensions"]) > 3.5
+
+
+def test_compact_floor_boundaries_preserve_disconnected_regions():
+    first = np.array(
+        [[x, y, 0.0] for x in np.linspace(0, 1, 11) for y in np.linspace(0, 1, 11)]
+    )
+    second = np.array(
+        [[x, y, 0.0] for x in np.linspace(5, 6, 11) for y in np.linspace(0, 1, 11)]
+    )
+
+    polygons = geometric._compact_floor_boundary_polygons(
+        np.concatenate([first, second]),
+        np.array([1.0, 0.0, 0.0]),
+        np.array([0.0, 1.0, 0.0]),
+    )
+
+    assert len(polygons) == 2
+    assert all(len(polygon["outer boundary coordinates"]) >= 3 for polygon in polygons)
+
+
+def test_compact_spatial_code_suppresses_co_visible_duplicate_tracks():
+    points = np.array(
+        [[x, y, z] for x in (-0.5, 0.5) for y in (-0.5, 0.5) for z in (0.0, 1.0)],
+        dtype=np.float32,
+    )
+    first = {
+        "pts": points,
+        "best_pts": points,
+        "observations": [points],
+        "frames": {0},
+        "n": len(points),
+        "nframes": 1,
+        "first_time": 0.0,
+    }
+    second = dict(first)
+    second.update({"pts": points + 0.01, "best_pts": points + 0.01})
+    scene = {
+        "instances": {"chair": [first, second]},
+        "stats": {"chair": {"raw": 2, "merged": 2, "peak": 2}},
+        "scene_pts": np.concatenate([points, points + 0.01]),
+        "cameras": None,
+    }
+
+    code, instances, *_ = geometric.build_spatial_code(scene, "compact")
+
+    assert len(instances["chair"]) == 1
+    assert len(code["objects"]["chair"]) == 1
+
+
+def test_compact_oriented_box_combines_observation_extents_by_consensus():
+    narrow_x = np.linspace(-1.0, 1.0, 80)
+    wide_x = np.linspace(-2.0, 2.0, 80)
+    narrow = np.stack(
+        [narrow_x, np.zeros_like(narrow_x), np.full_like(narrow_x, 0.5)], axis=1
+    ).astype(np.float32)
+    wide = np.stack(
+        [wide_x, np.zeros_like(wide_x), np.full_like(wide_x, 0.5)], axis=1
+    ).astype(np.float32)
+    instance = {
+        "pts": np.concatenate([narrow, wide]),
+        "best_pts": narrow,
+        "observations": [narrow, wide],
+        "conf": None,
+    }
+
+    box = geometric._compact_oriented_box(
+        instance,
+        np.array([1.0, 0.0, 0.0]),
+        np.array([0.0, 1.0, 0.0]),
+        np.array([0.0, 0.0, 1.0]),
+        0.0,
+    )
+
+    # The LONGEST axis recovers the fullest observed extent (the wide view's full 4.0 span),
+    # not the cross-observation consensus -- a partial view underestimates true length, so the
+    # object is at least as long as the fullest clean view saw (see _compact_oriented_box's
+    # length-axis decoupling). Width/depth stay on the robust consensus.
+    assert 3.9 < max(box["3D oriented bounding box dimensions"]) <= 4.0
+
+
+def test_compact_instances_keep_peak_co_visible_hypotheses_by_evidence():
+    scene = _schema_scene()
+    weak = _schema_instance(4.0, 0.0, 0.5, 0.8, first_time=-1.0)
+    weak.update({"n": 4, "nframes": 1, "frames": {2}})
+    strong = scene["instances"]["chair"][0]
+    strong.update({"n": 40, "nframes": 3, "frames": {0, 1, 2}})
+    scene["instances"]["chair"] = [weak, strong]
+    scene["stats"]["chair"] = {"raw": 2, "merged": 2, "peak": 1}
+
+    code, instances, *_ = geometric.build_spatial_code(scene, "compact")
+
+    assert len(instances["chair"]) == 1
+    assert instances["chair"][0]["nframes"] == 3
+    assert instances["chair"][0]["first_time"] == -1.0
+    assert len(code["objects"]["chair"]) == 1
+
+
+def test_compact_oriented_box_rejects_one_inconsistent_observation():
+    ordinary = np.stack(
+        [
+            np.linspace(-1.0, 1.0, 80),
+            np.zeros(80),
+            np.full(80, 0.5),
+        ],
+        axis=1,
+    ).astype(np.float32)
+    outlier = ordinary.copy()
+    outlier[:, 0] *= 20
+    instance = {
+        "pts": np.concatenate([ordinary] * 4 + [outlier]),
+        "best_pts": ordinary,
+        "observations": [ordinary] * 4 + [outlier],
+        "conf": None,
+    }
+
+    box = geometric._compact_oriented_box(
+        instance,
+        np.array([1.0, 0.0, 0.0]),
+        np.array([0.0, 1.0, 0.0]),
+        np.array([0.0, 0.0, 1.0]),
+        0.0,
+    )
+
+    assert max(box["3D oriented bounding box dimensions"]) < 3.0

tests/test_encoder/test_init.py

@@ -0,0 +1,7 @@
+"""Tests for encoder package importability."""
+
+import encoder
+
+
+def test_encoder_package_imports_without_data_or_checkpoints():
+    assert encoder.__doc__ == "Spatial-code encoder package."