docking_pipeline/benchmark_triage_repeated.py

from __future__ import annotations

import argparse
import csv
import json
import math
import random
import shutil
from argparse import Namespace
from pathlib import Path
from typing import Any

from .benchmark_adaptive import (
    MultiFidelityAdaptiveRunner,
    MultiFidelityConfig,
    _bool_arg,
    _evaluate_selection_against_reference,
    _float,
    _requested_survivor_count,
    _select_diverse,
    _write_json,
)
from .dataset import validate_dataset_dir
from .provenance import RDockPipelineError, require_file
from .rdock import RDockEngine, RDockRunConfig, _sanitize_chunk_output_scores
from .sdf import best_per_ligand, parse_rdock_sdf_records, records_to_rows, write_rows_csv


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


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


def _median(values: list[float]) -> float | None:
    if not values:
        return None
    ordered = sorted(values)
    mid = len(ordered) // 2
    if len(ordered) % 2:
        return ordered[mid]
    return 0.5 * (ordered[mid - 1] + ordered[mid])


def _ensure_matplotlib():
    try:
        import matplotlib

        matplotlib.use("Agg")
        import matplotlib.pyplot as plt
    except Exception:
        return None
    return plt


def _save_plot(plot_dir: Path, name: str, fn) -> str | None:  # type: ignore[no-untyped-def]
    plt = _ensure_matplotlib()
    if plt is None:
        return None
    fig = fn(plt)
    fig.tight_layout()
    path = plot_dir / name
    fig.savefig(path, dpi=160)
    plt.close(fig)
    return str(path)


