Remove old tests before replacement

tests/conftest.py

@@ -1,48 +0,0 @@
-"""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

@@ -1,12 +0,0 @@
-"""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

@@ -1,68 +0,0 @@
-"""Tests for harness/A/__init__.py -- shared config constants."""
-
-from argparse import ArgumentParser, Namespace
-from pathlib import Path
-
-import pytest
-
-from harness import A
-
-
-def test_thinking_mode_resolves_default_budgets():
-    args = Namespace(extended=True, reasoning_budget=None, force_budget=None)
-    A.resolve_protocol_budgets(ArgumentParser(), args)
-    assert args.reasoning_budget == A.EXTENDED_MAX_NEW_TOKENS
-    assert args.force_budget == A.MAX_NEW_TOKENS
-
-
-def test_base_mode_keeps_budgets_unset_without_budget_flags():
-    args = Namespace(extended=False, reasoning_budget=None, force_budget=None)
-    A.resolve_protocol_budgets(ArgumentParser(), args)
-    assert args.reasoning_budget is None
-    assert args.force_budget is None
-
-
-@pytest.mark.parametrize("flag", ["reasoning_budget", "force_budget"])
-def test_base_mode_rejects_thinking_budget_flags(flag):
-    args = Namespace(extended=False, reasoning_budget=None, force_budget=None)
-    setattr(args, flag, 8)
-    with pytest.raises(SystemExit):
-        A.resolve_protocol_budgets(ArgumentParser(), args)
-
-
-def test_generation_protocol_matches_vsibench_yaml():
-    # thinking-in-space/lmms_eval/tasks/vsibench/vsibench.yaml generation_kwargs.
-    assert A.MAX_NEW_TOKENS == 16
-    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

@@ -1,79 +0,0 @@
-"""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

@@ -1,60 +0,0 @@
-"""Tests for harness/A/__init__.py -- shared config constants."""
-
-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_workspace_results():
-    assert A.RESULTS_DIR == A.WORKSPACE_ROOT / "results" / "A"
-
-
-def test_question_protocol_policy_is_hardcoded_by_group():
-    assert A.question_group("object_counting") == "numerical"
-    assert A.protocol_for_question("object_counting") == "base"
-    assert A.question_group("route_planning") == "multiple_choice"
-    assert A.protocol_for_question("route_planning") == "thinking"
-
-
-def test_every_known_question_type_has_one_policy_group():
-    for question_type in A.NUMERICAL_QUESTION_TYPES:
-        assert (
-            A.protocol_for_question(question_type) == A.QUESTION_PROTOCOLS["numerical"]
-        )
-    for question_type in A.MULTIPLE_CHOICE_QUESTION_TYPES:
-        assert (
-            A.protocol_for_question(question_type)
-            == A.QUESTION_PROTOCOLS["multiple_choice"]
-        )

tests/test_A/test_launch.py

@@ -1,90 +0,0 @@
-"""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

@@ -1,94 +0,0 @@
-"""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 pytest
-
-from harness import A
-from harness.A import models as vlm_models
-
-
-def test_all_three_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_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

@@ -1,55 +0,0 @@
-"""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 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 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

@@ -1,229 +0,0 @@
-"""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_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

@@ -1,69 +0,0 @@
-"""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

@@ -1,12 +0,0 @@
-"""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

@@ -1,35 +0,0 @@
-"""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

@@ -1,33 +0,0 @@
-"""Tests for harness/B/__init__.py -- shared config constants."""
-
-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_workspace_results():
-    assert B.RESULTS_DIR == B.WORKSPACE_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

