#!/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())