Replace analysis tests with modular report suite

tests/test_analysis/conftest.py

@@ -1,12 +1,37 @@
-"""Shared import setup for harness.analysis tests."""
-
+"""Shared fixtures and helpers for report-export tests."""
+import json
+import tempfile
+import unittest
 from pathlib import Path
-import sys
+from analysis.letters_reports import analyze_modular, export_reports, load_profile as load
 
-ROOT = Path(__file__).resolve().parents[2]
-if str(ROOT) not in sys.path:
-    sys.path.insert(0, str(ROOT))
+def vlm(letter,qid=1,score=1.0,protocol="base",model="m",frames=32):
+ r={"model":model,"protocol":protocol,"condition":protocol,"question_id":qid,"scene":"s","dataset":"d","question_type":"count","score":score,"frame_count":frames,"input_token_count":10,"output_token_count":2,"generation_seconds":1.0,"answer_given":"x","full_prompt":"p"}
+ if letter=="A": r["frame_selection"]="uniform"
+ elif letter in "BC": r.update(input_selection="uniform",spatial_code_format="explicit",depth="metric",tracking="tracking")
+ elif letter=="D": r["spatial_code_format"]="explicit"
+ return r
 
+def put(root,relative,record):
+ p=root/relative; p.parent.mkdir(parents=True,exist_ok=True); p.write_text(json.dumps(record)); return p
 
-def pytest_configure(config):
-    config.option.importmode = "importlib"
+class ReportTestCase(unittest.TestCase):
+ def setUp(self): self.temp=tempfile.TemporaryDirectory(); self.root=Path(self.temp.name)
+ def tearDown(self): self.temp.cleanup()
+ def directory(self,letter,records):
+  d=self.root/letter; d.mkdir()
+  for i,r in enumerate(records): put(d,f"{i}.json",r)
+  return d
+ def symbolic(self,future=False):
+  d=self.root/("F_future" if future else "F"); d.mkdir(exist_ok=True)
+  prefix="perceived/metric/tracking/uniform/32/explicit" if future else "metric/tracking/uniform/32/explicit"
+  put(d,f"{prefix}/s/1.json",{"model":"symbolic","condition":"metric:tracking:uniform:32:explicit","question_id":1,"scene":"s","dataset":"d","question_type":"count","score":1.0,"spatial_code_format":"explicit","depth":"metric","tracking":"tracking","input":"uniform","number_of_frames":32})
+  return d
+ def ground_truth_symbolic(self):
+  d=self.root/"F"; d.mkdir()
+  put(d,"ground truth/explicit/s/1.json",{"model":"symbolic","condition":"ground truth:explicit","question_id":1,"scene":"s","dataset":"d","question_type":"count","score":1.0,"spatial_code_format":"explicit"})
+  return d
+ def analyze(self,letters,dirs,pairs=(),protocols=("base",)):
+  profiles={l:load(l) for l in letters}; per,combined=analyze_modular({l:dirs[l] for l in letters},profiles,protocols,pairs)
+  paths=export_reports(per,combined,self.root/"reports")
+  return per,combined,{p.name for p in paths}

tests/test_analysis/test_A_reports.py

@@ -0,0 +1,9 @@
+from conftest import ReportTestCase,vlm
+from analysis import A_reports
+class TestAReports(ReportTestCase):
+ def test_A_report_and_controlled_frame_comparison(self):
+  d=self.directory("A",[vlm("A",frames=32),vlm("A",frames=64)])
+  result=A_reports.generate(d,["base"],self.root/"reports")
+  self.assertEqual(result["path"].name,"A_report.json")
+  self.assertEqual(len(result["report"]["cells"]),2)
+  self.assertEqual(len(result["report"]["within_harness_comparisons"]),1)

tests/test_analysis/test_B_reports.py

@@ -0,0 +1,6 @@
+from conftest import ReportTestCase,vlm
+from analysis import B_reports
+class TestBReports(ReportTestCase):
+ def test_B_report_contains_spatial_cell(self):
+  result=B_reports.generate(self.directory("B",[vlm("B")]),["base"],self.root/"reports")
+  self.assertEqual(result["path"].name,"B_report.json"); self.assertEqual(len(result["report"]["cells"]),1)

tests/test_analysis/test_C_reports.py

@@ -0,0 +1,6 @@
+from conftest import ReportTestCase,vlm
+from analysis import C_reports
+class TestCReports(ReportTestCase):
+ def test_C_report_is_exported(self):
+  result=C_reports.generate(self.directory("C",[vlm("C")]),["base"],self.root/"reports")
+  self.assertEqual(result["path"].name,"C_report.json"); self.assertEqual(len(result["report"]["cells"]),1)

tests/test_analysis/test_D_reports.py

@@ -0,0 +1,7 @@
+from conftest import ReportTestCase,vlm
+from analysis import D_reports
+class TestDReports(ReportTestCase):
+ def test_D_report_is_ground_truth_code_report(self):
+  result=D_reports.generate(self.directory("D",[vlm("D")]),["base"],self.root/"reports")
+  self.assertEqual(result["path"].name,"D_report.json")
+  self.assertEqual(result["report"]["manifest"]["profile"]["input_source"],"ground_truth")

tests/test_analysis/test_F_reports.py

