docking_pipeline/audit_benchmark.py

from __future__ import annotations

import argparse
import csv
import json
import math
import traceback
from pathlib import Path
from typing import Any

from .config_io import dump_json_like, load_structured_file
from .dataset import repair_dataset_dir
from .provenance import RDockPipelineError, require_file
from .rdock import TargetConfig, load_target_config
from .sdf import write_rows_csv


def _read_rows(path: str | Path) -> list[dict[str, str]]:
    with require_file(path, "benchmark table").open("r", encoding="utf-8", newline="") as handle:
        return list(csv.DictReader(handle))


def _load_json_if_exists(path: str | Path) -> dict[str, Any]:
    candidate = Path(path)
    if not candidate.exists():
        return {}
    try:
        payload = json.loads(candidate.read_text(encoding="utf-8"))
    except Exception:
        return {}
    return payload if isinstance(payload, dict) else {}


def _load_struct_if_exists(path: str | Path) -> dict[str, Any]:
    candidate = Path(path)
    if not candidate.exists():
        return {}
    try:
        return load_structured_file(candidate)
    except Exception:
        return {}


def _float(value: object, default: float | None = None) -> float | None:
    try:
        text = str(value).strip()
        if not text:
            return default
        return float(text)
    except Exception:
        return default


def _finite(value: object) -> float | None:
    out = _float(value, None)
    if out is None or not math.isfinite(out):
        return None
    return out


def _score_from_row(row: dict[str, Any], *keys: str) -> float | None:
    for key in keys:
        value = _finite(row.get(key))
        if value is not None:
            return value
    return None


def _boolish(value: object) -> bool:
    return str(value).strip().lower() in {"1", "true", "yes", "y"}


def _mean(values: list[float]) -> float:
    return sum(values) / len(values) if values else 0.0


def _stdev(values: list[float], center: float) -> float:
    if not values:
        return 1.0
    variance = sum((value - center) ** 2 for value in values) / max(1, len(values))
    return math.sqrt(variance) or 1.0


def _sort_by_score(rows: list[dict[str, Any]], *keys: str) -> list[dict[str, Any]]:
    return sorted(
        rows,
        key=lambda row: (
            _score_from_row(row, *keys) if _score_from_row(row, *keys) is not None else float("inf"),
            str(row.get("ligand_id", "")),
        ),
    )


def _augment_full_rows(rows: list[dict[str, Any]]) -> list[dict[str, Any]]:
    success_rows = [row for row in rows if str(row.get("rdock_success", "true")).lower() in {"true", "1", ""} and _score_from_row(row, "best_score", "SCORE", "final_score") is not None]
    ordered = _sort_by_score(success_rows, "best_score", "SCORE", "final_score")
    total = max(1, len(ordered))
    enriched: list[dict[str, Any]] = []
    for idx, row in enumerate(ordered, start=1):
        item = dict(row)
        percentile = 100.0 if total == 1 else 100.0 * (1.0 - ((idx - 1) / (total - 1)))
        item["full_rank"] = idx
        item["rank_vs_full"] = idx
        item["full_percentile"] = percentile
        item["percentile_vs_full"] = percentile
        enriched.append(item)
    return enriched


def _normalize_target_config(cfg: TargetConfig) -> dict[str, Any]:
    return {
        "receptor_name": Path(cfg.receptor).name,
        "reference_ligand_name": Path(cfg.reference_ligand).name,
        "receptor_mol2_name": Path(cfg.receptor_mol2).name,
        "receptor_prm_name": Path(cfg.receptor_prm).name,
        "cavity_as_name": Path(cfg.cavity_as).name,
        "pocket_center": [round(float(value), 4) for value in cfg.pocket_center],
        "pocket_radius": round(float(cfg.pocket_radius), 4),
    }


def _same_target_config(run_dir: Path, dataset_dir: Path | None) -> tuple[bool, list[str]]:
    reasons: list[str] = []
    root_cfg_path = run_dir / "target" / "rdock_prm" / "target_config.yaml"
    if not root_cfg_path.exists():
        reasons.append("missing run target_config.yaml")
        return False, reasons
    root_cfg = _normalize_target_config(load_target_config(root_cfg_path))
    if dataset_dir is None:
        reasons.append("dataset_dir unavailable")
        return False, reasons
    dataset_cfg_path = dataset_dir / "target" / "rdock_prm" / "target_config.yaml"
    if not dataset_cfg_path.exists():
        reasons.append("missing dataset target_config.yaml")
        return False, reasons
    dataset_cfg = _normalize_target_config(load_target_config(dataset_cfg_path))
    if root_cfg != dataset_cfg:
        reasons.append("run target_config differs from dataset target_config")
        return False, reasons
    return True, reasons