def _build_config(args: argparse.Namespace, strategy: str, seed: int) -> MultiFidelityConfig:
    return MultiFidelityConfig(
        strategy=strategy,
        fidelity_levels=[5, 10, 15, 30, 50],
        cost_budget_runs=int(getattr(args, "cost_budget_runs", max(1000, args.calibration_size * 5 + args.fidelity_validation_size * 50))),
        adaptive_budget_ligands=None,
        promotion_fraction=0.5,
        min_per_cluster=1,
        max_per_cluster=50,
        outlier_intra_z_threshold=3.0,
        score_component_filter="warn",
        final_fidelity_only_hits=True,
        checkpoint_every=1,
        jobs=args.jobs,
        cpu_fraction=float(args.cpu_fraction),
        resume=bool(getattr(args, "resume", False)),
        reference_mode=args.reference_mode,
        evaluation_pool_mode="same_pool",
        balanced_baselines=True,
        reference_sample_size=int(args.reference_sample_size),
        reference_sample_seed=int(args.reference_sample_seed),
        posthoc_score_selected_hits=False,
        posthoc_final_runs=50,
        force_resume_stale=False,
        outlier_policy="downrank",
        intra_z_threshold=4.0,
        score_z_threshold=5.0,
        max_intra_fraction=0.75,
        max_intra_fraction_soft=0.75,
        max_intra_fraction_hard=0.9,
        exploration_fraction=0.35,
        diversity_weight=0.75,
        uncertainty_weight=0.35,
        outlier_risk_weight=2.0,
        cluster_min_coverage=1,
        use_reference_features=False,
        production_reference_free_mode=True,
        calibration_size=int(args.calibration_size),
        calibration_fraction=0.2,
        min_clusters_covered=8,
        calibration_random_fraction=0.15,
        calibration_diversity_weight=1.0,
        fidelity_validation_size=int(args.fidelity_validation_size),
        fidelity_validation_policy="cluster_stratified",
        promotion_policy=str(getattr(args, "promotion_policy", "conservative")),
        min_final_ligands=int(getattr(args, "min_final_ligands", 20)),
        min_promotion_per_level=int(getattr(args, "min_promotion_per_level", 8)),
        promotion_fraction_by_level=str(getattr(args, "promotion_fraction_by_level", "")),
        triage_retain_fraction=float(args.triage_retain_fraction),
        triage_target_recall=float(args.triage_target_recall),
        triage_min_survivors=50,
        triage_max_survivors=0,
        cluster_min_survivors=1,
        cluster_max_survivors=0,
        rescue_fraction=0.05,
        rare_cluster_rescue=20,
        uncertainty_rescue=20,
        allow_low_confidence_triage=False,
        top_good_fraction=0.1,
        minimum_training_ligands=50,
        triage_controller="auto_recall",
        max_retain_fraction_before_not_useful=0.5,
        classifier_top_percentile=float(getattr(args, "classifier_top_percentile", 0.1)),
        triage_model=str(getattr(args, "triage_model", "classifier")),
        classifier_threshold_mode=str(getattr(args, "classifier_threshold_mode", "recall_target")),
        classifier_min_positives=int(getattr(args, "classifier_min_positives", 10)),
        classifier_holdout_fraction=float(getattr(args, "classifier_holdout_fraction", 0.25)),
        classifier_fallback=str(getattr(args, "classifier_fallback", "cluster_only")),
        model_fallback_if_worse=str(getattr(args, "model_fallback_if_worse", "none")),
        survivor_combination_policy=str(getattr(args, "survivor_combination_policy", "model_only")),
        adaptive_policy=str(getattr(args, "adaptive_policy", "hybrid_rank")),
        regressor_contribution_mode=str(getattr(args, "regressor_contribution_mode", "linear")),
        classifier_weight=float(getattr(args, "classifier_weight", 1.0)),
        regressor_weight=float(getattr(args, "regressor_weight", 0.35)),
        cluster_quality_weight=float(getattr(args, "cluster_quality_weight", 0.5)),
        fixed_score_regressor_name=str(getattr(args, "fixed_score_regressor_name", "fixed_score_regressor_v1")),
        fixed_score_regressor_target=str(getattr(args, "fixed_score_regressor_target", "component_sane_affinity_like")),
        regressor_model_type=str(getattr(args, "regressor_model_type", "extra_trees")),
        model_validation_split=str(getattr(args, "model_validation_split", "cluster")),
        cluster_quota=int(getattr(args, "cluster_quota", 0)),
        promotion_temperature=float(getattr(args, "promotion_temperature", 1.0)),
        diagnostics_level=str(getattr(args, "diagnostics_level", "standard")),
        classifier_gate_fraction=float(getattr(args, "classifier_gate_fraction", 0.15)),
        classifier_max_gate_fraction=float(getattr(args, "classifier_max_gate_fraction", 0.2)),
        final_survivor_enumerate_variants=False,
        variant_stage="none",
        enumerate_stereoisomers="none",
        max_stereoisomers_per_parent=2,
        enumerate_tautomers="none",
        max_tautomers_per_parent=1,
        enumerate_protonation="none",
        ph=7.4,
        max_protomer_states_per_parent=1,
        max_conformers_per_variant=1,
        max_total_variants_per_parent=1,
        posthoc_top_parents=100,
        posthoc_max_total_variants_per_parent=20,
        variant_fairness_policy="cap",
    )