@@ -1,85 +0,0 @@
-"""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

@@ -1,103 +0,0 @@
-"""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.PRE_PROMPT)
-    assert json.dumps(_CODE, 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.PRE_PROMPT)
-
-
-@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.PRE_PROMPT)
-
-
-def test_default_arguments_reproduce_the_standard_prompt_byte_for_byte():
-    standard = code_prompts.build_prompt(_CODE, "object_counting", "How many chairs?")
-    explicit_defaults = code_prompts.build_prompt(
-        _CODE,
-        "object_counting",
-        "How many chairs?",
-        serialization="json",
-        context_line=None,
-    )
-    assert standard == explicit_defaults
-
-
-def test_yaml_serialization_renders_the_identical_dict():
-    import yaml
-
-    prompt = code_prompts.build_prompt(
-        _CODE, "object_counting", "How many chairs?", serialization="yaml"
-    )
-    rendered = prompt.split("\n", 1)[1].rsplit("How many chairs?", 1)[0]
-    assert yaml.safe_load(rendered) == _CODE
-
-
-def test_yaml_arm_context_line_does_not_claim_json():
-    prompt = code_prompts.build_prompt(
-        _CODE, "object_counting", "How many chairs?", serialization="yaml"
-    )
-    context = prompt.split("\n", 1)[0]
-    assert "JSON" not in context
-    assert "YAML" in context
-
-
-def test_paraphrase_context_line_swaps_only_the_first_line():
-    standard = code_prompts.build_prompt(_CODE, "object_counting", "How many chairs?")
-    paraphrased = code_prompts.build_prompt(
-        _CODE,
-        "object_counting",
-        "How many chairs?",
-        context_line=code_prompts.PARAPHRASE_PRE_PROMPT,
-    )
-    assert standard.split("\n", 1)[1] == paraphrased.split("\n", 1)[1]
-    assert standard.split("\n", 1)[0] != paraphrased.split("\n", 1)[0]
-
-
-def test_unknown_serialization_rejected():
-    with pytest.raises(ValueError):
-        code_prompts.render_code(_CODE, "xml")

tests/test_B/test_run.py

@@ -1,231 +0,0 @@
-"""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"] == "extended: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["forced"] is True
-    assert record["forced_input_token_count"] == 2510
-
-
-def test_run_strip_schema_legend_removes_only_the_legend(monkeypatch):
-    seen = {}
-
-    def fake_load(scene_id, depth, input_selection, tracking, frame_count, fmt):
-        return {
-            "spatial code schema": {"doc": 1},
-            "objects": {"chair": {"count": 1}},
-        }, "/fake.json"
-
-    class FakeAdapter:
-        model_path = "/fake/model"
-
-        def answer_extended(self, frames, prompt, **kwargs):
-            seen["prompt"] = prompt
-            return {
-                "prompt_text": prompt,
-                "answer_text": "1",
-                "answer_raw": "1",
-                "input_token_count": 1,
-                "vision_input_shapes": {},
-                "output_token_ids": [1],
-                "output_token_count": 1,
-                "hit_token_limit": False,
-                "eos_token_ids": [1],
-                "generation_seconds": 0.0,
-                "device": "cpu",
-                "dtype": "float32",
-                "library_versions": {},
-                "generation_config": {},
-            }
-
-    monkeypatch.setattr(harness_run.spatial_codes, "load_spatial_code", fake_load)
-    results = harness_run.run(
-        "qwen3.5-2b",
-        scene="13c3e046d7",
-        adapter=FakeAdapter(),
-        write_results=False,
-        limit=1,
-        strip_schema_legend=True,
-    )
-    assert results
-    assert "spatial code schema" not in seen["prompt"]
-    assert '"chair"' in seen["prompt"]
-
-
-def test_video_results_use_video_branch():
-    assert (
-        harness_run.results_dir_for(
-            "qwen3.5-4b", "thinking", "explicit", "metric", "tracking", "video", None
-        )
-        == B.RESULTS_DIR / "qwen3.5-4b" / "explicit" / "metric" / "tracking" / "video"
-    )
-
-
-def test_video_record_has_no_frame_count_in_condition():
-    info = dict(_FAKE_CODE_INFO, input_selection="video", frame_count=None)
-    record = harness_run._build_record(
-        _FAKE_ROW, "prompt", _FAKE_ANSWER, "metric", 1.0, "qwen3.5-4b", "/model", info
-    )
-    assert record["condition"] == "thinking:explicit:metric:tracking:video"
-    assert record["frame_count"] is None

tests/test_B/test_spatial_codes.py

@@ -1,48 +0,0 @@
-"""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

@@ -1,67 +0,0 @@
-"""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

@@ -1,12 +0,0 @@
-"""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

@@ -1,27 +0,0 @@
-"""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

@@ -1,25 +0,0 @@
-"""Tests for harness/C/__init__.py -- shared config constants."""
-
-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_workspace_results():
-    assert C.RESULTS_DIR == C.WORKSPACE_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

@@ -1,69 +0,0 @@
-"""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_overlay.py

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

tests/test_C/test_overlay_launch.py

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

tests/test_C/test_prompts.py

