Upload Experiments/V3_S3_A1/cidm_v3_scs_s3_a1_long_horizon_objective_repair.py with huggingface_hub

Experiments/V3_S3_A1/cidm_v3_scs_s3_a1_long_horizon_objective_repair.py

@@ -0,0 +1,2112 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+CIDM-v3 SCS V3-S3-A1
+长期目标修复、Persistence Skill与最终架构冻结资格实验
+========================================================
+
+S3-A0的有效结论：
+- 显式尺度 + Band Closure 在72 h和7 d的加权RMSE优于参数匹配Single-State；
+- Band Closure在72 h、7 d、15 d均稳定正向；
+- 15 d时显式尺度反而落后Single-State；
+- 所有神经模型显著落后Persistence；
+- 旧模型只训练到12步，却被外推到60步；
+- 旧S1-R3每个Epoch重建AdamW，优化器动量被重置；
+- 加权全域RMSE和等样本Bootstrap方向冲突，说明样本/海域权重需要严格审计。
+
+本轮遵守“只修训练，不加模块”：
+1. 架构完全不变；
+2. 未来BER继续删除；
+3. Cross-scale Flux、慢闭合、垂向闭合、因果方差放大继续关闭；
+4. 只训练Core、Decoder、Scale输出与Band Closure；
+5. AdamW在全部Epoch持续保存动量；
+6. 训练跨度课程扩展到60步；
+7. 加入Persistence-relative skill、增量、频谱、方差和波浪物理损失；
+8. 参数匹配Single-State执行同样训练目标；
+9. 秋季测试同时报告像素加权、等样本与时间块Bootstrap。
+
+没有新增神经分支、Router、Gate、Reservoir或新的闭合器。
+"""
+from __future__ import annotations
+
+import argparse
+import copy
+import hashlib
+import json
+import math
+import os
+import random
+import shutil
+import time
+import traceback
+import zipfile
+from pathlib import Path
+from typing import Any, Dict, Iterable, List, Mapping, Optional, Sequence, Tuple
+
+import numpy as np
+import pandas as pd
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from torch.utils.data import DataLoader, Dataset
+
+import matplotlib
+matplotlib.use("Agg")
+import matplotlib.pyplot as plt
+
+import scs_c0_data_runtime as data_runtime
+import v3s1_r1_base as r1base
+import cidm_v3_scs_s1_r3_slowfast_causal_closure as s1r3
+import cidm_v3_scs_s2_a1_r2_conditional_external_innovation_capacity as s2r2
+import cidm_v3_scs_s3_a0_long_rollout_freeze as s3a0
+
+
+VARIABLE_NAMES = list(data_runtime.VARIABLE_NAMES)
+S1_SEEDS = [20260902, 20260903, 20260904]
+HORIZONS = [1, 4, 12, 28, 60]
+HORIZON_LABELS = {1: "6h", 4: "24h", 12: "72h", 28: "7d", 60: "15d"}
+GROUPS = dict(s2r2.GROUPS)
+NONNEGATIVE_WAVE_INDICES = [9, 10, 11, 14, 15]
+DIRECTION_INDICES = [12, 13]
+METHODS = [
+    "persistence",
+    "parent_single",
+    "parent_explicit_band",
+    "repaired_single",
+    "repaired_explicit_no_band",
+    "repaired_explicit_band",
+]
+
+
+def json_default(value: Any) -> Any:
+    return data_runtime.json_default(value)
+
+
+def atomic_json(payload: Any, path: Path) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    temp = path.with_suffix(path.suffix + ".tmp")
+    temp.write_text(
+        json.dumps(payload, ensure_ascii=False, indent=2, default=json_default),
+        encoding="utf-8",
+    )
+    os.replace(temp, path)
+
+
+def stage(index: int, total: int, title: str) -> None:
+    print(f"\n[V3-S3-A1] 阶段 {index}/{total}：{title}", flush=True)
+
+
+def sha256_file(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as handle:
+        for block in iter(lambda: handle.read(1024 * 1024), b""):
+            digest.update(block)
+    return digest.hexdigest()
+
+
+def seed_everything(seed: int) -> None:
+    random.seed(seed)
+    np.random.seed(seed)
+    torch.manual_seed(seed)
+    if torch.cuda.is_available():
+        torch.cuda.manual_seed_all(seed)
+
+
+def hf_download_file(
+    repo_id: str,
+    repo_path: str,
+    local_path: Path,
+    token: Optional[str],
+) -> bool:
+    try:
+        from huggingface_hub import hf_hub_download
+        downloaded = Path(
+            hf_hub_download(
+                repo_id=repo_id,
+                filename=repo_path,
+                repo_type="dataset",
+                token=token,
+            )
+        )
+    except Exception as exc:
+        print(f"[HF miss] {repo_path}: {exc}", flush=True)
+        return False
+    local_path.parent.mkdir(parents=True, exist_ok=True)
+    if local_path.exists() or local_path.is_symlink():
+        local_path.unlink()
+    try:
+        local_path.symlink_to(downloaded)
+    except Exception:
+        shutil.copy2(downloaded, local_path)
+    print(f"[HF restored] {repo_path}", flush=True)
+    return True
+
+
+def ensure_assets(args: argparse.Namespace) -> Dict[str, Any]:
+    token = args.hf_token or os.environ.get("HF_TOKEN") or None
+    parent_zip = Path(args.parent_zip)
+    if not parent_zip.is_file():
+        candidates = [
+            "Experiments/V3_S3_A0/CIDM_v3_SCS_V3_S3_A0.zip",
+            "CIDM_v3_SCS_V3_S3_A0.zip",
+        ]
+        for candidate in candidates:
+            if hf_download_file(args.hf_repo_id, candidate, parent_zip, token):
+                break
+    if not parent_zip.is_file():
+        raise FileNotFoundError("CIDM_v3_SCS_V3_S3_A0.zip is required.")
+
+    restored = []
+    for season in ["summer", "autumn"]:
+        root = Path(args.native_cache_dir) / season / "prepared"
+        root.mkdir(parents=True, exist_ok=True)
+        for filename in [
+            "scs_c0_data.npy",
+            "scs_c0_mask.npy",
+            "scs_c0_variable_masks.npy",
+            "scs_c0_metadata.json",
+            "C0_data_audit.csv",
+        ]:
+            local_path = root / filename
+            if local_path.is_file() and local_path.stat().st_size > 128:
+                continue
+            repo_path = f"Cache/native_1_12/{season}/{filename}"
+            if not hf_download_file(args.hf_repo_id, repo_path, local_path, token):
+                raise FileNotFoundError(repo_path)
+            restored.append(repo_path)
+        metadata = json.loads(
+            (root / "scs_c0_metadata.json").read_text(encoding="utf-8")
+        )
+        if abs(float(metadata["native_resolution_degrees"]) - 1 / 12) > 1e-6:
+            raise RuntimeError(f"{season} cache is not native 1/12 degree.")
+
+    return {
+        "parent_zip_sha256": sha256_file(parent_zip),
+        "restored": restored,
+    }
+
+
+def extract_parent_assets(
+    parent_zip: Path,
+    destination: Path,
+) -> Dict[str, Any]:
+    destination.mkdir(parents=True, exist_ok=True)
+    with zipfile.ZipFile(parent_zip) as archive:
+        archive.extractall(destination)
+
+    s1_verdicts = list(destination.rglob("V3S1R3_verdict.json"))
+    if len(s1_verdicts) != 1:
+        raise RuntimeError(
+            f"Expected one nested S1-R3 verdict, found {len(s1_verdicts)}"
+        )
+    s1_root = s1_verdicts[0].parent
+    metadata_path = s1_root / "scs_c0_metadata.json"
+    if not metadata_path.is_file():
+        raise FileNotFoundError(metadata_path)
+
+    explicit_checkpoints: Dict[int, Path] = {}
+    for path in (
+        s1_root / "checkpoints" / "slowfast_causal"
+    ).glob("seed_*.pt"):
+        payload = torch.load(path, map_location="cpu", weights_only=False)
+        explicit_checkpoints[int(payload["seed"])] = path
+
+    single_checkpoints: Dict[int, Path] = {}
+    for path in s1_root.rglob("checkpoints/single/seed_*.pt"):
+        payload = torch.load(path, map_location="cpu", weights_only=False)
+        seed = int(payload["seed"])
+        if seed not in single_checkpoints:
+            single_checkpoints[seed] = path
+
+    missing_explicit = [seed for seed in S1_SEEDS if seed not in explicit_checkpoints]
+    missing_single = [seed for seed in S1_SEEDS if seed not in single_checkpoints]
+    if missing_explicit or missing_single:
+        raise RuntimeError(
+            f"Missing checkpoints explicit={missing_explicit}, single={missing_single}"
+        )
+
+    s3_verdicts = list(destination.rglob("S3A0_verdict.json"))
+    s3_verdict = (
+        json.loads(s3_verdicts[0].read_text(encoding="utf-8"))
+        if s3_verdicts else {}
+    )
+    return {
+        "s1_root": s1_root,
+        "metadata": json.loads(metadata_path.read_text(encoding="utf-8")),
+        "s1_verdict": json.loads(s1_verdicts[0].read_text(encoding="utf-8")),
+        "s3_verdict": s3_verdict,
+        "explicit_checkpoints": explicit_checkpoints,
+        "single_checkpoints": single_checkpoints,
+    }
+
+
+class LongHorizonDataset(Dataset):
+    def __init__(
+        self,
+        native_root: Path,
+        reference_mean: np.ndarray,
+        reference_std: np.ndarray,
+        samples: int,
+        seed: int,
+        history: int,
+        patch_size: int,
+        maximum_horizon: int,
+        split_tag: str,
+        forbidden_keys: Optional[set] = None,
+    ):
+        self.data = np.load(native_root / "scs_c0_data.npy", mmap_mode="r")
+        self.variable_masks = np.load(
+            native_root / "scs_c0_variable_masks.npy", mmap_mode="r"
+        )
+        self.metadata = json.loads(
+            (native_root / "scs_c0_metadata.json").read_text(encoding="utf-8")
+        )
+        self.window_mean = np.asarray(self.metadata["means"], dtype=np.float32)
+        self.window_std = np.asarray(self.metadata["stds"], dtype=np.float32)
+        self.reference_mean = np.asarray(reference_mean, dtype=np.float32)
+        self.reference_std = np.asarray(reference_std, dtype=np.float32)
+        self.history = history
+        self.patch_size = patch_size
+        self.maximum_horizon = maximum_horizon
+        self.split_tag = split_tag
+
+        valid_times = np.arange(
+            history - 1,
+            self.data.shape[0] - maximum_horizon,
+            dtype=np.int64,
+        )
+        if len(valid_times) < 8:
+            raise RuntimeError(f"Only {len(valid_times)} valid starts for {split_tag}")
+
+        generator = np.random.default_rng(seed)
+        height, width = self.data.shape[-2:]
+        max_y = height - patch_size
+        max_x = width - patch_size
+        records = []
+        used = set()
+        forbidden = set() if forbidden_keys is None else set(forbidden_keys)
+        attempts = 0
+        while len(records) < samples and attempts < samples * 100:
+            attempts += 1
+            time_index = int(generator.choice(valid_times))
+            y = int(generator.integers(0, max_y + 1))
+            x = int(generator.integers(0, max_x + 1))
+            # Tile key limits exact/near-identical duplicates and supports split audit.
+            key = (
+                time_index,
+                int(y // max(patch_size // 2, 1)),
+                int(x // max(patch_size // 2, 1)),
+            )
+            if key in used or key in forbidden:
+                continue
+            used.add(key)
+            records.append((time_index, y, x))
+        if len(records) < samples:
+            raise RuntimeError(
+                f"Could build only {len(records)}/{samples} unique records"
+            )
+        self.records = records
+        self.record_keys = used
+
+    def __len__(self) -> int:
+        return len(self.records)
+
+    def _to_reference(self, value: np.ndarray) -> np.ndarray:
+        physical = (
+            value
+            * self.window_std[None, :, None, None]
+            + self.window_mean[None, :, None, None]
+        )
+        return (
+            physical - self.reference_mean[None, :, None, None]
+        ) / self.reference_std[None, :, None, None]
+
+    def __getitem__(self, item: int) -> Dict[str, torch.Tensor]:
+        time_index, y, x = self.records[item]
+        p = self.patch_size
+        history_window = np.asarray(
+            self.data[
+                time_index - self.history + 1:time_index + 1,
+                :,
+                y:y + p,
+                x:x + p,
+            ],
+            dtype=np.float32,
+        ).copy()
+        future_window = np.asarray(
+            self.data[
+                time_index + 1:time_index + self.maximum_horizon + 1,
+                :,
+                y:y + p,
+                x:x + p,
+            ],
+            dtype=np.float32,
+        ).copy()
+        mask = np.asarray(
+            self.variable_masks[:, y:y + p, x:x + p],
+            dtype=np.float32,
+        ).copy()
+        history = self._to_reference(history_window).astype(np.float32)
+        future = self._to_reference(future_window).astype(np.float32)
+        valid_count = float(mask.sum())
+        return {
+            "history": torch.from_numpy(history),
+            "future": torch.from_numpy(future),
+            "mask": torch.from_numpy(mask),
+            "sample_index": torch.tensor(item, dtype=torch.long),
+            "time_index": torch.tensor(time_index, dtype=torch.long),
+            "origin_y": torch.tensor(y, dtype=torch.long),
+            "origin_x": torch.tensor(x, dtype=torch.long),
+            "valid_count": torch.tensor(valid_count, dtype=torch.float32),
+        }
+
+
+def make_loaders(
+    native_cache_dir: Path,
+    reference_mean: np.ndarray,
+    reference_std: np.ndarray,
+    args: argparse.Namespace,
+) -> Tuple[Dict[str, DataLoader], Dict[str, LongHorizonDataset]]:
+    roots = {
+        "train": native_cache_dir / "summer" / "prepared",
+        "validation": native_cache_dir / "summer" / "prepared",
+        "test": native_cache_dir / "autumn" / "prepared",
+    }
+    train_dataset = LongHorizonDataset(
+        roots["train"], reference_mean, reference_std,
+        args.train_samples, args.train_seed, args.history,
+        args.patch_size, args.max_horizon, "summer_train",
+    )
+    validation_dataset = LongHorizonDataset(
+        roots["validation"], reference_mean, reference_std,
+        args.validation_samples, args.validation_seed, args.history,
+        args.patch_size, args.max_horizon, "summer_validation",
+        forbidden_keys=train_dataset.record_keys,
+    )
+    test_dataset = LongHorizonDataset(
+        roots["test"], reference_mean, reference_std,
+        args.test_samples, args.test_seed, args.history,
+        args.patch_size, args.max_horizon, "autumn_test",
+    )
+    datasets = {
+        "train": train_dataset,
+        "validation": validation_dataset,
+        "test": test_dataset,
+    }
+    loaders = {
+        "train": DataLoader(
+            datasets["train"],
+            batch_size=args.batch_size,
+            shuffle=True,
+            num_workers=args.num_workers,
+            pin_memory=torch.cuda.is_available(),
+        ),
+        "validation": DataLoader(
+            datasets["validation"],
+            batch_size=args.batch_size,
+            shuffle=False,
+            num_workers=args.num_workers,
+            pin_memory=torch.cuda.is_available(),
+        ),
+        "test": DataLoader(
+            datasets["test"],
+            batch_size=args.batch_size,
+            shuffle=False,
+            num_workers=args.num_workers,
+            pin_memory=torch.cuda.is_available(),
+        ),
+    }
+    return loaders, datasets
+
+
+def make_explicit(checkpoint: Path, device: torch.device):
+    return s3a0.make_explicit(checkpoint, device)
+
+
+def make_single(checkpoint: Path, device: torch.device):
+    return s3a0.make_single(checkpoint, device)
+
+
+def set_explicit_trainable(model: nn.Module) -> List[nn.Parameter]:
+    for parameter in model.parameters():
+        parameter.requires_grad = False
+    train_modules = [
+        model.core,
+        model.decoder,
+        model.dec_film,
+        model.scale_out,
+        model.band_energy_closure,
+    ]
+    parameters = []
+    for module in train_modules:
+        for parameter in module.parameters():
+            parameter.requires_grad = True
+            parameters.append(parameter)
+    # Explicitly keep all deferred/removed components frozen.
+    for module in [
+        model.encoder,
+        model.enc_film,
+        model.frame,
+        model.flux,
+        model.rt_closure,
+        model.slow_memory,
+        model.vertical_closure,
+        model.causal_variance,
+    ]:
+        for parameter in module.parameters():
+            parameter.requires_grad = False
+    return parameters
+
+
+def set_single_trainable(model: nn.Module) -> List[nn.Parameter]:
+    parameters = []
+    for parameter in model.parameters():
+        parameter.requires_grad = True
+        parameters.append(parameter)
+    return parameters
+
+
+@torch.no_grad()
+def rollout_explicit(
+    model: nn.Module,
+    history: torch.Tensor,
+    mask: torch.Tensor,
+    steps: int,
+    band_closure: bool,
+) -> List[torch.Tensor]:
+    outputs, _ = model.rollout_latent(
+        history,
+        mask,
+        steps,
+        flux_mode="none",
+        projection=True,
+        radial_delta=False,
+        band_closure=band_closure,
+        slow_memory=False,
+        vertical_closure=False,
+        causal_variance=False,
+        counterfactual=False,
+    )
+    return [output["pred"] for output in outputs]
+
+
+@torch.no_grad()
+def rollout_single(
+    model: nn.Module,
+    history: torch.Tensor,
+    mask: torch.Tensor,
+    steps: int,
+) -> List[torch.Tensor]:
+    outputs, _ = model.rollout_latent(history, mask, steps)
+    return [output["pred"] for output in outputs]
+
+
+def rollout_explicit_train(
+    model: nn.Module,
+    history: torch.Tensor,
+    mask: torch.Tensor,
+    steps: int,
+) -> List[torch.Tensor]:
+    outputs, _ = model.rollout_latent(
+        history,
+        mask,
+        steps,
+        flux_mode="none",
+        projection=True,
+        radial_delta=False,
+        band_closure=True,
+        slow_memory=False,
+        vertical_closure=False,
+        causal_variance=False,
+        counterfactual=False,
+    )
+    return [output["pred"] for output in outputs]
+
+
+def rollout_single_train(
+    model: nn.Module,
+    history: torch.Tensor,
+    mask: torch.Tensor,
+    steps: int,
+) -> List[torch.Tensor]:
+    outputs, _ = model.rollout_latent(history, mask, steps)
+    return [output["pred"] for output in outputs]
+
+
+def masked_sample_mse(
+    prediction: torch.Tensor,
+    target: torch.Tensor,
+    mask: torch.Tensor,
+) -> torch.Tensor:
+    denominator = mask.flatten(1).sum(dim=1).clamp_min(1.0)
+    return (
+        ((prediction - target).square() * mask)
+        .flatten(1).sum(dim=1)
+        / denominator
+    )
+
+
+def masked_gradient_loss(
+    prediction: torch.Tensor,
+    target: torch.Tensor,
+    mask: torch.Tensor,
+) -> torch.Tensor:
+    px = prediction[..., :, 1:] - prediction[..., :, :-1]
+    tx = target[..., :, 1:] - target[..., :, :-1]
+    py = prediction[..., 1:, :] - prediction[..., :-1, :]
+    ty = target[..., 1:, :] - target[..., :-1, :]
+    mx = mask[..., :, 1:] * mask[..., :, :-1]
+    my = mask[..., 1:, :] * mask[..., :-1, :]
+    numerator = (
+        ((px - tx).square() * mx).sum()
+        + ((py - ty).square() * my).sum()
+    )
+    denominator = (mx.sum() + my.sum()).clamp_min(1.0)
+    return numerator / denominator
+
+
+def channel_variance_log_loss(
+    prediction: torch.Tensor,
+    target: torch.Tensor,
+    mask: torch.Tensor,
+) -> torch.Tensor:
+    denominator = mask.sum(dim=(-2, -1), keepdim=True).clamp_min(1.0)
+    pred_mean = (prediction * mask).sum(dim=(-2, -1), keepdim=True) / denominator
+    target_mean = (target * mask).sum(dim=(-2, -1), keepdim=True) / denominator
+    pred_var = (
+        (prediction - pred_mean).square() * mask
+    ).sum(dim=(-2, -1)) / denominator.squeeze(-1).squeeze(-1)
+    target_var = (
+        (target - target_mean).square() * mask
+    ).sum(dim=(-2, -1)) / denominator.squeeze(-1).squeeze(-1)
+    return (
+        torch.log(pred_var + 1e-6) - torch.log(target_var + 1e-6)
+    ).square().mean()
+
+
+def spectral_log_loss(
+    prediction: torch.Tensor,
+    target: torch.Tensor,
+    mask: torch.Tensor,
+) -> torch.Tensor:
+    pred_energy = s3a0.spectral_energy_ratios(prediction, mask)
+    target_energy = s3a0.spectral_energy_ratios(target, mask)
+    return (
+        torch.log(pred_energy + 1e-7)
+        - torch.log(target_energy + 1e-7)
+    ).abs().mean()
+
+
+def physical_domain_loss(
+    prediction: torch.Tensor,
+    mask: torch.Tensor,
+    means: torch.Tensor,
+    stds: torch.Tensor,
+) -> Tuple[torch.Tensor, torch.Tensor]:
+    physical = (
+        prediction
+        * stds[None, :, None, None]
+        + means[None, :, None, None]
+    )
+    wave_mask = mask[:, NONNEGATIVE_WAVE_INDICES]
+    wave = physical[:, NONNEGATIVE_WAVE_INDICES]
+    negative = (
+        F.relu(-wave).square() * wave_mask
+    ).sum() / wave_mask.sum().clamp_min(1.0)
+
+    sin_value = physical[:, DIRECTION_INDICES[0]]
+    cos_value = physical[:, DIRECTION_INDICES[1]]
+    direction_mask = (
+        mask[:, DIRECTION_INDICES[0]]
+        * mask[:, DIRECTION_INDICES[1]]
+    )
+    unit = torch.sqrt(
+        sin_value.square() + cos_value.square() + 1e-8
+    )
+    circle = (
+        (unit - 1.0).square() * direction_mask
+    ).sum() / direction_mask.sum().clamp_min(1.0)
+    return negative, circle
+
+
+def selected_steps(horizon: int) -> List[int]:
+    candidates = [1, 4, 12, 28, horizon]
+    return sorted(set(step for step in candidates if step <= horizon))
+
+
+def sequence_objective(
+    outputs: Sequence[torch.Tensor],
+    history: torch.Tensor,
+    future: torch.Tensor,
+    mask: torch.Tensor,
+    means: torch.Tensor,
+    stds: torch.Tensor,
+    args: argparse.Namespace,
+) -> Dict[str, torch.Tensor]:
+    horizon = len(outputs)
+    steps = selected_steps(horizon)
+    raw_weights = torch.tensor(
+        [0.12, 0.18, 0.24, 0.24, 0.32][:len(steps)],
+        device=history.device,
+        dtype=history.dtype,
+    )
+    weights = raw_weights / raw_weights.sum()
+
+    totals = {
+        "value": torch.zeros((), device=history.device),
+        "gradient": torch.zeros((), device=history.device),
+        "increment": torch.zeros((), device=history.device),
+        "skill": torch.zeros((), device=history.device),
+        "variance": torch.zeros((), device=history.device),
+        "spectral": torch.zeros((), device=history.device),
+        "wave_negative": torch.zeros((), device=history.device),
+        "direction_circle": torch.zeros((), device=history.device),
+    }
+    persistence = history[:, -1]
+    previous_prediction = persistence
+    previous_target = persistence
+    previous_step = 0
+
+    for weight, step in zip(weights, steps):
+        prediction = outputs[step - 1]
+        target = future[:, step - 1]
+        sample_mse = masked_sample_mse(prediction, target, mask)
+        persistence_mse = masked_sample_mse(persistence, target, mask)
+        totals["value"] += weight * sample_mse.mean()
+        totals["gradient"] += weight * masked_gradient_loss(
+            prediction, target, mask
+        )
+        # Multi-step displacement objective over the selected interval.
+        predicted_increment = prediction - previous_prediction
+        target_increment = target - previous_target
+        totals["increment"] += weight * masked_sample_mse(
+            predicted_increment, target_increment, mask
+        ).mean()
+        previous_prediction = prediction
+        previous_target = target
+        previous_step = step
+
+        normalized_skill_gap = (
+            sample_mse - args.persistence_target_ratio * persistence_mse
+        ) / (persistence_mse.detach() + 0.05)
+        totals["skill"] += weight * F.relu(normalized_skill_gap).mean()
+        totals["variance"] += weight * channel_variance_log_loss(
+            prediction, target, mask
+        )
+        if step >= 12:
+            totals["spectral"] += weight * spectral_log_loss(
+                prediction, target, mask
+            )
+        negative, circle = physical_domain_loss(
+            prediction, mask, means, stds
+        )
+        totals["wave_negative"] += weight * negative
+        totals["direction_circle"] += weight * circle
+
+    total = (
+        totals["value"]
+        + args.gradient_weight * totals["gradient"]
+        + args.increment_weight * totals["increment"]
+        + args.persistence_skill_weight * totals["skill"]
+        + args.variance_weight * totals["variance"]
+        + args.spectral_weight * totals["spectral"]
+        + args.wave_nonnegative_weight * totals["wave_negative"]
+        + args.direction_circle_weight * totals["direction_circle"]
+    )
+    return {"total": total, **totals}
+
+
+def horizon_schedule(args: argparse.Namespace) -> List[int]:
+    default = [12, 20, 28, 40, 60, 60]
+    if args.epochs <= len(default):
+        schedule = default[:args.epochs]
+    else:
+        schedule = default + [60] * (args.epochs - len(default))
+    return [min(args.max_horizon, value) for value in schedule]
+
+
+@torch.no_grad()
+def validation_score(
+    model: nn.Module,
+    kind: str,
+    loader: DataLoader,
+    device: torch.device,
+    means: torch.Tensor,
+    stds: torch.Tensor,
+) -> Dict[str, float]:
+    model.eval()
+    rmse_acc = {step: [] for step in HORIZONS}
+    variance_acc = {step: [] for step in [28, 60]}
+    skill_acc = {step: [] for step in [12, 28, 60]}
+    direction_acc = []
+    for batch in loader:
+        history = batch["history"].to(device)
+        future = batch["future"].to(device)
+        mask = batch["mask"].to(device)
+        if kind == "explicit":
+            outputs = rollout_explicit(model, history, mask, 60, True)
+        else:
+            outputs = rollout_single(model, history, mask, 60)
+        persistence = history[:, -1]
+        for step in HORIZONS:
+            prediction = outputs[step - 1]
+            target = future[:, step - 1]
+            rmse_acc[step].extend(
+                torch.sqrt(
+                    masked_sample_mse(prediction, target, mask) + 1e-12
+                ).cpu().tolist()
+            )
+            if step in variance_acc:
+                variance_acc[step].append(
+                    float(channel_variance_log_loss(
+                        prediction, target, mask
+                    ))
+                )
+            if step in skill_acc:
+                model_mse = masked_sample_mse(prediction, target, mask)
+                persist_mse = masked_sample_mse(persistence, target, mask)
+                skill_acc[step].extend(
+                    (
+                        (model_mse - persist_mse)
+                        / (persist_mse + 0.05)
+                    ).cpu().tolist()
+                )
+        _, circle = physical_domain_loss(
+            outputs[59], mask, means, stds
+        )
+        direction_acc.append(float(circle))
+
+    result = {
+        f"rmse_h{step}": float(np.mean(values))
+        for step, values in rmse_acc.items()
+    }
+    result["variance_log_7d"] = float(np.mean(variance_acc[28]))
+    result["variance_log_15d"] = float(np.mean(variance_acc[60]))
+    result["skill_gap_72h"] = float(np.mean(skill_acc[12]))
+    result["skill_gap_7d"] = float(np.mean(skill_acc[28]))
+    result["skill_gap_15d"] = float(np.mean(skill_acc[60]))
+    result["direction_circle_15d"] = float(np.mean(direction_acc))
+    result["score"] = (
+        0.10 * result["rmse_h4"]
+        + 0.20 * result["rmse_h12"]
+        + 0.30 * result["rmse_h28"]
+        + 0.40 * result["rmse_h60"]
+        + 0.08 * max(result["skill_gap_72h"], 0.0)
+        + 0.10 * max(result["skill_gap_7d"], 0.0)
+        + 0.12 * max(result["skill_gap_15d"], 0.0)
+        + 0.02 * result["variance_log_7d"]
+        + 0.03 * result["variance_log_15d"]
+        + 0.02 * result["direction_circle_15d"]
+    )
+    return result
+
+
+def train_model(
+    model: nn.Module,
+    kind: str,
+    seed: int,
+    loader: DataLoader,
+    validation_loader: DataLoader,
+    device: torch.device,
+    means: torch.Tensor,
+    stds: torch.Tensor,
+    args: argparse.Namespace,
+    output_dir: Path,
+) -> Tuple[nn.Module, Dict[str, Any]]:
+    seed_everything(seed)
+    if kind == "explicit":
+        parameters = set_explicit_trainable(model)
+        learning_rate = args.explicit_learning_rate
+    else:
+        parameters = set_single_trainable(model)
+        learning_rate = args.single_learning_rate
+
+    optimizer = torch.optim.AdamW(
+        parameters,
+        lr=learning_rate,
+        weight_decay=args.weight_decay,
+    )
+    scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(
+        optimizer, T_max=max(args.epochs, 1), eta_min=learning_rate * 0.2
+    )
+    schedule = horizon_schedule(args)
+    best_score = float("inf")
+    best_epoch = -1
+    best_state = None
+    logs = []
+
+    for epoch, horizon in enumerate(schedule, start=1):
+        model.train()
+        optimizer.zero_grad(set_to_none=True)
+        running = {}
+        for batch_index, batch in enumerate(loader, start=1):
+            history = batch["history"].to(device, non_blocking=True)
+            future = batch["future"].to(device, non_blocking=True)
+            mask = batch["mask"].to(device, non_blocking=True)
+            if kind == "explicit":
+                outputs = rollout_explicit_train(
+                    model, history, mask, horizon
+                )
+            else:
+                outputs = rollout_single_train(
+                    model, history, mask, horizon
+                )
+            parts = sequence_objective(
+                outputs,
+                history,
+                future[:, :horizon],
+                mask,
+                means,
+                stds,
+                args,
+            )
+            if not torch.isfinite(parts["total"]):
+                raise RuntimeError(
+                    f"Non-finite {kind} loss seed={seed} "
+                    f"epoch={epoch} batch={batch_index}"
+                )
+            (parts["total"] / args.accumulation).backward()
+            if (
+                batch_index % args.accumulation == 0
+                or batch_index == len(loader)
+            ):
+                torch.nn.utils.clip_grad_norm_(
+                    parameters, args.grad_clip
+                )
+                optimizer.step()
+                optimizer.zero_grad(set_to_none=True)
+            for key, value in parts.items():
+                running[key] = running.get(key, 0.0) + float(
+                    value.detach()
+                )
+            if batch_index % max(len(loader) // 5, 1) == 0:
+                print(
+                    f"[{kind} seed={seed}] epoch={epoch}/{args.epochs} "
+                    f"H={horizon} batch={batch_index}/{len(loader)} "
+                    f"loss={running['total']/batch_index:.6f}",
+                    flush=True,
+                )
+
+        scheduler.step()
+        validation = validation_score(
+            model, kind, validation_loader, device, means, stds
+        )
+        row = {
+            "kind": kind,
+            "seed": seed,
+            "epoch": epoch,
+            "train_horizon": horizon,
+            "learning_rate": optimizer.param_groups[0]["lr"],
+            **{
+                f"train_{key}": value / max(len(loader), 1)
+                for key, value in running.items()
+            },
+            **{
+                f"validation_{key}": value
+                for key, value in validation.items()
+            },
+        }
+        logs.append(row)
+        print(
+            f"[VAL {kind} seed={seed}] epoch={epoch} H={horizon} "
+            f"score={validation['score']:.6f} "
+            f"rmse72={validation['rmse_h12']:.5f} "
+            f"rmse7d={validation['rmse_h28']:.5f} "
+            f"rmse15d={validation['rmse_h60']:.5f}",
+            flush=True,
+        )
+        if validation["score"] < best_score:
+            best_score = validation["score"]
+            best_epoch = epoch
+            best_state = {
+                key: value.detach().cpu().clone()
+                for key, value in model.state_dict().items()
+            }
+
+    if best_state is None:
+        raise RuntimeError(f"No best state for {kind} seed={seed}")
+    model.load_state_dict(best_state, strict=True)
+    checkpoint_dir = output_dir / "checkpoints" / kind
+    checkpoint_dir.mkdir(parents=True, exist_ok=True)
+    checkpoint = checkpoint_dir / f"seed_{seed}.pt"
+    torch.save(
+        {
+            "kind": kind,
+            "seed": seed,
+            "best_epoch": best_epoch,
+            "best_score": best_score,
+            "model_state": best_state,
+            "args": vars(args),
+            "architecture_change": "none",
+            "optimizer_persistent_across_epochs": True,
+        },
+        checkpoint,
+    )
+    log_path = output_dir / "training" / f"{kind}_seed_{seed}.csv"
+    log_path.parent.mkdir(parents=True, exist_ok=True)
+    pd.DataFrame(logs).to_csv(log_path, index=False)
+    return model, {
+        "kind": kind,
+        "seed": seed,
+        "best_epoch": best_epoch,
+        "best_score": best_score,
+        "checkpoint": str(checkpoint),
+    }
+
+
+def empty_accumulator() -> Dict[str, Any]:
+    return {
+        "squared": {step: 0.0 for step in HORIZONS},
+        "count": {step: 0.0 for step in HORIZONS},
+        "pred": {step: [] for step in HORIZONS},
+        "target": {step: [] for step in HORIZONS},
+        "samples": [],
+        "groups": {
+            (step, group): []
+            for step in HORIZONS
+            for group in GROUPS
+        },
+        "gradient": {step: [] for step in HORIZONS},
+        "wave_invalid": {step: [] for step in HORIZONS},
+        "direction_norm": {step: [] for step in HORIZONS},
+        "spectral_pred": {step: [] for step in [12, 28, 60]},
+        "spectral_target": {step: [] for step in [12, 28, 60]},
+        "finite": True,
+        "max_abs": 0.0,
+    }
+
+
+def update_accumulator(
+    accumulator: Dict[str, Any],
+    outputs: Sequence[torch.Tensor],
+    future: torch.Tensor,
+    mask: torch.Tensor,
+    batch: Mapping[str, torch.Tensor],
+    means: torch.Tensor,
+    stds: torch.Tensor,
+) -> None:
+    for step in HORIZONS:
+        prediction = outputs[step - 1]
+        target = future[:, step - 1]
+        error = (prediction - target).square() * mask
+        sample_sse = error.flatten(1).sum(dim=1)
+        sample_count = mask.flatten(1).sum(dim=1).clamp_min(1.0)
+        sample_mse = sample_sse / sample_count
+        accumulator["squared"][step] += float(sample_sse.sum())
+        accumulator["count"][step] += float(sample_count.sum())
+        accumulator["pred"][step].append((prediction * mask).flatten(1).cpu())
+        accumulator["target"][step].append((target * mask).flatten(1).cpu())
+        gradient = torch.sqrt(
+            masked_gradient_loss(prediction, target, mask).detach()
+            + 1e-12
+        )
+        accumulator["gradient"][step].append(float(gradient))
+
+        for bi in range(prediction.shape[0]):
+            accumulator["samples"].append({
+                "sample_index": int(batch["sample_index"][bi]),
+                "time_index": int(batch["time_index"][bi]),
+                "origin_y": int(batch["origin_y"][bi]),
+                "origin_x": int(batch["origin_x"][bi]),
+                "horizon": step,
+                "sse": float(sample_sse[bi]),
+                "valid_count": float(sample_count[bi]),
+                "mse": float(sample_mse[bi]),
+                "rmse": math.sqrt(max(float(sample_mse[bi]), 0.0)),
+            })
+
+        for group, indices in GROUPS.items():
+            group_mask = mask[:, indices]
+            group_error = error[:, indices]
+            denominator = group_mask.flatten(1).sum(dim=1).clamp_min(1.0)
+            group_rmse = torch.sqrt(
+                group_error.flatten(1).sum(dim=1) / denominator
+            )
+            accumulator["groups"][(step, group)].extend(
+                group_rmse.cpu().tolist()
+            )
+
+        invalid, direction = s3a0.physical_wave_audit(
+            prediction, means, stds, mask
+        )
+        accumulator["wave_invalid"][step].extend(invalid.cpu().tolist())
+        accumulator["direction_norm"][step].extend(direction.cpu().tolist())
+
+        if step in accumulator["spectral_pred"]:
+            accumulator["spectral_pred"][step].append(
+                s3a0.spectral_energy_ratios(prediction, mask).cpu()
+            )
+            accumulator["spectral_target"][step].append(
+                s3a0.spectral_energy_ratios(target, mask).cpu()
+            )
+
+        accumulator["finite"] = (
+            accumulator["finite"]
+            and bool(torch.isfinite(prediction).all())
+        )
+        accumulator["max_abs"] = max(
+            accumulator["max_abs"],
+            float(prediction.abs().max()),
+        )
+
+
+def finalize_accumulator(accumulator: Dict[str, Any]) -> Dict[str, Any]:
+    result = {
+        "finite": bool(accumulator["finite"]),
+        "max_abs": float(accumulator["max_abs"]),
+    }
+    for step in HORIZONS:
+        result[f"rmse_h{step}"] = math.sqrt(
+            accumulator["squared"][step]
+            / max(accumulator["count"][step], 1.0)
+        )
+        prediction = torch.cat(accumulator["pred"][step], dim=0)
+        target = torch.cat(accumulator["target"][step], dim=0)
+        result[f"variance_ratio_h{step}"] = float(
+            prediction.var(unbiased=False)
+            / (target.var(unbiased=False) + 1e-8)
+        )
+        result[f"gradient_rmse_h{step}"] = float(
+            np.mean(accumulator["gradient"][step])
+        )
+        result[f"wave_invalid_fraction_h{step}"] = float(
+            np.mean(accumulator["wave_invalid"][step])
+        )
+        result[f"direction_norm_error_h{step}"] = float(
+            np.mean(accumulator["direction_norm"][step])
+        )
+        for group in GROUPS:
+            result[f"group_rmse_{group}_h{step}"] = float(
+                np.mean(accumulator["groups"][(step, group)])
+            )
+        if step in accumulator["spectral_pred"]:
+            pred_energy = torch.cat(
+                accumulator["spectral_pred"][step], dim=0
+            ).mean(dim=0)
+            target_energy = torch.cat(
+                accumulator["spectral_target"][step], dim=0
+            ).mean(dim=0)
+            ratio = pred_energy / (target_energy + 1e-8)
+            for band_index, band in enumerate(["low", "mid", "high"]):
+                result[f"spectral_{band}_ratio_h{step}"] = float(
+                    ratio[band_index]
+                )
+    result["sample_rows"] = accumulator["samples"]
+    return result
+
+
+@torch.no_grad()
+def evaluate_methods(
+    models: Mapping[str, nn.Module],
+    loader: DataLoader,
+    device: torch.device,
+    means: torch.Tensor,
+    stds: torch.Tensor,
+) -> Tuple[Dict[str, Dict[str, Any]], Dict[str, pd.DataFrame]]:
+    accumulators = {method: empty_accumulator() for method in METHODS}
+    for batch_number, batch in enumerate(loader, start=1):
+        history = batch["history"].to(device)
+        future = batch["future"].to(device)
+        mask = batch["mask"].to(device)
+        persistence = [history[:, -1] * mask for _ in range(60)]
+        outputs = {
+            "persistence": persistence,
+            "parent_single": rollout_single(
+                models["parent_single"], history, mask, 60
+            ),
+            "parent_explicit_band": rollout_explicit(
+                models["parent_explicit"], history, mask, 60, True
+            ),
+            "repaired_single": rollout_single(
+                models["repaired_single"], history, mask, 60
+            ),
+            "repaired_explicit_no_band": rollout_explicit(
+                models["repaired_explicit"], history, mask, 60, False
+            ),
+            "repaired_explicit_band": rollout_explicit(
+                models["repaired_explicit"], history, mask, 60, True
+            ),
+        }
+        for method, current in outputs.items():
+            update_accumulator(
+                accumulators[method],
+                current,
+                future,
+                mask,
+                batch,
+                means,
+                stds,
+            )
+        if batch_number % max(len(loader) // 6, 1) == 0:
+            print(
+                f"[test] batch={batch_number}/{len(loader)}",
+                flush=True,
+            )
+
+    metrics = {}
+    sample_tables = {}
+    for method, accumulator in accumulators.items():
+        current = finalize_accumulator(accumulator)
+        sample_tables[method] = pd.DataFrame(
+            current.pop("sample_rows")
+        )
+        metrics[method] = current
+    return metrics, sample_tables
+
+
+def time_block_bootstrap(
+    reference_tables: Sequence[pd.DataFrame],
+    candidate_tables: Sequence[pd.DataFrame],
+    horizon: int,
+    repetitions: int,
+    seed: int,
+) -> Dict[str, float]:
+    # Average model seeds within each exact sample before bootstrapping time blocks.
+    merged_rows = []
+    for model_seed, (reference, candidate) in enumerate(
+        zip(reference_tables, candidate_tables)
+    ):
+        ref = reference[reference.horizon == horizon].copy()
+        cand = candidate[candidate.horizon == horizon].copy()
+        merged = ref.merge(
+            cand,
+            on=[
+                "sample_index",
+                "time_index",
+                "origin_y",
+                "origin_x",
+                "horizon",
+                "valid_count",
+            ],
+            suffixes=("_reference", "_candidate"),
+        )
+        merged["model_seed_index"] = model_seed
+        merged_rows.append(merged)
+    table = pd.concat(merged_rows, ignore_index=True)
+    grouped = (
+        table.groupby(
+            [
+                "sample_index",
+                "time_index",
+                "origin_y",
+                "origin_x",
+                "horizon",
+                "valid_count",
+            ],
+            as_index=False,
+        )[
+            ["sse_reference", "sse_candidate", "mse_reference", "mse_candidate"]
+        ]
+        .mean()
+    )
+    blocks = sorted(grouped.time_index.unique().tolist())
+    generator = np.random.default_rng(seed)
+    weighted_differences = []
+    equal_sample_differences = []
+    for _ in range(repetitions):
+        sampled_blocks = generator.choice(
+            blocks, size=len(blocks), replace=True
+        )
+        sampled = pd.concat(
+            [grouped[grouped.time_index == block] for block in sampled_blocks],
+            ignore_index=True,
+        )
+        reference_weighted = (
+            sampled.sse_reference.sum()
+            / sampled.valid_count.sum()
+        )
+        candidate_weighted = (
+            sampled.sse_candidate.sum()
+            / sampled.valid_count.sum()
+        )
+        weighted_differences.append(
+            candidate_weighted - reference_weighted
+        )
+        equal_sample_differences.append(
+            float(
+                (
+                    sampled.mse_candidate
+                    - sampled.mse_reference
+                ).mean()
+            )
+        )
+    weighted_low, weighted_high = np.percentile(
+        weighted_differences, [2.5, 97.5]
+    )
+    sample_low, sample_high = np.percentile(
+        equal_sample_differences, [2.5, 97.5]
+    )
+    reference_weighted = (
+        grouped.sse_reference.sum()
+        / grouped.valid_count.sum()
+    )
+    candidate_weighted = (
+        grouped.sse_candidate.sum()
+        / grouped.valid_count.sum()
+    )
+    return {
+        "weighted_mean_mse_difference": float(
+            candidate_weighted - reference_weighted
+        ),
+        "weighted_ci_low": float(weighted_low),
+        "weighted_ci_high": float(weighted_high),
+        "weighted_mse_gain_percent": float(
+            100.0
+            * (reference_weighted - candidate_weighted)
+            / max(reference_weighted, 1e-12)
+        ),
+        "equal_sample_mean_difference": float(
+            (grouped.mse_candidate - grouped.mse_reference).mean()
+        ),
+        "equal_sample_ci_low": float(sample_low),
+        "equal_sample_ci_high": float(sample_high),
+        "fraction_samples_improved": float(
+            (grouped.mse_candidate < grouped.mse_reference).mean()
+        ),
+        "time_blocks": int(len(blocks)),
+        "unique_samples": int(len(grouped)),
+    }
+
+
+@torch.no_grad()
+def runtime_audit(
+    explicit: nn.Module,
+    single: nn.Module,
+    loader: DataLoader,
+    device: torch.device,
+    repetitions: int = 8,
+) -> Dict[str, float]:
+    batch = next(iter(loader))
+    history = batch["history"].to(device)
+    mask = batch["mask"].to(device)
+    for _ in range(2):
+        rollout_explicit(explicit, history, mask, 60, True)
+        rollout_single(single, history, mask, 60)
+    if device.type == "cuda":
+        torch.cuda.synchronize()
+    start = time.perf_counter()
+    for _ in range(repetitions):
+        rollout_explicit(explicit, history, mask, 60, True)
+    if device.type == "cuda":
+        torch.cuda.synchronize()
+    explicit_time = time.perf_counter() - start
+    start = time.perf_counter()
+    for _ in range(repetitions):
+        rollout_single(single, history, mask, 60)
+    if device.type == "cuda":
+        torch.cuda.synchronize()
+    single_time = time.perf_counter() - start
+    batch_size = history.shape[0]
+    return {
+        "explicit_60step_ms_per_sample": (
+            1000.0 * explicit_time / repetitions / batch_size
+        ),
+        "single_60step_ms_per_sample": (
+            1000.0 * single_time / repetitions / batch_size
+        ),
+    }
+
+
+def create_synthetic_native(
+    destination: Path,
+    reference_metadata: Mapping[str, Any],
+    time_steps: int = 80,
+    height: int = 64,
+    width: int = 64,
+) -> None:
+    destination.mkdir(parents=True, exist_ok=True)
+    generator = np.random.default_rng(20261020 + len(destination.parts))
+    data = generator.normal(
+        0.0,
+        1.0,
+        (time_steps, len(VARIABLE_NAMES), height, width),
+    ).astype(np.float32)
+    np.save(destination / "scs_c0_data.npy", data)
+    np.save(
+        destination / "scs_c0_mask.npy",
+        np.ones((height, width), np.float32),
+    )
+    np.save(
+        destination / "scs_c0_variable_masks.npy",
+        np.ones((len(VARIABLE_NAMES), height, width), np.float32),
+    )
+    metadata = {
+        "variable_names": VARIABLE_NAMES,
+        "means": reference_metadata["means"],
+        "stds": reference_metadata["stds"],
+        "times_ns": (
+            np.datetime64("2023-07-10")
+            + np.arange(time_steps) * np.timedelta64(6, "h")
+        ).astype("datetime64[ns]").astype(np.int64).tolist(),
+        "latitude": np.linspace(0, 25, height).tolist(),
+        "longitude": np.linspace(99, 123, width).tolist(),
+        "shape": list(data.shape),
+        "native_resolution_degrees": 1 / 12,
+    }
+    atomic_json(metadata, destination / "scs_c0_metadata.json")
+    pd.DataFrame({
+        "variable": VARIABLE_NAMES,
+        "mean": metadata["means"],
+        "std": metadata["stds"],
+    }).to_csv(destination / "C0_data_audit.csv", index=False)
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        description="CIDM-v3 S3-A1 long-horizon objective repair"
+    )
+    parser.add_argument(
+        "--parent_zip",
+        default="/content/CIDM_v3_SCS_V3_S3_A0.zip",
+    )
+    parser.add_argument(
+        "--native_cache_dir",
+        default="/content/CIDM_v3_SCS_S2A2_NATIVE_1_12",
+    )
+    parser.add_argument(
+        "--parent_cache",
+        default="/content/CIDM_v3_SCS_S3A1_PARENT_CACHE",
+    )
+    parser.add_argument(
+        "--output_dir",
+        default="/content/CIDM_v3_SCS_V3_S3_A1",
+    )
+    parser.add_argument(
+        "--hf_repo_id",
+        default="wuff-mann/CIDM-v3-SCS-S2A0-Data",
+    )
+    parser.add_argument("--hf_token", default="")
+    parser.add_argument("--history", type=int, default=4)
+    parser.add_argument("--patch_size", type=int, default=48)
+    parser.add_argument("--max_horizon", type=int, default=60)
+    parser.add_argument("--train_samples", type=int, default=192)
+    parser.add_argument("--validation_samples", type=int, default=48)
+    parser.add_argument("--test_samples", type=int, default=64)
+    parser.add_argument("--train_seed", type=int, default=20261021)
+    parser.add_argument("--validation_seed", type=int, default=20261022)
+    parser.add_argument("--test_seed", type=int, default=20261010)
+    parser.add_argument("--batch_size", type=int, default=1)
+    parser.add_argument("--num_workers", type=int, default=0)
+    parser.add_argument("--epochs", type=int, default=6)
+    parser.add_argument("--accumulation", type=int, default=4)
+    parser.add_argument("--explicit_learning_rate", type=float, default=2e-5)
+    parser.add_argument("--single_learning_rate", type=float, default=3e-5)
+    parser.add_argument("--weight_decay", type=float, default=1e-4)
+    parser.add_argument("--grad_clip", type=float, default=1.0)
+    parser.add_argument("--gradient_weight", type=float, default=0.08)
+    parser.add_argument("--increment_weight", type=float, default=0.12)
+    parser.add_argument("--persistence_skill_weight", type=float, default=0.20)
+    parser.add_argument("--persistence_target_ratio", type=float, default=0.98)
+    parser.add_argument("--variance_weight", type=float, default=0.04)
+    parser.add_argument("--spectral_weight", type=float, default=0.04)
+    parser.add_argument("--wave_nonnegative_weight", type=float, default=0.02)
+    parser.add_argument("--direction_circle_weight", type=float, default=0.04)
+    parser.add_argument("--bootstrap_reps", type=int, default=1000)
+    parser.add_argument(
+        "--seeds",
+        default="20260902,20260903,20260904",
+    )
+    parser.add_argument("--synthetic_smoke", action="store_true")
+    return parser
+
+
+def main() -> None:
+    args = build_parser().parse_args()
+    seeds = [
+        int(value) for value in args.seeds.split(",") if value.strip()
+    ]
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    if not args.synthetic_smoke and device.type != "cuda":
+        raise RuntimeError("Formal S3-A1 requires CUDA.")
+    torch.set_float32_matmul_precision("highest")
+    if torch.cuda.is_available():
+        torch.backends.cuda.matmul.allow_tf32 = False
+        torch.backends.cudnn.allow_tf32 = False
+
+    output_dir = Path(args.output_dir)
+    shutil.rmtree(output_dir, ignore_errors=True)
+    for subdir in [
+        "audits",
+        "training",
+        "checkpoints",
+        "evaluation",
+        "figures",
+        "lineage",
+        "deployment",
+    ]:
+        (output_dir / subdir).mkdir(parents=True, exist_ok=True)
+
+    try:
+        stage(1, 9, "恢复S3-A0谱系与夏季/秋季原生缓存")
+        if args.synthetic_smoke:
+            if not Path(args.parent_zip).is_file():
+                raise FileNotFoundError(args.parent_zip)
+            asset_report = {
+                "synthetic_smoke": True,
+                "parent_zip_sha256": sha256_file(Path(args.parent_zip)),
+            }
+        else:
+            asset_report = ensure_assets(args)
+        atomic_json(
+            asset_report,
+            output_dir / "audits" / "S3A1_asset_audit.json",
+        )
+
+        stage(2, 9, "提取显式尺度与Single-State父检查点")
+        parent_cache = Path(args.parent_cache)
+        shutil.rmtree(parent_cache, ignore_errors=True)
+        assets = extract_parent_assets(
+            Path(args.parent_zip), parent_cache
+        )
+        reference_mean = np.asarray(
+            assets["metadata"]["means"], dtype=np.float32
+        )
+        reference_std = np.asarray(
+            assets["metadata"]["stds"], dtype=np.float32
+        )
+        atomic_json(
+            {
+                "s1_verdict": assets["s1_verdict"],
+                "s3a0_verdict": assets["s3_verdict"],
+                "architecture_policy": {
+                    "unchanged": True,
+                    "keep": [
+                        "explicit scale state",
+                        "shared scale-conditioned core",
+                        "multi-step recurrence",
+                        "Band Closure",
+                    ],
+                    "remain_off": [
+                        "future BER",
+                        "learned cross-scale flux",
+                        "slow memory closure",
+                        "vertical closure",
+                        "causal variance amplifier",
+                        "event router",
+                    ],
+                },
+            },
+            output_dir / "lineage" / "S3A1_parent_lineage.json",
+        )
+
+        if args.synthetic_smoke:
+            for season in ["summer", "autumn"]:
+                create_synthetic_native(
+                    Path(args.native_cache_dir) / season / "prepared",
+                    assets["metadata"],
+                    time_steps=max(args.max_horizon + args.history + 12, 80),
+                    height=64,
+                    width=64,
+                )
+
+        stage(3, 9, "构建夏季训练/验证与秋季独立测试")
+        loaders, datasets = make_loaders(
+            Path(args.native_cache_dir),
+            reference_mean,
+            reference_std,
+            args,
+        )
+        train_keys = set(datasets["train"].record_keys)
+        validation_keys = set(datasets["validation"].record_keys)
+        exact_overlap = len(train_keys & validation_keys)
+        atomic_json(
+            {
+                split: {
+                    "samples": len(dataset),
+                    "native_shape": list(dataset.data.shape),
+                    "unique_records": len(set(dataset.records)),
+                }
+                for split, dataset in datasets.items()
+            }
+            | {
+                "train_validation_exact_overlap": exact_overlap,
+                "train_horizon_schedule": horizon_schedule(args),
+                "normalization": (
+                    "season storage -> physical -> original S1-R3 training"
+                ),
+            },
+            output_dir / "audits" / "S3A1_split_audit.json",
+        )
+        if exact_overlap > 0:
+            raise RuntimeError(
+                f"Train/validation exact overlap: {exact_overlap}"
+            )
+
+        means = torch.as_tensor(reference_mean, device=device)
+        stds = torch.as_tensor(reference_std, device=device)
+
+        stage(4, 9, "同目标修复显式尺度与参数匹配Single-State")
+        repaired_models = {}
+        parent_models = {}
+        training_summary = []
+        for seed in seeds:
+            print(f"[seed {seed}] loading parents", flush=True)
+            parent_explicit = make_explicit(
+                assets["explicit_checkpoints"][seed], device
+            )
+            parent_single = make_single(
+                assets["single_checkpoints"][seed], device
+            )
+            repaired_explicit = copy.deepcopy(parent_explicit)
+            repaired_single = copy.deepcopy(parent_single)
+
+            repaired_explicit, explicit_record = train_model(
+                repaired_explicit,
+                "explicit",
+                seed,
+                loaders["train"],
+                loaders["validation"],
+                device,
+                means,
+                stds,
+                args,
+                output_dir,
+            )
+            repaired_single, single_record = train_model(
+                repaired_single,
+                "single",
+                seed,
+                loaders["train"],
+                loaders["validation"],
+                device,
+                means,
+                stds,
+                args,
+                output_dir,
+            )
+            repaired_models[seed] = {
+                "repaired_explicit": repaired_explicit,
+                "repaired_single": repaired_single,
+            }
+            parent_models[seed] = {
+                "parent_explicit": parent_explicit,
+                "parent_single": parent_single,
+            }
+            training_summary.extend([explicit_record, single_record])
+        pd.DataFrame(training_summary).to_csv(
+            output_dir / "S3A1_training_summary.csv", index=False
+        )
+
+        stage(5, 9, "秋季60步测试与严格样本审计")
+        metric_rows = []
+        sample_tables: Dict[Tuple[int, str], pd.DataFrame] = {}
+        runtime_rows = []
+        for seed in seeds:
+            models = {
+                **parent_models[seed],
+                **repaired_models[seed],
+            }
+            metrics, tables = evaluate_methods(
+                models,
+                loaders["test"],
+                device,
+                means,
+                stds,
+            )
+            for method, current in metrics.items():
+                metric_rows.append({
+                    "seed": seed,
+                    "method": method,
+                    **current,
+                })
+                table = tables[method]
+                table["seed"] = seed
+                sample_tables[(seed, method)] = table
+                table.to_csv(
+                    output_dir
+                    / "evaluation"
+                    / f"S3A1_samples_{method}_seed_{seed}.csv",
+                    index=False,
+                )
+            runtime = runtime_audit(
+                repaired_models[seed]["repaired_explicit"],
+                repaired_models[seed]["repaired_single"],
+                loaders["test"],
+                device,
+            )
+            runtime["seed"] = seed
+            runtime_rows.append(runtime)
+            if device.type == "cuda":
+                torch.cuda.empty_cache()
+
+        metric_table = pd.DataFrame(metric_rows)
+        metric_table.to_csv(
+            output_dir / "evaluation" / "S3A1_seed_metrics.csv",
+            index=False,
+        )
+        runtime_table = pd.DataFrame(runtime_rows)
+        runtime_table.to_csv(
+            output_dir / "S3A1_runtime.csv", index=False
+        )
+
+        stage(6, 9, "时间块Bootstrap与加权/等样本一致性")
+        comparisons = [
+            ("repaired_explicit_band", "repaired_single"),
+            ("repaired_explicit_band", "parent_explicit_band"),
+            ("repaired_explicit_band", "repaired_explicit_no_band"),
+            ("repaired_explicit_band", "persistence"),
+            ("repaired_single", "parent_single"),
+        ]
+        bootstrap_payload = {}
+        comparison_rows = []
+        for candidate, reference in comparisons:
+            for horizon in [12, 28, 60]:
+                result = time_block_bootstrap(
+                    [sample_tables[(seed, reference)] for seed in seeds],
+                    [sample_tables[(seed, candidate)] for seed in seeds],
+                    horizon,
+                    args.bootstrap_reps,
+                    seeds[0] + horizon + sum(map(ord, candidate + reference)),
+                )
+                key = f"{candidate}_vs_{reference}_h{horizon}"
+                bootstrap_payload[key] = result
+                comparison_rows.append({
+                    "candidate": candidate,
+                    "reference": reference,
+                    "horizon": horizon,
+                    "lead": HORIZON_LABELS[horizon],
+                    **result,
+                })
+        comparison_table = pd.DataFrame(comparison_rows)
+        comparison_table.to_csv(
+            output_dir / "S3A1_block_bootstrap_comparisons.csv",
+            index=False,
+        )
+        atomic_json(
+            bootstrap_payload,
+            output_dir / "paired_block_bootstrap.json",
+        )
+
+        summary_rows = []
+        for method in METHODS:
+            current = metric_table[
+                metric_table["method"] == method
+            ].set_index("seed")
+            for horizon in HORIZONS:
+                summary_rows.append({
+                    "method": method,
+                    "horizon": horizon,
+                    "lead": HORIZON_LABELS[horizon],
+                    "rmse": float(current[f"rmse_h{horizon}"].mean()),
+                    "variance_ratio": float(
+                        current[f"variance_ratio_h{horizon}"].mean()
+                    ),
+                    "gradient_rmse": float(
+                        current[f"gradient_rmse_h{horizon}"].mean()
+                    ),
+                    "wave_invalid_fraction": float(
+                        current[f"wave_invalid_fraction_h{horizon}"].mean()
+                    ),
+                    "direction_norm_error": float(
+                        current[f"direction_norm_error_h{horizon}"].mean()
+                    ),
+                    "finite": bool(current["finite"].all()),
+                    "max_abs": float(current["max_abs"].max()),
+                })
+        summary = pd.DataFrame(summary_rows)
+        summary.to_csv(
+            output_dir / "S3A1_long_rollout_summary.csv",
+            index=False,
+        )
+
+        stage(7, 9, "最终架构冻结判决")
+        mean_metrics = metric_table.groupby(
+            "method"
+        ).mean(numeric_only=True)
+
+        def gain(candidate: str, reference: str, horizon: int) -> float:
+            return 100.0 * (
+                mean_metrics.loc[reference, f"rmse_h{horizon}"]
+                - mean_metrics.loc[candidate, f"rmse_h{horizon}"]
+            ) / mean_metrics.loc[reference, f"rmse_h{horizon}"]
+
+        def block(candidate: str, reference: str, horizon: int) -> pd.Series:
+            return comparison_table[
+                (comparison_table.candidate == candidate)
+                & (comparison_table.reference == reference)
+                & (comparison_table.horizon == horizon)
+            ].iloc[0]
+
+        scale_vs_single_72 = gain(
+            "repaired_explicit_band", "repaired_single", 12
+        )
+        scale_vs_single_7d = gain(
+            "repaired_explicit_band", "repaired_single", 28
+        )
+        scale_vs_single_15d = gain(
+            "repaired_explicit_band", "repaired_single", 60
+        )
+        repair_gain_72 = gain(
+            "repaired_explicit_band", "parent_explicit_band", 12
+        )
+        repair_gain_7d = gain(
+            "repaired_explicit_band", "parent_explicit_band", 28
+        )
+        repair_gain_15d = gain(
+            "repaired_explicit_band", "parent_explicit_band", 60
+        )
+        band_gain_72 = gain(
+            "repaired_explicit_band", "repaired_explicit_no_band", 12
+        )
+        band_gain_7d = gain(
+            "repaired_explicit_band", "repaired_explicit_no_band", 28
+        )
+        band_gain_15d = gain(
+            "repaired_explicit_band", "repaired_explicit_no_band", 60
+        )
+        persistence_gap_72 = gain(
+            "repaired_explicit_band", "persistence", 12
+        )
+        persistence_gap_7d = gain(
+            "repaired_explicit_band", "persistence", 28
+        )
+        persistence_gap_15d = gain(
+            "repaired_explicit_band", "persistence", 60
+        )
+        parent_persistence_gap_7d = gain(
+            "parent_explicit_band", "persistence", 28
+        )
+        persistence_gap_closed_7d = (
+            persistence_gap_7d - parent_persistence_gap_7d
+        )
+
+        variance_7d = float(
+            mean_metrics.loc[
+                "repaired_explicit_band", "variance_ratio_h28"
+            ]
+        )
+        variance_15d = float(
+            mean_metrics.loc[
+                "repaired_explicit_band", "variance_ratio_h60"
+            ]
+        )
+        high_spectral_15d = float(
+            mean_metrics.loc[
+                "repaired_explicit_band", "spectral_high_ratio_h60"
+            ]
+        )
+        direction_error_15d = float(
+            mean_metrics.loc[
+                "repaired_explicit_band", "direction_norm_error_h60"
+            ]
+        )
+        wave_invalid_15d = float(
+            mean_metrics.loc[
+                "repaired_explicit_band", "wave_invalid_fraction_h60"
+            ]
+        )
+        finite = bool(
+            metric_table[
+                metric_table.method == "repaired_explicit_band"
+            ]["finite"].all()
+        )
+        runtime_ms = float(
+            runtime_table["explicit_60step_ms_per_sample"].mean()
+        )
+
+        block_scale_72 = block(
+            "repaired_explicit_band", "repaired_single", 12
+        )
+        block_scale_7d = block(
+            "repaired_explicit_band", "repaired_single", 28
+        )
+        block_scale_15d = block(
+            "repaired_explicit_band", "repaired_single", 60
+        )
+        block_repair_7d = block(
+            "repaired_explicit_band", "parent_explicit_band", 28
+        )
+        block_persistence_7d = block(
+            "repaired_explicit_band", "persistence", 28
+        )
+
+        checks = {
+            "same_architecture_no_new_module": True,
+            "persistent_optimizer_across_epochs": True,
+            "three_repaired_explicit_and_single_pairs": len(seeds) == 3,
+            "all_repaired_explicit_rollouts_finite": finite,
+            "repair_improves_parent_explicit_72h": repair_gain_72 > 0.0,
+            "repair_improves_parent_explicit_7d": repair_gain_7d > 0.0,
+            "repair_improves_parent_explicit_15d": repair_gain_15d > 0.0,
+            "repair_7d_block_bootstrap_positive": (
+                float(block_repair_7d.weighted_ci_high) < 0.0
+            ),
+            "explicit_beats_single_72h_ge_1pct": scale_vs_single_72 >= 1.0,
+            "explicit_beats_single_7d_ge_1pct": scale_vs_single_7d >= 1.0,
+            "explicit_15d_nonworse_than_single": scale_vs_single_15d >= 0.0,
+            "scale_72h_block_bootstrap_positive": (
+                float(block_scale_72.weighted_ci_high) < 0.0
+            ),
+            "scale_7d_block_bootstrap_positive": (
+                float(block_scale_7d.weighted_ci_high) < 0.0
+            ),
+            "scale_15d_equal_sample_majority_positive": (
+                float(block_scale_15d.fraction_samples_improved) >= 0.50
+            ),
+            "band_closure_72h_positive": band_gain_72 >= 0.2,
+            "band_closure_7d_nonnegative": band_gain_7d >= 0.0,
+            "band_closure_15d_nonnegative": band_gain_15d >= 0.0,
+            "persistence_gap_closed_7d_by_5pct_points": (
+                persistence_gap_closed_7d >= 5.0
+            ),
+            "repaired_7d_beats_persistence": persistence_gap_7d > 0.0,
+            "repaired_7d_persistence_block_positive": (
+                float(block_persistence_7d.weighted_ci_high) < 0.0
+            ),
+            "variance_ratio_7d_ge_0_50": variance_7d >= 0.50,
+            "variance_ratio_15d_ge_0_35": variance_15d >= 0.35,
+            "high_spectral_ratio_15d_0_5_to_1_5": (
+                0.50 <= high_spectral_15d <= 1.50
+            ),
+            "direction_norm_error_15d_lt_0_30": direction_error_15d < 0.30,
+            "wave_invalid_fraction_15d_lt_0_03": wave_invalid_15d < 0.03,
+            "60step_runtime_lt_1200ms": runtime_ms < 1200.0,
+            "all_metrics_finite": bool(
+                np.isfinite(
+                    metric_table.select_dtypes(
+                        include=[np.number]
+                    ).to_numpy()
+                ).all()
+            ),
+        }
+        passed = sum(bool(value) for value in checks.values())
+        architecture_critical = [
+            "all_repaired_explicit_rollouts_finite",
+            "repair_improves_parent_explicit_7d",
+            "repair_improves_parent_explicit_15d",
+            "explicit_beats_single_72h_ge_1pct",
+            "explicit_beats_single_7d_ge_1pct",
+            "explicit_15d_nonworse_than_single",
+            "band_closure_72h_positive",
+            "band_closure_7d_nonnegative",
+            "band_closure_15d_nonnegative",
+            "variance_ratio_7d_ge_0_50",
+        ]
+        product_readiness = [
+            "repaired_7d_beats_persistence",
+            "repaired_7d_persistence_block_positive",
+            "direction_norm_error_15d_lt_0_30",
+        ]
+
+        architecture_qualified = all(
+            checks[key] for key in architecture_critical
+        )
+        product_ready = architecture_qualified and all(
+            checks[key] for key in product_readiness
+        )
+
+        if product_ready and passed >= 23:
+            verdict_name = (
+                "V3_S3_A1_MINIMAL_SCALE_ARCHITECTURE_AND_TRAINING_OBJECTIVE_QUALIFIED"
+            )
+            recommendation = (
+                "Freeze CIDM-v3 and proceed to the medium-scale distributed "
+                "training-pipeline qualification. No architecture changes."
+            )
+        elif architecture_qualified:
+            verdict_name = (
+                "V3_S3_A1_MINIMAL_SCALE_ARCHITECTURE_QUALIFIED_PRODUCT_TRAINING_NOT_YET"
+            )
+            recommendation = (
+                "Freeze the architecture. Proceed to medium-scale multi-season "
+                "training qualification before formal product training."
+            )
+        elif finite and passed >= 17:
+            verdict_name = (
+                "V3_S3_A1_LONG_HORIZON_OBJECTIVE_PARTIALLY_QUALIFIED"
+            )
+            recommendation = (
+                "Keep the same architecture. Do not add modules. The next step "
+                "must be a multi-season medium-scale training qualification, not "
+                "another architecture experiment."
+            )
+        else:
+            verdict_name = (
+                "V3_S3_A1_LONG_HORIZON_OBJECTIVE_NOT_QUALIFIED"
+            )
+            recommendation = (
+                "Do not add modules. Reconsider whether the current explicit-scale "
+                "core offers enough value over the mature Single-State baseline."
+            )
+
+        aggregate = {
+            "scale_vs_single_72h_percent": scale_vs_single_72,
+            "scale_vs_single_7d_percent": scale_vs_single_7d,
+            "scale_vs_single_15d_percent": scale_vs_single_15d,
+            "repair_gain_72h_percent": repair_gain_72,
+            "repair_gain_7d_percent": repair_gain_7d,
+            "repair_gain_15d_percent": repair_gain_15d,
+            "band_gain_72h_percent": band_gain_72,
+            "band_gain_7d_percent": band_gain_7d,
+            "band_gain_15d_percent": band_gain_15d,
+            "repaired_vs_persistence_72h_percent": persistence_gap_72,
+            "repaired_vs_persistence_7d_percent": persistence_gap_7d,
+            "repaired_vs_persistence_15d_percent": persistence_gap_15d,
+            "persistence_gap_closed_7d_percentage_points": (
+                persistence_gap_closed_7d
+            ),
+            "variance_ratio_7d": variance_7d,
+            "variance_ratio_15d": variance_15d,
+            "high_spectral_ratio_15d": high_spectral_15d,
+            "direction_norm_error_15d": direction_error_15d,
+            "wave_invalid_fraction_15d": wave_invalid_15d,
+            "runtime_60step_ms": runtime_ms,
+            "architecture_qualified": architecture_qualified,
+            "product_ready": product_ready,
+        }
+        verdict = {
+            "automatic_verdict": verdict_name,
+            "passed": passed,
+            "total": len(checks),
+            "checks": checks,
+            "architecture_critical_checks": architecture_critical,
+            "product_readiness_checks": product_readiness,
+            "aggregate": aggregate,
+            "frozen_candidate": {
+                "modules": [
+                    "MultiScalePhysicalEncoder",
+                    "ExplicitScaleInformationState",
+                    "SharedScaleConditionedCIDMCore",
+                    "MultiStepRecurrence",
+                    "BandClosure",
+                    "MultiResolutionDecoder",
+                ],
+                "default_off": [
+                    "CrossScaleFlux",
+                    "FutureBER",
+                    "BoundaryBER",
+                    "VerticalBER",
+                    "SlowMemoryClosure",
+                    "VerticalOutputClosure",
+                    "CausalVarianceAmplifier",
+                    "EventRouter",
+                ],
+            },
+            "next_stage_recommendation": recommendation,
+        }
+        atomic_json(
+            aggregate,
+            output_dir / "S3A1_main_aggregate.json",
+        )
+        atomic_json(
+            verdict,
+            output_dir / "S3A1_verdict.json",
+        )
+
+        stage(8, 9, "图表与架构冻结合同")
+        plt.figure(figsize=(11, 6))
+        for method in METHODS:
+            current = summary[summary.method == method]
+            plt.plot(
+                current.horizon,
+                current.rmse,
+                marker="o",
+                label=method,
+            )
+        plt.xlabel("Rollout steps (6 h each)")
+        plt.ylabel("RMSE")
+        plt.legend()
+        plt.tight_layout()
+        plt.savefig(
+            output_dir / "figures" / "S3A1_RMSE_growth.png",
+            dpi=180,
+        )
+        plt.close()
+
+        plt.figure(figsize=(11, 6))
+        for method in [
+            "persistence",
+            "repaired_single",
+            "repaired_explicit_band",
+        ]:
+            current = summary[summary.method == method]
+            plt.plot(
+                current.horizon,
+                current.variance_ratio,
+                marker="o",
+                label=method,
+            )
+        plt.axhline(1.0, linewidth=1)
+        plt.xlabel("Rollout steps (6 h each)")
+        plt.ylabel("Variance ratio")
+        plt.legend()
+        plt.tight_layout()
+        plt.savefig(
+            output_dir / "figures" / "S3A1_variance_ratio.png",
+            dpi=180,
+        )
+        plt.close()
+
+        atomic_json(
+            {
+                "architecture_name": "CIDM-v3-SCS-Minimal",
+                "architecture_changed_in_S3A1": False,
+                "modules": [
+                    "MultiScalePhysicalEncoder",
+                    "ExplicitScaleInformationState",
+                    "SharedScaleConditionedCIDMCore",
+                    "MultiStepRecurrence",
+                    "BandClosure",
+                    "MultiResolutionDecoder",
+                ],
+                "training_contract": {
+                    "optimizer_state_persistent_across_epochs": True,
+                    "rollout_curriculum": horizon_schedule(args),
+                    "persistence_relative_skill": True,
+                    "increment_loss": True,
+                    "spectral_and_variance_losses": True,
+                    "wave_domain_losses": True,
+                },
+                "grid": "native 1/12 degree",
+                "base_time_step_hours": 6,
+                "maximum_training_horizon_steps": args.max_horizon,
+            },
+            output_dir
+            / "deployment"
+            / "CIDM_v3_candidate_architecture_and_training_contract.json",
+        )
+
+        safe_args = dict(vars(args))
+        safe_args["hf_token"] = "<redacted>"
+        atomic_json(
+            {
+                "experiment": "CIDM_v3_SCS_V3_S3_A1",
+                "created_at": pd.Timestamp.now().isoformat(),
+                "device": str(device),
+                "arguments": safe_args,
+                "security": "No plaintext access token is written.",
+            },
+            output_dir / "S3A1_manifest.json",
+        )
+
+        stage(9, 9, "结果打包")
+        package = output_dir.parent / f"{output_dir.name}.zip"
+        package.unlink(missing_ok=True)
+        with zipfile.ZipFile(package, "w", zipfile.ZIP_DEFLATED) as archive:
+            for path in output_dir.rglob("*"):
+                if path.is_file():
+                    archive.write(
+                        path,
+                        path.relative_to(output_dir.parent),
+                    )
+        print(
+            json.dumps(
+                verdict,
+                ensure_ascii=False,
+                indent=2,
+                default=json_default,
+            ),
+            flush=True,
+        )
+        print(f"[result] {package}", flush=True)
+    except Exception:
+        trace = traceback.format_exc()
+        (output_dir / "failure_traceback.txt").write_text(
+            trace, encoding="utf-8"
+        )
+        print(trace, flush=True)
+        raise
+
+
+if __name__ == "__main__":
+    main()