src/explicit_learning/training/smoke_gate.py

"""Immutable certification and main-run validation for the controlled GPU smokes."""

from __future__ import annotations

import json
import math
from collections import Counter
from collections.abc import Mapping, Sequence
from pathlib import Path
from typing import Any

from ..atomic_io import read_jsonl
from ..hashing import canonical_json, canonical_json_hash, is_sha256
from .evi_po_contract import EVI_PO_ADAPTER_VERSION
from .papo_contract import (
    GAMMA_ZERO_GRADIENT_ABS_FLOOR,
    GAMMA_ZERO_GRADIENT_REL_TOL,
    PAPO_ADAPTER_VERSION,
    PAPO_UPSTREAM_SOURCE_SHA256,
)
from .rewards import GPU_SMOKE_ARMS, smoke_reference_arm

SMOKE_STEPS = 20


class SmokeGateError(RuntimeError):
    """Raised when smoke evidence is incomplete, drifted, or self-inconsistent."""


_COMMON_RUNTIME_FIELDS = (
    "training_contract_version",
    "model_revision",
    "model_snapshot_sha256",
    "environment_lock_sha256",
    "evaluation_manifest_sha256",
    "system_prompt_sha256",
    "precision",
    "attention_implementation",
    "max_prompt_tokens",
    "max_completion_tokens",
    "total_context_tokens",
    "per_device_train_batch_size",
    "gradient_accumulation_steps",
    "world_size",
    "generations_per_prompt",
    "checkpoint_interval",
    "max_completion_tokens_per_run",
    "learning_rate",
    "lora_rank",
    "lora_alpha",
    "lora_dropout",
    "lora_target_modules",
    "comparison_slot_manifest_sha256",
    "backend_entrypoint",
    "use_vllm",
    "vllm_config",
    "enable_thinking",
    "structured_output_regex",
    "optimizer",
    "scheduler",
    "gradient_checkpointing",
    "max_grad_norm",
    "freeze_vision_tower",
    "freeze_multimodal_projector",
    "train_full_weights",
    "lora_exclude_modules",
    "base_model_resource",
    "base_model_repo_id",
    "reject_overlength_samples",
    "temperature",
    "top_p",
)


def common_contract(
    runtime: Mapping[str, Any],
    manifest: Mapping[str, Any],
    *,
    source_config_sha256: str,
) -> dict[str, Any]:
    """Project behavior that must match between smoke and main.

    The whole repository commit and whole experiment-file hash are deliberately
    excluded: documentation, evaluator, or matrix edits do not invalidate a GPU
    trainer smoke.  Runtime/data/initialization identities below still pin every
    behavior-affecting input.
    """

    return {
        "dataset_manifest_sha256": manifest.get("dataset_manifest_sha256"),
        "initial_checkpoint_sha256": manifest.get("initial_checkpoint_sha256"),
        "runtime": {field: runtime.get(field) for field in _COMMON_RUNTIME_FIELDS},
        "papo_adapter_version": PAPO_ADAPTER_VERSION,
        "papo_upstream_source_sha256": PAPO_UPSTREAM_SOURCE_SHA256,
        "evi_po_adapter_version": EVI_PO_ADAPTER_VERSION,
    }


def method_contract(runtime: Mapping[str, Any]) -> dict[str, Any]:
    """Project arm-specific fields that main must match to its own smoke run."""

    def objective(value: Any) -> Any:
        if not isinstance(value, Mapping):
            return value
        projected = dict(value)
        projected.pop("require_gpu_contract_probe", None)
        return projected

    return {
        "arm": runtime.get("arm"),
        "trainer_kind": runtime.get("trainer_kind"),
        "loss_type": runtime.get("loss_type"),
        "beta": runtime.get("beta"),
        "papo_config": objective(runtime.get("papo_config")),
        "evi_po_config": objective(runtime.get("evi_po_config")),
    }