@@ -1,66 +0,0 @@
-"""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.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.PRE_PROMPT.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.PRE_PROMPT)
-    code_pos = prompt.find(json.dumps(_CODE, indent=1))
-    question_pos = prompt.find("How many chairs?")
-    post_pos = prompt.find(combined_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(combined_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.PRE_PROMPT)
-
-
-@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.PRE_PROMPT)
-
-
-def test_video_prompt_names_native_video():
-    prompt = combined_prompts.build_prompt(
-        _CODE, "object_counting", "How many chairs?", video=True
-    )
-    assert prompt.startswith("This is a video.\n")

tests/test_C/test_run.py

@@ -1,176 +0,0 @@
-"""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["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

@@ -1,67 +0,0 @@
-"""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_D/conftest.py

@@ -1,45 +0,0 @@
-"""Shared, self-contained import setup for harness.D tests."""
-
-import os
-from pathlib import Path
-import sys
-import tempfile
-import types
-
-ROOT = Path(__file__).resolve().parents[2]
-if str(ROOT) not in sys.path:
-    sys.path.insert(0, str(ROOT))
-
-# D imports the official VSI scorer eagerly. Provide a tiny interface-compatible scorer
-# and manifest so unit tests do not depend on /root/data being mounted.
-_FIXTURES = Path(tempfile.mkdtemp(prefix="test_D_"))
-_SCORER = _FIXTURES / "utils.py"
-_SCORER.write_text(
-    'MCA_QUESTION_TYPES = ("object_rel_direction_easy", "object_rel_direction_medium", "object_rel_direction_hard", "object_rel_distance", "route_planning", "obj_appearance_order")\n'
-    'NA_QUESTION_TYPES = ("object_abs_distance", "object_counting", "object_size_estimation", "room_size_estimation")\n'
-    'METRICS_FOR_MCA = {"exact_match": None}\n'
-    'METRICS_FOR_NA = {"MRA:.5:.95:.05": None}\n'
-    "def vsibench_process_results(doc, results):\n"
-    '    metric = "exact_match" if doc["question_type"] in MCA_QUESTION_TYPES else "MRA:.5:.95:.05"\n'
-    '    score = float(str(results[0]).strip() == str(doc["ground_truth"]).strip())\n'
-    '    return {"vsibench_score": {metric: score}}\n'
-)
-_MANIFEST = _FIXTURES / "test.jsonl"
-_MANIFEST.write_text(
-    '{"id": 7, "scene_name": "13c3e046d7", "dataset": "scannet", "question_type": "object_counting", "question": "How many chairs?", "options": null, "ground_truth": "1"}\n'
-)
-os.environ["HARNESS_OFFICIAL_EVAL"] = str(_SCORER)
-os.environ["SYMBOLIC_OFFICIAL_EVAL"] = str(_SCORER)
-sys.path.insert(0, str(_FIXTURES))
-os.environ["VSI_JSONL"] = str(_MANIFEST)
-
-# OpenCV is only needed when the optional frame arm actually decodes a video. Frame
-# unit tests monkeypatch that boundary and never call this placeholder.
-if "cv2" not in sys.modules:
-    cv2 = types.ModuleType("cv2")
-    cv2.CAP_PROP_FPS = 5
-    sys.modules["cv2"] = cv2
-
-
-def pytest_configure(config):
-    config.option.importmode = "importlib"

tests/test_D/test_D.py

@@ -1,21 +0,0 @@
-"""Tests for harness/D/__init__.py -- shared config constants."""
-
-from pathlib import Path
-
-from harness import A, B, D
-
-
-def test_spatial_code_formats_reuse_harness_b_vocabulary():
-    assert D.SPATIAL_CODE_FORMATS == B.SPATIAL_CODE_FORMATS
-    assert D.DEFAULT_SPATIAL_CODE_FORMAT in D.SPATIAL_CODE_FORMATS
-
-
-def test_reuses_harness_a_model_paths_and_generation_protocol():
-    assert D.MODEL_PATHS is A.MODEL_PATHS
-    assert D.MAX_NEW_TOKENS == A.MAX_NEW_TOKENS
-    assert D.DO_SAMPLE == A.DO_SAMPLE
-    assert D.TEMPERATURE == A.TEMPERATURE
-
-
-def test_results_dir_defaults_under_root_results():
-    assert D.RESULTS_DIR == Path("/root/results/D")

tests/test_D/test_init.py

@@ -1,19 +0,0 @@
-"""Tests for harness/D/__init__.py -- shared config constants."""
-
-from harness import A, B, D
-
-
-def test_spatial_code_formats_reuse_harness_b_vocabulary():
-    assert D.SPATIAL_CODE_FORMATS == B.SPATIAL_CODE_FORMATS
-    assert D.DEFAULT_SPATIAL_CODE_FORMAT in D.SPATIAL_CODE_FORMATS
-
-
-def test_reuses_harness_a_model_paths_and_generation_protocol():
-    assert D.MODEL_PATHS is A.MODEL_PATHS
-    assert D.MAX_NEW_TOKENS == A.MAX_NEW_TOKENS
-    assert D.DO_SAMPLE == A.DO_SAMPLE
-    assert D.TEMPERATURE == A.TEMPERATURE
-
-
-def test_results_dir_defaults_under_workspace_results():
-    assert D.RESULTS_DIR == D.WORKSPACE_ROOT / "results" / "D"

tests/test_D/test_launch.py

@@ -1,67 +0,0 @@
-"""Tests for harness/D/launch.py -- multi-GPU scene sharding across workers."""
-
-from harness.D import launch
-
-
-def test_launcher_imports():
-    assert callable(launch.main)
-
-
-class _FakeRun:
-    rows = [{"id": 2}, {"id": 5}]
-
-    @staticmethod
-    def results_dir_for(*args, **kwargs):
-        return args[3]
-
-    @classmethod
-    def load_questions(cls, scene=None):
-        return list(cls.rows)
-
-
-def test_launch_skips_scene_already_fully_answered(tmp_path, capsys, monkeypatch):
-    scene = "scene-d"
-    monkeypatch.setattr(launch, "_load_run_module", lambda: _FakeRun)
-
-    scene_dir = tmp_path / scene
-    scene_dir.mkdir()
-    for row in _FakeRun.rows:
-        (scene_dir / f"{row['id']}.json").write_text("{}")
-
-    launch.launch("qwen3.5-2b", "explicit", [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-d"
-    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", [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_scenes_is_subset_of_vsi_bench_scenes_with_ground_truth_coverage(monkeypatch):
-    monkeypatch.setattr("harness.A.launch.scenes", lambda: ["a", "b", "c"])
-    monkeypatch.setattr(launch, "ground_truth_scenes", lambda: ["b", "c", "z"])
-    assert launch.scenes() == ["b", "c"]

tests/test_D/test_prompts.py

@@ -1,55 +0,0 @@
-"""Tests for harness/D/prompts.py -- ground-truth spatial-code-as-text prompt construction."""
-
-import json
-
-import pytest
-
-from harness.A.prompts import MCA_QUESTION_TYPES, NA_QUESTION_TYPES
-from harness.D 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.PRE_PROMPT)
-    assert json.dumps(_CODE, 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_or_video_language_in_pre_prompt():
-    assert "frame" not in code_prompts.PRE_PROMPT.lower()
-    assert "video" 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.PRE_PROMPT)
-
-
-@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.PRE_PROMPT)

tests/test_D/test_run.py

@@ -1,246 +0,0 @@
-"""Tests for harness/D/run.py -- result-record shape and result-file writing."""
-
-import json
-
-from harness import D
-from harness.D 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": "extended",
-    "spatial_code_format": "explicit",
-    "spatial_code_path": "/workspace/data/spatial codes/ground truth/explicit/scene0001_00.json",
-}
-
-
-def test_results_dir_for_matches_model_protocol_and_format_only():
-    root = harness_run.results_dir_for("qwen3.5-4b", "extended", "compact")
-    assert root == D.RESULTS_DIR / "qwen3.5-4b" / "code" / "extended" / "compact"
-
-
-def test_results_dir_for_isolates_frames_and_truncated_budget_arms():
-    root = harness_run.results_dir_for(
-        "qwen3.5-4b",
-        "truncated/64",
-        "explicit",
-        frames=True,
-        frame_selection="uniform",
-        frame_count=32,
-    )
-    assert root == (
-        D.RESULTS_DIR
-        / "qwen3.5-4b"
-        / "code + frames"
-        / "truncated"
-        / "64"
-        / "explicit"
-        / "uniform"
-        / "32"
-    )
-
-
-def test_build_record_describes_frames_plus_ground_truth_condition():
-    code_info = {
-        **_FAKE_CODE_INFO,
-        "protocol": "512",
-        "frames": True,
-        "frame_selection": "uniform",
-        "frame_count": 32,
-        "video_path": "/fake/scene.mp4",
-        "frame_indices": [0, 30],
-        "frame_timestamps": [0.0, 1.0],
-    }
-    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",
-        code_info,
-    )
-    assert record["condition"] == "512:explicit:frames:uniform:32"
-    assert record["frames"] is True
-    assert record["video_path"] == "/fake/scene.mp4"
-    assert record["frame_indices"] == [0, 30]
-    assert record["frame_timestamps_seconds"] == [0.0, 1.0]
-
-
-def test_results_dir_for_honors_explicit_override(tmp_path):
-    root = harness_run.results_dir_for("qwen3.5-4b", "base", "explicit", 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["spatial_code_format"] == "explicit"
-    assert record["spatial_code_path"] == _FAKE_CODE_INFO["spatial_code_path"]
-    # No depth/tracking/input_selection -- ground truth has no such axis. frames/
-    # frame_selection/frame_count/video_path/frame_indices/frame_timestamps_seconds DO
-    # exist on every record (the frames+ground-truth-code arm's fields), null here since
-    # _FAKE_CODE_INFO has no "frames" key -- same present-but-null pattern as
-    # reasoning_text on a base-protocol record.
-    assert record["condition"] == "extended:explicit"
-    assert record["protocol"] == "extended"
-    assert record["frames"] is False
-    assert record["frame_selection"] is None
-    assert record["frame_count"] is None
-    assert record["video_path"] is None
-    assert "input_selection" not in record
-    assert "depth" not in record
-    assert "tracking" not in record
-    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_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["forced"] is True
-    assert record["forced_input_token_count"] == 2510
-
-
-def test_build_record_defaults_reasoning_fields_when_absent():
-    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["reasoning_token_count"] is None
-    assert record["forced"] is False
-
-
-def test_run_code_transform_hook_replaces_the_loaded_code(monkeypatch, tmp_path):
-    """The corruption module's entry point: the hook's return value is what the
-    prompt is built from, and passing no hook keeps behavior identical."""
-    scene = "13c3e046d7"
-    seen = {}
-
-    def fake_load(scene_id, spatial_code_format):
-        return {"objects": {"chair": {"count": 1}}}, f"/fake/{scene_id}.json"
-
-    class FakeAdapter:
-        model_path = "/fake/model"
-
-        def answer_extended(self, frames, prompt, **kwargs):
-            seen["prompt"] = prompt
-            return {
-                "prompt_text": prompt,
-                "answer_text": "1",
-                "answer_raw": "1",
-                "input_token_count": 1,
-                "vision_input_shapes": {},
-                "output_token_ids": [1],
-                "output_token_count": 1,
-                "hit_token_limit": False,
-                "eos_token_ids": [1],
-                "generation_seconds": 0.0,
-                "device": "cpu",
-                "dtype": "float32",
-                "library_versions": {},
-                "generation_config": {},
-            }
-
-    monkeypatch.setattr(harness_run.spatial_codes, "load_spatial_code", fake_load)
-    replacement = {"objects": {"table": {"count": 9}}}
-    results = harness_run.run(
-        "qwen3.5-2b",
-        scene=scene,
-        adapter=FakeAdapter(),
-        write_results=False,
-        limit=1,
-        code_transform=lambda code, scene_id, fmt: replacement,
-    )
-    assert results
-    assert '"table"' in seen["prompt"]
-    assert '"chair"' not in seen["prompt"]

tests/test_D/test_spatial_codes.py

@@ -1,33 +0,0 @@
-"""Tests for harness/D/spatial_codes.py -- loading on-disk ground-truth spatial codes."""
-
-import json
-
-import pytest
-
-from harness.D import spatial_codes
-
-
-def test_load_spatial_code_rejects_unknown_format():
-    with pytest.raises(ValueError):
-        spatial_codes.load_spatial_code("scene", "bogus")
-
-
-def test_load_spatial_code_raises_clearly_when_missing(tmp_path, monkeypatch):
-    monkeypatch.setattr(
-        spatial_codes,
-        "ground_truth_spatial_code_path",
-        lambda *a, **k: str(tmp_path / "missing.json"),
-    )
-    with pytest.raises(FileNotFoundError):
-        spatial_codes.load_spatial_code("scene", "explicit")
-
-
-def test_load_spatial_code_returns_dict_and_path(tmp_path, monkeypatch):
-    fixture = tmp_path / "scene1.json"
-    fixture.write_text(json.dumps({"objects": {}, "room": {}}))
-    monkeypatch.setattr(
-        spatial_codes, "ground_truth_spatial_code_path", lambda *a, **k: str(fixture)
-    )
-    code, path = spatial_codes.load_spatial_code("scene1", "compact")
-    assert code == {"objects": {}, "room": {}}
-    assert path == str(fixture)

tests/test_D/test_sweep.py

@@ -1,28 +0,0 @@
-"""Tests for harness/D/sweep.py -- multi-config sweep planning."""
-
-from harness.A import models as vlm_models
-from harness.D import sweep
-
-
-def test_build_plan_covers_every_combination():
-    plan = sweep.build_plan(["qwen3.5-2b", "qwen3.5-4b"], ["explicit", "compact"])
-    assert len(plan) == 4
-    assert ("qwen3.5-2b", "explicit") in plan
-    assert ("qwen3.5-4b", "compact") in plan
-
-
-def test_build_plan_with_all_registered_models():
-    plan = sweep.build_plan(list(vlm_models.available_models()), ["explicit"])
-    assert len(plan) == len(vlm_models.available_models())
-
-
-def test_default_spatial_code_formats_cover_both_when_not_restricted():
-    # This session's execution-design decision: D sweeps both formats by default
-    # (unlike a hypothetical "winning cell only" design) since ground truth costs
-    # nothing extra to build across formats.
-    import argparse
-
-    parser = argparse.ArgumentParser()
-    parser.add_argument("--spatial-code-formats", default="all")
-    args = parser.parse_args([])
-    assert args.spatial_code_formats == "all"

tests/test_D/test_symbolic_eval.py

@@ -1,116 +0,0 @@
-"""Tests for harness/D/symbolic_eval.py -- symbolic solver run directly on ground-truth
-spatial codes, no VLM, written through symbolic.run's own writer into
-results/symbolic/ground truth/<format>/... (not a separate results/D/... location)."""
-
-import json
-
-from harness.D import symbolic_eval
-
-_FAKE_CODE = {
-    "spatial code schema": {},
-    "objects": {
-        "chair": [
-            {
-                "3D oriented bounding box": {
-                    "3D oriented bounding box center coordinates": [0, 0, 0.5],
-                    "3D oriented bounding box dimensions": [1, 1, 1],
-                    "3D oriented bounding box orientation unit vectors": [
-                        [1, 0, 0],
-                        [0, 1, 0],
-                        [0, 0, 1],
-                    ],
-                },
-                "first visible time": 0.0,
-            }
-        ]
-    },
-    "room": {"floor boundary polygons": []},
-}
-
-
-def _fake_load(scene_id, spatial_code_format):
-    return _FAKE_CODE, f"/fake/{scene_id}.json"
-
-
-def test_run_answers_real_questions_for_a_real_ground_truth_scene(
-    tmp_path, monkeypatch
-):
-    scene = "13c3e046d7"
-    monkeypatch.setattr(symbolic_eval.spatial_codes, "load_spatial_code", _fake_load)
-
-    results = symbolic_eval.run(
-        spatial_code_format="compact",
-        scene=scene,
-        results_dir=tmp_path,
-    )
-
-    assert results
-    for record in results:
-        assert record["scene"] == scene
-        assert record["result_path"] is not None
-
-    written = list(tmp_path.rglob("*.json"))
-    assert len(written) == len(results)
-    native_record = json.loads(written[0].read_text())
-    assert native_record["model"] == "symbolic"
-    assert native_record["condition"] == "ground truth:compact"
-    assert native_record["scene"] == scene
-
-
-def test_run_selects_ground_truth_spatial_codes_when_writing(tmp_path, monkeypatch):
-    scene = "13c3e046d7"
-    monkeypatch.setattr(symbolic_eval.spatial_codes, "load_spatial_code", _fake_load)
-    called = {"select": False, "format": None}
-
-    def fake_select(spatial_code_format):
-        called["select"] = True
-        called["format"] = spatial_code_format
-
-    monkeypatch.setattr(
-        symbolic_eval.symbolic_run, "select_ground_truth_spatial_codes", fake_select
-    )
-
-    symbolic_eval.run(spatial_code_format="explicit", scene=scene, results_dir=tmp_path)
-
-    assert called["select"] is True
-    assert called["format"] == "explicit"
-
-
-def test_run_does_not_write_when_write_results_is_false(tmp_path, monkeypatch):
-    scene = "13c3e046d7"
-    monkeypatch.setattr(symbolic_eval.spatial_codes, "load_spatial_code", _fake_load)
-    called = {"select": False}
-    monkeypatch.setattr(
-        symbolic_eval.symbolic_run,
-        "select_ground_truth_spatial_codes",
-        lambda *a, **k: called.__setitem__("select", True),
-    )
-
-    results = symbolic_eval.run(
-        spatial_code_format="compact",
-        scene=scene,
-        results_dir=tmp_path,
-        write_results=False,
-    )
-
-    assert called["select"] is False
-    assert results
-    for record in results:
-        assert record["result_path"] is None
-    assert list(tmp_path.rglob("*.json")) == []
-
-
-def test_run_forwards_results_dir_to_symbolic_writer(tmp_path, monkeypatch):
-    scene = "13c3e046d7"
-    monkeypatch.setattr(symbolic_eval.spatial_codes, "load_spatial_code", _fake_load)
-    seen = {}
-
-    def fake_write(scene_id, pq, code, results_dir=None):
-        seen["results_dir"] = results_dir
-        return tmp_path / "fake.json"
-
-    monkeypatch.setattr(symbolic_eval.symbolic_run, "write_question_result", fake_write)
-
-    symbolic_eval.run(spatial_code_format="compact", scene=scene, results_dir=tmp_path)
-
-    assert seen["results_dir"] == tmp_path

tests/test_E/conftest.py

@@ -1,12 +0,0 @@
-"""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_E/test_E.py

@@ -1,20 +0,0 @@
-"""Tests for harness/E package configuration."""
-
-import importlib
-from pathlib import Path
-
-from harness import E
-
-
-def test_blind_floor_reuses_harness_a_public_config():
-    assert E.PROTOCOLS == ("base", "extended")
-    assert "qwen3.5-2b" in E.MODEL_PATHS
-    assert E.RESULTS_DIR == Path("/root/results/E")
-
-
-def test_results_dir_can_be_overridden_by_environment(monkeypatch, tmp_path):
-    monkeypatch.setenv("VSI_HARNESS_E_RESULTS_DIR", str(tmp_path / "E"))
-    reloaded = importlib.reload(E)
-    assert reloaded.RESULTS_DIR == tmp_path / "E"
-    monkeypatch.delenv("VSI_HARNESS_E_RESULTS_DIR")
-    importlib.reload(E)

tests/test_E/test_launch.py

@@ -1,66 +0,0 @@
-"""Tests for harness/E/launch.py -- multi-GPU scene sharding for the blind floor."""
-
-from harness.E import launch
-
-
-def test_launcher_imports():
-    assert callable(launch.main)
-
-
-class _FakeRun:
-    rows = [{"id": 4}, {"id": 9}]
-
-    @staticmethod
-    def results_dir_for(model, protocol, 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-e"
-    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", [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-e"
-    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", [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_protocols_use_separate_result_roots():
-    run = launch._load_run_module()
-    base = run.results_dir_for("qwen3.5-2b", "base")
-    extended = run.results_dir_for("qwen3.5-2b", "extended")
-    assert base != extended

tests/test_E/test_prompts.py

@@ -1,48 +0,0 @@
-"""Tests for harness/E/prompts.py -- blind question-only prompt construction."""
-
-import pytest
-
-from harness.A.prompts import MCA_QUESTION_TYPES, NA_QUESTION_TYPES
-from harness.E import prompts as blind_prompts
-
-
-def test_na_question_prompt_is_question_plus_post_prompt_only():
-    prompt = blind_prompts.build_prompt("object_counting", "How many chairs?")
-    assert prompt == "How many chairs?\n" + blind_prompts.NA_POST_PROMPT
-
-
-def test_mca_question_prompt_includes_options_and_post_prompt():
-    prompt = blind_prompts.build_prompt(
-        "object_rel_distance", "Which is closest?", ["A. sofa", "B. table"]
-    )
-    assert "Options:\nA. sofa\nB. table" in prompt
-    assert prompt.endswith(blind_prompts.MCA_POST_PROMPT)
-
-
-def test_no_scene_language_anywhere():
-    # Blind means blind: no context line claiming frames, video, or a spatial code.
-    prompt = blind_prompts.build_prompt("object_counting", "How many chairs?")
-    lowered = prompt.lower()
-    assert "frame" not in lowered
-    assert "video" not in lowered
-    assert "spatial code" not in lowered
-
-
-def test_mca_question_requires_options():
-    with pytest.raises(ValueError):
-        blind_prompts.build_prompt("route_planning", "Which way?", None)
-
-
-def test_unknown_question_type_rejected():
-    with pytest.raises(ValueError):
-        blind_prompts.build_prompt("not_a_real_type", "?", None)
-
-
-@pytest.mark.parametrize("question_type", NA_QUESTION_TYPES)
-def test_every_na_question_type_builds(question_type):
-    assert blind_prompts.build_prompt(question_type, "q?")
-
-
-@pytest.mark.parametrize("question_type", MCA_QUESTION_TYPES)
-def test_every_mca_question_type_builds(question_type):
-    assert blind_prompts.build_prompt(question_type, "q?", ["A. x", "B. y"])

tests/test_E/test_run.py

@@ -1,97 +0,0 @@
-"""Tests for harness/E/run.py -- result-record shape and result-file writing."""
-
-import json
-
-from harness import E
-from harness.E 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": 42,
-    "vision_input_shapes": {},
-    "output_token_ids": [19, 151645],
-    "output_token_count": 2,
-    "hit_token_limit": False,
-    "eos_token_ids": [151645],
-    "generation_seconds": 0.2,
-    "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",
-}
-
-
-def test_results_dir_for_matches_model_and_protocol_only():
-    root = harness_run.results_dir_for("qwen3.5-4b", "base")
-    assert root == E.RESULTS_DIR / "qwen3.5-4b" / "base"
-
-
-def test_results_dir_for_isolates_the_two_protocols():
-    assert harness_run.results_dir_for(
-        "qwen3.5-4b", "base"
-    ) != harness_run.results_dir_for("qwen3.5-4b", "extended")
-
-
-def test_results_dir_for_honors_explicit_override(tmp_path):
-    assert harness_run.results_dir_for("qwen3.5-4b", "base", tmp_path) == tmp_path
-
-
-def test_build_record_has_no_scene_input_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",
-        "base",
-    )
-    assert record["condition"] == "base"
-    assert record["protocol"] == "base"
-    assert record["question"] == "How many chairs?"
-    assert record["answer_given"] == "4"
-    assert record["metric"] == "MRA:.5:.95:.05"
-    assert record["score"] == 1.0
-    # Blind: no frame or spatial-code provenance of any kind.
-    assert "frame_selection" not in record
-    assert "video_path" not in record
-    assert "frame_indices" not in record
-    assert "spatial_code_format" not in record
-    assert "spatial_code_path" 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",
-        "base",
-        results_dir=tmp_path,
-    )
-    assert path == tmp_path / "scene0001_00" / "7.json"
-    on_disk = json.loads(path.read_text())
-    assert on_disk == record

