gmnet/code/journal_exp/scripts/generate_e4_alignment_deploy.py

#!/usr/bin/env python3
"""Generate and fail-closed validate the matched E4 ImageNet launch batch."""

from __future__ import annotations

import argparse
import copy
import hashlib
import json
import math
import re
import sys
from dataclasses import asdict, dataclass
from pathlib import Path
from typing import Any

import yaml

SCRIPT_PATH = Path(__file__).resolve()
JOURNAL_ROOT = SCRIPT_PATH.parents[1]
GMNET_ROOT = JOURNAL_ROOT.parent
PROTOCOL_PATH = JOURNAL_ROOT / "configs/e4_alignment_protocol.yaml"
BASE_TEMPLATE = Path("/nfs/ywang29/LongLive/deploy/jul11_vgp/j11_vgp01_base.yaml")
BATCH_ROOT = GMNET_ROOT / "depoly/e4_alignment_20260716"
RUN_ROOT = GMNET_ROOT / "runs/e4_alignment"
CODE_MANIFEST_RELATIVE_PATH = "configs/code_manifests/e4_alignment_20260716.json"
SMOKE_EVIDENCE_PATH = BATCH_ROOT / "smoke_evidence.json"
APPROVAL_ROOT = BATCH_ROOT / "approvals"
BASELINE_CONFIG_PATH = JOURNAL_ROOT / "configs/e0_baseline/imagenet_gmnet_s3.yaml"
GENERATED_HEADER = (
    "# Generated by journal_exp/scripts/generate_e4_alignment_deploy.py; "
    "do not edit.\n"
)
TASK_IDS = (
    "e4a_s3_stop_gradient_seed0",
    "e4a_s3_channel_derangement_seed0",
)
INTERVENTIONS = ("stop_gradient", "channel_derangement")
SHA256_PATTERN = re.compile(r"[0-9a-f]{64}")

RESOURCE_KEYS = (
    "gpu_type",
    "gpu_num",
    "gpu_memory",
    "cpu_num",
    "memory",
    "efa",
    "priority",
    "pytorchjob",
    "custom_node_labels",
    "volcano_queue",
)
PROJECT_KEYS = (
    "project_name",
    "project_support_alias",
    "team",
    "cost_team",
    "cost_feature",
    "cost_sub_feature",
    "docker_image",
    "mount",
)


class ApprovalError(RuntimeError):
    """Raised when the E4 launch guard intentionally denies a task."""


@dataclass(frozen=True)
class E4Task:
    task_id: str
    experiment: str
    model: str
    gate: str
    gate_intervention: str
    gate_intervention_seed: int
    seed: int
    config_path: str
    role: str
    status: str
    contrast: str
    question: str

    @property
    def output_dir(self) -> Path:
        return RUN_ROOT / self.task_id

    @property
    def deploy_path(self) -> Path:
        return BATCH_ROOT / f"{self.task_id}.yaml"

    @property
    def approval_path(self) -> Path:
        return APPROVAL_ROOT / f"{self.task_id}.json"

    @property
    def job_name(self) -> str:
        return "gmnet-" + self.task_id.replace("_", "-")


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


def stable_sha256(value: Any) -> str:
    payload = json.dumps(
        value, sort_keys=True, separators=(",", ":"), ensure_ascii=True
    ).encode("utf-8")
    return hashlib.sha256(payload).hexdigest()


def require_sha256(value: Any, location: str) -> str:
    if not isinstance(value, str) or SHA256_PATTERN.fullmatch(value) is None:
        raise ValueError(f"invalid SHA-256 at {location}: {value!r}")
    return value


def load_yaml(path: Path) -> dict[str, Any]:
    if not path.is_file():
        raise FileNotFoundError(path)
    loaded = yaml.safe_load(path.read_text(encoding="utf-8"))
    if not isinstance(loaded, dict):
        raise ValueError(f"expected a YAML mapping: {path}")
    return loaded


def load_json(path: Path) -> dict[str, Any]:
    if not path.is_file():
        raise FileNotFoundError(path)
    loaded = json.loads(path.read_text(encoding="utf-8"))
    if not isinstance(loaded, dict):
        raise ValueError(f"expected a JSON object: {path}")
    return loaded


def load_protocol() -> dict[str, Any]:
    return load_yaml(PROTOCOL_PATH)