def smoke_compatibility_contract(runtime: Mapping[str, Any]) -> dict[str, Any]:
    """Project the GPU-tested implementation family, excluding ablated knobs.

    A direct EVI/PAPO/target ablation intentionally differs from its parent
    objective and therefore cannot exact-match the parent's method contract.
    It still has to use the same tested trainer, adapter implementation, loss
    family, and grouped-data relationship contract.
    """

    arm = str(runtime.get("arm", ""))
    evi = runtime.get("evi_po_config")
    papo = runtime.get("papo_config")
    if isinstance(evi, Mapping):
        evi = {
            key: value
            for key, value in evi.items()
            if key not in {"lambda_direction", "lambda_evidence", "margin", "require_gpu_contract_probe"}
        }
    if isinstance(papo, Mapping):
        papo = {
            key: value
            for key, value in papo.items()
            if key not in {"mask_ratio", "perception_loss_weight", "require_gpu_contract_probe"}
        }
    return {
        "smoke_reference_arm": smoke_reference_arm(arm),
        "trainer_kind": runtime.get("trainer_kind"),
        "loss_type": runtime.get("loss_type"),
        "beta": runtime.get("beta"),
        "papo_implementation": papo,
        "evi_po_implementation": evi,
    }


def _load_object(path: Path, label: str) -> dict[str, Any]:
    try:
        value = json.loads(path.read_text(encoding="utf-8"))
    except (OSError, json.JSONDecodeError) as exc:
        raise SmokeGateError(f"cannot read {label} {path}: {exc}") from exc
    if not isinstance(value, dict):
        raise SmokeGateError(f"{label} must be a JSON object: {path}")
    return value


def _load_attested_object(row: Mapping[str, Any], label: str) -> dict[str, Any]:
    """Load one small external evidence file and match its embedded copy."""

    path = Path(str(row.get("path", "")))
    if not path.is_file():
        raise SmokeGateError(f"{label} file is missing: {path}")
    payload = _load_object(path, label)
    embedded = {key: value for key, value in row.items() if key not in {"path", "sha256"}}
    if canonical_json(payload) != canonical_json(embedded):
        raise SmokeGateError(f"{label} embedded copy differs from attested bytes")
    return payload


def _assert_finite(value: Any, label: str) -> None:
    if isinstance(value, bool | str) or value is None:
        return
    if isinstance(value, int | float):
        if not math.isfinite(float(value)):
            raise SmokeGateError(f"{label} contains NaN or Inf")
        return
    if isinstance(value, Mapping):
        for key, item in value.items():
            _assert_finite(item, f"{label}.{key}")
        return
    if isinstance(value, Sequence):
        for index, item in enumerate(value):
            _assert_finite(item, f"{label}[{index}]")


def _assert_phase_2_resume_audit(
    audit: Mapping[str, Any],
    *,
    arm: str,
) -> None:
    """Validate measured checkpoint/loaded digests without trusting booleans."""

    rng_components = audit.get("rng_components_equal")
    checkpoint_path = Path(str(audit.get("checkpoint", "")))
    digest_pairs = (
        ("checkpoint_trainable_parameter_sha256", "loaded_trainable_parameter_sha256"),
        ("checkpoint_optimizer_sha256", "loaded_optimizer_sha256"),
        ("checkpoint_scheduler_sha256", "loaded_scheduler_sha256"),
        ("checkpoint_rng_sha256", "loaded_rng_sha256"),
    )
    if (
        audit.get("status") != "passed"
        or audit.get("model_loader_called") is not True
        or audit.get("model_state_equal") is not True
        or audit.get("optimizer_state_equal") is not True
        or audit.get("scheduler_state_equal") is not True
        or audit.get("rng_state_equal") is not True
        or not isinstance(rng_components, dict)
        or set(rng_components) != {"python", "numpy", "cpu", "cuda"}
        or any(value is not True for value in rng_components.values())
        or not checkpoint_path.is_dir()
        or any(
            not is_sha256(str(audit.get(checkpoint_field)))
            or audit.get(checkpoint_field) != audit.get(loaded_field)
            for checkpoint_field, loaded_field in digest_pairs
        )
    ):
        raise SmokeGateError(f"{arm} phase-2 resume digests are inconsistent")


