feat(train/monitor): 评估峰值不再撑爆整卡 + 从指定阶段重训 + 闭环误差诊断

- train.py：evaluate 改 bs=64，结束后 empty_cache()。WDDM 下 15.9 GiB 的评估峰值用完不退，
  整卡顶到 96% 后驱动把训练张量换出（实测 Local 18.8 GB / Shared 1.9 GB），吞吐从 5.5k
  掉到 444 samples/s、8000 步 eval 卡死 68 分钟；改后峰值 5.32 GiB、eval 106 s、吞吐 6.4–7.0k。
- pstate/pipeline：新增 --fresh-from=<阶段>：只把该阶段及之后的产物移进 ml/archive/（不删），
  与参数失效取并集；配合 FROM 实现"只重训某一阶段，之后全部重做"（沙盒实测选 train 只归档 ml/runs/base）。
- monitor：运行方式加「从指定阶段重训」+ 起始阶段下拉；TARGET_SAMPLES 默认改 200 万；
  「最好 X%」改标最好那次 eval 的步数（原来错标当前步，18,000 步显示成 0.2% 的出处）。
  连同工作区已有的停止补扫 sweep_nt（按命令行补杀 git-bash 下逃逸的孙进程）一并提交。
- eval/diag_tail.py：闭环末位误差 / 是否进过 5 mm 窗口的逐题诊断（手动运行，不进流水线）。

docs/ML运行手册审查.md

@@ -25,7 +25,7 @@
 |---|---|
 | R9（真查看器、训练好的模型、30 道贴柱题） | 稳态 `planWarmP99` < 45 ms、运动中饥饿 < 1%、认证超时占比 < 5%；冷启动 P99、刹停率、`tickGapMax` 只报 |
 | R9 不过 | 几何查询（特征、投影、认证）搬进 Worker，主线程只执行 |
-| APG | batch 48、steps 8000（总任务量同原 128×3000），进程显存硬帽 `VRAM_FRAC=0.78` |
+| APG | batch 48、steps 8000（总任务量同原 128×3000），本进程显存上限浮动（整卡 − 已用 − 1 GB 余量，见 `ml/common/vram.py`） |
 | 离线 ort | 只用入库本地副本，缺失即报错，不退回 CDN |
 | 训练余量 3 mm | `stats.json` 间隙 p10 ≥ 3 mm 保持，否则降到 p10 |
 | `R2_STRICT` | `pool_check.independent=true` 且截距 < 0.10 时打开 |

ml/README.md

@@ -131,7 +131,7 @@ bash ml/pipeline.sh train                           # MeanFlow 头 → ml/runs/b
 
 - **通过线（R10）：`samples_per_s` ≥ 5000，即 60000 步 ≤ 3.5 小时**。参考：3090、batch 1024 实测 6.2 k 样本/s ≈ 2.8 小时。MeanFlow 的 JVP 双前向使训练受算力限制，加大 batch 不会提高样本/s；低于通过线时把 `configs/base.json` 的 `fk_caps` 从 96 降到 48，仍不够再把 `steps` 降到 40000
 - 训练中每 2000 步打印一行 `EVAL {...}`：val 任务闭环（部署节奏、不开安全层）`success`、`collision_rate`、`time_ok_1p3`、`start_fail`。时限 = 老师时长 × 2（至少 3 s）
-- 显存预算按 **19–20 GB** 算（Windows + 4K 桌面常驻占 4–5 GB），训练与 APG 进程启动时自设硬帽 `VRAM_FRAC=0.78`（≈18.7 GiB），日志 `vram` 字段记峰值；预训练 `batch=1024` 实测峰值 2.76 GiB。显存不够把 `batch` 改成 512。中断后再跑 `bash ml/pipeline.sh train`（或 `all`）会自动从 `ml/runs/<头>/last.pt` 续训（每 10 分钟存一次），测速那 2000 步做过就跳过。训练发散时不会用发散的权重覆盖 `last.pt` / `best.pt`。
+- 显存预算**浮动**：整卡留 1 GB 给系统（`VRAM_RESERVE_GIB`，默认 1），训练与 APG 进程启动时按"整卡 − nvidia-smi 已用 − 余量"和"CUDA 空闲 − 余量"两者取小自设本进程上限（`ml/common/vram.py`）。占显存的应用多，上限就自动变小，不用改配置；想按定值对拍给 `VRAM_FRAC`（旧口径 0.78）。日志 `vram` 字段记峰值；预训练 `batch=1024` 实测峰值 2.76 GiB、APG `batch=48` 13.08 GiB。显存不够把 `batch` 改成 512。中断后再跑 `bash ml/pipeline.sh train`（或 `all`）会自动从 `ml/runs/<头>/last.pt` 续训（每 10 分钟存一次），测速那 2000 步做过就跳过。训练发散时不会用发散的权重覆盖 `last.pt` / `best.pt`。
 
 ## 7. M5 门禁：选定动作头
 

ml/common/vram.py

@@ -1,19 +1,46 @@
-"""显存预算（2026-10-18 本机实测后加）。
-用户定的预算：这台 3090 只有 19–20 GB 能给训练用——Windows + 4K 桌面常驻就占掉 4–5 GB（空载 nvidia-smi 4.4 GB）。
-  limit()     给本进程设硬帽（VRAM_FRAC，默认 0.78 ≈ 18.7 GiB）。超限时在自己的反向里早失败，
-              而不是把桌面挤到没有显存（整机卡顿、别的应用崩），这也是 APG batch=128 原先 OOM 时把显存顶到 23.6 GB 的原因。
-  peak_gib()  记进日志的 vram 字段：网页指标卡与 ml/selftest.sh 都按它核对预算，不用再去猜。
-实测参考（d=192 同结构、1 步即到位）：预训练 batch=1024 → 2.76；APG batch=48/plans=150 → 13.08、batch=128 → OOM。"""
+"""显存预算（2026-10-18 本机实测后加；同日两次修正）。
+口径：整卡留 1 GB 给系统（VRAM_RESERVE_GIB），本进程上限 = CUDA 可用 − 余量。
+为什么不能按"整卡 − nvidia-smi 已用"扣：WDDM 下 nvidia-smi 的"已用"含**驱动可以换出**的量，
+把它当硬占用会把自己卡死——实测预训练第一次 evaluate 峰值要 ~15 GiB，那样算出的上限只有
+14.45 GiB，torch 就报 OOM，而同一时刻卡上其实还有 9.98 GiB 空闲（train.py step 2000 的评估里挂掉）。
+CUDA 的 mem_get_info 才是"我实际能拿到多少"：它已经把可换出的部分算进去了。
+  limit()     上限 = min(CUDA 可用, 整卡) − 余量；显式给 VRAM_FRAC 时再取较小值（跟旧口径 0.78 对拍用）。
+              别的应用占多少照样打印，但只作参考、不从上限里扣。
+  peak_gib()  记进日志的 vram 字段：网页指标卡与 ml/selftest.sh 都按它核对，不用再去猜。
+实测参考（d=192 同结构）：预训练 batch=1024 的训练步峰值只有 2.76 GiB，但第一次 evaluate 就要 ~15 GiB
+（kin.gaps 一次开 2.35 GiB）；APG batch=48/plans=150 → 13.08 GiB。"""
 import os
+import subprocess
 import torch
 
 
+def _smi():
+    """(整卡已用 GiB, 整卡总量 GiB)；拿不到就 (None, None)。"""
+    try:
+        q = 'memory.used,memory.total'
+        r = subprocess.run(['nvidia-smi', f'--query-gpu={q}', '--format=csv,noheader,nounits'],
+                           capture_output=True, text=True, timeout=3)
+        u, t = [float(x) for x in r.stdout.strip().splitlines()[0].split(',')[:2]]
+        return u / 1024, t / 1024
+    except Exception:
+        return None, None
+
+
 def limit():
     if not torch.cuda.is_available(): return False
-    f = float(os.environ.get('VRAM_FRAC', '0.78'))
     tot = torch.cuda.get_device_properties(0).total_memory / 2**30
-    torch.cuda.set_per_process_memory_fraction(f)
-    print('显存上限：本进程 %.1f GiB（整卡 %.1f GiB × %.2f，其余留给桌面）' % (f * tot, tot, f), flush=True)
+    torch.empty(1, device='cuda')            # 让本进程的 CUDA 上下文先落地，再读可用（否则会把自家上下文算进可用）
+    free = torch.cuda.mem_get_info()[0] / 2**30
+    res = float(os.environ.get('VRAM_RESERVE_GIB', '1'))
+    cap = min(free, tot) - res
+    if os.environ.get('VRAM_FRAC'):          # 显式硬帽（对拍旧口径用）
+        cap = min(cap, tot * float(os.environ['VRAM_FRAC']))
+    cap = max(1.0, min(cap, tot - res))
+    torch.cuda.set_per_process_memory_fraction(cap / tot)
+    used, _ = _smi()
+    note = '' if used is None else '；别的应用当前占 %.1f GiB，需要时驱动自行换出，不从上限里扣' % used
+    print('显存上限：本进程 %.1f GiB（CUDA 可用 %.1f − 系统余量 %.1f，= 整卡 %.1f 的 %.0f%%）%s'
+          % (cap, free, res, tot, 100 * cap / tot, note), flush=True)
     return True
 
 

ml/eval/diag_tail.py

