#!/usr/bin/env bash
# ModelArts entrypoint:CMP A2 试点 —— Wan2.2-TI2V-5B 在 graded_pitch_chain 的
# 9 档剂量 × 4 个种子上生成,看它的"倒几张"曲线是跟着剂量走还是一条平线。
#
# 这一版把今天(2026-07-31/08-01)踩过的坑全部前置成硬门:
#   1. import 自检放在权重下载**之前** —— 缺包 30 秒知道,不是 40 分钟后
#   2. 权重下载后**按文件逐个核对大小** —— snapshot_download 连不上远端时会把
#      已有本地目录当成功返回,不校验就会拿着残缺权重往下跑
#   3. 工作目录写 /cache(7.8TB),不写 /home/ma-user(/,300GB 且节点级共享)
#   4. 关 Xet 并直接卸掉 hf-xet —— 它会绕开镜像直连 AWS 美国 CDN
#   5. NVIDIA_DRIVER_CAPABILITIES 不加 graphics(会挂在容器初始化)
set -euo pipefail

WORK="${CMP_WORK:-/cache/cmp}/shard${SHARD_INDEX:-0}"
OUT="${CMP_OUT_DIR:-/home/ma-user/modelarts/outputs/result_0}"
export HF_HOME="${HF_HOME:-/cache/hf}"
# mkdir 失败要**当场说清是谁的目录**。平台建 input 的 local_dir 时以 root 建父目录,
# 而这里是 ma-user;裸 `set -e` 退出只会留下一行 Permission denied,查了三轮才定位
# (2026-08-03)。而且 /cache 是节点级共享,root 属主的残留目录会毒到后续作业。
for D in "$WORK" "$OUT" "$HF_HOME"; do
  if ! mkdir -p "$D" 2>/dev/null; then
    echo "[entry] FATAL 建不了目录 $D — 当前用户 $(id -un)($(id -u)) ;父目录属主/权限:"
    P="$D"; while [[ "$P" != "/" ]]; do
      [[ -e "$P" ]] && { ls -ld "$P"; break; }; P=$(dirname "$P")
    done
    exit 7
  fi
done

echo "[entry] work=$WORK out=$OUT shard=${SHARD_INDEX:-0}/${SHARD_COUNT:-1}"
nvidia-smi --query-gpu=index,name,memory.total,driver_version --format=csv,noheader || true
echo "[entry] nproc=$(nproc)  盘: $(df -BG --output=avail "$WORK" | tail -1 | tr -d ' ') 可用"

export HF_ENDPOINT="${HF_ENDPOINT:-https://hf-mirror.com}"
export HF_HUB_ENABLE_HF_TRANSFER=0
export HF_HUB_DISABLE_XET=1
pip uninstall -y hf-xet >/dev/null 2>&1 || true

# ---- 依赖
python3 -c "import torch;print(f'[entry] 镜像自带 torch {torch.__version__} cuda={torch.cuda.is_available()}',flush=True)"
export PIP_DEFAULT_TIMEOUT=20
probe() { local a=(); [[ -n "$1" ]] && a=(-i "$1"); timeout 30 pip download --no-deps --no-cache-dir -d /tmp/_probe "${a[@]}" six >/dev/null 2>&1; }
IDX=""; for c in "" "https://pypi.tuna.tsinghua.edu.cn/simple" "https://mirrors.aliyun.com/pypi/simple"; do
  if probe "$c"; then IDX="$c"; echo "[entry] pip 源: ${c:-<镜像默认>}"; break; fi
