Add files using upload-large-folder tool

harness/A/__init__.py

@@ -0,0 +1,54 @@
+"""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", WORKSPACE_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
+
+# Extended-budget generation (VLMAdapter.answer_extended, harness.B/C's default protocol
+# and harness.A's opt-in --extended flag): a much 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:"
+
+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",
+}

harness/A/frames.py

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

@@ -0,0 +1,224 @@
+"""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 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, 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,
+                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, results_dir=None, rebuild=False,
+    extended=False, reasoning_budget=EXTENDED_MAX_NEW_TOKENS, force_budget=MAX_NEW_TOKENS,
+):
+    """Answer every question for ``selected`` scenes, sharded across every visible GPU."""
+    condition = f"{model}/{frame_selection}/{frame_count}"
+    run = _load_run_module()
+    root = run.results_dir_for(model, frame_selection, frame_count, results_dir)
+    pending = []
+    completed = 0
+    for scene in selected:
+        rows = run.load_questions(scene=scene)
+        answered = all(
+            (root / scene / f"{row['id']}.json").is_file() for row in rows
+        )
+        if answered and not rebuild:
+            completed += 1
+            print(f"[{condition} {completed}/{len(selected)}] {scene}: skipped", flush=True)
+        else:
+            pending.append(scene)
+    if not pending:
+        print(f"[{condition}] DONE: {len(selected)} ok, 0 failed")
+        return
+
+    gpus = visible_gpus()
+    worker_count = min(len(pending), len(gpus) if gpus else 1)
+    assignments = gpus[:worker_count] if gpus else [None]
+    cpu_count = available_cpu_count()
+    cpu_threads = max(1, cpu_count // worker_count)
+    print(
+        f"[{condition}] starting {worker_count} persistent worker(s); "
+        f"GPUs={assignments}; CPU threads/worker={cpu_threads}",
+        flush=True,
+    )
+
+    context = mp.get_context("spawn")
+    tasks, results = context.Queue(), context.Queue()
+    for scene in pending:
+        tasks.put(scene)
+    for _ in range(worker_count):
+        tasks.put(None)
+    workers = [
+        context.Process(
+            target=_worker,
+            args=(
+                tasks, results, model, frame_selection, frame_count, 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=DEFAULT_FRAME_SELECTION, choices=FRAME_SELECTIONS,
+        dest="frame_selection",
+    )
+    parser.add_argument("--frames", type=int, default=FRAMES_PER_VIDEO)
+    parser.add_argument("--results-dir", default=None)
+    parser.add_argument("--rebuild", action="store_true")
+    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("--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.frames < 1:
+        parser.error("--frames must be positive")
+    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, args.frame_selection, args.frames, selected,
+        results_dir=args.results_dir, rebuild=args.rebuild,
+        extended=args.extended, reasoning_budget=args.reasoning_budget,
+        force_budget=args.force_budget,
+    )
+
+
+if __name__ == "__main__":
+    main()

harness/A/models.py

@@ -0,0 +1,343 @@
+"""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):
+    """Interleave "Frame N:" labels with each image, then the question text.
+
+    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.
+    """
+    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
+
+
+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):
+        """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.
+        """
+
+    @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):
+        if self.model is None or self.processor is None:
+            raise RuntimeError("load_model() must be called before answer()")
+        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, MAX_NEW_TOKENS)
+        eos_ids = self._eos_ids()
+        output_token_ids, hit_token_limit, answer_text, answer_raw = self._decode_new_tokens(
+            generated, input_token_count, MAX_NEW_TOKENS, 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": MAX_NEW_TOKENS,
+                "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)
+        )
+
+        forced = reasoning_hit_limit
+        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_prompt_ids = self.processor.tokenizer(
+                FORCE_ANSWER_PROMPT, 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
+
+        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,
+}
+
+
+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

@@ -0,0 +1,47 @@
+"""VSI-Bench prompt construction -- reproduces lmms_eval's own protocol exactly.
+
+Mirrors ``thinking-in-space/lmms_eval/tasks/vsibench/utils.py::vsibench_doc_to_text``
+and ``vsibench.yaml``'s ``lmms_eval_specific_kwargs.default`` profile verbatim (the
+profile every non-API model, including local HF checkpoints, is scored under): the
+same question-type split, the same pre/post prompt text, the same "\\n".join layout.
+"""
+
+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."
+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):
+    """Return the exact text prompt lmms_eval would send for one VSI-Bench question."""
+    if question_type in NA_QUESTION_TYPES:
+        return PRE_PROMPT + "\n" + question + "\n" + NA_POST_PROMPT
+    if question_type in MCA_QUESTION_TYPES:
+        if not options:
+            raise ValueError(f"question_type {question_type!r} requires options")
+        options_block = "Options:\n" + "\n".join(options)
+        return "\n".join([PRE_PROMPT, question, options_block, MCA_POST_PROMPT])
+    raise ValueError(
+        f"unknown question_type {question_type!r}; "
+        f"expected one of {MCA_QUESTION_TYPES + NA_QUESTION_TYPES}"
+    )

harness/A/run.py

@@ -0,0 +1,339 @@
+"""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 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, frame_selection, frame_count, results_dir=None):
+    """Return the result root isolated by model + frame-selection + frame-count."""
+    if results_dir is not None:
+        return Path(results_dir)
+    return RESULTS_DIR / model / 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['frame_selection']}:{frame_info['frame_count']}",
+        "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["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,
+    scene=None,
+    scenes=None,
+    limit=None,
+    device="cuda",
+    jsonl_path=None,
+    results_dir=None,
+    write_results=True,
+    adapter=None,
+    extended=False,
+    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`` switches from the fixed 16-token VSI-Bench protocol to
+    ``adapter.answer_extended`` -- a much larger first-pass budget (``reasoning_budget``)
+    with a short forced second call (``force_budget``) only if the model doesn't
+    conclude within it. Opt-in per call/CLI invocation, not a change to the default
+    protocol every other harness.A caller and test still exercises.
+    """
+    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:
+            scene_id = row["scene_name"]
+            if scene_id not in frame_cache:
+                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
+                )
+                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")
+            )
+            answer = (
+                adapter.answer_extended(
+                    cached["frame_images"], prompt,
+                    reasoning_budget=reasoning_budget, force_budget=force_budget,
+                )
+                if extended
+                else adapter.answer(cached["frame_images"], 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)
+            frame_info = {
+                "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=DEFAULT_FRAME_SELECTION,
+        choices=FRAME_SELECTIONS,
+        dest="frame_selection",
+    )
+    parser.add_argument("--frames", type=int, default=FRAMES_PER_VIDEO)
+    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> 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("--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.frames < 1:
+        parser.error("--frames must be positive")
+    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,
+        frame_selection=args.frame_selection,
+        frame_count=args.frames,
+        scene=args.scene,
+        limit=args.limit,
+        device=args.device,
+        results_dir=args.results_dir,
+        write_results=not args.no_write,
+        extended=args.extended,
+        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

@@ -0,0 +1,127 @@
+"""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 FRAME_SELECTIONS  # noqa: E402
+from harness.A import launch as harness_launch  # noqa: E402
+from harness.A import models as vlm_models  # 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, results_dir=None, rebuild=False):
+    """Run every (model, frame_selection, frame_count) triple across all visible GPUs."""
+    plan = 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}/{frame_selection}/{frame_count} ===", flush=True)
+        harness_launch.launch(
+            model, frame_selection, frame_count, selected_scenes,
+            results_dir=results_dir, rebuild=rebuild,
+        )
+
+
+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=True, dest="frame_selections",
+        help=f"comma-separated selections (or 'all'); one of {FRAME_SELECTIONS}",
+    )
+    parser.add_argument(
+        "--frames", required=True,
+        help="comma-separated frame counts, e.g. 16,32,64",
+    )
+    parser.add_argument("--results-dir", default=None)
+    parser.add_argument("--rebuild", action="store_true")
+    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")
+        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,
+        results_dir=args.results_dir, rebuild=args.rebuild,
+    )
+
+
+if __name__ == "__main__":
+    main()

