Blame for code/acquisition/run_experiment.py

#!/usr/bin/env python3
"""Portable release of the six-policy offline MolAS acquisition runner.

Historical source is preserved separately; see README.md for provenance and
release-only I/O, validation, metadata, and resume-log changes.
"""

from __future__ import annotations

import argparse
import hashlib
import json
import math
import os
import tempfile
import time
import uuid
from datetime import datetime, timezone
from dataclasses import dataclass
from pathlib import Path

import numpy as np
import pandas as pd
from sklearn.metrics import mean_absolute_error, mean_squared_error
from sklearn.neural_network import MLPRegressor
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler

from release_support import (add_path_arguments, environment_versions, fingerprint,
                             invocation_arguments, previous_checkpoint_size, verify_existing_run)


HERE = Path(__file__).resolve().parent
ROOT = HERE.parents[1]
DATA = ROOT / "data/raw"
FEATURE_CACHE = ROOT / "data/features/complex_features_ligand_protein_d256_seed0.npy"
FEATURE_IDS = ROOT / "data/features/complex_feature_ids.csv"
OUTPUT = ROOT / "outputs/acquisition"
DESCRIPTORS = ROOT / "data/descriptors/moad_physical_descriptors_filtered.csv"
FOLD_SPLIT = ROOT / "data/splits/moad_5fold_split_seed42.csv"


def configure_paths(args: argparse.Namespace) -> None:
    global DATA, FEATURE_CACHE, FEATURE_IDS, OUTPUT, DESCRIPTORS, FOLD_SPLIT
    DATA = args.data_dir.expanduser().resolve()
    FEATURE_CACHE = args.features.expanduser().resolve()
    FEATURE_IDS = args.feature_ids.expanduser().resolve()
    OUTPUT = args.output_dir.expanduser().resolve()
    DESCRIPTORS = args.descriptors.expanduser().resolve()
    FOLD_SPLIT = args.fold_split.expanduser().resolve()


ALGORITHMS = [
    "surfdock",
    "unimol",
    "diffdock",
    "diffdock_l",
    "gnina",
    "autodock",
    "smina",
]
SVD_RANKS = (1, 2, 3, 5)
LAMBDA = 3.0
METHODS = (
    "plain_mean_ucb",
    "direct_cost_uc",
    "runtime_uncertainty",
    "cost_tiers_5",
    "relaxed_cost_power_05",
    "log_cost",
)
COST_METHODS = set(METHODS) - {"plain_mean_ucb"}
ENSEMBLE_COST_METHODS = {"runtime_uncertainty"}


def atomic_json(path: Path, value: object) -> None:
    path.parent.mkdir(parents=True, exist_ok=True)
    with tempfile.NamedTemporaryFile("w", dir=path.parent, delete=False) as handle:
        json.dump(value, handle, indent=2, allow_nan=True)
        tmp = Path(handle.name)
    os.replace(tmp, path)


def atomic_csv(path: Path, frame: pd.DataFrame, *, index: bool = True) -> None:
    path.parent.mkdir(parents=True, exist_ok=True)
    with tempfile.NamedTemporaryFile("w", dir=path.parent, delete=False) as handle:
        frame.to_csv(handle, index=index, float_format="%.8g")
        tmp = Path(handle.name)
    os.replace(tmp, path)


def sha256(path: Path) -> str:
    digest = hashlib.sha256()
    with path.open("rb") as handle:
        for block in iter(lambda: handle.read(1024 * 1024), b""):
            digest.update(block)
    return digest.hexdigest()


def read_matrix(name: str) -> tuple[pd.Index, np.ndarray]:
    frame = pd.read_csv(DATA / name, index_col=0)
    if "rmsd" in name:
        suffix = "_rmsd"
    elif "pb_ratio" in name:
        suffix = "_pb_ratio"
    elif "runtime" in name:
        suffix = "_runtime"
    else:
        raise ValueError(f"Unknown matrix schema: {name}")
    source_columns = [f"{algorithm}{suffix}" for algorithm in ALGORITHMS]
    missing = [column for column in source_columns if column not in frame.columns]
    if missing:
        raise ValueError(f"{name} is missing algorithm columns: {missing}")
    return frame.index, frame.loc[:, source_columns].to_numpy(dtype=np.float64)


def _identifier_column(frame: pd.DataFrame, expected: pd.Index, source: Path) -> str:
    expected_values = set(expected.astype(str))
    matches = []
    for column in frame.columns:
        values = frame[column].astype(str)
        if values.is_unique and set(values) == expected_values:
            matches.append(column)
    if len(matches) != 1:
        raise ValueError(
            f"{source.name}: expected exactly one identifier column matching all matrix rows; "
            f"found {matches}"
        )
    return matches[0]