@@ -0,0 +1,9 @@
+from conftest import ReportTestCase
+from analysis import F_reports
+class TestFReports(ReportTestCase):
+ def test_F_legacy_and_future_perceived_layouts(self):
+  for future in (False,True):
+   result=F_reports.generate(self.symbolic(future),(),self.root/("future" if future else "legacy"))
+   self.assertEqual(result["path"].name,"F_report.json")
+   cell=next(iter(result["report"]["cells"].values()))
+   self.assertEqual(cell["identity"]["source"],"perceived")

tests/test_analysis/test_aggregate.py

@@ -1,165 +0,0 @@
-"""Tests for analysis/aggregate.py -- per-category scores + stats, shared across A/B/C."""
-
-import json
-
-from analysis import aggregate as harness_analysis
-
-
-def _record(
-    model="qwen3.5-2b", condition="uniform:16", question_type="object_counting",
-    answer_expected="4", metric="MRA:.5:.95:.05", score=1.0, generation_seconds=1.0,
-    input_token_count=100, output_token_count=4, hit_token_limit=False,
-    reasoning_token_count=None, forced=None,
-):
-    return {
-        "model": model,
-        "condition": condition,
-        "question_type": question_type,
-        "answer_expected": answer_expected,
-        "metric": metric,
-        "score": score,
-        "generation_seconds": generation_seconds,
-        "input_token_count": input_token_count,
-        "output_token_count": output_token_count,
-        "hit_token_limit": hit_token_limit,
-        "reasoning_token_count": reasoning_token_count,
-        "forced": forced,
-    }
-
-
-def test_results_dirs_cover_every_harness():
-    assert set(harness_analysis.RESULTS_DIRS) == {"A", "B", "C", "D", "E"}
-    from harness.A import RESULTS_DIR as a_dir
-    from harness.B import RESULTS_DIR as b_dir
-    from harness.C import RESULTS_DIR as c_dir
-    from harness.D import RESULTS_DIR as d_dir
-
-    assert harness_analysis.RESULTS_DIRS["A"] == a_dir
-    assert harness_analysis.RESULTS_DIRS["B"] == b_dir
-    assert harness_analysis.RESULTS_DIRS["C"] == c_dir
-    assert harness_analysis.RESULTS_DIRS["D"] == d_dir
-
-
-def test_iter_records_reads_every_json_under_results_dir(tmp_path):
-    scene_dir = tmp_path / "qwen3.5-2b" / "uniform" / "16" / "scene0001_00"
-    scene_dir.mkdir(parents=True)
-    (scene_dir / "0.json").write_text(json.dumps(_record()))
-    (scene_dir / "1.json").write_text(json.dumps(_record(question_type="object_size_estimation")))
-    records = list(harness_analysis.iter_records(tmp_path))
-    assert len(records) == 2
-
-
-def test_iter_records_returns_empty_for_missing_dir(tmp_path):
-    assert list(harness_analysis.iter_records(tmp_path / "does-not-exist")) == []
-
-
-def test_condition_key_groups_by_model_and_condition():
-    key = harness_analysis._condition_key(_record(model="qwen3.5-4b", condition="selective:64"))
-    assert key == "qwen3.5-4b/selective:64"
-
-
-def test_aggregate_groups_by_model_and_condition():
-    records = [
-        _record(model="qwen3.5-2b", condition="uniform:16"),
-        _record(model="qwen3.5-2b", condition="uniform:16", question_type="object_size_estimation"),
-        _record(model="qwen3.5-4b", condition="uniform:16"),
-    ]
-    aggregated = harness_analysis.aggregate(records)
-    assert set(aggregated) == {"qwen3.5-2b/uniform:16", "qwen3.5-4b/uniform:16"}
-    assert aggregated["qwen3.5-2b/uniform:16"]["count"] == 2
-    assert aggregated["qwen3.5-4b/uniform:16"]["count"] == 1
-
-
-def test_aggregate_computes_official_scores_via_the_real_scorer():
-    records = [_record(score=1.0), _record(score=0.0, question_type="object_size_estimation")]
-    aggregated = harness_analysis.aggregate(records)
-    official = aggregated["qwen3.5-2b/uniform:16"]["official"]
-    assert official["object_counting_MRA:.5:.95:.05"] == 100.0
-    assert official["object_size_estimation_MRA:.5:.95:.05"] == 0.0
-    assert official["overall"] == 50.0
-
-
-def test_aggregate_computes_latency_and_token_stats():
-    records = [
-        _record(generation_seconds=1.0, input_token_count=100, output_token_count=4),
-        _record(generation_seconds=3.0, input_token_count=200, output_token_count=8),
-    ]
-    aggregated = harness_analysis.aggregate(records)
-    stats = aggregated["qwen3.5-2b/uniform:16"]
-    assert stats["generation_seconds"]["mean"] == 2.0
-    assert stats["generation_seconds"]["total"] == 4.0
-    assert stats["input_token_count"]["mean"] == 150.0
-    assert stats["output_token_count"]["mean"] == 6.0
-
-
-def test_aggregate_computes_hit_token_limit_rate():
-    records = [
-        _record(hit_token_limit=True), _record(hit_token_limit=True), _record(hit_token_limit=False),
-    ]
-    aggregated = harness_analysis.aggregate(records)
-    assert aggregated["qwen3.5-2b/uniform:16"]["hit_token_limit_rate"] == 2 / 3
-
-
-def test_aggregate_omits_forced_stats_when_no_records_used_extended():
-    aggregated = harness_analysis.aggregate([_record()])
-    assert "forced_rate" not in aggregated["qwen3.5-2b/uniform:16"]
-
-
-def test_aggregate_includes_forced_stats_for_extended_records():
-    records = [
-        _record(reasoning_token_count=50, forced=True),
-        _record(reasoning_token_count=10, forced=False),
-    ]
-    aggregated = harness_analysis.aggregate(records)
-    stats = aggregated["qwen3.5-2b/uniform:16"]
-    assert stats["forced_rate"] == 0.5
-    assert stats["reasoning_token_count"]["mean"] == 30.0
-
-
-def test_aggregate_returns_empty_dict_for_no_records():
-    assert harness_analysis.aggregate([]) == {}
-
-
-def test_flatten_rows_splits_key_and_includes_official_and_summary_columns():
-    records = [_record(model="qwen3.5-2b", condition="uniform:16")]
-    aggregated = harness_analysis.aggregate(records)
-    rows = harness_analysis.flatten_rows(aggregated)
-    assert len(rows) == 1
-    row = rows[0]
-    assert row["model"] == "qwen3.5-2b"
-    assert row["condition"] == "uniform:16"
-    assert row["count"] == 1
-    assert row["official_overall"] == 100.0
-    assert row["generation_seconds_mean"] == 1.0
-    assert row["hit_token_limit_rate"] == 0.0
-    assert "forced_rate" not in row
-
-
-def test_flatten_rows_includes_forced_columns_for_extended_records():
-    records = [_record(reasoning_token_count=50, forced=True)]
-    aggregated = harness_analysis.aggregate(records)
-    row = harness_analysis.flatten_rows(aggregated)[0]
-    assert row["forced_rate"] == 1.0
-    assert row["reasoning_token_count_mean"] == 50.0
-
-
-def test_write_csv_round_trips_through_a_real_file(tmp_path):
-    import csv
-
-    records = [
-        _record(model="qwen3.5-2b", condition="uniform:16"),
-        _record(model="qwen3.5-4b", condition="uniform:16", reasoning_token_count=20, forced=False),
-    ]
-    aggregated = harness_analysis.aggregate(records)
-    csv_path = tmp_path / "out.csv"
-    harness_analysis.write_csv(aggregated, csv_path)
-
-    with csv_path.open(encoding="utf-8") as stream:
-        rows = list(csv.DictReader(stream))
-    assert len(rows) == 2
-    assert {row["model"] for row in rows} == {"qwen3.5-2b", "qwen3.5-4b"}
-    qwen2b_row = next(row for row in rows if row["model"] == "qwen3.5-2b")
-    assert qwen2b_row["official_overall"] == "100.0"
-    assert qwen2b_row["forced_rate"] == ""
-    qwen4b_row = next(row for row in rows if row["model"] == "qwen3.5-4b")
-    assert qwen4b_row["forced_rate"] == "0.0"

