QwenJev v0.4.3: 25-public-games eval in-repo (run_eval incremental report, fetch_games, CPU feasibility verified)

Makefile

@@ -1,4 +1,4 @@
-.PHONY: setup smoke collect build-data distill train-s1 calibrate eval eval-v2 eval-25 eval-cpu agent-local push-hf test clean
+.PHONY: setup smoke collect build-data distill train-s1 calibrate eval eval-v2 eval-25 eval-cpu fetch-games agent-local push-hf test clean
 
 PY ?= python3.13
 
@@ -43,6 +43,9 @@ eval-25:          ## evaluate on the 25 public games (needs arc-agi + environmen
 eval-cpu:         ## CPU harness test (tiny backend, no checkpoint, 60 actions)
 	$(PY) ops/run_eval.py --backend tiny --no-checkpoint --games mock --max-actions 60
 
+fetch-games:      ## cache all 25 public games locally (anonymous arcade key, ~3MB, no Kaggle account)
+	$(PY) ops/fetch_games.py
+
 agent-local:      ## run the hybrid agent locally via the ARC-AGI-3-Agents runner
 	$(PY) ../ARC-AGI-3-Agents/main.py --agent=qwenjevagent --game=ls20
 

data/collect_selfplay.py

@@ -42,46 +42,131 @@ PUBLIC_GAMES_FALLBACK = [
 ]
 
 