@@ -0,0 +1,130 @@
+#!/usr/bin/env python
+"""闭环末位误差诊断（只读，手动运行；不在流水线里）。
+
+回答一个问题：策略"差一点没进 1 mm 门"还是"根本没朝目标走"。
+输出每题：
+  - 最终位置误差 err_mm / 最终姿态误差 oerr_deg
+  - 全程最小位置误差 min_err_mm、最小综合误差时是否进过 5 mm & 5° 窗口（DLS 接管门槛）
+  - done（是否到达）、碰撞步数、用时
+以及按 cat/mode 分组的汇总与分位数。
+
+用法（仓库根目录）：
+  PYTHONUTF8=1 python ml/eval/diag_tail.py --ckpt ml/runs/base/last.pt --n 512 --out ml/runs/diag_tail.json
+"""
+import argparse, json, math, os, sys
+
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))))
+
+import torch
+
+
+def pct(v, p):
+    if not v:
+        return None
+    v = sorted(v)
+    return v[min(len(v) - 1, int(len(v) * p))]
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument('--ckpt', required=True)
+    ap.add_argument('--samples', default='ml/data/samples')
+    ap.add_argument('--tasks', default=None, help='任务 jsonl（覆盖 --samples/--split）')
+    ap.add_argument('--split', default='val')
+    ap.add_argument('--n', type=int, default=512)
+    ap.add_argument('--bs', type=int, default=64, help='每批题数（显存小就调小）')
+    ap.add_argument('--K', type=int, default=8)
+    ap.add_argument('--device', default='cuda' if torch.cuda.is_available() else 'cpu')
+    ap.add_argument('--out', default=None)
+    a = ap.parse_args()
+
+    from ml.common.kin_torch import Kin, D2R
+    from ml.data import load_tasks
+    from ml.model.policy import build
+    from ml.sim.closed_loop import rollout, goal_err
+
+    ck = torch.load(a.ckpt, map_location=a.device)
+    model = build(ck['cfg']).to(a.device)
+    model.load_state_dict(ck['model'])
+    model.eval()
+    kin = Kin(device=a.device)
+    if ck.get('fp') and ck['fp'] != kin.fp:
+        sys.exit('checkpoint 的碰撞模型指纹 %s 与当前 kin.json %s 不符' % (ck['fp'], kin.fp))
+
+    if a.tasks:
+        tasks = [json.loads(l) for l in open(a.tasks, encoding='utf-8') if l.strip()]
+    else:
+        tasks = [t for t in load_tasks([a.samples]) if t['split'] == a.split]
+    tasks = tasks[:a.n]
+
+    per_task = []
+    with torch.no_grad():
+        for i in range(0, len(tasks), a.bs):
+            chunk = tasks[i:i + a.bs]
+            res, per = rollout(model, kin, chunk, a.device, K=a.K, safety=False, seed=i, return_traj=True)
+            traj = per['traj']                      # [B, T, 6]
+            B, Tn, _ = traj.shape
+            Tt = torch.tensor([t['T'] for t in chunk], dtype=torch.float32, device=a.device)
+            Rt = torch.tensor([t['R'] if t.get('R') else [0.] * 9 for t in chunk], dtype=torch.float32, device=a.device)
+            min_e = torch.full((B,), float('inf'), device=a.device)
+            min_o = torch.full((B,), float('inf'), device=a.device)
+            entered = torch.zeros(B, dtype=torch.bool, device=a.device)   # 曾同时满足 e<5mm & (无姿态要求或 oe<5°)
+            step = 256
+            for t0 in range(0, Tn, step):
+                q = traj[:, t0:t0 + step].reshape(-1, 6)
+                n = q.shape[0] // B
+                e, oe = goal_err(kin, q, Tt.repeat_interleave(n, 0), Rt.repeat_interleave(n, 0))
+                e = e.view(B, n); oe = oe.view(B, n)
+                min_e = torch.minimum(min_e, e.min(1).values)
+                min_o = torch.minimum(min_o, oe.min(1).values)
+                pose = (Rt.abs().sum(-1) > 0)[:, None]
+                window = (e < 5) & (~pose | (oe < 5))
+                entered |= window.any(1)
+            done = per['done'].to(a.device); col = per['col'].to(a.device); td = per['t_done'].to(a.device)
+            end_e = per['err'].to(a.device)
+            # 末态姿态误差：traj 最后一帧
+            qend = traj[:, -1]
+            ee, eo = goal_err(kin, qend, Tt, Rt)
+            for j, t in enumerate(chunk):
+                per_task.append({
+                    'tid': t.get('tid'), 'cat': t.get('cat'), 'mode': t.get('mode'),
+                    'err_mm': float(end_e[j]), 'oerr_deg': float(eo[j]),
+                    'min_err_mm': float(min_e[j]), 'min_oerr_deg': float(min_o[j]),
+                    'entered_5mm5deg': bool(entered[j]),
+                    'done': bool(done[j]), 'collision_steps': float(col[j]),
+                    't_done_s': None if math.isnan(float(td[j])) else float(td[j]),
+                })
+            print('[diag] %d/%d  done=%d  entered=%d  min_err<=5mm=%d' % (
+                min(i + a.bs, len(tasks)), len(tasks), int(done.sum()), int(entered.sum()),
+                sum(1 for p in per_task if p['min_err_mm'] <= 5)), flush=True)
+
+    def summ(rows):
+        if not rows:
+            return {'n': 0}
+        e = [r['err_mm'] for r in rows]; me = [r['min_err_mm'] for r in rows]
+        o = [r['oerr_deg'] for r in rows]
+        return {'n': len(rows),
+                'done': sum(r['done'] for r in rows),
+                'entered_5mm5deg': sum(r['entered_5mm5deg'] for r in rows),
+                'min_err_mm<=5': sum(1 for v in me if v <= 5),
+                'min_err_mm<=10': sum(1 for v in me if v <= 10),
+                'err_mm_p10/p50/p90': [pct(e, .1), pct(e, .5), pct(e, .9)],
+                'min_err_mm_p10/p50/p90': [pct(me, .1), pct(me, .5), pct(me, .9)],
+                'oerr_deg_p50/p90': [pct(o, .5), pct(o, .9)],
+                'collision_steps_mean': sum(r['collision_steps'] for r in rows) / len(rows)}
+
+    out = {'ckpt': a.ckpt, 'step': ck.get('step'), 'fp': ck.get('fp'), 'n': len(per_task),
+           'overall': summ(per_task),
+           'by_cat_mode': {k: summ([r for r in per_task if '%s/%s' % (r['cat'], r['mode']) == k])
+                           for k in sorted({('%s/%s' % (r['cat'], r['mode'])) for r in per_task})},
+           'tasks': per_task}
+    s = json.dumps(out, indent=1, ensure_ascii=False)
+    print(s[:2000])
+    if a.out:
+        open(a.out + '.tmp', 'w', encoding='utf-8').write(s)
+        os.replace(a.out + '.tmp', a.out)
+        print('[diag] 已写', a.out)
+
+
+if __name__ == '__main__':
+    main()

ml/gen/run_parallel.sh

@@ -31,20 +31,25 @@ while :; do
 done
 # 判定按产物而不是 wait 的退出码：2026-10-18 实测 28 个种子跑了 5 小时后全部 wait 报失败，
 # 但每个 .part 都是完整的 1786 行（node 打了 done、mv 却没执行）——Git Bash 长跑后 wait 的返回码不可靠。
-fail=0
+# 短产物分两种：网页点「停止」把 node 杀掉（.part 是断点，续跑接着写，不是失败）和 node 自己报错。
+# 只有日志尾部有报错特征才算失败；143 让网页显示「已停止」而不是「失败（返回码 6）」（monitor.html:508 同一口径）。
+crashed=0; stopped=0; sn=0
 for k in "${!pids[@]}"; do
   s=${seeds[$k]}; f=ml/data/shard_$(printf %04d $s).jsonl
-  wait ${pids[$k]} || true
+  w=0; wait ${pids[$k]} || w=$?          # 记下来但不当判据：长跑后 Git Bash 的 wait 返回码不可靠
   if [ -f "$f" ]; then continue; fi
-  if [ -f "$f.part" ]; then
-    n=$(wc -l < "$f.part")
-    if [ "$n" -ge "$N" ]; then mv "$f.part" "$f" && echo "[gen] 种子 $s 产物完整（$n 行），补改名" && continue; fi
+  n=0; [ -f "$f.part" ] && n=$(wc -l < "$f.part")
+  if [ "$n" -ge "$N" ]; then mv "$f.part" "$f" && echo "[gen] 种子 $s 产物完整（$n 行），补改名" && continue; fi
+  if tail -n 4 ml/data/log_$s.txt 2>/dev/null | grep -qE '^(Error|.*Error:|.*SyntaxError|.*heap out of memory|Traceback|.*throw )'; then
     echo "[gen] 种子 $s 失败：.part 只有 $n/$N 行，最后几行："; tail -n 5 ml/data/log_$s.txt || true
+    crashed=1
   else
-    echo "[gen] 种子 $s 失败：没有产物，最后几行："; tail -n 5 ml/data/log_$s.txt || true
+    echo "[gen] 种子 $s 已停止：写好 $n/$N 条，断点保留在 $f.part，点「继续训练」从第 $((n + 1)) 条接着写（子进程返回码 $w）"
+    stopped=1; sn=$((sn + n))
   fi
-  fail=1
 done
-[ $fail = 0 ] || exit 6
+[ $crashed = 0 ] || exit 6
+# 全被停止时不跑 stats.cjs：分片还没改名，统计口径没变，重算一遍只会让「补量」看起来原地不动
+[ $stopped = 0 ] || { echo "[gen] 本轮是被停止的，没有报错：$stopped 个种子共保住 $sn 条，续跑不重复生成"; exit 143; }
 node ml/gen/stats.cjs ml/data/shard_*.jsonl > ml/data/stats.json
 cat ml/data/stats.json

ml/monitor.html