def aligned_auxiliary_frame(path: Path, expected: pd.Index) -> pd.DataFrame:
    if not path.exists():
        raise FileNotFoundError(
            f"Missing input: {path}. See {HERE / 'README.md'}"
        )
    frame = pd.read_csv(path)
    identifier = _identifier_column(frame, expected, path)
    frame[identifier] = frame[identifier].astype(str)
    aligned = frame.set_index(identifier).loc[expected.astype(str)]
    if aligned.index.duplicated().any():
        raise ValueError(f"{path.name}: duplicate complex identifiers")
    return aligned


def load_descriptors(expected: pd.Index) -> np.ndarray:
    frame = aligned_auxiliary_frame(DESCRIPTORS, expected)
    numeric = frame.select_dtypes(include=[np.number])
    if numeric.shape[1] != 4:
        raise ValueError(
            f"{DESCRIPTORS.name}: expected exactly four numeric physical descriptors, "
            f"found {list(numeric.columns)}"
        )
    if not np.isfinite(numeric.to_numpy(dtype=float)).all():
        raise ValueError(f"{DESCRIPTORS.name}: physical descriptors contain missing/non-finite values")
    return numeric.to_numpy(dtype=np.float32)


def load_folds(expected: pd.Index) -> np.ndarray:
    frame = aligned_auxiliary_frame(FOLD_SPLIT, expected)
    candidate_columns = [
        column for column in frame.columns
        if "fold" in column.lower() and pd.api.types.is_numeric_dtype(frame[column])
    ]
    if len(candidate_columns) != 1:
        raise ValueError(
            f"{FOLD_SPLIT.name}: expected one numeric fold column, found {candidate_columns}"
        )
    values = frame[candidate_columns[0]].to_numpy(dtype=np.float64)
    if not np.isfinite(values).all() or not np.equal(values, np.floor(values)).all():
        raise ValueError(f"{FOLD_SPLIT.name}: fold labels must be finite integers")
    folds = values.astype(np.int64)
    unique = sorted(np.unique(folds).tolist())
    if unique == [1, 2, 3, 4, 5]:
        folds = folds - 1
        unique = sorted(np.unique(folds).tolist())
    if unique != [0, 1, 2, 3, 4]:
        raise ValueError(f"{FOLD_SPLIT.name}: expected five folds encoded 0-4 or 1-5; found {unique}")
    return folds


def strict_score(rmsd: np.ndarray, pb_ratio: np.ndarray) -> np.ndarray:
    """Established MolAS strict-score definition used by Design 2."""
    with np.errstate(over="ignore", invalid="ignore"):
        rmsd_score = (1.0 + np.exp(-2.0 * LAMBDA)) / (
            1.0 + np.exp(LAMBDA * (rmsd - 2.0))
        )
    return np.clip(np.nan_to_num(rmsd_score) * (pb_ratio == 1.0), 0.0, 1.0)


def svd_complete(
    truth: np.ndarray,
    observed: np.ndarray,
    rank: int,
    iterations: int = 6,
) -> np.ndarray:
    if observed.all():
        return truth.copy()
    if not observed.any():
        raise ValueError("SVD completion requires an observed warm start")
    global_mean = float(truth[observed].mean())
    filled = np.empty_like(truth)
    for column in range(observed.shape[1]):
        mask = observed[:, column]
        filled[:, column] = float(truth[mask, column].mean()) if mask.any() else global_mean
    filled[observed] = truth[observed]
    for _ in range(iterations):
        column_mean = filled.mean(axis=0, keepdims=True)
        u, s, vt = np.linalg.svd(filled - column_mean, full_matrices=False)
        use_rank = min(rank, len(s))
        filled = (u[:, :use_rank] * s[:use_rank]) @ vt[:use_rank] + column_mean
        filled = np.clip(filled, 0.0, 1.0)
        filled[observed] = truth[observed]
    return filled


def score_ensemble(truth: np.ndarray, observed: np.ndarray) -> tuple[np.ndarray, np.ndarray]:
    stack = np.stack([svd_complete(truth, observed, rank, iterations=4) for rank in SVD_RANKS])
    return stack.mean(axis=0), stack.std(axis=0)


def warm_start(shape: tuple[int, int], seed: int, fraction: float = 0.01) -> np.ndarray:
    """Runtime-blind warm start with nearly equal representation by algorithm."""
    rows, columns = shape
    count = math.ceil(rows * columns * fraction)
    rng = np.random.default_rng(731_000 + seed)
    chosen: list[int] = []
    per_algorithm = count // columns
    remainder = count % columns
    for column in range(columns):
        number = per_algorithm + int(column < remainder)
        selected_rows = rng.choice(rows, size=number, replace=False)
        chosen.extend((selected_rows * columns + column).tolist())
    rng.shuffle(chosen)
    return np.asarray(chosen, dtype=np.int64)