def load_resolved_config(path: Path) -> dict[str, Any]:
    if str(JOURNAL_ROOT) not in sys.path:
        sys.path.insert(0, str(JOURNAL_ROOT))
    from gmnet.config import load_config

    return load_config(path)


def require_value(config: dict[str, Any], dotted_key: str, expected: Any) -> None:
    value: Any = config
    for part in dotted_key.split("."):
        if not isinstance(value, dict) or part not in value:
            raise ValueError(f"missing config value {dotted_key}")
        value = value[part]
    if value != expected:
        raise ValueError(
            f"config mismatch for {dotted_key}: {value!r}, expected {expected!r}"
        )


def _assert_exact_config_delta(task: E4Task, config: dict[str, Any]) -> None:
    baseline = load_resolved_config(BASELINE_CONFIG_PATH)
    expected = copy.deepcopy(baseline)
    expected["experiment_id"] = (
        "E4-ImageNet-S3-stop-gradient"
        if task.gate_intervention == "stop_gradient"
        else "E4-ImageNet-S3-channel-derangement"
    )
    expected["protocol_id"] = "e4-imagenet-matched-alignment-v1"
    expected["model"]["gate_intervention"] = task.gate_intervention
    expected["model"]["gate_intervention_seed"] = task.gate_intervention_seed
    if config != expected:
        raise ValueError(
            f"{task.task_id} must differ from the paper S3 baseline only in "
            "experiment/protocol identity and the registered gate intervention"
        )

    source = load_yaml(JOURNAL_ROOT / task.config_path)
    expected_source_keys = {"base", "experiment_id", "protocol_id", "model"}
    if set(source) != expected_source_keys:
        raise ValueError(f"unexpected source config keys for {task.task_id}")
    if source["base"] != "../e0_baseline/imagenet_gmnet_s3.yaml":
        raise ValueError(f"{task.task_id} must inherit the paper S3 baseline")
    if source["model"] != {
        "gate_intervention": task.gate_intervention,
        "gate_intervention_seed": task.gate_intervention_seed,
    }:
        raise ValueError(f"unexpected model overrides for {task.task_id}")


def validate_task_config(
    protocol: dict[str, Any], task: E4Task, config: dict[str, Any]
) -> None:
    invariants = {
        "recipe_id": "paper-supplementary-table8-v1",
        "protocol_id": "e4-imagenet-matched-alignment-v1",
        "model.variant": "s3",
        "model.num_classes": 1000,
        "model.gate_type": "relu6_self",
        "model.gate_intervention": task.gate_intervention,
        "model.gate_intervention_seed": task.gate_intervention_seed,
        "model.drop_path_rate": 0.02,
        "model.f12_bn": False,
        "model.projection_bn": True,
        "model.second_dw_bn": False,
        "data.dataset": "imagenet",
        "data.num_classes": 1000,
        "data.expected_train_samples": protocol["data"]["expected_train_samples"],
        "data.expected_val_samples": protocol["data"]["expected_val_samples"],
        "data.expected_manifest_sha256": protocol["data"]["canonical_manifest_sha256"],
        "train.epochs": 300,
        "train.eval_interval": 300,
        "train.fail_on_nonfinite": True,
        "train.strict_resume": True,
        "train.official_validation_policy": "final_epoch_only",
        "train.save_best_checkpoint": False,
    }
    for key, expected in invariants.items():
        require_value(config, key, expected)
    patterns = config.get("optimizer", {}).get("no_weight_decay_patterns")
    if not isinstance(patterns, list) or "raw_clip" not in patterns:
        raise ValueError(f"{task.task_id} must retain paper optimizer exclusions")
    _assert_exact_config_delta(task, config)


def build_tasks(protocol: dict[str, Any] | None = None) -> list[E4Task]:
    protocol = load_protocol() if protocol is None else protocol
    records = protocol.get("tasks")
    if not isinstance(records, list):
        raise ValueError("E4 alignment protocol tasks must be a list")
    tasks: list[E4Task] = []
    for record in records:
        if not isinstance(record, dict):
            raise ValueError("each E4 task must be a mapping")
        tasks.append(
            E4Task(
                task_id=str(record["task_id"]),
                experiment=str(record["experiment"]),
                model=str(record["model"]),
                gate=str(record["gate"]),
                gate_intervention=str(record["gate_intervention"]),
                gate_intervention_seed=int(record["gate_intervention_seed"]),
                seed=int(record["seed"]),
                config_path=str(record["config_path"]),
                role=str(record["role"]),
                status=str(record["status"]),
                contrast=str(record["contrast"]),
                question=str(record["question"]),
            )
        )
    validate_protocol(protocol, tasks)
    return tasks


