Remove old harness before replacement

harness/A/__init__.py

@@ -1,111 +0,0 @@
-"""Harness A: uniform/selective frame sampling + direct VLM inference calls.
-
-Mirrors the frame-selection vocabulary already used by ``inference`` (uniform vs.
-selective) and the exact generation protocol VSI-Bench's own harness
-(``thinking-in-space/lmms_eval/tasks/vsibench/vsibench.yaml``) evaluates every model
-under: greedy decoding (``do_sample=False``, temperature 0) and a hard 16-token output
-cap. Model weights live under ``MODELS_ROOT`` next to the other model checkpoints
-(``depth-anything-3``, ``sam3``) this workspace already downloads there.
-"""
-
-from __future__ import annotations
-
-import os
-from pathlib import Path
-
-DATA_ROOT = Path(os.environ.get("VSI_DATA_ROOT", "/root/data"))
-MODELS_ROOT = Path(os.environ.get("VSI_MODELS_ROOT", "/root/models"))
-VSI_ROOT = Path(os.environ.get("VSI_ROOT", DATA_ROOT / "VSI-Bench"))
-JSONL = Path(os.environ.get("VSI_JSONL", VSI_ROOT / "test.jsonl"))
-WORKSPACE_ROOT = Path(__file__).resolve().parent.parent.parent
-# One JSON per question, matching the layout results/symbolic/... already uses:
-# results/A/<model>/<frame_selection>/<frame_count>/<scene>/<question_id>.json
-RESULTS_DIR = Path(os.environ.get("VSI_HARNESS_RESULTS_DIR", "/root/results/A"))
-
-# Same two selection strategies and vocabulary as inference.SAM3_FRAME_SELECTIONS:
-# "uniform" (evenly spaced indices) or "selective" (the quality/redundancy/motion-
-# filtered keyframe selector in inference.adapters, algorithm 5 by default).
-FRAME_SELECTIONS = ("uniform", "selective")
-DEFAULT_FRAME_SELECTION = "uniform"
-FRAMES_PER_VIDEO = int(os.environ.get("VSI_HARNESS_FRAMES_PER_VIDEO", "32"))
-
-# Fixed by the VSI-Bench protocol (vsibench.yaml generation_kwargs) -- not configurable
-# per call, since comparing models under different decoding settings would be meaningless.
-MAX_NEW_TOKENS = 16
-TEMPERATURE = 0.0
-DO_SAMPLE = False
-
-# Thinking-protocol generation: a larger first-pass budget for the model
-# to work through the input before answering, with a short forced second call only if it
-# didn't conclude (hit the budget without emitting an end-of-sequence token) in that
-# first pass. The forced call reuses MAX_NEW_TOKENS (16) -- the same short-answer budget
-# the base protocol already uses -- since its whole job is to extract one terse answer,
-# not to reason further.
-EXTENDED_MAX_NEW_TOKENS = 2048
-FORCE_ANSWER_PROMPT = "\nFinal answer:"
-
-# Fixed experiment policy. Edit these two values to switch which question group
-# receives which generation protocol; every VLM harness imports this one mapping.
-QUESTION_PROTOCOLS = {
-    "numerical": "base",
-    "multiple_choice": "thinking",
-}
-PROTOCOLS = ("base", "thinking")
-
-NUMERICAL_QUESTION_TYPES = frozenset(
-    {
-        "object_abs_distance",
-        "object_counting",
-        "object_size_estimation",
-        "room_size_estimation",
-    }
-)
-MULTIPLE_CHOICE_QUESTION_TYPES = frozenset(
-    {
-        "object_rel_direction_easy",
-        "object_rel_direction_medium",
-        "object_rel_direction_hard",
-        "object_rel_distance",
-        "route_planning",
-        "obj_appearance_order",
-    }
-)
-
-
-def question_group(question_type):
-    """Return the fixed experiment group for one VSI-Bench question type."""
-    if question_type in NUMERICAL_QUESTION_TYPES:
-        return "numerical"
-    if question_type in MULTIPLE_CHOICE_QUESTION_TYPES:
-        return "multiple_choice"
-    raise ValueError(f"unknown VSI-Bench question type {question_type!r}")
-
-
-def protocol_for_question(question_type):
-    """Return the hardcoded protocol for one VSI-Bench question type."""
-    return QUESTION_PROTOCOLS[question_group(question_type)]
-
-
-def resolve_protocol_budgets(parser, args):
-    """Validate budgets used only by questions mapped to thinking."""
-    requested_reasoning = args.reasoning_budget
-    requested_force = getattr(args, "force_budget", None)
-    if requested_reasoning is not None and requested_reasoning < 1:
-        parser.error("--reasoning-budget must be positive")
-    if requested_force is not None and requested_force < 1:
-        parser.error("--force-budget must be positive")
-    args.reasoning_budget = (
-        EXTENDED_MAX_NEW_TOKENS if requested_reasoning is None else requested_reasoning
-    )
-    if hasattr(args, "force_budget"):
-        args.force_budget = (
-            MAX_NEW_TOKENS if requested_force is None else requested_force
-        )
-
-
-MODEL_PATHS = {
-    "qwen3.5-4b": MODELS_ROOT / "qwen3.5-4b",
-    "qwen3.5-2b": MODELS_ROOT / "qwen3.5-2b",
-    "internvl3.5-4b": MODELS_ROOT / "internvl3.5-4b",
-    "internvl3.5-2b": MODELS_ROOT / "internvl3.5-2b",
-}

harness/A/frames.py

@@ -1,54 +0,0 @@
-"""Uniform / selective frame sampling for direct VLM calls.
-
-Reuses ``inference.adapters._sample_video_frames`` -- the exact same decoder every
-other model adapter in this workspace (DA3, SAM3, SegVGGT) already samples through --
-so "uniform" and "selective" behave identically here and there, and the selective
-(smart) keyframe indices share that module's on-disk cache instead of being recomputed.
-"""
-
-from __future__ import annotations
-
-from pathlib import Path
-
-import cv2
-from PIL import Image
-
-from harness.A import FRAME_SELECTIONS
-from inference.adapters import _sample_video_frames
-
-
-def sample_frames(video_path, frame_count, frame_selection):
-    """Return (``frame_count`` RGB frames as PIL images, their video timestamps in
-    seconds, their raw integer frame indices).
-
-    ``frame_selection="uniform"`` takes evenly spaced indices across the whole video.
-    ``frame_selection="selective"`` (the "smart" mode) takes the quality/redundancy/
-    motion-filtered keyframe indices from ``inference.adapters.select_video_frame_indices``,
-    downsampled to ``frame_count`` if the selector kept more frames than requested.
-    Both timestamps and indices are returned (not discarded) so callers can log exactly
-    which frames of the source video were fed to a model, for full-provenance result
-    records -- indices are exact (unlike timestamps, which lose precision through the
-    index/fps conversion _sample_video_frames itself performs).
-    """
-    if frame_selection not in FRAME_SELECTIONS:
-        raise ValueError(
-            f"unknown frame selection {frame_selection!r}; expected one of {FRAME_SELECTIONS}"
-        )
-    if frame_count < 1:
-        raise ValueError("frame_count must be positive")
-    if not Path(video_path).is_file():
-        raise FileNotFoundError(f"video not found: {video_path}")
-    frames, times = _sample_video_frames(video_path, frame_count, frame_selection)
-    capture = cv2.VideoCapture(video_path)
-    try:
-        fps = capture.get(cv2.CAP_PROP_FPS) or 1.0
-    finally:
-        capture.release()
-    # Inverse of the exact index/fps conversion _sample_video_frames applies, so this
-    # recovers the original integer indices without redoing frame selection.
-    indices = [int(round(float(t) * fps)) for t in times]
-    return (
-        [Image.fromarray(frame) for frame in frames],
-        [float(t) for t in times],
-        indices,
-    )

harness/A/launch.py