def percentile_rank(values: np.ndarray) -> np.ndarray:
    return pd.Series(values).rank(method="average", pct=True).to_numpy(dtype=np.float64)


def quantiles(values: np.ndarray) -> dict[str, float]:
    if values.size == 0:
        return {key: math.nan for key in ("min", "q05", "q25", "median", "q75", "q95", "max")}
    qs = np.quantile(values, [0, 0.05, 0.25, 0.5, 0.75, 0.95, 1])
    return dict(zip(("min", "q05", "q25", "median", "q75", "q95", "max"), map(float, qs)))


@dataclass
class RuntimePrediction:
    mean: np.ndarray
    sd: np.ndarray
    conservative: np.ndarray
    lower: float
    upper: float


class RuntimeSurrogate:
    """Observed-only runtime predictor with positive, round-local bounds."""

    def __init__(self, features: np.ndarray, algorithms: int = 7):
        one_hot = np.eye(algorithms, dtype=np.float32)
        expanded = np.repeat(features, algorithms, axis=0)
        algorithm_features = np.tile(one_hot, (features.shape[0], 1))
        self.x = np.concatenate([expanded, algorithm_features], axis=1)

    def predict(
        self,
        observed_flat: np.ndarray,
        observed_runtime: np.ndarray,
        candidates: np.ndarray,
        seed: int,
        ensemble_size: int,
        legacy: bool = False,
    ) -> RuntimePrediction:
        y = np.log1p(observed_runtime)
        q05, q95 = np.quantile(observed_runtime, [0.05, 0.95])
        lower = max(float(q05), np.finfo(float).eps)
        upper = max(float(q95), lower * (1.0 + 1e-6))
        predictions = []
        for member in range(ensemble_size):
            member_seed = seed * 1009 + member * 97
            model = make_pipeline(
                StandardScaler(),
                MLPRegressor(
                    hidden_layer_sizes=(32, 16),
                    activation="relu",
                    solver="adam",
                    alpha=1e-4,
                    batch_size=min(128, len(observed_flat)),
                    learning_rate_init=1e-3,
                    max_iter=10,
                    early_stopping=len(observed_flat) >= 80,
                    validation_fraction=0.15,
                    n_iter_no_change=5,
                    random_state=member_seed,
                ),
            )
            model.fit(self.x[observed_flat], y)
            predicted_log = model.predict(self.x[candidates])
            raw = np.expm1(predicted_log)
            if legacy:
                raw = np.clip(raw, 1e-6, float(np.median(observed_runtime) * 100.0))
            else:
                raw = np.clip(raw, lower, upper)
            predictions.append(raw)
        stack = np.stack(predictions)
        mean = stack.mean(axis=0)
        sd = stack.std(axis=0)
        conservative = mean + sd
        if not legacy:
            conservative = np.clip(conservative, lower, upper)
        return RuntimePrediction(mean, sd, conservative, lower, upper)


class HiddenOracle:
    """The only object permitted to hold unrevealed scores and runtimes."""

    def __init__(self, score: np.ndarray, runtime: np.ndarray):
        self._score = score
        self._runtime = runtime
        self.shape = score.shape
        self.access_log: list[dict[str, int]] = []

    def reveal(self, flat: np.ndarray, round_id: int) -> tuple[np.ndarray, np.ndarray]:
        rows, columns = np.unravel_index(flat, self.shape)
        self.access_log.extend(
            {"flat_index": int(index), "round": int(round_id)} for index in flat
        )
        return self._score[rows, columns], self._runtime[rows, columns]

    def evaluate(self, prediction: np.ndarray, observed: np.ndarray) -> dict[str, float]:
        """Evaluate without exposing truth back to the acquisition pipeline."""
        truth = self._score
        missing = ~observed
        result = {
            "full_mae": float(mean_absolute_error(truth.ravel(), prediction.ravel())),
            "full_rmse": float(mean_squared_error(truth.ravel(), prediction.ravel()) ** 0.5),
        }
        if missing.any():
            result["unqueried_mae"] = float(mean_absolute_error(truth[missing], prediction[missing]))
            result["unqueried_rmse"] = float(mean_squared_error(truth[missing], prediction[missing]) ** 0.5)
        else:
            result["unqueried_mae"] = 0.0
            result["unqueried_rmse"] = 0.0
        true_top = truth.argmax(axis=1)
        pred_top = prediction.argmax(axis=1)
        result["top1_agreement"] = float(np.mean(true_top == pred_top))
        true_top3 = np.argsort(-truth, axis=1)[:, :3]
        pred_top3 = np.argsort(-prediction, axis=1)[:, :3]
        result["top3_overlap"] = float(
            np.mean([len(set(a).intersection(b)) / 3.0 for a, b in zip(true_top3, pred_top3)])
        )
        discounts = 1.0 / np.log2(np.arange(2, 5))
        ndcgs = []
        for row in range(truth.shape[0]):
            gain = truth[row, pred_top3[row]]
            ideal = truth[row, true_top3[row]]
            denominator = float(np.sum(ideal * discounts))
            ndcgs.append(float(np.sum(gain * discounts) / denominator) if denominator else 1.0)
        result["ndcg_at_3"] = float(np.mean(ndcgs))
        pair_correct: list[np.ndarray] = []
        for left in range(truth.shape[1]):
            for right in range(left + 1, truth.shape[1]):
                true_sign = np.sign(truth[:, left] - truth[:, right])
                pred_sign = np.sign(prediction[:, left] - prediction[:, right])
                non_tie = true_sign != 0
                if non_tie.any():
                    pair_correct.append((true_sign[non_tie] == pred_sign[non_tie]).astype(float))
        result["pairwise_ranking_accuracy"] = float(np.concatenate(pair_correct).mean())
        result["vbs_regret"] = float(np.mean(truth.max(axis=1) - truth[np.arange(truth.shape[0]), pred_top]))
        return result