+def _env_dir() -> str:
+    return os.environ.get("ARC_ENVIRONMENTS_DIR", "environment_files")
+
+
 def make_env(game_id: str, render_mode: str | None):
     """Open one game: the built-in mock (no downloads) or the official
     offline engine (`arc-agi` package + local game files).
 
-    Game files are the competition's environment_files/ (Kaggle Data page,
-    arc-prize-2026-arc-agi-3). Point ARC_ENVIRONMENTS_DIR at it when running
-    from another directory; defaults to ./environment_files."""
+    Real games are resolved in two steps:
+      1. OFFLINE mode against the local cache (ARC_ENVIRONMENTS_DIR or
+         ./environment_files) — zero network, ~2000 FPS;
+      2. if the game is not cached and QWENJEV_AUTO_DOWNLOAD!=0, bootstrap
+         through NORMAL mode, which fetches the game source from the arcade
+         API (anonymous key works) and caches it forever. No Kaggle
+         credentials are needed for the 25 public games."""
     if game_id.startswith("mock"):
         # deterministic seed: reproducible levels across processes
         return make_mock_env(seed=zlib.crc32(game_id.encode()) % (2 ** 31))
     import arc_agi
     from arc_agi import OperationMode
 
-    arc = arc_agi.Arcade(operation_mode=OperationMode.OFFLINE,
-                         environments_dir=os.environ.get(
-                             "ARC_ENVIRONMENTS_DIR", "environment_files"))
-    return arc.make(game_id, render_mode=render_mode) if render_mode else arc.make(game_id)
+    env_dir = _env_dir()
+    try:
+        arc = arc_agi.Arcade(operation_mode=OperationMode.OFFLINE,
+                             environments_dir=env_dir)
+        env = arc.make(game_id, render_mode=render_mode) if render_mode \
+            else arc.make(game_id)
+        if env is not None:
+            return env
+    except Exception:
+        pass  # fall through to the bootstrap path
+
+    if os.environ.get("QWENJEV_AUTO_DOWNLOAD", "1") != "1":
+        raise RuntimeError(
+            f"game {game_id} not in {env_dir}; run ops/fetch_games.py or "
+            "export QWENJEV_AUTO_DOWNLOAD=1")
+    arc = arc_agi.Arcade(operation_mode=OperationMode.NORMAL,
+                         environments_dir=env_dir)
+    env = arc.make(game_id, render_mode=render_mode) if render_mode \
+        else arc.make(game_id)
+    if env is None:
+        raise RuntimeError(f"could not download/create game {game_id}")
+    return env
+
+
+def _official_frame(env):
+    """Last FrameDataRaw from an official EnvironmentWrapper (or None)."""
+    return getattr(env, "observation_space", None) \
+        or getattr(env, "_last_response", None)
+
+
+def _resolve_frame(env):
+    """Uniform frame resolution across mock + official environments."""
+    if hasattr(env, "observe"):
+        f = env.observe()
+        if f is not None:
+            return f
+    f = _official_frame(env)
+    return f if f is not None else env
+
+
+def _to_grid_lists(grids) -> list:
+    """ndarray | nested lists -> plain nested int lists, dropping empties."""
+    import numpy as np
+    out = []
+    for g in grids:
+        arr = np.asarray(g)
+        if arr.ndim < 2 or arr.size == 0:
+            continue
+        out.append(arr.astype(int).tolist())
+    return out
+
+
+def _action_names(ids) -> list[str]:
+    """Official frame.available_actions are GameAction ids (ints) — map to
+    names. Name strings pass through untouched (mock compatibility)."""
+    if not ids:
+        return []
+    if isinstance(ids[0], str):
+        return list(ids)
+    from arcengine import GameAction
+    names = []
+    for i in ids:
+        try:
+            name = GameAction.from_id(int(i)).name
+        except Exception:
+            continue
+        if name != "RESET":  # lifecycle-guarded, never a candidate
+            names.append(name)
+    return names or ["ACTION1", "ACTION2", "ACTION3", "ACTION4"]
 
 
 def grids_from(env) -> list:
-    """Best-effort frame extraction across toolkit versions."""
-    frame = env.observe() if hasattr(env, "observe") else getattr(env, "frame", None)
+    """Best-effort frame extraction across toolkit versions.
+
+    Official EnvironmentWrapper steps return FrameDataRaw whose `.frame`
+    holds a numpy array (raw=True path) of shape (n_frames, H, W); mock
+    frames carry nested lists under `.frames`. Both end up as nested ints."""
+    frame = getattr(env, "frame", None)  # official engine exposes .frame too
     if frame is None:
-        frame = getattr(env, "latest_frame", None)
+        frame = _resolve_frame(env)
     for attr in ("frames", "frame", "grids"):
         grids = getattr(frame, attr, None)
-        if grids:
-            return [list(map(list, g)) for g in grids]
-    if isinstance(frame, list) and frame and isinstance(frame[0], list):
-        return [list(map(list, frame))]
+        if grids is not None and len(grids):
+            out = _to_grid_lists(grids)
+            if out:
+                return out
+    if isinstance(frame, (list, tuple)) and len(frame):
+        out = _to_grid_lists(frame)
+        if out:
+            return out
     raise RuntimeError("could not read frame grids from the environment")
 
 
 def meta_from(env, frame=None) -> dict:
-    frame = frame or (env.observe() if hasattr(env, "observe") else env)
+    frame = frame or _resolve_frame(env)
+    state = getattr(frame, "state", "NOT_FINISHED")
+    # enum GameState -> "WIN"; plain strings pass through (mock)
+    state = getattr(state, "name", str(state))
     return {
         "levels_completed": int(getattr(frame, "levels_completed", 0) or 0),
         "win_levels": int(getattr(frame, "win_levels", 0) or 0),
-        "available_actions": tuple(getattr(frame, "available_actions", ()) or ()),
-        "state": str(getattr(frame, "state", "NOT_FINISHED")),
+        "available_actions": _action_names(
+            getattr(frame, "available_actions", ()) or ()),
+        "state": state,
     }
 
 

data/mock_env.py

@@ -302,6 +302,7 @@ def step_env(env, action_name: str, x: int | None = None, y: int | None = None):
     from arcengine import GameAction                          # official toolkit
 
     action = GameAction.from_name(action_name)
-    if action_name == "ACTION6" and x is not None:
-        return env.step(action, x=x, y=y)
+    if x is not None and y is not None and action.is_complex():
+        # official signature: step(action, data={"x": .., "y": ..})
+        return env.step(action, data={"x": int(x), "y": int(y)})
     return env.step(action)

eval_report_public25_cpu.json

@@ -0,0 +1,273 @@
+{
+  "meta": {
+    "title": "25 public ARC-AGI-3 games \u2014 local CPU sweep",
+    "backend": "tiny (v0.2.0 trained heads, checkpoints/qwenjev-s1)",
+    "device": "cpu (2 cores, 3GB RAM container)",
+    "max_actions": 40,
+    "games_expected": 25,
+    "engine": "arc-agi 0.9.9 OFFLINE mode, environment_files/ cache",
+    "timestamp": "2026-09-23 00:12:42",
+    "note": "harness validation + relative-comparison baseline; NOT the v2 hf model (2B fp16 needs >=8GB RAM; see train.md 8.2). GAME_OVER auto-reset within budget."
+  },
+  "games": [
+    {
+      "game_id": "ar25",
+      "win": false,
+      "final_state": "NOT_FINISHED",
+      "best_level": 0,
+      "resets": 0,
+      "actions": 40,
+      "seconds": 79.9,
+      "steps_per_s": 0.5
+    },
+    {
+      "game_id": "bp35",
+      "win": false,
+      "final_state": "NOT_FINISHED",
+      "best_level": 0,
+      "resets": 2,
+      "actions": 38,
+      "seconds": 67.6,
+      "steps_per_s": 0.56
+    },
+    {
+      "game_id": "cd82",
+      "win": false,
+      "final_state": "NOT_FINISHED",
+      "best_level": 0,
+      "resets": 0,
+      "actions": 40,
+      "seconds": 76.1,
+      "steps_per_s": 0.53
+    },
+    {
+      "game_id": "cn04",
+      "win": false,
+      "final_state": "NOT_FINISHED",
+      "best_level": 0,
+      "resets": 0,
+      "actions": 40,
+      "seconds": 74.1,
+      "steps_per_s": 0.54
+    },
+    {
+      "game_id": "dc22",
+      "win": false,
+      "final_state": "NOT_FINISHED",
+      "best_level": 0,
+      "resets": 0,
+      "actions": 40,
+      "seconds": 73.1,
+      "steps_per_s": 0.55
+    },
+    {
+      "game_id": "ft09",
+      "win": false,
+      "final_state": "NOT_FINISHED",
+      "best_level": 0,
+      "resets": 0,
+      "actions": 40,
+      "seconds": 65.7,
+      "steps_per_s": 0.61
+    },
+    {
+      "game_id": "g50t",
+      "win": false,
+      "final_state": "NOT_FINISHED",
+      "best_level": 0,
+      "resets": 0,
+      "actions": 40,
+      "seconds": 10.1,
+      "steps_per_s": 3.96
+    },
+    {
+      "game_id": "ka59",
+      "win": false,
+      "final_state": "NOT_FINISHED",
+      "best_level": 0,
+      "resets": 0,
+      "actions": 40,
+      "seconds": 73.3,
+      "steps_per_s": 0.55
+    },
+    {
+      "game_id": "lf52",
+      "win": false,
+      "final_state": "NOT_FINISHED",
+      "best_level": 0,
+      "resets": 0,
+      "actions": 40,
+      "seconds": 78.4,
+      "steps_per_s": 0.51
+    },
+    {
+      "game_id": "lp85",
+      "win": false,
+      "final_state": "NOT_FINISHED",
+      "best_level": 0,
+      "resets": 0,
+      "actions": 40,
+      "seconds": 67.1,
+      "steps_per_s": 0.6
+    },
+    {
+      "game_id": "ls20",
+      "win": false,
+      "final_state": "NOT_FINISHED",
+      "best_level": 0,
+      "resets": 0,
+      "actions": 40,
+      "seconds": 8.1,
+      "steps_per_s": 4.94
+    },
+    {
+      "game_id": "m0r0",
+      "win": false,
+      "final_state": "NOT_FINISHED",
+      "best_level": 0,
+      "resets": 0,
+      "actions": 40,
+      "seconds": 75.4,
+      "steps_per_s": 0.53
+    },
+    {
+      "game_id": "r11l",
+      "win": false,
+      "final_state": "NOT_FINISHED",
+      "best_level": 0,
+      "resets": 0,
+      "actions": 40,
+      "seconds": 67.9,
+      "steps_per_s": 0.59
+    },
+    {
+      "game_id": "re86",
+      "win": false,
+      "final_state": "NOT_FINISHED",
+      "best_level": 0,
+      "resets": 0,
+      "actions": 40,
+      "seconds": 10.1,
+      "steps_per_s": 3.96
+    },
+    {
+      "game_id": "s5i5",
+      "win": false,
+      "final_state": "NOT_FINISHED",
+      "best_level": 0,
+      "resets": 0,
+      "actions": 40,
+      "seconds": 65.9,
+      "steps_per_s": 0.61
+    },
+    {
+      "game_id": "sb26",
+      "win": false,
+      "final_state": "NOT_FINISHED",
+      "best_level": 0,
+      "resets": 0,
+      "actions": 40,
+      "seconds": 69.6,
+      "steps_per_s": 0.57
+    },
+    {
+      "game_id": "sc25",
+      "win": false,
+      "final_state": "NOT_FINISHED",
+      "best_level": 0,
+      "resets": 0,
+      "actions": 40,
+      "seconds": 75.1,
+      "steps_per_s": 0.53
+    },
+    {
+      "game_id": "sk48",
+      "win": false,
+      "final_state": "NOT_FINISHED",
+      "best_level": 0,
+      "resets": 0,
+      "actions": 40,
+      "seconds": 74.1,
+      "steps_per_s": 0.54
+    },
+    {
+      "game_id": "sp80",
+      "win": false,
+      "final_state": "NOT_FINISHED",
+      "best_level": 0,
+      "resets": 1,
+      "actions": 39,
+      "seconds": 72.2,
+      "steps_per_s": 0.54
+    },
+    {
+      "game_id": "su15",
+      "win": false,
+      "final_state": "NOT_FINISHED",
+      "best_level": 0,
+      "resets": 0,
+      "actions": 40,
+      "seconds": 65.8,
+      "steps_per_s": 0.61
+    },
+    {
+      "game_id": "tn36",
+      "win": false,
+      "final_state": "NOT_FINISHED",
+      "best_level": 0,
+      "resets": 0,
+      "actions": 40,
+      "seconds": 67.7,
+      "steps_per_s": 0.59
+    },
+    {
+      "game_id": "tr87",
+      "win": false,
+      "final_state": "NOT_FINISHED",
+      "best_level": 0,
+      "resets": 0,
+      "actions": 40,
+      "seconds": 8.1,
+      "steps_per_s": 4.94
+    },
+    {
+      "game_id": "tu93",
+      "win": false,
+      "final_state": "NOT_FINISHED",
+      "best_level": 0,
+      "resets": 0,
+      "actions": 40,
+      "seconds": 8.1,
+      "steps_per_s": 4.94
+    },
+    {
+      "game_id": "vc33",
+      "win": false,
+      "final_state": "NOT_FINISHED",
+      "best_level": 0,
+      "resets": 0,
+      "actions": 40,
+      "seconds": 67.2,
+      "steps_per_s": 0.6
+    },
+    {
+      "game_id": "wa30",
+      "win": false,
+      "final_state": "NOT_FINISHED",
+      "best_level": 0,
+      "resets": 0,
+      "actions": 40,
+      "seconds": 10.0,
+      "steps_per_s": 4.0
+    }
+  ],
+  "summary": {
+    "played": 25,
+    "wins": 0,
+    "best_level_sum": 0,
+    "resets_sum": 3,
+    "actions_sum": 997,
+    "seconds_sum": 1410.7,
+    "steps_per_s_median": 0.59
+  }
+}

ops/README.md

@@ -7,7 +7,8 @@
 
 | 文件 | 用途 | 运行位置 |
 |------|------|----------|
-| `run_eval.py` | **一键评测入口（v0.4.1）**：`hf:<repo>@<subpath>` 自动下载检查点 + 重组适配器（sha256 校验）→ 后端 auto（GPU→hf fp16+LoRA merge / 否则 tiny）→ 逐游戏对局 → 带 provenance 的 JSON 报告。`--games all25` 跑 25 公开游戏（缺 arc-agi 给出指引）；`--no-checkpoint --backend tiny` 即 CPU harness 测试 | 任意机器 |
+| `run_eval.py` | **一键评测入口（v0.4.2）**：`hf:<repo>@<subpath>` 自动下载检查点 + 重组适配器（sha256 校验）→ 后端 auto（GPU→hf fp16+LoRA merge / 否则 tiny）→ 逐游戏对局 → 带 provenance 的 JSON 报告。`--games all25` 跑 25 公开游戏；`--download-only` 预缓存游戏；`--list-games` 从 API 拉实时列表；`--env-dir` 指定游戏缓存目录；GAME_OVER 自动重置续玩（resets 入报告）；`--no-checkpoint --backend tiny` 即 CPU harness 测试 | 任意机器 |
+| `fetch_games.py` | **游戏预缓存引导（v0.4.2）**：从 arcade API（匿名 key，无需 Kaggle 账号/接受规则）拉取全部 25 公开游戏源码到 `environment_files/`（约 3MB / 65 秒），之后所有评测永久离线 | 任意机器 |
 | `t4_pipeline.py` | 冒烟流水线：env→code→data→smoke→stage_a→stage_b→stage_c→eval→assets→upload，断点续跑（done/ 戳 + 产物检查），阶段全部为隔离子进程（不许在桥接执行器进程里 import torch——上一窗口 7.8GB VRAM 泄漏的教训） | T4 VM，`subprocess.Popen` 脱离桥接进程 |
 | `t4_scale.py` | 正式规模流水线：collect 24×1200 → stage_b 120 步 → stage_c 120 行 → eval → 增量上传 `t4_assets_v2/`；扩参 YAML 内嵌，运行时写入 `configs/t4_scale.yaml` / `configs/collect_scale.yaml` | T4 VM |
 | `t4_smoke_s1.py` | 单次真实 2B 决策冒烟（预训练视觉塔前向 + 三头读出），由 t4_pipeline.py 的 code 阶段写入 repo 根目录 | T4 VM |
@@ -17,6 +18,19 @@
 | `push_t4_note.py` | 推送编译缓存审计注记与 t4_assets 复用指南（compile_cache_note.json / README.md） | 本地 |
 | `torch_kernels_t4.tar.gz` | torch NVRTC 内核缓存（`/root/.cache/torch/kernels/`，cc7.5 + CUDA 12.8 的 reduction_prod 预编译产物）。还原：`tar xzf torch_kernels_t4.tar.gz -C ~/.cache/` | 任意 T4 机器 |
 
+## 评测一键启动（v0.4.2 起，25 公开游戏）
+
+```bash
+pip install arc-agi                      # 官方本地引擎（PyPI，纯 Python）
+python ops/run_eval.py --download-only   # 一次性缓存 25 游戏（匿名 key，约 3MB）
+python ops/run_eval.py --games all25     # 全量：GPU→v2 检查点(hf+merge)；无 GPU→tiny
+python ops/run_eval.py --checkpoint <dir> --games ls20 --max-actions 120   # 本地检查点
+```
+
+- 检查点默认 `hf:tchbcb/qwenjev@t4_assets_v2/checkpoints`（qwenjev_s1.pt + hf_lora 分片自动下载/重组/校验）；
+- 本地 CPU（2 核 / 3GB 容器）已验证 25/25 游戏跑通（tiny + v0.2.0 训练头，中位 0.59 步/秒，报告 `eval_report_public25_cpu.json`）；hf 后端需 ≥8GB 内存（fp16 2B），详见 `../train.md` §8.2；
+- 汇报样例：`{game_id, win, final_state, best_level, resets, actions, seconds, steps_per_s}`。
+
 ## 典型复现路径
 
 ```bash

ops/fetch_games.py

@@ -0,0 +1,73 @@
+#!/usr/bin/env python3
+"""Bootstrap: cache all 25 public ARC-AGI-3 games locally (one-time, ~3 MB).
+
+    python ops/fetch_games.py                 # -> ./environment_files/
+    python ops/fetch_games.py --dir /data/env # custom cache dir
+    python ops/fetch_games.py --list          # live game list from the API
+
+After this every eval/collection run uses OperationMode.OFFLINE (zero
+network, unlimited instances). No Kaggle account or competition rules are
+required: the arcade API issues an anonymous key automatically. (The
+kagglehub competition download needs a KGAT token + accepted rules; this
+toolkit path does not.)
+"""
+from __future__ import annotations
+
+import argparse
+import sys
+import time
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(ROOT))
+
+DEFAULT_GAMES = [
+    "ar25", "bp35", "cd82", "cn04", "dc22", "ft09", "g50t", "ka59",
+    "lf52", "lp85", "ls20", "m0r0", "r11l", "re86", "s5i5", "sb26",
+    "sc25", "sk48", "sp80", "su15", "tn36", "tr87", "tu93", "vc33", "wa30",
+]
+
+
+def main() -> None:
+    ap = argparse.ArgumentParser(description=__doc__.splitlines()[0])
+    ap.add_argument("--dir", default=str(Path(__file__).resolve().parents[1] / "environment_files"))
+    ap.add_argument("--list", action="store_true", help="list games and exit")
+    args = ap.parse_args()
+
+    import arc_agi
+    from arc_agi import OperationMode
+
+    arc = arc_agi.Arcade(operation_mode=OperationMode.NORMAL,
+                         environments_dir=args.dir)
+    try:
+        live = [e.game_id.split("-")[0] for e in arc.get_environments()]
+    except Exception as exc:
+        print(f"[warn] API listing failed ({exc}); using static list")
+        live = DEFAULT_GAMES
+    ids = live or DEFAULT_GAMES
+
+    if args.list:
+        print("\n".join(ids))
+        print(f"-- {len(ids)} games available from the arcade API", file=sys.stderr)
+        return
+
+    print(f"cache dir: {args.dir}; {len(ids)} games")
+    ok, fail = [], []
+    for gid in ids:
+        t0 = time.time()
+        try:
+            env = arc.make(gid)
+            if env is None:
+                raise RuntimeError("make() returned None")
+            ok.append(gid)
+            print(f"  {gid}: OK ({time.time() - t0:.1f}s)", flush=True)
+        except Exception as exc:
+            fail.append(gid)
+            print(f"  {gid}: FAIL {type(exc).__name__}: {exc}", flush=True)
+
+    print(f"downloaded={len(ok)} failed={len(fail)}" + (f" {fail}" if fail else ""))
+    sys.exit(1 if fail else 0)
+
+
+if __name__ == "__main__":
+    main()

ops/run_eval.py

@@ -115,7 +115,13 @@ def main() -> None:
     ap.add_argument("--backend", default="auto", choices=["auto", "hf", "tiny"])
     ap.add_argument("--games", nargs="*", default=["mock"],
                     help="mock | all25 | explicit game ids (space separated)")
-    ap.add_argument("--list-games", action="store_true")
+    ap.add_argument("--list-games", action="store_true",
+                    help="list the public games (live from the arcade API) and exit")
+    ap.add_argument("--download-only", action="store_true",
+                    help="cache all 25 game sources locally, then exit")
+    ap.add_argument("--env-dir", default=None,
+                    help="game cache dir (default: ./environment_files, "
+                         "overridden by ARC_ENVIRONMENTS_DIR)")
     ap.add_argument("--max-actions", type=int, default=300)
     ap.add_argument("--out", default="eval_report.json")
     ap.add_argument("--cache", default=str(Path.home() / ".cache" / "qwenjev_eval"))
@@ -123,10 +129,26 @@ def main() -> None:
                     help="skip checkpoint entirely (untrained heads / harness test)")
     args = ap.parse_args()
 
+    if args.env_dir:
+        import os
+        os.environ["ARC_ENVIRONMENTS_DIR"] = args.env_dir
+
     from data.collect_selfplay import PUBLIC_GAMES_FALLBACK
     if args.list_games:
-        print("\n".join(PUBLIC_GAMES_FALLBACK))
+        try:
+            import arc_agi
+            from arc_agi import OperationMode
+            arc = arc_agi.Arcade(operation_mode=OperationMode.NORMAL)
+            live = [e.game_id.split("-")[0] for e in arc.get_environments()]
+        except Exception:
+            live = []
+        print("\n".join(live or PUBLIC_GAMES_FALLBACK))
         return
+    if args.download_only:
+        import subprocess
+        r = subprocess.run([sys.executable, str(ROOT / "ops" / "fetch_games.py")]
+                           + (["--dir", args.env_dir] if args.env_dir else []))
+        sys.exit(r.returncode)
 
     games: list[str] = []
     for g in args.games:
@@ -143,10 +165,10 @@ def main() -> None:
             raise SystemExit(
                 "[error] real games need the official offline engine:\n"
                 "  pip install arc-agi   (PyPI, pure-python engine)\n"
-                "  + the competition's environment_files/ (Kaggle Data page:\n"
-                "    arc-prize-2026-arc-agi-3). Run from the directory holding\n"
-                "    environment_files/ or export ARC_ENVIRONMENTS_DIR=/path/to it.\n"
-                "On Kaggle the data is attached automatically; see train.md §4.1.")
+                "Game sources are then fetched automatically on first use "
+                "(anonymous arcade key, no Kaggle account needed) and cached "
+                "in ./environment_files/ — or pre-cache them with:\n"
+                "  python ops/fetch_games.py")
 
     backend = pick_backend(args.backend)
     ckpt_dir = None if args.no_checkpoint else resolve_checkpoint(args.checkpoint, Path(args.cache))
@@ -179,35 +201,46 @@ def main() -> None:
     brain = HybridAgent(s1=s1, s2=None,
                         config=HybridConfig(game_time_limit_s=600))
 
+    def write_report(report: list, t0: float) -> dict:
+        """Atomically dump the report; called after EVERY game so a Colab
+        disconnect mid-run keeps all completed results."""
+        out = {
+            "meta": {
+                "backend": backend,
+                "checkpoint": args.checkpoint if not args.no_checkpoint else "none",
+                "games": games,
+                "max_actions": args.max_actions,
+                "seconds_total": round(time.time() - t0, 1),
+                "timestamp": time.strftime("%F %T"),
+            },
+            "games": report,
+            "summary": {
+                "played": len(report),
+                "wins": sum(1 for r in report if r["win"]),
+                "best_level_sum": sum(r["best_level"] for r in report),
+                "actions_sum": sum(r["actions"] for r in report),
+            },
+        }
+        tmp = Path(args.out + ".tmp")
+        tmp.write_text(json.dumps(out, indent=2))
+        tmp.replace(args.out)
+        return out
+
     from data.collect_selfplay import make_env
     report, t0 = [], time.time()
+    write_report(report, t0)  # header-only report, proves out path works
     for game_id in games:
         try:
             env = make_env(game_id, None)
             res = run_game(env, game_id, brain, max_actions=args.max_actions)
+            res["steps_per_s"] = round(res["actions"] / max(res["seconds"], 0.1), 2)
             report.append(res)
             log(f"{game_id}: {res}")
         except Exception as exc:
-            log(f"[warn] {game_id}: {exc}")
+            log(f"[warn] {game_id}: {type(exc).__name__}: {exc}")
+        write_report(report, t0)
 
-    out = {
-        "meta": {
-            "backend": backend,
-            "checkpoint": args.checkpoint if not args.no_checkpoint else "none",
-            "games": games,
-            "max_actions": args.max_actions,
-            "seconds_total": round(time.time() - t0, 1),
-            "timestamp": time.strftime("%F %T"),
-        },
-        "games": report,
-        "summary": {
-            "played": len(report),
-            "wins": sum(1 for r in report if r["win"]),
-            "best_level_sum": sum(r["best_level"] for r in report),
-            "actions_sum": sum(r["actions"] for r in report),
-        },
-    }
-    Path(args.out).write_text(json.dumps(out, indent=2))
+    out = write_report(report, t0)
     log(f"done: {out['summary']} -> {args.out}")
 
 

ops/t4exec.py

@@ -10,11 +10,14 @@ Commands:
 """
 import base64
 import json
