Add files using upload-large-folder tool

harness/A/launch.py

@@ -47,12 +47,24 @@ def _load_run_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))
+        return list(
+            dict.fromkeys(str(json.loads(line)["scene_name"]) for line in manifest)
+        )
 
 
 def _worker(
-    tasks, results, model, frame_selection, frame_count, results_dir, gpu, cpu_threads,
-    extended, reasoning_budget, force_budget, truncated_budget,
+    tasks,
+    results,
+    model,
+    frame_selection,
+    frame_count,
+    results_dir,
+    gpu,
+    cpu_threads,
+    extended,
+    reasoning_budget,
+    force_budget,
+    truncated_budget,
 ):
     if gpu is not None:
         os.environ["CUDA_VISIBLE_DEVICES"] = str(gpu)
@@ -100,8 +112,15 @@ def _worker(
 
 
 def launch(
-    model, frame_selection, frame_count, selected, results_dir=None, rebuild=False,
-    extended=False, reasoning_budget=EXTENDED_MAX_NEW_TOKENS, force_budget=MAX_NEW_TOKENS,
+    model,
+    frame_selection,
+    frame_count,
+    selected,
+    results_dir=None,
+    rebuild=False,
+    extended=False,
+    reasoning_budget=EXTENDED_MAX_NEW_TOKENS,
+    force_budget=MAX_NEW_TOKENS,
     truncated_budget=None,
 ):
     """Answer every question for ``selected`` scenes, sharded across every visible GPU.
@@ -112,23 +131,30 @@ def launch(
     if extended and truncated_budget is not None:
         raise ValueError("extended and truncated_budget are mutually exclusive")
     protocol = (
-        f"{reasoning_budget}" if extended
-        else f"truncated/{truncated_budget}" if truncated_budget is not None
-        else "base"
+        f"{reasoning_budget}"
+        if extended
+        else f"truncated/{truncated_budget}" if truncated_budget is not None else "base"
     )
     condition = f"{model}/{protocol}/{frame_selection}/{frame_count}"
     run = _load_run_module()
-    root = run.results_dir_for(model, protocol, frame_selection, frame_count, results_dir)
+    root = run.results_dir_for(
+        model, protocol, frame_selection, frame_count, results_dir
+    )
     pending = []
     completed = 0
     for scene in selected:
         rows = run.load_questions(scene=scene)
-        answered = all(
-            (root / scene / f"{row['id']}.json").is_file() for row in rows
-        )
+        if 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)
+            print(
+                f"[{condition} {completed}/{len(selected)}] {scene}: skipped",
+                flush=True,
+            )
         else:
             pending.append(scene)
     if not pending:
@@ -156,8 +182,18 @@ def launch(
         context.Process(
             target=_worker,
             args=(
-                tasks, results, model, frame_selection, frame_count, results_dir,
-                gpu, cpu_threads, extended, reasoning_budget, force_budget, truncated_budget,
+                tasks,
+                results,
+                model,
+                frame_selection,
+                frame_count,
+                results_dir,
+                gpu,
+                cpu_threads,
+                extended,
+                reasoning_budget,
+                force_budget,
+                truncated_budget,
             ),
         )
         for gpu in assignments
@@ -188,11 +224,14 @@ def main():
     parser = argparse.ArgumentParser()
     parser.add_argument("scene", nargs="?")
     parser.add_argument(
-        "--scenes", help="comma-separated scenes (cannot be combined with positional scene)"
+        "--scenes",
+        help="comma-separated scenes (cannot be combined with positional scene)",
     )
     parser.add_argument("--model", required=True, choices=vlm_models.available_models())
     parser.add_argument(
-        "--frame-selection", default=DEFAULT_FRAME_SELECTION, choices=FRAME_SELECTIONS,
+        "--frame-selection",
+        default=DEFAULT_FRAME_SELECTION,
+        choices=FRAME_SELECTIONS,
         dest="frame_selection",
     )
     parser.add_argument("--frames", type=int, default=FRAMES_PER_VIDEO)
@@ -210,7 +249,9 @@ def main():
     parser.add_argument("--reasoning-budget", type=int, default=EXTENDED_MAX_NEW_TOKENS)
     parser.add_argument("--force-budget", type=int, default=MAX_NEW_TOKENS)
     parser.add_argument(
-        "--truncated-budget", type=int, default=None,
+        "--truncated-budget",
+        type=int,
+        default=None,
         help="raw-budget arm: base-protocol mechanics (single generation, no forced "
         "rescue) at this token cap, under its own truncated/<budget> path segment "
         "(mutually exclusive with --extended)",
@@ -236,10 +277,16 @@ def main():
     if args.extended and args.truncated_budget is not None:
         parser.error("--extended and --truncated-budget are mutually exclusive")
     launch(
-        args.model, args.frame_selection, args.frames, selected,
-        results_dir=args.results_dir, rebuild=args.rebuild,
-        extended=args.extended, reasoning_budget=args.reasoning_budget,
-        force_budget=args.force_budget, truncated_budget=args.truncated_budget,
+        args.model,
+        args.frame_selection,
+        args.frames,
+        selected,
+        results_dir=args.results_dir,
+        rebuild=args.rebuild,
+        extended=args.extended,
+        reasoning_budget=args.reasoning_budget,
+        force_budget=args.force_budget,
+        truncated_budget=args.truncated_budget,
     )
 
 

harness/A/models.py

@@ -79,8 +79,13 @@ class VLMAdapter(ABC):
         """
 
     @abstractmethod
-    def answer_extended(self, frames, question, reasoning_budget=EXTENDED_MAX_NEW_TOKENS,
-                         force_budget=MAX_NEW_TOKENS):
+    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
@@ -97,8 +102,10 @@ class VLMAdapter(ABC):
         whether a silent no-op is acceptable for their arm."""
         if "enable_thinking" not in type(self).chat_template_kwargs:
             return False
-        self.chat_template_kwargs = {**type(self).chat_template_kwargs,
-                                     "enable_thinking": bool(enabled)}
+        self.chat_template_kwargs = {
+            **type(self).chat_template_kwargs,
+            "enable_thinking": bool(enabled),
+        }
         return True
 
     def unload(self):
@@ -138,11 +145,18 @@ class _TransformersVLMAdapter(VLMAdapter):
         """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,
+            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,
+            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
@@ -169,8 +183,12 @@ class _TransformersVLMAdapter(VLMAdapter):
         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,
+                **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()
@@ -179,11 +197,12 @@ class _TransformersVLMAdapter(VLMAdapter):
     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)
+        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_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
 
@@ -201,8 +220,8 @@ class _TransformersVLMAdapter(VLMAdapter):
         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
+        output_token_ids, hit_token_limit, answer_text, answer_raw = (
+            self._decode_new_tokens(generated, input_token_count, cap, eos_ids)
         )
 
         return {
@@ -229,8 +248,13 @@ class _TransformersVLMAdapter(VLMAdapter):
             },
         }
 
-    def answer_extended(self, frames, question, reasoning_budget=EXTENDED_MAX_NEW_TOKENS,
-                         force_budget=MAX_NEW_TOKENS):
+    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:
@@ -241,7 +265,9 @@ class _TransformersVLMAdapter(VLMAdapter):
 
         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)
+            self._decode_new_tokens(
+                generated, input_token_count, reasoning_budget, eos_ids
+            )
         )
 
         thinking = bool(self.chat_template_kwargs.get("enable_thinking"))
@@ -257,9 +283,11 @@ class _TransformersVLMAdapter(VLMAdapter):
             # 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_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)
@@ -276,17 +304,27 @@ class _TransformersVLMAdapter(VLMAdapter):
                 # 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:]))
+                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
+            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:
@@ -380,5 +418,7 @@ 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()}")
+        raise KeyError(
+            f"unknown harness model {model!r}; expected one of {available_models()}"
+        )
     return adapter_type(MODEL_PATHS[model])

harness/A/sweep.py

@@ -33,7 +33,9 @@ def _parse_csv_choice(value, valid, flag):
         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')")
+        raise ValueError(
+            f"unknown {flag} value(s) {unknown}; expected one of {valid} (or 'all')"
+        )
     return list(dict.fromkeys(items))
 
 
@@ -66,15 +68,22 @@ def build_plan(models, frame_selections, frame_counts):
 
 
 def sweep(
-    models, frame_selections, frame_counts, selected_scenes, results_dir=None, rebuild=False,
-    extended=False, reasoning_budget=EXTENDED_MAX_NEW_TOKENS, truncated_budget=None,
+    models,
+    frame_selections,
+    frame_counts,
+    selected_scenes,
+    results_dir=None,
+    rebuild=False,
+    extended=False,
+    reasoning_budget=EXTENDED_MAX_NEW_TOKENS,
+    truncated_budget=None,
 ):
     """Run every (model, frame_selection, frame_count) triple across all visible GPUs."""
     plan = build_plan(models, frame_selections, frame_counts)
     protocol = (
-        f"{reasoning_budget}" if extended
-        else f"truncated/{truncated_budget}" if truncated_budget is not None
-        else "base"
+        f"{reasoning_budget}"
+        if extended
+        else f"truncated/{truncated_budget}" if truncated_budget is not None else "base"
     )
     for index, (model, frame_selection, frame_count) in enumerate(plan, start=1):
         print(
@@ -82,9 +91,15 @@ def sweep(
             flush=True,
         )
         harness_launch.launch(
-            model, frame_selection, frame_count, selected_scenes,
-            results_dir=results_dir, rebuild=rebuild, extended=extended,
-            reasoning_budget=reasoning_budget, truncated_budget=truncated_budget,
+            model,
+            frame_selection,
+            frame_count,
+            selected_scenes,
+            results_dir=results_dir,
+            rebuild=rebuild,
+            extended=extended,
+            reasoning_budget=reasoning_budget,
+            truncated_budget=truncated_budget,
         )
 
 
@@ -92,35 +107,45 @@ def main():
     parser = argparse.ArgumentParser()
     parser.add_argument("scene", nargs="?")
     parser.add_argument(
-        "--scenes", help="comma-separated scenes (cannot be combined with positional scene)"
+        "--scenes",
+        help="comma-separated scenes (cannot be combined with positional scene)",
     )
     parser.add_argument(
-        "--models", required=True,
+        "--models",
+        required=True,
         help=f"comma-separated models (or 'all'); one of {vlm_models.available_models()}",
     )
     parser.add_argument(
-        "--frame-selections", required=True, dest="frame_selections",
+        "--frame-selections",
+        required=True,
+        dest="frame_selections",
         help=f"comma-separated selections (or 'all'); one of {FRAME_SELECTIONS}",
     )
     parser.add_argument(
-        "--frames", required=True,
+        "--frames",
+        required=True,
         help="comma-separated frame counts, e.g. 16,32,64",
     )
     parser.add_argument("--results-dir", default=None)
     parser.add_argument("--rebuild", action="store_true")
     parser.add_argument(
-        "--extended", action="store_true",
+        "--extended",
+        action="store_true",
         help="run the whole sweep under the extended protocol instead of the fixed "
         "16-token VSI-Bench protocol (the same flag harness.A.run/launch take)",
     )
     parser.add_argument(
-        "--reasoning-budget", type=int, default=EXTENDED_MAX_NEW_TOKENS,
+        "--reasoning-budget",
+        type=int,
+        default=EXTENDED_MAX_NEW_TOKENS,
         dest="reasoning_budget",
         help="extended-protocol first-pass budget (the calibrated value from "
         "analysis/preregistration.md, e.g. 512)",
     )
     parser.add_argument(
-        "--truncated-budget", type=int, default=None,
+        "--truncated-budget",
+        type=int,
+        default=None,
         help="raw-budget arm: base-protocol mechanics (single generation, no forced "
         "rescue) at this token cap (mutually exclusive with --extended)",
     )
@@ -131,7 +156,9 @@ def main():
         parser.error("--extended and --truncated-budget are mutually exclusive")
 
     try:
-        models = _parse_csv_choice(args.models, vlm_models.available_models(), "--models")
+        models = _parse_csv_choice(
+            args.models, vlm_models.available_models(), "--models"
+        )
         frame_selections = _parse_csv_choice(
             args.frame_selections, FRAME_SELECTIONS, "--frame-selections"
         )
@@ -148,9 +175,15 @@ def main():
         selected = [args.scene] if args.scene else harness_launch.scenes()
 
     sweep(
-        models, frame_selections, frame_counts, selected,
-        results_dir=args.results_dir, rebuild=args.rebuild, extended=args.extended,
-        reasoning_budget=args.reasoning_budget, truncated_budget=args.truncated_budget,
+        models,
+        frame_selections,
+        frame_counts,
+        selected,
+        results_dir=args.results_dir,
+        rebuild=args.rebuild,
+        extended=args.extended,
+        reasoning_budget=args.reasoning_budget,
+        truncated_budget=args.truncated_budget,
     )
 
 

harness/B/__init__.py

@@ -15,7 +15,14 @@ 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
+from harness.A import (
+    DO_SAMPLE,
+    JSONL,
+    MAX_NEW_TOKENS,
+    MODEL_PATHS,
+    TEMPERATURE,
+    WORKSPACE_ROOT,
+)
 
 # Same two on-disk spatial-code schemas encoder/geometric.py can build.
 SPATIAL_CODE_FORMATS = ("explicit", "compact")
@@ -37,6 +44,4 @@ 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")
-)
+RESULTS_DIR = Path(os.environ.get("VSI_HARNESS_B_RESULTS_DIR", "/root/results/B"))

harness/B/prompts.py

@@ -16,7 +16,12 @@ from __future__ import annotations
 
 import json
 
-from harness.A.prompts import MCA_POST_PROMPT, MCA_QUESTION_TYPES, NA_POST_PROMPT, NA_QUESTION_TYPES
+from harness.A.prompts import (
+    MCA_POST_PROMPT,
+    MCA_QUESTION_TYPES,
+    NA_POST_PROMPT,
+    NA_QUESTION_TYPES,
+)
 
 # Deliberately vague about which fields are present -- compact and explicit carry
 # different fields (e.g. only explicit has a distance table and appearance order; only
@@ -66,61 +71,63 @@ REASONING_BREVITY_NOTE = (
     "or re-derive values you have already found."
 )
 