def continuous_cost_scale(cost: np.ndarray) -> np.ndarray:
    if np.allclose(cost.min(), cost.max()):
        return np.ones_like(cost)
    return 1.0 + 4.0 * (cost - cost.min()) / (cost.max() - cost.min())


def cost_tiers(cost: np.ndarray, number: int) -> np.ndarray:
    edges = np.quantile(cost, np.arange(1, number) / number)
    return np.digitize(cost, edges, right=True).astype(float) + 1.0


def acquisition_values(
    method: str,
    utility_mean: np.ndarray,
    utility_sd: np.ndarray,
    runtime: RuntimePrediction | None,
    candidate_algorithms: np.ndarray,
    cumulative_algorithm_counts: np.ndarray,
    rng: np.random.Generator,
) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
    utility = utility_mean + utility_sd
    if method == "plain_mean_ucb":
        return utility, utility.copy(), np.full(utility.size, np.nan)
    assert runtime is not None
    if method == "direct_cost_uc":
        return utility, utility / (runtime.mean + 1e-6), runtime.mean

    normalized_utility = np.maximum(percentile_rank(utility), 1e-3)
    selected_cost = runtime.conservative if method in ENSEMBLE_COST_METHODS else runtime.mean
    scaled_cost = continuous_cost_scale(selected_cost)
    if method == "relaxed_cost_power_05":
        acquisition = normalized_utility / np.sqrt(scaled_cost)
    elif method == "cost_tiers_5":
        acquisition = normalized_utility / cost_tiers(selected_cost, 5)
    elif method == "runtime_uncertainty":
        acquisition = normalized_utility / np.sqrt(scaled_cost)
    elif method == "log_cost":
        acquisition = normalized_utility / np.log1p(scaled_cost)
    else:
        raise ValueError(f"Unknown method: {method}")
    return utility, acquisition, selected_cost


def choose_batch(
    candidates: np.ndarray,
    acquisition: np.ndarray,
    batch_size: int,
    columns: int,
    hard_cap: bool,
) -> np.ndarray:
    order = np.argsort(-acquisition, kind="stable")
    if not hard_cap:
        return candidates[order[:batch_size]]
    cap = max(1, math.floor(0.35 * batch_size))
    counts = np.zeros(columns, dtype=int)
    selected: list[int] = []
    deferred: list[int] = []
    for position in order:
        flat = int(candidates[position])
        algorithm = flat % columns
        if counts[algorithm] < cap:
            selected.append(flat)
            counts[algorithm] += 1
            if len(selected) == batch_size:
                break
        else:
            deferred.append(flat)
    if len(selected) < batch_size:
        selected.extend(deferred[: batch_size - len(selected)])
    return np.asarray(selected, dtype=np.int64)


