Replace harness with local workspace contents

harness/A/__init__.py

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

harness/A/frames.py

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

harness/A/models.py

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

harness/A/prompts.py

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

harness/A/run.py

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

harness/A/sweep.py

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

harness/B/__init__.py

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

harness/B/launch.py

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

harness/B/prompts.py

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

harness/B/run.py

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

harness/B/spatial_codes.py

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

harness/B/sweep.py

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

harness/C/__init__.py

@@ -0,0 +1,37 @@
+"""Harness C supplies both visual input and explicit spatial code to the model.
+
+The visual input (sampled frames or video) and spatial-code source (frame-derived or
+video-derived) are configured independently. Changing one never changes the other.
+"""
+
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+from harness.A import (
+    DO_SAMPLE,
+    FRAME_SELECTIONS,
+    JSONL,
+    MAX_NEW_TOKENS,
+    MODEL_PATHS,
+    TEMPERATURE,
+    WORKSPACE_ROOT,
+)
+from harness.B import (
+    DEFAULT_DEPTH,
+    DEFAULT_INPUT_SELECTION,
+    DEFAULT_SPATIAL_CODE_FORMAT,
+    DEFAULT_TRACKING,
+    DEPTH_VARIANTS,
+    INPUT_SELECTIONS,
+    TRACKING_MODES,
+)
+
+assert INPUT_SELECTIONS == FRAME_SELECTIONS  # one shared vocabulary drives both sources
+
+FRAMES_PER_VIDEO = int(os.environ.get("VSI_HARNESS_C_FRAMES_PER_VIDEO", "32"))
+
+# One JSON per question, matching harness.A/B's layout:
+# results/C/<model>/explicit/<depth>/<tracking>/code/.../visual/.../<scene>/<question_id>.json
+RESULTS_DIR = Path(os.environ.get("VSI_HARNESS_C_RESULTS_DIR", "/root/results/C"))

harness/C/launch.py

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

harness/C/prompts.py

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

harness/C/run.py

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

harness/C/sweep.py