def validate_protocol(protocol: dict[str, Any], tasks: list[E4Task]) -> None:
    if protocol.get("schema_version") != 1:
        raise ValueError("E4 alignment protocol schema_version must be 1")
    if protocol.get("protocol_id") != "imagenet-e4-alignment-single-seed-20260716":
        raise ValueError("unexpected E4 alignment protocol_id")
    if Path(str(protocol.get("run_root"))) != RUN_ROOT:
        raise ValueError(f"E4 run_root must be {RUN_ROOT}")
    if Path(str(protocol.get("deploy_root"))) != BATCH_ROOT:
        raise ValueError(f"E4 deploy_root must be {BATCH_ROOT}")
    if protocol.get("code_manifest_path") != CODE_MANIFEST_RELATIVE_PATH:
        raise ValueError("unexpected E4 code manifest path")
    if Path(str(protocol.get("smoke_evidence_path"))) != SMOKE_EVIDENCE_PATH:
        raise ValueError("unexpected E4 smoke evidence path")
    if tuple(task.task_id for task in tasks) != TASK_IDS:
        raise ValueError("E4 task matrix or ordering drifted")
    if tuple(task.gate_intervention for task in tasks) != INTERVENTIONS:
        raise ValueError("E4 intervention matrix or ordering drifted")
    if len({task.task_id for task in tasks}) != len(tasks):
        raise ValueError("duplicate E4 task IDs")

    data = protocol.get("data", {})
    data_expected = {
        "runtime_root": "/tmp/gmnet_data/imagenet-1k",
        "source_archive_uri": (
            "s3://snap-research-cv-code/ywang29/datasets/imagenet-1k/" "imagenet-1k.tar"
        ),
        "expected_archive_bytes": 161381969920,
        "canonical_manifest_sha256": (
            "bb70bc9f530db6bb24f70e648624b35281bfbc76a57775d589a2e0209dd98661"
        ),
        "expected_train_samples": 1281167,
        "expected_val_samples": 50000,
    }
    for key, expected in data_expected.items():
        if data.get(key) != expected:
            raise ValueError(f"E4 data registration drifted: {key}")
    for key in (
        "train_sample_index_sha256",
        "val_sample_index_sha256",
        "train_sampled_content_sha256",
        "val_sampled_content_sha256",
    ):
        require_sha256(data.get(key), f"protocol.data.{key}")

    policy = protocol.get("policy", {})
    policy_expected = {
        "seed": 0,
        "seed_replication_in_scope": False,
        "model_variant": "s3",
        "baseline_recipe": "paper-supplementary-table8-v1",
        "baseline_top1": 78.746,
        "intervention_seed": 41041,
        "block_seed_stride": 10007,
        "gpus_per_job": 8,
        "epochs": 300,
        "eta_class": "greater_than_12h",
        "checkpoint_policy": "fixed_last",
        "resume": "auto",
        "post_eval": "strict_official",
        "approval_marker_required_for_every_task": True,
        "approval_requires_8gpu_strict_resume_smoke": True,
        "output_lock": "nonblocking_flock",
        "launchjob_submitted_by_generator": False,
    }
    for key, expected in policy_expected.items():
        if policy.get(key) != expected:
            raise ValueError(f"E4 policy drifted: {key}")

    if protocol.get("relationship_to_prior_work", "").startswith("Post-hoc") is False:
        raise ValueError("E4 relationship to prior work must remain post-hoc")
    if not protocol.get("known_before_registration"):
        raise ValueError("E4 known-results registration is missing")
    restrictions = protocol.get("claim_restrictions")
    if not isinstance(restrictions, list) or len(restrictions) < 4:
        raise ValueError("E4 claim restrictions are incomplete")

    for task in tasks:
        exact = {
            "experiment": "E4",
            "model": "s3",
            "gate": "relu6_self",
            "gate_intervention_seed": 41041,
            "seed": 0,
            "role": "matched_alignment_retraining",
            "status": "ready_after_smoke",
        }
        for field, expected in exact.items():
            if getattr(task, field) != expected:
                raise ValueError(f"E4 task drifted: {task.task_id}/{field}")
        if not task.contrast or not task.question:
            raise ValueError(f"E4 task rationale is incomplete: {task.task_id}")
        config_path = JOURNAL_ROOT / task.config_path
        validate_task_config(protocol, task, load_resolved_config(config_path))