@@ -56,7 +56,16 @@
   .step.done .ic { background: #34d39922; border-color: var(--ok); color: var(--ok); }
   .step.active .ic { background: #5aa9ff22; border-color: var(--accent); color: var(--accent); box-shadow: 0 0 0 4px #5aa9ff1f; }
   .step.fail .ic { background: #f8717122; border-color: var(--bad); color: var(--bad); }
+  .step.fail .ds { color: var(--bad); font-weight: 650; font-size: 12px; }
+  .alert { border-radius: 12px; padding: 13px 16px; margin: 2px 0 0; border: 1px solid; }
+  .alert.bad { background: linear-gradient(180deg,#7f1d1d66,#450a0a55); border-color: #f8717199; box-shadow: 0 0 0 1px #f8717122, 0 8px 26px #00000066; }
+  .alert.warn { background: #78350f55; border-color: #fbbf2488; }
+  .alert .alerth { font-size: 17px; font-weight: 700; color: #ffe3e3; letter-spacing: .2px; }
+  .alert.warn .alerth { color: #ffeccd; }
+  .alert .alerterr { font: 500 12.5px/1.5 var(--mono); color: #ffb4b4; margin-top: 7px; word-break: break-all; }
+  .alert .alerttip { font-size: 12.5px; color: #f0d9d9cc; margin-top: 7px; }
   .step .nm { font-size: 12.5px; color: var(--text); white-space: nowrap; } .step .ds { font-size: 11px; color: var(--dim2); white-space: nowrap; }
+  .step .ds.big { font-size: 14px; font-weight: 650; color: var(--accent); }
   .step.pending .nm { color: var(--dim); }
   .step.active .ds { color: var(--accent); }
 
@@ -85,7 +94,8 @@
   .ring .c b { font: 700 24px/1 var(--mono); display: block; } .ring .c span { font-size: 11px; color: var(--dim); }
   .gpurows { flex: 1; display: flex; flex-direction: column; gap: 10px; min-width: 0; }
   .cores { display: flex; gap: 2px; height: 26px; margin-top: 2px; background: #1b2433; border-radius: 3px; padding: 2px; }
-  .gr .l { display: flex; justify-content: space-between; font-size: 12px; color: var(--dim); margin-bottom: 4px; } .gr .l b { color: var(--text); font: 500 12.5px var(--mono); }
+  .gr .l { display: flex; justify-content: space-between; gap: 8px; font-size: 12px; color: var(--dim); margin-bottom: 4px; } .gr .l b { color: var(--text); font: 500 12.5px var(--mono); }
+  .gr .l span { flex: none; white-space: nowrap; } .gr .l b { white-space: nowrap; overflow: hidden; text-overflow: ellipsis; min-width: 0; }   /* 值太长就省略号，别把整行挤成两行 */
   .mini { height: 6px; background: #0d131d; border-radius: 99px; overflow: hidden; } .mini > div { height: 100%; border-radius: 99px; transition: width .6s; }
   .gname { font-size: 12px; color: var(--dim2); margin-top: 12px; }
 
@@ -127,8 +137,9 @@
   button.danger { color: var(--bad); border-color: #f8717166; } button.danger:hover { background: #f8717114; }
   .overall { display: flex; align-items: flex-end; justify-content: space-between; gap: 16px; flex-wrap: wrap; }
   .overall .now { font-size: 13px; color: var(--dim); } .overall .now b { display: block; color: var(--text); font-size: 18px; font-weight: 650; margin: 2px 0 2px; }
-  .sublabel { font-size: 12.5px; color: var(--dim); display: flex; justify-content: space-between; margin-top: 4px; }
-  .bar.thin { height: 8px; margin: 8px 0 4px; } .bar.ind .fill { width: 30% !important; animation: ind 1.6s ease-in-out infinite; }
+  .sublabel { font-size: 15px; color: var(--dim); display: flex; justify-content: space-between; align-items: baseline; margin-top: 6px; }
+  .sublabel b { font: 700 20px/1 var(--mono); color: var(--text); }
+  .bar.thin { height: 14px; margin: 10px 0 4px; } .bar.ind .fill { width: 30% !important; animation: ind 1.6s ease-in-out infinite; }
   @keyframes ind { 0% { margin-left: 0; } 50% { margin-left: 70%; } 100% { margin-left: 0; } }
   .ctlrow { display: flex; gap: 10px; margin-top: 14px; align-items: center; flex-wrap: wrap; }
   .ctlrow .hint { font-size: 12px; color: var(--dim2); }
@@ -168,6 +179,7 @@
 </header>
 
 <main>
+  <div id="alert"></div>
   <section class="card"><h2><span>流水线</span><span class="r" id="stepnote"></span></h2><div class="steps" id="steps"></div></section>
 
   <section class="hero">
@@ -195,12 +207,13 @@
   <h3>开始训练</h3>
   <div class="d">后台执行 <code>bash ml/pipeline.sh all</code>，从对拍一路跑到验收。已完成的步骤自动跳过；训练每 10 分钟存档、生成按条续写，断了再点一次就从断点接着跑。网页和控制台窗口都可以关，训练不受影响。</div>
   <div class="form">
-    <label>运行方式<select id="fMode"><option value="resume">续跑：跳过已完成的步骤</option><option value="fresh">从头重跑（旧产物移到 ml/archive/）</option></select></label>
+    <label>运行方式<select id="fMode"><option value="resume">续跑：跳过已完成的步骤</option><option value="from">从指定阶段重训（该阶段及之后全部重做）</option><option value="fresh">全部重跑（数据也重新生成）</option></select></label>
+    <label>起始阶段<select id="fFrom"><option value="train">预训练 train（保留数据、样本、门禁）</option><option value="m5">头门禁 m5</option><option value="apg">后训练 apg</option><option value="mine">挖错循环 mine</option><option value="export">导出 export</option><option value="bench">部署评测 bench</option><option value="accept">验收 accept</option><option value="gen">生成数据 gen（重跑约 7 小时）</option><option value="prep">打包样本 prep</option><option value="gate1">一致性门禁 gate1</option><option value="r4">推理延迟 r4</option><option value="kin">对拍 kin</option></select></label>
     <label>动作头 CFG<select id="fCfg"><option value="ml/configs/base.json">MeanFlow（base，M5 不过自动转 WTA）</option><option value="ml/configs/wta.json">WTA（wta）</option><option value="ml/configs/small.json">小模型 d=128（R4 不过时用）</option></select></label>
     <label>共识过滤 CONSENSUS<select id="fCons"><option value="">按老师门禁自动</option><option value="0">关</option><option value="1">开（生成约慢 5 倍）</option></select></label>
     <label>任务数 N_TASKS<input id="fN" value="50000"></label>
     <label>生成进程数 NPROC<input id="fP" placeholder="默认 = CPU 核数"></label>
-    <label>目标样本 TARGET_SAMPLES<input id="fT" value="1700000"></label>
+    <label>目标样本 TARGET_SAMPLES<input id="fT" value="2000000"></label>
     <label>挖错轮数 ROUNDS<input id="fR" value="6"></label>
     <label>老师间隙下限 MIN_GAP_MM<input id="fG" value="3"></label>
   </div>
@@ -208,6 +221,27 @@
   <div class="acts"><button id="fCancel">取消</button><button id="fGo" class="primary">▶ 开始</button></div>
 </div></div>
 
+<script>
+/* 兜底：正文脚本一旦有语法错误或抛异常，整页会空白（2026-10-18 真踩过：一行字符串写断 → 页面什么都不显示）。
+   这段在正文之前跑，负责"坏也坏得看得见"：看门狗 + 全局错误显示。 */
+window.__boot = { ok: false };
+function __pageFail(msg) {
+  const m = document.querySelector('main') || document.body;
+  let d = document.getElementById('pagefail');
+  if (!d) {
+    d = document.createElement('div'); d.id = 'pagefail';
+    d.style.cssText = 'margin:10px 24px 0;padding:14px 16px;border-radius:12px;background:#7f1d1dcc;border:1px solid #f87171;' +
+                      'color:#ffe3e3;font:600 15px/1.6 system-ui;position:sticky;top:8px;z-index:99;box-shadow:0 8px 26px #00000088';
+    m.prepend(d);
+  }
+  d.textContent = msg;
+}
+window.addEventListener('error', e => __pageFail('页面脚本出错：' + (e.message || '未知错误') +
+  '（' + (e.filename || '').split('/').pop() + ':' + (e.lineno || '?') + '）— 面板可能不完整，但训练本身没受影响；按 F12 看 Console'));
+setTimeout(() => { if (!window.__boot.ok) __pageFail('页面脚本没有启动（多半是 ml/monitor.html 有语法错误）：卡片空白不是训练出问题。' +
+  'F12 → Console 看第一条报错，或把该文件回滚到上一个提交。'); }, 3000);
+</script>
+
 <script>
 'use strict';
 /* =====================================================================
@@ -221,7 +255,7 @@ const $ = id => document.getElementById(id);
 const isNum = v => typeof v === 'number' && isFinite(v);
 const fmt = (v, d = 3) => !isNum(v) ? '—' : (Math.abs(v) >= 1000 ? Math.round(v).toLocaleString() : Math.abs(v) >= 100 ? v.toFixed(1) : Math.abs(v) >= 1 ? v.toFixed(Math.min(d, 3)) : v === 0 ? '0' : v.toPrecision(3));
 const pct = (v, d = 1) => !isNum(v) ? '—' : (100 * v).toFixed(d) + '%';
-const hms = s => { if (!isNum(s)) return '—'; s = Math.max(0, s); const h = Math.floor(s / 3600), m = Math.floor(s % 3600 / 60); return h ? `${h} 小时 ${m} 分` : m ? `${m} 分 ${Math.floor(s % 60)} 秒` : `${Math.floor(s)} 秒`; };
+const hms = s => { if (!isNum(s)) return '—'; s = Math.max(0, s); const h = Math.floor(s / 3600), m = Math.floor(s % 3600 / 60); return h ? `${h} 小时 ${m} 分 ${Math.floor(s % 60)} 秒` : m ? `${m} 分 ${Math.floor(s % 60)} 秒` : `${Math.floor(s)} 秒`; };   // 用时精确到秒（页面 1 秒轮询，秒位是有意义的）
 const hmsShort = s => !isNum(s) ? '—' : s >= 3600 ? `${(s / 3600).toFixed(1)} h` : s >= 60 ? `${Math.round(s / 60)} 分` : `${Math.round(s)} 秒`;
 const ago = t => { const s = Date.now() / 1000 - t; return s < 60 ? `${Math.max(0, Math.floor(s))} 秒前` : s < 3600 ? `${Math.floor(s / 60)} 分钟前` : `${(s / 3600).toFixed(1)} 小时前`; };
 const ICON_WAIT = '<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><circle cx="12" cy="12" r="9"/><path d="M12 7v5l3 2"/></svg>';
@@ -417,7 +451,7 @@ function renderProgress() {
     <div class="facts">
       ${fact('步数', `${step.toLocaleString()}${total ? ' / ' + total.toLocaleString() : ''}`)}
       ${fact('已用时间', hms(elapsed))}
-      ${fact('剩余时间', finished ? '—' : hms(eta))}
+      ${fact('剩余时间', finished ? '—' : hmsShort(eta))}
       ${fact('预计完成', fin)}
       ${kind === 'apg' ? fact('本批展开', r.plans ? `${r.plans} 次推理` : '—') : fact('学习率', isNum(r.lr) ? r.lr.toExponential(2) : '—')}
       ${fact('日志更新', lastMtime ? ago(lastMtime) : '—', running ? '' : 'warn')}
@@ -427,6 +461,7 @@ function renderProgress() {
 function renderKpis() {
   const r = recs[recs.length - 1] || {}, e = evals[evals.length - 1] || {}, pe = evals[evals.length - 2] || {}, kind = cur.kind;
   const best = evals.length ? Math.max(...evals.map(v => v.success ?? -1)) : null;
+  const bestE = evals.length ? evals.reduce((m, v) => ((v.success ?? -1) > (m.success ?? -1) ? v : m)) : null;
   const dlt = (k, good = 1) => { if (!isNum(e[k]) || !isNum(pe[k])) return ''; const d = (e[k] - pe[k]) * 100; if (Math.abs(d) < 0.05) return ''; const up = d > 0; return `<span class="delta ${(up ? 1 : -1) * good > 0 ? 'ok' : 'bad'}">${up ? '▲' : '▼'} ${Math.abs(d).toFixed(1)}pp</span>`; };
   const last = k => recs.filter(v => isNum(v[k])).slice(-300).map(v => [xOf(v), v[k]]);
   const evs = k => evals.filter(v => isNum(v[k])).map(v => [v.x, v[k]]);
@@ -442,7 +477,7 @@ function renderKpis() {
     const sps = r.samples_per_s;
     tile('总损失', fmt(r.loss, 4), `MF ${fmt(r.mf)} · FK ${fmt(r.fk_cm)} cm`, '', ema(last('loss'), 0.9), COLORS[0]);
     tile('吞吐', sps ? `${(sps / 1000).toFixed(2)}<small>k 样本/s</small>` : '—', sps ? (sps >= 5000 ? 'R10 达标（≥ 5k/s）' : 'R10 未达标（< 5k/s）') : 'R10 通过线 5k/s', sps ? (sps >= 5000 ? 'ok' : 'bad') : '', last('samples_per_s'), COLORS[5]);
-    tile('闭环到达率', pct(e.success) + dlt('success'), evals.length ? `最好 ${pct(best)} · @${e.x.toLocaleString()} 步` : '尚未评估', '', evs('success'), COLORS[2]);
+    tile('闭环到达率', pct(e.success) + dlt('success'), bestE ? `最好 ${pct(best)} · @${bestE.x.toLocaleString()} 步` : '尚未评估', '', evs('success'), COLORS[2]);
     tile('碰撞率', pct(e.collision_rate, 2) + dlt('collision_rate', -1), '关安全层，部署另有护栏', e.collision_rate > 0.03 ? 'warn' : '', evs('collision_rate'), COLORS[3]);
     tile('梯度范数', fmt(r.gnorm), '裁剪阈值 1.0', r.gnorm > 5 ? 'warn' : '', ema(last('gnorm'), 0.9), COLORS[4]);
     tile('显存峰值', isNum(r.vram) ? `${r.vram.toFixed(2)}<small>GiB</small>` : '—', '预算 19–20 GB（整卡 24，桌面占 4–5）', r.vram > 17 ? 'bad' : r.vram > 14 ? 'warn' : '', last('vram'), COLORS[1]);
@@ -485,8 +520,13 @@ async function poll() {
     if (DEMO) { setPill('demo', '示例数据'); if (!$('demobar')) $('pipe').closest('.hero').insertAdjacentHTML('beforebegin', `<div class="demobar" id="demobar">这是示例数据，不是你的训练。${location.protocol === 'file:' ? '直接双击 monitor.html 只能看示例；' : ''}看真实训练请双击 ml/console.bat（或 python -m ml.monitor --open）。</div>`); }
     else if (busy) setPill('live', `运行中 · ${P && P.current ? SM[P.current]?.n || P.current : '启动中'}`);
     else if (cur && Date.now() / 1000 - lastMtime < 120) setPill('live', `运行中 · ${ago(lastMtime)}更新`);
+    else if (P && P.plan && P.plan.some(k => P.stages[k] && P.stages[k].rc != null && P.stages[k].rc !== 0)) {
+      const k = P.plan.find(k => P.stages[k] && P.stages[k].rc != null && P.stages[k].rc !== 0), rc = P.stages[k].rc, nm = SM[k]?.n || k;
+      setPill(rc === -15 || rc === 143 ? 'stale' : 'dead', `${rc === -15 || rc === 143 ? '已停止' : '失败'} · 停在「${nm}」返回码 ${rc}`);
+    }
     else setPill('', '空闲');
-    renderStatus(lastStatus); renderPipe(lastStatus); renderJob();
+    try { renderStatus(lastStatus); renderPipe(lastStatus); renderJob(); }
+    catch (e) { __pageFail('渲染面板出错：' + e.message + ' —— 其余面板可能不更新；训练本身不受影响'); }
     await pollConsole();
   } catch (err) {
     setPill('dead', '连不上控制台（双击 ml/console.bat 或 python -m ml.monitor）'); console.error(err);
@@ -500,11 +540,12 @@ function stages(s) {
   if (P) {   // 有流水线记录：以它为准
     const plan = P.plan && P.plan.length ? P.plan : STAGE_META.map(x => x[0]).filter(k => k !== 'setup');
     const keys = STAGE_META.map(x => x[0]).filter(k => plan.includes(k) || P.stages[k]);
+    const el = P.elapsed || {};   // 累计用时（跨停止/续跑），没有就退回本段
     return keys.map(k => {
       const r = P.stages[k], nm = SM[k].n;
       if (!r) return [nm, 'pending', '—'];
       if (P.current === k) return [nm, 'active', P.progress && P.progress.frac != null ? pct(P.progress.frac, 0) : '进行中'];
-      if (r.rc === 0) return [nm, 'done', '用时 ' + hmsShort(r.end - r.start)];
+      if (r.rc === 0) return [nm, 'done', '用时 ' + hms(el[k] != null ? el[k] : r.end - r.start)];
       if (r.rc === -15 || r.rc === 143) return [nm, 'fail', '已停止'];
       if (r.rc != null) return [nm, 'fail', `失败（返回码 ${r.rc}）`];
       return [nm, 'fail', '中断'];
@@ -531,34 +572,39 @@ function stages(s) {
 }
 function renderStatus(s) {
   const L = stages(s);
-  $('steps').innerHTML = L.map(([nm, st, ds], i) => `<div class="step ${st}"><div class="ic">${st === 'done' ? '✓' : st === 'fail' ? '!' : i + 1}</div><div class="nm">${nm}</div><div class="ds">${ds}</div></div>`).join('');
+  $('steps').innerHTML = L.map(([nm, st, ds], i) => `<div class="step ${st}"><div class="ic">${st === 'done' ? '✓' : st === 'fail' ? '!' : i + 1}</div><div class="nm">${nm}</div><div class="ds${st === 'active' ? ' big' : ''}">${ds}</div></div>`).join('');
   const nDone = L.filter(x => x[1] === 'done').length; $('stepnote').textContent = `${nDone} / ${L.length} 完成`;
 
   // GPU + CPU（同一个框：上面是 GPU 环 + 显存/温度/功耗，下面接 CPU 总占用与每核条）
   const G = s.gpu || [], CP = s.cpu || {};
-  const BUD = (s.vram_budget_gb || 24) * 1024;      // 显存预算（MB）：桌面常驻占 4–5 GB，不能按整卡 24 GB 看
+  const RESV = s.vram_reserve_gb ?? 1;   // 给系统留的余量（GB）：训练进程启动时按"整卡 − 已用 − 余量"自设上限（浮动）
   const hr = '<hr style="border:none;border-top:1px solid var(--line);margin:14px 0">';
-  const gr = (k, v, p, c) => `<div class="gr"><div class="l"><span>${k}</span><b>${v}</b></div><div class="mini"><div style="width:${Math.min(100, p)}%;background:${c}"></div></div></div>`;
+  const gr = (k, v, p, c, t) => `<div class="gr"><div class="l"><span${t ? ` title="${t}"` : ''}>${k}</span><b>${v}</b></div><div class="mini"><div style="width:${Math.min(100, p)}%;background:${c}"></div></div></div>`;
   $('gputime').textContent = (G.length || CP.n) ? '实时' : '';
   const gpuBlk = G.length ? G.map(g => {
     const u = g.util ?? 0, C = 2 * Math.PI * 50, col = u > 85 ? css('--ok') : u > 50 ? css('--accent') : css('--warn');
+    const BUD = (s.vram_budget_gb || (g.mem_total / 1024 - RESV)) * 1024, avail = BUD / 1024 - g.mem_used / 1024;
     const memP = 100 * g.mem_used / BUD, tc = g.temp > 83 ? css('--bad') : g.temp > 75 ? css('--warn') : css('--c6');
     return `<div class="gpuwrap"><div class="ring"><svg width="116" height="116"><circle cx="58" cy="58" r="50" stroke="#1b2433" stroke-width="10" fill="none"/>
       <circle cx="58" cy="58" r="50" stroke="${col}" stroke-width="10" fill="none" stroke-linecap="round" stroke-dasharray="${C}" stroke-dashoffset="${C * (1 - u / 100)}" style="transition:stroke-dashoffset .6s"/></svg>
       <div class="c"><div><b>${u}%</b><span>利用率</span></div></div></div>
-      <div class="gpurows">${gr('显存', `${(g.mem_used / 1024).toFixed(1)} / ${(BUD / 1024).toFixed(0)} GB 预算（整卡 ${(g.mem_total / 1024).toFixed(0)}）`, memP, memP > 100 ? css('--bad') : memP > 85 ? css('--warn') : css('--accent2'))}
+      <div class="gpurows">${gr('显存', `${(g.mem_used / 1024).toFixed(1)} / ${(BUD / 1024).toFixed(0)} GB · 空 ${avail.toFixed(1)}`, memP, memP > 100 ? css('--bad') : memP > 85 ? css('--warn') : css('--accent2'), `可用 ${(BUD / 1024).toFixed(0)} GB = 整卡 ${(g.mem_total / 1024).toFixed(0)} GB − 给系统的余量 ${RESV} GB；训练进程启动时按「可用 − 那一刻已用」再自设本进程上限，别人占多少自动扣掉（ml/common/vram.py）`)}
       ${gr('温度', `${g.temp} °C`, g.temp, tc)}${gr('功耗', g.power != null ? `${Math.round(g.power)} W` : '—', g.power ? g.power / 3.5 : 0, css('--c7'))}</div></div>
       <div class="gname">${g.name}</div>`;
   }).join(hr) : '';
   const cpuBlk = CP.n ? (() => {
     const tot = CP.total ?? 0, C = 2 * Math.PI * 50, col = tot > 85 ? css('--bad') : tot > 60 ? css('--warn') : css('--ok');
-    const bars = (CP.per || []).map((v, i) => `<div title="核 ${i + 1}: ${v}%" style="flex:1;min-width:0;height:100%;border-radius:2px;background:${v > 85 ? css('--bad') : v > 60 ? css('--warn') : css('--accent2')};opacity:${0.18 + 0.82 * Math.min(1, v / 100)}"></div>`).join('');
+    const ct = CP.coreT || [], ctMax = ct.length ? Math.max(...ct) : null;
+    const tcol = v => v > 98 ? css('--bad') : v > 90 ? css('--warn') : css('--c6');
+    const bars = (CP.per || []).map((v, i) => `<div title="核 ${i + 1}: ${v}%${ct[i] != null ? ' · ' + ct[i] + ' °C' : ''}" style="flex:1;min-width:0;height:100%;border-radius:2px;background:${v > 85 ? css('--bad') : v > 60 ? css('--warn') : css('--accent2')};opacity:${0.18 + 0.82 * Math.min(1, v / 100)}"></div>`).join('');
     return `<div class="gpuwrap"><div class="ring"><svg width="116" height="116"><circle cx="58" cy="58" r="50" stroke="#1b2433" stroke-width="10" fill="none"/>
       <circle cx="58" cy="58" r="50" stroke="${col}" stroke-width="10" fill="none" stroke-linecap="round" stroke-dasharray="${C}" stroke-dashoffset="${C * (1 - tot / 100)}" style="transition:stroke-dashoffset .6s"/></svg>
       <div class="c"><div><b>${tot}%</b><span>CPU</span></div></div></div>
       <div class="gpurows">${gr('占用', `${tot}% · ${CP.n} 核`, tot, col)}
+      ${CP.temp != null ? gr('温度', `${CP.temp} °C${ctMax != null && ctMax !== CP.temp ? `（最高核 ${ctMax}）` : ''}`, CP.temp, tcol(CP.temp), 'MSI Afterburner 的共享内存；鼠标停在核条上还能看每核温度') : ''}
+      ${CP.power != null ? gr('功耗', `${Math.round(CP.power)} W`, 100 * CP.power / 253, css('--c7'), 'CPU 封装功耗（满标度按 14700K 的 PL2 253 W 画）') : ''}
       <div class="cores">${bars}</div></div></div>
-      <div class="gname">每核占用（深色=忙）</div>`;
+      <div class="gname">${CP.model || 'CPU'}${CP.temp == null ? ' · 开 MSI Afterburner 才能读 CPU 温度/功耗' : ''} · 每核占用（深色=忙）</div>`;
   })() : '';
   $('gpu').innerHTML = (gpuBlk + (gpuBlk && cpuBlk ? hr : '') + cpuBlk) || empty('未检测到 nvidia-smi / psutil');
 
@@ -622,21 +668,27 @@ function renderPipe(s) {
   const doneN = plan.filter(k => P.stages[k] && P.stages[k].rc === 0 && P.current !== k).length;
   const failed = plan.find(k => P.stages[k] && P.stages[k].rc != null && P.stages[k].rc !== 0);
   const allDone = !cur && doneN === plan.length;
-  let remain = 0; for (const k of plan) { const r = P.stages[k]; if (!r || r.rc == null) remain += (SM[k]?.w || 0.1) * (k === cur ? 1 - (pr.frac || 0) : 1); }
+  let remain = 0, calib = false; for (const k of plan) { const r = P.stages[k]; if (!r || r.rc == null) { if (k === cur && pr.eta_s != null) { remain += pr.eta_s / 3600; calib = true; } else remain += (SM[k]?.w || 0.1) * (k === cur ? 1 - (pr.frac || 0) : 1); } }
   const head = cur ? `<div class="now">正在运行<b>${SM[cur]?.n || cur}</b>${pr.label || ''}</div>`
     : allDone ? `<div class="now">状态<b class="ok">全部完成</b>共 ${plan.length} 步</div>`
     : failed ? `<div class="now">状态<b class="bad">停在「${SM[failed]?.n || failed}」</b>${(P.stages[failed].info || {}).timed_out || P.stages[failed].rc === 124 ? '超过时间上限，判定卡死' : P.stages[failed].rc === -15 || P.stages[failed].rc === 143 ? '已停止' : '失败，看终端输出'}</div>`
     : `<div class="now">状态<b>未在运行</b>已完成 ${doneN} / ${plan.length} 步</div>`;
+  const esc2 = x => String(x).replace(/&/g, '&amp;').replace(/</g, '&lt;');
+  const fr = failed && P.stages[failed], stopped = !!fr && (fr.rc === -15 || fr.rc === 143);
+  const timedOut = !!fr && ((fr.info || {}).timed_out || fr.rc === 124);
+  const why = !fr ? '' : stopped ? '已手动停止 —— 点「继续训练」从停下的地方接着跑' : timedOut ? '超过时间上限，判定卡死' : `失败（返回码 ${fr.rc}）`;
+  const lastErr = (() => { const t = $('term'); if (!t) return ''; const ls = (t.innerText || '').split(/\r?\n/).filter(x => /Error|error:|Traceback|不通过|失败|超过时间上限/.test(x)); return ls.length ? ls[ls.length - 1].slice(0, 300) : ''; })();
+  $('alert').innerHTML = failed ? `<div class="alert ${stopped ? 'warn' : 'bad'}"><div class="alerth">✕ 停在「${SM[failed]?.n || failed}」 · ${why}</div>${lastErr ? `<div class="alerterr">${esc2(lastErr)}</div>` : ''}<div class="alerttip">完整报错见下方「终端输出」；修好后点「继续训练」，已完成的步骤会自动跳过${stopped ? '、从停下的那一步接着跑' : ''}</div></div>` : '';
   $('pipe').innerHTML = `<h2><span>全流程</span><span class="r">${doneN} / ${plan.length} 步完成</span></h2>
     <div class="overall">${head}<div class="bigpct">${(100 * frac).toFixed(1)}<small>%</small></div></div>
     <div class="bar ${cur ? '' : 'idle'}"><div class="fill" style="width:${100 * frac}%"></div></div>
-    ${cur ? `<div class="sublabel"><span>当前步骤 · ${SM[cur]?.n}</span><span>${pr.frac != null ? pct(pr.frac) : '无法计量，按用时估'}</span></div>
+    ${cur ? `<div class="sublabel"><span>当前步骤 · ${SM[cur]?.n}</span>${pr.frac != null ? `<b>${pct(pr.frac)}</b>` : '<span>无法计量，按用时估</span>'}</div>
       <div class="bar thin ${pr.frac == null ? 'ind' : ''}"><div class="fill" style="width:${pr.frac != null ? 100 * pr.frac : 30}%"></div></div>` : ''}
     <div class="facts">
-      <div class="fact"><div class="k">总用时</div><div class="v">${hms((cur ? now : Math.max(...Object.values(P.stages).map(r => r.end || r.start))) - P.started)}</div></div>
-      <div class="fact"><div class="k">本步用时</div><div class="v">${cr ? hms(now - cr.start) : '—'}</div></div>
-      <div class="fact"><div class="k">本步粗估 / 上限</div><div class="v">${cur ? hmsShort((SM[cur]?.w || 0) * 3600) + ' / ' + hmsShort((cr && cr.timeout_h || SM[cur]?.to || 0) * 3600) : '—'}</div></div>
-      <div class="fact"><div class="k">全流程剩余（粗估）</div><div class="v">${allDone ? '—' : '约 ' + hmsShort(remain * 3600)}</div></div>
+      <div class="fact"><div class="k">总用时</div><div class="v">${hms(plan.reduce((a, k) => a + ((P.elapsed || {})[k] || 0), 0))}</div></div>
+      <div class="fact"><div class="k">本步用时</div><div class="v">${cur ? hms((P.elapsed || {})[cur] || 0) : '—'}</div></div>
+      <div class="fact"><div class="k">${cur && pr.eta_s != null ? '本步预计剩余（实测速率）' : '本步粗估 / 上限'}</div><div class="v">${cur ? (pr.eta_s != null ? hmsShort(pr.eta_s) + ' / 上限 ' + hmsShort((cr && cr.timeout_h || SM[cur]?.to || 0) * 3600) : hmsShort((SM[cur]?.w || 0) * 3600) + ' / ' + hmsShort((cr && cr.timeout_h || SM[cur]?.to || 0) * 3600)) : '—'}</div></div>
+      <div class="fact"><div class="k">全流程剩余（${calib ? '实测外推' : '粗估'}）</div><div class="v">${allDone ? '—' : '约 ' + hmsShort(remain * 3600)}</div></div>
     </div>${btns}`;
 }
 function renderJob() {
@@ -662,14 +714,17 @@ function openStart() {
   const w = $('fWarn'); const upd = () => { const msgs = [];
     const done = P ? (P.plan || []).filter(k => P.stages[k] && P.stages[k].rc === 0) : [];
     if ($('fMode').value === 'resume' && done.length) msgs.push(`将跳过已完成的 ${done.length} 步：${done.map(k => SM[k]?.n || k).join('、')}。改了参数会自动改为从头重跑。`);
-    if ($('fMode').value === 'fresh' && P) msgs.push('从头重跑：上次的数据、模型、评测结果整体移到 ml/archive/<时间>/（不删除）。');
+    if ($('fMode').value === 'from' && P) { const nm = $('fFrom').selectedOptions[0].textContent; msgs.push(`从「${nm}」开始重训：该阶段及之后的旧产物移到 ml/archive/<时间>/（不删除），之前的阶段保持不动。${$('fFrom').value === 'gen' ? '注意：生成的数据会被归档，重跑约 7 小时。' : ''}`); }
+    if ($('fMode').value === 'fresh' && P) msgs.push('全部重跑：上次的数据、模型、评测结果整体移到 ml/archive/<时间>/（不删除）。生成数据要重跑（约 7 小时）。');
+    $('fFrom').disabled = $('fMode').value !== 'from';
     w.style.display = msgs.length ? 'block' : 'none'; w.innerHTML = msgs.join('<br>'); };
   $('fMode').onchange = upd; upd();
   $('modal').classList.add('show');
 }
 async function startJob() {
-  const env = { CFG: $('fCfg').value, CONSENSUS: $('fCons').value, N_TASKS: $('fN').value.trim(), NPROC: $('fP').value.trim(), TARGET_SAMPLES: $('fT').value.trim(), ROUNDS: $('fR').value.trim(), MIN_GAP_MM: $('fG').value.trim() };
-  const body = JSON.stringify({ fresh: $('fMode').value === 'fresh', env });
+  const mode = $('fMode').value, from = mode === 'from' ? $('fFrom').value : 'kin';
+  const env = { CFG: $('fCfg').value, CONSENSUS: $('fCons').value, N_TASKS: $('fN').value.trim(), NPROC: $('fP').value.trim(), TARGET_SAMPLES: $('fT').value.trim(), ROUNDS: $('fR').value.trim(), MIN_GAP_MM: $('fG').value.trim(), FRESH_FROM: mode === 'from' ? from : '' };
+  const body = JSON.stringify({ fresh: mode === 'fresh', from, to: 'accept', env });
   const r = DEMO ? await api('/api/start', body) : await post('/api/start', body);
   if (r.error) { toast('没能开始：' + r.error); return; }
   $('modal').classList.remove('show'); toast('已开始'); conOff = 0; userPicked = false; poll();
@@ -730,10 +785,10 @@ function demoApi() {
   }
   let sc, runs, logs, pipe, jobS, con, genAt = 0;
   // 示例流水线：stages 里的 [阶段, 开始距今小时, 用时小时]
-  const mkPipe = (done, cur, curStartH) => { const t = now(); const st = {}; let tt = t - curStartH * 3600;
-    for (let i = done.length - 1; i >= 0; i--) { const [k, dur] = done[i]; st[k] = { start: tt - dur * 3600, end: tt, rc: 0, info: {} }; tt -= dur * 3600; }
-    if (cur) st[cur] = { start: t - curStartH * 3600, end: null, rc: null, info: {} };
-    return { started: tt, plan: ['kin', 'r4', 'gate1', 'gen', 'prep', 'train', 'm5', 'apg', 'mine', 'export', 'bench', 'accept'], stages: st, current: cur }; };
+  const mkPipe = (done, cur, curStartH) => { const t = now(); const st = {}, el = {}; let tt = t - curStartH * 3600;
+    for (let i = done.length - 1; i >= 0; i--) { const [k, dur] = done[i]; st[k] = { start: tt - dur * 3600, end: tt, rc: 0, info: {} }; el[k] = dur * 3600; tt -= dur * 3600; }
+    if (cur) { st[cur] = { start: t - curStartH * 3600, end: null, rc: null, info: {} }; el[cur] = curStartH * 3600; }
+    return { started: tt, plan: ['kin', 'r4', 'gate1', 'gen', 'prep', 'train', 'm5', 'apg', 'mine', 'export', 'bench', 'accept'], stages: st, elapsed: el, current: cur }; };
   const CON = {
     train: '$ FROM=kin TO=accept bash ml/pipeline.sh all\n计划：kin r4 gate1 gen prep train m5 apg mine export bench accept\n== node ml/prep/export_kin.cjs\n== node ml/eval/dump_parity.cjs 2000\n== python -m ml.eval.check_parity\n{"PASS": true, "fk_mm": 0.0004, "gap_mm": 0.0011}\n== node ml/gen/consistency.cjs 300 4242\n{"consistentByGateRule": 0.86}\n一致性门禁结果 → CONSENSUS=1\n== bash ml/gen/run_parallel.sh 1786 28 1 --consensus 4\n样本数 1702000 ≥ 目标，完成\n== bash ml/prep/run_prep.sh 28\n== python -m ml.eval.check_r2 --samples ml/data/samples --out ml/data/r2.json\n{"pairs": 250, "label_std_mean": 0.071, "pass": true}\n== python -m ml.train --samples ml/data/samples --out ml/runs/bench_base --steps 2000 --no-eval\nstep 2000  loss 1.912  6150 samples/s\n== python -m ml.train --samples ml/data/samples --out ml/runs/base\n',
     gen: '$ FROM=kin TO=accept bash ml/pipeline.sh all\n计划：kin r4 gate1 gen prep train m5 apg mine export bench accept\n== node ml/prep/export_kin.cjs\n== python -m ml.eval.check_parity\n{"PASS": true}\n== node ml/gen/consistency.cjs 300 4242\n{"consistentByGateRule": 0.86}\n一致性门禁结果 → CONSENSUS=1\n== bash ml/gen/run_parallel.sh 1786 28 1 --consensus 4\n',
@@ -819,6 +874,7 @@ function demoApi() {
   fn.scenario = setup;
   return fn;
 }
+window.__boot.ok = true;      // 正文脚本跑到了最后一行，看门狗不用再报"脚本没启动"
 </script>
 </body>
 </html>

ml/monitor.py

@@ -17,7 +17,7 @@
   N-11 Windows 子进程用 CREATE_NO_WINDOW 自带隐藏控制台：关掉控制台黑窗口训练照跑，重开控制台可接着看、可停止；
   N-9 生成阶段的行数按文件增量统计（只读新增字节），其他阶段不扫 shard；
   N-12 停止后的状态改写走 ml.pstate（单一写者、原子替换）；N-14 阶段名/估时/权重由 ml.pstate.STAGES 下发。"""
-import argparse, glob, json, os, re, shutil, signal, subprocess, sys, threading, time, webbrowser
+import argparse, glob, json, os, platform, re, shutil, signal, subprocess, sys, threading, time, webbrowser
 sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
 from ml import pstate
 from http.server import ThreadingHTTPServer, BaseHTTPRequestHandler
@@ -71,6 +71,22 @@ def read_log(name, offset):
 _CPU = {'v': {}}
 
 
+def cpu_name():
+    """CPU 型号：psutil 只有核数，型号得自己读——Windows 在注册表，Linux 在 /proc/cpuinfo。"""
+    try:
+        if os.name == 'nt':
+            import winreg
+            with winreg.OpenKey(winreg.HKEY_LOCAL_MACHINE, r'HARDWARE\DESCRIPTION\System\CentralProcessor\0') as k:
+                return re.sub(r'\s+', ' ', winreg.QueryValueEx(k, 'ProcessorNameString')[0]).strip()
+        with open('/proc/cpuinfo') as f:
+            for ln in f:
+                if ln.startswith('model name'):
+                    return ln.split(':', 1)[1].strip()
+    except Exception:
+        pass
+    return platform.processor().strip()
+
+
 class CpuSampler(threading.Thread):
     """后台每秒阻塞采样一次 CPU。cpu_percent 是"距上次调用"的差值：放在请求里算，窗口取决于两次
     HTTP 请求的间隔（网页 1 秒轮询 + 手动 curl 会把它压成几毫秒，读数恒为 0）——所以单独一个线程按固定
@@ -80,16 +96,66 @@ class CpuSampler(threading.Thread):
     def run(self):
         try:
             import psutil
+            name = cpu_name()                                       # 型号只读一次，别每秒翻注册表
             psutil.cpu_percent(interval=None, percpu=True)          # 打桩：第一次恒为 0，丢掉
             while True:
                 per = psutil.cpu_percent(interval=1.0, percpu=True)
-                _CPU['v'] = {'total': round(sum(per) / max(1, len(per)), 1), 'per': [round(x) for x in per], 'n': len(per)}
+                _CPU['v'] = {'total': round(sum(per) / max(1, len(per)), 1), 'per': [round(x) for x in per], 'n': len(per), 'model': name}
         except Exception:
             _CPU['v'] = {}
 
 
 def cpu():
-    return _CPU['v']
+    return {**_CPU['v'], **mahm()}
+
+
+_MAHM = {'t': 0.0, 'v': {}}
+
+
+def mahm():
+    """借 MSI Afterburner 的共享内存（MAHMSharedMemory）读 CPU 温度 / 封装功耗——Windows 上没有别的免驱动口子：
+    psutil 在 Windows 没有 sensors_temperatures；ACPI 热区只有个 27.9 °C 的板温；Power Meter 计数器没有实例。
+    条目布局实测：头 32 字节（签名 MAHM / 版本 / 头大小 / 条目数 / 条目大小 / 时间戳），每条 1324 字节，
+    名字在前 260 字节、单位在其后 260、数值是偏移 1300 的 float（用 GPU1 power 对 nvidia-smi 校准过）。
+    读数比 30 秒旧才当没读到：Afterburner 的硬件轮询周期实测 10~13 秒（不是 1 秒），阈值卡 10 秒会
+    正好落在两次刷新之间、把还在用的读数丢掉（表现为温度和功耗一闪一闪地消失）。"""
+    now = time.time()
+    if now - _MAHM['t'] < 1.0: return _MAHM['v']
+    _MAHM['t'] = now
+    out = {}
+    try:
+        import ctypes, struct
+        k = ctypes.windll.kernel32
+        k.OpenFileMappingW.restype = ctypes.c_void_p
+        k.OpenFileMappingW.argtypes = [ctypes.c_uint32, ctypes.c_int, ctypes.c_wchar_p]
+        k.MapViewOfFile.restype = ctypes.c_void_p
+        k.MapViewOfFile.argtypes = [ctypes.c_void_p, ctypes.c_uint32, ctypes.c_uint32, ctypes.c_uint32, ctypes.c_size_t]
+        h = k.OpenFileMappingW(0x0004, 0, 'MAHMSharedMemory')
+        p = k.MapViewOfFile(h, 0x0004, 0, 0, 0) if h else 0
+        if p:
+            hd = ctypes.string_at(p, 32)
+            num, esize, hsize = (int.from_bytes(hd[i * 4:i * 4 + 4], 'little') for i in (3, 4, 2))
+            upd = int.from_bytes(hd[20:24], 'little')
+            if 0 < num < 5000 and 32 < esize < 65536 and now - upd <= 30:
+                buf = ctypes.string_at(p, hsize + num * esize)
+                core = {}
+                for i in range(num):
+                    e = buf[hsize + i * esize: hsize + (i + 1) * esize]
+                    nm = e[:260].split(b'\x00')[0].decode('latin1')
+                    if not nm: continue
+                    val = struct.unpack('<f', e[1300:1304])[0]
+                    if nm == 'CPU temperature' and 0 < val < 130: out['temp'] = round(val)
+                    elif nm == 'CPU power' and 0 < val < 1000: out['power'] = round(val, 1)
+                    elif nm.startswith('CPU') and nm.endswith(' temperature'):
+                        try:
+                            j = int(nm[3:-12])
+                            if 0 < val < 130: core[j] = round(val)
+                        except ValueError: pass
+                if core: out['coreT'] = [core[k] for k in sorted(core)]
+    except Exception:
+        out = {}
+    _MAHM['v'] = out
+    return out
 
 
 _GPU_CACHE = {'t': 0.0, 'v': []}
@@ -156,7 +222,7 @@ def newer(pattern, t0):
 
 
 def stage_progress(st, s):
-    """当前阶段的进度：返回 {'frac': 0..1 或 None（无法计量）, 'label': 文字}。"""
+    """当前阶段的进度：返回 {'frac': 0..1 或 None（无法计量）, 'label': 文字, 'eta_s': 按实测速率外推的剩余秒数或 None}。"""
     t0, info = s['start'], s.get('info') or {}
     if st == 'gen':
         # 分子算全部（含之前轮次已完成的分片），分母是累计目标：补量时显示 50,008/79,688 而不是 0/79,688。
@@ -165,43 +231,96 @@ def stage_progress(st, s):
         n = sum(LC.count(f) for f in allf)
         tgt = info.get('target_tasks') or 0
         new = sum(LC.count(f) for f in newer(f'{DATA}/shard_*.jsonl', t0) + newer(f'{DATA}/shard_*.jsonl.part', t0))
-        lab = f'已生成 {n:,} / {tgt:,} 条任务' + (f'（本轮补 {new:,} 条）' if 0 < new < n else '')
-        return {'frac': min(1, n / tgt) if tgt else None, 'label': lab}
+        # 剩余时间按"本轮已写条数 ÷ 本轮已用时"外推（条数是实时数出来的，速率就是实测的），不再用静态估时
+        el = max(1.0, time.time() - t0)
+        rate = new / el if new > 0 else 0
+        eta = ((tgt - n) / rate if rate > 0 else None) if tgt > n else (0.0 if rate > 0 else None)
+        lab = f'已生成 {n:,} / {tgt:,} 条任务' + (f'（本轮补 {new:,} 条 · {rate * 60:.0f} 条/分）' if 0 < new < n else '')
+        return {'frac': min(1, n / tgt) if tgt else None, 'label': lab, 'eta_s': eta}
+    if st == 'gate1':
+        # 一致性门禁每 10 个任务往 stderr 打一行 "k/300"（consistency.cjs:41）。进度只读控制台日志最后 64 KB，
+        # 不跑任何计算、不占 CPU —— 正在生成的节点不受影响。日志里可能还留着上一次门禁的进度行，
+        # 所以只数最后一个 "consistency.cjs" 命令行之后的部分。
+        txt = console(0).get('text') or ''
+        cut = txt.rfind('consistency.cjs')
+        m = re.findall(r'^(\d+)/(\d+)\s*$', txt[cut:] if cut >= 0 else '', re.M)
+        n, N = (int(m[-1][0]), int(m[-1][1])) if m else (0, 300)
+        el = time.time() - t0
+        rate = n / el if n > 0 and el > 2 else 0
+        return {'frac': n / N if N else None,
+                'label': f'门禁 {n} / {N} 个任务' + (f' · {rate * 60:.0f} 个/分' if rate else '') if n else '准备中（日志里还没有进度行）',
+                'eta_s': (N - n) / rate if rate > 0 else None}
     if st == 'prep':
         nsh = len(glob.glob(os.path.join(ROOT, DATA, 'shard_*.jsonl')))
         done = len(newer(f'{DATA}/samples/*.X.npy', t0))
-        if os.path.exists(os.path.join(ROOT, DATA, 'r2.json')) and newer(f'{DATA}/r2.json', t0): return {'frac': 1, 'label': '打包完成，R2 检查完成'}
-        return {'frac': min(0.95, done / nsh) if nsh else None, 'label': f'已打包 {done} / {nsh} 个分片' + ('，R2 检查中' if nsh and done >= nsh else '')}
+        if os.path.exists(os.path.join(ROOT, DATA, 'r2.json')) and newer(f'{DATA}/r2.json', t0): return {'frac': 1, 'label': '打包完成，R2 检查完成', 'eta_s': 0}
+        el = time.time() - t0
+        eta = (nsh - done) / (done / el) if done > 0 and el > 1 and nsh > done else None
+        return {'frac': min(0.95, done / nsh) if nsh else None, 'label': f'已打包 {done} / {nsh} 个分片' + ('，R2 检查中' if nsh and done >= nsh else ''), 'eta_s': eta}
     if st == 'train':
         tag, bs = info.get('tag', 'base'), info.get('bench_steps', 2000)
         b, m = last_rec(f'bench_{tag}') if newer(f'{RUNS}/bench_{tag}/log.jsonl', t0) else None, last_rec(tag) if newer(f'{RUNS}/{tag}/log.jsonl', t0) else None
         if m and m.get('total'):
-            return {'frac': (bs + m['step']) / (bs + m['total']), 'label': f'正式训练 {m["step"]:,} / {m["total"]:,} 步', 'run': tag}
+            return {'frac': (bs + m['step']) / (bs + m['total']), 'label': f'正式训练 {m["step"]:,} / {m["total"]:,} 步', 'run': tag,
+                    'eta_s': m['eta_h'] * 3600 if m.get('eta_h') else None}   # 训练脚本自己按实测样本/s 算的
         if b: return {'frac': b['step'] / (bs + 60000), 'label': f'测速 {b["step"]:,} / {bs:,} 步', 'run': f'bench_{tag}'}
         return {'frac': 0, 'label': '加载数据中'}
     if st == 'apg':
         r = last_rec('apg') if newer(f'{RUNS}/apg/log.jsonl', t0) else None
-        return {'frac': r['it'] / r['total'] if r and r.get('total') else 0, 'label': f'APG {r["it"]:,} / {r["total"]:,} 步' if r else '准备中', 'run': 'apg'}
+        eta = None
+        if r and r.get('total'):
+            it, mn = r.get('it') or 0, r.get('min') or 0
+            eta = (r['total'] - it) / (it / mn) * 60 if it > 0 and mn > 0.1 else None   # 步/分实测外推
+        return {'frac': r['it'] / r['total'] if r and r.get('total') else 0, 'label': f'APG {r["it"]:,} / {r["total"]:,} 步' if r else '准备中', 'run': 'apg', 'eta_s': eta}
     if st == 'mine':
         R = info.get('rounds', 6)
         k = len(newer(f'{RUNS}/mine/r*/gate.json', t0))
         cur = sorted(newer(f'{RUNS}/apg_r*/log.jsonl', t0), key=os.path.getmtime)
-        frac_in, lab = 0, f'第 {k + 1} 轮：挖错出题'
-        if cur and len(cur) > k:
-            name = os.path.basename(os.path.dirname(cur[-1])); r = last_rec(name)
-            if r and r.get('total'): frac_in = 0.3 + 0.6 * r['it'] / r['total']; lab = f'第 {k + 1} 轮：APG {r["it"]:,} / {r["total"]:,} 步'
-            return {'frac': min(1, (k + frac_in) / R), 'label': f'{lab}（共最多 {R} 轮，提升不足会提前停）', 'run': name}
+        lab = f'第 {k + 1} 轮：挖错出题'
+        if cur:
+            name = os.path.basename(os.path.dirname(cur[-1]))                  # ml/runs/apg_rN
+            rn = re.sub(r'\D', '', name) or '1'
+            gate = os.path.join(ROOT, RUNS, 'mine', f'r{rn}', 'gate.json')
+            r = last_rec(name)
+            if r and r.get('total') and not os.path.exists(gate):               # 这一轮还在跑（还没出 gate）
+                frac_in = 0.3 + 0.6 * r['it'] / r['total']
+                lab = f'第 {k + 1} 轮：APG {r["it"]:,} / {r["total"]:,} 步'
+                it, mn = r.get('it') or 0, r.get('min') or 0
+                eta = (r['total'] - it) / (it / mn) * 60 if it > 0 and mn > 0.1 else None
+                if eta is not None and k >= 1:                                  # 剩余轮次按已完成轮次的平均时长外推
+                    eta += max(0, R - k - 1) * (time.time() - t0) / k
+                return {'frac': min(1, (k + frac_in) / R), 'label': f'{lab}（共最多 {R} 轮，提升不足会提前停）', 'run': name, 'eta_s': eta}
         return {'frac': min(1, k / R), 'label': f'{lab}（共最多 {R} 轮，提升不足会提前停）'}
     if st == 'm5':
         tag = info.get('tag', 'base')
         n = len(newer(f'{RUNS}/m5_{tag}_policy.json', t0)) + len(newer(f'{RUNS}/m5_{tag}_safety.json', t0))
-        return {'frac': n / 2, 'label': ['纯策略评估中', '加安全层评估中', '汇总'][min(n, 2)]}
+        el = time.time() - t0
+        eta = (2 - n) * (el / n) if n == 1 else (0.0 if n >= 2 else None)   # 两次评估（纯策略 / 加安全层）按已完成的平均耗时外推
+        return {'frac': n / 2, 'label': ['纯策略评估中', '加安全层评估中', '汇总'][min(n, 2)], 'eta_s': eta}
     return {'frac': None, 'label': '进行中'}
 
 
+def stage_elapsed(pl, now=None):
+    """每个阶段的累计用时（秒）：pipeline.json 的 time{阶段: 秒} 是不含当前段的累计，运行中的阶段
+    再把"这一段"实时加上。老记录（没有 time 字段）用 start/end 的差值兜底。
+    网页的「总用时」＝各阶段之和，「本步用时」＝当前阶段这条 —— 确定/续跑都不归零。"""
+    now = now or time.time()
+    acc = pl.get('time') or {}
+    cur = pl.get('current')
+    out = {}
+    for k, r in (pl.get('stages') or {}).items():
+        t = acc.get(k)
+        if t is None and r.get('start') and r.get('end'): t = r['end'] - r['start']
+        t = t or 0
+        if k == cur and r.get('start') and r.get('end') is None: t += max(0.0, now - r['start'])
+        out[k] = round(t, 1)
+    return out
+
+
 def pipeline():
     d = jload(os.path.join(ROOT, RUNS, 'pipeline.json'))
     if not d: return None
+    d['elapsed'] = stage_elapsed(d)
     cur = d.get('current')
     if cur and cur in d['stages']:
         try: d['progress'] = stage_progress(cur, d['stages'][cur])
@@ -228,7 +347,8 @@ def status():
     if pb: pb = {k: {kk: v.get(kk) for kk in ('n', 'ok', 'reached', 'collisionFrames', 'brakeRate', 'recoveryRate', 'livelock', 'inferMsP99', 'safetyMsP99')}
                  for k, v in pb.items() if isinstance(v, dict) and 'n' in v}
     return {'now': time.time(), 'gpu': gpu(), 'cpu': cpu(),
-            'vram_budget_gb': float(os.environ.get('VRAM_BUDGET_GB', 20)),      # 本机桌面常驻占 4–5 GB，给训练的预算 19–20 GB
+            'vram_reserve_gb': float(os.environ.get('VRAM_RESERVE_GIB', 1)),   # 给系统留的余量（GB）：训练进程上限 = 整卡 − 已用 − 这个余量（浮动，见 ml/common/vram.py）
+            'vram_budget_gb': float(os.environ['VRAM_BUDGET_GB']) if os.environ.get('VRAM_BUDGET_GB') else None,   # 只有显式指定才覆盖上面的口径
             'pipeline': pl, 'check': CHECK.get(), 'lock': lock_info(),   # 2026-10-18 第八轮修：上一版这三项被行尾注释吞掉，网页步骤条/锁状态拿不到
             'stage_meta': [{'id': k, 'name': n, 'est_h': h, 'timeout_h': pstate.TIMEOUT_H[k]} for k, n, h in pstate.STAGES],
             'r4': jload(P(RUNS, 'r4.json')),
@@ -243,7 +363,7 @@ def status():
 STAGES = pstate.ORDER
 ENV_KEYS = {'N_TASKS': r'\d+', 'NPROC': r'\d+', 'TARGET_SAMPLES': r'\d+', 'CFG': r'ml/configs/(base|wta|small)\.json',
             'CONSENSUS': r'[01]?', 'ROUNDS': r'\d+', 'APG_STEPS': r'\d+', 'MINE_N': r'\d+', 'MIN_GAP_MM': r'\d+(\.\d+)?',
-            'FRESH': r'[01]', 'R2_STRICT': r'[01]', 'AUTO_WTA': r'[01]'}
+            'FRESH': r'[01]', 'FRESH_FROM': r'(setup|kin|r4|gate1|gen|prep|train|m5|apg|mine|export|bench|accept)', 'R2_STRICT': r'[01]', 'AUTO_WTA': r'[01]'}
 CONSOLE = os.path.join(ROOT, RUNS, 'console.log')
 
 
@@ -299,6 +419,29 @@ def lock_info():
     return dict(lk, alive=pstate.lock_alive(lk), age_s=time.time() - lk.get('beat', 0))
 
 
+NT_NAMES = "'node.exe','xargs.exe','bash.exe','sh.exe','timeout.exe'"
+NT_SWEEP = (r"pipeline\.sh|run_prep\.sh|run_parallel\.sh|build_dataset\.cjs|"
+            r"gen_dataset\.cjs|teacher\.cjs|policy_bench\.cjs")
+
+
+def sweep_nt(keep_pid):
+    """taskkill /T 在 Git Bash 下只杀到 bash，xargs/node 孙进程会逃（10-18 实测：停止后还有 28 个
+    gen_dataset 在跑；当晚二次踩到：两批 build_dataset 抢同一批 shard）。按命令行补扫整条流水线，
+    keep_pid 的祖先链（= 控制台自己拉起的 monitor bash）不动。先杀包装再杀 node，否则 node 一死
+    xargs 会立刻补下一个 shard。返回仍存活个数，-1 = pwsh 没跑成。"""
+    q = ("$anc=@(); $c=%d; while ($c -gt 0 -and ($p=Get-CimInstance Win32_Process -Filter \"ProcessId=$c\" "
+         "-ErrorAction SilentlyContinue)) { $anc+=$p.ProcessId; $c=$p.ParentProcessId }; "
+         "$m={ $_.Name -in %s -and $_.CommandLine -match '%s' -and $anc -notcontains $_.ProcessId }; "
+         "foreach ($x in @(Get-CimInstance Win32_Process | Where-Object $m | "
+         "Sort-Object { if ($_.Name -eq 'node.exe') { 1 } else { 0 } })) "
+         "{ Stop-Process -Id $x.ProcessId -Force -ErrorAction SilentlyContinue }; "
+         "Start-Sleep -Seconds 2; "
+         "@(Get-CimInstance Win32_Process | Where-Object $m).Count" % (int(keep_pid), NT_NAMES, NT_SWEEP))
+    r = subprocess.run(['pwsh', '-NoProfile', '-Command', q], capture_output=True, text=True, timeout=90)
+    lines = [s for s in (r.stdout or '').split() if s.isdigit()]
+    return int(lines[-1]) if lines else -1
+
+
 def kill_session(sid):
     """POSIX：结束会话 sid 里的所有进程（含 timeout 另起的进程组）。"""
     pids = []
@@ -376,14 +519,14 @@ class Job:
         with self.lock:
             if os.name == 'nt':
                 subprocess.run(['taskkill', '/T', '/F', '/PID', str(pid)], capture_output=True)
-                # Git Bash 下 taskkill /T 只杀到 bash，node 孙进程会逃掉（2026-10-18 实测：点了停止还有 28 个
-                # gen_dataset 在跑）。按命令行补扫：只动本仓库 ml/ 下的脚本，绝不碰用户自己的 node 进程。
+                # 补扫漏网的子孙；有残留就写进网页日志，别让用户以为停干净了
                 try:
-                    q = ("Get-CimInstance Win32_Process -Filter \"Name='node.exe'\" | "
-                         "Where-Object { $_.CommandLine -match 'gen_dataset\\.cjs|run_parallel\\.sh|teacher\\.cjs|policy_bench\\.cjs' } | "
-                         "ForEach-Object { Stop-Process -Id $_.ProcessId -Force -ErrorAction SilentlyContinue }")
-                    subprocess.run(['pwsh', '-NoProfile', '-Command', q], capture_output=True, timeout=60)
-                except Exception: pass
+                    left = sweep_nt(os.getpid())
+                except Exception:
+                    left = -1
+                if left != 0:
+                    with open(CONSOLE, 'a', encoding='utf-8') as f:
+                        f.write(f'\n[停止补扫：仍有 {left} 个流水线子进程存活（-1=补扫没跑成），把这条发我]\n')
             else:
                 if ours:
                     kill_session(pid)

ml/pipeline.sh

@@ -127,19 +127,21 @@ case $stage in
           extra=""; [ "${CONSENSUS:-0}" = "1" ] && extra="--consensus 4"
           run bash ml/gen/run_parallel.sh $per $NPROC 1 "$extra"
           # 补量：共识过滤与间隙过滤都会降低保留率，样本不足 TARGET_SAMPLES 时按实测"样本/任务"补生成。
-          # 最多 4 次（第五轮由 2 改 4：两种过滤叠加时 2 次可能补不满）；已写完的补量 shard 续跑时跳过。
+          # 最多 5 次（第五轮由 2 改 4；2026-10-18 应用户要求 4 改 5：共识 + 间隙两道过滤叠加时余量更足）；已写完的补量 shard 续跑时跳过。
           s0=$((1 + NPROC))
-          for k in 1 2 3 4; do
+          for k in 1 2 3 4 5; do
             need=$($PY -c "import json,math;s=json.load(open('ml/data/stats.json', encoding='utf-8'));d=$TARGET_SAMPLES-s['samplesEvery3'];print(0 if d<=0 else math.ceil(d/(s['samplesEvery3']/max(1,s['tasks']))*1.05))")
             [ "$need" = "0" ] && break
             echo "样本不足目标 $TARGET_SAMPLES，补生成 $need 条任务（第 $k 次）"
             per2=$(( (need + NPROC - 1) / NPROC ))
-            old=$($PY -m ml.pstate get gen target_tasks)          # 读不到直接失败（审查 N-13：此前空值会被算成 56 这类数）
-            $PY -m ml.pstate set gen target_tasks=$(( old + per2 * NPROC ))
+            # 目标 = 已写完的分片条数 + 本轮要补的；不能用 pstate 里上次的 target_tasks 累加，
+            # 那样每次续跑（点停止后再「继续训练」）分母都加一截，进度条会越续越少（2026-10-18 实测 67368→84728）。
+            done_n=$($PY -c "import json;print(json.load(open('ml/data/stats.json', encoding='utf-8'))['tasks'])")
+            $PY -m ml.pstate set gen target_tasks=$(( done_n + per2 * NPROC ))
             run bash ml/gen/run_parallel.sh $per2 $NPROC $s0 "$extra"
             s0=$((s0 + NPROC))
           done
-          $PY -c "import json;s=json.load(open('ml/data/stats.json', encoding='utf-8'));import sys;sys.exit(0 if s['samplesEvery3']>=0.9*$TARGET_SAMPLES else 7)" || echo "警告：补 4 次后样本仍不足目标的 90%，按现有样本继续（stats.json 见 samplesEvery3）" ;;
+          $PY -c "import json;s=json.load(open('ml/data/stats.json', encoding='utf-8'));import sys;sys.exit(0 if s['samplesEvery3']>=0.9*$TARGET_SAMPLES else 7)" || echo "警告：补 5 次后样本仍不足目标的 90%，按现有样本继续（stats.json 见 samplesEvery3）" ;;
   prep)   # 间隙过滤口径必须与生成时一致（审查 N-1）
           $PY -c "import json,sys;m=json.load(open('ml/data/stats.json', encoding='utf-8')).get('minGapFilterMm');sys.exit(0 if m is None or float(m)==float($MIN_GAP_MM) else 8)" \
             || { echo "MIN_GAP_MM=$MIN_GAP_MM 与生成阶段 stats.json 的 minGapFilterMm 不一致：补量口径与训练集会分叉，请用同一值重跑 gen 或 prep"; exit 8; }
@@ -184,7 +186,7 @@ case $stage in
           # 启动前自检（审查 N-10：不能等到 train 才发现这个 Python 没有 torch）
           $PY -c "import torch" 2>/dev/null || { echo "当前 Python（$($PY -c 'import sys;print(sys.executable)')）没有 torch：请先激活训练环境或设 PYTHON=..."; exit 1; }
           command -v node >/dev/null || { echo "找不到 node"; exit 1; }
-          fl=""; [ "${FRESH:-0}" = 1 ] && fl="--fresh"
+          fl=""; [ "${FRESH:-0}" = 1 ] && fl="--fresh"; [ -n "${FRESH_FROM:-}" ] && fl="--fresh-from=$FRESH_FROM"
           $PY -m ml.pstate reset ${PLAN// /,} $fl     # 续跑 / 参数变了作废受影响阶段（旧产物移到 ml/archive/<时间>/）
           TODO=$($PY -m ml.pstate todo)
           echo "计划：$PLAN"; echo "待跑：${TODO:-（全部已完成）}"

ml/pstate.py

@@ -1,6 +1,6 @@
 """流水线状态与互斥锁（单一写者：所有对 ml/runs/pipeline.json / pipeline.lock 的写都经过本模块，原子替换）。
 pipeline.sh 自动调用，一般不需要手动运行：
-  python -m ml.pstate reset <阶段1,...> [--fresh]     # `all` 开始：保留 rc=0 的已完成阶段（续跑）；参数变了只作废受影响的阶段；--fresh 全部作废
+  python -m ml.pstate reset <阶段1,...> [--fresh]     # `all` 开始：保留 rc=0 的已完成阶段（续跑）；参数变了只作废受影响的阶段；--fresh 全部作废；--fresh-from=<阶段> 只作废该阶段及之后
   python -m ml.pstate todo                             # 打印计划中尚未完成的阶段（空格分隔）
   python -m ml.pstate begin <阶段> [键=值 ...]          # 阶段开始
   python -m ml.pstate set <阶段> 键=值 ...              # 阶段中途更新
@@ -13,7 +13,9 @@ pipeline.sh 自动调用，一般不需要手动运行：
     心跳超过 LOCK_STALE_S 未刷新视为陈旧（进程被强杀），可接管。
   - 续跑（缺口 1）：reset 默认保留已完成阶段；参数变了只作废受它影响的阶段（AFFECTS），其产物移到 ml/archive/，避免新旧参数混用。
   - 阶段表 STAGES 是估时 / 超时 / 网页进度权重的唯一来源（审查 N-14：网页权重与耗时表同源）。
-  - 停止也走本模块（审查 N-12：此前 monitor 直写 pipeline.json，与子进程竞态）。"""
+  - 停止也走本模块（审查 N-12：此前 monitor 直写 pipeline.json，与子进程竞态）。
+  - 累计用时（2026-10-18）：每个阶段跑过的时间并进顶部 time{阶段: 秒}，跨「停止 → 继续训练」累加，
+    网页的「总用时 / 本步用时」据此显示；产物被归档（要重做）的阶段清零，其余保留。"""
 import glob, json, os, shutil, socket, sys, time
 
 ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
@@ -69,7 +71,7 @@ def load():
     try:
         with open(P, encoding='utf-8') as f: return json.load(f)
     except Exception:
-        return {'started': time.time(), 'plan': None, 'stages': {}, 'current': None, 'params': {}}
+        return {'started': time.time(), 'plan': None, 'stages': {}, 'current': None, 'params': {}, 'time': {}}
 
 
 def save(d):
@@ -146,11 +148,21 @@ def todo(d=None):
     return [s for s in (d.get('plan') or []) if (d['stages'].get(s) or {}).get('rc') != 0]
 
 
+def _acc_time(d, st, now):
+    """把"这一段"的用时并进累计 time{阶段: 秒}。幂等：stage.end 已写就不再加，停止（mark_stopped）
+    与流水线的 end 都会调，重复调用不会双记。"""
+    s = d['stages'].get(st)
+    if s and s.get('start') and s.get('end') is None:
+        t = d.setdefault('time', {})
+        t[st] = round(t.get(st, 0) + max(0.0, now - s['start']), 1)
+
+
 def mark_stopped(rc=-15):
-    """网页「停止」后调用：当前阶段记为被停止，释放锁。"""
-    d = load(); st = d.get('current')
+    """网页「停止」后调用：当前阶段记为被停止、这段用时并进累计，释放锁。"""
+    d = load(); st = d.get('current'); now = time.time()
     if st and st in d['stages'] and d['stages'][st].get('end') is None:
-        d['stages'][st].update(end=time.time(), rc=rc)
+        _acc_time(d, st, now)
+        d['stages'][st].update(end=now, rc=rc)
     d['current'] = None
     save(d); lock_release()
 
@@ -182,11 +194,12 @@ def main():
     if cmd == 'reset':
         plan = rest[0].split(',') if rest and rest[0] else []
         pn = params_now(); prev = d.get('params') or {}
-        changed = []
+        changed = [k for k in PARAM_KEYS if prev and prev.get(k) != pn[k]]
+        ff = next((r.split('=', 1)[1] for r in rest if r.startswith('--fresh-from=')), '')
         if '--fresh' in rest: bad = set(ORDER)
         else:
-            changed = [k for k in PARAM_KEYS if prev and prev.get(k) != pn[k]]
             bad = {st for k in changed for st in AFFECTS[k]}
+            if ff in ORDER: bad |= set(ORDER[ORDER.index(ff):])
             if changed: print('参数与上次不同：' + json.dumps({k: (prev.get(k), pn[k]) for k in changed}, ensure_ascii=False)
                               + '；受影响的阶段重跑：' + ' '.join(st for st in ORDER if st in bad), file=sys.stderr)
         keep = {k: v for k, v in d.get('stages', {}).items() if v.get('rc') == 0 and k not in bad}
@@ -194,14 +207,21 @@ def main():
         # 例外：只改了目标样本量时，gen 要重跑补量，但已有分片必须留着（run_parallel 跳过写完的 shard、
         # 按差额补量），否则 5 小时的生成白跑。
         no_archive = {'gen'} if 'TARGET_SAMPLES' in changed else set()
-        arc = archive([st for st in ORDER if st in bad and st not in no_archive]) if bad else None
+        arch = [st for st in ORDER if st in bad and st not in no_archive]
+        arc = archive(arch) if arch else None
         if arc: print(f'旧产物已移到 {arc}/（未删除）', file=sys.stderr)
-        d = {'started': now, 'plan': plan, 'stages': keep, 'current': None, 'params': pn}
+        # 累计用时跨续跑保留；只有产物被挪走的阶段（要从头重做）才清零
+        tm = {k: v for k, v in (d.get('time') or {}).items() if k not in arch}
+        d = {'started': now, 'plan': plan, 'stages': keep, 'current': None, 'params': pn, 'time': tm}
         done = [s for s in plan if s in keep]
         if done: print('跳过已完成的 %d 个阶段：%s' % (len(done), ' '.join(done)), file=sys.stderr)
         save(d); return
     elif cmd == 'begin':
         st = rest[0]
+        prev = d['stages'].get(st) or {}
+        # 老记录（本次改动之前完成的）没有累计字段：用上一次的整段补上，免得续跑时用时从 0 起
+        if prev.get('start') and prev.get('end') and st not in (d.get('time') or {}):
+            d.setdefault('time', {})[st] = round(prev['end'] - prev['start'], 1)
         d['stages'][st] = {'start': now, 'end': None, 'rc': None, 'info': kv(rest[1:]), 'timeout_h': TIMEOUT_H.get(st)}
         d['current'] = st
     elif cmd == 'set':
@@ -210,6 +230,7 @@ def main():
     elif cmd == 'end':
         st, rc = rest[0], int(rest[1]) if len(rest) > 1 else 0
         s = d['stages'].setdefault(st, {'start': now, 'info': {}})
+        _acc_time(d, st, now)
         s['end'], s['rc'] = now, rc
         if d.get('current') == st: d['current'] = None
     else:

ml/train.py

@@ -117,7 +117,9 @@ def main():
             print(json.dumps(rec), flush=True); log.write(json.dumps(rec) + '\n'); log.flush()
         if not a.no_eval and (step + 1) % tc['eval_every'] == 0:
             model.eval()
-            res, _ = evaluate(model, kin, val_tasks, dev)
+            # bs=64 + 归还缓存池：WDDM 卡满时 15.9 GiB 的评估峰值会被驱动换出到内存，eval 从 2 分钟变 1 小时
+            res, _ = evaluate(model, kin, val_tasks, dev, bs=64)
+            torch.cuda.empty_cache()
             res['step'] = step + 1; res['t'] = time.time()
             print('EVAL', json.dumps(res), flush=True); log.write(json.dumps({'eval': res}) + '\n'); log.flush()
             save('last.pt', step + 1)