Replace analysis with local workspace contents

analysis/A_reports.py

@@ -0,0 +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
+    )
+
+
+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()

analysis/B_reports.py

@@ -0,0 +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
+    )
+
+
+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()

analysis/C_reports.py

@@ -0,0 +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
+    )
+
+
+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()

analysis/F_reports.py

@@ -0,0 +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
+    )
+
+
+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()

analysis/letters_reports.py

@@ -0,0 +1,1132 @@
+"""Comprehensive, matched A/B/C result analysis.
+
+Reports coverage, score, question-type and dataset breakdowns, response/prompt/token
+lengths, latency, limit/forced rates, spatial-code size for B/C, score relationships,
+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
+from collections import Counter, defaultdict
+from itertools import combinations
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parent.parent
+DEFAULT_DIRS = {h: Path("/root/results") / h for h in "ABCE"}
+NUMERIC_FIELDS = (
+    "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",
+)
+
+
+def iter_records(directory):
+    root = Path(directory)
+    if not root.is_dir():
+        return
+    for path in sorted(root.rglob("*.json")):
+        try:
+            with 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
+            and "condition" in record
+        ):
+            yield record
+
+
+def protocol_selected(protocol, selectors):
+    if protocol is None:
+        return not selectors
+    return not selectors or any(
+        protocol == item or ("/" not in item and protocol.startswith(item + "/"))
+        for item in selectors
+    )
+
+
+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")),
+    }
+    if harness in ("B", "C"):
+        common.update(
+            {
+                "format": record.get("spatial_code_format"),
+                "depth": record.get("depth"),
+                "tracking": record.get("tracking"),
+            }
+        )
+    return tuple(sorted(common.items()))
+
+
+def identity_dict(identity):
+    return 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"),
+    ]
+    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)
+
+
+def comparison_key(identity):
+    d = identity_dict(identity)
+    return d.get("model"), d.get("protocol"), d.get("selection"), d.get("frames")
+
+
+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)
+        ):
+            out.append(float(value))
+    return out
+
+
+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(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)
+    ]
+    if len(pairs) < 2:
+        return None
+    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
+
+
+def spatial_code_bytes(record, cache):
+    path = record.get("spatial_code_path")
+    if not path:
+        return None
+    if path not in cache:
+        try:
+            cache[path] = Path(path).stat().st_size
+        except OSError:
+            cache[path] = None
+    return cache[path]
+
+
+def breakdown(records, field):
+    groups = defaultdict(list)
+    for record in records:
+        groups[str(record.get(field) or "<missing>")].append(record)
+    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
+            ),
+            "scenes": len({r.get("scene") for r in group}),
+        }
+        for name, group in sorted(groups.items())
+    }
+
+
+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
+    }
+    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
+        },
+        "spatial_code_bytes": lambda r: spatial_code_bytes(r, code_cache),
+    }
+    for name, getter in measures.items():
+        pairs = [(r.get("score"), getter(r)) for r in records]
+        relationships["score_vs_" + name] = pearson(
+            [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}),
+        "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,
+        "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
+            ),
+            "reasoning_present": (
+                statistics.mean(
+                    bool(r.get("reasoning_text") or r.get("reasoning_raw"))
+                    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")
+                }
+            ),
+            "readable_file_bytes": numeric_summary(code_sizes),
+        },
+        "relationships": relationships,
+    }
+
+
+def paired_breakdown(x, y, common, field):
+    groups = defaultdict(list)
+    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
+    }
+
+
+def _scene_bootstrap(x, y, common, iterations=1000, seed=0):
+    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"]
+        )
+    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 = []
+    for _ in range(iterations):
+        values = []
+        for _ in scenes:
+            values.extend(by_scene[rng.choice(scenes)])
+        draws.append(statistics.mean(values))
+    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))
+    }
+    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
+    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))
+        ]
+        telemetry[field + "_delta"] = numeric_summary(vals)
+    return {
+        "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_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,
+        },
+        "by_question_type": paired_breakdown(x, y, common, "question_type"),
+        "by_dataset": paired_breakdown(x, y, common, "dataset"),
+        "telemetry_deltas": telemetry,
+    }
+
+
+def analyze(directories=None, protocols=()):
+    directories = directories or DEFAULT_DIRS
+    cells = defaultdict(list)
+    for harness, directory in directories.items():
+        for record in iter_records(directory):
+            protocol = record.get("protocol") or record["condition"].split(":", 1)[0]
+            if protocol_selected(protocol, protocols):
+                cells[cell_identity(harness, record)].append(record)
+    code_cache = {}
+    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),
+        }
+    grouped = defaultdict(list)
+    for identity in cells:
+        grouped[comparison_key(identity)].append(identity)
+    for key, identities in grouped.items():
+        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]
+            )
+        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
+            ),
+            "pairwise": pairs,
+        }
+    return report
+
+
+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; select base or thinking protocol families",
+    )
+    parser.add_argument(
+        "--output-dir",
+        default=str(ROOT / "reports"),
+        help="report directory (default: workspace/reports)",
+    )
+    parser.add_argument(
+        "--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"
+    }
+    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.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) ---
+
+# 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"],
+    },
+    "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")
+    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 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)}]
+    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 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
+        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 ""
+        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
+    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())]
+    )
+
+
+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"]
+    # F source semantics.
+    f = x if lx == "F" else y if ly == "F" else None
+    other = y if lx == "F" else x
+    if f:
+        expected = "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}"]
+            shared.append(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"]
+        shared.append("protocol")
+    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": _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 == "D":
+        raise argparse.ArgumentTypeError(
+            "letter must be one alphabetic character other than D"
+        )
+    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")
+        paths.append(path)
+    return paths
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "--cell",
+        action="append",
+        default=[],
+        help="repeatable LETTER=PATH; D is removed",
+    )
+    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; select base or thinking protocol families",
+    )
+    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 "abce":
+        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 "abce":
+        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}")
+        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}")
+
+
+# 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",
+        }
+
+
+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()}
+
+
+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=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()}
+    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; D is removed."
+    )
+    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()