def normalized_training_semantics(config: dict[str, Any]) -> dict[str, Any]:
    normalized = copy.deepcopy(config)
    normalized.pop("runtime", None)
    normalized.pop("experiment_id", None)
    protocol = normalized.get("protocol")
    if isinstance(protocol, dict):
        protocol.pop("code_sha256", None)
        if not protocol:
            normalized.pop("protocol")
    return normalized


def read_code_manifest() -> dict[str, Any]:
    manifest = load_json(JOURNAL_ROOT / CODE_MANIFEST_RELATIVE_PATH)
    if manifest.get("schema_version") != 1:
        raise ValueError("E4 code manifest schema_version must be 1")
    require_sha256(manifest.get("code_sha256"), "code_manifest.code_sha256")
    files = manifest.get("files")
    if not isinstance(files, list) or not files:
        raise ValueError("E4 code manifest files are missing")
    paths = {item.get("path") for item in files if isinstance(item, dict)}
    required_paths = {
        "configs/e4_alignment_protocol.yaml",
        "configs/e4_alignment/imagenet_gmnet_s3_stop_gradient.yaml",
        "configs/e4_alignment/imagenet_gmnet_s3_channel_derangement.yaml",
        "configs/smoke/imagenet5_gmnet_s1_e4_stop_gradient.yaml",
        "configs/smoke/imagenet5_gmnet_s1_e4_channel_derangement.yaml",
        "scripts/audit_e4_alignment_smoke.py",
        "scripts/generate_e4_alignment_deploy.py",
        "scripts/run_e4_alignment.sh",
    }
    missing = sorted(required_paths - paths)
    if missing:
        raise ValueError(f"E4 code manifest scope is incomplete: {missing}")
    return manifest


def verify_code_manifest() -> tuple[str, str]:
    if str(JOURNAL_ROOT) not in sys.path:
        sys.path.insert(0, str(JOURNAL_ROOT))
    from scripts.code_fingerprint import build_manifest

    path = JOURNAL_ROOT / CODE_MANIFEST_RELATIVE_PATH
    expected = read_code_manifest()
    actual = build_manifest(JOURNAL_ROOT)
    if actual != expected:
        raise ValueError(
            "E4 code manifest mismatch: "
            f"expected {expected.get('code_sha256')}, "
            f"computed {actual.get('code_sha256')}"
        )
    return str(expected["code_sha256"]), file_sha256(path)