def audit_summary(
    utility: np.ndarray,
    acquisition: np.ndarray,
    runtime: RuntimePrediction | None,
    selected_positions: np.ndarray,
) -> dict[str, object]:
    finite = np.isfinite(acquisition)
    safe_acquisition = acquisition[finite]
    overlap_count = min(50, utility.size)
    utility_top = set(np.argsort(-utility)[:overlap_count].tolist())
    acquisition_top = set(np.argsort(-acquisition)[:overlap_count].tolist())
    summary: dict[str, object] = {
        "utility_quantiles": quantiles(utility),
        "acquisition_quantiles": quantiles(safe_acquisition),
        "utility_acquisition_spearman": float(pd.Series(utility[finite]).corr(pd.Series(acquisition[finite]), method="spearman")),
        "top50_overlap": len(utility_top.intersection(acquisition_top)) / overlap_count,
        "selected_utility_mean": float(utility[selected_positions].mean()),
        "selected_acquisition_mean": float(acquisition[selected_positions].mean()),
    }
    if runtime is not None:
        summary.update(
            runtime_mean_quantiles=quantiles(runtime.mean),
            runtime_sd_quantiles=quantiles(runtime.sd),
            selected_predicted_runtime_mean=float(runtime.mean[selected_positions].mean()),
            runtime_lower_bound=runtime.lower,
            runtime_upper_bound=runtime.upper,
            predictions_at_lower_bound=int(np.isclose(runtime.mean, runtime.lower).sum()),
            predictions_at_upper_bound=int(np.isclose(runtime.mean, runtime.upper).sum()),
        )
    return summary


def checkpoint_paths(run_dir: Path, percentage: int) -> dict[str, Path]:
    label = f"{percentage:03d}pct"
    return {
        "matrix": run_dir / "strict_score_matrices" / f"strict_score_{label}.csv",
        "cumulative": run_dir / "queried_cells" / "cumulative" / f"queried_{label}.csv",
        "new": run_dir / "queried_cells" / "newly_queried" / f"queried_{label}.csv",
        "candidate": run_dir / "candidate_acquisition_audits" / f"audit_{label}.json",
        "distribution": run_dir / "algorithm_query_distributions" / f"distribution_{label}.csv",
        "reconstruction": run_dir / "reconstruction_metrics" / f"metrics_{label}.json",
        "runtime": run_dir / "runtime_prediction_metrics" / f"metrics_{label}.json",
    }


def query_frame(records: list[dict[str, object]], indices: list[int], columns: int) -> pd.DataFrame:
    selected = [records[index] for index in indices]
    return pd.DataFrame(selected)


def export_checkpoint(
    run_dir: Path,
    percentage: int,
    prediction: np.ndarray,
    row_index: pd.Index,
    records: list[dict[str, object]],
    previous_count: int,
    oracle: HiddenOracle,
    observed: np.ndarray,
) -> dict[str, float]:
    paths = checkpoint_paths(run_dir, percentage)
    atomic_csv(paths["matrix"], pd.DataFrame(prediction, index=row_index, columns=ALGORITHMS))
    cumulative_indices = list(range(len(records)))
    new_indices = list(range(previous_count, len(records)))
    atomic_csv(paths["cumulative"], query_frame(records, cumulative_indices, len(ALGORITHMS)), index=False)
    atomic_csv(paths["new"], query_frame(records, new_indices, len(ALGORITHMS)), index=False)
    counts = pd.Series([record["algorithm"] for record in records]).value_counts().reindex(ALGORITHMS, fill_value=0)
    distribution = pd.DataFrame({"algorithm": ALGORITHMS, "cumulative_count": counts.to_numpy()})
    distribution["cumulative_share"] = distribution["cumulative_count"] / len(records)
    atomic_csv(paths["distribution"], distribution, index=False)
    metrics = oracle.evaluate(prediction, observed)
    metrics.update(percentage=percentage, queried_cells=len(records))
    atomic_json(paths["reconstruction"], metrics)
    return metrics


def load_inputs() -> tuple[pd.Index, np.ndarray, np.ndarray, np.ndarray, np.ndarray]:
    rmsd_index, rmsd = read_matrix("moad_rmsd_trimmed.csv")
    pb_index, pb = read_matrix("moad_pb_ratio_trimmed.csv")
    runtime_index, runtime = read_matrix("moad_runtime_trimmed.csv")
    if not rmsd_index.equals(pb_index) or not rmsd_index.equals(runtime_index):
        raise ValueError("Input matrix row labels are not aligned")
    if not np.isfinite(runtime).all() or (runtime < 0).any():
        raise ValueError("Runtime matrix must contain finite, nonnegative seconds")
    if not rmsd_index.is_unique or rmsd_index.hasnans:
        raise ValueError("Raw matrices require unique, non-missing complex identifiers")
    features = np.load(FEATURE_CACHE, allow_pickle=False).astype(np.float32)
    if features.ndim != 2 or features.shape != (len(rmsd_index), 256):
        raise ValueError("Expected a finite molecular feature matrix with one row per complex and 256 columns")
    if not np.isfinite(features).all():
        raise ValueError("Molecular features contain non-finite values")
    if not FEATURE_IDS.is_file():
        raise FileNotFoundError(
            f"Missing producer-verified feature-row identifiers: {FEATURE_IDS}. "
            "Shape alone cannot establish cache alignment; do not create this file by guessing raw-matrix order."
        )
    feature_ids = pd.read_csv(FEATURE_IDS, dtype=str, keep_default_na=False)
    if feature_ids.shape[1] != 1 or feature_ids.iloc[:, 0].tolist() != rmsd_index.astype(str).tolist():
        raise ValueError("Feature-row identifier CSV must have one column matching matrix identifiers in exactly the same order")
    descriptors = load_descriptors(rmsd_index)
    folds = load_folds(rmsd_index)
    combined_features = np.concatenate([features, descriptors], axis=1)
    return rmsd_index, strict_score(rmsd, pb), runtime, combined_features, folds