tests/test_E/test_sweep.py

@@ -1,40 +0,0 @@
-"""Tests for harness/E/sweep.py -- per-model blind-floor sweeping."""
-
-import pytest
-
-from harness.E import sweep
-
-
-def test_sweep_imports():
-    assert callable(sweep.main)
-
-
-def test_sweep_runs_every_model_through_launch(monkeypatch):
-    launched = []
-    monkeypatch.setattr(
-        sweep.harness_launch,
-        "launch",
-        lambda model, scenes, **kwargs: launched.append(
-            (model, kwargs.get("extended"))
-        ),
-    )
-    sweep.sweep(["qwen3.5-2b", "qwen3.5-4b"], ["scene_a"], extended=True)
-    assert launched == [("qwen3.5-2b", True), ("qwen3.5-4b", True)]
-
-
-def test_sweep_defaults_to_base_protocol(monkeypatch):
-    launched = []
-    monkeypatch.setattr(
-        sweep.harness_launch,
-        "launch",
-        lambda model, scenes, **kwargs: launched.append(kwargs.get("extended")),
-    )
-    sweep.sweep(["qwen3.5-2b"], ["scene_a"])
-    assert launched == [False]
-
-
-def test_sweep_parser_rejects_unknown_model(monkeypatch, capsys):
-    monkeypatch.setattr("sys.argv", ["sweep", "--models", "not-a-model"])
-    with pytest.raises(SystemExit):
-        sweep.main()
-    assert "unknown" in capsys.readouterr().err

tests/test_F/conftest.py

@@ -1,12 +0,0 @@
-"""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"