def verify_historical_baseline(protocol: dict[str, Any]) -> None:
    record = protocol.get("historical_baseline")
    if not isinstance(record, dict):
        raise ValueError("historical baseline registration is missing")
    required_registration = {
        "evidence_id": "legacy_relu6_s3_seed0",
        "acceptance": "accepted_historical_seed0_alias",
        "code_provenance": "retrospective_unverified",
        "run_dir": "/nfs/ywang29/GmNet/runs/e0_s3_seed0",
        "target_config": "configs/e0_baseline/imagenet_gmnet_s3.yaml",
    }
    for key, expected in required_registration.items():
        if record.get(key) != expected:
            raise ValueError(f"historical baseline registration drifted: {key}")
    require_sha256(
        record.get("semantic_projection_sha256"),
        "historical_baseline.semantic_projection_sha256",
    )

    run_dir = Path(record["run_dir"])
    expected_files = record.get("expected")
    if not isinstance(expected_files, dict) or not expected_files:
        raise ValueError("historical baseline hashes are missing")
    for relative, expected_sha in expected_files.items():
        require_sha256(expected_sha, f"historical_baseline.expected.{relative}")
        path = run_dir / relative
        if not path.is_file():
            raise FileNotFoundError(f"missing historical baseline artifact: {path}")
        actual_sha = file_sha256(path)
        if actual_sha != expected_sha:
            raise ValueError(
                f"historical baseline hash mismatch for {relative}: {actual_sha}"
            )

    official = record.get("official", {})
    checks = load_json(run_dir / "official_eval/checks.json")
    results = load_json(run_dir / "official_eval/results.json")
    manifest = load_json(run_dir / "data_manifest.json")
    if checks.get("status") != "passed":
        raise ValueError("historical baseline official checks did not pass")
    if checks.get("checkpoint_sha256") != expected_files["checkpoint_last.pt"]:
        raise ValueError("historical baseline checkpoint identity drifted")
    if checks.get("artifacts_sha256") != official.get("artifacts_sha256"):
        raise ValueError("historical baseline artifact identity drifted")
    if results.get("status") != "complete" or results.get("partial_evaluation"):
        raise ValueError("historical baseline evaluation is incomplete")
    scalar_expected = {
        "run_name": "e0_s3_seed0",
        "seed": 0,
        "gate_type": "relu6_self",
        "checkpoint_epoch": 299,
        "training_epochs": 300,
    }
    for key, expected in scalar_expected.items():
        if results.get(key) != expected:
            raise ValueError(f"historical baseline result drifted: {key}")
    if not math.isclose(
        float(results.get("metrics", {}).get("top1", float("nan"))),
        float(official.get("top1", float("nan"))),
        rel_tol=0.0,
        abs_tol=1e-9,
    ):
        raise ValueError("historical baseline Top-1 drifted")
    if results.get("metrics", {}).get("samples") != 50000:
        raise ValueError("historical baseline evaluated sample count drifted")

    hashes = results.get("hashes", {})
    if hashes.get("config_sha256") != official.get("checkpoint_config_sha256"):
        raise ValueError("historical baseline checkpoint config identity drifted")
    if (
        hashes.get("checkpoint_data_manifest_sha256")
        != protocol["data"]["canonical_manifest_sha256"]
    ):
        raise ValueError("historical baseline checkpoint data identity drifted")
    topology = results.get("topology", {})
    for key in ("parameter_count", "state_tensor_count", "model_state_schema_sha256"):
        if topology.get(key) != official.get(key):
            raise ValueError(f"historical baseline topology drifted: {key}")
    completion_expected = {
        "epoch_complete": True,
        "expected_global_step": 187500,
        "expected_steps_per_epoch": 625,
        "global_step": 187500,
        "steps_in_epoch": 625,
        "training_complete": True,
        "world_size": 8,
    }
    completion = results.get("training_completion", {})
    for key, expected in completion_expected.items():
        if completion.get(key) != expected:
            raise ValueError(f"historical training completion drifted: {key}")

    data = protocol["data"]
    data_expected = {
        "manifest_sha256": data["canonical_manifest_sha256"],
        "num_classes": 1000,
        "samples": {
            "train": data["expected_train_samples"],
            "val": data["expected_val_samples"],
        },
        "sample_index_sha256": {
            "train": data["train_sample_index_sha256"],
            "val": data["val_sample_index_sha256"],
        },
        "sampled_content_sha256": {
            "train": data["train_sampled_content_sha256"],
            "val": data["val_sampled_content_sha256"],
        },
    }
    for key, expected in data_expected.items():
        if manifest.get(key) != expected:
            raise ValueError(f"historical data manifest drifted: {key}")

    resolved = load_yaml(run_dir / "config_resolved.yaml")
    target = load_resolved_config(JOURNAL_ROOT / record["target_config"])
    legacy_semantics = normalized_training_semantics(resolved)
    target_semantics = normalized_training_semantics(target)
    if legacy_semantics != target_semantics:
        raise ValueError("historical/current baseline config semantics differ")
    if stable_sha256(legacy_semantics) != record["semantic_projection_sha256"]:
        raise ValueError("historical baseline semantic projection drifted")