def _ensure_reference_full(
    dataset_dir: Path,
    out_dir: Path,
    jobs: str,
    cpu_fraction: float,
    force: bool,
    *,
    reference_mode: str,
    reference_sample_size: int,
    resume: bool = False,
    rdock_timeout_seconds: int = 3600,
) -> Path:
    ref_dir = out_dir / "reference_full"
    table = ref_dir / "tables" / "full_docking_scores.csv"
    if force and ref_dir.exists():
        shutil.rmtree(ref_dir)
    if table.exists():
        return table
    manifest = json.loads(require_file(dataset_dir / "dataset_manifest.json", "dataset manifest").read_text(encoding="utf-8"))
    expected_count = int(manifest.get("ligands_prepared", 0))
    if str(reference_mode).lower() == "sampled" and reference_sample_size > 0:
        expected_count = reference_sample_size
    candidates = [
        Path("/tmp/ref_free_triage_benchmark_v2/tables/full_docking_scores.csv"),
        Path("/tmp/ref_free_triage_benchmark/tables/full_docking_scores.csv"),
        Path("results/rdock_4wkq_pubchem_1500_medium_comparable_v5/tables/full_docking_scores.csv"),
        Path("results/rdock_4wkq_pubchem_1500_medium_comparable_v4/tables/full_docking_scores.csv"),
        Path("results/rdock_4wkq_pubchem_1500_medium_comparable_v3/tables/full_docking_scores.csv"),
    ]
    for candidate in candidates:
        if candidate.exists():
            try:
                row_count = len(_read_rows(candidate))
            except Exception:
                row_count = 0
            if expected_count > 0 and row_count != expected_count:
                continue
            table.parent.mkdir(parents=True, exist_ok=True)
            shutil.copy2(candidate, table)
            return table
    ref_dir.mkdir(parents=True, exist_ok=True)
    partial_chunks = sorted((ref_dir / "full_docking" / "rdock").glob("chunk_*_out.sd"))
    if partial_chunks:
        rows = []
        for chunk in partial_chunks:
            valid_records, _ = _sanitize_chunk_output_scores(chunk)
            if not valid_records:
                continue
            rows.extend(records_to_rows(best_per_ligand(valid_records)))
        unique_ids = {str(row.get("ligand_id", "")) for row in rows if str(row.get("ligand_id", ""))}
        if rows and (expected_count <= 0 or len(unique_ids) >= expected_count):
            table.parent.mkdir(parents=True, exist_ok=True)
            write_rows_csv(rows, table)
            return table
    engine = RDockEngine(RDockRunConfig(n_runs=50, jobs=jobs, cpu_fraction=cpu_fraction, timeout_seconds=int(rdock_timeout_seconds)))
    config = _build_config(
        Namespace(
            reference_mode="full",
            reference_sample_size=0,
            reference_sample_seed=42,
            calibration_size=50,
            fidelity_validation_size=20,
            triage_retain_fraction=0.2,
            triage_target_recall=0.95,
            jobs=jobs,
            cpu_fraction=cpu_fraction,
            resume=resume,
        ),
        strategy="reference_free_triage_bandit_v1",
        seed=0,
    )
    runner = MultiFidelityAdaptiveRunner(dataset_dir, ref_dir, engine, config)
    runner._prepare_output_layout()
    runner._run_full_docking()
    if not table.exists():
        raise RDockPipelineError(f"Failed to produce full reference table at {table}")
    return table


def _reference_lookup(full_rows: list[dict[str, str]]) -> dict[str, dict[str, str]]:
    return {str(row["ligand_id"]): row for row in full_rows}


def _cluster_random_selection(rows: list[dict[str, Any]], requested: int, seed: int, min_per_cluster: int, max_per_cluster: int) -> list[dict[str, Any]]:
    shuffled = list(rows)
    rng = random.Random(seed)
    rng.shuffle(shuffled)
    return _select_diverse(shuffled, requested, min_per_cluster, max_per_cluster)