@@ -1,282 +0,0 @@
-"""Keep every visible GPU busy with persistent harness-A inference workers.
-
-Same shape as ``inference/launch.py``: one persistent worker process per visible GPU,
-pulling scenes off a shared queue, each loading its model exactly once and reusing it
-for every scene it's assigned (via ``run.run(..., adapter=...)``) instead of paying the
-load cost per scene. One invocation covers one (model, frame_selection, frame_count)
-triple across every requested scene; sweep multiple triples by invoking this once per
-triple (a shell loop), exactly how ``inference/launch.py`` is invoked once per mode.
-"""
-
-from __future__ import annotations
-
-import argparse
-import importlib.util
-import json
-import multiprocessing as mp
-import os
-from pathlib import Path
-import sys
-import traceback
-
-HERE = Path(__file__).resolve().parent
-WORKSPACE_ROOT = HERE.parent.parent
-if str(WORKSPACE_ROOT) not in sys.path:
-    sys.path.insert(0, str(WORKSPACE_ROOT))
-
-from harness.A import (  # noqa: E402
-    DEFAULT_FRAME_SELECTION,
-    EXTENDED_MAX_NEW_TOKENS,
-    FRAME_SELECTIONS,
-    FRAMES_PER_VIDEO,
-    JSONL,
-    MAX_NEW_TOKENS,
-)
-from harness.A import models as vlm_models  # noqa: E402
-from harness.A import resolve_protocol_budgets  # noqa: E402
-from inference.launch import available_cpu_count, visible_gpus  # noqa: E402
-
-
-def _load_run_module():
-    spec = importlib.util.spec_from_file_location("_harness_A_run", HERE / "run.py")
-    module = importlib.util.module_from_spec(spec)
-    sys.modules[spec.name] = module
-    spec.loader.exec_module(module)
-    return module
-
-
-def scenes():
-    """Return unique VSI-Bench scenes in their original manifest order."""
-    with open(JSONL) as manifest:
-        return list(
-            dict.fromkeys(str(json.loads(line)["scene_name"]) for line in manifest)
-        )
-
-
-def _worker(
-    tasks,
-    results,
-    model,
-    frame_selection,
-    frame_count,
-    video,
-    results_dir,
-    gpu,
-    cpu_threads,
-    extended,
-    reasoning_budget,
-    force_budget,
-):
-    if gpu is not None:
-        os.environ["CUDA_VISIBLE_DEVICES"] = str(gpu)
-    for variable in ("OMP_NUM_THREADS", "MKL_NUM_THREADS", "OPENBLAS_NUM_THREADS"):
-        os.environ[variable] = str(cpu_threads)
-    import cv2
-
-    cv2.setNumThreads(cpu_threads)
-    run = _load_run_module()
-    adapter = None
-    load_error = None
-    try:
-        adapter = vlm_models.get_adapter(model)
-        adapter.load_model("cuda:0" if gpu is not None else "cpu")
-    except Exception:
-        load_error = traceback.format_exc()
-    while True:
-        scene = tasks.get()
-        if scene is None:
-            return
-        if load_error is not None:
-            results.put((scene, False, load_error))
-            continue
-        try:
-            answered = run.run(
-                model,
-                frame_selection=frame_selection,
-                frame_count=frame_count,
-                video=video,
-                scene=scene,
-                results_dir=results_dir,
-                adapter=adapter,
-                extended=extended,
-                reasoning_budget=reasoning_budget,
-                force_budget=force_budget,
-            )
-            mean_score = (
-                sum(r["score"] for r in answered) / len(answered) if answered else None
-            )
-            results.put(
-                (scene, True, f"{len(answered)} question(s), mean_score={mean_score}")
-            )
-        except Exception:
-            results.put((scene, False, traceback.format_exc()))
-
-
-def launch(
-    model,
-    frame_selection,
-    frame_count,
-    selected,
-    video=False,
-    results_dir=None,
-    rebuild=False,
-    extended=True,
-    reasoning_budget=EXTENDED_MAX_NEW_TOKENS,
-    force_budget=MAX_NEW_TOKENS,
-):
-    """Answer every question for ``selected`` scenes, sharded across visible GPUs."""
-    if video:
-        frame_selection = "video"
-        frame_count = None
-    elif frame_count is None or frame_count < 1:
-        raise ValueError("frame_count must be positive in frames mode")
-    mode = "video" if video else f"{frame_selection}/{frame_count}"
-    condition = f"{model}/{mode}"
-    run = _load_run_module()
-    root = run.results_dir_for(model, None, frame_selection, frame_count, results_dir)
-    pending = []
-    completed = 0
-    for scene in selected:
-        rows = run.load_questions(scene=scene)
-        if not rows:
-            raise ValueError(
-                f"no questions found for scene {scene!r}; check the manifest/scene selection"
-            )
-        answered = all((root / scene / f"{row['id']}.json").is_file() for row in rows)
-        if answered and not rebuild:
-            completed += 1
-            print(
-                f"[{condition} {completed}/{len(selected)}] {scene}: skipped",
-                flush=True,
-            )
-        else:
-            pending.append(scene)
-    if not pending:
-        print(f"[{condition}] DONE: {len(selected)} ok, 0 failed")
-        return
-
-    gpus = visible_gpus()
-    worker_count = min(len(pending), len(gpus) if gpus else 1)
-    assignments = gpus[:worker_count] if gpus else [None]
-    cpu_count = available_cpu_count()
-    cpu_threads = max(1, cpu_count // worker_count)
-    print(
-        f"[{condition}] starting {worker_count} persistent worker(s); "
-        f"GPUs={assignments}; CPU threads/worker={cpu_threads}",
-        flush=True,
-    )
-
-    context = mp.get_context("spawn")
-    tasks, results = context.Queue(), context.Queue()
-    for scene in pending:
-        tasks.put(scene)
-    for _ in range(worker_count):
-        tasks.put(None)
-    workers = [
-        context.Process(
-            target=_worker,
-            args=(
-                tasks,
-                results,
-                model,
-                frame_selection,
-                frame_count,
-                video,
-                results_dir,
-                gpu,
-                cpu_threads,
-                extended,
-                reasoning_budget,
-                force_budget,
-            ),
-        )
-        for gpu in assignments
-    ]
-    for worker in workers:
-        worker.start()
-    failed = []
-    for finished in range(1, len(pending) + 1):
-        scene, ok, detail = results.get()
-        if not ok:
-            failed.append(scene)
-        print(
-            f"[{condition} {completed + finished}/{len(selected)}] {scene}: "
-            f"{'done' if ok else 'FAILED'}\n{detail}",
-            flush=True,
-        )
-    for worker in workers:
-        worker.join()
-    print(
-        f"[{condition}] DONE: {len(pending) - len(failed)} answered, {completed} skipped, "
-        f"{len(failed)} failed"
-    )
-    if failed:
-        raise SystemExit(1)
-
-
-def main():
-    parser = argparse.ArgumentParser()
-    parser.add_argument("scene", nargs="?")
-    parser.add_argument(
-        "--scenes",
-        help="comma-separated scenes (cannot be combined with positional scene)",
-    )
-    parser.add_argument("--model", required=True, choices=vlm_models.available_models())
-    parser.add_argument(
-        "--frame-selection",
-        default=None,
-        choices=FRAME_SELECTIONS,
-        dest="frame_selection",
-    )
-    input_mode = parser.add_mutually_exclusive_group(required=True)
-    input_mode.add_argument("--frames", type=int)
-    input_mode.add_argument("--video", action="store_true")
-    parser.add_argument("--results-dir", default=None)
-    parser.add_argument("--rebuild", action="store_true")
-    parser.add_argument(
-        "--reasoning-budget",
-        type=int,
-        default=None,
-        help="thinking mode only (default: 2048)",
-    )
-    parser.add_argument(
-        "--force-budget",
-        type=int,
-        default=None,
-        help="thinking mode only (default: 16)",
-    )
-    args = parser.parse_args()
-    if args.scene and args.scenes:
-        parser.error("positional scene and --scenes cannot be used together")
-    if args.scenes is not None:
-        selected = [scene.strip() for scene in args.scenes.split(",") if scene.strip()]
-        if not selected:
-            parser.error("--scenes must contain at least one scene")
-        selected = list(dict.fromkeys(selected))
-    else:
-        selected = [args.scene] if args.scene else scenes()
-    if args.video:
-        if args.frame_selection is not None:
-            parser.error("--frame-selection cannot be used with --video")
-    else:
-        if args.frame_selection is None:
-            parser.error("--frame-selection is required with --frames")
-        if args.frames < 1:
-            parser.error("--frames must be positive")
-    resolve_protocol_budgets(parser, args)
-    launch(
-        args.model,
-        args.frame_selection,
-        args.frames,
-        selected,
-        video=args.video,
-        results_dir=args.results_dir,
-        rebuild=args.rebuild,
-        extended=True,
-        reasoning_budget=args.reasoning_budget,
-        force_budget=args.force_budget,
-    )
-
-
-if __name__ == "__main__":
-    main()

harness/A/models.py

@@ -1,416 +0,0 @@
-"""Model adapters: load one VLM, answer one (frames, prompt) pair, greedy-decoded.
-
-Same ``load_model`` / one-call-per-question shape as ``inference.adapters.InferenceAdapter``,
-but returning generated text instead of preserving a native raw-feature cache. Every
-adapter is forced to the fixed VSI-Bench decoding protocol from ``harness.A``
-(``do_sample=False``, 16 new tokens) -- callers cannot override it, since comparing
-models under different decoding settings defeats the point of a shared harness.
-"""
-
-from __future__ import annotations
-
-from abc import ABC, abstractmethod
-from pathlib import Path
-
-from harness.A import (
-    DO_SAMPLE,
-    EXTENDED_MAX_NEW_TOKENS,
-    FORCE_ANSWER_PROMPT,
-    MAX_NEW_TOKENS,
-    MODEL_PATHS,
-    TEMPERATURE,
-)
-
-
-def _numbered_content(frames, question):
-    """Build one visual question from either sampled frames or a native video path.
-
-    Numbering frames (not just concatenating raw images) is the documented convention
-    for multi-image/video prompting with both model families here -- it is the only way
-    the model can recover frame ORDER, which several VSI-Bench question types
-    (obj_appearance_order, route_planning) directly depend on.
-    """
-    if isinstance(frames, (str, Path)):
-        return [
-            {"type": "video", "video": str(frames)},
-            {"type": "text", "text": question},
-        ]
-    content = []
-    for index, frame in enumerate(frames, start=1):
-        content.append({"type": "text", "text": f"Frame {index}:"})
-        content.append({"type": "image", "image": frame})
-    content.append({"type": "text", "text": question})
-    return content
-
-
-def _split_think(text):
-    """Split a thinking-mode generation into (think_content, answer_after_think).
-    Returns (None, text) when no closed think block is present -- the caller then
-    treats the whole text as reasoning that never concluded."""
-    if "</think>" in text:
-        think, _, answer = text.partition("</think>")
-        return think.replace("<think>", "").strip(), answer.strip()
-    return None, text
-
-
-class VLMAdapter(ABC):
-    """Common interface implemented by every direct-inference VLM adapter."""
-
-    def __init__(self, model_path=None):
-        self.model_path = Path(model_path)
-        self.model = None
-        self.processor = None
-        self.device = None
-        self.dtype = None
-
-    @abstractmethod
-    def load_model(self, device="cuda"):
-        """Load model + processor weights once for repeated ``answer`` calls."""
-
-    @abstractmethod
-    def answer(self, frames, question, max_new_tokens=None):
-        """Return a full, untruncated record of one greedy-decoded response.
-
-        Every field a downstream result file needs is produced here, not reconstructed
-        later: the literal rendered prompt text, both the cleaned and fully raw decoded
-        response, the actual generated token ids/count, whether the token budget cut the
-        response off before a natural stop, and the exact generation config used.
-
-        ``max_new_tokens`` defaults to MAX_NEW_TOKENS (the VSI-Bench-standard 16-token
-        base protocol). Passing a larger cap runs this SAME single-generation,
-        no-rescue mechanism at a bigger truncation window -- the raw-budget arm
-        (analysis/preregistration.md): mimics the base protocol's exact behavior (no
-        forced second pass), just with more room before truncation.
-        """
-
-    @abstractmethod
-    def answer_extended(
-        self,
-        frames,
-        question,
-        reasoning_budget=EXTENDED_MAX_NEW_TOKENS,
-        force_budget=MAX_NEW_TOKENS,
-    ):
-        """Same record shape as ``answer``, but with a much larger first-pass budget to
-        work through the input before answering. If the model does not conclude within
-        that budget (hits it without emitting an end-of-sequence token), a short forced
-        second call -- continuing the exact same generation, not a new turn -- asks for
-        the final answer directly. Always records the full, untruncated first-pass text
-        too (``reasoning_text``), even when a forced second call supplies the answer
-        actually used for scoring.
-        """
-
-    def unload(self):
-        """Free GPU memory so another adapter can be loaded in its place."""
-        import torch
-
-        self.model = None
-        self.processor = None
-        torch.cuda.empty_cache()
-
-
-class _TransformersVLMAdapter(VLMAdapter):
-    """Shared load/generate path for HF ``AutoModelForImageTextToText`` checkpoints."""
-
-    chat_template_kwargs = {}
-
-    def load_model(self, device="cuda"):
-        import torch
-        from transformers import AutoModelForImageTextToText, AutoProcessor
-
-        if not self.model_path.is_dir():
-            raise FileNotFoundError(f"model not found: {self.model_path}")
-        self.device = device
-        self.dtype = torch.bfloat16
-        self.processor = AutoProcessor.from_pretrained(
-            str(self.model_path), trust_remote_code=True
-        )
-        self.model = (
-            AutoModelForImageTextToText.from_pretrained(
-                str(self.model_path), dtype=self.dtype, trust_remote_code=True
-            )
-            .eval()
-            .to(device)
-        )
-
-    def _build_inputs(self, frames, question):
-        """Render one chat turn to both plain text and tokenized model inputs."""
-        messages = [{"role": "user", "content": _numbered_content(frames, question)}]
-        prompt_text = self.processor.apply_chat_template(
-            messages,
-            add_generation_prompt=True,
-            tokenize=False,
-            **self.chat_template_kwargs,
-        )
-        inputs = self.processor.apply_chat_template(
-            messages,
-            add_generation_prompt=True,
-            tokenize=True,
-            return_dict=True,
-            return_tensors="pt",
-            **self.chat_template_kwargs,
-        ).to(self.device)
-        # Shapes of every non-text processor output (pixel_values, image_grid_thw, ...) --
-        # generic across model families instead of hunting each one's own vision placeholder
-        # token id, and still shows exactly how much visual input the model actually received.
-        vision_input_shapes = {
-            key: list(value.shape)
-            for key, value in inputs.items()
-            if key not in ("input_ids", "attention_mask") and hasattr(value, "shape")
-        }
-        return prompt_text, inputs, vision_input_shapes
-
-    def _eos_ids(self):
-        eos_ids = self.model.generation_config.eos_token_id
-        if eos_ids is None:
-            eos_ids = self.processor.tokenizer.eos_token_id
-        return [eos_ids] if isinstance(eos_ids, int) else list(eos_ids or [])
-
-    def _generate(self, inputs, max_new_tokens):
-        """Run one greedy generate() call. Returns (full sequence, elapsed seconds)."""
-        import time
-
-        import torch
-
-        start = time.monotonic()
-        with torch.no_grad():
-            generated = self.model.generate(
-                **inputs,
-                max_new_tokens=max_new_tokens,
-                do_sample=DO_SAMPLE,
-                temperature=None,
-                top_p=None,
-                top_k=None,
-            )
-        if self.device.startswith("cuda"):
-            torch.cuda.synchronize()
-        return generated, time.monotonic() - start
-
-    def _decode_new_tokens(self, generated, input_token_count, max_new_tokens, eos_ids):
-        """Split one generate() output into new-token ids + decoded text + hit-limit flag."""
-        output_token_ids = generated[0][input_token_count:].tolist()
-        hit_token_limit = len(output_token_ids) >= max_new_tokens and (
-            not output_token_ids or output_token_ids[-1] not in eos_ids
-        )
-        answer_text = self.processor.decode(
-            output_token_ids, skip_special_tokens=True
-        ).strip()
-        answer_raw = self.processor.decode(output_token_ids, skip_special_tokens=False)
-        return output_token_ids, hit_token_limit, answer_text, answer_raw
-
-    def _library_versions(self):
-        import torch
-        import transformers
-
-        return {"transformers": transformers.__version__, "torch": torch.__version__}
-
-    def answer(self, frames, question, max_new_tokens=None):
-        if self.model is None or self.processor is None:
-            raise RuntimeError("load_model() must be called before answer()")
-        cap = MAX_NEW_TOKENS if max_new_tokens is None else max_new_tokens
-        prompt_text, inputs, vision_input_shapes = self._build_inputs(frames, question)
-        input_token_count = int(inputs["input_ids"].shape[1])
-        generated, generation_seconds = self._generate(inputs, cap)
-        eos_ids = self._eos_ids()
-        output_token_ids, hit_token_limit, answer_text, answer_raw = (
-            self._decode_new_tokens(generated, input_token_count, cap, eos_ids)
-        )
-
-        return {
-            "prompt_text": prompt_text,
-            "answer_text": answer_text,
-            "answer_raw": answer_raw,
-            "input_token_count": input_token_count,
-            "vision_input_shapes": vision_input_shapes,
-            "output_token_ids": output_token_ids,
-            "output_token_count": len(output_token_ids),
-            "hit_token_limit": hit_token_limit,
-            "eos_token_ids": eos_ids,
-            "generation_seconds": generation_seconds,
-            "device": self.device,
-            "dtype": str(self.dtype).removeprefix("torch."),
-            "library_versions": self._library_versions(),
-            "generation_config": {
-                "max_new_tokens": cap,
-                "do_sample": DO_SAMPLE,
-                "temperature": TEMPERATURE,
-                "top_p": None,
-                "top_k": None,
-                **self.chat_template_kwargs,
-            },
-        }
-
-    def answer_extended(
-        self,
-        frames,
-        question,
-        reasoning_budget=EXTENDED_MAX_NEW_TOKENS,
-        force_budget=MAX_NEW_TOKENS,
-    ):
-        import torch
-
-        if self.model is None or self.processor is None:
-            raise RuntimeError("load_model() must be called before answer_extended()")
-        prompt_text, inputs, vision_input_shapes = self._build_inputs(frames, question)
-        input_token_count = int(inputs["input_ids"].shape[1])
-        eos_ids = self._eos_ids()
-
-        generated, reasoning_seconds = self._generate(inputs, reasoning_budget)
-        reasoning_token_ids, reasoning_hit_limit, reasoning_text, reasoning_raw = (
-            self._decode_new_tokens(
-                generated, input_token_count, reasoning_budget, eos_ids
-            )
-        )
-
-        thinking = bool(self.chat_template_kwargs.get("enable_thinking"))
-        think_closed = thinking and "</think>" in reasoning_text
-        # With thinking ON, a natural stop whose think block never closed is as
-        # unusable as hitting the limit -- force the commit either way, closing the
-        # block the way the template expects.
-        forced = reasoning_hit_limit or (thinking and not think_closed)
-        generation_seconds = reasoning_seconds
-        if forced:
-            # Continue the SAME generation (not a new chat turn): the model's own partial
-            # response, plus an explicit instruction to answer now, then a short second
-            # budget to extract that answer. Multimodal tensors (pixel_values, etc.) must
-            # be resupplied -- the continued sequence still contains the original image
-            # placeholder tokens, and generate() recomputes their embeddings from scratch.
-            force_text = (
-                ("\n</think>\n" + FORCE_ANSWER_PROMPT)
-                if (thinking and not think_closed)
-                else FORCE_ANSWER_PROMPT
-            )
-            force_prompt_ids = self.processor.tokenizer(
-                force_text, return_tensors="pt", add_special_tokens=False
-            )["input_ids"].to(self.device)
-            continued_ids = torch.cat([generated, force_prompt_ids], dim=1)
-            continued_mask = torch.ones_like(continued_ids)
-            added_length = int(continued_ids.shape[1]) - input_token_count
-            continued_inputs = {}
-            for key, value in inputs.items():
-                if key in ("input_ids", "attention_mask"):
-                    continue
-                # Per-token multimodal metadata (e.g. Qwen's mm_token_type_ids) is sized to
-                # the ORIGINAL prompt length and must grow with it; every newly generated
-                # token (reasoning + the force prompt) is plain text, never an image
-                # placeholder, so pad with zeros. Per-patch tensors (pixel_values,
-                # image_grid_thw, ...) don't depend on sequence length at all and pass
-                # through unchanged -- this check is what tells the two apart.
-                if (
-                    hasattr(value, "shape")
-                    and value.dim() >= 2
-                    and value.shape[1] == input_token_count
-                ):
-                    pad = value.new_zeros(
-                        (value.shape[0], added_length) + tuple(value.shape[2:])
-                    )
-                    value = torch.cat([value, pad], dim=1)
-                continued_inputs[key] = value
-            continued_inputs["input_ids"] = continued_ids
-            continued_inputs["attention_mask"] = continued_mask
-            forced_input_token_count = int(continued_ids.shape[1])
-
-            forced_generated, forced_seconds = self._generate(
-                continued_inputs, force_budget
-            )
-            output_token_ids, hit_token_limit, answer_text, answer_raw = (
-                self._decode_new_tokens(
-                    forced_generated, forced_input_token_count, force_budget, eos_ids
-                )
-            )
-            generation_seconds += forced_seconds
-        else:
-            forced_input_token_count = None
-            output_token_ids, hit_token_limit = reasoning_token_ids, reasoning_hit_limit
-            answer_text, answer_raw = reasoning_text, reasoning_raw
-            if thinking and think_closed:
-                # Score only what follows the closed think block; the full trace stays
-                # in reasoning_text/reasoning_raw below, untruncated.
-                _think, answer_text = _split_think(reasoning_text)
-
-        return {
-            "prompt_text": prompt_text,
-            "answer_text": answer_text,
-            "answer_raw": answer_raw,
-            "input_token_count": input_token_count,
-            "vision_input_shapes": vision_input_shapes,
-            "output_token_ids": output_token_ids,
-            "output_token_count": len(output_token_ids),
-            "hit_token_limit": hit_token_limit,
-            "eos_token_ids": eos_ids,
-            "generation_seconds": generation_seconds,
-            "device": self.device,
-            "dtype": str(self.dtype).removeprefix("torch."),
-            "library_versions": self._library_versions(),
-            "generation_config": {
-                "max_new_tokens": reasoning_budget,
-                "force_answer_max_new_tokens": force_budget,
-                "do_sample": DO_SAMPLE,
-                "temperature": TEMPERATURE,
-                "top_p": None,
-                "top_k": None,
-                **self.chat_template_kwargs,
-            },
-            "reasoning_text": reasoning_text,
-            "reasoning_raw": reasoning_raw,
-            "reasoning_token_ids": reasoning_token_ids,
-            "reasoning_token_count": len(reasoning_token_ids),
-            "reasoning_hit_limit": reasoning_hit_limit,
-            "forced": forced,
-            "forced_input_token_count": forced_input_token_count,
-        }
-
-
-class QwenVLAdapter(_TransformersVLMAdapter):
-    """Qwen3.5 (image-text-to-text): used for both the 4B and 2B checkpoints.
-
-    ``enable_thinking=False`` is required, not optional -- Qwen3.5's chat template
-    defaults to opening an unclosed ``<think>`` block before the answer, which would
-    consume the entire 16-token budget on reasoning preamble and never emit an answer.
-    """
-
-    chat_template_kwargs = {"enable_thinking": False}
-
-
-class InternVLAdapter(_TransformersVLMAdapter):
-    """InternVL3.5 (image-text-to-text).
-
-    ``crop_to_patches=False`` is required, not optional -- InternVL's default image
-    processor dynamically tiles EACH image content item into up to ~13 sub-patches at
-    448x448, meant for one high-resolution photo. Applied per FRAME (our multi-image
-    prompting, one item per frame -- see ``_numbered_content``), that explodes the
-    prompt to ~3300 tokens/frame; just 16 frames already exceeds this checkpoint's
-    40960-token context window before generation can even start. Disabling tiling
-    drops that to ~265 tokens/frame (measured: 16 frames 53401 -> 4251 tokens),
-    letting every frame count up to 96 fit comfortably. (The "correct" fix -- passing
-    frames as one native ``{"type": "video"}`` content item, which HF's own video
-    preprocessor handles at a similarly low per-frame cost without this flag -- hits
-    an unrelated shape-mismatch bug in this transformers version's InternVL vision
-    pixel-shuffle path; this is the working equivalent, not a workaround of our own
-    logic.)
-    """
-
-    chat_template_kwargs = {"crop_to_patches": False}
-
-
-_ADAPTERS = {
-    "qwen3.5-4b": QwenVLAdapter,
-    "qwen3.5-2b": QwenVLAdapter,
-    "internvl3.5-4b": InternVLAdapter,
-    "internvl3.5-2b": InternVLAdapter,
-}
-
-
-def available_models():
-    """Return registered model names in stable order."""
-    return tuple(sorted(_ADAPTERS))
-
-
-def get_adapter(model):
-    """Create one unloaded adapter bound to a registered model's checkpoint path."""
-    adapter_type = _ADAPTERS.get(model)
-    if adapter_type is None:
-        raise KeyError(
-            f"unknown harness model {model!r}; expected one of {available_models()}"
-        )
-    return adapter_type(MODEL_PATHS[model])

harness/A/prompts.py

@@ -1,58 +0,0 @@
-"""VSI-Bench prompt construction with the shared step-by-step reasoning instruction.
-
-Keeps lmms_eval's question-type split and final-answer constraints, but deliberately
-adds an explicit reasoning instruction before the final-answer line.
-"""
-
-from __future__ import annotations
-
-# Verbatim from thinking-in-space/lmms_eval/tasks/vsibench/utils.py.
-MCA_QUESTION_TYPES = (
-    "object_rel_direction_easy",
-    "object_rel_direction_medium",
-    "object_rel_direction_hard",
-    "object_rel_distance",
-    "route_planning",
-    "obj_appearance_order",
-)
-NA_QUESTION_TYPES = (
-    "object_abs_distance",
-    "object_counting",
-    "object_size_estimation",
-    "room_size_estimation",
-)
-
-# vsibench.yaml lmms_eval_specific_kwargs.default. pre_prompt is "" in the yaml, which
-# the original doc_to_text treats as falsy and falls back to this text -- so this is
-# the pre_prompt every non-API (incl. local HF) model is actually scored under.
-PRE_PROMPT = "These are frames of a video."
-VIDEO_PRE_PROMPT = "This is a video."
-STEP_BY_STEP_REASONING_PROMPT = "Think step by step and explain your reasoning briefly before giving the final answer."
-NA_POST_PROMPT = "Please answer the question using a single word or phrase."
-MCA_POST_PROMPT = "Answer with the option's letter from the given choices directly."
-
-
-def build_prompt(question_type, question, options=None, video=False):
-    """Return one VSI-Bench prompt with the shared reasoning instruction."""
-    pre_prompt = VIDEO_PRE_PROMPT if video else PRE_PROMPT
-    if question_type in NA_QUESTION_TYPES:
-        return "\n".join(
-            [pre_prompt, question, STEP_BY_STEP_REASONING_PROMPT, NA_POST_PROMPT]
-        )
-    if question_type in MCA_QUESTION_TYPES:
-        if not options:
-            raise ValueError(f"question_type {question_type!r} requires options")
-        options_block = "Options:\n" + "\n".join(options)
-        return "\n".join(
-            [
-                pre_prompt,
-                question,
-                options_block,
-                STEP_BY_STEP_REASONING_PROMPT,
-                MCA_POST_PROMPT,
-            ]
-        )
-    raise ValueError(
-        f"unknown question_type {question_type!r}; "
-        f"expected one of {MCA_QUESTION_TYPES + NA_QUESTION_TYPES}"
-    )

harness/A/run.py

@@ -1,419 +0,0 @@
-"""Run one VLM over VSI-Bench questions through harness A's frame sampling + adapters.
-
-Writes one JSON file per question -- the same one-file-per-question layout
-``symbolic/run.py`` uses for the spatial-code pipeline -- with the FULL, untruncated
-record: the exact prompt text sent, the cleaned and fully raw decoded response, the
-actual output token ids/count, whether the 16-token budget cut generation off before a
-natural stop, the exact generation config used, per-question latency, and full
-provenance (video path, frame indices/timestamps, device/dtype, library versions).
-Nothing here is summarized or truncated for display; printing to stdout is a separate,
-lossy convenience only.
-
-Scoring reuses the real, unmodified official scorer
-(``thinking-in-space/lmms_eval/tasks/vsibench/utils.py``), the same convention
-``symbolic/run.py`` already follows, so results here are directly comparable to those.
-"""
-
-from __future__ import annotations
-
-import argparse
-import importlib.util
-import json
-import os
-import sys
-from pathlib import Path
-
-WORKSPACE_ROOT = Path(__file__).resolve().parent.parent.parent
-if str(WORKSPACE_ROOT) not in sys.path:
-    sys.path.insert(0, str(WORKSPACE_ROOT))
-
-import inference as inference_config  # noqa: E402
-from harness.A import (  # noqa: E402
-    DEFAULT_FRAME_SELECTION,
-    EXTENDED_MAX_NEW_TOKENS,
-    FRAME_SELECTIONS,
-    FRAMES_PER_VIDEO,
-    JSONL,
-    MAX_NEW_TOKENS,
-    RESULTS_DIR,
-)
-from harness.A import frames as frame_sampling  # noqa: E402
-from harness.A import models as vlm_models  # noqa: E402
-from harness.A import (
-    protocol_for_question,
-    question_group,
-    resolve_protocol_budgets,
-)  # noqa: E402
-from harness.A import prompts as vsi_prompts  # noqa: E402
-
-_OFFICIAL_EVAL = os.environ.get(
-    "HARNESS_OFFICIAL_EVAL",
-    "/root/data/thinking-in-space/lmms_eval/tasks/vsibench/utils.py",
-)
-
-
-def _load_official_eval(path):
-    # Loaded under a unique module name (not the bare "utils" symbolic/run.py itself
-    # uses) so the two never fight over sys.modules["utils"] when both are imported in
-    # the same process, e.g. across the test suite.
-    spec = importlib.util.spec_from_file_location("harness_A_vsi_official_eval", path)
-    module = importlib.util.module_from_spec(spec)
-    spec.loader.exec_module(module)
-    return module
-
-
-vsi_official_eval = _load_official_eval(_OFFICIAL_EVAL)
-
-
-def _scalar_score(question_type, score_doc):
-    """Return (metric_name, value) -- the one numeric metric attached by the scorer."""
-    if question_type in vsi_official_eval.MCA_QUESTION_TYPES:
-        metric_keys = vsi_official_eval.METRICS_FOR_MCA
-    elif question_type in vsi_official_eval.NA_QUESTION_TYPES:
-        metric_keys = vsi_official_eval.METRICS_FOR_NA
-    else:
-        raise ValueError(
-            f"unknown question_type {question_type!r}; "
-            f"expected one of {vsi_official_eval.MCA_QUESTION_TYPES + vsi_official_eval.NA_QUESTION_TYPES}"
-        )
-    (metric_key,) = metric_keys.keys()
-    return metric_key, score_doc[metric_key]
-
-
-def load_questions(jsonl_path=None, scene=None, scenes=None, limit=None):
-    """Return VSI-Bench question rows, optionally filtered to one/many scenes / capped."""
-    if scene is not None and scenes is not None:
-        raise ValueError("scene and scenes cannot both be given")
-    allowed = (
-        {scene} if scene is not None else (set(scenes) if scenes is not None else None)
-    )
-    jsonl_path = jsonl_path or JSONL
-    rows = []
-    with open(jsonl_path) as stream:
-        for line in stream:
-            row = json.loads(line)
-            if allowed is not None and row["scene_name"] not in allowed:
-                continue
-            rows.append(row)
-            if limit is not None and len(rows) >= limit:
-                break
-    return rows
-
-
-def results_dir_for(model, protocol, frame_selection, frame_count, results_dir=None):
-    """Return the result root isolated by model + protocol + frame-selection +
-    frame-count. ``protocol`` is "base" (16-token) or "<reasoning budget>"
-    (e.g. "512") -- a real path segment, so records from different protocols
-    OR different reasoning budgets can never collide on disk."""
-    if results_dir is not None:
-        return Path(results_dir)
-    root = RESULTS_DIR / model
-    if frame_selection == "video":
-        return root / "video"
-    return root / frame_selection / str(frame_count)
-
-
-def _build_record(
-    row, prompt, answer, metric_name, score, model, model_path, frame_info
-):
-    """Assemble one question's full, untruncated result record (nothing summarized)."""
-    return {
-        "model": model,
-        "model_path": str(model_path),
-        "device": answer["device"],
-        "dtype": answer["dtype"],
-        "library_versions": answer["library_versions"],
-        "condition": (
-            f"{frame_info['protocol']}:video"
-            if frame_info["frame_selection"] == "video"
-            else (
-                f"{frame_info['protocol']}:{frame_info['frame_selection']}:"
-                f"{frame_info['frame_count']}"
-            )
-        ),
-        "protocol": frame_info["protocol"],
-        "question_group": question_group(row["question_type"]),
-        "frame_selection": frame_info["frame_selection"],
-        "frame_count": frame_info["frame_count"],
-        "video_path": frame_info["video_path"],
-        "frame_indices": frame_info["frame_indices"],
-        "frame_timestamps_seconds": frame_info["frame_timestamps"],
-        "scene": row["scene_name"],
-        "dataset": row.get("dataset"),
-        "question_id": row["id"],
-        "question_type": row["question_type"],
-        "question": row["question"],
-        "options": row.get("options"),
-        "full_prompt": prompt,
-        "rendered_prompt": answer["prompt_text"],
-        "answer_expected": row["ground_truth"],
-        "answer_given": answer["answer_text"],
-        "answer_raw": answer["answer_raw"],
-        "input_token_count": answer["input_token_count"],
-        "vision_input_shapes": answer["vision_input_shapes"],
-        "output_token_ids": answer["output_token_ids"],
-        "output_token_count": answer["output_token_count"],
-        "hit_token_limit": answer["hit_token_limit"],
-        "eos_token_ids": answer["eos_token_ids"],
-        "generation_seconds": answer["generation_seconds"],
-        "generation_config": answer["generation_config"],
-        "reasoning_text": answer.get("reasoning_text"),
-        "reasoning_raw": answer.get("reasoning_raw"),
-        "reasoning_token_ids": answer.get("reasoning_token_ids"),
-        "reasoning_token_count": answer.get("reasoning_token_count"),
-        "reasoning_hit_limit": answer.get("reasoning_hit_limit"),
-        "forced": answer.get("forced", False),
-        "forced_input_token_count": answer.get("forced_input_token_count"),
-        "metric": metric_name,
-        "score": score,
-    }
-
-
-def write_question_result(
-    row,
-    prompt,
-    answer,
-    metric_name,
-    score,
-    model,
-    model_path,
-    frame_info,
-    results_dir=None,
-):
-    """Write one question's full, untruncated result record. Return (path, record)."""
-    record = _build_record(
-        row, prompt, answer, metric_name, score, model, model_path, frame_info
-    )
-    root = results_dir_for(
-        model,
-        frame_info["protocol"],
-        frame_info["frame_selection"],
-        frame_info["frame_count"],
-        results_dir,
-    )
-    scene_dir = root / record["scene"]
-    scene_dir.mkdir(parents=True, exist_ok=True)
-    path = scene_dir / f"{row['id']}.json"
-    with path.open("w", encoding="utf-8") as stream:
-        json.dump(record, stream, indent=1)
-    return path, record
-
-
-def run(
-    model,
-    frame_selection=DEFAULT_FRAME_SELECTION,
-    frame_count=FRAMES_PER_VIDEO,
-    video=False,
-    scene=None,
-    scenes=None,
-    limit=None,
-    device="cuda",
-    jsonl_path=None,
-    results_dir=None,
-    write_results=True,
-    adapter=None,
-    extended=True,
-    reasoning_budget=EXTENDED_MAX_NEW_TOKENS,
-    force_budget=MAX_NEW_TOKENS,
-):
-    """Answer every matching question with one model, scored via the official scorer.
-
-    Each question's full record is written to its own JSON file as soon as it is
-    answered (unless ``write_results=False``); the in-memory list returned holds the
-    same full records for callers that want them without re-reading from disk.
-
-    Pass a pre-loaded ``adapter`` (as ``harness.A.launch``'s persistent per-GPU workers
-    do) to reuse one already-loaded model across many calls instead of paying the load
-    cost per call; the caller then owns unloading it. Without one, ``run`` loads and
-    unloads its own adapter, same as before.
-
-    ``extended=True`` uses ``adapter.answer_extended`` -- a larger first-pass
-    budget (``reasoning_budget``) with a short forced second call only if the model
-    does not conclude within it. The complete visible first-pass response is stored
-    in ``reasoning_text`` and ``reasoning_raw``.
-    """
-    if video:
-        frame_selection = "video"
-        frame_count = None
-    elif frame_count is None or frame_count < 1:
-        raise ValueError("frame_count must be positive in frames mode")
-    rows = load_questions(jsonl_path, scene, scenes, limit)
-    if not rows:
-        return []
-    owns_adapter = adapter is None
-    if owns_adapter:
-        adapter = vlm_models.get_adapter(model)
-        adapter.load_model(device)
-    frame_cache = {}
-    results = []
-    try:
-        for row in rows:
-            protocol = protocol_for_question(row["question_type"])
-            scene_id = row["scene_name"]
-            if scene_id not in frame_cache:
-                video_path = inference_config.video_path(scene_id, row.get("dataset"))
-                if video:
-                    frame_images = video_path
-                    frame_timestamps = None
-                    frame_indices = None
-                else:
-                    frame_images, frame_timestamps, frame_indices = (
-                        frame_sampling.sample_frames(
-                            video_path, frame_count, frame_selection
-                        )
-                    )
-                frame_cache[scene_id] = {
-                    "video_path": video_path,
-                    "frame_images": frame_images,
-                    "frame_timestamps": frame_timestamps,
-                    "frame_indices": frame_indices,
-                    "frame_selection": frame_selection,
-                    "frame_count": frame_count,
-                }
-            cached = frame_cache[scene_id]
-            prompt = vsi_prompts.build_prompt(
-                row["question_type"], row["question"], row.get("options"), video=video
-            )
-            answer = (
-                adapter.answer_extended(
-                    cached["frame_images"],
-                    prompt,
-                    reasoning_budget=reasoning_budget,
-                    force_budget=force_budget,
-                )
-                if protocol == "thinking"
-                else adapter.answer(
-                    cached["frame_images"], prompt, max_new_tokens=MAX_NEW_TOKENS
-                )
-            )
-            doc = {
-                "question_type": row["question_type"],
-                "ground_truth": row["ground_truth"],
-            }
-            score_doc = vsi_official_eval.vsibench_process_results(
-                doc, [answer["answer_text"]]
-            )["vsibench_score"]
-            metric_name, score = _scalar_score(row["question_type"], score_doc)
-            frame_info = {
-                "protocol": protocol,
-                "video_path": cached["video_path"],
-                "frame_timestamps": cached["frame_timestamps"],
-                "frame_indices": cached["frame_indices"],
-                "frame_selection": frame_selection,
-                "frame_count": frame_count,
-            }
-            if write_results:
-                path, record = write_question_result(
-                    row,
-                    prompt,
-                    answer,
-                    metric_name,
-                    score,
-                    model,
-                    adapter.model_path,
-                    frame_info,
-                    results_dir,
-                )
-            else:
-                path = None
-                record = _build_record(
-                    row,
-                    prompt,
-                    answer,
-                    metric_name,
-                    score,
-                    model,
-                    adapter.model_path,
-                    frame_info,
-                )
-            record["result_path"] = str(path) if path else None
-            results.append(record)
-    finally:
-        if owns_adapter:
-            adapter.unload()
-    return results
-
-
-def main():
-    parser = argparse.ArgumentParser()
-    parser.add_argument("--model", required=True, choices=vlm_models.available_models())
-    parser.add_argument("--scene", default=None, help="restrict to one VSI-Bench scene")
-    parser.add_argument(
-        "--frame-selection",
-        default=None,
-        choices=FRAME_SELECTIONS,
-        dest="frame_selection",
-    )
-    input_mode = parser.add_mutually_exclusive_group(required=True)
-    input_mode.add_argument("--frames", type=int)
-    input_mode.add_argument("--video", action="store_true")
-    parser.add_argument(
-        "--limit", type=int, default=None, help="cap the number of questions"
-    )
-    parser.add_argument("--device", default="cuda")
-    parser.add_argument(
-        "--results-dir",
-        default=None,
-        help="override the default results/A/<model>/{<selection>/<frames>|video} root",
-    )
-    parser.add_argument(
-        "--no-write",
-        action="store_true",
-        help="skip writing per-question JSON files; print/score only",
-    )
-    parser.add_argument(
-        "--reasoning-budget",
-        type=int,
-        default=None,
-        help="thinking questions only (default: 2048)",
-    )
-    parser.add_argument(
-        "--force-budget",
-        type=int,
-        default=None,
-        help="thinking questions only (default: 16)",
-    )
-    args = parser.parse_args()
-    if args.video:
-        if args.frame_selection is not None:
-            parser.error("--frame-selection cannot be used with --video")
-    else:
-        if args.frame_selection is None:
-            parser.error("--frame-selection is required with --frames")
-        if args.frames < 1:
-            parser.error("--frames must be positive")
-    resolve_protocol_budgets(parser, args)
-
-    results = run(
-        args.model,
-        frame_selection=args.frame_selection,
-        frame_count=args.frames,
-        video=args.video,
-        scene=args.scene,
-        limit=args.limit,
-        device=args.device,
-        results_dir=args.results_dir,
-        write_results=not args.no_write,
-        extended=True,
-        reasoning_budget=args.reasoning_budget,
-        force_budget=args.force_budget,
-    )
-
-    for result in results:
-        print(
-            f"[{result['scene']}#{result['question_id']}] {result['question_type']}: "
-            f"pred={result['answer_given']!r} gt={result['answer_expected']!r} "
-            f"score={result['score']} ({result['generation_seconds']:.2f}s) -> "
-            f"{result['result_path']}"
-        )
-    if results:
-        mean_score = sum(r["score"] for r in results) / len(results)
-        total_seconds = sum(r["generation_seconds"] for r in results)
-        print(
-            f"\n{len(results)} questions, mean vsibench_score={mean_score:.4f}, "
-            f"total generation time={total_seconds:.1f}s"
-        )
-
-
-if __name__ == "__main__":
-    main()

harness/A/sweep.py

@@ -1,187 +0,0 @@
-"""Sweep any set of models x frame-selections x frame-counts, one command.
-
-Every (model, frame_selection, frame_count) triple in the sweep is run through
-``harness.A.launch.launch`` in turn, so each triple individually saturates every
-visible GPU (persistent per-GPU workers, one model load per worker, scenes sharded off
-a shared queue) before the next triple starts. Triples aren't run concurrently with
-each other -- each already uses every GPU on its own, so there is nothing to gain by
-overlapping them, and it keeps peak GPU memory bounded to one model at a time.
-"""
-
-from __future__ import annotations
-
-import argparse
-from pathlib import Path
-import sys
-
-HERE = Path(__file__).resolve().parent
-WORKSPACE_ROOT = HERE.parent.parent
-if str(WORKSPACE_ROOT) not in sys.path:
-    sys.path.insert(0, str(WORKSPACE_ROOT))
-
-from harness.A import EXTENDED_MAX_NEW_TOKENS, FRAME_SELECTIONS  # noqa: E402
-from harness.A import launch as harness_launch  # noqa: E402
-from harness.A import models as vlm_models  # noqa: E402
-from harness.A import resolve_protocol_budgets  # noqa: E402
-
-
-def _parse_csv_choice(value, valid, flag):
-    """Split a comma-separated ``--flag`` value; ``"all"`` expands to every ``valid``."""
-    items = [item.strip() for item in value.split(",") if item.strip()]
-    if not items:
-        raise ValueError(f"{flag} must name at least one value")
-    if len(items) == 1 and items[0].lower() == "all":
-        return list(valid)
-    unknown = [item for item in items if item not in valid]
-    if unknown:
-        raise ValueError(
-            f"unknown {flag} value(s) {unknown}; expected one of {valid} (or 'all')"
-        )
-    return list(dict.fromkeys(items))
-
-
-def _parse_frame_counts(value):
-    items = [item.strip() for item in value.split(",") if item.strip()]
-    if not items:
-        raise ValueError("--frames must name at least one frame count")
-    counts = []
-    for item in items:
-        try:
-            count = int(item)
-        except ValueError:
-            raise ValueError(f"--frames value {item!r} is not an integer") from None
-        if count < 1:
-            raise ValueError(f"--frames value {count} must be positive")
-        counts.append(count)
-    return list(dict.fromkeys(counts))
-
-
-def build_plan(models, frame_selections, frame_counts):
-    """Return every (model, frame_selection, frame_count) triple in the sweep, in a
-    stable, cheapest-first-ish order (frame count is the dominant cost driver, so
-    sorting by it surfaces comparable results across every model/selection soonest)."""
-    return [
-        (model, selection, frame_count)
-        for frame_count in sorted(frame_counts)
-        for model in models
-        for selection in frame_selections
-    ]
-
-
-def sweep(
-    models,
-    frame_selections,
-    frame_counts,
-    selected_scenes,
-    video=False,
-    results_dir=None,
-    rebuild=False,
-    extended=True,
-    reasoning_budget=EXTENDED_MAX_NEW_TOKENS,
-):
-    """Run every (model, frame_selection, frame_count) triple across all visible GPUs."""
-    plan = (
-        [(model, "video", None) for model in models]
-        if video
-        else build_plan(models, frame_selections, frame_counts)
-    )
-    for index, (model, frame_selection, frame_count) in enumerate(plan, start=1):
-        print(
-            f"=== sweep {index}/{len(plan)}: {model}/"
-            + ("video" if video else f"{frame_selection}/{frame_count}")
-            + " ===",
-            flush=True,
-        )
-        harness_launch.launch(
-            model,
-            frame_selection,
-            frame_count,
-            selected_scenes,
-            video=video,
-            results_dir=results_dir,
-            rebuild=rebuild,
-            extended=extended,
-            reasoning_budget=reasoning_budget,
-        )
-
-
-def main():
-    parser = argparse.ArgumentParser()
-    parser.add_argument("scene", nargs="?")
-    parser.add_argument(
-        "--scenes",
-        help="comma-separated scenes (cannot be combined with positional scene)",
-    )
-    parser.add_argument(
-        "--models",
-        required=True,
-        help=f"comma-separated models (or 'all'); one of {vlm_models.available_models()}",
-    )
-    parser.add_argument(
-        "--frame-selections",
-        required=False,
-        dest="frame_selections",
-        help=f"comma-separated selections (or 'all'); one of {FRAME_SELECTIONS}",
-    )
-    input_mode = parser.add_mutually_exclusive_group(required=True)
-    input_mode.add_argument(
-        "--frames", help="comma-separated frame counts, e.g. 16,32,64"
-    )
-    input_mode.add_argument("--video", action="store_true")
-    parser.add_argument("--results-dir", default=None)
-    parser.add_argument("--rebuild", action="store_true")
-    parser.add_argument(
-        "--reasoning-budget",
-        type=int,
-        default=None,
-        dest="reasoning_budget",
-        help="thinking-protocol first-pass budget (the calibrated value from "
-        "analysis/preregistration.md, e.g. 512)",
-    )
-    args = parser.parse_args()
-    resolve_protocol_budgets(parser, args)
-    if args.scene and args.scenes:
-        parser.error("positional scene and --scenes cannot be used together")
-
-    try:
-        models = _parse_csv_choice(
-            args.models, vlm_models.available_models(), "--models"
-        )
-        if args.video:
-            if args.frame_selections is not None:
-                raise ValueError("--frame-selections cannot be used with --video")
-            frame_selections = ["video"]
-            frame_counts = [None]
-        else:
-            if args.frame_selections is None:
-                raise ValueError("--frame-selections is required with --frames")
-            frame_selections = _parse_csv_choice(
-                args.frame_selections, FRAME_SELECTIONS, "--frame-selections"
-            )
-            frame_counts = _parse_frame_counts(args.frames)
-    except ValueError as exc:
-        parser.error(str(exc))
-
-    if args.scenes is not None:
-        selected = [scene.strip() for scene in args.scenes.split(",") if scene.strip()]
-        if not selected:
-            parser.error("--scenes must contain at least one scene")
-        selected = list(dict.fromkeys(selected))
-    else:
-        selected = [args.scene] if args.scene else harness_launch.scenes()
-
-    sweep(
-        models,
-        frame_selections,
-        frame_counts,
-        selected,
-        video=args.video,
-        results_dir=args.results_dir,
-        rebuild=args.rebuild,
-        extended=True,
-        reasoning_budget=args.reasoning_budget,
-    )
-
-
-if __name__ == "__main__":
-    main()

harness/B/__init__.py

@@ -1,47 +0,0 @@
-"""Harness B: route a scene's on-disk explicit spatial code -- as TEXT,
-no video frames -- to all three models, for every VSI-Bench question.
-
-Reuses harness.A's model registry/adapters and fixed generation protocol exactly; only
-what is fed to the model differs (spatial-code text instead of frame images). Results
-are written in the identical per-question JSON shape harness.A uses, so B's records are
-directly comparable to A's -- the frame-provenance fields are simply replaced with
-spatial-code provenance fields (see harness.B.run._build_record).
-"""
-
-from __future__ import annotations
-
-import os
-from pathlib import Path
-
-from encoder.config import DEPTH_VARIANTS, TRACKING_MODES
-
-from harness.A import (
-    DO_SAMPLE,
-    JSONL,
-    MAX_NEW_TOKENS,
-    MODEL_PATHS,
-    TEMPERATURE,
-    WORKSPACE_ROOT,
-)
-
-# The harness consumes the encoder's fixed explicit spatial-code output.
-SPATIAL_CODE_FORMATS = ("explicit",)
-DEFAULT_SPATIAL_CODE_FORMAT = "explicit"
-
-# Same vocabulary as inference.SAM3_FRAME_SELECTIONS / harness.A.FRAME_SELECTIONS --
-# which raw video sampling the on-disk spatial code was itself built from.
-INPUT_SELECTIONS = ("uniform", "selective")
-DEFAULT_INPUT_SELECTION = "uniform"
-
-# Same depth/tracking vocabulary encoder.config uses to lay out spatial codes on disk --
-# real sweepable axes here too (see sweep.py's --depths/--trackings), not fixed
-# constants; DEFAULT_DEPTH/DEFAULT_TRACKING are just the single-value default when a
-# caller doesn't ask to sweep them, matching this workspace's shipped production config.
-DEFAULT_DEPTH = "metric"
-DEFAULT_TRACKING = "tracking"
-
-FRAMES_PER_VIDEO = int(os.environ.get("VSI_HARNESS_B_FRAMES_PER_VIDEO", "32"))
-
-# One JSON per question, matching harness.A's layout:
-# results/B/<model>/<spatial_code_format>/<depth>/<tracking>/<input_selection>/<frame_count>/<scene>/<question_id>.json
-RESULTS_DIR = Path(os.environ.get("VSI_HARNESS_B_RESULTS_DIR", "/root/results/B"))

harness/B/launch.py

@@ -1,309 +0,0 @@
-"""Keep every visible GPU busy with persistent harness-B inference workers.
-
-Same shape as ``harness.A.launch``: one persistent worker process per visible GPU,
-pulling scenes off a shared queue, each loading its model exactly once and reusing it
-for every scene it's assigned (via ``run.run(..., adapter=...)``). One invocation covers
-one (model, spatial_code_format, input_selection, frame_count) quadruple across every
-requested scene; sweep multiple quadruples by invoking this once per quadruple (see
-harness.B.sweep, or a shell loop).
-"""
-
-from __future__ import annotations
-
-import argparse
-import importlib.util
-import multiprocessing as mp
-import os
-from pathlib import Path
-import sys
-import traceback
-
-HERE = Path(__file__).resolve().parent
-WORKSPACE_ROOT = HERE.parent.parent
-if str(WORKSPACE_ROOT) not in sys.path:
-    sys.path.insert(0, str(WORKSPACE_ROOT))
-
-from harness.A import EXTENDED_MAX_NEW_TOKENS, MAX_NEW_TOKENS  # noqa: E402
-from harness.A import models as vlm_models  # noqa: E402
-from harness.A import resolve_protocol_budgets  # noqa: E402
-from harness.A.launch import scenes  # noqa: E402
-from harness.B import (  # noqa: E402
-    DEFAULT_DEPTH,
-    DEFAULT_INPUT_SELECTION,
-    DEFAULT_SPATIAL_CODE_FORMAT,
-    DEFAULT_TRACKING,
-    DEPTH_VARIANTS,
-    FRAMES_PER_VIDEO,
-    INPUT_SELECTIONS,
-    TRACKING_MODES,
-)
-from inference.launch import available_cpu_count, visible_gpus  # noqa: E402
-
-
-def _load_run_module():
-    spec = importlib.util.spec_from_file_location("_harness_B_run", HERE / "run.py")
-    module = importlib.util.module_from_spec(spec)
-    sys.modules[spec.name] = module
-    spec.loader.exec_module(module)
-    return module
-
-
-def _worker(
-    tasks,
-    results,
-    model,
-    spatial_code_format,
-    input_selection,
-    frame_count,
-    video,
-    depth,
-    tracking,
-    results_dir,
-    gpu,
-    cpu_threads,
-    extended,
-    reasoning_budget,
-    force_budget,
-    question_ids,
-):
-    if gpu is not None:
-        os.environ["CUDA_VISIBLE_DEVICES"] = str(gpu)
-    for variable in ("OMP_NUM_THREADS", "MKL_NUM_THREADS", "OPENBLAS_NUM_THREADS"):
-        os.environ[variable] = str(cpu_threads)
-    run = _load_run_module()
-    adapter = None
-    load_error = None
-    try:
-        adapter = vlm_models.get_adapter(model)
-        adapter.load_model("cuda:0" if gpu is not None else "cpu")
-    except Exception:
-        load_error = traceback.format_exc()
-    while True:
-        scene = tasks.get()
-        if scene is None:
-            return
-        if load_error is not None:
-            results.put((scene, False, load_error))
-            continue
-        try:
-            answered = run.run(
-                model,
-                spatial_code_format=spatial_code_format,
-                input_selection=input_selection,
-                frame_count=frame_count,
-                video=video,
-                depth=depth,
-                tracking=tracking,
-                scene=scene,
-                results_dir=results_dir,
-                adapter=adapter,
-                extended=extended,
-                reasoning_budget=reasoning_budget,
-                force_budget=force_budget,
-                question_ids=question_ids,
-            )
-            # thinking is applied on the adapter above, not passed to run() -- the
-            # worker owns the adapter, run() must not re-toggle it.
-            mean_score = (
-                sum(r["score"] for r in answered) / len(answered) if answered else None
-            )
-            results.put(
-                (scene, True, f"{len(answered)} question(s), mean_score={mean_score}")
-            )
-        except Exception:
-            results.put((scene, False, traceback.format_exc()))
-
-
-def launch(
-    model,
-    spatial_code_format,
-    input_selection,
-    frame_count,
-    selected,
-    video=False,
-    depth=DEFAULT_DEPTH,
-    tracking=DEFAULT_TRACKING,
-    results_dir=None,
-    rebuild=False,
-    extended=True,
-    reasoning_budget=EXTENDED_MAX_NEW_TOKENS,
-    force_budget=MAX_NEW_TOKENS,
-    question_ids=None,
-):
-    """Answer every question for ``selected`` scenes, sharded across every visible GPU.
-    ``question_ids``, when given, restricts every scene to that question subset."""
-    if video:
-        input_selection = "video"
-        frame_count = None
-    elif frame_count is None or frame_count < 1:
-        raise ValueError("frame_count must be positive in frames mode")
-    mode = "video" if video else f"{input_selection}/{frame_count}"
-    condition = f"{model}/{spatial_code_format}/{depth}/{tracking}/{mode}"
-    run = _load_run_module()
-    root = run.results_dir_for(
-        model,
-        None,
-        spatial_code_format,
-        depth,
-        tracking,
-        input_selection,
-        frame_count,
-        results_dir,
-    )
-    pending = []
-    completed = 0
-    for scene in selected:
-        rows = run.load_questions(scene=scene)
-        if question_ids is not None:
-            rows = [row for row in rows if row["id"] in question_ids]
-        if not rows:
-            raise ValueError(
-                f"no questions found for scene {scene!r}; check the manifest, scene selection, or question_ids"
-            )
-        answered = all((root / scene / f"{row['id']}.json").is_file() for row in rows)
-        if answered and not rebuild:
-            completed += 1
-            print(
-                f"[{condition} {completed}/{len(selected)}] {scene}: skipped",
-                flush=True,
-            )
-        else:
-            pending.append(scene)
-    if not pending:
-        print(f"[{condition}] DONE: {len(selected)} ok, 0 failed")
-        return
-
-    gpus = visible_gpus()
-    worker_count = min(len(pending), len(gpus) if gpus else 1)
-    assignments = gpus[:worker_count] if gpus else [None]
-    cpu_count = available_cpu_count()
-    cpu_threads = max(1, cpu_count // worker_count)
-    print(
-        f"[{condition}] starting {worker_count} persistent worker(s); "
-        f"GPUs={assignments}; CPU threads/worker={cpu_threads}",
-        flush=True,
-    )
-
-    context = mp.get_context("spawn")
-    tasks, results = context.Queue(), context.Queue()
-    for scene in pending:
-        tasks.put(scene)
-    for _ in range(worker_count):
-        tasks.put(None)
-    workers = [
-        context.Process(
-            target=_worker,
-            args=(
-                tasks,
-                results,
-                model,
-                spatial_code_format,
-                input_selection,
-                frame_count,
-                video,
-                depth,
-                tracking,
-                results_dir,
-                gpu,
-                cpu_threads,
-                extended,
-                reasoning_budget,
-                force_budget,
-                question_ids,
-            ),
-        )
-        for gpu in assignments
-    ]
-    for worker in workers:
-        worker.start()
-    failed = []
-    for finished in range(1, len(pending) + 1):
-        scene, ok, detail = results.get()
-        if not ok:
-            failed.append(scene)
-        print(
-            f"[{condition} {completed + finished}/{len(selected)}] {scene}: "
-            f"{'done' if ok else 'FAILED'}\n{detail}",
-            flush=True,
-        )
-    for worker in workers:
-        worker.join()
-    print(
-        f"[{condition}] DONE: {len(pending) - len(failed)} answered, {completed} skipped, "
-        f"{len(failed)} failed"
-    )
-    if failed:
-        raise SystemExit(1)
-
-
-def main():
-    parser = argparse.ArgumentParser()
-    parser.add_argument("scene", nargs="?")
-    parser.add_argument(
-        "--scenes",
-        help="comma-separated scenes (cannot be combined with positional scene)",
-    )
-    parser.add_argument("--model", required=True, choices=vlm_models.available_models())
-    parser.add_argument(
-        "--input-selection",
-        default=None,
-        choices=INPUT_SELECTIONS,
-        dest="input_selection",
-    )
-    input_mode = parser.add_mutually_exclusive_group(required=True)
-    input_mode.add_argument("--frames", type=int)
-    input_mode.add_argument("--video", action="store_true")
-    parser.add_argument("--depth", default=DEFAULT_DEPTH, choices=DEPTH_VARIANTS)
-    parser.add_argument("--tracking", default=DEFAULT_TRACKING, choices=TRACKING_MODES)
-    parser.add_argument("--results-dir", default=None)
-    parser.add_argument("--rebuild", action="store_true")
-    parser.add_argument(
-        "--reasoning-budget",
-        type=int,
-        default=None,
-        help="thinking mode only (default: 2048)",
-    )
-    parser.add_argument(
-        "--force-budget",
-        type=int,
-        default=None,
-        help="thinking mode only (default: 16)",
-    )
-    args = parser.parse_args()
-    if args.scene and args.scenes:
-        parser.error("positional scene and --scenes cannot be used together")
-    if args.scenes is not None:
-        selected = [scene.strip() for scene in args.scenes.split(",") if scene.strip()]
-        if not selected:
-            parser.error("--scenes must contain at least one scene")
-        selected = list(dict.fromkeys(selected))
-    else:
-        selected = [args.scene] if args.scene else scenes()
-    if args.video:
-        if args.input_selection is not None:
-            parser.error("--input-selection cannot be used with --video")
-    else:
-        if args.input_selection is None:
-            parser.error("--input-selection is required with --frames")
-        if args.frames < 1:
-            parser.error("--frames must be positive")
-    resolve_protocol_budgets(parser, args)
-    launch(
-        args.model,
-        DEFAULT_SPATIAL_CODE_FORMAT,
-        args.input_selection,
-        args.frames,
-        selected,
-        video=args.video,
-        depth=args.depth,
-        tracking=args.tracking,
-        results_dir=args.results_dir,
-        rebuild=args.rebuild,
-        extended=True,
-        reasoning_budget=args.reasoning_budget,
-        force_budget=args.force_budget,
-    )
-
-
-if __name__ == "__main__":
-    main()

harness/B/prompts.py

@@ -1,523 +0,0 @@
-"""VSI-Bench prompt construction for spatial-code inputs.
-
-There is one active spatial-code prompt: v2 legend + v2 prompt-facing code JSON,
-followed by the VSI question/options shape and the harness step-by-step instruction.
-"""
-
-from __future__ import annotations
-
-import copy
-import itertools
-import json
-
-from harness.A.prompts import (
-    MCA_POST_PROMPT,
-    MCA_QUESTION_TYPES,
-    NA_POST_PROMPT,
-    NA_QUESTION_TYPES,
-    STEP_BY_STEP_REASONING_PROMPT,
-)
-
-_CCF = "closest_classes_from"
-_CCF_L2 = "closest classes distance meters from"
-_CCF_L1 = "minimum distance between classes"
-
-_HEAD = (
-    "Below is the spatial code of a scanned room. It is a JSON description of the room, "
-    "built automatically from a video walkthrough."
-)
-_UNITS_NOTE = (
-    "Every value below that is a physical measurement is written as a STRING that "
-    'already names its own unit, such as "1.46 meters", "3.0 seconds", or "91 '
-    'degrees" -- so a field\'s name does not repeat the unit.'
-)
-
-
-def _m(value):
-    return f"{value} meters"
-
-
-def _s(value):
-    return f"{value} seconds"
-
-
-def _deg(value):
-    return f"{value} degrees"
-
-
-def _fr(value):
-    return f"{value} frames"
-
-
-def _unit_strings(code):
-    def pos(point):
-        return {
-            "x coordinate": _m(point["floor_x_meters"]),
-            "y coordinate": _m(point["floor_y_meters"]),
-            "height above floor": _m(point["height_above_floor_meters"]),
-        }
-
-    for object_class in code.get("objects", {}).values():
-        for instance in object_class.get("instances", ()):
-            if "position" in instance:
-                instance["position"] = pos(instance["position"])
-            if "bounding_box" in instance:
-                box = instance.pop("bounding_box")
-                instance["bounding box"] = {
-                    "x coordinate": [_m(v) for v in box["floor_x_meters"]],
-                    "y coordinate": [_m(v) for v in box["floor_y_meters"]],
-                    "height above floor": [_m(v) for v in box["height_above_floor_meters"]],
-                }
-            if "dimensions_meters" in instance:
-                instance["dimensions"] = [_m(v) for v in instance.pop("dimensions_meters")]
-            if "longest_dimension_meters" in instance:
-                instance["longest dimension"] = _m(instance.pop("longest_dimension_meters"))
-            if "seen_in_video_frames" in instance:
-                instance["seen in video"] = _fr(instance.pop("seen_in_video_frames"))
-    if "room" in code:
-        if "outline" in code["room"]:
-            code["room"]["outline"] = [
-                {
-                    "x coordinate": _m(point["floor_x_meters"]),
-                    "y coordinate": _m(point["floor_y_meters"]),
-                }
-                for point in code["room"]["outline"]
-            ]
-        if "floor_area_square_meters" in code["room"]:
-            code["room"]["floor area"] = f"{code['room'].pop('floor_area_square_meters')} square meters"
-    if "camera_trajectory" in code:
-        camera = code.pop("camera_trajectory")
-        for waypoint in camera.get("waypoints", ()):
-            if "time_seconds" in waypoint:
-                waypoint["time"] = _s(waypoint.pop("time_seconds"))
-            if "floor_x_meters" in waypoint:
-                waypoint["x coordinate"] = _m(waypoint.pop("floor_x_meters"))
-            if "floor_y_meters" in waypoint:
-                waypoint["y coordinate"] = _m(waypoint.pop("floor_y_meters"))
-            if "heading_degrees" in waypoint:
-                waypoint["heading"] = _deg(waypoint.pop("heading_degrees"))
-        if "sample_interval_seconds" in camera:
-            camera["sample interval seconds"] = camera.pop("sample_interval_seconds")
-        code["camera trajectory"] = camera
-    if _CCF_L2 in code:
-        for neighbors in code[_CCF_L2].values():
-            for entry in neighbors.values():
-                if "distance_meters" in entry:
-                    entry["distance"] = _m(entry.pop("distance_meters"))
-                if "closeness_rank" in entry:
-                    entry["closeness rank"] = entry.pop("closeness_rank")
-    if "appearance_order" in code:
-        code["appearance order"] = code.pop("appearance_order")
-    return code
-
-
-def ablate(code, level, evidence=True):
-    """Return prompt-facing spatial code at level 0, 1, or 2."""
-    code = copy.deepcopy(code)
-    code.pop("spatial code schema", None)
-    if not evidence:
-        for object_class in code.get("objects", {}).values():
-            for instance in object_class.get("instances", ()):
-                instance.pop("seen_in_video_frames", None)
-    if level == 2:
-        if _CCF in code:
-            code[_CCF_L2] = code.pop(_CCF)
-        return _unit_strings(code)
-
-    code.pop("appearance order", None)
-    code.pop("appearance_order", None)
-    ccf = code.pop(_CCF, None)
-    if ccf is not None:
-        classes = sorted(ccf)
-        code[_CCF_L1] = {
-            f"{a} to {b}": f"{ccf[a][b]['distance_meters']} meters"
-            for a, b in itertools.combinations(classes, 2)
-            if b in ccf.get(a, {})
-        }
-    if level == 1:
-        code.pop("camera_trajectory", None)
-        if "room" in code:
-            code["room"].pop("outline", None)
-        for object_class in code.get("objects", {}).values():
-            for instance in object_class.get("instances", ()):
-                instance.pop("bounding_box", None)
-                instance.pop("dimensions_meters", None)
-        return _unit_strings(code)
-
-    if level != 0:
-        raise ValueError(f"unknown ablation level {level!r}; expected 0, 1, or 2")
-    if "room" in code:
-        code["room"].pop("floor_area_square_meters", None)
-    code.pop(_CCF_L1, None)
-    for object_class in code.get("objects", {}).values():
-        object_class.pop("count", None)
-        for instance in object_class.get("instances", ()):
-            instance.pop("longest_dimension_meters", None)
-    return _unit_strings(code)
-
-
-def _objects_par(level, evidence):
-    paragraph = (
-        "The objects section lists, for every object class, the individual objects that were "
-        'detected in the room. Each object has a position given as "x coordinate", "y '
-        'coordinate" and "height above floor": x coordinate is the object\'s distance along '
-        "one fixed horizontal direction of the room, y coordinate is the object's distance "
-        "along a second fixed horizontal direction perpendicular to the first, and height "
-        "above floor is the object's vertical distance above the floor; these directions are "
-        "the same for everything in the room."
-    )
-    if level != 1:
-        paragraph += (
-            ' Each object also has a "bounding box" giving a minimum and a maximum value '
-            "along each of x coordinate, y coordinate and height above floor, marking the "
-            "full extent of the object. Each object also has dimensions, the object's three "
-            "side lengths, measured along the object's own axes and listed from longest to shortest."
-        )
-    if level >= 1:
-        paragraph += (
-            " Each object class also has a count, the number of objects of that class that "
-            'are in the room. Each object also has a "longest dimension", the length of '
-            "that object's single longest side"
-            + (" (the largest of its dimensions)" if level != 1 else "")
-            + "."
-        )
-    if evidence:
-        paragraph += (
-            ' Each object also has "seen in video", the number of video frames in which '
-            "that object was detected."
-        )
-    return paragraph
-
-
-def _room_par(level):
-    paragraph = "The room section describes the room as a whole."
-    if level != 1:
-        paragraph += (
-            " It has an outline giving the shape of the room's floor as a polygon: a list of "
-            "corner points that, connected in order, trace the boundary of the room, and each "
-            "corner point is given as x coordinate and y coordinate."
-        )
-    if level >= 1:
-        paragraph += ' The room also has a "floor area", the total floor area of the room.'
-    return paragraph
-
-
-def _camera_par():
-    return (
-        'The "camera trajectory" lists waypoints along the path the recording camera moved '
-        "through the room while filming: each waypoint gives a time, the camera's location "
-        "at that time as x coordinate and y coordinate, and the direction the camera was "
-        "facing at that time as a heading."
-    )
-
-
-def _distance_par(level):
-    if level == 0:
-        return ""
-    if level == 1:
-        return (
-            'The "minimum distance between classes" section gives the minimum distance '
-            'between every pair of object classes: each key names two classes as "A to B", '
-            "and its value is the distance between the closest points of those two classes. "
-            'Each pair appears once; a pair may be listed as either "A to B" or "B to A", '
-            "so check both when looking one up."
-        )
-    return (
-        'The "closest classes distance meters from" section gives, for every object class, '
-        "an entry for each other class containing a distance, the distance between the "
-        'closest points of the two classes, and a "closeness rank", which orders the other '
-        "classes by their nearness to the class the entry is listed under, from the nearest, "
-        "rank 1, to the farthest, the largest rank."
-    )
-
-
-def _appearance_par(level):
-    if level < 2:
-        return ""
-    return (
-        'The "appearance order" section lists every object class in the order it first '
-        "appeared in the video, earliest first -- just the class names, already sorted; "
-        "there is no timestamp to read, only the order itself."
-    )
-
-
-def _dir_base(level):
-    text = (
-        "To compute the number of objects of a class: go to the objects section, find the "
-        "class by its name, and count the entries in its instances list.\n"
-    )
-    if level != 1:
-        text += (
-            "To compute the size of an object: read its dimensions, the object's three side "
-            "lengths, and take the largest; that is its longest side.\n"
-            "To compute the size of the room: work out the area of the polygon formed by the "
-            "room's outline corner points.\n"
-            'To compute the distance between two objects: for each of the three axes take the '
-            'gap between their "bounding box" ranges (zero if they overlap, otherwise the '
-            "distance between the nearer edges), then square the three gaps, add them, and "
-            "take the square root.\n"
-        )
-    text += (
-        'To compute the order in which classes appeared: use "appearance order" when it is '
-        "present; otherwise use the video frames."
-    )
-    return text
-
-
-def _dir_l1_add(level):
-    if level == 1:
-        distance_text = (
-            'To read the distance between two classes directly: find their pair in "minimum '
-            'distance between classes" -- check both "A to B" and "B to A" -- and read off '
-            "its value.\n"
-            "To read which of several named classes is closest to a class X directly: look up "
-            'each candidate\'s pair with X in "minimum distance between classes" and pick the '
-            "smallest distance."
-        )
-    else:
-        distance_text = (
-            'To read the distance between two classes directly: in "closest classes distance '
-            'meters from", one class\'s entry for the other has a distance, the distance '
-            "between the closest points of the two classes.\n"
-            "To read which of several named classes is closest to a class X directly: compare "
-            'their distance under "closest classes distance meters from"[X] and pick the smallest.'
-        )
-    return (
-        "To read the number of objects of a class directly: its count is the number of objects "
-        "of that class that are in the room.\n"
-        'To read the size of an object directly: its "longest dimension" is the length of '
-        "its single longest side.\n"
-        'To read the size of the room directly: its "floor area" is the total floor area of '
-        "the room.\n"
-        + distance_text
-    )
-
-
-_DIR_L2_ADD = (
-    'To read the ranking of the classes by their nearness to a class X directly: in "closest '
-    'classes distance meters from"[X], each entry\'s "closeness rank" orders the other classes '
-    "by their nearness to X, from the nearest, rank 1, to the farthest, the largest rank; to "
-    "find the closest of several named classes pick the one with the smallest rank, comparing "
-    "only the classes named in the question.\n"
-    'To read the order in which the classes appeared directly: "appearance order" lists every '
-    "class already sorted from the earliest to the latest, so read it from top to bottom."
-)
-
-
-def _directions(level):
-    text = "How to use the spatial code to answer the question.\n" + _dir_base(level)
-    if level >= 1:
-        text += "\n" + _dir_l1_add(level)
-    if level >= 2:
-        text += "\n" + _DIR_L2_ADD
-    return text
-
-
-def legend(level=2, prompt_level=1, evidence=True):
-    paragraphs = [
-        _HEAD,
-        _UNITS_NOTE,
-        _objects_par(level, evidence),
-        _room_par(level),
-        _camera_par() if level != 1 else "",
-        _distance_par(level),
-        _appearance_par(level),
-    ]
-    if prompt_level >= 1:
-        paragraphs.append(_directions(level))
-    return "\n\n".join(paragraph for paragraph in paragraphs if paragraph)
-
-
-LEGENDS = {0: legend(0), 1: legend(1), 2: legend(2)}
-# The field-specific legend is appended by build_prompt(). Keeping this short shared
-# prefix avoids describing fields that the question-specific projection removed.
-PRE_PROMPT = _HEAD + "\n\n" + _UNITS_NOTE
-
-FRAMES_EVIDENCE_NOTE = (
-    "Known limitations of the spatial code (it was built automatically, and some of its values "
-    "are less reliable than others -- use the video frames to cross-check them):\n"
-    "- An object class's count is a LOWER BOUND (the most instances ever seen at once in a "
-    "single video frame). If the frames clearly show more instances than the code lists, trust "
-    "the frames.\n"
-    "- An object's size/extent comes from a single frame's 3D points and can be cut short by "
-    "occlusion. If the frames clearly show the object is larger than the code says, trust the "
-    "frames.\n"
-    "- The appearance order was derived by a heuristic and can be wrong for classes that enter "
-    "the video gradually or at the edge of the view. The frames themselves are the ground truth "
-    "for what appears when.\n"
-    "- Object positions and inter-object distances are the code's most reliable values -- "
-    "prefer the code over eyeballing the frames for those."
-)
-
-
-
-def _project_for_question(code, question_type, question, options=None):
-    """Keep only answer-relevant sections while retaining every object class.
-
-    This is a field-level projection of the raw v2 cache, before v2 unit/key
-    rendering. It deliberately does not filter individual classes: for example,
-    absolute-distance questions receive the complete distance matrix.
-    """
-    source = copy.deepcopy(code)
-    source.pop("spatial code schema", None)
-    objects = source.get("objects", {})
-
-    if question_type == "object_counting":
-        return {"objects": {
-            name: {"count": value.get("count")}
-            for name, value in objects.items()
-        }}
-
-    if question_type == "object_size_estimation":
-        return {"objects": {
-            name: {"instances": [
-                {"longest_dimension_meters": instance["longest_dimension_meters"]}
-                for instance in value.get("instances", [])
-                if "longest_dimension_meters" in instance
-            ]}
-            for name, value in objects.items()
-        }}
-
-    if question_type == "room_size_estimation":
-        return {"room": {"floor_area_square_meters":
-                          source.get("room", {}).get("floor_area_square_meters")}}
-
-    if question_type == "object_abs_distance":
-        # Keep the complete matrix. Only the ordering field is irrelevant here;
-        # each matrix entry keeps its distance and v2 rank metadata.
-        return {_CCF: copy.deepcopy(source.get(_CCF, {}))}
-
-    if question_type == "object_rel_distance":
-        # The question may name only some candidates, but the complete v2 matrix
-        # is retained so the model can resolve every option without guessing.
-        return {_CCF: copy.deepcopy(source.get(_CCF, {}))}
-
-    if question_type in {
-        "object_rel_direction_easy", "object_rel_direction_medium",
-        "object_rel_direction_hard", "route_planning",
-    }:
-        return {"objects": {
-            name: {"instances": [
-                {"position": copy.deepcopy(instance["position"])}
-                for instance in value.get("instances", [])
-                if "position" in instance
-            ]}
-            for name, value in objects.items()
-        }}
-
-    if question_type == "obj_appearance_order":
-        return {"appearance_order": copy.deepcopy(source.get("appearance_order", []))}
-
-    raise ValueError(f"unrecognized question_type: {question_type!r}")
-
-
-LEGEND_V2 = """SPATIAL CODE of a scanned room (JSON, built from the video). Answer using ONLY its values.
-- objects[X].count = number of instances of class X in the room (a lower-bound count: the most
-  ever seen at once in a single video frame).
-- objects[X].instances = up to `count` individual objects of class X, each with:
-    - position = {floor_x_meters, floor_y_meters, height_above_floor_meters}: location in meters;
-      height 0.0 = resting on the floor.
-    - longest_dimension_meters = the object's single longest side, in meters (x100 = centimeters).
-    - bounding_box = full 3D extent, same named axes as position, each a [minimum, maximum] pair.
-    - first_seen_seconds = video timestamp (seconds from start) when this instance first appeared.
-    - seen_in_video_frames = number of video frames this instance was detected in. A very low
-      value (a few frames) means weak evidence: the instance may be a false detection.
-- room.outline = the room's floor boundary as a polygon of {floor_x_meters, floor_y_meters}
-  vertices (same axes as positions).
-- room.floor_area_square_meters = total floor area of the room, in square meters.
-- closest_classes_from[X][Y] = {closeness_rank, distance_meters} for every other class Y as seen
-  from class X. distance_meters is between the closest points of X and Y (the lookup for "how far
-  is Y from X"). closeness_rank ranks all classes by nearness to X: rank 1 = the closest class.
-  To pick which of several given classes is closest to X, look up each one's closeness_rank under
-  closest_classes_from[X] and choose the class with the SMALLEST rank (farthest = largest rank).
-- camera_trajectory.waypoints = the recording camera's path: {time_seconds, floor_x_meters,
-  floor_y_meters, heading_degrees}, sampled every sample_interval_seconds. Positions use the
-  same floor axes as object positions.
-- appearance_order = every detected class with its first-appearance time, ALREADY SORTED
-  earliest-first."""
-
-# Exact word-for-word sections from LEGEND_V2, selected by question type.
-_V2_HEADER = "SPATIAL CODE of a scanned room (JSON, built from the video). Answer using ONLY its values."
-_V2_COUNT = """- objects[X].count = number of instances of class X in the room (a lower-bound count: the most
-  ever seen at once in a single video frame)."""
-_V2_INSTANCES = """- objects[X].instances = up to `count` individual objects of class X, each with:"""
-_V2_POSITION = """    - position = {floor_x_meters, floor_y_meters, height_above_floor_meters}: location in meters;
-      height 0.0 = resting on the floor."""
-_V2_SIZE = """    - longest_dimension_meters = the object's single longest side, in meters (x100 = centimeters)."""
-_V2_ROOM_AREA = "- room.floor_area_square_meters = total floor area of the room, in square meters."
-_V2_DISTANCE = """- closest_classes_from[X][Y] = {closeness_rank, distance_meters} for every other class Y as seen
-  from class X. distance_meters is between the closest points of X and Y (the lookup for "how far
-  is Y from X"). closeness_rank ranks all classes by nearness to X: rank 1 = the closest class.
-  To pick which of several given classes is closest to X, look up each one's closeness_rank under
-  closest_classes_from[X] and choose the class with the SMALLEST rank (farthest = largest rank)."""
-_V2_APPEARANCE = """- appearance_order = every detected class with its first-appearance time, ALREADY SORTED
-  earliest-first."""
-
-
-def _question_legend(question_type):
-    sections = [_V2_HEADER]
-    if question_type == "object_counting":
-        sections.append(_V2_COUNT)
-    elif question_type == "object_size_estimation":
-        sections.extend([_V2_INSTANCES, _V2_SIZE])
-    elif question_type == "room_size_estimation":
-        sections.append(_V2_ROOM_AREA)
-    elif question_type in {"object_abs_distance", "object_rel_distance"}:
-        sections.append(_V2_DISTANCE)
-    elif question_type in {
-        "object_rel_direction_easy", "object_rel_direction_medium",
-        "object_rel_direction_hard", "route_planning",
-    }:
-        sections.extend([_V2_INSTANCES, _V2_POSITION])
-    elif question_type == "obj_appearance_order":
-        sections.append(_V2_APPEARANCE)
-    else:
-        raise ValueError(f"unrecognized question_type: {question_type!r}")
-    return "\n".join(sections)
-
-def _post_prompt(question_type):
-    if question_type in NA_QUESTION_TYPES:
-        return "\n".join([STEP_BY_STEP_REASONING_PROMPT, NA_POST_PROMPT])
-    if question_type in MCA_QUESTION_TYPES:
-        return "\n".join([STEP_BY_STEP_REASONING_PROMPT, MCA_POST_PROMPT])
-    raise ValueError(
-        f"unknown question_type {question_type!r}; "
-        f"expected one of {MCA_QUESTION_TYPES + NA_QUESTION_TYPES}"
-    )
-
-
-def _assemble(pre_prompt, code, question_type, question, options=None):
-    code_text = json.dumps(code, indent=1)
-    if question_type in NA_QUESTION_TYPES:
-        return "\n".join([pre_prompt, "Spatial code:", code_text, question, _post_prompt(question_type)])
-    if question_type in MCA_QUESTION_TYPES:
-        if not options:
-            raise ValueError(f"question_type {question_type!r} requires options")
-        return "\n".join(
-            [
-                pre_prompt,
-                "Spatial code:",
-                code_text,
-                question,
-                "Options:\n" + "\n".join(options),
-                _post_prompt(question_type),
-            ]
-        )
-    return _post_prompt(question_type)
-
-
-def build_ablation_prompt(code, question, question_type, options, level, prompt_level=1, evidence=True, frames_note=False):
-    rendered = ablate(code, level, evidence=evidence)
-    pre_prompt = legend(level, prompt_level=prompt_level, evidence=evidence)
-    if frames_note:
-        pre_prompt += "\n\n" + FRAMES_EVIDENCE_NOTE
-    return _assemble(pre_prompt, rendered, question_type, question, options)
-
-
-def build_prompt(spatial_code, question_type, question, options=None, frames_note=False):
-    """Return the single v2 L2 spatial-code prompt."""
-    rendered = _project_for_question(spatial_code, question_type, question, options)
-    pre_prompt = _question_legend(question_type)
-    if frames_note:
-        pre_prompt += "\n\n" + FRAMES_EVIDENCE_NOTE
-    return _assemble(pre_prompt, rendered, question_type, question, options)

harness/B/run.py

@@ -1,379 +0,0 @@
-"""Run one VLM over VSI-Bench questions through harness B's spatial-code-as-text routing.
-
-Writes one JSON file per question in the identical shape harness.A uses (same
-provenance-heavy, nothing-truncated philosophy) -- the frame-provenance fields are
-simply replaced with spatial-code provenance fields (spatial_code_format,
-input_selection, frame_count, depth, tracking, spatial_code_path), since B has no
-video frames at all. Scoring reuses the same real, unmodified official scorer harness.A
-and symbolic/run.py both use.
-"""
-
-from __future__ import annotations
-
-import argparse
-import json
-import sys
-from pathlib import Path
-
-WORKSPACE_ROOT = Path(__file__).resolve().parent.parent.parent
-if str(WORKSPACE_ROOT) not in sys.path:
-    sys.path.insert(0, str(WORKSPACE_ROOT))
-
-from harness.A import EXTENDED_MAX_NEW_TOKENS, MAX_NEW_TOKENS  # noqa: E402
-from harness.A import models as vlm_models  # noqa: E402
-from harness.A import (
-    protocol_for_question,
-    question_group,
-    resolve_protocol_budgets,
-)  # noqa: E402
-from harness.A.run import _scalar_score, load_questions, vsi_official_eval  # noqa: E402
-from harness.B import (  # noqa: E402
-    DEFAULT_DEPTH,
-    DEFAULT_INPUT_SELECTION,
-    DEFAULT_SPATIAL_CODE_FORMAT,
-    DEFAULT_TRACKING,
-    DEPTH_VARIANTS,
-    FRAMES_PER_VIDEO,
-    INPUT_SELECTIONS,
-    RESULTS_DIR,
-    TRACKING_MODES,
-)
-from harness.B import prompts as code_prompts  # noqa: E402
-from harness.B import spatial_codes  # noqa: E402
-
-
-def results_dir_for(
-    model,
-    protocol,
-    spatial_code_format,
-    depth,
-    tracking,
-    input_selection,
-    frame_count,
-    results_dir=None,
-):
-    """Return the result root isolated by model + protocol + fixed explicit spatial code +
-    depth + tracking + input + frames. ``protocol`` is "base" (16-token) or
-    "extended-<reasoning budget>" (e.g. "extended-512") -- a real path segment, so
-    records from different protocols OR different reasoning budgets can never collide
-    on disk."""
-    if results_dir is not None:
-        return Path(results_dir)
-    root = RESULTS_DIR / model / spatial_code_format / depth / tracking
-    if input_selection == "video":
-        return root / "video"
-    return root / input_selection / str(frame_count)
-
-
-def _build_record(
-    row, prompt, answer, metric_name, score, model, model_path, code_info
-):
-    """Assemble one question's full, untruncated result record (nothing summarized)."""
-    return {
-        "model": model,
-        "model_path": str(model_path),
-        "device": answer["device"],
-        "dtype": answer["dtype"],
-        "library_versions": answer["library_versions"],
-        "condition": (
-            f"{code_info['protocol']}:{code_info['spatial_code_format']}:"
-            f"{code_info['depth']}:{code_info['tracking']}:"
-            + (
-                "video"
-                if code_info["input_selection"] == "video"
-                else f"{code_info['input_selection']}:{code_info['frame_count']}"
-            )
-        ),
-        "protocol": code_info["protocol"],
-        "question_group": question_group(row["question_type"]),
-        "spatial_code_format": code_info["spatial_code_format"],
-        "input_selection": code_info["input_selection"],
-        "frame_count": code_info["frame_count"],
-        "depth": code_info["depth"],
-        "tracking": code_info["tracking"],
-        "spatial_code_path": code_info["spatial_code_path"],
-        "scene": row["scene_name"],
-        "dataset": row.get("dataset"),
-        "question_id": row["id"],
-        "question_type": row["question_type"],
-        "question": row["question"],
-        "options": row.get("options"),
-        "full_prompt": prompt,
-        "rendered_prompt": answer["prompt_text"],
-        "answer_expected": row["ground_truth"],
-        "answer_given": answer["answer_text"],
-        "answer_raw": answer["answer_raw"],
-        "input_token_count": answer["input_token_count"],
-        "vision_input_shapes": answer["vision_input_shapes"],
-        "output_token_ids": answer["output_token_ids"],
-        "output_token_count": answer["output_token_count"],
-        "hit_token_limit": answer["hit_token_limit"],
-        "eos_token_ids": answer["eos_token_ids"],
-        "generation_seconds": answer["generation_seconds"],
-        "generation_config": answer["generation_config"],
-        "reasoning_text": answer.get("reasoning_text"),
-        "reasoning_raw": answer.get("reasoning_raw"),
-        "reasoning_token_ids": answer.get("reasoning_token_ids"),
-        "reasoning_token_count": answer.get("reasoning_token_count"),
-        "reasoning_hit_limit": answer.get("reasoning_hit_limit"),
-        "forced": answer.get("forced", False),
-        "forced_input_token_count": answer.get("forced_input_token_count"),
-        "metric": metric_name,
-        "score": score,
-    }
-
-
-def write_question_result(
-    row,
-    prompt,
-    answer,
-    metric_name,
-    score,
-    model,
-    model_path,
-    code_info,
-    results_dir=None,
-):
-    """Write one question's full, untruncated result record. Return (path, record)."""
-    record = _build_record(
-        row, prompt, answer, metric_name, score, model, model_path, code_info
-    )
-    root = results_dir_for(
-        model,
-        code_info["protocol"],
-        code_info["spatial_code_format"],
-        code_info["depth"],
-        code_info["tracking"],
-        code_info["input_selection"],
-        code_info["frame_count"],
-        results_dir,
-    )
-    scene_dir = root / record["scene"]
-    scene_dir.mkdir(parents=True, exist_ok=True)
-    path = scene_dir / f"{row['id']}.json"
-    with path.open("w", encoding="utf-8") as stream:
-        json.dump(record, stream, indent=1)
-    return path, record
-
-
-def run(
-    model,
-    spatial_code_format=DEFAULT_SPATIAL_CODE_FORMAT,
-    input_selection=DEFAULT_INPUT_SELECTION,
-    frame_count=FRAMES_PER_VIDEO,
-    video=False,
-    depth=DEFAULT_DEPTH,
-    tracking=DEFAULT_TRACKING,
-    scene=None,
-    scenes=None,
-    limit=None,
-    device="cuda",
-    jsonl_path=None,
-    results_dir=None,
-    write_results=True,
-    adapter=None,
-    extended=True,
-    reasoning_budget=EXTENDED_MAX_NEW_TOKENS,
-    force_budget=MAX_NEW_TOKENS,
-    question_ids=None,
-):
-    """Answer every matching question with one model, given its scene's spatial code as
-    text (no video frames). Each question's full record is written to its own JSON file
-    as soon as it is answered (unless ``write_results=False``).
-
-    Uses ``adapter.answer_extended`` (a large ``reasoning_budget`` first pass, with a
-    short forced second call only if the model doesn't conclude within it) as the
-    standing default protocol -- since working through a full spatial-code JSON before
-    answering benefits from more room than a short visual caption does.
-    ``extended=False`` runs harness.A's exact fixed 16-token base protocol instead
-    (plain ``adapter.answer``), so the protocol x representation grid can be measured
-    with the identical generation mechanism in every cell.
-
-    Pass a pre-loaded ``adapter`` (as harness.B.launch's persistent per-GPU workers do)
-    to reuse one already-loaded model across many calls; the caller then owns unloading
-    it. Without one, ``run`` loads and unloads its own adapter, same as harness.A.
-    """
-    if video:
-        input_selection = "video"
-        frame_count = None
-    elif frame_count is None or frame_count < 1:
-        raise ValueError("frame_count must be positive in frames mode")
-    rows = load_questions(jsonl_path, scene, scenes, limit)
-    if question_ids is not None:
-        rows = [row for row in rows if row["id"] in question_ids]
-    if not rows:
-        return []
-    owns_adapter = adapter is None
-    if owns_adapter:
-        adapter = vlm_models.get_adapter(model)
-        adapter.load_model(device)
-    code_cache = {}
-    results = []
-    try:
-        for row in rows:
-            protocol = protocol_for_question(row["question_type"])
-            scene_id = row["scene_name"]
-            if scene_id not in code_cache:
-                code, path = spatial_codes.load_spatial_code(
-                    scene_id,
-                    depth,
-                    input_selection,
-                    tracking,
-                    frame_count,
-                    spatial_code_format,
-                )
-                code_cache[scene_id] = {"code": code, "path": path}
-            cached = code_cache[scene_id]
-            prompt = code_prompts.build_prompt(
-                cached["code"],
-                row["question_type"],
-                row["question"],
-                row.get("options"),
-            )
-            answer = (
-                adapter.answer_extended(
-                    [],
-                    prompt,
-                    reasoning_budget=reasoning_budget,
-                    force_budget=force_budget,
-                )
-                if protocol == "thinking"
-                else adapter.answer([], prompt, max_new_tokens=MAX_NEW_TOKENS)
-            )
-            doc = {
-                "question_type": row["question_type"],
-                "ground_truth": row["ground_truth"],
-            }
-            score_doc = vsi_official_eval.vsibench_process_results(
-                doc, [answer["answer_text"]]
-            )["vsibench_score"]
-            metric_name, score = _scalar_score(row["question_type"], score_doc)
-            code_info = {
-                "protocol": protocol,
-                "spatial_code_format": spatial_code_format,
-                "input_selection": input_selection,
-                "frame_count": frame_count,
-                "depth": depth,
-                "tracking": tracking,
-                "spatial_code_path": cached["path"],
-            }
-            if write_results:
-                path, record = write_question_result(
-                    row,
-                    prompt,
-                    answer,
-                    metric_name,
-                    score,
-                    model,
-                    adapter.model_path,
-                    code_info,
-                    results_dir,
-                )
-            else:
-                path = None
-                record = _build_record(
-                    row,
-                    prompt,
-                    answer,
-                    metric_name,
-                    score,
-                    model,
-                    adapter.model_path,
-                    code_info,
-                )
-            record["result_path"] = str(path) if path else None
-            results.append(record)
-    finally:
-        if owns_adapter:
-            adapter.unload()
-    return results
-
-
-def main():
-    parser = argparse.ArgumentParser()
-    parser.add_argument("--model", required=True, choices=vlm_models.available_models())
-    parser.add_argument("--scene", default=None, help="restrict to one VSI-Bench scene")
-    parser.add_argument(
-        "--input-selection",
-        default=None,
-        choices=INPUT_SELECTIONS,
-        dest="input_selection",
-    )
-    input_mode = parser.add_mutually_exclusive_group(required=True)
-    input_mode.add_argument("--frames", type=int)
-    input_mode.add_argument("--video", action="store_true")
-    parser.add_argument("--depth", default=DEFAULT_DEPTH, choices=DEPTH_VARIANTS)
-    parser.add_argument("--tracking", default=DEFAULT_TRACKING, choices=TRACKING_MODES)
-    parser.add_argument(
-        "--limit", type=int, default=None, help="cap the number of questions"
-    )
-    parser.add_argument("--device", default="cuda")
-    parser.add_argument(
-        "--results-dir",
-        default=None,
-        help="override the default results/B/<model>/explicit/"
-        "<depth>/<tracking>/{<input>/<frames>|video} root",
-    )
-    parser.add_argument(
-        "--no-write",
-        action="store_true",
-        help="skip writing per-question JSON files; print/score only",
-    )
-    parser.add_argument(
-        "--reasoning-budget",
-        type=int,
-        default=None,
-        help="thinking questions only (default: 2048)",
-    )
-    parser.add_argument(
-        "--force-budget",
-        type=int,
-        default=None,
-        help="thinking questions only (default: 16)",
-    )
-    args = parser.parse_args()
-    if args.video:
-        if args.input_selection is not None:
-            parser.error("--input-selection cannot be used with --video")
-    else:
-        if args.input_selection is None:
-            parser.error("--input-selection is required with --frames")
-        if args.frames < 1:
-            parser.error("--frames must be positive")
-    resolve_protocol_budgets(parser, args)
-    results = run(
-        args.model,
-        spatial_code_format=DEFAULT_SPATIAL_CODE_FORMAT,
-        input_selection=args.input_selection,
-        frame_count=args.frames,
-        video=args.video,
-        depth=args.depth,
-        tracking=args.tracking,
-        scene=args.scene,
-        limit=args.limit,
-        device=args.device,
-        results_dir=args.results_dir,
-        write_results=not args.no_write,
-        extended=True,
-        reasoning_budget=args.reasoning_budget,
-        force_budget=args.force_budget,
-    )
-
-    for result in results:
-        print(
-            f"[{result['scene']}#{result['question_id']}] {result['question_type']}: "
-            f"pred={result['answer_given']!r} gt={result['answer_expected']!r} "
-            f"score={result['score']} ({result['generation_seconds']:.2f}s) -> "
-            f"{result['result_path']}"
-        )
-    if results:
-        mean_score = sum(r["score"] for r in results) / len(results)
-        total_seconds = sum(r["generation_seconds"] for r in results)
-        print(
-            f"\n{len(results)} questions, mean vsibench_score={mean_score:.4f}, "
-            f"total generation time={total_seconds:.1f}s"
-        )
-
-
-if __name__ == "__main__":
-    main()

harness/B/spatial_codes.py

@@ -1,33 +0,0 @@
-"""Load one scene's on-disk explicit spatial code as plain JSON.
-
-No solver-side adaptation (symbolic.adapters.adapt_spatial_code): the model is shown
-literally the same file encoder/geometric.py wrote to disk -- schema legend included --
-not a derived, answer-oriented shape a solver would compute from it.
-"""
-
-from __future__ import annotations
-
-import json
-from pathlib import Path
-
-from encoder.config import spatial_code_path
-
-from harness.B import SPATIAL_CODE_FORMATS
-
-
-def load_spatial_code(
-    scene, depth, input_selection, tracking, frame_count, spatial_code_format
-):
-    """Return (spatial code dict, path it was loaded from)."""
-    if spatial_code_format not in SPATIAL_CODE_FORMATS:
-        raise ValueError(
-            f"unknown spatial-code format {spatial_code_format!r}; "
-            f"expected one of {SPATIAL_CODE_FORMATS}"
-        )
-    path = spatial_code_path(
-        scene, depth, input_selection, tracking, frame_count, spatial_code_format
-    )
-    if not Path(path).is_file():
-        raise FileNotFoundError(f"no spatial code found for scene {scene!r} at {path}")
-    with open(path, encoding="utf-8") as stream:
-        return json.load(stream), path

harness/B/sweep.py

@@ -1,202 +0,0 @@
-"""Sweep any set of models x depths x trackings x
-input-selections x frame-counts.
-
-Every (model, spatial_code_format, depth, tracking, input_selection, frame_count)
-6-tuple in the sweep is run through ``harness.B.launch.launch`` in turn, so each
-combination individually saturates every visible GPU before the next one starts.
-Depth/tracking default to this workspace's single shipped production config
-(DEFAULT_DEPTH/DEFAULT_TRACKING) when --depths/--trackings aren't given, but are real
-sweepable axes like every other dimension here -- pass --depths all / --trackings all
-(or an explicit comma list) to sweep them too.
-"""
-
-from __future__ import annotations
-
-import argparse
-from pathlib import Path
-import sys
-
-HERE = Path(__file__).resolve().parent
-WORKSPACE_ROOT = HERE.parent.parent
-if str(WORKSPACE_ROOT) not in sys.path:
-    sys.path.insert(0, str(WORKSPACE_ROOT))
-
-from harness.A import models as vlm_models  # noqa: E402
-from harness.A import resolve_protocol_budgets  # noqa: E402
-from harness.A import EXTENDED_MAX_NEW_TOKENS  # noqa: E402
-from harness.A.sweep import _parse_csv_choice, _parse_frame_counts  # noqa: E402
-from harness.B import (  # noqa: E402
-    DEFAULT_DEPTH,
-    DEFAULT_SPATIAL_CODE_FORMAT,
-    DEFAULT_TRACKING,
-    DEPTH_VARIANTS,
-    INPUT_SELECTIONS,
-    TRACKING_MODES,
-)
-from harness.B import launch as harness_launch  # noqa: E402
-
-
-def build_plan(
-    models, spatial_code_formats, input_selections, frame_counts, depths, trackings
-):
-    """Return every (model, spatial_code_format, depth, tracking, input_selection,
-    frame_count) 6-tuple in the sweep, in a stable, cheapest-first-ish order (frame
-    count sorted first)."""
-    return [
-        (model, spatial_code_format, depth, tracking, input_selection, frame_count)
-        for frame_count in sorted(frame_counts)
-        for model in models
-        for spatial_code_format in spatial_code_formats
-        for depth in depths
-        for tracking in trackings
-        for input_selection in input_selections
-    ]
-
-
-def sweep(
-    models,
-    spatial_code_formats,
-    input_selections,
-    frame_counts,
-    selected_scenes,
-    video=False,
-    depths=(DEFAULT_DEPTH,),
-    trackings=(DEFAULT_TRACKING,),
-    results_dir=None,
-    rebuild=False,
-    extended=True,
-    reasoning_budget=EXTENDED_MAX_NEW_TOKENS,
-):
-    """Run every sweep combination across all visible GPUs."""
-    plan = build_plan(
-        models, spatial_code_formats, input_selections, frame_counts, depths, trackings
-    )
-    for index, (
-        model,
-        spatial_code_format,
-        depth,
-        tracking,
-        input_selection,
-        frame_count,
-    ) in enumerate(plan, start=1):
-        print(
-            f"=== sweep {index}/{len(plan)}: {model}/"
-            f"{spatial_code_format}/{depth}/{tracking}/"
-            + ("video" if video else f"{input_selection}/{frame_count}")
-            + " ===",
-            flush=True,
-        )
-        harness_launch.launch(
-            model,
-            spatial_code_format,
-            input_selection,
-            frame_count,
-            selected_scenes,
-            video=video,
-            depth=depth,
-            tracking=tracking,
-            results_dir=results_dir,
-            rebuild=rebuild,
-            extended=extended,
-            reasoning_budget=reasoning_budget,
-        )
-
-
-def main():
-    parser = argparse.ArgumentParser()
-    parser.add_argument("scene", nargs="?")
-    parser.add_argument(
-        "--scenes",
-        help="comma-separated scenes (cannot be combined with positional scene)",
-    )
-    parser.add_argument(
-        "--models",
-        required=True,
-        help=f"comma-separated models (or 'all'); one of {vlm_models.available_models()}",
-    )
-    parser.add_argument(
-        "--input-selections",
-        required=False,
-        dest="input_selections",
-        help=f"comma-separated selections (or 'all'); one of {INPUT_SELECTIONS}",
-    )
-    input_mode = parser.add_mutually_exclusive_group(required=True)
-    input_mode.add_argument(
-        "--frames", help="comma-separated frame counts, e.g. 16,32,64"
-    )
-    input_mode.add_argument("--video", action="store_true")
-    parser.add_argument(
-        "--depths",
-        default=DEFAULT_DEPTH,
-        help=f"comma-separated depths (or 'all'); one of {DEPTH_VARIANTS}",
-    )
-    parser.add_argument(
-        "--trackings",
-        default=DEFAULT_TRACKING,
-        help=f"comma-separated tracking modes (or 'all'); one of {TRACKING_MODES}",
-    )
-    parser.add_argument("--results-dir", default=None)
-    parser.add_argument("--rebuild", action="store_true")
-    parser.add_argument(
-        "--reasoning-budget",
-        type=int,
-        default=None,
-        dest="reasoning_budget",
-        help="thinking-protocol first-pass budget (the calibrated value from "
-        "analysis/preregistration.md, e.g. 512)",
-    )
-    args = parser.parse_args()
-    resolve_protocol_budgets(parser, args)
-    if args.scene and args.scenes:
-        parser.error("positional scene and --scenes cannot be used together")
-
-    try:
-        models = _parse_csv_choice(
-            args.models, vlm_models.available_models(), "--models"
-        )
-        spatial_code_formats = (DEFAULT_SPATIAL_CODE_FORMAT,)
-        if args.video:
-            if args.input_selections is not None:
-                raise ValueError("--input-selections cannot be used with --video")
-            input_selections = ["video"]
-            frame_counts = [None]
-        else:
-            if args.input_selections is None:
-                raise ValueError("--input-selections is required with --frames")
-            input_selections = _parse_csv_choice(
-                args.input_selections, INPUT_SELECTIONS, "--input-selections"
-            )
-            frame_counts = _parse_frame_counts(args.frames)
-        depths = _parse_csv_choice(args.depths, DEPTH_VARIANTS, "--depths")
-        trackings = _parse_csv_choice(args.trackings, TRACKING_MODES, "--trackings")
-    except ValueError as exc:
-        parser.error(str(exc))
-
-    if args.scenes is not None:
-        selected = [scene.strip() for scene in args.scenes.split(",") if scene.strip()]
-        if not selected:
-            parser.error("--scenes must contain at least one scene")
-        selected = list(dict.fromkeys(selected))
-    else:
-        from harness.A.launch import scenes
-
-        selected = [args.scene] if args.scene else scenes()
-
-    sweep(
-        models,
-        spatial_code_formats,
-        input_selections,
-        frame_counts,
-        selected,
-        video=args.video,
-        depths=depths,
-        trackings=trackings,
-        results_dir=args.results_dir,
-        rebuild=args.rebuild,
-        extended=True,
-        reasoning_budget=args.reasoning_budget,
-    )
-
-
-if __name__ == "__main__":
-    main()

harness/C/__init__.py

@@ -1,47 +0,0 @@
-"""Harness C: route BOTH a scene's video frames AND its on-disk spatial code (explicit
-explicit) to all three models, for every VSI-Bench question.
-
-Frames and spatial code are sourced from the exact same (depth, tracking,
-input_selection, frame_count) config -- the same parameters drive both
-harness.A.frames.sample_frames() and harness.B.spatial_codes.load_spatial_code(), so the
-spatial code shown to the model is guaranteed to have been built from sampling the same
-video the same way the frames themselves are sampled here; they can never mismatch.
-
-Reuses harness.A's model registry/adapters and fixed generation protocol exactly, and
-harness.B's spatial-code loading and format/input-selection vocabulary. Results are
-written in the identical per-question JSON shape harness.A and harness.B use, with both
-harnesses' provenance fields present (frame provenance from A, spatial-code provenance
-from B) since C uses both kinds of input.
-"""
-
-from __future__ import annotations
-
-import os
-from pathlib import Path
-
-from harness.A import (
-    DO_SAMPLE,
-    FRAME_SELECTIONS,
-    JSONL,
-    MAX_NEW_TOKENS,
-    MODEL_PATHS,
-    TEMPERATURE,
-    WORKSPACE_ROOT,
-)
-from harness.B import (
-    DEFAULT_DEPTH,
-    DEFAULT_INPUT_SELECTION,
-    DEFAULT_SPATIAL_CODE_FORMAT,
-    DEFAULT_TRACKING,
-    DEPTH_VARIANTS,
-    INPUT_SELECTIONS,
-    TRACKING_MODES,
-)
-
-assert INPUT_SELECTIONS == FRAME_SELECTIONS  # one shared vocabulary drives both sources
-
-FRAMES_PER_VIDEO = int(os.environ.get("VSI_HARNESS_C_FRAMES_PER_VIDEO", "32"))
-
-# One JSON per question, matching harness.A/B's layout:
-# results/C/<model>/<spatial_code_format>/<depth>/<tracking>/<input_selection>/<frame_count>/<scene>/<question_id>.json
-RESULTS_DIR = Path(os.environ.get("VSI_HARNESS_C_RESULTS_DIR", "/root/results/C"))

harness/C/launch.py

@@ -1,303 +0,0 @@
-"""Keep every visible GPU busy with persistent harness-C inference workers.
-
-Same shape as ``harness.A.launch`` / ``harness.B.launch``: one persistent worker
-process per visible GPU, pulling scenes off a shared queue, each loading its model
-exactly once and reusing it for every scene it's assigned (via ``run.run(...,
-adapter=...)``). One invocation covers one (model, spatial_code_format,
-input_selection, frame_count) quadruple across every requested scene; sweep multiple
-quadruples via harness.C.sweep.
-"""
-
-from __future__ import annotations
-
-import argparse
-import importlib.util
-import multiprocessing as mp
-import os
-from pathlib import Path
-import sys
-import traceback
-
-HERE = Path(__file__).resolve().parent
-WORKSPACE_ROOT = HERE.parent.parent
-if str(WORKSPACE_ROOT) not in sys.path:
-    sys.path.insert(0, str(WORKSPACE_ROOT))
-
-from harness.A import EXTENDED_MAX_NEW_TOKENS, MAX_NEW_TOKENS  # noqa: E402
-from harness.A import models as vlm_models  # noqa: E402
-from harness.A import resolve_protocol_budgets  # noqa: E402
-from harness.A.launch import scenes  # noqa: E402
-from harness.B import (  # noqa: E402
-    DEFAULT_DEPTH,
-    DEFAULT_INPUT_SELECTION,
-    DEFAULT_SPATIAL_CODE_FORMAT,
-    DEFAULT_TRACKING,
-    DEPTH_VARIANTS,
-    INPUT_SELECTIONS,
-    TRACKING_MODES,
-)
-from harness.C import FRAMES_PER_VIDEO  # noqa: E402
-from inference.launch import available_cpu_count, visible_gpus  # noqa: E402
-
-
-def _load_run_module():
-    spec = importlib.util.spec_from_file_location("_harness_C_run", HERE / "run.py")
-    module = importlib.util.module_from_spec(spec)
-    sys.modules[spec.name] = module
-    spec.loader.exec_module(module)
-    return module
-
-
-def _worker(
-    tasks,
-    results,
-    model,
-    spatial_code_format,
-    input_selection,
-    frame_count,
-    video,
-    depth,
-    tracking,
-    results_dir,
-    gpu,
-    cpu_threads,
-    extended,
-    reasoning_budget,
-    force_budget,
-):
-    if gpu is not None:
-        os.environ["CUDA_VISIBLE_DEVICES"] = str(gpu)
-    for variable in ("OMP_NUM_THREADS", "MKL_NUM_THREADS", "OPENBLAS_NUM_THREADS"):
-        os.environ[variable] = str(cpu_threads)
-    import cv2
-
-    cv2.setNumThreads(cpu_threads)
-    run = _load_run_module()
-    adapter = None
-    load_error = None
-    try:
-        adapter = vlm_models.get_adapter(model)
-        adapter.load_model("cuda:0" if gpu is not None else "cpu")
-    except Exception:
-        load_error = traceback.format_exc()
-    while True:
-        scene = tasks.get()
-        if scene is None:
-            return
-        if load_error is not None:
-            results.put((scene, False, load_error))
-            continue
-        try:
-            answered = run.run(
-                model,
-                spatial_code_format=spatial_code_format,
-                input_selection=input_selection,
-                frame_count=frame_count,
-                video=video,
-                depth=depth,
-                tracking=tracking,
-                scene=scene,
-                results_dir=results_dir,
-                adapter=adapter,
-                extended=extended,
-                reasoning_budget=reasoning_budget,
-                force_budget=force_budget,
-            )
-            mean_score = (
-                sum(r["score"] for r in answered) / len(answered) if answered else None
-            )
-            results.put(
-                (scene, True, f"{len(answered)} question(s), mean_score={mean_score}")
-            )
-        except Exception:
-            results.put((scene, False, traceback.format_exc()))
-
-
-def launch(
-    model,
-    spatial_code_format,
-    input_selection,
-    frame_count,
-    selected,
-    video=False,
-    depth=DEFAULT_DEPTH,
-    tracking=DEFAULT_TRACKING,
-    results_dir=None,
-    rebuild=False,
-    extended=True,
-    reasoning_budget=EXTENDED_MAX_NEW_TOKENS,
-    force_budget=MAX_NEW_TOKENS,
-):
-    """Answer every question for ``selected`` scenes, sharded across every visible GPU."""
-    if video:
-        input_selection = "video"
-        frame_count = None
-    elif frame_count is None or frame_count < 1:
-        raise ValueError("frame_count must be positive in frames mode")
-    mode = "video" if video else f"{input_selection}/{frame_count}"
-    condition = f"{model}/{spatial_code_format}/{depth}/{tracking}/{mode}"
-    run = _load_run_module()
-    root = run.results_dir_for(
-        model,
-        None,
-        spatial_code_format,
-        depth,
-        tracking,
-        input_selection,
-        frame_count,
-        results_dir,
-    )
-    pending = []
-    completed = 0
-    for scene in selected:
-        rows = run.load_questions(scene=scene)
-        if not rows:
-            raise ValueError(
-                f"no questions found for scene {scene!r}; check the manifest/scene selection"
-            )
-        answered = all((root / scene / f"{row['id']}.json").is_file() for row in rows)
-        if answered and not rebuild:
-            completed += 1
-            print(
-                f"[{condition} {completed}/{len(selected)}] {scene}: skipped",
-                flush=True,
-            )
-        else:
-            pending.append(scene)
-    if not pending:
-        print(f"[{condition}] DONE: {len(selected)} ok, 0 failed")
-        return
-
-    gpus = visible_gpus()
-    worker_count = min(len(pending), len(gpus) if gpus else 1)
-    assignments = gpus[:worker_count] if gpus else [None]
-    cpu_count = available_cpu_count()
-    cpu_threads = max(1, cpu_count // worker_count)
-    print(
-        f"[{condition}] starting {worker_count} persistent worker(s); "
-        f"GPUs={assignments}; CPU threads/worker={cpu_threads}",
-        flush=True,
-    )
-
-    context = mp.get_context("spawn")
-    tasks, results = context.Queue(), context.Queue()
-    for scene in pending:
-        tasks.put(scene)
-    for _ in range(worker_count):
-        tasks.put(None)
-    workers = [
-        context.Process(
-            target=_worker,
-            args=(
-                tasks,
-                results,
-                model,
-                spatial_code_format,
-                input_selection,
-                frame_count,
-                video,
-                depth,
-                tracking,
-                results_dir,
-                gpu,
-                cpu_threads,
-                extended,
-                reasoning_budget,
-                force_budget,
-            ),
-        )
-        for gpu in assignments
-    ]
-    for worker in workers:
-        worker.start()
-    failed = []
-    for finished in range(1, len(pending) + 1):
-        scene, ok, detail = results.get()
-        if not ok:
-            failed.append(scene)
-        print(
-            f"[{condition} {completed + finished}/{len(selected)}] {scene}: "
-            f"{'done' if ok else 'FAILED'}\n{detail}",
-            flush=True,
-        )
-    for worker in workers:
-        worker.join()
-    print(
-        f"[{condition}] DONE: {len(pending) - len(failed)} answered, {completed} skipped, "
-        f"{len(failed)} failed"
-    )
-    if failed:
-        raise SystemExit(1)
-
-
-def main():
-    parser = argparse.ArgumentParser()
-    parser.add_argument("scene", nargs="?")
-    parser.add_argument(
-        "--scenes",
-        help="comma-separated scenes (cannot be combined with positional scene)",
-    )
-    parser.add_argument("--model", required=True, choices=vlm_models.available_models())
-    parser.add_argument(
-        "--input-selection",
-        default=None,
-        choices=INPUT_SELECTIONS,
-        dest="input_selection",
-    )
-    input_mode = parser.add_mutually_exclusive_group(required=True)
-    input_mode.add_argument("--frames", type=int)
-    input_mode.add_argument("--video", action="store_true")
-    parser.add_argument("--depth", default=DEFAULT_DEPTH, choices=DEPTH_VARIANTS)
-    parser.add_argument("--tracking", default=DEFAULT_TRACKING, choices=TRACKING_MODES)
-    parser.add_argument("--results-dir", default=None)
-    parser.add_argument("--rebuild", action="store_true")
-    parser.add_argument(
-        "--reasoning-budget",
-        type=int,
-        default=None,
-        help="thinking mode only (default: 2048)",
-    )
-    parser.add_argument(
-        "--force-budget",
-        type=int,
-        default=None,
-        help="thinking mode only (default: 16)",
-    )
-    args = parser.parse_args()
-    if args.scene and args.scenes:
-        parser.error("positional scene and --scenes cannot be used together")
-    if args.scenes is not None:
-        selected = [scene.strip() for scene in args.scenes.split(",") if scene.strip()]
-        if not selected:
-            parser.error("--scenes must contain at least one scene")
-        selected = list(dict.fromkeys(selected))
-    else:
-        selected = [args.scene] if args.scene else scenes()
-    if args.video:
-        if args.input_selection is not None:
-            parser.error("--input-selection cannot be used with --video")
-    else:
-        if args.input_selection is None:
-            parser.error("--input-selection is required with --frames")
-        if args.frames < 1:
-            parser.error("--frames must be positive")
-    resolve_protocol_budgets(parser, args)
-    launch(
-        args.model,
-        DEFAULT_SPATIAL_CODE_FORMAT,
-        args.input_selection,
-        args.frames,
-        selected,
-        video=args.video,
-        depth=args.depth,
-        tracking=args.tracking,
-        results_dir=args.results_dir,
-        rebuild=args.rebuild,
-        extended=True,
-        reasoning_budget=args.reasoning_budget,
-        force_budget=args.force_budget,
-    )
-
-
-if __name__ == "__main__":
-    main()

harness/C/overlay.py

@@ -1,391 +0,0 @@
-"""Set-of-Marks overlay for the strong correspondence arm (harness C) -- sourced
-PURELY from SAM3's own raw per-frame output. No 3D math anywhere in this module.
-
-Gives frames and spatial code a SHARED instance namespace with 1:1 correspondence
-guaranteed BY CONSTRUCTION: every explicit-code instance gets an id ("bed 1",
-"chair 2", ...), and that id is stamped in EXACTLY the frames SAM3's own tracker
-reported that instance's masklet(s) present in, at EXACTLY the bounding box SAM3's
-own tracker reported for it there. There is no camera projection, no floor-basis
-inversion, no depth buffer, no occlusion heuristic anywhere in this pipeline -- an
-instance is drawn iff SAM3's raw cache says it's in this frame, at the box SAM3's
-raw cache says it's at. Any placement error, missing detection, or wrong-frame
-presence is therefore attributable to SAM3 (or the SAM3->code consolidation
-encoder.geometric already performs, verified separately), never to this module's
-own math, since this module doesn't do any.
-
-Provenance (which raw SAM3 masklet id(s) a final code instance came from) is
-recovered via encoder.geometric.instance_source_track_ids(), which exposes the
-"oids" field build_compact_spatial_code()'s own consolidation pipeline threads
-through internally but never emits in the on-disk schema (adding it there would
-change every harness's prompt -- this module is the only consumer).
-"""
-
-from __future__ import annotations
-
-import json
-import sys
-from pathlib import Path
-
-from PIL import Image, ImageDraw, ImageFont
-
-# Markers are drawn on a layer rendered at _SUPERSAMPLE x the frame's own resolution,
-# then downsampled with LANCZOS before compositing -- this is what makes the box
-# edges and glyph strokes look crisp/anti-aliased rather than jagged, WITHOUT the
-# marker's rendered footprint on the final frame growing (that footprint is set by
-# _FONT_SIZE below, sized for the frame's OWN resolution).
-_SUPERSAMPLE = 3
-_FONT_SIZE = 15
-_MARKER_RADIUS = 5
-_MAX_NUDGES = 12
-
-# A scalable font, not PIL's tiny fixed-size default bitmap font -- labels need to be
-# legible to a human reviewer (and to the model) at typical VSI-Bench frame resolution.
-# DejaVuSans-Bold ships inside every Pillow install (PIL/fonts/), so this never depends
-# on the host having a system font installed.
-try:
-    _LABEL_FONT = ImageFont.truetype(
-        str(Path(ImageFont.__file__).parent / "fonts" / "DejaVuSans-Bold.ttf"),
-        _FONT_SIZE * _SUPERSAMPLE,
-    )
-except OSError:
-    _LABEL_FONT = ImageFont.load_default(size=_FONT_SIZE * _SUPERSAMPLE)
-
-WORKSPACE_ROOT = Path(__file__).resolve().parent.parent.parent
-if str(WORKSPACE_ROOT) not in sys.path:
-    sys.path.insert(0, str(WORKSPACE_ROOT))
-
-from encoder import config as encoder_config  # noqa: E402
-from encoder import geometric as gm  # noqa: E402
-from encoder import run as perceive  # noqa: E402
-
-
-def _parse_meters(value):
-    return float(str(value).split()[0])
-
-
-def _boxes_overlap(a, b):
-    return a[0] < b[2] and a[2] > b[0] and a[1] < b[3] and a[3] > b[1]
-
-
-def _place_label_box(anchor_x, anchor_y, width, height, placed, frame_h, step):
-    """Return ((left, top, right, bottom), was_nudged) for one label, greedily moved
-    vertically away from every box already in ``placed`` (deterministic: labels are
-    tried in the caller's fixed order, so a given code always nudges the same way).
-    ``was_nudged`` is False only for attempt 0 (the label's natural, un-collided
-    position) -- the caller uses it to draw a leader line ONLY when the label actually
-    moved away from its marker, instead of drawing one, unconditionally, that's too
-    short to see for every other label. Alternates below/above the anchor in
-    increasing steps so a crowded cluster fans out symmetrically instead of drifting
-    off in one direction; stops at ``_MAX_NUDGES`` attempts and returns the last-tried
-    box rather than looping forever -- a residual overlap in a dense cluster is a
-    real, visible property of that cluster, not something to hide by trying
-    indefinitely."""
-    for attempt in range(_MAX_NUDGES):
-        direction = 1 if attempt % 2 == 0 else -1
-        offset = direction * step * ((attempt + 1) // 2)
-        top = anchor_y + offset
-        box = (anchor_x, top, anchor_x + width, top + height)
-        if (
-            0 <= box[1]
-            and box[3] <= frame_h
-            and not any(_boxes_overlap(box, p) for p in placed)
-        ):
-            return box, attempt > 0
-    return box, True
-
-
-def instance_ids(explicit_code):
-    """Return a copy of an explicit code whose instances each carry an
-    '"instance id": "<class> <n>"' field (1-based, in the code's own list order --
-    the same numbering label_positions() and stamp_frames() use). Input not mutated."""
-    code = dict(explicit_code)
-    objects = {}
-    for class_name, rendered in code.get("objects", {}).items():
-        instances = [
-            {**instance, "instance id": f"{class_name} {index}"}
-            for index, instance in enumerate(rendered.get("instances", []), 1)
-        ]
-        objects[class_name] = {**rendered, "instances": instances}
-    code["objects"] = objects
-    return code
-
-
-def label_positions(explicit_code):
-    """Return [(label, floor_x, floor_y, height_above_floor, longest_dimension)] for
-    every instance, labeled identically to instance_ids(). NOT used by stamp_frames
-    (which sources positions from SAM3's own raw boxes, not the code's stored 3D
-    position) -- kept as a standalone utility for auditing the code's own claimed
-    geometry against a scene (e.g. checking a suspect instance's stored height)."""
-    out = []
-    for class_name, rendered in explicit_code.get("objects", {}).items():
-        for index, instance in enumerate(rendered.get("instances", []), 1):
-            position = instance["position"]
-            out.append(
-                (
-                    f"{class_name} {index}",
-                    _parse_meters(position["x coordinate"]),
-                    _parse_meters(position["y coordinate"]),
-                    _parse_meters(position["height above floor"]),
-                    _parse_meters(instance["longest dimension"]),
-                )
-            )
-    return out
-
-
-def _load_raw_sam3_boxes(scene_id, input_selection, tracking, frame_count):
-    """Return {class_name: {frame_index: {masklet_id: (x, y, w, h) normalized [0,1]}}}
-    read directly from the native SAM3 tracking cache -- the same file
-    encoder.run.cache_or_load() itself reads, parsed here with NO further processing
-    (no masking, no merging, no geometry): exactly what SAM3's own tracker reported,
-    per frame, per masklet."""
-    import torch
-
-    path = encoder_config.sam3_cache_file(
-        scene_id, input_selection, tracking, frame_count
-    )
-    if not Path(path).is_file():
-        raise FileNotFoundError(
-            f"no raw SAM3 cache found for scene {scene_id!r} at {path} -- the strong "
-            "correspondence arm needs the scene's SAM3 perception cache on disk"
-        )
-    raw = torch.load(path, map_location="cpu", weights_only=False)
-    out = {}
-    for class_name, class_data in raw.items():
-        stream = class_data.get("stream", []) if isinstance(class_data, dict) else []
-        frames = {}
-        for entry in stream:
-            outputs = entry.get("outputs", {})
-            obj_ids = outputs.get("out_obj_ids", [])
-            boxes = outputs.get("out_boxes_xywh", [])
-            frames[int(entry["frame_index"])] = {
-                int(oid): tuple(float(v) for v in box)
-                for oid, box in zip(obj_ids, boxes)
-            }
-        out[str(class_name)] = frames
-    return out
-
-
-def overlay_frame_cache_dir(scene_id, depth, input_selection, tracking, frame_count):
-    """Return the on-disk cache directory for one scene's stamped overlay frames --
-    same axes as the spatial code path (depth still matters here even though box
-    POSITIONS never touch it: instance_source_track_ids's provenance mapping, which
-    decides which raw SAM3 id becomes "chair 1" vs "chair 3", is computed via
-    room_gravity on the depth-specific geometry cache). Format is always explicit
-    (the only format the correspondence arms support), so it isn't part of the path."""
-    return (
-        encoder_config.CACHE_ROOT
-        / "overlay-frames"
-        / depth
-        / tracking
-        / input_selection
-        / str(frame_count)
-        / scene_id
-    )
-
-
-def overlay_spatial_code_path(scene_id, depth, input_selection, tracking, frame_count):
-    """Return the durable overlay-code JSON path for one scene/config.
-
-    Overlay codes are stored under the configured spatial-code root's top-level
-    ``overlay`` directory so an overlay run has a browsable code artifact matching
-    the stamped frames, instead of only an in-memory prompt transform.
-    """
-    encoder_config._validate_dimensions(depth, input_selection, tracking, frame_count)
-    return (
-        encoder_config.CODES_ROOT
-        / "overlay"
-        / encoder_config.MODEL
-        / depth
-        / tracking
-        / input_selection
-        / str(frame_count)
-        / "explicit"
-        / f"{scene_id}.json"
-    )
-
-
-def load_or_create_overlay_code(
-    explicit_code, scene_id, depth, input_selection, tracking, frame_count
-):
-    """Load an existing overlay code, or create and save it from ``explicit_code``.
-
-    The saved code is exactly ``instance_ids(explicit_code)``. Existing files are
-    trusted as the durable artifact for that scene/config and are not rewritten.
-    Returns ``(code, path)``.
-    """
-    path = overlay_spatial_code_path(
-        scene_id, depth, input_selection, tracking, frame_count
-    )
-    if path.is_file():
-        return json.loads(path.read_text(encoding="utf-8")), str(path)
-    code = instance_ids(explicit_code)
-    path.parent.mkdir(parents=True, exist_ok=True)
-    path.write_text(json.dumps(code, indent=1) + "\n", encoding="utf-8")
-    return code, str(path)
-
-
-def _load_cached_frames(cache_dir, frame_count):
-    """Return (stamped_frame_copies, per_frame_visible_labels) if a complete cache
-    exists at ``cache_dir`` (every frame PNG plus the labels sidecar present), else
-    None. A partial cache (e.g. an interrupted pre-generation run) is treated as
-    absent -- regenerated in full, never silently served incomplete."""
-    labels_path = cache_dir / "labels.json"
-    if not labels_path.is_file():
-        return None
-    frame_paths = [cache_dir / f"{i}.png" for i in range(frame_count)]
-    if not all(path.is_file() for path in frame_paths):
-        return None
-    images = [Image.open(path).convert("RGB") for path in frame_paths]
-    visible = json.loads(labels_path.read_text())
-    return images, visible
-
-
-def _save_cached_frames(cache_dir, stamped, visible):
-    cache_dir.mkdir(parents=True, exist_ok=True)
-    for i, image in enumerate(stamped):
-        image.save(cache_dir / f"{i}.png")
-    (cache_dir / "labels.json").write_text(json.dumps(visible))
-
-
-def stamp_frames(
-    frame_images,
-    explicit_code,
-    scene_id,
-    depth,
-    input_selection,
-    tracking,
-    frame_count,
-    use_cache=True,
-):
-    """Return (stamped_frame_copies, per_frame_visible_labels). For every code
-    instance, looks up which raw SAM3 masklet id(s) it consolidated from
-    (encoder.geometric.instance_source_track_ids) and, per frame, whether SAM3's own
-    tracker reported any of those ids present -- if so, stamps SAM3's own reported box
-    for it, verbatim. An instance is absent from a frame's output iff SAM3's raw
-    tracker never reported it there; there is no other reason. Input images are
-    never mutated.
-
-    ``use_cache=True`` (default) reads/writes a persistent on-disk cache under
-    overlay_frame_cache_dir() -- the same stamping is otherwise recomputed from
-    scratch on every call (once per scene per model per run), and the result is
-    scene-only (never model- or question-dependent), so caching it once and reusing
-    it across every model/run that touches this scene/config is a pure speed win.
-    Pass False to force a fresh computation (e.g. after a code or overlay-logic
-    change, before the cache is known to be stale and worth clearing)."""
-    cache_dir = overlay_frame_cache_dir(
-        scene_id, depth, input_selection, tracking, frame_count
-    )
-    if use_cache:
-        cached = _load_cached_frames(cache_dir, frame_count)
-        if cached is not None:
-            return cached
-    geometry, _how = perceive.cache_or_load(
-        scene_id, depth, input_selection, tracking, frame_count, False
-    )
-    provenance = gm.instance_source_track_ids(geometry)
-    raw_boxes = _load_raw_sam3_boxes(scene_id, input_selection, tracking, frame_count)
-
-    labels = []
-    for class_name, rendered in explicit_code.get("objects", {}).items():
-        oid_lists = provenance.get(class_name, [])
-        for index, _instance in enumerate(rendered.get("instances", []), 1):
-            oids = oid_lists[index - 1] if index - 1 < len(oid_lists) else []
-            labels.append((f"{class_name} {index}", class_name, oids))
-
-    stamped, visible = [], []
-    for frame_index, image in enumerate(frame_images):
-        image = image.convert("RGB")
-        # Markers are drawn on a transparent layer at _SUPERSAMPLE x resolution, THEN
-        # downsampled with LANCZOS and alpha-composited onto the (unscaled, un-blurred)
-        # frame -- crisp anti-aliased edges on the marker itself, no change to the
-        # underlying photo's own resolution or the marker's on-frame footprint.
-        hi_res_size = (image.size[0] * _SUPERSAMPLE, image.size[1] * _SUPERSAMPLE)
-        overlay_layer = Image.new("RGBA", hi_res_size, (0, 0, 0, 0))
-        draw = ImageDraw.Draw(overlay_layer)
-        marker_r = _MARKER_RADIUS * _SUPERSAMPLE
-        placed_boxes = []
-        frame_labels = []
-        for label, class_name, oids in labels:
-            frame_detections = raw_boxes.get(class_name, {}).get(frame_index, {})
-            box = next(
-                (frame_detections[oid] for oid in oids if oid in frame_detections), None
-            )
-            if box is None:
-                continue  # SAM3's own tracker did not report this instance in this frame
-            nx, ny, nw, nh = box  # normalized [0,1] -- SAM3's own box, verbatim
-            bx0, by0 = nx * hi_res_size[0], ny * hi_res_size[1]
-            bw, bh = nw * hi_res_size[0], nh * hi_res_size[1]
-            draw.rectangle(
-                [bx0, by0, bx0 + bw, by0 + bh],
-                outline="red",
-                width=max(2, _SUPERSAMPLE),
-            )
-            px, py = bx0 + bw / 2, by0 + bh / 2
-            draw.ellipse(
-                [px - marker_r, py - marker_r, px + marker_r, py + marker_r],
-                outline="red",
-                width=max(2, _SUPERSAMPLE),
-            )
-            # Flip the label to the opposite side of the marker whenever its default
-            # placement would run off the frame -- a label clipped at the image edge is
-            # unreadable to both a human reviewer and the model.
-            text_width = draw.textlength(label, font=_LABEL_FONT)
-            text_height = _FONT_SIZE * _SUPERSAMPLE * 1.3
-            gap = 8 * _SUPERSAMPLE
-            text_x = (
-                px - gap - text_width
-                if px + gap + text_width > hi_res_size[0]
-                else px + gap
-            )
-            anchor_y = (
-                py + 4 * _SUPERSAMPLE
-                if py - 10 * _SUPERSAMPLE < 0
-                else py - 10 * _SUPERSAMPLE
-            )
-            # Nudge this label's box away from every label already placed in this
-            # frame -- a crowded cluster fans its labels out instead of stacking them
-            # into an unreadable smear (see _place_label_box's docstring).
-            label_box, was_nudged = _place_label_box(
-                text_x,
-                anchor_y,
-                text_width,
-                text_height,
-                placed_boxes,
-                hi_res_size[1],
-                step=text_height + 2 * _SUPERSAMPLE,
-            )
-            placed_boxes.append(label_box)
-            if was_nudged:
-                # A leader line from the marker to its (moved) label -- needed because
-                # dense clusters (several instances detected close together) can leave
-                # an unconnected dot cluster reading as unowned "random circles" once
-                # collision avoidance fans their labels apart. Only drawn when nudging
-                # actually happened -- a label already next to its own dot doesn't
-                # need one, and it would be invisible under the marker anyway.
-                anchor_x = label_box[2] if text_x < px else label_box[0]
-                anchor_y_mid = (label_box[1] + label_box[3]) / 2
-                draw.line(
-                    [(px, py), (anchor_x, anchor_y_mid)],
-                    fill=(255, 70, 55, 210),
-                    width=max(2, _SUPERSAMPLE),
-                )
-            # A thin dark stroke (not a solid fill box) keeps the label legible
-            # against any background without blotting out the photo underneath it.
-            draw.text(
-                (label_box[0], label_box[1]),
-                label,
-                font=_LABEL_FONT,
-                fill="#ff4030",
-                stroke_width=max(2, _SUPERSAMPLE),
-                stroke_fill=(0, 0, 0, 235),
-            )
-            frame_labels.append(label)
-        overlay_layer = overlay_layer.resize(image.size, Image.LANCZOS)
-        composited = Image.alpha_composite(
-            image.convert("RGBA"), overlay_layer
-        ).convert("RGB")
-        stamped.append(composited)
-        visible.append(frame_labels)
-    if use_cache:
-        _save_cached_frames(cache_dir, stamped, visible)
-    return stamped, visible

harness/C/overlay_launch.py

@@ -1,202 +0,0 @@
-"""Pre-generate the strong correspondence arm's stamped-frame cache for many scenes
-at once (harness.C.overlay.overlay_frame_cache_dir/stamp_frames).
-
-Stamping is scene-only (never model- or question-dependent), so pre-populating the
-cache once here means every later --overlay-ids run, for every model, reuses these
-same files instead of recomputing the identical stamping from scratch each time --
-and the cached PNGs are themselves a durable, browsable record of what every scene's
-overlay actually looks like, independent of any particular model run.
-
-Usage:
-    python -m harness.C.overlay_launch --depth metric --tracking tracking \\
-        --input uniform --frames 32
-        Pre-generates every scene with BOTH an explicit spatial code AND a SAM3
-        perception cache for this config -- skips scenes already cached and scenes
-        missing either dependency (reported, not silently dropped).
-
-    python -m harness.C.overlay_launch --depth metric --tracking tracking \\
-        --input uniform --frames 32 --scenes 42444976,45b0dac5e3
-        Restrict to specific scenes.
-
-    python -m harness.C.overlay_launch ... --rebuild
-        Recompute even scenes whose cache already exists (e.g. after an overlay.py
-        rendering change).
-"""
-
-from __future__ import annotations
-
-import argparse
-import multiprocessing as mp
-import os
-import sys
-import traceback
-from pathlib import Path
-
-HERE = Path(__file__).resolve().parent
-WORKSPACE_ROOT = HERE.parent.parent
-if str(WORKSPACE_ROOT) not in sys.path:
-    sys.path.insert(0, str(WORKSPACE_ROOT))
-
-from harness.A.launch import scenes as all_scenes  # noqa: E402
-from harness.A import frames as frame_sampling  # noqa: E402
-from harness.B import spatial_codes  # noqa: E402
-from harness.C import overlay  # noqa: E402
-import inference as inference_config  # noqa: E402
-
-
-def _available_cpu_count():
-    configured = os.environ.get("VSI_CPU_WORKERS")
-    if configured is not None:
-        count = int(configured)
-        if count < 1:
-            raise ValueError("VSI_CPU_WORKERS must be positive")
-        return count
-    try:
-        return max(1, len(os.sched_getaffinity(0)))
-    except AttributeError:
-        return max(1, os.cpu_count() or 1)
-
-
-def _has_dependencies(scene, depth, input_selection, tracking, frame_count):
-    """True iff this scene has both an explicit spatial code AND a raw SAM3 cache
-    for this config -- both are required to stamp its frames."""
-    try:
-        spatial_codes.load_spatial_code(
-            scene, depth, input_selection, tracking, frame_count, "explicit"
-        )
-    except FileNotFoundError:
-        return False
-    from encoder import config as encoder_config
-
-    return Path(
-        encoder_config.sam3_cache_file(scene, input_selection, tracking, frame_count)
-    ).is_file()
-
-
-def _generate_one(args):
-    scene, depth, input_selection, tracking, frame_count = args
-    try:
-        code, _path = spatial_codes.load_spatial_code(
-            scene, depth, input_selection, tracking, frame_count, "explicit"
-        )
-        video_path = inference_config.video_path(scene, None)
-        frame_images, _ts, _idx = frame_sampling.sample_frames(
-            video_path, frame_count, input_selection
-        )
-        overlay.stamp_frames(
-            frame_images,
-            code,
-            scene,
-            depth,
-            input_selection,
-            tracking,
-            frame_count,
-            use_cache=True,
-        )
-        overlay.load_or_create_overlay_code(
-            code, scene, depth, input_selection, tracking, frame_count
-        )
-        return scene, True, None
-    except Exception:
-        return scene, False, traceback.format_exc()
-
-
-def launch(
-    depth, input_selection, tracking, frame_count, selected, rebuild=False, workers=0
-):
-    """Pre-generate the overlay-frame cache for every scene in ``selected`` that has
-    both required dependencies. Returns (succeeded, failed, skipped_missing_deps)
-    scene-name lists."""
-    eligible, missing = [], []
-    for scene in selected:
-        if _has_dependencies(scene, depth, input_selection, tracking, frame_count):
-            eligible.append(scene)
-        else:
-            missing.append(scene)
-    if missing:
-        print(
-            f"[overlay-launch] {len(missing)} scene(s) missing a code or SAM3 cache, skipped:"
-        )
-        print(f"  {missing}")
-
-    if not rebuild:
-        pending = []
-        for scene in eligible:
-            cache_dir = overlay.overlay_frame_cache_dir(
-                scene, depth, input_selection, tracking, frame_count
-            )
-            code_path = overlay.overlay_spatial_code_path(
-                scene, depth, input_selection, tracking, frame_count
-            )
-            if (
-                overlay._load_cached_frames(cache_dir, frame_count) is not None
-                and code_path.is_file()
-            ):
-                continue
-            pending.append(scene)
-        skipped = len(eligible) - len(pending)
-        if skipped:
-            print(f"[overlay-launch] {skipped} scene(s) already cached, skipped")
-    else:
-        pending = eligible
-
-    if not pending:
-        print(
-            f"[overlay-launch] DONE: 0 generated, {len(eligible) - len(pending)} skipped"
-        )
-        return [], [], missing
-
-    worker_count = workers if workers > 0 else _available_cpu_count()
-    worker_count = min(worker_count, len(pending))
-    print(
-        f"[overlay-launch] generating {len(pending)} scene(s) with {worker_count} worker(s)"
-    )
-    tasks = [
-        (scene, depth, input_selection, tracking, frame_count) for scene in pending
-    ]
-    with mp.get_context("spawn").Pool(worker_count) as pool:
-        results = pool.map(_generate_one, tasks)
-
-    succeeded = [scene for scene, ok, _ in results if ok]
-    failed = [(scene, detail) for scene, ok, detail in results if not ok]
-    for scene, detail in failed:
-        print(f"[overlay-launch] FAILED {scene}:\n{detail}")
-    print(
-        f"[overlay-launch] DONE: {len(succeeded)} generated, {len(failed)} failed, "
-        f"{len(eligible) - len(pending)} already cached"
-    )
-    return succeeded, failed, missing
-
-
-def main():
-    parser = argparse.ArgumentParser()
-    parser.add_argument("--depth", required=True)
-    parser.add_argument("--tracking", required=True)
-    parser.add_argument("--input", required=True, dest="input_selection")
-    parser.add_argument("--frames", type=int, required=True)
-    parser.add_argument(
-        "--scenes", default=None, help="comma-separated scenes (default: all)"
-    )
-    parser.add_argument("--rebuild", action="store_true")
-    parser.add_argument("--workers", type=int, default=0, help="0 = all available CPUs")
-    args = parser.parse_args()
-    selected = (
-        [s.strip() for s in args.scenes.split(",") if s.strip()]
-        if args.scenes
-        else all_scenes()
-    )
-    _succeeded, failed, _missing = launch(
-        args.depth,
-        args.input_selection,
-        args.tracking,
-        args.frames,
-        selected,
-        rebuild=args.rebuild,
-        workers=args.workers,
-    )
-    if failed:
-        raise SystemExit(1)
-
-
-if __name__ == "__main__":
-    main()

harness/C/prompts.py

@@ -1,24 +0,0 @@
-"""Combined video-frames + v2 spatial-code prompt construction."""
-
-from __future__ import annotations
-
-from harness.B import prompts as code_prompts
-
-FRAMES_NOTE = "These are frames of a video."
-VIDEO_NOTE = "This is a video."
-
-
-def build_prompt(spatial_code, question_type, question, options=None, video=False):
-    """Return the trailing text block for frames + spatial code.
-
-    The actual frame images are prepended separately by harness.A.models. The text uses
-    the same v2 spatial-code prompt as harness.B, plus the code+frames evidence note.
-    """
-    prompt = code_prompts.build_prompt(
-        spatial_code,
-        question_type,
-        question,
-        options,
-        frames_note=True,
-    )
-    return (VIDEO_NOTE if video else FRAMES_NOTE) + "\n" + prompt

harness/C/run.py

@@ -1,416 +0,0 @@
-"""Run one VLM over VSI-Bench questions with BOTH video frames and the scene's on-disk
-explicit spatial code, sourced from the exact same (depth, tracking,
-input_selection, frame_count) config.
-
-Writes one JSON file per question in the identical shape harness.A/B use -- carrying
-BOTH frame provenance (video path, frame indices/timestamps) and spatial-code
-provenance (format, path), since C uses both kinds of input. Scoring reuses the same
-real, unmodified official scorer harness.A, harness.B, and symbolic/run.py all use.
-"""
-
-from __future__ import annotations
-
-import argparse
-import json
-import sys
-from pathlib import Path
-
-WORKSPACE_ROOT = Path(__file__).resolve().parent.parent.parent
-if str(WORKSPACE_ROOT) not in sys.path:
-    sys.path.insert(0, str(WORKSPACE_ROOT))
-
-import inference as inference_config  # noqa: E402
-from harness.A import EXTENDED_MAX_NEW_TOKENS, MAX_NEW_TOKENS  # noqa: E402
-from harness.A import frames as frame_sampling  # noqa: E402
-from harness.A import models as vlm_models  # noqa: E402
-from harness.A import (
-    protocol_for_question,
-    question_group,
-    resolve_protocol_budgets,
-)  # noqa: E402
-from harness.A.run import _scalar_score, load_questions, vsi_official_eval  # noqa: E402
-from harness.B import (  # noqa: E402
-    DEFAULT_DEPTH,
-    DEFAULT_INPUT_SELECTION,
-    DEFAULT_SPATIAL_CODE_FORMAT,
-    DEFAULT_TRACKING,
-    DEPTH_VARIANTS,
-    INPUT_SELECTIONS,
-    TRACKING_MODES,
-)
-from harness.B import spatial_codes  # noqa: E402
-from harness.C import FRAMES_PER_VIDEO, RESULTS_DIR  # noqa: E402
-from harness.C import prompts as combined_prompts  # noqa: E402
-
-
-def results_dir_for(
-    model,
-    protocol,
-    spatial_code_format,
-    depth,
-    tracking,
-    input_selection,
-    frame_count,
-    results_dir=None,
-):
-    """Return the result root isolated by model + protocol + fixed explicit spatial code +
-    depth + tracking + input + frames. ``protocol`` is "base" (16-token) or
-    "<reasoning budget>" (e.g. "512") -- a real path segment, so records from
-    different protocols OR different reasoning budgets can never collide on disk."""
-    if results_dir is not None:
-        return Path(results_dir)
-    root = RESULTS_DIR / model / spatial_code_format / depth / tracking
-    if input_selection == "video":
-        return root / "video"
-    return root / input_selection / str(frame_count)
-
-
-def _build_record(
-    row, prompt, answer, metric_name, score, model, model_path, source_info
-):
-    """Assemble one question's full, untruncated result record (nothing summarized)."""
-    return {
-        "model": model,
-        "model_path": str(model_path),
-        "device": answer["device"],
-        "dtype": answer["dtype"],
-        "library_versions": answer["library_versions"],
-        "condition": (
-            f"{source_info['protocol']}:{source_info['spatial_code_format']}:"
-            f"{source_info['depth']}:{source_info['tracking']}:"
-            + (
-                "video"
-                if source_info["input_selection"] == "video"
-                else f"{source_info['input_selection']}:{source_info['frame_count']}"
-            )
-        ),
-        "protocol": source_info["protocol"],
-        "question_group": question_group(row["question_type"]),
-        "spatial_code_format": source_info["spatial_code_format"],
-        "input_selection": source_info["input_selection"],
-        "frame_count": source_info["frame_count"],
-        "depth": source_info["depth"],
-        "tracking": source_info["tracking"],
-        "spatial_code_path": source_info["spatial_code_path"],
-        "video_path": source_info["video_path"],
-        "frame_indices": source_info["frame_indices"],
-        "frame_timestamps_seconds": source_info["frame_timestamps"],
-        "scene": row["scene_name"],
-        "dataset": row.get("dataset"),
-        "question_id": row["id"],
-        "question_type": row["question_type"],
-        "question": row["question"],
-        "options": row.get("options"),
-        "full_prompt": prompt,
-        "rendered_prompt": answer["prompt_text"],
-        "answer_expected": row["ground_truth"],
-        "answer_given": answer["answer_text"],
-        "answer_raw": answer["answer_raw"],
-        "input_token_count": answer["input_token_count"],
-        "vision_input_shapes": answer["vision_input_shapes"],
-        "output_token_ids": answer["output_token_ids"],
-        "output_token_count": answer["output_token_count"],
-        "hit_token_limit": answer["hit_token_limit"],
-        "eos_token_ids": answer["eos_token_ids"],
-        "generation_seconds": answer["generation_seconds"],
-        "generation_config": answer["generation_config"],
-        "reasoning_text": answer.get("reasoning_text"),
-        "reasoning_raw": answer.get("reasoning_raw"),
-        "reasoning_token_ids": answer.get("reasoning_token_ids"),
-        "reasoning_token_count": answer.get("reasoning_token_count"),
-        "reasoning_hit_limit": answer.get("reasoning_hit_limit"),
-        "forced": answer.get("forced", False),
-        "forced_input_token_count": answer.get("forced_input_token_count"),
-        "metric": metric_name,
-        "score": score,
-    }
-
-
-def write_question_result(
-    row,
-    prompt,
-    answer,
-    metric_name,
-    score,
-    model,
-    model_path,
-    source_info,
-    results_dir=None,
-):
-    """Write one question's full, untruncated result record. Return (path, record)."""
-    record = _build_record(
-        row, prompt, answer, metric_name, score, model, model_path, source_info
-    )
-    root = results_dir_for(
-        model,
-        source_info["protocol"],
-        source_info["spatial_code_format"],
-        source_info["depth"],
-        source_info["tracking"],
-        source_info["input_selection"],
-        source_info["frame_count"],
-        results_dir,
-    )
-    scene_dir = root / record["scene"]
-    scene_dir.mkdir(parents=True, exist_ok=True)
-    path = scene_dir / f"{row['id']}.json"
-    with path.open("w", encoding="utf-8") as stream:
-        json.dump(record, stream, indent=1)
-    return path, record
-
-
-def run(
-    model,
-    spatial_code_format=DEFAULT_SPATIAL_CODE_FORMAT,
-    input_selection=DEFAULT_INPUT_SELECTION,
-    frame_count=FRAMES_PER_VIDEO,
-    video=False,
-    depth=DEFAULT_DEPTH,
-    tracking=DEFAULT_TRACKING,
-    scene=None,
-    scenes=None,
-    limit=None,
-    device="cuda",
-    jsonl_path=None,
-    results_dir=None,
-    write_results=True,
-    adapter=None,
-    extended=True,
-    reasoning_budget=EXTENDED_MAX_NEW_TOKENS,
-    force_budget=MAX_NEW_TOKENS,
-):
-    """Answer every matching question with one model, given both its scene's video
-    frames AND its spatial code as text -- both sourced from the same (depth, tracking,
-    input_selection, frame_count) config, so they never mismatch.
-
-    Uses ``adapter.answer_extended`` (a large ``reasoning_budget`` first pass, with a
-    short forced second call only if the model doesn't conclude within it) as the
-    standing default protocol, same as harness.B, since C combines the same complex
-    spatial-code JSON with the video frames. ``extended=False`` runs harness.A's exact
-    fixed 16-token base protocol instead (plain ``adapter.answer``), so the protocol x
-    representation grid can be measured with the identical generation mechanism in
-    every cell.
-
-    Pass a pre-loaded ``adapter`` (as harness.C.launch's persistent per-GPU workers do)
-    to reuse one already-loaded model across many calls; the caller then owns unloading
-    it. Without one, ``run`` loads and unloads its own adapter, same as harness.A/B.
-    """
-    if video:
-        input_selection = "video"
-        frame_count = None
-    elif frame_count is None or frame_count < 1:
-        raise ValueError("frame_count must be positive in frames mode")
-    if spatial_code_format != "explicit":
-        raise ValueError("Harness C supports explicit spatial codes only")
-    protocol = "mixed"
-    results_dir = results_dir_for(
-        model,
-        protocol,
-        spatial_code_format,
-        depth,
-        tracking,
-        input_selection,
-        frame_count,
-        results_dir,
-    )
-    rows = load_questions(jsonl_path, scene, scenes, limit)
-    if not rows:
-        return []
-    owns_adapter = adapter is None
-    if owns_adapter:
-        adapter = vlm_models.get_adapter(model)
-        adapter.load_model(device)
-    source_cache = {}
-    results = []
-    try:
-        for row in rows:
-            protocol = protocol_for_question(row["question_type"])
-            scene_id = row["scene_name"]
-            if scene_id not in source_cache:
-                video_path = inference_config.video_path(scene_id, row.get("dataset"))
-                if video:
-                    frame_images = video_path
-                    frame_timestamps = None
-                    frame_indices = None
-                else:
-                    frame_images, frame_timestamps, frame_indices = (
-                        frame_sampling.sample_frames(
-                            video_path, frame_count, input_selection
-                        )
-                    )
-                code, code_path = spatial_codes.load_spatial_code(
-                    scene_id,
-                    depth,
-                    input_selection,
-                    tracking,
-                    frame_count,
-                    spatial_code_format,
-                )
-                source_cache[scene_id] = {
-                    "video_path": video_path,
-                    "frame_images": frame_images,
-                    "frame_timestamps": frame_timestamps,
-                    "frame_indices": frame_indices,
-                    "code": code,
-                    "spatial_code_path": code_path,
-                }
-            cached = source_cache[scene_id]
-            prompt = combined_prompts.build_prompt(
-                cached["code"],
-                row["question_type"],
-                row["question"],
-                row.get("options"),
-                video=video,
-            )
-            answer = (
-                adapter.answer_extended(
-                    cached["frame_images"],
-                    prompt,
-                    reasoning_budget=reasoning_budget,
-                    force_budget=force_budget,
-                )
-                if protocol == "thinking"
-                else adapter.answer(
-                    cached["frame_images"], prompt, max_new_tokens=MAX_NEW_TOKENS
-                )
-            )
-            doc = {
-                "question_type": row["question_type"],
-                "ground_truth": row["ground_truth"],
-            }
-            score_doc = vsi_official_eval.vsibench_process_results(
-                doc, [answer["answer_text"]]
-            )["vsibench_score"]
-            metric_name, score = _scalar_score(row["question_type"], score_doc)
-            source_info = {
-                "protocol": protocol,
-                "spatial_code_format": spatial_code_format,
-                "input_selection": input_selection,
-                "frame_count": frame_count,
-                "depth": depth,
-                "tracking": tracking,
-                "spatial_code_path": cached["spatial_code_path"],
-                "video_path": cached["video_path"],
-                "frame_indices": cached["frame_indices"],
-                "frame_timestamps": cached["frame_timestamps"],
-            }
-            if write_results:
-                path, record = write_question_result(
-                    row,
-                    prompt,
-                    answer,
-                    metric_name,
-                    score,
-                    model,
-                    adapter.model_path,
-                    source_info,
-                    results_dir,
-                )
-            else:
-                path = None
-                record = _build_record(
-                    row,
-                    prompt,
-                    answer,
-                    metric_name,
-                    score,
-                    model,
-                    adapter.model_path,
-                    source_info,
-                )
-            record["result_path"] = str(path) if path else None
-            results.append(record)
-    finally:
-        if owns_adapter:
-            adapter.unload()
-    return results
-
-
-def main():
-    parser = argparse.ArgumentParser()
-    parser.add_argument("--model", required=True, choices=vlm_models.available_models())
-    parser.add_argument("--scene", default=None, help="restrict to one VSI-Bench scene")
-    parser.add_argument(
-        "--input-selection",
-        default=None,
-        choices=INPUT_SELECTIONS,
-        dest="input_selection",
-    )
-    input_mode = parser.add_mutually_exclusive_group(required=True)
-    input_mode.add_argument("--frames", type=int)
-    input_mode.add_argument("--video", action="store_true")
-    parser.add_argument("--depth", default=DEFAULT_DEPTH, choices=DEPTH_VARIANTS)
-    parser.add_argument("--tracking", default=DEFAULT_TRACKING, choices=TRACKING_MODES)
-    parser.add_argument(
-        "--limit", type=int, default=None, help="cap the number of questions"
-    )
-    parser.add_argument("--device", default="cuda")
-    parser.add_argument(
-        "--results-dir",
-        default=None,
-        help="override the default results/C/<model>/explicit/"
-        "<depth>/<tracking>/{<input>/<frames>|video} root",
-    )
-    parser.add_argument(
-        "--no-write",
-        action="store_true",
-        help="skip writing per-question JSON files; print/score only",
-    )
-    parser.add_argument(
-        "--reasoning-budget",
-        type=int,
-        default=None,
-        help="thinking questions only (default: 2048)",
-    )
-    parser.add_argument(
-        "--force-budget",
-        type=int,
-        default=None,
-        help="thinking questions only (default: 16)",
-    )
-    args = parser.parse_args()
-    if args.video:
-        if args.input_selection is not None:
-            parser.error("--input-selection cannot be used with --video")
-    else:
-        if args.input_selection is None:
-            parser.error("--input-selection is required with --frames")
-        if args.frames < 1:
-            parser.error("--frames must be positive")
-    resolve_protocol_budgets(parser, args)
-    results = run(
-        args.model,
-        spatial_code_format=DEFAULT_SPATIAL_CODE_FORMAT,
-        input_selection=args.input_selection,
-        frame_count=args.frames,
-        video=args.video,
-        depth=args.depth,
-        tracking=args.tracking,
-        scene=args.scene,
-        limit=args.limit,
-        device=args.device,
-        results_dir=args.results_dir,
-        write_results=not args.no_write,
-        extended=True,
-        reasoning_budget=args.reasoning_budget,
-        force_budget=args.force_budget,
-    )
-
-    for result in results:
-        print(
-            f"[{result['scene']}#{result['question_id']}] {result['question_type']}: "
-            f"pred={result['answer_given']!r} gt={result['answer_expected']!r} "
-            f"score={result['score']} ({result['generation_seconds']:.2f}s) -> "
-            f"{result['result_path']}"
-        )
-    if results:
-        mean_score = sum(r["score"] for r in results) / len(results)
-        total_seconds = sum(r["generation_seconds"] for r in results)
-        print(
-            f"\n{len(results)} questions, mean vsibench_score={mean_score:.4f}, "
-            f"total generation time={total_seconds:.1f}s"
-        )
-
-
-if __name__ == "__main__":
-    main()

harness/C/sweep.py

@@ -1,202 +0,0 @@
-"""Sweep any set of models x depths x trackings x
-input-selections x frame-counts.
-
-Every (model, spatial_code_format, depth, tracking, input_selection, frame_count)
-6-tuple in the sweep is run through ``harness.C.launch.launch`` in turn, so each
-combination individually saturates every visible GPU before the next one starts.
-Depth/tracking default to this workspace's single shipped production config
-(DEFAULT_DEPTH/DEFAULT_TRACKING) when --depths/--trackings aren't given, but are real
-sweepable axes like every other dimension here -- pass --depths all / --trackings all
-(or an explicit comma list) to sweep them too.
-"""
-
-from __future__ import annotations
-
-import argparse
-from pathlib import Path
-import sys
-
-HERE = Path(__file__).resolve().parent
-WORKSPACE_ROOT = HERE.parent.parent
-if str(WORKSPACE_ROOT) not in sys.path:
-    sys.path.insert(0, str(WORKSPACE_ROOT))
-
-from harness.A import models as vlm_models  # noqa: E402
-from harness.A import resolve_protocol_budgets  # noqa: E402
-from harness.A import EXTENDED_MAX_NEW_TOKENS  # noqa: E402
-from harness.A.sweep import _parse_csv_choice, _parse_frame_counts  # noqa: E402
-from harness.B import (  # noqa: E402
-    DEFAULT_DEPTH,
-    DEFAULT_SPATIAL_CODE_FORMAT,
-    DEFAULT_TRACKING,
-    DEPTH_VARIANTS,
-    INPUT_SELECTIONS,
-    TRACKING_MODES,
-)
-from harness.C import launch as harness_launch  # noqa: E402
-
-
-def build_plan(
-    models, spatial_code_formats, input_selections, frame_counts, depths, trackings
-):
-    """Return every (model, spatial_code_format, depth, tracking, input_selection,
-    frame_count) 6-tuple in the sweep, in a stable, cheapest-first-ish order (frame
-    count sorted first)."""
-    return [
-        (model, spatial_code_format, depth, tracking, input_selection, frame_count)
-        for frame_count in sorted(frame_counts)
-        for model in models
-        for spatial_code_format in spatial_code_formats
-        for depth in depths
-        for tracking in trackings
-        for input_selection in input_selections
-    ]
-
-
-def sweep(
-    models,
-    spatial_code_formats,
-    input_selections,
-    frame_counts,
-    selected_scenes,
-    video=False,
-    depths=(DEFAULT_DEPTH,),
-    trackings=(DEFAULT_TRACKING,),
-    results_dir=None,
-    rebuild=False,
-    extended=True,
-    reasoning_budget=EXTENDED_MAX_NEW_TOKENS,
-):
-    """Run every sweep combination across all visible GPUs."""
-    plan = build_plan(
-        models, spatial_code_formats, input_selections, frame_counts, depths, trackings
-    )
-    for index, (
-        model,
-        spatial_code_format,
-        depth,
-        tracking,
-        input_selection,
-        frame_count,
-    ) in enumerate(plan, start=1):
-        print(
-            f"=== sweep {index}/{len(plan)}: {model}/"
-            f"{spatial_code_format}/{depth}/{tracking}/"
-            + ("video" if video else f"{input_selection}/{frame_count}")
-            + " ===",
-            flush=True,
-        )
-        harness_launch.launch(
-            model,
-            spatial_code_format,
-            input_selection,
-            frame_count,
-            selected_scenes,
-            video=video,
-            depth=depth,
-            tracking=tracking,
-            results_dir=results_dir,
-            rebuild=rebuild,
-            extended=extended,
-            reasoning_budget=reasoning_budget,
-        )
-
-
-def main():
-    parser = argparse.ArgumentParser()
-    parser.add_argument("scene", nargs="?")
-    parser.add_argument(
-        "--scenes",
-        help="comma-separated scenes (cannot be combined with positional scene)",
-    )
-    parser.add_argument(
-        "--models",
-        required=True,
-        help=f"comma-separated models (or 'all'); one of {vlm_models.available_models()}",
-    )
-    parser.add_argument(
-        "--input-selections",
-        required=False,
-        dest="input_selections",
-        help=f"comma-separated selections (or 'all'); one of {INPUT_SELECTIONS}",
-    )
-    input_mode = parser.add_mutually_exclusive_group(required=True)
-    input_mode.add_argument(
-        "--frames", help="comma-separated frame counts, e.g. 16,32,64"
-    )
-    input_mode.add_argument("--video", action="store_true")
-    parser.add_argument(
-        "--depths",
-        default=DEFAULT_DEPTH,
-        help=f"comma-separated depths (or 'all'); one of {DEPTH_VARIANTS}",
-    )
-    parser.add_argument(
-        "--trackings",
-        default=DEFAULT_TRACKING,
-        help=f"comma-separated tracking modes (or 'all'); one of {TRACKING_MODES}",
-    )
-    parser.add_argument("--results-dir", default=None)
-    parser.add_argument("--rebuild", action="store_true")
-    parser.add_argument(
-        "--reasoning-budget",
-        type=int,
-        default=None,
-        dest="reasoning_budget",
-        help="thinking-protocol first-pass budget (the calibrated value from "
-        "preregistration.md, e.g. 512)",
-    )
-    args = parser.parse_args()
-    resolve_protocol_budgets(parser, args)
-    if args.scene and args.scenes:
-        parser.error("positional scene and --scenes cannot be used together")
-
-    try:
-        models = _parse_csv_choice(
-            args.models, vlm_models.available_models(), "--models"
-        )
-        spatial_code_formats = (DEFAULT_SPATIAL_CODE_FORMAT,)
-        if args.video:
-            if args.input_selections is not None:
-                raise ValueError("--input-selections cannot be used with --video")
-            input_selections = ["video"]
-            frame_counts = [None]
-        else:
-            if args.input_selections is None:
-                raise ValueError("--input-selections is required with --frames")
-            input_selections = _parse_csv_choice(
-                args.input_selections, INPUT_SELECTIONS, "--input-selections"
-            )
-            frame_counts = _parse_frame_counts(args.frames)
-        depths = _parse_csv_choice(args.depths, DEPTH_VARIANTS, "--depths")
-        trackings = _parse_csv_choice(args.trackings, TRACKING_MODES, "--trackings")
-    except ValueError as exc:
-        parser.error(str(exc))
-
-    if args.scenes is not None:
-        selected = [scene.strip() for scene in args.scenes.split(",") if scene.strip()]
-        if not selected:
-            parser.error("--scenes must contain at least one scene")
-        selected = list(dict.fromkeys(selected))
-    else:
-        from harness.A.launch import scenes
-
-        selected = [args.scene] if args.scene else scenes()
-
-    sweep(
-        models,
-        spatial_code_formats,
-        input_selections,
-        frame_counts,
-        selected,
-        video=args.video,
-        depths=depths,
-        trackings=trackings,
-        results_dir=args.results_dir,
-        rebuild=args.rebuild,
-        extended=True,
-        reasoning_budget=args.reasoning_budget,
-    )
-
-
-if __name__ == "__main__":
-    main()

harness/D/__init__.py

@@ -1,42 +0,0 @@
-"""Harness D: harness.B's spatial-code-as-text routing, but the spatial code is the
-GROUND-TRUTH one (encoder.ground_truth -- built from the dataset's own 3D annotations,
-zero perception error) instead of the SAM3+DA3-perceived one B reads off disk.
-
-Ground truth has no depth/tracking/input-selection/frame-count axis at all (it is built
-once per scene directly from annotations, not from any particular video-frame sampling
-run) -- so D only sweeps model x spatial_code_format, both formats, mirroring exactly
-the (model, format) grid harness.B actually swept at its one frozen (selection, frames)
-config. Deliberately NOT narrowed to just B's winning format: ground-truth codes cost
-nothing extra to build across formats (no encoder GPU pass at all), so running both
-formats is free relative to running one, and it is the only way to see whether a
-format's real-vs-perfect-perception ranking flips.
-
-Results are written in the identical per-question JSON shape harness.A/B/C use, so D's
-records are directly comparable and drop straight into analysis.aggregate/analysis.compare
-alongside every other harness. harness.D.symbolic_eval additionally answers every
-question with the real symbolic solver run directly against the ground-truth code (no
-VLM at all) -- the perfect-information ceiling -- written through symbolic.run's own
-writer into results/symbolic/ground truth/<format>/, the same results family every
-other symbolic-solver result already lives in, not a separate results/D/... location.
-"""
-
-from __future__ import annotations
-
-import os
-from pathlib import Path
-
-from harness.A import (
-    DO_SAMPLE,
-    JSONL,
-    MAX_NEW_TOKENS,
-    MODEL_PATHS,
-    TEMPERATURE,
-    WORKSPACE_ROOT,
-)
-from harness.B import SPATIAL_CODE_FORMATS
-
-DEFAULT_SPATIAL_CODE_FORMAT = "explicit"
-
-# One JSON per question, matching harness.B's layout minus the axes ground truth doesn't
-# have: results/D/<model>/code/<protocol>/<spatial_code_format>/<scene>/<question_id>.json
-RESULTS_DIR = Path(os.environ.get("VSI_HARNESS_D_RESULTS_DIR", "/root/results/D"))

harness/D/launch.py

@@ -1,340 +0,0 @@
-"""Keep every visible GPU busy with persistent harness-D inference workers.
-
-Same shape as ``harness.B.launch``, minus the depth/tracking/input-selection/frame-count
-axes ground truth doesn't have: one persistent worker process per visible GPU, pulling
-scenes off a shared queue, each loading its model exactly once and reusing it for every
-scene it's assigned (via ``run.run(..., adapter=...)``). One invocation covers one
-(model, spatial_code_format) pair across every requested scene; sweep multiple pairs by
-invoking this once per pair (see harness.D.sweep).
-"""
-
-from __future__ import annotations
-
-import argparse
-import importlib.util
-import multiprocessing as mp
-import os
-from pathlib import Path
-import sys
-import traceback
-
-HERE = Path(__file__).resolve().parent
-WORKSPACE_ROOT = HERE.parent.parent
-if str(WORKSPACE_ROOT) not in sys.path:
-    sys.path.insert(0, str(WORKSPACE_ROOT))
-
-from encoder.ground_truth import scenes as ground_truth_scenes  # noqa: E402
-from harness.A import EXTENDED_MAX_NEW_TOKENS, MAX_NEW_TOKENS  # noqa: E402
-from harness.A import models as vlm_models  # noqa: E402
-from harness.B import (
-    DEFAULT_INPUT_SELECTION,
-    FRAMES_PER_VIDEO,
-    INPUT_SELECTIONS,
-)  # noqa: E402
-from harness.D import DEFAULT_SPATIAL_CODE_FORMAT, SPATIAL_CODE_FORMATS  # noqa: E402
-from inference.launch import available_cpu_count, visible_gpus  # noqa: E402
-
-
-def _load_run_module():
-    spec = importlib.util.spec_from_file_location("_harness_D_run", HERE / "run.py")
-    module = importlib.util.module_from_spec(spec)
-    sys.modules[spec.name] = module
-    spec.loader.exec_module(module)
-    return module
-
-
-def _worker(
-    tasks,
-    results,
-    model,
-    spatial_code_format,
-    results_dir,
-    gpu,
-    cpu_threads,
-    extended,
-    reasoning_budget,
-    force_budget,
-    frames,
-    frame_selection,
-    frame_count,
-    raw_budget,
-    thinking,
-):
-    if gpu is not None:
-        os.environ["CUDA_VISIBLE_DEVICES"] = str(gpu)
-    for variable in ("OMP_NUM_THREADS", "MKL_NUM_THREADS", "OPENBLAS_NUM_THREADS"):
-        os.environ[variable] = str(cpu_threads)
-    run = _load_run_module()
-    adapter = None
-    load_error = None
-    try:
-        adapter = vlm_models.get_adapter(model)
-        if thinking and not adapter.set_thinking(True):
-            raise ValueError(f"{model} has no native thinking mode to enable")
-        adapter.load_model("cuda:0" if gpu is not None else "cpu")
-    except Exception:
-        load_error = traceback.format_exc()
-    while True:
-        scene = tasks.get()
-        if scene is None:
-            return
-        if load_error is not None:
-            results.put((scene, False, load_error))
-            continue
-        try:
-            answered = run.run(
-                model,
-                spatial_code_format=spatial_code_format,
-                scene=scene,
-                results_dir=results_dir,
-                adapter=adapter,
-                extended=extended,
-                reasoning_budget=reasoning_budget,
-                force_budget=force_budget,
-                frames=frames,
-                frame_selection=frame_selection,
-                frame_count=frame_count,
-                raw_budget=raw_budget,
-                thinking=thinking,
-            )
-            mean_score = (
-                sum(r["score"] for r in answered) / len(answered) if answered else None
-            )
-            results.put(
-                (scene, True, f"{len(answered)} question(s), mean_score={mean_score}")
-            )
-        except Exception:
-            results.put((scene, False, traceback.format_exc()))
-
-
-def launch(
-    model,
-    spatial_code_format,
-    selected,
-    results_dir=None,
-    rebuild=False,
-    extended=True,
-    reasoning_budget=EXTENDED_MAX_NEW_TOKENS,
-    force_budget=MAX_NEW_TOKENS,
-    frames=False,
-    frame_selection=DEFAULT_INPUT_SELECTION,
-    frame_count=FRAMES_PER_VIDEO,
-    raw_budget=None,
-    thinking=False,
-):
-    """Answer every question for ``selected`` scenes, sharded across every visible GPU.
-
-    ``raw_budget`` (mutually exclusive with ``extended``) runs the raw-budget arm:
-    base-protocol mechanics at this token cap, under its own truncated/<budget> path
-    segment -- see harness.D.run.run."""
-    if extended and raw_budget is not None:
-        raise ValueError("extended and raw_budget are mutually exclusive")
-    protocol = (
-        f"{reasoning_budget}"
-        if extended
-        else f"truncated/{raw_budget}" if raw_budget is not None else "base"
-    )
-    condition = f"{model}/{protocol}/{spatial_code_format}"
-    if frames:
-        condition += f"/frames/{frame_selection}/{frame_count}"
-    run = _load_run_module()
-    root = run.results_dir_for(
-        model,
-        protocol,
-        spatial_code_format,
-        results_dir,
-        frames=frames,
-        frame_selection=frame_selection,
-        frame_count=frame_count,
-    )
-    pending = []
-    completed = 0
-    for scene in selected:
-        rows = run.load_questions(scene=scene)
-        if not rows:
-            raise ValueError(
-                f"no questions found for scene {scene!r}; check the manifest/scene selection"
-            )
-        answered = all((root / scene / f"{row['id']}.json").is_file() for row in rows)
-        if answered and not rebuild:
-            completed += 1
-            print(
-                f"[{condition} {completed}/{len(selected)}] {scene}: skipped",
-                flush=True,
-            )
-        else:
-            pending.append(scene)
-    if not pending:
-        print(f"[{condition}] DONE: {len(selected)} ok, 0 failed")
-        return
-
-    gpus = visible_gpus()
-    worker_count = min(len(pending), len(gpus) if gpus else 1)
-    assignments = gpus[:worker_count] if gpus else [None]
-    cpu_count = available_cpu_count()
-    cpu_threads = max(1, cpu_count // worker_count)
-    print(
-        f"[{condition}] starting {worker_count} persistent worker(s); "
-        f"GPUs={assignments}; CPU threads/worker={cpu_threads}",
-        flush=True,
-    )
-
-    context = mp.get_context("spawn")
-    tasks, results = context.Queue(), context.Queue()
-    for scene in pending:
-        tasks.put(scene)
-    for _ in range(worker_count):
-        tasks.put(None)
-    workers = [
-        context.Process(
-            target=_worker,
-            args=(
-                tasks,
-                results,
-                model,
-                spatial_code_format,
-                results_dir,
-                gpu,
-                cpu_threads,
-                extended,
-                reasoning_budget,
-                force_budget,
-                frames,
-                frame_selection,
-                frame_count,
-                raw_budget,
-                thinking,
-            ),
-        )
-        for gpu in assignments
-    ]
-    for worker in workers:
-        worker.start()
-    failed = []
-    for finished in range(1, len(pending) + 1):
-        scene, ok, detail = results.get()
-        if not ok:
-            failed.append(scene)
-        print(
-            f"[{condition} {completed + finished}/{len(selected)}] {scene}: "
-            f"{'done' if ok else 'FAILED'}\n{detail}",
-            flush=True,
-        )
-    for worker in workers:
-        worker.join()
-    print(
-        f"[{condition}] DONE: {len(pending) - len(failed)} answered, {completed} skipped, "
-        f"{len(failed)} failed"
-    )
-    if failed:
-        raise SystemExit(1)
-
-
-def scenes():
-    """Every scene that both has a real VSI-Bench question AND ground-truth annotation
-    coverage -- i.e. every scene harness.A/B/C could ever be run on (all of them have GT,
-    since encoder.ground_truth covers the full 288-scene meta_info set, a superset of any
-    perception-built spatial code's coverage)."""
-    from harness.A.launch import scenes as vsi_scenes
-
-    ground_truth = set(ground_truth_scenes())
-    return [scene for scene in vsi_scenes() if scene in ground_truth]
-
-
-def main():
-    parser = argparse.ArgumentParser()
-    parser.add_argument("scene", nargs="?")
-    parser.add_argument(
-        "--scenes",
-        help="comma-separated scenes (cannot be combined with positional scene)",
-    )
-    parser.add_argument("--model", required=True, choices=vlm_models.available_models())
-    parser.add_argument(
-        "--spatial-code-format",
-        default=DEFAULT_SPATIAL_CODE_FORMAT,
-        choices=SPATIAL_CODE_FORMATS,
-        dest="spatial_code_format",
-    )
-    parser.add_argument("--results-dir", default=None)
-    parser.add_argument("--rebuild", action="store_true")
-    parser.add_argument(
-        "--base-protocol",
-        action="store_true",
-        help="run harness.A's exact fixed 16-token protocol instead of the extended default",
-    )
-    parser.add_argument(
-        "--with-frames",
-        action="store_true",
-        dest="frames",
-        help="frames+ground-truth-code arm: also sample and show the scene's raw video "
-        "frames alongside the ground-truth code (default sampling: uniform, 32 frames -- "
-        "the frozen Step-1 config)",
-    )
-    parser.add_argument(
-        "--frame-selection",
-        default=DEFAULT_INPUT_SELECTION,
-        choices=INPUT_SELECTIONS,
-        dest="frame_selection",
-        help="only used with --with-frames",
-    )
-    parser.add_argument(
-        "--frames-per-video",
-        type=int,
-        default=FRAMES_PER_VIDEO,
-        dest="frame_count",
-        help="only used with --with-frames",
-    )
-    parser.add_argument(
-        "--thinking",
-        action="store_true",
-        help="enable the model's native thinking mode where supported; errors on models without the switch",
-    )
-    parser.add_argument("--reasoning-budget", type=int, default=EXTENDED_MAX_NEW_TOKENS)
-    parser.add_argument("--force-budget", type=int, default=MAX_NEW_TOKENS)
-    parser.add_argument(
-        "--truncated-budget",
-        type=int,
-        default=None,
-        help="raw-budget arm: base-protocol mechanics (single generation, no forced "
-        "rescue) at this token cap instead of the hardcoded 16 (mutually exclusive "
-        "with --base-protocol)",
-    )
-    args = parser.parse_args()
-    if args.scene and args.scenes:
-        parser.error("positional scene and --scenes cannot be used together")
-    if args.scenes is not None:
-        selected = [scene.strip() for scene in args.scenes.split(",") if scene.strip()]
-        if not selected:
-            parser.error("--scenes must contain at least one scene")
-        selected = list(dict.fromkeys(selected))
-    else:
-        selected = [args.scene] if args.scene else scenes()
-    if args.reasoning_budget < 1:
-        parser.error("--reasoning-budget must be positive")
-    if args.force_budget < 1:
-        parser.error("--force-budget must be positive")
-    if args.frame_count < 1:
-        parser.error("--frames-per-video must be positive")
-    if args.truncated_budget is not None and args.truncated_budget < 1:
-        parser.error("--truncated-budget must be positive")
-    if args.base_protocol and args.truncated_budget is not None:
-        parser.error("--base-protocol and --truncated-budget are mutually exclusive")
-    launch(
-        args.model,
-        args.spatial_code_format,
-        selected,
-        results_dir=args.results_dir,
-        rebuild=args.rebuild,
-        extended=not args.base_protocol and args.truncated_budget is None,
-        frames=args.frames,
-        frame_selection=args.frame_selection,
-        frame_count=args.frame_count,
-        thinking=args.thinking,
-        reasoning_budget=args.reasoning_budget,
-        force_budget=args.force_budget,
-        raw_budget=args.truncated_budget,
-    )
-
-
-if __name__ == "__main__":
-    main()

harness/D/prompts.py

@@ -1,9 +0,0 @@
-"""Ground-truth spatial-code prompt construction.
-
-Ground-truth and perceived code use the same v2 prompt text; only the loaded code file
-differs.
-"""
-
-from __future__ import annotations
-
-from harness.B.prompts import build_prompt

harness/D/run.py

@@ -1,457 +0,0 @@
-"""Run one VLM over VSI-Bench questions through harness D's ground-truth-spatial-code-
-as-text routing.
-
-Writes one JSON file per question in the identical shape harness.A/B/C use -- the
-frame-provenance fields are replaced with spatial-code provenance fields
-(spatial_code_format, spatial_code_path), since D has no video frames and no depth/
-tracking/input-selection/frame-count axis at all (ground truth is built once per scene
-straight from dataset annotations). Scoring reuses the same real, unmodified official
-scorer every harness uses.
-"""
-
-from __future__ import annotations
-
-import argparse
-import json
-import sys
-from pathlib import Path
-
-WORKSPACE_ROOT = Path(__file__).resolve().parent.parent.parent
-if str(WORKSPACE_ROOT) not in sys.path:
-    sys.path.insert(0, str(WORKSPACE_ROOT))
-
-import inference as inference_config  # noqa: E402
-from harness.A import EXTENDED_MAX_NEW_TOKENS, MAX_NEW_TOKENS  # noqa: E402
-from harness.A import frames as frame_sampling  # noqa: E402
-from harness.A import models as vlm_models  # noqa: E402
-from harness.A.run import _scalar_score, load_questions, vsi_official_eval  # noqa: E402
-from harness.B import (
-    DEFAULT_INPUT_SELECTION,
-    FRAMES_PER_VIDEO,
-    INPUT_SELECTIONS,
-)  # noqa: E402
-from harness.C import prompts as combined_prompts  # noqa: E402
-from harness.D import (
-    DEFAULT_SPATIAL_CODE_FORMAT,
-    RESULTS_DIR,
-    SPATIAL_CODE_FORMATS,
-)  # noqa: E402
-from harness.D import prompts as code_prompts  # noqa: E402
-from harness.D import spatial_codes  # noqa: E402
-
-
-def results_dir_for(
-    model,
-    protocol,
-    spatial_code_format,
-    results_dir=None,
-    frames=False,
-    frame_selection=DEFAULT_INPUT_SELECTION,
-    frame_count=FRAMES_PER_VIDEO,
-):
-    """Return the result root isolated by model + protocol + spatial-code-format.
-    ``protocol`` is "base" (16-token) or "<reasoning budget>" (e.g. "512") -- a real path segment, so records from different protocols OR
-    different reasoning budgets can never collide on disk.
-
-    ``frames=True`` (the frames+ground-truth-code arm) selects the sibling
-    "code + frames" branch and appends "<selection>/<count>" -- video frames have no bearing on which ground-truth
-    code gets loaded (ground truth has no depth/tracking/input-selection axis at all;
-    see harness/D/__init__.py), but they DO change what the model sees, so this arm's
-    records must never share a path with the text-only condition's."""
-    if results_dir is not None:
-        return Path(results_dir)
-    root = (
-        RESULTS_DIR
-        / model
-        / ("code + frames" if frames else "code")
-        / protocol
-        / spatial_code_format
-    )
-    if frames:
-        root = root / frame_selection / str(frame_count)
-    return root
-
-
-def _build_record(
-    row, prompt, answer, metric_name, score, model, model_path, code_info
-):
-    """Assemble one question's full, untruncated result record (nothing summarized).
-
-    ``code_info`` carries frame provenance (``video_path``, ``frame_indices``,
-    ``frame_timestamps``) only for the frames+ground-truth-code arm; all three are None
-    on the standard text-only condition, matching how harness.A/B/D's other optional
-    fields (``reasoning_text`` etc.) are present-but-null rather than absent."""
-    condition = f"{code_info['protocol']}:{code_info['spatial_code_format']}"
-    if code_info.get("frames"):
-        condition += (
-            f":frames:{code_info['frame_selection']}:{code_info['frame_count']}"
-        )
-    return {
-        "model": model,
-        "model_path": str(model_path),
-        "device": answer["device"],
-        "dtype": answer["dtype"],
-        "library_versions": answer["library_versions"],
-        "condition": condition,
-        "protocol": code_info["protocol"],
-        "spatial_code_format": code_info["spatial_code_format"],
-        "spatial_code_path": code_info["spatial_code_path"],
-        "frames": code_info.get("frames", False),
-        "frame_selection": code_info.get("frame_selection"),
-        "frame_count": code_info.get("frame_count"),
-        "video_path": code_info.get("video_path"),
-        "frame_indices": code_info.get("frame_indices"),
-        "frame_timestamps_seconds": code_info.get("frame_timestamps"),
-        "scene": row["scene_name"],
-        "dataset": row.get("dataset"),
-        "question_id": row["id"],
-        "question_type": row["question_type"],
-        "question": row["question"],
-        "options": row.get("options"),
-        "full_prompt": prompt,
-        "rendered_prompt": answer["prompt_text"],
-        "answer_expected": row["ground_truth"],
-        "answer_given": answer["answer_text"],
-        "answer_raw": answer["answer_raw"],
-        "input_token_count": answer["input_token_count"],
-        "vision_input_shapes": answer["vision_input_shapes"],
-        "output_token_ids": answer["output_token_ids"],
-        "output_token_count": answer["output_token_count"],
-        "hit_token_limit": answer["hit_token_limit"],
-        "eos_token_ids": answer["eos_token_ids"],
-        "generation_seconds": answer["generation_seconds"],
-        "generation_config": answer["generation_config"],
-        "reasoning_text": answer.get("reasoning_text"),
-        "reasoning_raw": answer.get("reasoning_raw"),
-        "reasoning_token_ids": answer.get("reasoning_token_ids"),
-        "reasoning_token_count": answer.get("reasoning_token_count"),
-        "reasoning_hit_limit": answer.get("reasoning_hit_limit"),
-        "forced": answer.get("forced", False),
-        "forced_input_token_count": answer.get("forced_input_token_count"),
-        "metric": metric_name,
-        "score": score,
-    }
-
-
-def write_question_result(
-    row,
-    prompt,
-    answer,
-    metric_name,
-    score,
-    model,
-    model_path,
-    code_info,
-    results_dir=None,
-):
-    """Write one question's full, untruncated result record. Return (path, record)."""
-    record = _build_record(
-        row, prompt, answer, metric_name, score, model, model_path, code_info
-    )
-    root = results_dir_for(
-        model,
-        code_info["protocol"],
-        code_info["spatial_code_format"],
-        results_dir,
-        frames=code_info.get("frames", False),
-        frame_selection=code_info.get("frame_selection", DEFAULT_INPUT_SELECTION),
-        frame_count=code_info.get("frame_count", FRAMES_PER_VIDEO),
-    )
-    scene_dir = root / record["scene"]
-    scene_dir.mkdir(parents=True, exist_ok=True)
-    path = scene_dir / f"{row['id']}.json"
-    with path.open("w", encoding="utf-8") as stream:
-        json.dump(record, stream, indent=1)
-    return path, record
-
-
-def run(
-    model,
-    spatial_code_format=DEFAULT_SPATIAL_CODE_FORMAT,
-    scene=None,
-    scenes=None,
-    limit=None,
-    device="cuda",
-    jsonl_path=None,
-    results_dir=None,
-    write_results=True,
-    adapter=None,
-    thinking=False,
-    extended=True,
-    reasoning_budget=EXTENDED_MAX_NEW_TOKENS,
-    force_budget=MAX_NEW_TOKENS,
-    code_transform=None,
-    frames=False,
-    frame_selection=DEFAULT_INPUT_SELECTION,
-    frame_count=FRAMES_PER_VIDEO,
-    raw_budget=None,
-):
-    """Answer every matching question with one model, given its scene's GROUND-TRUTH
-    spatial code as text. Each question's full record is written to its own JSON file
-    as soon as it is answered (unless ``write_results=False``).
-
-    ``frames=True`` runs the frames+ground-truth-code arm: the scene's raw video is
-    ALSO sampled (``frame_selection``/``frame_count``, harness.A.frames.sample_frames --
-    the same sampling every harness uses; ground truth has no depth/tracking axis for
-    frames to be sourced "from", so there is nothing for this to mismatch against) and
-    shown alongside the ground-truth code, with harness.C's frames+code context line
-    (byte-identical composition rule: harness.A's frame sentence + harness.B's code
-    sentence, the same CODE_DESCRIPTION D's own text-only line already uses). This is
-    the ground-truth counterpart of harness C -- C answers with frames + a PERCEIVED
-    code; this is frames + the PERFECT code -- which harness C itself cannot produce,
-    since its spatial-code loader is perception-only. The default ``frame_selection``/
-    ``frame_count`` match the frozen Step-1 config (uniform, 32) so a default frames=True
-    call needs no extra flags to land on the same sampling every other harness uses.
-
-    Uses ``adapter.answer_extended`` as the standing default protocol, same as
-    harness.B -- working through a full spatial-code JSON before answering benefits
-    from more room than a short visual caption does. ``extended=False`` runs
-    harness.A's exact fixed 16-token base protocol instead (plain ``adapter.answer``).
-
-    ``raw_budget`` (mutually exclusive with ``extended``) runs the raw-budget arm --
-    same mechanism as ``extended=False`` (single generation, no forced rescue) but at
-    this token cap instead of the hardcoded 16, under its own "truncated/<budget>"
-    protocol path segment (mirrors harness.B/C's identical arm) so it can never collide
-    with either the extended or the base-protocol condition on disk.
-
-    ``code_transform``, when given, is called as ``code_transform(code, scene_id,
-    spatial_code_format)`` on each freshly loaded code and its return value is what
-    the prompt is built from -- the hook the corruption module (README Theme 8) uses
-    to run corrupted codes through this EXACT prompt/adapter path instead of a
-    duplicated one. ``None`` (the default) leaves behavior byte-identical to before.
-
-    Pass a pre-loaded ``adapter`` (as harness.D.launch's persistent per-GPU workers do)
-    to reuse one already-loaded model across many calls; the caller then owns unloading
-    it. Without one, ``run`` loads and unloads its own adapter, same as harness.A/B.
-    """
-    if extended and raw_budget is not None:
-        raise ValueError("extended and raw_budget are mutually exclusive")
-    rows = load_questions(jsonl_path, scene, scenes, limit)
-    if not rows:
-        return []
-    owns_adapter = adapter is None
-    if owns_adapter:
-        adapter = vlm_models.get_adapter(model)
-        if thinking and not adapter.set_thinking(True):
-            raise ValueError(f"{model} has no native thinking mode to enable")
-        adapter.load_model(device)
-    code_cache = {}
-    results = []
-    try:
-        for row in rows:
-            scene_id = row["scene_name"]
-            if scene_id not in code_cache:
-                code, path = spatial_codes.load_spatial_code(
-                    scene_id, spatial_code_format
-                )
-                if code_transform is not None:
-                    code = code_transform(code, scene_id, spatial_code_format)
-                entry = {"code": code, "path": path}
-                if frames:
-                    video_path = inference_config.video_path(
-                        scene_id, row.get("dataset")
-                    )
-                    frame_images, frame_timestamps, frame_indices = (
-                        frame_sampling.sample_frames(
-                            video_path, frame_count, frame_selection
-                        )
-                    )
-                    entry.update(
-                        video_path=video_path,
-                        frame_images=frame_images,
-                        frame_timestamps=frame_timestamps,
-                        frame_indices=frame_indices,
-                    )
-                code_cache[scene_id] = entry
-            cached = code_cache[scene_id]
-            prompt_builder = combined_prompts.build_prompt if frames else code_prompts.build_prompt
-            prompt = prompt_builder(
-                cached["code"],
-                row["question_type"],
-                row["question"],
-                row.get("options"),
-            )
-            answer = (
-                adapter.answer_extended(
-                    cached["frame_images"] if frames else [],
-                    prompt,
-                    reasoning_budget=reasoning_budget,
-                    force_budget=force_budget,
-                )
-                if extended
-                else adapter.answer(
-                    cached["frame_images"] if frames else [],
-                    prompt,
-                    max_new_tokens=raw_budget,
-                )
-            )
-            doc = {
-                "question_type": row["question_type"],
-                "ground_truth": row["ground_truth"],
-            }
-            score_doc = vsi_official_eval.vsibench_process_results(
-                doc, [answer["answer_text"]]
-            )["vsibench_score"]
-            metric_name, score = _scalar_score(row["question_type"], score_doc)
-            code_info = {
-                "protocol": (
-                    f"{reasoning_budget}"
-                    if extended
-                    else f"truncated/{raw_budget}" if raw_budget is not None else "base"
-                ),
-                "spatial_code_format": spatial_code_format,
-                "spatial_code_path": cached["path"],
-                "frames": frames,
-                "frame_selection": frame_selection if frames else None,
-                "frame_count": frame_count if frames else None,
-                "video_path": cached.get("video_path"),
-                "frame_indices": cached.get("frame_indices"),
-                "frame_timestamps": cached.get("frame_timestamps"),
-            }
-            if write_results:
-                path, record = write_question_result(
-                    row,
-                    prompt,
-                    answer,
-                    metric_name,
-                    score,
-                    model,
-                    adapter.model_path,
-                    code_info,
-                    results_dir,
-                )
-            else:
-                path = None
-                record = _build_record(
-                    row,
-                    prompt,
-                    answer,
-                    metric_name,
-                    score,
-                    model,
-                    adapter.model_path,
-                    code_info,
-                )
-            record["result_path"] = str(path) if path else None
-            results.append(record)
-    finally:
-        if owns_adapter:
-            adapter.unload()
-    return results
-
-
-def main():
-    parser = argparse.ArgumentParser()
-    parser.add_argument("--model", required=True, choices=vlm_models.available_models())
-    parser.add_argument("--scene", default=None, help="restrict to one VSI-Bench scene")
-    parser.add_argument(
-        "--spatial-code-format",
-        default=DEFAULT_SPATIAL_CODE_FORMAT,
-        choices=SPATIAL_CODE_FORMATS,
-        dest="spatial_code_format",
-    )
-    parser.add_argument(
-        "--limit", type=int, default=None, help="cap the number of questions"
-    )
-    parser.add_argument("--device", default="cuda")
-    parser.add_argument(
-        "--results-dir",
-        default=None,
-        help="override the default results/D/<model>/<code or code + frames>/<protocol>/<format> root",
-    )
-    parser.add_argument(
-        "--no-write",
-        action="store_true",
-        help="skip writing per-question JSON files; print/score only",
-    )
-    parser.add_argument(
-        "--base-protocol",
-        action="store_true",
-        help="run harness.A's exact fixed 16-token protocol (plain answer()) instead of "
-        "the extended 2048-token default",
-    )
-    parser.add_argument(
-        "--with-frames",
-        action="store_true",
-        dest="frames",
-        help="frames+ground-truth-code arm: also sample and show the scene's raw video "
-        "frames alongside the ground-truth code (default sampling: uniform, 32 frames -- "
-        "the frozen Step-1 config)",
-    )
-    parser.add_argument(
-        "--frame-selection",
-        default=DEFAULT_INPUT_SELECTION,
-        choices=INPUT_SELECTIONS,
-        dest="frame_selection",
-        help="only used with --with-frames",
-    )
-    parser.add_argument(
-        "--frames-per-video",
-        type=int,
-        default=FRAMES_PER_VIDEO,
-        dest="frame_count",
-        help="only used with --with-frames",
-    )
-    parser.add_argument(
-        "--thinking",
-        action="store_true",
-        help="enable the model's native thinking mode where supported; errors on models without the switch",
-    )
-    parser.add_argument("--reasoning-budget", type=int, default=EXTENDED_MAX_NEW_TOKENS)
-    parser.add_argument("--force-budget", type=int, default=MAX_NEW_TOKENS)
-    parser.add_argument(
-        "--truncated-budget",
-        type=int,
-        default=None,
-        help="raw-budget arm: base-protocol mechanics (single generation, no forced "
-        "rescue) at this token cap instead of the hardcoded 16 (mutually exclusive "
-        "with --base-protocol)",
-    )
-    args = parser.parse_args()
-    if args.reasoning_budget < 1:
-        parser.error("--reasoning-budget must be positive")
-    if args.force_budget < 1:
-        parser.error("--force-budget must be positive")
-    if args.frame_count < 1:
-        parser.error("--frames-per-video must be positive")
-    if args.truncated_budget is not None and args.truncated_budget < 1:
-        parser.error("--truncated-budget must be positive")
-    if args.base_protocol and args.truncated_budget is not None:
-        parser.error("--base-protocol and --truncated-budget are mutually exclusive")
-
-    results = run(
-        args.model,
-        spatial_code_format=args.spatial_code_format,
-        scene=args.scene,
-        limit=args.limit,
-        device=args.device,
-        results_dir=args.results_dir,
-        write_results=not args.no_write,
-        extended=not args.base_protocol and args.truncated_budget is None,
-        thinking=args.thinking,
-        reasoning_budget=args.reasoning_budget,
-        force_budget=args.force_budget,
-        frames=args.frames,
-        frame_selection=args.frame_selection,
-        frame_count=args.frame_count,
-        raw_budget=args.truncated_budget,
-    )
-
-    for result in results:
-        print(
-            f"[{result['scene']}#{result['question_id']}] {result['question_type']}: "
-            f"pred={result['answer_given']!r} gt={result['answer_expected']!r} "
-            f"score={result['score']} ({result['generation_seconds']:.2f}s) -> "
-            f"{result['result_path']}"
-        )
-    if results:
-        mean_score = sum(r["score"] for r in results) / len(results)
-        total_seconds = sum(r["generation_seconds"] for r in results)
-        print(
-            f"\n{len(results)} questions, mean vsibench_score={mean_score:.4f}, "
-            f"total generation time={total_seconds:.1f}s"
-        )
-
-
-if __name__ == "__main__":
-    main()

harness/D/spatial_codes.py

@@ -1,32 +0,0 @@
-"""Load one scene's GROUND-TRUTH spatial code (explicit or compact) as plain JSON.
-
-Same "no solver-side adaptation" philosophy as harness.B.spatial_codes: the model is
-shown literally the same file encoder.ground_truth wrote to disk -- schema legend
-included -- not a derived, answer-oriented shape a solver would compute from it.
-"""
-
-from __future__ import annotations
-
-import json
-from pathlib import Path
-
-from encoder.config import ground_truth_spatial_code_path
-
-from harness.D import SPATIAL_CODE_FORMATS
-
-
-def load_spatial_code(scene, spatial_code_format):
-    """Return (spatial code dict, path it was loaded from)."""
-    if spatial_code_format not in SPATIAL_CODE_FORMATS:
-        raise ValueError(
-            f"unknown spatial-code format {spatial_code_format!r}; "
-            f"expected one of {SPATIAL_CODE_FORMATS}"
-        )
-    path = ground_truth_spatial_code_path(scene, spatial_code_format)
-    if not Path(path).is_file():
-        raise FileNotFoundError(
-            f"no ground-truth spatial code found for scene {scene!r} at {path} -- "
-            "run `python -m encoder.ground_truth` to build it"
-        )
-    with open(path, encoding="utf-8") as stream:
-        return json.load(stream), path

harness/D/sweep.py

@@ -1,204 +0,0 @@
-"""Sweep any set of models x spatial-code-formats over ground-truth spatial codes.
-
-Every (model, spatial_code_format) pair in the sweep is run through
-``harness.D.launch.launch`` in turn, so each pair individually saturates every visible
-GPU before the next one starts. No depth/tracking/input-selection/frame-count axes --
-ground truth has none of those (see harness/D/__init__.py) -- so by design this sweeps
-BOTH spatial_code_formats for every model rather than picking one winning format, per
-this session's execution-design decision: ground-truth codes cost nothing extra to build
-across formats (no GPU encoder pass at all), so the marginal cost of covering both is
-just the extra VLM inference calls, and seeing whether a format's real-vs-perfect
-ranking flips is exactly the kind of thing this phase exists to check.
-"""
-
-from __future__ import annotations
-
-import argparse
-from pathlib import Path
-import sys
-
-HERE = Path(__file__).resolve().parent
-WORKSPACE_ROOT = HERE.parent.parent
-if str(WORKSPACE_ROOT) not in sys.path:
-    sys.path.insert(0, str(WORKSPACE_ROOT))
-
-from harness.A import models as vlm_models  # noqa: E402
-from harness.A import EXTENDED_MAX_NEW_TOKENS  # noqa: E402
-from harness.A.sweep import _parse_csv_choice  # noqa: E402
-from harness.B import (
-    DEFAULT_INPUT_SELECTION,
-    FRAMES_PER_VIDEO,
-    INPUT_SELECTIONS,
-    SPATIAL_CODE_FORMATS,
-)  # noqa: E402
-from harness.D import launch as harness_launch  # noqa: E402
-
-
-def build_plan(models, spatial_code_formats):
-    """Return every (model, spatial_code_format) pair in the sweep."""
-    return [
-        (model, spatial_code_format)
-        for model in models
-        for spatial_code_format in spatial_code_formats
-    ]
-
-
-def sweep(
-    models,
-    spatial_code_formats,
-    selected_scenes,
-    results_dir=None,
-    rebuild=False,
-    thinking=False,
-    extended=True,
-    reasoning_budget=EXTENDED_MAX_NEW_TOKENS,
-    frames=False,
-    frame_selection=DEFAULT_INPUT_SELECTION,
-    frame_count=FRAMES_PER_VIDEO,
-    raw_budget=None,
-):
-    """Run every (model, spatial_code_format) pair across all visible GPUs."""
-    plan = build_plan(models, spatial_code_formats)
-    protocol = (
-        f"{reasoning_budget}"
-        if extended
-        else f"truncated/{raw_budget}" if raw_budget is not None else "base"
-    )
-    for index, (model, spatial_code_format) in enumerate(plan, start=1):
-        print(
-            f"=== sweep {index}/{len(plan)}: {model}/{protocol}/{spatial_code_format}"
-            + (f"/frames/{frame_selection}/{frame_count}" if frames else "")
-            + " ===",
-            flush=True,
-        )
-        harness_launch.launch(
-            model,
-            spatial_code_format,
-            selected_scenes,
-            results_dir=results_dir,
-            rebuild=rebuild,
-            thinking=thinking,
-            extended=extended,
-            reasoning_budget=reasoning_budget,
-            frames=frames,
-            frame_selection=frame_selection,
-            frame_count=frame_count,
-            raw_budget=raw_budget,
-        )
-
-
-def main():
-    parser = argparse.ArgumentParser()
-    parser.add_argument("scene", nargs="?")
-    parser.add_argument(
-        "--scenes",
-        help="comma-separated scenes (cannot be combined with positional scene)",
-    )
-    parser.add_argument(
-        "--models",
-        required=True,
-        help=f"comma-separated models (or 'all'); one of {vlm_models.available_models()}",
-    )
-    parser.add_argument(
-        "--spatial-code-formats",
-        default="all",
-        dest="spatial_code_formats",
-        help=f"comma-separated formats (or 'all'); one of {SPATIAL_CODE_FORMATS}",
-    )
-    parser.add_argument("--results-dir", default=None)
-    parser.add_argument("--rebuild", action="store_true")
-    parser.add_argument(
-        "--base-protocol",
-        action="store_true",
-        help="run the whole sweep under harness.A's exact fixed 16-token protocol "
-        "instead of the extended default",
-    )
-    parser.add_argument(
-        "--thinking",
-        action="store_true",
-        help="enable the model's native thinking mode where supported; errors on models without the switch",
-    )
-    parser.add_argument(
-        "--reasoning-budget",
-        type=int,
-        default=EXTENDED_MAX_NEW_TOKENS,
-        dest="reasoning_budget",
-        help="extended-protocol first-pass budget (the calibrated value from "
-        "analysis/preregistration.md, e.g. 512)",
-    )
-    parser.add_argument(
-        "--with-frames",
-        action="store_true",
-        dest="frames",
-        help="frames+ground-truth-code arm: also sample and show the scene's raw video "
-        "frames alongside the ground-truth code (default sampling: uniform, 32 frames -- "
-        "the frozen Step-1 config)",
-    )
-    parser.add_argument(
-        "--frame-selection",
-        default=DEFAULT_INPUT_SELECTION,
-        choices=INPUT_SELECTIONS,
-        dest="frame_selection",
-        help="only used with --with-frames",
-    )
-    parser.add_argument(
-        "--frames-per-video",
-        type=int,
-        default=FRAMES_PER_VIDEO,
-        dest="frame_count",
-        help="only used with --with-frames",
-    )
-    parser.add_argument(
-        "--truncated-budget",
-        type=int,
-        default=None,
-        help="raw-budget arm: base-protocol mechanics (single generation, no forced "
-        "rescue) at this token cap instead of the hardcoded 16 (mutually exclusive "
-        "with --base-protocol)",
-    )
-    args = parser.parse_args()
-    if args.scene and args.scenes:
-        parser.error("positional scene and --scenes cannot be used together")
-    if args.frame_count < 1:
-        parser.error("--frames-per-video must be positive")
-    if args.truncated_budget is not None and args.truncated_budget < 1:
-        parser.error("--truncated-budget must be positive")
-    if args.base_protocol and args.truncated_budget is not None:
-        parser.error("--base-protocol and --truncated-budget are mutually exclusive")
-
-    try:
-        models = _parse_csv_choice(
-            args.models, vlm_models.available_models(), "--models"
-        )
-        spatial_code_formats = _parse_csv_choice(
-            args.spatial_code_formats, SPATIAL_CODE_FORMATS, "--spatial-code-formats"
-        )
-    except ValueError as exc:
-        parser.error(str(exc))
-
-    if args.scenes is not None:
-        selected = [scene.strip() for scene in args.scenes.split(",") if scene.strip()]
-        if not selected:
-            parser.error("--scenes must contain at least one scene")
-        selected = list(dict.fromkeys(selected))
-    else:
-        selected = [args.scene] if args.scene else harness_launch.scenes()
-
-    sweep(
-        models,
-        spatial_code_formats,
-        selected,
-        results_dir=args.results_dir,
-        rebuild=args.rebuild,
-        thinking=args.thinking,
-        extended=not args.base_protocol and args.truncated_budget is None,
-        reasoning_budget=args.reasoning_budget,
-        frames=args.frames,
-        frame_selection=args.frame_selection,
-        frame_count=args.frame_count,
-        raw_budget=args.truncated_budget,
-    )
-
-
-if __name__ == "__main__":
-    main()

harness/D/symbolic_eval.py

@@ -1,152 +0,0 @@
-"""Run the real symbolic solver directly against ground-truth spatial codes -- no VLM at
-all -- the perfect-information ceiling: perfect geometry AND perfect (deterministic,
-formula-driven) reasoning over it.
-
-Reuses symbolic/solver.py and symbolic/adapters.py completely unmodified (the same
-solver harness.D.run's VLM path is being compared against use for scoring, and
-symbolic/run.py itself uses for the encoder-perceived spatial codes) -- this module only
-supplies ground-truth-sourced input instead of a perception-pipeline-sourced one.
-
-Results are written through symbolic.run's own writer, in symbolic's own native record
-shape, landing in the SAME results family every other symbolic-solver result already
-lives in: results/symbolic/ground truth/<format>/<scene>/<question_id>.json -- not a
-separate results/D/... location -- since this IS a symbolic-solver run, just against
-ground-truth input instead of a perception-pipeline selection
-(symbolic.run.select_ground_truth_spatial_codes).
-"""
-
-from __future__ import annotations
-
-import argparse
-import sys
-from pathlib import Path
-
-WORKSPACE_ROOT = Path(__file__).resolve().parent.parent.parent
-if str(WORKSPACE_ROOT) not in sys.path:
-    sys.path.insert(0, str(WORKSPACE_ROOT))
-
-from harness.A.run import _scalar_score, load_questions, vsi_official_eval  # noqa: E402
-from harness.D import DEFAULT_SPATIAL_CODE_FORMAT, SPATIAL_CODE_FORMATS  # noqa: E402
-from harness.D import spatial_codes  # noqa: E402
-from symbolic import adapters, solver  # noqa: E402
-from symbolic import run as symbolic_run  # noqa: E402
-
-
-def run(
-    spatial_code_format=DEFAULT_SPATIAL_CODE_FORMAT,
-    scene=None,
-    scenes=None,
-    limit=None,
-    jsonl_path=None,
-    results_dir=None,
-    write_results=True,
-):
-    """Answer every matching question with the real symbolic solver, given each
-    question's scene's GROUND-TRUTH spatial code. Writes symbolic's own native-shape
-    record (results/symbolic/ground truth/<format>/...) when ``write_results``."""
-    rows = load_questions(jsonl_path, scene, scenes, limit)
-    if not rows:
-        return []
-    if write_results:
-        symbolic_run.select_ground_truth_spatial_codes(spatial_code_format)
-    code_cache = {}
-    results = []
-    for row in rows:
-        scene_id = row["scene_name"]
-        if scene_id not in code_cache:
-            code, path = spatial_codes.load_spatial_code(scene_id, spatial_code_format)
-            code_cache[scene_id] = {
-                "adapted": adapters.adapt_spatial_code(code),
-                "path": path,
-            }
-        cached = code_cache[scene_id]
-        answer = solver.answer(
-            row["question_type"], row["question"], row["options"], cached["adapted"]
-        )
-        pred_str = "" if answer is None else str(answer)
-        doc = {
-            "question_type": row["question_type"],
-            "ground_truth": row["ground_truth"],
-        }
-        score_doc = vsi_official_eval.vsibench_process_results(doc, [pred_str])[
-            "vsibench_score"
-        ]
-        _metric_name, score = _scalar_score(row["question_type"], score_doc)
-        record = {
-            "scene": scene_id,
-            "dataset": row.get("dataset"),
-            "question_id": row["id"],
-            "question_type": row["question_type"],
-            "question": row["question"],
-            "answer_expected": row["ground_truth"],
-            "answer_given": pred_str,
-            "score": score,
-        }
-        if write_results:
-            pq = {
-                "question_id": row["id"],
-                "dataset": row.get("dataset"),
-                "question_type": row["question_type"],
-                "question": row["question"],
-                "options": row.get("options"),
-                "engine_answer": answer,
-                "ground_truth": row["ground_truth"],
-                "score": score,
-            }
-            path = symbolic_run.write_question_result(
-                scene_id, pq, cached["adapted"], results_dir=results_dir
-            )
-            record["result_path"] = str(path)
-        else:
-            record["result_path"] = None
-        results.append(record)
-    return results
-
-
-def main():
-    parser = argparse.ArgumentParser()
-    parser.add_argument("scene", nargs="?")
-    parser.add_argument("--scenes", help="comma-separated scenes")
-    parser.add_argument(
-        "--spatial-code-format",
-        default=DEFAULT_SPATIAL_CODE_FORMAT,
-        choices=SPATIAL_CODE_FORMATS,
-        dest="spatial_code_format",
-    )
-    parser.add_argument("--limit", type=int, default=None)
-    parser.add_argument(
-        "--results-dir",
-        default=None,
-        help="override the default results/symbolic/ground truth/<format> root",
-    )
-    parser.add_argument("--no-write", action="store_true")
-    args = parser.parse_args()
-    if args.scene and args.scenes:
-        parser.error("positional scene and --scenes cannot be used together")
-    selected = None
-    if args.scenes:
-        selected = list(
-            dict.fromkeys(s.strip() for s in args.scenes.split(",") if s.strip())
-        )
-
-    results = run(
-        spatial_code_format=args.spatial_code_format,
-        scene=args.scene,
-        scenes=selected,
-        limit=args.limit,
-        results_dir=args.results_dir,
-        write_results=not args.no_write,
-    )
-    for result in results:
-        print(
-            f"[{result['scene']}#{result['question_id']}] {result['question_type']}: "
-            f"pred={result['answer_given']!r} gt={result['answer_expected']!r} "
-            f"score={result['score']} -> {result['result_path']}"
-        )
-    if results:
-        mean_score = sum(r["score"] for r in results) / len(results)
-        print(f"\n{len(results)} questions, mean vsibench_score={mean_score:.4f}")
-
-
-if __name__ == "__main__":
-    main()

harness/E/__init__.py

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

harness/E/launch.py

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

harness/E/prompts.py

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

harness/E/run.py

@@ -1,262 +0,0 @@
-"""Run one VLM over VSI-Bench questions completely blind -- question text only.
-
-Writes one JSON file per question in the identical shape harness.A/B/C/D use -- with no
-frame or spatial-code provenance fields at all, since E receives no scene input of any
-kind. Scoring reuses the same real, unmodified official scorer every harness uses.
-"""
-
-from __future__ import annotations
-
-import argparse
-import json
-import sys
-from pathlib import Path
-
-WORKSPACE_ROOT = Path(__file__).resolve().parent.parent.parent
-if str(WORKSPACE_ROOT) not in sys.path:
-    sys.path.insert(0, str(WORKSPACE_ROOT))
-
-from harness.A import EXTENDED_MAX_NEW_TOKENS, MAX_NEW_TOKENS  # noqa: E402
-from harness.A import models as vlm_models  # noqa: E402
-from harness.A.run import _scalar_score, load_questions, vsi_official_eval  # noqa: E402
-from harness.E import RESULTS_DIR  # noqa: E402
-from harness.E import prompts as blind_prompts  # noqa: E402
-
-
-def results_dir_for(model, protocol, results_dir=None):
-    """Return the result root isolated by model + protocol. ``protocol`` is "base"
-    (16-token) or "extended" (2048-token) -- a real path segment, so the two protocols'
-    records can never collide on disk."""
-    if results_dir is not None:
-        return Path(results_dir)
-    return RESULTS_DIR / model / protocol
-
-
-def _build_record(row, prompt, answer, metric_name, score, model, model_path, protocol):
-    """Assemble one question's full, untruncated result record (nothing summarized)."""
-    return {
-        "model": model,
-        "model_path": str(model_path),
-        "device": answer["device"],
-        "dtype": answer["dtype"],
-        "library_versions": answer["library_versions"],
-        "condition": protocol,
-        "protocol": protocol,
-        "scene": row["scene_name"],
-        "dataset": row.get("dataset"),
-        "question_id": row["id"],
-        "question_type": row["question_type"],
-        "question": row["question"],
-        "options": row.get("options"),
-        "full_prompt": prompt,
-        "rendered_prompt": answer["prompt_text"],
-        "answer_expected": row["ground_truth"],
-        "answer_given": answer["answer_text"],
-        "answer_raw": answer["answer_raw"],
-        "input_token_count": answer["input_token_count"],
-        "vision_input_shapes": answer["vision_input_shapes"],
-        "output_token_ids": answer["output_token_ids"],
-        "output_token_count": answer["output_token_count"],
-        "hit_token_limit": answer["hit_token_limit"],
-        "eos_token_ids": answer["eos_token_ids"],
-        "generation_seconds": answer["generation_seconds"],
-        "generation_config": answer["generation_config"],
-        "reasoning_text": answer.get("reasoning_text"),
-        "reasoning_raw": answer.get("reasoning_raw"),
-        "reasoning_token_ids": answer.get("reasoning_token_ids"),
-        "reasoning_token_count": answer.get("reasoning_token_count"),
-        "reasoning_hit_limit": answer.get("reasoning_hit_limit"),
-        "forced": answer.get("forced", False),
-        "forced_input_token_count": answer.get("forced_input_token_count"),
-        "metric": metric_name,
-        "score": score,
-    }
-
-
-def write_question_result(
-    row,
-    prompt,
-    answer,
-    metric_name,
-    score,
-    model,
-    model_path,
-    protocol,
-    results_dir=None,
-):
-    """Write one question's full, untruncated result record. Return (path, record)."""
-    record = _build_record(
-        row, prompt, answer, metric_name, score, model, model_path, protocol
-    )
-    root = results_dir_for(model, protocol, results_dir)
-    scene_dir = root / record["scene"]
-    scene_dir.mkdir(parents=True, exist_ok=True)
-    path = scene_dir / f"{row['id']}.json"
-    with path.open("w", encoding="utf-8") as stream:
-        json.dump(record, stream, indent=1)
-    return path, record
-
-
-def run(
-    model,
-    scene=None,
-    scenes=None,
-    limit=None,
-    device="cuda",
-    jsonl_path=None,
-    results_dir=None,
-    write_results=True,
-    adapter=None,
-    thinking=False,
-    extended=False,
-    reasoning_budget=EXTENDED_MAX_NEW_TOKENS,
-    force_budget=MAX_NEW_TOKENS,
-):
-    """Answer every matching question with one model, completely blind (question text
-    only, no frames, no spatial code). Each question's full record is written to its
-    own JSON file as soon as it is answered (unless ``write_results=False``).
-
-    Base 16-token protocol by default, exactly like harness.A; ``extended=True``
-    switches to the same ``answer_extended`` protocol every other harness supports.
-
-    Pass a pre-loaded ``adapter`` (as harness.E.launch's persistent per-GPU workers do)
-    to reuse one already-loaded model across many calls; the caller then owns unloading
-    it. Without one, ``run`` loads and unloads its own adapter, same as harness.A.
-    """
-    rows = load_questions(jsonl_path, scene, scenes, limit)
-    if not rows:
-        return []
-    owns_adapter = adapter is None
-    if owns_adapter:
-        adapter = vlm_models.get_adapter(model)
-        if thinking and not adapter.set_thinking(True):
-            raise ValueError(f"{model} has no native thinking mode to enable")
-        adapter.load_model(device)
-    protocol = f"{reasoning_budget}" if extended else "base"
-    results = []
-    try:
-        for row in rows:
-            prompt = blind_prompts.build_prompt(
-                row["question_type"], row["question"], row.get("options")
-            )
-            answer = (
-                adapter.answer_extended(
-                    [],
-                    prompt,
-                    reasoning_budget=reasoning_budget,
-                    force_budget=force_budget,
-                )
-                if extended
-                else adapter.answer([], prompt)
-            )
-            doc = {
-                "question_type": row["question_type"],
-                "ground_truth": row["ground_truth"],
-            }
-            score_doc = vsi_official_eval.vsibench_process_results(
-                doc, [answer["answer_text"]]
-            )["vsibench_score"]
-            metric_name, score = _scalar_score(row["question_type"], score_doc)
-            if write_results:
-                path, record = write_question_result(
-                    row,
-                    prompt,
-                    answer,
-                    metric_name,
-                    score,
-                    model,
-                    adapter.model_path,
-                    protocol,
-                    results_dir,
-                )
-            else:
-                path = None
-                record = _build_record(
-                    row,
-                    prompt,
-                    answer,
-                    metric_name,
-                    score,
-                    model,
-                    adapter.model_path,
-                    protocol,
-                )
-            record["result_path"] = str(path) if path else None
-            results.append(record)
-    finally:
-        if owns_adapter:
-            adapter.unload()
-    return results
-
-
-def main():
-    parser = argparse.ArgumentParser()
-    parser.add_argument("--model", required=True, choices=vlm_models.available_models())
-    parser.add_argument("--scene", default=None, help="restrict to one VSI-Bench scene")
-    parser.add_argument(
-        "--limit", type=int, default=None, help="cap the number of questions"
-    )
-    parser.add_argument("--device", default="cuda")
-    parser.add_argument(
-        "--results-dir",
-        default=None,
-        help="override the default results/E/<model>/<protocol> root",
-    )
-    parser.add_argument(
-        "--no-write",
-        action="store_true",
-        help="skip writing per-question JSON files; print/score only",
-    )
-    parser.add_argument(
-        "--extended",
-        action="store_true",
-        help=(
-            f"use a {EXTENDED_MAX_NEW_TOKENS}-token reasoning budget instead of the fixed "
-            f"{MAX_NEW_TOKENS}-token VSI-Bench protocol, with a short forced second call "
-            "only if the model doesn't conclude within it"
-        ),
-    )
-    parser.add_argument(
-        "--thinking",
-        action="store_true",
-        help="enable the model's native thinking mode where supported; errors on models without the switch",
-    )
-    parser.add_argument("--reasoning-budget", type=int, default=EXTENDED_MAX_NEW_TOKENS)
-    parser.add_argument("--force-budget", type=int, default=MAX_NEW_TOKENS)
-    args = parser.parse_args()
-    if args.reasoning_budget < 1:
-        parser.error("--reasoning-budget must be positive")
-    if args.force_budget < 1:
-        parser.error("--force-budget must be positive")
-
-    results = run(
-        args.model,
-        scene=args.scene,
-        limit=args.limit,
-        device=args.device,
-        results_dir=args.results_dir,
-        write_results=not args.no_write,
-        extended=args.extended,
-        thinking=args.thinking,
-        reasoning_budget=args.reasoning_budget,
-        force_budget=args.force_budget,
-    )
-
-    for result in results:
-        print(
-            f"[{result['scene']}#{result['question_id']}] {result['question_type']}: "
-            f"pred={result['answer_given']!r} gt={result['answer_expected']!r} "
-            f"score={result['score']} ({result['generation_seconds']:.2f}s) -> "
-            f"{result['result_path']}"
-        )
-    if results:
-        mean_score = sum(r["score"] for r in results) / len(results)
-        total_seconds = sum(r["generation_seconds"] for r in results)
-        print(
-            f"\n{len(results)} questions, mean vsibench_score={mean_score:.4f}, "
-            f"total generation time={total_seconds:.1f}s"
-        )
-
-
-if __name__ == "__main__":
-    main()

harness/E/sweep.py

@@ -1,115 +0,0 @@
-"""Sweep any set of models over the blind floor (question-only, no scene input).
-
-Every model in the sweep is run through ``harness.E.launch.launch`` in turn, so each
-model individually saturates every visible GPU before the next one starts. The only
-other axis is the generation protocol (--extended), matching harness.A's flag.
-"""
-
-from __future__ import annotations
-
-import argparse
-from pathlib import Path
-import sys
-
-HERE = Path(__file__).resolve().parent
-WORKSPACE_ROOT = HERE.parent.parent
-if str(WORKSPACE_ROOT) not in sys.path:
-    sys.path.insert(0, str(WORKSPACE_ROOT))
-
-from harness.A import EXTENDED_MAX_NEW_TOKENS  # noqa: E402
-from harness.A import models as vlm_models  # noqa: E402
-from harness.A.sweep import _parse_csv_choice  # noqa: E402
-from harness.E import launch as harness_launch  # noqa: E402
-
-
-def sweep(
-    models,
-    selected_scenes,
-    results_dir=None,
-    rebuild=False,
-    thinking=False,
-    extended=False,
-    reasoning_budget=EXTENDED_MAX_NEW_TOKENS,
-):
-    """Run every model across all visible GPUs."""
-    protocol = "extended" if extended else "base"
-    for index, model in enumerate(models, start=1):
-        print(f"=== sweep {index}/{len(models)}: {model}/{protocol} ===", flush=True)
-        harness_launch.launch(
-            model,
-            selected_scenes,
-            results_dir=results_dir,
-            rebuild=rebuild,
-            thinking=thinking,
-            extended=extended,
-            reasoning_budget=reasoning_budget,
-        )
-
-
-def main():
-    parser = argparse.ArgumentParser()
-    parser.add_argument("scene", nargs="?")
-    parser.add_argument(
-        "--scenes",
-        help="comma-separated scenes (cannot be combined with positional scene)",
-    )
-    parser.add_argument(
-        "--models",
-        required=True,
-        help=f"comma-separated models (or 'all'); one of {vlm_models.available_models()}",
-    )
-    parser.add_argument("--results-dir", default=None)
-    parser.add_argument("--rebuild", action="store_true")
-    parser.add_argument(
-        "--extended",
-        action="store_true",
-        help="run the whole sweep under the extended protocol instead of the fixed "
-        "16-token default",
-    )
-    parser.add_argument(
-        "--thinking",
-        action="store_true",
-        help="enable the model's native thinking mode where supported; errors on models without the switch",
-    )
-    parser.add_argument(
-        "--reasoning-budget",
-        type=int,
-        default=EXTENDED_MAX_NEW_TOKENS,
-        dest="reasoning_budget",
-        help="extended-protocol first-pass budget (the calibrated value from "
-        "analysis/preregistration.md, e.g. 512)",
-    )
-    args = parser.parse_args()
-    if args.scene and args.scenes:
-        parser.error("positional scene and --scenes cannot be used together")
-
-    try:
-        models = _parse_csv_choice(
-            args.models, vlm_models.available_models(), "--models"
-        )
-    except ValueError as exc:
-        parser.error(str(exc))
-
-    if args.scenes is not None:
-        selected = [scene.strip() for scene in args.scenes.split(",") if scene.strip()]
-        if not selected:
-            parser.error("--scenes must contain at least one scene")
-        selected = list(dict.fromkeys(selected))
-    else:
-        from harness.A.launch import scenes
-
-        selected = [args.scene] if args.scene else scenes()
-
-    sweep(
-        models,
-        selected,
-        results_dir=args.results_dir,
-        rebuild=args.rebuild,
-        thinking=args.thinking,
-        extended=args.extended,
-        reasoning_budget=args.reasoning_budget,
-    )
-
-
-if __name__ == "__main__":
-    main()

harness/F/__init__.py

@@ -1,8 +0,0 @@
-"""Harness F: deterministic symbolic reasoning over perceived spatial codes."""
-
-from pathlib import Path
-import os
-
-RESULTS_DIR = Path(os.environ.get("VSI_HARNESS_F_RESULTS_DIR", "/root/results/F"))
-SOURCES = ("perceived",)
-DEFAULT_SOURCE = "perceived"

harness/F/launch.py

@@ -1,6 +0,0 @@
-"""Launch one Harness F symbolic-solver condition over selected scenes."""
-
-from harness.F.run import main
-
-if __name__ == "__main__":
-    main()

harness/F/run.py

@@ -1,188 +0,0 @@
-"""Run the existing symbolic solver as first-class Harness F."""
-
-from __future__ import annotations
-import argparse
-import glob
-import json
-import sys
-from pathlib import Path
-
-WORKSPACE_ROOT = Path(__file__).resolve().parent.parent.parent
-if str(WORKSPACE_ROOT) not in sys.path:
-    sys.path.insert(0, str(WORKSPACE_ROOT))
-
-from harness.F import DEFAULT_SOURCE, RESULTS_DIR, SOURCES
-from symbolic import run as symbolic_run
-
-
-def results_dir_for(
-    source,
-    spatial_code_format,
-    depth="metric",
-    tracking="tracking",
-    input_selection="uniform",
-    frame_count=32,
-    results_dir=None,
-):
-    if results_dir is not None:
-        return Path(results_dir)
-    root = RESULTS_DIR / "perceived" / depth / tracking
-    if input_selection == "video":
-        return root / "video" / spatial_code_format
-    return root / input_selection / str(frame_count) / spatial_code_format
-
-
-def select_source(
-    source=DEFAULT_SOURCE,
-    spatial_code_format="explicit",
-    depth="metric",
-    tracking="tracking",
-    input_selection="uniform",
-    frame_count=32,
-):
-    if source not in SOURCES:
-        raise ValueError(f"unknown source {source!r}; expected one of {SOURCES}")
-    if spatial_code_format != "explicit":
-        raise ValueError("Harness F supports explicit spatial codes only")
-    return symbolic_run.select_spatial_codes(
-        depth, input_selection, tracking, frame_count, spatial_code_format
-    )
-
-
-def available_scenes():
-    return sorted(
-        Path(path).stem
-        for path in glob.glob(str(Path(symbolic_run.SPATIAL_CODES_DIR) / "*.json"))
-    )
-
-
-def run(
-    source=DEFAULT_SOURCE,
-    spatial_code_format="explicit",
-    depth="metric",
-    tracking="tracking",
-    input_selection="uniform",
-    frame_count=32,
-    video=False,
-    scene=None,
-    scenes=None,
-    results_dir=None,
-    write_results=True,
-    quiet=True,
-):
-    if scene is not None and scenes is not None:
-        raise ValueError("scene and scenes cannot both be given")
-    if video:
-        input_selection = "video"
-        frame_count = None
-    elif frame_count is None or frame_count < 1:
-        raise ValueError("frame_count must be positive in frames mode")
-    select_source(
-        source, spatial_code_format, depth, tracking, input_selection, frame_count
-    )
-    selected = (
-        [scene] if scene else list(scenes) if scenes is not None else available_scenes()
-    )
-    root = results_dir_for(
-        source,
-        spatial_code_format,
-        depth,
-        tracking,
-        input_selection,
-        frame_count,
-        results_dir,
-    )
-    records = []
-    for scene_id in selected:
-        per_question, aggregate = symbolic_run.score_scene(scene_id)
-        code = symbolic_run.fetch_spatial_code(scene_id)
-        if not quiet:
-            symbolic_run._print_scene_report(scene_id, per_question, aggregate, code)
-        if write_results:
-            symbolic_run.write_scene_results(
-                scene_id, per_question, aggregate, code, root
-            )
-        for pq in per_question:
-            records.append(
-                {
-                    "model": "symbolic",
-                    "source": source,
-                    "scene": scene_id,
-                    "dataset": pq.get("dataset"),
-                    "question_id": pq["question_id"],
-                    "question_type": pq["question_type"],
-                    "question": pq["question"],
-                    "answer_expected": pq["ground_truth"],
-                    "answer_given": (
-                        "" if pq["engine_answer"] is None else str(pq["engine_answer"])
-                    ),
-                    "score": pq["score"],
-                    "result_path": (
-                        str(root / scene_id / f"{pq['question_id']}.json")
-                        if write_results
-                        else None
-                    ),
-                }
-            )
-    return records
-
-
-def main():
-    p = argparse.ArgumentParser()
-    p.add_argument("scene", nargs="?")
-    p.add_argument(
-        "--scenes", help="comma-separated scenes; default: every available scene"
-    )
-    p.add_argument("--source", choices=SOURCES, default=DEFAULT_SOURCE)
-    p.add_argument("--depth", choices=symbolic_run.DEPTH_VARIANTS, default="metric")
-    p.add_argument(
-        "--tracking", choices=symbolic_run.TRACKING_MODES, default="tracking"
-    )
-    p.add_argument(
-        "--input-selection",
-        choices=symbolic_run.INPUT_SELECTIONS,
-        default=None,
-        dest="input_selection",
-    )
-    input_mode = p.add_mutually_exclusive_group(required=True)
-    input_mode.add_argument("--frames", type=int)
-    input_mode.add_argument("--video", action="store_true")
-    p.add_argument("--results-dir", default=None)
-    p.add_argument("--no-write", action="store_true")
-    p.add_argument("--verbose", action="store_true")
-    a = p.parse_args()
-    if a.scene and a.scenes:
-        p.error("scene and --scenes cannot be combined")
-    if a.video:
-        if a.input_selection is not None:
-            p.error("--input-selection cannot be used with --video")
-    else:
-        if a.input_selection is None:
-            p.error("--input-selection is required with --frames")
-        if a.frames < 1:
-            p.error("--frames must be positive")
-    selected = (
-        None
-        if not a.scenes
-        else list(dict.fromkeys(x.strip() for x in a.scenes.split(",") if x.strip()))
-    )
-    records = run(
-        a.source,
-        "explicit",
-        a.depth,
-        a.tracking,
-        a.input_selection,
-        a.frames,
-        a.video,
-        a.scene,
-        selected,
-        a.results_dir,
-        not a.no_write,
-        not a.verbose,
-    )
-    mean = sum(r["score"] for r in records) / len(records) if records else None
-    print(f"{len(records)} questions, mean_score={mean}")
-
-
-if __name__ == "__main__":
-    main()

harness/F/sweep.py

@@ -1,79 +0,0 @@
-"""Sweep Harness F spatial-code configurations."""
-
-from __future__ import annotations
-import argparse
-from itertools import product
-from harness.F import run as harness_run
-from symbolic import run as symbolic_run
-
-
-def _csv(value, valid):
-    values = (
-        list(valid)
-        if value.lower() == "all"
-        else [x.strip() for x in value.split(",") if x.strip()]
-    )
-    unknown = [x for x in values if x not in valid]
-    if unknown:
-        raise ValueError(f"unknown values {unknown}; expected {valid} or all")
-    return list(dict.fromkeys(values))
-
-
-def main():
-    p = argparse.ArgumentParser()
-    p.add_argument("--sources", default="all")
-    p.add_argument("--depths", default="metric")
-    p.add_argument("--trackings", default="tracking")
-    p.add_argument("--input-selections", default=None)
-    input_mode = p.add_mutually_exclusive_group(required=True)
-    input_mode.add_argument("--frames")
-    input_mode.add_argument("--video", action="store_true")
-    p.add_argument("--scenes", default=None)
-    p.add_argument("--results-dir", default=None)
-    a = p.parse_args()
-    try:
-        sources = _csv(a.sources, harness_run.SOURCES)
-        formats = ("explicit",)
-        depths = _csv(a.depths, symbolic_run.DEPTH_VARIANTS)
-        trackings = _csv(a.trackings, symbolic_run.TRACKING_MODES)
-        if a.video:
-            if a.input_selections is not None:
-                raise ValueError("--input-selections cannot be used with --video")
-            selections = ["video"]
-            frames = [None]
-        else:
-            if a.input_selections is None:
-                raise ValueError("--input-selections is required with --frames")
-            selections = _csv(a.input_selections, symbolic_run.INPUT_SELECTIONS)
-            frames = list(
-                dict.fromkeys(int(x.strip()) for x in a.frames.split(",") if x.strip())
-            )
-            if not frames or any(x < 1 for x in frames):
-                raise ValueError("frames must be positive")
-    except ValueError as exc:
-        p.error(str(exc))
-    scenes = (
-        None
-        if not a.scenes
-        else list(dict.fromkeys(x.strip() for x in a.scenes.split(",") if x.strip()))
-    )
-    for source, fmt in product(sources, formats):
-        configs = product(depths, trackings, selections, frames)
-        for config in configs:
-            depth, tracking, selection, count = config
-            records = harness_run.run(
-                source,
-                fmt,
-                depth,
-                tracking,
-                selection,
-                count,
-                video=a.video,
-                scenes=scenes,
-                results_dir=a.results_dir,
-            )
-            print(source, fmt, depth, tracking, selection, count, len(records))
-
-
-if __name__ == "__main__":
-    main()

harness/__init__.py

@@ -1,2 +0,0 @@
-"""Top-level namespace for direct VLM-inference harnesses (as opposed to the
-encoder/symbolic spatial-code pipeline)."""