tests/test_analysis/test_analysis.py

@@ -0,0 +1,10 @@
+import json
+from conftest import ReportTestCase,vlm
+from analysis.letters_reports import load_profile as load
+class TestAnalysisDirectory(ReportTestCase):
+ def test_arbitrary_subset_exports_letter_and_combined_files(self):
+  dirs={l:self.directory(l,[vlm(l)]) for l in "AC"}; _,_,names=self.analyze("AC",dirs)
+  self.assertEqual(names,{"A_report.json","C_report.json","AC_report.json"})
+  for name in names: json.loads((self.root/"reports"/name).read_text())
+ def test_E_is_excluded(self):
+  with self.assertRaises(ValueError): load("E")

tests/test_analysis/test_citation_audit.py

@@ -1,180 +0,0 @@
-"""Tests for analysis/citation_audit.py."""
-
-import json
-
-from analysis import citation_audit
-
-
-def _write_code(path, table, objects=None):
-    code = {"closest classes distance meters from": table}
-    if objects is not None:
-        code["objects"] = objects
-    path.write_text(json.dumps(code))
-
-
-def _write_record(results_dir, i, **kwargs):
-    record = {
-        "model": "m", "question_type": "object_abs_distance", "condition": "base:x",
-        "scene": "scene", "question_id": i,
-    }
-    record.update(kwargs)
-    (results_dir / "scene" / f"{i}.json").write_text(json.dumps(record))
-
-
-def _three_class_code(path):
-    """chair<->table = 1.46, chair<->lamp = 3.0 -- two distinct real entries, so an
-    answer can be "faithful to some entry" while still being the WRONG pair."""
-    _write_code(
-        path,
-        {
-            "chair": {
-                "table": {"distance": "1.46 meters", "closeness rank": 1},
-                "lamp": {"distance": "3.0 meters", "closeness rank": 2},
-            },
-            "table": {"chair": {"distance": "1.46 meters", "closeness rank": 1}},
-            "lamp": {"chair": {"distance": "3.0 meters", "closeness rank": 1}},
-        },
-        objects={"chair": {"count": 1}, "table": {"count": 1}, "lamp": {"count": 1}},
-    )
-
-
-def test_audit_classifies_correct_pair(tmp_path):
-    code_path = tmp_path / "scene.json"
-    _three_class_code(code_path)
-    results_dir = tmp_path / "results"
-    (results_dir / "scene").mkdir(parents=True)
-    question = "distance between the chair and the table ("
-    _write_record(results_dir, 0, answer_given="1.46", spatial_code_path=str(code_path),
-                  question=question)
-
-    summary = citation_audit.audit(results_dir, "m")
-    assert summary["total_answered"] == 1
-    assert summary["breakdown"]["correct_pair"] == 1
-    assert summary["correct_pair_rate"] == 1.0
-    assert summary["examples"] == []  # only non-correct answers are collected
-
-
-def test_audit_classifies_wrong_entry_when_answer_matches_a_different_real_pair(tmp_path):
-    """The critical distinction this module exists for: citing SOME real table value
-    is not the same as citing the CORRECT one. An answer of 3.0 for "chair and table"
-    (whose real answer is 1.46) is a real citation of the chair/lamp pair instead --
-    faithful citation discipline, wrong pair."""
-    code_path = tmp_path / "scene.json"
-    _three_class_code(code_path)
-    results_dir = tmp_path / "results"
-    (results_dir / "scene").mkdir(parents=True)
-    question = "distance between the chair and the table ("
-    _write_record(results_dir, 0, answer_given="3.0", spatial_code_path=str(code_path),
-                  question=question, answer_expected="1.5")
-
-    summary = citation_audit.audit(results_dir, "m")
-    assert summary["breakdown"]["wrong_entry"] == 1
-    assert summary["breakdown"]["correct_pair"] == 0
-    assert summary["examples"][0]["kind"] == "wrong_entry"
-    assert summary["examples"][0]["answer_given"] == 3.0
-
-
-def test_audit_classifies_computed_or_guessed_when_both_objects_detected_but_answer_matches_nothing(tmp_path):
-    code_path = tmp_path / "scene.json"
-    _three_class_code(code_path)
-    results_dir = tmp_path / "results"
-    (results_dir / "scene").mkdir(parents=True)
-    question = "distance between the chair and the table ("
-    _write_record(results_dir, 0, answer_given="9.99", spatial_code_path=str(code_path),
-                  question=question)
-
-    summary = citation_audit.audit(results_dir, "m")
-    assert summary["breakdown"]["computed_or_guessed"] == 1
-    assert summary["examples"][0]["kind"] == "computed_or_guessed"
-
-
-def test_audit_classifies_missing_class_separately_from_wrong_entry(tmp_path):
-    """A question naming an object that was never detected at all (no class match in
-    the code) is NOT the same failure as citing the wrong existing entry -- no lookup
-    was ever possible, so this can't be blamed on the model's name-resolution."""
-    code_path = tmp_path / "scene.json"
-    _write_code(
-        code_path,
-        {"door": {"toilet": {"distance": "0.0 meters", "closeness rank": 1}}},
-        objects={"door": {"count": 1}, "toilet": {"count": 1}},
-    )
-    results_dir = tmp_path / "results"
-    (results_dir / "scene").mkdir(parents=True)
-    _write_record(
-        results_dir, 0, answer_given="0.58", spatial_code_path=str(code_path),
-        question="distance between the door and the ceiling light (",
-    )
-
-    summary = citation_audit.audit(results_dir, "m")
-    assert summary["examples"][0]["kind"] == "missing_class"
-    assert summary["breakdown"]["missing_class"] == 1
-    assert summary["breakdown"]["wrong_entry"] == 0
-
-
-def test_audit_skips_other_models_and_other_question_types(tmp_path):
-    code_path = tmp_path / "scene.json"
-    _three_class_code(code_path)
-    results_dir = tmp_path / "results"
-    (results_dir / "scene").mkdir(parents=True)
-    question = "distance between the chair and the table ("
-    _write_record(results_dir, 0, model="other", answer_given="1.46",
-                  spatial_code_path=str(code_path), question=question)
-    _write_record(results_dir, 1, question_type="object_counting", answer_given="3",
-                  spatial_code_path=str(code_path), question=question)
-
-    summary = citation_audit.audit(results_dir, "m")
-    assert summary["total_answered"] == 0
-    assert summary["unanswered"] == 0
-
-
-def test_audit_parses_answers_with_units_attached(tmp_path):
-    """Regression: answer_given values like "1.46 meters" (units not stripped by the
-    adapter) must still count as answered and be checked against the table -- an
-    early version used bare float() and silently misclassified every such answer as
-    unanswered, corrupting every downstream rate."""
-    code_path = tmp_path / "scene.json"
-    _three_class_code(code_path)
-    results_dir = tmp_path / "results"
-    (results_dir / "scene").mkdir(parents=True)
-    question = "distance between the chair and the table ("
-    _write_record(results_dir, 0, answer_given="1.46 meters", spatial_code_path=str(code_path),
-                  question=question)
-    _write_record(results_dir, 1, answer_given="no idea", spatial_code_path=str(code_path),
-                  question=question)
-
-    summary = citation_audit.audit(results_dir, "m")
-    assert summary["total_answered"] == 1
-    assert summary["breakdown"]["correct_pair"] == 1
-    assert summary["unanswered"] == 1  # "no idea" has no number at all -- genuinely unanswered
-
-
-def test_audit_respects_condition_prefix(tmp_path):
-    code_path = tmp_path / "scene.json"
-    _three_class_code(code_path)
-    results_dir = tmp_path / "results"
-    (results_dir / "scene").mkdir(parents=True)
-    question = "distance between the chair and the table ("
-    _write_record(results_dir, 0, answer_given="1.46", spatial_code_path=str(code_path),
-                  question=question, condition="base:x")
-    _write_record(results_dir, 1, answer_given="1.46", spatial_code_path=str(code_path),
-                  question=question, condition="512:x")
-
-    summary = citation_audit.audit(results_dir, "m", condition_prefix="base")
-    assert summary["total_answered"] == 1
-
-
-def test_find_class_rejects_substring_false_positive():
-    """Regression: "washer" must NOT match "dishwasher" just because the characters
-    appear inside it -- found via a real audit example (scene 44358499, question 794)
-    where "dishwasher" was never a detected class but the old substring matcher
-    silently resolved it to "washer", misclassifying a genuine missing_class case as
-    a fixable wrong_entry."""
-    code = {"objects": {"washer": {"count": 1}, "table": {"count": 1}}}
-    assert citation_audit._find_class("dishwasher", code) is None
-
-
-def test_find_class_still_matches_legitimate_multiword_classes():
-    code = {"objects": {"trash can": {"count": 1}, "night stand": {"count": 1}}}
-    assert citation_audit._find_class("can", code) == "trash can"
-    assert citation_audit._find_class("the trash can", code) == "trash can"
-    assert citation_audit._find_class("stand", code) == "night stand"