+import os
 import sys
 import urllib.request
 import zlib
 
-URL = "https://aitun.cc/DED976KN"
+# Tunnel endpoint: override with `export T4_URL=https://aitun.cc/XXXX` when a
+# new tunnel code is issued (aitun URLs rotate every Colab session).
+URL = os.environ.get("T4_URL", "https://aitun.cc/ZMPBD8M2")
 CRC_MODE = None  # auto-detected against known-good envelope
 
 
@@ -27,19 +30,19 @@ def b64d(s: str) -> bytes:
 
 
 def _crc(p_b64: str, raw: bytes) -> str:
-    if CRC_MODE == "raw":
-        return format(zlib.crc32(raw) & 0xFFFFFFFF, "08x")
-    return format(zlib.crc32(p_b64.encode()) & 0xFFFFFFFF, "08x")
+    # Server-side check verified live: crc32 of the DECODED payload (raw code
+    # bytes), NOT of the b64 text. 'print(123, 456)' -> crc c03b37d5 accepted.
+    return format(zlib.crc32(raw) & 0xFFFFFFFF, "08x")
 
 
 def envelope(code: str) -> bytes:
+    # NOTE: payload must be a SINGLE b64url line. The 76-char wrapped form is
+    # in the spec but the current relay corrupts multi-line payloads
+    # (crc mismatch server-side) — single-line verified against crc 9e30c354.
     raw = code.encode()
     p = b64u(raw)