-PROSE_LEGEND = "\n\n".join([
-    (
-        "You are a multimodal reasoning model that interprets structured scene inputs. "
-        "You will be provided with the spatial code of a scanned room."
-    ),
-    (
-        "Below is the spatial code of a scanned room. "
-        "It is a JSON description of the room. "
-        "It is built automatically from a video walkthrough."
-    ),
-    (
-        "Every value below that is a physical measurement is written as a STRING. "
-        "It already names its own unit, such as \"1.46 meters\", \"3.0 seconds\", or "
-        "\"91 degrees\"."
-    ),
-    (
-        "The objects section lists object classes that were detected in the room. "
-        "An object class is a category of object, such as \"chair\" or \"table\". "
-        "Each object class has a count, the number of objects of that class that are in "
-        "the room. "
-        "Each object class has a list of instances, the individual objects of that class "
-        "that were detected in the room. "
-        "Each instance has a position given as \"x coordinate\", \"y coordinate\" and "
-        "\"height above floor\". "
-        "X coordinate is the instance's distance in meters along one fixed horizontal "
-        "direction of the room. "
-        "Y coordinate is the instance's distance in meters along a second fixed horizontal "
-        "direction perpendicular to the first. "
-        "Height above floor is the instance's vertical distance in meters above the floor. "
-        "These directions are the same for everything in the room. "
-        "Each instance also has a \"longest dimension\", the length in meters of that "
-        "instance's single longest side."
-    ),
-    (
-        "The room section describes the room as a whole. "
-        "The room also has a \"floor area\", the total floor area of the room in square "
-        "meters."
-    ),
-    (
-        "The \"closest classes distance meters from\" section has, for every object class, "
-        "the distance to each other class and the closeness rank of each other class. "
-        "Distance is the minimum distance in meters between an instance of the class and an "
-        "instance of the other class. "
-        "Closeness rank orders the other classes by nearness to the class. "
-        "Rank 1 is the nearest class. The largest rank is the farthest class. "
-        "The larger the rank, the farther the class."
-    ),
-    (
-        "The \"appearance order\" section lists every object class in the order it "
-        "appeared in the video. "
-        "The leftmost class in the list is the class that appeared earliest. "
-        "The rightmost class in the list is the class that appeared last. "
-        "The further right a class is in the list, the later it appeared."
-    ),
-])
+PROSE_LEGEND = "\n\n".join(
+    [
+        (
+            "You are a multimodal reasoning model that interprets structured scene inputs. "
+            "You will be provided with the spatial code of a scanned room."
+        ),
+        (
+            "Below is the spatial code of a scanned room. "
+            "It is a JSON description of the room. "
+            "It is built automatically from a video walkthrough."
+        ),
+        (
+            "Every value below that is a physical measurement is written as a STRING. "
+            'It already names its own unit, such as "1.46 meters", "3.0 seconds", or '
+            '"91 degrees".'
+        ),
+        (
+            "The objects section lists object classes that were detected in the room. "
+            'An object class is a category of object, such as "chair" or "table". '
+            "Each object class has a count, the number of objects of that class that are in "
+            "the room. "
+            "Each object class has a list of instances, the individual objects of that class "
+            "that were detected in the room. "
+            'Each instance has a position given as "x coordinate", "y coordinate" and '
+            '"height above floor". '
+            "X coordinate is the instance's distance in meters along one fixed horizontal "
+            "direction of the room. "
+            "Y coordinate is the instance's distance in meters along a second fixed horizontal "
+            "direction perpendicular to the first. "
+            "Height above floor is the instance's vertical distance in meters above the floor. "
+            "These directions are the same for everything in the room. "
+            'Each instance also has a "longest dimension", the length in meters of that '
+            "instance's single longest side."
+        ),
+        (
+            "The room section describes the room as a whole. "
+            'The room also has a "floor area", the total floor area of the room in square '
+            "meters."
+        ),
+        (
+            'The "closest classes distance meters from" section has, for every object class, '
+            "the distance to each other class and the closeness rank of each other class. "
+            "Distance is the minimum distance in meters between an instance of the class and an "
+            "instance of the other class. "
+            "Closeness rank orders the other classes by nearness to the class. "
+            "Rank 1 is the nearest class. The largest rank is the farthest class. "
+            "The larger the rank, the farther the class."
+        ),
+        (
+            'The "appearance order" section lists every object class in the order it '
+            "appeared in the video. "
+            "The leftmost class in the list is the class that appeared earliest. "
+            "The rightmost class in the list is the class that appeared last. "
+            "The further right a class is in the list, the later it appeared."
+        ),
+    ]
+)
 
 
 def distance_only_table(spatial_code):
@@ -132,9 +139,7 @@ def distance_only_table(spatial_code):
     table = code.get("closest classes distance meters from")
     if table:
         code["closest classes distance meters from"] = {
-            class_name: {
-                other: entry["distance"] for other, entry in neighbors.items()
-            }
+            class_name: {other: entry["distance"] for other, entry in neighbors.items()}
             for class_name, neighbors in table.items()
         }
     return code
@@ -178,8 +183,13 @@ def render_code(spatial_code, serialization="json"):
 
 
 def build_prompt(
-    spatial_code, question_type, question, options=None,
-    serialization="json", context_line=None, reasoning_note=False,
+    spatial_code,
+    question_type,
+    question,
+    options=None,
+    serialization="json",
+    context_line=None,
+    reasoning_note=False,
 ):
     """Return the full text prompt: context line, the spatial code itself, the question,
     and the same VSI-Bench post-prompt harness.A uses for the same question_type.
@@ -187,8 +197,16 @@ def build_prompt(
     defaults reproduce the standard prompt byte-for-byte."""
     code_text = render_code(spatial_code, serialization)
     pre_prompt = PRE_PROMPT if context_line is None else context_line
-    na_post = (REASONING_BREVITY_NOTE + "\n" + NA_POST_PROMPT) if reasoning_note else NA_POST_PROMPT
-    mca_post = (REASONING_BREVITY_NOTE + "\n" + MCA_POST_PROMPT) if reasoning_note else MCA_POST_PROMPT
+    na_post = (
+        (REASONING_BREVITY_NOTE + "\n" + NA_POST_PROMPT)
+        if reasoning_note
+        else NA_POST_PROMPT
+    )
+    mca_post = (
+        (REASONING_BREVITY_NOTE + "\n" + MCA_POST_PROMPT)
+        if reasoning_note
+        else MCA_POST_PROMPT
+    )
     if serialization == "yaml" and context_line is None:
         # The context line must not claim JSON when the code is rendered as YAML --
         # otherwise the serialization arm would carry a false description as a

harness/B/run.py