def verify_smoke_evidence(
    protocol: dict[str, Any],
    tasks: list[E4Task],
    code_sha256: str,
    manifest_sha256: str,
) -> tuple[dict[str, Any], str]:
    evidence = load_json(SMOKE_EVIDENCE_PATH)
    required = {
        "schema_version": 1,
        "protocol_id": protocol["protocol_id"],
        "status": "passed",
        "code_sha256": code_sha256,
        "code_manifest_path": CODE_MANIFEST_RELATIVE_PATH,
        "code_manifest_sha256": manifest_sha256,
        "world_size": 8,
        "strict_resume": True,
    }
    for key, expected in required.items():
        if evidence.get(key) != expected:
            raise ApprovalError(f"E4 smoke evidence field drifted: {key}")
    smoke_tasks = evidence.get("tasks")
    if not isinstance(smoke_tasks, dict) or set(smoke_tasks) != set(TASK_IDS):
        raise ApprovalError("E4 smoke evidence task matrix or ordering drifted")
    for task in tasks:
        record = smoke_tasks.get(task.task_id)
        if not isinstance(record, dict):
            raise ApprovalError(f"missing E4 smoke task: {task.task_id}")
        task_required = {
            "gate_intervention": task.gate_intervention,
            "gate_intervention_seed": task.gate_intervention_seed,
            "resume_verified": True,
            "training_complete": True,
        }
        for key, expected in task_required.items():
            if record.get(key) != expected:
                raise ApprovalError(f"E4 smoke evidence drifted: {task.task_id}/{key}")
        first = require_sha256(
            record.get("checkpoint_epoch0_sha256"),
            f"smoke.tasks.{task.task_id}.checkpoint_epoch0_sha256",
        )
        final = require_sha256(
            record.get("checkpoint_last_sha256"),
            f"smoke.tasks.{task.task_id}.checkpoint_last_sha256",
        )
        if first == final:
            raise ApprovalError(
                f"E4 smoke resume did not advance checkpoint: {task.task_id}"
            )
    return evidence, file_sha256(SMOKE_EVIDENCE_PATH)


def load_base_invariants() -> dict[str, Any]:
    source = load_yaml(BASE_TEMPLATE)
    required = (*RESOURCE_KEYS, *PROJECT_KEYS)
    missing = [key for key in required if key not in source]
    if missing:
        raise ValueError(f"base launch template missing: {', '.join(missing)}")
    if source.get("gpu_num") != "8" or source.get("gpu_type") != "nvidia-tesla-a100":
        raise ValueError("base launch template must request eight A100 GPUs")
    mounts = source.get("mount")
    if not isinstance(mounts, list):
        raise ValueError("base launch template mounts are invalid")
    mount_paths = {item.get("mount_path") for item in mounts if isinstance(item, dict)}
    if "/nfs" not in mount_paths or "/s3-code" not in mount_paths:
        raise ValueError("base launch template is missing required NFS/S3 mounts")
    return {key: copy.deepcopy(source[key]) for key in required}


def _deny_completed_output(task: E4Task) -> None:
    checks_path = task.output_dir / "official_eval/checks.json"
    if not checks_path.is_file():
        return
    try:
        checks = load_json(checks_path)
    except (json.JSONDecodeError, ValueError):
        return
    if checks.get("status") == "passed":
        raise ApprovalError(
            f"E4 guard denied {task.task_id}: output already passed official evaluation"
        )


def approval_payload(
    protocol: dict[str, Any],
    task: E4Task,
    code_sha256: str,
    manifest_sha256: str,
    smoke: dict[str, Any],
    smoke_sha256: str,
) -> dict[str, Any]:
    smoke_task = smoke["tasks"][task.task_id]
    return {
        "schema_version": 1,
        "protocol_id": protocol["protocol_id"],
        "task_id": task.task_id,
        "status": "approved",
        "approval_basis": "passed_8gpu_strict_resume_smoke",
        "config_path": task.config_path,
        "output_dir": str(task.output_dir),
        "gate_intervention": task.gate_intervention,
        "gate_intervention_seed": task.gate_intervention_seed,
        "code_sha256": code_sha256,
        "code_manifest_path": CODE_MANIFEST_RELATIVE_PATH,
        "code_manifest_sha256": manifest_sha256,
        "smoke_evidence_path": str(SMOKE_EVIDENCE_PATH),
        "smoke_evidence_sha256": smoke_sha256,
        "smoke_checkpoint_last_sha256": smoke_task["checkpoint_last_sha256"],
    }