def _evaluate_strategy_offline(
    runner: MultiFidelityAdaptiveRunner,
    strategy: str,
    seed: int,
    reference_rows: list[dict[str, str]],
    seed_dir: Path,
) -> dict[str, Any]:
    full_lookup = _reference_lookup(reference_rows)
    screenable_rows = runner._prefilter_candidate_rows()
    requested = _requested_survivor_count(
        len(screenable_rows),
        runner.config.triage_retain_fraction,
        runner.config.triage_min_survivors,
        runner.config.triage_max_survivors,
    )
    selected_rows: list[dict[str, Any]]
    selection_metrics: dict[str, Any]
    if strategy == "cluster_only_triage":
        selected_rows, selection_metrics = runner._cluster_only_selection(screenable_rows)
    elif strategy == "cheap_descriptor_filter_only":
        selected_rows, selection_metrics = runner._descriptor_filter_selection(screenable_rows)
    elif strategy == "diverse_random_cost_balanced":
        selected_rows = _cluster_random_selection(screenable_rows, requested, seed, runner.config.cluster_min_survivors, runner.config.cluster_max_survivors or runner.config.max_per_cluster)
        selection_metrics = {"requested_survivor_count": requested, "final_survivor_count": len(selected_rows)}
    elif strategy == "single_fidelity_cost_balanced":
        ordered = sorted(screenable_rows, key=lambda row: (-float(row.get("model_score", 0.0)), str(row.get("cluster_id", "")), str(row.get("ligand_id", ""))))
        selected_rows = _select_diverse(ordered, requested, runner.config.cluster_min_survivors, runner.config.cluster_max_survivors or runner.config.max_per_cluster)
        selection_metrics = {"requested_survivor_count": requested, "final_survivor_count": len(selected_rows)}
    else:
        calibration_rows = runner._select_calibration_rows(screenable_rows)
        rng = random.Random(seed)
        rng.shuffle(calibration_rows)
        calibration_rows = calibration_rows[: runner.config.calibration_size]
        labeled_rows: list[dict[str, Any]] = []
        for row in calibration_rows:
            ligand_id = str(row["ligand_id"])
            ref = full_lookup.get(ligand_id)
            if ref is None:
                continue
            merged = dict(row)
            merged["final_score"] = ref.get("SCORE", ref.get("best_score", ""))
            merged["ranking_score"] = merged["final_score"]
            merged["SCORE"] = merged["final_score"]
            merged["rdock_success"] = str(ref.get("rdock_success", "true")).lower() in {"true", "1"}
            merged["component_warning"] = ""
            labeled_rows.append(merged)
        selected_rows, selection_metrics = runner._triage_survivors(screenable_rows, labeled_rows)
    selected_ids = {str(row["ligand_id"]) for row in selected_rows}
    selection_metrics.update(_evaluate_selection_against_reference(reference_rows, selected_ids, top_fraction=runner.config.classifier_top_percentile))
    survivor_scores = [
        _float(full_lookup[ligand_id].get("SCORE", full_lookup[ligand_id].get("best_score")), None)
        for ligand_id in selected_ids
        if ligand_id in full_lookup
    ]
    survivor_scores = [score for score in survivor_scores if score is not None]
    selected_ranked = [
        full_lookup[ligand_id]
        for ligand_id in sorted(selected_ids, key=lambda ligand_id: _float(full_lookup.get(ligand_id, {}).get("SCORE", full_lookup.get(ligand_id, {}).get("best_score")), float("inf")))
        if ligand_id in full_lookup
    ]
    topk_means = {}
    for k in (1, 5, 10):
        scores = [
            _float(row.get("SCORE", row.get("best_score")), None)
            for row in selected_ranked[: min(k, len(selected_ranked))]
        ]
        scores = [score for score in scores if score is not None]
        topk_means[f"top{k}_mean_score"] = _mean(scores) if scores else None
    estimated_full_runs = len(reference_rows) * 50
    if strategy in {"reference_free_triage_bandit_v1", "reference_free_active_learning_v2"}:
        estimated_runs = len(selected_rows) * 50 + min(len(screenable_rows), runner.config.calibration_size) * 5 + min(len(screenable_rows), runner.config.fidelity_validation_size) * (10 + 15 + 30 + 50)
    else:
        estimated_runs = len(selected_rows) * 50
    output = {
        "strategy": strategy,
        "seed": seed,
        "initial_ligands": len(screenable_rows),
        "survivor_count": len(selected_rows),
        "survivor_fraction": len(selected_rows) / max(1, len(screenable_rows)),
        "reduction_fraction": 1.0 - (len(selected_rows) / max(1, len(screenable_rows))),
        "estimated_total_runs_spent": estimated_runs,
        "estimated_runs_saved_vs_full": max(0, estimated_full_runs - estimated_runs),
        "best_survivor_score": _float(selected_ranked[0].get("SCORE", selected_ranked[0].get("best_score")), None) if selected_ranked else None,
        "best_survivor_ligand_id": selected_ranked[0].get("ligand_id") if selected_ranked else None,
    }
    output.update(topk_means)
    output.update(selection_metrics)
    seed_dir.mkdir(parents=True, exist_ok=True)
    write_rows_csv(selected_rows, seed_dir / f"{strategy}_survivors.csv")
    rejected_rows = [row for row in screenable_rows if str(row["ligand_id"]) not in selected_ids]
    write_rows_csv(rejected_rows, seed_dir / f"{strategy}_rejected.csv")
    _write_json(seed_dir / f"{strategy}_metrics.json", output)
    return output