done
IDXA=(); [[ -n "$IDX" ]] && IDXA=(-i "$IDX")
export PIP_DEFAULT_TIMEOUT=60
t0=$SECONDS
# transformers 卡在 [4.49, 4.52):下界要 Qwen2_5_VLModel,上界 4.52+ 用
# torch.distributed.tensor.DTensor 而 torch 2.4 没有(2026-08-01 两轮自检各撞一头)
# ---- 为什么必须升级 torch:两个版本区间不相交(2026-08-02 实测)
#   镜像 torch 2.4 能配的 diffusers <= 0.35.x
#     (0.36+ 的 transformer_kandinsky 模块级 import torch.nn.attention.flex_attention,
#      而 flex_attention 是 torch 2.5 才有,且该模块被 models/transformers/__init__ 急切导入)
#   Wan2.2 TI2V-5B 需要的 diffusers >= 0.36
#     (0.35.1 的 pipeline 不给 VAE 做 patch 化,3 通道喂进 12 通道卷积 →
#      RuntimeError: expected input to have 12 channels, but got 3)
# 所以补丁补不出来,只能把 torch 抬上去。PyPI 的 torch 2.6.0 默认构建就是 cu124,与镜像一致。
if [[ "${CMP_TORCH_UPGRADE:-1}" == "1" ]]; then
  t1=$SECONDS
  pip install "${IDXA[@]}" --progress-bar off -U "torch==2.6.0" "torchvision==0.21.0" || true
  echo "[entry] torch 升级用时 $((SECONDS-t1))s"
  python3 -c "import torch;print(f'[entry] torch 现在是 {torch.__version__} cuda={torch.cuda.is_available()}',flush=True)"

  # flash-attn 2.8.3 与 xformers 都是按 torch 2.4 的 ABI 编译的,升级后会因符号缺失挂掉。
  # 不能 import 的就卸掉 —— 留着它 diffusers 导入时会被带崩。
  for m in flash_attn xformers; do
    if python3 -c "import $m" 2>/dev/null; then
      echo "[entry] $m 升级后仍可导入,保留"
    else
      echo "[entry] $m 升级后已失效(按 torch 2.4 编译),卸掉"
      pip uninstall -y "$(echo $m | tr _ -)" >/dev/null 2>&1 || true
    fi
  done

  # 试装与 torch 2.6 匹配的 flash-attn 预编译轮子;拿不到就退回 torch 自带的 flash 内核。
  # 注意:torch 的 SDPA 本身就含 FlashAttention-2 内核,退回 _native_flash 并不丢加速。
  if ! python3 -c "import flash_attn" 2>/dev/null; then
    for ABI in FALSE TRUE; do
      U="https://github.com/Dao-AILab/flash-attention/releases/download/v2.8.3/flash_attn-2.8.3+cu12torch2.6cxx11abi${ABI}-cp310-cp310-linux_x86_64.whl"
      if timeout 300 pip install --no-deps --progress-bar off "$U" >/dev/null 2>&1; then
        python3 -c "import flash_attn" 2>/dev/null && { echo "[entry] flash-attn 预编译轮子装上了 (abi$ABI)"; break; }
      fi
      echo "[entry] flash-attn 轮子 abi$ABI 不可用"
    done
  fi
fi

# diffusers 用 0.39.0:本地 wan venv 正是这个版本 + torch 2.6,已实测能跑通
# Wan2.2 TI2V-5B(生成首帧与条件帧逐像素平均差 2.11/255)
pip install "${IDXA[@]}" --progress-bar off \
    "diffusers==0.39.0" einops safetensors sentencepiece protobuf ftfy \
    imageio "imageio[ffmpeg]" accelerate "transformers>=4.52,<4.58" || true
# ⚠️ 上界从 <4.52 抬到 <4.58。原来那个 pin 是 torch 升级前的遗留,它**正好把
# HunyuanVideo-1.5 挡死** —— 它的 text_encoder 类 Qwen2_5_VLTextModel 在 4.51.3 没有、
# 4.52.4 才有,权重下完 54GB 才会在 import 那步炸。
# 下界抬到 4.52 同时也满足 Cosmos3(它真实下限是 4.49:pipeline 调 apply_chat_template(),
# 而模板以独立的 chat_template.jinja 存在,4.49 才把它加进 resolved_vocab_files)
# 和 LTX-2(4.50,Gemma3ForConditionalGeneration)。
# 上界 4.58 是因为 diffusers 0.39 与 transformers 4.52~4.57 已验证共存;再高没验过。
python3 -c "import diffusers,torch;print(f'[entry] diffusers {diffusers.__version__} / torch {torch.__version__}',flush=True)" || true

echo "[entry] 依赖安装用时 $((SECONDS-t0))s"

# ---- 取 bundle(首帧 + jobs.json + 生成脚本,几 MB)
if [[ ! -f "$WORK/jobs.json" ]]; then
  echo "[entry] 从 HF 拉 bundle $CMP_CODE_REPO"
  python3 - <<PY
import os, tarfile
from huggingface_hub import hf_hub_download
p = hf_hub_download(repo_id="${CMP_CODE_REPO}", repo_type="dataset",
                    filename="cmp_a2_bundle.tar.gz", local_dir="/tmp/cmpb")
with tarfile.open(p) as t: t.extractall("${WORK}")
print("[entry] bundle 解包完成", flush=True)
PY
fi
cd "$WORK"
ls -la | head -8

# ---- torch 2.4 兼容补丁,必须在任何 import diffusers 之前
# diffusers 0.39 的版本 guard 写成 `torch.__version__ >= "2.4.0"`(字符串比较),
# 2.4.0 正好通过,于是用了真的 custom_op —— 而 torch 2.4 的 infer_schema 解析不了
# 它那个 `float | None` 签名。把阈值抬到 2.5.0,让 diffusers 走它自己的 no-op 兜底。
# 详见 torch24_compat.py 里记录的三条已排除的错误做法。
python3 torch24_compat.py