def _apply_component_flags(
    rows: list[dict[str, Any]],
    score_z_threshold: float = 5.0,
    intra_z_threshold: float = 4.0,
    max_intra_fraction_soft: float = 0.75,
    max_intra_fraction_hard: float = 0.9,
) -> list[dict[str, Any]]:
    score_values = [_score_from_row(row, "final_score", "SCORE") for row in rows]
    score_values = [value for value in score_values if value is not None]
    intra_values = [_score_from_row(row, "SCORE.INTRA") for row in rows]
    intra_values = [value for value in intra_values if value is not None]
    score_mean = _mean(score_values)
    score_sd = _stdev(score_values, score_mean)
    intra_mean = _mean(intra_values)
    intra_sd = _stdev(intra_values, intra_mean)
    enriched: list[dict[str, Any]] = []
    for row in rows:
        item = dict(row)
        score = _score_from_row(item, "final_score", "SCORE")
        intra = _score_from_row(item, "SCORE.INTRA")
        inter = _score_from_row(item, "SCORE.INTER")
        restr = _score_from_row(item, "SCORE.RESTR")
        intra_fraction = None
        if score is not None and abs(score) > 1e-9 and intra is not None:
            intra_fraction = abs(intra) / abs(score)
        elif intra is not None and abs(intra) > 0.0:
            intra_fraction = math.inf
        intra_z = ((intra - intra_mean) / intra_sd) if intra is not None and intra_sd else 0.0
        score_z = ((score - score_mean) / score_sd) if score is not None and score_sd else 0.0
        dominant_intra_soft = bool(intra_fraction is not None and math.isfinite(intra_fraction) and intra_fraction >= max_intra_fraction_soft)
        dominant_intra_hard = bool(intra_fraction is not None and math.isfinite(intra_fraction) and intra_fraction >= max_intra_fraction_hard)
        intra_outlier = _boolish(item.get("intra_outlier")) or bool(intra is not None and intra_z <= -abs(intra_z_threshold)) or dominant_intra_soft
        score_outlier = _boolish(item.get("score_outlier")) or bool(score is not None and score_z <= -abs(score_z_threshold))
        warnings = [token for token in str(item.get("component_warning", "")).split(",") if token.strip()]
        if intra_outlier and "intra_outlier" not in warnings:
            warnings.append("intra_outlier")
        if score_outlier and "score_outlier" not in warnings:
            warnings.append("score_outlier")
        if dominant_intra_soft and "intra_dominance" not in warnings:
            warnings.append("intra_dominance")
        severe_combined = (score_outlier and intra_outlier) or dominant_intra_hard
        item["SCORE"] = score if score is not None else item.get("SCORE", "")
        item["SCORE.INTER"] = inter if inter is not None else item.get("SCORE.INTER", "")
        item["SCORE.INTRA"] = intra if intra is not None else item.get("SCORE.INTRA", "")
        item["SCORE.RESTR"] = restr if restr is not None else item.get("SCORE.RESTR", "")
        item["intra_fraction"] = intra_fraction if intra_fraction is not None and math.isfinite(intra_fraction) else ("" if intra_fraction is None else "inf")
        item["intra_dominance"] = dominant_intra_soft
        item["intra_outlier"] = intra_outlier
        item["score_outlier"] = score_outlier
        item["component_warning"] = ",".join(warnings)
        penalty = 0.0
        if intra_outlier:
            penalty += 2.0
        if score_outlier:
            penalty += 2.0
        if dominant_intra_soft:
            penalty += 3.0
        if severe_combined:
            penalty += 8.0
        item["adjusted_score"] = (score + penalty) if score is not None else ""
        filtered_reasons: list[str] = []
        if severe_combined and intra_outlier:
            filtered_reasons.append("intra_outlier")
        if severe_combined and score_outlier:
            filtered_reasons.append("score_outlier")
        if dominant_intra_hard:
            filtered_reasons.append("intra_dominance")
        item["filtered_out"] = bool(filtered_reasons)
        item["filtered_reason"] = ",".join(filtered_reasons)
        item["downranked"] = bool(warnings) and not item["filtered_out"]
        item["potential_strain_artifact"] = intra_outlier or dominant_intra_soft
        enriched.append(item)
    return enriched


def _attach_vs_full(
    rows: list[dict[str, Any]],
    full_rows: list[dict[str, Any]],
    universe_complete: bool,
) -> list[dict[str, Any]]:
    full_map = {
        str(row["ligand_id"]): {
            "rank_vs_full": int(row["rank_vs_full"]),
            "percentile_vs_full": float(row["percentile_vs_full"]),
            "full_score": _score_from_row(row, "SCORE"),
        }
        for row in full_rows
    }
    enriched: list[dict[str, Any]] = []
    for row in rows:
        item = dict(row)
        ligand_id = str(item.get("ligand_id", ""))
        entry = full_map.get(ligand_id)
        if entry and universe_complete:
            item["rank_vs_full"] = entry["rank_vs_full"]
            item["percentile_vs_full"] = entry["percentile_vs_full"]
            item["not_comparable"] = False
            item["not_comparable_reason"] = ""
        else:
            item["rank_vs_full"] = ""
            item["percentile_vs_full"] = ""
            item["not_comparable"] = True
            item["not_comparable_reason"] = "ligand_missing_in_full" if entry is None else "full_universe_incomplete"
        enriched.append(item)
    return enriched


def _best_row(rows: list[dict[str, Any]], *score_keys: str) -> dict[str, Any] | None:
    ranked = [row for row in rows if _score_from_row(row, *score_keys) is not None]
    if not ranked:
        return None
    return _sort_by_score(ranked, *score_keys)[0]