def _write_summary_plots(out_dir: Path, rows: list[dict[str, Any]]) -> list[str]:
    plot_dir = out_dir / "plots"
    plot_dir.mkdir(parents=True, exist_ok=True)
    paths: list[str] = []
    if not rows:
        return paths
    by_strategy: dict[str, list[dict[str, Any]]] = {}
    for row in rows:
        by_strategy.setdefault(str(row["strategy"]), []).append(row)

    def _save_csv(name: str, payload: list[dict[str, Any]]) -> str:
        path = plot_dir / name
        write_rows_csv(payload, path)
        return str(path)

    summary_csv_rows = []
    for strategy, items in by_strategy.items():
        summary_csv_rows.append(
            {
                "strategy": strategy,
                "median_top5pct_recall": _median([float(item.get("top5pct_recall") or 0.0) for item in items]),
                "median_reduction_fraction": _median([float(item.get("reduction_fraction") or 0.0) for item in items]),
                "median_best_survivor_score": _median([float(item.get("best_survivor_score") or 0.0) for item in items if item.get("best_survivor_score") is not None]),
            }
        )
    _save_csv("strategy_comparison_recall_cost.csv", summary_csv_rows)

    def bar_plot(plt):  # type: ignore[no-untyped-def]
        labels = [row["strategy"] for row in summary_csv_rows]
        recalls = [float(row["median_top5pct_recall"] or 0.0) for row in summary_csv_rows]
        reductions = [float(row["median_reduction_fraction"] or 0.0) for row in summary_csv_rows]
        fig, ax1 = plt.subplots(figsize=(9, 4))
        ax1.bar(labels, recalls, color="#3b6ea8", alpha=0.8, label="top5% recall")
        ax1.set_ylabel("Median top-5% recall")
        ax1.set_xlabel("Strategy")
        ax1.set_title("Strategy comparison: recall versus reduction")
        ax1.tick_params(axis="x", rotation=25)
        ax2 = ax1.twinx()
        ax2.plot(labels, reductions, color="#bf7f2f", marker="o", linewidth=2, label="reduction")
        ax2.set_ylabel("Median reduction fraction")
        return fig

    def scatter_plot(plt):  # type: ignore[no-untyped-def]
        fig, ax = plt.subplots(figsize=(7, 5))
        colors = {
            "reference_free_triage_bandit_v1": "#3b6ea8",
            "cluster_only_triage": "#7a9d54",
            "cheap_descriptor_filter_only": "#bf7f2f",
            "diverse_random_cost_balanced": "#7a4f9d",
        }
        for strategy, items in by_strategy.items():
            xs = [float(item.get("reduction_fraction") or 0.0) for item in items]
            ys = [float(item.get("top5pct_recall") or 0.0) for item in items]
            ax.scatter(xs, ys, alpha=0.8, s=60, label=strategy, color=colors.get(strategy, "#444444"))
        ax.set_xlabel("Reduction fraction")
        ax.set_ylabel("Top-5% recall")
        ax.set_title("Triage safety tradeoff: reduction versus recall")
        handles, labels = ax.get_legend_handles_labels()
        if handles and labels:
            ax.legend()
        return fig

    def false_negative_plot(plt):  # type: ignore[no-untyped-def]
        strategies = list(by_strategy.keys())
        medians = [_median([float(item.get("false_negative_rate") or 0.0) for item in by_strategy[strategy]]) or 0.0 for strategy in strategies]
        fig, ax = plt.subplots(figsize=(8, 4))
        ax.bar(strategies, medians, color="#a83b3b")
        ax.set_xlabel("Strategy")
        ax.set_ylabel("Median false negative rate")
        ax.set_title("False negative rate by triage strategy")
        ax.tick_params(axis="x", rotation=25)
        return fig

    for name, fn in (
        ("strategy_comparison_recall_cost.png", bar_plot),
        ("triage_safety_tradeoff.png", scatter_plot),
        ("false_negative_rate_by_strategy.png", false_negative_plot),
    ):
        path = _save_plot(plot_dir, name, fn)
        if path:
            paths.append(path)
    return paths