# ---- import 自检(必须在权重下载之前)
echo "[entry] ---- import 自检"
python3 - <<'PYSELF'
import importlib, sys
bad = []
for m in ["torch", "diffusers", "transformers", "einops", "safetensors",
          "imageio", "PIL", "accelerate"]:
    try:
        importlib.import_module(m); print(f"  ok   {m}", flush=True)
    except Exception as e:
        bad.append(m); print(f"  FAIL {m}: {type(e).__name__}: {e}", flush=True)
from diffusers import WanImageToVideoPipeline, AutoencoderKLWan   # 点名要用的两个类
import torch
assert torch.cuda.is_available(), "cuda 不可用"
if bad:
    raise SystemExit(f"[entry] FATAL import 自检未过: {bad}")

# ---- 注意力后端:声明了要用 flash 就必须**实跑一次**确认,不能只看环境变量。
# 这里**不 fail-fast**,而是把三种可能都测一遍再报 —— 一轮自检把全貌拿到,
# 免得"修一个发现一个"又来回好几轮(前面已经为此耗了 6 轮)。
import os
from diffusers.models import attention_dispatch as _ad
want = os.environ.get("DIFFUSERS_ATTN_BACKEND", "native")
print(f"[entry] 声明后端={want}  flash可用={_ad._CAN_USE_FLASH_ATTN} "
      f"flash3可用={_ad._CAN_USE_FLASH_ATTN_3}", flush=True)

q = torch.randn(1, 8, 64, 64, device="cuda", dtype=torch.bfloat16)
# ① 外部 flash-attn 包
try:
    import flash_attn
    qq = q.permute(0, 2, 1, 3).contiguous()          # (B, S, H, D)
    o = flash_attn.flash_attn_func(qq, qq, qq)
    assert torch.isfinite(o).all()
    print(f"[entry] ① 外部 flash-attn {flash_attn.__version__} 实跑通过 {tuple(o.shape)}", flush=True)
except Exception as e:
    print(f"[entry] ① 外部 flash-attn 不可用: {type(e).__name__}: {str(e)[:90]}", flush=True)
# ② torch 自带 SDPA 的 flash 内核(torch 2.6 的 SDPA 里就含 FlashAttention-2)
try:
    from torch.nn.attention import SDPBackend, sdpa_kernel
    with sdpa_kernel(SDPBackend.FLASH_ATTENTION):
        o2 = torch.nn.functional.scaled_dot_product_attention(q, q, q)
    assert torch.isfinite(o2).all()
    print(f"[entry] ② torch SDPA flash 内核实跑通过 {tuple(o2.shape)}", flush=True)
except Exception as e:
    print(f"[entry] ② torch SDPA flash 内核不可用: {type(e).__name__}: {str(e)[:90]}", flush=True)

# ---- ③ 带 mask 的注意力(这一条 2026-08-03 吃过大亏)
# HunyuanVideo-1.5(Qwen2.5-VL)与 LTX-2(Gemma3)的文本编码器会把 padding mask
# 一路传进 attention,而 flash-attn 2 内核**不接受 attn_mask**,直接抛
# `ValueError: attn_mask is not supported for flash-attn 2.`。
# 上一轮这两个作业各自下完 54GB/144GB 权重、跑到第一条才炸。这里 1 秒钟就能看出来。
try:
    m = torch.ones(1, 1, 64, 64, device="cuda", dtype=torch.bool)
    o3 = torch.nn.functional.scaled_dot_product_attention(q, q, q, attn_mask=m)
    assert torch.isfinite(o3).all()
    print(f"[entry] ③ 带 mask 的 SDPA 实跑通过 {tuple(o3.shape)}", flush=True)
except Exception as e:
    print(f"[entry] ③ 带 mask 的 SDPA 不可用: {type(e).__name__}: {str(e)[:90]}", flush=True)
if want == "flash":
    print("[entry] ⚠️ 本作业声明 flash 后端。若该模型的文本编码器会传 attn_mask"
          "(HunyuanVideo-1.5 / LTX-2 就会),生成会抛 "
          "`attn_mask is not supported for flash-attn 2.` —— 这类模型的规格里"
          "必须写 attn_backend='native'。", flush=True)

print(f"[entry] import 自检通过 (torch {torch.__version__})", flush=True)
PYSELF
if [[ "${CMP_SELFTEST_ONLY:-0}" == "1" ]]; then
  echo "[entry] CMP_SELFTEST_ONLY=1,自检完毕提前退出(不下权重)"; exit 0
fi