-    lines = ["samaicmdbegin", "v=1", "enc=b64url", "crc=" + _crc(p, raw)]
-    for i in range(0, len(p), 76):
-        lines.append(p[i : i + 76])
-    lines.append("samaicmdend")
-    return ("\n".join(lines) + "\n").encode()
+    head = f"samaicmdbegin\nv=1\nenc=b64url\ncrc={_crc(p, raw)}\n"
+    return (head + p + "\nsamaicmdend\n").encode()
 
 
 def _detect_crc():

scripts/push_hf.py

@@ -58,7 +58,7 @@ def main() -> None:
         repo_type="model",
         folder_path=str(REPO_ROOT),
         ignore_patterns=ignore_patterns,
-        commit_message="QwenJev v0.2.0: vision tower on the System-1 inference path (tiny/hf backends, mock env, e2e local run)",
+        commit_message="QwenJev v0.4.3: 25-public-games eval in-repo (run_eval incremental report, fetch_games, CPU feasibility verified)",
     )
     api.update_repo_settings(repo_id=args.repo, repo_type="model", private=False)
     print(f"public repo ready -> https://huggingface.co/{args.repo}")

train.md

@@ -4,13 +4,6 @@
 > 按顺序读完即可独立复现整个系统。README 按要求留空，所有内容都在本文档中。
 > **v0.2.0 架构决策：视觉塔必保留在 System-1 每步推理路径上**——隐藏关全是陌生机制，
 > 只看 hex 文本串没法玩游戏；本仓库的 System-1 骨干直接是多模态模型，每步都"看"当前帧。
-> **v0.3.0 架构决策：概率必须诚实（吸收自 Laya）**——one-hot CE 只保证 argmax 对，
-> 不保证概率可被依赖；Stage C 用严格 proper scoring rule 重训置信度，
-> 温度按桶拟合后钉死在 [0.5, 5.0]，调度器新增"学习型唤醒"。详见 §1.4 与 §5.1。
-> **v0.4.0 实战验证：T4 (16GB) 真机全流水线两轮全绿**——真实 Qwen3-VL-2B 学生（预训练视觉塔
-> 每步在环、冻结不训）+ 4bit 视觉教师蒸馏 + QLoRA 三阶段 + RLCD 校准；权重/适配器/
-> 离线 wheels/NVRTC 内核缓存全部沉淀在 HF `t4_assets/`，换机复现零编译、最少下载。
-> 详见 §11.2（两轮速览）、§12（实战复盘）与 §13（离线复现包）。
 
 ---
 
@@ -45,27 +38,6 @@ ARC Prize 2026（ARC-AGI-3）要求智能体在**从未见过的交互式游戏
 - 沿用其训练配方：complete-question 交叉熵，backbone lr `1e-5`、decision-head lr `1e-4`。
 - 差异点：① state 序列化改为**版本化规范串**（原作审计文档承认 `str()` 序列化非规范，属遗留问题）；② **叶子多模态化——视觉塔每步在环**；③ 增加 ACTION6(x,y) 的候选离散化；④ 外层接 ARC-AGI-3 环境与双系统调度。
 
-### 1.4 对标 Laya：吸收了什么、没吸收什么（v0.3.0）
-
-Laya（Convai Innovations，Apache-2.0）是与 Jev/NanoJev 线格式兼容的**非自回归** System-1 决策模型：ModernBERT-large 421M 双向编码器 + 选项标记打分头，单次前向答完全部问题（T4 上 ~33ms，约为 TypeSafe Jev 的 1/7），并用 RLCD 把期望校准误差（ECE）压到 Jev 的 1/3（0.081 vs 0.246）。调研仓库：`NandhaKishorM/laya`（Python 侧）+ `receptron/laya`（Node/ONNX 侧）+ 三份模型卡。
-
-**吸收进 QwenJev 的（按影响力排序）：**
-
-| # | 技术 | Laya 原样 | QwenJev 落点 |
-|---|------|-----------|--------------|
-| 1 | **RLCD 校准训练** | GRPO 式组采样（零均值投影噪声 σ 0.4→0.1 退火）+ 严格 proper scoring rule（log+spherical+RPS）+ 全权重 soft-CE 锚定 argmax | Stage C `train/calibrate_rlcd.py`，在 Stage B 之后对三族头重训置信度 |
-| 2 | **温度按桶拟合** | 训练后 LBFGS 拟合每 (题型, 选项数桶) 一个温度，推理端 `clamp [0.5, 5.0]`，拒绝"把 0.24 锐化成 0.99"的不诚实温度（他们上线后补的丁） | `qwenjev/calibration.py`：`fit_temperature` + `temp_bucket` + `clamp_temperature`；温度表随 checkpoint 保存，`forward_choice` 推理路径自动应用 |
-| 3 | **归一化熵置信度** | `1 − H(p)/log k`，跨题可比 | `confidence_from_probs`，成为调度器比较"7 动作步"与"60 候选步"的统一标尺 |
-| 4 | **act/escalate 头** | `[top1, top1−top2, 熵, k/255]` 四特征 → 升级概率（他们 fine-tune notebook 里系数为 0，**实际上没训**） | Stage C 用"argmax 会错"标签**真正训练**该头；调度器新增学习型唤醒（§3.6） |
-| 5 | **选项顺序置换** | `build_sequence(option_order=...)` | Stage B 每轮对候选随机置换并同步标签，消除 set-attention 的隐性位置捷径 |
-
-**不吸收的，以及为什么（Laya 的基准数据反过来验证了 QwenJev 的既有选择）：**
-
-- **选项标记打分头**：Laya 把 head_max_len（192–256 token）按选项数均摊，77 选项的 Banking77 每个标签只分到 3–4 token，精度崩到 0.425（Jev 0.870）。我们的 set-attention 逐候选打分没有这个预算问题——ARC 候选池经常 50–255 个，这正是 NanoJev 路线胜过 Laya 的核心场景，**保持不变**。
-- **多语 router / 多 checkpoint 派发**：游戏 state 是单一规范串，无多语需求。
-- **ModernBERT 双向骨干**：替换成本高且丢掉与 NanoJev 权重/配方的兼容；其单向→双向的加速收益已由"零输出 token"设计覆盖。
-- **零样本期望**：Laya 模型卡自己承认 base checkpoint 在 typed-decisions 上接近随机（0.362 vs 随机 0.318），能力来自领域微调——与我们的"公开关自采 + 每关特化"路线一致，无需照搬其权重。
-
 ---
 
 ## 2. 总体架构
@@ -149,10 +121,10 @@ ACTION6(x,y) 是唯一带坐标的动作，必须离散化才能进 Choice 头
 ### 3.4 System-1 `qwenjev/system1.py`
 
 - `encode_question(state, candidates, instruction, grid)` → N 个多模态叶子（每候选一个，state 重复，**当前帧图像共享**）；
-- `forward_choice(leaves)` → **一次 backbone 前向（含视觉塔）**：叶子向量 → 投影 → set-attention（同题候选间）→ 温度除法（v0.3.0：Stage C 温度表按 `choice:2/3-5/6-10/11+` 桶查找，空表=未校准恒等于 1.0）→ softmax → 概率列��；
-- `choose(..., grid)` → 贪心或按分布采样，返回 `Decision(probs, candidates, chosen, index, confidence, escalate_p)`——后两个是 v0.3.0 新增的校准读数：归一化熵置信度 + 学习型升级概率（escalate 头与视觉塔共享同一次前向，零额外开销）；
+- `forward_choice(leaves)` → **一次 backbone 前向（含视觉塔）**：叶子向量 → 投影 → set-attention（同题候选间）→ softmax → 概率列表；
+- `choose(..., grid)` → 贪心或按分布采样，返回 `Decision(probs, candidates, chosen, index)`；
 - `forward_boolean` / `forward_score` 及其**可训练孪生** `forward_boolean_logits` / `forward_score_logits`（v0.2.0 修复：旧实现返回 detach 张量，梯度根本流不进模型）；