def verify_approval(
    protocol: dict[str, Any],
    task: E4Task,
    code_sha256: str,
    manifest_sha256: str,
    smoke: dict[str, Any],
    smoke_sha256: str,
) -> None:
    if not task.approval_path.is_file():
        raise ApprovalError(
            f"E4 guard denied {task.task_id}: missing {task.approval_path}"
        )
    marker = load_json(task.approval_path)
    expected = approval_payload(
        protocol,
        task,
        code_sha256,
        manifest_sha256,
        smoke,
        smoke_sha256,
    )
    if marker != expected:
        drifted = sorted(
            key
            for key in set(marker) | set(expected)
            if marker.get(key) != expected.get(key)
        )
        raise ApprovalError(
            f"E4 guard denied {task.task_id}: approval drifted ({','.join(drifted)})"
        )


def verify_task(task_id: str, require_approval: bool) -> None:
    protocol = load_protocol()
    tasks = build_tasks(protocol)
    task = next((item for item in tasks if item.task_id == task_id), None)
    if task is None:
        raise ValueError(f"unknown E4 alignment task: {task_id}")
    code_sha256, manifest_sha256 = verify_code_manifest()
    verify_historical_baseline(protocol)
    smoke, smoke_sha256 = verify_smoke_evidence(
        protocol, tasks, code_sha256, manifest_sha256
    )
    _deny_completed_output(task)
    if require_approval:
        verify_approval(
            protocol,
            task,
            code_sha256,
            manifest_sha256,
            smoke,
            smoke_sha256,
        )
    print(
        f"Verified E4 alignment task {task.task_id}: code={code_sha256}, "
        f"smoke={smoke_sha256}, baseline={protocol['historical_baseline']['evidence_id']}"
    )


def build_launch_document(
    protocol: dict[str, Any], task: E4Task, invariants: dict[str, Any]
) -> dict[str, Any]:
    verify = (
        "/tmp/gmnet_venv/bin/python "
        "scripts/generate_e4_alignment_deploy.py "
        f"--verify-task {task.task_id} --require-approval"
    )
    pre_run = (
        f"cd {JOURNAL_ROOT} && chmod +x ./scripts/*.sh && "
        "INSTALL_DEV=0 bash ./scripts/setup_env.sh && "
        f"{verify} && "
        "KEEP_ARCHIVE=0 bash ./scripts/stage_imagenet.sh full && "
        f"{verify}"
    )
    assignments = " ".join(
        (
            f"RUN_NAME={task.task_id}",
            f"CONFIG_PATH={task.config_path}",
            f"DATA_ROOT={protocol['data']['runtime_root']}",
            f"OUTPUT_DIR={task.output_dir}",
            f"SEED={task.seed}",
            "NPROC_PER_NODE=8",
            "RESUME=auto",
            "POST_EVAL=1",
            f"CODE_MANIFEST_PATH={CODE_MANIFEST_RELATIVE_PATH}",
        )
    )
    command = (
        f"cd {JOURNAL_ROOT} && {verify} && {assignments} "
        "bash scripts/run_e4_alignment.sh"
    )
    document: dict[str, Any] = {
        key: copy.deepcopy(invariants[key]) for key in RESOURCE_KEYS
    }
    document["script"] = {
        "pre_run_event": pre_run,
        "command": command,
        "jobs": [{"name": task.job_name}],
    }
    document.update({key: copy.deepcopy(invariants[key]) for key in PROJECT_KEYS})
    return document


def dump_yaml(value: Any) -> str:
    return GENERATED_HEADER + yaml.safe_dump(
        value,
        sort_keys=False,
        default_flow_style=False,
        width=1_000_000,
    )


