gmnet/code/journal_exp/scripts/generate_single_seed_followup.py

#!/usr/bin/env python3
"""Generate and fail-closed validate the single-seed ImageNet follow-up batch."""

from __future__ import annotations

import argparse
import copy
import hashlib
import json
import math
import sys
from dataclasses import asdict, dataclass
from datetime import datetime, timezone
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/single_seed_followup_protocol.yaml"
BASE_TEMPLATE = Path("/nfs/ywang29/LongLive/deploy/jul11_vgp/j11_vgp01_base.yaml")
BATCH_ROOT = GMNET_ROOT / "depoly/single_seed_followup_20260715"
RUN_ROOT = GMNET_ROOT / "runs/single_seed_followup"
CODE_MANIFEST_RELATIVE_PATH = "configs/imagenet_v2_code_manifest.json"
GENERATED_HEADER = (
    "# Generated by journal_exp/scripts/generate_single_seed_followup.py; "
    "do not edit.\n"
)
APPROVAL_ROOT = BATCH_ROOT / "approvals"
TASK_IDS = (
    "ssfu_e3_s3_no_gate_seed0",
    "ssfu_e3_s3_relu6_only_seed0",
    "ssfu_e3_s3_smooth_fixed_c6_seed0",
    "ssfu_e0_s3_release_paperbn_seed0",
)
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 a launch is intentionally denied by the batch protocol."""


@dataclass(frozen=True)
class FollowupTask:
    task_id: str
    experiment: str
    model: str
    gate: str
    seed: int
    config_path: str
    role: str
    status: str
    submission_allowed: bool
    evidence: tuple[str, ...]
    contrast: str
    question: str
    trigger: dict[str, Any] | None = None

    @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 load_yaml(path: Path) -> dict[str, Any]:
    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_protocol() -> dict[str, Any]:
    return load_yaml(PROTOCOL_PATH)


def build_tasks(protocol: dict[str, Any] | None = None) -> list[FollowupTask]:
    protocol = load_protocol() if protocol is None else protocol
    records = protocol.get("tasks")
    if not isinstance(records, list):
        raise ValueError("follow-up protocol tasks must be a list")
    tasks = [
        FollowupTask(
            task_id=str(record["task_id"]),
            experiment=str(record["experiment"]),
            model=str(record["model"]),
            gate=str(record["gate"]),
            seed=int(record["seed"]),
            config_path=str(record["config_path"]),
            role=str(record["role"]),
            status=str(record["status"]),
            submission_allowed=bool(record["submission_allowed"]),
            evidence=tuple(record.get("evidence", [])),
            contrast=str(record["contrast"]),
            question=str(record["question"]),
            trigger=copy.deepcopy(record.get("trigger")),
        )
        for record in records
    ]
    validate_protocol(protocol, tasks)
    return tasks


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 validate_task_config(
    protocol: dict[str, Any], task: FollowupTask, config: dict[str, Any]
) -> None:
    release_audit = task.role == "conditional_recipe_audit"
    expected_gate = (
        "smooth_clipped_self"
        if task.gate == "smooth_clipped_self_fixed_c6"
        else task.gate
    )
    common = {
        "model.variant": task.model,
        "model.gate_type": expected_gate,
        "model.num_classes": 1000,
        "model.f12_bn": False,
        "model.projection_bn": True,
        "model.second_dw_bn": False,
        "data.dataset": "imagenet",
        "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.fail_on_nonfinite": True,
        "train.strict_resume": True,
        "train.official_validation_policy": "final_epoch_only",
        "train.save_best_checkpoint": False,
    }
    for key, expected in common.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 exclude raw_clip from weight decay")

    if release_audit:
        require_value(config, "recipe_id", "release-readme-legacy-audit-only")
        require_value(config, "model.drop_path_rate", 0.0)
        require_value(config, "train.epochs", 310)
        require_value(config, "train.eval_interval", 310)
    else:
        require_value(config, "recipe_id", "paper-supplementary-table8-v1")
        require_value(config, "model.drop_path_rate", 0.02)
        require_value(config, "train.epochs", 300)
        require_value(config, "train.eval_interval", 300)

    if task.gate == "smooth_clipped_self_fixed_c6":
        require_value(config, "model.smooth_clip_init", 6.0)
        require_value(config, "model.smooth_clip_beta", 10.0)
        require_value(config, "model.smooth_clip_per_channel", False)
        require_value(config, "model.smooth_clip_trainable", False)


def validate_protocol(protocol: dict[str, Any], tasks: list[FollowupTask]) -> None:
    if protocol.get("schema_version") != 1:
        raise ValueError("follow-up protocol schema_version must be 1")
    if protocol.get("protocol_id") != "imagenet-single-seed-followup-20260715":
        raise ValueError("unexpected follow-up protocol_id")
    if Path(str(protocol.get("run_root"))) != RUN_ROOT:
        raise ValueError(f"follow-up run_root must be {RUN_ROOT}")
    if Path(str(protocol.get("deploy_root"))) != BATCH_ROOT:
        raise ValueError(f"follow-up deploy_root must be {BATCH_ROOT}")
    if protocol.get("code_manifest_path") != CODE_MANIFEST_RELATIVE_PATH:
        raise ValueError("unexpected follow-up code manifest path")
    if tuple(task.task_id for task in tasks) != TASK_IDS:
        raise ValueError("follow-up task matrix or ordering drifted")
    if len(set(TASK_IDS)) != len(TASK_IDS):
        raise ValueError("duplicate follow-up task IDs")

    parent = protocol["parent_protocol"]
    parent_path = JOURNAL_ROOT / str(parent["path"])
    if file_sha256(parent_path) != parent["sha256"]:
        raise ValueError("parent ImageNet-v2 protocol hash drifted")
    resume = protocol["historical_resume_manifest"]
    if file_sha256(Path(str(resume["path"]))) != resume["sha256"]:
        raise ValueError("historical resume manifest hash drifted")

    evidence_ids = set(protocol.get("legacy_evidence", {}))
    ready = []
    for task in tasks:
        if task.seed != 0:
            raise ValueError(f"non-seed0 task is outside this batch: {task.task_id}")
        if task.status not in {"ready", "conditional"}:
            raise ValueError(f"invalid task status: {task.task_id}")
        if task.submission_allowed != (task.status == "ready"):
            raise ValueError(f"task status/permission mismatch: {task.task_id}")
        if not task.evidence or not set(task.evidence).issubset(evidence_ids):
            raise ValueError(f"missing or unknown evidence for {task.task_id}")
        if task.status == "conditional" and task.trigger is None:
            raise ValueError(f"conditional task lacks trigger: {task.task_id}")
        if task.status == "ready":
            ready.append(task.task_id)
        config_path = JOURNAL_ROOT / task.config_path
        if not config_path.is_file():
            raise FileNotFoundError(config_path)
        validate_task_config(protocol, task, load_resolved_config(config_path))
    if ready != list(TASK_IDS[:3]):
        raise ValueError("only the three mechanism tasks may be initially ready")


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 _assert_finite(value: Any, location: str) -> None:
    if isinstance(value, float) and not math.isfinite(value):
        raise ValueError(f"non-finite value at {location}")
    if isinstance(value, dict):
        for key, child in value.items():
            _assert_finite(child, f"{location}.{key}")
    elif isinstance(value, list):
        for index, child in enumerate(value):
            _assert_finite(child, f"{location}[{index}]")


def verify_evidence(protocol: dict[str, Any], evidence_id: str) -> None:
    record = protocol["legacy_evidence"][evidence_id]
    if record.get("acceptance") != "accepted_historical_seed0_alias":
        raise ValueError(f"invalid evidence acceptance: {evidence_id}")
    if record.get("code_provenance") != "retrospective_unverified":
        raise ValueError(f"legacy provenance must remain unverified: {evidence_id}")
    run_dir = Path(str(record["run_dir"]))
    for relative, expected_sha in record["expected"].items():
        path = run_dir / relative
        if not path.is_file():
            raise FileNotFoundError(f"missing evidence file: {path}")
        actual_sha = file_sha256(path)
        if actual_sha != expected_sha:
            raise ValueError(
                f"evidence hash mismatch for {evidence_id}/{relative}: {actual_sha}"
            )

    expected = record["expected"]
    official = record["official"]
    checks = json.loads(
        (run_dir / "official_eval/checks.json").read_text(encoding="utf-8")
    )
    results = json.loads(
        (run_dir / "official_eval/results.json").read_text(encoding="utf-8")
    )
    manifest = json.loads((run_dir / "data_manifest.json").read_text(encoding="utf-8"))
    if checks.get("status") != "passed":
        raise ValueError(f"official check did not pass: {evidence_id}")
    if checks.get("checkpoint_sha256") != expected["checkpoint_last.pt"]:
        raise ValueError(f"official checkpoint identity mismatch: {evidence_id}")
    if checks.get("artifacts_sha256") != official["artifacts_sha256"]:
        raise ValueError(f"official artifact identity mismatch: {evidence_id}")
    if results.get("status") != "complete" or results.get("partial_evaluation"):
        raise ValueError(f"official evaluation is not complete: {evidence_id}")
    if results.get("run_name") != official["run_name"]:
        raise ValueError(f"official run identity mismatch: {evidence_id}")
    if results.get("seed") != 0 or results.get("gate_type") != official["gate_type"]:
        raise ValueError(f"official seed/gate mismatch: {evidence_id}")
    if not math.isclose(
        float(results["metrics"]["top1"]),
        float(official["top1"]),
        rel_tol=0.0,
        abs_tol=1e-9,
    ):
        raise ValueError(f"official Top-1 mismatch: {evidence_id}")
    if results["metrics"].get("samples") != protocol["data"]["expected_val_samples"]:
        raise ValueError(f"official sample count mismatch: {evidence_id}")
    if results["hashes"].get("config_sha256") != official["checkpoint_config_sha256"]:
        raise ValueError(f"checkpoint config identity mismatch: {evidence_id}")
    if (
        results["hashes"].get("checkpoint_data_manifest_sha256")
        != protocol["data"]["canonical_manifest_sha256"]
    ):
        raise ValueError(f"checkpoint data identity mismatch: {evidence_id}")
    topology = results["topology"]
    if (
        topology.get("parameter_count") != official["parameter_count"]
        or topology.get("state_tensor_count") != official["state_tensor_count"]
    ):
        raise ValueError(f"topology mismatch: {evidence_id}")
    completion = results["training_completion"]
    expected_completion = {
        "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,
    }
    for key, value in expected_completion.items():
        if completion.get(key) != value:
            raise ValueError(f"training completion mismatch: {evidence_id}/{key}")
    if results.get("checkpoint_epoch") != 299 or results.get("training_epochs") != 300:
        raise ValueError(f"training epoch mismatch: {evidence_id}")

    data = protocol["data"]
    manifest_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, value in manifest_expected.items():
        if manifest.get(key) != value:
            raise ValueError(f"data manifest mismatch: {evidence_id}/{key}")

    resolved = load_yaml(run_dir / "config_resolved.yaml")
    runtime = resolved.get("runtime", {})
    runtime_expected = {
        "run_name": official["run_name"],
        "seed": 0,
        "world_size": 8,
        "data_manifest_sha256": data["canonical_manifest_sha256"],
        "config_fingerprint": official["checkpoint_config_sha256"],
    }
    for key, value in runtime_expected.items():
        if runtime.get(key) != value:
            raise ValueError(f"resolved runtime mismatch: {evidence_id}/{key}")
    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(f"legacy/current config semantics differ: {evidence_id}")
    semantic_sha = stable_sha256(legacy_semantics)
    if semantic_sha != record["semantic_projection_sha256"]:
        raise ValueError(f"semantic projection hash mismatch: {evidence_id}")

    final_epochs = []
    for line_number, line in enumerate(
        (run_dir / "metrics.jsonl").read_text(encoding="utf-8").splitlines(), 1
    ):
        metric = json.loads(line)
        _assert_finite(metric, f"{evidence_id}.metrics[{line_number}]")
        if metric.get("kind") == "epoch" and metric.get("epoch") == 299:
            final_epochs.append(metric)
    if not any(
        item.get("epoch_complete")
        and item.get("training_complete")
        and item.get("global_step") == 187500
        for item in final_epochs
    ):
        raise ValueError(f"missing complete final epoch metric: {evidence_id}")

    if evidence_id == "legacy_learned_smooth_s3_seed0":
        model = resolved["model"]
        if (
            model.get("smooth_clip_trainable") is not True
            or model.get("smooth_clip_init") != 6.0
            or model.get("smooth_clip_beta") != 10.0
            or model.get("smooth_clip_per_channel") is not False
            or "raw_clip"
            not in resolved["optimizer"].get("no_weight_decay_patterns", [])
        ):
            raise ValueError("historical smooth controller semantics drifted")


def read_code_manifest() -> dict[str, Any]:
    path = JOURNAL_ROOT / CODE_MANIFEST_RELATIVE_PATH
    manifest = json.loads(path.read_text(encoding="utf-8"))
    if not isinstance(manifest.get("code_sha256"), str):
        raise ValueError("invalid code manifest")
    return manifest


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

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


def trigger_is_met(protocol: dict[str, Any], task: FollowupTask) -> bool:
    if task.trigger is None:
        return True
    trigger = task.trigger
    evidence = protocol["legacy_evidence"][trigger["evidence"]]
    observed = float(evidence["official"][trigger["metric"]])
    if not math.isclose(
        observed, float(trigger["observed"]), rel_tol=0.0, abs_tol=1e-9
    ):
        raise ValueError(f"conditional trigger observation drifted: {task.task_id}")
    if trigger["operator"] != "less_than":
        raise ValueError(f"unsupported trigger operator: {task.task_id}")
    met = observed < float(trigger["threshold"])
    if (trigger.get("state") == "met") != met:
        raise ValueError(f"conditional trigger state drifted: {task.task_id}")
    return met


def approval_payload(
    protocol: dict[str, Any],
    task: FollowupTask,
    *,
    conditional: bool = False,
) -> dict[str, Any]:
    return {
        "schema_version": 1,
        "protocol_id": protocol["protocol_id"],
        "task_id": task.task_id,
        "status": "approved",
        "approval_basis": (
            "manual_conditional_trigger_acknowledgement"
            if conditional
            else "registered_ready_task"
        ),
        "approved_at_utc": (
            datetime.now(timezone.utc).isoformat()
            if conditional
            else protocol["registered_at_utc"]
        ),
        "config_path": task.config_path,
        "output_dir": str(task.output_dir),
        "code_sha256": read_code_manifest()["code_sha256"],
    }


def verify_approval(
    protocol: dict[str, Any], task: FollowupTask, code_sha256: str
) -> None:
    if not task.approval_path.is_file():
        raise ApprovalError(
            f"Follow-up guard denied {task.task_id}: missing " f"{task.approval_path}"
        )
    marker = json.loads(task.approval_path.read_text(encoding="utf-8"))
    required = {
        "schema_version": 1,
        "protocol_id": protocol["protocol_id"],
        "task_id": task.task_id,
        "status": "approved",
        "config_path": task.config_path,
        "output_dir": str(task.output_dir),
        "code_sha256": code_sha256,
    }
    for key, expected in required.items():
        if marker.get(key) != expected:
            raise ApprovalError(
                f"Follow-up guard denied {task.task_id}: marker field {key} drifted"
            )
    expected_basis = (
        "registered_ready_task"
        if task.status == "ready"
        else "manual_conditional_trigger_acknowledgement"
    )
    if marker.get("approval_basis") != expected_basis:
        raise ApprovalError(
            f"Follow-up guard denied {task.task_id}: approval basis drifted"
        )
    if task.status == "conditional" and not trigger_is_met(protocol, task):
        raise ApprovalError(
            f"Follow-up guard denied {task.task_id}: trigger is not met"
        )


def verify_task(task_id: str, require_approval: bool) -> None:
    protocol = load_protocol()
    tasks = build_tasks(protocol)
    try:
        task = next(task for task in tasks if task.task_id == task_id)
    except StopIteration as error:
        raise ValueError(f"unknown follow-up task: {task_id}") from error
    code_sha256 = verify_code_manifest()
    for evidence_id in task.evidence:
        verify_evidence(protocol, evidence_id)
    if require_approval:
        verify_approval(protocol, task, code_sha256)
    print(
        f"Verified follow-up task {task.task_id}: code={code_sha256}, "
        f"evidence={','.join(task.evidence)}"
    )


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)}")
    return {key: copy.deepcopy(source[key]) for key in required}


def build_launch_document(
    protocol: dict[str, Any],
    task: FollowupTask,
    invariants: dict[str, Any],
) -> dict[str, Any]:
    verify = (
        "/tmp/gmnet_venv/bin/python "
        "scripts/generate_single_seed_followup.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"
    )
    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_single_seed_followup.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[FollowupTask]
) -> dict[str, Any]:
    records = []
    for task in tasks:
        record = asdict(task)
        record["evidence"] = list(task.evidence)
        record["deploy_path"] = str(task.deploy_path)
        record["approval_path"] = str(task.approval_path)
        record["output_dir"] = str(task.output_dir)
        record["job_name"] = task.job_name
        record["eta_class"] = ">12h"
        records.append(record)
    return {
        "schema_version": 1,
        "protocol_id": protocol["protocol_id"],
        "protocol_source": str(PROTOCOL_PATH),
        "generated_by": str(SCRIPT_PATH),
        "source_template": str(BASE_TEMPLATE),
        "code_manifest": str(JOURNAL_ROOT / CODE_MANIFEST_RELATIVE_PATH),
        "code_sha256": read_code_manifest()["code_sha256"],
        "relationship_to_parent": protocol["relationship_to_parent"],
        "post_hoc_registration": copy.deepcopy(protocol["post_hoc_registration"]),
        "policy": copy.deepcopy(protocol["policy"]),
        "data": copy.deepcopy(protocol["data"]),
        "run_root": str(RUN_ROOT),
        "summary": {
            "task_count": len(tasks),
            "initially_approved_count": sum(task.submission_allowed for task in tasks),
            "conditional_count": sum(task.status == "conditional" for task in tasks),
        },
        "tasks": records,
    }


def expected_files() -> dict[Path, str]:
    protocol = load_protocol()
    tasks = build_tasks(protocol)
    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.yaml"] = dump_yaml(
        build_batch_manifest(protocol, tasks)
    )
    for task in tasks:
        if task.submission_allowed:
            payload = approval_payload(protocol, task)
            files[task.approval_path] = (
                json.dumps(payload, 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
        path.write_text(content, encoding="utf-8")
    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 approve_conditional(task_id: str, acknowledged: bool) -> None:
    if not acknowledged:
        raise ApprovalError("conditional approval requires --acknowledge-conditional")
    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 or task.status != "conditional":
        raise ApprovalError(f"task is not conditional: {task_id}")
    verify_code_manifest()
    for evidence_id in task.evidence:
        verify_evidence(protocol, evidence_id)
    if not trigger_is_met(protocol, task):
        raise ApprovalError(f"conditional trigger is not met: {task_id}")
    task.approval_path.parent.mkdir(parents=True, exist_ok=True)
    task.approval_path.write_text(
        json.dumps(
            approval_payload(protocol, task, conditional=True),
            indent=2,
            sort_keys=True,
        )
        + "\n",
        encoding="utf-8",
    )
    print(f"Approved conditional follow-up task: {task_id}")


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")
    action.add_argument("--approve-conditional")
    parser.add_argument("--require-approval", action="store_true")
    parser.add_argument("--acknowledge-conditional", 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
        if args.approve_conditional:
            approve_conditional(args.approve_conditional, args.acknowledge_conditional)
            return 0
        protocol = load_protocol()
        tasks = build_tasks(protocol)
        verify_code_manifest()
        for evidence_id in protocol["legacy_evidence"]:
            verify_evidence(protocol, evidence_id)
        files = expected_files()
        if args.check:
            errors = check_files(files)
            if errors:
                print("\n".join(errors), file=sys.stderr)
                return 1
            print(
                f"Validated {len(tasks)} follow-up launch YAMLs, "
                "batch manifest, approvals, code, and legacy evidence"
            )
            return 0
        write_files(files)
        print(
            f"Generated {len(tasks)} follow-up 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())