def _assert_evi_probe(
    probe: Mapping[str, Any],
    *,
    runtime_config: Mapping[str, Any],
) -> None:
    """Validate the measured first-batch EVI objective/attention contract."""

    relationship_states = probe.get("relationship_states")
    required_states = {
        "FULL": "FULL",
        "CONTROL": "A_SAME",
        "MISSING": "U_MISSING",
    }
    source = probe.get("evidence_source")
    attention_shape = probe.get("attention_shape")
    configured_sources = runtime_config.get("evidence_sources")
    if (
        probe.get("status") != "passed"
        or probe.get("adapter_version") != EVI_PO_ADAPTER_VERSION
        or runtime_config.get("adapter_version") != EVI_PO_ADAPTER_VERSION
        or runtime_config.get("required_relationships") != ["FULL", "CONTROL", "MISSING"]
        or runtime_config.get("optional_relationships") != ["SUBSTITUTE"]
        or runtime_config.get("candidate_support") != "group_answers_plus_unanswerable"
        or runtime_config.get("evidence_supervision_relation") != "FULL"
        or runtime_config.get("attention_capture") != "last_full_attention_layer_eager_forward_hook"
        or runtime_config.get("zero_weight_reduction") != "exact_parent_grpo_path"
        or runtime_config.get("require_gpu_contract_probe") is not True
        or not isinstance(relationship_states, dict)
        or any(relationship_states.get(key) != value for key, value in required_states.items())
        or set(relationship_states) - {*required_states, "SUBSTITUTE"}
        or (
            "SUBSTITUTE" in relationship_states and relationship_states["SUBSTITUTE"] != "A_CHANGED"
        )
        or probe.get("substitute_available") != ("SUBSTITUTE" in relationship_states)
        or probe.get("lambda_direction") != runtime_config.get("lambda_direction")
        or probe.get("lambda_evidence") != runtime_config.get("lambda_evidence")
        or probe.get("margin") != runtime_config.get("margin")
        or float(probe.get("lambda_direction", 0.0)) <= 0.0
        or float(probe.get("lambda_evidence", 0.0)) <= 0.0
        or float(probe.get("direction_loss", -1.0)) < 0.0
        or float(probe.get("evidence_loss", -1.0)) < 0.0
        or float(probe.get("direction_gradient_norm", 0.0)) <= 0.0
        or float(probe.get("evidence_gradient_norm", 0.0)) <= 0.0
        or probe.get("attention_requires_grad") is not True
        or not isinstance(probe.get("attention_layer"), str)
        or not probe.get("attention_layer")
        or not isinstance(attention_shape, list)
        or len(attention_shape) != 4
        or attention_shape[0] != 1
        or any(not isinstance(value, int) or value <= 0 for value in attention_shape)
        or not isinstance(probe.get("visual_token_count"), int)
        or int(probe["visual_token_count"]) <= 0
        or not isinstance(probe.get("evidence_visual_token_count"), int)
        or not 0 < int(probe["evidence_visual_token_count"]) <= int(probe["visual_token_count"])
        or not isinstance(configured_sources, list)
        or source not in configured_sources
        or not is_sha256(str(probe.get("evidence_contract_sha256")))
    ):
        raise SmokeGateError("EVI-PO GPU probe/config evidence is inconsistent")
    _assert_finite(probe, "evi_gpu_contract_probe")


def _assert_papo_probe(
    probe: Mapping[str, Any] | None,
    *,
    runtime_config: Mapping[str, Any],
) -> None:
    """Validate the measured first-batch PAPO perception contract.

    ``gamma_zero_loss_max_abs_diff`` must be bit-exact 0.0 (gamma=0 recovers the
    parent GRPO loss exactly); the gradient equality is checked up to the
    floating-point tolerance defined in :mod:`papo_contract`, since two
    ``autograd.grad`` traversals differ only by accumulation-order roundoff.
    """

    if not isinstance(probe, dict) or probe.get("status") != "passed":
        raise SmokeGateError("PAPO smoke lacks a passed real-batch GPU contract probe")
    unchanged = probe.get("input_tensors_unchanged")
    if (
        not isinstance(unchanged, dict)
        or not unchanged
        or not all(value is True for value in unchanged.values())
        or probe.get("deterministic_mask_replay") is not True
        or not 0.55 <= float(probe.get("observed_mask_ratio", -1.0)) <= 0.65
        or float(probe.get("perception_kl", 0.0)) <= 0.0
        or float(probe.get("perception_gradient_norm", 0.0)) <= 0.0
        or probe.get("gamma_zero_loss_max_abs_diff") != 0.0
        or probe.get("gamma_zero_gradient_structure_equal") is not True
        or float(probe.get("gamma_zero_gradient_max_abs_diff", 0.0))
        > GAMMA_ZERO_GRADIENT_REL_TOL
        * float(probe.get("gamma_zero_parent_gradient_max_abs", 0.0))
        + GAMMA_ZERO_GRADIENT_ABS_FLOOR
        or probe.get("der_loss_weight1") != 0.0
        or probe.get("der_loss_weight2") != 0.0
        or not isinstance(runtime_config, dict)
        or runtime_config.get("adapter_version") != PAPO_ADAPTER_VERSION
        or runtime_config.get("upstream_source_sha256") != PAPO_UPSTREAM_SOURCE_SHA256
        or runtime_config.get("require_gpu_contract_probe") is not True
    ):
        raise SmokeGateError("PAPO GPU probe/config evidence is inconsistent")
    _assert_finite(probe, "papo_gpu_contract_probe")


