Upload Experiments/V3_S2_A1_R2/cidm_v3_scs_s2_a1_r2_conditional_external_innovation_capacity.py with huggingface_hub

Experiments/V3_S2_A1_R2/cidm_v3_scs_s2_a1_r2_conditional_external_innovation_capacity.py

@@ -0,0 +1,2731 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+CIDM-v3 SCS V3-S2-A1-R2
+条件外部创新可预测容量、事件活跃子集与来源残差资格实验
+===========================================================
+
+本轮不是继续堆叠 BER，而是回答一个前置问题：
+
+在冻结 A0（内部状态 + 历史/当前大气、边界、垂向）之后，
+未来大气创新和未来域外边界创新是否仍能独立预测 A0 的剩余误差？
+
+设计原则：
+- 以 A0 残差为监督目标，直接测量条件增量信息；
+- 大气与边界使用严格来源专属、零输入零输出的小探针；
+- 不使用内部特征作为探针输入，杜绝闭合系统捷径；
+- 不加入方差校准，避免把统一异常放大误判为来源信息；
+- 正确未来与同季节负样本、历史重复、时间反转公平比较；
+- 仅用夏季验证集选择检查点和非负收缩系数；
+- 秋季测试集完全不参与选择；
+- 额外评估外部活动度最高的 20% 样本，判断信号是否只在事件期出现。
+
+若本轮仍无法建立稳定的正确未来优势，则应停止继续调 BER，
+转向扩大事件富集数据，而不是继续增加网络分支。
+"""
+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)),
+}
+SOURCES = ["atmosphere", "boundary"]
+CONTROLS = ["correct", "negative", "history", "reversed", "shifted"]
+
+
+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)
+    temporary = path.with_suffix(path.suffix + ".tmp")
+    temporary.write_text(
+        json.dumps(payload, ensure_ascii=False, indent=2, default=json_default),
+        encoding="utf-8",
+    )
+    os.replace(temporary, path)
+
+
+def stage(index: int, total: int, title: str) -> None:
+    print(f"\n[V3-S2-A1-R2] 阶段 {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]:
+    cache = Path(args.cache_dir)
+    prepared = cache / "prepared"
+    prepared.mkdir(parents=True, exist_ok=True)
+    r1_zip = Path(args.r1_zip)
+    required: List[Tuple[str, Path]] = [
+        (
+            "Experiments/V3_S2_A1_R1/CIDM_v3_SCS_V3_S2_A1_R1.zip",
+            r1_zip,
+        )
+    ]
+    for window in WINDOWS:
+        name = window["name"]
+        required.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 required
+        if not local_path.is_file() or local_path.stat().st_size <= 128
+    ]
+    report = {
+        "repo_id": args.hf_repo_id,
+        "requested_files": len(required),
+        "already_local": len(required) - len(missing),
+        "downloaded": [],
+    }
+    if missing:
+        if not args.hf_repo_id:
+            raise RuntimeError("Missing assets 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)
+            local_path.unlink(missing_ok=True)
+            try:
+                local_path.symlink_to(downloaded)
+            except Exception:
+                shutil.copy2(downloaded, local_path)
+            report["downloaded"].append(repo_path)
+
+    for repo_path, local_path in required:
+        if not local_path.is_file() or local_path.stat().st_size <= 128:
+            raise RuntimeError(f"Asset missing: {repo_path} -> {local_path}")
+    return report
+
+
+def extract_r1_lineage(r1_zip: Path, work_dir: Path) -> Dict[str, Path]:
+    """Extract only R1 lineage and the nested frozen A0 parent assets."""
+    prefix = "CIDM_v3_SCS_V3_S2_A1_R1/"
+    a0_prefix = (
+        prefix
+        + "_a1_parent/CIDM_v3_SCS_V3_S2_A1/"
+        + "_a0_parent/CIDM_v3_SCS_V3_S2_A0/"
+    )
+    required = [
+        prefix + "S2A1R1_verdict.json",
+        prefix + "S2A1R1_main_aggregate.json",
+        a0_prefix + "audits/S2A0_normalization_stats.npz",
+    ]
+    for seed in [20260910, 20260911, 20260912]:
+        required.extend([
+            a0_prefix + f"checkpoints/baseline/seed_{seed}.pt",
+            a0_prefix + f"checkpoints/all_required/seed_{seed}.pt",
+        ])
+    work_dir.mkdir(parents=True, exist_ok=True)
+    with zipfile.ZipFile(r1_zip) as archive:
+        names = set(archive.namelist())
+        missing = [name for name in required if name not in names]
+        if missing:
+            raise RuntimeError(f"R1 archive misses required entries: {missing}")
+        for name in required:
+            target = work_dir / name
+            if not target.is_file():
+                archive.extract(name, work_dir)
+    r1_root = work_dir / prefix
+    a0_root = work_dir / a0_prefix
+    return {
+        "r1_root": r1_root,
+        "r1_verdict": r1_root / "S2A1R1_verdict.json",
+        "r1_aggregate": r1_root / "S2A1R1_main_aggregate.json",
+        "a0_root": a0_root,
+        "stats": a0_root / "audits" / "S2A0_normalization_stats.npz",
+    }
+
+
+@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"{name} time length mismatch: {lengths}")
+    finite = (
+        np.isfinite(cmems["internal"]).all()
+        and all(np.isfinite(value).all() for value in arrays.values())
+    )
+    if not finite:
+        raise RuntimeError(f"{name} contains non-finite values")
+    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, int]] = []
+        max_h = max(HORIZONS)
+        for wi, window in enumerate(self.windows):
+            valid = list(range(self.history - 1, len(window.time) - max_h))
+            if len(valid) < 2:
+                continue
+            offset = max(1, len(valid) // 2)
+            for position, t in enumerate(valid):
+                negative_t = valid[(position + offset) % len(valid)]
+                self.records.append((wi, t, negative_t))
+
+
+class R2Dataset(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, negative_t = self.index.records[item]
+        window = self.index.windows[wi]
+        history = self.index.history
+        internal_history = self.norm(
+            window.internal[t - history + 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_values = self.norm(
+                values[t - history + 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(
+                (history, 1, *history_values.shape[-2:]),
+                actual,
+                dtype=np.float32,
+            )
+            uncertainty_map = np.full(
+                (history, 1, *history_values.shape[-2:]),
+                uncertainty,
+                dtype=np.float32,
+            )
+            parent_value = np.concatenate(
+                [history_values, availability, uncertainty_map], axis=1
+            )
+            result[f"parent_{source}"] = torch.from_numpy(
+                parent_value.reshape(
+                    -1, *history_values.shape[-2:]
+                ).astype(np.float32)
+            )
+
+        for source in SOURCES:
+            mean, std = self.source_stats[source]
+            correct = self.norm(
+                window.sources[source][t:t + max(HORIZONS) + 1],
+                mean, std,
+            ).astype(np.float32)
+            negative = self.norm(
+                window.sources[source][
+                    negative_t:negative_t + max(HORIZONS) + 1
+                ],
+                mean, std,
+            ).astype(np.float32)
+            result[f"future_{source}"] = torch.from_numpy(correct)
+            result[f"negative_{source}"] = torch.from_numpy(negative)
+        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):
+    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,
+        sources: Mapping[str, torch.Tensor],
+    ) -> torch.Tensor:
+        base, features = self.baseline(internal)
+        update, _ = self.adapter(features, sources, REQUIRED_SOURCES)
+        return base + update
+
+
+def load_parent(
+    a0_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_checkpoint = torch.load(
+        a0_root / "checkpoints" / "baseline" / f"seed_{seed}.pt",
+        map_location="cpu",
+        weights_only=False,
+    )
+    adapter_checkpoint = torch.load(
+        a0_root / "checkpoints" / "all_required" / f"seed_{seed}.pt",
+        map_location="cpu",
+        weights_only=False,
+    )
+    baseline.load_state_dict(
+        baseline_checkpoint["model_state"], strict=True
+    )
+    adapter.load_state_dict(
+        adapter_checkpoint["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] = {}
+    audit: 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 = R2Dataset(
+            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
+            ),
+        )
+        audit[role] = {
+            "windows": [window.name for window in selected],
+            "samples": len(dataset),
+        }
+    return loaders, audit
+
+
+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 control_sequence(
+    correct: torch.Tensor,
+    negative: torch.Tensor,
+    control: str,
+) -> torch.Tensor:
+    if control == "correct":
+        return correct
+    if control == "negative":
+        return negative
+    if control == "history":
+        return correct[:, :1].expand_as(correct)
+    if control == "reversed":
+        return torch.flip(correct, dims=[1])
+    if control == "shifted":
+        return torch.cat([correct[:, 1:], correct[:, -1:]], dim=1)
+    raise ValueError(control)
+
+
+def build_innovation(
+    sequence: torch.Tensor,
+    source: str,
+) -> Tuple[torch.Tensor, torch.Tensor]:
+    """
+    Return:
+      features [B,H,F,Y,X]
+      activity [B,H]
+    Current absolute source state is excluded because A0 already receives it.
+    """
+    feature_list = []
+    activity_list = []
+    for horizon in HORIZONS:
+        segment = sequence[:, :horizon + 1]
+        current = segment[:, 0]
+        endpoint_delta = segment[:, -1] - current
+        mean_delta = segment.mean(dim=1) - current
+        temporal_std = segment.std(dim=1, unbiased=False)
+        feature = torch.cat(
+            [endpoint_delta, mean_delta, temporal_std], dim=1
+        )
+        if source == "boundary":
+            steps = {1: 1, 4: 3, 12: 6}[horizon]
+            diffused = feature
+            for _ in range(steps):
+                diffused = F.avg_pool2d(
+                    diffused, 3, stride=1, padding=1
+                )
+            feature = torch.cat([feature, diffused], dim=1)
+        feature_list.append(feature)
+        activity_list.append(
+            torch.sqrt(
+                feature.square().mean(
+                    dim=(1, 2, 3)
+                ) + 1e-12
+            )
+        )
+    return (
+        torch.stack(feature_list, dim=1),
+        torch.stack(activity_list, dim=1),
+    )
+
+
+class ZeroSourceResidualHead(nn.Module):
+    """Strict zero-input -> zero-output source residual probe."""
+    def __init__(
+        self,
+        input_channels: int,
+        hidden: int,
+        output_channels: int = 16,
+    ):
+        super().__init__()
+        self.net = nn.Sequential(
+            nn.Conv2d(
+                input_channels,
+                hidden,
+                3,
+                padding=1,
+                bias=False,
+            ),
+            nn.SiLU(),
+            nn.Conv2d(
+                hidden,
+                hidden,
+                3,
+                padding=1,
+                groups=hidden,
+                bias=False,
+            ),
+            nn.SiLU(),
+            nn.Conv2d(hidden, hidden, 1, bias=False),
+            nn.SiLU(),
+            nn.Conv2d(
+                hidden,
+                output_channels,
+                1,
+                bias=False,
+            ),
+        )
+        nn.init.normal_(
+            self.net[-1].weight,
+            mean=0.0,
+            std=1e-3,
+        )
+
+    def forward(self, value: torch.Tensor) -> torch.Tensor:
+        return self.net(value)
+
+
+class ConditionalInnovationProbe(nn.Module):
+    def __init__(
+        self,
+        source: str,
+        source_channels: int,
+        hidden: int,
+    ):
+        super().__init__()
+        self.source = source
+        feature_channels = source_channels * (
+            6 if source == "boundary" else 3
+        )
+        self.heads = nn.ModuleList([
+            ZeroSourceResidualHead(feature_channels, hidden)
+            for _ in HORIZONS
+        ])
+
+    def forward(
+        self,
+        sequence: torch.Tensor,
+    ) -> Tuple[torch.Tensor, torch.Tensor]:
+        features, activity = build_innovation(
+            sequence, self.source
+        )
+        outputs = [
+            self.heads[index](features[:, index])
+            for index in range(len(HORIZONS))
+        ]
+        return torch.stack(outputs, dim=1), activity
+
+
+class DualInnovationAudit(nn.Module):
+    def __init__(self, hidden: int):
+        super().__init__()
+        self.atmosphere = ConditionalInnovationProbe(
+            "atmosphere",
+            len(SOURCE_VARIABLES["atmosphere"]),
+            hidden,
+        )
+        self.boundary = ConditionalInnovationProbe(
+            "boundary",
+            len(SOURCE_VARIABLES["boundary"]),
+            hidden,
+        )
+
+    def forward(
+        self,
+        atmosphere: torch.Tensor,
+        boundary: torch.Tensor,
+    ) -> Dict[str, torch.Tensor]:
+        atmosphere_update, atmosphere_activity = self.atmosphere(
+            atmosphere
+        )
+        boundary_update, boundary_activity = self.boundary(
+            boundary
+        )
+        return {
+            "atmosphere": atmosphere_update,
+            "boundary": boundary_update,
+            "joint": atmosphere_update + boundary_update,
+            "atmosphere_activity": atmosphere_activity,
+            "boundary_activity": boundary_activity,
+        }
+
+
+def masked_sample_mse(
+    prediction: torch.Tensor,
+    target: torch.Tensor,
+    mask: torch.Tensor,
+) -> torch.Tensor:
+    expanded = mask[:, None].expand_as(prediction)
+    numerator = (
+        (prediction - target).square() * expanded
+    ).flatten(2).sum(dim=2)
+    denominator = (
+        expanded.flatten(2).sum(dim=2).clamp_min(1.0)
+    )
+    return numerator / denominator
+
+
+def masked_sample_cosine(
+    prediction: torch.Tensor,
+    target: torch.Tensor,
+    mask: torch.Tensor,
+) -> torch.Tensor:
+    expanded = mask[:, None].expand_as(prediction)
+    p = (prediction * expanded).flatten(2)
+    t = (target * expanded).flatten(2)
+    return (
+        (p * t).sum(dim=2)
+        / (
+            p.norm(dim=2) * t.norm(dim=2)
+            + 1e-8
+        )
+    )
+
+
+@torch.no_grad()
+def estimate_residual_scale(
+    parent: FrozenA0Parent,
+    loader: DataLoader,
+    device: torch.device,
+) -> torch.Tensor:
+    numerator = torch.zeros(
+        len(HORIZONS),
+        len(INTERNAL_VARIABLES),
+        device=device,
+    )
+    denominator = torch.zeros_like(numerator)
+    for raw_batch in loader:
+        batch = batch_to_device(raw_batch, device)
+        parent_prediction = parent(
+            batch["internal"], parent_sources(batch)
+        )
+        residual = batch["target"] - parent_prediction
+        mask = batch["mask"][:, None]
+        numerator += (
+            residual.square() * mask
+        ).sum(dim=(0, 3, 4))
+        denominator += (
+            mask.expand_as(residual)
+        ).sum(dim=(0, 3, 4))
+    scale = torch.sqrt(
+        numerator / denominator.clamp_min(1.0) + 1e-8
+    )
+    return scale.clamp_min(1e-3)
+
+
+def apply_scale(
+    normalized_update: torch.Tensor,
+    scale: torch.Tensor,
+) -> torch.Tensor:
+    return normalized_update * scale[
+        None, :, :, None, None
+    ]
+
+
+def weighted_source_loss(
+    prediction: torch.Tensor,
+    target: torch.Tensor,
+    mask: torch.Tensor,
+    activity: torch.Tensor,
+) -> torch.Tensor:
+    per_sample = masked_sample_mse(
+        prediction, target, mask
+    )
+    normalized_activity = activity / (
+        activity.mean(dim=0, keepdim=True) + 1e-6
+    )
+    weights = (0.5 + 0.5 * normalized_activity).clamp(
+        0.5, 2.0
+    )
+    horizon_weights = torch.tensor(
+        [0.25, 0.50, 1.0],
+        device=prediction.device,
+        dtype=prediction.dtype,
+    )
+    return (
+        per_sample * weights * horizon_weights[None]
+    ).mean()
+
+
+def rank_loss(
+    correct: torch.Tensor,
+    negative: torch.Tensor,
+    target: torch.Tensor,
+    mask: torch.Tensor,
+    margin: float,
+) -> torch.Tensor:
+    correct_mse = masked_sample_mse(
+        correct, target, mask
+    )
+    negative_mse = masked_sample_mse(
+        negative, target, mask
+    )
+    return F.relu(
+        margin + correct_mse - negative_mse
+    ).mean()
+
+
+def train_probe(
+    seed: int,
+    parent: FrozenA0Parent,
+    loaders: Mapping[str, DataLoader],
+    args: argparse.Namespace,
+    device: torch.device,
+    output_dir: Path,
+) -> Tuple[DualInnovationAudit, torch.Tensor, Dict[str, Any]]:
+    seed_everything(seed)
+    residual_scale = estimate_residual_scale(
+        parent, loaders["train"], device
+    )
+    model = DualInnovationAudit(args.hidden).to(device)
+
+    # Strict source zero sentinel.
+    sentinel_batch = batch_to_device(
+        next(iter(loaders["validation"])),
+        device,
+    )
+    with torch.no_grad():
+        zero_atmosphere = torch.zeros_like(
+            sentinel_batch["future_atmosphere"]
+        )
+        zero_boundary = torch.zeros_like(
+            sentinel_batch["future_boundary"]
+        )
+        zero_output = model(
+            zero_atmosphere, zero_boundary
+        )
+        source_zero_max = max(
+            float(zero_output["atmosphere"].abs().max()),
+            float(zero_output["boundary"].abs().max()),
+        )
+    if source_zero_max > 1e-8:
+        raise RuntimeError(
+            f"Source-zero sentinel failed: {source_zero_max}"
+        )
+
+    optimizer = torch.optim.AdamW(
+        model.parameters(),
+        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: List[Dict[str, Any]] = []
+
+    for epoch in range(1, args.epochs + 1):
+        model.train()
+        sums = {
+            "total": 0.0,
+            "atmosphere": 0.0,
+            "boundary": 0.0,
+            "joint": 0.0,
+            "rank": 0.0,
+            "alignment": 0.0,
+        }
+        for raw_batch in loaders["train"]:
+            batch = batch_to_device(raw_batch, device)
+            with torch.no_grad():
+                parent_prediction = parent(
+                    batch["internal"],
+                    parent_sources(batch),
+                )
+                residual = batch["target"] - parent_prediction
+                normalized_target = residual / residual_scale[
+                    None, :, :, None, None
+                ]
+
+            correct = model(
+                batch["future_atmosphere"],
+                batch["future_boundary"],
+            )
+            negative = model(
+                batch["negative_atmosphere"],
+                batch["negative_boundary"],
+            )
+            atmosphere_loss = weighted_source_loss(
+                correct["atmosphere"],
+                normalized_target,
+                batch["mask"],
+                correct["atmosphere_activity"],
+            )
+            boundary_loss = weighted_source_loss(
+                correct["boundary"],
+                normalized_target,
+                batch["mask"],
+                correct["boundary_activity"],
+            )
+            joint_activity = torch.maximum(
+                correct["atmosphere_activity"],
+                correct["boundary_activity"],
+            )
+            joint_loss = weighted_source_loss(
+                correct["joint"],
+                normalized_target,
+                batch["mask"],
+                joint_activity,
+            )
+            causal_rank = (
+                rank_loss(
+                    correct["atmosphere"],
+                    negative["atmosphere"],
+                    normalized_target,
+                    batch["mask"],
+                    args.rank_margin,
+                )
+                + rank_loss(
+                    correct["boundary"],
+                    negative["boundary"],
+                    normalized_target,
+                    batch["mask"],
+                    args.rank_margin,
+                )
+                + rank_loss(
+                    correct["joint"],
+                    negative["joint"],
+                    normalized_target,
+                    batch["mask"],
+                    args.rank_margin,
+                )
+            ) / 3.0
+            correct_cos = masked_sample_cosine(
+                correct["joint"],
+                normalized_target,
+                batch["mask"],
+            ).mean()
+            negative_cos = masked_sample_cosine(
+                negative["joint"],
+                normalized_target,
+                batch["mask"],
+            ).mean()
+            alignment = F.relu(
+                args.cosine_margin
+                - correct_cos
+                + negative_cos
+            )
+            loss = (
+                args.atmosphere_weight * atmosphere_loss
+                + args.boundary_weight * boundary_loss
+                + args.joint_weight * joint_loss
+                + args.rank_weight * causal_rank
+                + args.alignment_weight * alignment
+            )
+            if not torch.isfinite(loss):
+                raise RuntimeError(
+                    f"Non-finite training loss seed={seed} epoch={epoch}"
+                )
+            optimizer.zero_grad(set_to_none=True)
+            loss.backward()
+            torch.nn.utils.clip_grad_norm_(
+                model.parameters(), args.grad_clip
+            )
+            optimizer.step()
+            sums["total"] += float(loss.detach())
+            sums["atmosphere"] += float(atmosphere_loss.detach())
+            sums["boundary"] += float(boundary_loss.detach())
+            sums["joint"] += float(joint_loss.detach())
+            sums["rank"] += float(causal_rank.detach())
+            sums["alignment"] += float(alignment.detach())
+
+        validation = evaluate_raw_capacity(
+            model,
+            parent,
+            loaders["validation"],
+            residual_scale,
+            device,
+        )
+        # Lower normalized residual MSE is better; positive correct-control
+        # gaps lower the score without allowing variance objectives to dominate.
+        score = (
+            validation["joint_correct_mse"]
+            + 0.30 * validation["atmosphere_correct_mse"]
+            + 0.30 * validation["boundary_correct_mse"]
+            - args.selection_causal_weight
+            * max(validation["joint_negative_gap"], 0.0)
+        )
+        row = {
+            "seed": seed,
+            "epoch": epoch,
+            "validation_score": score,
+            **validation,
+            **{
+                f"train_{key}": value
+                / max(len(loaders["train"]), 1)
+                for key, value in sums.items()
+            },
+        }
+        logs.append(row)
+        print(
+            f"[R2 seed={seed}] epoch={epoch}/{args.epochs} "
+            f"score={score:.6f} joint={validation['joint_correct_mse']:.6f} "
+            f"atm_gap={validation['atmosphere_negative_gap']:.6e} "
+            f"bnd_gap={validation['boundary_negative_gap']:.6e} "
+            f"joint_gap={validation['joint_negative_gap']:.6e}",
+            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 best_state is None:
+        raise RuntimeError("No R2 checkpoint selected")
+    model.load_state_dict(best_state, strict=True)
+    checkpoint = output_dir / "checkpoints" / f"seed_{seed}.pt"
+    checkpoint.parent.mkdir(parents=True, exist_ok=True)
+    torch.save(
+        {
+            "model_state": best_state,
+            "residual_scale": residual_scale.detach().cpu(),
+            "seed": seed,
+            "best_epoch": best_epoch,
+            "validation_score": best_score,
+            "source_zero_max": source_zero_max,
+        },
+        checkpoint,
+    )
+    pd.DataFrame(logs).to_csv(
+        output_dir / "training" / f"seed_{seed}.csv",
+        index=False,
+    )
+    return model, residual_scale, {
+        "seed": seed,
+        "checkpoint": str(checkpoint),
+        "best_epoch": best_epoch,
+        "validation_score": best_score,
+        "source_zero_max": source_zero_max,
+    }
+
+
+@torch.no_grad()
+def evaluate_raw_capacity(
+    model: DualInnovationAudit,
+    parent: FrozenA0Parent,
+    loader: DataLoader,
+    residual_scale: torch.Tensor,
+    device: torch.device,
+) -> Dict[str, float]:
+    model.eval()
+    accum: Dict[str, List[float]] = {
+        "atmosphere_correct": [],
+        "atmosphere_negative": [],
+        "boundary_correct": [],
+        "boundary_negative": [],
+        "joint_correct": [],
+        "joint_negative": [],
+    }
+    cosine: Dict[str, List[float]] = {
+        "atmosphere": [],
+        "boundary": [],
+        "joint": [],
+    }
+    for raw_batch in loader:
+        batch = batch_to_device(raw_batch, device)
+        parent_prediction = parent(
+            batch["internal"], parent_sources(batch)
+        )
+        residual = batch["target"] - parent_prediction
+        normalized_target = residual / residual_scale[
+            None, :, :, None, None
+        ]
+        correct = model(
+            batch["future_atmosphere"],
+            batch["future_boundary"],
+        )
+        negative = model(
+            batch["negative_atmosphere"],
+            batch["negative_boundary"],
+        )
+        for source in ["atmosphere", "boundary", "joint"]:
+            accum[f"{source}_correct"].extend(
+                masked_sample_mse(
+                    correct[source],
+                    normalized_target,
+                    batch["mask"],
+                ).mean(dim=1).cpu().tolist()
+            )
+            accum[f"{source}_negative"].extend(
+                masked_sample_mse(
+                    negative[source],
+                    normalized_target,
+                    batch["mask"],
+                ).mean(dim=1).cpu().tolist()
+            )
+            cosine[source].extend(
+                masked_sample_cosine(
+                    correct[source],
+                    normalized_target,
+                    batch["mask"],
+                ).mean(dim=1).cpu().tolist()
+            )
+    result: Dict[str, float] = {}
+    for source in ["atmosphere", "boundary", "joint"]:
+        correct_value = float(
+            np.mean(accum[f"{source}_correct"])
+        )
+        negative_value = float(
+            np.mean(accum[f"{source}_negative"])
+        )
+        result[f"{source}_correct_mse"] = correct_value
+        result[f"{source}_negative_mse"] = negative_value
+        result[f"{source}_negative_gap"] = (
+            negative_value - correct_value
+        )
+        result[f"{source}_residual_cosine"] = float(
+            np.mean(cosine[source])
+        )
+    return result
+
+
+def group_alpha_tensor(
+    alpha: np.ndarray,
+    device: torch.device,
+    dtype: torch.dtype,
+) -> torch.Tensor:
+    # alpha [H,G] -> [1,H,C,1,1]
+    result = torch.zeros(
+        1,
+        len(HORIZONS),
+        len(INTERNAL_VARIABLES),
+        1,
+        1,
+        device=device,
+        dtype=dtype,
+    )
+    for group_index, indices in enumerate(GROUPS.values()):
+        result[:, :, indices] = torch.as_tensor(
+            alpha[:, group_index],
+            device=device,
+            dtype=dtype,
+        )[None, :, None, None, None]
+    return result
+
+
+@torch.no_grad()
+def collect_validation_arrays(
+    model: DualInnovationAudit,
+    parent: FrozenA0Parent,
+    loader: DataLoader,
+    residual_scale: torch.Tensor,
+    device: torch.device,
+) -> Dict[str, np.ndarray]:
+    model.eval()
+    collected: Dict[str, List[np.ndarray]] = {
+        "residual": [],
+        "mask": [],
+        "atmosphere": [],
+        "boundary": [],
+        "atmosphere_activity": [],
+        "boundary_activity": [],
+    }
+    for raw_batch in loader:
+        batch = batch_to_device(raw_batch, device)
+        parent_prediction = parent(
+            batch["internal"], parent_sources(batch)
+        )
+        residual = batch["target"] - parent_prediction
+        output = model(
+            batch["future_atmosphere"],
+            batch["future_boundary"],
+        )
+        collected["residual"].append(
+            residual.cpu().numpy()
+        )
+        collected["mask"].append(
+            batch["mask"].cpu().numpy()
+        )
+        for source in SOURCES:
+            collected[source].append(
+                apply_scale(
+                    output[source], residual_scale
+                ).cpu().numpy()
+            )
+            collected[f"{source}_activity"].append(
+                output[f"{source}_activity"]
+                .cpu().numpy()
+            )
+    return {
+        key: np.concatenate(values, axis=0)
+        for key, values in collected.items()
+    }
+
+
+def fit_nonnegative_group_coefficients(
+    arrays: Mapping[str, np.ndarray],
+    max_alpha: float,
+) -> Dict[str, Any]:
+    residual = arrays["residual"]
+    mask = arrays["mask"][:, None]
+    atmosphere = arrays["atmosphere"]
+    boundary = arrays["boundary"]
+    alpha_atmosphere = np.zeros(
+        (len(HORIZONS), len(GROUPS)), dtype=np.float32
+    )
+    alpha_boundary = np.zeros_like(alpha_atmosphere)
+    alpha_joint_atmosphere = np.zeros_like(alpha_atmosphere)
+    alpha_joint_boundary = np.zeros_like(alpha_atmosphere)
+    grid = np.linspace(0.0, max_alpha, 13, dtype=np.float32)
+
+    for hi in range(len(HORIZONS)):
+        for gi, indices in enumerate(GROUPS.values()):
+            r = residual[:, hi, indices]
+            a = atmosphere[:, hi, indices]
+            b = boundary[:, hi, indices]
+            m = mask[:, 0]
+            denominator_a = float((a * a * m).sum()) + 1e-12
+            denominator_b = float((b * b * m).sum()) + 1e-12
+            alpha_atmosphere[hi, gi] = np.clip(
+                float((a * r * m).sum()) / denominator_a,
+                0.0,
+                max_alpha,
+            )
+            alpha_boundary[hi, gi] = np.clip(
+                float((b * r * m).sum()) / denominator_b,
+                0.0,
+                max_alpha,
+            )
+            best = (float("inf"), 0.0, 0.0)
+            for aa in grid:
+                for bb in grid:
+                    error = (
+                        (r - aa * a - bb * b) ** 2 * m
+                    ).sum()
+                    if float(error) < best[0]:
+                        best = (float(error), float(aa), float(bb))
+            alpha_joint_atmosphere[hi, gi] = best[1]
+            alpha_joint_boundary[hi, gi] = best[2]
+
+    thresholds = {
+        source: np.quantile(
+            arrays[f"{source}_activity"],
+            0.80,
+            axis=0,
+        ).astype(np.float32)
+        for source in SOURCES
+    }
+    return {
+        "alpha_atmosphere": alpha_atmosphere,
+        "alpha_boundary": alpha_boundary,
+        "alpha_joint_atmosphere": alpha_joint_atmosphere,
+        "alpha_joint_boundary": alpha_joint_boundary,
+        "activity_thresholds": thresholds,
+    }
+
+
+def mode_definition(mode: str) -> Tuple[str, str]:
+    if mode == "parent":
+        return "none", "correct"
+    if mode.startswith("atmosphere_"):
+        return "atmosphere", mode.split("_", 1)[1]
+    if mode.startswith("boundary_"):
+        return "boundary", mode.split("_", 1)[1]
+    if mode.startswith("joint_"):
+        return "joint", mode.split("_", 1)[1]
+    raise ValueError(mode)
+
+
+@torch.no_grad()
+def evaluate_mode(
+    model: DualInnovationAudit,
+    parent: FrozenA0Parent,
+    loader: DataLoader,
+    residual_scale: torch.Tensor,
+    coefficients: Mapping[str, Any],
+    device: torch.device,
+    mode: str,
+) -> Dict[str, Any]:
+    model.eval()
+    source_mode, control = mode_definition(mode)
+    squared = {horizon: 0.0 for horizon in HORIZONS}
+    count = {horizon: 0.0 for horizon in HORIZONS}
+    prediction_values = {
+        horizon: [] for horizon in HORIZONS
+    }
+    target_values = {
+        horizon: [] for horizon in HORIZONS
+    }
+    sample_rows: List[Dict[str, Any]] = []
+    group_rows: Dict[Tuple[int, str], List[float]] = {
+        (horizon, group): []
+        for horizon in HORIZONS
+        for group in GROUPS
+    }
+    cosine_rows: List[Dict[str, Any]] = []
+    update_ratio_rows: List[Dict[str, Any]] = []
+
+    for raw_batch in loader:
+        batch = batch_to_device(raw_batch, device)
+        parent_prediction = parent(
+            batch["internal"], parent_sources(batch)
+        )
+        target = batch["target"]
+        if source_mode == "none":
+            update = torch.zeros_like(parent_prediction)
+            atmosphere_activity = torch.zeros(
+                parent_prediction.shape[0],
+                len(HORIZONS),
+                device=device,
+            )
+            boundary_activity = torch.zeros_like(
+                atmosphere_activity
+            )
+        else:
+            atmosphere_sequence = control_sequence(
+                batch["future_atmosphere"],
+                batch["negative_atmosphere"],
+                control,
+            )
+            boundary_sequence = control_sequence(
+                batch["future_boundary"],
+                batch["negative_boundary"],
+                control,
+            )
+            output = model(
+                atmosphere_sequence, boundary_sequence
+            )
+            atmosphere_raw = apply_scale(
+                output["atmosphere"], residual_scale
+            )
+            boundary_raw = apply_scale(
+                output["boundary"], residual_scale
+            )
+            atmosphere_activity = output[
+                "atmosphere_activity"
+            ]
+            boundary_activity = output[
+                "boundary_activity"
+            ]
+            if source_mode == "atmosphere":
+                alpha = group_alpha_tensor(
+                    coefficients["alpha_atmosphere"],
+                    device,
+                    parent_prediction.dtype,
+                )
+                update = alpha * atmosphere_raw
+            elif source_mode == "boundary":
+                alpha = group_alpha_tensor(
+                    coefficients["alpha_boundary"],
+                    device,
+                    parent_prediction.dtype,
+                )
+                update = alpha * boundary_raw
+            else:
+                alpha_a = group_alpha_tensor(
+                    coefficients["alpha_joint_atmosphere"],
+                    device,
+                    parent_prediction.dtype,
+                )
+                alpha_b = group_alpha_tensor(
+                    coefficients["alpha_joint_boundary"],
+                    device,
+                    parent_prediction.dtype,
+                )
+                update = (
+                    alpha_a * atmosphere_raw
+                    + alpha_b * boundary_raw
+                )
+
+        prediction = parent_prediction + update
+        residual_target = target - parent_prediction
+        update_cosine = masked_sample_cosine(
+            update,
+            residual_target,
+            batch["mask"],
+        )
+        update_ratio = torch.sqrt(
+            update.square().mean(dim=(2, 3, 4)) + 1e-12
+        ) / (
+            torch.sqrt(
+                parent_prediction.square().mean(
+                    dim=(2, 3, 4)
+                ) + 1e-12
+            ) + 1e-6
+        )
+        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)
+                * prediction.shape[2]
+            )
+            per_sample_mse = (
+                error.flatten(1).sum(dim=1)
+                / denominator
+            )
+            squared[horizon] += float(error.sum())
+            count[horizon] += (
+                float(batch["mask"].sum())
+                * prediction.shape[2]
+            )
+            prediction_values[horizon].append(
+                (prediction[:, hi] * batch["mask"])
+                .flatten(1).cpu()
+            )
+            target_values[horizon].append(
+                (target[:, hi] * batch["mask"])
+                .flatten(1).cpu()
+            )
+            for bi in range(prediction.shape[0]):
+                sample_rows.append({
+                    "sample_index": int(
+                        batch["sample_index"][bi]
+                    ),
+                    "horizon": horizon,
+                    "mse": float(per_sample_mse[bi]),
+                    "rmse": math.sqrt(
+                        max(float(per_sample_mse[bi]), 0.0)
+                    ),
+                    "atmosphere_activity": float(
+                        atmosphere_activity[bi, hi]
+                    ),
+                    "boundary_activity": float(
+                        boundary_activity[bi, hi]
+                    ),
+                })
+                cosine_rows.append({
+                    "sample_index": int(
+                        batch["sample_index"][bi]
+                    ),
+                    "horizon": horizon,
+                    "cosine": float(
+                        update_cosine[bi, hi]
+                    ),
+                })
+                update_ratio_rows.append({
+                    "sample_index": int(
+                        batch["sample_index"][bi]
+                    ),
+                    "horizon": horizon,
+                    "update_ratio": float(
+                        update_ratio[bi, hi]
+                    ),
+                })
+            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_rows[(horizon, group)].extend(
+                    group_rmse.cpu().tolist()
+                )
+
+    metrics: Dict[str, Any] = {}
+    for horizon in HORIZONS:
+        metrics[f"rmse_h{horizon}"] = math.sqrt(
+            squared[horizon]
+            / max(count[horizon], 1.0)
+        )
+        pred = torch.cat(
+            prediction_values[horizon], dim=0
+        )
+        truth = torch.cat(
+            target_values[horizon], dim=0
+        )
+        metrics[f"variance_ratio_h{horizon}"] = float(
+            pred.var(unbiased=False)
+            / (truth.var(unbiased=False) + 1e-8)
+        )
+    for (horizon, group), values in group_rows.items():
+        metrics[
+            f"group_rmse_{group}_h{horizon}"
+        ] = float(np.mean(values))
+    metrics["sample_rows"] = sample_rows
+    metrics["cosine_mean"] = float(
+        pd.DataFrame(cosine_rows)["cosine"].mean()
+    )
+    metrics["update_ratio_mean"] = float(
+        pd.DataFrame(update_ratio_rows)[
+            "update_ratio"
+        ].mean()
+    )
+    return metrics
+
+
+def paired_bootstrap(
+    reference: np.ndarray,
+    candidate: np.ndarray,
+    replicates: int,
+    seed: int,
+) -> Dict[str, float]:
+    if len(reference) != len(candidate):
+        raise ValueError("Paired arrays have different lengths")
+    difference = candidate - reference
+    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
+            * (reference.mean() - candidate.mean())
+            / max(reference.mean(), 1e-12)
+        ),
+        "n": int(len(difference)),
+    }
+
+
+def activity_subset_result(
+    parent_table: pd.DataFrame,
+    correct_table: pd.DataFrame,
+    negative_table: pd.DataFrame,
+    source: str,
+    horizon: int,
+    threshold: float,
+) -> Dict[str, float]:
+    activity_column = f"{source}_activity"
+    correct = correct_table[
+        correct_table.horizon == horizon
+    ].sort_values("sample_index")
+    parent = parent_table[
+        parent_table.horizon == horizon
+    ].sort_values("sample_index")
+    negative = negative_table[
+        negative_table.horizon == horizon
+    ].sort_values("sample_index")
+    if not (
+        np.array_equal(
+            correct.sample_index.to_numpy(),
+            parent.sample_index.to_numpy(),
+        )
+        and np.array_equal(
+            correct.sample_index.to_numpy(),
+            negative.sample_index.to_numpy(),
+        )
+    ):
+        raise RuntimeError("Activity subset pairing mismatch")
+    active = correct[activity_column].to_numpy() >= threshold
+    if active.sum() == 0:
+        return {
+            "n": 0,
+            "gain_vs_parent_percent": float("nan"),
+            "gain_vs_negative_percent": float("nan"),
+        }
+    parent_mse = parent.mse.to_numpy()[active]
+    correct_mse = correct.mse.to_numpy()[active]
+    negative_mse = negative.mse.to_numpy()[active]
+    return {
+        "n": int(active.sum()),
+        "gain_vs_parent_percent": float(
+            100.0
+            * (parent_mse.mean() - correct_mse.mean())
+            / max(parent_mse.mean(), 1e-12)
+        ),
+        "gain_vs_negative_percent": float(
+            100.0
+            * (negative_mse.mean() - correct_mse.mean())
+            / max(negative_mse.mean(), 1e-12)
+        ),
+    }
+
+
+def runtime_audit(
+    model: DualInnovationAudit,
+    loader: DataLoader,
+    device: torch.device,
+    warmup: int = 10,
+    repeats: int = 50,
+) -> Dict[str, float]:
+    model.eval()
+    batch = batch_to_device(
+        next(iter(loader)), device
+    )
+    def execute() -> None:
+        model(
+            batch["future_atmosphere"],
+            batch["future_boundary"],
+        )
+    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
+    batch_size = batch["internal"].shape[0]
+    return {
+        "batch_size": int(batch_size),
+        "mean_batch_ms": 1000.0 * elapsed / repeats,
+        "mean_sample_ms": (
+            1000.0 * elapsed / repeats / batch_size
+        ),
+    }
+
+
+def plot_summary(
+    summary: pd.DataFrame,
+    activity: pd.DataFrame,
+    output_dir: Path,
+) -> None:
+    output_dir.mkdir(parents=True, exist_ok=True)
+    subset = summary[
+        summary["horizon"] == 12
+    ].copy()
+    plt.figure(figsize=(11, 5))
+    plt.bar(
+        subset["mode"],
+        subset["rmse_gain_vs_parent_percent"],
+    )
+    plt.axhline(0, linewidth=1)
+    plt.ylabel("72 h RMSE gain over A0 parent (%)")
+    plt.xticks(rotation=30, ha="right")
+    plt.tight_layout()
+    plt.savefig(
+        output_dir / "S2A1R2_72h_RMSE_gain.png",
+        dpi=180,
+    )
+    plt.close()
+
+    plt.figure(figsize=(8, 5))
+    active72 = activity[
+        activity["horizon"] == 12
+    ]
+    labels = (
+        active72["source"]
+        + "_"
+        + active72["seed"].astype(str)
+    )
+    plt.bar(
+        labels,
+        active72["gain_vs_parent_percent"],
+    )
+    plt.axhline(0, linewidth=1)
+    plt.ylabel("Top-20% active subset RMSE gain (%)")
+    plt.xticks(rotation=30, ha="right")
+    plt.tight_layout()
+    plt.savefig(
+        output_dir / "S2A1R2_active_subset_gain.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 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(20260930)
+    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")
+        )
+        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)
+        internal = generator.normal(
+            0, 0.5, (t, 16, h, w)
+        ).astype(np.float32)
+        for index in range(1, t):
+            forcing = (
+                0.04 * atmosphere[index, :1]
+                + 0.03 * boundary[index, :1]
+            )
+            internal[index] = (
+                0.90 * internal[index - 1]
+                + forcing
+                + generator.normal(
+                    0, 0.03, 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,
+        )
+        np.savez_compressed(
+            prepared / f"{spec['name']}_tide.npz",
+            time=stamp,
+            tide=np.zeros(
+                (t, 11, h, w), np.float32
+            ),
+            actual_spatial_tide=np.asarray([0], np.int8),
+        )
+        np.savez_compressed(
+            prepared / f"{spec['name']}_river.npz",
+            time=stamp,
+            river=np.zeros(
+                (t, 2, h, w), np.float32
+            ),
+            available=np.asarray([0], np.int8),
+        )
+        np.savez_compressed(
+            prepared / f"{spec['name']}_events.npz",
+            time=stamp,
+            events=np.zeros(
+                (t, 3, h, w), np.float32
+            ),
+            available=np.asarray([0], np.int8),
+        )
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        description=(
+            "CIDM-v3 S2-A1-R2 conditional external "
+            "innovation capacity audit"
+        )
+    )
+    parser.add_argument(
+        "--cache_dir",
+        default="/content/CIDM_v3_SCS_S2A0_Cache",
+    )
+    parser.add_argument(
+        "--r1_zip",
+        default="/content/CIDM_v3_SCS_V3_S2_A1_R1.zip",
+    )
+    parser.add_argument(
+        "--output_dir",
+        default="/content/CIDM_v3_SCS_V3_S2_A1_R2",
+    )
+    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=10)
+    parser.add_argument("--batch_size", type=int, default=4)
+    parser.add_argument("--num_workers", type=int, default=0)
+    parser.add_argument("--hidden", type=int, default=40)
+    parser.add_argument(
+        "--learning_rate", type=float, default=3e-4
+    )
+    parser.add_argument(
+        "--weight_decay", type=float, default=1e-4
+    )
+    parser.add_argument(
+        "--atmosphere_weight", type=float, default=0.30
+    )
+    parser.add_argument(
+        "--boundary_weight", type=float, default=0.30
+    )
+    parser.add_argument(
+        "--joint_weight", type=float, default=0.40
+    )
+    parser.add_argument(
+        "--rank_weight", type=float, default=0.20
+    )
+    parser.add_argument(
+        "--alignment_weight", type=float, default=0.05
+    )
+    parser.add_argument(
+        "--rank_margin", type=float, default=0.002
+    )
+    parser.add_argument(
+        "--cosine_margin", type=float, default=0.01
+    )
+    parser.add_argument(
+        "--selection_causal_weight",
+        type=float,
+        default=0.50,
+    )
+    parser.add_argument(
+        "--max_alpha", type=float, default=1.5
+    )
+    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 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-R2 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, "恢复R1谱系和四季prepared数据")
+        if args.synthetic_smoke:
+            create_synthetic_assets(args)
+            hf_report = {"synthetic_smoke": True}
+        else:
+            hf_report = ensure_hf_assets(args)
+        atomic_json(
+            hf_report,
+            output_dir
+            / "audits"
+            / "S2A1R2_HF_asset_audit.json",
+        )
+
+        stage(2, 11, "提取R1结论与嵌套A0冻结父链")
+        assets = extract_r1_lineage(
+            Path(args.r1_zip),
+            output_dir / "_parent",
+        )
+        r1_verdict = json.loads(
+            assets["r1_verdict"].read_text(
+                encoding="utf-8"
+            )
+        )
+        r1_aggregate = json.loads(
+            assets["r1_aggregate"].read_text(
+                encoding="utf-8"
+            )
+        )
+        atomic_json(
+            {
+                "r1_verdict": r1_verdict,
+                "r1_aggregate": r1_aggregate,
+                "r2_parent": (
+                    "Frozen S2-A0 internal + history/current "
+                    "external adapter"
+                ),
+                "vertical_note": (
+                    "Current vertical context is already contained "
+                    "in A0 and is not treated as new future innovation."
+                ),
+            },
+            output_dir
+            / "lineage"
+            / "S2A1R2_parent_lineage.json",
+        )
+
+        stage(3, 11, "加载四季数据并建立同季节负样本")
+        windows = [
+            load_window(Path(args.cache_dir), spec)
+            for spec in WINDOWS
+        ]
+        loaders, split_audit = build_loaders(
+            windows, assets["stats"], args
+        )
+        atomic_json(
+            split_audit,
+            output_dir
+            / "audits"
+            / "S2A1R2_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
+                    )
+                ),
+                "finite": True,
+            })
+        pd.DataFrame(shape_rows).to_csv(
+            output_dir
+            / "audits"
+            / "S2A1R2_data_shape_audit.csv",
+            index=False,
+        )
+
+        stage(4, 11, "重建三种子A0父模型")
+        parents = {
+            seed: load_parent(
+                assets["a0_root"], seed, device
+            )
+            for seed in seeds
+        }
+
+        stage(5, 11, "训练来源专属条件创新残差探针")
+        models: Dict[int, DualInnovationAudit] = {}
+        residual_scales: Dict[int, torch.Tensor] = {}
+        training_records = []
+        for seed in seeds:
+            model, scale, record = train_probe(
+                seed,
+                parents[seed],
+                loaders,
+                args,
+                device,
+                output_dir,
+            )
+            models[seed] = model
+            residual_scales[seed] = scale
+            training_records.append(record)
+        training_table = pd.DataFrame(training_records)
+        training_table.to_csv(
+            output_dir
+            / "S2A1R2_training_summary.csv",
+            index=False,
+        )
+
+        stage(6, 11, "仅用验证集拟合非负来源收缩系数")
+        coefficient_payload: Dict[str, Any] = {}
+        coefficients: Dict[int, Dict[str, Any]] = {}
+        for seed in seeds:
+            arrays = collect_validation_arrays(
+                models[seed],
+                parents[seed],
+                loaders["validation"],
+                residual_scales[seed],
+                device,
+            )
+            fitted = fit_nonnegative_group_coefficients(
+                arrays, args.max_alpha
+            )
+            coefficients[seed] = fitted
+            coefficient_payload[str(seed)] = {
+                key: value
+                for key, value in fitted.items()
+            }
+        atomic_json(
+            coefficient_payload,
+            output_dir
+            / "S2A1R2_validation_coefficients.json",
+        )
+
+        stage(7, 11, "评估正确创新、负样本和时间反事实")
+        modes = [
+            "parent",
+            "atmosphere_correct",
+            "atmosphere_negative",
+            "atmosphere_history",
+            "atmosphere_reversed",
+            "atmosphere_shifted",
+            "boundary_correct",
+            "boundary_negative",
+            "boundary_history",
+            "boundary_reversed",
+            "boundary_shifted",
+            "joint_correct",
+            "joint_negative",
+            "joint_history",
+            "joint_reversed",
+            "joint_shifted",
+        ]
+        metric_rows = []
+        sample_tables: Dict[Tuple[int, str], pd.DataFrame] = {}
+        for seed in seeds:
+            for mode in modes:
+                metrics = evaluate_mode(
+                    models[seed],
+                    parents[seed],
+                    loaders["test"],
+                    residual_scales[seed],
+                    coefficients[seed],
+                    device,
+                    mode,
+                )
+                sample_tables[(seed, mode)] = pd.DataFrame(
+                    metrics.pop("sample_rows")
+                )
+                metric_rows.append({
+                    "seed": seed,
+                    "mode": mode,
+                    **metrics,
+                })
+        metric_table = pd.DataFrame(metric_rows)
+        metric_table.to_csv(
+            output_dir
+            / "evaluation"
+            / "S2A1R2_seed_metrics.csv",
+            index=False,
+        )
+
+        stage(8, 11, "配对Bootstrap和事件活跃子集审计")
+        parent_rmse = {
+            horizon: metric_table[
+                metric_table["mode"] == "parent"
+            ][f"rmse_h{horizon}"].mean()
+            for horizon in HORIZONS
+        }
+        summary_rows = []
+        bootstrap_payload: Dict[str, Any] = {}
+        for mode in modes:
+            for horizon in HORIZONS:
+                subset = metric_table[
+                    metric_table["mode"] == mode
+                ]
+                rmse = float(
+                    subset[f"rmse_h{horizon}"].mean()
+                )
+                variance = float(
+                    subset[
+                        f"variance_ratio_h{horizon}"
+                    ].mean()
+                )
+                reference_all = []
+                candidate_all = []
+                seed_gains = []
+                for seed in seeds:
+                    reference = sample_tables[
+                        (seed, "parent")
+                    ]
+                    candidate = sample_tables[(seed, mode)]
+                    reference_mse = reference[
+                        reference.horizon == horizon
+                    ].sort_values(
+                        "sample_index"
+                    ).mse.to_numpy()
+                    candidate_mse = candidate[
+                        candidate.horizon == horizon
+                    ].sort_values(
+                        "sample_index"
+                    ).mse.to_numpy()
+                    reference_all.append(reference_mse)
+                    candidate_all.append(candidate_mse)
+                    reference_rmse = float(
+                        metric_table[
+                            (metric_table.seed == seed)
+                            & (metric_table["mode"] == "parent")
+                        ][f"rmse_h{horizon}"].iloc[0]
+                    )
+                    candidate_rmse = float(
+                        metric_table[
+                            (metric_table.seed == seed)
+                            & (metric_table["mode"] == mode)
+                        ][f"rmse_h{horizon}"].iloc[0]
+                    )
+                    seed_gains.append(
+                        100.0
+                        * (
+                            reference_rmse
+                            - candidate_rmse
+                        )
+                        / reference_rmse
+                    )
+                bootstrap = paired_bootstrap(
+                    np.concatenate(reference_all),
+                    np.concatenate(candidate_all),
+                    args.bootstrap_reps,
+                    seeds[0]
+                    + horizon * 1000
+                    + sum(ord(char) for char in mode),
+                )
+                bootstrap_payload[
+                    f"{mode}_h{horizon}"
+                ] = bootstrap
+                summary_rows.append({
+                    "mode": mode,
+                    "horizon": horizon,
+                    "lead_hours": horizon * 6,
+                    "rmse": rmse,
+                    "variance_ratio": variance,
+                    "rmse_gain_vs_parent_percent": (
+                        100.0
+                        * (parent_rmse[horizon] - rmse)
+                        / parent_rmse[horizon]
+                    ),
+                    "mse_gain_vs_parent_percent": (
+                        bootstrap["mse_gain_percent"]
+                    ),
+                    "bootstrap_low": bootstrap["ci_low"],
+                    "bootstrap_high": bootstrap["ci_high"],
+                    "all_seed_positive": bool(
+                        all(value > 0 for value in seed_gains)
+                    ),
+                    "seed_gain_min": float(
+                        min(seed_gains)
+                    ),
+                    "seed_gain_max": float(
+                        max(seed_gains)
+                    ),
+                })
+        summary = pd.DataFrame(summary_rows)
+        summary.to_csv(
+            output_dir
+            / "S2A1R2_counterfactual_summary.csv",
+            index=False,
+        )
+        atomic_json(
+            bootstrap_payload,
+            output_dir / "paired_bootstrap.json",
+        )
+
+        activity_rows = []
+        for seed in seeds:
+            for source in SOURCES:
+                correct_mode = f"{source}_correct"
+                negative_mode = f"{source}_negative"
+                for hi, horizon in enumerate(HORIZONS):
+                    result = activity_subset_result(
+                        sample_tables[(seed, "parent")],
+                        sample_tables[(seed, correct_mode)],
+                        sample_tables[(seed, negative_mode)],
+                        source,
+                        horizon,
+                        float(
+                            coefficients[seed][
+                                "activity_thresholds"
+                            ][source][hi]
+                        ),
+                    )
+                    activity_rows.append({
+                        "seed": seed,
+                        "source": source,
+                        "horizon": horizon,
+                        "lead_hours": horizon * 6,
+                        "validation_threshold": float(
+                            coefficients[seed][
+                                "activity_thresholds"
+                            ][source][hi]
+                        ),
+                        **result,
+                    })
+        activity_table = pd.DataFrame(activity_rows)
+        activity_table.to_csv(
+            output_dir
+            / "S2A1R2_active_subset_summary.csv",
+            index=False,
+        )
+
+        stage(9, 11, "来源容量与正式分流判决")
+        runtime_rows = []
+        for seed in seeds:
+            runtime_row = runtime_audit(
+                models[seed],
+                loaders["test"],
+                device,
+            )
+            runtime_row["seed"] = seed
+            runtime_rows.append(runtime_row)
+        runtime_table = pd.DataFrame(runtime_rows)
+        runtime_table.to_csv(
+            output_dir / "S2A1R2_runtime.csv",
+            index=False,
+        )
+
+        def value(
+            mode: str,
+            horizon: int,
+            column: str,
+        ) -> float:
+            return float(
+                summary[
+                    (summary["mode"] == mode)
+                    & (summary["horizon"] == horizon)
+                ][column].iloc[0]
+            )
+
+        atmosphere_gain = value(
+            "atmosphere_correct",
+            12,
+            "rmse_gain_vs_parent_percent",
+        )
+        boundary_gain = value(
+            "boundary_correct",
+            12,
+            "rmse_gain_vs_parent_percent",
+        )
+        joint_gain = value(
+            "joint_correct",
+            12,
+            "rmse_gain_vs_parent_percent",
+        )
+        atmosphere_negative_gap = (
+            value(
+                "atmosphere_negative", 12, "rmse"
+            )
+            - value(
+                "atmosphere_correct", 12, "rmse"
+            )
+        ) / value(
+            "atmosphere_negative", 12, "rmse"
+        ) * 100.0
+        boundary_negative_gap = (
+            value(
+                "boundary_negative", 12, "rmse"
+            )
+            - value(
+                "boundary_correct", 12, "rmse"
+            )
+        ) / value(
+            "boundary_negative", 12, "rmse"
+        ) * 100.0
+        joint_negative_gap = (
+            value("joint_negative", 12, "rmse")
+            - value("joint_correct", 12, "rmse")
+        ) / value(
+            "joint_negative", 12, "rmse"
+        ) * 100.0
+        joint_variance_change = (
+            value(
+                "joint_correct", 12, "variance_ratio"
+            )
+            - value(
+                "parent", 12, "variance_ratio"
+            )
+        )
+        atmosphere_active = float(
+            activity_table[
+                (activity_table.source == "atmosphere")
+                & (activity_table.horizon == 12)
+            ]["gain_vs_parent_percent"].mean()
+        )
+        boundary_active = float(
+            activity_table[
+                (activity_table.source == "boundary")
+                & (activity_table.horizon == 12)
+            ]["gain_vs_parent_percent"].mean()
+        )
+        source_zero_max = float(
+            training_table["source_zero_max"].max()
+        )
+        all_seed_joint = bool(
+            summary[
+                (summary["mode"] == "joint_correct")
+                & (summary["horizon"] == 12)
+            ]["all_seed_positive"].iloc[0]
+        )
+        joint_bootstrap_positive = value(
+            "joint_correct", 12, "bootstrap_high"
+        ) < 0
+        atmosphere_bootstrap_positive = value(
+            "atmosphere_correct", 12, "bootstrap_high"
+        ) < 0
+        boundary_bootstrap_positive = value(
+            "boundary_correct", 12, "bootstrap_high"
+        ) < 0
+
+        checks = {
+            "r1_and_nested_a0_loaded_three_seeds": (
+                len(parents) == 3 and len(seeds) == 3
+            ),
+            "source_zero_sentinel_lt_1e8": (
+                source_zero_max < 1e-8
+            ),
+            "validation_only_coefficients_present": (
+                len(coefficients) == len(seeds)
+            ),
+            "atmosphere_72h_gain_ge_0_10pct": (
+                atmosphere_gain >= 0.10
+            ),
+            "atmosphere_72h_bootstrap_positive": (
+                atmosphere_bootstrap_positive
+            ),
+            "atmosphere_correct_beats_negative_ge_0_05pct": (
+                atmosphere_negative_gap >= 0.05
+            ),
+            "boundary_72h_gain_ge_0_05pct": (
+                boundary_gain >= 0.05
+            ),
+            "boundary_72h_bootstrap_positive": (
+                boundary_bootstrap_positive
+            ),
+            "boundary_correct_beats_negative_ge_0_03pct": (
+                boundary_negative_gap >= 0.03
+            ),
+            "joint_72h_gain_ge_0_30pct": (
+                joint_gain >= 0.30
+            ),
+            "joint_all_three_seeds_positive": (
+                all_seed_joint
+            ),
+            "joint_72h_bootstrap_positive": (
+                joint_bootstrap_positive
+            ),
+            "joint_correct_beats_negative_ge_0_08pct": (
+                joint_negative_gap >= 0.08
+            ),
+            "atmosphere_active_top20_gain_ge_0_30pct": (
+                atmosphere_active >= 0.30
+            ),
+            "boundary_active_top20_gain_ge_0_20pct": (
+                boundary_active >= 0.20
+            ),
+            "joint_variance_not_worse_by_0_02": (
+                joint_variance_change >= -0.02
+            ),
+            "mean_probe_runtime_lt_10ms": (
+                float(
+                    runtime_table[
+                        "mean_sample_ms"
+                    ].mean()
+                ) < 10.0
+            ),
+            "all_metrics_finite": bool(
+                np.isfinite(
+                    metric_table.select_dtypes(
+                        include=[np.number]
+                    ).to_numpy()
+                ).all()
+            ),
+        }
+        passed = sum(bool(item) for item in checks.values())
+        critical = [
+            "source_zero_sentinel_lt_1e8",
+            "joint_72h_gain_ge_0_30pct",
+            "joint_all_three_seeds_positive",
+            "joint_72h_bootstrap_positive",
+            "joint_correct_beats_negative_ge_0_08pct",
+        ]
+        if all(checks[item] for item in critical) and passed >= 14:
+            verdict_name = (
+                "V3_S2_A1_R2_CONDITIONAL_EXTERNAL_INNOVATION_CAPACITY_QUALIFIED"
+            )
+            recommendation = (
+                "Proceed to S2-A1-R3 and construct the production BER "
+                "only from the source representations qualified here."
+            )
+        elif (
+            atmosphere_active >= 0.30
+            or boundary_active >= 0.20
+        ) and passed >= 9:
+            verdict_name = (
+                "V3_S2_A1_R2_CONDITIONAL_EXTERNAL_INNOVATION_CAPACITY_EVENT_CONDITIONAL"
+            )
+            recommendation = (
+                "Do not integrate BER yet. Expand event-rich windows and "
+                "train an event-conditioned reservoir using the winning source."
+            )
+        else:
+            verdict_name = (
+                "V3_S2_A1_R2_CONDITIONAL_EXTERNAL_INNOVATION_CAPACITY_NOT_ESTABLISHED"
+            )
+            recommendation = (
+                "Stop tuning BER on the 139-day ordinary-season dataset. "
+                "Expand event-rich and boundary-entry data before another BER round."
+            )
+        aggregate = {
+            "atmosphere_72h_rmse_gain_percent": atmosphere_gain,
+            "boundary_72h_rmse_gain_percent": boundary_gain,
+            "joint_72h_rmse_gain_percent": joint_gain,
+            "atmosphere_correct_vs_negative_percent": (
+                atmosphere_negative_gap
+            ),
+            "boundary_correct_vs_negative_percent": (
+                boundary_negative_gap
+            ),
+            "joint_correct_vs_negative_percent": (
+                joint_negative_gap
+            ),
+            "atmosphere_active_top20_gain_percent": (
+                atmosphere_active
+            ),
+            "boundary_active_top20_gain_percent": (
+                boundary_active
+            ),
+            "joint_variance_change": joint_variance_change,
+            "source_zero_max": source_zero_max,
+            "mean_probe_runtime_ms": float(
+                runtime_table["mean_sample_ms"].mean()
+            ),
+        }
+        verdict = {
+            "automatic_verdict": verdict_name,
+            "passed": passed,
+            "total": len(checks),
+            "checks": checks,
+            "critical_checks": critical,
+            "aggregate": aggregate,
+            "next_stage_recommendation": recommendation,
+        }
+        atomic_json(
+            aggregate,
+            output_dir
+            / "S2A1R2_main_aggregate.json",
+        )
+        atomic_json(
+            verdict,
+            output_dir / "S2A1R2_verdict.json",
+        )
+
+        stage(10, 11, "生成图表、报告和HF续接清单")
+        plot_summary(
+            summary,
+            activity_table,
+            output_dir / "figures",
+        )
+        report = [
+            "# V3-S2-A1-R2 条件外部创新容量报告",
+            "",
+            f"自动判决：`{verdict_name}`",
+            "",
+            f"- 大气72小时RMSE增益：{atmosphere_gain:.4f}%",
+            f"- 边界72小时RMSE增益：{boundary_gain:.4f}%",
+            f"- 联合72小时RMSE增益：{joint_gain:.4f}%",
+            f"- 大气正确相对负样本：{atmosphere_negative_gap:.4f}%",
+            f"- 边界正确相对负样本：{boundary_negative_gap:.4f}%",
+            f"- 联合正确相对负样本：{joint_negative_gap:.4f}%",
+            f"- 大气活跃Top20增益：{atmosphere_active:.4f}%",
+            f"- 边界活跃Top20增益：{boundary_active:.4f}%",
+            "",
+            "本轮不使用方差校准；所有增益必须由来源创新残差本身产生。",
+            "当前垂向背景已包含在A0父模型中，不被重复计为新的未来来源。",
+        ]
+        (
+            output_dir
+            / "实验V3S2A1R2_条件外部创新容量报告.md"
+        ).write_text(
+            "\n".join(report), encoding="utf-8"
+        )
+        atomic_json(
+            {
+                "source_dataset_repo": args.hf_repo_id,
+                "parent_result": (
+                    "Experiments/V3_S2_A1_R1/"
+                    "CIDM_v3_SCS_V3_S2_A1_R1.zip"
+                ),
+                "recommended_result_path": (
+                    "Experiments/V3_S2_A1_R2/"
+                ),
+            },
+            output_dir / "S2A1R2_HF_handoff.json",
+        )
+        sanitized_arguments = dict(vars(args))
+        sanitized_arguments["hf_token"] = "<redacted>"
+        atomic_json(
+            {
+                "experiment": "CIDM_v3_SCS_V3_S2_A1_R2",
+                "created_at": dt.datetime.now().isoformat(),
+                "device": str(device),
+                "seeds": seeds,
+                "arguments": sanitized_arguments,
+                "security": (
+                    "No plaintext access token is written."
+                ),
+            },
+            output_dir / "S2A1R2_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()