Upload Experiments/V3_S2_A1/cidm_v3_scs_s2_a1_real_input_ber.py with huggingface_hub

Experiments/V3_S2_A1/cidm_v3_scs_s2_a1_real_input_ber.py

@@ -0,0 +1,1982 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+CIDM-v3 SCS V3-S2-A1
+真实外部输入 BER、未来强迫因果性与方差恢复资格实验
+=====================================================
+
+父链：
+- S2-A0 内部状态冻结探针；
+- S2-A0 all_required 历史外部信息适配器；
+- S2-A0 四季 CMEMS + ERA5 prepared cache。
+
+本轮只训练零初始化的新 BER：
+- 未来大气强迫分支；
+- 未来域外海洋边界分支；
+- 当前垂向背景条件；
+- 来源可用性/不确定度门；
+- 有界变量组方差恢复闭合。
+
+严格区分：
+- oracle_future：真实未来再分析，表示信息上限；
+- degraded_future：加入时滞、噪声和不确定度，作为业务预报代理；
+- history_only：只使用当前及历史外部信息；
+- shuffled_future：打乱未来外部输入，执行因果反证。
+
+注意：
+本轮仍是 1/4° BER 架构资格，不是正式 1/12° 产品训练。
+"""
+from __future__ import annotations
+
+import argparse
+import copy
+import dataclasses
+import datetime as dt
+import io
+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
+
+
+WINDOWS = [
+    {"name": "winter", "role": "train"},
+    {"name": "spring", "role": "train"},
+    {"name": "summer", "role": "validation"},
+    {"name": "autumn", "role": "test"},
+]
+HORIZONS = [1, 4, 12]
+INTERNAL_VARIABLES = [
+    "sst", "sss", "ssh", "u_surface", "v_surface",
+    "u_100m", "v_100m", "temperature_100m", "salinity_100m",
+    "significant_wave_height", "peak_wave_period", "tm02",
+    "peak_wave_direction_sin", "peak_wave_direction_cos",
+    "wind_sea_significant_height", "primary_swell_significant_height",
+]
+SOURCE_VARIABLES = {
+    "atmosphere": [
+        "u10", "v10", "wind_speed", "tau_x", "tau_y", "msl",
+        "net_heat_flux", "freshwater_flux", "wind_stress_curl",
+    ],
+    "boundary": [
+        "boundary_normal_inflow", "boundary_ssh", "boundary_sst", "boundary_sss",
+        "boundary_u_surface", "boundary_v_surface",
+        "boundary_temperature_100m", "boundary_salinity_100m",
+        "boundary_u_100m", "boundary_v_100m",
+    ],
+    "vertical": [
+        "mld_temperature_proxy", "thermocline_depth_proxy", "ohc_0_200_proxy",
+        "temperature_0_100_difference", "salinity_0_100_difference",
+        "current_shear_0_100", "density_stratification_0_100",
+        "temperature_100_200_difference", "salinity_100_200_difference",
+        "current_shear_100_200",
+    ],
+    "tide": [
+        "tide_elevation", "tide_u", "tide_v",
+        "m2_sin", "m2_cos", "s2_sin", "s2_cos",
+        "k1_sin", "k1_cos", "o1_sin", "o1_cos",
+    ],
+    "river": ["river_discharge_map", "river_discharge_anomaly"],
+    "events": ["event_intensity", "event_confidence", "event_type_code"],
+}
+SOURCE_KEYS = list(SOURCE_VARIABLES)
+REQUIRED_SOURCES = ["atmosphere", "boundary", "vertical"]
+GROUPS = {
+    "surface_thermohaline": [0, 1, 2],
+    "currents": [3, 4, 5, 6],
+    "subsurface_thermohaline": [7, 8],
+    "waves": list(range(9, 16)),
+}
+
+
+def json_default(value: Any) -> Any:
+    if isinstance(value, Path):
+        return str(value)
+    if isinstance(value, (np.integer, np.floating, np.bool_)):
+        return value.item()
+    if isinstance(value, np.ndarray):
+        return value.tolist()
+    if isinstance(value, (pd.Timestamp, dt.datetime, dt.date)):
+        return pd.Timestamp(value).isoformat()
+    raise TypeError(type(value).__name__)
+
+
+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-S2-A1] 阶段 {index}/{total}：{title}", flush=True)
+
+
+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 ensure_hf_assets(args: argparse.Namespace) -> Dict[str, Any]:
+    """优先复用本地资产；缺失时从用户的 HF Dataset 仓库按文件下载。"""
+    cache = Path(args.cache_dir)
+    prepared = cache / "prepared"
+    prepared.mkdir(parents=True, exist_ok=True)
+    a0_zip = Path(args.a0_zip)
+    needed: List[Tuple[str, Path]] = [("CIDM_v3_SCS_V3_S2_A0.zip", a0_zip)]
+    for window in WINDOWS:
+        name = window["name"]
+        needed.extend([
+            (f"Cache/prepared/{name}_cmems.npz", prepared / f"{name}_cmems.npz"),
+            (
+                f"Cache/prepared/{name}_atmosphere_aligned.npz",
+                prepared / f"{name}_atmosphere_aligned.npz",
+            ),
+            (f"Cache/prepared/{name}_tide.npz", prepared / f"{name}_tide.npz"),
+            (f"Cache/prepared/{name}_river.npz", prepared / f"{name}_river.npz"),
+            (f"Cache/prepared/{name}_events.npz", prepared / f"{name}_events.npz"),
+        ])
+
+    missing = [(repo_path, local_path) for repo_path, local_path in needed if not local_path.is_file()]
+    report = {
+        "repo_id": args.hf_repo_id,
+        "requested": len(needed),
+        "already_local": len(needed) - len(missing),
+        "downloaded": [],
+    }
+    if missing:
+        if not args.hf_repo_id:
+            raise RuntimeError(
+                "Prepared cache or A0 result is missing and --hf_repo_id is empty."
+            )
+        from huggingface_hub import hf_hub_download
+        token = args.hf_token or os.environ.get("HF_TOKEN") or None
+        for repo_path, local_path in missing:
+            print(f"[HF download] {repo_path}", flush=True)
+            downloaded = Path(
+                hf_hub_download(
+                    repo_id=args.hf_repo_id,
+                    filename=repo_path,
+                    repo_type="dataset",
+                    token=token,
+                )
+            )
+            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)
+            report["downloaded"].append(repo_path)
+
+    for repo_path, local_path in needed:
+        if not local_path.is_file() or local_path.stat().st_size <= 128:
+            raise RuntimeError(f"Asset missing or invalid: {repo_path} -> {local_path}")
+    return report
+
+
+def extract_a0_assets(a0_zip: Path, work_dir: Path) -> Dict[str, Path]:
+    work_dir.mkdir(parents=True, exist_ok=True)
+    required = [
+        "CIDM_v3_SCS_V3_S2_A0/audits/S2A0_normalization_stats.npz",
+        "CIDM_v3_SCS_V3_S2_A0/S2A0_verdict.json",
+        "CIDM_v3_SCS_V3_S2_A0/S2A0_main_aggregate.json",
+    ]
+    for seed in [20260910, 20260911, 20260912]:
+        required.extend([
+            f"CIDM_v3_SCS_V3_S2_A0/checkpoints/baseline/seed_{seed}.pt",
+            f"CIDM_v3_SCS_V3_S2_A0/checkpoints/all_required/seed_{seed}.pt",
+        ])
+    with zipfile.ZipFile(a0_zip) as archive:
+        names = set(archive.namelist())
+        missing = [name for name in required if name not in names]
+        if missing:
+            raise RuntimeError(f"A0 result zip misses required entries: {missing}")
+        for name in required:
+            target = work_dir / name
+            if not target.is_file():
+                archive.extract(name, work_dir)
+    root = work_dir / "CIDM_v3_SCS_V3_S2_A0"
+    return {
+        "root": root,
+        "stats": root / "audits" / "S2A0_normalization_stats.npz",
+        "verdict": root / "S2A0_verdict.json",
+        "aggregate": root / "S2A0_main_aggregate.json",
+    }
+
+
+@dataclasses.dataclass
+class WindowData:
+    name: str
+    role: str
+    time: np.ndarray
+    latitude: np.ndarray
+    longitude: np.ndarray
+    internal: np.ndarray
+    ocean_mask: np.ndarray
+    sources: Dict[str, np.ndarray]
+    actual: Dict[str, bool]
+
+
+def load_window(cache: Path, spec: Mapping[str, str]) -> WindowData:
+    name = spec["name"]
+    prepared = cache / "prepared"
+    cmems = np.load(prepared / f"{name}_cmems.npz")
+    atmosphere = np.load(prepared / f"{name}_atmosphere_aligned.npz")
+    tide = np.load(prepared / f"{name}_tide.npz")
+    river = np.load(prepared / f"{name}_river.npz")
+    events = np.load(prepared / f"{name}_events.npz")
+
+    arrays = {
+        "atmosphere": atmosphere["atmosphere"].astype(np.float32),
+        "boundary": cmems["boundary"].astype(np.float32),
+        "vertical": cmems["vertical"].astype(np.float32),
+        "tide": tide["tide"].astype(np.float32),
+        "river": river["river"].astype(np.float32),
+        "events": events["events"].astype(np.float32),
+    }
+    lengths = {key: value.shape[0] for key, value in arrays.items()}
+    lengths["internal"] = cmems["internal"].shape[0]
+    if len(set(lengths.values())) != 1:
+        raise RuntimeError(f"Window {name} time-length mismatch: {lengths}")
+    return WindowData(
+        name=name,
+        role=spec["role"],
+        time=cmems["time"].astype("datetime64[ns]"),
+        latitude=cmems["latitude"].astype(np.float32),
+        longitude=cmems["longitude"].astype(np.float32),
+        internal=cmems["internal"].astype(np.float32),
+        ocean_mask=cmems["ocean_mask"].astype(np.float32),
+        sources=arrays,
+        actual={
+            "atmosphere": True,
+            "boundary": True,
+            "vertical": True,
+            "tide": bool(int(tide["actual_spatial_tide"][0])),
+            "river": bool(int(river["available"][0])),
+            "events": bool(int(events["available"][0])),
+        },
+    )
+
+
+class SequenceIndex:
+    def __init__(self, windows: Sequence[WindowData], history: int):
+        self.windows = list(windows)
+        self.history = int(history)
+        self.records: List[Tuple[int, int]] = []
+        max_h = max(HORIZONS)
+        for wi, window in enumerate(self.windows):
+            for t in range(self.history - 1, len(window.time) - max_h):
+                self.records.append((wi, t))
+
+
+class A1Dataset(Dataset):
+    def __init__(
+        self,
+        index: SequenceIndex,
+        internal_mean: np.ndarray,
+        internal_std: np.ndarray,
+        source_stats: Mapping[str, Tuple[np.ndarray, np.ndarray]],
+    ):
+        self.index = index
+        self.internal_mean = internal_mean
+        self.internal_std = internal_std
+        self.source_stats = source_stats
+
+    def __len__(self) -> int:
+        return len(self.index.records)
+
+    @staticmethod
+    def norm(value: np.ndarray, mean: np.ndarray, std: np.ndarray) -> np.ndarray:
+        return (
+            np.nan_to_num(value, nan=0.0)
+            - mean[None, :, None, None]
+        ) / std[None, :, None, None]
+
+    def __getitem__(self, item: int) -> Dict[str, torch.Tensor]:
+        wi, t = self.index.records[item]
+        window = self.index.windows[wi]
+        h = self.index.history
+
+        internal_history = self.norm(
+            window.internal[t - h + 1:t + 1],
+            self.internal_mean,
+            self.internal_std,
+        )
+        targets = np.stack(
+            [
+                (window.internal[t + horizon] - self.internal_mean[:, None, None])
+                / self.internal_std[:, None, None]
+                for horizon in HORIZONS
+            ],
+            axis=0,
+        ).astype(np.float32)
+
+        result: Dict[str, torch.Tensor] = {
+            "internal": torch.from_numpy(
+                internal_history.reshape(-1, *internal_history.shape[-2:]).astype(np.float32)
+            ),
+            "target": torch.from_numpy(targets),
+            "mask": torch.from_numpy(window.ocean_mask[t].astype(np.float32)),
+            "sample_index": torch.tensor(item, dtype=torch.long),
+            "time_ns": torch.tensor(
+                window.time[t].astype("datetime64[ns]").astype(np.int64),
+                dtype=torch.long,
+            ),
+        }
+
+        for source, values in window.sources.items():
+            mean, std = self.source_stats[source]
+            history = self.norm(values[t - h + 1:t + 1], mean, std).astype(np.float32)
+            actual = 1.0 if window.actual[source] else 0.0
+            uncertainty = (
+                0.10 if source in REQUIRED_SOURCES
+                else (0.25 if actual else 1.0)
+            )
+            availability = np.full(
+                (h, 1, *history.shape[-2:]), actual, dtype=np.float32
+            )
+            uncertainty_map = np.full(
+                (h, 1, *history.shape[-2:]), uncertainty, dtype=np.float32
+            )
+            parent_source = np.concatenate(
+                [history, availability, uncertainty_map], axis=1
+            )
+            result[f"parent_{source}"] = torch.from_numpy(
+                parent_source.reshape(-1, *history.shape[-2:]).astype(np.float32)
+            )
+
+        # Future external trajectories use t..t+12. Vertical future truth is not used.
+        for source in ["atmosphere", "boundary"]:
+            mean, std = self.source_stats[source]
+            future = self.norm(
+                window.sources[source][t:t + max(HORIZONS) + 1],
+                mean,
+                std,
+            ).astype(np.float32)
+            result[f"future_{source}"] = torch.from_numpy(future)
+
+        mean, std = self.source_stats["vertical"]
+        current_vertical = (
+            window.sources["vertical"][t] - mean[:, None, None]
+        ) / std[:, None, None]
+        result["current_vertical"] = torch.from_numpy(
+            np.nan_to_num(current_vertical).astype(np.float32)
+        )
+        return result
+
+
+class DepthwiseBlock(nn.Module):
+    def __init__(self, channels: int):
+        super().__init__()
+        self.norm = nn.GroupNorm(1, channels)
+        self.dw = nn.Conv2d(channels, channels, 3, padding=1, groups=channels)
+        self.pw1 = nn.Conv2d(channels, channels * 2, 1)
+        self.pw2 = nn.Conv2d(channels * 2, channels, 1)
+        nn.init.zeros_(self.pw2.weight)
+        nn.init.zeros_(self.pw2.bias)
+
+    def forward(self, value: torch.Tensor) -> torch.Tensor:
+        update = self.dw(F.silu(self.norm(value)))
+        update = self.pw2(F.silu(self.pw1(update)))
+        return value + update
+
+
+class InternalProbe(nn.Module):
+    def __init__(self, history: int = 4, channels: int = 16,
+                 hidden: int = 48, horizons: int = 3):
+        super().__init__()
+        self.horizons = horizons
+        self.channels = channels
+        self.stem = nn.Conv2d(history * channels, hidden, 3, padding=1)
+        self.blocks = nn.Sequential(*[DepthwiseBlock(hidden) for _ in range(3)])
+        self.head = nn.Conv2d(hidden, horizons * channels, 1)
+
+    def forward_features(self, value: torch.Tensor) -> torch.Tensor:
+        return self.blocks(self.stem(value))
+
+    def forward(self, value: torch.Tensor) -> Tuple[torch.Tensor, torch.Tensor]:
+        features = self.forward_features(value)
+        prediction = self.head(features)
+        b, _, h, w = prediction.shape
+        return (
+            prediction.reshape(b, self.horizons, self.channels, h, w),
+            features,
+        )
+
+
+class SourceBranch(nn.Module):
+    def __init__(self, in_channels: int, out_channels: int):
+        super().__init__()
+        self.net = nn.Sequential(
+            nn.Conv2d(in_channels, out_channels, 1),
+            nn.GroupNorm(1, out_channels),
+            nn.SiLU(),
+            nn.Conv2d(
+                out_channels, out_channels, 3,
+                padding=1, groups=out_channels,
+            ),
+            nn.Conv2d(out_channels, out_channels, 1),
+            nn.SiLU(),
+        )
+
+    def forward(self, value: torch.Tensor) -> torch.Tensor:
+        return self.net(value)
+
+
+class A0ExternalResidualAdapter(nn.Module):
+    """Exact S2-A0 adapter reconstruction."""
+    def __init__(
+        self,
+        source_channels: Mapping[str, int],
+        history: int = 4,
+        internal_hidden: int = 48,
+        branch_hidden: int = 16,
+        channels: int = 16,
+        horizons: int = 3,
+    ):
+        super().__init__()
+        self.source_keys = list(source_channels)
+        self.branches = nn.ModuleDict({
+            key: SourceBranch(history * value, branch_hidden)
+            for key, value in source_channels.items()
+        })
+        fusion_in = internal_hidden + branch_hidden * len(self.source_keys)
+        self.fusion = nn.Sequential(
+            nn.Conv2d(fusion_in, internal_hidden, 1),
+            DepthwiseBlock(internal_hidden),
+            DepthwiseBlock(internal_hidden),
+        )
+        self.head = nn.Conv2d(internal_hidden, horizons * channels, 1)
+        self.ratio_logit = nn.Parameter(torch.tensor(-1.5))
+        self.channels = channels
+        self.horizons = horizons
+
+    def forward(
+        self,
+        internal_features: torch.Tensor,
+        sources: Mapping[str, torch.Tensor],
+        enabled: Sequence[str],
+    ) -> Tuple[torch.Tensor, Dict[str, torch.Tensor]]:
+        enabled_set = set(enabled)
+        values = []
+        energies: Dict[str, torch.Tensor] = {}
+        for key in self.source_keys:
+            feature = self.branches[key](sources[key])
+            if key not in enabled_set:
+                feature = torch.zeros_like(feature)
+            values.append(feature)
+            energies[key] = feature.square().mean().sqrt()
+        fused = self.fusion(torch.cat([internal_features] + values, dim=1))
+        raw = self.head(fused)
+        cap = 0.02 + 0.48 * torch.sigmoid(self.ratio_logit)
+        update = cap * torch.tanh(raw)
+        b, _, h, w = update.shape
+        return (
+            update.reshape(b, self.horizons, self.channels, h, w),
+            {"adapter_cap": cap, **{f"{key}_energy": value for key, value in energies.items()}},
+        )
+
+
+class FrozenA0Parent(nn.Module):
+    def __init__(self, baseline: InternalProbe, adapter: A0ExternalResidualAdapter):
+        super().__init__()
+        self.baseline = baseline
+        self.adapter = adapter
+        for parameter in self.parameters():
+            parameter.requires_grad = False
+
+    def forward(
+        self,
+        internal: torch.Tensor,
+        parent_sources: Mapping[str, torch.Tensor],
+    ) -> Tuple[torch.Tensor, torch.Tensor, Dict[str, torch.Tensor]]:
+        base, features = self.baseline(internal)
+        update, diagnostics = self.adapter(
+            features, parent_sources, REQUIRED_SOURCES
+        )
+        return base + update, features, {"a0_update": update, **diagnostics}
+
+
+class TemporalSourceEncoder(nn.Module):
+    def __init__(self, source_channels: int, hidden: int):
+        super().__init__()
+        self.hidden = hidden
+        self.stem = nn.Sequential(
+            nn.Conv2d(source_channels + 2, hidden, 1),
+            nn.GroupNorm(1, hidden),
+            nn.SiLU(),
+            DepthwiseBlock(hidden),
+        )
+        self.temporal_logits = nn.Parameter(torch.zeros(len(HORIZONS), max(HORIZONS) + 1))
+
+    def forward(
+        self,
+        sequence: torch.Tensor,
+        availability: torch.Tensor,
+        uncertainty: torch.Tensor,
+    ) -> torch.Tensor:
+        # sequence [B,T,C,H,W]
+        b, t, _, h, w = sequence.shape
+        availability_map = availability[:, None, None, None, None].expand(
+            b, t, 1, h, w
+        )
+        uncertainty_map = uncertainty[:, None, None, None, None].expand(
+            b, t, 1, h, w
+        )
+        value = torch.cat([sequence, availability_map, uncertainty_map], dim=2)
+        encoded = self.stem(value.reshape(b * t, value.shape[2], h, w))
+        encoded = encoded.reshape(b, t, self.hidden, h, w)
+
+        outputs = []
+        for hi, horizon in enumerate(HORIZONS):
+            allowed = min(horizon + 1, t)
+            weights = torch.softmax(self.temporal_logits[hi, :allowed], dim=0)
+            outputs.append(
+                (encoded[:, :allowed] * weights[None, :, None, None, None]).sum(dim=1)
+            )
+        return torch.stack(outputs, dim=1)
+
+
+class HorizonFusionHead(nn.Module):
+    def __init__(self, input_channels: int, hidden: int, output_channels: int):
+        super().__init__()
+        self.net = nn.Sequential(
+            nn.Conv2d(input_channels, hidden, 1),
+            nn.GroupNorm(1, hidden),
+            nn.SiLU(),
+            DepthwiseBlock(hidden),
+            nn.Conv2d(hidden, output_channels, 1),
+        )
+        nn.init.zeros_(self.net[-1].weight)
+        nn.init.zeros_(self.net[-1].bias)
+
+    def forward(self, value: torch.Tensor) -> torch.Tensor:
+        b, horizon_count, c, h, w = value.shape
+        output = self.net(value.reshape(b * horizon_count, c, h, w))
+        return output.reshape(b, horizon_count, output.shape[1], h, w)
+
+
+class OpenSystemBER(nn.Module):
+    def __init__(
+        self,
+        parent: FrozenA0Parent,
+        internal_hidden: int = 48,
+        source_hidden: int = 24,
+        fusion_hidden: int = 48,
+    ):
+        super().__init__()
+        self.parent = parent
+        self.atmosphere_encoder = TemporalSourceEncoder(9, source_hidden)
+        self.boundary_encoder = TemporalSourceEncoder(10, source_hidden)
+        self.vertical_encoder = nn.Sequential(
+            nn.Conv2d(10, source_hidden, 1),
+            nn.GroupNorm(1, source_hidden),
+            nn.SiLU(),
+            DepthwiseBlock(source_hidden),
+        )
+
+        source_input = internal_hidden + source_hidden * 2
+        self.atmosphere_head = HorizonFusionHead(
+            source_input, fusion_hidden, len(INTERNAL_VARIABLES)
+        )
+        self.boundary_head = HorizonFusionHead(
+            source_input, fusion_hidden, len(INTERNAL_VARIABLES)
+        )
+        self.vertical_head = HorizonFusionHead(
+            internal_hidden + source_hidden,
+            fusion_hidden,
+            len(INTERNAL_VARIABLES),
+        )
+        interaction_input = internal_hidden + source_hidden * 3
+        self.interaction_head = HorizonFusionHead(
+            interaction_input, fusion_hidden, len(INTERNAL_VARIABLES)
+        )
+
+        gate_input = internal_hidden + source_hidden * 3 + 4
+        self.gate_mlp = nn.Sequential(
+            nn.Linear(gate_input, fusion_hidden),
+            nn.SiLU(),
+            nn.Linear(fusion_hidden, len(HORIZONS) * 4),
+        )
+        nn.init.zeros_(self.gate_mlp[-1].weight)
+        nn.init.constant_(self.gate_mlp[-1].bias, -1.5)
+
+        self.cap_logits = nn.Parameter(torch.full((len(HORIZONS),), -2.0))
+        self.variance_mlp = nn.Sequential(
+            nn.Linear(gate_input, fusion_hidden),
+            nn.SiLU(),
+            nn.Linear(fusion_hidden, len(HORIZONS) * len(GROUPS)),
+        )
+        nn.init.zeros_(self.variance_mlp[-1].weight)
+        nn.init.zeros_(self.variance_mlp[-1].bias)
+
+    @staticmethod
+    def edge_support(height: int, width: int, device: torch.device,
+                     dtype: torch.dtype) -> torch.Tensor:
+        y = torch.linspace(0, 1, height, device=device, dtype=dtype)
+        x = torch.linspace(0, 1, width, device=device, dtype=dtype)
+        yy, xx = torch.meshgrid(y, x, indexing="ij")
+        distance = torch.minimum(
+            torch.minimum(xx, 1 - xx),
+            torch.minimum(yy, 1 - yy),
+        )
+        support = torch.exp(-distance / 0.09)
+        return support[None, None, None]
+
+    @staticmethod
+    def apply_variance_gain(
+        prediction: torch.Tensor,
+        mask: torch.Tensor,
+        log_gain: torch.Tensor,
+    ) -> torch.Tensor:
+        # prediction [B,H,C,Y,X], log_gain [B,H,G]
+        expanded_mask = mask[:, None]
+        denominator = expanded_mask.sum(dim=(-2, -1), keepdim=True).clamp_min(1.0)
+        mean = (prediction * expanded_mask).sum(
+            dim=(-2, -1), keepdim=True
+        ) / denominator
+        anomaly = prediction - mean
+        channel_gain = torch.zeros(
+            prediction.shape[:3], device=prediction.device, dtype=prediction.dtype
+        )
+        for gi, indices in enumerate(GROUPS.values()):
+            channel_gain[:, :, indices] = log_gain[:, :, gi:gi + 1]
+        return mean + torch.exp(channel_gain[:, :, :, None, None]) * anomaly
+
+    def forward(
+        self,
+        internal: torch.Tensor,
+        parent_sources: Mapping[str, torch.Tensor],
+        future_atmosphere: torch.Tensor,
+        future_boundary: torch.Tensor,
+        current_vertical: torch.Tensor,
+        mask: torch.Tensor,
+        atmosphere_quality: torch.Tensor,
+        boundary_quality: torch.Tensor,
+        enable_atmosphere: bool = True,
+        enable_boundary: bool = True,
+        enable_vertical: bool = True,
+        enable_variance: bool = True,
+        disable_ber: bool = False,
+    ) -> Tuple[torch.Tensor, Dict[str, torch.Tensor]]:
+        with torch.no_grad():
+            parent_prediction, internal_features, parent_diag = self.parent(
+                internal, parent_sources
+            )
+
+        b, _, h, w = internal_features.shape
+        atm_available = torch.ones(b, device=internal.device)
+        bnd_available = torch.ones(b, device=internal.device)
+        atm_uncertainty = 1.0 - atmosphere_quality
+        bnd_uncertainty = 1.0 - boundary_quality
+
+        atmosphere = self.atmosphere_encoder(
+            future_atmosphere, atm_available, atm_uncertainty
+        )
+        boundary = self.boundary_encoder(
+            future_boundary, bnd_available, bnd_uncertainty
+        )
+        vertical = self.vertical_encoder(current_vertical)
+        vertical_h = vertical[:, None].expand(-1, len(HORIZONS), -1, -1, -1)
+        internal_h = internal_features[:, None].expand(
+            -1, len(HORIZONS), -1, -1, -1
+        )
+
+        if not enable_atmosphere:
+            atmosphere = torch.zeros_like(atmosphere)
+        if not enable_boundary:
+            boundary = torch.zeros_like(boundary)
+        if not enable_vertical:
+            vertical_h = torch.zeros_like(vertical_h)
+            vertical_pool = torch.zeros_like(vertical)
+        else:
+            vertical_pool = vertical
+
+        atm_input = torch.cat([internal_h, atmosphere, vertical_h], dim=2)
+        bnd_input = torch.cat([internal_h, boundary, vertical_h], dim=2)
+        interaction_input = torch.cat(
+            [internal_h, atmosphere, boundary, vertical_h], dim=2
+        )
+        atm_update = self.atmosphere_head(atm_input)
+        bnd_update = self.boundary_head(bnd_input)
+        bnd_update = bnd_update * self.edge_support(
+            h, w, internal.device, internal.dtype
+        )
+        vertical_update = self.vertical_head(
+            torch.cat([internal_h, vertical_h], dim=2)
+        )
+        interaction_update = self.interaction_head(interaction_input)
+
+        pooled = torch.cat([
+            internal_features.mean(dim=(-2, -1)),
+            atmosphere.mean(dim=(1, -2, -1)),
+            boundary.mean(dim=(1, -2, -1)),
+            vertical_pool.mean(dim=(-2, -1)),
+            atmosphere_quality[:, None],
+            boundary_quality[:, None],
+            (1.0 - atmosphere_quality)[:, None],
+            (1.0 - boundary_quality)[:, None],
+        ], dim=1)
+        raw_gates = torch.sigmoid(
+            self.gate_mlp(pooled).reshape(b, len(HORIZONS), 4)
+        )
+        quality_scale = torch.stack([
+            atmosphere_quality,
+            boundary_quality,
+            torch.full_like(atmosphere_quality, 0.90 if enable_vertical else 0.0),
+            torch.minimum(atmosphere_quality, boundary_quality),
+        ], dim=1)[:, None, :]
+        gates = raw_gates * quality_scale
+
+        caps = 0.01 + 0.24 * torch.sigmoid(self.cap_logits)
+        raw_update = (
+            gates[:, :, 0, None, None, None] * atm_update
+            + gates[:, :, 1, None, None, None] * bnd_update
+            + gates[:, :, 2, None, None, None] * vertical_update
+            + gates[:, :, 3, None, None, None] * interaction_update
+        )
+        update = caps[None, :, None, None, None] * torch.tanh(raw_update)
+
+        log_gain = 0.15 * torch.tanh(
+            self.variance_mlp(pooled).reshape(
+                b, len(HORIZONS), len(GROUPS)
+            )
+        )
+        prediction = parent_prediction + update
+        if enable_variance:
+            prediction = self.apply_variance_gain(prediction, mask, log_gain)
+        else:
+            log_gain = torch.zeros_like(log_gain)
+
+        if disable_ber:
+            prediction = parent_prediction
+            update = torch.zeros_like(update)
+            log_gain = torch.zeros_like(log_gain)
+
+        diagnostics: Dict[str, torch.Tensor] = {
+            "parent_prediction": parent_prediction,
+            "update": update,
+            "atm_update": atm_update,
+            "boundary_update": bnd_update,
+            "vertical_update": vertical_update,
+            "interaction_update": interaction_update,
+            "gates": gates,
+            "caps": caps,
+            "log_gain": log_gain,
+            **parent_diag,
+        }
+        return prediction, diagnostics
+
+
+def load_parent(
+    assets_root: Path,
+    seed: int,
+    device: torch.device,
+) -> FrozenA0Parent:
+    baseline = InternalProbe()
+    source_channels = {
+        key: len(SOURCE_VARIABLES[key]) + 2 for key in SOURCE_KEYS
+    }
+    adapter = A0ExternalResidualAdapter(source_channels)
+    baseline_ckpt = torch.load(
+        assets_root / "checkpoints" / "baseline" / f"seed_{seed}.pt",
+        map_location="cpu",
+        weights_only=False,
+    )
+    adapter_ckpt = torch.load(
+        assets_root / "checkpoints" / "all_required" / f"seed_{seed}.pt",
+        map_location="cpu",
+        weights_only=False,
+    )
+    baseline.load_state_dict(baseline_ckpt["model_state"], strict=True)
+    adapter.load_state_dict(adapter_ckpt["adapter_state"], strict=True)
+    parent = FrozenA0Parent(baseline, adapter).to(device)
+    parent.eval()
+    return parent
+
+
+def load_stats(path: Path) -> Tuple[np.ndarray, np.ndarray, Dict[str, Tuple[np.ndarray, np.ndarray]]]:
+    with np.load(path) as stats:
+        internal_mean = stats["internal_mean"].astype(np.float32)
+        internal_std = stats["internal_std"].astype(np.float32)
+        source_stats = {
+            key: (
+                stats[f"{key}_mean"].astype(np.float32),
+                stats[f"{key}_std"].astype(np.float32),
+            )
+            for key in SOURCE_KEYS
+        }
+    return internal_mean, internal_std, source_stats
+
+
+def build_loaders(
+    windows: Sequence[WindowData],
+    stats_path: Path,
+    args: argparse.Namespace,
+) -> Tuple[Dict[str, DataLoader], Dict[str, Any]]:
+    internal_mean, internal_std, source_stats = load_stats(stats_path)
+    loaders: Dict[str, DataLoader] = {}
+    split_meta: Dict[str, Any] = {}
+    for role in ["train", "validation", "test"]:
+        selected = [window for window in windows if window.role == role]
+        index = SequenceIndex(selected, args.history)
+        dataset = A1Dataset(index, internal_mean, internal_std, source_stats)
+        loaders[role] = DataLoader(
+            dataset,
+            batch_size=args.batch_size,
+            shuffle=(role == "train"),
+            num_workers=args.num_workers,
+            pin_memory=torch.cuda.is_available(),
+            drop_last=(role == "train" and len(dataset) >= args.batch_size),
+        )
+        split_meta[role] = {
+            "windows": [window.name for window in selected],
+            "samples": len(dataset),
+        }
+    return loaders, split_meta
+
+
+def batch_to_device(
+    batch: Mapping[str, torch.Tensor],
+    device: torch.device,
+) -> Dict[str, torch.Tensor]:
+    return {
+        key: value.to(device, non_blocking=True)
+        if torch.is_tensor(value) else value
+        for key, value in batch.items()
+    }
+
+
+def parent_sources(batch: Mapping[str, torch.Tensor]) -> Dict[str, torch.Tensor]:
+    return {key: batch[f"parent_{key}"] for key in SOURCE_KEYS}
+
+
+def degrade_future(
+    atmosphere: torch.Tensor,
+    boundary: torch.Tensor,
+    mode: str,
+    seed: int,
+) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor]:
+    b = atmosphere.shape[0]
+    device = atmosphere.device
+    dtype = atmosphere.dtype
+    if mode == "oracle":
+        return (
+            atmosphere,
+            boundary,
+            torch.full((b,), 0.95, device=device, dtype=dtype),
+            torch.full((b,), 0.95, device=device, dtype=dtype),
+        )
+    if mode == "history":
+        return (
+            atmosphere[:, :1].expand_as(atmosphere),
+            boundary[:, :1].expand_as(boundary),
+            torch.full((b,), 0.45, device=device, dtype=dtype),
+            torch.full((b,), 0.45, device=device, dtype=dtype),
+        )
+    if mode == "shuffled":
+        if b > 1:
+            order = torch.roll(torch.arange(b, device=device), shifts=1)
+            atmosphere = atmosphere[order]
+            boundary = boundary[order]
+        return (
+            atmosphere,
+            boundary,
+            torch.full((b,), 0.70, device=device, dtype=dtype),
+            torch.full((b,), 0.65, device=device, dtype=dtype),
+        )
+    if mode not in {"degraded", "train"}:
+        raise ValueError(mode)
+
+    # One-step lag: future forecast is not granted perfect phase.
+    atmosphere_lagged = torch.cat(
+        [atmosphere[:, :1], atmosphere[:, :-1]], dim=1
+    )
+    boundary_lagged = torch.cat(
+        [boundary[:, :1], boundary[:, :-1]], dim=1
+    )
+    generator = torch.Generator(device=device)
+    generator.manual_seed(int(seed))
+    atm_noise = torch.randn(
+        atmosphere_lagged.shape, generator=generator,
+        device=device, dtype=dtype,
+    ) * 0.08
+    bnd_noise = torch.randn(
+        boundary_lagged.shape, generator=generator,
+        device=device, dtype=dtype,
+    ) * 0.06
+    atmosphere_lagged = atmosphere_lagged + atm_noise
+    boundary_lagged = boundary_lagged + bnd_noise
+    if mode == "train":
+        # Training-only source dropout. Availability is represented through quality.
+        if random.random() < 0.10:
+            atmosphere_lagged = torch.zeros_like(atmosphere_lagged)
+            atm_quality = 0.20
+        else:
+            atm_quality = 0.78
+        if random.random() < 0.10:
+            boundary_lagged = torch.zeros_like(boundary_lagged)
+            bnd_quality = 0.20
+        else:
+            bnd_quality = 0.72
+    else:
+        atm_quality, bnd_quality = 0.78, 0.72
+    return (
+        atmosphere_lagged,
+        boundary_lagged,
+        torch.full((b,), atm_quality, device=device, dtype=dtype),
+        torch.full((b,), bnd_quality, device=device, dtype=dtype),
+    )
+
+
+def masked_mse(
+    prediction: torch.Tensor,
+    target: torch.Tensor,
+    mask: torch.Tensor,
+) -> torch.Tensor:
+    expanded = mask[:, None].expand_as(prediction)
+    return (
+        ((prediction - target).square() * expanded).sum()
+        / expanded.sum().clamp_min(1.0)
+    )
+
+
+def 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, :]
+    mx = mx[:, None].expand_as(px)
+    my = my[:, None].expand_as(py)
+    return (
+        ((px - tx).square() * mx).sum() / mx.sum().clamp_min(1.0)
+        + ((py - ty).square() * my).sum() / my.sum().clamp_min(1.0)
+    )
+
+
+def group_variance_loss(
+    prediction: torch.Tensor,
+    target: torch.Tensor,
+    mask: torch.Tensor,
+) -> torch.Tensor:
+    """Match spatial anomaly variance per horizon and physical variable group."""
+    losses = []
+    horizon_weights = [0.2, 0.4, 1.0]
+    spatial_mask = mask  # [B,1,Y,X]
+    denominator = spatial_mask.sum(
+        dim=(-2, -1), keepdim=True
+    ).clamp_min(1.0)
+    for hi, weight in enumerate(horizon_weights):
+        for indices in GROUPS.values():
+            pred_group = prediction[:, hi, indices]  # [B,G,Y,X]
+            target_group = target[:, hi, indices]
+            pred_mean = (
+                (pred_group * spatial_mask).sum(
+                    dim=(-2, -1), keepdim=True
+                ) / denominator
+            )
+            target_mean = (
+                (target_group * spatial_mask).sum(
+                    dim=(-2, -1), keepdim=True
+                ) / denominator
+            )
+            pred_variance = (
+                ((pred_group - pred_mean).square() * spatial_mask)
+                .sum(dim=(-2, -1))
+                / denominator.squeeze(-1).squeeze(-1)
+            )
+            target_variance = (
+                ((target_group - target_mean).square() * spatial_mask)
+                .sum(dim=(-2, -1))
+                / denominator.squeeze(-1).squeeze(-1)
+            )
+            pred_std = torch.sqrt(pred_variance.mean(dim=1) + 1e-6)
+            target_std = torch.sqrt(target_variance.mean(dim=1) + 1e-6)
+            losses.append(
+                weight
+                * (torch.log(pred_std) - torch.log(target_std))
+                .square().mean()
+            )
+    return torch.stack(losses).mean()
+
+
+def train_model(
+    seed: int,
+    parent: FrozenA0Parent,
+    loaders: Mapping[str, DataLoader],
+    args: argparse.Namespace,
+    device: torch.device,
+    output_dir: Path,
+) -> Tuple[OpenSystemBER, Dict[str, Any]]:
+    seed_everything(seed)
+    model = OpenSystemBER(
+        copy.deepcopy(parent),
+        internal_hidden=48,
+        source_hidden=args.source_hidden,
+        fusion_hidden=args.fusion_hidden,
+    ).to(device)
+
+    # Exact identity sentinel before any training.
+    batch = batch_to_device(next(iter(loaders["validation"])), device)
+    with torch.no_grad():
+        atm, bnd, qa, qb = degrade_future(
+            batch["future_atmosphere"], batch["future_boundary"],
+            "oracle", seed,
+        )
+        initial, _ = model(
+            batch["internal"], parent_sources(batch),
+            atm, bnd, batch["current_vertical"], batch["mask"],
+            qa, qb,
+        )
+        parent_pred, _, _ = model.parent(
+            batch["internal"], parent_sources(batch)
+        )
+        identity_error = float((initial - parent_pred).abs().max())
+    if identity_error > 5e-6:
+        raise RuntimeError(
+            f"A1 zero-initialized identity sentinel failed: {identity_error}"
+        )
+
+    trainable = [
+        parameter for name, parameter in model.named_parameters()
+        if not name.startswith("parent.")
+    ]
+    optimizer = torch.optim.AdamW(
+        trainable,
+        lr=args.learning_rate,
+        weight_decay=args.weight_decay,
+    )
+    best_state: Optional[Dict[str, torch.Tensor]] = None
+    best_score = float("inf")
+    best_epoch = -1
+    logs = []
+
+    for epoch in range(1, args.epochs + 1):
+        model.train()
+        running = 0.0
+        for step, raw_batch in enumerate(loaders["train"], 1):
+            batch = batch_to_device(raw_batch, device)
+            mode_draw = random.random()
+            mode = "oracle" if mode_draw < 0.20 else (
+                "history" if mode_draw < 0.30 else "train"
+            )
+            atm, bnd, qa, qb = degrade_future(
+                batch["future_atmosphere"],
+                batch["future_boundary"],
+                mode,
+                seed * 100000 + epoch * 1000 + step,
+            )
+            prediction, diagnostics = model(
+                batch["internal"], parent_sources(batch),
+                atm, bnd, batch["current_vertical"], batch["mask"],
+                qa, qb,
+            )
+            target = batch["target"]
+            parent_prediction = diagnostics["parent_prediction"]
+            update = diagnostics["update"]
+            residual_target = target - parent_prediction
+
+            loss_prediction = masked_mse(prediction, target, batch["mask"])
+            loss_gradient = gradient_loss(prediction, target, batch["mask"])
+            loss_residual = masked_mse(update, residual_target, batch["mask"])
+            loss_variance = group_variance_loss(prediction, target, batch["mask"])
+            update_ratio = (
+                (update.square().mean() + 1e-12).sqrt()
+                / ((parent_prediction.square().mean() + 1e-12).sqrt() + 1e-6)
+            )
+            loss = (
+                loss_prediction
+                + args.gradient_weight * loss_gradient
+                + args.residual_weight * loss_residual
+                + args.variance_weight * loss_variance
+                + args.update_regularization * update_ratio
+            )
+            if not torch.isfinite(loss):
+                raise RuntimeError(
+                    f"Non-finite loss seed={seed} epoch={epoch} step={step}"
+                )
+            optimizer.zero_grad(set_to_none=True)
+            loss.backward()
+            torch.nn.utils.clip_grad_norm_(trainable, args.grad_clip)
+            optimizer.step()
+            running += float(loss.detach())
+
+        validation = evaluate(
+            model, loaders["validation"], device,
+            mode="degraded", seed=seed + epoch * 10000,
+            collect_samples=False,
+        )
+        variance_penalty = max(0.0, 0.80 - validation["variance_ratio_h12"]) ** 2
+        score = (
+            validation["rmse_h12"]
+            + 0.35 * validation["rmse_h4"]
+            + 0.15 * validation["rmse_h1"]
+            + args.selection_variance_weight * variance_penalty
+        )
+        row = {
+            "seed": seed,
+            "epoch": epoch,
+            "train_loss": running / max(len(loaders["train"]), 1),
+            "validation_score": score,
+            **{key: value for key, value in validation.items() if not isinstance(value, list)},
+        }
+        logs.append(row)
+        print(
+            f"[A1 seed={seed}] epoch={epoch}/{args.epochs} "
+            f"train={row['train_loss']:.6f} val={score:.6f} "
+            f"72h={row['rmse_h12']:.6f} var72={row['variance_ratio_h12']:.4f}",
+            flush=True,
+        )
+        if score < best_score:
+            best_score = score
+            best_epoch = epoch
+            best_state = {
+                key: value.detach().cpu().clone()
+                for key, value in model.state_dict().items()
+                if not key.startswith("parent.")
+            }
+
+    if best_state is None:
+        raise RuntimeError("No A1 checkpoint was selected")
+    current = model.state_dict()
+    current.update(best_state)
+    model.load_state_dict(current, strict=True)
+    checkpoint = output_dir / "checkpoints" / f"seed_{seed}.pt"
+    checkpoint.parent.mkdir(parents=True, exist_ok=True)
+    torch.save(
+        {
+            "a1_state": best_state,
+            "seed": seed,
+            "best_epoch": best_epoch,
+            "validation_score": best_score,
+            "identity_error": identity_error,
+        },
+        checkpoint,
+    )
+    pd.DataFrame(logs).to_csv(
+        output_dir / "training" / f"seed_{seed}.csv", index=False
+    )
+    return model, {
+        "seed": seed,
+        "checkpoint": str(checkpoint),
+        "best_epoch": best_epoch,
+        "validation_score": best_score,
+        "identity_error": identity_error,
+    }
+
+
+@torch.no_grad()
+def evaluate(
+    model: OpenSystemBER,
+    loader: DataLoader,
+    device: torch.device,
+    mode: str,
+    seed: int,
+    collect_samples: bool = True,
+    enable_atmosphere: bool = True,
+    enable_boundary: bool = True,
+    enable_vertical: bool = True,
+    enable_variance: bool = True,
+    disable_ber: bool = False,
+) -> Dict[str, Any]:
+    model.eval()
+    squared = {horizon: 0.0 for horizon in HORIZONS}
+    count = {horizon: 0.0 for horizon in HORIZONS}
+    pred_values: Dict[int, List[torch.Tensor]] = {horizon: [] for horizon in HORIZONS}
+    target_values: Dict[int, List[torch.Tensor]] = {horizon: [] for horizon in HORIZONS}
+    sample_rows: List[Dict[str, Any]] = []
+    diagnostic_rows: List[Dict[str, Any]] = []
+    group_accumulator: Dict[Tuple[int, str], List[float]] = {
+        (horizon, group): [] for horizon in HORIZONS for group in GROUPS
+    }
+
+    for step, raw_batch in enumerate(loader):
+        batch = batch_to_device(raw_batch, device)
+        atmosphere, boundary, qa, qb = degrade_future(
+            batch["future_atmosphere"],
+            batch["future_boundary"],
+            mode,
+            seed + step,
+        )
+        prediction, diagnostics = model(
+            batch["internal"], parent_sources(batch),
+            atmosphere, boundary, batch["current_vertical"], batch["mask"],
+            qa, qb,
+            enable_atmosphere=enable_atmosphere,
+            enable_boundary=enable_boundary,
+            enable_vertical=enable_vertical,
+            enable_variance=enable_variance,
+            disable_ber=disable_ber,
+        )
+        target = batch["target"]
+        channels = prediction.shape[2]
+        for hi, horizon in enumerate(HORIZONS):
+            error = (prediction[:, hi] - target[:, hi]).square() * batch["mask"]
+            denominator = (
+                batch["mask"].flatten(1).sum(dim=1).clamp_min(1.0) * channels
+            )
+            per_sample_mse = error.flatten(1).sum(dim=1) / denominator
+            squared[horizon] += float(error.sum())
+            count[horizon] += float(batch["mask"].sum()) * channels
+            pred_values[horizon].append(
+                (prediction[:, hi] * batch["mask"]).flatten(1).cpu()
+            )
+            target_values[horizon].append(
+                (target[:, hi] * batch["mask"]).flatten(1).cpu()
+            )
+            if collect_samples:
+                for index, mse in zip(
+                    batch["sample_index"].cpu().tolist(),
+                    per_sample_mse.cpu().tolist(),
+                ):
+                    sample_rows.append({
+                        "sample_index": int(index),
+                        "horizon": horizon,
+                        "mse": float(mse),
+                        "rmse": math.sqrt(max(float(mse), 0.0)),
+                    })
+            for group, indices in GROUPS.items():
+                group_error = (
+                    (prediction[:, hi, indices] - target[:, hi, indices]).square()
+                    * batch["mask"]
+                )
+                group_denominator = (
+                    batch["mask"].flatten(1).sum(dim=1).clamp_min(1.0)
+                    * len(indices)
+                )
+                group_rmse = torch.sqrt(
+                    group_error.flatten(1).sum(dim=1) / group_denominator
+                )
+                group_accumulator[(horizon, group)].extend(
+                    group_rmse.cpu().tolist()
+                )
+
+        update_ratio = (
+            (diagnostics["update"].square().mean(dim=(2, 3, 4)) + 1e-12).sqrt()
+            / (
+                (
+                    diagnostics["parent_prediction"]
+                    .square().mean(dim=(2, 3, 4))
+                    + 1e-12
+                ).sqrt()
+                + 1e-6
+            )
+        )
+        gates = diagnostics["gates"]
+        log_gain = diagnostics["log_gain"]
+        for bi in range(prediction.shape[0]):
+            diagnostic_rows.append({
+                "sample_index": int(batch["sample_index"][bi]),
+                "atmosphere_quality": float(qa[bi]),
+                "boundary_quality": float(qb[bi]),
+                "update_ratio_h1": float(update_ratio[bi, 0]),
+                "update_ratio_h4": float(update_ratio[bi, 1]),
+                "update_ratio_h12": float(update_ratio[bi, 2]),
+                "gate_atmosphere_h12": float(gates[bi, 2, 0]),
+                "gate_boundary_h12": float(gates[bi, 2, 1]),
+                "gate_vertical_h12": float(gates[bi, 2, 2]),
+                "gate_interaction_h12": float(gates[bi, 2, 3]),
+                "log_gain_abs_h12": float(log_gain[bi, 2].abs().mean()),
+            })
+
+    metrics: Dict[str, Any] = {}
+    for horizon in HORIZONS:
+        metrics[f"rmse_h{horizon}"] = math.sqrt(
+            squared[horizon] / max(count[horizon], 1.0)
+        )
+        prediction_flat = torch.cat(pred_values[horizon], dim=0)
+        target_flat = torch.cat(target_values[horizon], dim=0)
+        metrics[f"variance_ratio_h{horizon}"] = float(
+            prediction_flat.var(unbiased=False)
+            / (target_flat.var(unbiased=False) + 1e-8)
+        )
+    for (horizon, group), values in group_accumulator.items():
+        metrics[f"group_rmse_{group}_h{horizon}"] = float(np.mean(values))
+    metrics["sample_rows"] = sample_rows
+    metrics["diagnostic_rows"] = diagnostic_rows
+    return metrics
+
+
+def paired_bootstrap(
+    parent: np.ndarray,
+    candidate: np.ndarray,
+    replicates: int,
+    seed: int,
+) -> Dict[str, float]:
+    if len(parent) != len(candidate):
+        raise ValueError("Paired arrays must have equal length")
+    difference = candidate - parent
+    generator = np.random.default_rng(seed)
+    estimates = []
+    for _ in range(replicates):
+        indices = generator.integers(0, len(difference), len(difference))
+        estimates.append(float(difference[indices].mean()))
+    low, high = np.percentile(estimates, [2.5, 97.5])
+    return {
+        "mean_mse_difference": float(difference.mean()),
+        "ci_low": float(low),
+        "ci_high": float(high),
+        "mse_gain_percent": float(
+            100.0 * (parent.mean() - candidate.mean())
+            / max(parent.mean(), 1e-12)
+        ),
+        "n": int(len(difference)),
+    }
+
+
+def runtime_audit(
+    model: OpenSystemBER,
+    loader: DataLoader,
+    device: torch.device,
+    seed: int,
+    warmup: int = 10,
+    repeats: int = 50,
+) -> Dict[str, float]:
+    model.eval()
+    batch = batch_to_device(next(iter(loader)), device)
+    atmosphere, boundary, qa, qb = degrade_future(
+        batch["future_atmosphere"], batch["future_boundary"],
+        "degraded", seed,
+    )
+
+    def execute() -> None:
+        model(
+            batch["internal"], parent_sources(batch),
+            atmosphere, boundary, batch["current_vertical"],
+            batch["mask"], qa, qb,
+        )
+
+    with torch.no_grad():
+        for _ in range(warmup):
+            execute()
+        if device.type == "cuda":
+            torch.cuda.synchronize()
+        start = time.perf_counter()
+        for _ in range(repeats):
+            execute()
+        if device.type == "cuda":
+            torch.cuda.synchronize()
+        elapsed = time.perf_counter() - start
+    return {
+        "batch_size": int(batch["internal"].shape[0]),
+        "mean_batch_ms": 1000.0 * elapsed / repeats,
+        "mean_sample_ms": 1000.0 * elapsed / repeats / batch["internal"].shape[0],
+    }
+
+
+def plot_summary(summary: pd.DataFrame, output_dir: Path) -> None:
+    output_dir.mkdir(parents=True, exist_ok=True)
+    table = summary[summary["horizon"] == 12].copy()
+    plt.figure(figsize=(11, 5))
+    plt.bar(table["mode"], table["rmse_gain_vs_a0_percent"])
+    plt.axhline(0, linewidth=1)
+    plt.ylabel("72 h RMSE gain over A0 parent (%)")
+    plt.xticks(rotation=25, ha="right")
+    plt.tight_layout()
+    plt.savefig(output_dir / "S2A1_72h_RMSE_gain.png", dpi=180)
+    plt.close()
+
+    plt.figure(figsize=(11, 5))
+    plt.bar(table["mode"], table["variance_ratio"])
+    plt.axhline(0.75, linewidth=1)
+    plt.axhline(1.0, linewidth=1)
+    plt.ylabel("72 h variance ratio")
+    plt.xticks(rotation=25, ha="right")
+    plt.tight_layout()
+    plt.savefig(output_dir / "S2A1_72h_variance_ratio.png", dpi=180)
+    plt.close()
+
+
+def package_output(output_dir: Path) -> Path:
+    target = output_dir.parent / f"{output_dir.name}.zip"
+    target.unlink(missing_ok=True)
+    with zipfile.ZipFile(target, "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))
+    return target
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        description="CIDM-v3 S2-A1 real-input BER qualification"
+    )
+    parser.add_argument("--cache_dir", default="/content/CIDM_v3_SCS_S2A0_Cache")
+    parser.add_argument("--a0_zip", default="/content/CIDM_v3_SCS_V3_S2_A0.zip")
+    parser.add_argument("--output_dir", default="/content/CIDM_v3_SCS_V3_S2_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("--epochs", type=int, default=7)
+    parser.add_argument("--batch_size", type=int, default=4)
+    parser.add_argument("--num_workers", type=int, default=0)
+    parser.add_argument("--source_hidden", type=int, default=24)
+    parser.add_argument("--fusion_hidden", type=int, default=48)
+    parser.add_argument("--learning_rate", type=float, default=2.5e-4)
+    parser.add_argument("--weight_decay", type=float, default=1e-4)
+    parser.add_argument("--gradient_weight", type=float, default=0.06)
+    parser.add_argument("--residual_weight", type=float, default=0.10)
+    parser.add_argument("--variance_weight", type=float, default=0.20)
+    parser.add_argument("--selection_variance_weight", type=float, default=0.45)
+    parser.add_argument("--update_regularization", type=float, default=0.005)
+    parser.add_argument("--grad_clip", type=float, default=1.0)
+    parser.add_argument(
+        "--seeds", default="20260910,20260911,20260912"
+    )
+    parser.add_argument("--bootstrap_reps", type=int, default=1000)
+    parser.add_argument("--synthetic_smoke", action="store_true")
+    parser.add_argument("--smoke_time_steps", type=int, default=48)
+    parser.add_argument("--smoke_height", type=int, default=16)
+    parser.add_argument("--smoke_width", type=int, default=16)
+    return parser
+
+
+def create_synthetic_assets(args: argparse.Namespace) -> None:
+    """仅用于交付前执行链验证。"""
+    cache = Path(args.cache_dir)
+    prepared = cache / "prepared"
+    prepared.mkdir(parents=True, exist_ok=True)
+    generator = np.random.default_rng(20260920)
+    for wi, spec in enumerate(WINDOWS):
+        t = args.smoke_time_steps
+        h = args.smoke_height
+        w = args.smoke_width
+        time_values = (
+            np.datetime64("2023-01-01")
+            + np.arange(t) * np.timedelta64(6, "h")
+            + wi * np.timedelta64(100, "D")
+        )
+        internal = generator.normal(0, 1, (t, 16, h, w)).astype(np.float32)
+        atmosphere = generator.normal(0, 1, (t, 9, h, w)).astype(np.float32)
+        boundary = generator.normal(0, 1, (t, 10, h, w)).astype(np.float32)
+        vertical = generator.normal(0, 1, (t, 10, h, w)).astype(np.float32)
+        for index in range(1, t):
+            internal[index] = (
+                0.92 * internal[index - 1]
+                + 0.03 * atmosphere[index, :1]
+                + 0.03 * boundary[index, :1]
+                + 0.02 * vertical[index, :1]
+                + generator.normal(0, 0.05, internal[index].shape)
+            )
+        mask = np.ones((t, 1, h, w), np.float32)
+        lat = np.linspace(0, 25, h, dtype=np.float32)
+        lon = np.linspace(99, 123, w, dtype=np.float32)
+        stamp = time_values.astype("datetime64[ns]").astype("int64")
+        np.savez_compressed(
+            prepared / f"{spec['name']}_cmems.npz",
+            time=stamp, latitude=lat, longitude=lon,
+            internal=internal, vertical=vertical,
+            boundary=boundary, ocean_mask=mask,
+        )
+        np.savez_compressed(
+            prepared / f"{spec['name']}_atmosphere_aligned.npz",
+            time=stamp, atmosphere=atmosphere,
+        )
+        tide = np.zeros((t, 11, h, w), np.float32)
+        river = np.zeros((t, 2, h, w), np.float32)
+        events = np.zeros((t, 3, h, w), np.float32)
+        np.savez_compressed(
+            prepared / f"{spec['name']}_tide.npz",
+            time=stamp, tide=tide,
+            actual_spatial_tide=np.asarray([0], np.int8),
+        )
+        np.savez_compressed(
+            prepared / f"{spec['name']}_river.npz",
+            time=stamp, river=river,
+            available=np.asarray([0], np.int8),
+        )
+        np.savez_compressed(
+            prepared / f"{spec['name']}_events.npz",
+            time=stamp, events=events,
+            available=np.asarray([0], np.int8),
+        )
+
+
+def main() -> None:
+    args = build_parser().parse_args()
+    seeds = [int(value) for value in args.seeds.split(",") if value.strip()]
+    if not seeds:
+        raise ValueError("At least one seed is required")
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    if not args.synthetic_smoke and device.type != "cuda":
+        raise RuntimeError("Formal S2-A1 requires a CUDA GPU")
+    torch.set_float32_matmul_precision("highest")
+
+    output_dir = Path(args.output_dir)
+    if output_dir.exists():
+        shutil.rmtree(output_dir)
+    for subdir in [
+        "training", "checkpoints", "evaluation",
+        "audits", "figures", "lineage",
+    ]:
+        (output_dir / subdir).mkdir(parents=True, exist_ok=True)
+
+    try:
+        stage(1, 11, "从HF或本地缓存恢复S2-A0数据与父结果")
+        if args.synthetic_smoke:
+            create_synthetic_assets(args)
+            # Smoke uses a supplied synthetic A0 package generated by the notebook/package test.
+            hf_report = {"synthetic_smoke": True}
+        else:
+            hf_report = ensure_hf_assets(args)
+        atomic_json(hf_report, output_dir / "audits" / "S2A1_HF_asset_audit.json")
+
+        stage(2, 11, "提取A0父链、归一化统计与三种子检查点")
+        extracted = extract_a0_assets(
+            Path(args.a0_zip), output_dir / "_a0_parent"
+        )
+        a0_verdict = json.loads(extracted["verdict"].read_text(encoding="utf-8"))
+        a0_aggregate = json.loads(
+            extracted["aggregate"].read_text(encoding="utf-8")
+        )
+        atomic_json(
+            {"a0_verdict": a0_verdict, "a0_aggregate": a0_aggregate},
+            output_dir / "lineage" / "S2A1_parent_lineage.json",
+        )
+
+        stage(3, 11, "加载四季prepared数据并执行时间/形状审计")
+        windows = [
+            load_window(Path(args.cache_dir), spec) for spec in WINDOWS
+        ]
+        loaders, split_meta = build_loaders(windows, extracted["stats"], args)
+        atomic_json(split_meta, output_dir / "audits" / "S2A1_split_audit.json")
+        shape_rows = []
+        for window in windows:
+            shape_rows.append({
+                "window": window.name,
+                "role": window.role,
+                "time_steps": len(window.time),
+                "internal_shape": str(tuple(window.internal.shape)),
+                "atmosphere_shape": str(tuple(window.sources["atmosphere"].shape)),
+                "boundary_shape": str(tuple(window.sources["boundary"].shape)),
+                "vertical_shape": str(tuple(window.sources["vertical"].shape)),
+                "finite": bool(
+                    np.isfinite(window.internal).all()
+                    and all(np.isfinite(value).all() for value in window.sources.values())
+                ),
+            })
+        pd.DataFrame(shape_rows).to_csv(
+            output_dir / "audits" / "S2A1_data_shape_audit.csv", index=False
+        )
+
+        stage(4, 11, "重建A0历史外部信息父模型与恒等哨兵")
+        parents = {
+            seed: load_parent(extracted["root"], seed, device)
+            for seed in seeds
+        }
+
+        stage(5, 11, "训练零初始化真实开放系统BER")
+        models: Dict[int, OpenSystemBER] = {}
+        training_records = []
+        for seed in seeds:
+            model, record = train_model(
+                seed, parents[seed], loaders, args, device, output_dir
+            )
+            models[seed] = model
+            training_records.append(record)
+        pd.DataFrame(training_records).to_csv(
+            output_dir / "S2A1_training_summary.csv", index=False
+        )
+
+        stage(6, 11, "评估未来强迫、部署退化和来源消融")
+        modes = {
+            "a0_parent": dict(mode="degraded", disable_ber=True),
+            "a1_fallback": dict(mode="oracle", disable_ber=True),
+            "a1_degraded": dict(mode="degraded"),
+            "a1_oracle": dict(mode="oracle"),
+            "a1_history_only": dict(mode="history"),
+            "a1_no_atmosphere": dict(mode="degraded", enable_atmosphere=False),
+            "a1_no_boundary": dict(mode="degraded", enable_boundary=False),
+            "a1_no_vertical": dict(mode="degraded", enable_vertical=False),
+            "a1_no_variance": dict(mode="degraded", enable_variance=False),
+            "a1_shuffled": dict(mode="shuffled"),
+        }
+        metric_rows = []
+        sample_tables: Dict[Tuple[int, str], pd.DataFrame] = {}
+        diagnostic_tables: Dict[Tuple[int, str], pd.DataFrame] = {}
+        for seed in seeds:
+            for mode_name, options in modes.items():
+                metrics = evaluate(
+                    models[seed], loaders["test"], device,
+                    seed=seed * 1000 + sum(ord(char) for char in mode_name),
+                    collect_samples=True,
+                    **options,
+                )
+                sample_tables[(seed, mode_name)] = pd.DataFrame(
+                    metrics.pop("sample_rows")
+                )
+                diagnostic_tables[(seed, mode_name)] = pd.DataFrame(
+                    metrics.pop("diagnostic_rows")
+                )
+                metric_rows.append({
+                    "seed": seed,
+                    "mode": mode_name,
+                    **metrics,
+                })
+        metrics_table = pd.DataFrame(metric_rows)
+        metrics_table.to_csv(
+            output_dir / "evaluation" / "S2A1_seed_metrics.csv", index=False
+        )
+
+        stage(7, 11, "配对Bootstrap、RMSE增益和方差恢复分析")
+        summary_rows = []
+        bootstrap_payload: Dict[str, Any] = {}
+        parent_mean = {
+            horizon: metrics_table[
+                (metrics_table["mode"] == "a0_parent")
+            ][f"rmse_h{horizon}"].mean()
+            for horizon in HORIZONS
+        }
+        for mode_name in modes:
+            for horizon in HORIZONS:
+                subset = metrics_table[metrics_table["mode"] == mode_name]
+                rmse = float(subset[f"rmse_h{horizon}"].mean())
+                variance = float(
+                    subset[f"variance_ratio_h{horizon}"].mean()
+                )
+                seed_gains = []
+                parent_mse_all, candidate_mse_all = [], []
+                for seed in seeds:
+                    parent_samples = sample_tables[(seed, "a0_parent")]
+                    candidate_samples = sample_tables[(seed, mode_name)]
+                    parent_mse = (
+                        parent_samples[parent_samples.horizon == horizon]
+                        .sort_values("sample_index").mse.to_numpy()
+                    )
+                    candidate_mse = (
+                        candidate_samples[candidate_samples.horizon == horizon]
+                        .sort_values("sample_index").mse.to_numpy()
+                    )
+                    seed_gains.append(
+                        100.0 * (
+                            metrics_table[
+                                (metrics_table["seed"] == seed)
+                                & (metrics_table["mode"] == "a0_parent")
+                            ][f"rmse_h{horizon}"].iloc[0]
+                            - metrics_table[
+                                (metrics_table["seed"] == seed)
+                                & (metrics_table["mode"] == mode_name)
+                            ][f"rmse_h{horizon}"].iloc[0]
+                        ) / metrics_table[
+                            (metrics_table["seed"] == seed)
+                            & (metrics_table["mode"] == "a0_parent")
+                        ][f"rmse_h{horizon}"].iloc[0]
+                    )
+                    parent_mse_all.append(parent_mse)
+                    candidate_mse_all.append(candidate_mse)
+                bootstrap = paired_bootstrap(
+                    np.concatenate(parent_mse_all),
+                    np.concatenate(candidate_mse_all),
+                    args.bootstrap_reps,
+                    seeds[0] + horizon * 1000 + sum(ord(char) for char in mode_name),
+                )
+                bootstrap_payload[f"{mode_name}_h{horizon}"] = bootstrap
+                summary_rows.append({
+                    "mode": mode_name,
+                    "horizon": horizon,
+                    "lead_hours": horizon * 6,
+                    "rmse": rmse,
+                    "variance_ratio": variance,
+                    "rmse_gain_vs_a0_percent": (
+                        100.0 * (parent_mean[horizon] - rmse)
+                        / parent_mean[horizon]
+                    ),
+                    "mse_gain_vs_a0_percent": bootstrap["mse_gain_percent"],
+                    "bootstrap_mse_difference_low": bootstrap["ci_low"],
+                    "bootstrap_mse_difference_high": bootstrap["ci_high"],
+                    "all_seed_rmse_gains_positive": bool(
+                        all(value > 0 for value in seed_gains)
+                    ),
+                    "seed_rmse_gain_min": float(min(seed_gains)),
+                    "seed_rmse_gain_max": float(max(seed_gains)),
+                })
+        summary = pd.DataFrame(summary_rows)
+        summary.to_csv(
+            output_dir / "S2A1_counterfactual_summary.csv", index=False
+        )
+        atomic_json(
+            bootstrap_payload, output_dir / "paired_bootstrap.json"
+        )
+
+        stage(8, 11, "来源责任、变量组与不确定度单调性审计")
+        group_columns = [
+            column for column in metrics_table.columns
+            if column.startswith("group_rmse_")
+        ]
+        metrics_table[
+            ["seed", "mode"] + group_columns
+        ].to_csv(
+            output_dir / "evaluation" / "S2A1_variable_group_summary.csv",
+            index=False,
+        )
+        diagnostic_rows = []
+        for (seed, mode_name), table in diagnostic_tables.items():
+            row = {
+                "seed": seed,
+                "mode": mode_name,
+            }
+            for column in [
+                "update_ratio_h1", "update_ratio_h4", "update_ratio_h12",
+                "gate_atmosphere_h12", "gate_boundary_h12",
+                "gate_vertical_h12", "gate_interaction_h12",
+                "log_gain_abs_h12",
+            ]:
+                row[column] = float(table[column].mean())
+            diagnostic_rows.append(row)
+        diagnostics = pd.DataFrame(diagnostic_rows)
+        diagnostics.to_csv(
+            output_dir / "evaluation" / "S2A1_BER_diagnostics.csv",
+            index=False,
+        )
+
+        stage(9, 11, "运行时审计与正式资格判决")
+        runtime_rows = []
+        for seed in seeds:
+            row = runtime_audit(
+                models[seed], loaders["test"], device, seed
+            )
+            row["seed"] = seed
+            runtime_rows.append(row)
+        runtime_table = pd.DataFrame(runtime_rows)
+        runtime_table.to_csv(
+            output_dir / "S2A1_runtime.csv", index=False
+        )
+
+        def summary_value(mode: str, horizon: int, column: str) -> float:
+            return float(
+                summary[
+                    (summary["mode"] == mode)
+                    & (summary["horizon"] == horizon)
+                ][column].iloc[0]
+            )
+
+        degraded_rmse_gain = summary_value(
+            "a1_degraded", 12, "rmse_gain_vs_a0_percent"
+        )
+        degraded_var = summary_value(
+            "a1_degraded", 12, "variance_ratio"
+        )
+        oracle_gain = summary_value(
+            "a1_oracle", 12, "rmse_gain_vs_a0_percent"
+        )
+        no_atm_gain = summary_value(
+            "a1_no_atmosphere", 12, "rmse_gain_vs_a0_percent"
+        )
+        no_bnd_gain = summary_value(
+            "a1_no_boundary", 12, "rmse_gain_vs_a0_percent"
+        )
+        no_vert_gain = summary_value(
+            "a1_no_vertical", 12, "rmse_gain_vs_a0_percent"
+        )
+        no_variance_rmse = summary_value(
+            "a1_no_variance", 12, "rmse"
+        )
+        degraded_rmse = summary_value(
+            "a1_degraded", 12, "rmse"
+        )
+        no_variance_var = summary_value(
+            "a1_no_variance", 12, "variance_ratio"
+        )
+        shuffled_rmse = summary_value(
+            "a1_shuffled", 12, "rmse"
+        )
+        parent_rmse = summary_value(
+            "a0_parent", 12, "rmse"
+        )
+        bootstrap_upper = summary_value(
+            "a1_degraded", 12, "bootstrap_mse_difference_high"
+        )
+        all_seed_positive = bool(
+            summary[
+                (summary["mode"] == "a1_degraded")
+                & (summary["horizon"] == 12)
+            ]["all_seed_rmse_gains_positive"].iloc[0]
+        )
+        identity_max = max(
+            record["identity_error"] for record in training_records
+        )
+
+        # Marginal source utility: full should be better than the ablation.
+        atm_marginal = 100.0 * (
+            summary_value("a1_no_atmosphere", 12, "rmse")
+            - degraded_rmse
+        ) / degraded_rmse
+        bnd_marginal = 100.0 * (
+            summary_value("a1_no_boundary", 12, "rmse")
+            - degraded_rmse
+        ) / degraded_rmse
+        vert_marginal = 100.0 * (
+            summary_value("a1_no_vertical", 12, "rmse")
+            - degraded_rmse
+        ) / degraded_rmse
+        variance_improvement = degraded_var - no_variance_var
+        variance_rmse_harm = 100.0 * (
+            degraded_rmse - no_variance_rmse
+        ) / no_variance_rmse
+        shuffled_harm = 100.0 * (
+            shuffled_rmse - degraded_rmse
+        ) / degraded_rmse
+
+        checks = {
+            "a0_parent_loaded_three_seeds": len(parents) == 3 and len(seeds) == 3,
+            "zero_initialized_identity_lt_5e6": identity_max < 5e-6,
+            "degraded_future_72h_rmse_gain_ge_0_5pct": degraded_rmse_gain >= 0.5,
+            "degraded_future_72h_bootstrap_mse_positive": bootstrap_upper < 0,
+            "all_three_degraded_72h_rmse_positive": all_seed_positive,
+            "oracle_not_worse_than_degraded": oracle_gain >= degraded_rmse_gain,
+            "variance_ratio_72h_0_75_to_1_10": 0.75 <= degraded_var <= 1.10,
+            "variance_closure_improves_ratio_ge_0_02": variance_improvement >= 0.02,
+            "variance_closure_rmse_harm_le_0_3pct": variance_rmse_harm <= 0.3,
+            "atmosphere_has_positive_marginal_utility": atm_marginal > 0,
+            "boundary_has_positive_marginal_utility": bnd_marginal > 0,
+            "vertical_condition_has_positive_marginal_utility": vert_marginal > 0,
+            "shuffled_future_is_worse": shuffled_harm > 0,
+            "fallback_exactly_reproduces_a0": abs(
+                summary_value("a1_fallback", 12, "rmse") - parent_rmse
+            ) < 1e-10,
+            "mean_sample_runtime_lt_20ms": float(
+                runtime_table["mean_sample_ms"].mean()
+            ) < 20.0,
+            "all_metrics_finite": bool(
+                np.isfinite(metrics_table.select_dtypes(include=[np.number]).to_numpy()).all()
+            ),
+        }
+        passed = sum(bool(value) for value in checks.values())
+        if all(checks.values()):
+            verdict_name = (
+                "V3_S2_A1_REAL_INPUT_BER_AND_VARIANCE_RESTORATION_QUALIFIED"
+            )
+        elif passed >= 12 and checks[
+            "degraded_future_72h_rmse_gain_ge_0_5pct"
+        ]:
+            verdict_name = (
+                "V3_S2_A1_REAL_INPUT_BER_AND_VARIANCE_RESTORATION_PARTIALLY_QUALIFIED"
+            )
+        else:
+            verdict_name = (
+                "V3_S2_A1_REAL_INPUT_BER_AND_VARIANCE_RESTORATION_NOT_YET_QUALIFIED"
+            )
+        aggregate = {
+            "degraded_72h_rmse_gain_percent": degraded_rmse_gain,
+            "degraded_72h_variance_ratio": degraded_var,
+            "oracle_72h_rmse_gain_percent": oracle_gain,
+            "atmosphere_marginal_utility_percent": atm_marginal,
+            "boundary_marginal_utility_percent": bnd_marginal,
+            "vertical_marginal_utility_percent": vert_marginal,
+            "variance_ratio_improvement": variance_improvement,
+            "variance_closure_rmse_harm_percent": variance_rmse_harm,
+            "shuffled_future_harm_percent": shuffled_harm,
+            "identity_error_max": identity_max,
+            "mean_sample_runtime_ms": float(
+                runtime_table["mean_sample_ms"].mean()
+            ),
+        }
+        verdict = {
+            "automatic_verdict": verdict_name,
+            "passed": passed,
+            "total": len(checks),
+            "checks": checks,
+            "aggregate": aggregate,
+            "next_stage_recommendation": (
+                "Proceed to S2-A2 and integrate the qualified BER into the frozen S1-R3 CIDM core."
+                if verdict_name
+                == "V3_S2_A1_REAL_INPUT_BER_AND_VARIANCE_RESTORATION_QUALIFIED"
+                else "Use the failed counterfactual gates to repair BER before CIDM-core integration."
+            ),
+        }
+        atomic_json(aggregate, output_dir / "S2A1_main_aggregate.json")
+        atomic_json(verdict, output_dir / "S2A1_verdict.json")
+
+        stage(10, 11, "生成图表、报告和HF续接清单")
+        plot_summary(summary, output_dir / "figures")
+        report_lines = [
+            "# V3-S2-A1 真实外部输入BER资格报告",
+            "",
+            f"自动判决：`{verdict_name}`",
+            "",
+            f"- 部署退化代理72小时RMSE增益：{degraded_rmse_gain:.4f}%",
+            f"- Oracle未来强迫72小时RMSE增益：{oracle_gain:.4f}%",
+            f"- 部署退化代理72小时方差比：{degraded_var:.4f}",
+            f"- 大气边际效用：{atm_marginal:.4f}%",
+            f"- 边界边际效用：{bnd_marginal:.4f}%",
+            f"- 垂向条件边际效用：{vert_marginal:.4f}%",
+            f"- 方差闭合提升：{variance_improvement:.4f}",
+            f"- 打乱未来强迫损害：{shuffled_harm:.4f}%",
+            "",
+            "说明：Oracle使用未来再分析，仅表示外部信息上限；",
+            "正式资格以加入时滞、噪声和质量通道的degraded_future为主。",
+        ]
+        (
+            output_dir / "实验V3S2A1_真实外部输入BER与方差恢复报告.md"
+        ).write_text("\n".join(report_lines), encoding="utf-8")
+        atomic_json(
+            {
+                "source_dataset_repo": args.hf_repo_id,
+                "source_paths": [
+                    "Cache/prepared/<window>_cmems.npz",
+                    "Cache/prepared/<window>_atmosphere_aligned.npz",
+                    "CIDM_v3_SCS_V3_S2_A0.zip",
+                ],
+                "recommended_result_path": "Experiments/V3_S2_A1/",
+            },
+            output_dir / "S2A1_HF_handoff.json",
+        )
+        atomic_json(
+            {
+                "experiment": "CIDM_v3_SCS_V3_S2_A1",
+                "created_at": dt.datetime.now().isoformat(),
+                "device": str(device),
+                "seeds": seeds,
+                "arguments": vars(args),
+            },
+            output_dir / "S2A1_manifest.json",
+        )
+
+        stage(11, 11, "结果打包")
+        package = package_output(output_dir)
+        print(json.dumps(verdict, ensure_ascii=False, indent=2), 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()