@@ -45,7 +45,13 @@ from harness.B.prompts import (  # noqa: E402
 
 
 def results_dir_for(
-    model, protocol, spatial_code_format, depth, tracking, input_selection, frame_count,
+    model,
+    protocol,
+    spatial_code_format,
+    depth,
+    tracking,
+    input_selection,
+    frame_count,
     results_dir=None,
 ):
     """Return the result root isolated by model + protocol + spatial-code-format +
@@ -56,12 +62,20 @@ def results_dir_for(
     if results_dir is not None:
         return Path(results_dir)
     return (
-        RESULTS_DIR / model / protocol / spatial_code_format / depth / tracking
-        / input_selection / str(frame_count)
+        RESULTS_DIR
+        / model
+        / protocol
+        / spatial_code_format
+        / depth
+        / tracking
+        / input_selection
+        / str(frame_count)
     )
 
 
-def _build_record(row, prompt, answer, metric_name, score, model, model_path, code_info):
+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,
@@ -113,10 +127,20 @@ def _build_record(row, prompt, answer, metric_name, score, model, model_path, co
 
 
 def write_question_result(
-    row, prompt, answer, metric_name, score, model, model_path, code_info, results_dir=None
+    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)
+    record = _build_record(
+        row, prompt, answer, metric_name, score, model, model_path, code_info
+    )
     root = results_dir_for(
         model,
         code_info["protocol"],
@@ -211,7 +235,12 @@ def run(
             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
+                    scene_id,
+                    depth,
+                    input_selection,
+                    tracking,
+                    frame_count,
+                    spatial_code_format,
                 )
                 if strip_schema_legend:
                     # Legend-ablation arm: identical data, no embedded field legend.
@@ -221,27 +250,37 @@ def run(
                 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"),
-                serialization=serialization, context_line=context_line,
+                cached["code"],
+                row["question_type"],
+                row["question"],
+                row.get("options"),
+                serialization=serialization,
+                context_line=context_line,
                 reasoning_note=reasoning_note,
             )
             answer = (
                 adapter.answer_extended(
-                    [], prompt, reasoning_budget=reasoning_budget, force_budget=force_budget
+                    [],
+                    prompt,
+                    reasoning_budget=reasoning_budget,
+                    force_budget=force_budget,
                 )
                 if extended
                 else adapter.answer([], prompt, max_new_tokens=raw_budget)
             )
-            doc = {"question_type": row["question_type"], "ground_truth": row["ground_truth"]}
+            doc = {
+                "question_type": row["question_type"],
+                "ground_truth": row["ground_truth"],
+            }
             score_doc = vsi_official_eval.vsibench_process_results(
                 doc, [answer["answer_text"]]
             )["vsibench_score"]
             metric_name, score = _scalar_score(row["question_type"], score_doc)
             code_info = {
                 "protocol": (
-                    f"{reasoning_budget}" if extended
-                    else f"truncated/{raw_budget}" if raw_budget is not None
-                    else "base"
+                    f"{reasoning_budget}"
+                    if extended
+                    else f"truncated/{raw_budget}" if raw_budget is not None else "base"
                 ),
                 "spatial_code_format": spatial_code_format,
                 "input_selection": input_selection,
@@ -252,13 +291,27 @@ def run(
             }
             if write_results:
                 path, record = write_question_result(
-                    row, prompt, answer, metric_name, score, model, adapter.model_path,
-                    code_info, results_dir,
+                    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
+                    row,
+                    prompt,
+                    answer,
+                    metric_name,
+                    score,
+                    model,
+                    adapter.model_path,
+                    code_info,
                 )
             record["result_path"] = str(path) if path else None
             results.append(record)
@@ -273,73 +326,97 @@ def main():
     parser.add_argument("--model", required=True, choices=vlm_models.available_models())
     parser.add_argument("--scene", default=None, help="restrict to one VSI-Bench scene")
     parser.add_argument(
-        "--spatial-code-format", default=DEFAULT_SPATIAL_CODE_FORMAT,
-        choices=SPATIAL_CODE_FORMATS, dest="spatial_code_format",
+        "--spatial-code-format",
+        default=DEFAULT_SPATIAL_CODE_FORMAT,
+        choices=SPATIAL_CODE_FORMATS,
+        dest="spatial_code_format",
     )
     parser.add_argument(
-        "--input-selection", default=DEFAULT_INPUT_SELECTION,
-        choices=INPUT_SELECTIONS, dest="input_selection",
+        "--input-selection",
+        default=DEFAULT_INPUT_SELECTION,
+        choices=INPUT_SELECTIONS,
+        dest="input_selection",
     )
     parser.add_argument("--frames", type=int, default=FRAMES_PER_VIDEO)
     parser.add_argument("--depth", default=DEFAULT_DEPTH, choices=DEPTH_VARIANTS)
     parser.add_argument("--tracking", default=DEFAULT_TRACKING, choices=TRACKING_MODES)
-    parser.add_argument("--limit", type=int, default=None, help="cap the number of questions")
+    parser.add_argument(
+        "--limit", type=int, default=None, help="cap the number of questions"
+    )
     parser.add_argument("--device", default="cuda")
     parser.add_argument(
-        "--results-dir", default=None,
+        "--results-dir",
+        default=None,
         help="override the default results/B/<model>/<protocol>/<format>/"
         "<depth>/<tracking>/<input>/<frames> root",
     )
     parser.add_argument(
-        "--no-write", action="store_true",
+        "--no-write",
+        action="store_true",
         help="skip writing per-question JSON files; print/score only",
     )
     parser.add_argument(
-        "--serialization", default="json", choices=SERIALIZATIONS,
+        "--serialization",
+        default="json",
+        choices=SERIALIZATIONS,
         help="robustness arm only: render the identical code dict as YAML instead of "
         "JSON (pair with an explicit --results-dir so the arm stays isolated)",
     )
     parser.add_argument(
-        "--paraphrase-context", action="store_true", dest="paraphrase_context",
+        "--paraphrase-context",
+        action="store_true",
+        dest="paraphrase_context",
         help="robustness arm only: use the pre-registered paraphrased context line "
         "(pair with an explicit --results-dir)",
     )
     parser.add_argument(
-        "--no-schema-legend", action="store_true", dest="strip_schema_legend",
+        "--no-schema-legend",
+        action="store_true",
+        dest="strip_schema_legend",
         help="legend-ablation arm: drop the embedded 'spatial code schema' block from "
         "the code before prompting (identical data, no legend; pair with an explicit "
         "--results-dir)",
     )
     parser.add_argument(
-        "--prose-legend", action="store_true", dest="prose_legend",
+        "--prose-legend",
+        action="store_true",
+        dest="prose_legend",
         help="legacy-legend arm: drop the embedded schema block AND use the legacy "
         "prose legend as the context block (pair with an explicit --results-dir)",
     )
     parser.add_argument(
-        "--reasoning-note", action="store_true", dest="reasoning_note",
+        "--reasoning-note",
+        action="store_true",
+        dest="reasoning_note",
         help="prefix the Thinking-with-Spatial-Code step-by-step note to the "
         "post-prompt (pair with an explicit --results-dir)",
     )
     parser.add_argument(
-        "--thinking", action="store_true",
+        "--thinking",
+        action="store_true",
         help="enable the model's native thinking mode (Qwen only; errors on models "
         "without the switch; pair with an explicit --results-dir)",
     )
     parser.add_argument(
-        "--base-protocol", action="store_true",
+        "--base-protocol",
+        action="store_true",
         help="run harness.A's exact fixed 16-token protocol (plain answer()) instead of "
         "the extended 2048-token default",
     )
     parser.add_argument("--reasoning-budget", type=int, default=EXTENDED_MAX_NEW_TOKENS)
     parser.add_argument("--force-budget", type=int, default=MAX_NEW_TOKENS)
     parser.add_argument(
-        "--truncated-budget", type=int, default=None,
+        "--truncated-budget",
+        type=int,
+        default=None,
         help="raw-budget arm: base-protocol mechanics (single generation, no forced "
         "rescue) at this token cap instead of the hardcoded 16 (mutually exclusive "
         "with --base-protocol)",
     )
     parser.add_argument(
-        "--flat-distance-table", action="store_true", dest="flat_distance_table",
+        "--flat-distance-table",
+        action="store_true",
+        dest="flat_distance_table",
         help="flat-table arm: flatten the distance table's two-level nesting into "
         "single-level '<class> to <other>' keys, identical information (pair with "
         "an explicit --results-dir)",
@@ -372,10 +449,13 @@ def main():
         raw_budget=args.truncated_budget,
         serialization=args.serialization,
         context_line=(
-            PROSE_LEGEND if args.prose_legend
-            else PARAPHRASE_PRE_PROMPT if args.paraphrase_context
-            else NO_LEGEND_PRE_PROMPT if args.strip_schema_legend
-            else None
+            PROSE_LEGEND
+            if args.prose_legend
+            else (
+                PARAPHRASE_PRE_PROMPT
+                if args.paraphrase_context
+                else NO_LEGEND_PRE_PROMPT if args.strip_schema_legend else None
+            )
         ),
         strip_schema_legend=args.strip_schema_legend or args.prose_legend,
         reasoning_note=args.reasoning_note,

harness/C/__init__.py

@@ -45,6 +45,4 @@ FRAMES_PER_VIDEO = int(os.environ.get("VSI_HARNESS_C_FRAMES_PER_VIDEO", "32"))
 
 # One JSON per question, matching harness.A/B's layout:
 # results/C/<model>/<spatial_code_format>/<depth>/<tracking>/<input_selection>/<frame_count>/<scene>/<question_id>.json
-RESULTS_DIR = Path(
-    os.environ.get("VSI_HARNESS_C_RESULTS_DIR", "/root/results/C")
-)
+RESULTS_DIR = Path(os.environ.get("VSI_HARNESS_C_RESULTS_DIR", "/root/results/C"))

harness/C/launch.py

@@ -49,12 +49,25 @@ def _load_run_module():
 
 
 def _worker(
-    tasks, results, model, spatial_code_format, input_selection, frame_count, depth, tracking,
-    results_dir, gpu, cpu_threads, extended, reasoning_budget, force_budget,
+    tasks,
+    results,
+    model,
+    spatial_code_format,
+    input_selection,
+    frame_count,
+    depth,
+    tracking,
+    results_dir,
+    gpu,
+    cpu_threads,
+    extended,
+    reasoning_budget,
+    force_budget,
     strip_schema_legend,
     frame_linked,
     overlay,
-    raw_budget, flat_distance_table,
+    raw_budget,
+    flat_distance_table,
 ):
     if gpu is not None:
         os.environ["CUDA_VISIBLE_DEVICES"] = str(gpu)
@@ -109,13 +122,23 @@ def _worker(
 
 
 def launch(
-    model, spatial_code_format, input_selection, frame_count, selected,
-    depth=DEFAULT_DEPTH, tracking=DEFAULT_TRACKING, results_dir=None, rebuild=False,
-    extended=True, reasoning_budget=EXTENDED_MAX_NEW_TOKENS, force_budget=MAX_NEW_TOKENS,
+    model,
+    spatial_code_format,
+    input_selection,
+    frame_count,
+    selected,
+    depth=DEFAULT_DEPTH,
+    tracking=DEFAULT_TRACKING,
+    results_dir=None,
+    rebuild=False,
+    extended=True,
+    reasoning_budget=EXTENDED_MAX_NEW_TOKENS,
+    force_budget=MAX_NEW_TOKENS,
     strip_schema_legend=False,
     frame_linked=False,
     overlay=False,
-    raw_budget=None, flat_distance_table=False,
+    raw_budget=None,
+    flat_distance_table=False,
 ):
     """Answer every question for ``selected`` scenes, sharded across every visible GPU.
 
@@ -125,9 +148,9 @@ def launch(
     if extended and raw_budget is not None:
         raise ValueError("extended and raw_budget are mutually exclusive")
     protocol = (
-        f"{reasoning_budget}" if extended
-        else f"truncated/{raw_budget}" if raw_budget is not None
-        else "base"
+        f"{reasoning_budget}"
+        if extended
+        else f"truncated/{raw_budget}" if raw_budget is not None else "base"
     )
     condition = (
         f"{model}/{protocol}/{spatial_code_format}/{depth}/{tracking}"
@@ -135,7 +158,13 @@ def launch(
     )
     run = _load_run_module()
     root = run.results_dir_for(
-        model, protocol, spatial_code_format, depth, tracking, input_selection, frame_count,
+        model,
+        protocol,
+        spatial_code_format,
+        depth,
+        tracking,
+        input_selection,
+        frame_count,
         results_dir,
         overlay=overlay,
     )
@@ -143,10 +172,17 @@ def launch(
     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)
+            print(
+                f"[{condition} {completed}/{len(selected)}] {scene}: skipped",
+                flush=True,
+            )
         else:
             pending.append(scene)
     if not pending:
@@ -174,9 +210,24 @@ def launch(
         context.Process(
             target=_worker,
             args=(
-                tasks, results, model, spatial_code_format, input_selection, frame_count,
-                depth, tracking, results_dir, gpu, cpu_threads, extended, reasoning_budget,
-                force_budget, strip_schema_legend, frame_linked, overlay, raw_budget,
+                tasks,
+                results,
+                model,
+                spatial_code_format,
+                input_selection,
+                frame_count,
+                depth,
+                tracking,
+                results_dir,
+                gpu,
+                cpu_threads,
+                extended,
+                reasoning_budget,
+                force_budget,
+                strip_schema_legend,
+                frame_linked,
+                overlay,
+                raw_budget,
                 flat_distance_table,
             ),
         )
@@ -208,16 +259,21 @@ def main():
     parser = argparse.ArgumentParser()
     parser.add_argument("scene", nargs="?")
     parser.add_argument(
-        "--scenes", help="comma-separated scenes (cannot be combined with positional scene)"
+        "--scenes",
+        help="comma-separated scenes (cannot be combined with positional scene)",
     )
     parser.add_argument("--model", required=True, choices=vlm_models.available_models())
     parser.add_argument(
-        "--spatial-code-format", default=DEFAULT_SPATIAL_CODE_FORMAT,
-        choices=SPATIAL_CODE_FORMATS, dest="spatial_code_format",
+        "--spatial-code-format",
+        default=DEFAULT_SPATIAL_CODE_FORMAT,
+        choices=SPATIAL_CODE_FORMATS,
+        dest="spatial_code_format",
     )
     parser.add_argument(
-        "--input-selection", default=DEFAULT_INPUT_SELECTION,
-        choices=INPUT_SELECTIONS, dest="input_selection",
+        "--input-selection",
+        default=DEFAULT_INPUT_SELECTION,
+        choices=INPUT_SELECTIONS,
+        dest="input_selection",
     )
     parser.add_argument("--frames", type=int, default=FRAMES_PER_VIDEO)
     parser.add_argument("--depth", default=DEFAULT_DEPTH, choices=DEPTH_VARIANTS)
@@ -225,34 +281,45 @@ def main():
     parser.add_argument("--results-dir", default=None)
     parser.add_argument("--rebuild", action="store_true")
     parser.add_argument(
-        "--base-protocol", action="store_true",
+        "--base-protocol",
+        action="store_true",
         help="run harness.A's exact fixed 16-token protocol instead of the extended default",
     )
     parser.add_argument(
-        "--overlay-ids", action="store_true", dest="overlay",
+        "--overlay-ids",
+        action="store_true",
+        dest="overlay",
         help="strong correspondence arm: stamp instance ids onto the frames at each "
         "instance's projected position and add matching ids to the code (defaults to "
         "/root/results/C/overlay; pair with --no-schema-legend)",
     )
     parser.add_argument(
-        "--frame-linked-code", action="store_true", dest="frame_linked",
+        "--frame-linked-code",
+        action="store_true",
+        dest="frame_linked",
         help="correspondence arm: add per-instance 'first visible in: frame N' pointers "
         "(pair with an explicit --results-dir)",
     )
     parser.add_argument(
-        "--no-schema-legend", action="store_true", dest="strip_schema_legend",
+        "--no-schema-legend",
+        action="store_true",
+        dest="strip_schema_legend",
         help="drop the embedded schema legend (the amended main-run design)",
     )
     parser.add_argument("--reasoning-budget", type=int, default=EXTENDED_MAX_NEW_TOKENS)
     parser.add_argument("--force-budget", type=int, default=MAX_NEW_TOKENS)
     parser.add_argument(
-        "--truncated-budget", type=int, default=None,
+        "--truncated-budget",
+        type=int,
+        default=None,
         help="raw-budget arm: base-protocol mechanics (single generation, no forced "
         "rescue) at this token cap instead of the hardcoded 16 (mutually exclusive "
         "with --base-protocol)",
     )
     parser.add_argument(
-        "--flat-distance-table", action="store_true", dest="flat_distance_table",
+        "--flat-distance-table",
+        action="store_true",
+        dest="flat_distance_table",
         help="flat-table arm: flatten the distance table's two-level nesting into "
         "single-level '<class> to <other>' keys, identical information (pair with "
         "an explicit --results-dir)",
@@ -278,11 +345,19 @@ def main():
     if args.base_protocol and args.truncated_budget is not None:
         parser.error("--base-protocol and --truncated-budget are mutually exclusive")
     launch(
-        args.model, args.spatial_code_format, args.input_selection, args.frames, selected,
-        depth=args.depth, tracking=args.tracking, results_dir=args.results_dir, rebuild=args.rebuild,
+        args.model,
+        args.spatial_code_format,
+        args.input_selection,
+        args.frames,
+        selected,
+        depth=args.depth,
+        tracking=args.tracking,
+        results_dir=args.results_dir,
+        rebuild=args.rebuild,
         extended=not args.base_protocol and args.truncated_budget is None,
         raw_budget=args.truncated_budget,
-        reasoning_budget=args.reasoning_budget, force_budget=args.force_budget,
+        reasoning_budget=args.reasoning_budget,
+        force_budget=args.force_budget,
         strip_schema_legend=args.strip_schema_legend,
         frame_linked=args.frame_linked,
         overlay=args.overlay,

harness/C/overlay.py

@@ -85,7 +85,11 @@ def _place_label_box(anchor_x, anchor_y, width, height, placed, frame_h, step):
         offset = direction * step * ((attempt + 1) // 2)
         top = anchor_y + offset
         box = (anchor_x, top, anchor_x + width, top + height)
-        if 0 <= box[1] and box[3] <= frame_h and not any(_boxes_overlap(box, p) for p in placed):
+        if (
+            0 <= box[1]
+            and box[3] <= frame_h
+            and not any(_boxes_overlap(box, p) for p in placed)
+        ):
             return box, attempt > 0
     return box, True
 
@@ -136,7 +140,9 @@ def _load_raw_sam3_boxes(scene_id, input_selection, tracking, frame_count):
     per frame, per masklet."""
     import torch
 
-    path = encoder_config.sam3_cache_file(scene_id, input_selection, tracking, frame_count)
+    path = encoder_config.sam3_cache_file(
+        scene_id, input_selection, tracking, frame_count
+    )
     if not Path(path).is_file():
         raise FileNotFoundError(
             f"no raw SAM3 cache found for scene {scene_id!r} at {path} -- the strong "
@@ -152,7 +158,8 @@ def _load_raw_sam3_boxes(scene_id, input_selection, tracking, frame_count):
             obj_ids = outputs.get("out_obj_ids", [])
             boxes = outputs.get("out_boxes_xywh", [])
             frames[int(entry["frame_index"])] = {
-                int(oid): tuple(float(v) for v in box) for oid, box in zip(obj_ids, boxes)
+                int(oid): tuple(float(v) for v in box)
+                for oid, box in zip(obj_ids, boxes)
             }
         out[str(class_name)] = frames
     return out
@@ -166,11 +173,57 @@ def overlay_frame_cache_dir(scene_id, depth, input_selection, tracking, frame_co
     room_gravity on the depth-specific geometry cache). Format is always explicit
     (the only format the correspondence arms support), so it isn't part of the path."""
     return (
-        encoder_config.CACHE_ROOT / "overlay-frames" / depth / tracking / input_selection
-        / str(frame_count) / scene_id
+        encoder_config.CACHE_ROOT
+        / "overlay-frames"
+        / depth
+        / tracking
+        / input_selection
+        / str(frame_count)
+        / scene_id
     )
 
 
+def overlay_spatial_code_path(scene_id, depth, input_selection, tracking, frame_count):
+    """Return the durable overlay-code JSON path for one scene/config.
+
+    Overlay codes are stored under the configured spatial-code root's top-level
+    ``overlay`` directory so an overlay run has a browsable code artifact matching
+    the stamped frames, instead of only an in-memory prompt transform.
+    """
+    encoder_config._validate_dimensions(depth, input_selection, tracking, frame_count)
+    return (
+        encoder_config.CODES_ROOT
+        / "overlay"
+        / encoder_config.MODEL
+        / depth
+        / tracking
+        / input_selection
+        / str(frame_count)
+        / "explicit"
+        / f"{scene_id}.json"
+    )
+
+
+def load_or_create_overlay_code(
+    explicit_code, scene_id, depth, input_selection, tracking, frame_count
+):
+    """Load an existing overlay code, or create and save it from ``explicit_code``.
+
+    The saved code is exactly ``instance_ids(explicit_code)``. Existing files are
+    trusted as the durable artifact for that scene/config and are not rewritten.
+    Returns ``(code, path)``.
+    """
+    path = overlay_spatial_code_path(
+        scene_id, depth, input_selection, tracking, frame_count
+    )
+    if path.is_file():
+        return json.loads(path.read_text(encoding="utf-8")), str(path)
+    code = instance_ids(explicit_code)
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(json.dumps(code, indent=1) + "\n", encoding="utf-8")
+    return code, str(path)
+
+
 def _load_cached_frames(cache_dir, frame_count):
     """Return (stamped_frame_copies, per_frame_visible_labels) if a complete cache
     exists at ``cache_dir`` (every frame PNG plus the labels sidecar present), else
@@ -195,7 +248,13 @@ def _save_cached_frames(cache_dir, stamped, visible):
 
 
 def stamp_frames(
-    frame_images, explicit_code, scene_id, depth, input_selection, tracking, frame_count,
+    frame_images,
+    explicit_code,
+    scene_id,
+    depth,
+    input_selection,
+    tracking,
+    frame_count,
     use_cache=True,
 ):
     """Return (stamped_frame_copies, per_frame_visible_labels). For every code
@@ -213,7 +272,9 @@ def stamp_frames(
     it across every model/run that touches this scene/config is a pure speed win.
     Pass False to force a fresh computation (e.g. after a code or overlay-logic
     change, before the cache is known to be stale and worth clearing)."""
-    cache_dir = overlay_frame_cache_dir(scene_id, depth, input_selection, tracking, frame_count)
+    cache_dir = overlay_frame_cache_dir(
+        scene_id, depth, input_selection, tracking, frame_count
+    )
     if use_cache:
         cached = _load_cached_frames(cache_dir, frame_count)
         if cached is not None:
@@ -246,19 +307,24 @@ def stamp_frames(
         frame_labels = []
         for label, class_name, oids in labels:
             frame_detections = raw_boxes.get(class_name, {}).get(frame_index, {})
-            box = next((frame_detections[oid] for oid in oids if oid in frame_detections), None)
+            box = next(
+                (frame_detections[oid] for oid in oids if oid in frame_detections), None
+            )
             if box is None:
                 continue  # SAM3's own tracker did not report this instance in this frame
             nx, ny, nw, nh = box  # normalized [0,1] -- SAM3's own box, verbatim
             bx0, by0 = nx * hi_res_size[0], ny * hi_res_size[1]
             bw, bh = nw * hi_res_size[0], nh * hi_res_size[1]
             draw.rectangle(
-                [bx0, by0, bx0 + bw, by0 + bh], outline="red", width=max(2, _SUPERSAMPLE)
+                [bx0, by0, bx0 + bw, by0 + bh],
+                outline="red",
+                width=max(2, _SUPERSAMPLE),
             )
             px, py = bx0 + bw / 2, by0 + bh / 2
             draw.ellipse(
                 [px - marker_r, py - marker_r, px + marker_r, py + marker_r],
-                outline="red", width=max(2, _SUPERSAMPLE),
+                outline="red",
+                width=max(2, _SUPERSAMPLE),
             )
             # Flip the label to the opposite side of the marker whenever its default
             # placement would run off the frame -- a label clipped at the image edge is
@@ -267,15 +333,26 @@ def stamp_frames(
             text_height = _FONT_SIZE * _SUPERSAMPLE * 1.3
             gap = 8 * _SUPERSAMPLE
             text_x = (
-                px - gap - text_width if px + gap + text_width > hi_res_size[0] else px + gap
+                px - gap - text_width
+                if px + gap + text_width > hi_res_size[0]
+                else px + gap
+            )
+            anchor_y = (
+                py + 4 * _SUPERSAMPLE
+                if py - 10 * _SUPERSAMPLE < 0
+                else py - 10 * _SUPERSAMPLE
             )
-            anchor_y = py + 4 * _SUPERSAMPLE if py - 10 * _SUPERSAMPLE < 0 else py - 10 * _SUPERSAMPLE
             # Nudge this label's box away from every label already placed in this
             # frame -- a crowded cluster fans its labels out instead of stacking them
             # into an unreadable smear (see _place_label_box's docstring).
             label_box, was_nudged = _place_label_box(
-                text_x, anchor_y, text_width, text_height, placed_boxes,
-                hi_res_size[1], step=text_height + 2 * _SUPERSAMPLE,
+                text_x,
+                anchor_y,
+                text_width,
+                text_height,
+                placed_boxes,
+                hi_res_size[1],
+                step=text_height + 2 * _SUPERSAMPLE,
             )
             placed_boxes.append(label_box)
             if was_nudged:
@@ -289,17 +366,24 @@ def stamp_frames(
                 anchor_y_mid = (label_box[1] + label_box[3]) / 2
                 draw.line(
                     [(px, py), (anchor_x, anchor_y_mid)],
-                    fill=(255, 70, 55, 210), width=max(2, _SUPERSAMPLE),
+                    fill=(255, 70, 55, 210),
+                    width=max(2, _SUPERSAMPLE),
                 )
             # A thin dark stroke (not a solid fill box) keeps the label legible
             # against any background without blotting out the photo underneath it.
             draw.text(
-                (label_box[0], label_box[1]), label, font=_LABEL_FONT, fill="#ff4030",
-                stroke_width=max(2, _SUPERSAMPLE), stroke_fill=(0, 0, 0, 235),
+                (label_box[0], label_box[1]),
+                label,
+                font=_LABEL_FONT,
+                fill="#ff4030",
+                stroke_width=max(2, _SUPERSAMPLE),
+                stroke_fill=(0, 0, 0, 235),
             )
             frame_labels.append(label)
         overlay_layer = overlay_layer.resize(image.size, Image.LANCZOS)
-        composited = Image.alpha_composite(image.convert("RGBA"), overlay_layer).convert("RGB")
+        composited = Image.alpha_composite(
+            image.convert("RGBA"), overlay_layer
+        ).convert("RGB")
         stamped.append(composited)
         visible.append(frame_labels)
     if use_cache:

harness/C/overlay_launch.py

@@ -84,15 +84,26 @@ def _generate_one(args):
             video_path, frame_count, input_selection
         )
         overlay.stamp_frames(
-            frame_images, code, scene, depth, input_selection, tracking, frame_count,
+            frame_images,
+            code,
+            scene,
+            depth,
+            input_selection,
+            tracking,
+            frame_count,
             use_cache=True,
         )
+        overlay.load_or_create_overlay_code(
+            code, scene, depth, input_selection, tracking, frame_count
+        )
         return scene, True, None
     except Exception:
         return scene, False, traceback.format_exc()
 
 
-def launch(depth, input_selection, tracking, frame_count, selected, rebuild=False, workers=0):
+def launch(
+    depth, input_selection, tracking, frame_count, selected, rebuild=False, workers=0
+):
     """Pre-generate the overlay-frame cache for every scene in ``selected`` that has
     both required dependencies. Returns (succeeded, failed, skipped_missing_deps)
     scene-name lists."""
@@ -103,7 +114,9 @@ def launch(depth, input_selection, tracking, frame_count, selected, rebuild=Fals
         else:
             missing.append(scene)
     if missing:
-        print(f"[overlay-launch] {len(missing)} scene(s) missing a code or SAM3 cache, skipped:")
+        print(
+            f"[overlay-launch] {len(missing)} scene(s) missing a code or SAM3 cache, skipped:"
+        )
         print(f"  {missing}")
 
     if not rebuild:
@@ -112,7 +125,13 @@ def launch(depth, input_selection, tracking, frame_count, selected, rebuild=Fals
             cache_dir = overlay.overlay_frame_cache_dir(
                 scene, depth, input_selection, tracking, frame_count
             )
-            if overlay._load_cached_frames(cache_dir, frame_count) is not None:
+            code_path = overlay.overlay_spatial_code_path(
+                scene, depth, input_selection, tracking, frame_count
+            )
+            if (
+                overlay._load_cached_frames(cache_dir, frame_count) is not None
+                and code_path.is_file()
+            ):
                 continue
             pending.append(scene)
         skipped = len(eligible) - len(pending)
@@ -122,13 +141,19 @@ def launch(depth, input_selection, tracking, frame_count, selected, rebuild=Fals
         pending = eligible
 
     if not pending:
-        print(f"[overlay-launch] DONE: 0 generated, {len(eligible) - len(pending)} skipped")
+        print(
+            f"[overlay-launch] DONE: 0 generated, {len(eligible) - len(pending)} skipped"
+        )
         return [], [], missing
 
     worker_count = workers if workers > 0 else _available_cpu_count()
     worker_count = min(worker_count, len(pending))
-    print(f"[overlay-launch] generating {len(pending)} scene(s) with {worker_count} worker(s)")
-    tasks = [(scene, depth, input_selection, tracking, frame_count) for scene in pending]
+    print(
+        f"[overlay-launch] generating {len(pending)} scene(s) with {worker_count} worker(s)"
+    )
+    tasks = [
+        (scene, depth, input_selection, tracking, frame_count) for scene in pending
+    ]
     with mp.get_context("spawn").Pool(worker_count) as pool:
         results = pool.map(_generate_one, tasks)
 
@@ -149,17 +174,25 @@ def main():
     parser.add_argument("--tracking", required=True)
     parser.add_argument("--input", required=True, dest="input_selection")
     parser.add_argument("--frames", type=int, required=True)
-    parser.add_argument("--scenes", default=None, help="comma-separated scenes (default: all)")
+    parser.add_argument(
+        "--scenes", default=None, help="comma-separated scenes (default: all)"
+    )
     parser.add_argument("--rebuild", action="store_true")
     parser.add_argument("--workers", type=int, default=0, help="0 = all available CPUs")
     args = parser.parse_args()
     selected = (
         [s.strip() for s in args.scenes.split(",") if s.strip()]
-        if args.scenes else all_scenes()
+        if args.scenes
+        else all_scenes()
     )
     _succeeded, failed, _missing = launch(
-        args.depth, args.input_selection, args.tracking, args.frames, selected,
-        rebuild=args.rebuild, workers=args.workers,
+        args.depth,
+        args.input_selection,
+        args.tracking,
+        args.frames,
+        selected,
+        rebuild=args.rebuild,
+        workers=args.workers,
     )
     if failed:
         raise SystemExit(1)

harness/C/prompts.py

@@ -31,7 +31,9 @@ PRE_PROMPT = FRAMES_PRE_PROMPT + " Also provided is a spatial code: " + CODE_DES
 # No-legend variant: same literal composition, minus the legend claim -- keeps C's
 # line a strict concatenation of A's sentence and B's (no-legend) description.
 NO_LEGEND_PRE_PROMPT = (
-    FRAMES_PRE_PROMPT + " Also provided is a spatial code: " + NO_LEGEND_CODE_DESCRIPTION
+    FRAMES_PRE_PROMPT
+    + " Also provided is a spatial code: "
+    + NO_LEGEND_CODE_DESCRIPTION
 )
 
 # Strong correspondence arm (Set-of-Marks overlays): the no-legend line plus ONE added
@@ -80,7 +82,9 @@ def frame_linked_code(explicit_code, compact_code, frame_timestamps):
     return code
 
 
-def build_prompt(spatial_code, question_type, question, options=None, context_line=None):
+def build_prompt(
+    spatial_code, question_type, question, options=None, context_line=None
+):
     """Return the full trailing text block: context line, the spatial code itself, the
     question, and the same VSI-Bench post-prompt harness.A uses for the same
     question_type. Frames themselves are prepended separately by the caller via
@@ -94,7 +98,9 @@ def build_prompt(spatial_code, question_type, question, options=None, context_li
         if not options:
             raise ValueError(f"question_type {question_type!r} requires options")
         options_block = "Options:\n" + "\n".join(options)
-        return "\n".join([pre_prompt, code_text, question, options_block, MCA_POST_PROMPT])
+        return "\n".join(
+            [pre_prompt, code_text, question, options_block, MCA_POST_PROMPT]
+        )
     raise ValueError(
         f"unknown question_type {question_type!r}; "
         f"expected one of {MCA_QUESTION_TYPES + NA_QUESTION_TYPES}"

harness/C/run.py

@@ -42,8 +42,15 @@ from harness.C.prompts import NO_LEGEND_PRE_PROMPT  # noqa: E402
 
 
 def results_dir_for(
-    model, protocol, spatial_code_format, depth, tracking, input_selection, frame_count,
-    results_dir=None, overlay=False,
+    model,
+    protocol,
+    spatial_code_format,
+    depth,
+    tracking,
+    input_selection,
+    frame_count,
+    results_dir=None,
+    overlay=False,
 ):
     """Return the result root isolated by model + protocol + spatial-code-format +
     depth + tracking + input + frames. ``protocol`` is "base" (16-token) or
@@ -53,12 +60,20 @@ def results_dir_for(
         return Path(results_dir)
     root = RESULTS_DIR / "overlay" if overlay else RESULTS_DIR
     return (
-        root / model / protocol / spatial_code_format / depth / tracking
-        / input_selection / str(frame_count)
+        root
+        / model
+        / protocol
+        / spatial_code_format
+        / depth
+        / tracking
+        / input_selection
+        / str(frame_count)
     )
 
 
-def _build_record(row, prompt, answer, metric_name, score, model, model_path, source_info):
+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,
@@ -113,10 +128,20 @@ def _build_record(row, prompt, answer, metric_name, score, model, model_path, so
 
 
 def write_question_result(
-    row, prompt, answer, metric_name, score, model, model_path, source_info, results_dir=None
+    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)
+    record = _build_record(
+        row, prompt, answer, metric_name, score, model, model_path, source_info
+    )
     root = results_dir_for(
         model,
         source_info["protocol"],
@@ -126,6 +151,7 @@ def write_question_result(
         source_info["input_selection"],
         source_info["frame_count"],
         results_dir,
+        overlay=source_info.get("overlay", False),
     )
     scene_dir = root / record["scene"]
     scene_dir.mkdir(parents=True, exist_ok=True)
@@ -202,13 +228,20 @@ def run(
             "no-legend context line, which is only truthful without the embedded schema"
         )
     protocol = (
-        f"{reasoning_budget}" if extended
-        else f"truncated/{raw_budget}" if raw_budget is not None
-        else "base"
+        f"{reasoning_budget}"
+        if extended
+        else f"truncated/{raw_budget}" if raw_budget is not None else "base"
     )
     results_dir = results_dir_for(
-        model, protocol, spatial_code_format, depth, tracking, input_selection,
-        frame_count, results_dir, overlay=overlay,
+        model,
+        protocol,
+        spatial_code_format,
+        depth,
+        tracking,
+        input_selection,
+        frame_count,
+        results_dir,
+        overlay=overlay,
     )
     rows = load_questions(jsonl_path, scene, scenes, limit)
     if not rows:
@@ -224,15 +257,27 @@ def run(
             scene_id = row["scene_name"]
             if scene_id not in source_cache:
                 video_path = inference_config.video_path(scene_id, row.get("dataset"))
-                frame_images, frame_timestamps, frame_indices = frame_sampling.sample_frames(
-                    video_path, frame_count, input_selection
+                frame_images, frame_timestamps, frame_indices = (
+                    frame_sampling.sample_frames(
+                        video_path, frame_count, input_selection
+                    )
                 )
                 code, code_path = spatial_codes.load_spatial_code(
-                    scene_id, depth, input_selection, tracking, frame_count, spatial_code_format
+                    scene_id,
+                    depth,
+                    input_selection,
+                    tracking,
+                    frame_count,
+                    spatial_code_format,
                 )
                 if frame_linked:
                     compact_code, _ = spatial_codes.load_spatial_code(
-                        scene_id, depth, input_selection, tracking, frame_count, "compact"
+                        scene_id,
+                        depth,
+                        input_selection,
+                        tracking,
+                        frame_count,
+                        "compact",
                     )
                     code = combined_prompts.frame_linked_code(
                         code, compact_code, frame_timestamps
@@ -241,10 +286,17 @@ def run(
                     from harness.C import overlay as overlay_module
 
                     frame_images, _visible = overlay_module.stamp_frames(
-                        frame_images, code, scene_id, depth, input_selection, tracking,
+                        frame_images,
+                        code,
+                        scene_id,
+                        depth,
+                        input_selection,
+                        tracking,
                         frame_count,
                     )
-                    code = overlay_module.instance_ids(code)
+                    code, code_path = overlay_module.load_or_create_overlay_code(
+                        code, scene_id, depth, input_selection, tracking, frame_count
+                    )
                 if strip_schema_legend:
                     code = {k: v for k, v in code.items() if k != "spatial code schema"}
                 if flat_distance_table:
@@ -265,18 +317,28 @@ def run(
             else:
                 context_line = None
             prompt = combined_prompts.build_prompt(
-                cached["code"], row["question_type"], row["question"], row.get("options"),
+                cached["code"],
+                row["question_type"],
+                row["question"],
+                row.get("options"),
                 context_line=context_line,
             )
             answer = (
                 adapter.answer_extended(
-                    cached["frame_images"], prompt,
-                    reasoning_budget=reasoning_budget, force_budget=force_budget,
+                    cached["frame_images"],
+                    prompt,
+                    reasoning_budget=reasoning_budget,
+                    force_budget=force_budget,
                 )
                 if extended
-                else adapter.answer(cached["frame_images"], prompt, max_new_tokens=raw_budget)
+                else adapter.answer(
+                    cached["frame_images"], prompt, max_new_tokens=raw_budget
+                )
             )
-            doc = {"question_type": row["question_type"], "ground_truth": row["ground_truth"]}
+            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"]
@@ -292,16 +354,31 @@ def run(
                 "video_path": cached["video_path"],
                 "frame_indices": cached["frame_indices"],
                 "frame_timestamps": cached["frame_timestamps"],
+                "overlay": overlay,
             }
             if write_results:
                 path, record = write_question_result(
-                    row, prompt, answer, metric_name, score, model, adapter.model_path,
-                    source_info, results_dir,
+                    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
+                    row,
+                    prompt,
+                    answer,
+                    metric_name,
+                    score,
+                    model,
+                    adapter.model_path,
+                    source_info,
                 )
             record["result_path"] = str(path) if path else None
             results.append(record)
@@ -316,57 +393,76 @@ def main():
     parser.add_argument("--model", required=True, choices=vlm_models.available_models())
     parser.add_argument("--scene", default=None, help="restrict to one VSI-Bench scene")
     parser.add_argument(
-        "--spatial-code-format", default=DEFAULT_SPATIAL_CODE_FORMAT,
-        choices=SPATIAL_CODE_FORMATS, dest="spatial_code_format",
+        "--spatial-code-format",
+        default=DEFAULT_SPATIAL_CODE_FORMAT,
+        choices=SPATIAL_CODE_FORMATS,
+        dest="spatial_code_format",
     )
     parser.add_argument(
-        "--input-selection", default=DEFAULT_INPUT_SELECTION,
-        choices=INPUT_SELECTIONS, dest="input_selection",
+        "--input-selection",
+        default=DEFAULT_INPUT_SELECTION,
+        choices=INPUT_SELECTIONS,
+        dest="input_selection",
     )
     parser.add_argument("--frames", type=int, default=FRAMES_PER_VIDEO)
     parser.add_argument("--depth", default=DEFAULT_DEPTH, choices=DEPTH_VARIANTS)
     parser.add_argument("--tracking", default=DEFAULT_TRACKING, choices=TRACKING_MODES)
-    parser.add_argument("--limit", type=int, default=None, help="cap the number of questions")
+    parser.add_argument(
+        "--limit", type=int, default=None, help="cap the number of questions"
+    )
     parser.add_argument("--device", default="cuda")
     parser.add_argument(
-        "--results-dir", default=None,
+        "--results-dir",
+        default=None,
         help="override the default results/C/<model>/<protocol>/<format>/"
         "<depth>/<tracking>/<input>/<frames> root",
     )
     parser.add_argument(
-        "--no-write", action="store_true",
+        "--no-write",
+        action="store_true",
         help="skip writing per-question JSON files; print/score only",
     )
     parser.add_argument(
-        "--base-protocol", action="store_true",
+        "--base-protocol",
+        action="store_true",
         help="run harness.A's exact fixed 16-token protocol (plain answer()) instead of "
         "the extended 2048-token default",
     )
     parser.add_argument(
-        "--overlay-ids", action="store_true", dest="overlay",
+        "--overlay-ids",
+        action="store_true",
+        dest="overlay",
         help="strong correspondence arm: stamp instance ids onto the frames at each "
         "instance's projected position and add matching ids to the code (defaults to "
         "/root/results/C/overlay; pair with --no-schema-legend)",
     )
     parser.add_argument(
-        "--frame-linked-code", action="store_true", dest="frame_linked",
+        "--frame-linked-code",
+        action="store_true",
+        dest="frame_linked",
         help="correspondence arm: add per-instance 'first visible in: frame N' pointers "
         "(pair with an explicit --results-dir)",
     )
     parser.add_argument(
-        "--no-schema-legend", action="store_true", dest="strip_schema_legend",
+        "--no-schema-legend",
+        action="store_true",
+        dest="strip_schema_legend",
         help="drop the embedded schema legend (the amended main-run design)",
     )
     parser.add_argument("--reasoning-budget", type=int, default=EXTENDED_MAX_NEW_TOKENS)
     parser.add_argument("--force-budget", type=int, default=MAX_NEW_TOKENS)
     parser.add_argument(
-        "--truncated-budget", type=int, default=None,
+        "--truncated-budget",
+        type=int,
+        default=None,
         help="raw-budget arm: base-protocol mechanics (single generation, no forced "
         "rescue) at this token cap instead of the hardcoded 16 (mutually exclusive "
         "with --base-protocol)",
     )
     parser.add_argument(
-        "--flat-distance-table", action="store_true", dest="flat_distance_table",
+        "--flat-distance-table",
+        action="store_true",
+        dest="flat_distance_table",
         help="flat-table arm: flatten the distance table's two-level nesting into "
         "single-level '<class> to <other>' keys, identical information (pair with "
         "an explicit --results-dir)",

harness/C/sweep.py

@@ -35,7 +35,9 @@ from harness.B import (  # noqa: E402
 from harness.C import launch as harness_launch  # noqa: E402
 
 
-def build_plan(models, spatial_code_formats, input_selections, frame_counts, depths, trackings):
+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)."""
@@ -51,30 +53,57 @@ def build_plan(models, spatial_code_formats, input_selections, frame_counts, dep
 
 
 def sweep(
-    models, spatial_code_formats, input_selections, frame_counts, selected_scenes,
-    depths=(DEFAULT_DEPTH,), trackings=(DEFAULT_TRACKING,), results_dir=None, rebuild=False,
-    extended=True, reasoning_budget=EXTENDED_MAX_NEW_TOKENS, strip_schema_legend=False,
-    frame_linked=False, overlay=False, raw_budget=None, flat_distance_table=False,
+    models,
+    spatial_code_formats,
+    input_selections,
+    frame_counts,
+    selected_scenes,
+    depths=(DEFAULT_DEPTH,),
+    trackings=(DEFAULT_TRACKING,),
+    results_dir=None,
+    rebuild=False,
+    extended=True,
+    reasoning_budget=EXTENDED_MAX_NEW_TOKENS,
+    strip_schema_legend=False,
+    frame_linked=False,
+    overlay=False,
+    raw_budget=None,
+    flat_distance_table=False,
 ):
     """Run every sweep combination across all visible GPUs."""
-    plan = build_plan(models, spatial_code_formats, input_selections, frame_counts, depths, trackings)
+    plan = build_plan(
+        models, spatial_code_formats, input_selections, frame_counts, depths, trackings
+    )
     protocol = (
-        f"{reasoning_budget}" if extended
-        else f"truncated/{raw_budget}" if raw_budget is not None
-        else "base"
+        f"{reasoning_budget}"
+        if extended
+        else f"truncated/{raw_budget}" if raw_budget is not None else "base"
     )
-    for index, (model, spatial_code_format, depth, tracking, input_selection, frame_count) in enumerate(
-        plan, start=1
-    ):
+    for index, (
+        model,
+        spatial_code_format,
+        depth,
+        tracking,
+        input_selection,
+        frame_count,
+    ) in enumerate(plan, start=1):
         print(
             f"=== sweep {index}/{len(plan)}: {model}/{protocol}/"
             f"{spatial_code_format}/{depth}/{tracking}/{input_selection}/{frame_count} ===",
             flush=True,
         )
         harness_launch.launch(
-            model, spatial_code_format, input_selection, frame_count, selected_scenes,
-            depth=depth, tracking=tracking, results_dir=results_dir, rebuild=rebuild,
-            extended=extended, reasoning_budget=reasoning_budget,
+            model,
+            spatial_code_format,
+            input_selection,
+            frame_count,
+            selected_scenes,
+            depth=depth,
+            tracking=tracking,
+            results_dir=results_dir,
+            rebuild=rebuild,
+            extended=extended,
+            reasoning_budget=reasoning_budget,
             strip_schema_legend=strip_schema_legend,
             frame_linked=frame_linked,
             overlay=overlay,
@@ -87,66 +116,87 @@ def main():
     parser = argparse.ArgumentParser()
     parser.add_argument("scene", nargs="?")
     parser.add_argument(
-        "--scenes", help="comma-separated scenes (cannot be combined with positional scene)"
+        "--scenes",
+        help="comma-separated scenes (cannot be combined with positional scene)",
     )
     parser.add_argument(
-        "--models", required=True,
+        "--models",
+        required=True,
         help=f"comma-separated models (or 'all'); one of {vlm_models.available_models()}",
     )
     parser.add_argument(
-        "--spatial-code-formats", required=True, dest="spatial_code_formats",
+        "--spatial-code-formats",
+        required=True,
+        dest="spatial_code_formats",
         help=f"comma-separated formats (or 'all'); one of {SPATIAL_CODE_FORMATS}",
     )
     parser.add_argument(
-        "--input-selections", required=True, dest="input_selections",
+        "--input-selections",
+        required=True,
+        dest="input_selections",
         help=f"comma-separated selections (or 'all'); one of {INPUT_SELECTIONS}",
     )
     parser.add_argument(
         "--frames", required=True, help="comma-separated frame counts, e.g. 16,32,64"
     )
     parser.add_argument(
-        "--depths", default=DEFAULT_DEPTH,
+        "--depths",
+        default=DEFAULT_DEPTH,
         help=f"comma-separated depths (or 'all'); one of {DEPTH_VARIANTS}",
     )
     parser.add_argument(
-        "--trackings", default=DEFAULT_TRACKING,
+        "--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(
-        "--base-protocol", action="store_true",
+        "--base-protocol",
+        action="store_true",
         help="run the whole sweep under harness.A's exact fixed 16-token protocol "
         "instead of the extended default",
     )
     parser.add_argument(
-        "--reasoning-budget", type=int, default=EXTENDED_MAX_NEW_TOKENS,
+        "--reasoning-budget",
+        type=int,
+        default=EXTENDED_MAX_NEW_TOKENS,
         dest="reasoning_budget",
         help="extended-protocol first-pass budget (the calibrated value from "
         "preregistration.md, e.g. 512)",
     )
     parser.add_argument(
-        "--overlay-ids", action="store_true", dest="overlay",
+        "--overlay-ids",
+        action="store_true",
+        dest="overlay",
         help="strong correspondence arm: stamp instance ids onto the frames at each "
         "instance's projected position and add matching ids to the code (defaults to "
         "/root/results/C/overlay; pair with --no-schema-legend)",
     )
     parser.add_argument(
-        "--frame-linked-code", action="store_true", dest="frame_linked",
+        "--frame-linked-code",
+        action="store_true",
+        dest="frame_linked",
         help="correspondence arm: add per-instance 'first visible in: frame N' pointers "
         "(pair with an explicit --results-dir)",
     )
     parser.add_argument(
-        "--no-schema-legend", action="store_true", dest="strip_schema_legend",
+        "--no-schema-legend",
+        action="store_true",
+        dest="strip_schema_legend",
         help="drop the embedded schema legend (the amended main-run design)",
     )
     parser.add_argument(
-        "--truncated-budget", type=int, default=None,
+        "--truncated-budget",
+        type=int,
+        default=None,
         help="raw-budget arm: base-protocol mechanics (single generation, no forced "
         "rescue) at this token cap (mutually exclusive with --base-protocol)",
     )
     parser.add_argument(
-        "--flat-distance-table", action="store_true", dest="flat_distance_table",
+        "--flat-distance-table",
+        action="store_true",
+        dest="flat_distance_table",
         help="flat-table arm: flatten the distance table's two-level nesting into "
         "single-level '<class> to <other>' keys, identical information",
     )
@@ -157,7 +207,9 @@ def main():
         parser.error("--base-protocol and --truncated-budget are mutually exclusive")
 
     try:
-        models = _parse_csv_choice(args.models, vlm_models.available_models(), "--models")
+        models = _parse_csv_choice(
+            args.models, vlm_models.available_models(), "--models"
+        )
         spatial_code_formats = _parse_csv_choice(
             args.spatial_code_formats, SPATIAL_CODE_FORMATS, "--spatial-code-formats"
         )
@@ -181,9 +233,15 @@ def main():
         selected = [args.scene] if args.scene else scenes()
 
     sweep(
-        models, spatial_code_formats, input_selections, frame_counts, selected,
-        depths=depths, trackings=trackings,
-        results_dir=args.results_dir, rebuild=args.rebuild,
+        models,
+        spatial_code_formats,
+        input_selections,
+        frame_counts,
+        selected,
+        depths=depths,
+        trackings=trackings,
+        results_dir=args.results_dir,
+        rebuild=args.rebuild,
         extended=not args.base_protocol and args.truncated_budget is None,
         reasoning_budget=args.reasoning_budget,
         strip_schema_legend=args.strip_schema_legend,

harness/D/__init__.py

@@ -25,13 +25,18 @@ from __future__ import annotations
 import os
 from pathlib import Path
 
-from harness.A import DO_SAMPLE, JSONL, MAX_NEW_TOKENS, MODEL_PATHS, TEMPERATURE, WORKSPACE_ROOT
+from harness.A import (
+    DO_SAMPLE,
+    JSONL,
+    MAX_NEW_TOKENS,
+    MODEL_PATHS,
+    TEMPERATURE,
+    WORKSPACE_ROOT,
+)
 from harness.B import SPATIAL_CODE_FORMATS
 
 DEFAULT_SPATIAL_CODE_FORMAT = "explicit"
 
 # One JSON per question, matching harness.B's layout minus the axes ground truth doesn't
 # have: results/D/<model>/code/<protocol>/<spatial_code_format>/<scene>/<question_id>.json
-RESULTS_DIR = Path(
-    os.environ.get("VSI_HARNESS_D_RESULTS_DIR", "/root/results/D")
-)
+RESULTS_DIR = Path(os.environ.get("VSI_HARNESS_D_RESULTS_DIR", "/root/results/D"))

harness/D/launch.py

@@ -26,7 +26,11 @@ if str(WORKSPACE_ROOT) not in sys.path:
 from encoder.ground_truth import scenes as ground_truth_scenes  # noqa: E402
 from harness.A import EXTENDED_MAX_NEW_TOKENS, MAX_NEW_TOKENS  # noqa: E402
 from harness.A import models as vlm_models  # noqa: E402
-from harness.B import DEFAULT_INPUT_SELECTION, FRAMES_PER_VIDEO, INPUT_SELECTIONS  # noqa: E402
+from harness.B import (
+    DEFAULT_INPUT_SELECTION,
+    FRAMES_PER_VIDEO,
+    INPUT_SELECTIONS,
+)  # noqa: E402
 from harness.D import DEFAULT_SPATIAL_CODE_FORMAT, SPATIAL_CODE_FORMATS  # noqa: E402
 from inference.launch import available_cpu_count, visible_gpus  # noqa: E402
 
@@ -39,9 +43,24 @@ def _load_run_module():
     return module
 
 
-def _worker(tasks, results, model, spatial_code_format, results_dir, gpu, cpu_threads,
-            extended, reasoning_budget, force_budget, strip_schema_legend,
-            frames, frame_selection, frame_count, raw_budget, flat_distance_table):
+def _worker(
+    tasks,
+    results,
+    model,
+    spatial_code_format,
+    results_dir,
+    gpu,
+    cpu_threads,
+    extended,
+    reasoning_budget,
+    force_budget,
+    strip_schema_legend,
+    frames,
+    frame_selection,
+    frame_count,
+    raw_budget,
+    flat_distance_table,
+):
     if gpu is not None:
         os.environ["CUDA_VISIBLE_DEVICES"] = str(gpu)
     for variable in ("OMP_NUM_THREADS", "MKL_NUM_THREADS", "OPENBLAS_NUM_THREADS"):
@@ -89,11 +108,20 @@ def _worker(tasks, results, model, spatial_code_format, results_dir, gpu, cpu_th
 
 
 def launch(
-    model, spatial_code_format, selected, results_dir=None, rebuild=False,
-    extended=True, reasoning_budget=EXTENDED_MAX_NEW_TOKENS, force_budget=MAX_NEW_TOKENS,
+    model,
+    spatial_code_format,
+    selected,
+    results_dir=None,
+    rebuild=False,
+    extended=True,
+    reasoning_budget=EXTENDED_MAX_NEW_TOKENS,
+    force_budget=MAX_NEW_TOKENS,
     strip_schema_legend=False,
-    frames=False, frame_selection=DEFAULT_INPUT_SELECTION, frame_count=FRAMES_PER_VIDEO,
-    raw_budget=None, flat_distance_table=False,
+    frames=False,
+    frame_selection=DEFAULT_INPUT_SELECTION,
+    frame_count=FRAMES_PER_VIDEO,
+    raw_budget=None,
+    flat_distance_table=False,
 ):
     """Answer every question for ``selected`` scenes, sharded across every visible GPU.
 
@@ -103,26 +131,38 @@ def launch(
     if extended and raw_budget is not None:
         raise ValueError("extended and raw_budget are mutually exclusive")
     protocol = (
-        f"{reasoning_budget}" if extended
-        else f"truncated/{raw_budget}" if raw_budget is not None
-        else "base"
+        f"{reasoning_budget}"
+        if extended
+        else f"truncated/{raw_budget}" if raw_budget is not None else "base"
     )
     condition = f"{model}/{protocol}/{spatial_code_format}"
     if frames:
         condition += f"/frames/{frame_selection}/{frame_count}"
     run = _load_run_module()
     root = run.results_dir_for(
-        model, protocol, spatial_code_format, results_dir,
-        frames=frames, frame_selection=frame_selection, frame_count=frame_count,
+        model,
+        protocol,
+        spatial_code_format,
+        results_dir,
+        frames=frames,
+        frame_selection=frame_selection,
+        frame_count=frame_count,
     )
     pending = []
     completed = 0
     for scene in selected:
         rows = run.load_questions(scene=scene)
+        if not rows:
+            raise ValueError(
+                f"no questions found for scene {scene!r}; check the manifest/scene selection"
+            )
         answered = all((root / scene / f"{row['id']}.json").is_file() for row in rows)
         if answered and not rebuild:
             completed += 1
-            print(f"[{condition} {completed}/{len(selected)}] {scene}: skipped", flush=True)
+            print(
+                f"[{condition} {completed}/{len(selected)}] {scene}: skipped",
+                flush=True,
+            )
         else:
             pending.append(scene)
     if not pending:
@@ -150,9 +190,22 @@ def launch(
         context.Process(
             target=_worker,
             args=(
-                tasks, results, model, spatial_code_format, results_dir, gpu, cpu_threads,
-                extended, reasoning_budget, force_budget, strip_schema_legend,
-                frames, frame_selection, frame_count, raw_budget, flat_distance_table,
+                tasks,
+                results,
+                model,
+                spatial_code_format,
+                results_dir,
+                gpu,
+                cpu_threads,
+                extended,
+                reasoning_budget,
+                force_budget,
+                strip_schema_legend,
+                frames,
+                frame_selection,
+                frame_count,
+                raw_budget,
+                flat_distance_table,
             ),
         )
         for gpu in assignments
@@ -194,47 +247,65 @@ def main():
     parser = argparse.ArgumentParser()
     parser.add_argument("scene", nargs="?")
     parser.add_argument(
-        "--scenes", help="comma-separated scenes (cannot be combined with positional scene)"
+        "--scenes",
+        help="comma-separated scenes (cannot be combined with positional scene)",
     )
     parser.add_argument("--model", required=True, choices=vlm_models.available_models())
     parser.add_argument(
-        "--spatial-code-format", default=DEFAULT_SPATIAL_CODE_FORMAT,
-        choices=SPATIAL_CODE_FORMATS, dest="spatial_code_format",
+        "--spatial-code-format",
+        default=DEFAULT_SPATIAL_CODE_FORMAT,
+        choices=SPATIAL_CODE_FORMATS,
+        dest="spatial_code_format",
     )
     parser.add_argument("--results-dir", default=None)
     parser.add_argument("--rebuild", action="store_true")
     parser.add_argument(
-        "--base-protocol", action="store_true",
+        "--base-protocol",
+        action="store_true",
         help="run harness.A's exact fixed 16-token protocol instead of the extended default",
     )
     parser.add_argument(
-        "--no-schema-legend", action="store_true", dest="strip_schema_legend",
+        "--no-schema-legend",
+        action="store_true",
+        dest="strip_schema_legend",
         help="drop the embedded schema legend (the amended main-run design)",
     )
     parser.add_argument(
-        "--with-frames", action="store_true", dest="frames",
+        "--with-frames",
+        action="store_true",
+        dest="frames",
         help="frames+ground-truth-code arm: also sample and show the scene's raw video "
         "frames alongside the ground-truth code (default sampling: uniform, 32 frames -- "
         "the frozen Step-1 config)",
     )
     parser.add_argument(
-        "--frame-selection", default=DEFAULT_INPUT_SELECTION, choices=INPUT_SELECTIONS,
-        dest="frame_selection", help="only used with --with-frames",
+        "--frame-selection",
+        default=DEFAULT_INPUT_SELECTION,
+        choices=INPUT_SELECTIONS,
+        dest="frame_selection",
+        help="only used with --with-frames",
     )
     parser.add_argument(
-        "--frames-per-video", type=int, default=FRAMES_PER_VIDEO, dest="frame_count",
+        "--frames-per-video",
+        type=int,
+        default=FRAMES_PER_VIDEO,
+        dest="frame_count",
         help="only used with --with-frames",
     )
     parser.add_argument("--reasoning-budget", type=int, default=EXTENDED_MAX_NEW_TOKENS)
     parser.add_argument("--force-budget", type=int, default=MAX_NEW_TOKENS)
     parser.add_argument(
-        "--truncated-budget", type=int, default=None,
+        "--truncated-budget",
+        type=int,
+        default=None,
         help="raw-budget arm: base-protocol mechanics (single generation, no forced "
         "rescue) at this token cap instead of the hardcoded 16 (mutually exclusive "
         "with --base-protocol)",
     )
     parser.add_argument(
-        "--flat-distance-table", action="store_true", dest="flat_distance_table",
+        "--flat-distance-table",
+        action="store_true",
+        dest="flat_distance_table",
         help="flat-table arm: flatten the distance table's two-level nesting into "
         "single-level '<class> to <other>' keys, identical information (pair with "
         "an explicit --results-dir)",
@@ -260,11 +331,17 @@ def main():
     if args.base_protocol and args.truncated_budget is not None:
         parser.error("--base-protocol and --truncated-budget are mutually exclusive")
     launch(
-        args.model, args.spatial_code_format, selected,
-        results_dir=args.results_dir, rebuild=args.rebuild,
+        args.model,
+        args.spatial_code_format,
+        selected,
+        results_dir=args.results_dir,
+        rebuild=args.rebuild,
         extended=not args.base_protocol and args.truncated_budget is None,
-        frames=args.frames, frame_selection=args.frame_selection, frame_count=args.frame_count,
-        reasoning_budget=args.reasoning_budget, force_budget=args.force_budget,
+        frames=args.frames,
+        frame_selection=args.frame_selection,
+        frame_count=args.frame_count,
+        reasoning_budget=args.reasoning_budget,
+        force_budget=args.force_budget,
         strip_schema_legend=args.strip_schema_legend,
         raw_budget=args.truncated_budget,
         flat_distance_table=args.flat_distance_table,

harness/D/prompts.py

@@ -12,11 +12,18 @@ from __future__ import annotations
 
 import json
 
-from harness.A.prompts import MCA_POST_PROMPT, MCA_QUESTION_TYPES, NA_POST_PROMPT, NA_QUESTION_TYPES
+from harness.A.prompts import (
+    MCA_POST_PROMPT,
+    MCA_QUESTION_TYPES,
+    NA_POST_PROMPT,
+    NA_QUESTION_TYPES,
+)
 from harness.B.prompts import NO_LEGEND_PRE_PROMPT, PRE_PROMPT
 
 
-def build_prompt(spatial_code, question_type, question, options=None, context_line=None):
+def build_prompt(
+    spatial_code, question_type, question, options=None, context_line=None
+):
     """Return the full text prompt: context line, the spatial code itself, the question,
     and the same VSI-Bench post-prompt harness.A uses for the same question_type.
     ``context_line`` overrides the standard PRE_PROMPT (the no-legend main-run design
@@ -29,7 +36,9 @@ def build_prompt(spatial_code, question_type, question, options=None, context_li
         if not options:
             raise ValueError(f"question_type {question_type!r} requires options")
         options_block = "Options:\n" + "\n".join(options)
-        return "\n".join([pre_prompt, code_text, question, options_block, MCA_POST_PROMPT])
+        return "\n".join(
+            [pre_prompt, code_text, question, options_block, MCA_POST_PROMPT]
+        )
     raise ValueError(
         f"unknown question_type {question_type!r}; "
         f"expected one of {MCA_QUESTION_TYPES + NA_QUESTION_TYPES}"

harness/D/run.py

@@ -25,18 +25,31 @@ from harness.A import EXTENDED_MAX_NEW_TOKENS, MAX_NEW_TOKENS  # noqa: E402
 from harness.A import frames as frame_sampling  # noqa: E402
 from harness.A import models as vlm_models  # noqa: E402
 from harness.A.run import _scalar_score, load_questions, vsi_official_eval  # noqa: E402
-from harness.B import DEFAULT_INPUT_SELECTION, FRAMES_PER_VIDEO, INPUT_SELECTIONS  # noqa: E402
+from harness.B import (
+    DEFAULT_INPUT_SELECTION,
+    FRAMES_PER_VIDEO,
+    INPUT_SELECTIONS,
+)  # noqa: E402
 from harness.B.prompts import flat_distance_table as _flat_distance_table  # noqa: E402
 from harness.C import prompts as combined_prompts  # noqa: E402
-from harness.D import DEFAULT_SPATIAL_CODE_FORMAT, RESULTS_DIR, SPATIAL_CODE_FORMATS  # noqa: E402
+from harness.D import (
+    DEFAULT_SPATIAL_CODE_FORMAT,
+    RESULTS_DIR,
+    SPATIAL_CODE_FORMATS,
+)  # noqa: E402
 from harness.D import prompts as code_prompts  # noqa: E402
 from harness.D.prompts import NO_LEGEND_PRE_PROMPT  # noqa: E402
 from harness.D import spatial_codes  # noqa: E402
 
 
 def results_dir_for(
-    model, protocol, spatial_code_format, results_dir=None,
-    frames=False, frame_selection=DEFAULT_INPUT_SELECTION, frame_count=FRAMES_PER_VIDEO,
+    model,
+    protocol,
+    spatial_code_format,
+    results_dir=None,
+    frames=False,
+    frame_selection=DEFAULT_INPUT_SELECTION,
+    frame_count=FRAMES_PER_VIDEO,
 ):
     """Return the result root isolated by model + protocol + spatial-code-format.
     ``protocol`` is "base" (16-token) or "<reasoning budget>" (e.g. "512") -- a real path segment, so records from different protocols OR
@@ -49,13 +62,21 @@ def results_dir_for(
     records must never share a path with the text-only condition's."""
     if results_dir is not None:
         return Path(results_dir)
-    root = RESULTS_DIR / model / ("code + frames" if frames else "code") / protocol / spatial_code_format
+    root = (
+        RESULTS_DIR
+        / model
+        / ("code + frames" if frames else "code")
+        / protocol
+        / spatial_code_format
+    )
     if frames:
         root = root / frame_selection / str(frame_count)
     return root
 
 
-def _build_record(row, prompt, answer, metric_name, score, model, model_path, code_info):
+def _build_record(
+    row, prompt, answer, metric_name, score, model, model_path, code_info
+):
     """Assemble one question's full, untruncated result record (nothing summarized).
 
     ``code_info`` carries frame provenance (``video_path``, ``frame_indices``,
@@ -64,7 +85,9 @@ def _build_record(row, prompt, answer, metric_name, score, model, model_path, co
     fields (``reasoning_text`` etc.) are present-but-null rather than absent."""
     condition = f"{code_info['protocol']}:{code_info['spatial_code_format']}"
     if code_info.get("frames"):
-        condition += f":frames:{code_info['frame_selection']}:{code_info['frame_count']}"
+        condition += (
+            f":frames:{code_info['frame_selection']}:{code_info['frame_count']}"
+        )
     return {
         "model": model,
         "model_path": str(model_path),
@@ -113,12 +136,25 @@ def _build_record(row, prompt, answer, metric_name, score, model, model_path, co
 
 
 def write_question_result(
-    row, prompt, answer, metric_name, score, model, model_path, code_info, results_dir=None
+    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)
+    record = _build_record(
+        row, prompt, answer, metric_name, score, model, model_path, code_info
+    )
     root = results_dir_for(
-        model, code_info["protocol"], code_info["spatial_code_format"], results_dir,
+        model,
+        code_info["protocol"],
+        code_info["spatial_code_format"],
+        results_dir,
         frames=code_info.get("frames", False),
         frame_selection=code_info.get("frame_selection", DEFAULT_INPUT_SELECTION),
         frame_count=code_info.get("frame_count", FRAMES_PER_VIDEO),
@@ -215,7 +251,9 @@ def run(
         for row in rows:
             scene_id = row["scene_name"]
             if scene_id not in code_cache:
-                code, path = spatial_codes.load_spatial_code(scene_id, spatial_code_format)
+                code, path = spatial_codes.load_spatial_code(
+                    scene_id, spatial_code_format
+                )
                 if code_transform is not None:
                     code = code_transform(code, scene_id, spatial_code_format)
                 if strip_schema_legend:
@@ -224,47 +262,64 @@ def run(
                     code = _flat_distance_table(code)
                 entry = {"code": code, "path": path}
                 if frames:
-                    video_path = inference_config.video_path(scene_id, row.get("dataset"))
-                    frame_images, frame_timestamps, frame_indices = frame_sampling.sample_frames(
-                        video_path, frame_count, frame_selection
+                    video_path = inference_config.video_path(
+                        scene_id, row.get("dataset")
+                    )
+                    frame_images, frame_timestamps, frame_indices = (
+                        frame_sampling.sample_frames(
+                            video_path, frame_count, frame_selection
+                        )
                     )
                     entry.update(
-                        video_path=video_path, frame_images=frame_images,
-                        frame_timestamps=frame_timestamps, frame_indices=frame_indices,
+                        video_path=video_path,
+                        frame_images=frame_images,
+                        frame_timestamps=frame_timestamps,
+                        frame_indices=frame_indices,
                     )
                 code_cache[scene_id] = entry
             cached = code_cache[scene_id]
             if frames:
                 context_line = (
-                    combined_prompts.NO_LEGEND_PRE_PROMPT if strip_schema_legend
+                    combined_prompts.NO_LEGEND_PRE_PROMPT
+                    if strip_schema_legend
                     else combined_prompts.PRE_PROMPT
                 )
             else:
                 context_line = NO_LEGEND_PRE_PROMPT if strip_schema_legend else None
             prompt = code_prompts.build_prompt(
-                cached["code"], row["question_type"], row["question"], row.get("options"),
+                cached["code"],
+                row["question_type"],
+                row["question"],
+                row.get("options"),
                 context_line=context_line,
             )
             answer = (
                 adapter.answer_extended(
-                    cached["frame_images"] if frames else [], prompt,
-                    reasoning_budget=reasoning_budget, force_budget=force_budget,
+                    cached["frame_images"] if frames else [],
+                    prompt,
+                    reasoning_budget=reasoning_budget,
+                    force_budget=force_budget,
                 )
                 if extended
                 else adapter.answer(
-                    cached["frame_images"] if frames else [], prompt, max_new_tokens=raw_budget
+                    cached["frame_images"] if frames else [],
+                    prompt,
+                    max_new_tokens=raw_budget,
                 )
             )
-            doc = {"question_type": row["question_type"], "ground_truth": row["ground_truth"]}
+            doc = {
+                "question_type": row["question_type"],
+                "ground_truth": row["ground_truth"],
+            }
             score_doc = vsi_official_eval.vsibench_process_results(
                 doc, [answer["answer_text"]]
             )["vsibench_score"]
             metric_name, score = _scalar_score(row["question_type"], score_doc)
             code_info = {
                 "protocol": (
-                    f"{reasoning_budget}" if extended
-                    else f"truncated/{raw_budget}" if raw_budget is not None
-                    else "base"
+                    f"{reasoning_budget}"
+                    if extended
+                    else f"truncated/{raw_budget}" if raw_budget is not None else "base"
                 ),
                 "spatial_code_format": spatial_code_format,
                 "spatial_code_path": cached["path"],
@@ -277,13 +332,27 @@ def run(
             }
             if write_results:
                 path, record = write_question_result(
-                    row, prompt, answer, metric_name, score, model, adapter.model_path,
-                    code_info, results_dir,
+                    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
+                    row,
+                    prompt,
+                    answer,
+                    metric_name,
+                    score,
+                    model,
+                    adapter.model_path,
+                    code_info,
                 )
             record["result_path"] = str(path) if path else None
             results.append(record)
@@ -298,52 +367,73 @@ def main():
     parser.add_argument("--model", required=True, choices=vlm_models.available_models())
     parser.add_argument("--scene", default=None, help="restrict to one VSI-Bench scene")
     parser.add_argument(
-        "--spatial-code-format", default=DEFAULT_SPATIAL_CODE_FORMAT,
-        choices=SPATIAL_CODE_FORMATS, dest="spatial_code_format",
+        "--spatial-code-format",
+        default=DEFAULT_SPATIAL_CODE_FORMAT,
+        choices=SPATIAL_CODE_FORMATS,
+        dest="spatial_code_format",
+    )
+    parser.add_argument(
+        "--limit", type=int, default=None, help="cap the number of questions"
     )
-    parser.add_argument("--limit", type=int, default=None, help="cap the number of questions")
     parser.add_argument("--device", default="cuda")
     parser.add_argument(
-        "--results-dir", default=None,
+        "--results-dir",
+        default=None,
         help="override the default results/D/<model>/<code or code + frames>/<protocol>/<format> root",
     )
     parser.add_argument(
-        "--no-write", action="store_true",
+        "--no-write",
+        action="store_true",
         help="skip writing per-question JSON files; print/score only",
     )
     parser.add_argument(
-        "--base-protocol", action="store_true",
+        "--base-protocol",
+        action="store_true",
         help="run harness.A's exact fixed 16-token protocol (plain answer()) instead of "
         "the extended 2048-token default",
     )
     parser.add_argument(
-        "--no-schema-legend", action="store_true", dest="strip_schema_legend",
+        "--no-schema-legend",
+        action="store_true",
+        dest="strip_schema_legend",
         help="drop the embedded schema legend (the amended main-run design)",
     )
     parser.add_argument(
-        "--with-frames", action="store_true", dest="frames",
+        "--with-frames",
+        action="store_true",
+        dest="frames",
         help="frames+ground-truth-code arm: also sample and show the scene's raw video "
         "frames alongside the ground-truth code (default sampling: uniform, 32 frames -- "
         "the frozen Step-1 config)",
     )
     parser.add_argument(
-        "--frame-selection", default=DEFAULT_INPUT_SELECTION, choices=INPUT_SELECTIONS,
-        dest="frame_selection", help="only used with --with-frames",
+        "--frame-selection",
+        default=DEFAULT_INPUT_SELECTION,
+        choices=INPUT_SELECTIONS,
+        dest="frame_selection",
+        help="only used with --with-frames",
     )
     parser.add_argument(
-        "--frames-per-video", type=int, default=FRAMES_PER_VIDEO, dest="frame_count",
+        "--frames-per-video",
+        type=int,
+        default=FRAMES_PER_VIDEO,
+        dest="frame_count",
         help="only used with --with-frames",
     )
     parser.add_argument("--reasoning-budget", type=int, default=EXTENDED_MAX_NEW_TOKENS)
     parser.add_argument("--force-budget", type=int, default=MAX_NEW_TOKENS)
     parser.add_argument(
-        "--truncated-budget", type=int, default=None,
+        "--truncated-budget",
+        type=int,
+        default=None,
         help="raw-budget arm: base-protocol mechanics (single generation, no forced "
         "rescue) at this token cap instead of the hardcoded 16 (mutually exclusive "
         "with --base-protocol)",
     )
     parser.add_argument(
-        "--flat-distance-table", action="store_true", dest="flat_distance_table",
+        "--flat-distance-table",
+        action="store_true",
+        dest="flat_distance_table",
         help="flat-table arm: flatten the distance table's two-level nesting into "
         "single-level '<class> to <other>' keys, identical information (pair with "
         "an explicit --results-dir)",

harness/D/sweep.py

@@ -25,7 +25,12 @@ if str(WORKSPACE_ROOT) not in sys.path:
 from harness.A import models as vlm_models  # noqa: E402
 from harness.A import EXTENDED_MAX_NEW_TOKENS  # noqa: E402
 from harness.A.sweep import _parse_csv_choice  # noqa: E402
-from harness.B import DEFAULT_INPUT_SELECTION, FRAMES_PER_VIDEO, INPUT_SELECTIONS, SPATIAL_CODE_FORMATS  # noqa: E402
+from harness.B import (
+    DEFAULT_INPUT_SELECTION,
+    FRAMES_PER_VIDEO,
+    INPUT_SELECTIONS,
+    SPATIAL_CODE_FORMATS,
+)  # noqa: E402
 from harness.D import launch as harness_launch  # noqa: E402
 
 
@@ -39,30 +44,48 @@ def build_plan(models, spatial_code_formats):
 
 
 def sweep(
-    models, spatial_code_formats, selected_scenes, results_dir=None, rebuild=False,
-    extended=True, reasoning_budget=EXTENDED_MAX_NEW_TOKENS, strip_schema_legend=False,
-    frames=False, frame_selection=DEFAULT_INPUT_SELECTION, frame_count=FRAMES_PER_VIDEO,
-    raw_budget=None, flat_distance_table=False,
+    models,
+    spatial_code_formats,
+    selected_scenes,
+    results_dir=None,
+    rebuild=False,
+    extended=True,
+    reasoning_budget=EXTENDED_MAX_NEW_TOKENS,
+    strip_schema_legend=False,
+    frames=False,
+    frame_selection=DEFAULT_INPUT_SELECTION,
+    frame_count=FRAMES_PER_VIDEO,
+    raw_budget=None,
+    flat_distance_table=False,
 ):
     """Run every (model, spatial_code_format) pair across all visible GPUs."""
     plan = build_plan(models, spatial_code_formats)
     protocol = (
-        f"{reasoning_budget}" if extended
-        else f"truncated/{raw_budget}" if raw_budget is not None
-        else "base"
+        f"{reasoning_budget}"
+        if extended
+        else f"truncated/{raw_budget}" if raw_budget is not None else "base"
     )
     for index, (model, spatial_code_format) in enumerate(plan, start=1):
         print(
             f"=== sweep {index}/{len(plan)}: {model}/{protocol}/{spatial_code_format}"
-            + (f"/frames/{frame_selection}/{frame_count}" if frames else "") + " ===",
+            + (f"/frames/{frame_selection}/{frame_count}" if frames else "")
+            + " ===",
             flush=True,
         )
         harness_launch.launch(
-            model, spatial_code_format, selected_scenes,
-            results_dir=results_dir, rebuild=rebuild, extended=extended,
-            reasoning_budget=reasoning_budget, strip_schema_legend=strip_schema_legend,
-            frames=frames, frame_selection=frame_selection, frame_count=frame_count,
-            raw_budget=raw_budget, flat_distance_table=flat_distance_table,
+            model,
+            spatial_code_format,
+            selected_scenes,
+            results_dir=results_dir,
+            rebuild=rebuild,
+            extended=extended,
+            reasoning_budget=reasoning_budget,
+            strip_schema_legend=strip_schema_legend,
+            frames=frames,
+            frame_selection=frame_selection,
+            frame_count=frame_count,
+            raw_budget=raw_budget,
+            flat_distance_table=flat_distance_table,
         )
 
 
@@ -70,55 +93,76 @@ def main():
     parser = argparse.ArgumentParser()
     parser.add_argument("scene", nargs="?")
     parser.add_argument(
-        "--scenes", help="comma-separated scenes (cannot be combined with positional scene)"
+        "--scenes",
+        help="comma-separated scenes (cannot be combined with positional scene)",
     )
     parser.add_argument(
-        "--models", required=True,
+        "--models",
+        required=True,
         help=f"comma-separated models (or 'all'); one of {vlm_models.available_models()}",
     )
     parser.add_argument(
-        "--spatial-code-formats", default="all", dest="spatial_code_formats",
+        "--spatial-code-formats",
+        default="all",
+        dest="spatial_code_formats",
         help=f"comma-separated formats (or 'all'); one of {SPATIAL_CODE_FORMATS}",
     )
     parser.add_argument("--results-dir", default=None)
     parser.add_argument("--rebuild", action="store_true")
     parser.add_argument(
-        "--base-protocol", action="store_true",
+        "--base-protocol",
+        action="store_true",
         help="run the whole sweep under harness.A's exact fixed 16-token protocol "
         "instead of the extended default",
     )
     parser.add_argument(
-        "--reasoning-budget", type=int, default=EXTENDED_MAX_NEW_TOKENS,
+        "--reasoning-budget",
+        type=int,
+        default=EXTENDED_MAX_NEW_TOKENS,
         dest="reasoning_budget",
         help="extended-protocol first-pass budget (the calibrated value from "
         "analysis/preregistration.md, e.g. 512)",
     )
     parser.add_argument(
-        "--no-schema-legend", action="store_true", dest="strip_schema_legend",
+        "--no-schema-legend",
+        action="store_true",
+        dest="strip_schema_legend",
         help="drop the embedded schema legend (the amended main-run design)",
     )
     parser.add_argument(
-        "--with-frames", action="store_true", dest="frames",
+        "--with-frames",
+        action="store_true",
+        dest="frames",
         help="frames+ground-truth-code arm: also sample and show the scene's raw video "
         "frames alongside the ground-truth code (default sampling: uniform, 32 frames -- "
         "the frozen Step-1 config)",
     )
     parser.add_argument(
-        "--frame-selection", default=DEFAULT_INPUT_SELECTION, choices=INPUT_SELECTIONS,
-        dest="frame_selection", help="only used with --with-frames",
+        "--frame-selection",
+        default=DEFAULT_INPUT_SELECTION,
+        choices=INPUT_SELECTIONS,
+        dest="frame_selection",
+        help="only used with --with-frames",
     )
     parser.add_argument(
-        "--frames-per-video", type=int, default=FRAMES_PER_VIDEO, dest="frame_count",
+        "--frames-per-video",
+        type=int,
+        default=FRAMES_PER_VIDEO,
+        dest="frame_count",
         help="only used with --with-frames",
     )
     parser.add_argument(
-        "--truncated-budget", type=int, default=None,
+        "--truncated-budget",
+        type=int,
+        default=None,
         help="raw-budget arm: base-protocol mechanics (single generation, no forced "
         "rescue) at this token cap instead of the hardcoded 16 (mutually exclusive "
         "with --base-protocol)",
     )
     parser.add_argument(
-        "--flat-distance-table", action="store_true", dest="flat_distance_table",
+        "--flat-distance-table",
+        action="store_true",
+        dest="flat_distance_table",
         help="flat-table arm: flatten the distance table's two-level nesting into "
         "single-level '<class> to <other>' keys, identical information",
     )
@@ -133,7 +177,9 @@ def main():
         parser.error("--base-protocol and --truncated-budget are mutually exclusive")
 
     try:
-        models = _parse_csv_choice(args.models, vlm_models.available_models(), "--models")
+        models = _parse_csv_choice(
+            args.models, vlm_models.available_models(), "--models"
+        )
         spatial_code_formats = _parse_csv_choice(
             args.spatial_code_formats, SPATIAL_CODE_FORMATS, "--spatial-code-formats"
         )
@@ -149,12 +195,17 @@ def main():
         selected = [args.scene] if args.scene else harness_launch.scenes()
 
     sweep(
-        models, spatial_code_formats, selected,
-        results_dir=args.results_dir, rebuild=args.rebuild,
+        models,
+        spatial_code_formats,
+        selected,
+        results_dir=args.results_dir,
+        rebuild=args.rebuild,
         extended=not args.base_protocol and args.truncated_budget is None,
         reasoning_budget=args.reasoning_budget,
         strip_schema_legend=args.strip_schema_legend,
-        frames=args.frames, frame_selection=args.frame_selection, frame_count=args.frame_count,
+        frames=args.frames,
+        frame_selection=args.frame_selection,
+        frame_count=args.frame_count,
         raw_budget=args.truncated_budget,
         flat_distance_table=args.flat_distance_table,
     )

harness/D/symbolic_eval.py

@@ -55,12 +55,22 @@ def run(
         scene_id = row["scene_name"]
         if scene_id not in code_cache:
             code, path = spatial_codes.load_spatial_code(scene_id, spatial_code_format)
-            code_cache[scene_id] = {"adapted": adapters.adapt_spatial_code(code), "path": path}
+            code_cache[scene_id] = {
+                "adapted": adapters.adapt_spatial_code(code),
+                "path": path,
+            }
         cached = code_cache[scene_id]
-        answer = solver.answer(row["question_type"], row["question"], row["options"], cached["adapted"])
+        answer = solver.answer(
+            row["question_type"], row["question"], row["options"], cached["adapted"]
+        )
         pred_str = "" if answer is None else str(answer)
-        doc = {"question_type": row["question_type"], "ground_truth": row["ground_truth"]}
-        score_doc = vsi_official_eval.vsibench_process_results(doc, [pred_str])["vsibench_score"]
+        doc = {
+            "question_type": row["question_type"],
+            "ground_truth": row["ground_truth"],
+        }
+        score_doc = vsi_official_eval.vsibench_process_results(doc, [pred_str])[
+            "vsibench_score"
+        ]
         _metric_name, score = _scalar_score(row["question_type"], score_doc)
         record = {
             "scene": scene_id,
@@ -98,12 +108,15 @@ def main():
     parser.add_argument("scene", nargs="?")
     parser.add_argument("--scenes", help="comma-separated scenes")
     parser.add_argument(
-        "--spatial-code-format", default=DEFAULT_SPATIAL_CODE_FORMAT,
-        choices=SPATIAL_CODE_FORMATS, dest="spatial_code_format",
+        "--spatial-code-format",
+        default=DEFAULT_SPATIAL_CODE_FORMAT,
+        choices=SPATIAL_CODE_FORMATS,
+        dest="spatial_code_format",
     )
     parser.add_argument("--limit", type=int, default=None)
     parser.add_argument(
-        "--results-dir", default=None,
+        "--results-dir",
+        default=None,
         help="override the default results/symbolic/ground truth/<format> root",
     )
     parser.add_argument("--no-write", action="store_true")
@@ -112,7 +125,9 @@ def main():
         parser.error("positional scene and --scenes cannot be used together")
     selected = None
     if args.scenes:
-        selected = list(dict.fromkeys(s.strip() for s in args.scenes.split(",") if s.strip()))
+        selected = list(
+            dict.fromkeys(s.strip() for s in args.scenes.split(",") if s.strip())
+        )
 
     results = run(
         spatial_code_format=args.spatial_code_format,

harness/E/__init__.py

@@ -28,6 +28,4 @@ from harness.A import (
 )
 
 # One JSON per question: results/E/<model>/<protocol>/<scene>/<question_id>.json
-RESULTS_DIR = Path(
-    os.environ.get("VSI_HARNESS_E_RESULTS_DIR", "/root/results/E")
-)
+RESULTS_DIR = Path(os.environ.get("VSI_HARNESS_E_RESULTS_DIR", "/root/results/E"))

harness/E/launch.py

@@ -35,8 +35,17 @@ def _load_run_module():
     return module
 
 
-def _worker(tasks, results, model, results_dir, gpu, cpu_threads, extended,
-            reasoning_budget, force_budget):
+def _worker(
+    tasks,
+    results,
+    model,
+    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"):
@@ -77,8 +86,13 @@ def _worker(tasks, results, model, results_dir, gpu, cpu_threads, extended,
 
 
 def launch(
-    model, selected, results_dir=None, rebuild=False, extended=False,
-    reasoning_budget=EXTENDED_MAX_NEW_TOKENS, force_budget=MAX_NEW_TOKENS,
+    model,
+    selected,
+    results_dir=None,
+    rebuild=False,
+    extended=False,
+    reasoning_budget=EXTENDED_MAX_NEW_TOKENS,
+    force_budget=MAX_NEW_TOKENS,
 ):
     """Answer every question for ``selected`` scenes, sharded across every visible GPU."""
     protocol = f"{reasoning_budget}" if extended else "base"
@@ -89,10 +103,17 @@ def launch(
     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)
+            print(
+                f"[{condition} {completed}/{len(selected)}] {scene}: skipped",
+                flush=True,
+            )
         else:
             pending.append(scene)
     if not pending:
@@ -120,8 +141,15 @@ def launch(
         context.Process(
             target=_worker,
             args=(
-                tasks, results, model, results_dir, gpu, cpu_threads, extended,
-                reasoning_budget, force_budget,
+                tasks,
+                results,
+                model,
+                results_dir,
+                gpu,
+                cpu_threads,
+                extended,
+                reasoning_budget,
+                force_budget,
             ),
         )
         for gpu in assignments
@@ -152,13 +180,15 @@ def main():
     parser = argparse.ArgumentParser()
     parser.add_argument("scene", nargs="?")
     parser.add_argument(
-        "--scenes", help="comma-separated scenes (cannot be combined with positional scene)"
+        "--scenes",
+        help="comma-separated scenes (cannot be combined with positional scene)",
     )
     parser.add_argument("--model", required=True, choices=vlm_models.available_models())
     parser.add_argument("--results-dir", default=None)
     parser.add_argument("--rebuild", action="store_true")
     parser.add_argument(
-        "--extended", action="store_true",
+        "--extended",
+        action="store_true",
         help="use the extended 2048-token protocol instead of the fixed 16-token default",
     )
     parser.add_argument("--reasoning-budget", type=int, default=EXTENDED_MAX_NEW_TOKENS)
@@ -178,8 +208,12 @@ def main():
     if args.force_budget < 1:
         parser.error("--force-budget must be positive")
     launch(
-        args.model, selected, results_dir=args.results_dir, rebuild=args.rebuild,
-        extended=args.extended, reasoning_budget=args.reasoning_budget,
+        args.model,
+        selected,
+        results_dir=args.results_dir,
+        rebuild=args.rebuild,
+        extended=args.extended,
+        reasoning_budget=args.reasoning_budget,
         force_budget=args.force_budget,
     )
 

harness/E/prompts.py

@@ -9,7 +9,12 @@ plus the same post-prompt every other harness uses for that question type.
 
 from __future__ import annotations
 
-from harness.A.prompts import MCA_POST_PROMPT, MCA_QUESTION_TYPES, NA_POST_PROMPT, NA_QUESTION_TYPES
+from harness.A.prompts import (
+    MCA_POST_PROMPT,
+    MCA_QUESTION_TYPES,
+    NA_POST_PROMPT,
+    NA_QUESTION_TYPES,
+)
 
 
 def build_prompt(question_type, question, options=None):

harness/E/run.py

@@ -74,10 +74,20 @@ def _build_record(row, prompt, answer, metric_name, score, model, model_path, pr
 
 
 def write_question_result(
-    row, prompt, answer, metric_name, score, model, model_path, protocol, results_dir=None
+    row,
+    prompt,
+    answer,
+    metric_name,
+    score,
+    model,
+    model_path,
+    protocol,
+    results_dir=None,
 ):
     """Write one question's full, untruncated result record. Return (path, record)."""
-    record = _build_record(row, prompt, answer, metric_name, score, model, model_path, protocol)
+    record = _build_record(
+        row, prompt, answer, metric_name, score, model, model_path, protocol
+    )
     root = results_dir_for(model, protocol, results_dir)
     scene_dir = root / record["scene"]
     scene_dir.mkdir(parents=True, exist_ok=True)
@@ -128,25 +138,45 @@ def run(
             )
             answer = (
                 adapter.answer_extended(
-                    [], prompt, reasoning_budget=reasoning_budget, force_budget=force_budget
+                    [],
+                    prompt,
+                    reasoning_budget=reasoning_budget,
+                    force_budget=force_budget,
                 )
                 if extended
                 else adapter.answer([], prompt)
             )
-            doc = {"question_type": row["question_type"], "ground_truth": row["ground_truth"]}
+            doc = {
+                "question_type": row["question_type"],
+                "ground_truth": row["ground_truth"],
+            }
             score_doc = vsi_official_eval.vsibench_process_results(
                 doc, [answer["answer_text"]]
             )["vsibench_score"]
             metric_name, score = _scalar_score(row["question_type"], score_doc)
             if write_results:
                 path, record = write_question_result(
-                    row, prompt, answer, metric_name, score, model, adapter.model_path,
-                    protocol, results_dir,
+                    row,
+                    prompt,
+                    answer,
+                    metric_name,
+                    score,
+                    model,
+                    adapter.model_path,
+                    protocol,
+                    results_dir,
                 )
             else:
                 path = None
                 record = _build_record(
-                    row, prompt, answer, metric_name, score, model, adapter.model_path, protocol
+                    row,
+                    prompt,
+                    answer,
+                    metric_name,
+                    score,
+                    model,
+                    adapter.model_path,
+                    protocol,
                 )
             record["result_path"] = str(path) if path else None
             results.append(record)
@@ -160,18 +190,23 @@ def main():
     parser = argparse.ArgumentParser()
     parser.add_argument("--model", required=True, choices=vlm_models.available_models())
     parser.add_argument("--scene", default=None, help="restrict to one VSI-Bench scene")
-    parser.add_argument("--limit", type=int, default=None, help="cap the number of questions")
+    parser.add_argument(
+        "--limit", type=int, default=None, help="cap the number of questions"
+    )
     parser.add_argument("--device", default="cuda")
     parser.add_argument(
-        "--results-dir", default=None,
+        "--results-dir",
+        default=None,
         help="override the default results/E/<model>/<protocol> root",
     )
     parser.add_argument(
-        "--no-write", action="store_true",
+        "--no-write",
+        action="store_true",
         help="skip writing per-question JSON files; print/score only",
     )
     parser.add_argument(
-        "--extended", action="store_true",
+        "--extended",
+        action="store_true",
         help=(
             f"use a {EXTENDED_MAX_NEW_TOKENS}-token reasoning budget instead of the fixed "
             f"{MAX_NEW_TOKENS}-token VSI-Bench protocol, with a short forced second call "

harness/E/sweep.py

@@ -23,7 +23,11 @@ from harness.E import launch as harness_launch  # noqa: E402
 
 
 def sweep(
-    models, selected_scenes, results_dir=None, rebuild=False, extended=False,
+    models,
+    selected_scenes,
+    results_dir=None,
+    rebuild=False,
+    extended=False,
     reasoning_budget=EXTENDED_MAX_NEW_TOKENS,
 ):
     """Run every model across all visible GPUs."""
@@ -31,8 +35,12 @@ def sweep(
     for index, model in enumerate(models, start=1):
         print(f"=== sweep {index}/{len(models)}: {model}/{protocol} ===", flush=True)
         harness_launch.launch(
-            model, selected_scenes, results_dir=results_dir, rebuild=rebuild,
-            extended=extended, reasoning_budget=reasoning_budget,
+            model,
+            selected_scenes,
+            results_dir=results_dir,
+            rebuild=rebuild,
+            extended=extended,
+            reasoning_budget=reasoning_budget,
         )
 
 
@@ -40,21 +48,26 @@ def main():
     parser = argparse.ArgumentParser()
     parser.add_argument("scene", nargs="?")
     parser.add_argument(
-        "--scenes", help="comma-separated scenes (cannot be combined with positional scene)"
+        "--scenes",
+        help="comma-separated scenes (cannot be combined with positional scene)",
     )
     parser.add_argument(
-        "--models", required=True,
+        "--models",
+        required=True,
         help=f"comma-separated models (or 'all'); one of {vlm_models.available_models()}",
     )
     parser.add_argument("--results-dir", default=None)
     parser.add_argument("--rebuild", action="store_true")
     parser.add_argument(
-        "--extended", action="store_true",
+        "--extended",
+        action="store_true",
         help="run the whole sweep under the extended protocol instead of the fixed "
         "16-token default",
     )
     parser.add_argument(
-        "--reasoning-budget", type=int, default=EXTENDED_MAX_NEW_TOKENS,
+        "--reasoning-budget",
+        type=int,
+        default=EXTENDED_MAX_NEW_TOKENS,
         dest="reasoning_budget",
         help="extended-protocol first-pass budget (the calibrated value from "
         "analysis/preregistration.md, e.g. 512)",
@@ -64,7 +77,9 @@ def main():
         parser.error("positional scene and --scenes cannot be used together")
 
     try:
-        models = _parse_csv_choice(args.models, vlm_models.available_models(), "--models")
+        models = _parse_csv_choice(
+            args.models, vlm_models.available_models(), "--models"
+        )
     except ValueError as exc:
         parser.error(str(exc))
 
@@ -79,8 +94,12 @@ def main():
         selected = [args.scene] if args.scene else scenes()
 
     sweep(
-        models, selected, results_dir=args.results_dir, rebuild=args.rebuild,
-        extended=args.extended, reasoning_budget=args.reasoning_budget,
+        models,
+        selected,
+        results_dir=args.results_dir,
+        rebuild=args.rebuild,
+        extended=args.extended,
+        reasoning_budget=args.reasoning_budget,
     )
 
 

harness/F/__init__.py

@@ -1,4 +1,5 @@
 """Harness F: deterministic symbolic reasoning over perceived or ground-truth spatial codes."""
+
 from pathlib import Path
 import os