def benchmark_triage_repeated(args: argparse.Namespace) -> dict[str, Any]:
    dataset_dir = Path(args.dataset_dir)
    validate_dataset_dir(dataset_dir, check_rdock_tools=False)
    out_dir = Path(args.out)
    preserved_reference_chunks: Path | None = None
    if args.force and out_dir.exists():
        partial_chunk_dir = out_dir / "reference_full" / "full_docking" / "rdock"
        if partial_chunk_dir.exists() and any(partial_chunk_dir.glob("chunk_*_out.sd")):
            preserved_reference_chunks = out_dir.parent / f"{out_dir.name}_preserved_reference_full"
            if preserved_reference_chunks.exists():
                shutil.rmtree(preserved_reference_chunks)
            shutil.copytree(out_dir / "reference_full", preserved_reference_chunks)
        shutil.rmtree(out_dir)
    out_dir.mkdir(parents=True, exist_ok=True)
    if preserved_reference_chunks is not None:
        shutil.copytree(preserved_reference_chunks, out_dir / "reference_full")
        shutil.rmtree(preserved_reference_chunks)
    seeds = [int(part.strip()) for part in str(args.seeds).split(",") if part.strip()]
    strategies = [str(args.strategy)] + [part.strip() for part in str(args.baselines).split(",") if part.strip()]
    reference_table = _ensure_reference_full(
        dataset_dir,
        out_dir,
        args.jobs,
        float(args.cpu_fraction),
        bool(args.force),
        reference_mode=str(args.reference_mode),
        reference_sample_size=int(args.reference_sample_size),
    )
    reference_rows = [row for row in _read_rows(reference_table) if str(row.get("rdock_success", "")).lower() in {"true", "1"} and _float(row.get("SCORE", row.get("best_score")), None) is not None]
    reference_rows.sort(key=lambda row: (_float(row.get("SCORE", row.get("best_score")), float("inf")), str(row.get("ligand_id", ""))))
    all_results: list[dict[str, Any]] = []
    for seed in seeds:
        for strategy in strategies:
            seed_dir = out_dir / f"seed_{seed:02d}"
            strategy_out = seed_dir / strategy
            strategy_out.mkdir(parents=True, exist_ok=True)
            config = _build_config(args, strategy, seed)
            config.reference_sample_seed = seed
            runner = MultiFidelityAdaptiveRunner(
                dataset_dir,
                strategy_out,
                RDockEngine(RDockRunConfig(n_runs=50, jobs=args.jobs, cpu_fraction=float(args.cpu_fraction), timeout_seconds=3600)),
                config,
            )
            result = _evaluate_strategy_offline(runner, strategy, seed, reference_rows, strategy_out / "tables")
            all_results.append(result)
    write_rows_csv(all_results, out_dir / "tables" / "triage_repeated_results.csv")
    summary: dict[str, Any] = {
        "dataset_dir": str(dataset_dir),
        "reference_mode": args.reference_mode,
        "reference_count": len(reference_rows),
        "seeds": seeds,
        "strategies": strategies,
        "by_strategy": {},
    }
    for strategy in strategies:
        items = [row for row in all_results if str(row["strategy"]) == strategy]
        recalls = [float(row.get("top5pct_recall") or 0.0) for row in items]
        reductions = [float(row.get("reduction_fraction") or 0.0) for row in items]
        best_scores = [float(row.get("best_survivor_score")) for row in items if row.get("best_survivor_score") is not None]
        summary["by_strategy"][strategy] = {
            "median_top5pct_recall": _median(recalls),
            "median_reduction_fraction": _median(reductions),
            "median_best_survivor_score": _median(best_scores),
            "median_false_negative_rate": _median([float(row.get("false_negative_rate") or 0.0) for row in items]),
            "median_estimated_runs_saved_vs_full": _median([float(row.get("estimated_runs_saved_vs_full") or 0.0) for row in items]),
        }
    model_summary = summary["by_strategy"].get(args.strategy, {})
    cluster_summary = summary["by_strategy"].get("cluster_only_triage", {})
    model_beats_cluster = False
    if model_summary and cluster_summary:
        model_score = model_summary.get("median_best_survivor_score")
        cluster_score = cluster_summary.get("median_best_survivor_score")
        if model_score is not None and cluster_score is not None:
            model_beats_cluster = float(model_score) < float(cluster_score)
    summary["model_beats_cluster_only"] = model_beats_cluster
    plots = _write_summary_plots(out_dir, all_results)
    _write_json(out_dir / "metrics" / "triage_repeated_summary.json", summary)
    lines = [
        f"# benchmark-triage-repeated: {dataset_dir.name}",
        "",
        "## Triage Safety",
        f"- target_recall: `{args.triage_target_recall}`",
        f"- requested_retain_fraction: `{args.triage_retain_fraction}`",
        f"- model_beats_cluster_only: `{model_beats_cluster}`",
        "",
        "## Computational Value",
    ]
    for strategy in strategies:
        item = summary["by_strategy"][strategy]
        lines.extend(
            [
                f"- {strategy} median_reduction_fraction: `{item.get('median_reduction_fraction')}`",
                f"- {strategy} median_estimated_runs_saved_vs_full: `{item.get('median_estimated_runs_saved_vs_full')}`",
            ]
        )
    lines.extend(["", "## Final Hit Quality"])
    for strategy in strategies:
        item = summary["by_strategy"][strategy]
        lines.append(f"- {strategy} median_best_survivor_score: `{item.get('median_best_survivor_score')}`")
    lines.extend(["", "## Baseline Comparison"])
    if not model_beats_cluster:
        lines.append("- warning: `MODEL TRIAGE DOES NOT OUTPERFORM SIMPLE CLUSTERING.`")
    for strategy in strategies:
        item = summary["by_strategy"][strategy]
        lines.append(
            f"- {strategy}: median_top5pct_recall `{item.get('median_top5pct_recall')}`, "
            f"median_false_negative_rate `{item.get('median_false_negative_rate')}`"
        )
    lines.extend(["", "## Plots"])
    lines.extend([f"- `{path}`" for path in plots] or ["- no_plots"])
    (out_dir / "report.md").write_text("\n".join(lines) + "\n", encoding="utf-8")
    return {
        "run_dir": str(out_dir),
        "summary": summary,
        "plots": plots,
    }