def run_one(
    method: str,
    seed: int,
    fold: int,
    *,
    smoke_test: bool = False,
    resume: bool = True,
    context: dict[str, object] | None = None,
    prepared_inputs: tuple | None = None,
) -> None:
    if method not in METHODS:
        raise ValueError(method)
    row_index, score_truth, runtime_truth, features, fold_labels = (
        load_inputs() if prepared_inputs is None else prepared_inputs
    )
    training = fold_labels != fold
    row_index = row_index[training]
    score_truth = score_truth[training]
    runtime_truth = runtime_truth[training]
    features = features[training]
    if smoke_test:
        score_truth = score_truth[:120]
        runtime_truth = runtime_truth[:120]
        features = features[:120]
        row_index = row_index[:120]
    rows, columns = score_truth.shape
    total = rows * columns
    run_root = (
        OUTPUT / ("smoke" if smoke_test else "runs")
        / method / f"fold{fold}" / f"seed{seed}"
    )
    state_path = run_root / "run_state" / "state.json"
    log_path = run_root / "run_state" / "events.jsonl"
    specification = {
        "method": method, "fold": fold, "seed": seed, "smoke_test": smoke_test,
        "context": context if context is not None else build_run_context(),
    }
    configuration_fingerprint = fingerprint(specification)
    if verify_existing_run(run_root, configuration_fingerprint, resume=resume):
        print(f"Already complete with matching provenance: {run_root}", flush=True)
        return
    atomic_json(run_root / "run_state/run_manifest.json", {
        "schema_version": 1, "configuration_fingerprint": configuration_fingerprint,
        "run": specification,
    })
    oracle = HiddenOracle(score_truth, runtime_truth)
    runtime_model = RuntimeSurrogate(features, columns)
    if resume and state_path.exists():
        state = json.loads(state_path.read_text())
        records = state["records"]
        last_checkpoint = int(state["last_checkpoint"])
        round_id = int(state["round_id"])
        pending_round_audits = state.get("pending_round_audits", [])
        if (state.get("method"), state.get("fold"), state.get("seed")) != (method, fold, seed):
            raise RuntimeError("Resume-state job identity does not match the requested run")
        observed_flat = np.asarray([record["flat_index"] for record in records], dtype=np.int64)
        revealed_score, revealed_runtime = oracle.reveal(observed_flat, -1)
        for record, score, runtime in zip(records, revealed_score, revealed_runtime):
            if not np.isclose(float(record["score"]), score) or not np.isclose(float(record["runtime"]), runtime):
                raise RuntimeError("Resume-state oracle values do not match current inputs")
    else:
        observed_flat = warm_start(score_truth.shape, seed)
        revealed_score, revealed_runtime = oracle.reveal(observed_flat, 0)
        records = []
        for flat, score, runtime in zip(observed_flat, revealed_score, revealed_runtime):
            row, column = divmod(int(flat), columns)
            records.append(
                {
                    "query_order": len(records) + 1,
                    "round": 0,
                    "flat_index": int(flat),
                    "row_index": row,
                    "row_label": str(row_index[row]),
                    "algorithm_index": column,
                    "algorithm": ALGORITHMS[column],
                    "utility": math.nan,
                    "acquisition": math.nan,
                    "predicted_runtime_mean": math.nan,
                    "predicted_runtime_sd": math.nan,
                    "score": float(score),
                    "runtime": float(runtime),
                }
            )
        last_checkpoint = 0
        round_id = 0
        pending_round_audits = []

    observed = np.zeros(total, dtype=bool)
    observed[observed_flat] = True
    checkpoint_targets = {percentage: math.ceil(total * percentage / 100.0) for percentage in range(1, 101)}
    checkpoint_targets[100] = total
    previous_checkpoint_count = previous_checkpoint_size(last_checkpoint, checkpoint_targets)
    rng = np.random.default_rng(seed * 100_003 + METHODS.index(method) * 997)
    started = time.time()

    for percentage in range(max(1, last_checkpoint + 1), 101):
        target = checkpoint_targets[percentage]
        round_audits: list[dict[str, object]] = list(pending_round_audits)
        pending_round_audits = []
        while observed.sum() < target:
            round_id += 1
            score_mean, score_sd = score_ensemble(score_truth, observed.reshape(score_truth.shape))
            candidates = np.flatnonzero(~observed)
            candidate_rows, candidate_algorithms = np.unravel_index(candidates, score_truth.shape)
            utility_mean = score_mean[candidate_rows, candidate_algorithms]
            utility_sd = score_sd[candidate_rows, candidate_algorithms]
            prediction = None
            if method in COST_METHODS:
                queried = np.flatnonzero(observed)
                runtime_ledger = {
                    int(record["flat_index"]): float(record["runtime"])
                    for record in records
                }
                observed_runtime = np.asarray(
                    [runtime_ledger[int(index)] for index in queried],
                    dtype=np.float64,
                )
                prediction = runtime_model.predict(
                    queried,
                    observed_runtime,
                    candidates,
                    seed + round_id * 31,
                    3 if method in ENSEMBLE_COST_METHODS else 1,
                    legacy=method == "legacy_direct_cost_mean_ucb",
                )
            cumulative_counts = np.bincount(np.flatnonzero(observed) % columns, minlength=columns)
            utility, acquisition, selected_cost = acquisition_values(
                method,
                utility_mean,
                utility_sd,
                prediction,
                candidate_algorithms,
                cumulative_counts,
                rng,
            )
            batch_size = min(50, target - int(observed.sum()))
            selected_flat = choose_batch(
                candidates,
                acquisition,
                batch_size,
                columns,
                hard_cap=method == "hard_cap_35",
            )
            candidate_lookup = {int(flat): position for position, flat in enumerate(candidates)}
            positions = np.asarray([candidate_lookup[int(flat)] for flat in selected_flat], dtype=int)
            round_audit = audit_summary(utility, acquisition, prediction, positions)
            round_audit.update(round=round_id, selected_cells=batch_size)
            round_audits.append(round_audit)
            revealed_score, revealed_runtime = oracle.reveal(selected_flat, round_id)
            for flat, score, runtime, position in zip(selected_flat, revealed_score, revealed_runtime, positions):
                row, column = divmod(int(flat), columns)
                records.append(
                    {
                        "query_order": len(records) + 1,
                        "round": round_id,
                        "flat_index": int(flat),
                        "row_index": row,
                        "row_label": str(row_index[row]),
                        "algorithm_index": column,
                        "algorithm": ALGORITHMS[column],
                        "utility": float(utility[position]),
                        "acquisition": float(acquisition[position]),
                        "predicted_runtime_mean": float(prediction.mean[position]) if prediction is not None else math.nan,
                        "predicted_runtime_sd": float(prediction.sd[position]) if prediction is not None else math.nan,
                        "score": float(score),
                        "runtime": float(runtime),
                    }
                )
            observed[selected_flat] = True
            state = {
                "version": 1,
                "method": method,
                "fold": fold,
                "seed": seed,
                "round_id": round_id,
                "last_checkpoint": percentage - 1,
                "records": records,
                "pending_round_audits": round_audits,
            }
            atomic_json(state_path, state)
            with log_path.open("a") as handle:
                handle.write(json.dumps({"event": "microbatch", "method": method, "fold": fold, "seed": seed, "round": round_id, "observed": int(observed.sum()), "target_percentage": percentage}) + "\n")

        final_prediction = svd_complete(score_truth, observed.reshape(score_truth.shape), rank=3)
        metrics = export_checkpoint(
            run_root,
            percentage,
            final_prediction,
            row_index,
            records,
            previous_checkpoint_count,
            oracle,
            observed.reshape(score_truth.shape),
        )
        paths = checkpoint_paths(run_root, percentage)
        atomic_json(paths["candidate"], {"percentage": percentage, "rounds": round_audits})
        queried_runtime = np.asarray([record["runtime"] for record in records], dtype=float)
        runtime_metrics = {
            "percentage": percentage,
            "queried_cells": len(records),
            "cumulative_true_runtime": float(queried_runtime.sum()),
            "mean_true_runtime": float(queried_runtime.mean()),
        }
        predicted = np.asarray([record["predicted_runtime_mean"] for record in records], dtype=float)
        valid = np.isfinite(predicted)
        if valid.any():
            runtime_metrics.update(
                prediction_mae=float(mean_absolute_error(queried_runtime[valid], predicted[valid])),
                prediction_rmse=float(mean_squared_error(queried_runtime[valid], predicted[valid]) ** 0.5),
                prediction_spearman=float(pd.Series(queried_runtime[valid]).corr(pd.Series(predicted[valid]), method="spearman")),
            )
        atomic_json(paths["runtime"], runtime_metrics)
        previous_checkpoint_count = target
        state = {
            "version": 1,
            "method": method,
            "fold": fold,
            "seed": seed,
            "round_id": round_id,
            "last_checkpoint": percentage,
            "records": records,
            "pending_round_audits": [],
            "last_metrics": metrics,
        }
        atomic_json(state_path, state)
        with log_path.open("a") as handle:
            handle.write(json.dumps({"event": "checkpoint", "method": method, "fold": fold, "seed": seed, "percentage": percentage, "observed": len(records), "elapsed_seconds": time.time() - started}) + "\n")

    atomic_json(
        run_root / "run_state" / "complete.json",
        {
            "method": method,
            "fold": fold,
            "seed": seed,
            "checkpoints": 100,
            "configuration_fingerprint": configuration_fingerprint,
            "queried_cells": len(records),
            "oracle_accesses": len(oracle.access_log),
            "elapsed_seconds": time.time() - started,
        },
    )