def _validate_marker_references(
    marker: Mapping[str, Any],
    *,
    generations_per_prompt: int,
) -> dict[str, int]:
    final_adapter = Path(str(marker.get("final_adapter", "")))
    if not final_adapter.is_dir() or not any(path.is_file() for path in final_adapter.iterdir()):
        raise SmokeGateError("smoke final adapter is missing or empty")
    observed_generations: dict[str, set[int]] = {}
    ledger_identities: Counter[tuple[str, str, int, int]] = Counter()
    trace_identities: Counter[tuple[str, str, int, int]] = Counter()
    ledger_tokens = 0
    ledger_rows = 0
    empty_answer_count = 0
    for field in ("rank_ledger_manifest", "rank_reward_trace_manifest"):
        rows = marker.get(field)
        if not isinstance(rows, list):
            raise SmokeGateError(f"smoke marker lacks {field}")
        for row in rows:
            if not isinstance(row, dict):
                raise SmokeGateError(f"{field} contains a malformed row")
            path = Path(str(row.get("path", "")))
            if not path.is_file():
                raise SmokeGateError(f"{field} referenced file is missing: {path}")
            if field == "rank_ledger_manifest":
                value = _load_object(path, "rank completion ledger")
                entries = value.get("entries")
                if not isinstance(entries, list) or len(entries) != row.get("completion_count"):
                    raise SmokeGateError(f"ledger entry count mismatch: {path}")
                if value.get("consumed_tokens") != row.get("consumed_tokens"):
                    raise SmokeGateError(f"ledger token total mismatch: {path}")
                for entry in entries:
                    if not isinstance(entry, dict):
                        raise SmokeGateError(f"malformed ledger entry: {path}")
                    slot_id = entry.get("slot_id")
                    generation = entry.get("generation_index")
                    measured_completion_id = entry.get("completion_id")
                    token_count = entry.get("token_count")
                    if (
                        not isinstance(slot_id, str)
                        or not isinstance(generation, int)
                        or not isinstance(measured_completion_id, str)
                        or not measured_completion_id
                        or not isinstance(token_count, int)
                        or token_count <= 0
                    ):
                        raise SmokeGateError(f"malformed measured ledger identity: {path}")
                    observed_generations.setdefault(slot_id, set()).add(generation)
                    ledger_identities[
                        (measured_completion_id, slot_id, generation, token_count)
                    ] += 1
                    ledger_tokens += token_count
                    ledger_rows += 1
            else:
                traces = list(read_jsonl(path))
                if len(traces) != row.get("row_count"):
                    raise SmokeGateError(f"reward trace row count mismatch: {path}")
                invalid = 0
                for trace in traces:
                    _assert_finite(trace, f"reward_trace:{path}")
                    slot_id = trace.get("slot_id")
                    generation = trace.get("generation_index")
                    measured_completion_id = trace.get("completion_id")
                    token_count = trace.get("completion_tokens")
                    if (
                        not isinstance(slot_id, str)
                        or not isinstance(generation, int)
                        or not isinstance(measured_completion_id, str)
                        or not measured_completion_id
                        or not isinstance(token_count, int)
                        or token_count <= 0
                    ):
                        raise SmokeGateError(f"malformed reward-trace identity: {path}")
                    trace_identities[
                        (measured_completion_id, slot_id, generation, token_count)
                    ] += 1
                    invalid += int(trace.get("parser_valid") is not True)
                    if trace.get("parser_error") == "empty_answer":
                        empty_answer_count += 1
                if invalid != row.get("malformed_completion_count"):
                    raise SmokeGateError(f"reward trace malformed count mismatch: {path}")
    checkpoints = marker.get("checkpoint_manifest")
    if not isinstance(checkpoints, list) or not checkpoints:
        raise SmokeGateError("smoke marker has no checkpoint manifest")
    for row in checkpoints:
        if not isinstance(row, dict):
            raise SmokeGateError("checkpoint manifest contains a malformed row")
        path = Path(str(row.get("path", "")))
        if not path.is_dir():
            raise SmokeGateError(f"checkpoint directory is missing: {path}")
    expected_generations = set(range(generations_per_prompt))
    if any(generations != expected_generations for generations in observed_generations.values()):
        raise SmokeGateError("ledger slot lacks the exact generation-index set")
    if ledger_identities != trace_identities:
        raise SmokeGateError("ledger and reward-trace completion identities differ")
    return {
        "completion_count": ledger_rows,
        "completion_tokens": ledger_tokens,
        "unique_slots": len(observed_generations),
        "empty_answer_count": empty_answer_count,
    }