harness/B/__init__.py

@@ -0,0 +1,42 @@
+"""Harness B: route a scene's on-disk spatial code (explicit or compact) -- 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
+
+# Same two on-disk spatial-code schemas encoder/geometric.py can build.
+SPATIAL_CODE_FORMATS = ("explicit", "compact")
+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", WORKSPACE_ROOT / "results" / "B")
+)

harness/B/launch.py

@@ -0,0 +1,218 @@
+"""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.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,
+    SPATIAL_CODE_FORMATS,
+    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, depth, tracking,
+    results_dir, gpu, cpu_threads, reasoning_budget, force_budget,
+):
+    if gpu is not None:
+        os.environ["CUDA_VISIBLE_DEVICES"] = str(gpu)
+    for variable in ("OMP_NUM_THREADS", "MKL_NUM_THREADS", "OPENBLAS_NUM_THREADS"):
+        os.environ[variable] = str(cpu_threads)
+    run = _load_run_module()
+    adapter = None
+    load_error = None
+    try:
+        adapter = vlm_models.get_adapter(model)
+        adapter.load_model("cuda:0" if gpu is not None else "cpu")
+    except Exception:
+        load_error = traceback.format_exc()
+    while True:
+        scene = tasks.get()
+        if scene is None:
+            return
+        if load_error is not None:
+            results.put((scene, False, load_error))
+            continue
+        try:
+            answered = run.run(
+                model,
+                spatial_code_format=spatial_code_format,
+                input_selection=input_selection,
+                frame_count=frame_count,
+                depth=depth,
+                tracking=tracking,
+                scene=scene,
+                results_dir=results_dir,
+                adapter=adapter,
+                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,
+    depth=DEFAULT_DEPTH, tracking=DEFAULT_TRACKING, results_dir=None, rebuild=False,
+    reasoning_budget=EXTENDED_MAX_NEW_TOKENS, force_budget=MAX_NEW_TOKENS,
+):
+    """Answer every question for ``selected`` scenes, sharded across every visible GPU."""
+    condition = f"{model}/{spatial_code_format}/{depth}/{tracking}/{input_selection}/{frame_count}"
+    run = _load_run_module()
+    root = run.results_dir_for(
+        model, spatial_code_format, depth, tracking, input_selection, frame_count, results_dir
+    )
+    pending = []
+    completed = 0
+    for scene in selected:
+        rows = run.load_questions(scene=scene)
+        answered = all((root / scene / f"{row['id']}.json").is_file() for row in rows)
+        if answered and not rebuild:
+            completed += 1
+            print(f"[{condition} {completed}/{len(selected)}] {scene}: skipped", flush=True)
+        else:
+            pending.append(scene)
+    if not pending:
+        print(f"[{condition}] DONE: {len(selected)} ok, 0 failed")
+        return
+
+    gpus = visible_gpus()
+    worker_count = min(len(pending), len(gpus) if gpus else 1)
+    assignments = gpus[:worker_count] if gpus else [None]
+    cpu_count = available_cpu_count()
+    cpu_threads = max(1, cpu_count // worker_count)
+    print(
+        f"[{condition}] starting {worker_count} persistent worker(s); "
+        f"GPUs={assignments}; CPU threads/worker={cpu_threads}",
+        flush=True,
+    )
+
+    context = mp.get_context("spawn")
+    tasks, results = context.Queue(), context.Queue()
+    for scene in pending:
+        tasks.put(scene)
+    for _ in range(worker_count):
+        tasks.put(None)
+    workers = [
+        context.Process(
+            target=_worker,
+            args=(
+                tasks, results, model, spatial_code_format, input_selection, frame_count,
+                depth, tracking, results_dir, gpu, cpu_threads, 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(
+        "--spatial-code-format", default=DEFAULT_SPATIAL_CODE_FORMAT,
+        choices=SPATIAL_CODE_FORMATS, dest="spatial_code_format",
+    )
+    parser.add_argument(
+        "--input-selection", default=DEFAULT_INPUT_SELECTION,
+        choices=INPUT_SELECTIONS, dest="input_selection",
+    )
+    parser.add_argument("--frames", type=int, default=FRAMES_PER_VIDEO)
+    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=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.frames < 1:
+        parser.error("--frames must be positive")
+    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, args.spatial_code_format, args.input_selection, args.frames, selected,
+        depth=args.depth, tracking=args.tracking, results_dir=args.results_dir, rebuild=args.rebuild,
+        reasoning_budget=args.reasoning_budget, force_budget=args.force_budget,
+    )
+
+
+if __name__ == "__main__":
+    main()

harness/B/prompts.py

@@ -0,0 +1,55 @@
+"""VSI-Bench prompt construction with a spatial code (as text) instead of video frames.
+
+Reuses harness.A.prompts's exact question-type split and post-prompts verbatim -- only
+the pre-prompt context line changes (there are no frames to describe), and the spatial
+code's own JSON text is inserted between that context line and the question.
+
+CODE_DESCRIPTION deliberately says nothing about where the code came from (not "based on
+an analysis of a video", not "ground truth annotation") -- the model is never told
+whether it's reading a perceived or ground-truth code, in either harness.B (perceived)
+or harness.D (ground truth), which is exactly what makes a B-vs-D comparison a clean
+read of perception error alone, not a comparison the model could game by knowing which
+condition it's in.
+"""
+
+from __future__ import annotations
+
+import json
+
+from harness.A.prompts import MCA_POST_PROMPT, MCA_QUESTION_TYPES, NA_POST_PROMPT, NA_QUESTION_TYPES
+
+# Deliberately vague about which fields are present -- compact and explicit carry
+# different fields (e.g. only explicit has a distance table and appearance order; only
+# compact has per-instance orientation vectors), and this line has to describe both
+# without over- or under-claiming either one. The code's own "spatial code schema" key
+# is what actually documents every field present in a given call.
+#
+# CODE_DESCRIPTION is factored out (not just inlined into PRE_PROMPT) so that
+# harness.C.prompts and harness.D.prompts can build their own context lines by literally
+# reusing this exact string -- guaranteeing the frames-only, code-only, and
+# frames+code conditions never drift into differently-worded descriptions of the same
+# spatial code, and guaranteeing B and D (perceived vs. ground-truth code, otherwise the
+# same condition) get a byte-identical prompt, which would be a real, avoidable wording
+# confound between conditions if it ever drifted.
+CODE_DESCRIPTION = (
+    "a structured JSON description of a room and its objects. The schema included in "
+    "it explains every field."
+)
+PRE_PROMPT = "This is a spatial code: " + CODE_DESCRIPTION
+
+
+def build_prompt(spatial_code, question_type, question, options=None):
+    """Return the full text prompt: context line, the spatial code itself, the question,
+    and the same VSI-Bench post-prompt harness.A uses for the same question_type."""
+    code_text = json.dumps(spatial_code, indent=1)
+    if question_type in NA_QUESTION_TYPES:
+        return "\n".join([PRE_PROMPT, code_text, question, 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, code_text, question, options_block, MCA_POST_PROMPT])
+    raise ValueError(
+        f"unknown question_type {question_type!r}; "
+        f"expected one of {MCA_QUESTION_TYPES + NA_QUESTION_TYPES}"
+    )

harness/B/run.py

@@ -0,0 +1,281 @@
+"""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.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,
+    SPATIAL_CODE_FORMATS,
+    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, spatial_code_format, depth, tracking, input_selection, frame_count, results_dir=None
+):
+    """Return the result root isolated by model + spatial-code-format + depth +
+    tracking + input + frames."""
+    if results_dir is not None:
+        return Path(results_dir)
+    return (
+        RESULTS_DIR / model / spatial_code_format / depth / tracking
+        / 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['spatial_code_format']}:{code_info['depth']}:"
+            f"{code_info['tracking']}:{code_info['input_selection']}:"
+            f"{code_info['frame_count']}"
+        ),
+        "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["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,
+    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,
+    reasoning_budget=EXTENDED_MAX_NEW_TOKENS,
+    force_budget=MAX_NEW_TOKENS,
+):
+    """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 -- not harness.A's fixed 16-token budget -- since working
+    through a full spatial-code JSON before answering benefits from more room than a
+    short visual caption does.
+
+    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.
+    """
+    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)
+    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, 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
+            )
+            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 = {
+                "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(
+        "--spatial-code-format", default=DEFAULT_SPATIAL_CODE_FORMAT,
+        choices=SPATIAL_CODE_FORMATS, dest="spatial_code_format",
+    )
+    parser.add_argument(
+        "--input-selection", default=DEFAULT_INPUT_SELECTION,
+        choices=INPUT_SELECTIONS, dest="input_selection",
+    )
+    parser.add_argument("--frames", type=int, default=FRAMES_PER_VIDEO)
+    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>/<format>/<depth>/<tracking>/<input>/<frames> 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=EXTENDED_MAX_NEW_TOKENS)
+    parser.add_argument("--force-budget", type=int, default=MAX_NEW_TOKENS)
+    args = parser.parse_args()
+    if args.frames < 1:
+        parser.error("--frames must be positive")
+    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,
+        spatial_code_format=args.spatial_code_format,
+        input_selection=args.input_selection,
+        frame_count=args.frames,
+        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,
+        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

@@ -0,0 +1,31 @@
+"""Load one scene's on-disk spatial code (explicit or compact) 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

@@ -0,0 +1,139 @@
+"""Sweep any set of models x spatial-code-formats 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.sweep import _parse_csv_choice, _parse_frame_counts  # noqa: E402
+from harness.B import (  # noqa: E402
+    DEFAULT_DEPTH,
+    DEFAULT_TRACKING,
+    DEPTH_VARIANTS,
+    INPUT_SELECTIONS,
+    SPATIAL_CODE_FORMATS,
+    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,
+    depths=(DEFAULT_DEPTH,), trackings=(DEFAULT_TRACKING,), results_dir=None, rebuild=False,
+):
+    """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)}: "
+            f"{model}/{spatial_code_format}/{depth}/{tracking}/{input_selection}/{frame_count} ===",
+            flush=True,
+        )
+        harness_launch.launch(
+            model, spatial_code_format, input_selection, frame_count, selected_scenes,
+            depth=depth, tracking=tracking, results_dir=results_dir, rebuild=rebuild,
+        )
+
+
+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", required=True, dest="spatial_code_formats",
+        help=f"comma-separated formats (or 'all'); one of {SPATIAL_CODE_FORMATS}",
+    )
+    parser.add_argument(
+        "--input-selections", required=True, dest="input_selections",
+        help=f"comma-separated selections (or 'all'); one of {INPUT_SELECTIONS}",
+    )
+    parser.add_argument(
+        "--frames", required=True, help="comma-separated frame counts, e.g. 16,32,64"
+    )
+    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")
+    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")
+        spatial_code_formats = _parse_csv_choice(
+            args.spatial_code_formats, SPATIAL_CODE_FORMATS, "--spatial-code-formats"
+        )
+        input_selections = _parse_csv_choice(
+            args.input_selections, INPUT_SELECTIONS, "--input-selections"
+        )
+        depths = _parse_csv_choice(args.depths, DEPTH_VARIANTS, "--depths")
+        trackings = _parse_csv_choice(args.trackings, TRACKING_MODES, "--trackings")
+        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:
+        from harness.A.launch import scenes
+
+        selected = [args.scene] if args.scene else scenes()
+
+    sweep(
+        models, spatial_code_formats, input_selections, frame_counts, selected,
+        depths=depths, trackings=trackings,
+        results_dir=args.results_dir, rebuild=args.rebuild,
+    )
+
+
+if __name__ == "__main__":
+    main()