def input_files() -> dict[str, Path]:
    return {
        "rmsd": DATA / "moad_rmsd_trimmed.csv",
        "pb_ratio": DATA / "moad_pb_ratio_trimmed.csv",
        "runtime": DATA / "moad_runtime_trimmed.csv",
        "features": FEATURE_CACHE, "feature_ids": FEATURE_IDS,
        "descriptors": DESCRIPTORS, "fold_split": FOLD_SPLIT,
    }


def build_run_context() -> dict[str, object]:
    return {
        "implementation": "publication release; historical source snapshot is separate",
        "input_files": {role: {"filename": path.name, "bytes": path.stat().st_size,
                               "sha256": sha256(path)} for role, path in input_files().items()},
        "code_sha256": {name: sha256(HERE / name) for name in ("run_experiment.py", "release_support.py")},
        "environment": environment_versions(),
        "configuration": {
            "algorithms": ALGORITHMS, "score_lambda": LAMBDA,
            "acquisition_svd_ranks": list(SVD_RANKS), "acquisition_svd_iterations": 4,
            "export_svd_rank": 3, "export_svd_iterations": 6,
            "beta": 1.0, "microbatch_maximum": 50,
            "checkpoints": list(range(1, 101)), "warm_start_fraction": 0.01,
            "runtime_surrogate": {"family": "MLPRegressor", "hidden_layers": [32, 16],
                                  "max_iterations_per_refit": 10, "target": "log1p(runtime)",
                                  "observed_runtime_clip_quantiles": [0.05, 0.95]},
            "feature_order": "producer-verified ID file required; exact ordered-ID match validated",
        },
    }