def _overlap_count(full_rows: list[dict[str, Any]], sample_rows: list[dict[str, Any]], n: int, *score_keys: str) -> int:
    full_top = {str(row["ligand_id"]) for row in _sort_by_score(full_rows, "SCORE")[:n]}
    sample_top = {str(row["ligand_id"]) for row in _sort_by_score(sample_rows, *score_keys)[:n]}
    return len(full_top & sample_top)


def _trace_lookup(trace_rows: list[dict[str, Any]], final_level: int) -> dict[str, dict[str, Any]]:
    by_id: dict[str, dict[str, Any]] = {}
    for row in trace_rows:
        ligand_id = str(row.get("ligand_id", ""))
        prev = by_id.get(ligand_id)
        level = int(_float(row.get("selected_fidelity_runs"), 0.0) or 0)
        prev_level = int(_float(prev.get("selected_fidelity_runs"), 0.0) or 0) if prev else -1
        if prev is None or level > prev_level or (level == final_level and prev_level != final_level):
            by_id[ligand_id] = dict(row)
    return by_id


def _estimate_total_runs(rows: list[dict[str, Any]], fallback_runs: int) -> int:
    values = []
    for row in rows:
        value = _float(row.get("n_rdock_runs_total_spent"))
        if value is not None:
            values.append(int(value))
    if values:
        return sum(values)
    return len(rows) * max(0, int(fallback_runs))


def _load_reference_ids(run_dir: Path, reference_mode: str) -> list[str]:
    if reference_mode != "sampled":
        return []
    sample_path = run_dir / "tables" / "reference_sample_ligand_ids.txt"
    if not sample_path.exists():
        return []
    return [line.strip() for line in sample_path.read_text(encoding="utf-8").splitlines() if line.strip()]


def _time_breakdown(run_dir: Path, existing_metrics: dict[str, Any], final_level: int) -> dict[str, Any]:
    checkpoints = run_dir / "checkpoints"
    full_ckpt = _load_json_if_exists(checkpoints / "full_docking.json")
    single_ckpt = _load_json_if_exists(checkpoints / "single_fidelity.json")
    random_ckpt = _load_json_if_exists(checkpoints / "random_baseline.json")
    walltime = _float(existing_metrics.get("walltime_total_seconds"), 0.0) or 0.0
    docking_total = _float(existing_metrics.get("docking_time_seconds"), 0.0) or 0.0
    full_docking = _float(full_ckpt.get("full_docking_seconds"), 0.0) or 0.0
    single_docking = _float(single_ckpt.get("seconds"), 0.0) or 0.0
    random_docking = _float(random_ckpt.get("seconds"), 0.0) or 0.0
    training = _float(existing_metrics.get("training_time_seconds"), 0.0) or 0.0
    parsing = _float(existing_metrics.get("parsing_time_seconds"), 0.0) or 0.0
    split_merge = _float(existing_metrics.get("sdf_split_merge_time_seconds"), 0.0) or 0.0
    scheduler = _float(existing_metrics.get("scheduler_time_seconds"), 0.0) or 0.0
    io_time = _float(existing_metrics.get("io_time_seconds"), 0.0) or 0.0
    known = docking_total + training + parsing + split_merge + scheduler + io_time
    overhead = max(0.0, walltime - known)
    overhead_fraction = (overhead / walltime) if walltime > 0 else 0.0
    warnings: list[str] = []
    if overhead_fraction > 0.30:
        warnings.append("overhead_fraction_gt_30pct")
    return {
        "walltime_total_seconds": walltime,
        "docking_time_seconds": docking_total,
        "training_time_seconds": training,
        "parsing_time_seconds": parsing,
        "sdf_split_merge_time_seconds": split_merge,
        "scheduler_time_seconds": scheduler,
        "io_time_seconds": io_time,
        "overhead_unclassified_seconds": overhead,
        "overhead_fraction": overhead_fraction,
        "time_warnings": warnings,
        "final_fidelity_runs": final_level,
        "full_docking_time_seconds": full_docking,
        "single_fidelity_time_seconds": single_docking,
        "random_baseline_time_seconds": random_docking,
        "multifidelity_docking_time_seconds": max(0.0, docking_total - full_docking - single_docking - random_docking),
    }