# ---- 权重:优先用**挂载的 OBS 缓存**,没挂载才从 hf-mirror 下
# 上一轮 canary 已经把权重同步到 OBS 了(hunyuan 54.2GB / LTX-2 143.7GB)。
# 重跑时挂回来,省掉 53~67 分钟的下载。挂载点由 submit 指到 /cache(7.8TB),
# **不能落 /home/ma-user** —— 那是 300GB 且节点级共享,144GB 进去就危险。
MOUNT="${CMP_MODEL_MOUNT:-}"
if [[ -n "$MOUNT" ]]; then
  echo "[entry] 用挂载的权重缓存:$MOUNT"
  if [[ ! -f "$MOUNT/model_index.json" ]]; then
    echo "[entry] FATAL 挂载点里没有 model_index.json,挂错前缀了:$MOUNT"; ls -la "$MOUNT" | head -20; exit 8
  fi
  # 验收:挂载不是下载,平台同步中断不会报错,必须自己核字节数
  GOT=$(du -sb "$MOUNT" | cut -f1)
  WANT=$(python3 -c "print(int(float('${CMP_WEIGHTS_GB:-0}')*1e9*0.95))")
  echo "[entry] 挂载权重 $((GOT/1000000000))GB,下限 $((WANT/1000000000))GB(规格 ${CMP_WEIGHTS_GB:-?}GB 的 95%)"
  if [[ "$GOT" -lt "$WANT" ]]; then
    echo "[entry] FATAL 挂载的权重不完整,拒绝往下跑"; exit 8
  fi
  export CMP_MODEL_DIR="$MOUNT"
  export CMP_CACHE_WEIGHTS=0          # 已经在 OBS 了,不要再复制回去
  echo "[entry] 权重验收通过,跳过下载"
else
python3 - <<'PY'
import os, time
from huggingface_hub import snapshot_download, HfApi
REPO = os.environ.get("CMP_MODEL_REPO", "Wan-AI/Wan2.2-TI2V-5B-Diffusers")
LOCAL = os.environ["CMP_MODEL_DIR"]
# ⚠️ allow_patterns:有的仓整仓远大于 diffusers 布局真正需要的部分。
# LTX-2 整仓 314.35GB,其中 169.66GB 是根目录的 ComfyUI 单文件权重
# (ltx-2-19b-{dev,distilled,dev-fp8,distilled-fp8,dev-fp4}.safetensors),
# diffusers 一个都不读。不设白名单就是下 314GB。
import fnmatch
_ap = os.environ.get("CMP_ALLOW_PATTERNS", "").strip()
ALLOW = [x for x in _ap.split("|") if x] or None
if ALLOW:
    print(f"[entry] 定向下载,白名单 {ALLOW}", flush=True)

def retried(fn, what, attempts=8):
    for i in range(attempts):
        try:
            return fn()
        except Exception as e:
            if i == attempts - 1: raise
            w = min(60, 5 * 2 ** i)
            print(f"[entry] {what} 第 {i+1} 次失败({type(e).__name__}),{w}s 后续传重试", flush=True)
            time.sleep(w)

exp = retried(lambda: {f.rfilename: (f.size or 0) for f in
                       HfApi(endpoint=os.environ["HF_ENDPOINT"]).model_info(
                           REPO, files_metadata=True).siblings}, "取文件清单")
if ALLOW:
    n0, g0 = len(exp), sum(exp.values()) / 1e9
    exp = {k: v for k, v in exp.items() if any(fnmatch.fnmatch(k, p) for p in ALLOW)}
    print(f"[entry] 白名单过滤:{n0} 个文件 / {g0:.1f}GB "
          f"-> {len(exp)} 个 / {sum(exp.values())/1e9:.1f}GB", flush=True)
    if not exp:
        raise SystemExit("[entry] FATAL 白名单把文件全过滤掉了,模式写错了")

def missing():
    bad = []
    for n, s in exp.items():
        p = os.path.join(LOCAL, n)
        if not os.path.exists(p) or (s and os.path.getsize(p) != s):
            bad.append(n)
    return bad

t = time.time()
for attempt in range(8):
    retried(lambda: snapshot_download(REPO, local_dir=LOCAL, max_workers=4,
                                      allow_patterns=ALLOW), "权重")
    bad = missing()
    if not bad: break
    print(f"[entry] 验收第 {attempt+1} 轮:{len(bad)}/{len(exp)} 个文件不齐,例如 {bad[:2]}", flush=True)
    time.sleep(10)
else:
    raise SystemExit(f"[entry] FATAL 权重始终不完整,缺 {missing()[:5]}")
tot = sum(exp.values())
print(f"[entry] 权重就位并验收通过 {time.time()-t:.0f}s "
      f"({len(exp)} 个文件 / {tot/1e9:.1f}GB)", flush=True)
PY
fi
# set -u 下引用未设置的变量会直接退出,连 `|| true` 都救不回来,所以给默认值
du -sh "${CMP_MODEL_DIR:-/nonexistent}" 2>/dev/null || true