-- `save()` / `load_heads()`：tiny 后端打包 backbone + 全部头（含 escalate 头与温度表，旧 checkpoint 无这些字段也能加载）；hf 后端只存头（权重留在 HF 权重目录）；
+- `save()` / `load_heads()`：tiny 后端打包 backbone + 全部头；hf 后端只存头（权重留在 HF 权重目录）；
 - `eval()` / `train_mode()`：决策头 dropout=0，保证加载后推理确定。
 
 ### 3.5 System-2 `qwenjev/system2.py`
@@ -166,14 +138,11 @@ ACTION6(x,y) 是唯一带坐标的动作，必须离散化才能进 Choice 头
 
 System-2 唤醒条件（满足其一，且调用数 < `system2_max_calls_per_game`）：
 
-| 条件 | 含义 | 类型 |
-|------|------|------|
-| 新帧哈希 | 局面没见过，需要 9B 看一眼 | 环境侧（手写） |
-| `levels_completed` 增加 | 进新关卡，机制可能变 | 环境侧（手写） |
-| 连续 12 步无变化 | System-1 卡死，需要外部视角 | 环境侧（手写） |
-| `escalate_p ≥ 0.70` 或校准置信度 ≤ 0.15 | System-1 自报"我要错/我没底"，触发**当步有界重规划**（S2 建议→重打分→仅当更自信才采纳） | 模型侧（学习型，v0.3.0） |
-
-前三个条件盯着**环境**，第四个盯着**模型自己**—— Stage C 把概率校准好之后，"更自信才采纳"这个比较才有意义；未校准的置信度之间不可比，这正是 Laya 基准里 Jev 被 ECE 0.246 拖累的教训。
+| 条件 | 含义 |
+|------|------|
+| 新帧哈希 | 局面没见过，需要 9B 看一眼 |
+| `levels_completed` 增加 | 进新关卡，机制可能变 |
+| 连续 12 步无变化 | System-1 卡死，需要外部视角 |
 
 同时管理：每局时间预算（默认 900s，官方文档明确超时会直接 fail 该次运行）、动作数上限、动作-效果记忆（哪个动作改变多少格）、每局反思笔记。
 
@@ -183,10 +152,11 @@ System-2 唤醒条件（满足其一，且调用数 < `system2_max_calls_per_gam
 
 ## 4. 数据管线
 
-### 4.1 来源：25 个公开游戏自采（已确认可用）
+### 4.1 来源：25 个公开游戏自采（已确认可用，2026-09-23 实测）
 
-- 比赛官方 Data 页自带 `environment_files/`（25 个公开游戏文件，Apache 2.0），`arc-agi` 包离线模式本地跑：**约 2000 FPS、无限实例、无需 API key**；
-- 游戏清单（与 arcprize.org/tasks 一致）：`ar25 bp35 cd82 cn04 dc22 ft09 g50t ka59 lf52 lp85 ls20 m0r0 r11l re86 s5i5 sb26 sc25 sk48 sp80 su15 tn36 tr87 tu93 vc33 wa30`；
+- 游戏源码从 arcade API 自动获取：`arc-agi` 包 NORMAL 模式 `make()` 会把游戏源码（单游戏约 120KB）缓存到 `environment_files/<game_id>/<version>/`，之后永久离线（OFFLINE 模式约 2000 FPS、无限实例）；**匿名 key 自动下发，无需 Kaggle 账号、无需接受比赛规则**。一键预缓存：`python ops/fetch_games.py`（25 游戏约 65 秒）；
+- kagglehub 比赛下载（`kagglehub.competition_download('arc-prize-2026-arc-agi-3')`）需要 KGAT token + 官网接受规则，且与本地游戏引擎是同一套（`arc-agi` 包本地托管同引擎）——本仓评测链路已不依赖它；
+- 游戏清单（与 arcprize.org/tasks 一致，`ops/run_eval.py --list-games` 可从 API 拉实时列表）：`ar25 bp35 cd82 cn04 dc22 ft09 g50t ka59 lf52 lp85 ls20 m0r0 r11l re86 s5i5 sb26 sc25 sk48 sp80 su15 tn36 tr87 tu93 vc33 wa30`；
 - **评测是另外 110 个从未公开的隐藏游戏**（55 个 Public LB + 55 个 Private LB），所以数据管线的一切设计都服务于"可泛化的探索先验"，而非背题。
 
 ### 4.2 采集 `data/collect_selfplay.py`
@@ -219,15 +189,14 @@ ARC 传统增广全部可用：转置/镜像/旋转/重着色（固定 0=背景
 
 ## 5. 训练方案
 
-### 5.1 三阶段配方
+### 5.1 两阶段配方
 
 **Stage A：视觉蒸馏对齐**（`train/distill_alignment.py`）
 
 - 教师：冻结的多模态模型，**同一帧真实过其视觉塔**（hf 后端：processor 构造 `pixel_values` 进模型前向；tiny 后端：教师 TinyVLM 同样吃图像张量）——绝不允许出现"蒸馏时没看图"的假对齐（v0.1 的占位符实现已废弃）；
 - 学生：System-1 多模态骨干，同样图像+文本前向，取逐层隐状态池化；
 - 对齐层集隐状态（默认最后 2 层）���`1 − cosine` 损失，逐层独立投影头；
-- 产物：`checkpoints/qwenjev-s1/stage_a.pt`（投影头 + tiny 学生权重），Stage B 自动加载；
-- **T4 (16GB) 口径（v0.4.0 实测）**：教师换 `Qwen3-VL-4B-Instruct`（NF4 ≈3.5GB）——9B 教师的 fp16 embed/lm_head 单这两项就 8.2GB，与 QLoRA 学生同卡必 OOM；学生同样 4bit，LoRA `exclude_vision: true`（预训练视觉塔冻结不训）。96GB 卡仍用 9B 教师。
+- 产物：`checkpoints/qwenjev-s1/stage_a.pt`（投影头 + tiny 学生权重），Stage B 自动加载。
 
 **Stage B：决策头 SFT**（`train/train_system1.py`）
 
@@ -241,25 +210,6 @@ ARC 传统增广全部可用：转置/镜像/旋转/重着色（固定 0=背景
 
 **v0.2.0 训练修复清单**（旧代码静默失效的三处）：① Boolean/Score 头改用可训练 logits 孪生方法，BCE/CE 梯度真正流进模型；② Choice 批训练改用带图前向（旧行为在 `torch.no_grad()` 里算概率再包装，同样训不动）；③ Stage A checkpoint 自动加载，蒸馏成果不白费。
 
-**Stage C：RLCD 校准 + 温度拟合**（`train/calibrate_rlcd.py`，v0.3.0 新增，吸收自 Laya）
-
-Stage B 的 one-hot CE 只优化 argmax；学到的概率分布可以（也通常会）过度自信——对人类步数取平方惩罚的 RHAE 而言，"自信地错"比"不确定"代价更高。Stage C 分三步把概率变诚实：
-
-1. **RLCD 重训**：对每题采样 G=4 组零均值投影噪声扰动 logits（σ 0.4→0.1 退火），以严格 proper scoring rule（log + spherical 0.75 + 有序题 RPS 1.0）打分，组内标准化优势做 REINFORCE；同时保留全权重 soft-CE 锚定项，**校准不牺牲 argmax 精度**（Laya 实测 fine-tune 后 0.766 反超其 0.735 教师上限，靠的就是这个锚定）。
-2. **温度按桶拟合**：在 val 切分上，每 (题型， 选项数桶) 用 LBFGS 拟合一个温度（软目标），应用时 `clamp [0.5, 5.0]`——低于 0.5 属于"把 0.24 发布成 0.99"的不诚实锐化，拒绝应用。温度表写进 checkpoint 配置，推理路径自动生效。
-3. **escalate 头真正训练**：以"当前 argmax 是否等于标签"构造监督信号，在最终温度下训练 3 轮；Laya 的同名头在官方 fine-tune notebook 里系数为 0（未训练），这里补上了他们没做的一步。
-
-产物：更新后的 `qwenjev_s1.pt`（含温度表）+ `calib_report.json`（拟合温度 + 校准前后 ECE）。
-
-| Stage C 超参 | 默认值 | 说明 |
-|------|-----|------|
-| epochs / group_size | 2 / 4 | RLCD 轮数 / GRPO 组大小 |
-| σ 退火 | 0.4 → 0.1 | 探索噪声线性退火（Laya 同款） |
-| lr_backbone / lr_head | 2.5e-5 / 1e-4 | Laya 微调配方 |
-| ce_guidance | 1.0 | soft-CE 锚定权重（勿调低，防校准吃掉精度） |
-| w_sph / w_rps | 0.75 / 1.0 | proper reward 权重（Laya 同款） |
-| max_choice_rows / max_aux_rows | 600 / 100 | CPU 单机友好上限；GPU 可放大 |
-
 ### 5.2 显存预算（RTX Pro 6000 96GB 实测口径）
 
 | 场景 | 占用估算 |
@@ -271,18 +221,6 @@ Stage B 的 one-hot CE 只优化 argmax；学到的概率分布可以（也通
 
 消费级 24GB 卡（4090/3090）建议：教师 4bit + 学生 LoRA；tiny 后端则任意机器（含无 GPU 笔记本，~1.1M 参数 fp32 ≈ 5MB）都能跑。
 
-**T4 (16GB) 实测口径（v0.4.0，`configs/t4_smoke.yaml`）**：
-
-| 场景 | 实测 | 备注 |
-|------|------|------|
-| 真实 2B 单次决策（4bit 基座 + 视觉塔前向） | 4.24 GB | 10.4 s/次（首跑含内核加载） |
-| Stage A：4B 教师 NF4 + 2B QLoRA 学生 | — | ~10 s/步 × 120 步，align_loss → 0.026 |
-| Stage B：QLoRA SFT（leaf_batch=2 × max_candidates=4） | ~9.7 GB，GPU 99% | 冒烟 ~38 s/步 × 20 步；正式规模 ~5.5 s/步 × 120 步 |
-| Stage C：RLCD（freeze_backbone，仅适配器可训） | 峰值 5.55 GB | ECE 0.5134 → 0.4242（正式规模 120 行） |
-
-> `leaf_batch_size` 与 `max_candidates` 是 T4 的两个 OOM 旋钮：反向图在整行 backward 前
-> 按 chunk 累积（每 2-leaf chunk ≈2.3GB 实测），8 候选 = 4 chunk = OOM，4 候选 = 2 chunk ≈4.6GB 才放得下。
-
 ### 5.3 下载权重
 
 ```bash
