Add files using upload-large-folder tool

harness/A/__init__.py

@@ -47,6 +47,12 @@ DO_SAMPLE = False
 EXTENDED_MAX_NEW_TOKENS = 2048
 FORCE_ANSWER_PROMPT = "\nFinal answer:"
 
+# The generation-protocol axis every harness sweeps: "base" is the paper's fixed
+# 16-token protocol (plain answer()), "extended" is the 2048-token answer_extended
+# protocol above. A results-path segment on every harness, so the two protocols'
+# records can never collide on disk.
+PROTOCOLS = ("base", "extended")
+
 MODEL_PATHS = {
     "qwen3.5-4b": MODELS_ROOT / "qwen3.5-4b",
     "qwen3.5-2b": MODELS_ROOT / "qwen3.5-2b",

harness/A/launch.py

@@ -103,9 +103,10 @@ def launch(
     extended=False, reasoning_budget=EXTENDED_MAX_NEW_TOKENS, force_budget=MAX_NEW_TOKENS,
 ):
     """Answer every question for ``selected`` scenes, sharded across every visible GPU."""
-    condition = f"{model}/{frame_selection}/{frame_count}"
+    protocol = "extended" if extended else "base"
+    condition = f"{model}/{protocol}/{frame_selection}/{frame_count}"
     run = _load_run_module()
-    root = run.results_dir_for(model, 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:

harness/A/run.py

@@ -93,11 +93,13 @@ def load_questions(jsonl_path=None, scene=None, scenes=None, limit=None):
     return rows
 
 
-def results_dir_for(model, frame_selection, frame_count, results_dir=None):
-    """Return the result root isolated by model + frame-selection + frame-count."""
+def results_dir_for(model, protocol, frame_selection, frame_count, results_dir=None):
+    """Return the result root isolated by model + protocol + frame-selection +
+    frame-count. ``protocol`` is "base" (16-token) or "extended" (2048-token) -- a real
+    path segment, so the two protocols' records can never collide on disk."""
     if results_dir is not None:
         return Path(results_dir)
-    return RESULTS_DIR / model / frame_selection / str(frame_count)
+    return RESULTS_DIR / model / protocol / frame_selection / str(frame_count)
 
 
 def _build_record(row, prompt, answer, metric_name, score, model, model_path, frame_info):
@@ -108,7 +110,11 @@ def _build_record(row, prompt, answer, metric_name, score, model, model_path, fr
         "device": answer["device"],
         "dtype": answer["dtype"],
         "library_versions": answer["library_versions"],
-        "condition": f"{frame_info['frame_selection']}:{frame_info['frame_count']}",
+        "condition": (
+            f"{frame_info['protocol']}:{frame_info['frame_selection']}:"
+            f"{frame_info['frame_count']}"
+        ),
+        "protocol": frame_info["protocol"],
         "frame_selection": frame_info["frame_selection"],
         "frame_count": frame_info["frame_count"],
         "video_path": frame_info["video_path"],
@@ -153,7 +159,8 @@ def write_question_result(
         row, prompt, answer, metric_name, score, model, model_path, frame_info
     )
     root = results_dir_for(
-        model, frame_info["frame_selection"], frame_info["frame_count"], results_dir
+        model, frame_info["protocol"], frame_info["frame_selection"],
+        frame_info["frame_count"], results_dir,
     )
     scene_dir = root / record["scene"]
     scene_dir.mkdir(parents=True, exist_ok=True)
@@ -239,6 +246,7 @@ def run(
             )["vsibench_score"]
             metric_name, score = _scalar_score(row["question_type"], score_doc)
             frame_info = {
+                "protocol": "extended" if extended else "base",
                 "video_path": cached["video_path"],
                 "frame_timestamps": cached["frame_timestamps"],
                 "frame_indices": cached["frame_indices"],
@@ -279,7 +287,7 @@ def main():
     parser.add_argument(
         "--results-dir",
         default=None,
-        help="override the default results/A/<model>/<selection>/<frames> root",
+        help="override the default results/A/<model>/<protocol>/<selection>/<frames> root",
     )
     parser.add_argument(
         "--no-write",

harness/A/sweep.py

@@ -65,14 +65,21 @@ def build_plan(models, frame_selections, frame_counts):
     ]
 
 
-def sweep(models, frame_selections, frame_counts, selected_scenes, results_dir=None, rebuild=False):
+def sweep(
+    models, frame_selections, frame_counts, selected_scenes, results_dir=None, rebuild=False,
+    extended=False,
+):
     """Run every (model, frame_selection, frame_count) triple across all visible GPUs."""
     plan = build_plan(models, frame_selections, frame_counts)
+    protocol = "extended" if extended else "base"
     for index, (model, frame_selection, frame_count) in enumerate(plan, start=1):
-        print(f"=== sweep {index}/{len(plan)}: {model}/{frame_selection}/{frame_count} ===", flush=True)
+        print(
+            f"=== sweep {index}/{len(plan)}: {model}/{protocol}/{frame_selection}/{frame_count} ===",
+            flush=True,
+        )
         harness_launch.launch(
             model, frame_selection, frame_count, selected_scenes,
-            results_dir=results_dir, rebuild=rebuild,
+            results_dir=results_dir, rebuild=rebuild, extended=extended,
         )
 
 
@@ -96,6 +103,11 @@ def main():
     )
     parser.add_argument("--results-dir", default=None)
     parser.add_argument("--rebuild", action="store_true")
+    parser.add_argument(
+        "--extended", action="store_true",
+        help="run the whole sweep under the extended 2048-token protocol instead of the "
+        "fixed 16-token VSI-Bench protocol (the same flag harness.A.run/launch take)",
+    )
     args = parser.parse_args()
     if args.scene and args.scenes:
         parser.error("positional scene and --scenes cannot be used together")
@@ -119,7 +131,7 @@ def main():
 
     sweep(
         models, frame_selections, frame_counts, selected,
-        results_dir=args.results_dir, rebuild=args.rebuild,
+        results_dir=args.results_dir, rebuild=args.rebuild, extended=args.extended,
     )
 
 

harness/B/launch.py

@@ -50,7 +50,7 @@ def _load_run_module():
 
 def _worker(
     tasks, results, model, spatial_code_format, input_selection, frame_count, depth, tracking,
-    results_dir, gpu, cpu_threads, reasoning_budget, force_budget,
+    results_dir, gpu, cpu_threads, extended, reasoning_budget, force_budget,
 ):
     if gpu is not None:
         os.environ["CUDA_VISIBLE_DEVICES"] = str(gpu)
@@ -82,6 +82,7 @@ def _worker(
                 scene=scene,
                 results_dir=results_dir,
                 adapter=adapter,
+                extended=extended,
                 reasoning_budget=reasoning_budget,
                 force_budget=force_budget,
             )
@@ -98,13 +99,18 @@ def _worker(
 def launch(
     model, spatial_code_format, input_selection, frame_count, selected,
     depth=DEFAULT_DEPTH, tracking=DEFAULT_TRACKING, results_dir=None, rebuild=False,
-    reasoning_budget=EXTENDED_MAX_NEW_TOKENS, force_budget=MAX_NEW_TOKENS,
+    extended=True, reasoning_budget=EXTENDED_MAX_NEW_TOKENS, force_budget=MAX_NEW_TOKENS,
 ):
     """Answer every question for ``selected`` scenes, sharded across every visible GPU."""
-    condition = f"{model}/{spatial_code_format}/{depth}/{tracking}/{input_selection}/{frame_count}"
+    protocol = "extended" if extended else "base"
+    condition = (
+        f"{model}/{protocol}/{spatial_code_format}/{depth}/{tracking}"
+        f"/{input_selection}/{frame_count}"
+    )
     run = _load_run_module()
     root = run.results_dir_for(
-        model, spatial_code_format, depth, tracking, input_selection, frame_count, results_dir
+        model, protocol, spatial_code_format, depth, tracking, input_selection, frame_count,
+        results_dir,
     )
     pending = []
     completed = 0
@@ -142,7 +148,8 @@ def launch(
             target=_worker,
             args=(
                 tasks, results, model, spatial_code_format, input_selection, frame_count,
-                depth, tracking, results_dir, gpu, cpu_threads, reasoning_budget, force_budget,
+                depth, tracking, results_dir, gpu, cpu_threads, extended, reasoning_budget,
+                force_budget,
             ),
         )
         for gpu in assignments
@@ -189,6 +196,10 @@ def main():
     parser.add_argument("--tracking", default=DEFAULT_TRACKING, choices=TRACKING_MODES)
     parser.add_argument("--results-dir", default=None)
     parser.add_argument("--rebuild", action="store_true")
+    parser.add_argument(
+        "--base-protocol", action="store_true",
+        help="run 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)
     parser.add_argument("--force-budget", type=int, default=MAX_NEW_TOKENS)
     args = parser.parse_args()
@@ -210,6 +221,7 @@ def main():
     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,
+        extended=not args.base_protocol,
         reasoning_budget=args.reasoning_budget, force_budget=args.force_budget,
     )
 

harness/B/run.py

@@ -39,14 +39,17 @@ from harness.B import spatial_codes  # noqa: E402
 
 
 def results_dir_for(
-    model, spatial_code_format, depth, tracking, input_selection, frame_count, results_dir=None
+    model, protocol, spatial_code_format, depth, tracking, input_selection, frame_count,
+    results_dir=None,
 ):
-    """Return the result root isolated by model + spatial-code-format + depth +
-    tracking + input + frames."""
+    """Return the result root isolated by model + protocol + spatial-code-format +
+    depth + tracking + input + frames. ``protocol`` is "base" (16-token) or "extended"
+    (2048-token) -- a real path segment, so the two protocols' records can never collide
+    on disk."""
     if results_dir is not None:
         return Path(results_dir)
     return (
-        RESULTS_DIR / model / spatial_code_format / depth / tracking
+        RESULTS_DIR / model / protocol / spatial_code_format / depth / tracking
         / input_selection / str(frame_count)
     )
 
@@ -60,10 +63,11 @@ def _build_record(row, prompt, answer, metric_name, score, model, model_path, co
         "dtype": answer["dtype"],
         "library_versions": answer["library_versions"],
         "condition": (
-            f"{code_info['spatial_code_format']}:{code_info['depth']}:"
-            f"{code_info['tracking']}:{code_info['input_selection']}:"
-            f"{code_info['frame_count']}"
+            f"{code_info['protocol']}:{code_info['spatial_code_format']}:"
+            f"{code_info['depth']}:{code_info['tracking']}:"
+            f"{code_info['input_selection']}:{code_info['frame_count']}"
         ),
+        "protocol": code_info["protocol"],
         "spatial_code_format": code_info["spatial_code_format"],
         "input_selection": code_info["input_selection"],
         "frame_count": code_info["frame_count"],
@@ -108,6 +112,7 @@ def write_question_result(
     record = _build_record(row, prompt, answer, metric_name, score, model, model_path, code_info)
     root = results_dir_for(
         model,
+        code_info["protocol"],
         code_info["spatial_code_format"],
         code_info["depth"],
         code_info["tracking"],
@@ -138,6 +143,7 @@ def run(
     results_dir=None,
     write_results=True,
     adapter=None,
+    extended=True,
     reasoning_budget=EXTENDED_MAX_NEW_TOKENS,
     force_budget=MAX_NEW_TOKENS,
 ):
@@ -147,9 +153,11 @@ def run(
 
     Uses ``adapter.answer_extended`` (a large ``reasoning_budget`` first pass, with a
     short forced second call only if the model doesn't conclude within it) as the
-    standing default protocol -- not harness.A's fixed 16-token budget -- since working
-    through a full spatial-code JSON before answering benefits from more room than a
-    short visual caption does.
+    standing default protocol -- since working through a full spatial-code JSON before
+    answering benefits from more room than a short visual caption does.
+    ``extended=False`` runs harness.A's exact fixed 16-token base protocol instead
+    (plain ``adapter.answer``), so the protocol x representation grid can be measured
+    with the identical generation mechanism in every cell.
 
     Pass a pre-loaded ``adapter`` (as harness.B.launch's persistent per-GPU workers do)
     to reuse one already-loaded model across many calls; the caller then owns unloading
@@ -176,8 +184,12 @@ def run(
             prompt = code_prompts.build_prompt(
                 cached["code"], row["question_type"], row["question"], row.get("options")
             )
-            answer = adapter.answer_extended(
-                [], prompt, reasoning_budget=reasoning_budget, force_budget=force_budget
+            answer = (
+                adapter.answer_extended(
+                    [], prompt, reasoning_budget=reasoning_budget, force_budget=force_budget
+                )
+                if extended
+                else adapter.answer([], prompt)
             )
             doc = {"question_type": row["question_type"], "ground_truth": row["ground_truth"]}
             score_doc = vsi_official_eval.vsibench_process_results(
@@ -185,6 +197,7 @@ def run(
             )["vsibench_score"]
             metric_name, score = _scalar_score(row["question_type"], score_doc)
             code_info = {
+                "protocol": "extended" if extended else "base",
                 "spatial_code_format": spatial_code_format,
                 "input_selection": input_selection,
                 "frame_count": frame_count,
@@ -229,12 +242,18 @@ def main():
     parser.add_argument("--device", default="cuda")
     parser.add_argument(
         "--results-dir", default=None,
-        help="override the default results/B/<model>/<format>/<depth>/<tracking>/<input>/<frames> root",
+        help="override the default results/B/<model>/<protocol>/<format>/"
+        "<depth>/<tracking>/<input>/<frames> root",
     )
     parser.add_argument(
         "--no-write", action="store_true",
         help="skip writing per-question JSON files; print/score only",
     )
+    parser.add_argument(
+        "--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)
     args = parser.parse_args()
@@ -257,6 +276,7 @@ def main():
         device=args.device,
         results_dir=args.results_dir,
         write_results=not args.no_write,
+        extended=not args.base_protocol,
         reasoning_budget=args.reasoning_budget,
         force_budget=args.force_budget,
     )

harness/B/sweep.py

@@ -52,20 +52,23 @@ 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,
 ):
     """Run every sweep combination across all visible GPUs."""
     plan = build_plan(models, spatial_code_formats, input_selections, frame_counts, depths, trackings)
+    protocol = "extended" if extended else "base"
     for index, (model, spatial_code_format, depth, tracking, input_selection, frame_count) in enumerate(
         plan, start=1
     ):
         print(
-            f"=== sweep {index}/{len(plan)}: "
-            f"{model}/{spatial_code_format}/{depth}/{tracking}/{input_selection}/{frame_count} ===",
+            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,
         )
 
 
@@ -100,6 +103,11 @@ def main():
     )
     parser.add_argument("--results-dir", default=None)
     parser.add_argument("--rebuild", action="store_true")
+    parser.add_argument(
+        "--base-protocol", action="store_true",
+        help="run the whole sweep under harness.A's exact fixed 16-token protocol "
+        "instead of the extended 2048-token default",
+    )
     args = parser.parse_args()
     if args.scene and args.scenes:
         parser.error("positional scene and --scenes cannot be used together")
@@ -132,6 +140,7 @@ def main():
         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,
     )
 
 

harness/C/launch.py

@@ -50,7 +50,7 @@ def _load_run_module():
 
 def _worker(
     tasks, results, model, spatial_code_format, input_selection, frame_count, depth, tracking,
-    results_dir, gpu, cpu_threads, reasoning_budget, force_budget,
+    results_dir, gpu, cpu_threads, extended, reasoning_budget, force_budget,
 ):
     if gpu is not None:
         os.environ["CUDA_VISIBLE_DEVICES"] = str(gpu)
@@ -85,6 +85,7 @@ def _worker(
                 scene=scene,
                 results_dir=results_dir,
                 adapter=adapter,
+                extended=extended,
                 reasoning_budget=reasoning_budget,
                 force_budget=force_budget,
             )
@@ -101,13 +102,18 @@ def _worker(
 def launch(
     model, spatial_code_format, input_selection, frame_count, selected,
     depth=DEFAULT_DEPTH, tracking=DEFAULT_TRACKING, results_dir=None, rebuild=False,
-    reasoning_budget=EXTENDED_MAX_NEW_TOKENS, force_budget=MAX_NEW_TOKENS,
+    extended=True, reasoning_budget=EXTENDED_MAX_NEW_TOKENS, force_budget=MAX_NEW_TOKENS,
 ):
     """Answer every question for ``selected`` scenes, sharded across every visible GPU."""
-    condition = f"{model}/{spatial_code_format}/{depth}/{tracking}/{input_selection}/{frame_count}"
+    protocol = "extended" if extended else "base"
+    condition = (
+        f"{model}/{protocol}/{spatial_code_format}/{depth}/{tracking}"
+        f"/{input_selection}/{frame_count}"
+    )
     run = _load_run_module()
     root = run.results_dir_for(
-        model, spatial_code_format, depth, tracking, input_selection, frame_count, results_dir
+        model, protocol, spatial_code_format, depth, tracking, input_selection, frame_count,
+        results_dir,
     )
     pending = []
     completed = 0
@@ -145,7 +151,8 @@ def launch(
             target=_worker,
             args=(
                 tasks, results, model, spatial_code_format, input_selection, frame_count,
-                depth, tracking, results_dir, gpu, cpu_threads, reasoning_budget, force_budget,
+                depth, tracking, results_dir, gpu, cpu_threads, extended, reasoning_budget,
+                force_budget,
             ),
         )
         for gpu in assignments
@@ -192,6 +199,10 @@ def main():
     parser.add_argument("--tracking", default=DEFAULT_TRACKING, choices=TRACKING_MODES)
     parser.add_argument("--results-dir", default=None)
     parser.add_argument("--rebuild", action="store_true")
+    parser.add_argument(
+        "--base-protocol", action="store_true",
+        help="run 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)
     parser.add_argument("--force-budget", type=int, default=MAX_NEW_TOKENS)
     args = parser.parse_args()
@@ -213,6 +224,7 @@ def main():
     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,
+        extended=not args.base_protocol,
         reasoning_budget=args.reasoning_budget, force_budget=args.force_budget,
     )
 

harness/C/run.py

@@ -40,14 +40,17 @@ from harness.C import prompts as combined_prompts  # noqa: E402
 
 
 def results_dir_for(
-    model, spatial_code_format, depth, tracking, input_selection, frame_count, results_dir=None
+    model, protocol, spatial_code_format, depth, tracking, input_selection, frame_count,
+    results_dir=None,
 ):
-    """Return the result root isolated by model + spatial-code-format + depth +
-    tracking + input + frames."""
+    """Return the result root isolated by model + protocol + spatial-code-format +
+    depth + tracking + input + frames. ``protocol`` is "base" (16-token) or "extended"
+    (2048-token) -- a real path segment, so the two protocols' records can never collide
+    on disk."""
     if results_dir is not None:
         return Path(results_dir)
     return (
-        RESULTS_DIR / model / spatial_code_format / depth / tracking
+        RESULTS_DIR / model / protocol / spatial_code_format / depth / tracking
         / input_selection / str(frame_count)
     )
 
@@ -61,10 +64,11 @@ def _build_record(row, prompt, answer, metric_name, score, model, model_path, so
         "dtype": answer["dtype"],
         "library_versions": answer["library_versions"],
         "condition": (
-            f"{source_info['spatial_code_format']}:{source_info['depth']}:"
-            f"{source_info['tracking']}:{source_info['input_selection']}:"
-            f"{source_info['frame_count']}"
+            f"{source_info['protocol']}:{source_info['spatial_code_format']}:"
+            f"{source_info['depth']}:{source_info['tracking']}:"
+            f"{source_info['input_selection']}:{source_info['frame_count']}"
         ),
+        "protocol": source_info["protocol"],
         "spatial_code_format": source_info["spatial_code_format"],
         "input_selection": source_info["input_selection"],
         "frame_count": source_info["frame_count"],
@@ -112,6 +116,7 @@ def write_question_result(
     record = _build_record(row, prompt, answer, metric_name, score, model, model_path, source_info)
     root = results_dir_for(
         model,
+        source_info["protocol"],
         source_info["spatial_code_format"],
         source_info["depth"],
         source_info["tracking"],
@@ -142,6 +147,7 @@ def run(
     results_dir=None,
     write_results=True,
     adapter=None,
+    extended=True,
     reasoning_budget=EXTENDED_MAX_NEW_TOKENS,
     force_budget=MAX_NEW_TOKENS,
 ):
@@ -152,7 +158,10 @@ def run(
     Uses ``adapter.answer_extended`` (a large ``reasoning_budget`` first pass, with a
     short forced second call only if the model doesn't conclude within it) as the
     standing default protocol, same as harness.B, since C combines the same complex
-    spatial-code JSON with the video frames.
+    spatial-code JSON with the video frames. ``extended=False`` runs harness.A's exact
+    fixed 16-token base protocol instead (plain ``adapter.answer``), so the protocol x
+    representation grid can be measured with the identical generation mechanism in
+    every cell.
 
     Pass a pre-loaded ``adapter`` (as harness.C.launch's persistent per-GPU workers do)
     to reuse one already-loaded model across many calls; the caller then owns unloading
@@ -190,9 +199,13 @@ def run(
             prompt = combined_prompts.build_prompt(
                 cached["code"], row["question_type"], row["question"], row.get("options")
             )
-            answer = adapter.answer_extended(
-                cached["frame_images"], prompt,
-                reasoning_budget=reasoning_budget, force_budget=force_budget,
+            answer = (
+                adapter.answer_extended(
+                    cached["frame_images"], prompt,
+                    reasoning_budget=reasoning_budget, force_budget=force_budget,
+                )
+                if extended
+                else adapter.answer(cached["frame_images"], prompt)
             )
             doc = {"question_type": row["question_type"], "ground_truth": row["ground_truth"]}
             score_doc = vsi_official_eval.vsibench_process_results(
@@ -200,6 +213,7 @@ def run(
             )["vsibench_score"]
             metric_name, score = _scalar_score(row["question_type"], score_doc)
             source_info = {
+                "protocol": "extended" if extended else "base",
                 "spatial_code_format": spatial_code_format,
                 "input_selection": input_selection,
                 "frame_count": frame_count,
@@ -247,12 +261,18 @@ def main():
     parser.add_argument("--device", default="cuda")
     parser.add_argument(
         "--results-dir", default=None,
-        help="override the default results/C/<model>/<format>/<depth>/<tracking>/<input>/<frames> root",
+        help="override the default results/C/<model>/<protocol>/<format>/"
+        "<depth>/<tracking>/<input>/<frames> root",
     )
     parser.add_argument(
         "--no-write", action="store_true",
         help="skip writing per-question JSON files; print/score only",
     )
+    parser.add_argument(
+        "--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)
     args = parser.parse_args()
@@ -275,6 +295,7 @@ def main():
         device=args.device,
         results_dir=args.results_dir,
         write_results=not args.no_write,
+        extended=not args.base_protocol,
         reasoning_budget=args.reasoning_budget,
         force_budget=args.force_budget,
     )

harness/D/run.py

@@ -28,11 +28,13 @@ from harness.D import prompts as code_prompts  # noqa: E402
 from harness.D import spatial_codes  # noqa: E402
 
 
-def results_dir_for(model, spatial_code_format, results_dir=None):
-    """Return the result root isolated by model + spatial-code-format."""
+def results_dir_for(model, protocol, spatial_code_format, results_dir=None):
+    """Return the result root isolated by model + protocol + spatial-code-format.
+    ``protocol`` is "base" (16-token) or "extended" (2048-token) -- a real path
+    segment, so the two protocols' records can never collide on disk."""
     if results_dir is not None:
         return Path(results_dir)
-    return RESULTS_DIR / model / spatial_code_format
+    return RESULTS_DIR / model / protocol / spatial_code_format
 
 
 def _build_record(row, prompt, answer, metric_name, score, model, model_path, code_info):
@@ -43,7 +45,8 @@ def _build_record(row, prompt, answer, metric_name, score, model, model_path, co
         "device": answer["device"],
         "dtype": answer["dtype"],
         "library_versions": answer["library_versions"],
-        "condition": code_info["spatial_code_format"],
+        "condition": f"{code_info['protocol']}:{code_info['spatial_code_format']}",
+        "protocol": code_info["protocol"],
         "spatial_code_format": code_info["spatial_code_format"],
         "spatial_code_path": code_info["spatial_code_path"],
         "scene": row["scene_name"],
@@ -82,7 +85,9 @@ def write_question_result(
 ):
     """Write one question's full, untruncated result record. Return (path, record)."""
     record = _build_record(row, prompt, answer, metric_name, score, model, model_path, code_info)
-    root = results_dir_for(model, code_info["spatial_code_format"], results_dir)
+    root = results_dir_for(
+        model, code_info["protocol"], code_info["spatial_code_format"], results_dir
+    )
     scene_dir = root / record["scene"]
     scene_dir.mkdir(parents=True, exist_ok=True)
     path = scene_dir / f"{row['id']}.json"
@@ -102,8 +107,10 @@ def run(
     results_dir=None,
     write_results=True,
     adapter=None,
+    extended=True,
     reasoning_budget=EXTENDED_MAX_NEW_TOKENS,
     force_budget=MAX_NEW_TOKENS,
+    code_transform=None,
 ):
     """Answer every matching question with one model, given its scene's GROUND-TRUTH
     spatial code as text (no video frames). Each question's full record is written to
@@ -111,7 +118,14 @@ def run(
 
     Uses ``adapter.answer_extended`` as the standing default protocol, same as
     harness.B -- working through a full spatial-code JSON before answering benefits
-    from more room than a short visual caption does.
+    from more room than a short visual caption does. ``extended=False`` runs
+    harness.A's exact fixed 16-token base protocol instead (plain ``adapter.answer``).
+
+    ``code_transform``, when given, is called as ``code_transform(code, scene_id,
+    spatial_code_format)`` on each freshly loaded code and its return value is what
+    the prompt is built from -- the hook the corruption module (README Theme 8) uses
+    to run corrupted codes through this EXACT prompt/adapter path instead of a
+    duplicated one. ``None`` (the default) leaves behavior byte-identical to before.
 
     Pass a pre-loaded ``adapter`` (as harness.D.launch's persistent per-GPU workers do)
     to reuse one already-loaded model across many calls; the caller then owns unloading
@@ -131,13 +145,19 @@ 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)
+                if code_transform is not None:
+                    code = code_transform(code, scene_id, spatial_code_format)
                 code_cache[scene_id] = {"code": code, "path": path}
             cached = code_cache[scene_id]
             prompt = code_prompts.build_prompt(
                 cached["code"], row["question_type"], row["question"], row.get("options")
             )
-            answer = adapter.answer_extended(
-                [], prompt, reasoning_budget=reasoning_budget, force_budget=force_budget
+            answer = (
+                adapter.answer_extended(
+                    [], prompt, reasoning_budget=reasoning_budget, force_budget=force_budget
+                )
+                if extended
+                else adapter.answer([], prompt)
             )
             doc = {"question_type": row["question_type"], "ground_truth": row["ground_truth"]}
             score_doc = vsi_official_eval.vsibench_process_results(
@@ -145,6 +165,7 @@ def run(
             )["vsibench_score"]
             metric_name, score = _scalar_score(row["question_type"], score_doc)
             code_info = {
+                "protocol": "extended" if extended else "base",
                 "spatial_code_format": spatial_code_format,
                 "spatial_code_path": cached["path"],
             }
@@ -178,12 +199,17 @@ def main():
     parser.add_argument("--device", default="cuda")
     parser.add_argument(
         "--results-dir", default=None,
-        help="override the default results/D/<model>/<format> root",
+        help="override the default results/D/<model>/<protocol>/<format> root",
     )
     parser.add_argument(
         "--no-write", action="store_true",
         help="skip writing per-question JSON files; print/score only",
     )
+    parser.add_argument(
+        "--base-protocol", action="store_true",
+        help="run harness.A's exact fixed 16-token protocol (plain answer()) instead of "
+        "the extended 2048-token default",
+    )
     parser.add_argument("--reasoning-budget", type=int, default=EXTENDED_MAX_NEW_TOKENS)
     parser.add_argument("--force-budget", type=int, default=MAX_NEW_TOKENS)
     args = parser.parse_args()
@@ -200,6 +226,7 @@ def main():
         device=args.device,
         results_dir=args.results_dir,
         write_results=not args.no_write,
+        extended=not args.base_protocol,
         reasoning_budget=args.reasoning_budget,
         force_budget=args.force_budget,
     )

harness/E/run.py

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

tests/test_C/test_run.py

@@ -40,6 +40,7 @@ _FAKE_ROW = {
 }
 
 _FAKE_SOURCE_INFO = {
+    "protocol": "extended",
     "spatial_code_format": "explicit",
     "input_selection": "selective",
     "frame_count": 64,
@@ -53,15 +54,18 @@ _FAKE_SOURCE_INFO = {
 
 
 def test_results_dir_for_matches_established_dimension_nesting():
-    root = harness_run.results_dir_for("qwen3.5-4b", "compact", "metric", "tracking", "uniform", 32)
+    root = harness_run.results_dir_for(
+        "qwen3.5-4b", "extended", "compact", "metric", "tracking", "uniform", 32
+    )
     assert root == (
-        C.RESULTS_DIR / "qwen3.5-4b" / "compact" / "metric" / "tracking" / "uniform" / "32"
+        C.RESULTS_DIR / "qwen3.5-4b" / "extended" / "compact" / "metric" / "tracking"
+        / "uniform" / "32"
     )
 
 
 def test_results_dir_for_honors_explicit_override(tmp_path):
     root = harness_run.results_dir_for(
-        "qwen3.5-4b", "explicit", "relative", "no tracking", "selective", 16, tmp_path
+        "qwen3.5-4b", "base", "explicit", "relative", "no tracking", "selective", 16, tmp_path
     )
     assert root == tmp_path
 
@@ -86,7 +90,8 @@ def test_build_record_carries_both_frame_and_spatial_code_provenance():
     assert record["question"] == "How many chairs?"
     assert record["answer_given"] == "4"
     assert record["vision_input_shapes"] == _FAKE_ANSWER["vision_input_shapes"]
-    assert record["condition"] == "explicit:metric:tracking:selective:64"
+    assert record["condition"] == "extended:explicit:metric:tracking:selective:64"
+    assert record["protocol"] == "extended"
     assert record["score"] == 1.0
 
 

tests/test_D/test_run.py

@@ -40,18 +40,19 @@ _FAKE_ROW = {
 }
 
 _FAKE_CODE_INFO = {
+    "protocol": "extended",
     "spatial_code_format": "explicit",
     "spatial_code_path": "/workspace/data/spatial codes/ground truth/explicit/scene0001_00.json",
 }
 
 
-def test_results_dir_for_matches_model_and_format_only():
-    root = harness_run.results_dir_for("qwen3.5-4b", "compact")
-    assert root == D.RESULTS_DIR / "qwen3.5-4b" / "compact"
+def test_results_dir_for_matches_model_protocol_and_format_only():
+    root = harness_run.results_dir_for("qwen3.5-4b", "extended", "compact")
+    assert root == D.RESULTS_DIR / "qwen3.5-4b" / "extended" / "compact"
 
 
 def test_results_dir_for_honors_explicit_override(tmp_path):
-    root = harness_run.results_dir_for("qwen3.5-4b", "explicit", tmp_path)
+    root = harness_run.results_dir_for("qwen3.5-4b", "base", "explicit", tmp_path)
     assert root == tmp_path
 
 
@@ -67,7 +68,8 @@ def test_build_record_preserves_every_field_untruncated():
     assert record["spatial_code_format"] == "explicit"
     assert record["spatial_code_path"] == _FAKE_CODE_INFO["spatial_code_path"]
     # No depth/tracking/input_selection/frame_count -- ground truth has no such axis.
-    assert record["condition"] == "explicit"
+    assert record["condition"] == "extended:explicit"
+    assert record["protocol"] == "extended"
     assert "input_selection" not in record
     assert "frame_count" not in record
     assert "depth" not in record
@@ -115,3 +117,37 @@ def test_build_record_defaults_reasoning_fields_when_absent():
     )
     assert record["reasoning_token_count"] is None
     assert record["forced"] is False
+
+
+def test_run_code_transform_hook_replaces_the_loaded_code(monkeypatch, tmp_path):
+    """The corruption module's entry point: the hook's return value is what the
+    prompt is built from, and passing no hook keeps behavior identical."""
+    scene = "13c3e046d7"
+    seen = {}
+
+    def fake_load(scene_id, spatial_code_format):
+        return {"objects": {"chair": {"count": 1}}}, f"/fake/{scene_id}.json"
+
+    class FakeAdapter:
+        model_path = "/fake/model"
+
+        def answer_extended(self, frames, prompt, **kwargs):
+            seen["prompt"] = prompt
+            return {
+                "prompt_text": prompt, "answer_text": "1", "answer_raw": "1",
+                "input_token_count": 1, "vision_input_shapes": {},
+                "output_token_ids": [1], "output_token_count": 1,
+                "hit_token_limit": False, "eos_token_ids": [1],
+                "generation_seconds": 0.0, "device": "cpu", "dtype": "float32",
+                "library_versions": {}, "generation_config": {},
+            }
+
+    monkeypatch.setattr(harness_run.spatial_codes, "load_spatial_code", fake_load)
+    replacement = {"objects": {"table": {"count": 9}}}
+    results = harness_run.run(
+        "qwen3.5-2b", scene=scene, adapter=FakeAdapter(), write_results=False, limit=1,
+        code_transform=lambda code, scene_id, fmt: replacement,
+    )
+    assert results
+    assert '"table"' in seen["prompt"]
+    assert '"chair"' not in seen["prompt"]

tests/test_E/test_launch.py

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

tests/test_E/test_prompts.py

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

tests/test_E/test_run.py

@@ -0,0 +1,84 @@
+"""Tests for harness/E/run.py -- result-record shape and result-file writing."""
+
+import json
+
+from harness import E
+from harness.E import run as harness_run
+
+_FAKE_ANSWER = {
+    "prompt_text": "<rendered chat template>",
+    "answer_text": "4",
+    "answer_raw": "<|im_start|>assistant\n4<|im_end|>",
+    "input_token_count": 42,
+    "vision_input_shapes": {},
+    "output_token_ids": [19, 151645],
+    "output_token_count": 2,
+    "hit_token_limit": False,
+    "eos_token_ids": [151645],
+    "generation_seconds": 0.2,
+    "device": "cuda",
+    "dtype": "bfloat16",
+    "library_versions": {"transformers": "5.14.1", "torch": "2.13.0+cu130"},
+    "generation_config": {
+        "max_new_tokens": 16,
+        "do_sample": False,
+        "temperature": 0.0,
+        "top_p": None,
+        "top_k": None,
+        "enable_thinking": False,
+    },
+}
+
+_FAKE_ROW = {
+    "id": 7,
+    "scene_name": "scene0001_00",
+    "dataset": "scannet",
+    "question_type": "object_counting",
+    "question": "How many chairs?",
+    "options": None,
+    "ground_truth": "4",
+}
+
+
+def test_results_dir_for_matches_model_and_protocol_only():
+    root = harness_run.results_dir_for("qwen3.5-4b", "base")
+    assert root == E.RESULTS_DIR / "qwen3.5-4b" / "base"
+
+
+def test_results_dir_for_isolates_the_two_protocols():
+    assert harness_run.results_dir_for("qwen3.5-4b", "base") != harness_run.results_dir_for(
+        "qwen3.5-4b", "extended"
+    )
+
+
+def test_results_dir_for_honors_explicit_override(tmp_path):
+    assert harness_run.results_dir_for("qwen3.5-4b", "base", tmp_path) == tmp_path
+
+
+def test_build_record_has_no_scene_input_provenance():
+    record = harness_run._build_record(
+        _FAKE_ROW, "full prompt text", _FAKE_ANSWER, "MRA:.5:.95:.05", 1.0,
+        "qwen3.5-4b", "/root/models/qwen3.5-4b", "base",
+    )
+    assert record["condition"] == "base"
+    assert record["protocol"] == "base"
+    assert record["question"] == "How many chairs?"
+    assert record["answer_given"] == "4"
+    assert record["metric"] == "MRA:.5:.95:.05"
+    assert record["score"] == 1.0
+    # Blind: no frame or spatial-code provenance of any kind.
+    assert "frame_selection" not in record
+    assert "video_path" not in record
+    assert "frame_indices" not in record
+    assert "spatial_code_format" not in record
+    assert "spatial_code_path" not in record
+
+
+def test_write_question_result_writes_one_json_file_per_question(tmp_path):
+    path, record = harness_run.write_question_result(
+        _FAKE_ROW, "full prompt text", _FAKE_ANSWER, "MRA:.5:.95:.05", 1.0,
+        "qwen3.5-4b", "/root/models/qwen3.5-4b", "base", results_dir=tmp_path,
+    )
+    assert path == tmp_path / "scene0001_00" / "7.json"
+    on_disk = json.loads(path.read_text())
+    assert on_disk == record

tests/test_E/test_sweep.py

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