def _validate_smoke_run(config_path: Path) -> dict[str, Any]:
    frozen = _load_object(config_path, "frozen smoke config")
    manifest_path = config_path.with_name("run-manifest.json")
    manifest = _load_object(manifest_path, "smoke run manifest")
    runtime = frozen.get("runtime")
    if not isinstance(runtime, dict):
        raise SmokeGateError(f"{config_path} has no runtime object")
    if runtime.get("run_mode") != "smoke" or runtime.get("max_optimizer_steps") != SMOKE_STEPS:
        raise SmokeGateError(
            f"smoke runtime must use run_mode=smoke and exactly {SMOKE_STEPS} steps"
        )
    if manifest.get("run_mode") != "smoke":
        raise SmokeGateError("smoke run manifest has the wrong run mode")
    frozen_sha = canonical_json_hash(frozen)
    if manifest.get("frozen_config_sha256") != frozen_sha:
        raise SmokeGateError("smoke frozen config hash differs from run manifest")
    completion_path = Path(str(runtime.get("output_dir", ""))) / "training-complete.json"
    marker = _load_object(completion_path, "smoke completion marker")
    if (
        marker.get("schema_version") != 4
        or marker.get("status") != "completed"
        or marker.get("trained") is not True
        or marker.get("run_mode") != "smoke"
        or marker.get("optimizer_steps") != SMOKE_STEPS
    ):
        raise SmokeGateError(f"incomplete {SMOKE_STEPS}-step smoke: {completion_path}")
    arm = str(runtime.get("arm", ""))
    if marker.get("arm") != arm or manifest.get("arm") != arm:
        raise SmokeGateError("smoke arm identity drift")
    expected_completions = (
        SMOKE_STEPS
        * int(runtime["per_device_train_batch_size"])
        * int(runtime["gradient_accumulation_steps"])
        * int(runtime["world_size"])
    )
    if marker.get("realized_sampled_completion_count") != expected_completions:
        raise SmokeGateError(f"{arm} completion count is not exactly {expected_completions}")
    expected_unique = expected_completions // int(runtime["generations_per_prompt"])
    if marker.get("unique_prompt_groups_consumed") != expected_unique:
        raise SmokeGateError(f"{arm} unique-prompt count is not exactly {expected_unique}")
    if marker.get("prompt_truncation_count") != 0:
        raise SmokeGateError(f"{arm} has non-zero prompt_truncation_count")
    if marker.get("completion_truncation_count") != 0:
        raise SmokeGateError(f"{arm} has non-zero completion_truncation_count")
    if marker.get("oom_count") != 0:
        raise SmokeGateError(f"{arm} has non-zero oom_count")
    realized_tokens = marker.get("realized_sampled_completion_tokens")
    if not isinstance(realized_tokens, int) or realized_tokens <= 0:
        raise SmokeGateError(f"{arm} has no positive sampled completion-token count")
    projected_main_tokens = math.ceil(realized_tokens * 5750 / SMOKE_STEPS)
    if projected_main_tokens > int(runtime["max_completion_tokens_per_run"]):
        raise SmokeGateError(
            f"{arm} smoke projects {projected_main_tokens} main completion tokens, "
            f"above the {runtime['max_completion_tokens_per_run']} safety ceiling"
        )
    resume = marker.get("forced_process_resume_probe")
    if (
        not isinstance(resume, dict)
        or resume.get("status") != "passed"
        or resume.get("checkpoint_step") != 5
        or resume.get("resumed_to_step") != SMOKE_STEPS
        or resume.get("first_process_pid") == resume.get("resumed_process_pid")
    ):
        raise SmokeGateError(f"{arm} lacks the forced step-5 new-process resume proof")
    world_size = int(runtime["world_size"])
    expected_ranks = set(range(world_size))
    rank_resume_audits = resume.get("rank_resume_load_audits")
    if not isinstance(rank_resume_audits, list) or len(rank_resume_audits) != world_size:
        raise SmokeGateError(f"{arm} rank resume-load evidence is incomplete")
    if any(not isinstance(audit, dict) for audit in rank_resume_audits):
        raise SmokeGateError(f"{arm} rank resume-load evidence is malformed")
    resume_by_rank: dict[int, dict[str, Any]] = {}
    for embedded_audit in rank_resume_audits:
        audit = _load_attested_object(embedded_audit, f"{arm} phase-2 resume audit")
        rank = audit.get("rank")
        if not isinstance(rank, int) or rank in resume_by_rank:
            raise SmokeGateError(f"{arm} phase-2 rank set is malformed")
        resume_by_rank[rank] = audit
        _assert_phase_2_resume_audit(
            audit,
            arm=arm,
        )
    if set(resume_by_rank) != expected_ranks:
        raise SmokeGateError(f"{arm} phase-2 rank set is incomplete")
    phase_1_rank_evidence = resume.get("phase_1_rank_evidence")
    if not isinstance(phase_1_rank_evidence, list) or len(phase_1_rank_evidence) != world_size:
        raise SmokeGateError(f"{arm} phase-1 rank evidence is incomplete")
    phase_1_by_rank: dict[int, dict[str, Any]] = {}
    for embedded_evidence in phase_1_rank_evidence:
        if not isinstance(embedded_evidence, dict):
            raise SmokeGateError(f"{arm} has malformed phase-1 rank evidence")
        evidence = _load_attested_object(
            embedded_evidence, f"{arm} phase-1 trainable-state evidence"
        )
        rank = evidence.get("rank")
        if (
            not isinstance(rank, int)
            or rank in phase_1_by_rank
            or not is_sha256(str(evidence.get("trainable_parameter_state_sha256")))
            or not isinstance(evidence.get("max_gpu_memory_allocated_bytes"), int)
            or int(evidence["max_gpu_memory_allocated_bytes"]) <= 0
            or not isinstance(evidence.get("max_gpu_memory_reserved_bytes"), int)
            or int(evidence["max_gpu_memory_reserved_bytes"]) <= 0
        ):
            raise SmokeGateError(f"{arm} phase-1 evidence content is malformed")
        phase_1_by_rank[rank] = evidence
    if set(phase_1_by_rank) != expected_ranks:
        raise SmokeGateError(f"{arm} phase-1 rank set is incomplete")
    for embedded_audit in rank_resume_audits:
        rank = int(embedded_audit["rank"])
        audit = resume_by_rank[rank]
        phase_1 = phase_1_by_rank.get(rank)
        phase_1_embedded = next(row for row in phase_1_rank_evidence if row.get("rank") == rank)
        if (
            phase_1 is None
            or audit.get("phase_1_evidence_path") != phase_1_embedded.get("path")
            or audit.get("checkpoint_trainable_parameter_sha256")
            != phase_1.get("trainable_parameter_state_sha256")
        ):
            raise SmokeGateError(f"{arm} resume model-state evidence drifted")
    if marker.get("frozen_config_sha256") != frozen_sha:
        raise SmokeGateError("completion marker frozen-config hash mismatch")
    if marker.get("run_manifest_sha256") != canonical_json_hash(manifest):
        raise SmokeGateError("completion marker run-manifest hash mismatch")
    if marker.get("dataset_sha256") != manifest.get("dataset_manifest_sha256"):
        raise SmokeGateError("completion marker dataset hash mismatch")
    if (
        not isinstance(marker.get("max_gpu_memory_allocated_bytes"), int)
        or int(marker["max_gpu_memory_allocated_bytes"]) <= 0
    ):
        raise SmokeGateError(f"{arm} has no positive GPU allocation measurement")
    if (
        not isinstance(marker.get("max_gpu_memory_reserved_bytes"), int)
        or int(marker["max_gpu_memory_reserved_bytes"]) <= 0
    ):
        raise SmokeGateError(f"{arm} has no positive GPU reservation measurement")
    metrics = marker.get("metrics")
    if not isinstance(metrics, dict) or float(metrics.get("train_runtime", 0.0)) <= 0:
        raise SmokeGateError(f"{arm} has no positive train_runtime")
    if "train_loss" not in metrics:
        raise SmokeGateError(f"{arm} metrics lack train_loss")
    _assert_finite(metrics, f"{arm}.metrics")
    log_history = marker.get("log_history")
    _assert_finite(log_history, f"{arm}.log_history")
    if not isinstance(log_history, list) or not any(
        isinstance(row, dict) and "grad_norm" in row for row in log_history
    ):
        raise SmokeGateError(f"{arm} log history lacks measured grad_norm")
    if arm == "papo_controlled":
        _assert_papo_probe(
            marker.get("papo_gpu_contract_probe"),
            runtime_config=runtime.get("papo_config") or {},
        )
    elif marker.get("papo_gpu_contract_probe") is not None:
        raise SmokeGateError(f"non-PAPO arm {arm} unexpectedly has a PAPO probe")
    if arm == "evi_po":
        probe = marker.get("evi_gpu_contract_probe")
        evi_config = runtime.get("evi_po_config")
        if (
            not isinstance(probe, dict)
            or not isinstance(evi_config, dict)
            or canonical_json(marker.get("evi_po_config")) != canonical_json(evi_config)
        ):
            raise SmokeGateError("EVI-PO smoke lacks its frozen config/probe evidence")
        _assert_evi_probe(probe, runtime_config=evi_config)
    elif (
        marker.get("evi_gpu_contract_probe") is not None or runtime.get("evi_po_config") is not None
    ):
        raise SmokeGateError(f"non-EVI arm {arm} unexpectedly has EVI-PO state")
    measured = _validate_marker_references(
        marker,
        generations_per_prompt=int(runtime["generations_per_prompt"]),
    )
    if (
        measured["completion_count"] != expected_completions
        or measured["completion_tokens"] != marker.get("realized_sampled_completion_tokens")
        or measured["unique_slots"] != expected_unique
    ):
        raise SmokeGateError(f"{arm} measured ledger totals differ from marker")
    # ADR-0003 hard gate: prompt-truncation 0 + completion-truncation 0 + a single
    # <answer> block.  An ``empty_answer`` is structurally conformant (one open, one
    # close, in order, terminated, no trailing text) -- a content-empty zero-reward
    # sample, not a structural decode failure -- so it is excluded from the gate's
    # malformed decision.  vLLM's regex backend enforces the single-block structure
    # but not the content min-bound ``{1,128}``, so empties are an inherent sampling
    # outcome; the raw count (incl. empty) stays in the marker for provenance and the
    # trace/marker cross-check above still holds for it.
    empty_answer_count = int(measured.get("empty_answer_count", 0))
    structural_malformed = int(marker.get("malformed_completion_count", 0)) - empty_answer_count
    if structural_malformed != 0:
        raise SmokeGateError(
            f"{arm} has {structural_malformed} structurally-malformed completions "
            f"(raw malformed={marker.get('malformed_completion_count')}, "
            f"empty_answer={empty_answer_count})"
        )
    source_config_sha = frozen.get("source_config_sha256")
    if not isinstance(source_config_sha, str):
        raise SmokeGateError("smoke frozen config lacks source_config_sha256")
    return {
        "arm": arm,
        "run_id": runtime.get("run_id"),
        "config_path": str(config_path.resolve()),
        "frozen_config_sha256": frozen_sha,
        "run_manifest_path": str(manifest_path.resolve()),
        "run_manifest_sha256": canonical_json_hash(manifest),
        "completion_path": str(completion_path.resolve()),
        "final_adapter": marker["final_adapter"],
        "realized_sampled_completion_tokens": marker["realized_sampled_completion_tokens"],
        "malformed_completion_count": marker["malformed_completion_count"],
        "method_contract": method_contract(runtime),
        "smoke_compatibility_contract": smoke_compatibility_contract(runtime),
        "projected_main_completion_tokens": projected_main_tokens,
        "common_contract": common_contract(
            runtime,
            manifest,
            source_config_sha256=source_config_sha,
        ),
    }