tests/test_analysis/test_compare.py

@@ -1,116 +0,0 @@
-"""Tests for analysis/compare.py -- matched-question cross-harness comparison."""
-
-from analysis import compare as analysis_compare
-
-
-def _record(harness, question_id, score, scene="scene_a", model="qwen3.5-2b"):
-    conditions = {
-        "A": "extended:selective:32",
-        "B": "extended:explicit:relative:tracking:selective:32",
-        "C": "extended:explicit:relative:tracking:selective:32",
-        "D": "extended:explicit",
-        "E": "extended",
-    }
-    return {
-        "model": model,
-        "condition": conditions[harness],
-        "question_id": question_id,
-        "scene": scene,
-        "question_type": "object_counting",
-        "answer_expected": "4",
-        "metric": "MRA:.5:.95:.05",
-        "score": score,
-    }
-
-
-def test_parse_a_condition_splits_protocol_selection_frames():
-    assert analysis_compare._parse_a_condition("base:uniform:16") == (
-        "base", "uniform", "16"
-    )
-
-
-def test_parse_bc_condition_splits_all_six_axes():
-    assert analysis_compare._parse_bc_condition(
-        "extended:explicit:relative:tracking:selective:64"
-    ) == ("extended", "explicit", "relative", "tracking", "selective", "64")
-
-
-def test_parse_d_condition_splits_protocol_and_format():
-    assert analysis_compare._parse_d_condition("base:compact") == ("base", "compact")
-
-
-def _patch_dirs(monkeypatch, by_dir):
-    from analysis.aggregate import RESULTS_DIRS
-
-    def fake_iter_records(results_dir):
-        for harness, records in by_dir.items():
-            if str(results_dir) == str(RESULTS_DIRS[harness]):
-                return list(records)
-        return []
-
-    monkeypatch.setattr(analysis_compare, "iter_records", fake_iter_records)
-
-
-def test_compare_scores_only_the_shared_question_intersection(monkeypatch):
-    # A answered questions 1-3; B only 1-2 -- the row must be scored on {1, 2} for
-    # BOTH cells, with each cell's full count still reported.
-    _patch_dirs(monkeypatch, {
-        "A": [_record("A", 1, 1.0), _record("A", 2, 0.0), _record("A", 3, 1.0)],
-        "B": [_record("B", 1, 1.0), _record("B", 2, 1.0)],
-    })
-    rows = analysis_compare.compare()
-    row = rows[("qwen3.5-2b", "extended", "selective", "32")]
-    assert row["common_count"] == 2
-    assert row["cells"]["A"]["full_count"] == 3
-    assert row["cells"]["B_explicit:relative:tracking"]["full_count"] == 2
-    # A scored 1.0 on q1 and 0.0 on q2 -> 50.0 on the shared set (q3's 1.0 excluded).
-    assert row["cells"]["A"]["overall"] == 50.0
-    assert row["cells"]["B_explicit:relative:tracking"]["overall"] == 100.0
-
-
-def test_compare_joins_d_and_e_on_model_and_protocol(monkeypatch):
-    _patch_dirs(monkeypatch, {
-        "A": [_record("A", 1, 1.0)],
-        "D": [_record("D", 1, 1.0)],
-        "E": [_record("E", 1, 0.0)],
-    })
-    rows = analysis_compare.compare()
-    row = rows[("qwen3.5-2b", "extended", "selective", "32")]
-    assert row["cells"]["D_explicit"]["overall"] == 100.0
-    assert row["cells"]["E"]["overall"] == 0.0
-
-
-def test_compare_keeps_protocols_in_separate_rows(monkeypatch):
-    base_a = _record("A", 1, 1.0)
-    base_a["condition"] = "base:selective:32"
-    _patch_dirs(monkeypatch, {"A": [base_a, _record("A", 1, 0.0)]})
-    rows = analysis_compare.compare()
-    assert ("qwen3.5-2b", "base", "selective", "32") in rows
-    assert ("qwen3.5-2b", "extended", "selective", "32") in rows
-
-
-def test_format_score_handles_none():
-    assert analysis_compare._format_score(None) == "-"
-    assert analysis_compare._format_score(47.5) == "47.50"
-
-
-def test_write_csv_round_trips_through_a_real_file(tmp_path, monkeypatch):
-    import csv
-
-    _patch_dirs(monkeypatch, {
-        "A": [_record("A", 1, 1.0)],
-        "B": [_record("B", 1, 1.0)],
-    })
-    rows = analysis_compare.compare()
-    csv_path = tmp_path / "compare.csv"
-    analysis_compare.write_csv(rows, csv_path)
-
-    with csv_path.open(encoding="utf-8") as stream:
-        read_rows = list(csv.DictReader(stream))
-    assert len(read_rows) == 1
-    row = read_rows[0]
-    assert row["model"] == "qwen3.5-2b"
-    assert row["protocol"] == "extended"
-    assert row["common_count"] == "1"
-    assert row["A"] == "100.0"
-    assert row["B_explicit:relative:tracking"] == "100.0"