harness/C/launch.py

@@ -0,0 +1,221 @@
+"""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.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,
+    SPATIAL_CODE_FORMATS,
+    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, depth, tracking,
+    results_dir, gpu, cpu_threads, 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,
+                depth=depth,
+                tracking=tracking,
+                scene=scene,
+                results_dir=results_dir,
+                adapter=adapter,
+                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,
+    depth=DEFAULT_DEPTH, tracking=DEFAULT_TRACKING, results_dir=None, rebuild=False,
+    reasoning_budget=EXTENDED_MAX_NEW_TOKENS, force_budget=MAX_NEW_TOKENS,
+):
+    """Answer every question for ``selected`` scenes, sharded across every visible GPU."""
+    condition = f"{model}/{spatial_code_format}/{depth}/{tracking}/{input_selection}/{frame_count}"
+    run = _load_run_module()
+    root = run.results_dir_for(
+        model, spatial_code_format, depth, tracking, input_selection, frame_count, results_dir
+    )
+    pending = []
+    completed = 0
+    for scene in selected:
+        rows = run.load_questions(scene=scene)
+        answered = all((root / scene / f"{row['id']}.json").is_file() for row in rows)
+        if answered and not rebuild:
+            completed += 1
+            print(f"[{condition} {completed}/{len(selected)}] {scene}: skipped", flush=True)
+        else:
+            pending.append(scene)
+    if not pending:
+        print(f"[{condition}] DONE: {len(selected)} ok, 0 failed")
+        return
+
+    gpus = visible_gpus()
+    worker_count = min(len(pending), len(gpus) if gpus else 1)
+    assignments = gpus[:worker_count] if gpus else [None]
+    cpu_count = available_cpu_count()
+    cpu_threads = max(1, cpu_count // worker_count)
+    print(
+        f"[{condition}] starting {worker_count} persistent worker(s); "
+        f"GPUs={assignments}; CPU threads/worker={cpu_threads}",
+        flush=True,
+    )
+
+    context = mp.get_context("spawn")
+    tasks, results = context.Queue(), context.Queue()
+    for scene in pending:
+        tasks.put(scene)
+    for _ in range(worker_count):
+        tasks.put(None)
+    workers = [
+        context.Process(
+            target=_worker,
+            args=(
+                tasks, results, model, spatial_code_format, input_selection, frame_count,
+                depth, tracking, results_dir, gpu, cpu_threads, 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(
+        "--spatial-code-format", default=DEFAULT_SPATIAL_CODE_FORMAT,
+        choices=SPATIAL_CODE_FORMATS, dest="spatial_code_format",
+    )
+    parser.add_argument(
+        "--input-selection", default=DEFAULT_INPUT_SELECTION,
+        choices=INPUT_SELECTIONS, dest="input_selection",
+    )
+    parser.add_argument("--frames", type=int, default=FRAMES_PER_VIDEO)
+    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=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.frames < 1:
+        parser.error("--frames must be positive")
+    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, args.spatial_code_format, args.input_selection, args.frames, selected,
+        depth=args.depth, tracking=args.tracking, results_dir=args.results_dir, rebuild=args.rebuild,
+        reasoning_budget=args.reasoning_budget, force_budget=args.force_budget,
+    )
+
+
+if __name__ == "__main__":
+    main()

harness/C/prompts.py

@@ -0,0 +1,48 @@
+"""Combined video-frames + spatial-code-as-text prompt construction.
+
+Reuses harness.A.prompts's exact question-type split and post-prompts verbatim. The
+returned text becomes the ONE trailing content item passed to
+harness.A.models._numbered_content(frames, this_text) -- since that helper already puts
+every numbered frame image first and appends a single text block last, the resulting
+model input order is exactly: frames (numbered) -> spatial code text -> question.
+"""
+
+from __future__ import annotations
+
+import json
+
+from harness.A.prompts import (
+    MCA_POST_PROMPT,
+    MCA_QUESTION_TYPES,
+    NA_POST_PROMPT,
+    NA_QUESTION_TYPES,
+    PRE_PROMPT as FRAMES_PRE_PROMPT,
+)
+from harness.B.prompts import CODE_DESCRIPTION
+
+# Built by literally concatenating harness.A's frames sentence with harness.B's spatial
+# code sentence (not independently reworded) -- so a reviewer can see the frames-only,
+# code-only, and frames+code context lines never describe the same content in different
+# words. This is the ONE deliberate difference from B's context line (mentioning frames
+# at all); everything describing the spatial code itself is the identical CODE_DESCRIPTION
+# string B uses.
+PRE_PROMPT = FRAMES_PRE_PROMPT + " Also provided is a spatial code: " + CODE_DESCRIPTION
+
+
+def build_prompt(spatial_code, question_type, question, options=None):
+    """Return the full trailing text block: context line, the spatial code itself, the
+    question, and the same VSI-Bench post-prompt harness.A uses for the same
+    question_type. Frames themselves are prepended separately by the caller via
+    harness.A.models._numbered_content."""
+    code_text = json.dumps(spatial_code, indent=1)
+    if question_type in NA_QUESTION_TYPES:
+        return "\n".join([PRE_PROMPT, code_text, question, 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, code_text, question, options_block, MCA_POST_PROMPT])
+    raise ValueError(
+        f"unknown question_type {question_type!r}; "
+        f"expected one of {MCA_QUESTION_TYPES + NA_QUESTION_TYPES}"
+    )

tests/test_B/conftest.py

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

tests/test_B/test_init.py

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

tests/test_B/test_launch.py

@@ -0,0 +1,49 @@
+"""Tests for harness/B/launch.py -- multi-GPU scene sharding across workers."""
+
+from harness.A.run import load_questions as harness_a_load_questions
+from harness.B import launch
+
+
+def test_launcher_imports():
+    assert callable(launch.main)
+
+
+def test_launch_skips_scene_already_fully_answered(tmp_path, capsys):
+    scene = "13c3e046d7"
+    rows = harness_a_load_questions(scene=scene)
+    assert rows, "fixture scene must have real questions in the VSI-Bench manifest"
+
+    scene_dir = tmp_path / scene
+    scene_dir.mkdir()
+    for row in rows:
+        (scene_dir / f"{row['id']}.json").write_text("{}")
+
+    launch.launch("qwen3.5-2b", "explicit", "selective", 64, [scene], results_dir=tmp_path)
+
+    output = capsys.readouterr().out
+    assert "skipped" in output
+    assert "DONE: 1 ok, 0 failed" in output
+
+
+def test_launch_rebuild_forces_pending_even_when_answered(tmp_path, monkeypatch):
+    scene = "13c3e046d7"
+    rows = harness_a_load_questions(scene=scene)
+    scene_dir = tmp_path / scene
+    scene_dir.mkdir()
+    for row in rows:
+        (scene_dir / f"{row['id']}.json").write_text("{}")
+
+    monkeypatch.setattr(launch, "visible_gpus", lambda: [])
+    monkeypatch.setattr(
+        launch.mp, "get_context",
+        lambda *_: (_ for _ in ()).throw(RuntimeError("rebuild correctly reached worker dispatch")),
+    )
+    try:
+        launch.launch(
+            "qwen3.5-2b", "explicit", "selective", 64, [scene],
+            results_dir=tmp_path, rebuild=True,
+        )
+    except RuntimeError as exc:
+        assert "rebuild correctly reached worker dispatch" in str(exc)
+    else:
+        raise AssertionError("expected rebuild to force scene into the pending path")

tests/test_B/test_sweep.py

@@ -0,0 +1,55 @@
+"""Tests for harness/B/sweep.py -- multi-config sweep planning."""
+
+import pytest
+
+from harness.A import models as vlm_models
+from harness.B import sweep
+
+
+def test_build_plan_covers_every_combination():
+    plan = sweep.build_plan(
+        ["qwen3.5-2b", "qwen3.5-4b"], ["explicit", "compact"], ["uniform", "selective"],
+        [16, 32], ["metric"], ["tracking"],
+    )
+    assert len(plan) == 2 * 2 * 2 * 2
+    assert ("qwen3.5-2b", "explicit", "metric", "tracking", "uniform", 16) in plan
+    assert ("qwen3.5-4b", "compact", "metric", "tracking", "selective", 32) in plan
+
+
+def test_build_plan_sweeps_depth_and_tracking_too():
+    plan = sweep.build_plan(
+        ["qwen3.5-2b"], ["explicit"], ["uniform"], [16],
+        ["metric", "relative"], ["tracking", "no tracking"],
+    )
+    assert len(plan) == 4
+    assert ("qwen3.5-2b", "explicit", "relative", "no tracking", "uniform", 16) in plan
+
+
+def test_build_plan_orders_by_frame_count_first():
+    plan = sweep.build_plan(
+        ["qwen3.5-2b"], ["explicit"], ["uniform"], [64, 16, 32], ["metric"], ["tracking"]
+    )
+    assert [frame_count for *_rest, frame_count in plan] == [16, 32, 64]
+
+
+def test_build_plan_with_all_registered_models():
+    plan = sweep.build_plan(
+        list(vlm_models.available_models()), ["explicit"], ["uniform"], [16],
+        ["metric"], ["tracking"],
+    )
+    assert len(plan) == len(vlm_models.available_models())
+
+
+def test_sweep_parser_rejects_unknown_spatial_code_format():
+    with pytest.raises(ValueError):
+        sweep._parse_csv_choice("bogus", ("explicit", "compact"), "--spatial-code-formats")
+
+
+def test_sweep_parser_rejects_unknown_depth():
+    with pytest.raises(ValueError):
+        sweep._parse_csv_choice("bogus", sweep.DEPTH_VARIANTS, "--depths")
+
+
+def test_sweep_parser_rejects_unknown_tracking():
+    with pytest.raises(ValueError):
+        sweep._parse_csv_choice("bogus", sweep.TRACKING_MODES, "--trackings")