def write_manifest(args: argparse.Namespace) -> dict[str, object]:
    context = build_run_context()
    invocation_id = uuid.uuid4().hex
    atomic_json(OUTPUT / "invocations" / f"{invocation_id}.json", {
        "schema_version": 1, "invocation_id": invocation_id,
        "created_utc": datetime.now(timezone.utc).isoformat(),
        "invocation": invocation_arguments(args), "context": context,
    })
    return context


def main() -> None:
    parser = argparse.ArgumentParser()
    parser.add_argument("--methods", nargs="+", choices=METHODS, default=list(METHODS))
    parser.add_argument("--seeds", nargs="+", type=int, default=[0, 1, 2])
    parser.add_argument("--folds", nargs="+", type=int, choices=range(5), default=[0, 1, 2, 3, 4])
    parser.add_argument("--smoke-test", action="store_true")
    parser.add_argument("--no-resume", action="store_true",
                        help="Start fresh; refuses an existing run directory.")
    parser.add_argument("--validate-only", action="store_true", help="Validate inputs without fitting models or acquiring cells.")
    add_path_arguments(parser)
    args = parser.parse_args()
    configure_paths(args)
    prepared_inputs = load_inputs()
    if args.validate_only:
        print(json.dumps({"status": "pass", "complexes": len(prepared_inputs[0]), "algorithms": len(ALGORITHMS)}))
        return
    context = write_manifest(args)
    for fold in args.folds:
        for seed in args.seeds:
            for method in args.methods:
                run_one(
                    method,
                    seed,
                    fold,
                    smoke_test=args.smoke_test,
                    resume=not args.no_resume,
                    context=context,
                    prepared_inputs=prepared_inputs,
                )


if __name__ == "__main__":
    main()