def certify_smoke_gate(
    config_paths: Sequence[Path],
    output: Path,
) -> dict[str, Any]:
    """Inspect each trainer-family smoke once and write a compatibility gate."""

    expected_count = len(GPU_SMOKE_ARMS)
    if len(config_paths) != expected_count:
        raise SmokeGateError(f"exactly {expected_count} smoke configs are required")
    runs = [_validate_smoke_run(path.resolve()) for path in config_paths]
    by_arm = {str(run["arm"]): run for run in runs}
    if set(by_arm) != set(GPU_SMOKE_ARMS) or len(by_arm) != expected_count:
        raise SmokeGateError("smoke gate requires each GPU trainer family exactly once")
    if (
        len({str(run["frozen_config_sha256"]) for run in runs}) != expected_count
        or len({str(run["run_id"]) for run in runs}) != expected_count
    ):
        raise SmokeGateError("smoke gate requires one unique artifact per controlled arm")
    contracts = {canonical_json_hash(run["common_contract"]) for run in runs}
    if len(contracts) != 1:
        raise SmokeGateError("controlled smoke arms do not share one common contract")
    contract = runs[0]["common_contract"]
    value = {
        "schema_version": 1,
        "kind": "three_trainer_20_step_gpu_smoke_gate",
        "status": "passed",
        "smoke_optimizer_steps_per_arm": SMOKE_STEPS,
        "forced_new_process_resume_step": 5,
        "common_contract": contract,
        "common_contract_sha256": canonical_json_hash(contract),
        "runs": [
            {key: item for key, item in run.items() if key != "common_contract"}
            for run in sorted(runs, key=lambda item: str(item["arm"]))
        ],
    }
    if output.exists():
        existing = _load_object(output, "existing smoke gate")
        if canonical_json(existing) != canonical_json(value):
            raise SmokeGateError(f"refusing to overwrite drifted smoke gate: {output}")
        return existing
    output.parent.mkdir(parents=True, exist_ok=True)
    from ..atomic_io import atomic_write_json

    atomic_write_json(output, value)
    return value