tests/test_analysis/test_cot_audit.py

@@ -1,76 +0,0 @@
-"""Tests for analysis/cot_audit.py -- deterministic reasoning-trace audit (H23)."""
-
-import json
-
-from analysis import cot_audit
-
-
-def test_numbers_in_extracts_floats_and_ints():
-    assert cot_audit.numbers_in("the sofa is 2.5 m from 3 chairs") == [2.5, 3.0]
-
-
-def test_code_numbers_reads_nested_values_and_unit_strings():
-    code = {"objects": {"chair": {"count": 2, "instances": [{"x": "4.98 meters"}]}}}
-    numbers = cot_audit.code_numbers(code)
-    assert 2.0 in numbers
-    assert 4.98 in numbers
-
-
-def _record(tmp_path, reasoning, score=0.0, question="How far is the sofa?", options=None):
-    code = {"objects": {"sofa": {"instances": [{"x coordinate": "4.98 meters"}]}}}
-    code_path = tmp_path / "code.json"
-    code_path.write_text(json.dumps(code))
-    return {
-        "question_id": 1,
-        "question_type": "object_abs_distance",
-        "score": score,
-        "reasoning_text": reasoning,
-        "spatial_code_path": str(code_path),
-        "question": question,
-        "options": options,
-    }
-
-
-def test_audit_record_grounds_cited_code_values(tmp_path):
-    record = _record(tmp_path, "the sofa is at 4.98, so the answer is 4.98")
-    result = cot_audit.audit_record(record)
-    assert result["cited"] == 2
-    assert result["fabricated"] == 0
-
-
-def test_audit_record_flags_fabricated_values(tmp_path):
-    record = _record(tmp_path, "the sofa is at 123.45 meters")
-    result = cot_audit.audit_record(record)
-    assert result["fabricated"] == 1
-    assert result["fabricated_values"] == [123.45]
-
-
-def test_small_integers_are_whitelisted_as_derived_counts(tmp_path):
-    record = _record(tmp_path, "there are 7 objects in total")
-    result = cot_audit.audit_record(record)
-    assert result["fabricated"] == 0
-
-
-def test_question_and_option_numbers_are_grounded(tmp_path):
-    record = _record(
-        tmp_path, "option B says 87.5", question="Which?", options=["A. 20.5", "B. 87.5"]
-    )
-    assert cot_audit.audit_record(record)["fabricated"] == 0
-
-
-def test_audit_summary_splits_wrong_answers_by_fabrication(tmp_path):
-    records = [
-        _record(tmp_path, "answer from 4.98", score=0.0),
-        _record(tmp_path, "made up 99.99", score=0.0),
-        _record(tmp_path, "correct, 4.98", score=1.0),
-    ]
-    _audits, summary = cot_audit.audit(records)
-    assert summary["audited"] == 3
-    assert summary["wrong"] == 2
-    assert summary["wrong_with_fabrication"] == 1
-    assert summary["fabrication_share_of_wrong"] == 0.5
-
-
-def test_audit_skips_records_without_reasoning(tmp_path):
-    record = _record(tmp_path, None)
-    assert cot_audit.audit_record(record) is None

