Add files using upload-large-folder tool

.pytest_cache/v/cache/lastfailed

@@ -33,5 +33,6 @@
   "tests/test_symbolic/test_run.py::test_select_model_reads_frame_mode_subfolder[selective-no-tracking-frames/selective/no tracking]": true,
   "tests/test_symbolic/test_run.py::test_symbolic_results_mirror_frame_mode_cache_layout": true,
   "tests/test_symbolic/test_run.py::test_question_result_records_selected_frame_mode": true,
-  "tests/test_symbolic/test_run.py::test_parse_frame_mode_rejects_video_mode": true
+  "tests/test_symbolic/test_run.py::test_parse_frame_mode_rejects_video_mode": true,
+  "tests/test_B/test_spatial_codes.py::test_load_spatial_code_reads_a_real_on_disk_file": true
 }

.pytest_cache/v/cache/nodeids

@@ -1,4 +1,358 @@
 [
+  "tests/test_A/test_A.py::test_default_frame_selection_is_a_valid_selection",
+  "tests/test_A/test_A.py::test_extended_generation_protocol",
+  "tests/test_A/test_A.py::test_frame_selections_match_inference_vocabulary",
+  "tests/test_A/test_A.py::test_generation_protocol_matches_vsibench_yaml",
+  "tests/test_A/test_A.py::test_model_paths_cover_every_registered_model",
+  "tests/test_A/test_A.py::test_results_dir_defaults_under_root_results",
+  "tests/test_A/test_frames.py::test_sample_frames_derives_indices_from_real_fps",
+  "tests/test_A/test_frames.py::test_sample_frames_rejects_missing_video",
+  "tests/test_A/test_frames.py::test_sample_frames_rejects_nonpositive_frame_count",
+  "tests/test_A/test_frames.py::test_sample_frames_rejects_unknown_selection",
+  "tests/test_A/test_frames.py::test_sample_frames_returns_pil_images_in_order",
+  "tests/test_A/test_init.py::test_default_frame_selection_is_a_valid_selection",
+  "tests/test_A/test_init.py::test_extended_generation_protocol",
+  "tests/test_A/test_init.py::test_frame_selections_match_inference_vocabulary",
+  "tests/test_A/test_init.py::test_generation_protocol_matches_vsibench_yaml",
+  "tests/test_A/test_init.py::test_model_paths_cover_every_registered_model",
+  "tests/test_A/test_init.py::test_results_dir_defaults_under_root_results",
+  "tests/test_A/test_launch.py::test_launch_rebuild_forces_pending_even_when_answered",
+  "tests/test_A/test_launch.py::test_launch_rejects_scene_with_no_questions",
+  "tests/test_A/test_launch.py::test_launch_skips_scene_already_fully_answered",
+  "tests/test_A/test_launch.py::test_launcher_imports",
+  "tests/test_A/test_launch.py::test_scenes_dedups_and_preserves_order",
+  "tests/test_A/test_models.py::test_adapter_answer_before_load_model_raises",
+  "tests/test_A/test_models.py::test_adapter_answer_extended_before_load_model_raises",
+  "tests/test_A/test_models.py::test_all_three_models_are_registered",
+  "tests/test_A/test_models.py::test_every_adapter_implements_answer_extended",
+  "tests/test_A/test_models.py::test_get_adapter_binds_the_correct_checkpoint_path",
+  "tests/test_A/test_models.py::test_get_adapter_rejects_unknown_model",
+  "tests/test_A/test_models.py::test_get_adapter_returns_the_right_class_per_model",
+  "tests/test_A/test_models.py::test_internvl_adapter_disables_per_frame_tiling",
+  "tests/test_A/test_models.py::test_numbered_content_handles_zero_frames",
+  "tests/test_A/test_models.py::test_numbered_content_labels_every_frame_in_order",
+  "tests/test_A/test_models.py::test_qwen_adapter_disables_thinking_mode",
+  "tests/test_A/test_models.py::test_unload_clears_model_and_processor",
+  "tests/test_A/test_prompts.py::test_every_mca_question_type_builds_with_options[obj_appearance_order]",
+  "tests/test_A/test_prompts.py::test_every_mca_question_type_builds_with_options[object_rel_direction_easy]",
+  "tests/test_A/test_prompts.py::test_every_mca_question_type_builds_with_options[object_rel_direction_hard]",
+  "tests/test_A/test_prompts.py::test_every_mca_question_type_builds_with_options[object_rel_direction_medium]",
+  "tests/test_A/test_prompts.py::test_every_mca_question_type_builds_with_options[object_rel_distance]",
+  "tests/test_A/test_prompts.py::test_every_mca_question_type_builds_with_options[route_planning]",
+  "tests/test_A/test_prompts.py::test_every_na_question_type_builds_without_options[object_abs_distance]",
+  "tests/test_A/test_prompts.py::test_every_na_question_type_builds_without_options[object_counting]",
+  "tests/test_A/test_prompts.py::test_every_na_question_type_builds_without_options[object_size_estimation]",
+  "tests/test_A/test_prompts.py::test_every_na_question_type_builds_without_options[room_size_estimation]",
+  "tests/test_A/test_prompts.py::test_mca_question_prompt_matches_vsibench_protocol",
+  "tests/test_A/test_prompts.py::test_mca_question_requires_options",
+  "tests/test_A/test_prompts.py::test_na_question_prompt_matches_vsibench_protocol",
+  "tests/test_A/test_prompts.py::test_unknown_question_type_rejected",
+  "tests/test_A/test_run.py::test_build_record_carries_reasoning_fields_when_extended",
+  "tests/test_A/test_run.py::test_build_record_defaults_reasoning_fields_when_not_extended",
+  "tests/test_A/test_run.py::test_build_record_preserves_every_field_untruncated",
+  "tests/test_A/test_run.py::test_load_questions_filters_by_scene",
+  "tests/test_A/test_run.py::test_load_questions_reads_every_row",
+  "tests/test_A/test_run.py::test_load_questions_respects_limit",
+  "tests/test_A/test_run.py::test_results_dir_for_honors_explicit_override",
+  "tests/test_A/test_run.py::test_results_dir_for_isolates_the_two_protocols",
+  "tests/test_A/test_run.py::test_results_dir_for_matches_established_dimension_nesting",
+  "tests/test_A/test_run.py::test_scalar_score_rejects_unknown_question_type",
+  "tests/test_A/test_run.py::test_scalar_score_returns_metric_name_and_value",
+  "tests/test_A/test_run.py::test_write_question_result_writes_one_json_file_per_question",
+  "tests/test_A/test_sweep.py::test_build_plan_covers_every_combination",
+  "tests/test_A/test_sweep.py::test_build_plan_orders_by_frame_count_first",
+  "tests/test_A/test_sweep.py::test_build_plan_with_all_registered_models",
+  "tests/test_A/test_sweep.py::test_parse_csv_choice_expands_all",
+  "tests/test_A/test_sweep.py::test_parse_csv_choice_rejects_empty",
+  "tests/test_A/test_sweep.py::test_parse_csv_choice_rejects_unknown_value",
+  "tests/test_A/test_sweep.py::test_parse_csv_choice_splits_and_dedups",
+  "tests/test_A/test_sweep.py::test_parse_frame_counts_rejects_non_integer",
+  "tests/test_A/test_sweep.py::test_parse_frame_counts_rejects_nonpositive",
+  "tests/test_A/test_sweep.py::test_parse_frame_counts_splits_and_dedups",
+  "tests/test_B/test_B.py::test_depth_and_tracking_reuse_encoder_config_vocabulary",
+  "tests/test_B/test_B.py::test_input_selections_match_harness_a_vocabulary",
+  "tests/test_B/test_B.py::test_results_dir_defaults_under_root_results",
+  "tests/test_B/test_B.py::test_reuses_harness_a_model_paths_and_generation_protocol",
+  "tests/test_B/test_B.py::test_spatial_code_formats_match_the_two_on_disk_schemas",
+  "tests/test_B/test_init.py::test_depth_and_tracking_reuse_encoder_config_vocabulary",
+  "tests/test_B/test_init.py::test_input_selections_match_harness_a_vocabulary",
+  "tests/test_B/test_init.py::test_results_dir_defaults_under_root_results",
+  "tests/test_B/test_init.py::test_reuses_harness_a_model_paths_and_generation_protocol",
+  "tests/test_B/test_init.py::test_spatial_code_formats_match_the_two_on_disk_schemas",
+  "tests/test_B/test_launch.py::test_launch_rebuild_forces_pending_even_when_answered",
+  "tests/test_B/test_launch.py::test_launch_rejects_question_id_filter_that_matches_nothing",
+  "tests/test_B/test_launch.py::test_launch_skips_scene_already_fully_answered",
+  "tests/test_B/test_launch.py::test_launcher_imports",
+  "tests/test_B/test_prompts.py::test_default_arguments_reproduce_the_standard_prompt_byte_for_byte",
+  "tests/test_B/test_prompts.py::test_every_mca_question_type_builds[obj_appearance_order]",
+  "tests/test_B/test_prompts.py::test_every_mca_question_type_builds[object_rel_direction_easy]",
+  "tests/test_B/test_prompts.py::test_every_mca_question_type_builds[object_rel_direction_hard]",
+  "tests/test_B/test_prompts.py::test_every_mca_question_type_builds[object_rel_direction_medium]",
+  "tests/test_B/test_prompts.py::test_every_mca_question_type_builds[object_rel_distance]",
+  "tests/test_B/test_prompts.py::test_every_mca_question_type_builds[route_planning]",
+  "tests/test_B/test_prompts.py::test_every_na_question_type_builds[object_abs_distance]",
+  "tests/test_B/test_prompts.py::test_every_na_question_type_builds[object_counting]",
+  "tests/test_B/test_prompts.py::test_every_na_question_type_builds[object_size_estimation]",
+  "tests/test_B/test_prompts.py::test_every_na_question_type_builds[room_size_estimation]",
+  "tests/test_B/test_prompts.py::test_mca_question_prompt_includes_options_and_matches_harness_a_post_prompt",
+  "tests/test_B/test_prompts.py::test_mca_question_requires_options",
+  "tests/test_B/test_prompts.py::test_na_question_prompt_embeds_the_spatial_code_as_text_and_a_post_prompt",
+  "tests/test_B/test_prompts.py::test_no_frames_language_in_pre_prompt",
+  "tests/test_B/test_prompts.py::test_paraphrase_context_line_swaps_only_the_first_line",
+  "tests/test_B/test_prompts.py::test_unknown_question_type_rejected",
+  "tests/test_B/test_prompts.py::test_unknown_serialization_rejected",
+  "tests/test_B/test_prompts.py::test_yaml_arm_context_line_does_not_claim_json",
+  "tests/test_B/test_prompts.py::test_yaml_serialization_renders_the_identical_dict",
+  "tests/test_B/test_run.py::test_build_record_carries_reasoning_fields_when_forced",
+  "tests/test_B/test_run.py::test_build_record_preserves_every_field_untruncated",
+  "tests/test_B/test_run.py::test_results_dir_for_honors_explicit_override",
+  "tests/test_B/test_run.py::test_results_dir_for_isolates_the_two_protocols",
+  "tests/test_B/test_run.py::test_results_dir_for_matches_established_dimension_nesting",
+  "tests/test_B/test_run.py::test_run_strip_schema_legend_removes_only_the_legend",
+  "tests/test_B/test_run.py::test_write_question_result_writes_one_json_file_per_question",
+  "tests/test_B/test_spatial_codes.py::test_load_spatial_code_raises_clearly_when_missing",
+  "tests/test_B/test_spatial_codes.py::test_load_spatial_code_reads_a_real_on_disk_file",
+  "tests/test_B/test_spatial_codes.py::test_load_spatial_code_rejects_unknown_format",
+  "tests/test_B/test_spatial_codes.py::test_load_spatial_code_returns_dict_and_path",
+  "tests/test_B/test_spatial_codes.py::test_spatial_code_path_includes_every_cache_axis",
+  "tests/test_B/test_sweep.py::test_build_plan_covers_every_combination",
+  "tests/test_B/test_sweep.py::test_build_plan_orders_by_frame_count_first",
+  "tests/test_B/test_sweep.py::test_build_plan_sweeps_depth_and_tracking_too",
+  "tests/test_B/test_sweep.py::test_build_plan_with_all_registered_models",
+  "tests/test_B/test_sweep.py::test_sweep_parser_rejects_unknown_depth",
+  "tests/test_B/test_sweep.py::test_sweep_parser_rejects_unknown_spatial_code_format",
+  "tests/test_B/test_sweep.py::test_sweep_parser_rejects_unknown_tracking",
+  "tests/test_C/test_C.py::test_depth_and_tracking_reuse_encoder_config_vocabulary",
+  "tests/test_C/test_C.py::test_input_selections_are_one_shared_vocabulary_with_a_and_b",
+  "tests/test_C/test_C.py::test_results_dir_defaults_under_root_results",
+  "tests/test_C/test_C.py::test_reuses_harness_a_model_paths_and_generation_protocol",
+  "tests/test_C/test_init.py::test_depth_and_tracking_reuse_encoder_config_vocabulary",
+  "tests/test_C/test_init.py::test_input_selections_are_one_shared_vocabulary_with_a_and_b",
+  "tests/test_C/test_init.py::test_results_dir_defaults_under_root_results",
+  "tests/test_C/test_init.py::test_reuses_harness_a_model_paths_and_generation_protocol",
+  "tests/test_C/test_launch.py::test_launch_rebuild_forces_pending_even_when_answered",
+  "tests/test_C/test_launch.py::test_launch_routes_overlay_to_overlay_result_tree",
+  "tests/test_C/test_launch.py::test_launch_skips_scene_already_fully_answered",
+  "tests/test_C/test_launch.py::test_launcher_imports",
+  "tests/test_C/test_overlay.py::test_instance_ids_adds_stable_one_based_labels_without_mutating_input",
+  "tests/test_C/test_overlay.py::test_label_positions_parse_meter_strings_in_code_order",
+  "tests/test_C/test_overlay.py::test_load_cached_frames_requires_complete_png_set_and_labels",
+  "tests/test_C/test_overlay.py::test_load_or_create_overlay_code_reuses_existing_file",
+  "tests/test_C/test_overlay.py::test_load_or_create_overlay_code_saves_missing_file",
+  "tests/test_C/test_overlay.py::test_overlay_spatial_code_path_lives_under_overlay_root",
+  "tests/test_C/test_overlay.py::test_save_cached_frames_writes_pngs_and_labels",
+  "tests/test_C/test_overlay.py::test_stamp_frames_serves_complete_cache_without_loading_dependencies",
+  "tests/test_C/test_overlay.py::test_stamp_frames_uses_raw_sam3_boxes_and_does_not_mutate_inputs",
+  "tests/test_C/test_overlay_launch.py::test_available_cpu_count_honors_positive_environment",
+  "tests/test_C/test_overlay_launch.py::test_has_dependencies_requires_spatial_code_and_sam3_cache",
+  "tests/test_C/test_overlay_launch.py::test_has_dependencies_treats_missing_code_as_ineligible",
+  "tests/test_C/test_overlay_launch.py::test_launch_does_not_skip_frames_cache_when_overlay_code_is_missing",
+  "tests/test_C/test_overlay_launch.py::test_launch_skips_missing_and_already_cached_without_pool",
+  "tests/test_C/test_prompts.py::test_every_mca_question_type_builds[obj_appearance_order]",
+  "tests/test_C/test_prompts.py::test_every_mca_question_type_builds[object_rel_direction_easy]",
+  "tests/test_C/test_prompts.py::test_every_mca_question_type_builds[object_rel_direction_hard]",
+  "tests/test_C/test_prompts.py::test_every_mca_question_type_builds[object_rel_direction_medium]",
+  "tests/test_C/test_prompts.py::test_every_mca_question_type_builds[object_rel_distance]",
+  "tests/test_C/test_prompts.py::test_every_mca_question_type_builds[route_planning]",
+  "tests/test_C/test_prompts.py::test_every_na_question_type_builds[object_abs_distance]",
+  "tests/test_C/test_prompts.py::test_every_na_question_type_builds[object_counting]",
+  "tests/test_C/test_prompts.py::test_every_na_question_type_builds[object_size_estimation]",
+  "tests/test_C/test_prompts.py::test_every_na_question_type_builds[room_size_estimation]",
+  "tests/test_C/test_prompts.py::test_mca_question_prompt_includes_options_and_post_prompt",
+  "tests/test_C/test_prompts.py::test_mca_question_requires_options",
+  "tests/test_C/test_prompts.py::test_na_question_prompt_layout_is_context_then_code_then_question_then_post_prompt",
+  "tests/test_C/test_prompts.py::test_pre_prompt_mentions_both_frames_and_spatial_code",
+  "tests/test_C/test_prompts.py::test_unknown_question_type_rejected",
+  "tests/test_C/test_run.py::test_build_record_carries_both_frame_and_spatial_code_provenance",
+  "tests/test_C/test_run.py::test_build_record_carries_reasoning_fields_when_forced",
+  "tests/test_C/test_run.py::test_results_dir_for_honors_explicit_override",
+  "tests/test_C/test_run.py::test_results_dir_for_matches_established_dimension_nesting",
+  "tests/test_C/test_run.py::test_results_dir_for_places_overlay_under_C_results",
+  "tests/test_C/test_run.py::test_write_question_result_routes_overlay_default_to_overlay_tree",
+  "tests/test_C/test_run.py::test_write_question_result_writes_one_json_file_per_question",
+  "tests/test_C/test_sweep.py::test_build_plan_covers_every_combination",
+  "tests/test_C/test_sweep.py::test_build_plan_orders_by_frame_count_first",
+  "tests/test_C/test_sweep.py::test_build_plan_sweeps_depth_and_tracking_too",
+  "tests/test_C/test_sweep.py::test_build_plan_with_all_registered_models",
+  "tests/test_C/test_sweep.py::test_sweep_forwards_overlay_to_each_launch",
+  "tests/test_C/test_sweep.py::test_sweep_parser_rejects_unknown_depth",
+  "tests/test_C/test_sweep.py::test_sweep_parser_rejects_unknown_spatial_code_format",
+  "tests/test_C/test_sweep.py::test_sweep_parser_rejects_unknown_tracking",
+  "tests/test_D/test_D.py::test_results_dir_defaults_under_root_results",
+  "tests/test_D/test_D.py::test_reuses_harness_a_model_paths_and_generation_protocol",
+  "tests/test_D/test_D.py::test_spatial_code_formats_reuse_harness_b_vocabulary",
+  "tests/test_D/test_init.py::test_results_dir_defaults_under_root_results",
+  "tests/test_D/test_init.py::test_reuses_harness_a_model_paths_and_generation_protocol",
+  "tests/test_D/test_init.py::test_spatial_code_formats_reuse_harness_b_vocabulary",
+  "tests/test_D/test_launch.py::test_launch_rebuild_forces_pending_even_when_answered",
+  "tests/test_D/test_launch.py::test_launch_skips_scene_already_fully_answered",
+  "tests/test_D/test_launch.py::test_launcher_imports",
+  "tests/test_D/test_launch.py::test_scenes_is_subset_of_vsi_bench_scenes_with_ground_truth_coverage",
+  "tests/test_D/test_prompts.py::test_every_mca_question_type_builds[obj_appearance_order]",
+  "tests/test_D/test_prompts.py::test_every_mca_question_type_builds[object_rel_direction_easy]",
+  "tests/test_D/test_prompts.py::test_every_mca_question_type_builds[object_rel_direction_hard]",
+  "tests/test_D/test_prompts.py::test_every_mca_question_type_builds[object_rel_direction_medium]",
+  "tests/test_D/test_prompts.py::test_every_mca_question_type_builds[object_rel_distance]",
+  "tests/test_D/test_prompts.py::test_every_mca_question_type_builds[route_planning]",
+  "tests/test_D/test_prompts.py::test_every_na_question_type_builds[object_abs_distance]",
+  "tests/test_D/test_prompts.py::test_every_na_question_type_builds[object_counting]",
+  "tests/test_D/test_prompts.py::test_every_na_question_type_builds[object_size_estimation]",
+  "tests/test_D/test_prompts.py::test_every_na_question_type_builds[room_size_estimation]",
+  "tests/test_D/test_prompts.py::test_mca_question_prompt_includes_options_and_matches_harness_a_post_prompt",
+  "tests/test_D/test_prompts.py::test_mca_question_requires_options",
+  "tests/test_D/test_prompts.py::test_na_question_prompt_embeds_the_spatial_code_as_text_and_a_post_prompt",
+  "tests/test_D/test_prompts.py::test_no_frames_or_video_language_in_pre_prompt",
+  "tests/test_D/test_prompts.py::test_unknown_question_type_rejected",
+  "tests/test_D/test_run.py::test_build_record_carries_reasoning_fields_when_forced",
+  "tests/test_D/test_run.py::test_build_record_defaults_reasoning_fields_when_absent",
+  "tests/test_D/test_run.py::test_build_record_describes_frames_plus_ground_truth_condition",
+  "tests/test_D/test_run.py::test_build_record_preserves_every_field_untruncated",
+  "tests/test_D/test_run.py::test_results_dir_for_honors_explicit_override",
+  "tests/test_D/test_run.py::test_results_dir_for_isolates_frames_and_truncated_budget_arms",
+  "tests/test_D/test_run.py::test_results_dir_for_matches_model_protocol_and_format_only",
+  "tests/test_D/test_run.py::test_run_code_transform_hook_replaces_the_loaded_code",
+  "tests/test_D/test_run.py::test_write_question_result_writes_one_json_file_per_question",
+  "tests/test_D/test_spatial_codes.py::test_load_spatial_code_raises_clearly_when_missing",
+  "tests/test_D/test_spatial_codes.py::test_load_spatial_code_rejects_unknown_format",
+  "tests/test_D/test_spatial_codes.py::test_load_spatial_code_returns_dict_and_path",
+  "tests/test_D/test_sweep.py::test_build_plan_covers_every_combination",
+  "tests/test_D/test_sweep.py::test_build_plan_with_all_registered_models",
+  "tests/test_D/test_sweep.py::test_default_spatial_code_formats_cover_both_when_not_restricted",
+  "tests/test_D/test_symbolic_eval.py::test_run_answers_real_questions_for_a_real_ground_truth_scene",
+  "tests/test_D/test_symbolic_eval.py::test_run_does_not_write_when_write_results_is_false",
+  "tests/test_D/test_symbolic_eval.py::test_run_forwards_results_dir_to_symbolic_writer",
+  "tests/test_D/test_symbolic_eval.py::test_run_selects_ground_truth_spatial_codes_when_writing",
+  "tests/test_E/test_E.py::test_blind_floor_reuses_harness_a_public_config",
+  "tests/test_E/test_E.py::test_results_dir_can_be_overridden_by_environment",
+  "tests/test_E/test_init.py::test_blind_floor_reuses_harness_a_public_config",
+  "tests/test_E/test_init.py::test_results_dir_can_be_overridden_by_environment",
+  "tests/test_E/test_launch.py::test_launch_protocols_use_separate_result_roots",
+  "tests/test_E/test_launch.py::test_launch_rebuild_forces_pending_even_when_answered",
+  "tests/test_E/test_launch.py::test_launch_skips_scene_already_fully_answered",
+  "tests/test_E/test_launch.py::test_launcher_imports",
+  "tests/test_E/test_prompts.py::test_every_mca_question_type_builds[obj_appearance_order]",
+  "tests/test_E/test_prompts.py::test_every_mca_question_type_builds[object_rel_direction_easy]",
+  "tests/test_E/test_prompts.py::test_every_mca_question_type_builds[object_rel_direction_hard]",
+  "tests/test_E/test_prompts.py::test_every_mca_question_type_builds[object_rel_direction_medium]",
+  "tests/test_E/test_prompts.py::test_every_mca_question_type_builds[object_rel_distance]",
+  "tests/test_E/test_prompts.py::test_every_mca_question_type_builds[route_planning]",
+  "tests/test_E/test_prompts.py::test_every_na_question_type_builds[object_abs_distance]",
+  "tests/test_E/test_prompts.py::test_every_na_question_type_builds[object_counting]",
+  "tests/test_E/test_prompts.py::test_every_na_question_type_builds[object_size_estimation]",
+  "tests/test_E/test_prompts.py::test_every_na_question_type_builds[room_size_estimation]",
+  "tests/test_E/test_prompts.py::test_mca_question_prompt_includes_options_and_post_prompt",
+  "tests/test_E/test_prompts.py::test_mca_question_requires_options",
+  "tests/test_E/test_prompts.py::test_na_question_prompt_is_question_plus_post_prompt_only",
+  "tests/test_E/test_prompts.py::test_no_scene_language_anywhere",
+  "tests/test_E/test_prompts.py::test_unknown_question_type_rejected",
+  "tests/test_E/test_run.py::test_build_record_has_no_scene_input_provenance",
+  "tests/test_E/test_run.py::test_results_dir_for_honors_explicit_override",
+  "tests/test_E/test_run.py::test_results_dir_for_isolates_the_two_protocols",
+  "tests/test_E/test_run.py::test_results_dir_for_matches_model_and_protocol_only",
+  "tests/test_E/test_run.py::test_write_question_result_writes_one_json_file_per_question",
+  "tests/test_E/test_sweep.py::test_sweep_defaults_to_base_protocol",
+  "tests/test_E/test_sweep.py::test_sweep_imports",
+  "tests/test_E/test_sweep.py::test_sweep_parser_rejects_unknown_model",
+  "tests/test_E/test_sweep.py::test_sweep_runs_every_model_through_launch",
+  "tests/test_F/test_F.py::test_results_dir_can_be_overridden_by_environment",
+  "tests/test_F/test_F.py::test_sources_and_default_are_declared",
+  "tests/test_F/test_init.py::test_results_dir_can_be_overridden_by_environment",
+  "tests/test_F/test_init.py::test_sources_and_default_are_declared",
+  "tests/test_F/test_launch.py::test_launch_entrypoint_exposes_run_main",
+  "tests/test_F/test_run.py::test_ground_truth_layout_has_no_perception_axes",
+  "tests/test_F/test_run.py::test_perceived_layout_contains_every_input_axis",
+  "tests/test_F/test_run.py::test_results_default_under_root",
+  "tests/test_F/test_run.py::test_select_source_routes_to_existing_symbolic_selectors",
+  "tests/test_F/test_sweep.py::test_csv_expands_all_dedups_and_rejects_unknowns",
+  "tests/test_F/test_sweep.py::test_main_routes_ground_truth_without_perception_axes",
+  "tests/test_analysis/test_A_reports.py::TestAReports::test_A_report_and_controlled_frame_comparison",
+  "tests/test_analysis/test_B_reports.py::TestBReports::test_B_report_contains_spatial_cell",
+  "tests/test_analysis/test_C_reports.py::TestCReports::test_C_report_is_exported",
+  "tests/test_analysis/test_D_reports.py::TestDReports::test_D_report_is_ground_truth_code_report",
+  "tests/test_analysis/test_F_reports.py::TestFReports::test_F_legacy_and_future_perceived_layouts",
+  "tests/test_analysis/test_analysis.py::TestAnalysisDirectory::test_E_is_excluded",
+  "tests/test_analysis/test_analysis.py::TestAnalysisDirectory::test_arbitrary_subset_exports_letter_and_combined_files",
+  "tests/test_analysis/test_letters_reports.py::TestLettersReports::test_DF_and_BF_semantic_alignment",
+  "tests/test_analysis/test_letters_reports.py::TestLettersReports::test_arbitrary_subset_and_combined_name",
+  "tests/test_analysis/test_letters_reports.py::TestLettersReports::test_folded_statistical_and_solver_helpers",
+  "tests/test_analysis/test_letters_reports.py::TestLettersReports::test_manifest_generated_at_is_deterministic_by_default",
+  "tests/test_analysis/test_letters_reports.py::TestLettersReports::test_pair_restriction",
+  "tests/test_backup.py::test_backup_dry_run_skips_empty_targets_and_never_imports_hub",
+  "tests/test_backup.py::test_local_paths_keep_results_under_results_host",
+  "tests/test_backup.py::test_resolve_targets_expands_all_without_uploading_unknowns",
+  "tests/test_backup.py::test_target_root_rejects_mixed_workspace_and_results_roots",
+  "tests/test_calibration/test_calibration.py::test_results_dir_can_be_overridden_by_environment",
+  "tests/test_calibration/test_calibration.py::test_results_dir_defaults_to_root_results",
+  "tests/test_calibration/test_init.py::test_results_dir_can_be_overridden_by_environment",
+  "tests/test_calibration/test_init.py::test_results_dir_defaults_to_root_results",
+  "tests/test_calibration/test_report.py::test_cell_stats_counts_forced_and_natural_lengths",
+  "tests/test_calibration/test_report.py::test_load_grid_does_not_mistake_frame_count_dirs_for_budgets",
+  "tests/test_calibration/test_report.py::test_load_grid_includes_variant_budget_directories",
+  "tests/test_calibration/test_report.py::test_load_grid_reads_the_full_config_layout",
+  "tests/test_calibration/test_report.py::test_recommendation_picks_smallest_saturated_low_forced_budget",
+  "tests/test_calibration/test_report.py::test_recommendation_rejects_high_forced_rate_even_at_best_accuracy",
+  "tests/test_calibration/test_report.py::test_report_scores_only_the_shared_question_intersection",
+  "tests/test_calibration/test_report.py::test_variant_rows_are_never_recommended",
+  "tests/test_calibration/test_run.py::test_build_plan_orders_cheapest_budget_first",
+  "tests/test_calibration/test_run.py::test_cli_rejects_nonpositive_budget",
+  "tests/test_calibration/test_run.py::test_cli_requires_exactly_one_question_source",
+  "tests/test_calibration/test_run.py::test_results_dir_isolates_every_pilot_axis",
+  "tests/test_calibration/test_run.py::test_run_grid_passes_budget_questions_and_isolated_dir",
+  "tests/test_calibration/test_run.py::test_scenes_for_derives_scenes_and_rejects_unknown_ids",
+  "tests/test_corruption/test_chimera.py::test_chimeras_do_not_mutate_inputs",
+  "tests/test_corruption/test_chimera.py::test_gt_inventory_keeps_gt_counts_but_takes_perceived_boxes",
+  "tests/test_corruption/test_chimera.py::test_perceived_inventory_keeps_perceived_counts_but_takes_gt_boxes",
+  "tests/test_corruption/test_chimera.py::test_perturb_single_object_changes_exactly_one_instance",
+  "tests/test_corruption/test_chimera.py::test_perturb_single_object_empty_code_is_a_noop",
+  "tests/test_corruption/test_corruption.py::test_corruption_defaults_are_explicit",
+  "tests/test_corruption/test_corruption.py::test_results_dir_can_be_overridden_by_environment",
+  "tests/test_corruption/test_empirical.py::test_empirical_noise_applies_sampled_residuals",
+  "tests/test_corruption/test_empirical.py::test_empirical_noise_at_zero_scale_is_identity",
+  "tests/test_corruption/test_empirical.py::test_empirical_noise_is_reproducible",
+  "tests/test_corruption/test_empirical.py::test_measure_residuals_dimension_ratios",
+  "tests/test_corruption/test_empirical.py::test_measure_residuals_matches_missed_and_hallucinated",
+  "tests/test_corruption/test_init.py::test_corruption_defaults_are_explicit",
+  "tests/test_corruption/test_init.py::test_results_dir_can_be_overridden_by_environment",
+  "tests/test_corruption/test_launch.py::test_launch_imports",
+  "tests/test_corruption/test_launch.py::test_launch_rejects_unknown_transform",
+  "tests/test_corruption/test_launch.py::test_launch_runs_the_full_grid_through_run_solver",
+  "tests/test_corruption/test_launch.py::test_launch_vlm_arm_requires_models",
+  "tests/test_corruption/test_run.py::test_certify_rejects_non_invariance_transforms",
+  "tests/test_corruption/test_run.py::test_certify_translate_passes_on_a_real_scene",
+  "tests/test_corruption/test_run.py::test_chimera_requires_perceived_config",
+  "tests/test_corruption/test_run.py::test_corrupted_code_is_reproducible",
+  "tests/test_corruption/test_run.py::test_corrupted_explicit_is_derived_from_the_corrupted_compact",
+  "tests/test_corruption/test_run.py::test_empirical_requires_residuals",
+  "tests/test_corruption/test_run.py::test_make_code_transform_ignores_the_loaded_code",
+  "tests/test_corruption/test_run.py::test_non_probe_runs_write_no_sidecar",
+  "tests/test_corruption/test_run.py::test_results_dir_for_isolates_every_axis",
+  "tests/test_corruption/test_run.py::test_run_solver_answers_and_writes_records",
+  "tests/test_corruption/test_run.py::test_run_solver_respects_the_question_sample",
+  "tests/test_corruption/test_run.py::test_run_solver_zero_magnitude_jitter_matches_clean_ground_truth",
+  "tests/test_corruption/test_run.py::test_seed_is_deterministic_and_condition_specific",
+  "tests/test_corruption/test_run.py::test_single_object_info_is_deterministic_and_recomputable",
+  "tests/test_corruption/test_run.py::test_single_object_solver_run_writes_perturbation_sidecar",
+  "tests/test_corruption/test_run.py::test_unknown_transform_rejected",
+  "tests/test_corruption/test_run.py::test_wrong_scene_requires_a_substitute",
+  "tests/test_corruption/test_run.py::test_wrong_scene_returns_the_substitute_scenes_code",
+  "tests/test_corruption/test_sample.py::test_budget_key_pools_direction_subtypes",
+  "tests/test_corruption/test_sample.py::test_draw_sample_budget_caps_the_draw",
+  "tests/test_corruption/test_sample.py::test_draw_sample_excludes_unlisted_categories_and_scenes",
+  "tests/test_corruption/test_sample.py::test_draw_sample_is_deterministic_for_the_frozen_seed",
+  "tests/test_corruption/test_sample.py::test_draw_sample_spreads_across_scenes_round_robin",
+  "tests/test_corruption/test_transforms.py::test_class_swap_keeps_geometry_but_relabels",
+  "tests/test_corruption/test_transforms.py::test_dimension_noise_never_collapses_a_dimension",
+  "tests/test_corruption/test_transforms.py::test_drop_objects_removes_emptied_classes_entirely",
+  "tests/test_corruption/test_transforms.py::test_drop_objects_zero_fraction_drops_nothing",
+  "tests/test_corruption/test_transforms.py::test_hallucinate_objects_only_ever_adds",
+  "tests/test_corruption/test_transforms.py::test_position_jitter_moves_centers_and_nothing_else",
+  "tests/test_corruption/test_transforms.py::test_position_jitter_zero_sigma_is_identity_geometry",
+  "tests/test_corruption/test_transforms.py::test_reorder_changes_only_order",
+  "tests/test_corruption/test_transforms.py::test_rotate_z_preserves_pairwise_distances",
+  "tests/test_corruption/test_transforms.py::test_round_precision_rounds_every_geometry_value",
+  "tests/test_corruption/test_transforms.py::test_seeded_transforms_are_reproducible",
+  "tests/test_corruption/test_transforms.py::test_transforms_never_mutate_the_input",
+  "tests/test_corruption/test_transforms.py::test_translate_shifts_centers_and_polygons_together",
   "tests/test_encoder/test_adapters.py::test_adapt_sam3_depth_anything_3_decodes_masks_and_backprojects",
   "tests/test_encoder/test_adapters.py::test_adapt_segvggt_reads_flat_npz",
   "tests/test_encoder/test_adapters.py::test_adapt_segvggt_rejects_missing_npz_fields",
@@ -7,16 +361,22 @@
   "tests/test_encoder/test_adapters.py::test_adapters_default_to_root_data_caches",
   "tests/test_encoder/test_adapters.py::test_backproject_resizes_sam3_mask_to_da3_depth_shape",
   "tests/test_encoder/test_adapters.py::test_fusion_adapter_resolves_two_native_model_directories",
+  "tests/test_encoder/test_adapters.py::test_native_fusion_times_are_measured_in_seconds",
   "tests/test_encoder/test_adapters.py::test_native_sam3_decodes_lossless_tracking_cache",
   "tests/test_encoder/test_adapters.py::test_native_sam3_decodes_prompt_keyed_independent_frames",
   "tests/test_encoder/test_adapters.py::test_native_sam3_preserves_tracked_object_ids",
   "tests/test_encoder/test_adapters.py::test_registry_decodes_native_segvggt_dictionary",
+  "tests/test_encoder/test_adapters.py::test_spatial_code_format_validation",
   "tests/test_encoder/test_adapters.py::test_validate_identifies_empty_scene",
   "tests/test_encoder/test_adapters.py::test_validate_normalizes_canonical_geometry",
   "tests/test_encoder/test_adapters.py::test_validate_rejects_invalid_geometry[scene0-TypeError]",
   "tests/test_encoder/test_adapters.py::test_validate_rejects_invalid_geometry[scene1-ValueError]",
   "tests/test_encoder/test_adapters.py::test_validate_rejects_invalid_geometry[scene2-ValueError]",
   "tests/test_encoder/test_config.py::test_cache_and_code_paths_are_flat",
+  "tests/test_encoder/test_config.py::test_encoder_paths_mirror_all_dimensions",
+  "tests/test_encoder/test_config.py::test_encoder_paths_reject_unknown_spatial_code_format",
+  "tests/test_encoder/test_config.py::test_ground_truth_paths_have_no_depth_tracking_input_frames_axis",
+  "tests/test_encoder/test_config.py::test_ground_truth_paths_reject_unknown_spatial_code_format",
   "tests/test_encoder/test_config.py::test_mode_paths_are_isolated[selective-no-tracking-selective/no tracking]",
   "tests/test_encoder/test_config.py::test_mode_paths_are_isolated[uniform-tracking-uniform/tracking]",
   "tests/test_encoder/test_config.py::test_parse_frame_mode_rejects_video_modes",
@@ -29,16 +389,47 @@
   "tests/test_encoder/test_encoder.py::test_depth_edges_handles_small_and_discontinuous_frames",
   "tests/test_encoder/test_encoder.py::test_relative_direction_modes",
   "tests/test_encoder/test_encoder.py::test_robust_centroid_extent_returns_sorted_dimensions",
+  "tests/test_encoder/test_geometric.py::test_compact_floor_boundaries_preserve_disconnected_regions",
+  "tests/test_encoder/test_geometric.py::test_compact_instances_keep_peak_co_visible_hypotheses_by_evidence",
+  "tests/test_encoder/test_geometric.py::test_compact_oriented_box_combines_observation_extents_by_consensus",
+  "tests/test_encoder/test_geometric.py::test_compact_oriented_box_rejects_one_inconsistent_observation",
+  "tests/test_encoder/test_geometric.py::test_compact_oriented_box_uses_accumulated_instance_points",
+  "tests/test_encoder/test_geometric.py::test_compact_spatial_code_exposes_only_reusable_primitives",
+  "tests/test_encoder/test_geometric.py::test_compact_spatial_code_merges_revisit_instances_and_keeps_earliest_time",
+  "tests/test_encoder/test_geometric.py::test_compact_spatial_code_suppresses_co_visible_duplicate_tracks",
   "tests/test_encoder/test_geometric.py::test_dump_spatial_code",
   "tests/test_encoder/test_geometric.py::test_dumped_json_preserves_schema",
   "tests/test_encoder/test_geometric.py::test_exact_math_is_integrated_into_geometric_module",
+  "tests/test_encoder/test_geometric.py::test_explicit_is_a_derivation_of_compact",
+  "tests/test_encoder/test_geometric.py::test_explicit_spatial_code_remains_the_default",
   "tests/test_encoder/test_geometric.py::test_floor_level_v1_v2_math_is_shared",
   "tests/test_encoder/test_geometric.py::test_position_reader_accepts_current_and_legacy_formatting",
+  "tests/test_encoder/test_geometric.py::test_raw_bundle_dispatches_to_explicit_derivation",
   "tests/test_encoder/test_geometric.py::test_raw_bundle_dispatches_to_integrated_exact_path",
   "tests/test_encoder/test_geometric.py::test_spatial_code_matches_reference_schema",
+  "tests/test_encoder/test_ground_truth.py::test_appearance_order_ranks_topological_across_multiple_questions",
+  "tests/test_encoder/test_ground_truth.py::test_build_all_respects_explicit_scene_list_and_formats",
+  "tests/test_encoder/test_ground_truth.py::test_build_all_writes_every_scene_and_format",
+  "tests/test_encoder/test_ground_truth.py::test_build_and_write_writes_to_the_ground_truth_path",
+  "tests/test_encoder/test_ground_truth.py::test_build_compact_ground_truth_spatial_code_nulls_untimed_classes",
+  "tests/test_encoder/test_ground_truth.py::test_build_compact_ground_truth_spatial_code_raises_for_unknown_scene",
+  "tests/test_encoder/test_ground_truth.py::test_build_compact_ground_truth_spatial_code_uses_ranks_and_nulls_unranked",
+  "tests/test_encoder/test_ground_truth.py::test_build_explicit_ground_truth_spatial_code_is_derived_from_compact",
+  "tests/test_encoder/test_ground_truth.py::test_build_ground_truth_spatial_code_dispatches_by_format",
+  "tests/test_encoder/test_ground_truth.py::test_build_ground_truth_spatial_code_rejects_unknown_format",
+  "tests/test_encoder/test_ground_truth.py::test_floor_level_accounts_for_tilted_box_support",
+  "tests/test_encoder/test_ground_truth.py::test_floor_level_defaults_to_zero_for_empty_scene",
+  "tests/test_encoder/test_ground_truth.py::test_floor_level_is_the_lowest_box_support_across_every_instance",
+  "tests/test_encoder/test_ground_truth.py::test_gt_floor_boundary_polygon_area_matches_room_size",
+  "tests/test_encoder/test_ground_truth.py::test_gt_oriented_box_rebases_height_above_floor_and_passes_xy_through",
+  "tests/test_encoder/test_ground_truth.py::test_gt_oriented_box_renormalizes_orientation_vectors",
+  "tests/test_encoder/test_ground_truth.py::test_load_meta_info_merges_all_three_datasets_and_tags_dataset",
+  "tests/test_encoder/test_ground_truth.py::test_scenes_returns_sorted_meta_info_keys",
+  "tests/test_encoder/test_init.py::test_encoder_package_imports_without_data_or_checkpoints",
   "tests/test_encoder/test_launch.py::test_available_cpu_count_respects_affinity_and_override",
   "tests/test_encoder/test_launch.py::test_cached_scenes_requires_both_sam3_and_da3_caches",
   "tests/test_encoder/test_launch.py::test_cached_scenes_requires_segvggt_cache",
+  "tests/test_encoder/test_launch.py::test_encoder_launcher_imports",
   "tests/test_encoder/test_launch.py::test_main_all_dispatches_every_frame_mode",
   "tests/test_encoder/test_launch.py::test_main_dispatches_one_requested_mode",
   "tests/test_encoder/test_launch.py::test_main_skips_existing_spatial_codes",
@@ -49,35 +440,87 @@
   "tests/test_encoder/test_launch.py::test_visible_gpus_uses_environment",
   "tests/test_encoder/test_launch.py::test_worker_skips_empty_scenes_but_fails_other_errors",
   "tests/test_encoder/test_render.py::test_build_spatial_code_uses_cached_geometry",
+  "tests/test_encoder/test_render.py::test_render_exposes_tracking_and_format_dimensions",
   "tests/test_encoder/test_render.py::test_write_spatial_code_propagates_mode",
   "tests/test_encoder/test_render.py::test_write_spatial_code_uses_scene_json",
   "tests/test_encoder/test_run.py::test_cache_or_load_builds_and_writes_cache",
+  "tests/test_encoder/test_run.py::test_cache_or_load_exposes_explicit_dimensions",
   "tests/test_encoder/test_run.py::test_cache_or_load_reads_flat_cache",
   "tests/test_encoder/test_run.py::test_fusion_cache_rejects_changed_native_source",
   "tests/test_encoder/test_run.py::test_fusion_cache_uses_explicit_mode_inputs",
   "tests/test_encoder/test_run.py::test_fusion_requires_mode",
+  "tests/test_harness/test_harness.py::test_harness_package_imports_without_side_effects",
+  "tests/test_harness/test_init.py::test_harness_package_imports_without_side_effects",
+  "tests/test_inference/test_adapters.py::test_algorithm_3_catches_injected_corruption_without_false_positives",
+  "tests/test_inference/test_adapters.py::test_algorithm_4_compresses_static_redundancy_at_least_as_well_as_algorithm_1",
+  "tests/test_inference/test_adapters.py::test_algorithm_5_output_is_subset_of_algorithm_2_output",
   "tests/test_inference/test_adapters.py::test_alignment_failure_falls_back_to_unaligned_ssim",
   "tests/test_inference/test_adapters.py::test_alignment_makes_small_camera_shift_redundant",
+  "tests/test_inference/test_adapters.py::test_cache_is_invalidated_when_selector_config_changes",
   "tests/test_inference/test_adapters.py::test_combined_adapter_gives_both_models_the_same_decoded_frames",
   "tests/test_inference/test_adapters.py::test_combined_adapter_runs_only_requested_target",
   "tests/test_inference/test_adapters.py::test_da3_preserves_native_prediction_object",
   "tests/test_inference/test_adapters.py::test_load_model_validates_repository_and_checkpoint",
+  "tests/test_inference/test_adapters.py::test_metric_adapter_is_registered",
   "tests/test_inference/test_adapters.py::test_read_video_rejects_unopenable_file",
   "tests/test_inference/test_adapters.py::test_redundancy_groups_keep_sharpest_and_earlier_ties",
+  "tests/test_inference/test_adapters.py::test_relative_adapter_is_registered",
   "tests/test_inference/test_adapters.py::test_run_scene_preserves_raw_dtypes_and_encoder_geometry",
   "tests/test_inference/test_adapters.py::test_run_scene_requires_loaded_model",
+  "tests/test_inference/test_adapters.py::test_sam3_adapter_accepts_tracking_modes",
   "tests/test_inference/test_adapters.py::test_sam3_preserves_independent_image_responses_without_tracking",
+  "tests/test_inference/test_adapters.py::test_select_video_frame_indices_rejects_unknown_algorithm",
   "tests/test_inference/test_adapters.py::test_selective_sampling_honors_requested_frame_count",
+  "tests/test_inference/test_adapters.py::test_selector_algorithm_defaults_to_five",
+  "tests/test_inference/test_adapters.py::test_selector_algorithm_dispatch_is_registered[1]",
+  "tests/test_inference/test_adapters.py::test_selector_algorithm_dispatch_is_registered[2]",
+  "tests/test_inference/test_adapters.py::test_selector_algorithm_dispatch_is_registered[3]",
+  "tests/test_inference/test_adapters.py::test_selector_algorithm_dispatch_is_registered[4]",
+  "tests/test_inference/test_adapters.py::test_selector_algorithm_dispatch_is_registered[5]",
+  "tests/test_inference/test_adapters.py::test_selector_config_reflects_every_tunable_constant[1-MINIMUM_ALIGNMENT_INLIER_RATIO]",
+  "tests/test_inference/test_adapters.py::test_selector_config_reflects_every_tunable_constant[1-MINIMUM_ALIGNMENT_MATCHES]",
+  "tests/test_inference/test_adapters.py::test_selector_config_reflects_every_tunable_constant[1-MINIMUM_VALID_OVERLAP_FRACTION]",
+  "tests/test_inference/test_adapters.py::test_selector_config_reflects_every_tunable_constant[1-REDUNDANCY_SSIM_THRESHOLD]",
+  "tests/test_inference/test_adapters.py::test_selector_config_reflects_every_tunable_constant[2-BLUR_ABSOLUTE_FLOOR]",
+  "tests/test_inference/test_adapters.py::test_selector_config_reflects_every_tunable_constant[2-BLUR_CANONICAL_WIDTH]",
+  "tests/test_inference/test_adapters.py::test_selector_config_reflects_every_tunable_constant[2-BLUR_RELATIVE_MEDIAN_FRACTION]",
+  "tests/test_inference/test_adapters.py::test_selector_config_reflects_every_tunable_constant[2-BRIGHT_MEAN_THRESHOLD]",
+  "tests/test_inference/test_adapters.py::test_selector_config_reflects_every_tunable_constant[2-DARK_MEAN_THRESHOLD]",
+  "tests/test_inference/test_adapters.py::test_selector_config_reflects_every_tunable_constant[2-LOW_CONTRAST_STD_THRESHOLD]",
+  "tests/test_inference/test_adapters.py::test_selector_config_reflects_every_tunable_constant[3-BLACK_FRAME_PIXEL_RATIO_THRESHOLD]",
+  "tests/test_inference/test_adapters.py::test_selector_config_reflects_every_tunable_constant[3-BLACK_PIXEL_LUMINANCE_THRESHOLD]",
+  "tests/test_inference/test_adapters.py::test_selector_config_reflects_every_tunable_constant[3-GLITCH_MAX_NEIGHBOR_COVISIBILITY]",
+  "tests/test_inference/test_adapters.py::test_selector_config_reflects_every_tunable_constant[3-GLITCH_MINIMUM_OWN_KEYPOINTS]",
+  "tests/test_inference/test_adapters.py::test_selector_config_reflects_every_tunable_constant[3-GLITCH_THUMBNAIL_WIDTH]",
+  "tests/test_inference/test_adapters.py::test_selector_config_reflects_every_tunable_constant[3-MINIMUM_ALIGNMENT_MATCHES]",
+  "tests/test_inference/test_adapters.py::test_selector_config_reflects_every_tunable_constant[4-COVISIBILITY_OVERLAP_THRESHOLD]",
+  "tests/test_inference/test_adapters.py::test_selector_config_reflects_every_tunable_constant[4-MINIMUM_ALIGNMENT_MATCHES]",
+  "tests/test_inference/test_adapters.py::test_selector_config_reflects_every_tunable_constant[4-REDUNDANCY_SSIM_THRESHOLD]",
+  "tests/test_inference/test_adapters.py::test_selector_config_reflects_every_tunable_constant[5-BLUR_ABSOLUTE_FLOOR]",
+  "tests/test_inference/test_adapters.py::test_selector_config_reflects_every_tunable_constant[5-BLUR_CANONICAL_WIDTH]",
+  "tests/test_inference/test_adapters.py::test_selector_config_reflects_every_tunable_constant[5-BLUR_RELATIVE_MEDIAN_FRACTION]",
+  "tests/test_inference/test_adapters.py::test_selector_config_reflects_every_tunable_constant[5-BRIGHT_MEAN_THRESHOLD]",
+  "tests/test_inference/test_adapters.py::test_selector_config_reflects_every_tunable_constant[5-COVISIBILITY_OVERLAP_THRESHOLD]",
+  "tests/test_inference/test_adapters.py::test_selector_config_reflects_every_tunable_constant[5-DARK_MEAN_THRESHOLD]",
+  "tests/test_inference/test_adapters.py::test_selector_config_reflects_every_tunable_constant[5-LOW_CONTRAST_STD_THRESHOLD]",
+  "tests/test_inference/test_adapters.py::test_selector_config_reflects_every_tunable_constant[5-MINIMUM_ALIGNMENT_MATCHES]",
+  "tests/test_inference/test_adapters.py::test_selector_config_reflects_every_tunable_constant[5-REDUNDANCY_SSIM_THRESHOLD]",
   "tests/test_inference/test_adapters.py::test_tracking_frames_preserve_tracker_object_ids",
   "tests/test_inference/test_inference.py::test_adapter_registry",
   "tests/test_inference/test_inference.py::test_combined_run_resumes_only_missing_target",
   "tests/test_inference/test_inference.py::test_frame_modes_are_complete_and_parseable",
   "tests/test_inference/test_inference.py::test_local_model_roots_are_exact",
+  "tests/test_inference/test_inference.py::test_model_registry_uses_explicit_names",
   "tests/test_inference/test_inference.py::test_native_output_paths_are_isolated_by_mode",
+  "tests/test_inference/test_inference.py::test_output_paths_include_frame_hierarchy",
   "tests/test_inference/test_inference.py::test_run_scene_builds_then_skips_selected_mode",
   "tests/test_inference/test_inference.py::test_scenes_deduplicates_manifest",
   "tests/test_inference/test_inference.py::test_visible_gpus_uses_environment",
+  "tests/test_inference/test_init.py::test_cache_dir_helpers_validate_axes_and_include_dimensions",
+  "tests/test_inference/test_init.py::test_video_path_finds_exact_dataset_match",
+  "tests/test_inference/test_init.py::test_video_path_reports_missing_unknown_and_ambiguous_datasets",
   "tests/test_inference/test_launch.py::test_available_cpu_count_respects_affinity_and_override",
+  "tests/test_inference/test_launch.py::test_launcher_imports",
   "tests/test_inference/test_launch.py::test_main_requires_mode_or_all",
   "tests/test_inference/test_launch.py::test_main_runs_only_requested_modes_or_all",
   "tests/test_inference/test_launch.py::test_scenes_deduplicate_manifest",
@@ -85,26 +528,52 @@
   "tests/test_inference/test_launch.py::test_visible_gpus_uses_environment",
   "tests/test_inference/test_launch.py::test_worker_loads_tracking_adapter_once_and_reuses_it",
   "tests/test_inference/test_launch.py::test_worker_reports_model_load_failure_for_every_scene",
+  "tests/test_inference/test_prompts.py::test_dataset_from_video_path_matches_one_dataset_case_insensitively",
+  "tests/test_inference/test_prompts.py::test_dataset_from_video_path_rejects_missing_or_ambiguous_dataset",
+  "tests/test_inference/test_prompts.py::test_object_prompts_are_immutable_and_dataset_specific",
   "tests/test_inference/test_run.py::test_real_segvggt_scene_preserves_native_prediction_dictionary",
+  "tests/test_symbolic/test_adapters.py::test_adapter_rejects_format_mismatch",
+  "tests/test_symbolic/test_adapters.py::test_compact_adapter_derives_solver_values_from_primitives",
+  "tests/test_symbolic/test_adapters.py::test_compact_adapter_ignores_none_instances_within_a_partially_timed_class",
+  "tests/test_symbolic/test_adapters.py::test_compact_adapter_treats_none_first_visible_time_as_unknown",
+  "tests/test_symbolic/test_adapters.py::test_explicit_adapter_preserves_existing_solver_shape",
+  "tests/test_symbolic/test_adapters.py::test_floor_area_sums_disconnected_polygons_and_subtracts_all_holes",
+  "tests/test_symbolic/test_adapters.py::test_oriented_box_distance_is_surface_to_surface",
+  "tests/test_symbolic/test_adapters.py::test_oriented_box_distance_uses_corresponding_rotated_axes",
+  "tests/test_symbolic/test_adapters.py::test_polygon_area_implicitly_closes_ordered_boundary",
+  "tests/test_symbolic/test_adapters.py::test_symbolic_solver_answers_all_direction_levels_from_compact_code",
+  "tests/test_symbolic/test_adapters.py::test_symbolic_solver_answers_numeric_categories_from_compact_code",
+  "tests/test_symbolic/test_adapters.py::test_symbolic_solver_answers_relative_distance_and_order_from_compact_code",
+  "tests/test_symbolic/test_adapters.py::test_symbolic_solver_answers_route_planning_from_compact_code",
   "tests/test_symbolic/test_launch.py::test_error_analysis_rejects_non_numeric_question_type",
   "tests/test_symbolic/test_launch.py::test_error_analysis_summarizes_numeric_errors",
   "tests/test_symbolic/test_launch.py::test_main_all_runs_every_frame_mode",
   "tests/test_symbolic/test_launch.py::test_mca_answer_breakdown_distinguishes_outcomes",
   "tests/test_symbolic/test_launch.py::test_scenes_with_spatial_codes_returns_sorted_stems",
+  "tests/test_symbolic/test_launch.py::test_symbolic_launcher_imports",
   "tests/test_symbolic/test_run.py::test_fetch_spatial_code_reads_flat_json",
   "tests/test_symbolic/test_run.py::test_fetch_spatial_code_reports_missing_file",
+  "tests/test_symbolic/test_run.py::test_fetch_spatial_code_uses_selected_format_adapter",
   "tests/test_symbolic/test_run.py::test_find_workspace_root_uses_spatial_codes_folder",
   "tests/test_symbolic/test_run.py::test_parse_frame_mode_rejects_video_mode",
   "tests/test_symbolic/test_run.py::test_question_result_records_selected_frame_mode",
   "tests/test_symbolic/test_run.py::test_real_questions_for_scene_filters_jsonl",
+  "tests/test_symbolic/test_run.py::test_results_dir_for_selection_uses_ground_truth_layout",
+  "tests/test_symbolic/test_run.py::test_select_ground_truth_spatial_codes_points_at_the_ground_truth_directory",
+  "tests/test_symbolic/test_run.py::test_select_ground_truth_spatial_codes_rejects_unknown_format",
   "tests/test_symbolic/test_run.py::test_select_model_reads_frame_mode_subfolder[selective-no-tracking-frames/selective/no tracking]",
   "tests/test_symbolic/test_run.py::test_select_model_reads_frame_mode_subfolder[selective-tracking-frames/selective/tracking]",
   "tests/test_symbolic/test_run.py::test_select_model_reads_frame_mode_subfolder[uniform-no-tracking-frames/uniform/no tracking]",
   "tests/test_symbolic/test_run.py::test_select_model_reads_frame_mode_subfolder[uniform-tracking-frames/uniform/tracking]",
   "tests/test_symbolic/test_run.py::test_select_model_reads_fusion_subfolder",
+  "tests/test_symbolic/test_run.py::test_select_spatial_codes_clears_ground_truth_flag",
   "tests/test_symbolic/test_run.py::test_symbolic_results_are_isolated_by_model_and_mode",
   "tests/test_symbolic/test_run.py::test_symbolic_results_mirror_frame_mode_cache_layout",
+  "tests/test_symbolic/test_run.py::test_symbolic_selection_isolates_compact_codes",
+  "tests/test_symbolic/test_run.py::test_symbolic_selection_uses_new_hierarchy",
+  "tests/test_symbolic/test_run.py::test_write_question_result_nulls_perception_fields_under_ground_truth",
   "tests/test_symbolic/test_run.py::test_write_scene_results_uses_one_file_per_question",
+  "tests/test_symbolic/test_solver.py::test_answer_snapshots_operation_counts_per_question",
   "tests/test_symbolic/test_solver.py::test_direct_numeric_answers",
   "tests/test_symbolic/test_solver.py::test_direction_answers_use_floor_coordinates",
   "tests/test_symbolic/test_solver.py::test_dispatch_returns_none_for_unknown_or_missing_data",

analysis/A_reports.py

@@ -1,9 +1,34 @@
 """Generate the high-level within-A report."""
+
 import argparse
 from pathlib import Path
 from analysis.letters_reports import generate_letter
-LETTER='A'
-def generate(results_dir,protocols=(),output_dir=None,spatial_codes_dir=None,profile_path=None): return generate_letter(LETTER,results_dir,protocols,output_dir,spatial_codes_dir,profile_path)
+
+LETTER = "A"
+
+
+def generate(
+    results_dir,
+    protocols=(),
+    output_dir=None,
+    spatial_codes_dir=None,
+    profile_path=None,
+):
+    return generate_letter(
+        LETTER, results_dir, protocols, output_dir, spatial_codes_dir, profile_path
+    )
+
+
 def main():
- p=argparse.ArgumentParser(description='Generate the high-level within-A report.'); p.add_argument('--results-dir',default='/root/results/A'); p.add_argument('--protocol',action='append',default=[]); p.add_argument('--output-dir',default='/workspace/reports'); p.add_argument('--spatial-codes-dir',default=None); a=p.parse_args(); result=generate(a.results_dir,a.protocol,a.output_dir,a.spatial_codes_dir); print(f"wrote {result['path']}")
-if __name__=='__main__': main()
+    p = argparse.ArgumentParser(description="Generate the high-level within-A report.")
+    p.add_argument("--results-dir", default="/root/results/A")
+    p.add_argument("--protocol", action="append", default=[])
+    p.add_argument("--output-dir", default="/workspace/reports")
+    p.add_argument("--spatial-codes-dir", default=None)
+    a = p.parse_args()
+    result = generate(a.results_dir, a.protocol, a.output_dir, a.spatial_codes_dir)
+    print(f"wrote {result['path']}")
+
+
+if __name__ == "__main__":
+    main()

analysis/B_reports.py

@@ -1,9 +1,34 @@
 """Generate the high-level within-B report."""
+
 import argparse
 from pathlib import Path
 from analysis.letters_reports import generate_letter
-LETTER='B'
-def generate(results_dir,protocols=(),output_dir=None,spatial_codes_dir=None,profile_path=None): return generate_letter(LETTER,results_dir,protocols,output_dir,spatial_codes_dir,profile_path)
+
+LETTER = "B"
+
+
+def generate(
+    results_dir,
+    protocols=(),
+    output_dir=None,
+    spatial_codes_dir=None,
+    profile_path=None,
+):
+    return generate_letter(
+        LETTER, results_dir, protocols, output_dir, spatial_codes_dir, profile_path
+    )
+
+
 def main():
- p=argparse.ArgumentParser(description='Generate the high-level within-B report.'); p.add_argument('--results-dir',default='/root/results/B'); p.add_argument('--protocol',action='append',default=[]); p.add_argument('--output-dir',default='/workspace/reports'); p.add_argument('--spatial-codes-dir',default=None); a=p.parse_args(); result=generate(a.results_dir,a.protocol,a.output_dir,a.spatial_codes_dir); print(f"wrote {result['path']}")
-if __name__=='__main__': main()
+    p = argparse.ArgumentParser(description="Generate the high-level within-B report.")
+    p.add_argument("--results-dir", default="/root/results/B")
+    p.add_argument("--protocol", action="append", default=[])
+    p.add_argument("--output-dir", default="/workspace/reports")
+    p.add_argument("--spatial-codes-dir", default=None)
+    a = p.parse_args()
+    result = generate(a.results_dir, a.protocol, a.output_dir, a.spatial_codes_dir)
+    print(f"wrote {result['path']}")
+
+
+if __name__ == "__main__":
+    main()

analysis/C_reports.py

@@ -1,9 +1,34 @@
 """Generate the high-level within-C report."""
+
 import argparse
 from pathlib import Path
 from analysis.letters_reports import generate_letter
-LETTER='C'
-def generate(results_dir,protocols=(),output_dir=None,spatial_codes_dir=None,profile_path=None): return generate_letter(LETTER,results_dir,protocols,output_dir,spatial_codes_dir,profile_path)
+
+LETTER = "C"
+
+
+def generate(
+    results_dir,
+    protocols=(),
+    output_dir=None,
+    spatial_codes_dir=None,
+    profile_path=None,
+):
+    return generate_letter(
+        LETTER, results_dir, protocols, output_dir, spatial_codes_dir, profile_path
+    )
+
+
 def main():
- p=argparse.ArgumentParser(description='Generate the high-level within-C report.'); p.add_argument('--results-dir',default='/root/results/C'); p.add_argument('--protocol',action='append',default=[]); p.add_argument('--output-dir',default='/workspace/reports'); p.add_argument('--spatial-codes-dir',default=None); a=p.parse_args(); result=generate(a.results_dir,a.protocol,a.output_dir,a.spatial_codes_dir); print(f"wrote {result['path']}")
-if __name__=='__main__': main()
+    p = argparse.ArgumentParser(description="Generate the high-level within-C report.")
+    p.add_argument("--results-dir", default="/root/results/C")
+    p.add_argument("--protocol", action="append", default=[])
+    p.add_argument("--output-dir", default="/workspace/reports")
+    p.add_argument("--spatial-codes-dir", default=None)
+    a = p.parse_args()
+    result = generate(a.results_dir, a.protocol, a.output_dir, a.spatial_codes_dir)
+    print(f"wrote {result['path']}")
+
+
+if __name__ == "__main__":
+    main()

analysis/D_reports.py

@@ -1,9 +1,34 @@
 """Generate the high-level within-D report."""
+
 import argparse
 from pathlib import Path
 from analysis.letters_reports import generate_letter
-LETTER='D'
-def generate(results_dir,protocols=(),output_dir=None,spatial_codes_dir=None,profile_path=None): return generate_letter(LETTER,results_dir,protocols,output_dir,spatial_codes_dir,profile_path)
+
+LETTER = "D"
+
+
+def generate(
+    results_dir,
+    protocols=(),
+    output_dir=None,
+    spatial_codes_dir=None,
+    profile_path=None,
+):
+    return generate_letter(
+        LETTER, results_dir, protocols, output_dir, spatial_codes_dir, profile_path
+    )
+
+
 def main():
- p=argparse.ArgumentParser(description='Generate the high-level within-D report.'); p.add_argument('--results-dir',default='/root/results/D'); p.add_argument('--protocol',action='append',default=[]); p.add_argument('--output-dir',default='/workspace/reports'); p.add_argument('--spatial-codes-dir',default=None); a=p.parse_args(); result=generate(a.results_dir,a.protocol,a.output_dir,a.spatial_codes_dir); print(f"wrote {result['path']}")
-if __name__=='__main__': main()
+    p = argparse.ArgumentParser(description="Generate the high-level within-D report.")
+    p.add_argument("--results-dir", default="/root/results/D")
+    p.add_argument("--protocol", action="append", default=[])
+    p.add_argument("--output-dir", default="/workspace/reports")
+    p.add_argument("--spatial-codes-dir", default=None)
+    a = p.parse_args()
+    result = generate(a.results_dir, a.protocol, a.output_dir, a.spatial_codes_dir)
+    print(f"wrote {result['path']}")
+
+
+if __name__ == "__main__":
+    main()

analysis/F_reports.py

@@ -1,9 +1,34 @@
 """Generate the high-level within-F report."""
+
 import argparse
 from pathlib import Path
 from analysis.letters_reports import generate_letter
-LETTER='F'
-def generate(results_dir,protocols=(),output_dir=None,spatial_codes_dir=None,profile_path=None): return generate_letter(LETTER,results_dir,protocols,output_dir,spatial_codes_dir,profile_path)
+
+LETTER = "F"
+
+
+def generate(
+    results_dir,
+    protocols=(),
+    output_dir=None,
+    spatial_codes_dir=None,
+    profile_path=None,
+):
+    return generate_letter(
+        LETTER, results_dir, protocols, output_dir, spatial_codes_dir, profile_path
+    )
+
+
 def main():
- p=argparse.ArgumentParser(description='Generate the high-level within-F report.'); p.add_argument('--results-dir',default='/root/results/F'); p.add_argument('--protocol',action='append',default=[]); p.add_argument('--output-dir',default='/workspace/reports'); p.add_argument('--spatial-codes-dir',default=None); a=p.parse_args(); result=generate(a.results_dir,a.protocol,a.output_dir,a.spatial_codes_dir); print(f"wrote {result['path']}")
-if __name__=='__main__': main()
+    p = argparse.ArgumentParser(description="Generate the high-level within-F report.")
+    p.add_argument("--results-dir", default="/root/results/F")
+    p.add_argument("--protocol", action="append", default=[])
+    p.add_argument("--output-dir", default="/workspace/reports")
+    p.add_argument("--spatial-codes-dir", default=None)
+    a = p.parse_args()
+    result = generate(a.results_dir, a.protocol, a.output_dir, a.spatial_codes_dir)
+    print(f"wrote {result['path']}")
+
+
+if __name__ == "__main__":
+    main()

analysis/letters_reports.py

@@ -5,10 +5,12 @@ lengths, latency, limit/forced rates, spatial-code size for B/C, score relations
 and pairwise deltas on exact question intersections. Stored per-question scores are
 used directly; ``mean_score`` is not the category-weighted official VSI overall.
 """
+
 from __future__ import annotations
 
 import argparse
 import json
+import os
 import math
 import statistics
 import random
@@ -19,11 +21,18 @@ from pathlib import Path
 ROOT = Path(__file__).resolve().parent.parent
 DEFAULT_DIRS = {h: Path("/root/results") / h for h in "ABC"}
 NUMERIC_FIELDS = (
-    "input_token_count", "output_token_count", "reasoning_token_count",
-    "generation_seconds", "forced_input_token_count",
+    "input_token_count",
+    "output_token_count",
+    "reasoning_token_count",
+    "generation_seconds",
+    "forced_input_token_count",
 )
 TEXT_FIELDS = (
-    "answer_given", "answer_raw", "reasoning_text", "full_prompt", "rendered_prompt",
+    "answer_given",
+    "answer_raw",
+    "reasoning_text",
+    "full_prompt",
+    "rendered_prompt",
 )
 
 
@@ -37,7 +46,11 @@ def iter_records(directory):
                 record = json.load(stream)
         except (OSError, json.JSONDecodeError):
             continue
-        if isinstance(record, dict) and "question_id" in record and "condition" in record:
+        if (
+            isinstance(record, dict)
+            and "question_id" in record
+            and "condition" in record
+        ):
             yield record
 
 
@@ -54,14 +67,20 @@ def cell_identity(harness, record):
     protocol = record.get("protocol") or record["condition"].split(":", 1)[0]
     selection = record.get("frame_selection", record.get("input_selection"))
     common = {
-        "harness": harness, "model": record.get("model"), "protocol": protocol,
-        "selection": selection, "frames": str(record.get("frame_count")),
+        "harness": harness,
+        "model": record.get("model"),
+        "protocol": protocol,
+        "selection": selection,
+        "frames": str(record.get("frame_count")),
     }
     if harness in ("B", "C"):
-        common.update({
-            "format": record.get("spatial_code_format"), "depth": record.get("depth"),
-            "tracking": record.get("tracking"),
-        })
+        common.update(
+            {
+                "format": record.get("spatial_code_format"),
+                "depth": record.get("depth"),
+                "tracking": record.get("tracking"),
+            }
+        )
     return tuple(sorted(common.items()))
 
 
@@ -71,7 +90,13 @@ def identity_dict(identity):
 
 def cell_label(identity):
     d = identity_dict(identity)
-    parts = [d["harness"], d.get("model"), d.get("protocol"), d.get("selection"), d.get("frames")]
+    parts = [
+        d["harness"],
+        d.get("model"),
+        d.get("protocol"),
+        d.get("selection"),
+        d.get("frames"),
+    ]
     if d["harness"] in ("B", "C"):
         parts += [d.get("format"), d.get("depth"), d.get("tracking")]
     return "/".join("?" if value is None else str(value) for value in parts)
@@ -86,7 +111,11 @@ def _numbers(records, getter):
     out = []
     for record in records:
         value = getter(record)
-        if isinstance(value, (int, float)) and not isinstance(value, bool) and math.isfinite(value):
+        if (
+            isinstance(value, (int, float))
+            and not isinstance(value, bool)
+            and math.isfinite(value)
+        ):
             out.append(float(value))
     return out
 
@@ -95,30 +124,44 @@ def numeric_summary(values):
     values = sorted(values)
     if not values:
         return None
+
     def percentile(p):
         position = (len(values) - 1) * p
         low, high = math.floor(position), math.ceil(position)
         if low == high:
             return values[low]
         return values[low] + (values[high] - values[low]) * (position - low)
+
     return {
-        "n": len(values), "mean": statistics.mean(values), "median": statistics.median(values),
-        "min": values[0], "p25": percentile(.25), "p75": percentile(.75), "max": values[-1],
+        "n": len(values),
+        "mean": statistics.mean(values),
+        "median": statistics.median(values),
+        "min": values[0],
+        "p25": percentile(0.25),
+        "p75": percentile(0.75),
+        "max": values[-1],
         "stdev": statistics.stdev(values) if len(values) > 1 else 0.0,
     }
 
 
 def pearson(xs, ys):
-    pairs = [(float(x), float(y)) for x, y in zip(xs, ys)
-             if isinstance(x, (int, float)) and isinstance(y, (int, float))
-             and not isinstance(x, bool) and not isinstance(y, bool)
-             and math.isfinite(x) and math.isfinite(y)]
+    pairs = [
+        (float(x), float(y))
+        for x, y in zip(xs, ys)
+        if isinstance(x, (int, float))
+        and isinstance(y, (int, float))
+        and not isinstance(x, bool)
+        and not isinstance(y, bool)
+        and math.isfinite(x)
+        and math.isfinite(y)
+    ]
     if len(pairs) < 2:
         return None
-    x, y = zip(*pairs); mx, my = statistics.mean(x), statistics.mean(y)
+    x, y = zip(*pairs)
+    mx, my = statistics.mean(x), statistics.mean(y)
     dx, dy = [v - mx for v in x], [v - my for v in y]
-    denom = math.sqrt(sum(v*v for v in dx) * sum(v*v for v in dy))
-    return sum(a*b for a, b in zip(dx, dy)) / denom if denom else None
+    denom = math.sqrt(sum(v * v for v in dx) * sum(v * v for v in dy))
+    return sum(a * b for a, b in zip(dx, dy)) / denom if denom else None
 
 
 def spatial_code_bytes(record, cache):
@@ -140,8 +183,11 @@ def breakdown(records, field):
     return {
         name: {
             "count": len(group),
-            "mean_score": numeric_summary(_numbers(group, lambda r: r.get("score")))["mean"]
-                if _numbers(group, lambda r: r.get("score")) else None,
+            "mean_score": (
+                numeric_summary(_numbers(group, lambda r: r.get("score")))["mean"]
+                if _numbers(group, lambda r: r.get("score"))
+                else None
+            ),
             "scenes": len({r.get("scene") for r in group}),
         }
         for name, group in sorted(groups.items())
@@ -150,17 +196,31 @@ def breakdown(records, field):
 
 def summarize_cell(records, code_cache):
     scores = _numbers(records, lambda r: r.get("score"))
-    numeric = {field: numeric_summary(_numbers(records, lambda r, f=field: r.get(f)))
-               for field in NUMERIC_FIELDS}
-    text = {field + "_chars": numeric_summary(_numbers(
-        records, lambda r, f=field: len(r[f]) if isinstance(r.get(f), str) else None
-    )) for field in TEXT_FIELDS}
+    numeric = {
+        field: numeric_summary(_numbers(records, lambda r, f=field: r.get(f)))
+        for field in NUMERIC_FIELDS
+    }
+    text = {
+        field
+        + "_chars": numeric_summary(
+            _numbers(
+                records,
+                lambda r, f=field: len(r[f]) if isinstance(r.get(f), str) else None,
+            )
+        )
+        for field in TEXT_FIELDS
+    }
     code_sizes = _numbers(records, lambda r: spatial_code_bytes(r, code_cache))
     relationships = {}
     measures = {
         **{field: lambda r, f=field: r.get(f) for field in NUMERIC_FIELDS},
-        **{field + "_chars": lambda r, f=field: len(r[f]) if isinstance(r.get(f), str) else None
-           for field in TEXT_FIELDS},
+        **{
+            field
+            + "_chars": lambda r, f=field: (
+                len(r[f]) if isinstance(r.get(f), str) else None
+            )
+            for field in TEXT_FIELDS
+        },
         "spatial_code_bytes": lambda r: spatial_code_bytes(r, code_cache),
     }
     for name, getter in measures.items():
@@ -169,22 +229,42 @@ def summarize_cell(records, code_cache):
             [p[1] for p in pairs], [p[0] for p in pairs]
         )
     return {
-        "questions": len(records), "unique_question_ids": len({r["question_id"] for r in records}),
+        "questions": len(records),
+        "unique_question_ids": len({r["question_id"] for r in records}),
         "scenes": len({r.get("scene") for r in records}),
         "mean_score": statistics.mean(scores) if scores else None,
         "score_distribution": numeric_summary(scores),
         "question_types": breakdown(records, "question_type"),
         "datasets": breakdown(records, "dataset"),
-        "numeric": numeric, "text_lengths": text,
+        "numeric": numeric,
+        "text_lengths": text,
         "rates": {
-            "hit_token_limit": statistics.mean(bool(r.get("hit_token_limit")) for r in records) if records else None,
-            "reasoning_hit_limit": statistics.mean(bool(r.get("reasoning_hit_limit")) for r in records) if records else None,
-            "forced": statistics.mean(bool(r.get("forced")) for r in records) if records else None,
+            "hit_token_limit": (
+                statistics.mean(bool(r.get("hit_token_limit")) for r in records)
+                if records
+                else None
+            ),
+            "reasoning_hit_limit": (
+                statistics.mean(bool(r.get("reasoning_hit_limit")) for r in records)
+                if records
+                else None
+            ),
+            "forced": (
+                statistics.mean(bool(r.get("forced")) for r in records)
+                if records
+                else None
+            ),
             "scored": len(scores) / len(records) if records else None,
         },
         "spatial_codes": {
             "records_with_path": sum(bool(r.get("spatial_code_path")) for r in records),
-            "unique_paths": len({r.get("spatial_code_path") for r in records if r.get("spatial_code_path")}),
+            "unique_paths": len(
+                {
+                    r.get("spatial_code_path")
+                    for r in records
+                    if r.get("spatial_code_path")
+                }
+            ),
             "readable_file_bytes": numeric_summary(code_sizes),
         },
         "relationships": relationships,
@@ -196,51 +276,94 @@ def paired_breakdown(x, y, common, field):
     for qid in common:
         name = str(x[qid].get(field) or y[qid].get(field) or "<missing>")
         groups[name].append(y[qid].get("score") - x[qid].get("score"))
-    return {name: {"count": len(vals), "mean_delta": statistics.mean(vals)}
-            for name, vals in sorted(groups.items()) if vals}
+    return {
+        name: {"count": len(vals), "mean_delta": statistics.mean(vals)}
+        for name, vals in sorted(groups.items())
+        if vals
+    }
 
 
 def _scene_bootstrap(x, y, common, iterations=1000, seed=0):
-    by_scene=defaultdict(list)
+    by_scene = defaultdict(list)
     for qid in common:
         by_scene[str(x[qid].get("scene") or y[qid].get("scene") or "<missing>")].append(
-            y[qid]["score"]-x[qid]["score"]
+            y[qid]["score"] - x[qid]["score"]
         )
     if not by_scene:
-        return {"scenes":0,"iterations":iterations,"ci_low":None,"ci_high":None,"p_value":None}
-    scenes=sorted(by_scene); rng=random.Random(seed); draws=[]
+        return {
+            "scenes": 0,
+            "iterations": iterations,
+            "ci_low": None,
+            "ci_high": None,
+            "p_value": None,
+        }
+    scenes = sorted(by_scene)
+    rng = random.Random(seed)
+    draws = []
     for _ in range(iterations):
-        values=[]
-        for _ in scenes: values.extend(by_scene[rng.choice(scenes)])
+        values = []
+        for _ in scenes:
+            values.extend(by_scene[rng.choice(scenes)])
         draws.append(statistics.mean(values))
-    draws.sort(); low=int(.025*iterations); high=min(iterations-1,int(.975*iterations))
-    below=sum(v<=0 for v in draws)/iterations; above=sum(v>=0 for v in draws)/iterations
-    return {"scenes":len(scenes),"iterations":iterations,"seed":seed,"confidence":.95,
-            "ci_low":draws[low],"ci_high":draws[high],
-            "p_value":max(1/iterations,min(1.0,2*min(below,above)))}
+    draws.sort()
+    low = int(0.025 * iterations)
+    high = min(iterations - 1, int(0.975 * iterations))
+    below = sum(v <= 0 for v in draws) / iterations
+    above = sum(v >= 0 for v in draws) / iterations
+    return {
+        "scenes": len(scenes),
+        "iterations": iterations,
+        "seed": seed,
+        "confidence": 0.95,
+        "ci_low": draws[low],
+        "ci_high": draws[high],
+        "p_value": max(1 / iterations, min(1.0, 2 * min(below, above))),
+    }
+
 
 def paired_report(x_records, y_records):
-    x = {r["question_id"]: r for r in x_records if isinstance(r.get("score"), (int, float))}
-    y = {r["question_id"]: r for r in y_records if isinstance(r.get("score"), (int, float))}
+    x = {
+        r["question_id"]: r
+        for r in x_records
+        if isinstance(r.get("score"), (int, float))
+    }
+    y = {
+        r["question_id"]: r
+        for r in y_records
+        if isinstance(r.get("score"), (int, float))
+    }
     common = sorted(set(x) & set(y))
     deltas = [y[q]["score"] - x[q]["score"] for q in common]
-    solved_x={q for q in common if x[q]["score"]>=1.0}; solved_y={q for q in common if y[q]["score"]>=1.0}
-    union=solved_x|solved_y
+    solved_x = {q for q in common if x[q]["score"] >= 1.0}
+    solved_y = {q for q in common if y[q]["score"] >= 1.0}
+    union = solved_x | solved_y
     telemetry = {}
     for field in NUMERIC_FIELDS:
-        vals = [y[q].get(field) - x[q].get(field) for q in common
-                if isinstance(x[q].get(field), (int, float)) and isinstance(y[q].get(field), (int, float))]
+        vals = [
+            y[q].get(field) - x[q].get(field)
+            for q in common
+            if isinstance(x[q].get(field), (int, float))
+            and isinstance(y[q].get(field), (int, float))
+        ]
         telemetry[field + "_delta"] = numeric_summary(vals)
     return {
-        "common_questions": len(common), "x_full_questions": len(x), "y_full_questions": len(y),
+        "common_questions": len(common),
+        "x_full_questions": len(x),
+        "y_full_questions": len(y),
         "mean_score_delta_y_minus_x": statistics.mean(deltas) if deltas else None,
         "score_delta_distribution": numeric_summary(deltas),
-        "wins_y": sum(d > 0 for d in deltas), "ties": sum(d == 0 for d in deltas),
+        "wins_y": sum(d > 0 for d in deltas),
+        "ties": sum(d == 0 for d in deltas),
         "wins_x": sum(d < 0 for d in deltas),
-        "scene_clustered_bootstrap": _scene_bootstrap(x,y,common),
-        "solved_overlap": {"x":len(solved_x),"y":len(solved_y),"both":len(solved_x&solved_y),
-                           "only_x":len(solved_x-solved_y),"only_y":len(solved_y-solved_x),
-                           "jaccard":len(solved_x&solved_y)/len(union) if union else None},
+        "scene_clustered_bootstrap": _scene_bootstrap(x, y, common),
+        "solved_overlap": {
+            "x": len(solved_x),
+            "y": len(solved_y),
+            "both": len(solved_x & solved_y),
+            "only_x": len(solved_x - solved_y),
+            "only_y": len(solved_y - solved_x),
+            "jaccard": len(solved_x & solved_y) / len(union) if union else None,
+        },
         "by_question_type": paired_breakdown(x, y, common, "question_type"),
         "by_dataset": paired_breakdown(x, y, common, "dataset"),
         "telemetry_deltas": telemetry,
@@ -259,7 +382,8 @@ def analyze(directories=None, protocols=()):
     report = {"cells": {}, "comparison_groups": {}}
     for identity, records in cells.items():
         report["cells"][cell_label(identity)] = {
-            "identity": identity_dict(identity), "summary": summarize_cell(records, code_cache)
+            "identity": identity_dict(identity),
+            "summary": summarize_cell(records, code_cache),
         }
     grouped = defaultdict(list)
     for identity in cells:
@@ -268,11 +392,15 @@ def analyze(directories=None, protocols=()):
         name = "/".join("?" if v is None else str(v) for v in key)
         pairs = {}
         for first, second in combinations(sorted(identities, key=cell_label), 2):
-            pairs[cell_label(first) + " -> " + cell_label(second)] = paired_report(cells[first], cells[second])
+            pairs[cell_label(first) + " -> " + cell_label(second)] = paired_report(
+                cells[first], cells[second]
+            )
         id_sets = [{r["question_id"] for r in cells[i]} for i in identities]
         report["comparison_groups"][name] = {
             "cells": [cell_label(i) for i in identities],
-            "all_cell_common_questions": len(set.intersection(*id_sets)) if id_sets else 0,
+            "all_cell_common_questions": (
+                len(set.intersection(*id_sets)) if id_sets else 0
+            ),
             "pairwise": pairs,
         }
     return report
@@ -282,293 +410,742 @@ def main():
     parser = argparse.ArgumentParser()
     for harness in "abc":
         parser.add_argument(f"--{harness}-results-dir", default=None)
-    parser.add_argument("--protocol", action="append", default=[],
-                        help="repeatable; family 'truncated' includes truncated/<budget>")
     parser.add_argument(
-        "--output-dir", default=str(ROOT / "reports"),
+        "--protocol",
+        action="append",
+        default=[],
+        help="repeatable; family 'truncated' includes truncated/<budget>",
+    )
+    parser.add_argument(
+        "--output-dir",
+        default=str(ROOT / "reports"),
         help="report directory (default: workspace/reports)",
     )
     parser.add_argument(
-        "--json-out", default=None,
+        "--json-out",
+        default=None,
         help="override the JSON report path (default: <output-dir>/comprehensive.json)",
     )
     args = parser.parse_args()
-    dirs = {h.upper(): Path(getattr(args, f"{h}_results_dir") or DEFAULT_DIRS[h.upper()]) for h in "abc"}
+    dirs = {
+        h.upper(): Path(getattr(args, f"{h}_results_dir") or DEFAULT_DIRS[h.upper()])
+        for h in "abc"
+    }
     report = analyze(dirs, args.protocol)
     text = json.dumps(report, indent=1)
-    output_path = Path(args.json_out) if args.json_out else Path(args.output_dir) / "comprehensive.json"
+    output_path = (
+        Path(args.json_out)
+        if args.json_out
+        else Path(args.output_dir) / "comprehensive.json"
+    )
     output_path.parent.mkdir(parents=True, exist_ok=True)
     output_path.write_text(text + "\n", encoding="utf-8")
     print(f"wrote {output_path}")
 
 
-
 # --- Modular profile-driven interface (v2) ---
-from datetime import datetime, timezone
 
 # Built-in, versioned harness profiles.
 PROFILE_VERSION = 1
 BUILTINS = {
- "A":{"letter":"A","kind":"vlm","input_source":"frames","axes":["model","protocol","selection","frames"],"capabilities":["tokens","latency","reasoning","frames"]},
- "B":{"letter":"B","kind":"vlm","input_source":"perceived","axes":["model","protocol","format","depth","tracking","selection","frames"],"capabilities":["tokens","latency","reasoning","spatial_code"]},
- "C":{"letter":"C","kind":"vlm","input_source":"frames_perceived","axes":["model","protocol","format","depth","tracking","selection","frames"],"capabilities":["tokens","latency","reasoning","frames","spatial_code"]},
- "D":{"letter":"D","kind":"vlm","input_source":"ground_truth","axes":["model","protocol","format","selection","frames"],"capabilities":["tokens","latency","reasoning","frames","spatial_code"]},
- "F":{"letter":"F","kind":"solver","input_source":"dynamic","axes":["source","depth","tracking","selection","frames","format","spatial_code_model"],"capabilities":["spatial_code","solver"]},
+    "A": {
+        "letter": "A",
+        "kind": "vlm",
+        "input_source": "frames",
+        "axes": ["model", "protocol", "selection", "frames"],
+        "capabilities": ["tokens", "latency", "reasoning", "frames"],
+    },
+    "B": {
+        "letter": "B",
+        "kind": "vlm",
+        "input_source": "perceived",
+        "axes": [
+            "model",
+            "protocol",
+            "format",
+            "depth",
+            "tracking",
+            "selection",
+            "frames",
+        ],
+        "capabilities": ["tokens", "latency", "reasoning", "spatial_code"],
+    },
+    "C": {
+        "letter": "C",
+        "kind": "vlm",
+        "input_source": "frames_perceived",
+        "axes": [
+            "model",
+            "protocol",
+            "format",
+            "depth",
+            "tracking",
+            "selection",
+            "frames",
+        ],
+        "capabilities": ["tokens", "latency", "reasoning", "frames", "spatial_code"],
+    },
+    "D": {
+        "letter": "D",
+        "kind": "vlm",
+        "input_source": "ground_truth",
+        "axes": ["model", "protocol", "format", "selection", "frames"],
+        "capabilities": ["tokens", "latency", "reasoning", "frames", "spatial_code"],
+    },
+    "F": {
+        "letter": "F",
+        "kind": "solver",
+        "input_source": "dynamic",
+        "axes": [
+            "source",
+            "depth",
+            "tracking",
+            "selection",
+            "frames",
+            "format",
+            "spatial_code_model",
+        ],
+        "capabilities": ["spatial_code", "solver"],
+    },
 }
+
+
 def validate_profile(profile):
- p=dict(profile); letter=str(p.get("letter","")).upper()
- if len(letter)!=1 or not letter.isalpha(): raise ValueError("profile letter must be one alphabetic character")
- if letter=="E": raise ValueError("E is explicitly excluded")
- p["letter"]=letter; p.setdefault("kind","generic"); p.setdefault("input_source","unknown"); p.setdefault("axes",["model","protocol"]); p.setdefault("capabilities",[]); p["profile_version"]=PROFILE_VERSION
- return p
-def load_profile(letter,path=None):
- letter=letter.upper()
- if letter=="E": raise ValueError("E is explicitly excluded")
- if path:
-  p=json.loads(Path(path).read_text()); p.setdefault("letter",letter)
-  if p["letter"].upper()!=letter: raise ValueError(f"profile letter mismatch for {letter}")
-  return validate_profile(p)
- return validate_profile(BUILTINS.get(letter,{"letter":letter,"kind":"generic","input_source":"unknown","axes":["model","protocol","format","depth","tracking","selection","frames"]}))
+    p = dict(profile)
+    letter = str(p.get("letter", "")).upper()
+    if len(letter) != 1 or not letter.isalpha():
+        raise ValueError("profile letter must be one alphabetic character")
+    if letter == "E":
+        raise ValueError("E is explicitly excluded")
+    p["letter"] = letter
+    p.setdefault("kind", "generic")
+    p.setdefault("input_source", "unknown")
+    p.setdefault("axes", ["model", "protocol"])
+    p.setdefault("capabilities", [])
+    p["profile_version"] = PROFILE_VERSION
+    return p
+
+
+def load_profile(letter, path=None):
+    letter = letter.upper()
+    if letter == "E":
+        raise ValueError("E is explicitly excluded")
+    if path:
+        p = json.loads(Path(path).read_text())
+        p.setdefault("letter", letter)
+        if p["letter"].upper() != letter:
+            raise ValueError(f"profile letter mismatch for {letter}")
+        return validate_profile(p)
+    return validate_profile(
+        BUILTINS.get(
+            letter,
+            {
+                "letter": letter,
+                "kind": "generic",
+                "input_source": "unknown",
+                "axes": [
+                    "model",
+                    "protocol",
+                    "format",
+                    "depth",
+                    "tracking",
+                    "selection",
+                    "frames",
+                ],
+            },
+        )
+    )
+
 
 ANALYSIS_VERSION = 2
 
+
 def discover_records(letter, directory, profile, protocols=(), spatial_codes_dir=None):
-    root=Path(directory); records=[]; warnings=[]
-    if not root.is_dir(): return records,[{"code":"missing_directory","path":str(root)}]
+    root = Path(directory)
+    records = []
+    warnings = []
+    if not root.is_dir():
+        return records, [{"code": "missing_directory", "path": str(root)}]
     for path in sorted(root.rglob("*.json")):
-        if path.name.startswith("_"): continue
-        try: record=json.loads(path.read_text(encoding="utf-8"))
-        except (OSError,json.JSONDecodeError) as exc:
-            warnings.append({"code":"unreadable_json","path":str(path),"detail":str(exc)}); continue
-        if not isinstance(record,dict) or record.get("question_id") is None or record.get("score") is None:
-            warnings.append({"code":"not_question_record","path":str(path)}); continue
-        record=dict(record); record["_result_path"]=str(path); record["_relative_path"]=path.relative_to(root).parts
-        record=_normalize_record(letter,record,profile)
-        code_path=record.get("spatial_code_path")
+        if path.name.startswith("_"):
+            continue
+        try:
+            record = json.loads(path.read_text(encoding="utf-8"))
+        except (OSError, json.JSONDecodeError) as exc:
+            warnings.append(
+                {"code": "unreadable_json", "path": str(path), "detail": str(exc)}
+            )
+            continue
+        if (
+            not isinstance(record, dict)
+            or record.get("question_id") is None
+            or record.get("score") is None
+        ):
+            warnings.append({"code": "not_question_record", "path": str(path)})
+            continue
+        record = dict(record)
+        record["_result_path"] = str(path)
+        record["_relative_path"] = path.relative_to(root).parts
+        record = _normalize_record(letter, record, profile)
+        code_path = record.get("spatial_code_path")
         if code_path and not Path(code_path).is_file() and spatial_codes_dir:
-            marker="spatial codes/"
-            suffix=str(code_path).split(marker,1)[-1] if marker in str(code_path) else None
-            candidate=Path(spatial_codes_dir)/suffix if suffix else None
-            if candidate and candidate.is_file(): record["spatial_code_path"]=str(candidate)
-            else: warnings.append({"code":"unresolved_spatial_code_path","path":str(path),"recorded_path":str(code_path)})
-        if letter!="F" and not protocol_selected(record.get("protocol"),protocols): continue
+            marker = "spatial codes/"
+            suffix = (
+                str(code_path).split(marker, 1)[-1]
+                if marker in str(code_path)
+                else None
+            )
+            candidate = Path(spatial_codes_dir) / suffix if suffix else None
+            if candidate and candidate.is_file():
+                record["spatial_code_path"] = str(candidate)
+            else:
+                warnings.append(
+                    {
+                        "code": "unresolved_spatial_code_path",
+                        "path": str(path),
+                        "recorded_path": str(code_path),
+                    }
+                )
+        if letter != "F" and not protocol_selected(record.get("protocol"), protocols):
+            continue
         records.append(record)
-    return records,warnings
-
-def _normalize_record(letter,r,profile):
-    r["format"]=r.get("spatial_code_format") or r.get("format")
-    r["selection"]=r.get("frame_selection") or r.get("input_selection") or r.get("input")
-    r["frames"]=r.get("frame_count") or r.get("number_of_frames")
-    if not r.get("protocol") and r.get("condition") and letter!="F": r["protocol"]=r["condition"].split(":",1)[0]
-    if letter=="F":
-        parts=list(r.get("_relative_path",()))
-        top=parts[0].lower() if parts else ""
-        if top in ("ground truth","ground_truth"):
-            r.update(source="ground_truth",depth=None,tracking=None,selection=None,frames=None)
-            r["format"]=r.get("format") or (parts[1] if len(parts)>1 else None)
+    return records, warnings
+
+
+def _normalize_record(letter, r, profile):
+    r["format"] = r.get("spatial_code_format") or r.get("format")
+    r["selection"] = (
+        r.get("frame_selection") or r.get("input_selection") or r.get("input")
+    )
+    r["frames"] = r.get("frame_count") or r.get("number_of_frames")
+    if not r.get("protocol") and r.get("condition") and letter != "F":
+        r["protocol"] = r["condition"].split(":", 1)[0]
+    if letter == "F":
+        parts = list(r.get("_relative_path", ()))
+        top = parts[0].lower() if parts else ""
+        if top in ("ground truth", "ground_truth"):
+            r.update(
+                source="ground_truth",
+                depth=None,
+                tracking=None,
+                selection=None,
+                frames=None,
+            )
+            r["format"] = r.get("format") or (parts[1] if len(parts) > 1 else None)
         else:
-            r["source"]="perceived"
-            offset=1
-            if top=="perceived": r["depth"]=r.get("depth") or (parts[1] if len(parts)>1 else None); offset=2
-            elif top in ("metric","relative"): r["depth"]=r.get("depth") or top
-            r["tracking"]=r.get("tracking") or (parts[offset] if len(parts)>offset else None)
-            r["selection"]=r.get("selection") or (parts[offset+1] if len(parts)>offset+1 else None)
-            r["frames"]=r.get("frames") or (parts[offset+2] if len(parts)>offset+2 else None)
-            candidate=parts[offset+3] if len(parts)>offset+3 else None
-            if candidate and not candidate.startswith("scene") and len(candidate)!=10: r["format"]=r.get("format") or candidate
-        r["spatial_code_model"]=r.get("spatial_code_model")
-        r["protocol"]=None
+            r["source"] = "perceived"
+            offset = 1
+            if top == "perceived":
+                r["depth"] = r.get("depth") or (parts[1] if len(parts) > 1 else None)
+                offset = 2
+            elif top in ("metric", "relative"):
+                r["depth"] = r.get("depth") or top
+            r["tracking"] = r.get("tracking") or (
+                parts[offset] if len(parts) > offset else None
+            )
+            r["selection"] = r.get("selection") or (
+                parts[offset + 1] if len(parts) > offset + 1 else None
+            )
+            r["frames"] = r.get("frames") or (
+                parts[offset + 2] if len(parts) > offset + 2 else None
+            )
+            candidate = parts[offset + 3] if len(parts) > offset + 3 else None
+            if candidate and not candidate.startswith("scene") and len(candidate) != 10:
+                r["format"] = r.get("format") or candidate
+        r["spatial_code_model"] = r.get("spatial_code_model")
+        r["protocol"] = None
     return r
 
-def modular_identity(letter,record,profile):
-    values={"harness":letter}
-    for axis in profile["axes"]: values[axis]=str(record.get(axis)) if record.get(axis) is not None else None
+
+def modular_identity(letter, record, profile):
+    values = {"harness": letter}
+    for axis in profile["axes"]:
+        values[axis] = str(record.get(axis)) if record.get(axis) is not None else None
     return tuple(sorted(values.items()))
 
+
 def modular_label(identity):
-    d=dict(identity); return "/".join([d.pop("harness")]+[f"{k}={v or '?'}" for k,v in sorted(d.items())])
+    d = dict(identity)
+    return "/".join(
+        [d.pop("harness")] + [f"{k}={v or '?'}" for k, v in sorted(d.items())]
+    )
+
 
-def _controlled(first,second,profile):
-    a,b=dict(first),dict(second); diffs=[axis for axis in profile["axes"] if a.get(axis)!=b.get(axis)]
-    return len(diffs)==1,diffs
+def _controlled(first, second, profile):
+    a, b = dict(first), dict(second)
+    diffs = [axis for axis in profile["axes"] if a.get(axis) != b.get(axis)]
+    return len(diffs) == 1, diffs
 
-def _compatible(a,b,profiles):
-    x,y=dict(a),dict(b); lx,ly=x["harness"],y["harness"]
-    warnings=[]
-    if lx==ly: return False,[],["same_harness"]
+
+def _compatible(a, b, profiles):
+    x, y = dict(a), dict(b)
+    lx, ly = x["harness"], y["harness"]
+    warnings = []
+    if lx == ly:
+        return False, [], ["same_harness"]
     # F source semantics.
-    f=x if lx=="F" else y if ly=="F" else None; other=y if lx=="F" else x
+    f = x if lx == "F" else y if ly == "F" else None
+    other = y if lx == "F" else x
     if f:
-        expected="ground_truth" if other["harness"]=="D" else "perceived" if other["harness"] in ("B","C") else None
-        if expected and f.get("source")!=expected: return False,[],["incompatible_F_source"]
-    shared=[]
-    for axis in ("model","format","depth","tracking","selection","frames"):
-        av,bv=x.get(axis),y.get(axis)
-        if axis=="model" and f: continue
+        expected = (
+            "ground_truth"
+            if other["harness"] == "D"
+            else "perceived" if other["harness"] in ("B", "C") else None
+        )
+        if expected and f.get("source") != expected:
+            return False, [], ["incompatible_F_source"]
+    shared = []
+    for axis in ("model", "format", "depth", "tracking", "selection", "frames"):
+        av, bv = x.get(axis), y.get(axis)
+        if axis == "model" and f:
+            continue
         if av is not None and bv is not None:
-            if av!=bv: return False,[],[f"conflicting_{axis}"]
+            if av != bv:
+                return False, [], [f"conflicting_{axis}"]
             shared.append(axis)
-        else: warnings.append(f"unmatched_{axis}")
+        else:
+            warnings.append(f"unmatched_{axis}")
     if not f and x.get("protocol") is not None and y.get("protocol") is not None:
-        if x["protocol"]!=y["protocol"]: return False,[],["conflicting_protocol"]
+        if x["protocol"] != y["protocol"]:
+            return False, [], ["conflicting_protocol"]
         shared.append("protocol")
-    return True,shared,warnings
-
-def analyze_modular(cells, profiles, protocols=(), requested_pairs=(), spatial_codes_dir=None):
-    all_cells=defaultdict(list); warnings={}; sources={}
-    for letter,directory in cells.items():
-        recs,warns=discover_records(letter,directory,profiles[letter],protocols,spatial_codes_dir); warnings[letter]=warns; sources[letter]=str(directory)
-        for r in recs: all_cells[modular_identity(letter,r,profiles[letter])].append(r)
-    cache={}; per={letter:{"manifest":{"analysis_version":ANALYSIS_VERSION,"profile_version":PROFILE_VERSION,"generated_at":datetime.now(timezone.utc).isoformat(),"letter":letter,"profile":profiles[letter],"source":sources[letter],"protocols":list(protocols)},"cells":{},"within_harness_comparisons":{},"integrity_warnings":warnings[letter]} for letter in cells}
-    for ident,recs in all_cells.items(): per[dict(ident)["harness"]]["cells"][modular_label(ident)]={"identity":dict(ident),"summary":summarize_cell(recs,cache)}
+    return True, shared, warnings
+
+
+def _generated_at():
+    return os.environ.get("VSI_ANALYSIS_GENERATED_AT", "reproducible")
+
+
+def analyze_modular(
+    cells, profiles, protocols=(), requested_pairs=(), spatial_codes_dir=None
+):
+    all_cells = defaultdict(list)
+    warnings = {}
+    sources = {}
+    for letter, directory in cells.items():
+        recs, warns = discover_records(
+            letter, directory, profiles[letter], protocols, spatial_codes_dir
+        )
+        warnings[letter] = warns
+        sources[letter] = str(directory)
+        for r in recs:
+            all_cells[modular_identity(letter, r, profiles[letter])].append(r)
+    cache = {}
+    per = {
+        letter: {
+            "manifest": {
+                "analysis_version": ANALYSIS_VERSION,
+                "profile_version": PROFILE_VERSION,
+                "generated_at": _generated_at(),
+                "letter": letter,
+                "profile": profiles[letter],
+                "source": sources[letter],
+                "protocols": list(protocols),
+            },
+            "cells": {},
+            "within_harness_comparisons": {},
+            "integrity_warnings": warnings[letter],
+        }
+        for letter in cells
+    }
+    for ident, recs in all_cells.items():
+        per[dict(ident)["harness"]]["cells"][modular_label(ident)] = {
+            "identity": dict(ident),
+            "summary": summarize_cell(recs, cache),
+        }
     for letter in cells:
-        ids=[i for i in all_cells if dict(i)["harness"]==letter]
-        for a,b in combinations(ids,2):
-            ok,diffs=_controlled(a,b,profiles[letter])
-            if ok: per[letter]["within_harness_comparisons"][modular_label(a)+" -> "+modular_label(b)]={"varied_axis":diffs[0],**paired_report(all_cells[a],all_cells[b])}
-    allowed={tuple(sorted(p)) for p in requested_pairs}
-    cross={}
-    ids=list(all_cells)
-    for a,b in combinations(ids,2):
-        letters=tuple(sorted((dict(a)["harness"],dict(b)["harness"])))
-        if letters[0]==letters[1] or (allowed and letters not in allowed): continue
-        ok,shared,warns=_compatible(a,b,profiles)
-        if ok: cross[modular_label(a)+" -> "+modular_label(b)]={"letters":letters,"shared_axes":shared,"alignment_warnings":warns,**paired_report(all_cells[a],all_cells[b])}
-    manifest={"analysis_version":ANALYSIS_VERSION,"profile_version":PROFILE_VERSION,"generated_at":datetime.now(timezone.utc).isoformat(),"letters":sorted(cells),"sources":sources,"protocols":list(protocols),"requested_pairs":[":".join(p) for p in requested_pairs]}
-    return per,{"manifest":manifest,"cross_harness_comparisons":cross,"harness_summaries":{l:{"cell_count":len(per[l]["cells"]),"warning_count":len(per[l]["integrity_warnings"])} for l in per}}
-
-def parse_assignment(value,option):
-    if "=" not in value: raise argparse.ArgumentTypeError(f"{option} must be LETTER=PATH")
-    letter,path=value.split("=",1); letter=letter.upper()
-    if len(letter)!=1 or not letter.isalpha() or letter=="E": raise argparse.ArgumentTypeError("letter must be one alphabetic character other than E")
-    return letter,path
-
-def export_reports(per,combined,output_dir):
-    out=Path(output_dir); out.mkdir(parents=True,exist_ok=True); paths=[]
-    for letter,report in sorted(per.items()):
-        path=out/f"{letter}_report.json"; path.write_text(json.dumps(report,indent=1)+"\n"); paths.append(path)
+        ids = [i for i in all_cells if dict(i)["harness"] == letter]
+        for a, b in combinations(ids, 2):
+            ok, diffs = _controlled(a, b, profiles[letter])
+            if ok:
+                per[letter]["within_harness_comparisons"][
+                    modular_label(a) + " -> " + modular_label(b)
+                ] = {
+                    "varied_axis": diffs[0],
+                    **paired_report(all_cells[a], all_cells[b]),
+                }
+    allowed = {tuple(sorted(p)) for p in requested_pairs}
+    cross = {}
+    ids = list(all_cells)
+    for a, b in combinations(ids, 2):
+        letters = tuple(sorted((dict(a)["harness"], dict(b)["harness"])))
+        if letters[0] == letters[1] or (allowed and letters not in allowed):
+            continue
+        ok, shared, warns = _compatible(a, b, profiles)
+        if ok:
+            cross[modular_label(a) + " -> " + modular_label(b)] = {
+                "letters": letters,
+                "shared_axes": shared,
+                "alignment_warnings": warns,
+                **paired_report(all_cells[a], all_cells[b]),
+            }
+    manifest = {
+        "analysis_version": ANALYSIS_VERSION,
+        "profile_version": PROFILE_VERSION,
+        "generated_at": _generated_at(),
+        "letters": sorted(cells),
+        "sources": sources,
+        "protocols": list(protocols),
+        "requested_pairs": [":".join(p) for p in requested_pairs],
+    }
+    return per, {
+        "manifest": manifest,
+        "cross_harness_comparisons": cross,
+        "harness_summaries": {
+            l: {
+                "cell_count": len(per[l]["cells"]),
+                "warning_count": len(per[l]["integrity_warnings"]),
+            }
+            for l in per
+        },
+    }
+
+
+def parse_assignment(value, option):
+    if "=" not in value:
+        raise argparse.ArgumentTypeError(f"{option} must be LETTER=PATH")
+    letter, path = value.split("=", 1)
+    letter = letter.upper()
+    if len(letter) != 1 or not letter.isalpha() or letter == "E":
+        raise argparse.ArgumentTypeError(
+            "letter must be one alphabetic character other than E"
+        )
+    return letter, path
+
+
+def export_reports(per, combined, output_dir):
+    out = Path(output_dir)
+    out.mkdir(parents=True, exist_ok=True)
+    paths = []
+    for letter, report in sorted(per.items()):
+        path = out / f"{letter}_report.json"
+        path.write_text(json.dumps(report, indent=1) + "\n")
+        paths.append(path)
     if len(per) > 1:
-        name="".join(sorted(per))+"_report.json"
-        path=out/name
-        path.write_text(json.dumps(combined,indent=1)+"\n")
+        name = "".join(sorted(per)) + "_report.json"
+        path = out / name
+        path.write_text(json.dumps(combined, indent=1) + "\n")
         paths.append(path)
     return paths
 
+
 def main():
-    parser=argparse.ArgumentParser()
-    parser.add_argument("--cell",action="append",default=[],help="repeatable LETTER=PATH; E is excluded")
-    parser.add_argument("--profile",action="append",default=[],help="optional LETTER=profile.json")
-    parser.add_argument("--compare",action="append",default=[],help="optional pair restriction, e.g. A:B")
-    parser.add_argument("--protocol",action="append",default=[],help="repeatable; truncated includes truncated/<budget>")
-    parser.add_argument("--output-dir",default=str(ROOT/"reports"))
-    parser.add_argument("--spatial-codes-dir",default=None,help="optional local root used to rebase stale recorded code paths")
-    for h in "abc": parser.add_argument(f"--{h}-results-dir",default=None,help=argparse.SUPPRESS)
-    args=parser.parse_args(); cells=dict(parse_assignment(v,"--cell") for v in args.cell)
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "--cell",
+        action="append",
+        default=[],
+        help="repeatable LETTER=PATH; E is excluded",
+    )
+    parser.add_argument(
+        "--profile", action="append", default=[], help="optional LETTER=profile.json"
+    )
+    parser.add_argument(
+        "--compare",
+        action="append",
+        default=[],
+        help="optional pair restriction, e.g. A:B",
+    )
+    parser.add_argument(
+        "--protocol",
+        action="append",
+        default=[],
+        help="repeatable; truncated includes truncated/<budget>",
+    )
+    parser.add_argument("--output-dir", default=str(ROOT / "reports"))
+    parser.add_argument(
+        "--spatial-codes-dir",
+        default=None,
+        help="optional local root used to rebase stale recorded code paths",
+    )
     for h in "abc":
-        value=getattr(args,f"{h}_results_dir")
-        if value: cells[h.upper()]=value
-    if not cells: parser.error("provide at least one --cell LETTER=PATH")
-    profile_paths=dict(parse_assignment(v,"--profile") for v in args.profile)
-    profiles={letter:load_profile(letter,profile_paths.get(letter)) for letter in cells}
-    pairs=[]
+        parser.add_argument(f"--{h}-results-dir", default=None, help=argparse.SUPPRESS)
+    args = parser.parse_args()
+    cells = dict(parse_assignment(v, "--cell") for v in args.cell)
+    for h in "abc":
+        value = getattr(args, f"{h}_results_dir")
+        if value:
+            cells[h.upper()] = value
+    if not cells:
+        parser.error("provide at least one --cell LETTER=PATH")
+    profile_paths = dict(parse_assignment(v, "--profile") for v in args.profile)
+    profiles = {
+        letter: load_profile(letter, profile_paths.get(letter)) for letter in cells
+    }
+    pairs = []
     for value in args.compare:
-        bits=[x.upper() for x in value.split(":")]
-        if len(bits)!=2 or any(x not in cells for x in bits): parser.error(f"invalid --compare {value}")
+        bits = [x.upper() for x in value.split(":")]
+        if len(bits) != 2 or any(x not in cells for x in bits):
+            parser.error(f"invalid --compare {value}")
         pairs.append(tuple(bits))
-    per,combined=analyze_modular(cells,profiles,args.protocol,pairs,args.spatial_codes_dir)
-    for path in export_reports(per,combined,args.output_dir): print(f"wrote {path}")
+    per, combined = analyze_modular(
+        cells, profiles, args.protocol, pairs, args.spatial_codes_dir
+    )
+    for path in export_reports(per, combined, args.output_dir):
+        print(f"wrote {path}")
 
 
 # Consolidated analysis helpers formerly split across stats/solvability/sufficiency/audits.
 def _official_scores(records):
- records=list(records)
- try:
-  import importlib.util, os
-  path=os.environ.get("HARNESS_OFFICIAL_EVAL","/root/data/thinking-in-space/lmms_eval/tasks/vsibench/utils.py")
-  spec=importlib.util.spec_from_file_location("analysis_vsi_official_eval",path)
-  module=importlib.util.module_from_spec(spec); spec.loader.exec_module(module)
-  docs=[{"question_type":r["question_type"],"ground_truth":r.get("answer_expected"),r["metric"]:r["score"]} for r in records]
-  return module.vsibench_aggregate_results(docs)
- except (OSError,ImportError,AttributeError,TypeError):
-  scores=[r.get("score") for r in records if isinstance(r.get("score"),(int,float))]
-  return {"overall":statistics.mean(scores)*100 if scores else None,"scoring_mode":"stored_per_question_mean_fallback"}
+    records = list(records)
+    try:
+        import importlib.util, os
+
+        path = os.environ.get(
+            "HARNESS_OFFICIAL_EVAL",
+            "/root/data/thinking-in-space/lmms_eval/tasks/vsibench/utils.py",
+        )
+        spec = importlib.util.spec_from_file_location(
+            "analysis_vsi_official_eval", path
+        )
+        module = importlib.util.module_from_spec(spec)
+        spec.loader.exec_module(module)
+        docs = [
+            {
+                "question_type": r["question_type"],
+                "ground_truth": r.get("answer_expected"),
+                r["metric"]: r["score"],
+            }
+            for r in records
+        ]
+        return module.vsibench_aggregate_results(docs)
+    except (OSError, ImportError, AttributeError, TypeError):
+        scores = [
+            r.get("score") for r in records if isinstance(r.get("score"), (int, float))
+        ]
+        return {
+            "overall": statistics.mean(scores) * 100 if scores else None,
+            "scoring_mode": "stored_per_question_mean_fallback",
+        }
+
 
 def holm_bonferroni(p_values):
- ordered=sorted(p_values.items(),key=lambda item:item[1]); total=len(ordered); out={}; running=0.0
- for rank,(name,p) in enumerate(ordered):
-  running=max(running,min(1.0,(total-rank)*p)); out[name]=running
- return out
-
-def solved_set_overlap(cells,threshold=1.0):
- maps={name:{r["question_id"]:r.get("score") for r in records} for name,records in cells.items()}
- common=set.intersection(*(set(m) for m in maps.values())) if maps else set(); solved={n:{q for q in common if v[q] is not None and v[q]>=threshold} for n,v in maps.items()}
- pairs={}
- for a,b in combinations(sorted(solved),2):
-  union=solved[a]|solved[b]; pairs[f"{a}|{b}"]={"jaccard":len(solved[a]&solved[b])/len(union) if union else None,"both":len(solved[a]&solved[b]),f"only_{a}":len(solved[a]-solved[b]),f"only_{b}":len(solved[b]-solved[a])}
- return {"questions":len(common),"solved":{n:len(v) for n,v in solved.items()},"pairs":pairs}
-
-def sufficiency_decomposition(vlm_records,solver_records,threshold=1.0,exclude=()):
- cert={r["question_id"]:r.get("score") is not None and r["score"]>=threshold for r in solver_records}; buckets={"certified":[],"uncertified":[]}
- for r in vlm_records:
-  if r.get("question_type") in set(exclude) or r.get("question_id") not in cert: continue
-  buckets["certified" if cert[r["question_id"]] else "uncertified"].append(r.get("score"))
- def summary(vals):
-  valid=[v for v in vals if isinstance(v,(int,float))]; correct=sum(v>=threshold for v in valid)
-  return {"count":len(vals),"mean_score":statistics.mean(valid) if valid else None,"vlm_correct":correct,"vlm_wrong":len(vals)-correct}
- return {name:summary(vals) for name,vals in buckets.items()}
+    ordered = sorted(p_values.items(), key=lambda item: item[1])
+    total = len(ordered)
+    out = {}
+    running = 0.0
+    for rank, (name, p) in enumerate(ordered):
+        running = max(running, min(1.0, (total - rank) * p))
+        out[name] = running
+    return out
+
+
+def solved_set_overlap(cells, threshold=1.0):
+    maps = {
+        name: {r["question_id"]: r.get("score") for r in records}
+        for name, records in cells.items()
+    }
+    common = set.intersection(*(set(m) for m in maps.values())) if maps else set()
+    solved = {
+        n: {q for q in common if v[q] is not None and v[q] >= threshold}
+        for n, v in maps.items()
+    }
+    pairs = {}
+    for a, b in combinations(sorted(solved), 2):
+        union = solved[a] | solved[b]
+        pairs[f"{a}|{b}"] = {
+            "jaccard": len(solved[a] & solved[b]) / len(union) if union else None,
+            "both": len(solved[a] & solved[b]),
+            f"only_{a}": len(solved[a] - solved[b]),
+            f"only_{b}": len(solved[b] - solved[a]),
+        }
+    return {
+        "questions": len(common),
+        "solved": {n: len(v) for n, v in solved.items()},
+        "pairs": pairs,
+    }
+
+
+def sufficiency_decomposition(vlm_records, solver_records, threshold=1.0, exclude=()):
+    cert = {
+        r["question_id"]: r.get("score") is not None and r["score"] >= threshold
+        for r in solver_records
+    }
+    buckets = {"certified": [], "uncertified": []}
+    for r in vlm_records:
+        if r.get("question_type") in set(exclude) or r.get("question_id") not in cert:
+            continue
+        buckets["certified" if cert[r["question_id"]] else "uncertified"].append(
+            r.get("score")
+        )
+
+    def summary(vals):
+        valid = [v for v in vals if isinstance(v, (int, float))]
+        correct = sum(v >= threshold for v in valid)
+        return {
+            "count": len(vals),
+            "mean_score": statistics.mean(valid) if valid else None,
+            "vlm_correct": correct,
+            "vlm_wrong": len(vals) - correct,
+        }
+
+    return {name: summary(vals) for name, vals in buckets.items()}
+
 
 def solver_depth_table(records):
- try: from symbolic import adapters,solver
- except ImportError: return {"status":"unavailable","reason":"symbolic solver imports unavailable"}
- cache={}; buckets=defaultdict(list)
- for r in records:
-  path=r.get("spatial_code_path")
-  if not path: continue
-  try:
-   if path not in cache: cache[path]=adapters.adapt_spatial_code(json.loads(Path(path).read_text()))
-   solver.answer(r["question_type"],r["question"],r.get("options"),cache[path]); depth=solver.LAST_ANSWER_OPS.get("total")
-  except (OSError,KeyError,ValueError): continue
-  if depth is not None and isinstance(r.get("score"),(int,float)): buckets["0-2" if depth<=2 else "3-8" if depth<=8 else "9-20" if depth<=20 else "21-inf"].append((depth,r["score"]))
- return {k:{"count":len(v),"mean_depth":statistics.mean(x for x,_ in v),"mean_score":statistics.mean(y for _,y in v)} for k,v in buckets.items()}
-
-_NUMBER_RE=__import__('re').compile(r"[-+]?\d+(?:\.\d+)?")
-def deterministic_cot_audit(records,tolerance=.01):
- def nums(value): return [float(x) for x in _NUMBER_RE.findall(str(value or ''))]
- audits=[]; cache={}
- for r in records:
-  reasoning=r.get("reasoning_text"); path=r.get("spatial_code_path")
-  if not reasoning or not path: continue
-  try:
-   if path not in cache: cache[path]=nums(Path(path).read_text())
-  except OSError: continue
-  sources=cache[path]+nums(r.get("question"))+sum((nums(x) for x in r.get("options") or []),[]); cited=nums(reasoning)
-  fabricated=[v for v in cited if not (abs(v)<=12 and v.is_integer()) and not any(abs(v-x)<=tolerance*max(1,abs(x)) for x in sources)]
-  audits.append({"question_id":r["question_id"],"score":r.get("score"),"cited":len(cited),"fabricated":len(fabricated)})
- wrong=[a for a in audits if a["score"] is not None and a["score"]<1]; bad=[a for a in wrong if a["fabricated"]]
- return {"audited":len(audits),"wrong":len(wrong),"wrong_with_fabrication":len(bad),"fabrication_share_of_wrong":len(bad)/len(wrong) if wrong else None}
-
-def generate_letter(letter,results_dir,protocols=(),output_dir=None,spatial_codes_dir=None,profile_path=None):
- letter=letter.upper(); profile=load_profile(letter,profile_path)
- per,combined=analyze_modular({letter:Path(results_dir)},{letter:profile},protocols,(),spatial_codes_dir)
- paths=export_reports(per,combined,output_dir or ROOT/'reports')
- return {"report":per[letter],"path":paths[0]}
-
-def generate(cells,protocols=(),comparisons=(),output_dir=None,profile_paths=None,spatial_codes_dir=None):
- normalized={str(k).upper():Path(v) for k,v in cells.items()}
- if 'E' in normalized: raise ValueError('E is explicitly excluded')
- profile_paths={str(k).upper():v for k,v in (profile_paths or {}).items()}; profiles={l:load_profile(l,profile_paths.get(l)) for l in normalized}; pairs=[]
- for pair in comparisons:
-  pair=tuple(x.upper() for x in (pair.split(':') if isinstance(pair,str) else pair))
-  if len(pair)!=2 or any(x not in normalized for x in pair): raise ValueError(f'invalid comparison {pair}')
-  pairs.append(pair)
- per,combined=analyze_modular(normalized,profiles,protocols,pairs,spatial_codes_dir); paths=export_reports(per,combined,output_dir or ROOT/'reports')
- return {"letter_reports":per,"combined_report":combined,"paths":paths}
+    try:
+        from symbolic import adapters, solver
+    except ImportError:
+        return {
+            "status": "unavailable",
+            "reason": "symbolic solver imports unavailable",
+        }
+    cache = {}
+    buckets = defaultdict(list)
+    for r in records:
+        path = r.get("spatial_code_path")
+        if not path:
+            continue
+        try:
+            if path not in cache:
+                cache[path] = adapters.adapt_spatial_code(
+                    json.loads(Path(path).read_text())
+                )
+            solver.answer(
+                r["question_type"], r["question"], r.get("options"), cache[path]
+            )
+            depth = solver.LAST_ANSWER_OPS.get("total")
+        except (OSError, KeyError, ValueError):
+            continue
+        if depth is not None and isinstance(r.get("score"), (int, float)):
+            buckets[
+                (
+                    "0-2"
+                    if depth <= 2
+                    else "3-8" if depth <= 8 else "9-20" if depth <= 20 else "21-inf"
+                )
+            ].append((depth, r["score"]))
+    return {
+        k: {
+            "count": len(v),
+            "mean_depth": statistics.mean(x for x, _ in v),
+            "mean_score": statistics.mean(y for _, y in v),
+        }
+        for k, v in buckets.items()
+    }
+
+
+_NUMBER_RE = __import__("re").compile(r"[-+]?\d+(?:\.\d+)?")
+
+
+def deterministic_cot_audit(records, tolerance=0.01):
+    def nums(value):
+        return [float(x) for x in _NUMBER_RE.findall(str(value or ""))]
+
+    audits = []
+    cache = {}
+    for r in records:
+        reasoning = r.get("reasoning_text")
+        path = r.get("spatial_code_path")
+        if not reasoning or not path:
+            continue
+        try:
+            if path not in cache:
+                cache[path] = nums(Path(path).read_text())
+        except OSError:
+            continue
+        sources = (
+            cache[path]
+            + nums(r.get("question"))
+            + sum((nums(x) for x in r.get("options") or []), [])
+        )
+        cited = nums(reasoning)
+        fabricated = [
+            v
+            for v in cited
+            if not (abs(v) <= 12 and v.is_integer())
+            and not any(abs(v - x) <= tolerance * max(1, abs(x)) for x in sources)
+        ]
+        audits.append(
+            {
+                "question_id": r["question_id"],
+                "score": r.get("score"),
+                "cited": len(cited),
+                "fabricated": len(fabricated),
+            }
+        )
+    wrong = [a for a in audits if a["score"] is not None and a["score"] < 1]
+    bad = [a for a in wrong if a["fabricated"]]
+    return {
+        "audited": len(audits),
+        "wrong": len(wrong),
+        "wrong_with_fabrication": len(bad),
+        "fabrication_share_of_wrong": len(bad) / len(wrong) if wrong else None,
+    }
+
+
+def generate_letter(
+    letter,
+    results_dir,
+    protocols=(),
+    output_dir=None,
+    spatial_codes_dir=None,
+    profile_path=None,
+):
+    letter = letter.upper()
+    profile = load_profile(letter, profile_path)
+    per, combined = analyze_modular(
+        {letter: Path(results_dir)}, {letter: profile}, protocols, (), spatial_codes_dir
+    )
+    paths = export_reports(per, combined, output_dir or ROOT / "reports")
+    return {"report": per[letter], "path": paths[0]}
+
+
+def generate(
+    cells,
+    protocols=(),
+    comparisons=(),
+    output_dir=None,
+    profile_paths=None,
+    spatial_codes_dir=None,
+):
+    normalized = {str(k).upper(): Path(v) for k, v in cells.items()}
+    if "E" in normalized:
+        raise ValueError("E is explicitly excluded")
+    profile_paths = {str(k).upper(): v for k, v in (profile_paths or {}).items()}
+    profiles = {l: load_profile(l, profile_paths.get(l)) for l in normalized}
+    pairs = []
+    for pair in comparisons:
+        pair = tuple(
+            x.upper() for x in (pair.split(":") if isinstance(pair, str) else pair)
+        )
+        if len(pair) != 2 or any(x not in normalized for x in pair):
+            raise ValueError(f"invalid comparison {pair}")
+        pairs.append(pair)
+    per, combined = analyze_modular(
+        normalized, profiles, protocols, pairs, spatial_codes_dir
+    )
+    paths = export_reports(per, combined, output_dir or ROOT / "reports")
+    return {"letter_reports": per, "combined_report": combined, "paths": paths}
+
 
 def main():
- parser=argparse.ArgumentParser(description='Generate arbitrary mixed letter reports; E is excluded.')
- parser.add_argument('--cell',action='append',required=True); parser.add_argument('--profile',action='append',default=[]); parser.add_argument('--compare',action='append',default=[]); parser.add_argument('--protocol',action='append',default=[]); parser.add_argument('--output-dir',default=str(ROOT/'reports')); parser.add_argument('--spatial-codes-dir',default=None)
- args=parser.parse_args(); cells=dict(parse_assignment(v,'--cell') for v in args.cell); profiles=dict(parse_assignment(v,'--profile') for v in args.profile)
- try: result=generate(cells,args.protocol,args.compare,args.output_dir,profiles,args.spatial_codes_dir)
- except ValueError as exc: parser.error(str(exc))
- for path in result['paths']: print(f'wrote {path}')
-if __name__=='__main__': main()
+    parser = argparse.ArgumentParser(
+        description="Generate arbitrary mixed letter reports; E is excluded."
+    )
+    parser.add_argument("--cell", action="append", required=True)
+    parser.add_argument("--profile", action="append", default=[])
+    parser.add_argument("--compare", action="append", default=[])
+    parser.add_argument("--protocol", action="append", default=[])
+    parser.add_argument("--output-dir", default=str(ROOT / "reports"))
+    parser.add_argument("--spatial-codes-dir", default=None)
+    args = parser.parse_args()
+    cells = dict(parse_assignment(v, "--cell") for v in args.cell)
+    profiles = dict(parse_assignment(v, "--profile") for v in args.profile)
+    try:
+        result = generate(
+            cells,
+            args.protocol,
+            args.compare,
+            args.output_dir,
+            profiles,
+            args.spatial_codes_dir,
+        )
+    except ValueError as exc:
+        parser.error(str(exc))
+    for path in result["paths"]:
+        print(f"wrote {path}")
+
+
+if __name__ == "__main__":
+    main()

backup.py

@@ -1,58 +1,9 @@
 #!/usr/bin/env python3
-"""Back up this workspace -- results, spatial codes, AND the code/setup itself -- to a
-Hugging Face dataset repo.
-
-Every "target" maps to one or more self-contained local paths (directories or single
-files), each uploaded with the exact same relative path it has in the workspace
-(results/A/... stays results/A/... in the repo, backup.py stays backup.py). That's what
-makes this safe to call repeatedly, once per plan, without ever overwriting or deleting
-anything outside the target you asked for:
-
-- Each target's --allow-patterns scope is disjoint from every other target's (results/A
-  vs results/B vs ... vs "data/spatial codes" vs "code"'s own paths), so backing up B can
-  never touch what A already uploaded.
-- huggingface_hub's upload_large_folder() only ever adds or updates the files it's given
-  -- it never deletes anything else already in the repo (no delete_patterns is passed
-  here, ever), so re-running the same target later (more scenes finished, --rebuild
-  reran a config, source files edited) just adds/updates those files' remote copies.
-- "symbolic" covers BOTH results/symbolic/<depth>/... (production) and
-  results/symbolic/ground truth/... in one call, since the latter is already nested
-  under the former; "spatial-codes" likewise covers both encoder-perceived
-  ("data/spatial codes/<model>/...") and ground-truth ("data/spatial codes/ground
-  truth/...") codes in one call, satisfying "upload after the regenerate spatial code
-  parts" without a separate target for it.
-- "code" covers every source directory (harness, symbolic, analysis, corruption,
-  encoder, inference, tests) plus the top-level README.md, backup.py, and setup.sh -- everything
-  needed to reproduce or re-run the experiment, not just its output. Deliberately
-  excludes data/ and results/ (covered by their own targets already) and experiments/
-  (its own target below, not part of the reproducible pipeline this "code" target
-  covers).
-- "experiments" covers the separate, concluded geometry-formula-tuning track (its own
-  code, caches, and results all live under one experiments/ tree) -- kept as its own
-  target rather than folded into "code" since it's large and conceptually separate from
-  the main A/B/C/D/symbolic pipeline.
-
-Usage:
-    python backup.py --repo-id <you>/<repo> --target A
-    python backup.py --repo-id <you>/<repo> --target all
-    HF_TOKEN=hf_xxx python backup.py --repo-id <you>/<repo> --target spatial-codes
-    python backup.py --repo-id <you>/<repo> --target D --dry-run   # no token/network needed
-    python backup.py                                                # fully interactive
-
-Run after each plan finishes:
-    Plan A done            -> python backup.py --repo-id <you>/<repo> --target A
-    spatial codes regen'd  -> python backup.py --repo-id <you>/<repo> --target spatial-codes
-    Plan B done            -> python backup.py --repo-id <you>/<repo> --target B
-    Plan C done            -> python backup.py --repo-id <you>/<repo> --target C
-    Plan D done            -> python backup.py --repo-id <you>/<repo> --target D
-    blind floor (E) done   -> python backup.py --repo-id <you>/<repo> --target E
-    symbolic runs done     -> python backup.py --repo-id <you>/<repo> --target symbolic
-    code/setup changed     -> python backup.py --repo-id <you>/<repo> --target code
-    experiments/ changed   -> python backup.py --repo-id <you>/<repo> --target experiments
-
---repo-id, --target, and the Hugging Face token are all prompted for interactively
-(the token hidden) when not supplied via flag or $HF_TOKEN -- no separate shell wrapper
-needed to get that interactive setup.sh-style experience.
+"""Upload selected workspace artifacts to a Hugging Face dataset repository.
+
+The script is intentionally conservative: dry-run mode never imports
+``huggingface_hub``, empty targets are skipped, and result targets are resolved from
+``/root`` while source/code targets are resolved from ``/workspace``.
 """
 
 from __future__ import annotations
@@ -60,163 +11,139 @@ from __future__ import annotations
 import argparse
 import getpass
 import os
-import sys
 from pathlib import Path
 
-WORKSPACE_ROOT = Path(__file__).resolve().parent
+WORKSPACE_ROOT = Path(os.environ.get("VSI_WORKSPACE_ROOT", "/workspace"))
+RESULTS_HOST_ROOT = Path(os.environ.get("VSI_RESULTS_HOST_ROOT", "/root"))
+DEFAULT_REPO = os.environ.get("VSI_BACKUP_REPO", "AntonioJun/workspace")
 
-# name -> list of paths (directories or single files, relative to WORKSPACE_ROOT)
 TARGETS = {
-    "A": ["results/A"],
-    # results/B covers the main (512-budget) condition AND the budget dose-response
-    # arm (16/32/64/128/256): the reasoning budget IS the extended protocol's
-    # path segment and of every record's condition string, so the arm's runs are
-    # path-separated and group-separated without needing their own target.
-    # The flat-distance-table arm is listed alongside its own plan rather than as a
-    # separate target: --flat-distance-table has no path segment of its own (unlike the
-    # protocol/format/depth/tracking/input/frames axes), so the arm is isolated only by
-    # the explicit --results-dir it is always run with -- "results/<plan>-flat-table".
-    # That path sits BESIDE results/<plan>, not under it, so a plain results/B sweep
-    # would silently miss it. Folding it in here keeps "back up plan B when B finishes"
-    # a single command that cannot leave the arm behind, while the two patterns stay
-    # disjoint from each other and from every other target.
-    "B": ["results/B", "results/B-flat-table"],
-    "C": ["results/C", "results/C-flat-table"],
-    "D": ["results/D", "results/D-flat-table"],
-    "E": ["results/E"],
-    "corruption": ["results/corruption"],
-    "calibration": ["results/calibration"],
-    "symbolic": ["results/symbolic"],
-    "spatial-codes": ["data/spatial codes"],
     "code": [
         "README.md",
-        "backup.py",
         "setup.sh",
-        "harness",
-        "symbolic",
+        "backup.py",
         "analysis",
-        "corruption",
         "calibration",
+        "corruption",
         "encoder",
+        "harness",
         "inference",
+        "symbolic",
         "tests",
+        "selective_frame_counts.csv",
     ],
-    "experiments": ["experiments"],
+    "reports": ["reports"],
+    "spatial-codes": ["data/spatial codes", "bundles/spatial-codes.tar.gz"],
+    "caches": ["data/caches"],
+    "A": ["results/A"],
+    "B": ["results/B"],
+    "C": ["results/C"],
+    "D": ["results/D"],
+    "E": ["results/E"],
+    "F": ["results/F"],
+    "calibration": ["results/calibration"],
+    "corruption": ["results/corruption"],
 }
 
 
 def _resolve_targets(target):
     if target == "all":
         return list(TARGETS)
-    if target in TARGETS:
-        return [target]
-    raise ValueError(f"unknown target {target!r}; expected one of {list(TARGETS) + ['all']}")
+    requested = [part.strip() for part in str(target).split(",") if part.strip()]
+    unknown = [name for name in requested if name not in TARGETS]
+    if unknown:
+        raise ValueError(f"unknown target(s): {', '.join(unknown)}")
+    return requested
+
+
+def _local_path(relative):
+    relative = str(relative).lstrip("/")
+    root = RESULTS_HOST_ROOT if relative.startswith("results/") else WORKSPACE_ROOT
+    return root / relative
 
 
-def _has_content(local_path):
-    """True if this path is a real file, or a directory containing at least one file."""
-    if local_path.is_file():
+def _has_files(path):
+    path = Path(path)
+    if path.is_file():
         return True
-    if local_path.is_dir():
-        return any(p.is_file() for p in local_path.rglob("*"))
+    if path.is_dir():
+        return any(child.is_file() for child in path.rglob("*"))
     return False
 
 
-def _allow_pattern(path):
-    """A directory needs a /** glob to sweep its contents; a single file's own relative
-    path already IS the exact pattern upload_large_folder needs."""
-    return f"{path}/**" if (WORKSPACE_ROOT / path).is_dir() else path
-
+def _target_root(relatives):
+    roots = {
+        "results" if str(rel).lstrip("/").startswith("results/") else "workspace"
+        for rel in relatives
+    }
+    if len(roots) > 1:
+        raise ValueError(
+            f"target mixes incompatible workspace/results roots: {relatives}"
+        )
+    return RESULTS_HOST_ROOT if "results" in roots else WORKSPACE_ROOT
 
-def backup(repo_id, target, token=None, private=False, dry_run=False):
-    """Upload one (or every) target's paths to repo_id, preserving their exact relative
-    workspace paths. Returns the list of target names actually uploaded (skips any whose
-    local paths don't exist yet or are empty)."""
-    names = _resolve_targets(target)
 
-    pending = []
-    for name in names:
-        paths = TARGETS[name]
-        if not any(_has_content(WORKSPACE_ROOT / p) for p in paths):
-            print(f"[{name}] skipped -- nothing found at {', '.join(paths)}")
-            continue
-        pending.append(name)
-
-    if not pending:
-        return []
-
-    if dry_run:
-        for name in pending:
-            for path in TARGETS[name]:
-                print(f"[{name}] would upload {WORKSPACE_ROOT / path} -> {repo_id}:{path}")
-        return pending
-
-    from huggingface_hub import HfApi
-
-    api = HfApi(token=token)
-    api.create_repo(repo_id=repo_id, repo_type="dataset", private=private, exist_ok=True)
-
-    for name in pending:
-        patterns = [_allow_pattern(p) for p in TARGETS[name]]
-        print(f"[{name}] uploading {', '.join(TARGETS[name])} -> {repo_id} ...")
-        api.upload_large_folder(
-            repo_id=repo_id,
-            repo_type="dataset",
-            folder_path=str(WORKSPACE_ROOT),
-            allow_patterns=patterns,
-        )
-        print(f"[{name}] done")
-    return pending
+def _path_in_repo(relative):
+    return str(relative).lstrip("/")
 
 
-def main():
-    parser = argparse.ArgumentParser()
-    parser.add_argument(
-        "--repo-id", default=None, help="e.g. yourname/vsi-spatial-code-results"
-    )
-    parser.add_argument("--target", default=None, choices=list(TARGETS) + ["all"])
+def backup(repo_id=DEFAULT_REPO, target="all", dry_run=False, token=None):
+    selected = _resolve_targets(target)
+    uploaded = []
+    for name in selected:
+        relatives = TARGETS[name]
+        _target_root(relatives)
+        existing = [(relative, _local_path(relative)) for relative in relatives]
+        existing = [(relative, path) for relative, path in existing if _has_files(path)]
+        if not existing:
+            print(f"[{name}] skipped: no files found")
+            continue
+        uploaded.append(name)
+        if dry_run:
+            for relative, path in existing:
+                print(
+                    f"[{name}] would upload {path} -> {repo_id}/{_path_in_repo(relative)}"
+                )
+            continue
+        from huggingface_hub import HfApi
+
+        api = HfApi(token=token)
+        for relative, path in existing:
+            repo_path = _path_in_repo(relative)
+            if path.is_dir():
+                api.upload_folder(
+                    folder_path=str(path),
+                    repo_id=repo_id,
+                    repo_type="dataset",
+                    path_in_repo=repo_path,
+                )
+            else:
+                api.upload_file(
+                    path_or_fileobj=str(path),
+                    repo_id=repo_id,
+                    repo_type="dataset",
+                    path_in_repo=repo_path,
+                )
+            print(f"[{name}] uploaded {path} -> {repo_id}/{repo_path}")
+    return uploaded
+
+
+def main(argv=None):
+    parser = argparse.ArgumentParser(description=__doc__)
     parser.add_argument(
-        "--token", default=None, help="defaults to $HF_TOKEN, then a cached hf login"
+        "target", nargs="?", default="all", help="target name, comma list, or all"
     )
-    parser.add_argument("--private", action="store_true", help="create the repo private if new")
+    parser.add_argument("--repo", default=DEFAULT_REPO)
     parser.add_argument(
-        "--dry-run", action="store_true",
-        help="print what would be uploaded and exit -- no token or network needed",
+        "--token",
+        default=os.environ.get("HF_TOKEN") or os.environ.get("HUGGING_FACE_HUB_TOKEN"),
     )
-    args = parser.parse_args()
-
-    repo_id = args.repo_id or input(
-        "Hugging Face dataset repo to back up to (e.g. yourname/vsi-spatial-code-results): "
-    ).strip()
-    if not repo_id:
-        parser.error("no repo given")
-
-    target = args.target
-    if target is None:
-        target = input(f"Target [{'|'.join(list(TARGETS) + ['all'])}]: ").strip()
-    if target not in TARGETS and target != "all":
-        parser.error(f"unknown target {target!r}; expected one of {list(TARGETS) + ['all']}")
-
-    token = args.token or os.environ.get("HF_TOKEN") or os.environ.get("HUGGING_FACE_HUB_TOKEN")
-    if not args.dry_run and token is None:
-        print(f"Hugging Face token needed to upload to {repo_id} (write access)")
-        print("Create one at https://huggingface.co/settings/tokens")
-        token = getpass.getpass("HF token (input hidden): ").strip()
+    parser.add_argument("--dry-run", action="store_true")
+    args = parser.parse_args(argv)
+    token = args.token
     if not args.dry_run and not token:
-        parser.error(
-            "no Hugging Face token given -- pass --token, set $HF_TOKEN, or run "
-            "`huggingface-cli login` first (not needed for --dry-run)"
-        )
-
-    uploaded = backup(
-        repo_id, target, token=token, private=args.private, dry_run=args.dry_run
-    )
-    if not uploaded:
-        print("nothing to upload")
-        sys.exit(1)
-    print(f"\n{'would upload' if args.dry_run else 'uploaded'} target(s): {', '.join(uploaded)}")
-    if not args.dry_run:
-        print(f"https://huggingface.co/datasets/{repo_id}")
+        token = getpass.getpass("HF token: ")
+    backup(args.repo, args.target, dry_run=args.dry_run, token=token)
 
 
 if __name__ == "__main__":

calibration/__init__.py

@@ -26,5 +26,5 @@ from harness.A import WORKSPACE_ROOT
 # One JSON per question:
 # results/calibration/<model>/<spatial_code_format>/<budget>/<scene>/<question_id>.json
 RESULTS_DIR = Path(
-    os.environ.get("VSI_CALIBRATION_RESULTS_DIR", WORKSPACE_ROOT / "results" / "calibration")
+    os.environ.get("VSI_CALIBRATION_RESULTS_DIR", "/root/results/calibration")
 )

calibration/report.py

@@ -26,7 +26,7 @@ WORKSPACE_ROOT = Path(__file__).resolve().parent.parent
 if str(WORKSPACE_ROOT) not in sys.path:
     sys.path.insert(0, str(WORKSPACE_ROOT))
 
-from analysis.aggregate import _official_scores, iter_records  # noqa: E402
+from analysis.letters_reports import _official_scores  # noqa: E402
 from calibration import RESULTS_DIR  # noqa: E402
 
 
@@ -53,7 +53,15 @@ def load_grid(results_dir=None):
         )
         if not has_question_files:
             continue
-        records = {r["question_id"]: r for r in iter_records(budget_dir)}
+        records = {}
+        for record_path in sorted(budget_dir.rglob("*.json")):
+            try:
+                with record_path.open(encoding="utf-8") as stream:
+                    record = json.load(stream)
+            except (OSError, json.JSONDecodeError):
+                continue
+            if isinstance(record, dict) and "question_id" in record:
+                records[record["question_id"]] = record
         if records:
             cell = str(budget_dir.parent.relative_to(root))
             grid[cell][budget_dir.name] = records
@@ -76,7 +84,9 @@ def cell_stats(records):
         "natural_reasoning_tokens_mean": (
             statistics.mean(natural_lengths) if natural_lengths else None
         ),
-        "generation_seconds_mean": statistics.mean(r["generation_seconds"] for r in rows),
+        "generation_seconds_mean": statistics.mean(
+            r["generation_seconds"] for r in rows
+        ),
     }
 
 
@@ -99,7 +109,8 @@ def report(grid, tolerance=1.0, max_forced_rate=0.15):
         # ("512-prose-legend", ...) are shown as rows but never recommended, since they
         # change the prompt, not just the budget.
         scored = {
-            b: s for b, s in stats.items()
+            b: s
+            for b, s in stats.items()
             if s["overall"] is not None and str(b).isdigit()
         }
         recommended = None
@@ -124,11 +135,16 @@ def main():
     parser = argparse.ArgumentParser()
     parser.add_argument("--results-dir", default=None)
     parser.add_argument(
-        "--tolerance", type=float, default=1.0,
+        "--tolerance",
+        type=float,
+        default=1.0,
         help="accuracy points a budget may trail the best and still be recommended",
     )
     parser.add_argument(
-        "--max-forced-rate", type=float, default=0.15, dest="max_forced_rate",
+        "--max-forced-rate",
+        type=float,
+        default=0.15,
+        dest="max_forced_rate",
         help="maximum acceptable forced-continuation rate for a recommended budget",
     )
     parser.add_argument("--json", action="store_true")
@@ -138,7 +154,9 @@ def main():
     if not grid:
         print("no calibration results found -- run calibration.run first")
         raise SystemExit(1)
-    result = report(grid, tolerance=args.tolerance, max_forced_rate=args.max_forced_rate)
+    result = report(
+        grid, tolerance=args.tolerance, max_forced_rate=args.max_forced_rate
+    )
     if args.json:
         print(json.dumps(result, indent=1))
         return
@@ -146,10 +164,15 @@ def main():
         print(f"=== {model} ({model_report['questions']} shared questions) ===")
         for budget, stats in model_report["budgets"].items():
             overall = f"{stats['overall']:.2f}" if stats["overall"] is not None else "-"
-            forced = f"{stats['forced_rate']:.3f}" if stats["forced_rate"] is not None else "-"
+            forced = (
+                f"{stats['forced_rate']:.3f}"
+                if stats["forced_rate"] is not None
+                else "-"
+            )
             natural = (
                 f"{stats['natural_reasoning_tokens_mean']:.0f}"
-                if stats["natural_reasoning_tokens_mean"] is not None else "-"
+                if stats["natural_reasoning_tokens_mean"] is not None
+                else "-"
             )
             print(
                 f"  {str(budget):>18}: overall={overall} forced_rate={forced} "

calibration/run.py

@@ -42,12 +42,20 @@ from harness.B import (  # noqa: E402
 from harness.B import launch as harness_b_launch  # noqa: E402
 
 
-def results_dir_for(model, spatial_code_format, depth, tracking, input_selection, frame_count, budget):
+def results_dir_for(
+    model, spatial_code_format, depth, tracking, input_selection, frame_count, budget
+):
     """Return the result root isolated by every pilot axis -- model, format, the full
     perceived-code config, and the reasoning budget -- so no two pilots collide."""
     return (
-        RESULTS_DIR / model / spatial_code_format / depth / tracking
-        / input_selection / str(frame_count) / str(budget)
+        RESULTS_DIR
+        / model
+        / spatial_code_format
+        / depth
+        / tracking
+        / input_selection
+        / str(frame_count)
+        / str(budget)
     )
 
 
@@ -69,8 +77,14 @@ def scenes_for(question_ids):
 
 
 def run_grid(
-    models, budgets, question_ids, spatial_code_format,
-    depth, tracking, input_selection, frame_count,
+    models,
+    budgets,
+    question_ids,
+    spatial_code_format,
+    depth,
+    tracking,
+    input_selection,
+    frame_count,
     rebuild=False,
     strip_schema_legend=False,
     prose_legend=False,
@@ -89,7 +103,10 @@ def run_grid(
     )
     plan = build_plan(models, budgets)
     for index, (model, budget) in enumerate(plan, start=1):
-        print(f"=== calibration {index}/{len(plan)}: {model} @ {budget} tokens ===", flush=True)
+        print(
+            f"=== calibration {index}/{len(plan)}: {model} @ {budget} tokens ===",
+            flush=True,
+        )
         variant_parts = [str(budget)]
         if thinking:
             variant_parts.append("thinking")
@@ -110,11 +127,21 @@ def run_grid(
 
             harness_kwargs["context_line"] = NO_LEGEND_PRE_PROMPT
         harness_b_launch.launch(
-            model, spatial_code_format, input_selection, frame_count, selected_scenes,
-            depth=depth, tracking=tracking,
+            model,
+            spatial_code_format,
+            input_selection,
+            frame_count,
+            selected_scenes,
+            depth=depth,
+            tracking=tracking,
             results_dir=results_dir_for(
-                model, spatial_code_format, depth, tracking, input_selection,
-                frame_count, variant,
+                model,
+                spatial_code_format,
+                depth,
+                tracking,
+                input_selection,
+                frame_count,
+                variant,
             ),
             rebuild=rebuild,
             reasoning_budget=budget,
@@ -129,49 +156,65 @@ def run_grid(
 def main():
     parser = argparse.ArgumentParser()
     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(
-        "--budgets", required=True,
+        "--budgets",
+        required=True,
         help="comma-separated reasoning budgets in tokens -- entirely your choice",
     )
     parser.add_argument(
-        "--questions", default=None,
+        "--questions",
+        default=None,
         help="comma-separated VSI-Bench question ids to test",
     )
     parser.add_argument(
-        "--questions-file", default=None, dest="questions_file",
+        "--questions-file",
+        default=None,
+        dest="questions_file",
         help="path to a JSON list of question ids (alternative to --questions)",
     )
     parser.add_argument(
-        "--spatial-code-format", required=True, choices=SPATIAL_CODE_FORMATS,
+        "--spatial-code-format",
+        required=True,
+        choices=SPATIAL_CODE_FORMATS,
         dest="spatial_code_format",
     )
     parser.add_argument("--depth", required=True, choices=DEPTH_VARIANTS)
     parser.add_argument("--tracking", required=True, choices=TRACKING_MODES)
     parser.add_argument(
-        "--input-selection", required=True, choices=INPUT_SELECTIONS,
+        "--input-selection",
+        required=True,
+        choices=INPUT_SELECTIONS,
         dest="input_selection",
     )
     parser.add_argument("--frames", type=int, required=True)
     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 schema legend; results land in "
         "a '<budget>-no-legend' sibling directory so the standard cells stay intact",
     )
     parser.add_argument(
-        "--prose-legend", action="store_true", dest="prose_legend",
+        "--prose-legend",
+        action="store_true",
+        dest="prose_legend",
         help="legacy-legend arm: prose legend before the code instead of the embedded "
         "schema block; results land in a '<budget>-prose-legend' sibling directory",
     )
     parser.add_argument(
-        "--reasoning-note", action="store_true", dest="reasoning_note",
+        "--reasoning-note",
+        action="store_true",
+        dest="reasoning_note",
         help="Thinking-with-Spatial-Code step-by-step note prefixed to the "
         "post-prompt; results land in a '<budget>-reasoning' sibling directory",
     )
     parser.add_argument(
-        "--thinking", action="store_true",
+        "--thinking",
+        action="store_true",
         help="enable native thinking mode (Qwen only); results land in a "
         "'<budget>-thinking[...]' sibling directory",
     )
@@ -179,7 +222,9 @@ def main():
     args = parser.parse_args()
 
     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))
     budgets = []
@@ -208,8 +253,14 @@ def main():
         parser.error("--frames must be positive")
     try:
         run_grid(
-            models, budgets, question_ids, args.spatial_code_format,
-            args.depth, args.tracking, args.input_selection, args.frames,
+            models,
+            budgets,
+            question_ids,
+            args.spatial_code_format,
+            args.depth,
+            args.tracking,
+            args.input_selection,
+            args.frames,
             rebuild=args.rebuild,
             strip_schema_legend=args.strip_schema_legend,
             prose_legend=args.prose_legend,

corruption/chimera.py

@@ -29,7 +29,9 @@ def _copy(code):
 
 
 def _center(instance):
-    return instance["3D oriented bounding box"]["3D oriented bounding box center coordinates"]
+    return instance["3D oriented bounding box"][
+        "3D oriented bounding box center coordinates"
+    ]
 
 
 def _distance(a, b):
@@ -44,9 +46,7 @@ def _swap_boxes(target_code, source_code):
     swapped = 0
     total = 0
     for class_name, items in code["objects"].items():
-        available = [
-            _copy(item) for item in source_code["objects"].get(class_name, [])
-        ]
+        available = [_copy(item) for item in source_code["objects"].get(class_name, [])]
         for item in items:
             total += 1
             if not available:
@@ -94,6 +94,7 @@ def perturb_single_object(code, rng, position_offset_meters=1.0, size_scale=2.0)
         center[2],
     ]
     box["3D oriented bounding box dimensions"] = [
-        round(value * size_scale, 2) for value in box["3D oriented bounding box dimensions"]
+        round(value * size_scale, 2)
+        for value in box["3D oriented bounding box dimensions"]
     ]
     return code, {"class": class_name, "instance": index}

corruption/empirical.py

@@ -28,7 +28,9 @@ if str(WORKSPACE_ROOT) not in sys.path:
 
 
 def _center(instance):
-    return instance["3D oriented bounding box"]["3D oriented bounding box center coordinates"]
+    return instance["3D oriented bounding box"][
+        "3D oriented bounding box center coordinates"
+    ]
 
 
 def _dimensions(instance):
@@ -59,7 +61,9 @@ def measure_residuals(code_pairs):
                     continue
                 best = min(
                     unmatched,
-                    key=lambda index: math.dist(_center(perceived[index]), _center(gt_item)),
+                    key=lambda index: math.dist(
+                        _center(perceived[index]), _center(gt_item)
+                    ),
                 )
                 unmatched.remove(best)
                 matched += 1
@@ -70,7 +74,9 @@ def measure_residuals(code_pairs):
                 dimension_ratios.append(
                     [
                         round(p / g, 4) if g else 1.0
-                        for p, g in zip(_dimensions(perceived[best]), _dimensions(gt_item))
+                        for p, g in zip(
+                            _dimensions(perceived[best]), _dimensions(gt_item)
+                        )
                     ]
                 )
             hallucinated += len(unmatched)
@@ -83,7 +89,9 @@ def measure_residuals(code_pairs):
         "missed": missed,
         "hallucinated": hallucinated,
         "miss_rate": missed / gt_total if gt_total else 0.0,
-        "hallucination_rate": hallucinated / perceived_total if perceived_total else 0.0,
+        "hallucination_rate": (
+            hallucinated / perceived_total if perceived_total else 0.0
+        ),
     }
 
 
@@ -148,9 +156,13 @@ def main():
 
     parser = argparse.ArgumentParser()
     parser.add_argument("--depth", required=True, choices=("relative", "metric"))
-    parser.add_argument("--tracking", required=True, choices=("tracking", "no tracking"))
     parser.add_argument(
-        "--input-selection", required=True, choices=("uniform", "selective"),
+        "--tracking", required=True, choices=("tracking", "no tracking")
+    )
+    parser.add_argument(
+        "--input-selection",
+        required=True,
+        choices=("uniform", "selective"),
         dest="input_selection",
     )
     parser.add_argument("--frames", type=int, required=True)
@@ -168,7 +180,12 @@ def main():
         seen.add(scene)
         perceived_path = Path(
             encoder_config.spatial_code_path(
-                scene, args.depth, args.input_selection, args.tracking, args.frames, "compact"
+                scene,
+                args.depth,
+                args.input_selection,
+                args.tracking,
+                args.frames,
+                "compact",
             )
         )
         gt_path = Path(ground_truth_spatial_code_path(scene, "compact"))

corruption/launch.py

@@ -32,29 +32,45 @@ def main():
     parser.add_argument(
         "--models", default=None, help="comma-separated (required unless --arm solver)"
     )
-    parser.add_argument("--transforms", required=True, help="comma-separated transform names")
-    parser.add_argument("--magnitudes", required=True, help="comma-separated magnitudes")
     parser.add_argument(
-        "--spatial-code-format", default="explicit", choices=("explicit", "compact"),
+        "--transforms", required=True, help="comma-separated transform names"
+    )
+    parser.add_argument(
+        "--magnitudes", required=True, help="comma-separated magnitudes"
+    )
+    parser.add_argument(
+        "--spatial-code-format",
+        default="explicit",
+        choices=("explicit", "compact"),
         dest="spatial_code_format",
     )
     parser.add_argument("--scenes", default=None, help="comma-separated scenes")
     parser.add_argument("--sample", default=None, help="JSON list of question ids")
     parser.add_argument(
-        "--depth", default=None, choices=("relative", "metric"),
+        "--depth",
+        default=None,
+        choices=("relative", "metric"),
         help="chimera transforms only: the perceived codes' Step-2 config",
     )
     parser.add_argument(
-        "--tracking", default=None, choices=("tracking", "no tracking"),
+        "--tracking",
+        default=None,
+        choices=("tracking", "no tracking"),
+        help="chimera transforms only",
+    )
+    parser.add_argument(
+        "--input-selection",
+        default=None,
+        choices=("uniform", "selective"),
+        dest="input_selection",
         help="chimera transforms only",
     )
     parser.add_argument(
-        "--input-selection", default=None, choices=("uniform", "selective"),
-        dest="input_selection", help="chimera transforms only",
+        "--frames", type=int, default=None, help="chimera transforms only"
     )
-    parser.add_argument("--frames", type=int, default=None, help="chimera transforms only")
     parser.add_argument(
-        "--residuals", default=None,
+        "--residuals",
+        default=None,
         help="empirical transform only: corruption.empirical's measured-residuals JSON",
     )
     args = parser.parse_args()
@@ -62,7 +78,9 @@ def main():
     transforms = [t.strip() for t in args.transforms.split(",") if t.strip()]
     unknown = [t for t in transforms if t not in ALL_CONDITIONS]
     if unknown:
-        parser.error(f"unknown transform(s) {unknown}; expected one of {ALL_CONDITIONS}")
+        parser.error(
+            f"unknown transform(s) {unknown}; expected one of {ALL_CONDITIONS}"
+        )
     magnitudes = [float(m.strip()) for m in args.magnitudes.split(",") if m.strip()]
     models = []
     if args.arm in ("vlm", "both"):
@@ -74,7 +92,9 @@ def main():
             parser.error(f"unknown model(s) {bad}")
     scenes = None
     if args.scenes:
-        scenes = list(dict.fromkeys(s.strip() for s in args.scenes.split(",") if s.strip()))
+        scenes = list(
+            dict.fromkeys(s.strip() for s in args.scenes.split(",") if s.strip())
+        )
     question_ids = None
     if args.sample:
         with open(args.sample, encoding="utf-8") as stream:
@@ -100,17 +120,29 @@ def main():
 
     conditions = [(t, m) for t in transforms for m in magnitudes]
     for index, (transform, magnitude) in enumerate(conditions, start=1):
-        print(f"=== corruption {index}/{len(conditions)}: {transform}@{magnitude} ===", flush=True)
+        print(
+            f"=== corruption {index}/{len(conditions)}: {transform}@{magnitude} ===",
+            flush=True,
+        )
         if args.arm in ("solver", "both"):
             results = run_solver(
-                transform, magnitude, args.spatial_code_format,
-                scenes=scenes, question_ids=question_ids, **condition_kwargs,
+                transform,
+                magnitude,
+                args.spatial_code_format,
+                scenes=scenes,
+                question_ids=question_ids,
+                **condition_kwargs,
             )
             print(f"  [solver] {len(results)} questions", flush=True)
         for model in models:
             results = run_vlm(
-                model, transform, magnitude, args.spatial_code_format,
-                scenes=scenes, question_ids=question_ids, **condition_kwargs,
+                model,
+                transform,
+                magnitude,
+                args.spatial_code_format,
+                scenes=scenes,
+                question_ids=question_ids,
+                **condition_kwargs,
             )
             print(f"  [{model}] {len(results)} questions", flush=True)
 

corruption/run.py

@@ -72,7 +72,9 @@ def single_object_info(scene, magnitude):
     fully determined by the frozen seed, so it can be recovered at any time. H6's
     analysis needs this to select the questions that mention the perturbed object."""
     rng = random.Random(_seed_for(scene, "single-object", magnitude))
-    _code, info = chimera_mod.perturb_single_object(load_ground_truth_compact(scene), rng)
+    _code, info = chimera_mod.perturb_single_object(
+        load_ground_truth_compact(scene), rng
+    )
     return info
 
 
@@ -106,7 +108,9 @@ def corrupted_compact(
         return perturbed
     if transform == "empirical":
         if residuals is None:
-            raise ValueError("empirical requires measured residuals (corruption.empirical)")
+            raise ValueError(
+                "empirical requires measured residuals (corruption.empirical)"
+            )
         return empirical_mod.empirical_noise(code, residuals, rng, scale=magnitude)
     if transform in CHIMERA_CONDITIONS:
         if perceived_config is None:
@@ -120,16 +124,23 @@ def corrupted_compact(
             "compact",
         )
         if transform == "chimera-gt-inventory":
-            hybrid, _coverage = chimera_mod.gt_inventory_perceived_geometry(code, perceived)
+            hybrid, _coverage = chimera_mod.gt_inventory_perceived_geometry(
+                code, perceived
+            )
         else:
-            hybrid, _coverage = chimera_mod.perceived_inventory_gt_geometry(code, perceived)
+            hybrid, _coverage = chimera_mod.perceived_inventory_gt_geometry(
+                code, perceived
+            )
         return hybrid
-    raise ValueError(f"unknown transform {transform!r}; expected one of {ALL_CONDITIONS}")
+    raise ValueError(
+        f"unknown transform {transform!r}; expected one of {ALL_CONDITIONS}"
+    )
 
 
 def corrupted_code(scene, transform, magnitude, spatial_code_format, **kwargs):
     """Corrupt the compact code, then derive the requested format from it -- the same
-    derivation path the encoder uses, so both formats stay consistent under corruption."""
+    derivation path the encoder uses, so both formats stay consistent under corruption.
+    """
     compact = corrupted_compact(scene, transform, magnitude, **kwargs)
     if spatial_code_format == "compact":
         return compact
@@ -146,14 +157,23 @@ def make_code_transform(transform, magnitude, **kwargs):
     """Build the ``harness.D.run.run(code_transform=...)`` hook for one condition."""
 
     def hook(_loaded_code, scene_id, spatial_code_format):
-        return corrupted_code(scene_id, transform, magnitude, spatial_code_format, **kwargs)
+        return corrupted_code(
+            scene_id, transform, magnitude, spatial_code_format, **kwargs
+        )
 
     return hook
 
 
 def run_vlm(
-    model, transform, magnitude, spatial_code_format="explicit", scenes=None, limit=None,
-    question_ids=None, results_dir=None, **kwargs
+    model,
+    transform,
+    magnitude,
+    spatial_code_format="explicit",
+    scenes=None,
+    limit=None,
+    question_ids=None,
+    results_dir=None,
+    **kwargs,
 ):
     """Answer the sampled questions with one VLM on corrupted codes, through
     harness.D's unmodified path. Returns harness.D-shape records."""
@@ -173,28 +193,44 @@ def run_vlm(
 
 
 def run_solver(
-    transform, magnitude, spatial_code_format="explicit", scenes=None, limit=None,
-    question_ids=None, write_results=True, results_dir=None, **kwargs
+    transform,
+    magnitude,
+    spatial_code_format="explicit",
+    scenes=None,
+    limit=None,
+    question_ids=None,
+    write_results=True,
+    results_dir=None,
+    **kwargs,
 ):
     """Answer the sampled questions with the symbolic solver on the SAME corrupted
     codes -- the zero-GPU second reasoner for every corruption arm."""
     rows = load_questions(None, None, scenes, limit)
     if question_ids is not None:
         rows = [row for row in rows if row["id"] in question_ids]
-    root = Path(results_dir or results_dir_for("solver", transform, magnitude, "symbolic"))
+    root = Path(
+        results_dir or results_dir_for("solver", transform, magnitude, "symbolic")
+    )
     code_cache = {}
     results = []
     for row in rows:
         scene = row["scene_name"]
         if scene not in code_cache:
-            code = corrupted_code(scene, transform, magnitude, spatial_code_format, **kwargs)
+            code = corrupted_code(
+                scene, transform, magnitude, spatial_code_format, **kwargs
+            )
             code_cache[scene] = adapters.adapt_spatial_code(code)
         answer = solver.answer(
             row["question_type"], row["question"], row["options"], code_cache[scene]
         )
         pred = "" 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])["vsibench_score"]
+        doc = {
+            "question_type": row["question_type"],
+            "ground_truth": row["ground_truth"],
+        }
+        score_doc = vsi_official_eval.vsibench_process_results(doc, [pred])[
+            "vsibench_score"
+        ]
         metric_name, score = _scalar_score(row["question_type"], score_doc)
         record = {
             "model": "symbolic",
@@ -257,13 +293,19 @@ def _condition_kwargs(args, parser):
     kwargs = {}
     if args.transform in CHIMERA_CONDITIONS:
         missing = [
-            flag for flag, value in (
-                ("--depth", args.depth), ("--tracking", args.tracking),
-                ("--input-selection", args.input_selection), ("--frames", args.frames),
-            ) if value is None
+            flag
+            for flag, value in (
+                ("--depth", args.depth),
+                ("--tracking", args.tracking),
+                ("--input-selection", args.input_selection),
+                ("--frames", args.frames),
+            )
+            if value is None
         ]
         if missing:
-            parser.error(f"{args.transform} requires {', '.join(missing)} (the Step-2 config)")
+            parser.error(
+                f"{args.transform} requires {', '.join(missing)} (the Step-2 config)"
+            )
         kwargs["perceived_config"] = {
             "depth": args.depth,
             "tracking": args.tracking,
@@ -292,38 +334,53 @@ def main():
     parser.add_argument("--magnitude", type=float, required=True)
     parser.add_argument("--model", default=None, help="required for --arm vlm")
     parser.add_argument(
-        "--spatial-code-format", default="explicit", choices=("explicit", "compact"),
+        "--spatial-code-format",
+        default="explicit",
+        choices=("explicit", "compact"),
         dest="spatial_code_format",
     )
     parser.add_argument("--scenes", default=None, help="comma-separated scenes")
     parser.add_argument("--limit", type=int, default=None)
     parser.add_argument(
-        "--sample", default=None,
+        "--sample",
+        default=None,
         help="path to a JSON list of question ids (the pre-registered sample)",
     )
     parser.add_argument("--results-dir", default=None)
     parser.add_argument(
-        "--depth", default=None, choices=("relative", "metric"),
+        "--depth",
+        default=None,
+        choices=("relative", "metric"),
         help="chimera only: the perceived codes' Step-2 config",
     )
     parser.add_argument(
-        "--tracking", default=None, choices=("tracking", "no tracking"),
+        "--tracking",
+        default=None,
+        choices=("tracking", "no tracking"),
         help="chimera only: the perceived codes' Step-2 config",
     )
     parser.add_argument(
-        "--input-selection", default=None, choices=("uniform", "selective"),
-        dest="input_selection", help="chimera only: the perceived codes' Step-2 config",
+        "--input-selection",
+        default=None,
+        choices=("uniform", "selective"),
+        dest="input_selection",
+        help="chimera only: the perceived codes' Step-2 config",
     )
     parser.add_argument(
-        "--frames", type=int, default=None,
+        "--frames",
+        type=int,
+        default=None,
         help="chimera only: the perceived codes' Step-2 config",
     )
     parser.add_argument(
-        "--wrong-scene", default=None, dest="wrong_scene",
+        "--wrong-scene",
+        default=None,
+        dest="wrong_scene",
         help="wrong-scene only: the substitute scene id",
     )
     parser.add_argument(
-        "--residuals", default=None,
+        "--residuals",
+        default=None,
         help="empirical only: path to corruption.empirical's measured-residuals JSON",
     )
     args = parser.parse_args()
@@ -331,7 +388,9 @@ def main():
 
     scenes = None
     if args.scenes:
-        scenes = list(dict.fromkeys(s.strip() for s in args.scenes.split(",") if s.strip()))
+        scenes = list(
+            dict.fromkeys(s.strip() for s in args.scenes.split(",") if s.strip())
+        )
     question_ids = None
     if args.sample:
         with open(args.sample, encoding="utf-8") as stream:
@@ -351,15 +410,26 @@ def main():
         if not args.model:
             parser.error("--arm vlm requires --model")
         results = run_vlm(
-            args.model, args.transform, args.magnitude, args.spatial_code_format,
-            scenes=scenes, limit=args.limit, question_ids=question_ids,
-            results_dir=args.results_dir, **condition_kwargs,
+            args.model,
+            args.transform,
+            args.magnitude,
+            args.spatial_code_format,
+            scenes=scenes,
+            limit=args.limit,
+            question_ids=question_ids,
+            results_dir=args.results_dir,
+            **condition_kwargs,
         )
     else:
         results = run_solver(
-            args.transform, args.magnitude, args.spatial_code_format,
-            scenes=scenes, limit=args.limit, question_ids=question_ids,
-            results_dir=args.results_dir, **condition_kwargs,
+            args.transform,
+            args.magnitude,
+            args.spatial_code_format,
+            scenes=scenes,
+            limit=args.limit,
+            question_ids=question_ids,
+            results_dir=args.results_dir,
+            **condition_kwargs,
         )
     if results:
         mean_score = sum(r["score"] for r in results) / len(results)

corruption/sample.py

@@ -109,20 +109,28 @@ def draw_sample(scenes, seed=SAMPLE_SEED, budgets=None):
 def main():
     parser = argparse.ArgumentParser()
     parser.add_argument("--depth", required=True, choices=("relative", "metric"))
-    parser.add_argument("--tracking", required=True, choices=("tracking", "no tracking"))
     parser.add_argument(
-        "--input-selection", required=True, choices=("uniform", "selective"),
+        "--tracking", required=True, choices=("tracking", "no tracking")
+    )
+    parser.add_argument(
+        "--input-selection",
+        required=True,
+        choices=("uniform", "selective"),
         dest="input_selection",
     )
     parser.add_argument("--frames", type=int, required=True)
     parser.add_argument("--output", default=str(DEFAULT_OUTPUT))
     parser.add_argument(
-        "--seed", type=int, default=SAMPLE_SEED,
+        "--seed",
+        type=int,
+        default=SAMPLE_SEED,
         help="frozen in analysis/preregistration.md -- do not change for real runs",
     )
     args = parser.parse_args()
 
-    scenes = eligible_scenes(args.depth, args.input_selection, args.tracking, args.frames)
+    scenes = eligible_scenes(
+        args.depth, args.input_selection, args.tracking, args.frames
+    )
     if not scenes:
         raise SystemExit(
             "no eligible scenes: need BOTH perceived (Step 2) and ground-truth codes on disk"
@@ -134,7 +142,9 @@ def main():
     with open(args.output, "w", encoding="utf-8") as stream:
         json.dump(sample, stream, indent=1)
     print(f"wrote {len(sample)} question ids to {args.output}")
-    print(f"eligible scenes: {len(scenes)}; distinct scenes in sample: {len(distinct_scenes)}")
+    print(
+        f"eligible scenes: {len(scenes)}; distinct scenes in sample: {len(distinct_scenes)}"
+    )
     print(
         "NOW: commit this file into the repository and re-run the code backup so the "
         "realized sample is timestamped before any corruption run "

corruption/transforms.py

@@ -157,7 +157,10 @@ def translate(code, offset_meters, rng=None):
                 ]
             else:
                 polygon[key] = [
-                    [[round(x + offset_meters, 2), round(y + offset_meters, 2)] for x, y in hole]
+                    [
+                        [round(x + offset_meters, 2), round(y + offset_meters, 2)]
+                        for x, y in hole
+                    ]
                     for hole in polygon[key]
                 ]
     return code
@@ -178,7 +181,11 @@ def rotate_z(code, angle_degrees, rng=None):
         box = _box(instance)
         center = box["3D oriented bounding box center coordinates"]
         x, y = rotate_xy(center[0], center[1])
-        box["3D oriented bounding box center coordinates"] = [round(x, 2), round(y, 2), center[2]]
+        box["3D oriented bounding box center coordinates"] = [
+            round(x, 2),
+            round(y, 2),
+            center[2],
+        ]
         vectors = box["3D oriented bounding box orientation unit vectors"]
         box["3D oriented bounding box orientation unit vectors"] = [
             [round(v, 2) for v in (*rotate_xy(vector[0], vector[1]), vector[2])]