def build_arg_parser() -> argparse.ArgumentParser:
    parser = argparse.ArgumentParser(description="Repeated offline triage benchmark against a real full-reference docking table.")
    parser.add_argument("--dataset-dir", required=True)
    parser.add_argument("--reference-mode", default="full", choices=["full", "sampled"])
    parser.add_argument("--reference-sample-size", type=int, default=500)
    parser.add_argument("--reference-sample-seed", type=int, default=42)
    parser.add_argument("--strategy", default="reference_free_triage_bandit_v1")
    parser.add_argument("--baselines", default="cluster_only_triage,cheap_descriptor_filter_only,diverse_random_cost_balanced")
    parser.add_argument("--triage-target-recall", type=float, default=0.98)
    parser.add_argument("--triage-retain-fraction", type=float, default=0.02)
    parser.add_argument("--calibration-size", type=int, default=300)
    parser.add_argument("--fidelity-validation-size", type=int, default=100)
    parser.add_argument("--triage-model", default="classifier")
    parser.add_argument("--classifier-top-percentile", type=float, default=0.05)
    parser.add_argument("--classifier-threshold-mode", default="recall_target")
    parser.add_argument("--classifier-min-positives", type=int, default=10)
    parser.add_argument("--classifier-holdout-fraction", type=float, default=0.25)
    parser.add_argument("--classifier-fallback", default="cluster_only")
    parser.add_argument("--model-fallback-if-worse", default="none")
    parser.add_argument("--survivor-combination-policy", default="model_only")
    parser.add_argument("--seeds", default="1,2,3")
    parser.add_argument("--jobs", default="auto")
    parser.add_argument("--chunk-size", type=int, default=20)
    parser.add_argument("--cpu-fraction", type=float, default=0.85)
    parser.add_argument("--out", required=True)
    parser.add_argument("--force", action="store_true")
    return parser


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


def main() -> int:
    print(json.dumps(run_from_args(build_arg_parser().parse_args()), indent=2))
    return 0


if __name__ == "__main__":
    raise SystemExit(main())