tests/test_analysis/test_depth.py

@@ -1,66 +0,0 @@
-"""Tests for analysis/depth.py -- solver computation-depth transfer (H25)."""
-
-import json
-
-from analysis import depth
-
-
-def _gt_code():
-    return {
-        "spatial code schema": {},
-        "objects": {
-            "chair": [
-                {
-                    "3D oriented bounding box": {
-                        "3D oriented bounding box center coordinates": [0.0, 0.0, 0.5],
-                        "3D oriented bounding box dimensions": [1.0, 1.0, 1.0],
-                        "3D oriented bounding box orientation unit vectors": [
-                            [1.0, 0.0, 0.0], [0.0, 0.0, 1.0], [0.0, -1.0, 0.0],
-                        ],
-                    },
-                    "first visible time": 0.0,
-                }
-            ]
-        },
-        "room": {"floor boundary polygons": []},
-    }
-
-
-def test_question_depth_counts_solver_operations(tmp_path):
-    code_path = tmp_path / "code.json"
-    code_path.write_text(json.dumps(_gt_code()))
-    record = {
-        "question_type": "object_counting",
-        "question": "How many chair(s) are in this room?",
-        "options": None,
-        "spatial_code_path": str(code_path),
-    }
-    ops = depth.question_depth(record, {})
-    assert ops is not None and ops >= 1
-
-
-def test_question_depth_unreadable_code_returns_none():
-    record = {
-        "question_type": "object_counting",
-        "question": "How many chairs?",
-        "options": None,
-        "spatial_code_path": "/does/not/exist.json",
-    }
-    assert depth.question_depth(record, {}) is None
-
-
-def test_depth_table_buckets_by_operation_count(tmp_path):
-    code_path = tmp_path / "code.json"
-    code_path.write_text(json.dumps(_gt_code()))
-    records = [
-        {
-            "question_type": "object_counting",
-            "question": "How many chair(s) are in this room?",
-            "options": None,
-            "spatial_code_path": str(code_path),
-            "score": 1.0,
-        }
-    ]
-    table, pairs = depth.depth_table(records)
-    assert len(pairs) == 1
-    assert sum(stats["count"] for stats in table.values()) == 1