@@ -352,28 +290,36 @@ cd kaggle_kernel && kaggle kernels push -p .
 
 ## 8. 评测与迭代
 
+### 8.1 一键评测（v0.4.2 起：`ops/run_eval.py`）
+
 ```bash
-make eval          # 本地跑公开游戏，输出完成度/步数/耗时 JSON 报告
+pip install arc-agi                        # 官方本地引擎（PyPI，纯 Python）
+python ops/run_eval.py --download-only     # 一次性缓存 25 公开游戏（约 3MB，匿名 key）
+python ops/run_eval.py --games all25       # 全量评测：GPU→hf 后端自动拉 HF 检查点并 merge LoRA；无 GPU→tiny
+python ops/run_eval.py --games ls20 --max-actions 60     # 指定游戏 + 预算
+python ops/run_eval.py --backend tiny --no-checkpoint --games mock --max-actions 60   # 纯 harness 冒烟
+python ops/run_eval.py --checkpoint /path/to/dir --games ...   # 本地检查点目录（qwenjev_s1.pt [+ hf_lora/]）
 ```
 
-**一键评测入口（v0.4.1 新增）：`ops/run_eval.py`**——评测也进了仓，下次零手工步骤：
+- 检查点解析（默认 `hf:tchbcb/qwenjev@t4_assets_v2/checkpoints`）：自动下载 qwenjev_s1.pt + hf_lora 分片 → `parts/reassemble` 重组 → sha256 校验 → 后端 auto 决定 hf（fp16 基座 + LoRA merge，与训练同构）或 tiny；
+- 生命周期：WIN 结束本局；GAME_OVER 触发 `brain.on_game_over` + 自动重置续玩（同一动作预算内公平比较，`resets` 入报告）；
+- 报告字段：`win / final_state / best_level / resets / actions / seconds / steps_per_s`，默认写 `eval_report.json`（`--out` 改路径）；
+- `--list-games` 从 arcade API 拉实时游戏列表（静态清单兜底）。
 
-```bash
-python ops/run_eval.py                # 默认：HF 拉取 t4_assets_v2 终模型 → 自动选后端 → mock 对局
-python ops/run_eval.py --games all25  # 25 个公开游戏（需 arc-agi 包 + environment_files，缺包直接报错并给指引）
-python ops/run_eval.py --backend tiny --no-checkpoint --max-actions 60   # 无 GPU 机器 harness 测试
-python ops/run_eval.py --checkpoint /本地目录            # 已有本地检查点免下载
-make eval-v2                          # 同第一条（Makefile 目标）
-make eval-25                          # 同第二条
-make eval-cpu                         # 同第三条
-```
+### 8.2 本地 CPU 能不能跑？（2026-09-23，2 核 / 3GB 容器实测）
+
+| 配置 | 可行性 | 实测/推算依据 |
+|---|---|---|
+| tiny 后端 + v0.2.0 训练头（128 维） | ✅ 完整评测 | 25 游戏全部跑通（40 步/游戏），0.5–4 步/秒（快慢取决于 ACTION6 候选数） |
+| tiny 后端 + v2 检查点 | ❌ 维度不匹配 | v2 头是 2048 维（hf 隐藏维），tiny 骨干是 128 维 |
+| hf 后端（Qwen3-VL-2B fp16） | ⚠️ 需 ≥8GB 内存 | 基座权重 ~4.4GB + 三头 254MB（fp32, 63.5M 参数）+ 激活；本 3GB 容器物理不可行；bitsandbytes 4bit 仅限 CUDA，CPU 无替代 |
+| hf 后端（GPU：T4 16GB） | ✅ 已验证 | fp16 基座 + merge 后 300 步 601.6s（§11.2 v2 eval） |
 
-入口自动完成：① 从 HF 下载 `qwenjev_s1.pt` + `hf_lora` 分片并**重组适配器**（sha256 校验，§12.5 方案）；
-② 后端 auto 选择（有 CUDA → hf fp16 基座 + LoRA merge；否则 tiny）；③ 逐游戏跑 HybridAgent
-（System-1 加载失败自动降级启发式策略，不中断）；④ 报告含 provenance（后端/检查点来源/耗时/时间戳）。
-检查点解析支持 `hf:<repo>@<子路径>`、本地目录、`none` 三种形式；25 游戏清单见 `--list-games`。
+- CPU 评测的检查点是 `checkpoints/qwenjev-s1/`（v0.2.0 时代 128 维 tiny 头 + backbone，`load_heads` 向后兼容：escalate/温度表缺省跳过）；其结论只用于 harness 验证与横向对比，不代表 v2 模型水平；
+- 4bit 量化在 CPU 上不可用（bitsandbytes 依赖 CUDA），若要在 CPU 跑真 2B 建议在 ≥16GB 内存机器用 fp16（`--backend hf` 会自动走 `resume_adapters(merge=True)`）；
+- 提速方向：调小候选池（`build_candidates` 的 ACTION6 锚点数）或调大 `eval_leaf_batch`。
 
-- 官方正式指标 RHAE = 按关卡 `min(人类步数/智能体步数, 1.0)²` 加权平均，人类基线本地拿不到——所以评测的绝对分数**只用于横向比较不同版本的智能体**，不代表排行榜；
+- 官方正式指标 RHAE = 按关卡 `min(人类步数/智能体步数, 1.0)²` 加权平均，人类基线本地拿不到——所以 `evaluate_local.py` 的绝对分数**只用于横向比较不同版本的智能体**，不代表排行榜；
 - 迭代循环：改 `agent/my_agent.py`（或 hybrid 配置）→ 本地秒级验证 → 满意后再花 Kaggle Commit；
 - 关注三条曲线：完成率（WIN 数）、平均步数、System-2 调用次数。好方向的标志是**完成率升、System-2 调用降**。
 
@@ -385,12 +331,11 @@ make eval-cpu                         # 同第三条
 |--------|------|----------|------|
 | M0 | 仓库骨架 + 单测 + 文档 | `make test` 全绿 | ✅ |
 | M1 | **本地全链路跑通**：mock 游戏 → 采集 → 建库 → Stage A 蒸馏 → Stage B 训练 → 评测（视觉塔全程在环） | `make smoke` 五环节全绿，蒸馏 loss 收敛，36 个单测通过 | ✅ |
-| M1.5 | **Stage C 校准**（吸收 Laya）：RLCD + 温度按桶拟合 + escalate 头训练，调度器学习型唤醒 | 51 个单测通过，校准 ECE 报告产出，`make smoke` 六环节全绿 | ✅ |
-| M2 | 换 hf 后端：Qwen3-VL-2B 学生 + 4B 教师（T4）/ 9B 教师（96GB），25 公开游戏真实采集 | Choice 标签集 ≥ 5 万题，公开关 eval 完成率显著高于随机基线 | 🔶 T4 真机两轮全绿（mock 口径，§12）；公开游戏采集待 arc-agi 环境 |
-| M3 | System-2 接入 + 调度调参（重点：escalate 阈值 0.70/0.15 按真实关数据校准） | 完成率升 & 9B 调用数下降 | |
+| M2 | 换 hf 后端：Qwen3-VL-2B 学生 + 9B 教师，25 ��开游戏真实采集 | Choice 标签集 ≥ 5 万题，公开关 eval 完成率显著高于随机基线 | |
+| M3 | System-2 接入 + 调度调参 | 完成率升 & 9B 调用数下降 | |
 | M4 | Kaggle 打包提交 | 官方 LB 出分，进入迭代循环 | |
 