def build_batch_manifest(
    protocol: dict[str, Any],
    tasks: list[E4Task],
    code_sha256: str,
    manifest_sha256: str,
    smoke_sha256: str,
) -> dict[str, Any]:
    records = []
    for task in tasks:
        record = asdict(task)
        record.update(
            {
                "deploy_path": str(task.deploy_path),
                "approval_path": str(task.approval_path),
                "output_dir": str(task.output_dir),
                "job_name": task.job_name,
                "eta_class": ">12h",
            }
        )
        records.append(record)
    return {
        "schema_version": 1,
        "protocol_id": protocol["protocol_id"],
        "protocol_source": str(PROTOCOL_PATH),
        "protocol_sha256": file_sha256(PROTOCOL_PATH),
        "generated_by": str(SCRIPT_PATH),
        "source_template": str(BASE_TEMPLATE),
        "source_template_sha256": file_sha256(BASE_TEMPLATE),
        "code_manifest_path": CODE_MANIFEST_RELATIVE_PATH,
        "code_manifest_sha256": manifest_sha256,
        "code_sha256": code_sha256,
        "smoke_evidence_path": str(SMOKE_EVIDENCE_PATH),
        "smoke_evidence_sha256": smoke_sha256,
        "historical_baseline": copy.deepcopy(protocol["historical_baseline"]),
        "relationship_to_prior_work": protocol["relationship_to_prior_work"],
        "known_before_registration": copy.deepcopy(
            protocol["known_before_registration"]
        ),
        "claim_restrictions": copy.deepcopy(protocol["claim_restrictions"]),
        "policy": copy.deepcopy(protocol["policy"]),
        "data": copy.deepcopy(protocol["data"]),
        "run_root": str(RUN_ROOT),
        "summary": {
            "task_count": len(tasks),
            "approved_count": len(tasks),
            "seed_count": 1,
        },
        "tasks": records,
    }


def expected_files() -> dict[Path, str]:
    protocol = load_protocol()
    tasks = build_tasks(protocol)
    code_sha256, manifest_sha256 = verify_code_manifest()
    verify_historical_baseline(protocol)
    smoke, smoke_sha256 = verify_smoke_evidence(
        protocol, tasks, code_sha256, manifest_sha256
    )
    invariants = load_base_invariants()
    files = {
        task.deploy_path: dump_yaml(build_launch_document(protocol, task, invariants))
        for task in tasks
    }
    files[BATCH_ROOT / "batch_manifest.json"] = (
        json.dumps(
            build_batch_manifest(
                protocol, tasks, code_sha256, manifest_sha256, smoke_sha256
            ),
            indent=2,
            sort_keys=True,
        )
        + "\n"
    )
    for task in tasks:
        files[task.approval_path] = (
            json.dumps(
                approval_payload(
                    protocol,
                    task,
                    code_sha256,
                    manifest_sha256,
                    smoke,
                    smoke_sha256,
                ),
                indent=2,
                sort_keys=True,
            )
            + "\n"
        )
    return files


def write_files(files: dict[Path, str]) -> None:
    for path, content in files.items():
        path.parent.mkdir(parents=True, exist_ok=True)
        if path.is_file() and path.read_text(encoding="utf-8") == content:
            continue
        temporary = path.with_name(f".{path.name}.tmp")
        temporary.write_text(content, encoding="utf-8")
        temporary.replace(path)
    expected = set(files)
    for path in BATCH_ROOT.glob("*.yaml"):
        if path in expected:
            continue
        if path.read_text(encoding="utf-8").startswith(GENERATED_HEADER):
            path.unlink()


def check_files(files: dict[Path, str]) -> list[str]:
    errors = []
    for path, expected in files.items():
        if not path.is_file():
            errors.append(f"missing: {path}")
        elif path.read_text(encoding="utf-8") != expected:
            errors.append(f"stale: {path}")
    for path in BATCH_ROOT.glob("*.yaml"):
        if path in files:
            continue
        if path.read_text(encoding="utf-8").startswith(GENERATED_HEADER):
            errors.append(f"stale generated file: {path}")
    return errors


def parse_args() -> argparse.Namespace:
    parser = argparse.ArgumentParser(description=__doc__)
    action = parser.add_mutually_exclusive_group()
    action.add_argument("--check", action="store_true")
    action.add_argument("--verify-task")
    parser.add_argument("--require-approval", action="store_true")
    return parser.parse_args()


def main() -> int:
    args = parse_args()
    try:
        if args.verify_task:
            verify_task(args.verify_task, args.require_approval)
            return 0
        files = expected_files()
        tasks = build_tasks()
        if args.check:
            errors = check_files(files)
            if errors:
                print("\n".join(errors), file=sys.stderr)
                return 1
            print(
                f"Validated {len(tasks)} E4 launch YAMLs, batch manifest, "
                "approvals, code, smoke, and historical baseline"
            )
            return 0
        write_files(files)
        print(
            f"Generated {len(tasks)} E4 launch YAMLs under {BATCH_ROOT}; "
            "no launchjob was submitted"
        )
        return 0
    except ApprovalError as error:
        print(str(error), file=sys.stderr)
        return 64


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