# ---- 分支:双臂训练(uniform vs weighted)。latent 缓存随包带,云上不跑 VAE。
if [[ "${CMP_TASK:-gen}" == "train" ]]; then
  echo "[entry] ==== CMP_TASK=train:臂 ${CMP_TRAIN_ARM:-weighted}"
  # latent 缓存(90 条,89MB)随包带 —— 云上**不跑 VAE**,预处理一次做完复用
  if [[ ! -d "$WORK/latents" ]]; then
    echo "[entry] 从 HF 拉 latent 缓存"
    python3 - <<PY
import tarfile
from huggingface_hub import hf_hub_download
p = hf_hub_download(repo_id="${CMP_CODE_REPO}", repo_type="dataset",
                    filename="latents.tar.gz", local_dir="/tmp/lat")
with tarfile.open(p) as t: t.extractall("${WORK}")
print("[entry] latent 解包完成", flush=True)
PY
  fi
  NL=$(ls "$WORK/latents"/*.npz 2>/dev/null | wc -l)
  echo "[entry] latent 缓存 $NL 条"
  [[ "$NL" -ge 80 ]] || { echo "[entry] FATAL latent 只有 $NL 条,不完整"; exit 30; }
  pip install "${IDXA[@]}" --progress-bar off peft >/dev/null 2>&1 \
    && echo "[entry] peft 就位" || { echo "[entry] FATAL peft 装不上"; exit 31; }
  # ⚠️ 符号约定自检必须先过。写反了模型朝反方向训,loss 照样下降,不会报任何错。
  python3 -u "$WORK/train_stopmask.py" selftest || {
    echo "[entry] FATAL 流匹配符号自检未过,拒绝开训"; exit 32; }
  # ⚠️ 文本嵌入**必须在云上现编**:分词器和文本编码器只有模型目录里有(34GB,不随包带)。
  # 2026-08-06 之前这一步根本不存在,训练用的是 build_kwargs 里给探针准备的全零占位 ——
  # 等于"在没有文本的世界里训,拿有文本的世界去测"。T3 那四个 LoRA 就是这么来的。
  python3 -u "$WORK/train_stopmask.py" text \
    --model "$CMP_MODEL_DIR" --out "$WORK" --prompts "$WORK/prompts.json" || {
    echo "[entry] FATAL 文本嵌入没编出来,拒绝开训(不许退回全零占位)"; exit 34; }
  TOUT="$OUT/train"
  set +e
  python3 -u "$WORK/train_stopmask.py" train --arm "${CMP_TRAIN_ARM:-weighted}" \
    --model "$CMP_MODEL_DIR" --out "$WORK" --layers "$WORK/phase_layers" \
    --manifest "$WORK/train_manifest.json" --prompts "$WORK/prompts.json" \
    --steps "${CMP_TRAIN_STEPS:-3000}" --lr "${CMP_TRAIN_LR:-1e-4}" \
    --rank "${CMP_TRAIN_RANK:-32}" --seed "${CMP_TRAIN_SEED:-0}" 2>&1 \
    | grep -a --line-buffered -vE "^\s*$|it/s\]"
  TRC=${PIPESTATUS[0]}
  set -e
  echo "[entry] 训练退出码 = $TRC"
  cp -r "$WORK/lora_${CMP_TRAIN_ARM:-weighted}" "$OUT/" 2>/dev/null || true
  cp "$WORK"/loss_*.json "$WORK"/prompt_index.json "$WORK"/cond_proj_*.safetensors "$OUT/" 2>/dev/null || true
  N=$(find "$OUT" -name '*.safetensors' | wc -l)
  echo "[entry] LoRA 权重 $N 个"
  [[ "$TRC" -eq 0 && "$N" -gt 0 ]] || { echo "[entry] FATAL 训练失败(码 $TRC,权重 $N)"; exit 33; }
  echo "[entry] DONE"; exit 0
fi

# ---- 分支:C 实验(因果干预)。到目前为止全是观察(固定视频上跑探针),这是第一个因果实验。
# 前置(依赖链/权重校验/注意力自检)照旧复用,只换最后一步。
if [[ "${CMP_TASK:-gen}" == "intervene" ]]; then
  echo "[entry] ==== CMP_TASK=intervene:因果干预(模式 ${CMP_IV_MODE:-none})"
  IVOUT="$OUT/iv"; mkdir -p "$IVOUT"
  ARGS=(--jobs "$WORK/jobs.json" --images "$WORK/images" --out "$IVOUT"
        --specs "$WORK/model_specs.py" --model "$CMP_MODEL_DIR"
        --model-key "$CMP_MODEL_KEY" --mode "${CMP_IV_MODE:-none}")
  [[ -n "${CMP_IV_DIRECTION:-}" ]] && ARGS+=(--direction "$WORK/${CMP_IV_DIRECTION}")
  [[ -n "${CMP_IV_ALPHAS:-}"    ]] && ARGS+=(--alphas "$CMP_IV_ALPHAS")
  [[ -n "${CMP_IV_STEPS:-}"     ]] && ARGS+=(--steps "$CMP_IV_STEPS")
  [[ -n "${CMP_IV_SEEDS:-}"     ]] && ARGS+=(--seeds "$CMP_IV_SEEDS")
  [[ -n "${CMP_IV_LIMIT:-}"     ]] && ARGS+=(--limit "$CMP_IV_LIMIT")
  [[ "${CMP_IV_CHECK_NOOP:-0}" == "1" ]] && ARGS+=(--check-noop)
  set +e
  python3 -u "$WORK/intervene_gen.py" "${ARGS[@]}" 2>&1 \
    | grep -a --line-buffered -vE "^\s*$|it/s\]|Loading pipeline"
  IRC=${PIPESTATUS[0]}
  set -e
  echo "[entry] 干预退出码 = $IRC"
  # 空转自检那一趟不产 mp4,退出码 0 就算过;其余模式必须有产物
  if [[ "${CMP_IV_CHECK_NOOP:-0}" == "1" ]]; then
    [[ "$IRC" -eq 0 ]] || { echo "[entry] FATAL 空转自检未过(退出码 $IRC)——"
                            echo "        挂钩子本身在改东西,或采样里有未固定的随机源。"
                            echo "        **这一关不过,后面任何干预结果都不可信。**"; exit 13; }
    echo "[entry] ✅ 空转自检通过"
  else
    N=$(find "$IVOUT" -name '*.mp4' | wc -l)
    echo "[entry] 干预产物 $N 个 mp4"
    [[ "$IRC" -eq 0 && "$N" -gt 0 ]] || { echo "[entry] FATAL 干预失败(码 $IRC,产物 $N)"; exit 14; }
  fi
  echo "[entry] DONE"
  exit 0
fi

# ---- 分支:B 实验(DiT 接触探针)。走到这里前置全都跑过了 ——
# 依赖链、权重逐文件校验、注意力后端实跑,一条都不重写。只把最后一步换掉。
if [[ "${CMP_TASK:-gen}" == "probe" ]]; then
  echo "[entry] ==== CMP_TASK=probe:跑 DiT 接触探针,不生成视频"
  DZ="$WORK/cmp288_dataset.zip"
  if [[ ! -f "$DZ" ]]; then
    echo "[entry] 从 HF 拉参考数据集 ${CMP_DATA_REPO}"
    python3 - <<PY
from huggingface_hub import hf_hub_download
import shutil
p = hf_hub_download(repo_id="${CMP_DATA_REPO}", repo_type="dataset",
                    filename="cmp288_dataset.zip", local_dir="/tmp/cmpdata")
shutil.copy(p, "${DZ}")
print("[entry] 数据集就位", flush=True)
PY
  fi
  # 大小核对:snapshot/hf_hub_download 断线时会把残缺文件当成功返回(权重那边吃过)
  SZ=$(stat -c %s "$DZ")
  if [[ "$SZ" -lt 200000000 ]]; then
    echo "[entry] FATAL 数据集只有 $SZ 字节,不完整(应 ~228MB)"; exit 11
  fi
  echo "[entry] 数据集 $((SZ/1000000)) MB"
  NPZ="$OUT/feats_${CMP_MODEL_KEY}.npz"
  set +e
  python3 -u "$WORK/dit_contact_probe.py" extract \
    --model "$CMP_MODEL_DIR" --zip "$DZ" --n "${CMP_PROBE_N:-40}" --npz "$NPZ" \
    --phys-labels "$WORK/phys_labels.json" 2>&1 \
    | grep -a --line-buffered -vE "^\s*$|Loading pipeline|it/s\]|clip_output"
  PRC=${PIPESTATUS[0]}
  set -e
  echo "[entry] 抽特征退出码 = $PRC"

  # ---- 分析也在云上做。特征 npz 有 1.6~2 GB,拉回本地再算是白耗带宽,
  # 而且下载没完就开跑会读到半个文件(2026-08-06 踩过:BadZipFile)。
  # 这里直接出结果 JSON(几 KB),本地只回收它。
  if [[ "$PRC" -eq 0 ]]; then
    echo "[entry] ---- 装分析依赖并跑探针"
    pip install "${IDXA[@]}" --progress-bar off scikit-learn scipy >/dev/null 2>&1 \
      && echo "[entry] scikit-learn/scipy 就位" || echo "[entry] ⚠️ 分析依赖装不上"
    RES="$OUT/result_${CMP_MODEL_KEY}.json"
    set +e
    python3 -u "$WORK/dit_contact_probe.py" probe --npz "$NPZ" --out "$RES" 2>&1 \
      | grep -a --line-buffered -vE "LinAlgWarning|ill-conditioned|return linalg|ConstantInputWarning|r = spearmanr"
    ARC=${PIPESTATUS[0]}
    set -e
    echo "[entry] 探针分析退出码 = $ARC(2=自检未过,结果仍会落盘)"
    [[ -s "$RES" ]] && echo "[entry] 结果 $(stat -c %s "$RES") 字节 -> $(basename "$RES")" \
                    || echo "[entry] ⚠️ 结果 JSON 没落盘"

    # ---- 逐跳 kill test:方法第二件事的生死判据。
    # 标签是本地从轨迹 npz 的**速度**算好随包带的(容器里没有轨迹)——
    # 不能就地用位移凑,那会把牛顿摆族 48 个标签标反(中间球位移≈0 但冲量穿过去了)。
    HRES="$OUT/hop_${CMP_MODEL_KEY}.json"
    set +e
    python3 -u "$WORK/hop_probe.py" --npz "$NPZ" --zip "$DZ" \
      --hop-labels "$WORK/hop_labels.json" --out "$HRES" 2>&1 \
      | grep -a --line-buffered -vE "LinAlgWarning|ill-conditioned|return linalg|ConstantInputWarning"
    HRC=${PIPESTATUS[0]}
    set -e
    echo "[entry] 逐跳探针退出码 = $HRC"
    [[ -s "$HRES" ]] && echo "[entry] 逐跳结果 $(stat -c %s "$HRES") 字节" \
                     || echo "[entry] ⚠️ 逐跳结果没落盘"
  fi
  if [[ "${CMP_CACHE_WEIGHTS:-1}" == "1" ]]; then
    WDST="$OUT/weights/$(basename "$CMP_MODEL_DIR")"
    echo "[entry] 把权重复制到 outputs 供平台同步到 OBS -> $WDST"
    mkdir -p "$WDST"; cp -r "$CMP_MODEL_DIR/." "$WDST/" || true
  fi
  # 产物门:npz 必须存在且不是空壳。探针失败时留个 0 字节文件比没有更坏。
  if [[ "$PRC" -ne 0 || ! -s "$NPZ" ]]; then
    echo "[entry] FATAL 探针失败(退出码 $PRC,npz $(stat -c %s "$NPZ" 2>/dev/null || echo 无))"
    exit 12
  fi
  echo "[entry] 探针产物 $(du -h "$NPZ" | cut -f1)"
  echo "[entry] DONE"
  exit 0
fi

# ---- 分支:渲染泄漏 σ 扫描。把真值 latent 在第 k 步注进去,量物理还剩多少。
if [[ "${CMP_TASK:-gen}" == "leak" ]]; then
  echo "[entry] ==== CMP_TASK=leak:渲染泄漏 σ 扫描(注入步 ${CMP_LEAK_STEPS:-默认})"
  NR=$(ls "$WORK/refs"/*.mp4 2>/dev/null | wc -l)
  echo "[entry] 真值视频 $NR 条"
  [[ "$NR" -gt 0 ]] || { echo "[entry] FATAL 包里没有 refs/*.mp4,泄漏实验没有输入"; exit 36; }
  export CMP_JOBS="$WORK/jobs.json" CMP_IMAGES="$WORK/images" \
         CMP_REFS="$WORK/refs" CMP_OUT="$OUT/leak" CMP_SPECS="$WORK/model_specs.py"
  set +e
  python3 -u "$WORK/cmp_leak_gen.py" 2>&1 \
    | grep -a --line-buffered -E "^\[leak\]|Traceback|Error|error|CUDA out of memory|^ +File \"|^ +[a-zA-Z_]|^[A-Za-z_.]+Error"
  LRC=${PIPESTATUS[0]}
  set -e
  echo "[entry] 泄漏脚本退出码 = $LRC(13=注入没生效 14=σ 方向反了)"
  N=$(find "$OUT" -name '*.mp4' | wc -l)
  echo "[entry] 产物 $N 个 mp4"
  [[ "$LRC" -eq 0 && "$N" -gt 0 ]] || { echo "[entry] FATAL 泄漏实验失败(码 $LRC,产物 $N)"; exit 37; }
  echo "[entry] DONE"; exit 0
fi

# ---- 生成
export CMP_JOBS="$WORK/jobs.json" CMP_IMAGES="$WORK/images" CMP_OUT="$OUT/gen"
export CMP_SPECS="$WORK/model_specs.py"
# ---- 评测臂:CMP_LORA_ARM 给臂名(uniform_s0 / weighted_s1 / …),空=跑未微调的基座。
# 合并由 lora_merge.py 做,**不走 peft**:T2 那 4 个作业就是被 peft 包装改掉返回类型弄死的。
# 合并不生效会抛异常,不会静默跑一个没挂 LoRA 的模型冒充"微调后"。
if [[ -n "${CMP_LORA_ARM:-}" ]]; then
  export CMP_LORA="$WORK/lora/${CMP_LORA_ARM}"
  if [[ ! -f "$CMP_LORA/adapter_model.safetensors" ]]; then
    echo "[entry] FATAL 找不到 LoRA:$CMP_LORA"; ls -R "$WORK/lora" 2>/dev/null | head -20; exit 35
  fi
  echo "[entry] 评测臂 = $CMP_LORA_ARM  ($(du -h "$CMP_LORA/adapter_model.safetensors" | cut -f1))"
  # 相位条件自动探测:包里有该臂的 cond_proj 就必须连图层一起挂;缺图层 = FATAL,
  # 不许静默跑成"只有 LoRA 没有条件"的半吊子。
  if [[ -f "$WORK/cond_proj/${CMP_LORA_ARM}.safetensors" ]]; then
    [[ -d "$WORK/layers" ]] || { echo "[entry] FATAL 有 cond_proj 没有 layers/ 目录"; exit 38; }
    export CMP_COND_PROJ="$WORK/cond_proj/${CMP_LORA_ARM}.safetensors"
    export CMP_PHASE_DIR="$WORK/layers"
    echo "[entry] 相位条件已启用:$CMP_COND_PROJ + $(ls "$WORK/layers" | wc -l) 份图层"
  else
    echo "[entry] 无 cond_proj(纯 LoRA 臂)"
  fi
else
  echo "[entry] 评测臂 = base(未微调基座)"
fi
# 流场输运自动探测(与 LoRA/相位条件独立;flows/ 在包里就启用)
if [[ -d "$WORK/flows" ]]; then
  export CMP_FLOW_DIR="$WORK/flows"
  echo "[entry] 流场输运已启用:$(ls "$WORK/flows" | wc -l) 份流场"
fi
# 管道里 grep 会把 python 的退出码吃掉(pipefail 也只看最后一个非零),
# 所以用 PIPESTATUS 单独取出来显式报告 —— 否则 python 崩了日志里只是"少了几个 mp4"
set +e
# ⚠️ 过滤器必须留住**缩进的调用栈行**(`  File "...", line N, in fn`)。
# 原来的 `^\[gen\]|Traceback|Error` 只留了首行和末行,中间调用栈全被吃掉 ——
# 结果 OOM 只看得到"要分配 23 GiB",看不到是谁分配的,白白多跑了两轮
# (2026-08-03 HunyuanVideo-1.5)。
# ⚠️ `--line-buffered` 不能省。grep 的输出不是 tty 时按块缓冲(4KB),
# 整个生成过程的 [gen] 进度会攒着不吐,要等作业结束才一次性出现 ——
# 对 hunyuan/wan21 那种几小时的作业,等于全程看不见进度,也判断不了是慢还是卡死
# (2026-08-03 实测:跑了 30 分钟的作业日志停在 `du -sh` 那一行)。
python3 -u "$WORK/cmp_multimodel_gen.py" 2>&1 \
  | grep -a --line-buffered -E "^\[gen\]|Traceback|Error|error|CUDA out of memory|^ +File \"|^ +[a-zA-Z_]|^[A-Za-z_.]+Error"
GEN_RC=${PIPESTATUS[0]}
set -e
echo "[entry] 生成脚本退出码 = $GEN_RC"

# ---- 把权重同步到 OBS(下次作业挂载复用,不用再从 hf-mirror 下)
# 写进 outputs 目录,平台会同步到 --output-root。CMP_CACHE_WEIGHTS=0 可关掉。
if [[ "${CMP_CACHE_WEIGHTS:-1}" == "1" ]]; then
  WDST="$OUT/weights/$(basename "$CMP_MODEL_DIR")"
  echo "[entry] 把权重复制到 outputs 供平台同步到 OBS -> $WDST"
  mkdir -p "$WDST"
  t1=$SECONDS
  cp -r "$CMP_MODEL_DIR/." "$WDST/" && echo "[entry] 权重复制用时 $((SECONDS-t1))s,$(du -sh "$WDST" | cut -f1)"
fi

N=$(find "$OUT" -name '*.mp4' | wc -l)
echo "[entry] 产物 $N 个 mp4"
if [[ "$GEN_RC" -ne 0 || "$N" -eq 0 ]]; then
  echo "[entry] FATAL 生成失败(退出码 $GEN_RC,产物 $N)"; exit 9
fi
echo "[entry] DONE"