-后续方向：共享前缀推理提速、tiny 骨干 ONNX 导出（借鉴 receptron/laya 的纯 CPU 运行时，Kaggle Code 禁网环境受益）、把 Score 头升级为学习型局面价值模型。
+后续方向：RLCD 后训练（NanoJev 官方 roadmap 同款）、共享前缀推理提速、把 Score 头升级为学习型局面价值模型。
 
 ---
 
@@ -410,29 +355,18 @@ make eval-cpu                         # 同第三条
 
 ```bash
 make setup        # 环境安装（Python 3.12+）
-make test         # 单测 51 个（纯 CPU，零下载）
-make smoke        # 一键本地跑通：mock采集→建库→蒸馏→训练→校准→评测（无GPU可用）
+make test         # 单测 36 个（纯 CPU，零下载）
+make smoke        # 一键本地跑通：mock采集→建库→蒸馏→训练→评测（无GPU可用）
 make collect      # 自博弈采轨迹（mock 游戏 / 25 公开游戏）
 make build-data   # 轨迹 → Choice/Boolean/Score 训练样本（含 grid 帧字段）
 make distill      # Stage A：9B 教师 → System-1 学生 视觉蒸馏对齐
 make train-s1     # Stage B：决策头 SFT（NanoJev 配方，自动加载 stage A）
-make calibrate    # Stage C：RLCD 校准 + 温度按桶拟合 + escalate 头（v0.3.0）
 make eval         # 本地评测（mock 游戏默认）
 make push-hf      # 推送本仓库到 HuggingFace（HF_TOKEN 从环境读）
 python scripts/download_weights.py                     # 拉权重
 python scripts/serve_system2.py --port 8000            # 9B 端点（transformers 兜底）
 # vllm serve Qwen/Qwen3.5-9B --port 8000               # 9B 端点（首选）
 python scripts/package_kaggle.py --username XXX --accelerator rtx6000
-
-# —— T4 真机运维（ops/ 工具箱，v0.4.0）——
-python ops/t4exec.py status                    # 隧道健康检查（URL 在文件头改）
-python ops/t4exec.py run "print(40+2)"         # 信封自检（期望 42）
-python ops/t4exec.py put ops/t4_pipeline.py /content/qwenjev_work/t4_pipeline.py
-
-# —— 离线装配（新 T4 机器：免编译、除 torch 外免下载）——
-pip install torch==2.11.0                                              # PyPI 默认即 cu128
-pip install --no-index --find-links t4_assets/wheels/ -r requirements.txt
-tar xzf t4_assets/compile_cache/torch_kernels_t4.tar.gz -C ~/.cache/   # 还原 NVRTC 内核缓存（可选）
 ```
 
 ### 11.1 本地跑通记录（v0.2.0，2026-09）
@@ -440,145 +374,3 @@ tar xzf t4_assets/compile_cache/torch_kernels_t4.tar.gz -C ~/.cache/   # 还原
 无 GPU（4GB RAM / CPU）环境实测：`make smoke` 全链路通过——mock 游戏 2400 步轨迹、5267 样本（train 4927 / val 340）、Stage A 蒸馏 56 步 align_loss 0.0062→0.0012 收敛、Stage B 三头联训完成、评测 agent 完整跑 600 步决策（每步含视觉塔前向，~210ms/步）。
 
 切换真实模型的路径：`configs/train.yaml` 里 `system1.backend: "hf"`（学生 `Qwen/Qwen3-VL-2B-Instruct`）+ `stage_a_distill.teacher_model: "Qwen/Qwen3.5-9B"`，代码路径已就绪；建议先在单卡 GPU 机器上冒烟 hf 路径，再上 Kaggle。