def _render_report(
    run_dir: Path,
    metrics: dict[str, Any],
    comparability: dict[str, Any],
    final_raw_rows: list[dict[str, Any]],
    final_downranked_rows: list[dict[str, Any]],
    final_filtered_rows: list[dict[str, Any]],
) -> str:
    lines = [
        f"# benchmark-adaptive audit: {metrics.get('target_id') or run_dir.name}",
        "",
        f"## {metrics.get('benchmark_status', 'BENCHMARK PARTIAL / NOT COMPARABLE')}",
        "",
        "## Comparability",
        f"- comparable: `{comparability.get('comparable')}`",
        f"- same_target_config: `{comparability.get('same_target_config')}`",
        f"- same_dataset_manifest: `{comparability.get('same_dataset_manifest')}`",
        f"- same_final_fidelity_runs: `{comparability.get('same_final_fidelity_runs')}`",
        f"- stale_checkpoint_detected: `{comparability.get('stale_checkpoint_detected')}`",
    ]
    for reason in comparability.get("reasons", []):
        lines.append(f"- reason: `{reason}`")
    if not comparability.get("comparable"):
        lines.extend(["", "> WARNING: this benchmark is not fully comparable; rank/percentile claims should be treated as non-authoritative."])
    lines.extend(
        [
            "",
            "## Corrected Metrics",
        ]
    )
    ordered_keys = [
        "best_raw_hit_ligand_id",
        "best_raw_hit_score",
        "best_filtered_hit_ligand_id",
        "best_filtered_hit_score",
        "best_random_hit_ligand_id",
        "best_random_hit_score",
        "best_random_filtered_hit_ligand_id",
        "best_random_filtered_hit_score",
        "best_single_fidelity_ligand_id",
        "best_single_fidelity_score",
        "best_full_docking_ligand_id",
        "best_full_docking_score",
        "multifidelity_rank_vs_full",
        "multifidelity_percentile_vs_full",
        "random_rank_vs_full",
        "random_percentile_vs_full",
        "single_fidelity_rank_vs_full",
        "single_fidelity_percentile_vs_full",
        "adaptive_gain_score",
        "adaptive_gain_score_filtered",
        "multifidelity_total_runs_spent",
        "random_total_runs_spent",
        "single_fidelity_total_runs_spent",
        "cost_ratio",
        "walltime_total_seconds",
        "docking_time_seconds",
        "training_time_seconds",
        "parsing_time_seconds",
        "sdf_split_merge_time_seconds",
        "scheduler_time_seconds",
        "io_time_seconds",
        "overhead_unclassified_seconds",
        "overhead_fraction",
        "filtered_outlier_count",
    ]
    for key in ordered_keys:
        if key in metrics:
            lines.append(f"- {key}: `{metrics.get(key)}`")
    for warning in metrics.get("warnings", []):
        lines.append(f"- warning: `{warning}`")
    lines.extend(["", "## Top Raw Final Hits"])
    for row in final_raw_rows[:20]:
        lines.append(
            f"- `{row.get('ligand_id')}` SCORE `{row.get('final_score', row.get('SCORE', ''))}` "
            f"SCORE.INTER `{row.get('SCORE.INTER', '')}` SCORE.INTRA `{row.get('SCORE.INTRA', '')}` "
            f"SCORE.RESTR `{row.get('SCORE.RESTR', '')}` intra_fraction `{row.get('intra_fraction', '')}` "
            f"raw_rank `{row.get('raw_rank', '')}` downranked_rank `{row.get('downranked_rank', '')}` filtered_rank `{row.get('filtered_rank', '')}` "
            f"rank_vs_full `{row.get('rank_vs_full', '')}` percentile_vs_full `{row.get('percentile_vs_full', '')}` "
            f"warnings `{row.get('component_warning', '')}`"
        )
    lines.extend(["", "## Top Downranked Final Hits"])
    for row in final_downranked_rows[:20]:
        lines.append(
            f"- `{row.get('ligand_id')}` SCORE `{row.get('final_score', row.get('SCORE', ''))}` "
            f"adjusted `{row.get('adjusted_score', '')}` SCORE.INTER `{row.get('SCORE.INTER', '')}` SCORE.INTRA `{row.get('SCORE.INTRA', '')}` "
            f"intra_fraction `{row.get('intra_fraction', '')}` raw_rank `{row.get('raw_rank', '')}` downranked_rank `{row.get('downranked_rank', '')}` "
            f"warnings `{row.get('component_warning', '')}`"
        )
    lines.extend(["", "## Top Filtered Final Hits"])
    for row in final_filtered_rows[:20]:
        lines.append(
            f"- `{row.get('ligand_id')}` SCORE `{row.get('final_score', row.get('SCORE', ''))}` "
            f"SCORE.INTER `{row.get('SCORE.INTER', '')}` SCORE.INTRA `{row.get('SCORE.INTRA', '')}` "
            f"SCORE.RESTR `{row.get('SCORE.RESTR', '')}` intra_fraction `{row.get('intra_fraction', '')}` "
            f"raw_rank `{row.get('raw_rank', '')}` downranked_rank `{row.get('downranked_rank', '')}` filtered_rank `{row.get('filtered_rank', '')}` "
            f"rank_vs_full `{row.get('rank_vs_full', '')}` percentile_vs_full `{row.get('percentile_vs_full', '')}` "
            f"warnings `{row.get('component_warning', '')}`"
        )
    return "\n".join(lines) + "\n"