tests/test_analysis/test_letters_reports.py

@@ -0,0 +1,28 @@
+from conftest import ReportTestCase,vlm
+from analysis import letters_reports
+class TestLettersReports(ReportTestCase):
+ def test_arbitrary_subset_and_combined_name(self):
+  cells={l:self.directory(l,[vlm(l)]) for l in "AC"}
+  result=letters_reports.generate(cells,["base"],output_dir=self.root/"reports")
+  self.assertEqual({p.name for p in result["paths"]},{"A_report.json","C_report.json","AC_report.json"})
+ def test_DF_and_BF_semantic_alignment(self):
+  d=self.directory("D",[vlm("D")]); f=self.ground_truth_symbolic()
+  result=letters_reports.generate({"D":d,"F":f},["base"],output_dir=self.root/"df")
+  self.assertEqual(len(result["combined_report"]["cross_harness_comparisons"]),1)
+  b=self.directory("B",[vlm("B")]); perceived=self.symbolic(False)
+  result=letters_reports.generate({"B":b,"F":perceived},["base"],output_dir=self.root/"bf")
+  self.assertEqual(len(result["combined_report"]["cross_harness_comparisons"]),1)
+ def test_folded_statistical_and_solver_helpers(self):
+  self.assertEqual(letters_reports.holm_bonferroni({"a":.01,"b":.04,"c":.03}),{"a":.03,"c":.06,"b":.06})
+  a=[{"question_id":1,"score":1.0},{"question_id":2,"score":0.0}]
+  b=[{"question_id":1,"score":1.0},{"question_id":2,"score":1.0}]
+  overlap=letters_reports.solved_set_overlap({"A":a,"B":b})
+  self.assertEqual(overlap["pairs"]["A|B"]["only_B"],1)
+  vlm=[{"question_id":1,"question_type":"count","score":0.0},{"question_id":2,"question_type":"count","score":1.0}]
+  solver=[{"question_id":1,"score":1.0},{"question_id":2,"score":0.0}]
+  split=letters_reports.sufficiency_decomposition(vlm,solver)
+  self.assertEqual(split["certified"]["vlm_wrong"],1)
+ def test_pair_restriction(self):
+  cells={l:self.directory(l,[vlm(l)]) for l in "ABC"}
+  result=letters_reports.generate(cells,["base"],["A:B"],self.root/"reports")
+  self.assertTrue(all(v["letters"]==("A","B") for v in result["combined_report"]["cross_harness_comparisons"].values()))

tests/test_analysis/test_solvability.py

@@ -1,37 +0,0 @@
-"""Tests for analysis/solvability.py -- solved-set overlap (H19, exploratory)."""
-
-from analysis import solvability
-
-
-def _cell(scores):
-    return [{"question_id": qid, "score": score} for qid, score in scores.items()]
-
-
-def test_overlap_restricts_to_shared_questions():
-    cells = {
-        "A": _cell({1: 1.0, 2: 0.0, 3: 1.0}),
-        "B": _cell({1: 1.0, 2: 1.0}),  # never answered 3
-    }
-    report = solvability.overlap(cells)
-    assert report["questions"] == 2
-    assert report["solved"] == {"A": 1, "B": 2}
-
-
-def test_overlap_pairwise_jaccard_and_exclusives():
-    cells = {
-        "A": _cell({1: 1.0, 2: 1.0, 3: 0.0}),
-        "B": _cell({1: 1.0, 2: 0.0, 3: 1.0}),
-    }
-    report = solvability.overlap(cells)
-    pair = report["pairs"]["A|B"]
-    assert pair["both"] == 1
-    assert pair["only_A"] == 1
-    assert pair["only_B"] == 1
-    assert pair["jaccard"] == 1 / 3
-    assert report["solved_by_all"] == 1
-    assert report["solved_by_none"] == 0
-
-
-def test_overlap_empty_intersection():
-    report = solvability.overlap({"A": _cell({1: 1.0}), "B": _cell({2: 1.0})})
-    assert report == {"questions": 0}

tests/test_analysis/test_stats.py