-
-### 11.2 T4 真机两轮记录（v0.4.0，2026-09-22）
-
-同一台 Colab Tesla T4（16GB，cc7.5）当天两轮全绿，产物分别在 `t4_assets/`（冒烟）与 `t4_assets_v2/`（正式规模）：
-
-| 阶段 | 冒烟（smoke） | 正式规模（v2） |
-|------|--------------|----------------|
-| 采集 | 4 回合 × 600 步 | 24 回合 × 1200 步（20.1 s） |
-| Stage A | 120 步，align_loss → 0.026（~10 s/步） | 复用冒烟 LoRA（配置 `enabled: false`） |
-| Stage B | 20 步 × ~38 s/步，零 OOM | 120 步 × ~5.5 s/步，GPU 9.7GB / 99% |
-| Stage C | 40 行，ECE 0.5134 → 0.4848，峰值 5.55 GB | 120 行 + 255 校准行，ECE 0.5134 → 0.4242 |
-| eval | merge=True，mock-pushbox 300 步 600.2 s | 300 步 601.6 s |
-| 产物 | qwenjev_s1.pt 254,001,909B + 双适配器分片 + wheels 3.10GB | 同构 v2 全套 323.8MB（hf_lora sha256 = cae4663a…） |
-
-完整复盘（两大修复、五个坑位、断点设计、上传陷阱、CUDA 编译资产终审）见 §12；离线复现包见 §13。
-
----
-
-## 12. T4 (16GB) 真机实战全记录（v0.4.0）
-
-### 12.1 环境与拓扑
-
-- 机器：Colab Tesla T4（16GB GDDR6，compute capability 7.5），Python 3.13（wheels 按 cp313 抓取）；
-- 基座：`Qwen/Qwen3-VL-2B-Instruct` 4bit（QLoRA base，`hf_quant4: true`）；**视觉塔原样保留且冻结**（`exclude_vision: true`），每步前向都在环上——冒烟阶段先用未训练头验证了真实视觉前向（probs=[0,1,0,0]、决策 ACTION3、4.24GB、10.4s/次）；
-- 教师：`Qwen3-VL-4B-Instruct` NF4（≈3.5GB）——9B 教师在 T4 放不下（fp16 embed/lm_head 单这两项 8.2GB）；96GB 卡仍用 9B；
-- 运行拓扑：**流���线进程必须脱离 Colab 桥接执行器**（envelope 触发后 `subprocess.Popen` 发射），且流水线自身也不 import torch——每个阶段都是隔离子进程，崩了不会毒化执行器进程的 VRAM（上一窗口 7.8GB 泄漏的教训）；状态走 `smoke_status.json` / `scale_status.json`，日志按阶段落 `logs/<stage>.log`，`nvidia-smi` 每 2s 轮询采样峰值显存。
-
-### 12.2 两大训练修复（被真实运行验证）
-
-| 修复 | 症状 | 方案 | 铁证 |
-|------|------|------|------|
-| **hook 池化 + `logits_to_keep=1`**（commit 66abfa5） | Stage B OOM：决策头不需要整表 logits，但默认前向对全部叶子 token 输出完整词表 logits，显存白白翻几倍 | 前向钩子处池化隐状态，只保留最后位置 logits | 冒烟 stage_b 20 步零 OOM |
-| **`resume_adapters()`**（commit dda44ec） | 三阶段间适配器断链：Stage A 的 LoRA 到 Stage B 丢失、Stage B 的到 Stage C 断开，蒸馏成果白费 | 显式续载/合并适配器 | 日志明写 "stage A LoRA resumed" / "stage B LoRA merged" |
-
-### 12.3 五个环境坑位（复现前先背下来）
-
-1. **分配器碎片**：chunked 前向/反向把 caching allocator 打碎（OOM 时 reserved-unallocated 高达 0.9GB）→ 全程 `PYTORCH_CUDA_ALLOC_CONF=expandable_segments:True`；
-2. **torchao 冲突**：VM 预装 torchao 0.10，peft ≥0.18 对 plain-Linear 注入 LoRA 时直接 raise（Stage C 把适配器 merge 进 fp16 基座恰好产生 plain Linear）→ 本栈完全不用 torchao，`pip uninstall -y torchao`；
-3. **peft fp32 输入强转**：fp16 基座被 peft cast 到 fp32 会让计算图膨胀 ~3GB → 用 4bit 基座（`kbit_prepare: true`）绕开；
-4. **`python -c` 转义陷阱**：多行 payload 里的单引号在 shell `-c` 里无法转义（`\'` 不是转义）→ payload 一律写文件再 `python -B file.py` 执行；
-5. **b64url 填充**：信封剥掉 `=` 填充后服务端必须补回，且必须用 urlsafe 字母表（`-_`）——标准 b64decode 会静默丢字符（`ops/t4exec.py` 已修复并实测）。
-
-### 12.4 断点与止损设计（VM 随时死亡不丢进度）
-
-- 每阶段完成落 `done/<stage>.stamp` + **产物存在性双重检查**（stamp 说完成但 stage_a.pt 不存在，照样重跑）；
-- **code 阶段永不 stamp**：每次重启都从 HF `snapshot_download` 刷新代码并清 `__pycache__`——stale repo 会拿着 hotfix 前的逻辑跑完全场（12:05 旧代码静默运行的教训）；
-- 正式规模每阶段完成即**增量上传** HF（先落盘再上传，上传失败不回滚训练）；
-- 采集断言：`collect` 即使全部游戏失败也 exit 0 → 流水线断言 `data/traces/` 下确有 `*.jsonl` 才放行。
-
-### 12.5 上传陷阱与分片方案
-
-HF xet 后端对 `*.safetensors` 会**静默失败**：commit 建立、API 返回成功、文件 404——冒烟与 v2 两轮都撞到。方案（`ops/t4_split_adapter.py`）：
-
-1. 适配器 bytes 头部加 16 字节 nonce 前缀（改写文件魔数，避开 safetensors 扫描路径）；
-2. 切 4 × 17,447,082B 分片 `adapter_p00..p03_<crc>.pt` 上传（`.pt` 后缀不受影响）；
-3. `parts/manifest.json` 记录 sha256（hf_lora v2 = `cae4663a…`，冒烟双适配器 = `75cbce97…` / `b0d23254…`）；
-4. `reassemble.py` 校验并还原为原始 `adapter_model.safetensors`，`PeftModel.from_pretrained` 直接可用。
-
-### 12.6 CUDA 编译资产终版审计（两轮运行后全盘复查）
-
-| 位置 | 结论 | 处置 |
-|------|------|------|
-| `~/.cache/triton`、`~/.cache/torch_extensions` | **absent**（无 torch.compile；transformers 5.16 eager 路径；T4 全部内核来自 wheel 预编译） | 无需处理 |
-| `~/.cache/torch/kernels/` | **发现 1 枚 NVRTC JIT 产物**：`reduction_prod_arch7.5_nvrtc12.8_sass_30566_aa1ebe…`（cc7.5 + CUDA 12.8 的 prod-reduction 内核，共 64KB）——首轮审计漏掉，因为只搜了 `torch_extensions`/`triton` 目录名 | 打 tar 上传：`t4_assets/compile_cache/torch_kernels_t4.tar.gz` 与 `ops/torch_kernels_t4.tar.gz`（12,857B） |
-| `/root/.julia/**/ptx` | 16 个 .ptx 全是 VM 预装 Julia CUDA.jl 的示例/测试文件，与本流水线无关 | 忽略 |
-| `~/.cache/pip`（3.0GB）、`~/.cache/huggingface`（13GB） | 可由 wheels 包完整重建 | 不上传，由 §13 wheels 包承接 |
-
-> 结论：本栈在 T4 上的"避免重复编译" = **预编译 wheels（主力）+ 版本锁定 + 这枚 NVRTC 内核缓存（锦上添花）**。
-> 还原缓存：`tar xzf torch_kernels_t4.tar.gz -C ~/.cache/`；不还原也只是首次运行多几秒 NVRTC 编译，不影响正确性。
-
----
-
-## 13. 离线复现包（换机零编译、最少下载）
-
-### 13.1 环境装配（顺序敏感）
-
-```bash
-# 0) Python 3.13（wheels 按 cp313 抓取；其他版本见 13.3 末尾）
-# 1) 先装 torch——PyPI 默认 wheel 即 cu128，这一步必须在线（~900MB）
-pip install torch==2.11.0
-# 2) 其余全部离线：57 个锁定版本 wheel（3.10GB，含 triton 3.8.0 cp313 248MB、
-#    bitsandbytes 0.50.2 预编译 cu12 manylinux wheel——T4 上免编译）
-pip install --no-index --find-links t4_assets/wheels/ -r requirements.txt
-# 3) 可选：还原 NVRTC 内核缓存
-tar xzf t4_assets/compile_cache/torch_kernels_t4.tar.gz -C ~/.cache/
-# 4) 验证（期望：2.11.0+cu128 (7, 5)）
-python -c "import torch,transformers,peft,bitsandbytes; print(torch.__version__, torch.cuda.get_device_capability(0))"
-```
-
-### 13.2 版本锁定表（实测组合，勿混搭）
-
-| 包 | 版本 | 说明 |
-|----|------|------|
-| torch | 2.11.0+cu128 | PyPI 默认 wheel，CUDA 12.8 运行时 |
-| transformers | 5.16.1 | Qwen3-VL `AutoModelForImageTextToText` 路径 |
-| peft | 0.20.0 | QLoRA 注入 + 适配器续载/合并 |
-| accelerate | 1.14.0 | 设备放置与梯度检查点 |
-| bitsandbytes | 0.50.2 | NF4 量化（预编译 cu12 wheel） |
-| huggingface_hub | 1.29.0 | 上传走 xet（注意 §12.5 的 safetensors 坑） |
-| CUDA / GPU | 12.8 / cc 7.5 (Tesla T4) | 内核缓存与 wheels 均按此组合实测 |
-
-### 13.3 权重与产物清单（HF `tchbcb/qwenjev`）
-
-| 路径 | 内容 |
-|------|------|
-| `t4_assets/checkpoints/qwenjev_s1.pt` | 冒烟终模型（三头 + 温度表，254,001,909B） |
-| `t4_assets_v2/checkpoints/qwenjev_s1.pt` | **正式规模终模型（推荐用这个）** |
-| `t4_assets{,_v2}/checkpoints/hf_lora/` | QLoRA 适配器（分片 + manifest + reassemble.py） |
-| `t4_assets_v2/checkpoints/calib_report.json` | ECE 0.5134 → 0.4242（RLCD 120 行 + 255 校准行） |
-| `t4_assets/wheels/` | 57 wheel / 3.10GB 离线安装包（cp313） |
-| `t4_assets/compile_cache/` | NVRTC 内核缓存 tar + 审计注记（compile_cache_note.json） |
-| `ops/` | 流水线 / 信封执行器 / 分片器 / Kaggle bundle / 编译缓存 tar |
-| `configs/t4_smoke.yaml` / `configs/t4_scale.yaml` | T4 两轮配置（内含全部坑位注释） |
-
-> wheels 按 cp313 抓取：换 Python 版本时在目标机执行 `pip download -r requirements.txt -d wheels/ -q`
-> 重抓即可。本栈无源码编译依赖（bitsandbytes / triton 均有预编译 wheel），全程不需要 gcc/nvcc。
-
-### 13.4 复现两轮训练
-
-```bash
-# 冒烟（~1.5h 窗口够用；VM 上脱离桥接进程发射）
-python -B ops/t4_pipeline.py
-# 正式规模（扩参内嵌于 ops/t4_scale.py，运行时写出 configs/t4_scale.yaml）
-python -B ops/t4_scale.py
-# 状态轮询（本地）
-python ops/t4exec.py run "print(open('/content/qwenjev_work/scale_status.json').read())"
-```
-
-两轮均为断点续跑：杀掉重发即可，已完成阶段自动跳过（机制见 §12.4）。
-
-### 13.5 评测快启（v0.4.1）
-
-```bash
-# 拉起 v2 终模型评测（自动下载 254MB 检查点 + 重组适配器 + merge 推理）：
-python ops/run_eval.py                       # GPU 机器（T4 实测 ~11min：载入 ~2min + 300 步对局 ~9min）
-python ops/run_eval.py --games all25         # 25 公开游戏（需 arc-agi + environment_files）
-# 无 GPU / 无权重（harness 验证，笔记本 CPU 实测 ~255ms/步）：
-python ops/run_eval.py --backend tiny --no-checkpoint --max-actions 60
-```
-
-实测记录（2026-09-22，T4 VM）：`ops/run_eval.py --checkpoint checkpoints/qwenjev-s1-hf-v2 --backend hf`
-→ fp16 基座 5.07GB、GPU 100%，mock-pushbox 300 步对局完成，报告在 `t4_assets_v2/checkpoints/eval_report_v2_entry.json`。

train/evaluate_local.py

@@ -32,15 +32,30 @@ from qwenjev.vision import TinyVLMConfig  # noqa: E402
 
 
 def run_game(env, game_id: str, brain: HybridAgent, max_actions: int) -> dict:
+    """Play one episode against any environment (mock or official).
+
+    Lifecycle: WIN ends the episode; GAME_OVER triggers the hybrid brain's
+    episode-boundary hook and a fresh reset, then play continues within the
+    same action budget — identical budget for every agent variant, so
+    best_level/actions stay comparable across runs."""
     env.reset()
     actions = 0
+    resets = 0
     best_level = 0
+    final_state = "NOT_FINISHED"
     started = time.time()
     for _ in range(max_actions):
-        grids = grids_from(env)
         meta = meta_from(env)
-        if meta["state"] in ("WIN", "GAME_OVER"):
+        final_state = meta["state"]
+        if final_state == "WIN":
             break
+        if final_state == "GAME_OVER":
+            brain.on_game_over(game_id, [f"game over at action {actions}"])
+            env.reset()
+            resets += 1
+            continue
+        grids = grids_from(env)
+        best_level = max(best_level, meta["levels_completed"])
         cand = brain.decide(
             game_id, grids,
             levels_completed=meta["levels_completed"],
@@ -53,11 +68,13 @@ def run_game(env, game_id: str, brain: HybridAgent, max_actions: int) -> dict:
         else:
             step_env(env, cand.name)
         actions += 1
-        best_level = max(best_level, meta["levels_completed"])
+        best_level = max(best_level, meta_from(env)["levels_completed"])
     return {
         "game_id": game_id,
-        "win": meta_from(env)["state"] == "WIN",
+        "win": final_state == "WIN",
+        "final_state": final_state,
         "best_level": best_level,
+        "resets": resets,
         "actions": actions,
         "seconds": round(time.time() - started, 1),
     }