def audit_benchmark_run(run_dir: str | Path) -> dict[str, Any]:
    root = Path(run_dir)
    tables = root / "tables"
    metrics_dir = root / "metrics"
    raw_metrics = _load_json_if_exists(metrics_dir / "adaptive_benchmark_metrics_raw.json")
    existing_metrics = raw_metrics or _load_json_if_exists(metrics_dir / "adaptive_benchmark_metrics.json")
    validation_metrics = _load_json_if_exists(metrics_dir / "validation_metrics.json")
    signature = _load_json_if_exists(root / "checkpoints" / "run_signature.json")
    config = _load_struct_if_exists(root / "config.yaml")
    manifest = _load_json_if_exists(root / "manifest.json")
    dataset_dir_value = config.get("dataset_dir") or existing_metrics.get("dataset_dir") or manifest.get("dataset_dir")
    dataset_dir = Path(dataset_dir_value) if dataset_dir_value else None
    dataset_repair: dict[str, Any] = {}
    dataset_manifest: dict[str, Any] = {}
    if dataset_dir and dataset_dir.exists():
        dataset_repair = repair_dataset_dir(dataset_dir)
        dataset_manifest = _load_json_if_exists(dataset_dir / "dataset_manifest.json")
    reference_mode = str(
        config.get("reference_mode")
        or signature.get("reference_mode")
        or raw_metrics.get("reference_mode")
        or validation_metrics.get("reference_mode")
        or existing_metrics.get("reference_mode")
        or "full"
    ).lower()
    evaluation_pool_mode = str(
        config.get("evaluation_pool_mode")
        or signature.get("evaluation_pool_mode")
        or raw_metrics.get("evaluation_pool_mode")
        or validation_metrics.get("evaluation_pool_mode")
        or existing_metrics.get("evaluation_pool_mode")
        or "same_pool"
    ).lower()
    final_level = 0
    levels = config.get("fidelity_levels") or signature.get("fidelity_levels") or raw_metrics.get("fidelity_levels") or validation_metrics.get("fidelity_levels") or existing_metrics.get("fidelity_levels") or []
    if isinstance(levels, list) and levels:
        final_level = int(levels[-1])
    elif isinstance(levels, str) and levels.strip():
        final_level = int(str(levels).split(",")[-1].strip())

    full_table_rows = _read_rows(tables / "full_docking_scores.csv") if (tables / "full_docking_scores.csv").exists() else []
    full_rows = _augment_full_rows(full_table_rows) if full_table_rows else []
    full_rank_map = {str(row["ligand_id"]): row for row in full_rows}
    normalized_full_rows: list[dict[str, Any]] = []
    for row in full_table_rows:
        item = dict(row)
        item.update({k: v for k, v in full_rank_map.get(str(row.get("ligand_id", "")), {}).items() if k not in item or item[k] in {"", None}})
        normalized_full_rows.append(item)
    if normalized_full_rows:
        write_rows_csv(normalized_full_rows, tables / "full_docking_scores.csv")
    full_ligand_ids = {str(row["ligand_id"]) for row in normalized_full_rows}
    expected_universe = int(_float(dataset_manifest.get("ligands_prepared"), len(full_rows)) or len(full_rows))
    reference_ids = _load_reference_ids(root, reference_mode)
    reference_sample_size = int(
        _float(
            config.get("reference_sample_size")
            or signature.get("reference_sample_size")
            or raw_metrics.get("reference_sample_size")
            or validation_metrics.get("reference_sample_size"),
            len(normalized_full_rows) if reference_mode == "sampled" else expected_universe,
        )
        or (len(normalized_full_rows) if reference_mode == "sampled" else expected_universe)
    )
    n_reference_ligands = expected_universe if reference_mode == "full" else (len(reference_ids) if reference_ids else reference_sample_size if reference_mode == "sampled" else 0)
    reference_completion_fraction = len(normalized_full_rows) / max(1, n_reference_ligands) if n_reference_ligands else 0.0
    full_universe_complete = reference_mode == "full" and reference_completion_fraction >= 0.99

    audit_settings = {
        "score_z_threshold": float(config.get("score_z_threshold") or signature.get("command_args", {}).get("score_z_threshold") or validation_metrics.get("score_z_threshold") or 5.0),
        "intra_z_threshold": float(config.get("intra_z_threshold") or signature.get("command_args", {}).get("intra_z_threshold") or validation_metrics.get("intra_z_threshold") or 4.0),
        "max_intra_fraction_soft": float(config.get("max_intra_fraction_soft") or signature.get("command_args", {}).get("max_intra_fraction_soft") or validation_metrics.get("max_intra_fraction_soft") or config.get("max_intra_fraction") or 0.75),
        "max_intra_fraction_hard": float(config.get("max_intra_fraction_hard") or signature.get("command_args", {}).get("max_intra_fraction_hard") or validation_metrics.get("max_intra_fraction_hard") or 0.9),
    }

    random_rows = _apply_component_flags(
        _attach_vs_full(_read_rows(tables / "random_baseline_scores.csv"), full_rows, full_universe_complete),
        **audit_settings,
    )
    single_path = tables / "single_fidelity_adaptive_scores.csv"
    if not single_path.exists():
        single_path = tables / "single_fidelity_scores.csv"
    single_rows = _apply_component_flags(_attach_vs_full(_read_rows(single_path), full_rows, full_universe_complete), **audit_settings)
    trace_rows = _read_rows(tables / "multifidelity_trace.csv") if (tables / "multifidelity_trace.csv").exists() else []
    final_seed_rows = _read_rows(tables / "final_hits.csv")
    trace_map = _trace_lookup(trace_rows, final_level)
    final_raw_rows: list[dict[str, Any]] = []
    for row in final_seed_rows:
        ligand_id = str(row.get("ligand_id", ""))
        merged = dict(row)
        merged.update({key: value for key, value in trace_map.get(ligand_id, {}).items() if key not in {"ligand_id"}})
        if "final_score" not in merged or str(merged.get("final_score", "")).strip() == "":
            if str(merged.get("is_final_fidelity", "")).lower() in {"true", "1"}:
                merged["final_score"] = merged.get("SCORE", merged.get("current_best_score", ""))
        final_raw_rows.append(merged)
    final_raw_rows = _apply_component_flags(_attach_vs_full(final_raw_rows, full_rows, full_universe_complete), **audit_settings)
    final_raw_rows = _sort_by_score(final_raw_rows, "final_score", "SCORE")
    for idx, row in enumerate(final_raw_rows, start=1):
        row["raw_rank"] = idx
    write_rows_csv(final_raw_rows, tables / "final_hits_raw.csv")
    final_downranked_rows = _sort_by_score([dict(row) for row in final_raw_rows], "adjusted_score", "final_score", "SCORE")
    for idx, row in enumerate(final_downranked_rows, start=1):
        row["downranked_rank"] = idx
    downrank_map = {str(row["ligand_id"]): row["downranked_rank"] for row in final_downranked_rows}
    write_rows_csv(final_downranked_rows, tables / "final_hits_downranked.csv")
    final_filtered_rows = [dict(row) for row in final_downranked_rows if not _boolish(row.get("filtered_out"))]
    final_filtered_rows = _sort_by_score(final_filtered_rows, "final_score", "SCORE")
    for idx, row in enumerate(final_filtered_rows, start=1):
        row["filtered_rank"] = idx
    filtered_map = {str(row["ligand_id"]): row["filtered_rank"] for row in final_filtered_rows}
    for row in final_raw_rows:
        row["downranked_rank"] = downrank_map.get(str(row.get("ligand_id", "")), "")
        row["filtered_rank"] = filtered_map.get(str(row.get("ligand_id", "")), "")
    for row in final_downranked_rows:
        row["raw_rank"] = next((raw["raw_rank"] for raw in final_raw_rows if str(raw.get("ligand_id")) == str(row.get("ligand_id"))), "")
        row["filtered_rank"] = filtered_map.get(str(row.get("ligand_id", "")), "")
    write_rows_csv(final_filtered_rows, tables / "final_hits_filtered.csv")

    random_filtered_rows = [dict(row) for row in random_rows if not _boolish(row.get("filtered_out"))]
    single_filtered_rows = [dict(row) for row in single_rows if not _boolish(row.get("filtered_out"))]

    best_full = _best_row(full_rows, "SCORE")
    best_raw = _best_row(final_raw_rows, "final_score", "SCORE")
    best_filtered = _best_row(final_filtered_rows, "final_score", "SCORE")
    best_random = _best_row(random_rows, "final_score", "SCORE")
    best_random_filtered = _best_row(random_filtered_rows, "final_score", "SCORE")
    best_single = _best_row(single_rows, "final_score", "SCORE")

    reference_id_set = set(reference_ids) if reference_ids else full_ligand_ids
    overlap_multifidelity_full = len({str(row["ligand_id"]) for row in final_raw_rows} & reference_id_set)
    overlap_random_full = len({str(row["ligand_id"]) for row in random_rows} & reference_id_set)
    overlap_single_full = len({str(row["ligand_id"]) for row in single_rows} & reference_id_set)
    same_target_config, target_reasons = _same_target_config(root, dataset_dir)
    same_dataset_manifest = bool(dataset_dir and dataset_dir.exists() and dataset_manifest)
    same_final_fidelity_runs = True
    final_reasons: list[str] = []
    full_run_metrics = _load_json_if_exists(root / "full_docking" / "metrics" / "rdock_metrics.json")
    random_run_metrics = _load_json_if_exists(root / "random_baseline" / "metrics" / "rdock_metrics.json")
    single_run_metrics = _load_json_if_exists(root / "single_fidelity_adaptive" / "metrics" / "rdock_metrics.json")
    for label, payload in (("full_docking", full_run_metrics), ("random_baseline", random_run_metrics), ("single_fidelity", single_run_metrics)):
        if payload:
            n_runs = int(_float(payload.get("n_runs"), final_level) or final_level)
            if final_level and n_runs != final_level:
                same_final_fidelity_runs = False
                final_reasons.append(f"{label}_n_runs={n_runs} differs from final_fidelity={final_level}")
    stale_checkpoint_detected = (root / "checkpoints" / "failure.json").exists()
    reasons: list[str] = []
    reasons.extend(target_reasons)
    reasons.extend(final_reasons)
    if reference_mode == "full" and not full_universe_complete:
        reasons.append(f"incomplete_full_reference coverage={reference_completion_fraction:.4f}")
    expected_overlap_size = len(reference_id_set) if reference_mode == "sampled" and evaluation_pool_mode == "same_pool" else None
    for label, rows, overlap in (
        ("multifidelity", final_raw_rows, overlap_multifidelity_full),
        ("random", random_rows, overlap_random_full),
        ("single_fidelity", single_rows, overlap_single_full),
    ):
        if overlap != len(rows):
            reasons.append(f"{label}_contains_ligands_missing_from_full")
        if expected_overlap_size is not None and any(str(row.get("ligand_id", "")) not in reference_id_set for row in rows):
            reasons.append(f"{label}_contains_ligands_missing_from_reference_sample")
    if best_raw and str(best_raw.get("ligand_id")) not in full_ligand_ids:
        reasons.append("best_multifidelity_ligand_missing_from_full")
    if best_random and str(best_random.get("ligand_id")) not in full_ligand_ids:
        reasons.append("best_random_ligand_missing_from_full")
    if best_single and str(best_single.get("ligand_id")) not in full_ligand_ids:
        reasons.append("best_single_fidelity_ligand_missing_from_full")
    if best_single and best_full and same_target_config and same_dataset_manifest and same_final_fidelity_runs and overlap_single_full == len(single_rows):
        if _score_from_row(best_single, "final_score", "SCORE") is not None and _score_from_row(best_full, "SCORE") is not None:
            epsilon = float(config.get("single_full_score_epsilon") or signature.get("command_args", {}).get("single_full_score_epsilon") or 1.0)
            if _score_from_row(best_single, "final_score", "SCORE") < (_score_from_row(best_full, "SCORE") - epsilon):
                reasons.append("hard_warning_single_fidelity_better_than_full_docking_in_same_universe")
    if stale_checkpoint_detected:
        reasons.append("stale_checkpoint_detected")
    time_metrics = _time_breakdown(root, existing_metrics, final_level)
    multifidelity_total_runs = int(
        _float(validation_metrics.get("multifidelity_total_runs_spent"), None)
        or _float(validation_metrics.get("total_rdock_runs_spent"), None)
        or _float(raw_metrics.get("multifidelity_total_runs_spent"), None)
        or _float(raw_metrics.get("total_rdock_runs_spent"), None)
        or _float(existing_metrics.get("multifidelity_total_runs_spent"), None)
        or _float(existing_metrics.get("total_rdock_runs_spent"), None)
        or _estimate_total_runs(trace_rows, 0)
        or _estimate_total_runs(final_raw_rows, final_level)
    )
    random_total_runs = _estimate_total_runs(random_rows, final_level)
    single_total_runs = _estimate_total_runs(single_rows, final_level)
    cost_ratio = (random_total_runs / multifidelity_total_runs) if multifidelity_total_runs else None
    cost_ratio_single = (single_total_runs / multifidelity_total_runs) if multifidelity_total_runs else None
    warnings = list(time_metrics.get("time_warnings", []))
    if cost_ratio is not None and abs(cost_ratio - 1.0) > 0.05:
        warnings.append("cost_ratio_differs_by_more_than_5pct")
        reasons.append("not_cost_comparable_random")
    if cost_ratio_single is not None and abs(cost_ratio_single - 1.0) > 0.05:
        warnings.append("single_cost_ratio_differs_by_more_than_5pct")
        reasons.append("not_cost_comparable_single")
    if reference_mode == "none":
        reasons.append("reference_mode_none")
    comparable = False if reference_mode == "none" else not reasons

    best_raw_score = _score_from_row(best_raw or {}, "final_score", "SCORE")
    best_filtered_score = _score_from_row(best_filtered or {}, "final_score", "SCORE")
    best_random_score = _score_from_row(best_random or {}, "final_score", "SCORE")
    best_random_filtered_score = _score_from_row(best_random_filtered or {}, "final_score", "SCORE")
    best_single_score = _score_from_row(best_single or {}, "final_score", "SCORE")
    best_full_score = _score_from_row(best_full or {}, "SCORE")

    corrected_metrics: dict[str, Any] = {
        "strategy": config.get("strategy") or existing_metrics.get("strategy"),
        "dataset_dir": str(dataset_dir) if dataset_dir else "",
        "target_id": (dataset_manifest.get("pdb_id") or existing_metrics.get("target_id") or root.name),
        "reference_mode": reference_mode,
        "evaluation_pool_mode": evaluation_pool_mode,
        "benchmark_status": (
            "BENCHMARK COMPLETE"
            if reference_mode == "full" and comparable
            else "BENCHMARK SAMPLED REFERENCE"
            if reference_mode == "sampled" and not reasons
            else "BENCHMARK PARTIAL / NOT COMPARABLE"
        ),
        "best_final_SCORE_found_by_multifidelity": best_raw_score,
        "best_filtered_SCORE_found_by_multifidelity": best_filtered_score,
        "best_final_SCORE_found_by_random_at_same_cost": best_random_score,
        "best_filtered_SCORE_found_by_random_at_same_cost": best_random_filtered_score,
        "best_final_SCORE_found_by_single_fidelity": best_single_score,
        "best_SCORE_in_full_docking": best_full_score,
        "best_raw_hit_ligand_id": best_raw.get("ligand_id") if best_raw else None,
        "best_raw_hit_score": best_raw_score,
        "best_filtered_hit_ligand_id": best_filtered.get("ligand_id") if best_filtered else None,
        "best_filtered_hit_score": best_filtered_score,
        "best_random_hit_ligand_id": best_random.get("ligand_id") if best_random else None,
        "best_random_hit_score": best_random_score,
        "best_random_filtered_hit_ligand_id": best_random_filtered.get("ligand_id") if best_random_filtered else None,
        "best_random_filtered_hit_score": best_random_filtered_score,
        "best_single_fidelity_ligand_id": best_single.get("ligand_id") if best_single else None,
        "best_single_fidelity_score": best_single_score,
        "best_full_docking_ligand_id": best_full.get("ligand_id") if best_full else None,
        "best_full_docking_score": best_full_score,
        "multifidelity_rank_vs_full": best_raw.get("rank_vs_full") if best_raw and not _boolish(best_raw.get("not_comparable")) else None,
        "multifidelity_percentile_vs_full": best_raw.get("percentile_vs_full") if best_raw and not _boolish(best_raw.get("not_comparable")) else None,
        "random_rank_vs_full": best_random.get("rank_vs_full") if best_random and not _boolish(best_random.get("not_comparable")) else None,
        "random_percentile_vs_full": best_random.get("percentile_vs_full") if best_random and not _boolish(best_random.get("not_comparable")) else None,
        "single_fidelity_rank_vs_full": best_single.get("rank_vs_full") if best_single and not _boolish(best_single.get("not_comparable")) else None,
        "single_fidelity_percentile_vs_full": best_single.get("percentile_vs_full") if best_single and not _boolish(best_single.get("not_comparable")) else None,
        "adaptive_gain_score": (best_random_score - best_raw_score) if best_random_score is not None and best_raw_score is not None else None,
        "adaptive_gain_score_filtered": (best_random_filtered_score - best_filtered_score) if best_random_filtered_score is not None and best_filtered_score is not None else None,
        "adaptive_gain_over_random": (best_random_score - best_raw_score) if best_random_score is not None and best_raw_score is not None else None,
        "multifidelity_total_runs_spent": multifidelity_total_runs,
        "random_total_runs_spent": random_total_runs,
        "single_fidelity_total_runs_spent": single_total_runs,
        "cost_ratio": cost_ratio,
        "cost_ratio_single": cost_ratio_single,
        "reference_completion_fraction": reference_completion_fraction,
        "filtered_outlier_count": sum(1 for row in final_raw_rows if _boolish(row.get("filtered_out"))),
        "raw_final_hits_count": len(final_raw_rows),
        "downranked_final_hits_count": len(final_downranked_rows),
        "filtered_final_hits_count": len(final_filtered_rows),
        "outlier_policy": config.get("outlier_policy") or signature.get("command_args", {}).get("outlier_policy") or "downrank",
        "warnings": warnings,
        "dataset_repair_warnings": dataset_repair.get("warnings", []),
    }
    corrected_metrics.update(time_metrics)

    comparability = {
        "dataset_ligands_prepared": expected_universe,
        "n_reference_ligands": n_reference_ligands,
        "n_full_ligands": len(normalized_full_rows),
        "n_multifidelity_ligands": len(final_raw_rows),
        "n_random_ligands": len(random_rows),
        "n_single_fidelity_ligands": len(single_rows),
        "overlap_multifidelity_reference": overlap_multifidelity_full,
        "overlap_random_reference": overlap_random_full,
        "overlap_single_reference": overlap_single_full,
        "cost_ratio_random_vs_multifidelity": cost_ratio,
        "cost_ratio_single_vs_multifidelity": cost_ratio_single,
        "same_target_config": same_target_config,
        "same_dataset_manifest": same_dataset_manifest,
        "same_final_fidelity_runs": same_final_fidelity_runs,
        "stale_checkpoint_detected": stale_checkpoint_detected,
        "comparable": comparable,
        "reasons": reasons,
    }

    if existing_metrics:
        dump_json_like(metrics_dir / "adaptive_benchmark_metrics_raw.json", existing_metrics)
    dump_json_like(metrics_dir / "adaptive_benchmark_metrics.json", corrected_metrics)
    dump_json_like(metrics_dir / "adaptive_benchmark_metrics_corrected.json", corrected_metrics)
    dump_json_like(metrics_dir / "comparability_audit.json", comparability)
    (root / "report.md").write_text(_render_report(root, corrected_metrics, comparability, final_raw_rows, final_downranked_rows, final_filtered_rows), encoding="utf-8")
    return {
        "run_dir": str(root),
        "metrics": corrected_metrics,
        "comparability_audit": comparability,
        "final_hits_raw": str(tables / "final_hits_raw.csv"),
        "final_hits_downranked": str(tables / "final_hits_downranked.csv"),
        "final_hits_filtered": str(tables / "final_hits_filtered.csv"),
        "report": str(root / "report.md"),
    }


def build_arg_parser() -> argparse.ArgumentParser:
    parser = argparse.ArgumentParser(description="Re-audit an existing adaptive benchmark run without re-running docking.")
    parser.add_argument("--run-dir", required=True)
    return parser


def run_from_args(args: argparse.Namespace) -> dict[str, Any]:
    return audit_benchmark_run(args.run_dir)


def main() -> int:
    parser = build_arg_parser()
    args = parser.parse_args()
    try:
        print(json.dumps(run_from_args(args), indent=2))
    except Exception as exc:
        failure = {
            "error": str(exc),
            "traceback": traceback.format_exc(),
            "run_dir": str(args.run_dir),
        }
        target = Path(args.run_dir) / "checkpoints" / "audit_failure.json"
        dump_json_like(target, failure)
        raise
    return 0