def main_gate_errors(
    runtime: Mapping[str, Any],
    manifest: Mapping[str, Any],
    *,
    source_config_sha256: str,
) -> list[str]:
    """Admit a main run from the once-certified gate summary.

    ``certify_smoke_gate`` performs the expensive evidence inspection once.
    Every main/ablation launch then checks only the small gate artifact and its
    semantic contracts; it deliberately does not walk old checkpoints, model
    adapters, ledgers, or reward traces again.
    """

    if runtime.get("run_mode") != "main":
        return []
    path = Path(str(runtime.get("compatibility_gate_path", "")))
    if not path.is_file():
        return [f"compatibility smoke gate not found: {path}"]
    try:
        gate = _load_object(path, "compatibility smoke gate")
        if (
            gate.get("schema_version") != 1
            or gate.get("kind") != "three_trainer_20_step_gpu_smoke_gate"
            or gate.get("status") != "passed"
        ):
            raise SmokeGateError("compatibility smoke gate is not a passed v1 gate")
        runs = gate.get("runs")
        expected_count = len(GPU_SMOKE_ARMS)
        if not isinstance(runs, list) or len(runs) != expected_count:
            raise SmokeGateError("compatibility smoke gate does not contain every controlled run")
        stored_runs = [run for run in runs if isinstance(run, dict)]
        stored_arms = [str(run.get("arm", "")) for run in stored_runs]
        if (
            len(stored_runs) != expected_count
            or set(stored_arms) != set(GPU_SMOKE_ARMS)
            or len(set(stored_arms)) != expected_count
        ):
            raise SmokeGateError("certified gate does not contain every unique controlled arm")
        certified_contract = gate.get("common_contract")
        if not isinstance(certified_contract, dict):
            raise SmokeGateError("certified gate has no common contract")
        expected_contract = common_contract(
            runtime,
            manifest,
            source_config_sha256=source_config_sha256,
        )
        if canonical_json(expected_contract) != canonical_json(certified_contract):
            raise SmokeGateError("main runtime differs from the certified smoke contract")
        if gate.get("common_contract_sha256") != canonical_json_hash(expected_contract):
            raise SmokeGateError("smoke gate common-contract hash mismatch")
        reference_arm = smoke_reference_arm(str(runtime.get("arm", "")))
        matching_smoke = next(
            (run for run in stored_runs if run.get("arm") == reference_arm),
            None,
        )
        if not isinstance(matching_smoke, dict):
            raise SmokeGateError(f"main arm has no {reference_arm} implementation smoke")
        if runtime.get("arm") == reference_arm:
            if canonical_json(matching_smoke.get("method_contract")) != canonical_json(
                method_contract(runtime)
            ):
                raise SmokeGateError("main arm-specific objective differs from its certified smoke")
        elif canonical_json(matching_smoke.get("smoke_compatibility_contract")) != canonical_json(
            smoke_compatibility_contract(runtime)
        ):
            raise SmokeGateError("ablation implementation differs from its parent smoke")
    except (
        KeyError,
        SmokeGateError,
        OSError,
        TypeError,
        ValueError,
        json.JSONDecodeError,
    ) as exc:
        return [f"compatibility smoke gate validation failed: {exc}"]
    return []