@@ -1,59 +0,0 @@
-"""Tests for analysis/stats.py -- scene-clustered paired bootstrap."""
-
-from analysis import stats as analysis_stats
-
-
-def _record(question_id, score, scene):
-    return {"question_id": question_id, "score": score, "scene": scene}
-
-
-def test_paired_questions_matches_on_question_id_intersection():
-    x = [_record(1, 1.0, "a"), _record(2, 0.0, "a"), _record(3, 1.0, "b")]
-    y = [_record(1, 0.0, "a"), _record(3, 1.0, "b"), _record(9, 1.0, "z")]
-    by_scene = analysis_stats.paired_questions(x, y)
-    assert by_scene == {"a": [(1.0, 0.0)], "b": [(1.0, 1.0)]}
-
-
-def test_paired_bootstrap_returns_none_on_empty_intersection():
-    assert analysis_stats.paired_bootstrap([_record(1, 1.0, "a")], [_record(2, 1.0, "a")]) is None
-
-
-def test_paired_bootstrap_observed_delta_is_mean_paired_difference():
-    x = [_record(1, 0.0, "a"), _record(2, 0.0, "a"), _record(3, 0.0, "b"), _record(4, 0.0, "b")]
-    y = [_record(1, 1.0, "a"), _record(2, 1.0, "a"), _record(3, 1.0, "b"), _record(4, 0.0, "b")]
-    result = analysis_stats.paired_bootstrap(x, y, iterations=200, seed=0)
-    assert result["delta"] == 0.75
-    assert result["questions"] == 4
-    assert result["scenes"] == 2
-    assert result["ci_low"] <= result["delta"] <= result["ci_high"]
-
-
-def test_paired_bootstrap_is_deterministic_for_a_fixed_seed():
-    x = [_record(i, 0.0, f"s{i % 3}") for i in range(9)]
-    y = [_record(i, float(i % 2), f"s{i % 3}") for i in range(9)]
-    first = analysis_stats.paired_bootstrap(x, y, iterations=300, seed=7)
-    second = analysis_stats.paired_bootstrap(x, y, iterations=300, seed=7)
-    assert first == second
-
-
-def test_paired_bootstrap_zero_delta_when_cells_identical():
-    x = [_record(i, 1.0, "a") for i in range(4)]
-    result = analysis_stats.paired_bootstrap(x, list(x), iterations=100, seed=0)
-    assert result["delta"] == 0.0
-    assert result["ci_low"] == 0.0
-    assert result["ci_high"] == 0.0
-
-
-def test_paired_bootstrap_reports_a_floored_p_value():
-    x = [_record(i, 0.0, f"s{i % 3}") for i in range(9)]
-    y = [_record(i, 1.0, f"s{i % 3}") for i in range(9)]
-    result = analysis_stats.paired_bootstrap(x, y, iterations=200, seed=0)
-    assert result["p_value"] == 1 / 200  # every resample is positive -> floor
-
-
-def test_holm_bonferroni_adjusts_and_stays_monotone():
-    adjusted = analysis_stats.holm_bonferroni({"a": 0.01, "b": 0.04, "c": 0.03})
-    assert adjusted["a"] == 0.03   # 3 * 0.01
-    assert adjusted["c"] == 0.06   # 2 * 0.03
-    assert adjusted["b"] == 0.06   # 1 * 0.04 = 0.04, raised to running max
-    assert all(value <= 1.0 for value in adjusted.values())

tests/test_analysis/test_sufficiency.py

@@ -1,49 +0,0 @@
-"""Tests for analysis/sufficiency.py -- solver-certified decomposition (H26)."""
-
-from analysis import sufficiency
-
-
-def _solver(question_id, score):
-    return {"question_id": question_id, "score": score}
-
-
-def _vlm(question_id, score, question_type="object_counting"):
-    return {"question_id": question_id, "score": score, "question_type": question_type}
-
-
-def test_certificates_threshold():
-    certs = sufficiency.certificates([_solver(1, 1.0), _solver(2, 0.4), _solver(3, None)])
-    assert certs == {1: True, 2: False, 3: False}
-
-
-def test_decompose_splits_proven_reasoning_from_information_failures():
-    solver_records = [_solver(1, 1.0), _solver(2, 1.0), _solver(3, 0.0)]
-    vlm_records = [_vlm(1, 1.0), _vlm(2, 0.0), _vlm(3, 0.0)]
-    result = sufficiency.decompose(vlm_records, solver_records)
-    assert result["questions"] == 3
-    # q1: certified + VLM correct; q2: certified + VLM wrong = PROVEN reasoning failure.
-    assert result["certified"]["count"] == 2
-    assert result["certified"]["vlm_correct"] == 1
-    assert result["certified"]["vlm_wrong"] == 1
-    # q3: uncertified -- information failure, not reasoning evidence.
-    assert result["uncertified"]["count"] == 1
-
-
-def test_decompose_ignores_unmatched_and_excluded():
-    solver_records = [_solver(1, 1.0)]
-    vlm_records = [
-        _vlm(1, 1.0),
-        _vlm(2, 1.0),  # solver never answered -> excluded from the join
-        _vlm(3, 1.0, question_type="obj_appearance_order"),
-    ]
-    result = sufficiency.decompose(
-        vlm_records, solver_records, exclude=("obj_appearance_order",)
-    )
-    assert result["questions"] == 1
-
-
-def test_decompose_empty_bucket_stats():
-    result = sufficiency.decompose([_vlm(1, 1.0)], [_solver(1, 1.0)])
-    assert result["uncertified"] == {
-        "count": 0, "mean_score": None, "vlm_correct": 0, "vlm_wrong": 0,
-    }