Upload Experiments/V3_S2_A2_MIN/cidm_v3_scs_s2_a2_minimal_ber_scale_core_integration.py with huggingface_hub

Experiments/V3_S2_A2_MIN/cidm_v3_scs_s2_a2_minimal_ber_scale_core_integration.py

@@ -0,0 +1,1309 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+CIDM-v3 SCS V3-S2-A2-MIN
+显式尺度主干 × 最小大气创新 BER 冻结集成资格实验
+====================================================
+
+目的
+----
+R3-MIN 已经证明，经过部署退化的未来大气创新对 A0 父模型具有稳定、
+来源专属和强因果预测价值。本轮不再增加任何新神经模块，只验证该最小
+BER 是否能够作为外部创新修正器，安全地叠加到冻结的 S1-R3 显式尺度主干。
+
+冻结结构
+--------
+1. S1-R3 显式多尺度编码/动力学/解码；
+2. S1-R3 Band Closure；
+3. flux_mode='none'；
+4. slow_memory=False；vertical_closure=False；causal_variance=False；
+5. R3-MIN 未来大气创新探针；
+6. 只修正 currents 与 waves；
+7. 只允许 3 个时效 × 2 个责任组的验证集非负接口系数。
+
+本轮没有
+------
+- 新的边界 BER；
+- 新的垂向 BER；
+- 方差放大器；
+- Router；
+- 多源交互；
+- S1-R3 主干微调；
+- 测试集选参。
+
+若通过：冻结 V3 的最小开放系统接口，进入物理约束/长滚动正式冻结阶段。
+若失败：V3 删除未来 BER，只保留显式尺度主干；复杂 BER 延期到 V4/V5。
+"""
+from __future__ import annotations
+
+import argparse
+import datetime as dt
+import hashlib
+import json
+import math
+import os
+import random
+import shutil
+import time
+import traceback
+import zipfile
+from pathlib import Path
+from typing import Any, Dict, List, Mapping, Optional, Sequence, Tuple
+
+import numpy as np
+import pandas as pd
+import torch
+import torch.nn.functional as F
+from torch.utils.data import DataLoader
+
+import matplotlib
+matplotlib.use("Agg")
+import matplotlib.pyplot as plt
+
+import cidm_v3_scs_s1_r3_slowfast_causal_closure as s1r3
+import cidm_v3_scs_s2_a1_r2_conditional_external_innovation_capacity as s2r2
+import cidm_v3_scs_s2_a1_r3_minimal_atmosphere_ber as minber
+
+
+HORIZONS = [1, 4, 12]
+CURRENT_CHANNELS = [3, 4, 5, 6]
+WAVE_CHANNELS = list(range(9, 16))
+RESPONSIBILITY_GROUPS = {
+    "currents": CURRENT_CHANNELS,
+    "waves": WAVE_CHANNELS,
+}
+RESPONSIBILITY_CHANNELS = CURRENT_CHANNELS + WAVE_CHANNELS
+UNRESPONSIBLE_GROUPS = {
+    "surface_thermohaline": [0, 1, 2],
+    "subsurface_thermohaline": [7, 8],
+}
+PAIRING = {
+    20260902: 20260910,
+    20260903: 20260911,
+    20260904: 20260912,
+}
+S1_CONFIG_DEFAULTS = {
+    "latent_dim": 64,
+    "hidden": 72,
+    "flux_hidden": 48,
+    "flux_downsample": 4,
+    "exchange_dim": 32,
+    "energy_trend_clip": 0.06,
+    "energy_band": 0.10,
+}
+
+
+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-A2-MIN] 阶段 {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 sha256_file(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as handle:
+        for block in iter(lambda: handle.read(1024 * 1024), b""):
+            digest.update(block)
+    return digest.hexdigest()
+
+
+def ensure_prepared_and_parent_assets(args: argparse.Namespace) -> Dict[str, Any]:
+    """Restore prepared arrays, R3-MIN, and the frozen S1-R3 parent when missing.
+
+    S1-R3 is an earlier architecture-parent asset, not an output of R3-MIN.  The
+    function first reuses a local file, then tries several stable paths in the
+    user's HF dataset repository.  This prevents the integration run from
+    silently assuming that the user retained an old local ZIP.
+    """
+    cache = Path(args.cache_dir)
+    prepared = cache / "prepared"
+    prepared.mkdir(parents=True, exist_ok=True)
+    min_zip = Path(args.min_zip)
+    s1r3_zip = Path(args.s1r3_zip)
+    needed: List[Tuple[str, Path]] = [
+        (
+            "Experiments/V3_S2_A1_R3_MIN/CIDM_v3_SCS_V3_S2_A1_R3_MIN.zip",
+            min_zip,
+        )
+    ]
+    for window in s2r2.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) for repo_path, local in needed if not local.is_file()]
+    report = {
+        "repo_id": args.hf_repo_id,
+        "requested": len(needed) + 1,
+        "already_local": len(needed) - len(missing) + int(s1r3_zip.is_file()),
+        "downloaded": [],
+        "s1r3_source": "local" if s1r3_zip.is_file() else None,
+    }
+    from huggingface_hub import hf_hub_download
+    token = os.environ.get("HF_TOKEN") or args.hf_token or None
+    if missing:
+        for repo_path, local in missing:
+            print(f"[HF download] {repo_path}", flush=True)
+            source = Path(hf_hub_download(
+                repo_id=args.hf_repo_id,
+                filename=repo_path,
+                repo_type="dataset",
+                token=token,
+            ))
+            local.parent.mkdir(parents=True, exist_ok=True)
+            if local.exists() or local.is_symlink():
+                local.unlink()
+            try:
+                local.symlink_to(source)
+            except Exception:
+                shutil.copy2(source, local)
+            report["downloaded"].append(repo_path)
+
+    # S1-R3 is not produced by R3-MIN.  Recover the earlier parent from HF when
+    # the local runtime does not already contain it.  Multiple candidate paths
+    # are supported so old and new repositories remain compatible.
+    if not s1r3_zip.is_file():
+        candidates = [
+            item.strip() for item in args.s1r3_hf_candidates.split(",")
+            if item.strip()
+        ]
+        failures = []
+        for repo_path in candidates:
+            try:
+                print(f"[HF parent lookup] {repo_path}", flush=True)
+                source = Path(hf_hub_download(
+                    repo_id=args.hf_repo_id,
+                    filename=repo_path,
+                    repo_type="dataset",
+                    token=token,
+                ))
+                s1r3_zip.parent.mkdir(parents=True, exist_ok=True)
+                if s1r3_zip.exists() or s1r3_zip.is_symlink():
+                    s1r3_zip.unlink()
+                try:
+                    s1r3_zip.symlink_to(source)
+                except Exception:
+                    shutil.copy2(source, s1r3_zip)
+                report["downloaded"].append(repo_path)
+                report["s1r3_source"] = repo_path
+                break
+            except Exception as exc:
+                failures.append(f"{repo_path}: {type(exc).__name__}: {exc}")
+        if not s1r3_zip.is_file():
+            raise FileNotFoundError(
+                "The frozen explicit-scale parent is required for S2-A2, but it "
+                "was neither local nor present at the configured HF candidate "
+                "paths. Upload CIDM_v3_SCS_V3_S1_R3.zip (or the compatible "
+                "CIDM_v3_SCS_V3_S1_R4.zip containing nested R3 assets) to "
+                f"{s1r3_zip}. Tried: {failures}"
+            )
+
+    for repo_path, local in needed:
+        if not local.is_file() or local.stat().st_size <= 128:
+            raise RuntimeError(f"Missing or invalid asset: {repo_path} -> {local}")
+    if s1r3_zip.stat().st_size <= 128:
+        raise RuntimeError(f"Invalid S1-R3 parent asset: {s1r3_zip}")
+    return report
+
+
+def extract_s1r3_assets(zip_path: Path, destination: Path) -> Dict[str, Any]:
+    if not zip_path.is_file():
+        raise FileNotFoundError(zip_path)
+    destination.mkdir(parents=True, exist_ok=True)
+    with zipfile.ZipFile(zip_path) as archive:
+        archive.extractall(destination)
+    verdicts = list(destination.rglob("V3S1R3_verdict.json"))
+    if len(verdicts) != 1:
+        raise RuntimeError(f"Expected one V3S1R3 verdict, found {len(verdicts)}")
+    root = verdicts[0].parent
+    metadata_path = root / "scs_c0_metadata.json"
+    if not metadata_path.is_file():
+        raise FileNotFoundError(metadata_path)
+    checkpoints: Dict[int, Path] = {}
+    for path in (root / "checkpoints" / "slowfast_causal").glob("seed_*.pt"):
+        payload = torch.load(path, map_location="cpu", weights_only=False)
+        checkpoints[int(payload.get("seed", path.stem.split("_")[-1]))] = path
+    missing = [seed for seed in PAIRING if seed not in checkpoints]
+    if missing:
+        raise RuntimeError(f"S1-R3 checkpoints missing: {missing}")
+    return {
+        "root": root,
+        "verdict": json.loads((root / "V3S1R3_verdict.json").read_text(encoding="utf-8")),
+        "manifest": json.loads((root / "V3S1R3_manifest.json").read_text(encoding="utf-8")),
+        "metadata": json.loads(metadata_path.read_text(encoding="utf-8")),
+        "checkpoints": checkpoints,
+        "sha256": sha256_file(zip_path),
+    }
+
+
+def extract_min_assets(zip_path: Path, destination: Path) -> Dict[str, Any]:
+    if not zip_path.is_file():
+        raise FileNotFoundError(zip_path)
+    destination.mkdir(parents=True, exist_ok=True)
+    with zipfile.ZipFile(zip_path) as archive:
+        archive.extractall(destination)
+    verdicts = list(destination.rglob("MIN_verdict.json"))
+    if len(verdicts) != 1:
+        raise RuntimeError(f"Expected one MIN verdict, found {len(verdicts)}")
+    root = verdicts[0].parent
+    stats_paths = list(root.rglob("S2A0_normalization_stats.npz"))
+    if len(stats_paths) != 1:
+        raise RuntimeError(f"Expected one A0 stats file, found {len(stats_paths)}")
+    checkpoints: Dict[int, Path] = {}
+    for path in (root / "checkpoints").glob("seed_*.pt"):
+        payload = torch.load(path, map_location="cpu", weights_only=False)
+        checkpoints[int(payload["seed"])] = path
+    missing = [seed for seed in PAIRING.values() if seed not in checkpoints]
+    if missing:
+        raise RuntimeError(f"MIN checkpoints missing: {missing}")
+    coefficients = json.loads((root / "MIN_validation_coefficients.json").read_text(encoding="utf-8"))
+    return {
+        "root": root,
+        "verdict": json.loads((root / "MIN_verdict.json").read_text(encoding="utf-8")),
+        "aggregate": json.loads((root / "MIN_main_aggregate.json").read_text(encoding="utf-8")),
+        "stats": stats_paths[0],
+        "checkpoints": checkpoints,
+        "coefficients": {int(key): np.asarray(value, dtype=np.float32) for key, value in coefficients.items()},
+        "sha256": sha256_file(zip_path),
+    }
+
+
+def make_s1_model(args: argparse.Namespace, checkpoint: Path, device: torch.device):
+    model = s1r3.ExplicitScaleDynamicsR3(
+        channels=len(s1r3.VARIABLE_NAMES),
+        latent=args.s1_latent_dim,
+        hidden=args.s1_hidden,
+        flux_hidden=args.s1_flux_hidden,
+        flux_downsample=args.s1_flux_downsample,
+        exchange_dim=args.s1_exchange_dim,
+        trend_clip=args.s1_energy_trend_clip,
+        energy_band=args.s1_energy_band,
+    ).to(device)
+    payload = torch.load(checkpoint, map_location="cpu", weights_only=False)
+    missing, unexpected = model.load_state_dict(payload["model_state"], strict=False)
+    if missing or unexpected:
+        raise RuntimeError(
+            f"S1-R3 checkpoint mismatch. missing={missing}, unexpected={unexpected}"
+        )
+    model.eval()
+    for parameter in model.parameters():
+        parameter.requires_grad = False
+    return model, {
+        "seed": int(payload.get("seed", -1)),
+        "epoch": int(payload.get("epoch", -1)),
+        "validation_score": float(payload.get("validation_score", float("nan"))),
+    }
+
+
+def make_min_model(args: argparse.Namespace, checkpoint: Path, device: torch.device):
+    model = minber.MinimalAtmosphereBER(args.min_hidden).to(device)
+    payload = torch.load(checkpoint, map_location="cpu", weights_only=False)
+    model.load_state_dict(payload["model_state"], strict=True)
+    model.eval()
+    for parameter in model.parameters():
+        parameter.requires_grad = False
+    residual_scale = payload["residual_scale"].to(device)
+    return model, residual_scale, {
+        "seed": int(payload["seed"]),
+        "best_epoch": int(payload["best_epoch"]),
+        "source_zero_max": float(payload["source_zero_max"]),
+    }
+
+
+def load_a0_internal_stats(path: Path) -> Tuple[np.ndarray, np.ndarray]:
+    with np.load(path) as stats:
+        return (
+            stats["internal_mean"].astype(np.float32),
+            stats["internal_std"].astype(np.float32),
+        )
+
+
+def convert_batch_to_s1(
+    batch: Mapping[str, torch.Tensor],
+    a0_mean: torch.Tensor,
+    a0_std: torch.Tensor,
+    s1_mean: torch.Tensor,
+    s1_std: torch.Tensor,
+) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
+    b, flat, h, w = batch["internal"].shape
+    channels = len(s1r3.VARIABLE_NAMES)
+    history = flat // channels
+    internal_a0 = batch["internal"].reshape(b, history, channels, h, w)
+    physical_history = (
+        internal_a0 * a0_std[None, None, :, None, None]
+        + a0_mean[None, None, :, None, None]
+    )
+    history_s1 = (
+        physical_history - s1_mean[None, None, :, None, None]
+    ) / s1_std[None, None, :, None, None]
+
+    target_physical = (
+        batch["target"] * a0_std[None, None, :, None, None]
+        + a0_mean[None, None, :, None, None]
+    )
+    target_s1 = (
+        target_physical - s1_mean[None, None, :, None, None]
+    ) / s1_std[None, None, :, None, None]
+
+    mask = batch["mask"]
+    if mask.shape[1] == 1:
+        mask = mask.expand(-1, channels, -1, -1)
+    return history_s1, target_s1, mask
+
+
+@torch.no_grad()
+def core_predict(model, history: torch.Tensor, mask: torch.Tensor) -> torch.Tensor:
+    outputs, _ = model.rollout_latent(
+        history,
+        mask,
+        max(HORIZONS),
+        flux_mode="none",
+        projection=True,
+        radial_delta=False,
+        band_closure=True,
+        slow_memory=False,
+        vertical_closure=False,
+        causal_variance=False,
+        counterfactual=False,
+    )
+    return torch.stack([outputs[horizon - 1]["pred"] for horizon in HORIZONS], dim=1)
+
+
+def min_update_in_s1_units(
+    model: minber.MinimalAtmosphereBER,
+    residual_scale: torch.Tensor,
+    min_coefficients: np.ndarray,
+    sequence: torch.Tensor,
+    a0_std: torch.Tensor,
+    s1_std: torch.Tensor,
+) -> torch.Tensor:
+    normalized, _ = model(sequence)
+    alpha = minber.coefficient_tensor(
+        min_coefficients,
+        normalized.device,
+        normalized.dtype,
+    )
+    update_a0_normalized = alpha * minber.apply_residual_scale(
+        normalized, residual_scale
+    )
+    update_physical = update_a0_normalized * a0_std[None, None, :, None, None]
+    return update_physical / s1_std[None, None, :, None, None]
+
+
+def quantize_alpha(value: float, max_alpha: float) -> float:
+    grid = np.asarray([0.0, 0.25, 0.50, 0.75, 1.0, 1.25], dtype=np.float32)
+    grid = grid[grid <= max_alpha + 1e-8]
+    return float(grid[np.argmin(np.abs(grid - value))])
+
+
+@torch.no_grad()
+def fit_integration_coefficients(
+    s1_model,
+    min_model,
+    residual_scale: torch.Tensor,
+    min_coefficients: np.ndarray,
+    loader: DataLoader,
+    device: torch.device,
+    a0_mean: torch.Tensor,
+    a0_std: torch.Tensor,
+    s1_mean: torch.Tensor,
+    s1_std: torch.Tensor,
+    max_alpha: float,
+) -> np.ndarray:
+    numerator = np.zeros((len(HORIZONS), len(RESPONSIBILITY_GROUPS)), dtype=np.float64)
+    denominator = np.zeros_like(numerator)
+    for step, raw_batch in enumerate(loader):
+        batch = s2r2.batch_to_device(raw_batch, device)
+        history, target, mask = convert_batch_to_s1(
+            batch, a0_mean, a0_std, s1_mean, s1_std
+        )
+        core = core_predict(s1_model, history, mask)
+        sequence = minber.degrade_sequence(
+            batch["future_atmosphere"], "medium", 880000 + step
+        )
+        update = min_update_in_s1_units(
+            min_model,
+            residual_scale,
+            min_coefficients,
+            sequence,
+            a0_std,
+            s1_std,
+        )
+        residual = target - core
+        mask_h = mask[:, None]
+        for hi in range(len(HORIZONS)):
+            for gi, indices in enumerate(RESPONSIBILITY_GROUPS.values()):
+                u = update[:, hi, indices]
+                r = residual[:, hi, indices]
+                m = mask_h[:, :, indices]
+                numerator[hi, gi] += float((u * r * m).sum())
+                denominator[hi, gi] += float((u.square() * m).sum())
+    raw = numerator / np.maximum(denominator, 1e-12)
+    raw = np.clip(raw, 0.0, max_alpha)
+    quantized = np.vectorize(lambda value: quantize_alpha(float(value), max_alpha))(raw)
+    return quantized.astype(np.float32)
+
+
+def integration_alpha_tensor(
+    coefficients: np.ndarray,
+    device: torch.device,
+    dtype: torch.dtype,
+) -> torch.Tensor:
+    result = torch.zeros(
+        len(HORIZONS), len(s1r3.VARIABLE_NAMES), device=device, dtype=dtype
+    )
+    for gi, indices in enumerate(RESPONSIBILITY_GROUPS.values()):
+        result[:, indices] = torch.as_tensor(
+            coefficients[:, gi:gi + 1], device=device, dtype=dtype
+        )
+    return result[None, :, :, None, None]
+
+
+def empty_accumulator() -> Dict[str, Any]:
+    return {
+        "squared": {h: 0.0 for h in HORIZONS},
+        "count": {h: 0.0 for h in HORIZONS},
+        "pred": {h: [] for h in HORIZONS},
+        "target": {h: [] for h in HORIZONS},
+        "sample_rows": [],
+        "groups": {
+            (h, group): []
+            for h in HORIZONS
+            for group in {**s2r2.GROUPS}
+        },
+        "update_ratios": [],
+        "wave_negative": [],
+        "direction_error": [],
+    }
+
+
+def update_metrics(
+    accumulator: Dict[str, Any],
+    prediction: torch.Tensor,
+    target: torch.Tensor,
+    mask: torch.Tensor,
+    update: torch.Tensor,
+    sample_index: torch.Tensor,
+    s1_mean: torch.Tensor,
+    s1_std: torch.Tensor,
+) -> None:
+    channels = prediction.shape[2]
+    for hi, horizon in enumerate(HORIZONS):
+        error = (prediction[:, hi] - target[:, hi]).square() * mask
+        denominator = (
+            mask.flatten(1).sum(dim=1).clamp_min(1.0) * channels
+        )
+        per_sample_mse = error.flatten(1).sum(dim=1) / denominator
+        accumulator["squared"][horizon] += float(error.sum())
+        accumulator["count"][horizon] += float(mask.sum()) * channels
+        accumulator["pred"][horizon].append(
+            (prediction[:, hi] * mask).flatten(1).cpu()
+        )
+        accumulator["target"][horizon].append(
+            (target[:, hi] * mask).flatten(1).cpu()
+        )
+        for index, mse in zip(sample_index.cpu().tolist(), per_sample_mse.cpu().tolist()):
+            accumulator["sample_rows"].append({
+                "sample_index": int(index),
+                "horizon": horizon,
+                "mse": float(mse),
+                "rmse": math.sqrt(max(float(mse), 0.0)),
+            })
+        for group, indices in s2r2.GROUPS.items():
+            group_error = (
+                (prediction[:, hi, indices] - target[:, hi, indices]).square()
+                * mask[:, indices]
+            )
+            group_denominator = (
+                mask[:, indices].flatten(1).sum(dim=1).clamp_min(1.0)
+            )
+            group_rmse = torch.sqrt(
+                group_error.flatten(1).sum(dim=1) / group_denominator
+            )
+            accumulator["groups"][(horizon, group)].extend(group_rmse.cpu().tolist())
+
+        physical = prediction[:, hi] * s1_std[None, :, None, None] + s1_mean[None, :, None, None]
+        physical_target = target[:, hi] * s1_std[None, :, None, None] + s1_mean[None, :, None, None]
+        magnitude_channels = [9, 10, 11, 14, 15]
+        valid_wave = mask[:, magnitude_channels] > 0
+        negative_fraction = (
+            ((physical[:, magnitude_channels] < 0) & valid_wave).float().sum()
+            / valid_wave.float().sum().clamp_min(1.0)
+        )
+        accumulator["wave_negative"].append(float(negative_fraction))
+
+        pred_angle = torch.atan2(physical[:, 12], physical[:, 13])
+        true_angle = torch.atan2(physical_target[:, 12], physical_target[:, 13])
+        diff = torch.atan2(torch.sin(pred_angle - true_angle), torch.cos(pred_angle - true_angle)).abs()
+        direction_mask = mask[:, 12] * mask[:, 13]
+        direction_error = (
+            (diff * direction_mask).sum()
+            / direction_mask.sum().clamp_min(1.0)
+        ) * (180.0 / math.pi)
+        accumulator["direction_error"].append(float(direction_error))
+
+    ratio = torch.sqrt(update.square().mean(dim=(2, 3, 4)) + 1e-12) / (
+        torch.sqrt(prediction.square().mean(dim=(2, 3, 4)) + 1e-12) + 1e-6
+    )
+    accumulator["update_ratios"].extend(ratio.cpu().flatten().tolist())
+
+
+def finalize_metrics(accumulator: Dict[str, Any]) -> Dict[str, Any]:
+    metrics: Dict[str, Any] = {}
+    for horizon in HORIZONS:
+        metrics[f"rmse_h{horizon}"] = math.sqrt(
+            accumulator["squared"][horizon]
+            / max(accumulator["count"][horizon], 1.0)
+        )
+        pred = torch.cat(accumulator["pred"][horizon], dim=0)
+        target = torch.cat(accumulator["target"][horizon], dim=0)
+        metrics[f"variance_ratio_h{horizon}"] = float(
+            pred.var(unbiased=False) / (target.var(unbiased=False) + 1e-8)
+        )
+    for (horizon, group), values in accumulator["groups"].items():
+        metrics[f"group_rmse_{group}_h{horizon}"] = float(np.mean(values))
+    metrics["update_ratio_mean"] = float(np.mean(accumulator["update_ratios"]))
+    metrics["wave_negative_fraction"] = float(np.mean(accumulator["wave_negative"]))
+    metrics["wave_direction_error_deg"] = float(np.mean(accumulator["direction_error"]))
+    metrics["sample_rows"] = accumulator["sample_rows"]
+    return metrics
+
+
+@torch.no_grad()
+def evaluate_all_modes(
+    s1_model,
+    min_model,
+    residual_scale: torch.Tensor,
+    min_coefficients: np.ndarray,
+    integration_coefficients: np.ndarray,
+    loader: DataLoader,
+    device: torch.device,
+    a0_mean: torch.Tensor,
+    a0_std: torch.Tensor,
+    s1_mean: torch.Tensor,
+    s1_std: torch.Tensor,
+    seed: int,
+) -> Tuple[Dict[str, Dict[str, Any]], Dict[str, pd.DataFrame]]:
+    mode_specs = {
+        "core": ("oracle", False, False, False),
+        "raw_medium": ("medium", False, False, True),
+        "integrated_oracle": ("oracle", False, False, False),
+        "integrated_mild": ("mild", False, False, False),
+        "integrated_medium": ("medium", False, False, False),
+        "integrated_severe": ("severe", False, False, False),
+        "integrated_history": ("history", False, False, False),
+        "integrated_negative": ("medium", True, False, False),
+        "integrated_reversed": ("reversed", False, False, False),
+        "integrated_shifted": ("shifted", False, False, False),
+        "fallback": ("medium", False, True, False),
+    }
+    accumulators = {name: empty_accumulator() for name in mode_specs}
+    calibrated_alpha = integration_alpha_tensor(
+        integration_coefficients, device, torch.float32
+    )
+    raw_alpha = integration_alpha_tensor(
+        np.ones_like(integration_coefficients, dtype=np.float32),
+        device,
+        torch.float32,
+    )
+
+    for step, raw_batch in enumerate(loader):
+        batch = s2r2.batch_to_device(raw_batch, device)
+        history, target, mask = convert_batch_to_s1(
+            batch, a0_mean, a0_std, s1_mean, s1_std
+        )
+        core = core_predict(s1_model, history, mask)
+        for name, (mode, negative, disabled, raw_interface) in mode_specs.items():
+            if disabled or name == "core":
+                update = torch.zeros_like(core)
+            else:
+                sequence = (
+                    batch["negative_atmosphere"]
+                    if negative else batch["future_atmosphere"]
+                )
+                sequence = minber.degrade_sequence(
+                    sequence,
+                    mode,
+                    seed * 10000 + step + sum(map(ord, name)),
+                )
+                update = min_update_in_s1_units(
+                    min_model,
+                    residual_scale,
+                    min_coefficients,
+                    sequence,
+                    a0_std,
+                    s1_std,
+                )
+                update = (
+                    raw_alpha.to(update)
+                    if raw_interface else calibrated_alpha.to(update)
+                ) * update
+            prediction = core + update
+            update_metrics(
+                accumulators[name],
+                prediction,
+                target,
+                mask,
+                update,
+                batch["sample_index"],
+                s1_mean,
+                s1_std,
+            )
+    metrics = {}
+    sample_tables = {}
+    for name, accumulator in accumulators.items():
+        result = finalize_metrics(accumulator)
+        sample_tables[name] = pd.DataFrame(result.pop("sample_rows"))
+        metrics[name] = result
+    return metrics, sample_tables
+
+
+def paired_bootstrap(reference: np.ndarray, candidate: np.ndarray, reps: int, seed: int) -> Dict[str, float]:
+    return s2r2.paired_bootstrap(reference, candidate, reps, seed)
+
+
+@torch.no_grad()
+def runtime_audit(
+    s1_model,
+    min_model,
+    residual_scale: torch.Tensor,
+    min_coefficients: np.ndarray,
+    integration_coefficients: np.ndarray,
+    loader: DataLoader,
+    device: torch.device,
+    a0_mean: torch.Tensor,
+    a0_std: torch.Tensor,
+    s1_mean: torch.Tensor,
+    s1_std: torch.Tensor,
+    repeats: int = 20,
+) -> Dict[str, float]:
+    batch = s2r2.batch_to_device(next(iter(loader)), device)
+    history, _, mask = convert_batch_to_s1(
+        batch, a0_mean, a0_std, s1_mean, s1_std
+    )
+    sequence = minber.degrade_sequence(batch["future_atmosphere"], "medium", 12345)
+    alpha = integration_alpha_tensor(
+        integration_coefficients, device, torch.float32
+    )
+
+    def core_only():
+        return core_predict(s1_model, history, mask)
+
+    def integrated():
+        core = core_predict(s1_model, history, mask)
+        update = min_update_in_s1_units(
+            min_model,
+            residual_scale,
+            min_coefficients,
+            sequence,
+            a0_std,
+            s1_std,
+        )
+        return core + alpha.to(update) * update
+
+    for _ in range(3):
+        core_only(); integrated()
+    if device.type == "cuda":
+        torch.cuda.synchronize()
+    start = time.perf_counter()
+    for _ in range(repeats):
+        core_only()
+    if device.type == "cuda":
+        torch.cuda.synchronize()
+    core_seconds = time.perf_counter() - start
+
+    if device.type == "cuda":
+        torch.cuda.synchronize()
+    start = time.perf_counter()
+    for _ in range(repeats):
+        integrated()
+    if device.type == "cuda":
+        torch.cuda.synchronize()
+    integrated_seconds = time.perf_counter() - start
+
+    batch_size = int(history.shape[0])
+    core_ms = 1000.0 * core_seconds / repeats / batch_size
+    integrated_ms = 1000.0 * integrated_seconds / repeats / batch_size
+    return {
+        "batch_size": batch_size,
+        "core_sample_ms": core_ms,
+        "integrated_sample_ms": integrated_ms,
+        "ber_overhead_ms": integrated_ms - core_ms,
+        "ber_overhead_percent": 100.0 * (integrated_ms - core_ms) / max(core_ms, 1e-8),
+    }
+
+
+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() and "_parents" not in path.parts:
+                archive.write(path, path.relative_to(output_dir.parent))
+    return target
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        description="Frozen S1-R3 × minimal atmosphere BER integration audit"
+    )
+    parser.add_argument("--cache_dir", default="/content/CIDM_v3_SCS_S2A0_Cache")
+    parser.add_argument("--s1r3_zip", default="/content/CIDM_v3_SCS_V3_S1_R3.zip")
+    parser.add_argument(
+        "--s1r3_hf_candidates",
+        default=(
+            "Parents/CIDM_v3_SCS_V3_S1_R3.zip,"
+            "Experiments/V3_S1_R3/CIDM_v3_SCS_V3_S1_R3.zip,"
+            "CIDM_v3_SCS_V3_S1_R3.zip,"
+            "Parents/CIDM_v3_SCS_V3_S1_R4.zip,"
+            "CIDM_v3_SCS_V3_S1_R4.zip"
+        ),
+    )
+    parser.add_argument("--min_zip", default="/content/CIDM_v3_SCS_V3_S2_A1_R3_MIN.zip")
+    parser.add_argument("--parent_cache", default="/content/CIDM_v3_SCS_S2A2_ParentCache")
+    parser.add_argument("--output_dir", default="/content/CIDM_v3_SCS_V3_S2_A2_MIN")
+    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("--batch_size", type=int, default=1)
+    parser.add_argument("--num_workers", type=int, default=0)
+    parser.add_argument("--min_hidden", type=int, default=40)
+    parser.add_argument("--max_integration_alpha", type=float, default=1.25)
+    parser.add_argument("--bootstrap_reps", type=int, default=1000)
+    parser.add_argument("--s1_latent_dim", type=int, default=64)
+    parser.add_argument("--s1_hidden", type=int, default=72)
+    parser.add_argument("--s1_flux_hidden", type=int, default=48)
+    parser.add_argument("--s1_flux_downsample", type=int, default=4)
+    parser.add_argument("--s1_exchange_dim", type=int, default=32)
+    parser.add_argument("--s1_energy_trend_clip", type=float, default=0.06)
+    parser.add_argument("--s1_energy_band", type=float, default=0.10)
+    parser.add_argument("--pairing", default="20260902:20260910,20260903:20260911,20260904:20260912")
+    parser.add_argument("--synthetic_smoke", action="store_true")
+    parser.add_argument("--smoke_time_steps", type=int, default=36)
+    parser.add_argument("--smoke_height", type=int, default=24)
+    parser.add_argument("--smoke_width", type=int, default=24)
+    return parser
+
+
+def parse_pairing(value: str) -> Dict[int, int]:
+    result = {}
+    for item in value.split(","):
+        left, right = item.split(":")
+        result[int(left)] = int(right)
+    return result
+
+
+def main() -> None:
+    args = build_parser().parse_args()
+    pairing = parse_pairing(args.pairing)
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    if not args.synthetic_smoke and device.type != "cuda":
+        raise RuntimeError("Formal S2-A2 integration audit requires CUDA")
+    torch.set_float32_matmul_precision("highest")
+
+    output_dir = Path(args.output_dir)
+    if output_dir.exists():
+        shutil.rmtree(output_dir)
+    for subdir in ["evaluation", "audits", "figures", "lineage", "deployment"]:
+        (output_dir / subdir).mkdir(parents=True, exist_ok=True)
+
+    parent_cache = Path(args.parent_cache)
+    if parent_cache.exists() and args.synthetic_smoke:
+        shutil.rmtree(parent_cache)
+    parent_cache.mkdir(parents=True, exist_ok=True)
+
+    try:
+        stage(1, 9, "恢复prepared数据、S1-R3和R3-MIN父资产")
+        if args.synthetic_smoke:
+            s2r2.create_synthetic_assets(args)
+            asset_report = {"synthetic_smoke": True}
+        else:
+            asset_report = ensure_prepared_and_parent_assets(args)
+        atomic_json(asset_report, output_dir / "audits" / "S2A2_asset_audit.json")
+
+        stage(2, 9, "提取冻结主干、最小BER和归一化谱系")
+        s1_assets = extract_s1r3_assets(
+            Path(args.s1r3_zip), parent_cache / "s1r3"
+        )
+        min_assets = extract_min_assets(
+            Path(args.min_zip), parent_cache / "min"
+        )
+        if min_assets["verdict"]["automatic_verdict"] != "V3_S2_A1_R3_MINIMAL_ATMOSPHERE_BER_QUALIFIED":
+            raise RuntimeError("R3-MIN parent is not formally qualified")
+        a0_mean_np, a0_std_np = load_a0_internal_stats(min_assets["stats"])
+        s1_mean_np = np.asarray(s1_assets["metadata"]["means"], dtype=np.float32)
+        s1_std_np = np.asarray(s1_assets["metadata"]["stds"], dtype=np.float32)
+        a0_mean = torch.as_tensor(a0_mean_np, device=device)
+        a0_std = torch.as_tensor(a0_std_np, device=device)
+        s1_mean = torch.as_tensor(s1_mean_np, device=device)
+        s1_std = torch.as_tensor(s1_std_np, device=device)
+        atomic_json(
+            {
+                "s1r3_sha256": s1_assets["sha256"],
+                "min_sha256": min_assets["sha256"],
+                "s1r3_verdict": s1_assets["verdict"],
+                "min_verdict": min_assets["verdict"],
+                "pairing": pairing,
+                "canonical_s1_settings": {
+                    "flux_mode": "none",
+                    "band_closure": True,
+                    "slow_memory": False,
+                    "vertical_closure": False,
+                    "causal_variance": False,
+                    "radial_delta": False,
+                },
+            },
+            output_dir / "lineage" / "S2A2_parent_lineage.json",
+        )
+
+        stage(3, 9, "加载四季资格数据和冻结模型对")
+        windows = [
+            s2r2.load_window(Path(args.cache_dir), spec)
+            for spec in s2r2.WINDOWS
+        ]
+        loaders, split_audit = s2r2.build_loaders(
+            windows, min_assets["stats"], args
+        )
+        atomic_json(split_audit, output_dir / "audits" / "S2A2_split_audit.json")
+
+        pairs = {}
+        loading_rows = []
+        for s1_seed, min_seed in pairing.items():
+            s1_model, s1_report = make_s1_model(
+                args, s1_assets["checkpoints"][s1_seed], device
+            )
+            min_model, residual_scale, min_report = make_min_model(
+                args, min_assets["checkpoints"][min_seed], device
+            )
+            pairs[s1_seed] = {
+                "min_seed": min_seed,
+                "s1_model": s1_model,
+                "min_model": min_model,
+                "residual_scale": residual_scale,
+                "min_coefficients": min_assets["coefficients"][min_seed],
+            }
+            loading_rows.append({
+                "s1_seed": s1_seed,
+                "min_seed": min_seed,
+                **{f"s1_{key}": value for key, value in s1_report.items()},
+                **{f"min_{key}": value for key, value in min_report.items()},
+            })
+        pd.DataFrame(loading_rows).to_csv(
+            output_dir / "audits" / "S2A2_model_loading.csv", index=False
+        )
+
+        stage(4, 9, "仅用夏季验证集拟合六个接口系数")
+        integration_coefficients = {}
+        for s1_seed, pair in pairs.items():
+            integration_coefficients[s1_seed] = fit_integration_coefficients(
+                pair["s1_model"],
+                pair["min_model"],
+                pair["residual_scale"],
+                pair["min_coefficients"],
+                loaders["validation"],
+                device,
+                a0_mean,
+                a0_std,
+                s1_mean,
+                s1_std,
+                args.max_integration_alpha,
+            )
+            print(
+                f"[integration alpha s1={s1_seed} min={pair['min_seed']}] "
+                f"{integration_coefficients[s1_seed].tolist()}",
+                flush=True,
+            )
+        atomic_json(
+            {str(seed): value for seed, value in integration_coefficients.items()},
+            output_dir / "S2A2_validation_interface_coefficients.json",
+        )
+
+        stage(5, 9, "秋季测试：核心、集成、重度退化和因果反事实")
+        metric_rows = []
+        sample_tables: Dict[Tuple[int, str], pd.DataFrame] = {}
+        runtime_rows = []
+        for s1_seed, pair in pairs.items():
+            metrics, samples = evaluate_all_modes(
+                pair["s1_model"],
+                pair["min_model"],
+                pair["residual_scale"],
+                pair["min_coefficients"],
+                integration_coefficients[s1_seed],
+                loaders["test"],
+                device,
+                a0_mean,
+                a0_std,
+                s1_mean,
+                s1_std,
+                s1_seed,
+            )
+            for mode, values in metrics.items():
+                metric_rows.append({
+                    "s1_seed": s1_seed,
+                    "min_seed": pair["min_seed"],
+                    "mode": mode,
+                    **values,
+                })
+                sample_tables[(s1_seed, mode)] = samples[mode]
+            runtime = runtime_audit(
+                pair["s1_model"],
+                pair["min_model"],
+                pair["residual_scale"],
+                pair["min_coefficients"],
+                integration_coefficients[s1_seed],
+                loaders["test"],
+                device,
+                a0_mean,
+                a0_std,
+                s1_mean,
+                s1_std,
+                repeats=5 if args.synthetic_smoke else 20,
+            )
+            runtime_rows.append({
+                "s1_seed": s1_seed,
+                "min_seed": pair["min_seed"],
+                **runtime,
+            })
+        metrics_table = pd.DataFrame(metric_rows)
+        metrics_table.to_csv(
+            output_dir / "evaluation" / "S2A2_seed_metrics.csv", index=False
+        )
+        runtime_table = pd.DataFrame(runtime_rows)
+        runtime_table.to_csv(output_dir / "S2A2_runtime.csv", index=False)
+
+        stage(6, 9, "配对Bootstrap、责任组和物理安全汇总")
+        summary_rows = []
+        bootstrap_payload = {}
+        core_mean = metrics_table[metrics_table["mode"] == "core"].set_index("s1_seed")
+        modes = list(metrics_table["mode"].unique())
+        for mode in modes:
+            candidate = metrics_table[metrics_table["mode"] == mode].set_index("s1_seed")
+            for horizon in HORIZONS:
+                rmse = float(candidate[f"rmse_h{horizon}"].mean())
+                core_rmse = float(core_mean[f"rmse_h{horizon}"].mean())
+                seed_gains = [
+                    100.0 * (
+                        core_mean.loc[seed, f"rmse_h{horizon}"]
+                        - candidate.loc[seed, f"rmse_h{horizon}"]
+                    ) / core_mean.loc[seed, f"rmse_h{horizon}"]
+                    for seed in pairing
+                ]
+                ref_all = []
+                cand_all = []
+                for seed in pairing:
+                    ref = sample_tables[(seed, "core")]
+                    cand = sample_tables[(seed, mode)]
+                    ref_all.append(
+                        ref[ref.horizon == horizon]
+                        .sort_values("sample_index").mse.to_numpy()
+                    )
+                    cand_all.append(
+                        cand[cand.horizon == horizon]
+                        .sort_values("sample_index").mse.to_numpy()
+                    )
+                boot = paired_bootstrap(
+                    np.concatenate(ref_all),
+                    np.concatenate(cand_all),
+                    args.bootstrap_reps,
+                    min(pairing) + horizon * 100 + sum(map(ord, mode)),
+                )
+                bootstrap_payload[f"{mode}_h{horizon}"] = boot
+                summary_rows.append({
+                    "mode": mode,
+                    "horizon": horizon,
+                    "lead_hours": horizon * 6,
+                    "rmse": rmse,
+                    "variance_ratio": float(candidate[f"variance_ratio_h{horizon}"].mean()),
+                    "rmse_gain_vs_core_percent": 100.0 * (core_rmse - rmse) / core_rmse,
+                    "mse_gain_vs_core_percent": boot["mse_gain_percent"],
+                    "bootstrap_low": boot["ci_low"],
+                    "bootstrap_high": boot["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 / "S2A2_counterfactual_summary.csv", index=False)
+        atomic_json(bootstrap_payload, output_dir / "paired_bootstrap.json")
+
+        stage(7, 9, "冻结判决：通过则结束S2，否则V3删除未来BER")
+        def value(mode: str, horizon: int, column: str) -> float:
+            return float(summary[
+                (summary["mode"] == mode)
+                & (summary["horizon"] == horizon)
+            ][column].iloc[0])
+
+        medium_gain = value("integrated_medium", 12, "rmse_gain_vs_core_percent")
+        raw_gain = value("raw_medium", 12, "rmse_gain_vs_core_percent")
+        severe_gain = value("integrated_severe", 12, "rmse_gain_vs_core_percent")
+        negative_gap = 100.0 * (
+            value("integrated_negative", 12, "rmse")
+            - value("integrated_medium", 12, "rmse")
+        ) / value("integrated_negative", 12, "rmse")
+        history_gap = 100.0 * (
+            value("integrated_history", 12, "rmse")
+            - value("integrated_medium", 12, "rmse")
+        ) / value("integrated_history", 12, "rmse")
+        shifted_gap = 100.0 * (
+            value("integrated_shifted", 12, "rmse")
+            - value("integrated_medium", 12, "rmse")
+        ) / value("integrated_shifted", 12, "rmse")
+        mean_metrics = metrics_table.groupby("mode").mean(numeric_only=True)
+        core_metrics = mean_metrics.loc["core"]
+        medium_metrics = mean_metrics.loc["integrated_medium"]
+        current_gain = 100.0 * (
+            core_metrics["group_rmse_currents_h12"]
+            - medium_metrics["group_rmse_currents_h12"]
+        ) / core_metrics["group_rmse_currents_h12"]
+        wave_gain = 100.0 * (
+            core_metrics["group_rmse_waves_h12"]
+            - medium_metrics["group_rmse_waves_h12"]
+        ) / core_metrics["group_rmse_waves_h12"]
+        surface_change = abs(
+            medium_metrics["group_rmse_surface_thermohaline_h12"]
+            - core_metrics["group_rmse_surface_thermohaline_h12"]
+        )
+        subsurface_change = abs(
+            medium_metrics["group_rmse_subsurface_thermohaline_h12"]
+            - core_metrics["group_rmse_subsurface_thermohaline_h12"]
+        )
+        variance_change = (
+            medium_metrics["variance_ratio_h12"]
+            - core_metrics["variance_ratio_h12"]
+        )
+        direction_change = (
+            medium_metrics["wave_direction_error_deg"]
+            - core_metrics["wave_direction_error_deg"]
+        )
+        negative_fraction_change = (
+            medium_metrics["wave_negative_fraction"]
+            - core_metrics["wave_negative_fraction"]
+        )
+        mean_alpha = float(np.mean([
+            value for array in integration_coefficients.values() for value in array.flatten()
+        ]))
+        active_alpha_fraction = float(np.mean([
+            value > 0 for array in integration_coefficients.values() for value in array.flatten()
+        ]))
+        source_zero_max = max(row["min_source_zero_max"] for row in loading_rows)
+        fallback_error = abs(
+            value("fallback", 12, "rmse") - value("core", 12, "rmse")
+        )
+        bootstrap_upper = value("integrated_medium", 12, "bootstrap_high")
+        all_seed_positive = bool(summary[
+            (summary["mode"] == "integrated_medium")
+            & (summary["horizon"] == 12)
+        ]["all_seed_positive"].iloc[0])
+
+        checks = {
+            "s1r3_and_min_three_pairs_loaded": len(pairs) == 3 and len(pairing) == 3,
+            "min_parent_formally_qualified": min_assets["verdict"]["automatic_verdict"] == "V3_S2_A1_R3_MINIMAL_ATMOSPHERE_BER_QUALIFIED",
+            "source_zero_sentinel_lt_1e8": source_zero_max < 1e-8,
+            "fallback_exactly_reproduces_core": fallback_error < 1e-10,
+            "raw_medium_not_harmful_0_3pct": raw_gain >= -0.3,
+            "integrated_medium_72h_gain_ge_0_5pct": medium_gain >= 0.5,
+            "integrated_medium_all_three_positive": all_seed_positive,
+            "integrated_medium_bootstrap_positive": bootstrap_upper < 0,
+            "correct_beats_negative_ge_0_5pct": negative_gap >= 0.5,
+            "correct_beats_history_ge_0_5pct": history_gap >= 0.5,
+            "correct_beats_shifted_ge_0_1pct": shifted_gap >= 0.1,
+            "severe_72h_nonnegative": severe_gain >= 0.0,
+            "currents_72h_gain_ge_0_25pct": current_gain >= 0.25,
+            "waves_72h_gain_ge_0_75pct": wave_gain >= 0.75,
+            "surface_group_exactly_unchanged": surface_change < 1e-8,
+            "subsurface_group_exactly_unchanged": subsurface_change < 1e-8,
+            "variance_not_worse_by_0_02": variance_change >= -0.02,
+            "wave_direction_not_worse_0_5deg": direction_change <= 0.5,
+            "wave_negative_fraction_not_worse": negative_fraction_change <= 1e-4,
+            "interface_coefficients_nontrivial": mean_alpha >= 0.15 and active_alpha_fraction >= 0.5,
+            "ber_runtime_overhead_lt_15pct": float(runtime_table["ber_overhead_percent"].mean()) < 15.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())
+        critical = [
+            "source_zero_sentinel_lt_1e8",
+            "fallback_exactly_reproduces_core",
+            "integrated_medium_72h_gain_ge_0_5pct",
+            "integrated_medium_all_three_positive",
+            "integrated_medium_bootstrap_positive",
+            "correct_beats_negative_ge_0_5pct",
+            "currents_72h_gain_ge_0_25pct",
+            "waves_72h_gain_ge_0_75pct",
+            "surface_group_exactly_unchanged",
+            "subsurface_group_exactly_unchanged",
+        ]
+        qualified = all(checks[key] for key in critical) and passed >= 18
+        if qualified:
+            verdict_name = "V3_S2_A2_MINIMAL_BER_SCALE_CORE_INTEGRATION_QUALIFIED"
+            recommendation = (
+                "Freeze the V3 minimal architecture and proceed to S3 physical "
+                "alignment plus 7-15 day rollout qualification. Do not add deferred modules."
+            )
+        else:
+            verdict_name = "V3_S2_A2_MINIMAL_BER_SCALE_CORE_INTEGRATION_NOT_QUALIFIED"
+            recommendation = (
+                "Drop future BER from V3. Freeze the explicit-scale S1-R3 core with "
+                "Band Closure only; defer richer BER integration to V4/V5."
+            )
+        aggregate = {
+            "raw_medium_72h_rmse_gain_percent": raw_gain,
+            "integrated_medium_72h_rmse_gain_percent": medium_gain,
+            "integrated_severe_72h_rmse_gain_percent": severe_gain,
+            "correct_vs_negative_percent": negative_gap,
+            "correct_vs_history_percent": history_gap,
+            "correct_vs_shifted_percent": shifted_gap,
+            "currents_72h_gain_percent": current_gain,
+            "waves_72h_gain_percent": wave_gain,
+            "variance_ratio_change_72h": variance_change,
+            "wave_direction_error_change_deg": direction_change,
+            "wave_negative_fraction_change": negative_fraction_change,
+            "mean_interface_alpha": mean_alpha,
+            "active_interface_alpha_fraction": active_alpha_fraction,
+            "mean_ber_runtime_overhead_percent": float(runtime_table["ber_overhead_percent"].mean()),
+        }
+        verdict = {
+            "automatic_verdict": verdict_name,
+            "passed": passed,
+            "total": len(checks),
+            "checks": checks,
+            "critical_checks": critical,
+            "aggregate": aggregate,
+            "v3_frozen_scope_if_qualified": [
+                "explicit multi-scale state",
+                "shared scale-conditioned dynamics",
+                "multi-step rollout training",
+                "Band Closure",
+                "minimal future-atmosphere innovation BER",
+                "currents/waves responsibility mask",
+                "six validation-frozen interface coefficients",
+            ],
+            "permanently_excluded_from_v3": [
+                "future boundary BER",
+                "duplicate vertical BER",
+                "explicit variance amplifier",
+                "event router",
+                "multi-source interaction head",
+                "dual-timescale latent core",
+                "strong learned cross-scale flux",
+            ],
+            "next_stage_recommendation": recommendation,
+        }
+        atomic_json(aggregate, output_dir / "S2A2_main_aggregate.json")
+        atomic_json(verdict, output_dir / "S2A2_verdict.json")
+
+        stage(8, 9, "生成冻结合同、图表和部署引用")
+        deployment_contract = {
+            "format": "CIDM_V3_SCS_MINIMAL_FROZEN_INTEGRATION_V1",
+            "s1r3_parent_sha256": s1_assets["sha256"],
+            "min_parent_sha256": min_assets["sha256"],
+            "pairing": pairing,
+            "interface_coefficients": integration_coefficients,
+            "core_runtime_settings": {
+                "flux_mode": "none",
+                "projection": True,
+                "radial_delta": False,
+                "band_closure": True,
+                "slow_memory": False,
+                "vertical_closure": False,
+                "causal_variance": False,
+            },
+            "ber_responsibility": RESPONSIBILITY_GROUPS,
+            "ber_input": "future atmosphere innovation only",
+            "ber_default_deployment_proxy": "medium",
+            "ber_fallback": "exact zero update",
+        }
+        atomic_json(
+            deployment_contract,
+            output_dir / "deployment" / "CIDM_v3_minimal_integration_contract.json",
+        )
+        plt.figure(figsize=(10, 5))
+        subset = summary[summary.horizon == 12]
+        plt.bar(subset["mode"], subset["rmse_gain_vs_core_percent"])
+        plt.axhline(0, linewidth=1)
+        plt.ylabel("72 h RMSE gain over frozen scale core (%)")
+        plt.xticks(rotation=35, ha="right")
+        plt.tight_layout()
+        plt.savefig(output_dir / "figures" / "S2A2_72h_integration_gain.png", dpi=180)
+        plt.close()
+
+        report = f"""# V3-S2-A2-MIN 显式尺度主干与最小BER冻结集成报告
+
+自动判决：`{verdict_name}`
+
+- 原始中等退化接口72小时增益：{raw_gain:.4f}%
+- 验证校准后中等退化72小时增益：{medium_gain:.4f}%
+- 重度退化72小时增益：{severe_gain:.4f}%
+- 正确未来相对负样本：{negative_gap:.4f}%
+- 流场72小时增益：{current_gain:.4f}%
+- 波浪72小时增益：{wave_gain:.4f}%
+- 72小时方差比变化：{variance_change:.4f}
+- 平均接口系数：{mean_alpha:.4f}
+- BER运行时开销：{aggregate['mean_ber_runtime_overhead_percent']:.4f}%
+
+本轮没有训练S1-R3主干，也没有增加新的神经模块。只有六个验证集冻结接口系数。
+"""
+        (output_dir / "实验V3S2A2MIN_冻结集成报告.md").write_text(report, encoding="utf-8")
+
+        stage(9, 9, "安全manifest和结果打包")
+        safe_args = dict(vars(args))
+        safe_args["hf_token"] = "<redacted>"
+        atomic_json(
+            {
+                "experiment": "CIDM_v3_SCS_V3_S2_A2_MIN",
+                "created_at": dt.datetime.now().isoformat(),
+                "device": str(device),
+                "arguments": safe_args,
+                "verdict": verdict_name,
+                "security": "No plaintext access token is written.",
+            },
+            output_dir / "S2A2_manifest.json",
+        )
+        package = package_output(output_dir)
+        print(json.dumps(verdict, ensure_ascii=False, indent=2, default=json_default), flush=True)
+        print(f"[result] {package}", flush=True)
+    except Exception:
+        trace = traceback.format_exc()
+        (output_dir / "failure_traceback.txt").write_text(trace, encoding="utf-8")
+        print(trace, flush=True)
+        raise
+
+
+if __name__ == "__main__":
+    main()