@@ -0,0 +1,171 @@
+"""Sweep any set of models x depths x trackings x
+input-selections x frame-counts.
+
+Every (model, spatial_code_format, depth, tracking, input_selection, frame_count)
+6-tuple in the sweep is run through ``harness.C.launch.launch`` in turn, so each
+combination individually saturates every visible GPU before the next one starts.
+Depth/tracking default to this workspace's single shipped production config
+(DEFAULT_DEPTH/DEFAULT_TRACKING) when --depths/--trackings aren't given, but are real
+sweepable axes like every other dimension here -- pass --depths all / --trackings all
+(or an explicit comma list) to sweep them too.
+"""
+
+from __future__ import annotations
+
+import argparse
+from pathlib import Path
+import sys
+
+HERE = Path(__file__).resolve().parent
+WORKSPACE_ROOT = HERE.parent.parent
+if str(WORKSPACE_ROOT) not in sys.path:
+    sys.path.insert(0, str(WORKSPACE_ROOT))
+
+from harness.A import models as vlm_models  # noqa: E402
+from harness.A import resolve_protocol_budgets  # noqa: E402
+from harness.A import EXTENDED_MAX_NEW_TOKENS  # noqa: E402
+from harness.A.sweep import _parse_csv_choice, _parse_frame_counts  # noqa: E402
+from harness.B import (  # noqa: E402
+    DEFAULT_DEPTH,
+    DEFAULT_INPUT_SELECTION,
+    DEFAULT_SPATIAL_CODE_FORMAT,
+    DEFAULT_TRACKING,
+    DEPTH_VARIANTS,
+    INPUT_SELECTIONS,
+    TRACKING_MODES,
+)
+from harness.C import launch as harness_launch  # noqa: E402
+
+
+def build_plan(
+    models, spatial_code_formats, input_selections, frame_counts, depths, trackings,
+    spatial_code_sources, spatial_code_input_selections, spatial_code_frame_counts,
+):
+    """Return every independent visual-input x spatial-code-input combination."""
+    code_configs = []
+    for source in spatial_code_sources:
+        if source == "video":
+            code_configs.append(("video", "video", None))
+        else:
+            code_configs.extend(
+                ("frames", selection, count)
+                for count in sorted(spatial_code_frame_counts)
+                for selection in spatial_code_input_selections
+            )
+    return [
+        (model, fmt, depth, tracking, selection, count,
+         code_source, code_selection, code_count)
+        for count in frame_counts
+        for model in models
+        for fmt in spatial_code_formats
+        for depth in depths
+        for tracking in trackings
+        for selection in input_selections
+        for code_source, code_selection, code_count in code_configs
+    ]
+
+
+def sweep(
+    models, spatial_code_formats, input_selections, frame_counts, selected_scenes,
+    video=False, depths=(DEFAULT_DEPTH,), trackings=(DEFAULT_TRACKING,),
+    spatial_code_sources=("frames",),
+    spatial_code_input_selections=(DEFAULT_INPUT_SELECTION,),
+    spatial_code_frame_counts=(32,), results_dir=None, rebuild=False,
+    extended=True, reasoning_budget=EXTENDED_MAX_NEW_TOKENS,
+):
+    """Run every independent visual-input x spatial-code-input combination."""
+    plan = build_plan(
+        models, spatial_code_formats, input_selections, frame_counts, depths, trackings,
+        spatial_code_sources, spatial_code_input_selections, spatial_code_frame_counts,
+    )
+    for index, config in enumerate(plan, start=1):
+        (model, fmt, depth, tracking, selection, count,
+         code_source, code_selection, code_count) = config
+        visual_mode = "video" if video else f"{selection}/{count}"
+        code_mode = "video" if code_source == "video" else f"{code_selection}/{code_count}"
+        print(f"=== sweep {index}/{len(plan)}: {model}/{fmt}/{depth}/{tracking}/"
+              f"code-{code_mode}/visual-{visual_mode} ===", flush=True)
+        harness_launch.launch(
+            model, fmt, selection, count, selected_scenes, video=video,
+            spatial_code_source=code_source,
+            spatial_code_input_selection=code_selection,
+            spatial_code_frame_count=code_count,
+            depth=depth, tracking=tracking, results_dir=results_dir,
+            rebuild=rebuild, extended=extended, reasoning_budget=reasoning_budget,
+        )
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("scene", nargs="?")
+    parser.add_argument("--scenes", help="comma-separated scenes")
+    parser.add_argument("--models", required=True)
+    parser.add_argument("--input-selections", dest="input_selections")
+    visual = parser.add_mutually_exclusive_group(required=True)
+    visual.add_argument("--frames", help="comma-separated visual frame counts")
+    visual.add_argument("--video", action="store_true")
+    parser.add_argument("--spatial-code-sources", required=True)
+    parser.add_argument("--spatial-code-input-selections")
+    parser.add_argument("--spatial-code-frames")
+    parser.add_argument("--depths", default=DEFAULT_DEPTH)
+    parser.add_argument("--trackings", default=DEFAULT_TRACKING)
+    parser.add_argument("--results-dir")
+    parser.add_argument("--rebuild", action="store_true")
+    parser.add_argument("--reasoning-budget", type=int, default=None,
+                        help="thinking questions only")
+    args = parser.parse_args()
+    resolve_protocol_budgets(parser, args)
+    if args.scene and args.scenes:
+        parser.error("positional scene and --scenes cannot be used together")
+    try:
+        models = _parse_csv_choice(args.models, vlm_models.available_models(), "--models")
+        if args.video:
+            if args.input_selections is not None:
+                raise ValueError("--input-selections cannot be used with --video")
+            selections, counts = ["video"], [None]
+        else:
+            if args.input_selections is None:
+                raise ValueError("--input-selections is required with --frames")
+            selections = _parse_csv_choice(args.input_selections, INPUT_SELECTIONS,
+                                           "--input-selections")
+            counts = _parse_frame_counts(args.frames)
+        code_sources = _parse_csv_choice(args.spatial_code_sources,
+                                         ("frames", "video"),
+                                         "--spatial-code-sources")
+        if "frames" in code_sources:
+            if (args.spatial_code_input_selections is None or
+                    args.spatial_code_frames is None):
+                raise ValueError("spatial-code selections and frame counts are required "
+                                 "when frame-derived codes are included")
+            code_selections = _parse_csv_choice(
+                args.spatial_code_input_selections, INPUT_SELECTIONS,
+                "--spatial-code-input-selections")
+            code_counts = _parse_frame_counts(args.spatial_code_frames)
+        else:
+            if (args.spatial_code_input_selections is not None or
+                    args.spatial_code_frames is not None):
+                raise ValueError("spatial-code frame flags cannot be used with video-only codes")
+            code_selections, code_counts = [], []
+        depths = _parse_csv_choice(args.depths, DEPTH_VARIANTS, "--depths")
+        trackings = _parse_csv_choice(args.trackings, TRACKING_MODES, "--trackings")
+    except ValueError as exc:
+        parser.error(str(exc))
+    if args.scenes is not None:
+        selected = list(dict.fromkeys(x.strip() for x in args.scenes.split(",") if x.strip()))
+        if not selected:
+            parser.error("--scenes must contain at least one scene")
+    else:
+        from harness.A.launch import scenes
+        selected = [args.scene] if args.scene else scenes()
+    sweep(
+        models, (DEFAULT_SPATIAL_CODE_FORMAT,), selections, counts, selected,
+        video=args.video, depths=depths, trackings=trackings,
+        spatial_code_sources=code_sources,
+        spatial_code_input_selections=code_selections,
+        spatial_code_frame_counts=code_counts,
+        results_dir=args.results_dir, rebuild=args.rebuild,
+        reasoning_budget=args.reasoning_budget,
+    )
+
+
+if __name__ == "__main__":
+    main()

harness/F/__init__.py

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

harness/F/launch.py

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

harness/F/run.py

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

harness/F/sweep.py

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

harness/__init__.py

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