Add files using upload-large-folder tool

scripts/convert_rl_to_sft_blackjack.py

@@ -0,0 +1,250 @@
+#!/usr/bin/env python3
+"""
+Convert RL test trajectories from Blackjack into LLM SFT-ready language trajectories.
+Uses pre-recorded text_states from the training script to ensure exact match with environment feedback.
+
+Input: runs/<exp>/trajectories/step_XXXXXX/trajectories.jsonl
+Output: runs/<exp>/sft/step_XXXXXX_sft.jsonl
+"""
+
+import argparse
+import json
+import os
+from pathlib import Path
+from typing import List, Tuple
+
+try:
+    import yaml  # type: ignore
+except Exception:
+    yaml = None
+
+ACTION_LOOKUP = {0: "Stick", 1: "Hit"}
+
+
+def load_env_instruction_and_cfg(repo_root: Path) -> Tuple[str, int, bool, str, int]:
+    """Load Blackjack env_instruction, max_tokens, enable_think, action_sep, max_actions.
+    Fallbacks are provided if YAML is unavailable or keys are missing.
+    """
+    instruction = (
+        "You are playing Blackjack against a dealer. The dealer must hit on 16 or less and stand on 17 or more.\n"
+        "Choose either Stick or Hit. Respond with a single action.\n"
+        "Example: <answer>Hit</answer>"
+    )
+    max_tokens = 64
+    enable_think = True
+    action_sep = "||"
+    max_actions = 10
+
+    if yaml is None:
+        instruction += (
+            "\nYour available actions are:\n"
+            "Stick, Hit\n"
+            f"You can make up to {max_actions} actions, separated by the action separator \" " + action_sep + " \"\n"
+        )
+        return instruction, max_tokens, enable_think, action_sep, max_actions
+
+    envs_yaml = repo_root / "config" / "envs.yaml"
+    if envs_yaml.exists():
+        try:
+            with open(envs_yaml, "r", encoding="utf-8") as f:
+                envs = yaml.safe_load(f)
+            if isinstance(envs, dict):
+                bj = envs.get("Blackjack", {})
+                if isinstance(bj, dict):
+                    instruction = bj.get("env_instruction", instruction)
+                    max_tokens = int(bj.get("max_tokens", max_tokens))
+                    max_actions = int(bj.get("max_actions_per_traj", max_actions))
+        except Exception:
+            pass
+
+    base_yaml = repo_root / "config" / "base.yaml"
+    if base_yaml.exists():
+        try:
+            with open(base_yaml, "r", encoding="utf-8") as f:
+                base_cfg = yaml.safe_load(f)
+            ap = base_cfg.get("agent_proxy", {}) if isinstance(base_cfg, dict) else {}
+            action_sep = ap.get("action_sep", action_sep)
+            enable_think = bool(ap.get("enable_think", enable_think))
+        except Exception:
+            pass
+            
+    instruction += (
+        "\nYour available actions are:\n"
+        "Stick, Hit\n"
+        f"You can make up to {max_actions} actions, separated by the action separator \" " + action_sep + " \"\n"
+    )
+    return instruction, max_tokens, enable_think, action_sep, max_actions
+
+
+def build_messages_for_episode(
+    text_states: List[str],
+    actions: List[int],
+    rewards: List[float],
+    instruction: str,
+    max_tokens: int,
+    enable_think: bool,
+    max_actions: int,
+) -> List[dict]:
+    messages = [
+        {"role": "system", "content": "You're a helpful assistant. "},
+        {"role": "user", "content": instruction},
+    ]
+
+    total_actions = len(actions)
+    
+    # 遍历每一步动作
+    for t in range(len(actions)):
+        # 获取当前步骤的文本状态
+        # text_states[0] 是初始状态, text_states[1] 是 action[0] 之后的状态
+        current_text_state = text_states[t] 
+        
+        actions_left = max(0, max_actions - t)
+        format_prompt = (
+            "<think> [Your thoughts] </think> <answer> [your answer] </answer>"
+            if enable_think
+            else "<answer> [your answer] </answer>"
+        )
+        length_prompt = f"Max response length: {max_tokens} words (tokens)."
+
+        # --- 核心修改：使用保存的文本状态并拼接 Question ---
+        turn_content = (
+            f"\nTurn {t + 1}:\n"
+            f"State:\n"
+            f"{current_text_state}\n" # text_state 已经包含了 === Blackjack Game State === 等内容
+            f"What is your next move?\n"
+            f"You have {actions_left} actions left. Always output: {format_prompt}"
+            f" with no extra text. Strictly follow this format. {length_prompt}"
+        )
+
+        # 追加到上一条 user 消息（如果是第一回合）或者新建 user 消息
+        if messages[-1]["role"] == "user":
+            messages[-1]["content"] += turn_content
+        else:
+            messages.append({"role": "user", "content": turn_content})
+
+        # 添加 Assistant 回复
+        action_id = int(actions[t])
+        action_name = ACTION_LOOKUP.get(action_id, "unknown")
+        assistant_text = (
+            f"<think></think><answer>{action_name}</answer>" if enable_think else f"<answer>{action_name}</answer>"
+        )
+        messages.append({"role": "assistant", "content": assistant_text})
+        
+        # 添加 Reward 信息
+        reward_val = rewards[t] 
+        messages.append({"role": "user", "content": f"Reward:\n{reward_val}\n"})
+
+    # 移除最后一条仅包含 Reward 的 User 消息（SFT 数据通常以 Assistant 结尾）
+    if messages[-1]["role"] == "user":
+        messages.pop()
+
+    return messages
+
+
+def convert_file(step_dir: Path, output_dir: Path, repo_root: Path, include_failed: bool = False, max_actions: int = 10) -> Path:
+    traj_path = step_dir / "trajectories.jsonl"
+    metrics_path = step_dir / "metrics.json"
+    if not traj_path.exists():
+        raise FileNotFoundError(f"Missing trajectories.jsonl at {traj_path}")
+
+    instruction, max_tokens, enable_think, action_sep, cfg_max_actions = load_env_instruction_and_cfg(repo_root)
+    if max_actions is None:
+        max_actions = cfg_max_actions
+
+    output_dir.mkdir(parents=True, exist_ok=True)
+    out_path = output_dir / f"{step_dir.name}_sft.jsonl"
+
+    global_step = None
+    if metrics_path.exists():
+        try:
+            with open(metrics_path, "r", encoding="utf-8") as f:
+                m = json.load(f)
+            global_step = m.get("global_step")
+        except Exception:
+            pass
+
+    written = 0
+    with open(traj_path, "r", encoding="utf-8") as fin, open(out_path, "w", encoding="utf-8") as fout:
+        for line in fin:
+            line = line.strip()
+            if not line:
+                continue
+            traj = json.loads(line)
+
+            ep_success = bool(traj.get("episode_success", False))
+            if (not include_failed) and (not ep_success):
+                continue
+            
+            # 读取新的 text_states 字段
+            text_states = traj.get("text_states", [])
+            actions = traj.get("actions", [])
+            rewards = traj.get("rewards", [])
+            
+            # 兼容性检查：如果该轨迹是旧代码生成的（没有 text_states），则跳过
+            if not text_states:
+                # Silently skip or warn
+                continue
+
+            if len(actions) > max_actions:
+                continue
+
+            messages = build_messages_for_episode(
+                text_states=text_states,
+                actions=actions,
+                rewards=rewards,
+                instruction=instruction,
+                max_tokens=max_tokens,
+                enable_think=enable_think,
+                max_actions=max_actions,
+            )
+
+            record = {
+                "messages": messages,
+                "meta": {
+                    "episode_return": traj.get("episode_return", None),
+                    "episode_success": ep_success,
+                    "global_step": global_step,
+                },
+            }
+            fout.write(json.dumps(record, ensure_ascii=False) + "\n")
+            written += 1
+
+    if written == 0:
+        # 创建空文件以防报错，或者写入一个空数组
+        with open(out_path, "w", encoding="utf-8") as f:
+            pass
+        print("Warning: No trajectories converted. Check if input file has 'text_states' or if filtering is too strict.")
+    
+    return out_path
+
+
+def find_latest_step_dir(traj_root: Path) -> Path:
+    step_dirs = [p for p in traj_root.iterdir() if p.is_dir() and p.name.startswith("step_")]
+    if not step_dirs:
+        raise FileNotFoundError(f"No step_* directories under {traj_root}")
+    step_dirs.sort(key=lambda p: int(p.name.split("_")[-1]))
+    return step_dirs[-1]
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Convert Blackjack RL trajectories to LLM SFT chat JSONL")
+    parser.add_argument("run_dir", help="Path to the run directory (contains trajectories/)")
+    parser.add_argument("--step", default=None, help="Specific step directory name (e.g., step_499712)")
+    parser.add_argument("--include_failed", action="store_true", help="Include failed episodes in SFT data")
+    parser.add_argument("--max_actions", type=int, default=None, help="Max actions cap for filtering and counter display")
+    args = parser.parse_args()
+
+    repo_root = Path(__file__).resolve().parents[1]
+    run_dir = Path(args.run_dir)
+    traj_root = run_dir / "trajectories"
+    if not traj_root.exists():
+        raise FileNotFoundError(f"Not found trajectories directory: {traj_root}")
+
+    step_dir = traj_root / args.step if args.step else find_latest_step_dir(traj_root)
+    output_dir = run_dir / "sft"
+    out_path = convert_file(step_dir=step_dir, output_dir=output_dir, repo_root=repo_root, include_failed=args.include_failed, max_actions=args.max_actions)
+    print(f"SFT data written to: {out_path}")
+
+
+if __name__ == "__main__":
+    main()

scripts/convert_rl_to_sft_frozenlake.py

@@ -0,0 +1,267 @@
+#!/usr/bin/env python3
+"""
+Convert RL test trajectories (numeric states/actions) from FrozenLake into
+LLM SFT-ready language trajectories in chat-style messages.
+
+Input: runs/<exp>/trajectories/step_XXXXXX/trajectories.jsonl
+Output: runs/<exp>/sft/step_XXXXXX_sft.jsonl
+
+Each output JSON line contains:
+  - messages: [{role: system|user|assistant, content: str}, ...]
+  - meta: {episode_return: float, episode_success: bool, global_step: int}
+
+We mirror RAGEN ContextManager’s prompt format as much as possible:
+  - system: "You're a helpful assistant. "
+  - user: env_instruction + per-turn state blocks with action constraints
+  - assistant: "<think></think><answer>Action</answer>" (or without think if disabled)
+  - user (reward): "Reward:\n{reward}\n"
+"""
+
+import argparse
+import json
+import math
+import os
+from pathlib import Path
+from typing import List, Tuple
+
+try:
+    import yaml  # type: ignore
+except Exception:
+    yaml = None
+
+
+ACTION_LOOKUP = {1: "Left", 2: "Down", 3: "Right", 4: "Up"}
+
+
+def infer_grid_dims(state_vec: List[float]) -> Tuple[int, int]:
+    """Infer (rows, cols) from flattened one-hot grid length.
+    Our PPO wrapper encodes each cell as one-hot over 6 tokens: ['P','_','O','G','X','√'].
+    """
+    n = len(state_vec)
+    assert n % 6 == 0, f"State length {n} not divisible by 6 (channels)"
+    n_cells = n // 6
+    r = int(math.isqrt(n_cells))
+    assert r * r == n_cells, f"Grid is not square: {n_cells} cells"
+    return r, r
+
+
+def decode_state_to_grid_text(state_vec: List[float]) -> str:
+    """Decode numeric state vector back to textual grid.
+
+    Encoding per PPO wrapper:
+      One-hot per cell over tokens = ['P', '_', 'O', 'G', 'X', '√'] in this order.
+      The wrapper already encodes P/X/√ directly in the grid; no separate coords needed.
+    """
+    tokens = ['P', '_', 'O', 'G', 'X', '√']
+    rows, cols = infer_grid_dims(state_vec)
+    lines = []
+    for i in range(rows):
+        row_chars = []
+        for j in range(cols):
+            base = (i * cols + j) * 6
+            cell = state_vec[base: base + 6]
+            idx = max(range(6), key=lambda k: cell[k])
+            ch = tokens[idx] if 0 <= idx < len(tokens) else '_'
+            row_chars.append(ch)
+        lines.append("".join(row_chars))
+    return "\n".join(lines)
+
+
+def load_env_instruction_and_cfg(repo_root: Path) -> Tuple[str, int, str, bool]:
+    """Load FrozenLake env_instruction, max_tokens, action_sep, enable_think from config.
+    Fallbacks are provided if YAML is unavailable.
+    """
+    default_instruction = (
+        "You are solving the FrozenLake puzzle. Forbid the hole and go to the target. "
+        "You may move to unintended directions due to slippery ice. "
+        "Example answer format: <think>To forbid the hole and go to the target, I should go left then go up.</think><answer>Left || Up</answer>"
+        "The meaning of each symbol in the state is:\nP: player, _: empty, O: hole, G: goal, X: player in hole, √: player on goal \nYour available actions are: \nLeft, Down, Right, Up \nYou can make up to 10 actions, separated by the action separator ' || '"
+    )
+    instruction = default_instruction
+    max_tokens = 100
+    action_sep = "||"
+    enable_think = True
+
+    if yaml is None:
+        return instruction, max_tokens, action_sep, enable_think
+
+    # envs.yaml
+    envs_yaml = repo_root / "config" / "envs.yaml"
+    if envs_yaml.exists():
+        try:
+            with open(envs_yaml, "r", encoding="utf-8") as f:
+                envs = yaml.safe_load(f)
+            if isinstance(envs, dict) and "FrozenLake" in envs:
+                fl = envs["FrozenLake"]
+                instruction = fl.get("env_instruction", instruction)
+                max_tokens = int(fl.get("max_tokens", max_tokens))
+        except Exception:
+            pass
+
+    # base.yaml
+    base_yaml = repo_root / "config" / "base.yaml"
+    if base_yaml.exists():
+        try:
+            with open(base_yaml, "r", encoding="utf-8") as f:
+                base_cfg = yaml.safe_load(f)
+            ap = base_cfg.get("agent_proxy", {}) if isinstance(base_cfg, dict) else {}
+            action_sep = ap.get("action_sep", action_sep)
+            enable_think = bool(ap.get("enable_think", enable_think))
+        except Exception:
+            pass
+
+    return instruction, max_tokens, action_sep, enable_think
+
+
+def build_messages_for_episode(
+    states: List[List[float]],
+    actions: List[int],
+    rewards: List[float],
+    instruction: str,
+    max_tokens: int,
+    action_sep: str,
+    enable_think: bool,
+) -> List[dict]:
+    """Construct chat messages mirroring ContextManager format.
+
+    - First system message.
+    - One user message containing the instruction and per-turn state blocks.
+    - Assistant messages per executed action with tag-only outputs.
+    - User messages for rewards.
+    """
+    messages = [
+        {"role": "system", "content": "You're a helpful assistant. "},
+        {"role": "user", "content": instruction},
+    ]
+
+    total_actions = len(actions)
+    # Append state blocks into the initial user content
+    for t, state in enumerate(states):
+        grid_text = decode_state_to_grid_text(state)
+        actions_left = max(0, total_actions - t)  # before taking action at turn t
+        format_prompt = (
+            "<think> [Your thoughts] </think> <answer> [your answer] </answer>"
+            if enable_think
+            else "<answer> [your answer] </answer>"
+        )
+        length_prompt = f"Max response length: {max_tokens} words (tokens)."
+
+        messages[-1]["content"] += (
+            f"\nTurn {t + 1}:\n"
+            f"State:\n{grid_text}\n"
+            f"You have {actions_left} actions left. Always output: {format_prompt} "
+            f"with no extra text. Strictly follow this format. {length_prompt}\n"
+        )
+        # If action exists for this turn, add assistant + reward
+        if t < total_actions:
+            # Map RL action (0..3) -> RAGEN action (1..4) -> text
+            action_id = actions[t] + 1
+            action_name = ACTION_LOOKUP.get(action_id, "unknown")
+            if enable_think:
+                assistant_text = f"<think></think><answer>{action_name}</answer>"
+            else:
+                assistant_text = f"<answer>{action_name}</answer>"
+            messages.append({"role": "assistant", "content": assistant_text})
+            # Reward message
+            reward_val = rewards[t] if t < len(rewards) else 0.0
+            messages.append({"role": "user", "content": f"Reward:\n{reward_val}\n"})
+    # import pdb;pdb.set_trace()
+    messages.append({"role": "assistant", "content": "<think>"})
+    return messages
+
+
+def convert_file(step_dir: Path, output_dir: Path, repo_root: Path, include_failed: bool = False) -> Path:
+    traj_path = step_dir / "trajectories.jsonl"
+    metrics_path = step_dir / "metrics.json"
+    if not traj_path.exists():
+        raise FileNotFoundError(f"Missing trajectories.jsonl at {traj_path}")
+
+    instruction, max_tokens, action_sep, enable_think = load_env_instruction_and_cfg(repo_root)
+
+    output_dir.mkdir(parents=True, exist_ok=True)
+    out_path = output_dir / f"{step_dir.name}_sft.jsonl"
+
+    # Read global step from metrics if available
+    global_step = None
+    if metrics_path.exists():
+        try:
+            with open(metrics_path, "r", encoding="utf-8") as f:
+                m = json.load(f)
+            global_step = m.get("global_step")
+        except Exception:
+            pass
+
+    written = 0
+    with open(traj_path, "r", encoding="utf-8") as fin, open(out_path, "w", encoding="utf-8") as fout:
+        for line in fin:
+            line = line.strip()
+            if not line:
+                continue
+            traj = json.loads(line)
+            # Filter if requested
+            ep_success = bool(traj.get("episode_success", False))
+            if (not include_failed) and (not ep_success):
+                continue
+
+            states = traj.get("states", [])
+            actions = traj.get("actions", [])
+            rewards = traj.get("rewards", [])
+            messages = build_messages_for_episode(
+                states=states,
+                actions=actions,
+                rewards=rewards,
+                instruction=instruction,
+                max_tokens=max_tokens,
+                action_sep=action_sep,
+                enable_think=enable_think,
+            )
+
+            record = {
+                "messages": messages,
+                "meta": {
+                    "episode_return": traj.get("episode_return", None),
+                    "episode_success": ep_success,
+                    "global_step": global_step,
+                },
+            }
+            fout.write(json.dumps(record, ensure_ascii=False) + "\n")
+            written += 1
+
+    if written == 0:
+        # Still write an empty file to signal conversion executed
+        with open(out_path, "w", encoding="utf-8") as f:
+            pass
+    return out_path
+
+
+def find_latest_step_dir(traj_root: Path) -> Path:
+    step_dirs = [p for p in traj_root.iterdir() if p.is_dir() and p.name.startswith("step_")]
+    if not step_dirs:
+        raise FileNotFoundError(f"No step_* directories under {traj_root}")
+    # Sort by numeric suffix
+    step_dirs.sort(key=lambda p: int(p.name.split("_")[-1]))
+    return step_dirs[-1]
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Convert FrozenLake RL trajectories to LLM SFT chat JSONL")
+    parser.add_argument("run_dir", help="Path to the run directory (contains trajectories/)" )
+    parser.add_argument("--step", default=None, help="Specific step directory name (e.g., step_993280)")
+    parser.add_argument("--include_failed", action="store_true", help="Include failed episodes in SFT data")
+    args = parser.parse_args()
+
+    repo_root = Path(__file__).resolve().parents[1]
+    run_dir = Path(args.run_dir)
+    traj_root = run_dir / "trajectories"
+    if not traj_root.exists():
+        raise FileNotFoundError(f"Not found trajectories directory: {traj_root}")
+
+    step_dir = traj_root / args.step if args.step else find_latest_step_dir(traj_root)
+    output_dir = run_dir / "sft"
+    out_path = convert_file(step_dir=step_dir, output_dir=output_dir, repo_root=repo_root, include_failed=args.include_failed)
+    print(f"SFT data written to: {out_path}")
+
+
+if __name__ == "__main__":
+    main()
+

scripts/convert_rl_to_sft_frozenlake_daoshuaction.py

@@ -0,0 +1,300 @@
+#!/usr/bin/env python3
+
+import argparse
+import json
+import math
+import os
+from pathlib import Path
+from typing import List, Tuple
+
+try:
+    import yaml  # type: ignore
+except Exception:
+    yaml = None
+
+
+ACTION_LOOKUP = {1: "Left", 2: "Down", 3: "Right", 4: "Up"}
+
+
+def infer_grid_dims(state_vec: List[float]) -> Tuple[int, int]:
+    """Infer (rows, cols) from flattened one-hot grid length.
+    Our PPO wrapper encodes each cell as one-hot over 6 tokens: ['P','_','O','G','X','√'].
+    """
+    n = len(state_vec)
+    assert n % 6 == 0, f"State length {n} not divisible by 6 (channels)"
+    n_cells = n // 6
+    r = int(math.isqrt(n_cells))
+    assert r * r == n_cells, f"Grid is not square: {n_cells} cells"
+    return r, r
+
+
+def decode_state_to_grid_text(state_vec: List[float]) -> str:
+    """Decode numeric state vector back to textual grid.
+
+    Encoding per PPO wrapper:
+      One-hot per cell over tokens = ['P', '_', 'O', 'G', 'X', '√'] in this order.
+      The wrapper already encodes P/X/√ directly in the grid; no separate coords needed.
+    """
+    tokens = ['P', '_', 'O', 'G', 'X', '√']
+    rows, cols = infer_grid_dims(state_vec)
+    lines = []
+    for i in range(rows):
+        row_chars = []
+        for j in range(cols):
+            base = (i * cols + j) * 6
+            cell = state_vec[base: base + 6]
+            idx = max(range(6), key=lambda k: cell[k])
+            ch = tokens[idx] if 0 <= idx < len(tokens) else '_'
+            row_chars.append(ch)
+        lines.append("".join(row_chars))
+    return "\n".join(lines)
+
+
+def parse_positions_from_state(state_vec: List[float]):
+    """Extract board size, player, goal, and holes positions from one-hot state.
+    - Player is where token is one of ['P','X','√'].
+    - Goal is where token is 'G'.
+    - Holes include all 'O' cells; if player is on hole ('X'), include that cell as a hole as well.
+    Returns: (rows, cols, (pr, pc), (gr, gc) or None, holes: List[(r,c)])
+    """
+    tokens = ['P', '_', 'O', 'G', 'X', '√']
+    rows, cols = infer_grid_dims(state_vec)
+    player = None
+    goal = None
+    holes: List[Tuple[int, int]] = []
+    for i in range(rows):
+        for j in range(cols):
+            base = (i * cols + j) * 6
+            cell = state_vec[base: base + 6]
+            idx = max(range(6), key=lambda k: cell[k])
+            if idx == 0 or idx == 4 or idx == 5:  # P or X or √
+                player = (i, j)
+                if idx == 4:  # X means on a hole
+                    holes.append((i, j))
+            elif idx == 2:  # O
+                holes.append((i, j))
+            elif idx == 3:  # G
+                goal = (i, j)
+    return rows, cols, player, goal, holes
+
+
+def load_env_instruction_and_cfg(repo_root: Path) -> Tuple[str, int, str, bool]:
+    """Load FrozenLake env_instruction, max_tokens, action_sep, enable_think from config.
+    Fallbacks are provided if YAML is unavailable.
+    """
+    default_instruction = (
+        "You are solving the FrozenLake puzzle. The observation includes both a symbol grid and zero-indexed coordinates for the start, goal, player, and any holes.\n"
+        "Coordinates range from the top-left corner (0, 0) to the bottom-right corner (5, 5).\n"
+        "Beware that the ice is slippery, so the agent might slide and end up in an unintended tile.\n"
+        "Respond with a sequence of actions such as <answer>Left || Up || Up</answer>.\n"
+        "\nThe meaning of each symbol in the state is:\n"
+        "P: player, _: empty, O: hole, G: goal, X: player in hole, √: player on goal\n"
+        "Your available actions are:\n"
+        "Left, Down, Right, Up\n"
+        "You can make up to 25 actions, separated by the action separator \" || \"\n"
+    )
+    instruction = default_instruction
+    max_tokens = 100
+    action_sep = "||"
+    enable_think = True
+
+    if yaml is None:
+        return instruction, max_tokens, action_sep, enable_think
+
+    # envs.yaml
+    envs_yaml = repo_root / "config" / "envs.yaml"
+    if envs_yaml.exists():
+        try:
+            with open(envs_yaml, "r", encoding="utf-8") as f:
+                envs = yaml.safe_load(f)
+            if isinstance(envs, dict) and "FrozenLake" in envs:
+                fl = envs["FrozenLake"]
+                instruction = fl.get("env_instruction", instruction)
+                max_tokens = int(fl.get("max_tokens", max_tokens))
+        except Exception:
+            pass
+
+    # base.yaml
+    base_yaml = repo_root / "config" / "base.yaml"
+    if base_yaml.exists():
+        try:
+            with open(base_yaml, "r", encoding="utf-8") as f:
+                base_cfg = yaml.safe_load(f)
+            ap = base_cfg.get("agent_proxy", {}) if isinstance(base_cfg, dict) else {}
+            action_sep = ap.get("action_sep", action_sep)
+            enable_think = bool(ap.get("enable_think", enable_think))
+        except Exception:
+            pass
+
+    return instruction, max_tokens, action_sep, enable_think
+
+
+def build_messages_for_episode(
+    states: List[List[float]],
+    actions: List[int],
+    rewards: List[float],
+    instruction: str,
+    max_tokens: int,
+    action_sep: str,
+    enable_think: bool,
+    max_actions: int,
+) -> List[dict]:
+    """Construct chat messages mirroring ContextManager format.
+
+    - First system message.
+    - One user message containing the instruction and per-turn state blocks.
+    - Assistant messages per executed action with tag-only outputs.
+    - User messages for rewards.
+    """
+    messages = [
+        {"role": "system", "content": "You're a helpful assistant. "},
+        {"role": "user", "content": instruction},
+    ]
+
+    total_actions = len(actions)
+    # Determine start position from the first state's player
+    start_rows, start_cols, start_player, start_goal, start_holes = parse_positions_from_state(states[0]) if states else (0, 0, None, None, [])
+    # Append state blocks into the initial user content
+    for t, state in enumerate(states):
+        grid_text = decode_state_to_grid_text(state)
+        rows, cols, player_pos, goal_pos, holes_pos = parse_positions_from_state(state)
+        # Start counter from max_actions (e.g., 25) regardless of episode length
+        actions_left = max(0, max_actions - t)
+        format_prompt = (
+            "<think> [Your thoughts] </think> <answer> [your answer] </answer>"
+            if enable_think
+            else "<answer> [your answer] </answer>"
+        )
+        length_prompt = f"Max response length: {max_tokens} words (tokens)."
+
+        messages[-1]["content"] += (
+            f"\nTurn {t + 1}:\n"
+            f"State:\n"
+            f"Coordinates:\n"
+            f"Board size: {rows} rows x {cols} cols (zero-indexed).\n"
+            f"Start: {start_player if start_player is not None else (-1, -1)}\n"
+            f"Goal: {goal_pos if goal_pos is not None else (-1, -1)}\n"
+            f"Player: {player_pos if player_pos is not None else (-1, -1)}\n"
+            f"Holes: {holes_pos}\n"
+            f"Grid Map:\n{grid_text}\n"
+            f"You have {actions_left} actions left. Always output: {format_prompt}"
+            f"with no extra text. Strictly follow this format. {length_prompt}"
+        )
+        # If action exists for this turn, add assistant + reward
+        if t < total_actions:
+            # Map RL action (0..3) -> RAGEN action (1..4) -> text
+            action_id = actions[t] + 1
+            action_name = ACTION_LOOKUP.get(action_id, "unknown")
+            if enable_think:
+                assistant_text = f"<think></think><answer>{action_name}</answer>"
+            else:
+                assistant_text = f"<answer>{action_name}</answer>"
+            messages.append({"role": "assistant", "content": assistant_text})
+            # Reward message
+            reward_val = rewards[t] if t < len(rewards) else 0.0
+            messages.append({"role": "user", "content": f"Reward:\n{reward_val}\n"})
+    # import pdb;pdb.set_trace()
+    
+    return messages[:-1]
+
+
+def convert_file(step_dir: Path, output_dir: Path, repo_root: Path, include_failed: bool = False, max_actions: int = 25) -> Path:
+    traj_path = step_dir / "trajectories.jsonl"
+    metrics_path = step_dir / "metrics.json"
+    if not traj_path.exists():
+        raise FileNotFoundError(f"Missing trajectories.jsonl at {traj_path}")
+
+    instruction, max_tokens, action_sep, enable_think = load_env_instruction_and_cfg(repo_root)
+
+    output_dir.mkdir(parents=True, exist_ok=True)
+    out_path = output_dir / f"{step_dir.name}_sft.jsonl"
+
+    # Read global step from metrics if available
+    global_step = None
+    if metrics_path.exists():
+        try:
+            with open(metrics_path, "r", encoding="utf-8") as f:
+                m = json.load(f)
+            global_step = m.get("global_step")
+        except Exception:
+            pass
+
+    written = 0
+    with open(traj_path, "r", encoding="utf-8") as fin, open(out_path, "w", encoding="utf-8") as fout:
+        for line in fin:
+            line = line.strip()
+            if not line:
+                continue
+            traj = json.loads(line)
+            # Filter if requested
+            ep_success = bool(traj.get("episode_success", False))
+            if (not include_failed) and (not ep_success):
+                continue
+
+            states = traj.get("states", [])
+            actions = traj.get("actions", [])
+            rewards = traj.get("rewards", [])
+            # Filter: keep only episodes with total actions <= max_actions
+            if len(actions) > max_actions:
+                continue
+            messages = build_messages_for_episode(
+                states=states,
+                actions=actions,
+                rewards=rewards,
+                instruction=instruction,
+                max_tokens=max_tokens,
+                action_sep=action_sep,
+                enable_think=enable_think,
+                max_actions=max_actions,
+            )
+
+            record = {
+                "messages": messages,
+                "meta": {
+                    "episode_return": traj.get("episode_return", None),
+                    "episode_success": ep_success,
+                    "global_step": global_step,
+                },
+            }
+            fout.write(json.dumps(record, ensure_ascii=False) + "\n")
+            written += 1
+
+    if written == 0:
+        # Still write an empty file to signal conversion executed
+        with open(out_path, "w", encoding="utf-8") as f:
+            pass
+    return out_path
+
+
+def find_latest_step_dir(traj_root: Path) -> Path:
+    step_dirs = [p for p in traj_root.iterdir() if p.is_dir() and p.name.startswith("step_")]
+    if not step_dirs:
+        raise FileNotFoundError(f"No step_* directories under {traj_root}")
+    # Sort by numeric suffix
+    step_dirs.sort(key=lambda p: int(p.name.split("_")[-1]))
+    return step_dirs[-1]
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Convert FrozenLake RL trajectories to LLM SFT chat JSONL")
+    parser.add_argument("run_dir", help="Path to the run directory (contains trajectories/)" )
+    parser.add_argument("--step", default=None, help="Specific step directory name (e.g., step_993280)")
+    parser.add_argument("--include_failed", action="store_true", help="Include failed episodes in SFT data")
+    parser.add_argument("--max_actions", type=int, default=25, help="Max actions cap for filtering and counter display")
+    args = parser.parse_args()
+
+    repo_root = Path(__file__).resolve().parents[1]
+    run_dir = Path(args.run_dir)
+    traj_root = run_dir / "trajectories"
+    if not traj_root.exists():
+        raise FileNotFoundError(f"Not found trajectories directory: {traj_root}")
+
+    step_dir = traj_root / args.step if args.step else find_latest_step_dir(traj_root)
+    output_dir = run_dir / "sft"
+    out_path = convert_file(step_dir=step_dir, output_dir=output_dir, repo_root=repo_root, include_failed=args.include_failed, max_actions=args.max_actions)
+    print(f"SFT data written to: {out_path}")
+
+
+if __name__ == "__main__":
+    main()
+

scripts/convert_rl_to_sft_rubikscube.py

@@ -0,0 +1,266 @@
+#!/usr/bin/env python3
+"""
+Convert RL eval trajectories from Rubik's Cube 2x2 into LLM SFT-ready chat data.
+
+Input: runs/<exp>/trajectories/step_XXXXXX/trajectories.jsonl
+Output: runs/<exp>/sft/step_XXXXXX_sft.jsonl
+
+Each output JSON line contains:
+  - messages: [{role: system|user|assistant, content: str}, ...]
+  - meta: {episode_return: float, episode_success: bool, global_step: int}
+
+We mirror the FrozenLake converter structure:
+  - system: "You're a helpful assistant. "
+  - user: env_instruction + per-turn state blocks
+  - assistant: tag-only actions, one per step
+  - user: reward after each action
+"""
+
+import argparse
+import json
+from pathlib import Path
+from typing import List, Tuple
+
+try:
+    import yaml  # type: ignore
+except Exception:
+    yaml = None
+
+
+# Rubik's 2x2 actions (env uses 1..12; PPO wrapper stores 0..11)
+RUBIK_ACTIONS = [
+    "U", "U'", "D", "D'", "L", "L'", "R", "R'", "F", "F'", "B", "B'",
+]
+
+COLORS = ['W', 'O', 'G', 'R', 'B', 'Y']
+
+
+def load_env_instruction_and_cfg(repo_root: Path) -> Tuple[str, int, str, bool, int]:
+    """Load RubiksCube2x2 env instruction and base agent_proxy configs.
+    Returns: (instruction, max_tokens, action_sep, enable_think, max_actions)
+    """
+    instruction = (
+        "You are solving a 2x2 Rubik's Cube (Pocket Cube). The goal is to restore the cube so that each of the faces consists of a single, unique color.\n"
+        "Available actions use standard Singmaster notation for face rotations: U, U', D, D', L, L', R, R', F, F', B, B'.\n"
+        "- Faces: U (Up), D (Down), L (Left), R (Right), F (Front), B (Back).\n"
+        "- Modifiers: A letter alone means 90° clockwise (e.g., 'R'). A letter with prime (') means 90° counter-clockwise (e.g., \"R'\")."
+        "Respond with a sequence of actions separated by \"||\".\n"
+        "Example: <answer>U</answer>\n\n"
+        "Your available actions are:\n"
+        "U, U', D, D', L, L', R, R', F, F', B, B'\n"
+        "You can make up to 20 actions, separated by the action separator \" || \"\n"
+    )
+    max_tokens = 96
+    action_sep = "||"
+    enable_think = True
+    max_actions = 20
+
+    if yaml is None:
+        return instruction, max_tokens, action_sep, enable_think, max_actions
+
+    # envs.yaml
+    envs_yaml = repo_root / "config" / "envs.yaml"
+    if envs_yaml.exists():
+        try:
+            with open(envs_yaml, "r", encoding="utf-8") as f:
+                envs = yaml.safe_load(f)
+            if isinstance(envs, dict) and "custom_envs" in envs and "RubiksCube2x2" in envs["custom_envs"]:
+                e = envs["custom_envs"]["RubiksCube2x2"]
+                instruction = e.get("env_instruction", instruction)
+                max_tokens = int(e.get("max_tokens", max_tokens))
+                max_actions = int(e.get("max_actions_per_traj", max_actions))
+        except Exception:
+            pass
+
+    # base.yaml
+    base_yaml = repo_root / "config" / "base.yaml"
+    if base_yaml.exists():
+        try:
+            with open(base_yaml, "r", encoding="utf-8") as f:
+                base_cfg = yaml.safe_load(f)
+            ap = base_cfg.get("agent_proxy", {}) if isinstance(base_cfg, dict) else {}
+            action_sep = ap.get("action_sep", action_sep)
+            enable_think = bool(ap.get("enable_think", enable_think))
+        except Exception:
+            pass
+
+    return instruction, max_tokens, action_sep, enable_think, max_actions
+
+
+def decode_state_to_text(state_vec: List[float]) -> str:
+    """Decode one-hot length 24*6 vector into sticker letters.
+    Returns a compact textual block listing each face in order: U, L, F, R, B, D.
+    """
+    if not state_vec:
+        return ""
+    n = len(state_vec)
+    if n % len(COLORS) != 0:
+        return ""
+    n_stickers = n // len(COLORS)
+    if n_stickers != 24:
+        # Unknown shape; still try to decode row-wise
+        pass
+    # decode one-hot to color letter per sticker
+    stickers: List[str] = []
+    for i in range(n_stickers):
+        base = i * len(COLORS)
+        cell = state_vec[base: base + len(COLORS)]
+        idx = max(range(len(COLORS)), key=lambda k: cell[k])
+        c = COLORS[idx] if 0 <= idx < len(COLORS) else '?'
+        stickers.append(c)
+    # format faces (4 stickers per face)
+    faces = [stickers[i*4:(i+1)*4] for i in range(6)]
+    face_names = ["Up (U)", "Left (L)", "Front (F)", "Right (R)", "Back (B)", "Down (D)"]
+    lines = ["=== Rubik's Cube 2x2 State ===\n"]
+    for name, face in zip(face_names, faces):
+        lines.append(f"{name}: [{face[0]}, {face[1]}] \n [{face[2]}, {face[3]}]")
+    lines.append("\nAvailable actions: \n" + ", ".join(RUBIK_ACTIONS))
+    return "\n".join(lines)
+
+
+def build_messages_for_episode(
+    states: List[List[float]],
+    actions: List[int],
+    rewards: List[float],
+    instruction: str,
+    max_tokens: int,
+    action_sep: str,
+    enable_think: bool,
+    max_actions: int,
+) -> List[dict]:
+    messages = [
+        {"role": "system", "content": "You're a helpful assistant. "},
+        {"role": "user", "content": instruction},
+    ]
+
+    total_actions = len(actions)
+    for t, state in enumerate(states):
+        state_text = decode_state_to_text(state)
+        actions_left = max(0, max_actions - t)
+        format_prompt = (
+            "<think> [Your thoughts] </think> <answer> [your answer] </answer>"
+            if enable_think
+            else "<answer> [your answer] </answer>"
+        )
+        length_prompt = f"Max response length: {max_tokens} words (tokens)."
+
+        messages[-1]["content"] += (
+            f"\nTurn {t + 1}:\n"
+            f"State:\n{state_text}\n"
+            f"\nWhat is your next move?\n"
+            f"You have {actions_left} actions left. Always output: {format_prompt}"
+            f"with no extra text. {length_prompt}"
+        )
+
+        if t < total_actions:
+            a = actions[t]
+            a_name = RUBIK_ACTIONS[int(a)] if 0 <= int(a) < len(RUBIK_ACTIONS) else str(a)
+            if enable_think:
+                assistant_text = f"<think> </think><answer>{a_name}</answer>"
+            else:
+                assistant_text = f"<answer>{a_name}</answer>"
+            messages.append({"role": "assistant", "content": assistant_text})
+            r = rewards[t] if t < len(rewards) else 0.0
+            messages.append({"role": "user", "content": f"Reward:\n{r}\n"})
+    # import pdb;pdb.set_trace()
+    return messages[:-1]
+
+
+def find_latest_step_dir(traj_root: Path) -> Path:
+    step_dirs = [p for p in traj_root.iterdir() if p.is_dir() and p.name.startswith("step_")]
+    if not step_dirs:
+        raise FileNotFoundError(f"No step_* directories under {traj_root}")
+    step_dirs.sort(key=lambda p: int(p.name.split("_")[-1]))
+    return step_dirs[-1]
+
+
+def convert_file(step_dir: Path, output_dir: Path, repo_root: Path, include_failed: bool, max_actions_cap: int | None) -> Path:
+    traj_path = step_dir / "trajectories.jsonl"
+    metrics_path = step_dir / "metrics.json"
+    if not traj_path.exists():
+        raise FileNotFoundError(f"Missing trajectories.jsonl at {traj_path}")
+
+    instruction, max_tokens, action_sep, enable_think, default_max_actions = load_env_instruction_and_cfg(repo_root)
+    max_actions = int(max_actions_cap) if max_actions_cap is not None else int(default_max_actions)
+
+    output_dir.mkdir(parents=True, exist_ok=True)
+    out_path = output_dir / f"{step_dir.name}_sft.jsonl"
+
+    # Read global step from metrics if available
+    global_step = None
+    if metrics_path.exists():
+        try:
+            with open(metrics_path, "r", encoding="utf-8") as f:
+                m = json.load(f)
+            global_step = m.get("global_step")
+        except Exception:
+            pass
+
+    written = 0
+    with open(traj_path, "r", encoding="utf-8") as fin, open(out_path, "w", encoding="utf-8") as fout:
+        for line in fin:
+            line = line.strip()
+            if not line:
+                continue
+            traj = json.loads(line)
+
+            ep_success = bool(traj.get("episode_success", False))
+            if (not include_failed) and (not ep_success):
+                continue
+
+            states = traj.get("states", [])
+            actions = traj.get("actions", [])
+            rewards = traj.get("rewards", [])
+            if len(actions) > max_actions:
+                continue
+
+            messages = build_messages_for_episode(
+                states=states,
+                actions=actions,
+                rewards=rewards,
+                instruction=instruction,
+                max_tokens=max_tokens,
+                action_sep=action_sep,
+                enable_think=enable_think,
+                max_actions=max_actions,
+            )
+
+            record = {
+                "messages": messages,
+                "meta": {
+                    "episode_return": traj.get("episode_return", None),
+                    "episode_success": ep_success,
+                    "global_step": global_step,
+                },
+            }
+            fout.write(json.dumps(record, ensure_ascii=False) + "\n")
+            written += 1
+
+    if written == 0:
+        with open(out_path, "w", encoding="utf-8"):
+            pass
+    return out_path
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Convert Rubik's Cube 2x2 RL trajectories to LLM SFT chat JSONL")
+    parser.add_argument("run_dir", help="Path to the run directory (contains trajectories/)")
+    parser.add_argument("--step", default=None, help="Specific step directory name (e.g., step_123456)")
+    parser.add_argument("--include_failed", action="store_true", help="Include failed episodes in SFT data")
+    parser.add_argument("--max_actions", type=int, default=None, help="Override max actions cap (default from envs.yaml)")
+    args = parser.parse_args()
+
+    repo_root = Path(__file__).resolve().parents[1]
+    run_dir = Path(args.run_dir)
+    traj_root = run_dir / "trajectories"
+    if not traj_root.exists():
+        raise FileNotFoundError(f"Not found trajectories directory: {traj_root}")
+
+    step_dir = traj_root / args.step if args.step else find_latest_step_dir(traj_root)
+    output_dir = run_dir / "sft"
+    out_path = convert_file(step_dir=step_dir, output_dir=output_dir, repo_root=repo_root, include_failed=args.include_failed, max_actions_cap=args.max_actions)
+    print(f"SFT data written to: {out_path}")
+
+
+if __name__ == "__main__":
+    main()

scripts/convert_rl_to_sft_sokoban.py

@@ -0,0 +1,273 @@
+#!/usr/bin/env python3
+import argparse
+import json
+import os
+from pathlib import Path
+from typing import List, Tuple
+
+try:
+    import yaml  # type: ignore
+except Exception:
+    yaml = None
+
+# Sokoban tokens and actions (as used by SokobanWrapper)
+TOKENS = ['#', '_', 'O', '√', 'X', 'P', 'S']
+ACTION_LOOKUP = {1: 'Up', 2: 'Down', 3: 'Left', 4: 'Right'}
+
+
+def infer_grid_dims(state_arr: List[List[List[float]]]) -> Tuple[int, int, int]:
+    c = len(state_arr)
+    h = len(state_arr[0]) if c > 0 else 0
+    w = len(state_arr[0][0]) if (c > 0 and h > 0) else 0
+    return c, h, w
+
+
+def decode_state_to_grid_text(state_arr: List[List[List[float]]]) -> str:
+    c, h, w = infer_grid_dims(state_arr)
+    lines = []
+    for i in range(h):
+        row = []
+        for j in range(w):
+            argmax_k = 0
+            vmax = -1e9
+            for k in range(c):
+                v = state_arr[k][i][j]
+                if v > vmax:
+                    vmax = v
+                    argmax_k = k
+            ch = TOKENS[argmax_k] if 0 <= argmax_k < len(TOKENS) else '_'
+            row.append(ch)
+        lines.append(''.join(row))
+    return '\n'.join(lines)
+
+
+def parse_positions_from_state(state_arr: List[List[List[float]]]):
+    """Extract board size, targets, boxes, and player coordinates from one-hot state.
+    - Tokens index mapping per TOKENS: 0 '#', 1 '_', 2 'O'(target), 3 '√'(box on target), 4 'X'(box), 5 'P'(player), 6 'S'(player on target)
+    - Targets include cells with 'O' or '√'.
+    - Boxes include cells with 'X' or '√'.
+    - Player is where token is 'P' or 'S'.
+    Returns: (rows, cols, targets: List[(r,c)], boxes: List[(r,c)], player: (r,c) or None)
+    """
+    c, h, w = infer_grid_dims(state_arr)
+    targets: List[Tuple[int, int]] = []
+    boxes: List[Tuple[int, int]] = []
+    player: Tuple[int, int] | None = None
+    for i in range(h):
+        for j in range(w):
+            # argmax over channels
+            argk = 0
+            vmax = -1e9
+            for k in range(c):
+                v = state_arr[k][i][j]
+                if v > vmax:
+                    vmax = v
+                    argk = k
+            if argk == 2:  # 'O' target
+                targets.append((i, j))
+            elif argk == 3:  # '√' box on target (both a box and a target)
+                targets.append((i, j))
+                boxes.append((i, j))
+            elif argk == 4:  # 'X' box
+                boxes.append((i, j))
+            elif argk == 5 or argk == 6:  # 'P' or 'S' (player or player on target)
+                player = (i, j)
+    return h, w, targets, boxes, player
+
+
+def load_env_instruction_and_cfg(repo_root: Path) -> Tuple[str, int, str, bool]:
+    instruction = (
+        "You are solving the Sokoban puzzle. You are the player and you need to push all boxes to targets. "
+        "When you are right next to a box, you can push it by moving in the same direction. "
+        "You cannot push a box through a wall, and you cannot pull a box. "
+        "The answer should be a sequence of actions, like <answer>Right || Right || Up</answer>\n"
+        "\nThe meaning of each symbol in the state is:\n"
+        "#: wall, _: empty, O: target, √: box on target, X: box, P: player, S: player on target\n"
+        "Your available actions are:\n"
+        "Up, Down, Left, Right\n"
+        "You can make up to 10 actions, separated by the action separator \" || \"\n"
+    )
+    max_tokens = 100
+    action_sep = "||"
+    enable_think = True
+
+    if yaml is None:
+        return instruction, max_tokens, action_sep, enable_think
+
+    envs_yaml = repo_root / "config" / "envs.yaml"
+    if envs_yaml.exists():
+        try:
+            with open(envs_yaml, "r", encoding="utf-8") as f:
+                envs = yaml.safe_load(f)
+            custom_envs = envs.get("custom_envs", {}) if isinstance(envs, dict) else {}
+            if isinstance(custom_envs, dict):
+                # Prefer CoordSokoban, fallback to SimpleSokoban, then LargerSokoban
+                for key in ["CoordSokoban", "SimpleSokoban", "LargerSokoban", "SokobanDifferentGridVocab"]:
+                    if key in custom_envs:
+                        cfg = custom_envs[key]
+                        instruction = cfg.get("env_instruction", instruction)
+                        max_tokens = int(cfg.get("max_tokens", max_tokens))
+                        break
+        except Exception:
+            pass
+
+    base_yaml = repo_root / "config" / "base.yaml"
+    if base_yaml.exists():
+        try:
+            with open(base_yaml, "r", encoding="utf-8") as f:
+                base_cfg = yaml.safe_load(f)
+            ap = base_cfg.get("agent_proxy", {}) if isinstance(base_cfg, dict) else {}
+            action_sep = ap.get("action_sep", action_sep)
+            enable_think = bool(ap.get("enable_think", enable_think))
+        except Exception:
+            pass
+
+    return instruction, max_tokens, action_sep, enable_think
+
+
+def build_messages_for_episode(
+    states: List[List[List[List[float]]]],
+    actions: List[int],
+    rewards: List[float],
+    instruction: str,
+    max_tokens: int,
+    action_sep: str,
+    enable_think: bool,
+    max_actions: int,
+) -> List[dict]:
+    messages = [
+        {"role": "system", "content": "You're a helpful assistant. "},
+        {"role": "user", "content": instruction},
+    ]
+
+    total_actions = len(actions)
+    # states contain T+1 elements typically; we iterate over min(len(states), len(actions)) turns
+    for t, state in enumerate(states):
+        grid_text = decode_state_to_grid_text(state)
+        rows, cols, targets_pos, boxes_pos, player_pos = parse_positions_from_state(state)
+        actions_left = max(0, max_actions - t)
+        if enable_think:
+            format_prompt = "<think> [Your thoughts] </think> <answer> [your answer] </answer>"
+        else:
+            format_prompt = "<answer> [your answer] </answer>"
+        length_prompt = f"Max response length: {max_tokens} words (tokens)."
+
+        messages[-1]["content"] += (
+            f"\nTurn {t + 1}:\n"
+            f"State:\n"
+            f"Coordinates:\n"
+            f"Board size: {rows} rows x {cols} cols (zero-indexed).\n"
+            f"Targets: {targets_pos}\n"
+            f"Boxes: {boxes_pos}\n"
+            f"Player: {player_pos if player_pos is not None else (-1, -1)}\n"
+            f"Grid Map:\n{grid_text}\n"
+            f"You have {actions_left} actions left. Always output: {format_prompt}"
+            f"with no extra text. Strictly follow this format. {length_prompt}"
+        )
+
+        if t < total_actions:
+            action_id = actions[t] + 1  # map 0..3 -> 1..4
+            action_name = ACTION_LOOKUP.get(action_id, "unknown")
+            assistant_text = f"<answer>{action_name}</answer>" if not enable_think else f"<think></think><answer>{action_name}</answer>"
+            messages.append({"role": "assistant", "content": assistant_text})
+            reward_val = rewards[t] if t < len(rewards) else 0.0
+            messages.append({"role": "user", "content": f"Reward:\n{reward_val}\n"})
+
+    return messages[:-1]
+
+
+def convert_file(step_dir: Path, output_dir: Path, repo_root: Path, include_failed: bool = False, max_actions: int = 10) -> Path:
+    traj_path = step_dir / "trajectories.jsonl"
+    metrics_path = step_dir / "metrics.json"
+    if not traj_path.exists():
+        raise FileNotFoundError(f"Missing trajectories.jsonl at {traj_path}")
+
+    instruction, max_tokens, action_sep, enable_think = load_env_instruction_and_cfg(repo_root)
+
+    output_dir.mkdir(parents=True, exist_ok=True)
+    out_path = output_dir / f"{step_dir.name}_sft.jsonl"
+
+    global_step = None
+    if metrics_path.exists():
+        try:
+            with open(metrics_path, "r", encoding="utf-8") as f:
+                m = json.load(f)
+            global_step = m.get("global_step")
+        except Exception:
+            pass
+
+    written = 0
+    with open(traj_path, "r", encoding="utf-8") as fin, open(out_path, "w", encoding="utf-8") as fout:
+        for line in fin:
+            line = line.strip()
+            if not line:
+                continue
+            traj = json.loads(line)
+            ep_success = bool(traj.get("episode_success", False))
+            if (not include_failed) and (not ep_success):
+                continue
+
+            states = traj.get("states", [])
+            actions = traj.get("actions", [])
+            rewards = traj.get("rewards", [])
+            if len(actions) > max_actions:
+                continue
+
+            messages = build_messages_for_episode(
+                states=states,
+                actions=actions,
+                rewards=rewards,
+                instruction=instruction,
+                max_tokens=max_tokens,
+                action_sep=action_sep,
+                enable_think=enable_think,
+                max_actions=max_actions,
+            )
+
+            record = {
+                "messages": messages,
+                "meta": {
+                    "episode_return": traj.get("episode_return", None),
+                    "episode_success": ep_success,
+                    "global_step": global_step,
+                },
+            }
+            fout.write(json.dumps(record, ensure_ascii=False) + "\n")
+            written += 1
+
+    if written == 0:
+        with open(out_path, "w", encoding="utf-8") as f:
+            pass
+    return out_path
+
+
+def find_latest_step_dir(traj_root: Path) -> Path:
+    step_dirs = [p for p in traj_root.iterdir() if p.is_dir() and p.name.startswith("step_")]
+    if not step_dirs:
+        raise FileNotFoundError(f"No step_* directories under {traj_root}")
+    step_dirs.sort(key=lambda p: int(p.name.split("_")[-1]))
+    return step_dirs[-1]
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Convert Sokoban RL trajectories to LLM SFT chat JSONL")
+    parser.add_argument("run_dir", help="Path to the run directory (contains trajectories/)")
+    parser.add_argument("--step", default=None, help="Specific step directory name (e.g., step_993280)")
+    parser.add_argument("--include_failed", action="store_true", help="Include failed episodes in SFT data")
+    parser.add_argument("--max_actions", type=int, default=15, help="Max actions cap for filtering and counter display")
+    args = parser.parse_args()
+
+    repo_root = Path(__file__).resolve().parents[1]
+    run_dir = Path(args.run_dir)
+    traj_root = run_dir / "trajectories"
+    if not traj_root.exists():
+        raise FileNotFoundError(f"Not found trajectories directory: {traj_root}")
+
+    step_dir = traj_root / args.step if args.step else find_latest_step_dir(traj_root)
+    output_dir = run_dir / "sft"
+    out_path = convert_file(step_dir=step_dir, output_dir=output_dir, repo_root=repo_root, include_failed=args.include_failed, max_actions=args.max_actions)
+    print(f"SFT data written to: {out_path}")
+
+
+if __name__ == "__main__":
+    main()

scripts/convert_rl_to_sft_sudoku.py

@@ -0,0 +1,342 @@
+#!/usr/bin/env python3
+import argparse
+import json
+import math
+from pathlib import Path
+from typing import List, Tuple, Set, Dict
+
+def infer_grid_size_from_state_len(n: int) -> int:
+    """Given flattened one-hot length n = G*G*(G+1), solve for integer G."""
+    for G in range(2, 17):
+        if G * G * (G + 1) == n:
+            return G
+    raise ValueError(f"Cannot infer grid size from state length {n}")
+
+def state_to_matrix(state_vec: List[float], G: int) -> List[List[int]]:
+    """Convert one-hot vector to GxG integer matrix."""
+    cell_dim = G + 1
+    matrix = []
+    for r in range(G):
+        row = []
+        for c in range(G):
+            base = (r * G + c) * cell_dim
+            cell_data = state_vec[base : base + cell_dim]
+            # argmax to find value
+            val = 0
+            max_v = -1e9
+            for k, v in enumerate(cell_data):
+                if v > max_v:
+                    max_v = v
+                    val = k
+            row.append(val)
+        matrix.append(row)
+    return matrix
+
+def check_conflict(grid: List[List[int]], r: int, c: int, val: int, G: int) -> bool:
+    """Check if placing val at (r,c) causes a conflict in current grid."""
+    if val == 0:
+        return False
+        
+    # Row check
+    for j in range(G):
+        if j != c and grid[r][j] == val:
+            return True
+    # Col check
+    for i in range(G):
+        if i != r and grid[i][c] == val:
+            return True
+    # Box check
+    box_size = int(math.sqrt(G))
+    br, bc = (r // box_size) * box_size, (c // box_size) * box_size
+    for i in range(br, br + box_size):
+        for j in range(bc, bc + box_size):
+            if (i, j) != (r, c) and grid[i][j] == val:
+                return True
+    return False
+
+def get_valid_moves(grid: List[List[int]], G: int) -> Dict[Tuple[int, int], List[int]]:
+    """Compute valid numbers for all empty cells."""
+    valid_moves = {}
+    box_size = int(math.sqrt(G))
+    
+    for r in range(G):
+        for c in range(G):
+            if grid[r][c] == 0:
+                possibles = []
+                for v in range(1, G + 1):
+                    is_row_ok = all(grid[r][j] != v for j in range(G))
+                    is_col_ok = all(grid[i][c] != v for i in range(G))
+                    br, bc = (r // box_size) * box_size, (c // box_size) * box_size
+                    is_box_ok = True
+                    for i in range(br, br + box_size):
+                        for j in range(bc, bc + box_size):
+                            if grid[i][j] == v:
+                                is_box_ok = False
+                                break
+                    if is_row_ok and is_col_ok and is_box_ok:
+                        possibles.append(v)
+                if possibles:
+                    valid_moves[(r + 1, c + 1)] = possibles # 1-indexed keys
+    return valid_moves
+
+def render_ascii_board(grid: List[List[int]], initial_grid: List[List[int]], G: int) -> str:
+    """Render the board in the rich ASCII format seen in logs."""
+    box_size = int(math.sqrt(G))
+    lines = []
+    
+    header = "=" * 50 + "\nSUDOKU PUZZLE\n" + "=" * 50
+    lines.append(header)
+
+    for r in range(G):
+        if r > 0 and r % box_size == 0:
+            row_sep = []
+            for c in range(G):
+                if c > 0 and c % box_size == 0:
+                    row_sep.append("-") 
+                row_sep.append("----")
+            lines.append("-" * (G * 4 + int(G/box_size)*2))
+
+        row_str = []
+        for c in range(G):
+            if c > 0 and c % box_size == 0:
+                row_str.append("|")
+            
+            val = grid[r][c]
+            is_init = (initial_grid[r][c] != 0)
+            
+            if val == 0:
+                cell_str = " . "
+            else:
+                is_conflict = check_conflict(grid, r, c, val, G)
+                if is_conflict and not is_init:
+                    cell_str = f"*{val}*"
+                elif is_init:
+                    cell_str = f"[{val}]"
+                else:
+                    cell_str = f" {val} " # User placed
+            
+            row_str.append(cell_str)
+        
+        lines.append("".join(row_str))
+
+    lines.append("\nLegend: [N]=initial cell, N=user-placed, *N*=conflict, .=empty")
+    return "\n".join(lines)
+
+def decode_action(action_id: int, G: int) -> Tuple[int, int, int]:
+    """Map discrete id -> 1-indexed (row, col, num)."""
+    row0 = action_id // (G * G)
+    rem = action_id % (G * G)
+    col0 = rem // G
+    num = (rem % G) + 1
+    return row0 + 1, col0 + 1, num
+
+def build_messages_for_episode(
+    states: List[List[float]],
+    actions: List[int],
+    rewards: List[float],
+    max_tokens: int,
+    max_actions: int,
+) -> List[dict]:
+    
+    # Infer G from first state
+    G = infer_grid_size_from_state_len(len(states[0]))
+    box_size = int(math.sqrt(G))
+    
+    grid_history = [state_to_matrix(s, G) for s in states]
+    initial_grid = grid_history[0] 
+    
+    sys_msg = "You're a helpful assistant. "
+    
+    intro_prompt = (
+        f"You are solving a Sudoku puzzle. Fill in the grid so that every row, column, "
+        f"and {box_size}x{box_size} box contains the numbers 1-{G} without repetition.\n"
+        "Initial cells are shown in [brackets] and cannot be modified. Empty cells are shown as dots (.).\n"
+        "Place numbers one at a time using the format: <answer>place 1 at row 2 col 3</answer> or <answer>1,2,3</answer>\n"
+        "The environment will provide feedback on valid/invalid moves and show conflicts if any occur.\n"
+    )
+
+    messages = [
+        {"role": "system", "content": sys_msg},
+        {"role": "user", "content": intro_prompt},
+    ]
+
+    # Main loop iterates over steps
+    for t in range(len(states)):
+        # If this state corresponds to a step where no action was taken (end of episode), stop
+        if t >= len(actions):
+            break
+
+        current_grid = grid_history[t]
+        actions_left = max(0, max_actions - t)
+        
+        # --- 1. Prepare Reward String (Combined into this User turn) ---
+        # If t > 0, we have a reward from the previous action (at t-1)
+        reward_prefix = ""
+        if t > 0:
+            prev_reward = rewards[t-1] if (t-1) < len(rewards) else 0.0
+            # Double newline to separate from the previous content logically
+            reward_prefix = f"Reward:\n{prev_reward}\n\n"
+
+        # --- 2. Render Board ---
+        board_str = render_ascii_board(current_grid, initial_grid, G)
+        
+        # --- 3. Calc Valid Moves ---
+        valid_map = get_valid_moves(current_grid, G)
+        valid_str_lines = ["\n💡 VALID NUMBERS FOR EMPTY CELLS:"]
+        sorted_keys = sorted(valid_map.keys())
+        if not sorted_keys:
+            valid_str_lines.append("   (None)")
+        else:
+            count = 0
+            for (r, c) in sorted_keys:
+                vals = valid_map[(r,c)]
+                valid_str_lines.append(f"   - ({r},{c}): {vals}")
+                count += 1
+                if count > 15: 
+                    valid_str_lines.append("   ... (list truncated)")
+                    break
+        # valid_section = "\n".join(valid_str_lines)
+        valid_section = ""
+
+        # --- 4. Stats ---
+        total_cells = G * G
+        filled_cells = sum(1 for r in range(G) for c in range(G) if current_grid[r][c] != 0)
+        init_cells = sum(1 for r in range(G) for c in range(G) if initial_grid[r][c] != 0)
+        placed_cells = filled_cells - init_cells
+        if placed_cells < 0: placed_cells = 0
+
+        stats_section = (
+            f"\nProgress: {filled_cells}/{total_cells} cells filled ({init_cells} initial, {placed_cells} placed)\n"
+            f"Steps: {t}/{max_actions}"
+        )
+
+        # --- 5. Construct User Content ---
+        turn_header = f"Turn {t + 1}:\nState:"
+        
+        constraint_prompt = (
+            f"You have {actions_left} actions left. Always output: <think> [Your thoughts] </think> "
+            f"<answer> [your answer] </answer> with no extra text. Strictly follow this format. "
+            f"Max response length: {max_tokens} words (tokens)."
+        )
+
+        # COMBINE: Reward + Header + Board + Valid + Stats + Constraint
+        full_user_text = (
+            f"{reward_prefix}{turn_header}\n"
+            f"{board_str}{valid_section}\n{stats_section}\n{constraint_prompt}"
+        )
+
+        # --- 6. Append to Messages ---
+        if t == 0:
+            # First turn: Append to the "Intro" user message
+            messages[-1]["content"] += ("\n" + full_user_text)
+        else:
+            # Subsequent turns: New User message containing (Reward + State)
+            messages.append({"role": "user", "content": full_user_text})
+
+        # --- 7. Assistant Response ---
+        r_act, c_act, n_act = decode_action(actions[t], G)
+        ans_text = f"place {n_act} at row {r_act} col {c_act}"
+        assistant_text = f"<think> </think><answer>{ans_text}</answer>"
+        messages.append({"role": "assistant", "content": assistant_text})
+
+    return messages
+
+def convert_file(step_dir: Path, output_dir: Path, include_failed: bool = False, max_actions_override: int | None = None) -> Path:
+    traj_path = step_dir / "trajectories.jsonl"
+    metrics_path = step_dir / "metrics.json"
+    
+    if not traj_path.exists():
+        raise FileNotFoundError(f"Missing trajectories.jsonl at {traj_path}")
+
+    max_tokens = 150
+    
+    output_dir.mkdir(parents=True, exist_ok=True)
+    out_path = output_dir / f"{step_dir.name}_sft.jsonl"
+
+    global_step = None
+    if metrics_path.exists():
+        try:
+            with open(metrics_path, "r", encoding="utf-8") as f:
+                m = json.load(f)
+            global_step = m.get("global_step")
+        except Exception:
+            pass
+
+    written = 0
+    with open(traj_path, "r", encoding="utf-8") as fin, open(out_path, "w", encoding="utf-8") as fout:
+        for line in fin:
+            line = line.strip()
+            if not line:
+                continue
+            traj = json.loads(line)
+            ep_success = bool(traj.get("episode_success", False))
+            if (not include_failed) and (not ep_success):
+                continue
+
+            states = traj.get("states", [])
+            actions = traj.get("actions", [])
+            rewards = traj.get("rewards", [])
+
+            if not states:
+                continue
+
+            G = infer_grid_size_from_state_len(len(states[0]))
+            if max_actions_override is not None:
+                eff_max = max_actions_override
+            else:
+                eff_max = 20 if G == 4 else int(G*G * 1.5)
+
+            messages = build_messages_for_episode(
+                states=states,
+                actions=actions,
+                rewards=rewards,
+                max_tokens=max_tokens,
+                max_actions=eff_max,
+            )
+
+            record = {
+                "messages": messages,
+                "meta": {
+                    "episode_return": traj.get("episode_return", None),
+                    "episode_success": ep_success,
+                    "global_step": global_step,
+                },
+            }
+            fout.write(json.dumps(record, ensure_ascii=False) + "\n")
+            written += 1
+
+    return out_path
+
+def find_latest_step_dir(traj_root: Path) -> Path:
+    step_dirs = [p for p in traj_root.iterdir() if p.is_dir() and p.name.startswith("step_")]
+    if not step_dirs:
+        raise FileNotFoundError(f"No step_* directories under {traj_root}")
+    step_dirs.sort(key=lambda p: int(p.name.split("_")[-1]))
+    return step_dirs[-1]
+
+def main():
+    parser = argparse.ArgumentParser(description="Convert Sudoku RL trajectories to LLM SFT chat JSONL (Rich Format, Merged Reward)")
+    parser.add_argument("run_dir", help="Path to the run directory (contains trajectories/)")
+    parser.add_argument("--step", default=None, help="Specific step directory name")
+    parser.add_argument("--include_failed", action="store_true", help="Include failed episodes")
+    parser.add_argument("--max_actions", type=int, default=None, help="Max actions cap display")
+    args = parser.parse_args()
+
+    run_dir = Path(args.run_dir)
+    traj_root = run_dir / "trajectories"
+    if not traj_root.exists():
+        raise FileNotFoundError(f"Not found trajectories directory: {traj_root}")
+
+    step_dir = traj_root / args.step if args.step else find_latest_step_dir(traj_root)
+    output_dir = run_dir / "sft"
+    
+    out_path = convert_file(
+        step_dir=step_dir, 
+        output_dir=output_dir, 
+        include_failed=args.include_failed, 
+        max_actions_override=args.max_actions
+    )
+    print(f"SFT data written to: {out_path}")
+
+if __name__ == "__main__":
+    main()

scripts/download_data.py

@@ -0,0 +1,38 @@
+#!/usr/bin/env python3
+
+import os
+from huggingface_hub import snapshot_download
+
+def download_datasets(repo_id="ZihanWang314/ragen-datasets", local_dir="data"):
+    """
+    Download all datasets from Hugging Face Hub to local directory.
+    
+    Args:
+        repo_id (str): Hugging Face repository ID
+        local_dir (str): Local directory to save datasets
+    """
+    print(f"Downloading datasets from {repo_id}...")
+
+    url = "https://huggingface.co/datasets/Jiayi-Pan/Countdown-Tasks-3to4/resolve/main/data/train-00000-of-00001.parquet"
+    os.makedirs("data/countdown", exist_ok=True)
+    os.system(f"wget {url} -O data/countdown/train.parquet")
+    
+    # Create the data directory if it doesn't exist
+    os.makedirs(local_dir, exist_ok=True)
+
+    try:
+        # Download the entire repository
+        snapshot_download(
+            repo_id=repo_id,
+            repo_type="dataset",
+            local_dir=local_dir,
+            local_dir_use_symlinks=False
+        )
+        print(f"\nDatasets successfully downloaded to {local_dir}/")
+        
+    except Exception as e:
+        print(f"Error downloading datasets: {e}")
+        return False
+
+if __name__ == "__main__":
+    download_datasets()

scripts/nothink_dataset.py

@@ -0,0 +1,58 @@
+import json
+
+# with open("/mnt/general/wanghy/RAGEN/runs/Game2048NoisyDQN__noisy_dqn_2048_refined__1__1765041200/sft/step_300000_sft_singleturn_slidewindows5_7000score.json") as f:
+#     dataset1 = json.load(f)
+
+with open("/mnt/general/wanghy/RAGEN/runs/BanditDQN__dqn_bandit_nochangeenv__1__1764233298/sft/step_50000_sft.json") as f:
+    dataset2 = json.load(f)
+
+with open("/mnt/general/wanghy/RAGEN/runs/RubiksCube2x2__ppo_rubikscube1_1218/sft/step_999424_sft_singleturn.json") as f:
+    dataset3 = json.load(f)
+
+with open("/mnt/general/wanghy/RAGEN/runs/RubiksCube2x2__ppo_rubikscube2_1219_turn5/sft/step_999424_sft_singleturn.json") as f:
+    dataset4 = json.load(f)
+
+with open("/mnt/general/wanghy/RAGEN/runs/RubiksCube2x2__ppo_rubikscube3_1219_turn5_6000/sft/step_999424_sft_singleturn.json") as f:
+    dataset5 = json.load(f)
+
+with open("/mnt/general/wanghy/RAGEN/runs/FrozenLake__ppo_frozenlake_nochangeenv__p0.9_slippery/sft/step_1986560_sft_slippery_singleturn.json") as f:
+    dataset6 = json.load(f)
+
+with open("/mnt/general/wanghy/RAGEN/runs/SokobanNoisyDQN__noisy_dqn_sokoban__1__1764155447/sft/step_1000000_sft_singleturn.json") as f:
+    dataset7 = json.load(f)
+
+with open("/mnt/general/wanghy/RAGEN/runs/SokobanNoisyDQN__noisy_dqn_sokoban__1__1764155464/sft/step_1000000_sft_singleturn.json") as f:
+    dataset8 = json.load(f)
+
+with open("/mnt/general/wanghy/RAGEN/runs/Sudoku__ppo_sudoku_actionmask__4x4/sft/step_999424_sft_singleturn_nohint.json") as f:
+    dataset9 = json.load(f)
+
+
+data = dataset2 +dataset3 +dataset4 +dataset5 +dataset6 +dataset7 +dataset8 +dataset9
+
+target_user_str = " <think> [Your thoughts] </think>" 
+target_assistant_str1 = "<think></think>"
+target_assistant_str2 = "<think> </think>"
+
+# 2. 遍历数据并进行替换
+# 假设 data 是一个列表，列表里每个元素都有 "messages" 字段
+if isinstance(data, list):
+    for entry in data:
+        if "messages" in entry:
+            for msg in entry["messages"]:
+                role = msg.get("role")
+                content = msg.get("content", "")
+                
+                # 处理 User
+                if role == "user":
+                    if target_user_str in content:
+                        msg["content"] = content.replace(target_user_str, "")
+                
+                # 处理 Assistant
+                elif role == "assistant":
+                    if (target_assistant_str1 in content) or (target_assistant_str2 in content):
+                        msg["content"] = content.replace(target_assistant_str1, "").replace(target_assistant_str2, "")
+import pdb;pdb.set_trace()
+# 3. 将修改后的数据保存为新文件
+with open("/mnt/general/wanghy/RAGEN/runs/multitask_nothink/sft_no2048.json", 'w', encoding='utf-8') as f:
+    json.dump(data, f, ensure_ascii=False, indent=2)

scripts/ppl_2048.py

@@ -0,0 +1,105 @@
+import torch
+from transformers import AutoModelForCausalLM, AutoTokenizer
+import math
+
+# 1. 加载模型和分词器
+# 注意：第一次运行会自动从 Hugging Face 下载模型，约需 3GB 显存或内存
+model_name = "Qwen/Qwen2.5-1.5B-Instruct"
+device = "cuda" if torch.cuda.is_available() else "cpu"
+
+print(f"Loading {model_name} on {device}...")
+try:
+    tokenizer = AutoTokenizer.from_pretrained(model_name, trust_remote_code=True)
+    model = AutoModelForCausalLM.from_pretrained(model_name, device_map=device, trust_remote_code=True)
+    model.eval() # 设置为评估模式
+except Exception as e:
+    print(f"Error loading model: {e}")
+    exit()
+
+def calculate_perplexity(text):
+    """
+    计算给定文本字符串的困惑度 (PPL)
+    """
+    # 对输入文本进行编码
+    encodings = tokenizer(text, return_tensors="pt")
+    input_ids = encodings.input_ids.to(device)
+
+    # 计算 Loss (NLL)
+    # labels=input_ids 会让模型自动计算 CrossEntropyLoss
+    with torch.no_grad():
+        outputs = model(input_ids, labels=input_ids)
+        loss = outputs.loss
+
+    # PPL = exp(Loss)
+    ppl = torch.exp(loss).item()
+    return ppl
+
+# ==========================================
+# 场景 1: 2048 游戏
+# ==========================================
+def run_2048_test():
+    # 模拟一个 2048 的原始符号状态 (Raw Symbolic State)
+    # 论文指出这种原始数字矩阵通常具有较高的 PPL
+    state_2048 = (
+        "Turn 15:"
+        "#2 #4 #8 #2 \n . "
+        " #16 #64 #32 #512 \n "
+        ". #0 #2 #0 #256. . #0 #128 #0 #4  "
+    )
+    "\nCurrent 2048 Grid:\nRow 1: [2, 4, 8, 2]\nRow 2: [16, 64, 32, 512]\nRow 3: [0, 2, 0, 256]\nRow 4: [0, 128, 0 4]\n"
+    # 2048 的随机基准：数字种类 (0, 2, 4, 8... 2048) 约为 12 种
+    baseline_2048 = 12 
+    
+    ppl = calculate_perplexity(state_2048)
+    
+    print("-" * 30)
+    print("TASK: 2048 Game")
+    print(f"Input State:\n{state_2048}")
+    print(f"\nRandom Guess Baseline (#States): ~{baseline_2048}")
+    print(f"Model Perplexity (PPL): {ppl:.2f}")
+    
+    if ppl > baseline_2048: # 简单的倍数阈值判断
+        print(">> 结论: OOD 环境 (模型看不懂这个数字矩阵)")
+    else:
+        print(">> 结论: In-Domain 环境 (模型对这种排列很熟悉)")
+
+# ==========================================
+# 场景 2: 二阶魔方 (2x2 Rubik's Cube)
+# ==========================================
+def run_cube_test():
+    # 模拟一个二阶魔方的展开图状态 (Raw Symbolic State)
+    # U=Up, F=Front, R=Right, D=Down, L=Left, B=Back
+    # 这里模拟一个打乱后的状态
+    state_cube = (
+        "Cube State:\n"
+        "  U R\n"
+        "  F U\n"
+        "L D F R B U\n"
+        "L B R D F L\n"
+        "  D B\n"
+        "  R B"
+    )
+    
+    # 魔方的随机基准：只有 6 种颜色
+    baseline_cube = 6
+    
+    ppl = calculate_perplexity(state_cube)
+    
+    print("-" * 30)
+    print("TASK: 2x2 Rubik's Cube")
+    print(f"Input State:\n{state_cube}")
+    print(f"\nRandom Guess Baseline (#States): {baseline_cube}")
+    print(f"Model Perplexity (PPL): {ppl:.2f}")
+    
+    if ppl > baseline_cube * 2:
+        print(">> 结论: OOD 环境 (模型难以解析空间展开图)")
+    else:
+        print(">> 结论: In-Domain 环境")
+
+# ==========================================
+# 执行测试
+# ==========================================
+if __name__ == "__main__":
+    print("Starting PPL Calculation based on paper methodology[cite: 174]...")
+    run_2048_test()
+    run_cube_test()

scripts/runs/bandit_jobs.sh

@@ -0,0 +1,227 @@
+#!/bin/bash
+# Experiments: Bandit 3B base PPO/GRPO contrast (normal vs StarPO-S) with entropy and instruct ablations.
+# Args: 400 steps, lr_actor=1e-6, lr_critic=1e-5, micro_batch=1, env tags=[Bandit] with BanditTest validation; StarPO-S disables reference, optional entropy/filter tweaks.
+
+# set -u -o pipefail
+set +e
+
+GPUS=(0 1 2 3 4 5 6 7)
+TOTAL_GPUS=${#GPUS[@]}
+gpu_idx=0
+
+maybe_flush() {
+  local needed=$1
+  if (( gpu_idx + needed > TOTAL_GPUS )); then
+    wait
+    gpu_idx=0
+    sleep 10
+  fi
+}
+
+init_singleton() {
+  local tag=${1:-$(basename "$0")}
+  local dir="/blob/v-zihanwang/tmp"
+  mkdir -p "$dir"
+  export SGL_FILE="${dir}/${tag}.lock"
+
+  local ts
+  ts=$(date +%s)
+
+  if [[ -f "$SGL_FILE" ]]; then
+    local last_modified
+    last_modified=$(stat -c %Y "$SGL_FILE")
+    if (( ts - last_modified < 60 )); then
+      echo "[singleton] newer process already active (lock updated $(date -d @$last_modified)). exiting."
+      exit 0
+    fi
+  fi
+
+  echo "$ts" > "$SGL_FILE"
+  touch -d "@$ts" "$SGL_FILE"
+
+  export SGL_TS="$ts"
+
+  echo "[singleton] init: file=$SGL_FILE ts=$SGL_TS"
+}
+
+check_singleton() {
+  if [[ -z "${SGL_FILE:-}" || -z "${SGL_TS:-}" ]]; then
+    echo "[singleton] check: env not initialized (SGL_FILE/SGL_TS empty) -> exiting."
+    exit 0
+  fi
+
+  if [[ ! -f "$SGL_FILE" ]]; then
+    echo "[singleton] check: lock file missing -> taken over by another script. exiting."
+    exit 0
+  fi
+
+  local mtime
+  mtime=$(stat -c %Y "$SGL_FILE" 2>/dev/null || echo 0)
+
+  if [[ "$mtime" != "$SGL_TS" ]]; then
+    echo "[singleton] check: lock updated (was $SGL_TS, now $mtime). exiting."
+    exit 0
+  fi
+}
+
+wait_sleep_reset_check() {
+  wait
+  sleep 15
+  gpu_idx=0
+  check_singleton
+}
+
+launch_bandit() {
+  local run_name=$1
+  local think=$2
+  local algo=$3
+  local mode=$4
+  local n_gpus=${5:-2}
+  local total_training_steps=${6:-200}
+  shift 6
+  local overrides=("$@")
+
+  maybe_flush ${n_gpus}
+
+  local estimator
+  if [[ "$algo" == "ppo" ]]; then
+    estimator="gae"
+  else
+    estimator="$algo"
+  fi
+
+  local assigned=(${GPUS[@]:$gpu_idx:$n_gpus})
+  local visible=""
+  for id in "${assigned[@]}"; do
+    if [[ -n "$visible" ]]; then
+      visible+="," 
+    fi
+    visible+="$id"
+  done
+  gpu_idx=$((gpu_idx + n_gpus))
+
+  local storage_args=(
+    "trainer.default_local_dir=/blob/v-zihanwang/ragen_checkpoints/${run_name}"
+    "trainer.max_actor_ckpt_to_keep=1"
+    "trainer.max_critic_ckpt_to_keep=1"
+  )
+
+  local mode_overrides=()
+  case "$mode" in
+    normal)
+      mode_overrides=(
+        "algorithm.kl_ctrl.kl_coef=0.001"
+        "actor_rollout_ref.actor.clip_ratio_high=0.20"
+        "actor_rollout_ref.rollout.rollout_filter_ratio=1"
+        "actor_rollout_ref.actor.use_ref=True"
+      )
+      ;;
+    s)
+      mode_overrides=(
+        "actor_rollout_ref.actor.use_ref=False"
+        "algorithm.kl_ctrl.kl_coef=0.0"
+        "actor_rollout_ref.rollout.rollout_filter_ratio=0.5"
+      )
+      ;;
+    det)
+      mode_overrides=(
+        "algorithm.kl_ctrl.kl_coef=0.001"
+        "actor_rollout_ref.actor.clip_ratio_high=0.20"
+        "actor_rollout_ref.rollout.rollout_filter_ratio=1"
+        "actor_rollout_ref.actor.use_ref=True"
+        "agent_proxy.max_turn=1"
+        "agent_proxy.max_actions_per_turn=1"
+        "custom_envs.Bandit.max_actions_per_traj=1"
+        "+custom_envs.Bandit.env_config.hi_arm_loscore=0.25"
+        "+custom_envs.Bandit.env_config.hi_arm_hiscore=0.25"
+      )
+      ;;
+    *)
+      echo "[bandit_jobs] Unknown mode: $mode" >&2
+      return 1
+      ;;
+  esac
+
+  local base_args=(
+    "system.CUDA_VISIBLE_DEVICES=\"${visible}\""
+    "trainer.n_gpus_per_node=${n_gpus}"
+    "trainer.experiment_name=${run_name}"
+    "trainer.total_training_steps=${total_training_steps}"
+    "trainer.save_freq=50"
+    "model_path=Qwen/Qwen2.5-3B"
+    "lora.rank=0"
+    "actor_rollout_ref.actor.optim.lr=1e-6"
+    "critic.optim.lr=1e-5"
+    "micro_batch_size_per_gpu=1"
+    "algorithm.adv_estimator=${estimator}"
+    "agent_proxy.enable_think=${think}"
+    "agent_proxy.max_turn=1"
+    "agent_proxy.max_actions_per_turn=1"
+    "es_manager.train.env_configs.tags=[Bandit]"
+    "es_manager.val.env_configs.tags=[Bandit,BanditTest]"
+    "es_manager.val.env_configs.n_groups=[32,32]"
+    "es_manager.val.env_groups=64"
+  )
+
+  local log_dir=$(echo "${storage_args[0]}" | cut -d'=' -f2)
+  mkdir -p "$log_dir"
+
+  echo "=== Running ${run_name} on GPUs ${visible} ==="
+  CUDA_VISIBLE_DEVICES="${visible}" \
+  WANDB_RUN_ID=${run_name} \
+  python train.py \
+    "${base_args[@]}" \
+    "${mode_overrides[@]}" \
+    "${storage_args[@]}" \
+    "${overrides[@]}" \
+    2>&1 | tee -a "$log_dir/log.log" &
+
+  sleep 5
+}
+
+kl_coef_overrides=(
+        "algorithm.kl_ctrl.kl_coef=0.001"
+        "actor_rollout_ref.actor.use_ref=True"
+)
+
+entropy_filter_overrides=(
+  "actor_rollout_ref.rollout.rollout_filter_ratio=0.5"
+  "actor_rollout_ref.rollout.rollout_filter_metric=entropy"
+)
+
+entvar_filter_overrides=(
+  "actor_rollout_ref.rollout.rollout_filter_metric=entropy_variance"
+)
+
+instruct_overrides=("model_path=Qwen/Qwen2.5-3B-Instruct")
+
+init_singleton "$(basename "${BASH_SOURCE[0]}")" # create a lock file with the name of the script
+
+# launch_bandit "bandit_3b_base_ppo_think_s_entvarfilter" True ppo s 8 400 "${entvar_filter_overrides[@]}"
+
+# launch_bandit "bandit_3b_base_grpo_think_normal_1" True grpo normal 8 200
+
+launch_bandit "bandit_3b_base_ppo_think_s_2" True ppo s 8 400
+
+# launch_bandit "bandit_3b_base_ppo_think_normal_2" True ppo normal 4 200
+# launch_bandit "bandit_3b_base_ppo_nothink_normal_2" False ppo normal 4 200
+
+wait_sleep_reset_check
+
+# launch_bandit "bandit_3b_base_ppo_think_s" True ppo s 4
+# launch_bandit "bandit_3b_base_ppo_think_det" True ppo det 4
+
+# wait_sleep_reset_check
+
+# launch_bandit "bandit_3b_base_ppo_think_s_klcoef0.001" True ppo s 4 "${kl_coef_overrides[@]}"
+# launch_bandit "bandit_3b_base_ppo_think_s_entropyfilter" True ppo s 4 "${entropy_filter_overrides[@]}"
+
+# wait_sleep_reset_check
+
+# launch_bandit "bandit_3b_instruct_ppo_think_s" True ppo s 4 "${instruct_overrides[@]}"
+# launch_bandit "bandit_3b_base_grpo_nothink_normal" False grpo normal 4 200
+
+# wait_sleep_reset_check
+
+# launch_bandit "bandit_3b_base_grpo_nothink_normal" False grpo normal 4
+# launch_bandit "bandit_3b_base_ppo_think_s" True ppo s 8 400

scripts/runs/frozenlake_jobs.sh

@@ -0,0 +1,247 @@
+#!/bin/bash
+# Experiments: FrozenLake 3B base PPO/GRPO (normal no-think) and StarPO-S variants including deterministic, entropy, and instruct ablations.
+# Args: 400 steps, lr_actor=1e-6, lr_critic=1e-5, micro_batch=1, env tags=CoordFrozenLake; StarPO-S disables reference and optionally tweaks entropy/filtering.
+
+# set -u -o pipefail
+set +e
+
+GPUS=(0 1 2 3 4 5 6 7)
+TOTAL_GPUS=${#GPUS[@]}
+gpu_idx=0
+
+maybe_flush() {
+  local needed=$1
+  if (( gpu_idx + needed > TOTAL_GPUS )); then
+    wait
+    gpu_idx=0
+    sleep 10
+  fi
+}
+
+init_singleton() {
+  local tag=${1:-$(basename "$0")}
+  local dir="/blob/v-zihanwang/tmp"
+  mkdir -p "$dir"
+  export SGL_FILE="${dir}/${tag}.lock"
+
+  local ts
+  ts=$(date +%s)
+
+  if [[ -f "$SGL_FILE" ]]; then
+    local last_modified
+    last_modified=$(stat -c %Y "$SGL_FILE")
+    if (( ts - last_modified < 60 )); then
+      echo "[singleton] newer process already active (lock updated $(date -d @$last_modified)). exiting."
+      exit 0
+    fi
+  fi
+
+  echo "$ts" > "$SGL_FILE"
+  touch -d "@$ts" "$SGL_FILE"
+
+  export SGL_TS="$ts"
+
+  echo "[singleton] init: file=$SGL_FILE ts=$SGL_TS"
+}
+
+check_singleton() {
+  if [[ -z "${SGL_FILE:-}" || -z "${SGL_TS:-}" ]]; then
+    echo "[singleton] check: env not initialized (SGL_FILE/SGL_TS empty) -> exiting."
+    exit 0
+  fi
+
+  if [[ ! -f "$SGL_FILE" ]]; then
+    echo "[singleton] check: lock file missing -> taken over by another script. exiting."
+    exit 0
+  fi
+
+  local mtime
+  mtime=$(stat -c %Y "$SGL_FILE" 2>/dev/null || echo 0)
+
+  if [[ "$mtime" != "$SGL_TS" ]]; then
+    echo "[singleton] check: lock updated (was $SGL_TS, now $mtime). exiting."
+    exit 0
+  fi
+}
+
+wait_sleep_reset_check() {
+  wait
+  sleep 15
+  gpu_idx=0
+  check_singleton
+}
+
+launch_frozenlake() {
+  local run_name=$1
+  local think=$2
+  local algo=$3
+  local mode=$4
+  local n_gpus=${5:-2}
+  local total_training_steps=${6:-200}
+  shift 6
+  local overrides=("$@")
+
+  maybe_flush ${n_gpus}
+
+  local estimator
+  if [[ "$algo" == "ppo" ]]; then
+    estimator="gae"
+  else
+    estimator="$algo"
+  fi
+
+  local assigned=(${GPUS[@]:$gpu_idx:$n_gpus})
+  local visible=""
+  for id in "${assigned[@]}"; do
+    if [[ -n "$visible" ]]; then
+      visible+="," 
+    fi
+    visible+="$id"
+  done
+  gpu_idx=$((gpu_idx + n_gpus))
+
+  local storage_args=(
+    "trainer.default_local_dir=/blob/v-zihanwang/ragen_checkpoints/${run_name}"
+    "trainer.max_actor_ckpt_to_keep=1"
+    "trainer.max_critic_ckpt_to_keep=1"
+  )
+
+  local mode_overrides=()
+  case "$mode" in
+    normal)
+      mode_overrides=(
+        "algorithm.kl_ctrl.kl_coef=0.001"
+        "actor_rollout_ref.actor.clip_ratio_high=0.20"
+        "actor_rollout_ref.rollout.rollout_filter_ratio=1"
+        "actor_rollout_ref.actor.use_ref=True"
+      )
+      ;;
+    s)
+      mode_overrides=(
+        "actor_rollout_ref.actor.use_ref=False"
+        "algorithm.kl_ctrl.kl_coef=0.0"
+        "actor_rollout_ref.rollout.rollout_filter_ratio=0.5"
+      )
+      ;;
+    det)
+      mode_overrides=(
+        "algorithm.kl_ctrl.kl_coef=0.001"
+        "actor_rollout_ref.actor.clip_ratio_high=0.20"
+        "actor_rollout_ref.rollout.rollout_filter_ratio=1"
+        "actor_rollout_ref.actor.use_ref=True"
+        "agent_proxy.max_turn=1"
+        "agent_proxy.max_actions_per_turn=10"
+        "+custom_envs.CoordFrozenLake.max_actions_per_traj=10"
+        "+custom_envs.CoordFrozenLake.env_config.is_slippery=False"
+      )
+      ;;
+    void)
+      mode_overrides=(
+        "actor_rollout_ref.actor.use_ref=False"
+        "algorithm.kl_ctrl.kl_coef=0.0"
+      )
+      ;;
+    *)
+      echo "[frozenlake_jobs] Unknown mode: $mode" >&2
+      return 1
+      ;;
+  esac
+
+  local base_args=(
+    "system.CUDA_VISIBLE_DEVICES=\"${visible}\""
+    "trainer.n_gpus_per_node=${n_gpus}"
+    "trainer.experiment_name=${run_name}"
+    "trainer.total_training_steps=${total_training_steps}"
+    "trainer.save_freq=50"
+    "model_path=Qwen/Qwen2.5-3B"
+    "lora.rank=0"
+    "actor_rollout_ref.actor.optim.lr=1e-6"
+    "critic.optim.lr=1e-5"
+    "micro_batch_size_per_gpu=1"
+    "algorithm.adv_estimator=${estimator}"
+    "agent_proxy.enable_think=${think}"
+    "es_manager.train.env_configs.tags=[CoordFrozenLake]"
+    "es_manager.val.env_configs.tags=[CoordFrozenLake]"
+  )
+
+  local log_dir=$(echo "${storage_args[0]}" | cut -d'=' -f2)
+  mkdir -p "$log_dir"
+  
+  echo "=== Running ${run_name} on GPUs ${visible} ==="
+  CUDA_VISIBLE_DEVICES="${visible}" \
+  WANDB_RUN_ID=${run_name} \
+  python train.py \
+    "${base_args[@]}" \
+    "${mode_overrides[@]}" \
+    "${storage_args[@]}" \
+    "${overrides[@]}" \
+    2>&1 | tee -a "$log_dir/log.log" &
+
+  sleep 5
+}
+
+wait_and_sleep() {
+  wait
+  sleep 15
+  gpu_idx=0
+} 
+
+kl_coef_overrides=(
+        "algorithm.kl_ctrl.kl_coef=0.001"
+        "actor_rollout_ref.actor.use_ref=True"
+)
+
+entropy_filter_overrides=(
+  "actor_rollout_ref.rollout.rollout_filter_ratio=0.5"
+  "actor_rollout_ref.rollout.rollout_filter_metric=entropy"
+)
+
+entvar_filter_overrides=(
+  "actor_rollout_ref.rollout.rollout_filter_metric=entropy_variance"
+)
+
+filter_ratio_0_25_overrides=(
+  "actor_rollout_ref.rollout.rollout_filter_ratio=0.25"
+)
+
+filter_ratio_0_75_overrides=(
+  "actor_rollout_ref.rollout.rollout_filter_ratio=0.75"
+)
+
+instruct_overrides=("model_path=Qwen/Qwen2.5-3B-Instruct")
+
+init_singleton "$(basename "${BASH_SOURCE[0]}")"
+
+# launch_frozenlake "frozenlake_coord_3b_base_ppo_think_rolloutfilterratio0.25" True ppo void 8 1600 "${filter_ratio_0_25_overrides[@]}"
+# launch_frozenlake "frozenlake_coord_3b_base_ppo_think_rolloutfilterratio0.75" True ppo void 8 800 "${filter_ratio_0_75_overrides[@]}"
+launch_frozenlake "frozenlake_coord_3b_base_ppo_think_s_5" True ppo s 8 800
+wait_sleep_reset_check
+
+# Submitted experiments:
+
+
+
+# launch_frozenlake "frozenlake_coord_3b_base_ppo_think_s_entvarfilter" True ppo s 8 800 "${entvar_filter_overrides[@]}"
+# launch_frozenlake "frozenlake_coord_3b_base_ppo_think_det" True ppo det 4
+
+
+# launch_frozenlake "frozenlake_coord_3b_base_ppo_nothink_normal" False ppo normal 4
+# launch_frozenlake "frozenlake_coord_3b_base_grpo_nothink_normal" False grpo normal 4
+# wait_sleep_reset_check
+
+# launch_frozenlake "frozenlake_coord_3b_base_ppo_think_normal" True ppo normal 4
+# launch_frozenlake "frozenlake_coord_3b_base_grpo_think_normal" True grpo normal 4
+# wait_sleep_reset_check
+
+# launch_frozenlake "frozenlake_coord_3b_base_ppo_think_s_klcoef0.001" True ppo s 4 400 "${kl_coef_overrides[@]}"
+# launch_frozenlake "frozenlake_coord_3b_base_ppo_think_s_entropyfilter" True ppo s 4 400 "${entropy_filter_overrides[@]}"
+# wait_sleep_reset_check
+
+# launch_frozenlake "frozenlake_coord_3b_base_ppo_think_normal_2" True ppo normal 4 400
+# launch_frozenlake "frozenlake_coord_3b_base_grpo_think_normal_2" True grpo normal 4 400
+# wait_sleep_reset_check
+
+
+# launch_frozenlake "frozenlake_coord_3b_base_ppo_think_s_2" True ppo s 4 800
+# launch_frozenlake "frozenlake_coord_3b_base_grpo_nothink_normal_2" False grpo normal 4 400
+# wait_sleep_reset_check

scripts/runs/sokoban_jobs.sh

@@ -0,0 +1,226 @@
+#!/bin/bash
+# Experiments: Sokoban 3B base PPO normal vs StarPO-S variants (think/no-think, deterministic, entropy ablations).
+# Args: 400 steps, lr_actor=1e-6, lr_critic=1e-5, micro_batch=2, env tags=CoordSokoban; StarPO-S disables reference, optional entropy coeff/filter overrides.
+
+# set -u -o pipefail
+set +e
+
+
+GPUS=(0 1 2 3 4 5 6 7)
+TOTAL_GPUS=${#GPUS[@]}
+gpu_idx=0
+
+maybe_flush() {
+  local needed=$1
+  if (( gpu_idx + needed > TOTAL_GPUS )); then
+    wait
+    gpu_idx=0
+    sleep 10
+  fi
+}
+
+init_singleton() {
+  local tag=${1:-$(basename "$0")}
+  local dir="/blob/v-zihanwang/tmp"
+  mkdir -p "$dir"
+  export SGL_FILE="${dir}/${tag}.lock"
+
+  local ts
+  ts=$(date +%s)
+
+  if [[ -f "$SGL_FILE" ]]; then
+    local last_modified
+    last_modified=$(stat -c %Y "$SGL_FILE")
+    if (( ts - last_modified < 60 )); then
+      echo "[singleton] newer process already active (lock updated $(date -d @$last_modified)). exiting."
+      exit 0
+    fi
+  fi
+
+  echo "$ts" > "$SGL_FILE"
+  touch -d "@$ts" "$SGL_FILE"
+
+  export SGL_TS="$ts"
+
+  echo "[singleton] init: file=$SGL_FILE ts=$SGL_TS"
+}
+
+check_singleton() {
+  if [[ -z "${SGL_FILE:-}" || -z "${SGL_TS:-}" ]]; then
+    echo "[singleton] check: env not initialized (SGL_FILE/SGL_TS empty) -> exiting."
+    exit 0
+  fi
+
+  if [[ ! -f "$SGL_FILE" ]]; then
+    echo "[singleton] check: lock file missing -> taken over by another script. exiting."
+    exit 0
+  fi
+
+  local mtime
+  mtime=$(stat -c %Y "$SGL_FILE" 2>/dev/null || echo 0)
+
+  if [[ "$mtime" != "$SGL_TS" ]]; then
+    echo "[singleton] check: lock updated (was $SGL_TS, now $mtime). exiting."
+    exit 0
+  fi
+}
+
+wait_sleep_reset_check() {
+  wait
+  sleep 15
+  gpu_idx=0
+  check_singleton
+}
+
+launch_sokoban() {
+  local run_name=$1
+  local think=$2
+  local algo=$3
+  local mode=$4
+  local n_gpus=${5:-2}
+  local total_training_steps=${6:-200}
+  shift 6
+  local overrides=("$@")
+
+  maybe_flush ${n_gpus}
+
+  local estimator
+  if [[ "$algo" == "ppo" ]]; then
+    estimator="gae"
+  else
+    estimator="$algo"
+  fi
+
+  local assigned=(${GPUS[@]:$gpu_idx:$n_gpus})
+  local visible=""
+  for id in "${assigned[@]}"; do
+    if [[ -n "$visible" ]]; then
+      visible+="," 
+    fi
+    visible+="$id"
+  done
+  gpu_idx=$((gpu_idx + n_gpus))
+
+  local storage_args=(
+    "trainer.default_local_dir=/blob/v-zihanwang/ragen_checkpoints/${run_name}"
+    "trainer.max_actor_ckpt_to_keep=1"
+    "trainer.max_critic_ckpt_to_keep=1"
+  )
+
+  local mode_overrides=()
+  case "$mode" in
+    normal)
+      mode_overrides=(
+        "algorithm.kl_ctrl.kl_coef=0.001"
+        "actor_rollout_ref.actor.clip_ratio_high=0.20"
+        "actor_rollout_ref.rollout.rollout_filter_ratio=1"
+        "actor_rollout_ref.actor.use_ref=True"
+      )
+      ;;
+    s)
+      mode_overrides=(
+        "actor_rollout_ref.actor.use_ref=False"
+        "algorithm.kl_ctrl.kl_coef=0.0"
+        "actor_rollout_ref.rollout.rollout_filter_ratio=0.5"
+      )
+      ;;
+    det)
+      mode_overrides=(
+        "algorithm.kl_ctrl.kl_coef=0.001"
+        "actor_rollout_ref.actor.clip_ratio_high=0.20"
+        "actor_rollout_ref.rollout.rollout_filter_ratio=1"
+        "actor_rollout_ref.actor.use_ref=True"
+        "agent_proxy.max_turn=1"
+        "agent_proxy.max_actions_per_turn=10"
+        "custom_envs.CoordSokoban.max_actions_per_traj=10"
+      )
+      ;;
+    *)
+      echo "[sokoban_jobs] Unknown mode: $mode" >&2
+      return 1
+      ;;
+  esac
+
+  local base_args=(
+    "system.CUDA_VISIBLE_DEVICES=\"${visible}\""
+    "trainer.n_gpus_per_node=${n_gpus}"
+    "trainer.experiment_name=${run_name}"
+    "trainer.total_training_steps=${total_training_steps}"
+    "trainer.save_freq=50"
+    "model_path=Qwen/Qwen2.5-3B"
+    "lora.rank=0"
+    "actor_rollout_ref.actor.optim.lr=1e-6"
+    "critic.optim.lr=1e-5"
+    "micro_batch_size_per_gpu=1"
+    "algorithm.adv_estimator=${estimator}"
+    "agent_proxy.enable_think=${think}"
+    "es_manager.train.env_configs.tags=[CoordSokoban]"
+    "es_manager.val.env_configs.tags=[CoordSokoban]"
+  )
+
+  local log_dir=$(echo "${storage_args[0]}" | cut -d'=' -f2)
+  mkdir -p "$log_dir"
+
+  echo "=== Running ${run_name} on GPUs ${visible} ==="
+  CUDA_VISIBLE_DEVICES="${visible}" \
+  WANDB_RUN_ID=${run_name} \
+  python train.py \
+    "${base_args[@]}" \
+    "${mode_overrides[@]}" \
+    "${storage_args[@]}" \
+    "${overrides[@]}" \
+    2>&1 | tee -a "$log_dir/log.log" &
+
+  sleep 5
+}
+
+# gpu_idx=0
+# # Wave 2: entropy ablations and instruct comparison
+kl_coef_overrides=(
+        "algorithm.kl_ctrl.kl_coef=0.001"
+        "actor_rollout_ref.actor.use_ref=True"
+)
+
+entropy_filter_overrides=(
+  "actor_rollout_ref.rollout.rollout_filter_ratio=0.5"
+  "actor_rollout_ref.rollout.rollout_filter_metric=entropy"
+)
+
+entvar_filter_overrides=(
+  "actor_rollout_ref.rollout.rollout_filter_metric=entropy_variance"
+)
+
+instruct_overrides=("model_path=Qwen/Qwen2.5-3B-Instruct")
+
+
+lora_overrides=(
+  "lora.rank=64"
+  "lora.alpha=64"
+  "actor_rollout_ref.actor.optim.lr=1e-5"
+  "critic.optim.lr=1e-4"
+  "micro_batch_size_per_gpu=8"
+)
+
+init_singleton "$(basename "${BASH_SOURCE[0]}")"
+
+launch_sokoban "sokoban_coord_3b_base_ppo_think_s_entvarfilter" True ppo s 8 800 "${entvar_filter_overrides[@]}"
+
+# launch_sokoban "sokoban_coord_3b_base_ppo_think_normal" True ppo normal 4
+# launch_sokoban "sokoban_coord_3b_base_ppo_nothink_normal" False ppo normal 4
+# wait_sleep_reset_check
+
+# launch_sokoban "sokoban_coord_3b_base_ppo_think_det" True ppo det 4
+# launch_sokoban "sokoban_coord_3b_base_ppo_think_normal_lora" True ppo normal 4 "${lora_overrides[@]}"
+# wait_sleep_reset_check
+
+
+# launch_sokoban "sokoban_coord_3b_instruct_ppo_think_s" True ppo s 4 400 "${instruct_overrides[@]}"
+# launch_sokoban "sokoban_coord_3b_base_ppo_think_s_2" True ppo s 8 800
+# wait_sleep_reset_check
+
+
+# launch_sokoban "sokoban_coord_3b_base_ppo_think_s_klcoef0.001" True ppo s 4 400 "${kl_coef_overrides[@]}"
+# launch_sokoban "sokoban_coord_3b_base_ppo_think_s_entropyfilter" True ppo s 4 400 "${entropy_filter_overrides[@]}"
+# wait_sleep_reset_check
+
+

scripts/runs/webshop_budget_jobs.sh

@@ -0,0 +1,57 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+MODEL="Qwen/Qwen2.5-3B-Instruct"
+PROJ="budget_main"
+BASE_DIR="/blob/v-zihanwang/budget_checkpoints"
+DEVICES=\"0,1,2,3,4,5,6,7\"
+
+run_experiment() {
+  local turns=$1
+  local exp_name=$2
+  local out_dir="${BASE_DIR}/${exp_name}"
+
+  if [[ "$turns" -ge 7 ]]; then
+    local max_len=15000
+    local max_tok=15000
+  else
+    local max_len=10000
+    local max_tok=10000
+  fi
+
+  echo "=== Running ${exp_name} ==="
+  mkdir -p "${BASE_DIR}/${exp_name}"
+
+  CUDA_VISIBLE_DEVICES="${DEVICES}" \
+  WANDB_RUN_ID=${exp_name} \
+  python train.py --config-name _6_webshop ${USE_PPO:-} \
+    model_path="${MODEL}" \
+    actor_rollout_ref.rollout.rollout_filter_ratio=1 \
+    trainer.project_name="${PROJ}" \
+    micro_batch_size_per_gpu=1 \
+    trainer.experiment_name="${exp_name}" \
+    es_manager.train.env_groups=8 es_manager.train.group_size=16 es_manager.train.env_configs.n_groups='[8]' \
+    es_manager.val.env_groups=64 es_manager.val.group_size=8 es_manager.val.env_configs.n_groups='[64]' \
+    system.CUDA_VISIBLE_DEVICES="${DEVICES}" trainer.n_gpus_per_node=8 actor_rollout_ref.rollout.tensor_model_parallel_size=8 \
+    trainer.resume_mode=disable \
+    trainer.total_training_steps=200 \
+    trainer.save_freq=50 \
+    agent_proxy.max_turn="${turns}" \
+    actor_rollout_ref.rollout.max_model_len="${max_len}" actor_rollout_ref.rollout.max_num_batched_tokens="${max_tok}" \
+    trainer.default_local_dir="${out_dir}" \
+    trainer.max_actor_ckpt_to_keep=4 \
+    trainer.max_critic_ckpt_to_keep=4 \
+    custom_envs.WebShop.max_actions_per_traj="${turns}" \
+    actor_rollout_ref.actor.use_ref=False \
+    trainer.nnodes=1
+}
+
+main() {
+  # run_experiment 3 "webshop_starpos_grpo_3b_small_max_3turns"
+  # run_experiment 4 "webshop_starpos_grpo_3b_small_max_4turns"
+  # run_experiment 5 "webshop_starpos_grpo_3b_small_max_5turns"
+  # run_experiment 6 "webshop_starpos_grpo_3b_small_max_6turns"
+  # run_experiment 7 "webshop_starpos_grpo_3b_small_max_7turns"
+}
+
+main "$@"

scripts/runs/webshop_jobs.sh

@@ -0,0 +1,165 @@
+#!/bin/bash
+# Experiments: WebShop 3B StarPO-S sweeps (base vs instruct, entropy/n-gram filtering, entropy ablation).
+# Args: 400 steps, lr_actor=1e-6, lr_critic=1e-5, micro_batch=1, actor rollout max_len=15000, env tags=WebShop, StarPO-S disables reference.
+
+# set -u -o pipefail
+set +e
+
+
+GPUS=(0 1 2 3 4 5 6 7)
+TOTAL_GPUS=${#GPUS[@]}
+gpu_idx=0
+
+maybe_flush() {
+  local needed=$1
+  if (( gpu_idx + needed > TOTAL_GPUS )); then
+    wait
+    gpu_idx=0
+    sleep 10
+  fi
+}
+
+init_singleton() {
+  local tag=${1:-$(basename "$0")}
+  local dir="/blob/v-zihanwang/tmp"
+  mkdir -p "$dir"
+  export SGL_FILE="${dir}/${tag}.lock"
+
+  local ts
+  ts=$(date +%s)
+
+  if [[ -f "$SGL_FILE" ]]; then
+    local last_modified
+    last_modified=$(stat -c %Y "$SGL_FILE")
+    if (( ts - last_modified < 60 )); then
+      echo "[singleton] newer process already active (lock updated $(date -d @$last_modified)). exiting."
+      exit 0
+    fi
+  fi
+
+  echo "$ts" > "$SGL_FILE"
+  touch -d "@$ts" "$SGL_FILE"
+
+  export SGL_TS="$ts"
+
+  echo "[singleton] init: file=$SGL_FILE ts=$SGL_TS"
+}
+
+check_singleton() {
+  if [[ -z "${SGL_FILE:-}" || -z "${SGL_TS:-}" ]]; then
+    echo "[singleton] check: env not initialized (SGL_FILE/SGL_TS empty) -> exiting."
+    exit 0
+  fi
+
+  if [[ ! -f "$SGL_FILE" ]]; then
+    echo "[singleton] check: lock file missing -> taken over by another script. exiting."
+    exit 0
+  fi
+
+  local mtime
+  mtime=$(stat -c %Y "$SGL_FILE" 2>/dev/null || echo 0)
+
+  if [[ "$mtime" != "$SGL_TS" ]]; then
+    echo "[singleton] check: lock updated (was $SGL_TS, now $mtime). exiting."
+    exit 0
+  fi
+}
+
+wait_sleep_reset_check() {
+  wait
+  sleep 15
+  gpu_idx=0
+  check_singleton
+}
+
+launch_webshop_s() {
+  local run_name=$1
+  local n_gpus=${2:-4}
+  local total_training_steps=${3:-200}
+  shift 3
+  local overrides=("$@")
+
+  maybe_flush ${n_gpus}
+
+  local assigned=(${GPUS[@]:$gpu_idx:$n_gpus})
+  local visible=""
+  for id in "${assigned[@]}"; do
+    if [[ -n "$visible" ]]; then
+      visible+="," 
+    fi
+    visible+="$id"
+  done
+  gpu_idx=$((gpu_idx + n_gpus))
+
+  local storage_args=(
+    "trainer.default_local_dir=/blob/v-zihanwang/ragen_checkpoints/${run_name}"
+    "trainer.max_actor_ckpt_to_keep=1"
+    "trainer.max_critic_ckpt_to_keep=1"
+  )
+
+  local base_args=(
+    "system.CUDA_VISIBLE_DEVICES=\"${visible}\""
+    "trainer.n_gpus_per_node=${n_gpus}"
+    "trainer.experiment_name=${run_name}"
+    "trainer.total_training_steps=${total_training_steps}"
+    "trainer.save_freq=25"
+    "model_path=Qwen/Qwen2.5-3B"
+    "lora.rank=0"
+    "actor_rollout_ref.actor.optim.lr=1e-6"
+    "critic.optim.lr=1e-5"
+    "micro_batch_size_per_gpu=1"
+    "algorithm.adv_estimator=gae"
+    "agent_proxy.enable_think=True"
+    "agent_proxy.max_turn=8"
+    "agent_proxy.max_actions_per_turn=1"
+    "actor_rollout_ref.actor.use_ref=False"
+    "algorithm.kl_ctrl.kl_coef=0.0"
+    "actor_rollout_ref.rollout.rollout_filter_ratio=0.5"
+    "actor_rollout_ref.rollout.max_model_len=15000"
+    "actor_rollout_ref.rollout.max_num_batched_tokens=15000"
+    "es_manager.train.env_configs.tags=[WebShop]"
+    "es_manager.val.env_configs.tags=[WebShop]"
+  )
+
+  local log_dir=$(echo "${storage_args[0]}" | cut -d'=' -f2)
+  mkdir -p "$log_dir"
+
+  echo "=== Running ${run_name} on GPUs ${visible} ==="
+  CUDA_VISIBLE_DEVICES="${visible}" \
+  WANDB_RUN_ID=${run_name} \
+  python train.py \
+    "${base_args[@]}" \
+    "${mode_overrides[@]}" \
+    "${storage_args[@]}" \
+    "${overrides[@]}" \
+    2>&1 | tee -a "$log_dir/log.log" &
+
+  sleep 5
+}
+
+kl_coef_overrides=(
+  "algorithm.kl_ctrl.kl_coef=0.001"
+  "actor_rollout_ref.actor.use_ref=True"
+)
+
+entropy_filter_overrides=(
+  "actor_rollout_ref.rollout.rollout_filter_metric=entropy"
+)
+
+entvar_filter_overrides=(
+  "actor_rollout_ref.rollout.rollout_filter_metric=entropy_variance"
+)
+
+init_singleton "$(basename "${BASH_SOURCE[0]}")"
+launch_webshop_s "webshop_3b_base_ppo_think_s_entvarfilter" 8 400 "${entvar_filter_overrides[@]}"
+wait_sleep_reset_check
+
+# launch_webshop_s "webshop_3b_base_ppo_think_s" 8 400
+# wait_sleep_reset_check
+
+# launch_webshop_s "webshop_3b_base_ppo_think_s_entropyfilter" 8 400 "${entropy_filter_overrides[@]}"
+# wait_sleep_reset_check
+
+# launch_webshop_s "webshop_3b_base_ppo_think_s_klcoef0.001" 8 400 "${kl_coef_overrides[@]}"
+# wait_sleep_reset_check
+

scripts/setup_ragen.md

@@ -0,0 +1,26 @@
+# Manual Scripts to Setup Environment
+```bash
+conda create -n ragen python=3.9 -y
+conda activate ragen
+
+
+git clone git@github.com:ZihanWang314/ragen.git
+cd ragen
+
+pip install -e .
+pip install torch==2.6.0 --index-url https://download.pytorch.org/whl/cu124
+
+# Optional: to install flash-attn, you may need to install cuda-toolkit first if you don't have
+conda install -c "nvidia/label/cuda-12.4.0" cuda-toolkit -y
+export CUDA_HOME=$CONDA_PREFIX # /opt/conda/envs/zero
+pip3 install flash-attn --no-build-isolation
+
+pip install -r requirements.txt
+
+git submodule init
+git submodule update
+cd verl
+pip install -e .
+cd ..
+
+```

scripts/setup_ragen.sh

@@ -0,0 +1,151 @@
+#!/bin/bash
+
+# Exit on error
+set -e
+
+# Function to check if CUDA is available
+check_cuda() {
+    if command -v nvidia-smi &> /dev/null; then
+        echo "CUDA GPU detected"
+        return 0
+    else
+        echo "No CUDA GPU detected"
+        return 1
+    fi
+}
+
+# Function to check if conda is available
+check_conda() {
+    if command -v conda &> /dev/null; then
+        echo "Conda is available"
+        return 0
+    else
+        echo "Conda is not installed. Please install Conda first."
+        return 1
+    fi
+}
+
+# Colors for output
+GREEN='\033[0;32m'
+BLUE='\033[0;34m'
+NC='\033[0m' # No Color
+
+# Print step with color
+print_step() {
+    echo -e "${BLUE}[Step] ${1}${NC}"
+}
+
+# Main installation process
+main() {
+    # Check prerequisites
+    check_conda || exit 1
+    
+    # Create and activate conda environment
+    # if not exists, create it
+    if ! conda env list | grep -q "ragen"; then
+        print_step "Creating conda environment 'ragen' with Python 3.12..."
+        conda create -n ragen python=3.12 -y
+    else
+        print_step "Conda environment 'ragen' already exists"
+    fi
+    
+    # Need to source conda for script environment
+    eval "$(conda shell.bash hook)"
+    conda activate ragen
+
+    # Install package in editable mode
+    print_step "setting up verl..."
+    git submodule init
+    git submodule update
+    cd verl
+    pip install -e . --no-dependencies # we put dependencies in requirements.txt
+    cd ..
+    
+    # Install package in editable mode
+    print_step "Installing ragen package..."
+    pip install -e .
+    
+    # Install PyTorch with CUDA if available
+    if check_cuda; then
+        print_step "CUDA detected, checking CUDA version..."
+        
+        if command -v nvcc &> /dev/null; then
+            nvcc_version=$(nvcc --version | grep "release" | awk '{print $6}' | cut -c2-)
+            nvcc_major=$(echo $nvcc_version | cut -d. -f1)
+            nvcc_minor=$(echo $nvcc_version | cut -d. -f2)
+            
+            print_step "Found NVCC version: $nvcc_version"
+            
+            if [[ "$nvcc_major" -gt 12 || ("$nvcc_major" -eq 12 && "$nvcc_minor" -ge 1) ]]; then
+                print_step "CUDA $nvcc_version is already installed and meets requirements (>=12.4)"
+                export CUDA_HOME=${CUDA_HOME:-$(dirname $(dirname $(which nvcc)))}
+            else
+                print_step "CUDA version < 12.4, installing CUDA toolkit 12.4..."
+                conda install -c "nvidia/label/cuda-12.4.0" cuda-toolkit -y
+                export CUDA_HOME=$CONDA_PREFIX
+            fi
+        else
+            print_step "NVCC not found, installing CUDA toolkit 12.4..."
+            conda install -c "nvidia/label/cuda-12.4.0" cuda-toolkit -y
+            export CUDA_HOME=$CONDA_PREFIX
+        fi
+        
+        print_step "Installing PyTorch with CUDA support..."
+        pip install torch==2.5.0 --index-url https://download.pytorch.org/whl/cu124
+        
+        print_step "Installing flash-attention..."
+        # pip3 install flash-attn==2.7.4.post1 --no-build-isolation
+    else
+        print_step "Installing PyTorch without CUDA support..."
+        pip install torch==2.4.0
+    fi
+    
+    # Install remaining requirements
+    print_step "Installing additional requirements..."
+    pip install -r requirements.txt
+
+    print_step "Downloading data..."
+    python scripts/download_data.py
+
+    echo -e "${GREEN}Installation completed successfully!${NC}"
+    echo "To activate the environment, run: conda activate ragen"
+    
+    # export CMAKE_POLICY_VERSION_MINIMUM=3.5 && pip install alfworld[full]
+    # alfworld-download
+
+    # installing webshop
+    print_step "Installing webshop dependencies..."
+    conda install -c pytorch faiss-cpu -y
+    sudo apt update
+    sudo apt install default-jdk -y
+    conda install -c conda-forge openjdk=21 maven -y
+
+    # Install remaining requirements
+    print_step "Installing additional requirements..."
+    pip install -r requirements.txt
+
+    # webshop installation, model loading
+    pip install -e external/webshop-minimal/ --no-dependencies
+    python -m spacy download en_core_web_sm
+    python -m spacy download en_core_web_lg
+
+    print_step "Downloading data..."
+    python scripts/download_data.py
+
+    # Optional: download full data set
+    print_step "Downloading full data set..."
+    conda install conda-forge::gdown
+    mkdir -p external/webshop-minimal/webshop_minimal/data/full
+    cd external/webshop-minimal/webshop_minimal/data/full
+    # gdown https://drive.google.com/uc?id=1A2whVgOO0euk5O13n2iYDM0bQRkkRduB # items_shuffle
+    # gdown https://drive.google.com/uc?id=1s2j6NgHljiZzQNL3veZaAiyW_qDEgBNi # items_ins_v2
+    cd ../../../../..
+
+    echo -e "${GREEN}Installation completed successfully!${NC}"
+    echo "To activate the environment, run: conda activate ragen"
+
+
+}
+
+# Run main installation
+main

scripts/setup_ragen_webshop.sh.old

@@ -0,0 +1,144 @@
+#!/bin/bash
+
+# Exit on error
+set -e
+
+# Function to check if CUDA is available
+check_cuda() {
+    if command -v nvidia-smi &> /dev/null; then
+        echo "CUDA GPU detected"
+        return 0
+    else
+        echo "No CUDA GPU detected"
+        return 1
+    fi
+}
+
+# Function to check if conda is available
+check_conda() {
+    if command -v conda &> /dev/null; then
+        echo "Conda is available"
+        return 0
+    else
+        echo "Conda is not installed. Please install Conda first."
+        return 1
+    fi
+}
+
+# Colors for output
+GREEN='\033[0;32m'
+BLUE='\033[0;34m'
+NC='\033[0m' # No Color
+
+# Print step with color
+print_step() {
+    echo -e "${BLUE}[Step] ${1}${NC}"
+}
+
+# Main installation process
+main() {
+    # Check prerequisites
+    check_conda || exit 1
+    
+    # Create and activate conda environment
+    # if not exists, create it
+    if ! conda env list | grep -q "ragen"; then
+        print_step "Creating conda environment 'ragen' with Python 3.12..."
+        conda create -n ragen python=3.12 -y
+    else
+        print_step "Conda environment 'ragen' already exists"
+    fi
+    
+    # Need to source conda for script environment
+    eval "$(conda shell.bash hook)"
+    conda activate ragen
+    
+    # Clone repository
+    # print_step "Cloning ragen repository..."
+    # git clone git@github.com:ZihanWang314/ragen.git
+    # cd ragen
+
+    # Install package in editable mode
+    print_step "setting up verl..."
+    git submodule init
+    git submodule update
+    cd verl
+    pip install -e . --no-dependencies # we put dependencies in RAGEN/requirements.txt
+    cd ..
+    
+    # Install package in editable mode
+    print_step "Installing ragen package..."
+    pip install -e .
+    
+    # Install PyTorch with CUDA if available
+    if check_cuda; then
+        print_step "CUDA detected, checking CUDA version..."
+        
+        if command -v nvcc &> /dev/null; then
+            nvcc_version=$(nvcc --version | grep "release" | awk '{print $6}' | cut -c2-)
+            nvcc_major=$(echo $nvcc_version | cut -d. -f1)
+            nvcc_minor=$(echo $nvcc_version | cut -d. -f2)
+            
+            print_step "Found NVCC version: $nvcc_version"
+            
+            if [[ "$nvcc_major" -gt 12 || ("$nvcc_major" -eq 12 && "$nvcc_minor" -ge 1) ]]; then
+                print_step "CUDA $nvcc_version is already installed and meets requirements (>=12.4)"
+                export CUDA_HOME=${CUDA_HOME:-$(dirname $(dirname $(which nvcc)))}
+            else
+                print_step "CUDA version < 12.4, installing CUDA toolkit 12.4..."
+                conda install -c "nvidia/label/cuda-12.4.0" cuda-toolkit -y
+                export CUDA_HOME=$CONDA_PREFIX
+            fi
+        else
+            print_step "NVCC not found, installing CUDA toolkit 12.4..."
+            conda install -c "nvidia/label/cuda-12.4.0" cuda-toolkit -y
+            export CUDA_HOME=$CONDA_PREFIX
+        fi
+        
+        print_step "Installing PyTorch with CUDA support..."
+        pip install torch==2.6.0 --index-url https://download.pytorch.org/whl/cu124
+        
+        print_step "Installing flash-attention..."
+        pip3 install flash-attn --no-build-isolation
+    else
+        print_step "Installing PyTorch without CUDA support..."
+        pip install torch==2.6.0
+    fi
+    
+    # TODO: merge this with the main setup script with an option to install webshop
+    # Install if you want to use webshop
+    conda install -c pytorch faiss-cpu -y
+    sudo apt update
+    sudo apt install default-jdk
+    conda install -c conda-forge openjdk=21 maven -y
+
+    # Install remaining requirements
+    print_step "Installing additional requirements..."
+    pip install -r requirements.txt
+
+    # webshop installation, model loading
+    pip install -e external/webshop-minimal/ --no-dependencies
+    python -m spacy download en_core_web_sm
+    python -m spacy download en_core_web_lg
+
+    print_step "Downloading data..."
+    python scripts/download_data.py
+
+    # Optional: download full data set
+    print_step "Downloading full data set..."
+    conda install conda-forge::gdown
+    mkdir -p external/webshop-minimal/webshop_minimal/data/full
+    cd external/webshop-minimal/webshop_minimal/data/full
+    gdown https://drive.google.com/uc?id=1A2whVgOO0euk5O13n2iYDM0bQRkkRduB # items_shuffle
+    gdown https://drive.google.com/uc?id=1s2j6NgHljiZzQNL3veZaAiyW_qDEgBNi # items_ins_v2
+    cd ../../../../..
+
+    echo -e "${GREEN}Installation completed successfully!${NC}"
+    echo "To activate the environment, run: conda activate ragen"
+    
+    # export CMAKE_POLICY_VERSION_MINIMUM=3.5 && pip install alfworld[full]
+    # alfworld-download
+}
+
+# Run main installation
+main

scripts/setup_webshop.sh

@@ -0,0 +1,50 @@
+#!/bin/bash
+
+# Exit on error
+set -e
+
+echo "Setting up webshop..."
+echo "NOTE: please run scripts/setup_ragen.sh before running this script"
+
+# Colors for output
+GREEN='\033[0;32m'
+BLUE='\033[0;34m'
+NC='\033[0m' # No Color
+
+# Print step with color
+print_step() {
+    echo -e "${BLUE}[Step] ${1}${NC}"
+}
+
+# Main installation process
+# TODO: merge this with the main setup script with an option to install webshop
+# Install if you want to use webshop
+conda install -c pytorch faiss-cpu -y
+sudo apt update
+sudo apt install default-jdk -y
+conda install -c conda-forge openjdk=21 maven -y
+
+# Install remaining requirements
+print_step "Installing additional requirements..."
+pip install -r requirements.txt
+
+# webshop installation, model loading
+pip install -e external/webshop-minimal/ --no-dependencies
+python -m spacy download en_core_web_sm
+python -m spacy download en_core_web_lg
+
+print_step "Downloading data..."
+python scripts/download_data.py
+
+# Optional: download full data set
+print_step "Downloading full data set..."
+conda install conda-forge::gdown
+mkdir -p external/webshop-minimal/webshop_minimal/data/full
+cd external/webshop-minimal/webshop_minimal/data/full
+gdown https://drive.google.com/uc?id=1A2whVgOO0euk5O13n2iYDM0bQRkkRduB # items_shuffle
+gdown https://drive.google.com/uc?id=1s2j6NgHljiZzQNL3veZaAiyW_qDEgBNi # items_ins_v2
+cd ../../../../..
+
+echo -e "${GREEN}Installation completed successfully!${NC}"
+echo "To activate the environment, run: conda activate ragen"
+

scripts/synthesize_bon.sh

@@ -0,0 +1,69 @@
+# python3 /mnt/general/wanghy/RAGEN/scripts/synthesize_think_bon_traj_sa.py \
+#   --input /mnt/general/wanghy/RAGEN/runs/Sudoku__ppo_sudoku_actionmask__4x4/sft/step_999424_sft_singleturn.json \
+#   --output-dir /mnt/general/wanghy/RAGEN/runs/Sudoku__ppo_sudoku_actionmask__4x4/sft/ \
+#   --output-prefix withthink_fulltraj_sa \
+#   --model /mnt/general/share/model/Qwen/Qwen2-72B-Instruct \
+#   --tensor-parallel-size 4 \
+#   --n 8 \
+#   --batch-size 32 \
+#   --judge-batch-size 32 
+
+# python3 /mnt/general/wanghy/RAGEN/scripts/synthesize_think_bon_traj_sa.py \
+#   --input /mnt/general/wanghy/RAGEN/runs/SokobanNoisyDQN__noisy_dqn_sokoban__1__1764155447/sft/step_1000000_sft_singleturn.json \
+#   --output-dir /mnt/general/wanghy/RAGEN/runs/SokobanNoisyDQN__noisy_dqn_sokoban__1__1764155447/sft/ \
+#   --output-prefix withthink_fulltraj_sa \
+#   --model /mnt/general/share/model/Qwen/Qwen2-72B-Instruct \
+#   --tensor-parallel-size 4 \
+#   --n 8 \
+#   --batch-size 32 \
+#   --judge-batch-size 32
+
+# python3 /mnt/general/wanghy/RAGEN/scripts/synthesize_think_bon_traj_sa.py \
+#   --input /mnt/general/wanghy/RAGEN/runs/FrozenLake__ppo_frozenlake_nochangeenv__p0.9_slippery/sft/step_1986560_sft_slippery_singleturn.json \
+#   --output-dir /mnt/general/wanghy/RAGEN/runs/FrozenLake__ppo_frozenlake_nochangeenv__p0.9_slippery/sft/ \
+#   --output-prefix withthink_fulltraj_sa \
+#   --model /mnt/general/share/model/Qwen/Qwen2-72B-Instruct \
+#   --tensor-parallel-size 4 \
+#   --n 8 \
+#   --batch-size 32 \
+#   --judge-batch-size 32 
+
+# python3 /mnt/general/wanghy/RAGEN/scripts/synthesize_think_bon_traj_sa.py \
+#   --input /mnt/general/wanghy/RAGEN/runs/FrozenLake__ppo_frozenlake_nochangeenv__1__1763646695/sft/step_1986560_sft_noslippery_singleturn.json \
+#   --output-dir /mnt/general/wanghy/RAGEN/runs/FrozenLake__ppo_frozenlake_nochangeenv__1__1763646695/sft/ \
+#   --output-prefix withthink_fulltraj_sa \
+#   --model /mnt/general/share/model/Qwen/Qwen2-72B-Instruct \
+#   --tensor-parallel-size 4 \
+#   --n 8 \
+#   --batch-size 32 \
+#   --judge-batch-size 32
+
+# python3 /mnt/general/wanghy/RAGEN/scripts/synthesize_think_bon_traj_sa.py \
+#   --input /mnt/general/wanghy/RAGEN/runs/RubiksCube2x2__ppo_rubikscube1_1218/sft/step_999424_sft_singleturn.json \
+#   --output-dir /mnt/general/wanghy/RAGEN/runs/RubiksCube2x2__ppo_rubikscube1_1218/sft/ \
+#   --output-prefix withthink_fulltraj_sa \
+#   --model /mnt/general/share/model/Qwen/Qwen2-72B-Instruct \
+#   --tensor-parallel-size 4 \
+#   --n 8 \
+#   --batch-size 32 \
+#   --judge-batch-size 32 
+
+python3 /mnt/general/wanghy/RAGEN/scripts/synthesize_think_bon_traj_sa.py \
+  --input /mnt/general/wanghy/RAGEN/runs/RubiksCube2x2__ppo_rubikscube2_1219_turn5/sft/step_999424_sft_singleturn.json \
+  --output-dir /mnt/general/wanghy/RAGEN/runs/RubiksCube2x2__ppo_rubikscube2_1219_turn5/sft/ \
+  --output-prefix withthink_fulltraj_sa \
+  --model /mnt/general/share/model/Qwen/Qwen2-72B-Instruct \
+  --tensor-parallel-size 4 \
+  --n 8 \
+  --batch-size 32 \
+  --judge-batch-size 32
+
+# python3 /mnt/general/wanghy/RAGEN/scripts/synthesize_think_bon_traj_sa.py \
+#   --input /mnt/general/wanghy/RAGEN/runs/RubiksCube2x2__ppo_rubikscube3_1219_turn5_6000/sft/step_999424_sft_singleturn.json \
+#   --output-dir /mnt/general/wanghy/RAGEN/runs/RubiksCube2x2__ppo_rubikscube3_1219_turn5_6000/sft/ \
+#   --output-prefix withthink_fulltraj_sa \
+#   --model /mnt/general/share/model/Qwen/Qwen2-72B-Instruct \
+#   --tensor-parallel-size 4 \
+#   --n 8 \
+#   --batch-size 32 \
+#   --judge-batch-size 32 

scripts/synthesize_think_bon.py

@@ -0,0 +1,827 @@
+#!/usr/bin/env python3
+"""Synthesize <think> traces for SFT singleturn trajectories with BoN + judge.
+
+This script is intentionally environment-agnostic. It assumes a JSON list of rows
+with the common RAGEN SFT shape:
+
+  {"messages": [{"role": "system"}, {"role": "user"}, {"role": "assistant"}, ...],
+   "meta": {"source_id": ..., "turns": ..., "total_turns": ...}}
+
+For each source_id, the complete trajectory row is selected, one reasoning trace
+is synthesized per turn, and the selected traces are written back to every
+cumulative singleturn prefix while keeping every original <answer>...</answer>
+block exactly unchanged.
+
+
+python3 /mnt/general/wanghy/RAGEN/scripts/synthesize_think_bon.py \
+  --input /mnt/general/wanghy/RAGEN/runs/Sudoku__ppo_sudoku_actionmask__4x4/sft/step_999424_sft_singleturn_nohint.json \
+  --output-dir /mnt/general/wanghy/RAGEN/runs/Sudoku__ppo_sudoku_actionmask__4x4/sft/ \
+  --output-prefix step_999424_sft_singleturn_withthink \
+  --versions sa,sas \
+  --model /mnt/general/share/model/Qwen/Qwen2.5-7B-Instruct \
+  --tensor-parallel-size 4 \
+  --n 8 \
+  --batch-size 32 \
+  --judge-batch-size 32 \
+  --limit-sources 50
+"""
+
+from __future__ import annotations
+
+import argparse
+import copy
+import json
+import re
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, Dict, Iterable, List, Optional, Sequence, Tuple
+
+
+ANSWER_RE = re.compile(r"<answer>.*?</answer>", re.IGNORECASE | re.DOTALL)
+THINK_RE = re.compile(r"<think>(.*?)</think>", re.IGNORECASE | re.DOTALL)
+JSON_OBJ_RE = re.compile(r"\{.*\}", re.DOTALL)
+
+
+@dataclass
+class TurnExample:
+    source_id: Any
+    turn_idx: int
+    total_turns: int
+    user_content: str
+    assistant_content: str
+    answer_block: str
+    next_user_content: Optional[str]
+
+
+@dataclass
+class FullTrajectory:
+    source_id: Any
+    sys_prefix: List[Dict[str, Any]]
+    pairs: List[Tuple[Dict[str, Any], Dict[str, Any]]]
+    meta: Dict[str, Any]
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(
+        description="Synthesize expert-action thinking traces with per-turn BoN and LLM judge."
+    )
+    parser.add_argument("--input", "-i", type=Path, required=True, help="Input SFT JSON list.")
+    parser.add_argument(
+        "--output-dir",
+        type=Path,
+        default=None,
+        help="Directory for output files. Defaults to input parent.",
+    )
+    parser.add_argument(
+        "--output-prefix",
+        default=None,
+        help="Output filename prefix. Defaults to input stem.",
+    )
+    parser.add_argument(
+        "--versions",
+        default="sa,sas",
+        help="Comma-separated versions: sa and/or sas. sa uses s,a; sas uses s,a,s'.",
+    )
+    parser.add_argument("--model", default=None, help="HF model path for tokenizer + vLLM.")
+    parser.add_argument("--judge-model", default=None, help="Optional separate judge model path.")
+    parser.add_argument("--n", type=int, default=8, help="BoN candidates per turn.")
+    parser.add_argument(
+        "--mode",
+        default="per_turn",
+        choices=["per_turn"],
+        help="BoN mode. Currently only independent per-turn BoN is implemented.",
+    )
+    parser.add_argument("--limit-sources", type=int, default=None, help="Pilot limit by source_id count.")
+    parser.add_argument("--source-ids", default="", help="Optional comma-separated source_id allowlist.")
+    parser.add_argument("--batch-size", type=int, default=64, help="Prompt batch size for generation.")
+    parser.add_argument("--judge-batch-size", type=int, default=64, help="Prompt batch size for judge.")
+    parser.add_argument("--temperature", type=float, default=0.7)
+    parser.add_argument("--top-p", type=float, default=0.95)
+    parser.add_argument("--top-k", type=int, default=-1)
+    parser.add_argument("--max-tokens", type=int, default=160, help="Max tokens for think generation.")
+    parser.add_argument("--judge-temperature", type=float, default=0.0)
+    parser.add_argument("--judge-max-tokens", type=int, default=768)
+    parser.add_argument("--tensor-parallel-size", type=int, default=1)
+    parser.add_argument("--judge-tensor-parallel-size", type=int, default=None)
+    parser.add_argument("--dtype", default="auto")
+    parser.add_argument("--gpu-memory-utilization", type=float, default=0.9)
+    parser.add_argument("--max-model-len", type=int, default=None)
+    parser.add_argument("--trust-remote-code", action="store_true")
+    parser.add_argument("--min-judge-score", type=float, default=3.0)
+    parser.add_argument("--save-candidates", action="store_true", help="Store all candidates in report.")
+    parser.add_argument(
+        "--selected-only",
+        action="store_true",
+        help="Write only rows whose source_id was selected by --limit-sources/--source-ids.",
+    )
+    parser.add_argument("--no-cache", action="store_true", help="Disable JSONL cache/resume.")
+    parser.add_argument("--dry-run", action="store_true", help="Do not load vLLM; create deterministic mock thinks.")
+    parser.add_argument("--indent", type=int, default=2, help="JSON output indent. Use -1 for compact.")
+    return parser.parse_args()
+
+
+def load_json_list(path: Path) -> List[Dict[str, Any]]:
+    with path.open("r", encoding="utf-8") as f:
+        data = json.load(f)
+    if not isinstance(data, list):
+        raise ValueError(f"Expected JSON list at {path}, got {type(data).__name__}")
+    if not all(isinstance(row, dict) for row in data):
+        raise ValueError(f"Expected all rows to be objects in {path}")
+    return data
+
+
+def dump_json(path: Path, data: Any, indent: int) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    kwargs = {"ensure_ascii": False}
+    if indent >= 0:
+        kwargs["indent"] = indent
+    with path.open("w", encoding="utf-8") as f:
+        json.dump(data, f, **kwargs)
+
+
+def extract_system_prefix(messages: Sequence[Dict[str, Any]]) -> List[Dict[str, Any]]:
+    out: List[Dict[str, Any]] = []
+    for msg in messages:
+        if msg.get("role") == "system":
+            out.append(copy.deepcopy(msg))
+        else:
+            break
+    return out
+
+
+def collect_pairs(messages: Sequence[Dict[str, Any]], start_idx: int = 0) -> List[Tuple[Dict[str, Any], Dict[str, Any]]]:
+    pairs: List[Tuple[Dict[str, Any], Dict[str, Any]]] = []
+    idx = start_idx
+    while idx < len(messages):
+        while idx < len(messages) and messages[idx].get("role") != "user":
+            idx += 1
+        if idx >= len(messages):
+            break
+        if idx + 1 < len(messages) and messages[idx + 1].get("role") == "assistant":
+            pairs.append((copy.deepcopy(messages[idx]), copy.deepcopy(messages[idx + 1])))
+            idx += 2
+        else:
+            idx += 1
+    return pairs
+
+
+def to_int(value: Any, default: int = 0) -> int:
+    try:
+        return int(value)
+    except (TypeError, ValueError):
+        return default
+
+
+def source_key(source_id: Any) -> str:
+    return str(source_id)
+
+
+def group_rows(rows: Sequence[Dict[str, Any]]) -> Dict[Any, List[Dict[str, Any]]]:
+    groups: Dict[Any, List[Dict[str, Any]]] = {}
+    for idx, row in enumerate(rows):
+        meta = row.get("meta") or {}
+        source_id = meta.get("source_id", f"missing_source_{idx}")
+        groups.setdefault(source_id, []).append(row)
+    for items in groups.values():
+        items.sort(key=lambda r: to_int((r.get("meta") or {}).get("turns"), 0))
+    return groups
+
+
+def select_full_row(source_id: Any, items: Sequence[Dict[str, Any]]) -> Dict[str, Any]:
+    exact = [
+        row
+        for row in items
+        if to_int((row.get("meta") or {}).get("turns"), -1)
+        == to_int((row.get("meta") or {}).get("total_turns"), -2)
+    ]
+    if exact:
+        return exact[-1]
+    return max(items, key=lambda r: to_int((r.get("meta") or {}).get("turns"), 0))
+
+
+def build_full_trajectories(rows: Sequence[Dict[str, Any]]) -> Dict[Any, FullTrajectory]:
+    groups = group_rows(rows)
+    full: Dict[Any, FullTrajectory] = {}
+    for source_id, items in groups.items():
+        row = select_full_row(source_id, items)
+        messages = row.get("messages") or []
+        if not isinstance(messages, list):
+            continue
+        sys_prefix = extract_system_prefix(messages)
+        pairs = collect_pairs(messages, start_idx=len(sys_prefix))
+        if not pairs:
+            continue
+        full[source_id] = FullTrajectory(
+            source_id=source_id,
+            sys_prefix=sys_prefix,
+            pairs=pairs,
+            meta=dict(row.get("meta") or {}),
+        )
+    return full
+
+
+def extract_answer_block(text: str) -> str:
+    match = ANSWER_RE.search(text or "")
+    return match.group(0) if match is not None else ""
+
+
+def clean_think(text: str) -> str:
+    text = (text or "").strip()
+    think_match = THINK_RE.search(text)
+    if think_match is not None:
+        text = think_match.group(1).strip()
+    text = re.split(r"<\s*/?\s*answer\s*>", text, flags=re.IGNORECASE)[0]
+    text = re.sub(r"</?think>", "", text, flags=re.IGNORECASE)
+    text = re.sub(r"\s+", " ", text).strip()
+    text = text.strip('` \t\n\r"')
+    return text
+
+
+def make_response(think: str, answer_block: str) -> str:
+    return f"<think>{think.strip()}</think>{answer_block}"
+
+
+def iter_turns(full: Dict[Any, FullTrajectory]) -> List[TurnExample]:
+    turns: List[TurnExample] = []
+    for source_id, traj in full.items():
+        total_turns = len(traj.pairs)
+        for i, (user_msg, asst_msg) in enumerate(traj.pairs):
+            answer_block = extract_answer_block(str(asst_msg.get("content", "")))
+            next_user = None
+            if i + 1 < total_turns:
+                next_user = str(traj.pairs[i + 1][0].get("content", ""))
+            turns.append(
+                TurnExample(
+                    source_id=source_id,
+                    turn_idx=i + 1,
+                    total_turns=total_turns,
+                    user_content=str(user_msg.get("content", "")),
+                    assistant_content=str(asst_msg.get("content", "")),
+                    answer_block=answer_block,
+                    next_user_content=next_user,
+                )
+            )
+    return turns
+
+
+def build_generation_messages(example: TurnExample, version: str) -> List[Dict[str, str]]:
+    if version not in {"sa", "sas"}:
+        raise ValueError(f"Unknown version: {version}")
+    sas_available = version == "sas" and example.next_user_content is not None
+    parts = [
+        "We are creating high-quality SFT reasoning for an expert trajectory.",
+        "The expert action is fixed. Your job is only to write the inner text for <think>...</think>.",
+        "Do not output <think>, </think>, <answer>, JSON, bullets, or any extra wrapper.",
+        "Do not change or restate a different action. Do not invent hidden facts, future rewards, or unsupported optimality claims.",
+        "Keep it concise: 1-3 English sentences explaining why the fixed action is reasonable from the visible context.",
+        "",
+        "Current observation/state s:",
+        "```text",
+        example.user_content.strip(),
+        "```",
+        "",
+        "Fixed expert action a:",
+        "```text",
+        example.answer_block.strip() or example.assistant_content.strip(),
+        "```",
+    ]
+    if sas_available:
+        parts.extend(
+            [
+                "",
+                "Observed next state/feedback s' after executing the fixed action:",
+                "```text",
+                str(example.next_user_content).strip(),
+                "```",
+                "Use s' only to ground the explanation of the observed transition; never alter the fixed action.",
+            ]
+        )
+    elif version == "sas":
+        parts.extend(
+            [
+                "",
+                "No next state s' is available for this final turn, so explain using only s and a.",
+            ]
+        )
+    return [
+        {
+            "role": "system",
+            "content": "You write faithful, concise reasoning for fixed expert actions.",
+        },
+        {"role": "user", "content": "\n".join(parts)},
+    ]
+
+
+def build_judge_messages(example: TurnExample, version: str, candidates: Sequence[str]) -> List[Dict[str, str]]:
+    candidate_text = "\n".join(f"[{i + 1}] {cand}" for i, cand in enumerate(candidates))
+    sas_available = version == "sas" and example.next_user_content is not None
+    parts = [
+        "You are auditing candidate <think> texts for an expert SFT trajectory.",
+        "The expert action is fixed. Select the candidate that best explains it while staying faithful to the visible context.",
+        "Penalize unsupported factual claims, contradicted claims, changing the action, excessive certainty such as 'only'/'optimal' without clear support, verbosity, and format pollution.",
+        "Return strict JSON only, with no markdown.",
+        "",
+        "Current observation/state s:",
+        "```text",
+        example.user_content.strip(),
+        "```",
+        "",
+        "Fixed expert action a:",
+        "```text",
+        example.answer_block.strip() or example.assistant_content.strip(),
+        "```",
+    ]
+    if sas_available:
+        parts.extend(
+            [
+                "",
+                "Observed next state/feedback s' after executing a:",
+                "```text",
+                str(example.next_user_content).strip(),
+                "```",
+            ]
+        )
+    elif version == "sas":
+        parts.append("\nNo next state s' is available for this final turn.")
+    parts.extend(
+        [
+            "",
+            "Candidates:",
+            candidate_text,
+            "",
+            "Use this JSON schema:",
+            '{"best_index": 1, "scores": [{"index": 1, "score": 1, "unsupported_claims": 0, "contradictions": 0, "reason": "short reason"}], "selected_reason": "short reason", "low_quality": false}',
+            "Scores are from 1 to 5. Set low_quality=true if the best candidate is still weak or generic.",
+        ]
+    )
+    return [
+        {"role": "system", "content": "You are a strict factuality judge for reasoning traces."},
+        {"role": "user", "content": "\n".join(parts)},
+    ]
+
+
+def render_prompt(tokenizer: Any, messages: List[Dict[str, str]]) -> str:
+    return tokenizer.apply_chat_template(messages, add_generation_prompt=True, tokenize=False)
+
+
+def load_vllm_model(
+    model_path: str,
+    args: argparse.Namespace,
+    tensor_parallel_size: Optional[int] = None,
+) -> Tuple[Any, Any]:
+    try:
+        from transformers import AutoTokenizer
+        from vllm import LLM
+    except ImportError as exc:
+        raise RuntimeError("This script requires `vllm` and `transformers`.") from exc
+
+    tokenizer = AutoTokenizer.from_pretrained(model_path, trust_remote_code=bool(args.trust_remote_code))
+    llm_kwargs: Dict[str, Any] = {
+        "model": model_path,
+        "tensor_parallel_size": int(tensor_parallel_size or args.tensor_parallel_size),
+        "dtype": args.dtype,
+        "gpu_memory_utilization": float(args.gpu_memory_utilization),
+        "trust_remote_code": bool(args.trust_remote_code),
+    }
+    if args.max_model_len is not None:
+        llm_kwargs["max_model_len"] = int(args.max_model_len)
+    return LLM(**llm_kwargs), tokenizer
+
+
+def make_sampling_params(args: argparse.Namespace, *, judge: bool = False) -> Any:
+    try:
+        from vllm import SamplingParams
+    except ImportError as exc:
+        raise RuntimeError("This script requires `vllm`.") from exc
+    if judge:
+        return SamplingParams(
+            temperature=float(args.judge_temperature),
+            top_p=1.0,
+            max_tokens=int(args.judge_max_tokens),
+        )
+    return SamplingParams(
+        n=int(args.n),
+        temperature=float(args.temperature),
+        top_p=float(args.top_p),
+        top_k=int(args.top_k),
+        max_tokens=int(args.max_tokens),
+    )
+
+
+def chunks(items: Sequence[Any], size: int) -> Iterable[Sequence[Any]]:
+    if size <= 0:
+        yield items
+        return
+    for start in range(0, len(items), size):
+        yield items[start : start + size]
+
+
+def parse_judge_json(text: str) -> Dict[str, Any]:
+    text = (text or "").strip()
+    match = JSON_OBJ_RE.search(text)
+    if match is not None:
+        text = match.group(0)
+    try:
+        obj = json.loads(text)
+        if isinstance(obj, dict):
+            return obj
+    except json.JSONDecodeError:
+        pass
+    return {}
+
+
+def selected_score(judge_obj: Dict[str, Any], best_index: int) -> float:
+    for item in judge_obj.get("scores") or []:
+        if isinstance(item, dict) and to_int(item.get("index"), -1) == best_index:
+            try:
+                return float(item.get("score", 0.0))
+            except (TypeError, ValueError):
+                return 0.0
+    return 0.0
+
+
+def fallback_think(version: str) -> str:
+    if version == "sas":
+        return (
+            "The expert action is kept fixed and is explained using the current observation "
+            "together with the observed next-state feedback, without changing the action."
+        )
+    return (
+        "The expert action is kept fixed and is chosen based on the current observation "
+        "and task constraints, aiming to make progress without changing the demonstrated action."
+    )
+
+
+def cache_key(version: str, source_id: Any, turn_idx: int) -> str:
+    return json.dumps(
+        {"version": version, "source_id": source_id, "turn_idx": turn_idx},
+        ensure_ascii=False,
+        sort_keys=True,
+    )
+
+
+def load_cache(path: Path) -> Dict[str, Dict[str, Any]]:
+    cache: Dict[str, Dict[str, Any]] = {}
+    if not path.exists():
+        return cache
+    with path.open("r", encoding="utf-8") as f:
+        for line_no, line in enumerate(f, start=1):
+            line = line.strip()
+            if not line:
+                continue
+            try:
+                row = json.loads(line)
+            except json.JSONDecodeError:
+                print(f"Warning: skipped invalid cache line {path}:{line_no}")
+                continue
+            key = row.get("cache_key")
+            if isinstance(key, str):
+                cache[key] = row
+    return cache
+
+
+def append_cache(path: Path, rows: Sequence[Dict[str, Any]]) -> None:
+    if not rows:
+        return
+    path.parent.mkdir(parents=True, exist_ok=True)
+    with path.open("a", encoding="utf-8") as f:
+        for row in rows:
+            f.write(json.dumps(row, ensure_ascii=False) + "\n")
+
+
+def dry_candidates(example: TurnExample, version: str, n: int) -> List[str]:
+    base = "This fixed expert action is explained from the visible state while preserving the demonstrated answer."
+    if version == "sas" and example.next_user_content is not None:
+        base = "This fixed expert action is explained from the visible state and the observed next-state feedback."
+    return [f"{base} Candidate {i + 1}." for i in range(n)]
+
+
+def synthesize_version(
+    *,
+    version: str,
+    turns: Sequence[TurnExample],
+    args: argparse.Namespace,
+    output_dir: Path,
+    output_prefix: str,
+    llm: Any,
+    tokenizer: Any,
+    judge_llm: Any,
+    judge_tokenizer: Any,
+) -> Dict[Tuple[Any, int], Dict[str, Any]]:
+    cache_path = output_dir / f"{output_prefix}_with_think_{version}_bon{args.n}.cache.jsonl"
+    cache = {} if args.no_cache else load_cache(cache_path)
+    results: Dict[Tuple[Any, int], Dict[str, Any]] = {}
+    missing: List[TurnExample] = []
+    for ex in turns:
+        key = cache_key(version, ex.source_id, ex.turn_idx)
+        cached = cache.get(key)
+        if cached is not None and cached.get("selected_think"):
+            results[(ex.source_id, ex.turn_idx)] = cached
+        else:
+            missing.append(ex)
+
+    print(f"[{version}] turns={len(turns)} cached={len(results)} missing={len(missing)}")
+    gen_params = None if args.dry_run else make_sampling_params(args, judge=False)
+    judge_params = None if args.dry_run else make_sampling_params(args, judge=True)
+
+    for batch_no, batch in enumerate(chunks(missing, int(args.batch_size)), start=1):
+        batch = list(batch)
+        if args.dry_run:
+            all_candidates = [dry_candidates(ex, version, int(args.n)) for ex in batch]
+        else:
+            prompts = [render_prompt(tokenizer, build_generation_messages(ex, version)) for ex in batch]
+            outputs = llm.generate(prompts, sampling_params=gen_params)
+            all_candidates = []
+            for out in outputs:
+                candidates = [clean_think(candidate.text) for candidate in out.outputs]
+                candidates = [cand for cand in candidates if cand]
+                all_candidates.append(candidates)
+
+        judge_inputs: List[Tuple[TurnExample, List[str]]] = []
+        batch_rows: List[Dict[str, Any]] = []
+        for ex, candidates in zip(batch, all_candidates):
+            if not candidates:
+                selected = fallback_think(version)
+                row = {
+                    "cache_key": cache_key(version, ex.source_id, ex.turn_idx),
+                    "version": version,
+                    "source_id": ex.source_id,
+                    "turn_idx": ex.turn_idx,
+                    "total_turns": ex.total_turns,
+                    "selected_think": selected,
+                    "selected_index": None,
+                    "score": 0.0,
+                    "low_quality": True,
+                    "fallback": True,
+                    "missing_next_state": version == "sas" and ex.next_user_content is None,
+                    "selected_reason": "No valid generation candidates; used fallback.",
+                }
+                if args.save_candidates:
+                    row["candidates"] = []
+                batch_rows.append(row)
+            else:
+                judge_inputs.append((ex, candidates))
+
+        judge_texts: List[str] = []
+        if judge_inputs:
+            if args.dry_run:
+                judge_texts = [
+                    json.dumps(
+                        {
+                            "best_index": 1,
+                            "scores": [
+                                {
+                                    "index": 1,
+                                    "score": 3,
+                                    "unsupported_claims": 0,
+                                    "contradictions": 0,
+                                    "reason": "dry run",
+                                }
+                            ],
+                            "selected_reason": "dry run",
+                            "low_quality": False,
+                        }
+                    )
+                    for _ in judge_inputs
+                ]
+            else:
+                judge_prompts = [
+                    render_prompt(judge_tokenizer, build_judge_messages(ex, version, candidates))
+                    for ex, candidates in judge_inputs
+                ]
+                judge_texts = []
+                for judge_chunk in chunks(judge_prompts, int(args.judge_batch_size)):
+                    judge_outputs = judge_llm.generate(list(judge_chunk), sampling_params=judge_params)
+                    judge_texts.extend(out.outputs[0].text for out in judge_outputs)
+
+        for (ex, candidates), judge_text in zip(judge_inputs, judge_texts):
+            judge_obj = parse_judge_json(judge_text)
+            best_index = to_int(judge_obj.get("best_index"), 1)
+            if best_index < 1 or best_index > len(candidates):
+                best_index = 1
+            selected = candidates[best_index - 1]
+            score = selected_score(judge_obj, best_index)
+            if score <= 0.0:
+                score = 3.0 if selected else 0.0
+            low_quality = bool(judge_obj.get("low_quality", False)) or score < float(args.min_judge_score)
+            row = {
+                "cache_key": cache_key(version, ex.source_id, ex.turn_idx),
+                "version": version,
+                "source_id": ex.source_id,
+                "turn_idx": ex.turn_idx,
+                "total_turns": ex.total_turns,
+                "selected_think": selected or fallback_think(version),
+                "selected_index": best_index,
+                "score": score,
+                "low_quality": low_quality,
+                "fallback": not bool(selected),
+                "missing_next_state": version == "sas" and ex.next_user_content is None,
+                "selected_reason": str(judge_obj.get("selected_reason", "")),
+            }
+            if args.save_candidates:
+                row["candidates"] = candidates
+                row["judge"] = judge_obj
+                row["judge_raw"] = judge_text
+            batch_rows.append(row)
+
+        append_cache(cache_path, batch_rows) if not args.no_cache else None
+        for row in batch_rows:
+            results[(row["source_id"], int(row["turn_idx"]))] = row
+        print(f"[{version}] batch {batch_no}: wrote {len(batch_rows)} turn results")
+    return results
+
+
+def rebuild_rows(
+    rows: Sequence[Dict[str, Any]],
+    full: Dict[Any, FullTrajectory],
+    result_map: Dict[Tuple[Any, int], Dict[str, Any]],
+) -> List[Dict[str, Any]]:
+    rebuilt_by_source: Dict[Any, List[Tuple[Dict[str, Any], Dict[str, Any]]]] = {}
+    for source_id, traj in full.items():
+        new_pairs: List[Tuple[Dict[str, Any], Dict[str, Any]]] = []
+        for idx, (user_msg, asst_msg) in enumerate(traj.pairs, start=1):
+            answer_block = extract_answer_block(str(asst_msg.get("content", "")))
+            result = result_map.get((source_id, idx))
+            think = str(result.get("selected_think", "")) if result else fallback_think("sa")
+            new_user = copy.deepcopy(user_msg)
+            new_asst = copy.deepcopy(asst_msg)
+            if answer_block:
+                new_asst["content"] = make_response(think, answer_block)
+            else:
+                new_asst["content"] = str(asst_msg.get("content", ""))
+            new_pairs.append((new_user, new_asst))
+        rebuilt_by_source[source_id] = new_pairs
+
+    output: List[Dict[str, Any]] = []
+    for idx, row in enumerate(rows):
+        meta = row.get("meta") or {}
+        source_id = meta.get("source_id", f"missing_source_{idx}")
+        turns = to_int(meta.get("turns"), 0)
+        new_row = copy.deepcopy(row)
+        traj = full.get(source_id)
+        pairs = rebuilt_by_source.get(source_id)
+        if traj is None or pairs is None or turns <= 0:
+            output.append(new_row)
+            continue
+        turns = min(turns, len(pairs))
+        new_row["messages"] = copy.deepcopy(traj.sys_prefix) + [
+            copy.deepcopy(msg) for pair in pairs[:turns] for msg in pair
+        ]
+        output.append(new_row)
+    return output
+
+
+def validate_answer_unchanged(original: Sequence[Dict[str, Any]], rebuilt: Sequence[Dict[str, Any]]) -> Dict[str, Any]:
+    if len(original) != len(rebuilt):
+        raise ValueError(f"Row count changed: original={len(original)} rebuilt={len(rebuilt)}")
+    checked = 0
+    mismatches: List[Dict[str, Any]] = []
+    for row_idx, (old_row, new_row) in enumerate(zip(original, rebuilt)):
+        old_pairs = collect_pairs(old_row.get("messages") or [], start_idx=len(extract_system_prefix(old_row.get("messages") or [])))
+        new_pairs = collect_pairs(new_row.get("messages") or [], start_idx=len(extract_system_prefix(new_row.get("messages") or [])))
+        if len(old_pairs) != len(new_pairs):
+            mismatches.append({"row_idx": row_idx, "reason": "pair_count_changed"})
+            continue
+        for turn_idx, ((_, old_asst), (_, new_asst)) in enumerate(zip(old_pairs, new_pairs), start=1):
+            old_answer = extract_answer_block(str(old_asst.get("content", "")))
+            new_answer = extract_answer_block(str(new_asst.get("content", "")))
+            checked += 1
+            if old_answer != new_answer:
+                mismatches.append(
+                    {
+                        "row_idx": row_idx,
+                        "turn_idx": turn_idx,
+                        "old_answer": old_answer,
+                        "new_answer": new_answer,
+                    }
+                )
+                if len(mismatches) >= 20:
+                    break
+        if len(mismatches) >= 20:
+            break
+    if mismatches:
+        raise ValueError(f"Answer validation failed, examples: {mismatches[:3]}")
+    return {"checked_assistant_messages": checked, "answer_mismatches": 0}
+
+
+def filter_full_by_args(full: Dict[Any, FullTrajectory], args: argparse.Namespace) -> Dict[Any, FullTrajectory]:
+    selected = dict(full)
+    if args.source_ids.strip():
+        allow = {item.strip() for item in args.source_ids.split(",") if item.strip()}
+        selected = {sid: traj for sid, traj in selected.items() if source_key(sid) in allow}
+    if args.limit_sources is not None:
+        limited: Dict[Any, FullTrajectory] = {}
+        for sid in list(selected.keys())[: int(args.limit_sources)]:
+            limited[sid] = selected[sid]
+        selected = limited
+    return selected
+
+
+def report_from_results(
+    *,
+    version: str,
+    result_map: Dict[Tuple[Any, int], Dict[str, Any]],
+    validation: Dict[str, Any],
+    args: argparse.Namespace,
+) -> Dict[str, Any]:
+    values = list(result_map.values())
+    low_quality = sum(1 for row in values if row.get("low_quality"))
+    fallback = sum(1 for row in values if row.get("fallback"))
+    missing_next = sum(1 for row in values if row.get("missing_next_state"))
+    scores = [float(row.get("score", 0.0)) for row in values]
+    summary = {
+        "version": version,
+        "n": int(args.n),
+        "turn_results": len(values),
+        "low_quality": low_quality,
+        "fallback": fallback,
+        "missing_next_state": missing_next,
+        "avg_score": sum(scores) / len(scores) if scores else 0.0,
+        "min_score": min(scores) if scores else 0.0,
+        "max_score": max(scores) if scores else 0.0,
+        **validation,
+    }
+    per_turn: List[Dict[str, Any]] = []
+    for row in values:
+        item = {
+            "source_id": row.get("source_id"),
+            "turn_idx": row.get("turn_idx"),
+            "total_turns": row.get("total_turns"),
+            "selected_index": row.get("selected_index"),
+            "score": row.get("score"),
+            "low_quality": row.get("low_quality"),
+            "fallback": row.get("fallback"),
+            "missing_next_state": row.get("missing_next_state"),
+            "selected_reason": row.get("selected_reason", ""),
+        }
+        if args.save_candidates:
+            item["selected_think"] = row.get("selected_think")
+            item["candidates"] = row.get("candidates", [])
+            item["judge"] = row.get("judge", {})
+        per_turn.append(item)
+    return {"summary": summary, "per_turn": per_turn}
+
+
+def main() -> None:
+    args = parse_args()
+    versions = [v.strip() for v in args.versions.split(",") if v.strip()]
+    if not versions or any(v not in {"sa", "sas"} for v in versions):
+        raise ValueError("--versions must contain only sa and/or sas")
+    if not args.dry_run and not args.model:
+        raise ValueError("--model is required unless --dry-run is set")
+
+    input_path = args.input.expanduser().resolve()
+    output_dir = (args.output_dir or input_path.parent).expanduser().resolve()
+    output_prefix = args.output_prefix or input_path.stem
+
+    print(f"Loading input: {input_path}")
+    rows = load_json_list(input_path)
+    full_all = build_full_trajectories(rows)
+    full_selected = filter_full_by_args(full_all, args)
+    if not full_selected:
+        raise ValueError("No usable trajectories selected.")
+    turns = iter_turns(full_selected)
+    print(f"Rows={len(rows)} sources={len(full_all)} selected_sources={len(full_selected)} selected_turns={len(turns)}")
+
+    llm = tokenizer = judge_llm = judge_tokenizer = None
+    if not args.dry_run:
+        llm, tokenizer = load_vllm_model(args.model, args, tensor_parallel_size=args.tensor_parallel_size)
+        judge_model = args.judge_model or args.model
+        if judge_model == args.model:
+            judge_llm, judge_tokenizer = llm, tokenizer
+        else:
+            judge_tp = args.judge_tensor_parallel_size or args.tensor_parallel_size
+            judge_llm, judge_tokenizer = load_vllm_model(judge_model, args, tensor_parallel_size=judge_tp)
+
+    for version in versions:
+        result_map = synthesize_version(
+            version=version,
+            turns=turns,
+            args=args,
+            output_dir=output_dir,
+            output_prefix=output_prefix,
+            llm=llm,
+            tokenizer=tokenizer,
+            judge_llm=judge_llm,
+            judge_tokenizer=judge_tokenizer,
+        )
+        rows_for_output = [
+            row
+            for idx, row in enumerate(rows)
+            if not args.selected_only
+            or (row.get("meta") or {}).get("source_id", f"missing_source_{idx}") in full_selected
+        ]
+        rebuilt = rebuild_rows(rows_for_output, full_selected, result_map)
+        validation = validate_answer_unchanged(rows_for_output, rebuilt)
+        out_path = output_dir / f"{output_prefix}_with_think_{version}_bon{args.n}.json"
+        report_path = output_dir / f"{output_prefix}_with_think_{version}_bon{args.n}.report.json"
+        dump_json(out_path, rebuilt, indent=int(args.indent))
+        report = report_from_results(version=version, result_map=result_map, validation=validation, args=args)
+        dump_json(report_path, report, indent=2)
+        print(f"[{version}] wrote SFT: {out_path}")
+        print(f"[{version}] wrote report: {report_path}")
+        print(f"[{version}] summary: {json.dumps(report['summary'], ensure_ascii=False)}")
+
+
+if __name__ == "__main__":
+    main()

scripts/synthesize_think_bon_traj_sa.py

@@ -0,0 +1,884 @@
+#!/usr/bin/env python3
+"""Synthesize <think> traces for SFT singleturn trajectories with BoN + judge.
+
+This script is intentionally environment-agnostic. It assumes a JSON list of rows
+with the common RAGEN SFT shape:
+
+  {"messages": [{"role": "system"}, {"role": "user"}, {"role": "assistant"}, ...],
+   "meta": {"source_id": ..., "turns": ..., "total_turns": ...}}
+
+For each source_id, the complete trajectory row is selected, one reasoning trace
+is synthesized per turn, and the selected traces are written back to every
+cumulative singleturn prefix while keeping every original <answer>...</answer>
+block exactly unchanged.
+
+
+python3 /mnt/general/wanghy/RAGEN/scripts/synthesize_think_bon_v2.py \
+  --input /mnt/general/wanghy/RAGEN/runs/Sudoku__ppo_sudoku_actionmask__4x4/sft/step_999424_sft_singleturn_nohint.json \
+  --output-dir /mnt/general/wanghy/RAGEN/runs/Sudoku__ppo_sudoku_actionmask__4x4/sft/ \
+  --output-prefix step_999424_sft_singleturn_withthink \
+  --model /mnt/general/share/model/Qwen/Qwen2-72B-Instruct \
+  --tensor-parallel-size 4 \
+  --n 8 \
+  --batch-size 32 \
+  --judge-batch-size 32
+"""
+
+from __future__ import annotations
+
+import argparse
+import copy
+import json
+import re
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, Dict, Iterable, List, Optional, Sequence, Tuple
+
+
+ANSWER_RE = re.compile(r"<answer>.*?</answer>", re.IGNORECASE | re.DOTALL)
+THINK_RE = re.compile(r"<think>(.*?)</think>", re.IGNORECASE | re.DOTALL)
+JSON_OBJ_RE = re.compile(r"\{.*\}", re.DOTALL)
+META_REASONING_RE = re.compile(
+    r"\b("
+    r"expert action|fixed action|given action|provided action|target action|"
+    r"demonstrated action|demonstrated answer|known action|chosen by (?:the )?expert|"
+    r"the action (?:was|is) (?:given|fixed|provided|known)"
+    r")\b",
+    re.IGNORECASE,
+)
+
+
+@dataclass
+class TurnExample:
+    source_id: Any
+    turn_idx: int
+    total_turns: int
+    user_content: str
+    assistant_content: str
+    answer_block: str
+    next_user_content: Optional[str]
+    trajectory_context: str
+
+
+@dataclass
+class FullTrajectory:
+    source_id: Any
+    sys_prefix: List[Dict[str, Any]]
+    pairs: List[Tuple[Dict[str, Any], Dict[str, Any]]]
+    meta: Dict[str, Any]
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(
+        description="Synthesize first-person target-action thinking traces with per-turn BoN and LLM judge."
+    )
+    parser.add_argument("--input", "-i", type=Path, required=True, help="Input SFT JSON list.")
+    parser.add_argument(
+        "--output-dir",
+        type=Path,
+        default=None,
+        help="Directory for output files. Defaults to input parent.",
+    )
+    parser.add_argument(
+        "--output-prefix",
+        default=None,
+        help="Output filename prefix. Defaults to input stem.",
+    )
+    parser.add_argument(
+        "--versions",
+        default="traj_sa",
+        help="Comma-separated versions. This script supports only traj_sa: full trajectory in system, current s,a in user.",
+    )
+    parser.add_argument("--model", default=None, help="HF model path for tokenizer + vLLM.")
+    parser.add_argument("--judge-model", default=None, help="Optional separate judge model path.")
+    parser.add_argument("--n", type=int, default=8, help="BoN candidates per turn.")
+    parser.add_argument(
+        "--mode",
+        default="per_turn",
+        choices=["per_turn"],
+        help="BoN mode. Currently only independent per-turn BoN is implemented.",
+    )
+    parser.add_argument("--limit-sources", type=int, default=None, help="Pilot limit by source_id count.")
+    parser.add_argument("--source-ids", default="", help="Optional comma-separated source_id allowlist.")
+    parser.add_argument("--batch-size", type=int, default=64, help="Prompt batch size for generation.")
+    parser.add_argument("--judge-batch-size", type=int, default=64, help="Prompt batch size for judge.")
+    parser.add_argument("--temperature", type=float, default=0.7)
+    parser.add_argument("--top-p", type=float, default=0.95)
+    parser.add_argument("--top-k", type=int, default=-1)
+    parser.add_argument("--max-tokens", type=int, default=160, help="Max tokens for think generation.")
+    parser.add_argument("--judge-temperature", type=float, default=0.0)
+    parser.add_argument("--judge-max-tokens", type=int, default=768)
+    parser.add_argument("--tensor-parallel-size", type=int, default=1)
+    parser.add_argument("--judge-tensor-parallel-size", type=int, default=None)
+    parser.add_argument("--dtype", default="auto")
+    parser.add_argument("--gpu-memory-utilization", type=float, default=0.9)
+    parser.add_argument("--max-model-len", type=int, default=None)
+    parser.add_argument("--trust-remote-code", action="store_true")
+    parser.add_argument("--min-judge-score", type=float, default=3.0)
+    parser.add_argument("--save-candidates", action="store_true", help="Store all candidates in report.")
+    parser.add_argument(
+        "--trajectory-state-max-chars",
+        type=int,
+        default=1200,
+        help="Max characters kept for each state in the compact trajectory context. Use -1 to disable truncation.",
+    )
+    parser.add_argument(
+        "--trajectory-action-max-chars",
+        type=int,
+        default=200,
+        help="Max characters kept for each action in the compact trajectory context. Use -1 to disable truncation.",
+    )
+    parser.add_argument(
+        "--selected-only",
+        action="store_true",
+        help="Write only rows whose source_id was selected by --limit-sources/--source-ids.",
+    )
+    parser.add_argument("--no-cache", action="store_true", help="Disable JSONL cache/resume.")
+    parser.add_argument("--dry-run", action="store_true", help="Do not load vLLM; create deterministic mock thinks.")
+    parser.add_argument("--indent", type=int, default=2, help="JSON output indent. Use -1 for compact.")
+    return parser.parse_args()
+
+
+def load_json_list(path: Path) -> List[Dict[str, Any]]:
+    with path.open("r", encoding="utf-8") as f:
+        data = json.load(f)
+    if not isinstance(data, list):
+        raise ValueError(f"Expected JSON list at {path}, got {type(data).__name__}")
+    if not all(isinstance(row, dict) for row in data):
+        raise ValueError(f"Expected all rows to be objects in {path}")
+    return data
+
+
+def dump_json(path: Path, data: Any, indent: int) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    kwargs = {"ensure_ascii": False}
+    if indent >= 0:
+        kwargs["indent"] = indent
+    with path.open("w", encoding="utf-8") as f:
+        json.dump(data, f, **kwargs)
+
+
+def extract_system_prefix(messages: Sequence[Dict[str, Any]]) -> List[Dict[str, Any]]:
+    out: List[Dict[str, Any]] = []
+    for msg in messages:
+        if msg.get("role") == "system":
+            out.append(copy.deepcopy(msg))
+        else:
+            break
+    return out
+
+
+def collect_pairs(messages: Sequence[Dict[str, Any]], start_idx: int = 0) -> List[Tuple[Dict[str, Any], Dict[str, Any]]]:
+    pairs: List[Tuple[Dict[str, Any], Dict[str, Any]]] = []
+    idx = start_idx
+    while idx < len(messages):
+        while idx < len(messages) and messages[idx].get("role") != "user":
+            idx += 1
+        if idx >= len(messages):
+            break
+        if idx + 1 < len(messages) and messages[idx + 1].get("role") == "assistant":
+            pairs.append((copy.deepcopy(messages[idx]), copy.deepcopy(messages[idx + 1])))
+            idx += 2
+        else:
+            idx += 1
+    return pairs
+
+
+def to_int(value: Any, default: int = 0) -> int:
+    try:
+        return int(value)
+    except (TypeError, ValueError):
+        return default
+
+
+def source_key(source_id: Any) -> str:
+    return str(source_id)
+
+
+def group_rows(rows: Sequence[Dict[str, Any]]) -> Dict[Any, List[Dict[str, Any]]]:
+    groups: Dict[Any, List[Dict[str, Any]]] = {}
+    for idx, row in enumerate(rows):
+        meta = row.get("meta") or {}
+        source_id = meta.get("source_id", f"missing_source_{idx}")
+        groups.setdefault(source_id, []).append(row)
+    for items in groups.values():
+        items.sort(key=lambda r: to_int((r.get("meta") or {}).get("turns"), 0))
+    return groups
+
+
+def select_full_row(source_id: Any, items: Sequence[Dict[str, Any]]) -> Dict[str, Any]:
+    exact = [
+        row
+        for row in items
+        if to_int((row.get("meta") or {}).get("turns"), -1)
+        == to_int((row.get("meta") or {}).get("total_turns"), -2)
+    ]
+    if exact:
+        return exact[-1]
+    return max(items, key=lambda r: to_int((r.get("meta") or {}).get("turns"), 0))
+
+
+def build_full_trajectories(rows: Sequence[Dict[str, Any]]) -> Dict[Any, FullTrajectory]:
+    groups = group_rows(rows)
+    full: Dict[Any, FullTrajectory] = {}
+    for source_id, items in groups.items():
+        row = select_full_row(source_id, items)
+        messages = row.get("messages") or []
+        if not isinstance(messages, list):
+            continue
+        sys_prefix = extract_system_prefix(messages)
+        pairs = collect_pairs(messages, start_idx=len(sys_prefix))
+        if not pairs:
+            continue
+        full[source_id] = FullTrajectory(
+            source_id=source_id,
+            sys_prefix=sys_prefix,
+            pairs=pairs,
+            meta=dict(row.get("meta") or {}),
+        )
+    return full
+
+
+def extract_answer_block(text: str) -> str:
+    match = ANSWER_RE.search(text or "")
+    return match.group(0) if match is not None else ""
+
+
+def clean_think(text: str) -> str:
+    text = (text or "").strip()
+    think_match = THINK_RE.search(text)
+    if think_match is not None:
+        text = think_match.group(1).strip()
+    text = re.split(r"<\s*/?\s*answer\s*>", text, flags=re.IGNORECASE)[0]
+    text = re.sub(r"</?think>", "", text, flags=re.IGNORECASE)
+    text = re.sub(r"\s+", " ", text).strip()
+    text = text.strip('` \t\n\r"')
+    return text
+
+
+def make_response(think: str, answer_block: str) -> str:
+    return f"<think>{think.strip()}</think>{answer_block}"
+
+
+def has_meta_reasoning(text: str) -> bool:
+    return META_REASONING_RE.search(text or "") is not None
+
+
+def extract_answer_payload(text: str) -> str:
+    answer_block = extract_answer_block(text)
+    if not answer_block:
+        return (text or "").strip()
+    return re.sub(
+        r"^\s*<\s*answer\s*>|<\s*/\s*answer\s*>\s*$",
+        "",
+        answer_block,
+        flags=re.IGNORECASE | re.DOTALL,
+    ).strip()
+
+
+def compact_for_trajectory(text: str, max_chars: int) -> str:
+    text = (text or "").strip()
+    text = re.sub(r"\n{3,}", "\n\n", text)
+    text = text.replace("```", "'''")
+    if max_chars >= 0 and len(text) > max_chars:
+        text = text[:max_chars].rstrip() + " ...[truncated]"
+    return text
+
+
+def build_trajectory_context(traj: FullTrajectory, state_max_chars: int, action_max_chars: int) -> str:
+    chunks: List[str] = []
+    for idx, (user_msg, asst_msg) in enumerate(traj.pairs):
+        state = compact_for_trajectory(str(user_msg.get("content", "")), state_max_chars)
+        action = compact_for_trajectory(extract_answer_payload(str(asst_msg.get("content", ""))), action_max_chars)
+        chunks.append(f"(s{idx}: {state}, a{idx}: {action})")
+    return " -> ".join(chunks)
+
+
+def iter_turns(full: Dict[Any, FullTrajectory], state_max_chars: int, action_max_chars: int) -> List[TurnExample]:
+    turns: List[TurnExample] = []
+    for source_id, traj in full.items():
+        total_turns = len(traj.pairs)
+        trajectory_context = build_trajectory_context(traj, state_max_chars, action_max_chars)
+        for i, (user_msg, asst_msg) in enumerate(traj.pairs):
+            answer_block = extract_answer_block(str(asst_msg.get("content", "")))
+            next_user = None
+            if i + 1 < total_turns:
+                next_user = str(traj.pairs[i + 1][0].get("content", ""))
+            turns.append(
+                TurnExample(
+                    source_id=source_id,
+                    turn_idx=i + 1,
+                    total_turns=total_turns,
+                    user_content=str(user_msg.get("content", "")),
+                    assistant_content=str(asst_msg.get("content", "")),
+                    answer_block=answer_block,
+                    next_user_content=next_user,
+                    trajectory_context=trajectory_context,
+                )
+            )
+    return turns
+
+
+def build_generation_messages(example: TurnExample, version: str) -> List[Dict[str, str]]:
+    if version != "traj_sa":
+        raise ValueError(f"Unknown version for this script: {version}")
+    target_action = extract_answer_payload(example.assistant_content) or example.answer_block.strip()
+    system_parts = [
+        "You write faithful, concise first-person reasoning for your own next action.",
+        "You are given the full trajectory as compact ordered (state, action) tuples in the form (s0, a0) -> (s1, a1) -> ... .",
+        "Use the full trajectory only as context for understanding the current decision. Do not copy future information as if it were known at the current turn.",
+        "",
+        "Full compressed trajectory:",
+        "```text",
+        example.trajectory_context,
+        "```",
+    ]
+    parts = [
+        "You are the assistant acting in this environment at the current turn.",
+        "You have already decided which action to output; now write the private inner reasoning that naturally leads to that action.",
+        "Write from your own first-person decision-making perspective, as if you are solving the task, not evaluating another model or an expert.",
+        "Only output the inner text for <think>...</think>. Do not output <think>, </think>, <answer>, JSON, bullets, or any extra wrapper.",
+        "Do not say or imply that the action was given, fixed, known, demonstrated, provided, or chosen by an expert. Avoid meta phrases such as 'the expert action', 'the fixed action', 'given action', or 'demonstrated answer', 'the expert'.",
+        "Do not change to a different action. Do not invent hidden facts, future rewards, or unsupported optimality claims.",
+        "Keep it concise: 1-3 English sentences with step-by-step reasoning grounded in the current state/action and the compressed trajectory context.",
+        "",
+        "Current observation/state s:",
+        "```text",
+        example.user_content.strip(),
+        "```",
+        "",
+        "Action a that your reasoning should lead to:",
+        "```text",
+        target_action,
+        "```",
+    ]
+    return [
+        {"role": "system", "content": "\n".join(system_parts)},
+        {"role": "user", "content": "\n".join(parts)},
+    ]
+
+
+def build_judge_messages(example: TurnExample, version: str, candidates: Sequence[str]) -> List[Dict[str, str]]:
+    if version != "traj_sa":
+        raise ValueError(f"Unknown version for this script: {version}")
+    candidate_text = "\n".join(f"[{i + 1}] {cand}" for i, cand in enumerate(candidates))
+    target_action = extract_answer_payload(example.assistant_content) or example.answer_block.strip()
+    system_parts = [
+        "You are a strict factuality judge for reasoning traces.",
+        "You are given the full trajectory as compact ordered (state, action) tuples in the form (s0, a0) -> (s1, a1) -> ... .",
+        "Use it only to judge whether candidate reasoning is faithful to the current state/action and trajectory context.",
+        "",
+        "Full compressed trajectory:",
+        "```text",
+        example.trajectory_context,
+        "```",
+    ]
+    parts = [
+        "You are auditing candidate <think> texts for an SFT trajectory.",
+        "Select the candidate that reads like the assistant's own private step-by-step reasoning leading to the target action, while staying faithful to the visible context.",
+        "Strongly penalize meta-reasoning that says or implies the action was given, fixed, known, demonstrated, provided, or chosen by an expert.",
+        "Also penalize unsupported factual claims, contradicted claims, changing the action, excessive certainty such as 'only'/'optimal' without clear support, verbosity, and format pollution.",
+        "Return strict JSON only, with no markdown.",
+        "",
+        "Current observation/state s:",
+        "```text",
+        example.user_content.strip(),
+        "```",
+        "",
+        "Target action a that the reasoning should lead to:",
+        "```text",
+        target_action,
+        "```",
+        "",
+        "Candidates:",
+        candidate_text,
+        "",
+        "Use this JSON schema:",
+        '{"best_index": 1, "scores": [{"index": 1, "score": 1, "unsupported_claims": 0, "contradictions": 0, "reason": "short reason"}], "selected_reason": "short reason", "low_quality": false}',
+        "Scores are from 1 to 5. Set low_quality=true if the best candidate is still weak or generic.",
+    ]
+    return [
+        {"role": "system", "content": "\n".join(system_parts)},
+        {"role": "user", "content": "\n".join(parts)},
+    ]
+
+
+def render_prompt(tokenizer: Any, messages: List[Dict[str, str]]) -> str:
+    return tokenizer.apply_chat_template(messages, add_generation_prompt=True, tokenize=False)
+
+
+def load_vllm_model(
+    model_path: str,
+    args: argparse.Namespace,
+    tensor_parallel_size: Optional[int] = None,
+) -> Tuple[Any, Any]:
+    try:
+        from transformers import AutoTokenizer
+        from vllm import LLM
+    except ImportError as exc:
+        raise RuntimeError("This script requires `vllm` and `transformers`.") from exc
+
+    tokenizer = AutoTokenizer.from_pretrained(model_path, trust_remote_code=bool(args.trust_remote_code))
+    llm_kwargs: Dict[str, Any] = {
+        "model": model_path,
+        "tensor_parallel_size": int(tensor_parallel_size or args.tensor_parallel_size),
+        "dtype": args.dtype,
+        "gpu_memory_utilization": float(args.gpu_memory_utilization),
+        "trust_remote_code": bool(args.trust_remote_code),
+    }
+    if args.max_model_len is not None:
+        llm_kwargs["max_model_len"] = int(args.max_model_len)
+    return LLM(**llm_kwargs), tokenizer
+
+
+def make_sampling_params(args: argparse.Namespace, *, judge: bool = False) -> Any:
+    try:
+        from vllm import SamplingParams
+    except ImportError as exc:
+        raise RuntimeError("This script requires `vllm`.") from exc
+    if judge:
+        return SamplingParams(
+            temperature=float(args.judge_temperature),
+            top_p=1.0,
+            max_tokens=int(args.judge_max_tokens),
+        )
+    return SamplingParams(
+        n=int(args.n),
+        temperature=float(args.temperature),
+        top_p=float(args.top_p),
+        top_k=int(args.top_k),
+        max_tokens=int(args.max_tokens),
+    )
+
+
+def chunks(items: Sequence[Any], size: int) -> Iterable[Sequence[Any]]:
+    if size <= 0:
+        yield items
+        return
+    for start in range(0, len(items), size):
+        yield items[start : start + size]
+
+
+def parse_judge_json(text: str) -> Dict[str, Any]:
+    text = (text or "").strip()
+    match = JSON_OBJ_RE.search(text)
+    if match is not None:
+        text = match.group(0)
+    try:
+        obj = json.loads(text)
+        if isinstance(obj, dict):
+            return obj
+    except json.JSONDecodeError:
+        pass
+    return {}
+
+
+def selected_score(judge_obj: Dict[str, Any], best_index: int) -> float:
+    for item in judge_obj.get("scores") or []:
+        if isinstance(item, dict) and to_int(item.get("index"), -1) == best_index:
+            try:
+                return float(item.get("score", 0.0))
+            except (TypeError, ValueError):
+                return 0.0
+    return 0.0
+
+
+def fallback_think(version: str) -> str:
+    if version == "sas":
+        return (
+            "I compare the current observation with the next-state feedback and choose the move "
+            "that is consistent with making progress under the task constraints."
+        )
+    return (
+        "I inspect the current observation and choose the move that best follows the task constraints "
+        "while aiming to make progress from this state."
+    )
+
+
+def cache_key(version: str, source_id: Any, turn_idx: int) -> str:
+    return json.dumps(
+        {"version": version, "source_id": source_id, "turn_idx": turn_idx},
+        ensure_ascii=False,
+        sort_keys=True,
+    )
+
+
+def load_cache(path: Path) -> Dict[str, Dict[str, Any]]:
+    cache: Dict[str, Dict[str, Any]] = {}
+    if not path.exists():
+        return cache
+    with path.open("r", encoding="utf-8") as f:
+        for line_no, line in enumerate(f, start=1):
+            line = line.strip()
+            if not line:
+                continue
+            try:
+                row = json.loads(line)
+            except json.JSONDecodeError:
+                print(f"Warning: skipped invalid cache line {path}:{line_no}")
+                continue
+            key = row.get("cache_key")
+            if isinstance(key, str):
+                cache[key] = row
+    return cache
+
+
+def append_cache(path: Path, rows: Sequence[Dict[str, Any]]) -> None:
+    if not rows:
+        return
+    path.parent.mkdir(parents=True, exist_ok=True)
+    with path.open("a", encoding="utf-8") as f:
+        for row in rows:
+            f.write(json.dumps(row, ensure_ascii=False) + "\n")
+
+
+def dry_candidates(example: TurnExample, version: str, n: int) -> List[str]:
+    base = "I inspect the visible state and the compressed trajectory context to reason step by step toward the next move."
+    return [f"{base} Candidate {i + 1}." for i in range(n)]
+
+
+def synthesize_version(
+    *,
+    version: str,
+    turns: Sequence[TurnExample],
+    args: argparse.Namespace,
+    output_dir: Path,
+    output_prefix: str,
+    llm: Any,
+    tokenizer: Any,
+    judge_llm: Any,
+    judge_tokenizer: Any,
+) -> Dict[Tuple[Any, int], Dict[str, Any]]:
+    cache_path = output_dir / f"{output_prefix}_with_think_{version}_bon{args.n}.cache.jsonl"
+    cache = {} if args.no_cache else load_cache(cache_path)
+    results: Dict[Tuple[Any, int], Dict[str, Any]] = {}
+    missing: List[TurnExample] = []
+    for ex in turns:
+        key = cache_key(version, ex.source_id, ex.turn_idx)
+        cached = cache.get(key)
+        if cached is not None and cached.get("selected_think"):
+            results[(ex.source_id, ex.turn_idx)] = cached
+        else:
+            missing.append(ex)
+
+    print(f"[{version}] turns={len(turns)} cached={len(results)} missing={len(missing)}")
+    gen_params = None if args.dry_run else make_sampling_params(args, judge=False)
+    judge_params = None if args.dry_run else make_sampling_params(args, judge=True)
+
+    for batch_no, batch in enumerate(chunks(missing, int(args.batch_size)), start=1):
+        batch = list(batch)
+        if args.dry_run:
+            all_candidates = [dry_candidates(ex, version, int(args.n)) for ex in batch]
+        else:
+            prompts = [render_prompt(tokenizer, build_generation_messages(ex, version)) for ex in batch]
+            outputs = llm.generate(prompts, sampling_params=gen_params)
+            all_candidates = []
+            for out in outputs:
+                raw_candidates = [clean_think(candidate.text) for candidate in out.outputs]
+                candidates = [cand for cand in raw_candidates if cand and not has_meta_reasoning(cand)]
+                if not candidates:
+                    candidates = [cand for cand in raw_candidates if cand]
+                all_candidates.append(candidates)
+
+        judge_inputs: List[Tuple[TurnExample, List[str]]] = []
+        batch_rows: List[Dict[str, Any]] = []
+        for ex, candidates in zip(batch, all_candidates):
+            if not candidates:
+                selected = fallback_think(version)
+                row = {
+                    "cache_key": cache_key(version, ex.source_id, ex.turn_idx),
+                    "version": version,
+                    "source_id": ex.source_id,
+                    "turn_idx": ex.turn_idx,
+                    "total_turns": ex.total_turns,
+                    "selected_think": selected,
+                    "selected_index": None,
+                    "score": 0.0,
+                    "low_quality": True,
+                    "meta_language": False,
+                    "fallback": True,
+                    "missing_next_state": False,
+                    "selected_reason": "No valid generation candidates; used fallback.",
+                }
+                if args.save_candidates:
+                    row["candidates"] = []
+                batch_rows.append(row)
+            else:
+                judge_inputs.append((ex, candidates))
+
+        judge_texts: List[str] = []
+        if judge_inputs:
+            if args.dry_run:
+                judge_texts = [
+                    json.dumps(
+                        {
+                            "best_index": 1,
+                            "scores": [
+                                {
+                                    "index": 1,
+                                    "score": 3,
+                                    "unsupported_claims": 0,
+                                    "contradictions": 0,
+                                    "reason": "dry run",
+                                }
+                            ],
+                            "selected_reason": "dry run",
+                            "low_quality": False,
+                        }
+                    )
+                    for _ in judge_inputs
+                ]
+            else:
+                judge_prompts = [
+                    render_prompt(judge_tokenizer, build_judge_messages(ex, version, candidates))
+                    for ex, candidates in judge_inputs
+                ]
+                judge_texts = []
+                for judge_chunk in chunks(judge_prompts, int(args.judge_batch_size)):
+                    judge_outputs = judge_llm.generate(list(judge_chunk), sampling_params=judge_params)
+                    judge_texts.extend(out.outputs[0].text for out in judge_outputs)
+
+        for (ex, candidates), judge_text in zip(judge_inputs, judge_texts):
+            judge_obj = parse_judge_json(judge_text)
+            best_index = to_int(judge_obj.get("best_index"), 1)
+            if best_index < 1 or best_index > len(candidates):
+                best_index = 1
+            selected = candidates[best_index - 1]
+            meta_language = has_meta_reasoning(selected)
+            score = selected_score(judge_obj, best_index)
+            if score <= 0.0:
+                score = 3.0 if selected else 0.0
+            low_quality = (
+                bool(judge_obj.get("low_quality", False))
+                or score < float(args.min_judge_score)
+                or meta_language
+            )
+            row = {
+                "cache_key": cache_key(version, ex.source_id, ex.turn_idx),
+                "version": version,
+                "source_id": ex.source_id,
+                "turn_idx": ex.turn_idx,
+                "total_turns": ex.total_turns,
+                "selected_think": selected or fallback_think(version),
+                "selected_index": best_index,
+                "score": score,
+                "low_quality": low_quality,
+                "meta_language": meta_language,
+                "fallback": not bool(selected),
+                "missing_next_state": False,
+                "selected_reason": str(judge_obj.get("selected_reason", "")),
+            }
+            if args.save_candidates:
+                row["candidates"] = candidates
+                row["judge"] = judge_obj
+                row["judge_raw"] = judge_text
+            batch_rows.append(row)
+
+        append_cache(cache_path, batch_rows) if not args.no_cache else None
+        for row in batch_rows:
+            results[(row["source_id"], int(row["turn_idx"]))] = row
+        print(f"[{version}] batch {batch_no}: wrote {len(batch_rows)} turn results")
+    return results
+
+
+def rebuild_rows(
+    rows: Sequence[Dict[str, Any]],
+    full: Dict[Any, FullTrajectory],
+    result_map: Dict[Tuple[Any, int], Dict[str, Any]],
+) -> List[Dict[str, Any]]:
+    rebuilt_by_source: Dict[Any, List[Tuple[Dict[str, Any], Dict[str, Any]]]] = {}
+    for source_id, traj in full.items():
+        new_pairs: List[Tuple[Dict[str, Any], Dict[str, Any]]] = []
+        for idx, (user_msg, asst_msg) in enumerate(traj.pairs, start=1):
+            answer_block = extract_answer_block(str(asst_msg.get("content", "")))
+            result = result_map.get((source_id, idx))
+            think = str(result.get("selected_think", "")) if result else fallback_think("traj_sa")
+            new_user = copy.deepcopy(user_msg)
+            new_asst = copy.deepcopy(asst_msg)
+            if answer_block:
+                new_asst["content"] = make_response(think, answer_block)
+            else:
+                new_asst["content"] = str(asst_msg.get("content", ""))
+            new_pairs.append((new_user, new_asst))
+        rebuilt_by_source[source_id] = new_pairs
+
+    output: List[Dict[str, Any]] = []
+    for idx, row in enumerate(rows):
+        meta = row.get("meta") or {}
+        source_id = meta.get("source_id", f"missing_source_{idx}")
+        turns = to_int(meta.get("turns"), 0)
+        new_row = copy.deepcopy(row)
+        traj = full.get(source_id)
+        pairs = rebuilt_by_source.get(source_id)
+        if traj is None or pairs is None or turns <= 0:
+            output.append(new_row)
+            continue
+        turns = min(turns, len(pairs))
+        new_row["messages"] = copy.deepcopy(traj.sys_prefix) + [
+            copy.deepcopy(msg) for pair in pairs[:turns] for msg in pair
+        ]
+        output.append(new_row)
+    return output
+
+
+def validate_answer_unchanged(original: Sequence[Dict[str, Any]], rebuilt: Sequence[Dict[str, Any]]) -> Dict[str, Any]:
+    if len(original) != len(rebuilt):
+        raise ValueError(f"Row count changed: original={len(original)} rebuilt={len(rebuilt)}")
+    checked = 0
+    mismatches: List[Dict[str, Any]] = []
+    for row_idx, (old_row, new_row) in enumerate(zip(original, rebuilt)):
+        old_pairs = collect_pairs(old_row.get("messages") or [], start_idx=len(extract_system_prefix(old_row.get("messages") or [])))
+        new_pairs = collect_pairs(new_row.get("messages") or [], start_idx=len(extract_system_prefix(new_row.get("messages") or [])))
+        if len(old_pairs) != len(new_pairs):
+            mismatches.append({"row_idx": row_idx, "reason": "pair_count_changed"})
+            continue
+        for turn_idx, ((_, old_asst), (_, new_asst)) in enumerate(zip(old_pairs, new_pairs), start=1):
+            old_answer = extract_answer_block(str(old_asst.get("content", "")))
+            new_answer = extract_answer_block(str(new_asst.get("content", "")))
+            checked += 1
+            if old_answer != new_answer:
+                mismatches.append(
+                    {
+                        "row_idx": row_idx,
+                        "turn_idx": turn_idx,
+                        "old_answer": old_answer,
+                        "new_answer": new_answer,
+                    }
+                )
+                if len(mismatches) >= 20:
+                    break
+        if len(mismatches) >= 20:
+            break
+    if mismatches:
+        raise ValueError(f"Answer validation failed, examples: {mismatches[:3]}")
+    return {"checked_assistant_messages": checked, "answer_mismatches": 0}
+
+
+def filter_full_by_args(full: Dict[Any, FullTrajectory], args: argparse.Namespace) -> Dict[Any, FullTrajectory]:
+    selected = dict(full)
+    if args.source_ids.strip():
+        allow = {item.strip() for item in args.source_ids.split(",") if item.strip()}
+        selected = {sid: traj for sid, traj in selected.items() if source_key(sid) in allow}
+    if args.limit_sources is not None:
+        limited: Dict[Any, FullTrajectory] = {}
+        for sid in list(selected.keys())[: int(args.limit_sources)]:
+            limited[sid] = selected[sid]
+        selected = limited
+    return selected
+
+
+def report_from_results(
+    *,
+    version: str,
+    result_map: Dict[Tuple[Any, int], Dict[str, Any]],
+    validation: Dict[str, Any],
+    args: argparse.Namespace,
+) -> Dict[str, Any]:
+    values = list(result_map.values())
+    low_quality = sum(1 for row in values if row.get("low_quality"))
+    fallback = sum(1 for row in values if row.get("fallback"))
+    meta_language = sum(1 for row in values if row.get("meta_language"))
+    missing_next = sum(1 for row in values if row.get("missing_next_state"))
+    scores = [float(row.get("score", 0.0)) for row in values]
+    summary = {
+        "version": version,
+        "n": int(args.n),
+        "turn_results": len(values),
+        "low_quality": low_quality,
+        "fallback": fallback,
+        "meta_language": meta_language,
+        "missing_next_state": missing_next,
+        "avg_score": sum(scores) / len(scores) if scores else 0.0,
+        "min_score": min(scores) if scores else 0.0,
+        "max_score": max(scores) if scores else 0.0,
+        **validation,
+    }
+    per_turn: List[Dict[str, Any]] = []
+    for row in values:
+        item = {
+            "source_id": row.get("source_id"),
+            "turn_idx": row.get("turn_idx"),
+            "total_turns": row.get("total_turns"),
+            "selected_index": row.get("selected_index"),
+            "score": row.get("score"),
+            "low_quality": row.get("low_quality"),
+            "fallback": row.get("fallback"),
+            "meta_language": row.get("meta_language", False),
+            "missing_next_state": row.get("missing_next_state"),
+            "selected_reason": row.get("selected_reason", ""),
+        }
+        if args.save_candidates:
+            item["selected_think"] = row.get("selected_think")
+            item["candidates"] = row.get("candidates", [])
+            item["judge"] = row.get("judge", {})
+        per_turn.append(item)
+    return {"summary": summary, "per_turn": per_turn}
+
+
+def main() -> None:
+    args = parse_args()
+    versions = [v.strip() for v in args.versions.split(",") if v.strip()]
+    if not versions or any(v != "traj_sa" for v in versions):
+        raise ValueError("--versions must contain only traj_sa for this script")
+    if not args.dry_run and not args.model:
+        raise ValueError("--model is required unless --dry-run is set")
+
+    input_path = args.input.expanduser().resolve()
+    output_dir = (args.output_dir or input_path.parent).expanduser().resolve()
+    output_prefix = args.output_prefix or input_path.stem
+
+    print(f"Loading input: {input_path}")
+    rows = load_json_list(input_path)
+    full_all = build_full_trajectories(rows)
+    full_selected = filter_full_by_args(full_all, args)
+    if not full_selected:
+        raise ValueError("No usable trajectories selected.")
+    turns = iter_turns(
+        full_selected,
+        state_max_chars=int(args.trajectory_state_max_chars),
+        action_max_chars=int(args.trajectory_action_max_chars),
+    )
+    print(f"Rows={len(rows)} sources={len(full_all)} selected_sources={len(full_selected)} selected_turns={len(turns)}")
+
+    llm = tokenizer = judge_llm = judge_tokenizer = None
+    if not args.dry_run:
+        llm, tokenizer = load_vllm_model(args.model, args, tensor_parallel_size=args.tensor_parallel_size)
+        judge_model = args.judge_model or args.model
+        if judge_model == args.model:
+            judge_llm, judge_tokenizer = llm, tokenizer
+        else:
+            judge_tp = args.judge_tensor_parallel_size or args.tensor_parallel_size
+            judge_llm, judge_tokenizer = load_vllm_model(judge_model, args, tensor_parallel_size=judge_tp)
+
+    for version in versions:
+        result_map = synthesize_version(
+            version=version,
+            turns=turns,
+            args=args,
+            output_dir=output_dir,
+            output_prefix=output_prefix,
+            llm=llm,
+            tokenizer=tokenizer,
+            judge_llm=judge_llm,
+            judge_tokenizer=judge_tokenizer,
+        )
+        rows_for_output = [
+            row
+            for idx, row in enumerate(rows)
+            if not args.selected_only
+            or (row.get("meta") or {}).get("source_id", f"missing_source_{idx}") in full_selected
+        ]
+        rebuilt = rebuild_rows(rows_for_output, full_selected, result_map)
+        validation = validate_answer_unchanged(rows_for_output, rebuilt)
+        out_path = output_dir / f"{output_prefix}_with_think_{version}_bon{args.n}.json"
+        report_path = output_dir / f"{output_prefix}_with_think_{version}_bon{args.n}.report.json"
+        dump_json(out_path, rebuilt, indent=int(args.indent))
+        report = report_from_results(version=version, result_map=result_map, validation=validation, args=args)
+        dump_json(report_path, report, indent=2)
+        print(f"[{version}] wrote SFT: {out_path}")
+        print(f"[{version}] wrote report: {report_path}")
+        print(f"[{version}] summary: {json.dumps(report['summary'], ensure_ascii=False)}")
+
+
+if __name__ == "__main__":
+    main()

scripts/synthesize_think_bon_v2.py

@@ -0,0 +1,854 @@
+#!/usr/bin/env python3
+"""Synthesize <think> traces for SFT singleturn trajectories with BoN + judge.
+
+This script is intentionally environment-agnostic. It assumes a JSON list of rows
+with the common RAGEN SFT shape:
+
+  {"messages": [{"role": "system"}, {"role": "user"}, {"role": "assistant"}, ...],
+   "meta": {"source_id": ..., "turns": ..., "total_turns": ...}}
+
+For each source_id, the complete trajectory row is selected, one reasoning trace
+is synthesized per turn, and the selected traces are written back to every
+cumulative singleturn prefix while keeping every original <answer>...</answer>
+block exactly unchanged.
+
+
+python3 /mnt/general/wanghy/RAGEN/scripts/synthesize_think_bon_v2.py \
+  --input /mnt/general/wanghy/RAGEN/runs/Sudoku__ppo_sudoku_actionmask__4x4/sft/step_999424_sft_singleturn_nohint.json \
+  --output-dir /mnt/general/wanghy/RAGEN/runs/Sudoku__ppo_sudoku_actionmask__4x4/sft/ \
+  --output-prefix step_999424_sft_singleturn_withthink \
+  --versions sa,sas \
+  --model /mnt/general/share/model/Qwen/Qwen2-72B-Instruct \
+  --tensor-parallel-size 4 \
+  --n 8 \
+  --batch-size 32 \
+  --judge-batch-size 32 \
+  --limit-sources 50
+"""
+
+from __future__ import annotations
+
+import argparse
+import copy
+import json
+import re
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, Dict, Iterable, List, Optional, Sequence, Tuple
+
+
+ANSWER_RE = re.compile(r"<answer>.*?</answer>", re.IGNORECASE | re.DOTALL)
+THINK_RE = re.compile(r"<think>(.*?)</think>", re.IGNORECASE | re.DOTALL)
+JSON_OBJ_RE = re.compile(r"\{.*\}", re.DOTALL)
+META_REASONING_RE = re.compile(
+    r"\b("
+    r"expert action|fixed action|given action|provided action|target action|"
+    r"demonstrated action|demonstrated answer|known action|chosen by (?:the )?expert|"
+    r"the action (?:was|is) (?:given|fixed|provided|known)"
+    r")\b",
+    re.IGNORECASE,
+)
+
+
+@dataclass
+class TurnExample:
+    source_id: Any
+    turn_idx: int
+    total_turns: int
+    user_content: str
+    assistant_content: str
+    answer_block: str
+    next_user_content: Optional[str]
+
+
+@dataclass
+class FullTrajectory:
+    source_id: Any
+    sys_prefix: List[Dict[str, Any]]
+    pairs: List[Tuple[Dict[str, Any], Dict[str, Any]]]
+    meta: Dict[str, Any]
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(
+        description="Synthesize first-person target-action thinking traces with per-turn BoN and LLM judge."
+    )
+    parser.add_argument("--input", "-i", type=Path, required=True, help="Input SFT JSON list.")
+    parser.add_argument(
+        "--output-dir",
+        type=Path,
+        default=None,
+        help="Directory for output files. Defaults to input parent.",
+    )
+    parser.add_argument(
+        "--output-prefix",
+        default=None,
+        help="Output filename prefix. Defaults to input stem.",
+    )
+    parser.add_argument(
+        "--versions",
+        default="sa,sas",
+        help="Comma-separated versions: sa and/or sas. sa uses s,a; sas uses s,a,s'.",
+    )
+    parser.add_argument("--model", default=None, help="HF model path for tokenizer + vLLM.")
+    parser.add_argument("--judge-model", default=None, help="Optional separate judge model path.")
+    parser.add_argument("--n", type=int, default=8, help="BoN candidates per turn.")
+    parser.add_argument(
+        "--mode",
+        default="per_turn",
+        choices=["per_turn"],
+        help="BoN mode. Currently only independent per-turn BoN is implemented.",
+    )
+    parser.add_argument("--limit-sources", type=int, default=None, help="Pilot limit by source_id count.")
+    parser.add_argument("--source-ids", default="", help="Optional comma-separated source_id allowlist.")
+    parser.add_argument("--batch-size", type=int, default=64, help="Prompt batch size for generation.")
+    parser.add_argument("--judge-batch-size", type=int, default=64, help="Prompt batch size for judge.")
+    parser.add_argument("--temperature", type=float, default=0.7)
+    parser.add_argument("--top-p", type=float, default=0.95)
+    parser.add_argument("--top-k", type=int, default=-1)
+    parser.add_argument("--max-tokens", type=int, default=160, help="Max tokens for think generation.")
+    parser.add_argument("--judge-temperature", type=float, default=0.0)
+    parser.add_argument("--judge-max-tokens", type=int, default=768)
+    parser.add_argument("--tensor-parallel-size", type=int, default=1)
+    parser.add_argument("--judge-tensor-parallel-size", type=int, default=None)
+    parser.add_argument("--dtype", default="auto")
+    parser.add_argument("--gpu-memory-utilization", type=float, default=0.9)
+    parser.add_argument("--max-model-len", type=int, default=None)
+    parser.add_argument("--trust-remote-code", action="store_true")
+    parser.add_argument("--min-judge-score", type=float, default=3.0)
+    parser.add_argument("--save-candidates", action="store_true", help="Store all candidates in report.")
+    parser.add_argument(
+        "--selected-only",
+        action="store_true",
+        help="Write only rows whose source_id was selected by --limit-sources/--source-ids.",
+    )
+    parser.add_argument("--no-cache", action="store_true", help="Disable JSONL cache/resume.")
+    parser.add_argument("--dry-run", action="store_true", help="Do not load vLLM; create deterministic mock thinks.")
+    parser.add_argument("--indent", type=int, default=2, help="JSON output indent. Use -1 for compact.")
+    return parser.parse_args()
+
+
+def load_json_list(path: Path) -> List[Dict[str, Any]]:
+    with path.open("r", encoding="utf-8") as f:
+        data = json.load(f)
+    if not isinstance(data, list):
+        raise ValueError(f"Expected JSON list at {path}, got {type(data).__name__}")
+    if not all(isinstance(row, dict) for row in data):
+        raise ValueError(f"Expected all rows to be objects in {path}")
+    return data
+
+
+def dump_json(path: Path, data: Any, indent: int) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    kwargs = {"ensure_ascii": False}
+    if indent >= 0:
+        kwargs["indent"] = indent
+    with path.open("w", encoding="utf-8") as f:
+        json.dump(data, f, **kwargs)
+
+
+def extract_system_prefix(messages: Sequence[Dict[str, Any]]) -> List[Dict[str, Any]]:
+    out: List[Dict[str, Any]] = []
+    for msg in messages:
+        if msg.get("role") == "system":
+            out.append(copy.deepcopy(msg))
+        else:
+            break
+    return out
+
+
+def collect_pairs(messages: Sequence[Dict[str, Any]], start_idx: int = 0) -> List[Tuple[Dict[str, Any], Dict[str, Any]]]:
+    pairs: List[Tuple[Dict[str, Any], Dict[str, Any]]] = []
+    idx = start_idx
+    while idx < len(messages):
+        while idx < len(messages) and messages[idx].get("role") != "user":
+            idx += 1
+        if idx >= len(messages):
+            break
+        if idx + 1 < len(messages) and messages[idx + 1].get("role") == "assistant":
+            pairs.append((copy.deepcopy(messages[idx]), copy.deepcopy(messages[idx + 1])))
+            idx += 2
+        else:
+            idx += 1
+    return pairs
+
+
+def to_int(value: Any, default: int = 0) -> int:
+    try:
+        return int(value)
+    except (TypeError, ValueError):
+        return default
+
+
+def source_key(source_id: Any) -> str:
+    return str(source_id)
+
+
+def group_rows(rows: Sequence[Dict[str, Any]]) -> Dict[Any, List[Dict[str, Any]]]:
+    groups: Dict[Any, List[Dict[str, Any]]] = {}
+    for idx, row in enumerate(rows):
+        meta = row.get("meta") or {}
+        source_id = meta.get("source_id", f"missing_source_{idx}")
+        groups.setdefault(source_id, []).append(row)
+    for items in groups.values():
+        items.sort(key=lambda r: to_int((r.get("meta") or {}).get("turns"), 0))
+    return groups
+
+
+def select_full_row(source_id: Any, items: Sequence[Dict[str, Any]]) -> Dict[str, Any]:
+    exact = [
+        row
+        for row in items
+        if to_int((row.get("meta") or {}).get("turns"), -1)
+        == to_int((row.get("meta") or {}).get("total_turns"), -2)
+    ]
+    if exact:
+        return exact[-1]
+    return max(items, key=lambda r: to_int((r.get("meta") or {}).get("turns"), 0))
+
+
+def build_full_trajectories(rows: Sequence[Dict[str, Any]]) -> Dict[Any, FullTrajectory]:
+    groups = group_rows(rows)
+    full: Dict[Any, FullTrajectory] = {}
+    for source_id, items in groups.items():
+        row = select_full_row(source_id, items)
+        messages = row.get("messages") or []
+        if not isinstance(messages, list):
+            continue
+        sys_prefix = extract_system_prefix(messages)
+        pairs = collect_pairs(messages, start_idx=len(sys_prefix))
+        if not pairs:
+            continue
+        full[source_id] = FullTrajectory(
+            source_id=source_id,
+            sys_prefix=sys_prefix,
+            pairs=pairs,
+            meta=dict(row.get("meta") or {}),
+        )
+    return full
+
+
+def extract_answer_block(text: str) -> str:
+    match = ANSWER_RE.search(text or "")
+    return match.group(0) if match is not None else ""
+
+
+def clean_think(text: str) -> str:
+    text = (text or "").strip()
+    think_match = THINK_RE.search(text)
+    if think_match is not None:
+        text = think_match.group(1).strip()
+    text = re.split(r"<\s*/?\s*answer\s*>", text, flags=re.IGNORECASE)[0]
+    text = re.sub(r"</?think>", "", text, flags=re.IGNORECASE)
+    text = re.sub(r"\s+", " ", text).strip()
+    text = text.strip('` \t\n\r"')
+    return text
+
+
+def make_response(think: str, answer_block: str) -> str:
+    return f"<think>{think.strip()}</think>{answer_block}"
+
+
+def has_meta_reasoning(text: str) -> bool:
+    return META_REASONING_RE.search(text or "") is not None
+
+
+def iter_turns(full: Dict[Any, FullTrajectory]) -> List[TurnExample]:
+    turns: List[TurnExample] = []
+    for source_id, traj in full.items():
+        total_turns = len(traj.pairs)
+        for i, (user_msg, asst_msg) in enumerate(traj.pairs):
+            answer_block = extract_answer_block(str(asst_msg.get("content", "")))
+            next_user = None
+            if i + 1 < total_turns:
+                next_user = str(traj.pairs[i + 1][0].get("content", ""))
+            turns.append(
+                TurnExample(
+                    source_id=source_id,
+                    turn_idx=i + 1,
+                    total_turns=total_turns,
+                    user_content=str(user_msg.get("content", "")),
+                    assistant_content=str(asst_msg.get("content", "")),
+                    answer_block=answer_block,
+                    next_user_content=next_user,
+                )
+            )
+    return turns
+
+
+def build_generation_messages(example: TurnExample, version: str) -> List[Dict[str, str]]:
+    if version not in {"sa", "sas"}:
+        raise ValueError(f"Unknown version: {version}")
+    sas_available = version == "sas" and example.next_user_content is not None
+    parts = [
+        "You are the assistant acting in this environment at the current turn.",
+        "You have already decided which action to output; now write the private inner reasoning that naturally leads to that action.",
+        "Write from your own first-person decision-making perspective, as if you are solving the task, not evaluating another model or an expert.",
+        "Only output the inner text for <think>...</think>. Do not output <think>, </think>, <answer>, JSON, bullets, or any extra wrapper.",
+        "Do not say or imply that the action was given, fixed, known, demonstrated, provided, or chosen by an expert. Avoid meta phrases such as 'the expert action', 'the fixed action', 'given action', or 'demonstrated answer', 'the expert'.",
+        "Do not change to a different action. Do not invent hidden facts, future rewards, or unsupported optimality claims.",
+        "Keep it concise: 1-3 English sentences with step-by-step reasoning grounded in the visible context.",
+        "",
+        "Current observation/state s:",
+        "```text",
+        example.user_content.strip(),
+        "```",
+        "",
+        "Action that your reasoning should lead to:",
+        "```text",
+        example.answer_block.strip() or example.assistant_content.strip(),
+        "```",
+    ]
+    if sas_available:
+        parts.extend(
+            [
+                "",
+                "Observed next state/feedback s' after taking this action:",
+                "```text",
+                str(example.next_user_content).strip(),
+                "```",
+                "Use s' only to ground the explanation of the observed transition; do not switch to another action.",
+            ]
+        )
+    elif version == "sas":
+        parts.extend(
+            [
+                "",
+                "No next state s' is available for this final turn, so explain using only s and a.",
+            ]
+        )
+    return [
+        {
+            "role": "system",
+            "content": "You write faithful, concise first-person reasoning for your own next action.",
+        },
+        {"role": "user", "content": "\n".join(parts)},
+    ]
+
+
+def build_judge_messages(example: TurnExample, version: str, candidates: Sequence[str]) -> List[Dict[str, str]]:
+    candidate_text = "\n".join(f"[{i + 1}] {cand}" for i, cand in enumerate(candidates))
+    sas_available = version == "sas" and example.next_user_content is not None
+    parts = [
+        "You are auditing candidate <think> texts for an SFT trajectory.",
+        "Select the candidate that reads like the assistant's own private step-by-step reasoning leading to the target action, while staying faithful to the visible context.",
+        "Strongly penalize meta-reasoning that says or implies the action was given, fixed, known, demonstrated, provided, or chosen by an expert.",
+        "Also penalize unsupported factual claims, contradicted claims, changing the action, excessive certainty such as 'only'/'optimal' without clear support, verbosity, and format pollution.",
+        "Return strict JSON only, with no markdown.",
+        "",
+        "Current observation/state s:",
+        "```text",
+        example.user_content.strip(),
+        "```",
+        "",
+        "Target action a that the reasoning should lead to:",
+        "```text",
+        example.answer_block.strip() or example.assistant_content.strip(),
+        "```",
+    ]
+    if sas_available:
+        parts.extend(
+            [
+                "",
+                "Observed next state/feedback s' after taking action a:",
+                "```text",
+                str(example.next_user_content).strip(),
+                "```",
+            ]
+        )
+    elif version == "sas":
+        parts.append("\nNo next state s' is available for this final turn.")
+    parts.extend(
+        [
+            "",
+            "Candidates:",
+            candidate_text,
+            "",
+            "Use this JSON schema:",
+            '{"best_index": 1, "scores": [{"index": 1, "score": 1, "unsupported_claims": 0, "contradictions": 0, "reason": "short reason"}], "selected_reason": "short reason", "low_quality": false}',
+            "Scores are from 1 to 5. Set low_quality=true if the best candidate is still weak or generic.",
+        ]
+    )
+    return [
+        {"role": "system", "content": "You are a strict factuality judge for reasoning traces."},
+        {"role": "user", "content": "\n".join(parts)},
+    ]
+
+
+def render_prompt(tokenizer: Any, messages: List[Dict[str, str]]) -> str:
+    return tokenizer.apply_chat_template(messages, add_generation_prompt=True, tokenize=False)
+
+
+def load_vllm_model(
+    model_path: str,
+    args: argparse.Namespace,
+    tensor_parallel_size: Optional[int] = None,
+) -> Tuple[Any, Any]:
+    try:
+        from transformers import AutoTokenizer
+        from vllm import LLM
+    except ImportError as exc:
+        raise RuntimeError("This script requires `vllm` and `transformers`.") from exc
+
+    tokenizer = AutoTokenizer.from_pretrained(model_path, trust_remote_code=bool(args.trust_remote_code))
+    llm_kwargs: Dict[str, Any] = {
+        "model": model_path,
+        "tensor_parallel_size": int(tensor_parallel_size or args.tensor_parallel_size),
+        "dtype": args.dtype,
+        "gpu_memory_utilization": float(args.gpu_memory_utilization),
+        "trust_remote_code": bool(args.trust_remote_code),
+    }
+    if args.max_model_len is not None:
+        llm_kwargs["max_model_len"] = int(args.max_model_len)
+    return LLM(**llm_kwargs), tokenizer
+
+
+def make_sampling_params(args: argparse.Namespace, *, judge: bool = False) -> Any:
+    try:
+        from vllm import SamplingParams
+    except ImportError as exc:
+        raise RuntimeError("This script requires `vllm`.") from exc
+    if judge:
+        return SamplingParams(
+            temperature=float(args.judge_temperature),
+            top_p=1.0,
+            max_tokens=int(args.judge_max_tokens),
+        )
+    return SamplingParams(
+        n=int(args.n),
+        temperature=float(args.temperature),
+        top_p=float(args.top_p),
+        top_k=int(args.top_k),
+        max_tokens=int(args.max_tokens),
+    )
+
+
+def chunks(items: Sequence[Any], size: int) -> Iterable[Sequence[Any]]:
+    if size <= 0:
+        yield items
+        return
+    for start in range(0, len(items), size):
+        yield items[start : start + size]
+
+
+def parse_judge_json(text: str) -> Dict[str, Any]:
+    text = (text or "").strip()
+    match = JSON_OBJ_RE.search(text)
+    if match is not None:
+        text = match.group(0)
+    try:
+        obj = json.loads(text)
+        if isinstance(obj, dict):
+            return obj
+    except json.JSONDecodeError:
+        pass
+    return {}
+
+
+def selected_score(judge_obj: Dict[str, Any], best_index: int) -> float:
+    for item in judge_obj.get("scores") or []:
+        if isinstance(item, dict) and to_int(item.get("index"), -1) == best_index:
+            try:
+                return float(item.get("score", 0.0))
+            except (TypeError, ValueError):
+                return 0.0
+    return 0.0
+
+
+def fallback_think(version: str) -> str:
+    if version == "sas":
+        return (
+            "I compare the current observation with the next-state feedback and choose the move "
+            "that is consistent with making progress under the task constraints."
+        )
+    return (
+        "I inspect the current observation and choose the move that best follows the task constraints "
+        "while aiming to make progress from this state."
+    )
+
+
+def cache_key(version: str, source_id: Any, turn_idx: int) -> str:
+    return json.dumps(
+        {"version": version, "source_id": source_id, "turn_idx": turn_idx},
+        ensure_ascii=False,
+        sort_keys=True,
+    )
+
+
+def load_cache(path: Path) -> Dict[str, Dict[str, Any]]:
+    cache: Dict[str, Dict[str, Any]] = {}
+    if not path.exists():
+        return cache
+    with path.open("r", encoding="utf-8") as f:
+        for line_no, line in enumerate(f, start=1):
+            line = line.strip()
+            if not line:
+                continue
+            try:
+                row = json.loads(line)
+            except json.JSONDecodeError:
+                print(f"Warning: skipped invalid cache line {path}:{line_no}")
+                continue
+            key = row.get("cache_key")
+            if isinstance(key, str):
+                cache[key] = row
+    return cache
+
+
+def append_cache(path: Path, rows: Sequence[Dict[str, Any]]) -> None:
+    if not rows:
+        return
+    path.parent.mkdir(parents=True, exist_ok=True)
+    with path.open("a", encoding="utf-8") as f:
+        for row in rows:
+            f.write(json.dumps(row, ensure_ascii=False) + "\n")
+
+
+def dry_candidates(example: TurnExample, version: str, n: int) -> List[str]:
+    base = "I inspect the visible state and reason step by step toward the next move."
+    if version == "sas" and example.next_user_content is not None:
+        base = "I inspect the visible state and the observed next-state feedback to reason toward the next move."
+    return [f"{base} Candidate {i + 1}." for i in range(n)]
+
+
+def synthesize_version(
+    *,
+    version: str,
+    turns: Sequence[TurnExample],
+    args: argparse.Namespace,
+    output_dir: Path,
+    output_prefix: str,
+    llm: Any,
+    tokenizer: Any,
+    judge_llm: Any,
+    judge_tokenizer: Any,
+) -> Dict[Tuple[Any, int], Dict[str, Any]]:
+    cache_path = output_dir / f"{output_prefix}_with_think_{version}_bon{args.n}.cache.jsonl"
+    cache = {} if args.no_cache else load_cache(cache_path)
+    results: Dict[Tuple[Any, int], Dict[str, Any]] = {}
+    missing: List[TurnExample] = []
+    for ex in turns:
+        key = cache_key(version, ex.source_id, ex.turn_idx)
+        cached = cache.get(key)
+        if cached is not None and cached.get("selected_think"):
+            results[(ex.source_id, ex.turn_idx)] = cached
+        else:
+            missing.append(ex)
+
+    print(f"[{version}] turns={len(turns)} cached={len(results)} missing={len(missing)}")
+    gen_params = None if args.dry_run else make_sampling_params(args, judge=False)
+    judge_params = None if args.dry_run else make_sampling_params(args, judge=True)
+
+    for batch_no, batch in enumerate(chunks(missing, int(args.batch_size)), start=1):
+        batch = list(batch)
+        if args.dry_run:
+            all_candidates = [dry_candidates(ex, version, int(args.n)) for ex in batch]
+        else:
+            prompts = [render_prompt(tokenizer, build_generation_messages(ex, version)) for ex in batch]
+            outputs = llm.generate(prompts, sampling_params=gen_params)
+            all_candidates = []
+            for out in outputs:
+                raw_candidates = [clean_think(candidate.text) for candidate in out.outputs]
+                candidates = [cand for cand in raw_candidates if cand and not has_meta_reasoning(cand)]
+                if not candidates:
+                    candidates = [cand for cand in raw_candidates if cand]
+                all_candidates.append(candidates)
+
+        judge_inputs: List[Tuple[TurnExample, List[str]]] = []
+        batch_rows: List[Dict[str, Any]] = []
+        for ex, candidates in zip(batch, all_candidates):
+            if not candidates:
+                selected = fallback_think(version)
+                row = {
+                    "cache_key": cache_key(version, ex.source_id, ex.turn_idx),
+                    "version": version,
+                    "source_id": ex.source_id,
+                    "turn_idx": ex.turn_idx,
+                    "total_turns": ex.total_turns,
+                    "selected_think": selected,
+                    "selected_index": None,
+                    "score": 0.0,
+                    "low_quality": True,
+                    "meta_language": False,
+                    "fallback": True,
+                    "missing_next_state": version == "sas" and ex.next_user_content is None,
+                    "selected_reason": "No valid generation candidates; used fallback.",
+                }
+                if args.save_candidates:
+                    row["candidates"] = []
+                batch_rows.append(row)
+            else:
+                judge_inputs.append((ex, candidates))
+
+        judge_texts: List[str] = []
+        if judge_inputs:
+            if args.dry_run:
+                judge_texts = [
+                    json.dumps(
+                        {
+                            "best_index": 1,
+                            "scores": [
+                                {
+                                    "index": 1,
+                                    "score": 3,
+                                    "unsupported_claims": 0,
+                                    "contradictions": 0,
+                                    "reason": "dry run",
+                                }
+                            ],
+                            "selected_reason": "dry run",
+                            "low_quality": False,
+                        }
+                    )
+                    for _ in judge_inputs
+                ]
+            else:
+                judge_prompts = [
+                    render_prompt(judge_tokenizer, build_judge_messages(ex, version, candidates))
+                    for ex, candidates in judge_inputs
+                ]
+                judge_texts = []
+                for judge_chunk in chunks(judge_prompts, int(args.judge_batch_size)):
+                    judge_outputs = judge_llm.generate(list(judge_chunk), sampling_params=judge_params)
+                    judge_texts.extend(out.outputs[0].text for out in judge_outputs)
+
+        for (ex, candidates), judge_text in zip(judge_inputs, judge_texts):
+            judge_obj = parse_judge_json(judge_text)
+            best_index = to_int(judge_obj.get("best_index"), 1)
+            if best_index < 1 or best_index > len(candidates):
+                best_index = 1
+            selected = candidates[best_index - 1]
+            meta_language = has_meta_reasoning(selected)
+            score = selected_score(judge_obj, best_index)
+            if score <= 0.0:
+                score = 3.0 if selected else 0.0
+            low_quality = (
+                bool(judge_obj.get("low_quality", False))
+                or score < float(args.min_judge_score)
+                or meta_language
+            )
+            row = {
+                "cache_key": cache_key(version, ex.source_id, ex.turn_idx),
+                "version": version,
+                "source_id": ex.source_id,
+                "turn_idx": ex.turn_idx,
+                "total_turns": ex.total_turns,
+                "selected_think": selected or fallback_think(version),
+                "selected_index": best_index,
+                "score": score,
+                "low_quality": low_quality,
+                "meta_language": meta_language,
+                "fallback": not bool(selected),
+                "missing_next_state": version == "sas" and ex.next_user_content is None,
+                "selected_reason": str(judge_obj.get("selected_reason", "")),
+            }
+            if args.save_candidates:
+                row["candidates"] = candidates
+                row["judge"] = judge_obj
+                row["judge_raw"] = judge_text
+            batch_rows.append(row)
+
+        append_cache(cache_path, batch_rows) if not args.no_cache else None
+        for row in batch_rows:
+            results[(row["source_id"], int(row["turn_idx"]))] = row
+        print(f"[{version}] batch {batch_no}: wrote {len(batch_rows)} turn results")
+    return results
+
+
+def rebuild_rows(
+    rows: Sequence[Dict[str, Any]],
+    full: Dict[Any, FullTrajectory],
+    result_map: Dict[Tuple[Any, int], Dict[str, Any]],
+) -> List[Dict[str, Any]]:
+    rebuilt_by_source: Dict[Any, List[Tuple[Dict[str, Any], Dict[str, Any]]]] = {}
+    for source_id, traj in full.items():
+        new_pairs: List[Tuple[Dict[str, Any], Dict[str, Any]]] = []
+        for idx, (user_msg, asst_msg) in enumerate(traj.pairs, start=1):
+            answer_block = extract_answer_block(str(asst_msg.get("content", "")))
+            result = result_map.get((source_id, idx))
+            think = str(result.get("selected_think", "")) if result else fallback_think("sa")
+            new_user = copy.deepcopy(user_msg)
+            new_asst = copy.deepcopy(asst_msg)
+            if answer_block:
+                new_asst["content"] = make_response(think, answer_block)
+            else:
+                new_asst["content"] = str(asst_msg.get("content", ""))
+            new_pairs.append((new_user, new_asst))
+        rebuilt_by_source[source_id] = new_pairs
+
+    output: List[Dict[str, Any]] = []
+    for idx, row in enumerate(rows):
+        meta = row.get("meta") or {}
+        source_id = meta.get("source_id", f"missing_source_{idx}")
+        turns = to_int(meta.get("turns"), 0)
+        new_row = copy.deepcopy(row)
+        traj = full.get(source_id)
+        pairs = rebuilt_by_source.get(source_id)
+        if traj is None or pairs is None or turns <= 0:
+            output.append(new_row)
+            continue
+        turns = min(turns, len(pairs))
+        new_row["messages"] = copy.deepcopy(traj.sys_prefix) + [
+            copy.deepcopy(msg) for pair in pairs[:turns] for msg in pair
+        ]
+        output.append(new_row)
+    return output
+
+
+def validate_answer_unchanged(original: Sequence[Dict[str, Any]], rebuilt: Sequence[Dict[str, Any]]) -> Dict[str, Any]:
+    if len(original) != len(rebuilt):
+        raise ValueError(f"Row count changed: original={len(original)} rebuilt={len(rebuilt)}")
+    checked = 0
+    mismatches: List[Dict[str, Any]] = []
+    for row_idx, (old_row, new_row) in enumerate(zip(original, rebuilt)):
+        old_pairs = collect_pairs(old_row.get("messages") or [], start_idx=len(extract_system_prefix(old_row.get("messages") or [])))
+        new_pairs = collect_pairs(new_row.get("messages") or [], start_idx=len(extract_system_prefix(new_row.get("messages") or [])))
+        if len(old_pairs) != len(new_pairs):
+            mismatches.append({"row_idx": row_idx, "reason": "pair_count_changed"})
+            continue
+        for turn_idx, ((_, old_asst), (_, new_asst)) in enumerate(zip(old_pairs, new_pairs), start=1):
+            old_answer = extract_answer_block(str(old_asst.get("content", "")))
+            new_answer = extract_answer_block(str(new_asst.get("content", "")))
+            checked += 1
+            if old_answer != new_answer:
+                mismatches.append(
+                    {
+                        "row_idx": row_idx,
+                        "turn_idx": turn_idx,
+                        "old_answer": old_answer,
+                        "new_answer": new_answer,
+                    }
+                )
+                if len(mismatches) >= 20:
+                    break
+        if len(mismatches) >= 20:
+            break
+    if mismatches:
+        raise ValueError(f"Answer validation failed, examples: {mismatches[:3]}")
+    return {"checked_assistant_messages": checked, "answer_mismatches": 0}
+
+
+def filter_full_by_args(full: Dict[Any, FullTrajectory], args: argparse.Namespace) -> Dict[Any, FullTrajectory]:
+    selected = dict(full)
+    if args.source_ids.strip():
+        allow = {item.strip() for item in args.source_ids.split(",") if item.strip()}
+        selected = {sid: traj for sid, traj in selected.items() if source_key(sid) in allow}
+    if args.limit_sources is not None:
+        limited: Dict[Any, FullTrajectory] = {}
+        for sid in list(selected.keys())[: int(args.limit_sources)]:
+            limited[sid] = selected[sid]
+        selected = limited
+    return selected
+
+
+def report_from_results(
+    *,
+    version: str,
+    result_map: Dict[Tuple[Any, int], Dict[str, Any]],
+    validation: Dict[str, Any],
+    args: argparse.Namespace,
+) -> Dict[str, Any]:
+    values = list(result_map.values())
+    low_quality = sum(1 for row in values if row.get("low_quality"))
+    fallback = sum(1 for row in values if row.get("fallback"))
+    meta_language = sum(1 for row in values if row.get("meta_language"))
+    missing_next = sum(1 for row in values if row.get("missing_next_state"))
+    scores = [float(row.get("score", 0.0)) for row in values]
+    summary = {
+        "version": version,
+        "n": int(args.n),
+        "turn_results": len(values),
+        "low_quality": low_quality,
+        "fallback": fallback,
+        "meta_language": meta_language,
+        "missing_next_state": missing_next,
+        "avg_score": sum(scores) / len(scores) if scores else 0.0,
+        "min_score": min(scores) if scores else 0.0,
+        "max_score": max(scores) if scores else 0.0,
+        **validation,
+    }
+    per_turn: List[Dict[str, Any]] = []
+    for row in values:
+        item = {
+            "source_id": row.get("source_id"),
+            "turn_idx": row.get("turn_idx"),
+            "total_turns": row.get("total_turns"),
+            "selected_index": row.get("selected_index"),
+            "score": row.get("score"),
+            "low_quality": row.get("low_quality"),
+            "fallback": row.get("fallback"),
+            "meta_language": row.get("meta_language", False),
+            "missing_next_state": row.get("missing_next_state"),
+            "selected_reason": row.get("selected_reason", ""),
+        }
+        if args.save_candidates:
+            item["selected_think"] = row.get("selected_think")
+            item["candidates"] = row.get("candidates", [])
+            item["judge"] = row.get("judge", {})
+        per_turn.append(item)
+    return {"summary": summary, "per_turn": per_turn}
+
+
+def main() -> None:
+    args = parse_args()
+    versions = [v.strip() for v in args.versions.split(",") if v.strip()]
+    if not versions or any(v not in {"sa", "sas"} for v in versions):
+        raise ValueError("--versions must contain only sa and/or sas")
+    if not args.dry_run and not args.model:
+        raise ValueError("--model is required unless --dry-run is set")
+
+    input_path = args.input.expanduser().resolve()
+    output_dir = (args.output_dir or input_path.parent).expanduser().resolve()
+    output_prefix = args.output_prefix or input_path.stem
+
+    print(f"Loading input: {input_path}")
+    rows = load_json_list(input_path)
+    full_all = build_full_trajectories(rows)
+    full_selected = filter_full_by_args(full_all, args)
+    if not full_selected:
+        raise ValueError("No usable trajectories selected.")
+    turns = iter_turns(full_selected)
+    print(f"Rows={len(rows)} sources={len(full_all)} selected_sources={len(full_selected)} selected_turns={len(turns)}")
+
+    llm = tokenizer = judge_llm = judge_tokenizer = None
+    if not args.dry_run:
+        llm, tokenizer = load_vllm_model(args.model, args, tensor_parallel_size=args.tensor_parallel_size)
+        judge_model = args.judge_model or args.model
+        if judge_model == args.model:
+            judge_llm, judge_tokenizer = llm, tokenizer
+        else:
+            judge_tp = args.judge_tensor_parallel_size or args.tensor_parallel_size
+            judge_llm, judge_tokenizer = load_vllm_model(judge_model, args, tensor_parallel_size=judge_tp)
+
+    for version in versions:
+        result_map = synthesize_version(
+            version=version,
+            turns=turns,
+            args=args,
+            output_dir=output_dir,
+            output_prefix=output_prefix,
+            llm=llm,
+            tokenizer=tokenizer,
+            judge_llm=judge_llm,
+            judge_tokenizer=judge_tokenizer,
+        )
+        rows_for_output = [
+            row
+            for idx, row in enumerate(rows)
+            if not args.selected_only
+            or (row.get("meta") or {}).get("source_id", f"missing_source_{idx}") in full_selected
+        ]
+        rebuilt = rebuild_rows(rows_for_output, full_selected, result_map)
+        validation = validate_answer_unchanged(rows_for_output, rebuilt)
+        out_path = output_dir / f"{output_prefix}_with_think_{version}_bon{args.n}.json"
+        report_path = output_dir / f"{output_prefix}_with_think_{version}_bon{args.n}.report.json"
+        dump_json(out_path, rebuilt, indent=int(args.indent))
+        report = report_from_results(version=version, result_map=result_map, validation=validation, args=args)
+        dump_json(report_path, report, indent=2)
+        print(f"[{version}] wrote SFT: {out_path}")
+        print(f"[{version}] wrote report: {report_path}")
+        print(f"[{version}] summary: {json.dumps(report['summary'], ensure_ascii=False)}")
+
+
+if __name__ == "__main__":
+    main()

scripts/train_sokoban.py

@@ -0,0 +1,356 @@
+import argparse
+import os
+import time
+from dataclasses import dataclass
+from typing import Tuple, Dict, List
+
+import numpy as np
+import torch
+import torch.nn as nn
+import torch.optim as optim
+from torch.distributions import Categorical
+
+from ragen.env.sokoban.env import SokobanEnv
+from ragen.env.sokoban.config import SokobanEnvConfig
+from ragen.utils import all_seed
+
+
+# ===== Observation parsing (text grid -> 7xHxW one-hot) =====
+SYMBOLS = ["#", "_", "O", "√", "X", "P", "S"]
+SYMBOL_TO_IDX: Dict[str, int] = {s: i for i, s in enumerate(SYMBOLS)}
+
+
+def parse_grid_text(obs_text: str, board_shape: Tuple[int, int]) -> torch.Tensor:
+    lines = obs_text.splitlines()
+    H, W = board_shape
+    assert len(lines) == H, f"Grid height mismatch: expected {H}, got {len(lines)}"
+    grid = [[c for c in line] for line in lines]
+    assert all(len(row) == W for row in grid), "Grid width mismatch"
+    out = np.zeros((len(SYMBOLS), H, W), dtype=np.float32)
+    for r in range(H):
+        for c in range(W):
+            ch = grid[r][c]
+            idx = SYMBOL_TO_IDX.get(ch, None)
+            if idx is None:
+                raise ValueError(f"Unknown grid symbol '{ch}' at {(r, c)}")
+            out[idx, r, c] = 1.0
+    return torch.from_numpy(out)
+
+
+# ===== Small CNN Policy-Value Net =====
+class SmallSokobanCNN(nn.Module):
+    def __init__(self, in_channels: int, num_actions: int):
+        super().__init__()
+        # 6x6 is tiny; use minimal convs
+        self.encoder = nn.Sequential(
+            nn.Conv2d(in_channels, 32, kernel_size=3, padding=1),
+            nn.ReLU(inplace=True),
+            nn.Conv2d(32, 64, kernel_size=3, padding=1),
+            nn.ReLU(inplace=True),
+            nn.Flatten(),
+        )
+        # compute flat size for 6x6 grids at runtime
+        self._feat_dim = None
+        self.policy_head = nn.Linear(64 * 6 * 6, num_actions)
+        self.value_head = nn.Linear(64 * 6 * 6, 1)
+
+    def forward(self, x: torch.Tensor):
+        # x: [B, C, H, W]
+        z = self.encoder(x)
+        logits = self.policy_head(z)
+        value = self.value_head(z).squeeze(-1)
+        return logits, value
+
+
+@dataclass
+class PPOConfig:
+    total_steps: int = 200_000
+    rollout_steps: int = 256
+    batch_size: int = 256
+    update_epochs: int = 4
+    gamma: float = 0.99
+    gae_lambda: float = 0.95
+    clip_coef: float = 0.2
+    ent_coef: float = 0.01
+    vf_coef: float = 0.5
+    max_grad_norm: float = 0.5
+    lr: float = 2.5e-4
+    device: str = "cpu"
+
+
+def compute_gae(rewards, dones, values, next_value, cfg: PPOConfig):
+    T = len(rewards)
+    adv = np.zeros(T, dtype=np.float32)
+    lastgaelam = 0.0
+    for t in reversed(range(T)):
+        nonterminal = 1.0 - float(dones[t])
+        delta = rewards[t] + cfg.gamma * next_value * nonterminal - values[t]
+        lastgaelam = delta + cfg.gamma * cfg.gae_lambda * nonterminal * lastgaelam
+        adv[t] = lastgaelam
+        next_value = values[t]
+    returns = adv + values
+    return adv, returns
+
+
+def collect_rollout(env: SokobanEnv, policy: SmallSokobanCNN, cfg: PPOConfig, board_shape: Tuple[int, int], device: str):
+    obs_buf = []
+    act_buf = []
+    logp_buf = []
+    rew_buf = []
+    done_buf = []
+    val_buf = []
+
+    policy.eval()
+
+    obs_text = env.render()  # current text observation
+    for _ in range(cfg.rollout_steps):
+        obs_t = parse_grid_text(obs_text, board_shape).unsqueeze(0).to(device)
+        with torch.no_grad():
+            logits, value = policy(obs_t)
+            dist = Categorical(logits=logits)
+            act_model = dist.sample()[0].item()  # 0..3
+            logp = dist.log_prob(torch.tensor([act_model], device=device)).item()
+            val = value[0].item()
+        act_env = act_model + 1  # map to 1..4
+        next_obs_text, reward, done, _ = env.step(act_env)
+
+        obs_buf.append(obs_t.squeeze(0).cpu().numpy())
+        act_buf.append(act_model)
+        logp_buf.append(logp)
+        rew_buf.append(reward)
+        done_buf.append(done)
+        val_buf.append(val)
+
+        obs_text = next_obs_text
+        if done:
+            obs_text = env.reset()
+
+    # bootstrap value
+    with torch.no_grad():
+        obs_t = parse_grid_text(obs_text, board_shape).unsqueeze(0).to(device)
+        _, next_value = policy(obs_t)
+        next_value = next_value[0].item()
+
+    adv, ret = compute_gae(
+        np.array(rew_buf, dtype=np.float32),
+        np.array(done_buf, dtype=np.bool_),
+        np.array(val_buf, dtype=np.float32),
+        next_value,
+        cfg,
+    )
+
+    data = {
+        "obs": torch.from_numpy(np.stack(obs_buf)).to(device),
+        "actions": torch.tensor(act_buf, dtype=torch.long, device=device),
+        "logp": torch.tensor(logp_buf, dtype=torch.float32, device=device),
+        "advantages": torch.tensor(adv, dtype=torch.float32, device=device),
+        "returns": torch.tensor(ret, dtype=torch.float32, device=device),
+        "values": torch.tensor(val_buf, dtype=torch.float32, device=device),
+    }
+    return data
+
+
+def ppo_update(policy, optimizer, data, cfg: PPOConfig):
+    policy.train()
+    obs = data["obs"]
+    actions = data["actions"]
+    old_logp = data["logp"]
+    advantages = data["advantages"]
+    returns = data["returns"]
+
+    advantages = (advantages - advantages.mean()) / (advantages.std() + 1e-8)
+
+    N = obs.shape[0]
+    idxs = np.arange(N)
+
+    for _ in range(cfg.update_epochs):
+        np.random.shuffle(idxs)
+        for start in range(0, N, cfg.batch_size):
+            end = start + cfg.batch_size
+            mb_idx = idxs[start:end]
+            mb_obs = obs[mb_idx]
+            mb_act = actions[mb_idx]
+            mb_old_logp = old_logp[mb_idx]
+            mb_adv = advantages[mb_idx]
+            mb_ret = returns[mb_idx]
+
+            logits, values = policy(mb_obs)
+            dist = Categorical(logits=logits)
+            new_logp = dist.log_prob(mb_act)
+            entropy = dist.entropy().mean()
+
+            ratio = (new_logp - mb_old_logp).exp()
+            pg_loss1 = -mb_adv * ratio
+            pg_loss2 = -mb_adv * torch.clamp(ratio, 1.0 - cfg.clip_coef, 1.0 + cfg.clip_coef)
+            pg_loss = torch.max(pg_loss1, pg_loss2).mean()
+
+            v_loss = 0.5 * (mb_ret - values).pow(2).mean()
+            loss = pg_loss + cfg.vf_coef * v_loss - cfg.ent_coef * entropy
+
+            optimizer.zero_grad(set_to_none=True)
+            loss.backward()
+            nn.utils.clip_grad_norm_(policy.parameters(), cfg.max_grad_norm)
+            optimizer.step()
+
+    with torch.no_grad():
+        approx_kl = (old_logp - new_logp).mean().item()
+        clipfrac = (torch.gt(torch.abs(ratio - 1.0), cfg.clip_coef)).float().mean().item()
+    return {
+        "loss": float(loss.item()),
+        "pg_loss": float(pg_loss.mean().item()),
+        "v_loss": float(v_loss.item()),
+        "entropy": float(entropy.item()),
+        "approx_kl": approx_kl,
+        "clipfrac": clipfrac,
+    }
+
+
+def evaluate(env: SokobanEnv, policy: SmallSokobanCNN, board_shape: Tuple[int, int], device: str, episodes: int = 5):
+    policy.eval()
+    returns = []
+    with torch.no_grad():
+        for _ in range(episodes):
+            obs_text = env.reset()
+            done = False
+            ep_ret = 0.0
+            steps = 0
+            while not done and steps < 200:
+                obs_t = parse_grid_text(obs_text, board_shape).unsqueeze(0).to(device)
+                logits, _ = policy(obs_t)
+                dist = Categorical(logits=logits)
+                act_model = torch.argmax(dist.probs, dim=-1)[0].item()
+                act_env = act_model + 1
+                obs_text, reward, done, info = env.step(act_env)
+                ep_ret += reward
+                steps += 1
+            returns.append(ep_ret)
+    return float(np.mean(returns)), float(np.std(returns))
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    # Sokoban config flags to preserve exact environment
+    parser.add_argument("--dim_x", type=int, default=None)
+    parser.add_argument("--dim_y", type=int, default=None)
+    parser.add_argument("--max_steps", type=int, default=None)
+    parser.add_argument("--num_boxes", type=int, default=None)
+    parser.add_argument("--search_depth", type=int, default=None)
+    parser.add_argument("--render_mode", type=str, default=None, choices=[None, "text", "rgb_array"])
+    parser.add_argument("--observation_format", type=str, default=None, choices=[None, "grid", "coord", "grid_coord"])
+
+    # PPO/training
+    parser.add_argument("--total_steps", type=int, default=200_000)
+    parser.add_argument("--rollout_steps", type=int, default=256)
+    parser.add_argument("--batch_size", type=int, default=256)
+    parser.add_argument("--update_epochs", type=int, default=4)
+    parser.add_argument("--gamma", type=float, default=0.99)
+    parser.add_argument("--gae_lambda", type=float, default=0.95)
+    parser.add_argument("--clip_coef", type=float, default=0.2)
+    parser.add_argument("--ent_coef", type=float, default=0.01)
+    parser.add_argument("--vf_coef", type=float, default=0.5)
+    parser.add_argument("--max_grad_norm", type=float, default=0.5)
+    parser.add_argument("--lr", type=float, default=2.5e-4)
+    parser.add_argument("--device", type=str, default="cpu")
+    parser.add_argument("--seed", type=int, default=42)
+    parser.add_argument("--eval_interval", type=int, default=5000)
+    parser.add_argument("--eval_episodes", type=int, default=5)
+    parser.add_argument("--save_path", type=str, default="runs/sokoban_small_ppo.pt")
+    parser.add_argument("--sanity_rollout", action="store_true", help="Run a short rollout to validate parsing & action mapping, then exit")
+
+    args = parser.parse_args()
+
+    # Build Sokoban config strictly following defaults unless explicitly overridden
+    env_cfg = SokobanEnvConfig()
+    if args.dim_x is not None and args.dim_y is not None:
+        env_cfg.dim_room = (args.dim_x, args.dim_y)
+    if args.max_steps is not None:
+        env_cfg.max_steps = args.max_steps
+    if args.num_boxes is not None:
+        env_cfg.num_boxes = args.num_boxes
+    if args.search_depth is not None:
+        env_cfg.search_depth = args.search_depth
+    if args.render_mode is not None:
+        env_cfg.render_mode = args.render_mode
+    if args.observation_format is not None:
+        env_cfg.observation_format = args.observation_format
+
+    # Enforce text + grid parsing, which matches LLM environment training by default
+    assert env_cfg.render_mode == "text", "Training expects text observations"
+    assert env_cfg.observation_format == "grid", "Training expects 'grid' observation format"
+
+    device = torch.device(args.device)
+
+    with all_seed(args.seed):
+        env = SokobanEnv(env_cfg)
+        # derive board shape from config
+        board_shape = env_cfg.dim_room
+        obs_text = env.reset()
+
+    policy = SmallSokobanCNN(in_channels=len(SYMBOLS), num_actions=4).to(device)
+    optimizer = optim.Adam(policy.parameters(), lr=args.lr)
+
+    if args.sanity_rollout:
+        print("[Sanity] Running 10 steps...")
+        obs = obs_text
+        for t in range(10):
+            obs_t = parse_grid_text(obs, board_shape).unsqueeze(0).to(device)
+            with torch.no_grad():
+                logits, _ = policy(obs_t)
+                dist = Categorical(logits=logits)
+                a = dist.sample()[0].item()
+            obs, r, d, info = env.step(a + 1)
+            print(f"t={t} r={r} done={d} info={info}")
+            if d:
+                obs = env.reset()
+        return
+
+    cfg = PPOConfig(
+        total_steps=args.total_steps,
+        rollout_steps=args.rollout_steps,
+        batch_size=args.batch_size,
+        update_epochs=args.update_epochs,
+        gamma=args.gamma,
+        gae_lambda=args.gae_lambda,
+        clip_coef=args.clip_coef,
+        ent_coef=args.ent_coef,
+        vf_coef=args.vf_coef,
+        max_grad_norm=args.max_grad_norm,
+        lr=args.lr,
+        device=args.device,
+    )
+
+    steps_done = 0
+    last_eval = 0
+    start_time = time.time()
+
+    while steps_done < cfg.total_steps:
+        data = collect_rollout(env, policy, cfg, board_shape, device)
+        steps_done += cfg.rollout_steps
+
+        stats = ppo_update(policy, optimizer, data, cfg)
+
+        if steps_done - last_eval >= args.eval_interval:
+            with all_seed(args.seed + 123):
+                eval_env = SokobanEnv(env_cfg)
+                mean_ret, std_ret = evaluate(eval_env, policy, board_shape, device, episodes=args.eval_episodes)
+            last_eval = steps_done
+            elapsed = time.time() - start_time
+            print(
+                f"steps={steps_done} elapsed={elapsed:.1f}s loss={stats['loss']:.3f} "
+                f"pg={stats['pg_loss']:.3f} v={stats['v_loss']:.3f} ent={stats['entropy']:.3f} "
+                f"kl={stats['approx_kl']:.4f} clipfrac={stats['clipfrac']:.3f} eval_ret={mean_ret:.2f}±{std_ret:.2f}"
+            )
+            # Save
+            os.makedirs(os.path.dirname(args.save_path), exist_ok=True)
+            torch.save({
+                "model_state": policy.state_dict(),
+                "env_cfg": env_cfg.__dict__,
+                "steps": steps_done,
+                "seed": args.seed,
+            }, args.save_path)
+
+    print(f"Training finished. Model saved to {args.save_path}")
+
+
+if __name__ == "__main__":
+    main()

scripts/visualize.py

@@ -0,0 +1,692 @@
+#!/usr/bin/env python3
+"""
+Local rollout visualizer.
+
+Usage:
+    python scripts/visualize.py --rollout_path results/ [--host 127.0.0.1] [--port 8000]
+
+The script launches a small HTTP server that lets you inspect .pkl files
+(containing verl.DataProto dumps) inside the rollout path. Open the printed
+URL in a browser to explore directories, select a file, and view its
+meta information and non-tensor batches entry by entry.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import logging
+import threading
+from functools import lru_cache
+from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
+from pathlib import Path
+from typing import Any, Dict, List
+from urllib.parse import parse_qs, urlparse
+import webbrowser
+
+import numpy as np
+
+from verl import DataProto
+
+LOGGER = logging.getLogger(__name__)
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description="Launch a local rollout visualizer")
+    parser.add_argument("--rollout_path", required=True, help="Directory containing rollout .pkl files")
+    parser.add_argument("--host", default="127.0.0.1", help="Host to bind (default: 127.0.0.1)")
+    parser.add_argument("--port", type=int, default=8000, help="Port to bind (default: 8000)")
+    parser.add_argument("--no-browser", action="store_true", help="Do not attempt to open a browser automatically")
+    return parser.parse_args()
+
+
+def ensure_within(path: Path, root: Path) -> Path:
+    resolved = path.resolve()
+    try:
+        resolved.relative_to(root)
+    except ValueError as exc:
+        raise ValueError(f"Path {path} escapes the rollout root {root}") from exc
+    return resolved
+
+
+def numpy_summary(array: np.ndarray) -> Dict[str, Any]:
+    array = np.asarray(array)
+    summary: Dict[str, Any] = {
+        "__type__": "ndarray",
+        "dtype": str(array.dtype),
+        "shape": list(array.shape),
+        "size": int(array.size),
+    }
+    preview_limit = 32
+    flat = array.reshape(-1)
+    preview = flat[:preview_limit].tolist()
+    summary["preview"] = preview
+    summary["preview_count"] = len(preview)
+    if array.size <= preview_limit and array.size <= 10_000:
+        summary["values"] = array.tolist()
+    return summary
+
+
+def serialize_for_view(value: Any, depth: int = 0) -> Any:
+    if depth > 6:
+        return repr(value)
+
+    if value is None or isinstance(value, (str, int, float, bool)):
+        return value
+
+    if isinstance(value, (np.integer, np.floating, np.bool_)):
+        return value.item()
+
+    if isinstance(value, dict):
+        return {str(key): serialize_for_view(val, depth + 1) for key, val in value.items()}
+
+    if isinstance(value, (list, tuple, set)):
+        return [serialize_for_view(val, depth + 1) for val in value]
+
+    if isinstance(value, np.ndarray):
+        return numpy_summary(value)
+
+    return repr(value)
+
+
+def build_tree(root: Path) -> Dict[str, Any]:
+    root_node: Dict[str, Any] = {"name": root.name, "path": "", "type": "dir", "children": []}
+    nodes: Dict[str, Dict[str, Any]] = {"": root_node}
+
+    for file_path in sorted(root.rglob("*.pkl")):
+        rel_path = file_path.relative_to(root)
+        rel_path_posix = rel_path.as_posix()
+        parts = rel_path.parts
+        if not parts:
+            continue
+
+        cumulative = []
+        for part in parts[:-1]:
+            cumulative.append(part)
+            current_key = "/".join(cumulative)
+            parent_key = "/".join(cumulative[:-1]) if len(cumulative) > 1 else ""
+            if current_key not in nodes:
+                node = {"name": part, "path": current_key, "type": "dir", "children": []}
+                nodes[current_key] = node
+                nodes[parent_key]["children"].append(node)
+        file_parent_key = "/".join(parts[:-1]) if len(parts) > 1 else ""
+        file_node = {"name": parts[-1], "path": rel_path_posix, "type": "file"}
+        nodes[file_parent_key]["children"].append(file_node)
+
+    def sort_children(node: Dict[str, Any]) -> None:
+        children = node.get("children")
+        if not children:
+            return
+        children.sort(key=lambda item: (item.get("type") != "dir", item.get("name", "")))
+        for child in children:
+            if child.get("type") == "dir":
+                sort_children(child)
+
+    sort_children(root_node)
+    return root_node
+
+
+def data_proto_to_payload(file_path: Path) -> Dict[str, Any]:
+    data = DataProto.load_from_disk(str(file_path))
+    length = len(data)
+    items: List[Dict[str, Any]] = []
+    for idx in range(length):
+        try:
+            item = data[idx]
+        except Exception as exc:  # pragma: no cover - defensive guard
+            LOGGER.warning("Failed to read item %s from %s: %s", idx, file_path, exc)
+            continue
+        items.append(
+            {
+                "index": idx,
+                "meta_info": serialize_for_view(item.meta_info),
+                "non_tensor_batch": serialize_for_view(item.non_tensor_batch),
+            }
+        )
+
+    return {
+        "path": str(file_path),
+        "length": length,
+        "meta_info": serialize_for_view(data.meta_info),
+        "items": items,
+    }
+
+
+class RolloutExplorer:
+    def __init__(self, root: Path):
+        self.root = root
+        self._tree_cache: Dict[str, Any] | None = None
+        self._lock = threading.Lock()
+
+    def tree(self) -> Dict[str, Any]:
+        with self._lock:
+            if self._tree_cache is None:
+                self._tree_cache = build_tree(self.root)
+            return self._tree_cache
+
+    @lru_cache(maxsize=32)
+    def load_file(self, relative_path: str) -> Dict[str, Any]:
+        normalized_path = Path(relative_path)
+        target = ensure_within(self.root / normalized_path, self.root)
+        if not target.exists() or not target.is_file():
+            raise FileNotFoundError(f"File {relative_path} not found under {self.root}")
+        payload = data_proto_to_payload(target)
+        payload["relative_path"] = target.relative_to(self.root).as_posix()
+        return payload
+
+
+HTML_PAGE = """<!DOCTYPE html>
+<html lang=\"en\">
+<head>
+    <meta charset=\"utf-8\" />
+    <title>Rollout Visualizer</title>
+    <style>
+        :root {
+            color-scheme: light dark;
+            --bg: #f7f7fb;
+            --panel: #ffffffcc;
+            --accent: #4a6cff;
+            --accent-soft: #e6ebff;
+            --text: #1d1d25;
+            --border: #d9d9e3;
+        }
+        * { box-sizing: border-box; }
+        body {
+            margin: 0;
+            font-family: "Segoe UI", Tahoma, sans-serif;
+            background: var(--bg);
+            color: var(--text);
+        }
+        header {
+            padding: 14px 24px;
+            background: linear-gradient(135deg, var(--accent), #7f9bff);
+            color: white;
+            font-weight: 600;
+            letter-spacing: 0.4px;
+        }
+        #layout {
+            display: flex;
+            height: calc(100vh - 56px);
+        }
+        #sidebar {
+            width: 28%;
+            max-width: 360px;
+            min-width: 240px;
+            border-right: 1px solid var(--border);
+            background: var(--panel);
+            padding: 12px 16px;
+            overflow-y: auto;
+        }
+        #content {
+            flex: 1;
+            overflow-y: auto;
+            padding: 20px 28px;
+        }
+        .tree-node {
+            margin-left: 12px;
+        }
+        .tree-toggle {
+            cursor: pointer;
+            user-select: none;
+            display: inline-flex;
+            align-items: center;
+            gap: 6px;
+            padding: 4px 6px;
+            border-radius: 6px;
+        }
+        .tree-toggle:hover {
+            background: var(--accent-soft);
+        }
+        .file-entry {
+            cursor: pointer;
+            display: block;
+            padding: 4px 8px;
+            margin: 2px 0;
+            border-radius: 6px;
+        }
+        .file-entry:hover,
+        .file-entry.active {
+            background: var(--accent-soft);
+            color: var(--accent);
+        }
+        .panel {
+            background: var(--panel);
+            border: 1px solid var(--border);
+            border-radius: 12px;
+            padding: 16px 20px;
+            box-shadow: 0 4px 16px rgba(76, 96, 255, 0.05);
+        }
+        .section-title {
+            font-weight: 600;
+            margin-bottom: 12px;
+            font-size: 18px;
+        }
+        .meta-grid {
+            display: grid;
+            grid-template-columns: repeat(auto-fit, minmax(220px, 1fr));
+            gap: 12px;
+        }
+        .section-subtitle {
+            font-weight: 600;
+            margin: 18px 0 10px;
+            color: var(--accent);
+            font-size: 16px;
+        }
+        .kv-block {
+            border: 1px solid var(--border);
+            border-radius: 10px;
+            padding: 12px;
+            background: #fff;
+        }
+        .kv-header {
+            font-weight: 600;
+            margin-bottom: 8px;
+            color: var(--accent);
+        }
+        .kv-body {
+            font-size: 14px;
+            line-height: 1.5;
+            white-space: pre-wrap;
+        }
+        details {
+            border: 1px solid var(--border);
+            border-radius: 10px;
+            padding: 10px 14px;
+            margin-bottom: 10px;
+            background: #fff;
+        }
+        details[open] {
+            border-color: var(--accent);
+            box-shadow: 0 4px 12px rgba(74, 108, 255, 0.08);
+        }
+        summary {
+            cursor: pointer;
+            font-weight: 600;
+            color: var(--accent);
+        }
+        .message-card {
+            border: 1px solid var(--border);
+            border-radius: 8px;
+            padding: 10px 12px;
+            margin: 6px 0;
+            background: #fbfbff;
+        }
+        .message-meta {
+            font-size: 13px;
+            opacity: 0.7;
+            margin-bottom: 4px;
+        }
+        .message-content {
+            white-space: pre-wrap;
+            font-family: "Fira Code", "Consolas", monospace;
+            font-size: 14px;
+        }
+        .messages-section {
+            border: 1px solid var(--border);
+            border-radius: 12px;
+            padding: 14px 16px;
+            background: #f3f5ff;
+            margin-bottom: 14px;
+            box-shadow: inset 0 0 0 1px rgba(74, 108, 255, 0.05);
+        }
+        .messages-section .section-subtitle {
+            margin-top: 0;
+            color: var(--accent);
+        }
+        .placeholder {
+            opacity: 0.6;
+            font-style: italic;
+        }
+    </style>
+</head>
+<body>
+    <header>Rollout Visualizer</header>
+    <div id="layout">
+        <aside id="sidebar">
+            <div id="tree"></div>
+        </aside>
+        <main id="content">
+            <div class="panel placeholder">Select a file to inspect its rollout details.</div>
+        </main>
+    </div>
+    <script>
+        let activePath = null;
+
+        async function fetchJSON(url) {
+            const res = await fetch(url);
+            if (!res.ok) {
+                const text = await res.text();
+                throw new Error(text || res.statusText);
+            }
+            return res.json();
+        }
+
+        function createElement(tag, options = {}) {
+            const el = document.createElement(tag);
+            if (options.className) el.className = options.className;
+            if (options.text) el.textContent = options.text;
+            if (options.html) el.innerHTML = options.html;
+            return el;
+        }
+
+        function renderTree(node, container) {
+            const wrapper = createElement('div', { className: 'tree-node' });
+            const hasChildren = Array.isArray(node.children) && node.children.length > 0;
+
+            if (node.type === 'dir') {
+                const summary = createElement('div', { className: 'tree-toggle' });
+                const icon = createElement('span', { text: hasChildren ? '▸' : '•' });
+                icon.dataset.state = 'collapsed';
+                const label = createElement('span', { text: node.name || '(root)' });
+                summary.append(icon, label);
+                wrapper.appendChild(summary);
+                const childrenContainer = createElement('div');
+                childrenContainer.style.display = 'none';
+                if (node.path === '') {
+                    childrenContainer.style.display = 'block';
+                    icon.textContent = '▾';
+                }
+                summary.addEventListener('click', () => {
+                    if (!hasChildren) return;
+                    if (childrenContainer.style.display === 'none') {
+                        childrenContainer.style.display = 'block';
+                        icon.textContent = '▾';
+                    } else {
+                        childrenContainer.style.display = 'none';
+                        icon.textContent = '▸';
+                    }
+                });
+                wrapper.appendChild(childrenContainer);
+                node.children.forEach(child => renderTree(child, childrenContainer));
+            } else if (node.type === 'file') {
+                const entry = createElement('div', { className: 'file-entry', text: node.name });
+                entry.dataset.path = node.path;
+                entry.addEventListener('click', () => loadFile(node.path, entry));
+                wrapper.appendChild(entry);
+            }
+            container.appendChild(wrapper);
+        }
+
+        function renderKeyValue(container, key, value) {
+            const block = createElement('div', { className: 'kv-block' });
+            block.appendChild(createElement('div', { className: 'kv-header', text: key }));
+            const body = createElement('div', { className: 'kv-body' });
+            body.appendChild(renderValue(value, key));
+            block.appendChild(body);
+            container.appendChild(block);
+        }
+
+        function renderMessages(messages) {
+            const wrapper = createElement('div');
+            messages.forEach((msg, idx) => {
+                const card = createElement('div', { className: 'message-card' });
+                const role = msg.role || msg.author || `Message ${idx}`;
+                const meta = createElement('div', { className: 'message-meta', text: `${role}` });
+                if (msg.timestamp) {
+                    meta.textContent += ` · ${msg.timestamp}`;
+                }
+                const contentContainer = createElement('div', { className: 'message-content' });
+                let content = msg.content;
+                if (Array.isArray(content)) {
+                    content = content.map(part => typeof part === 'string' ? part : JSON.stringify(part, null, 2)).join('\\n');
+                }
+                contentContainer.textContent = content ?? '';
+                card.append(meta, contentContainer);
+                wrapper.appendChild(card);
+            });
+            return wrapper;
+        }
+
+        function renderNdArray(info) {
+            const wrapper = createElement('div');
+            const summary = `dtype=${info.dtype} · shape=[${info.shape.join(', ')}] · size=${info.size}`;
+            wrapper.appendChild(createElement('div', { text: summary }));
+            if (info.preview && info.preview.length) {
+                const preview = createElement('pre');
+                preview.textContent = JSON.stringify(info.preview, null, 2);
+                wrapper.appendChild(preview);
+            }
+            if (info.values) {
+                const details = document.createElement('details');
+                details.appendChild(createElement('summary', { text: 'Show full values' }));
+                const pre = createElement('pre');
+                pre.textContent = JSON.stringify(info.values, null, 2);
+                details.appendChild(pre);
+                wrapper.appendChild(details);
+            }
+            return wrapper;
+        }
+
+        function renderValue(value, key = '') {
+            if (value === null || typeof value === 'undefined') {
+                return createElement('span', { text: '—' });
+            }
+            if (typeof value !== 'object') {
+                return createElement('span', { text: String(value) });
+            }
+            if (Array.isArray(value)) {
+                if (key === 'messages') {
+                    return renderMessages(value.map(item => typeof item === 'object' ? item : { content: String(item) }));
+                }
+                const details = document.createElement('details');
+                details.appendChild(createElement('summary', { text: `List [${value.length}]` }));
+                value.forEach((item, idx) => {
+                    const line = createElement('div');
+                    line.appendChild(createElement('strong', { text: `#${idx}` }));
+                    line.appendChild(createElement('div', { className: 'kv-body' }));
+                    line.lastChild.appendChild(renderValue(item));
+                    details.appendChild(line);
+                });
+                return details;
+            }
+            if (value.__type__ === 'ndarray') {
+                return renderNdArray(value);
+            }
+            const entries = Object.entries(value);
+            const container = createElement('div');
+            entries.forEach(([childKey, childValue]) => {
+                const block = createElement('div');
+                block.appendChild(createElement('strong', { text: childKey }));
+                const inner = createElement('div', { className: 'kv-body' });
+                inner.appendChild(renderValue(childValue, childKey));
+                block.appendChild(inner);
+                container.appendChild(block);
+            });
+            return container;
+        }
+
+        function markActive(entry) {
+            document.querySelectorAll('.file-entry.active').forEach(el => el.classList.remove('active'));
+            entry.classList.add('active');
+        }
+
+        async function loadFile(path, entryEl) {
+            try {
+                activePath = path;
+                markActive(entryEl);
+                const data = await fetchJSON(`/api/file?path=${encodeURIComponent(path)}`);
+                renderContent(data);
+            } catch (error) {
+                console.error(error);
+                const panel = createElement('div', { className: 'panel' });
+                panel.appendChild(createElement('h2', { text: 'Failed to load file' }));
+                panel.appendChild(createElement('pre', { text: error.message }));
+                const content = document.getElementById('content');
+                content.innerHTML = '';
+                content.appendChild(panel);
+            }
+        }
+
+        function renderContent(data) {
+            const content = document.getElementById('content');
+            content.innerHTML = '';
+            const panel = createElement('div', { className: 'panel' });
+            const title = createElement('div', { className: 'section-title', text: data.relative_path || data.path });
+            panel.appendChild(title);
+            panel.appendChild(createElement('div', { text: `Entries: ${data.length}` }));
+
+            const metaSection = createElement('div', { className: 'section-title', text: 'Meta Info (global)' });
+            panel.appendChild(metaSection);
+            const metaGrid = createElement('div', { className: 'meta-grid' });
+            Object.entries(data.meta_info || {}).forEach(([key, value]) => {
+                renderKeyValue(metaGrid, key, value);
+            });
+            if (!Object.keys(data.meta_info || {}).length) {
+                metaGrid.appendChild(createElement('div', { className: 'placeholder', text: 'No meta info available.' }));
+            }
+            panel.appendChild(metaGrid);
+
+            const itemsSection = createElement('div', { className: 'section-title', text: 'Entries' });
+            panel.appendChild(itemsSection);
+            if (!data.items.length) {
+                panel.appendChild(createElement('div', { className: 'placeholder', text: 'No entries in this DataProto.' }));
+            }
+            data.items.forEach(item => {
+                const details = document.createElement('details');
+                const summary = createElement('summary', { text: `Item #${item.index}` });
+                details.appendChild(summary);
+
+                const metaBlock = createElement('div', { className: 'meta-grid' });
+                Object.entries(item.meta_info || {}).forEach(([key, value]) => {
+                    renderKeyValue(metaBlock, key, value);
+                });
+                if (!Object.keys(item.meta_info || {}).length) {
+                    metaBlock.appendChild(createElement('div', { className: 'placeholder', text: 'No item-level meta info.' }));
+                }
+                details.appendChild(metaBlock);
+
+                const nonTensorEntries = Object.entries(item.non_tensor_batch || {});
+                let messagesHandled = false;
+                if (nonTensorEntries.length) {
+                    nonTensorEntries.forEach(([key, value]) => {
+                        if (key === 'messages_list') {
+                            const messagesSection = createElement('div', { className: 'messages-section' });
+                            messagesSection.appendChild(createElement('div', { className: 'section-subtitle', text: 'Messages' }));
+                            messagesSection.appendChild(renderValue(value, key));
+                            details.appendChild(messagesSection);
+                            messagesHandled = true;
+                        }
+                    });
+                    const others = nonTensorEntries.filter(([key]) => key !== 'messages_list');
+                    if (others.length) {
+                        const ntBlock = createElement('div', { className: 'meta-grid' });
+                        others.forEach(([key, value]) => {
+                            renderKeyValue(ntBlock, key, value);
+                        });
+                        details.appendChild(ntBlock);
+                    }
+                    if (!messagesHandled && !others.length) {
+                        details.appendChild(createElement('div', { className: 'placeholder', text: 'No non-tensor batch data.' }));
+                    }
+                } else {
+                    details.appendChild(createElement('div', { className: 'placeholder', text: 'No non-tensor batch data.' }));
+                }
+
+                panel.appendChild(details);
+            });
+
+            content.appendChild(panel);
+        }
+
+        async function init() {
+            try {
+                const treeData = await fetchJSON('/api/tree');
+                const treeRoot = document.getElementById('tree');
+                treeRoot.innerHTML = '';
+                renderTree(treeData, treeRoot);
+            } catch (error) {
+                const treeRoot = document.getElementById('tree');
+                treeRoot.textContent = 'Failed to load file tree.';
+                console.error(error);
+            }
+        }
+
+        init();
+    </script>
+</body>
+</html>
+"""
+
+
+class VisualizerHandler(BaseHTTPRequestHandler):
+    explorer: RolloutExplorer
+
+    def do_GET(self) -> None:  # noqa: N802 - http.server signature
+        parsed = urlparse(self.path)
+        if parsed.path == "/":
+            self.respond_html(HTML_PAGE)
+            return
+        if parsed.path == "/api/tree":
+            payload = VisualizerHandler.explorer.tree()
+            self.respond_json(payload)
+            return
+        if parsed.path == "/api/file":
+            query = parse_qs(parsed.query)
+            relative = query.get("path", [None])[0]
+            if not relative:
+                self.respond_json({"error": "Missing path query parameter"}, status=400)
+                return
+            try:
+                payload = VisualizerHandler.explorer.load_file(relative)
+            except FileNotFoundError:
+                self.respond_json({"error": "File not found"}, status=404)
+                return
+            except Exception as exc:  # pragma: no cover - defensive guard
+                LOGGER.exception("Failed to load %s", relative)
+                self.respond_json({"error": str(exc)}, status=500)
+                return
+            self.respond_json(payload)
+            return
+
+        self.respond_json({"error": "Not found"}, status=404)
+
+    def log_message(self, format: str, *args: Any) -> None:  # noqa: A003 - inherited name
+        LOGGER.info("%s - %s", self.address_string(), format % args)
+
+    def respond_json(self, payload: Any, status: int = 200) -> None:
+        body = json.dumps(payload).encode("utf-8")
+        self.send_response(status)
+        self.send_header("Content-Type", "application/json; charset=utf-8")
+        self.send_header("Content-Length", str(len(body)))
+        self.end_headers()
+        self.wfile.write(body)
+
+    def respond_html(self, html: str, status: int = 200) -> None:
+        body = html.encode("utf-8")
+        self.send_response(status)
+        self.send_header("Content-Type", "text/html; charset=utf-8")
+        self.send_header("Content-Length", str(len(body)))
+        self.end_headers()
+        self.wfile.write(body)
+
+
+def main() -> None:
+    logging.basicConfig(level=logging.INFO, format="[%(levelname)s] %(message)s")
+    args = parse_args()
+    root = Path(args.rollout_path).expanduser().resolve()
+    if not root.exists() or not root.is_dir():
+        raise SystemExit(f"Rollout path {root} does not exist or is not a directory")
+
+    explorer = RolloutExplorer(root)
+    VisualizerHandler.explorer = explorer
+
+    server = ThreadingHTTPServer((args.host, args.port), VisualizerHandler)
+
+    address = f"http://{args.host}:{args.port}/"
+    print(f"Serving rollout visualizer for {root} at {address}")
+    if not args.no_browser:
+        try:
+            webbrowser.open(address)
+        except Exception as exc:  # pragma: no cover - best effort
+            LOGGER.info("Could not open browser automatically: %s", exc)
+
+    try:
+        server.serve_forever()
+    except KeyboardInterrupt:
+        print("\nShutting down...")
+    finally:
+        server.server_close()
+
+
+if __name__ == "__main__":
+    main()

tests/env/test_sokoban_render.py

@@ -0,0 +1,41 @@
+import re
+
+from ragen.env.sokoban.config import SokobanEnvConfig
+from ragen.env.sokoban.env import SokobanEnv
+
+
+def test_sokoban_render_supports_grid_and_coord():
+    seed = 1234
+    grid_config = SokobanEnvConfig(
+        dim_room=(5, 5),
+        num_boxes=1,
+        max_steps=10,
+        search_depth=20,
+        observation_format="grid",
+    )
+    coord_config = SokobanEnvConfig(
+        dim_room=(5, 5),
+        num_boxes=1,
+        max_steps=10,
+        search_depth=20,
+        observation_format="coord",
+    )
+
+    grid_env = SokobanEnv(grid_config)
+    coord_env = SokobanEnv(coord_config)
+
+    try:
+        grid_obs = grid_env.reset(seed=seed)
+        coord_obs = coord_env.reset(seed=seed)
+
+        assert isinstance(grid_obs, str)
+        assert isinstance(coord_obs, str)
+
+        assert "Board size:" in coord_obs
+        assert re.search(r"Walls: \(\d+, \d+\)", coord_obs)
+
+        assert isinstance(coord_env.render(mode="grid"), str)
+        assert "Board size:" in grid_env.render(mode="coord")
+    finally:
+        grid_env.close()
+        coord_env.close()

tests/es_manager/test_seed_iteration.py

@@ -0,0 +1,34 @@
+import pytest
+from omegaconf import OmegaConf
+from ragen.llm_agent.es_manager import EnvStateManager
+
+
+def make_cfg():
+    return OmegaConf.create({
+        'seed': {'train': 7},
+        'es_manager': {
+            'train': {
+                'env_groups': 1,
+                'group_size': 1,
+                'env_configs': {'tags': ['Bandit'], 'n_groups': [1]},
+            }
+        },
+        'custom_envs': {
+            'Bandit': {
+                'env_type': 'bandit',
+                'max_actions_per_traj': 1,
+                'env_config': None
+            }
+        }
+    })
+
+
+def test_seed_iteration():
+    cfg = make_cfg()
+    es = EnvStateManager(cfg, mode='train')
+    es.reset()
+    first_seed = es.envs[0]['status'].seed
+    es.reset()
+    second_seed = es.envs[0]['status'].seed
+    assert first_seed == 7
+    assert second_seed == 8

tests/llm_agent/test_context_window.py

@@ -0,0 +1,84 @@
+import pytest
+from ragen.llm_agent.ctx_manager import ContextManager
+from omegaconf import OmegaConf
+from verl.verl.protocol import DataProto
+
+class DummyTokenizer:
+    name_or_path = "qwen"  # or "llama-3" or any string your code expects
+
+    def apply_chat_template(self, messages, add_generation_prompt, tokenize):
+        return " ".join([msg["content"] for msg in messages])
+
+    def __call__(self, texts, return_tensors, padding, padding_side, truncation):
+        import torch
+        class DummyOutput:
+            input_ids = torch.tensor([[1, 2, 3]])
+            attention_mask = torch.tensor([[1, 1, 1]])
+        return DummyOutput()
+
+    def encode(self, text):
+        # Return a dummy list of token ids; must be at least length 1 for [0] indexing
+        return [42, 43]
+
+@pytest.fixture
+def dummy_config():
+    cfg = OmegaConf.create({
+        "agent_proxy": {
+            "max_context_window": 2,
+            "enable_think": False,
+            "use_turn_scores": False,
+            "action_sep": "|",
+            "reward_normalization": {
+                "grouping": "batch",
+                "method": "identity"
+            }
+        },
+        "enable_response_mask": False,
+        "es_manager": {
+            "train": {
+                "env_configs": {
+                    "n_groups": [1],
+                    "tags": ["sokoban"]
+                },
+                "group_size": 1
+            }
+        },
+        "custom_envs": {
+            "sokoban": {
+                "env_type": "sokoban",
+                "max_actions_per_traj": 10
+            }
+        },
+        "actor_rollout_ref": {
+            "rollout": {
+                "response_length": 128
+            }
+        }
+    })
+    return cfg
+
+def test_context_window_truncation(dummy_config):
+    tokenizer = DummyTokenizer()
+    ctx = ContextManager(config=dummy_config, tokenizer=tokenizer, mode="train")
+    ctx.prefix_lookup = {0: "Initial prompt"}
+    ctx.env_config_lookup = {0: {"max_tokens": 128}}
+    ctx.env_nums = {"": 1}  # For metrics
+
+    env_outputs = [{
+        "env_id": 0,
+        "group_id": 0,
+        "history": [
+            {"state": "S1", "llm_response": "R1", "reward": 0.1, "actions_left": 5},
+            {"state": "S2", "llm_response": "R2", "reward": 0.2, "actions_left": 4},
+            {"state": "S3", "llm_response": "R3", "reward": 0.3, "actions_left": 3},
+        ],
+        "metrics": {},
+    }]
+
+    lm_inputs: DataProto = ctx.get_lm_inputs(env_outputs, prepare_for_update=True)
+    messages = lm_inputs.non_tensor_batch["messages_list"][0]
+
+    # Ensure only last 2 turns are present
+    assert "S1" not in str(messages)
+    assert "S2" in str(messages)
+    assert "S3" in str(messages)

tests/test_rollout_filter.py

@@ -0,0 +1,137 @@
+import sys
+import types
+
+import numpy as np
+import torch
+from tensordict import TensorDict
+
+
+if "verl" not in sys.modules:
+    stub = types.ModuleType("verl")
+
+    class DummyDataProto:
+        def __init__(self, batch=None, non_tensor_batch=None, meta_info=None):
+            self.batch = batch
+            self.non_tensor_batch = non_tensor_batch or {}
+            self.meta_info = meta_info or {}
+
+        def union(self, other):
+            if other.batch is not None:
+                for key, value in other.batch.items():
+                    self.batch[key] = value
+            if other.non_tensor_batch:
+                self.non_tensor_batch.update(other.non_tensor_batch)
+            if other.meta_info:
+                self.meta_info.update(other.meta_info)
+            return self
+
+    stub.DataProto = DummyDataProto
+    sys.modules["verl"] = stub
+
+
+from ragen.trainer.rollout_filter import (
+    RolloutFilterConfig,
+    RewardRolloutFilter,
+    EntropyRolloutFilter,
+)
+
+
+def _make_reward_batch(num_groups: int, group_size: int, traj_len: int):
+    total = num_groups * group_size
+    rm_scores = torch.arange(total * traj_len, dtype=torch.float32).reshape(total, traj_len)
+    loss_mask = torch.ones(total, traj_len)
+    batch = TensorDict(
+        {
+            "original_rm_scores": rm_scores,
+            "loss_mask": loss_mask,
+        },
+        batch_size=[total],
+    )
+    non_tensor_batch = {"uids": np.arange(total)}
+    return sys.modules["verl"].DataProto(batch=batch, non_tensor_batch=non_tensor_batch, meta_info={})
+
+
+def test_reward_variance_filter_reduces_batch_size():
+    num_groups, group_size, traj_len = 4, 2, 3
+    batch = _make_reward_batch(num_groups, group_size, traj_len)
+
+    rollout_filter = RewardRolloutFilter(
+        RolloutFilterConfig(
+            ratio=0.5,
+            filter_type="largest",
+            num_groups=num_groups,
+            group_size=group_size,
+        )
+    )
+
+    filtered_batch, metrics = rollout_filter.filter(batch)
+
+    assert filtered_batch.batch["original_rm_scores"].shape[0] == group_size * max(int(0.5 * num_groups), 1)
+    assert "rollout/in_group_std" in metrics
+
+
+def test_entropy_variance_filter_uses_compute_log_prob():
+    num_groups, group_size, traj_len = 2, 3, 4
+    batch = _make_reward_batch(num_groups, group_size, traj_len)
+
+    entropies = torch.linspace(0.1, 1.0, steps=num_groups * group_size * traj_len).reshape(num_groups * group_size, traj_len)
+    old_log_probs = -entropies
+
+    def fake_compute_log_prob(data_proto):
+        td = TensorDict(
+            {
+                "old_log_probs": old_log_probs,
+                "entropys": entropies,
+            },
+            batch_size=[num_groups * group_size],
+        )
+        return sys.modules["verl"].DataProto(batch=td, non_tensor_batch={}, meta_info={})
+
+    rollout_filter = EntropyRolloutFilter(
+        RolloutFilterConfig(
+            ratio=0.5,
+            filter_type="largest",
+            num_groups=num_groups,
+            group_size=group_size,
+            metric="entropy",
+        ),
+        compute_log_prob=fake_compute_log_prob,
+    )
+
+    filtered_batch, metrics = rollout_filter.filter(batch)
+
+    expected = group_size * max(int(0.5 * num_groups), 1)
+    assert filtered_batch.batch["loss_mask"].shape[0] == expected
+    assert "old_log_probs" in filtered_batch.batch.keys()
+    assert "rollout/in_group_entropy_std" in metrics
+
+
+def test_reward_metric_selects_high_mean_group():
+    num_groups, group_size, traj_len = 2, 2, 1
+    batch = _make_reward_batch(num_groups, group_size, traj_len)
+
+    # Overwrite scores: first group has higher mean, second has higher variance.
+    batch.batch["original_rm_scores"] = torch.tensor(
+        [
+            [10.0],
+            [11.0],
+            [0.0],
+            [5.0],
+        ]
+    )
+
+    rollout_filter = RewardRolloutFilter(
+        RolloutFilterConfig(
+            ratio=0.5,
+            filter_type="largest",
+            num_groups=num_groups,
+            group_size=group_size,
+            metric="reward",
+        )
+    )
+
+    filtered_batch, _ = rollout_filter.filter(batch)
+
+    # Highest mean group is the first one, so we expect its entries to remain.
+    retained = filtered_batch.batch["original_rm_scores"].squeeze(-1)
+    assert torch.allclose(retained, torch.tensor([10.0, 11.0]))

verl/.gemini/config.yaml

@@ -0,0 +1,10 @@
+have_fun: false
+code_review:
+  disable: false
+  comment_severity_threshold: HIGH
+  max_review_comments: -1
+  pull_request_opened:
+    help: false
+    summary: false
+    code_review: true
+ignore_patterns: []

verl/.github/CODEOWNERS

@@ -0,0 +1,30 @@
+/docs @eric-haibin-lin @zhaochenyang20 @hongpeng-guo
+/docs/amd_tutorial @yushengsu-thu
+/docs/slang_multiturn @zhaochenyang20 @SwordFaith
+/docs/ascend_tutorial @FightingZhen
+
+/recipe/dapo @tongyx361 @PeterSH6 @vermouth1992 @tardis-key @FightingZhen @ji-huazhong
+/recipe/spin @zhaochenyang20
+/recipe/sppo @zhaochenyang20
+
+/third_party/sglang @zhaochenyang20 @SwordFaith
+/third_party/vllm @PeterSH6 @wuxibin89
+
+/examples/grpo_trainer @vermouth1992 @PeterSH6 @tardis-key @FightingZhen @ji-huazhong
+
+/verl/single_controller @zw0610 @wuxibin89 @hongpeng-guo
+/verl/trainer @eric-haibin-lin @vermouth1992 @tongyx361 @PeterSH6
+/verl/models/mcore @ISEEKYAN @vermouth1992
+/verl/models/transformers @vermouth1992 @PeterSH6 @tardis-key @FightingZhen @ji-huazhong
+/verl/workers/engine @eric-haibin-lin @vermouth1992 @ZihengJiang
+/verl/workers/roles @eric-haibin-lin @vermouth1992 @ZihengJiang
+/verl/workers/engine/fsdp @eric-haibin-lin @vermouth1992 @ZihengJiang
+/verl/workers/rollout/vllm_rollout @wuxibin89 @PeterSH6 @chenhaiq
+/verl/workers/rollout/sglang_rollout @zhaochenyang20 @SwordFaith @chenhaiq
+/verl/workers/actor/megatron_actor.py @ISEEKYAN @vermouth1992
+/verl/workers/critic/megatron_critic.py @ISEEKYAN @vermouth1992
+/verl/workers/megatron_workers.py @ISEEKYAN @vermouth1992
+
+/tests/single_controller @zw0610 @wuxibin89
+/tests/trainer @eric-haibin-lin @vermouth1992 @tongyx361 @PeterSH6
+/tests/workers/rollout/vllm_rollout @wuxibin89 @PeterSH6 @chenhaiq

verl/.github/ISSUE_TEMPLATE/bug-report.yml

@@ -0,0 +1,65 @@
+# modified from https://github.com/huggingface/transformers/blob/main/.github/ISSUE_TEMPLATE/bug-report.yml?plain=1
+name: "\U0001F41B Bug Report"
+description: Submit a bug report to help us improve verl
+labels: [ "bug" ]
+body:
+  - type: markdown
+    attributes:
+      value: |
+        Thanks for taking the time to fill out this bug report! 🤗
+
+  - type: textarea
+    id: system-info
+    attributes:
+      label: System Info
+      description: Please share your system info with us. You can run the command `python scripts/diagnose.py` and copy-paste its output below.
+      placeholder: verl version, platform, python version, ...
+    validations:
+      required: true
+
+  - type: checkboxes
+    id: information-scripts-examples
+    attributes:
+      label: Information
+      description: 'The problem arises when using:'
+      options:
+        - label: "The official example scripts"
+        - label: "My own modified scripts"
+
+  - type: checkboxes
+    id: information-tasks
+    attributes:
+      label: Tasks
+      description: "The tasks I am working on are:"
+      options:
+        - label: "An officially supported task in the `examples` folder (such as GLUE/SQuAD, ...)"
+        - label: "My own task or dataset (give details below)"
+
+  - type: textarea
+    id: reproduction
+    validations:
+      required: true
+    attributes:
+      label: Reproduction
+      description: |
+        Please provide a code sample that reproduces the problem you ran into. It can be a Colab link or just a code snippet.
+        Please include relevant config information with your code.
+        If you have code snippets, error messages, stack traces please provide them here as well.
+        Important! Use code tags to correctly format your code. See https://help.github.com/en/github/writing-on-github/creating-and-highlighting-code-blocks#syntax-highlighting
+        Do not use screenshots, as they are hard to read and (more importantly) don't allow others to copy-and-paste your code.
+
+      placeholder: |
+        Steps to reproduce the behavior:
+
+          1.
+          2.
+          3.
+
+
+  - type: textarea
+    id: expected-behavior
+    validations:
+      required: true
+    attributes:
+      label: Expected behavior
+      description: "A clear and concise description of what you would expect to happen."

verl/.github/ISSUE_TEMPLATE/config.yml

@@ -0,0 +1,2 @@
+blank_issues_enabled: true
+version: 0.1

verl/.github/ISSUE_TEMPLATE/feature-request.yml

@@ -0,0 +1,32 @@
+# modified from https://github.com/huggingface/transformers/blob/main/.github/ISSUE_TEMPLATE/feature-request.yml?plain=1
+name: "\U0001F680 Feature request"
+description: Submit a proposal/request for a new verl feature
+labels: [ "Feature request" ]
+body:
+  - type: textarea
+    id: feature-request
+    validations:
+      required: true
+    attributes:
+      label: Feature request
+      description: |
+        A clear and concise description of the feature proposal. Please provide a link to the paper and code in case they exist.
+
+  - type: textarea
+    id: motivation
+    validations:
+      required: true
+    attributes:
+      label: Motivation
+      description: |
+        Please outline the motivation for the proposal. Is your feature request related to a problem? e.g., I'm always frustrated when [...]. If this is related to another GitHub issue, please link here too.
+
+
+  - type: textarea
+    id: contribution
+    validations:
+      required: true
+    attributes:
+      label: Your contribution
+      description: |
+        Is there any way that you could help, e.g. by submitting a PR? Make sure to read the CONTRIBUTING.MD [readme](https://github.com/volcengine/verl/blob/main/CONTRIBUTING.md)

verl/.github/PULL_REQUEST_TEMPLATE.md

@@ -0,0 +1,40 @@
+### What does this PR do?
+
+> Add **concise** overview of what this PR aims to achieve or accomplish. Reference related GitHub issues and PRs that help with the review.
+
+### Checklist Before Starting
+
+- [ ] Search for similar PRs. Paste at least one query link here: ...
+- [ ] Format the PR title as `[{modules}] {type}: {description}` (This will be checked by the CI)
+  - `{modules}` include `fsdp`, `megatron`, `sglang`, `vllm`, `rollout`, `trainer`, `ci`, `training_utils`, `recipe`, `hardware`, `deployment`, `ray`, `worker`, `single_controller`, `misc`, `perf`, `model`, `algo`, `env`, `tool`, `ckpt`, `doc`, `data`
+  - If this PR involves multiple modules, separate them with `,` like `[megatron, fsdp, doc]`
+  - `{type}` is in `feat`, `fix`, `refactor`, `chore`, `test`
+  - If this PR breaks any API (CLI arguments, config, function signature, etc.), add `[BREAKING]` to the beginning of the title.
+  - Example: `[BREAKING][fsdp, megatron] feat: dynamic batching`
+
+### Test
+
+> For changes that can not be tested by CI (e.g., algorithm implementation, new model support), validate by experiment(s) and show results like training curve plots, evaluation results, etc.
+
+### API and Usage Example
+
+> Demonstrate how the API changes if any, and provide usage example(s) if possible.
+
+```python
+# Add code snippet or script demonstrating how to use this
+```
+
+### Design & Code Changes
+
+> Demonstrate the high-level design if this PR is complex, and list the specific changes.
+
+### Checklist Before Submitting
+
+> [!IMPORTANT]
+> Please check all the following items before requesting a review, otherwise the reviewer might deprioritize this PR for review.
+
+- [ ] Read the [Contribute Guide](https://github.com/volcengine/verl/blob/main/CONTRIBUTING.md).
+- [ ] Apply [pre-commit checks](https://github.com/volcengine/verl/blob/main/CONTRIBUTING.md#code-linting-and-formatting): `pre-commit install && pre-commit run --all-files --show-diff-on-failure --color=always`
+- [ ] Add / Update [the documentation](https://github.com/volcengine/verl/tree/main/docs).
+- [ ] Add unit or end-to-end test(s) to [the CI workflow](https://github.com/volcengine/verl/tree/main/.github/workflows) to cover all the code. If not feasible, explain why: ...
+- [ ] Once your PR is ready for CI, send a message in [the `ci-request` channel](https://verl-project.slack.com/archives/C091TCESWB1) in [the `verl` Slack workspace](https://join.slack.com/t/verl-project/shared_invite/zt-3855yhg8g-CTkqXu~hKojPCmo7k_yXTQ). (If not accessible, please try [the Feishu group (飞书群)](https://applink.larkoffice.com/client/chat/chatter/add_by_link?link_token=772jd4f1-cd91-441e-a820-498c6614126a).)

verl/.github/dependabot.yml

@@ -0,0 +1,9 @@
+## Enabled the dependabot to check the dependencies of the project
+## Dependabot will open pull requests to update dependencies automatically
+
+version: 2
+updates:
+  - package-ecosystem: pip
+    directory: "/"
+    schedule:
+      interval: weekly

verl/.github/workflows/.deprecate/e2e_eval_aime24.yml

@@ -0,0 +1,147 @@
+# # Tests layout
+
+# Each folder under tests/ corresponds to a test category for a sub-namespace in verl. For instance:
+# - `tests/trainer` for testing functionality related to `verl/trainer`
+# - `tests/models` for testing functionality related to `verl/models`
+# - ...
+
+# There are a few folders with `special_` prefix, created for special purposes:
+# - `special_distributed`: unit tests that must run with multiple GPUs
+# - `special_e2e`: end-to-end tests with training/generation scripts
+# - `special_npu`: tests for NPUs
+# - `special_sanity`: a suite of quick sanity tests
+# - `special_standalone`: a set of test that are designed to run in dedicated environments
+
+# Accelerators for tests 
+# - By default tests are run with GPU available, except for the ones under `special_npu`, and any test script whose name ends with `on_cpu.py`.
+# - For test scripts with `on_cpu.py` name suffix would be tested on CPU resources in linux environment.
+
+# # Workflow layout
+
+# All CI tests are configured by yaml files in `.github/workflows/`. Here's an overview of all test configs:
+# 1. A list of always triggered CPU sanity tests: `check-pr-title.yml`, `secrets_scan.yml`, `check-pr-title,yml`, `pre-commit.yml`, `doc.yml`
+# 2. Some heavy multi-GPU unit tests, such as `model.yml`, `vllm.yml`, `sgl.yml`
+# 3. End-to-end tests: `e2e_*.yml`
+# 4. Unit tests
+#   - `cpu_unit_tests.yml`, run pytest on all scripts with file name pattern `tests/**/test_*_on_cpu.py`
+#   - `gpu_unit_tests.yml`, run pytest on all scripts with file without the `on_cpu.py` suffix.
+#   - Since cpu/gpu unit tests by default runs all tests under `tests`, please make sure tests are manually excluded in them when
+#     - new workflow yaml is added to `.github/workflows`
+#     - new tests are added to workflow mentioned in 2.
+
+
+name: e2e_eval_aime24
+
+on:
+  # Trigger the workflow on push or pull request,
+  # but only for the main branch
+  # For push, for now only anti-patterns are specified so it is more conservative
+  # and achieves higher coverage.
+  push:
+    branches:
+      - main
+      - v0.*
+    paths:
+      - "**/*.py"
+      # Other entrypoints
+      - "!*.md"
+      - "!docker/**"
+      - "!docs/**"
+      - "!examples/**"
+      - "!tests/**"
+      - "!verl/trainer/main_*.py"
+      - "!verl/trainer/fsdp_sft_trainer.py"
+      - "!recipe/**"
+      - "recipe/r1"
+      - "!recipe/r1/README.md"
+  pull_request:
+    branches:
+      - main
+    paths:
+      - "**/*.py"
+      # Other entrypoints
+      - "!*.md"
+      - "!docker/**"
+      - "!docs/**"
+      - "!examples/**"
+      - "!tests/**"
+      - "!verl/trainer/main_*.py"
+      - "!verl/trainer/fsdp_sft_trainer.py"
+      # Home
+      - "recipe/r1"
+      - "!recipe/r1/README.md"
+      # Other recipes
+      - "!recipe/**"
+      # Entrypoints
+      - ".github/workflows/e2e_eval_aime24.yml"
+      - "tests/special_e2e/run_r1_distill_qwen_aime24_eval.sh"
+      - "verl/trainer/main_generation.py"
+      - "verl/trainer/config/generation.yaml"
+
+# Cancel jobs on the same ref if a new one is triggered
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: ${{ github.ref != 'refs/heads/main' }}
+
+# Declare permissions just read content.
+permissions:
+  contents: read
+
+env:
+  IMAGE: "verl-ci-cn-beijing.cr.volces.com/verlai/verl:app-verl0.5-transformers4.55.4-vllm0.10.0-mcore0.13.0-te2.2"
+  DYNAMIC_RUNNER_ENDPOINT: "https://sd10g3clalm04ug7alq90.apigateway-cn-beijing.volceapi.com/runner"
+
+jobs:
+  setup:
+    if: github.repository_owner == 'volcengine'
+    runs-on: ubuntu-latest
+    outputs:
+      runner-label: ${{ steps.create-runner.outputs.runner-label }}
+      mlp-task-id: ${{ steps.create-runner.outputs.mlp-task-id }}
+    steps:
+      - uses: actions/checkout@v4
+      - id: create-runner
+        uses: volcengine/vemlp-github-runner@v1 
+        with:
+          mode: "create"
+          faas-url: "${{ env.DYNAMIC_RUNNER_ENDPOINT }}"
+          mlp-image: "${{ env.IMAGE }}"
+  
+  e2e_eval_aime24:
+    needs: setup
+    runs-on: ["${{ needs.setup.outputs.runner-label || 'L20x8' }}"]
+    timeout-minutes: 40 # Increase this timeout value as needed
+    env:
+      HTTP_PROXY: ${{ secrets.PROXY_HTTP }}
+      HTTPS_PROXY: ${{ secrets.PROXY_HTTPS }}
+      NO_PROXY: "localhost,127.0.0.1,hf-mirror.com"
+      HF_ENDPOINT: "https://hf-mirror.com"
+      HF_HUB_ENABLE_HF_TRANSFER: "0" # This is more stable
+    steps:
+      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+        with:
+          fetch-depth: 0
+      - name: Install the current repository
+        run: |
+          pip3 install --no-deps -e .[test,gpu,math]
+          pip3 install math-verify transformers==4.56.2
+      - name: Prepare aime24 dataset
+        run: |
+          ray stop --force
+          python3 recipe/r1/data_process.py --task aime2024
+      - name: Running generation and evaluation in AIME 2024
+        run: |
+          ray stop --force
+          bash tests/special_e2e/run_r1_distill_qwen_aime24_eval.sh
+
+  cleanup:
+      runs-on: ubuntu-latest
+      needs: [setup, e2e_eval_aime24]
+      if: always()
+      steps:
+        - id: destroy-runner
+          uses: volcengine/vemlp-github-runner@v1
+          with:
+            mode: "destroy"
+            faas-url: "${{ env.DYNAMIC_RUNNER_ENDPOINT }}"
+            mlp-task-id: "${{ needs.setup.outputs.mlp-task-id }}"

verl/.github/workflows/.deprecate/e2e_ppo_trainer.yml

@@ -0,0 +1,133 @@
+name: e2e_ppo_trainer_deprecate
+
+on:
+  # Trigger the workflow on push or pull request,
+  # but only for the main branch
+  # For push, for now only anti-patterns are specified so it is more conservative
+  # and achieves higher coverage.
+  push:
+    branches:
+      - disabled_ci
+  pull_request:
+    branches:
+      - disabled_ci
+    paths:
+      - "**/*.py"
+      # Other entrypoints
+      - "!**/*.md"
+      - "!docker/**"
+      - "!examples/**"
+      - "!tests/**"
+      - "!verl/trainer/main_*.py"
+      - "!verl/trainer/fsdp_sft_trainer.py"
+      # Docs
+      - "!docs/**"
+      # Recipes
+      - "!recipe/**"
+      # Megatron
+      - "!verl/workers/**/megatron_*.py"
+      # Entrypoints
+      - ".github/workflows/e2e_ppo_trainer.yml"
+      - "examples/data_preprocess/gsm8k.py"
+      - "examples/data_preprocess/geo3k.py"
+      - "tests/special_e2e/ppo_trainer"
+      - "verl/trainer/main_ppo.py"
+      - "verl/trainer/config/ppo_trainer.yaml"
+
+# Cancel jobs on the same ref if a new one is triggered
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: ${{ github.ref != 'refs/heads/main' }}
+
+# Declare permissions just read content.
+permissions:
+  contents: read
+
+jobs:
+  pre_commit_for_ppo:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version: ["3.12"]
+    steps:
+      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+      - name: Set up Python ${{ matrix.python-version }}
+        uses: actions/setup-python@0b93645e9fea7318ecaed2b359559ac225c90a2b # v5.3.0
+        with:
+          python-version: ${{ matrix.python-version }}
+      - name: Install the current repository
+        run: |
+          pip install -e .
+      - name: Set ruff --output-format=github
+        run: |
+          sed -i 's/--output-format=full/--output-format=github/' .pre-commit-config.yaml
+          git add .pre-commit-config.yaml
+      - uses: pre-commit/action@v3.0.1
+        with:
+          extra_args: "" # Overriding default "--all-files"
+
+  e2e_ppo_trainer_sglang_multiturn_with_tool:
+    runs-on: [L20x8]
+    needs: pre_commit_for_ppo
+    timeout-minutes: 40 # Increase this timeout value as needed
+    env:
+      HTTP_PROXY: ${{ secrets.PROXY_HTTP }}
+      HTTPS_PROXY: ${{ secrets.PROXY_HTTPS }}
+      NO_PROXY: "localhost,127.0.0.1,hf-mirror.com"
+      HF_ENDPOINT: "https://hf-mirror.com"
+      HF_HUB_ENABLE_HF_TRANSFER: "0" # This is more stable
+    container:
+      image: verlai/verl:app-verl0.6-transformers4.56.1-sglang0.5.2-mcore0.13.0-te2.2
+      options: --gpus all --shm-size=10g
+    steps:
+      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+        with:
+          fetch-depth: 0
+      - name: Install the current repository
+        run: |
+          pip3 install -e .[test,gpu,sglang]
+      - name: Prepare gsm8k dataset with tool
+        run: |
+          ray stop --force
+          python3 examples/data_preprocess/gsm8k_multiturn_w_tool.py --local_save_dir $HOME/data/gsm8k_verl_sgl_multi_turn_preprocessed
+      - name: Running GSM8K with tool E2E training tests on 8 L20 GPUs with rmpad using function rm and save ckpt with sglang
+        run: |
+          ray stop --force
+          bash tests/special_e2e/run_gsm8k_fsdp_sgl_multiturn_w_tool.sh
+      - name: Running GSM8K with tool E2E training tests with FSDP2
+        run: |
+          ray stop --force
+          FSDP_STRATEGY=fsdp2 bash tests/special_e2e/run_gsm8k_fsdp_sgl_multiturn_w_tool.sh
+
+  e2e_ppo_trainer_sglang_vlm_multiturn_with_tool:
+    runs-on: [L20x8]
+    needs: pre_commit_for_ppo
+    timeout-minutes: 40 # Increase this timeout value as needed
+    env:
+      HTTP_PROXY: ${{ secrets.PROXY_HTTP }}
+      HTTPS_PROXY: ${{ secrets.PROXY_HTTPS }}
+      NO_PROXY: "localhost,127.0.0.1,hf-mirror.com"
+      HF_ENDPOINT: "https://hf-mirror.com"
+      HF_HUB_ENABLE_HF_TRANSFER: "0" # This is more stable
+    container:
+      image: verlai/verl:app-verl0.6-transformers4.56.1-sglang0.5.2-mcore0.13.0-te2.2
+      options: --gpus all --shm-size=10g
+    steps:
+      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+        with:
+          fetch-depth: 0
+      - name: Install the current repository
+        run: |
+          pip3 install -e .[test,geo,gpu,sglang]
+      - name: Prepare geo3k dataset with tool
+        run: |
+          ray stop --force
+          python3 examples/data_preprocess/geo3k_multiturn_w_tool.py --local_dir $HOME/data/geo3k_verl_sgl_multi_turn_preprocessed
+      - name: Running GEO3K with tool E2E training tests on 8 L20 GPUs with rmpad using function rm and save ckpt with sglang
+        run: |
+          ray stop --force
+          bash tests/special_e2e/run_geo3k_fsdp_sgl_multiturn_w_tool.sh
+      - name: Running GEO3K with tool E2E training tests with FSDP2
+        run: |
+          ray stop --force
+          FSDP_STRATEGY=fsdp2 bash tests/special_e2e/run_geo3k_fsdp_sgl_multiturn_w_tool.sh

verl/.github/workflows/.deprecate/e2e_ppo_trainer_megatron_sglang.yml

@@ -0,0 +1,155 @@
+# # Tests layout
+
+# Each folder under tests/ corresponds to a test category for a sub-namespace in verl. For instance:
+# - `tests/trainer` for testing functionality related to `verl/trainer`
+# - `tests/models` for testing functionality related to `verl/models`
+# - ...
+
+# There are a few folders with `special_` prefix, created for special purposes:
+# - `special_distributed`: unit tests that must run with multiple GPUs
+# - `special_e2e`: end-to-end tests with training/generation scripts
+# - `special_npu`: tests for NPUs
+# - `special_sanity`: a suite of quick sanity tests
+# - `special_standalone`: a set of test that are designed to run in dedicated environments
+
+# Accelerators for tests
+# - By default tests are run with GPU available, except for the ones under `special_npu`, and any test script whose name ends with `on_cpu.py`.
+# - For test scripts with `on_cpu.py` name suffix would be tested on CPU resources in linux environment.
+
+# # Workflow layout
+
+# All CI tests are configured by yaml files in `.github/workflows/`. Here's an overview of all test configs:
+# 1. A list of always triggered CPU sanity tests: `check-pr-title.yml`, `secrets_scan.yml`, `check-pr-title,yml`, `pre-commit.yml`, `doc.yml`
+# 2. Some heavy multi-GPU unit tests, such as `model.yml`, `vllm.yml`, `sgl.yml`
+# 3. End-to-end tests: `e2e_*.yml`
+# 4. Unit tests
+#   - `cpu_unit_tests.yml`, run pytest on all scripts with file name pattern `tests/**/test_*_on_cpu.py`
+#   - `gpu_unit_tests.yml`, run pytest on all scripts with file without the `on_cpu.py` suffix.
+#   - Since cpu/gpu unit tests by default runs all tests under `tests`, please make sure tests are manually excluded in them when
+#     - new workflow yaml is added to `.github/workflows`
+#     - new tests are added to workflow mentioned in 2.
+
+name: e2e_ppo_trainer_megatron_sglang_deprecate
+
+on:
+  # Trigger the workflow on push or pull request,
+  # but only for the main branch.
+  # For push, for now only anti-patterns are specified so it is more conservative
+  # and achieves higher coverage.
+  push:
+    branches:
+      - disabled_ci
+  pull_request:
+    branches:
+      - disabled_ci
+    paths:
+      - "**/*.py"
+      # Other entrypoints
+      - "!docker/**"
+      # Docs
+      - "!**/*.md"
+      - "!docs/**"
+      - "!examples/**"
+      - "!tests/**"
+      - "!verl/trainer/main_*.py"
+      - "!verl/trainer/fsdp_sft_trainer.py"
+      # Recipes
+      - "!recipe/**"
+      # FSDP
+      - "!verl/workers/**/*dp_*.py"
+      # Entrypoints
+      - ".github/workflows/e2e_ppo_trainer_megatron_sglang.yml"
+      - "examples/data_preprocess/gsm8k.py"
+      - "examples/data_preprocess/geo3k.py"
+      - "tests/special_e2e/run_ppo_trainer_megatron.sh"
+      - "verl/trainer/main_ppo.py"
+      - "verl/trainer/config/ppo_megatron_trainer.yaml"
+
+# Cancel jobs on the same ref if a new one is triggered
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: ${{ github.ref != 'refs/heads/main' }}
+
+# Declare permissions just read content.
+permissions:
+  contents: read
+
+env:
+  IMAGE: "verl-ci-cn-beijing.cr.volces.com/verlai/verl:app-verl0.6-transformers4.56.1-sglang0.5.2-mcore0.13.0-te2.2"
+  DYNAMIC_RUNNER_ENDPOINT: "https://sd10g3clalm04ug7alq90.apigateway-cn-beijing.volceapi.com/runner"
+
+jobs:
+  setup:
+    if: github.repository_owner == 'volcengine'
+    runs-on: ubuntu-latest
+    outputs:
+      runner-label: ${{ steps.create-runner.outputs.runner-label }}
+      mlp-task-id: ${{ steps.create-runner.outputs.mlp-task-id }}
+    steps:
+      - uses: actions/checkout@v4
+      - id: create-runner
+        uses: volcengine/vemlp-github-runner@v1
+        with:
+          mode: "create"
+          faas-url: "${{ env.DYNAMIC_RUNNER_ENDPOINT }}"
+          mlp-image: "${{ env.IMAGE }}"
+
+  e2e_ppo_trainer_megatron-qwen3:
+    needs: setup
+    runs-on: ["${{ needs.setup.outputs.runner-label || 'L20x8' }}"]
+    timeout-minutes: 60 # Increase this timeout value as needed
+    env:
+      HTTP_PROXY: ${{ secrets.PROXY_HTTP }}
+      HTTPS_PROXY: ${{ secrets.PROXY_HTTPS }}
+      NO_PROXY: "localhost,127.0.0.1,hf-mirror.com"
+      HF_ENDPOINT: "https://hf-mirror.com"
+      HF_HUB_ENABLE_HF_TRANSFER: "0" # This is more stable
+    steps:
+      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+        with:
+          fetch-depth: 0
+      - name: Install the current repository
+        run: |
+          pip3 install --no-deps -e .[test]
+      - name: Prepare GSM8K dataset
+        run: |
+          python3 examples/data_preprocess/gsm8k.py
+      - name: Running GSM8K E2E training tests with 3D parallelism on 8 L20 GPUs with Megatron (Qwen3) with validation and saving
+        run: |
+          ray stop --force
+          ENGINE=sglang ALL_OFFLOAD=True VAL_BEFORE_TRAIN=True TEST_FREQ=1 SAVE_FREQ=1 MODEL_ID=Qwen/Qwen3-0.6B bash tests/special_e2e/run_ppo_trainer_megatron.sh
+      - name: Running GSM8K E2E training tests with 3D parallelism on 8 L20 GPUs with Megatron (Qwen3) testing learning rate scheduler
+        run: |
+          ray stop --force
+          ENGINE=sglang LR_WARMUP_STEPS=1 TOTAL_TRAIN_STEPS=2 MODEL_ID=Qwen/Qwen3-0.6B bash tests/special_e2e/run_ppo_trainer_megatron.sh
+
+      - name: Test Megatron checkpoints merging function (Qwen3 Actor and Critic)
+        run: |
+          exp_name="qwen3-0.6b-megatron-gsm8k-minimal"
+          python -m verl.model_merger test --backend megatron --tie-word-embedding --local_dir checkpoints/verl-test/${exp_name}/global_step_1/actor --test_hf_dir checkpoints/verl-test/${exp_name}/global_step_1/actor/huggingface
+          python -m verl.model_merger test --backend megatron --is-value-model --local_dir checkpoints/verl-test/${exp_name}/global_step_1/critic --test_hf_dir checkpoints/verl-test/${exp_name}/global_step_1/critic/huggingface
+      - name: clean up
+        run: |
+          rm -rf checkpoints
+
+  cleanup:
+    runs-on: ubuntu-latest
+    needs:
+      [
+        setup,
+        e2e_ppo_trainer_megatron-deepseek,
+        e2e_ppo_trainer_megatron-qwen3,
+        e2e_ppo_trainer_megatron-different-train-infer-tp-qwen-tie-embedding,
+        e2e_ppo_trainer_megatron-qwen-override-transformer-config,
+        e2e_ppo_trainer_megatron-deepseek-override-transformer-config,
+        e2e_ppo_trainer_megatron-moe-expert-parallel,
+        e2e_ppo_trainer_megatron-qwen2_5vl-3b,
+      ]
+    if: always()
+    steps:
+      - id: destroy-runner
+        uses: volcengine/vemlp-github-runner@v1
+        with:
+          mode: "destroy"
+          faas-url: "${{ env.DYNAMIC_RUNNER_ENDPOINT }}"
+          mlp-task-id: "${{ needs.setup.outputs.mlp-task-id }}"

verl/.github/workflows/.deprecate/e2e_prime.yml

@@ -0,0 +1,66 @@
+name: e2e_prime_deprecate
+
+on:
+  # Trigger the workflow on push or pull request,
+  # but only for the main branch
+  push:
+    branches:
+      - disabled_ci
+  pull_request:
+    branches:
+      - disabled_ci
+    paths:
+      - "**/*.py"
+      # Other entrypoints
+      - "!examples/**"
+      - "!tests/**"
+      - "!verl/trainer/main_*.py"
+      - "!verl/trainer/fsdp_sft_trainer.py"
+      # Other recipes
+      - "!recipe/**"
+      # Megatron
+      - "!verl/workers/**/megatron_*.py"
+      # Home
+      - "recipe/prime"
+      # Entrypoints
+      - ".github/workflows/e2e_prime.yml"
+      - "examples/data_preprocess/gsm8k.py"
+      - "tests/special_e2e/run_prime.sh"
+
+# Cancel jobs on the same ref if a new one is triggered
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: ${{ github.ref != 'refs/heads/main' }}
+
+# Declare permissions just read content.
+permissions:
+  contents: read
+
+jobs:
+  e2e_prime:
+    runs-on: [L20x8]
+    timeout-minutes: 50 # Increase this timeout value as needed
+    env:
+      HTTP_PROXY: ${{ secrets.PROXY_HTTP }}
+      HTTPS_PROXY: ${{ secrets.PROXY_HTTPS }}
+      NO_PROXY: "localhost,127.0.0.1,hf-mirror.com"
+      HF_ENDPOINT: "https://hf-mirror.com"
+      HF_HUB_ENABLE_HF_TRANSFER: "0" # This is more stable
+    container:
+      image: whatcanyousee/verl:ngc-cu124-vllm0.8.5-sglang0.4.6.post5-mcore0.12.0-te2.3
+      options: --gpus all --shm-size=10g
+    steps:
+      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+        with:
+          fetch-depth: 0
+      - name: Install the current repository
+        run: |
+          pip3 install --no-deps -e .[test,gpu]
+      - name: Prepare gsm8k dataset
+        run: |
+          ray stop --force
+          python3 examples/data_preprocess/gsm8k.py
+      - name: Running GSM8K E2E with prime alg
+        run: |
+          ray stop --force
+          bash tests/special_e2e/run_prime.sh

verl/.github/workflows/.deprecate/e2e_spin.yml

@@ -0,0 +1,119 @@
+name: e2e_spin
+
+on:
+  # Trigger the workflow on push or pull request,
+  # but only for the main branch
+  push:
+    branches:
+      - main
+      - v0.*
+    paths:
+      - "**/*.py"
+      # Other entrypoints
+      - "!examples/**"
+      - "!tests/**"
+      - "!verl/trainer/main_*.py"
+      - "!verl/trainer/fsdp_sft_trainer.py"
+      # Other recipes
+      - "!recipe/**"
+      # Megatron
+      - "!verl/workers/**/megatron_*.py"
+      # Home
+      - "recipe/spin"
+      # Entrypoints
+      - ".github/workflows/e2e_spin.yml"
+      - "examples/data_preprocess/gsm8k.py"
+      - "tests/special_e2e/run_spin.sh"
+      - "!examples"
+  pull_request:
+    branches:
+      - main
+      - v0.*
+    paths:
+      - "**/*.py"
+      # Other entrypoints
+      - "!examples/**"
+      - "!tests/**"
+      - "!verl/trainer/main_*.py"
+      - "!verl/trainer/fsdp_sft_trainer.py"
+      # Other recipes
+      - "!recipe/**"
+      # Megatron
+      - "!verl/workers/**/megatron_*.py"
+      # Home
+      - "recipe/spin"
+      # Entrypoints
+      - ".github/workflows/e2e_spin.yml"
+      - "examples/data_preprocess/gsm8k.py"
+      - "tests/special_e2e/run_spin.sh"
+      - "!examples"
+
+# Declare permissions just read content.
+permissions:
+  contents: read
+
+env:
+  IMAGE: "verl-ci-cn-beijing.cr.volces.com/verlai/verl:app-verl0.6-transformers4.56.1-sglang0.5.2-mcore0.13.0-te2.2"
+  DYNAMIC_RUNNER_ENDPOINT: "https://sd10g3clalm04ug7alq90.apigateway-cn-beijing.volceapi.com/runner"
+
+# Cancel jobs on the same ref if a new one is triggered
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: ${{ github.ref != 'refs/heads/main' }}
+
+jobs:
+  setup:
+    if: github.repository_owner == 'volcengine'
+    runs-on: ubuntu-latest
+    outputs:
+      runner-label: ${{ steps.create-runner.outputs.runner-label }}
+      mlp-task-id: ${{ steps.create-runner.outputs.mlp-task-id }}
+    steps:
+      - uses: actions/checkout@v4
+      - id: create-runner
+        uses: volcengine/vemlp-github-runner@v1
+        with:
+          mode: "create"
+          faas-url: "${{ env.DYNAMIC_RUNNER_ENDPOINT }}"
+          mlp-image: "${{ env.IMAGE }}"
+
+  e2e_spin:
+    needs: setup
+    runs-on: [ "${{ needs.setup.outputs.runner-label || 'L20x8' }}" ]
+    timeout-minutes: 40 # Increase this timeout value as needed
+    env:
+      HTTP_PROXY: ${{ secrets.PROXY_HTTP }}
+      HTTPS_PROXY: ${{ secrets.PROXY_HTTPS }}
+      NO_PROXY: "localhost,127.0.0.1,hf-mirror.com"
+      HF_ENDPOINT: "https://hf-mirror.com"
+      HF_HUB_ENABLE_HF_TRANSFER: "0" # This is more stable
+    steps:
+      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+        with:
+          fetch-depth: 0
+      - name: Install the current repository
+        run: |
+          pip3 install -e .[test,gpu,sglang]
+      - name: Prepare GSM8K dataset
+        run: |
+          python3 examples/data_preprocess/gsm8k.py --local_dataset_path ${HOME}/models/hf_data/gsm8k
+      - name: Running the E2E test with the spin algorithm
+        run: |
+          ray stop --force
+          bash tests/special_e2e/run_spin.sh
+
+  cleanup:
+    runs-on: ubuntu-latest
+    needs:
+      [
+        setup,
+        e2e_spin
+      ]
+    if: always()
+    steps:
+      - id: destroy-runner
+        uses: volcengine/vemlp-github-runner@v1
+        with:
+          mode: "destroy"
+          faas-url: "${{ env.DYNAMIC_RUNNER_ENDPOINT }}"
+          mlp-task-id: "${{ needs.setup.outputs.mlp-task-id }}"

verl/.github/workflows/.deprecate/e2e_sppo.yml

@@ -0,0 +1,118 @@
+name: e2e_sppo
+
+on:
+  # Trigger the workflow on push or pull request,
+  # but only for the main branch
+  push:
+    branches:
+      - main
+      - v0.*
+    paths:
+      - "**/*.py"
+      # Other entrypoints
+      - "!examples/**"
+      - "!tests/**"
+      - "!verl/trainer/main_*.py"
+      - "!verl/trainer/fsdp_sft_trainer.py"
+      # Other recipes
+      - "!recipe/**"
+      # Megatron
+      - "!verl/workers/**/megatron_*.py"
+      # Home
+      - "recipe/sppo"
+      # Entrypoints
+      - ".github/workflows/e2e_sppo.yml"
+      - "examples/data_preprocess/gsm8k.py"
+      - "tests/special_e2e/run_sppo.sh"
+  pull_request:
+    branches:
+      - main
+      - v0.*
+    paths:
+      - "**/*.py"
+      # Other entrypoints
+      - "!examples/**"
+      - "!tests/**"
+      - "!verl/trainer/main_*.py"
+      - "!verl/trainer/fsdp_sft_trainer.py"
+      # Other recipes
+      - "!recipe/**"
+      # Megatron
+      - "!verl/workers/**/megatron_*.py"
+      # Home
+      - "recipe/sppo"
+      # Entrypoints
+      - ".github/workflows/e2e_sppo.yml"
+      - "examples/data_preprocess/gsm8k.py"
+      - "tests/special_e2e/run_sppo.sh"
+
+# Declare permissions just read content.
+permissions:
+  contents: read
+
+# Cancel jobs on the same ref if a new one is triggered
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: ${{ github.ref != 'refs/heads/main' }}
+
+env:
+  IMAGE: "verl-ci-cn-beijing.cr.volces.com/verlai/verl:app-verl0.6-transformers4.56.1-sglang0.5.2-mcore0.13.0-te2.2"
+  DYNAMIC_RUNNER_ENDPOINT: "https://sd10g3clalm04ug7alq90.apigateway-cn-beijing.volceapi.com/runner"
+  TRANSFORMERS_VERSION: "4.56.2"
+
+jobs:
+  setup:
+    if: github.repository_owner == 'volcengine'
+    runs-on: ubuntu-latest
+    outputs:
+      runner-label: ${{ steps.create-runner.outputs.runner-label }}
+      mlp-task-id: ${{ steps.create-runner.outputs.mlp-task-id }}
+    steps:
+      - uses: actions/checkout@v4
+      - id: create-runner
+        uses: volcengine/vemlp-github-runner@v1
+        with:
+          mode: "create"
+          faas-url: "${{ env.DYNAMIC_RUNNER_ENDPOINT }}"
+          mlp-image: "${{ env.IMAGE }}"
+
+  e2e_sppo:
+    needs: setup
+    runs-on: [ "${{ needs.setup.outputs.runner-label || 'L20x8' }}" ]
+    timeout-minutes: 40 # Increase this timeout value as needed
+    env:
+      HTTP_PROXY: ${{ secrets.PROXY_HTTP }}
+      HTTPS_PROXY: ${{ secrets.PROXY_HTTPS }}
+      NO_PROXY: "localhost,127.0.0.1,hf-mirror.com"
+      HF_ENDPOINT: "https://hf-mirror.com"
+      HF_HUB_ENABLE_HF_TRANSFER: "0" # This is more stable
+    steps:
+      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+        with:
+          fetch-depth: 0
+      - name: Install the current repository
+        run: |
+          pip3 install -e .[test,gpu,sglang]
+      - name: Prepare MATH dataset
+        run: |
+          python3 examples/data_preprocess/math_dataset.py --local_dataset_path $HOME/models/hf_data/DigitalLearningGmbH/MATH-lighteval
+      - name: Running the E2E test with the SPPO algorithm
+        run: |
+          ray stop --force
+          bash tests/special_e2e/run_sppo.sh
+
+  cleanup:
+    runs-on: ubuntu-latest
+    needs:
+      [
+        setup,
+        e2e_sppo
+      ]
+    if: always()
+    steps:
+      - id: destroy-runner
+        uses: volcengine/vemlp-github-runner@v1
+        with:
+          mode: "destroy"
+          faas-url: "${{ env.DYNAMIC_RUNNER_ENDPOINT }}"
+          mlp-task-id: "${{ needs.setup.outputs.mlp-task-id }}"

verl/.github/workflows/README.md

@@ -0,0 +1,73 @@
+### Adding a New Workflow
+
+When adding a new workflow for continuous integration (CI), you have two runner options: a fixed runner or a machine from the vemlp.
+
+- **Fixed Runner**: To use a fixed runner, specify it in your workflow using the `runs-on` keyword, like `runs-on: [L20x8]`. 
+- **Vemlp Runner**: Opting for a Vemlp machine allows you to launch tasks elastically. 
+
+Here is a template to assist you. This template is designed for using Vemlp machines. Currently, for each workflow, you need to create a `setup` and a `cleanup` job. When using this template, the main parts you need to modify are the `IMAGE` environment variable and the specific `job steps`.
+
+```yaml
+name: Your Default Workflow
+
+on:
+  push:
+    branches:
+      - main
+      - v0.*
+  pull_request:
+    branches:
+      - main
+      - v0.*
+    paths:
+      - "**/*.py"
+      - ".github/workflows/template.yml"
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: ${{ github.ref != 'refs/heads/main' }}
+
+permissions:
+  contents: read
+
+env:
+  IMAGE: "your vemlp image" # e.g. "verl-ci-cn-beijing.cr.volces.com/verlai/verl:app-verl0.4-vllm0.8.5-mcore0.12.2"
+  DYNAMIC_RUNNER_URL: "https://sd10g3clalm04ug7alq90.apigateway-cn-beijing.volceapi.com/runner" # public veFaas api
+
+jobs:
+  setup:
+    if: github.repository_owner == 'volcengine'
+    runs-on: ubuntu-latest
+    outputs:
+      runner-label: ${{ steps.create-runner.outputs.runner-label }}
+      task-id: ${{ steps.create-runner.outputs.task-id }}
+    steps:
+      - uses: actions/checkout@v4
+      - id: create-runner
+        uses: volcengine/vemlp-github-runner@v1 
+        with:
+          mode: "create"
+          faas-url: "${{ env.DYNAMIC_RUNNER_URL }}"
+          image: "${{ env.DEFAULT_IMAGE }}"
+
+  your_job:
+    needs: setup
+    runs-on: ["${{ needs.setup.outputs.runner-label || 'default-runner' }}"]
+    steps:
+      xxxx # your jobs
+
+  cleanup:
+    runs-on: ubuntu-latest
+    needs: [setup, your_job]
+    if: always()
+    steps:
+      - id: destroy-runner
+        uses: volcengine/vemlp-github-runner@v1
+        with:
+          mode: "destroy"
+          faas-url: "${{ env.DYNAMIC_RUNNER_URL }}"
+          task-id: "${{ needs.setup.outputs.task-id }}"
+```
+
+### Model and Dataset
+To avoid CI relies on network, we pre-download dataset on a NFS on the CI machine. The path for models are \${HOME}/models and the path for dataset is \${HOME}/models/hf_data.

verl/.github/workflows/check-pr-title.yml

@@ -0,0 +1,58 @@
+# # Tests layout
+
+# Each folder under tests/ corresponds to a test category for a sub-namespace in verl. For instance:
+# - `tests/trainer` for testing functionality related to `verl/trainer`
+# - `tests/models` for testing functionality related to `verl/models`
+# - ...
+
+# There are a few folders with `special_` prefix, created for special purposes:
+# - `special_distributed`: unit tests that must run with multiple GPUs
+# - `special_e2e`: end-to-end tests with training/generation scripts
+# - `special_npu`: tests for NPUs
+# - `special_sanity`: a suite of quick sanity tests
+# - `special_standalone`: a set of test that are designed to run in dedicated environments
+
+# Accelerators for tests 
+# - By default tests are run with GPU available, except for the ones under `special_npu`, and any test script whose name ends with `on_cpu.py`.
+# - For test scripts with `on_cpu.py` name suffix would be tested on CPU resources in linux environment.
+
+# # Workflow layout
+
+# All CI tests are configured by yaml files in `.github/workflows/`. Here's an overview of all test configs:
+# 1. A list of always triggered CPU sanity tests: `check-pr-title.yml`, `secrets_scan.yml`, `check-pr-title,yml`, `pre-commit.yml`, `doc.yml`
+# 2. Some heavy multi-GPU unit tests, such as `model.yml`, `vllm.yml`, `sgl.yml`
+# 3. End-to-end tests: `e2e_*.yml`
+# 4. Unit tests
+#   - `cpu_unit_tests.yml`, run pytest on all scripts with file name pattern `tests/**/test_*_on_cpu.py`
+#   - `gpu_unit_tests.yml`, run pytest on all scripts with file without the `on_cpu.py` suffix.
+#   - Since cpu/gpu unit tests by default runs all tests under `tests`, please make sure tests are manually excluded in them when
+#     - new workflow yaml is added to `.github/workflows`
+#     - new tests are added to workflow mentioned in 2.
+
+
+on:
+  pull_request:
+    types: [opened, edited, synchronize]
+
+jobs:
+  check-title:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: '3.11'
+
+      - name: Run PR title checker
+        run: python3 tests/special_sanity/check_pr_title.py
+        env:
+          PR_TITLE: ${{ github.event.pull_request.title }}
+
+      - name: Run PR description checker
+        run: python3 tests/special_sanity/check_pr_description.py
+        env:
+          PR_TITLE: ${{ github.event.pull_request.title }}
+          GITHUB_EVENT_PATH: ${{ github.event_path }}

verl/.github/workflows/checkpoint_converter.yml

@@ -0,0 +1,175 @@
+# # Tests layout
+
+# Each folder under tests/ corresponds to a test category for a sub-namespace in verl. For instance:
+# - `tests/trainer` for testing functionality related to `verl/trainer`
+# - `tests/models` for testing functionality related to `verl/models`
+# - ...
+
+# There are a few folders with `special_` prefix, created for special purposes:
+# - `special_distributed`: unit tests that must run with multiple GPUs
+# - `special_e2e`: end-to-end tests with training/generation scripts
+# - `special_npu`: tests for NPUs
+# - `special_sanity`: a suite of quick sanity tests
+# - `special_standalone`: a set of test that are designed to run in dedicated environments
+
+# Accelerators for tests
+# - By default tests are run with GPU available, except for the ones under `special_npu`, and any test script whose name ends with `on_cpu.py`.
+# - For test scripts with `on_cpu.py` name suffix would be tested on CPU resources in linux environment.
+
+# # Workflow layout
+
+# All CI tests are configured by yaml files in `.github/workflows/`. Here's an overview of all test configs:
+# 1. A list of always triggered CPU sanity tests: `check-pr-title.yml`, `secrets_scan.yml`, `check-pr-title,yml`, `pre-commit.yml`, `doc.yml`
+# 2. Some heavy multi-GPU unit tests, such as `model.yml`, `vllm.yml`, `sgl.yml`
+# 3. End-to-end tests: `e2e_*.yml`
+# 4. Unit tests
+#   - `cpu_unit_tests.yml`, run pytest on all scripts with file name pattern `tests/**/test_*_on_cpu.py`
+#   - `gpu_unit_tests.yml`, run pytest on all scripts with file without the `on_cpu.py` suffix.
+#   - Since cpu/gpu unit tests by default runs all tests under `tests`, please make sure tests are manually excluded in them when
+#     - new workflow yaml is added to `.github/workflows`
+#     - new tests are added to workflow mentioned in 2.
+
+name: checkpoint_converter
+# latest version: Megatron-LM core_r0.11.0 https://github.com/NVIDIA/Megatron-LM/tree/core_r0.11.0
+
+on:
+  # Trigger the workflow on push or pull request,
+  # but only for the main branch
+  push:
+    branches:
+      - main
+      - v0.*
+  pull_request:
+    branches:
+      - main
+      - v0.*
+    paths:
+      - "**/*.py"
+      # Other entrypoints
+      - "!examples/**"
+      - "!tests/**"
+      - "!verl/trainer/main_*.py"
+      - "!verl/trainer/fsdp_sft_trainer.py"
+      # Recipes
+      - "!recipe/**"
+      # FSDP
+      - "!verl/workers/**/*dp_*.py"
+      # Entrypoints
+      - ".github/workflows/checkpoint_converter.yml"
+      - ".github/workflows/e2e_ppo_trainer_megatron.yml"
+      - "examples/data_preprocess/gsm8k.py"
+      - "tests/special_e2e/run_ppo_trainer_megatron.sh"
+      - "verl/trainer/main_ppo.py"
+      - "verl/trainer/config/ppo_megatron_trainer.yaml"
+
+# Cancel jobs on the same ref if a new one is triggered
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: ${{ github.ref != 'refs/heads/main' }}
+
+# Declare permissions just read content.
+permissions:
+  contents: read
+
+env:
+  IMAGE: "verl-ci-cn-beijing.cr.volces.com/verlai/verl:app-verl0.6-transformers4.56.1-sglang0.5.2-mcore0.13.0-te2.2"
+  DYNAMIC_RUNNER_ENDPOINT: "https://sd10g3clalm04ug7alq90.apigateway-cn-beijing.volceapi.com/runner"
+
+jobs:
+  setup:
+    if: github.repository_owner == 'volcengine'
+    runs-on: ubuntu-latest
+    outputs:
+      runner-label: ${{ steps.create-runner.outputs.runner-label }}
+      mlp-task-id: ${{ steps.create-runner.outputs.mlp-task-id }}
+    steps:
+      - uses: actions/checkout@v4
+      - id: create-runner
+        uses: volcengine/vemlp-github-runner@v1
+        with:
+          mode: "create"
+          faas-url: "${{ env.DYNAMIC_RUNNER_ENDPOINT }}"
+          mlp-image: "${{ env.IMAGE }}"
+
+  checkpoint_converter:
+    needs: setup
+    runs-on: [ "${{ needs.setup.outputs.runner-label || 'L20x8' }}" ]
+    timeout-minutes: 20 # Increase this timeout value as needed
+    env:
+      HTTP_PROXY: ${{ secrets.PROXY_HTTP }}
+      HTTPS_PROXY: ${{ secrets.PROXY_HTTPS }}
+      NO_PROXY: "localhost,127.0.0.1"
+      HF_HUB_ENABLE_HF_TRANSFER: "0" # This is more stable
+    steps:
+      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+        with:
+          fetch-depth: 0
+      - name: Install the current repository
+        run: |
+          pip3 install -e .[test]
+#      - name: Download Model to Use
+#        run: |
+#          huggingface-cli download Qwen/Qwen2.5-0.5B --local-dir ${HOME}/models/Qwen/Qwen2.5-0.5B
+#          huggingface-cli download deepseek-ai/deepseek-coder-1.3b-instruct --local-dir ${HOME}/models/deepseek-ai/deepseek-coder-1.3b-instruct
+#          export HF_HUB_OFFLINE=1
+      - name: Running Huggingface to Megatron dist_ckpt converter (Qwen/Qwen2.5-0.5B)
+        run: |
+          ray stop --force
+          python scripts/converter_hf_to_mcore.py --hf_model_path=${HOME}/models/Qwen/Qwen2.5-0.5B --output_path checkpoints/Qwen/Qwen2.5-0.5B --test
+      - name: Running Huggingface to Megatron dist_ckpt converter (deepseek-ai/deepseek-coder-1.3b-instruct)
+        run: |
+          ray stop --force
+          python scripts/converter_hf_to_mcore.py --hf_model_path=${HOME}/models/deepseek-ai/deepseek-coder-1.3b-instruct --output_path checkpoints/deepseek-ai/deepseek-coder-1.3b-instruct --test
+      - name: Clean up
+        run: |
+          rm -rf checkpoints
+
+  checkpoint_converter_large_moe_models:
+    needs: setup
+    runs-on: [ "${{ needs.setup.outputs.runner-label || 'L20x8' }}" ]
+    timeout-minutes: 30 # Increase this timeout value as needed
+    env:
+      HTTP_PROXY: ${{ secrets.PROXY_HTTP }}
+      HTTPS_PROXY: ${{ secrets.PROXY_HTTPS }}
+      NO_PROXY: "localhost,127.0.0.1"
+      HF_HUB_ENABLE_HF_TRANSFER: "0" # This is more stable
+      HF_ENDPOINT: "https://hf-mirror.com"
+    steps:
+      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+        with:
+          fetch-depth: 0
+      - name: Install the current repository
+        run: |
+          pip3 install -e .[test]
+#      - name: Download Model to Use
+#        run: |
+#          huggingface-cli download Qwen/Qwen1.5-MoE-A2.7B-Chat --local-dir ${HOME}/models/Qwen/Qwen1.5-MoE-A2.7B-Chat
+#          export HF_HUB_OFFLINE=1
+      - name: Running Huggingface to Megatron dist_ckpt CPU converter (Qwen/Qwen1.5-MoE-A2.7B-Chat)
+        run: |
+          ray stop --force
+          python scripts/converter_hf_to_mcore.py --hf_model_path=${HOME}/models/Qwen/Qwen1.5-MoE-A2.7B-Chat --output_path checkpoints/Qwen/Qwen1.5-MoE-A2.7B-Chat --use_cpu_initialization
+      - name: Running distributed Huggingface to Megatron dist_ckpt CPU converter (Qwen/Qwen1.5-MoE-A2.7B-Chat)
+        run: |
+          ray stop --force
+          torchrun --nproc_per_node 8 --nnodes 1 scripts/converter_hf_to_mcore.py --hf_model_path=${HOME}/models/Qwen/Qwen1.5-MoE-A2.7B-Chat --output_path checkpoints/Qwen/Qwen1.5-MoE-A2.7B-Chat_dist --use_cpu_initialization
+      - name: clean up
+        run: |
+          rm -rf checkpoints
+
+  cleanup:
+    runs-on: ubuntu-latest
+    needs:
+      [
+        setup,
+        checkpoint_converter,
+        checkpoint_converter_large_moe_models
+      ]
+    if: always()
+    steps:
+      - id: destroy-runner
+        uses: volcengine/vemlp-github-runner@v1
+        with:
+          mode: "destroy"
+          faas-url: "${{ env.DYNAMIC_RUNNER_ENDPOINT }}"
+          mlp-task-id: "${{ needs.setup.outputs.mlp-task-id }}"

verl/.github/workflows/cpu_unit_tests.yml

@@ -0,0 +1,89 @@
+# # Tests layout
+
+# Each folder under tests/ corresponds to a test category for a sub-namespace in verl. For instance:
+# - `tests/trainer` for testing functionality related to `verl/trainer`
+# - `tests/models` for testing functionality related to `verl/models`
+# - ...
+
+# There are a few folders with `special_` prefix, created for special purposes:
+# - `special_distributed`: unit tests that must run with multiple GPUs
+# - `special_e2e`: end-to-end tests with training/generation scripts
+# - `special_npu`: tests for NPUs
+# - `special_sanity`: a suite of quick sanity tests
+# - `special_standalone`: a set of test that are designed to run in dedicated environments
+
+# Accelerators for tests 
+# - By default tests are run with GPU available, except for the ones under `special_npu`, and any test script whose name ends with `on_cpu.py`.
+# - For test scripts with `on_cpu.py` name suffix would be tested on CPU resources in linux environment.
+
+# # Workflow layout
+
+# All CI tests are configured by yaml files in `.github/workflows/`. Here's an overview of all test configs:
+# 1. A list of always triggered CPU sanity tests: `check-pr-title.yml`, `secrets_scan.yml`, `check-pr-title,yml`, `pre-commit.yml`, `doc.yml`
+# 2. Some heavy multi-GPU unit tests, such as `model.yml`, `vllm.yml`, `sgl.yml`
+# 3. End-to-end tests: `e2e_*.yml`
+# 4. Unit tests
+#   - `cpu_unit_tests.yml`, run pytest on all scripts with file name pattern `tests/**/test_*_on_cpu.py`
+#   - `gpu_unit_tests.yml`, run pytest on all scripts with file without the `on_cpu.py` suffix.
+#   - Since cpu/gpu unit tests by default runs all tests under `tests`, please make sure tests are manually excluded in them when
+#     - new workflow yaml is added to `.github/workflows`
+#     - new tests are added to workflow mentioned in 2.
+
+
+name: cpu_unit_tests
+
+on:
+  # Trigger the workflow on push or pull request,
+  # but only for the main branch
+  push:
+    branches:
+      - main
+      - v0.*
+  pull_request:
+    branches:
+      - main
+      - v0.*
+    paths:
+      - "**/*.py"
+      - .github/workflows/cpu_unit_tests.yml
+      - "!recipe/**/*.py"
+
+# Cancel jobs on the same ref if a new one is triggered
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: ${{ github.ref != 'refs/heads/main' }}
+
+# Declare permissions just read content.
+permissions:
+  contents: read
+
+jobs:
+  cpu_unit_tests:
+    if: github.repository_owner == 'volcengine'
+    runs-on: [L20x8]
+    timeout-minutes: 20 # Increase this timeout value as needed
+    env:
+      HTTP_PROXY: ${{ secrets.PROXY_HTTP }}
+      HTTPS_PROXY: ${{ secrets.PROXY_HTTPS }}
+      NO_PROXY: "localhost,127.0.0.1,hf-mirror.com"
+      HF_ENDPOINT: "https://hf-mirror.com"
+      HF_HUB_ENABLE_HF_TRANSFER: "0" # This is more stable
+    container:
+      image: verlai/verl:app-verl0.5-transformers4.55.4-vllm0.10.0-mcore0.13.0-te2.2
+    steps:
+      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+        with:
+          fetch-depth: 0
+      - name: Install the current repository
+        run: |
+          pip install -e .[test,prime,geo]
+          pip install --upgrade "ray>=2.40.0" pillow
+      - name: Download datasets
+        run: |
+          huggingface-cli download verl-team/gsm8k-v0.4.1 --repo-type dataset --local-dir ~/verl-data/gsm8k
+          python3 examples/data_preprocess/geo3k.py
+      - name: Running CPU unit tests
+        run: |
+          echo '[pytest]' > pytest.ini
+          echo 'python_files = *_on_cpu.py' >> pytest.ini
+          pytest -s -x --asyncio-mode=auto tests/

verl/.github/workflows/doc.yml

@@ -0,0 +1,100 @@
+# # Tests layout
+
+# Each folder under tests/ corresponds to a test category for a sub-namespace in verl. For instance:
+# - `tests/trainer` for testing functionality related to `verl/trainer`
+# - `tests/models` for testing functionality related to `verl/models`
+# - ...
+
+# There are a few folders with `special_` prefix, created for special purposes:
+# - `special_distributed`: unit tests that must run with multiple GPUs
+# - `special_e2e`: end-to-end tests with training/generation scripts
+# - `special_npu`: tests for NPUs
+# - `special_sanity`: a suite of quick sanity tests
+# - `special_standalone`: a set of test that are designed to run in dedicated environments
+
+# Accelerators for tests 
+# - By default tests are run with GPU available, except for the ones under `special_npu`, and any test script whose name ends with `on_cpu.py`.
+# - For test scripts with `on_cpu.py` name suffix would be tested on CPU resources in linux environment.
+
+# # Workflow layout
+
+# All CI tests are configured by yaml files in `.github/workflows/`. Here's an overview of all test configs:
+# 1. A list of always triggered CPU sanity tests: `check-pr-title.yml`, `secrets_scan.yml`, `check-pr-title,yml`, `pre-commit.yml`, `doc.yml`
+# 2. Some heavy multi-GPU unit tests, such as `model.yml`, `vllm.yml`, `sgl.yml`
+# 3. End-to-end tests: `e2e_*.yml`
+# 4. Unit tests
+#   - `cpu_unit_tests.yml`, run pytest on all scripts with file name pattern `tests/**/test_*_on_cpu.py`
+#   - `gpu_unit_tests.yml`, run pytest on all scripts with file without the `on_cpu.py` suffix.
+#   - Since cpu/gpu unit tests by default runs all tests under `tests`, please make sure tests are manually excluded in them when
+#     - new workflow yaml is added to `.github/workflows`
+#     - new tests are added to workflow mentioned in 2.
+
+
+name: doc_test
+
+on:
+  # Trigger the workflow on push or pull request,
+  # but only for the main branch
+  push:
+    branches:
+      - main
+      - v0.*
+  pull_request:
+    branches:
+      - main
+      - v0.*
+    paths:
+      - "**/*.py"
+      - "docs/**"
+      - .github/workflows/doc.yml
+
+# Cancel jobs on the same ref if a new one is triggered
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: ${{ github.ref != 'refs/heads/main' }}
+
+# Declare permissions just read content.
+permissions:
+  contents: read      # for checkout
+  pages: write        # for deploy-pages
+  id-token: write     # for deploy-pages
+
+jobs:
+  doc_test:
+    runs-on: ubuntu-latest
+    timeout-minutes: 5 # Increase this timeout value as needed
+    strategy:
+      matrix:
+        python-version: ["3.10"]
+    steps:
+      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+      - name: Set up Python ${{ matrix.python-version }}
+        uses: actions/setup-python@0b93645e9fea7318ecaed2b359559ac225c90a2b # v5.3.0
+        with:
+          python-version: ${{ matrix.python-version }}
+      - name: Install the current repository
+        run: |
+          pip install -e .[test] --no-deps
+          pip install -r docs/requirements-docs.txt
+
+      - name: Run doc make html
+        run: |
+          cd docs 
+          make clean
+          make html SPHINXOPTS="--keep-going -w _build/sphinx.log"
+          if grep -q ": ERROR:" _build/sphinx.log; then
+            echo "🚨 Sphinx doc build contained ERRORs - see _build/sphinx.log"
+            exit 1
+          fi
+          if grep -q "WARNING: document isn't included in any toctree" _build/sphinx.log; then
+            echo "🚨 Sphinx doc build contained WARNING. Please include newly added docs in index.rst. See _build/sphinx.log for details"
+            exit 1
+          fi
+          if grep -q "WARNING: Inline emphasis" _build/sphinx.log; then
+            echo "🚨 Sphinx doc build contained WARNING. Please check inline emphasis is correct. See _build/sphinx.log for details"
+            exit 1
+          fi
+          if grep -q "WARNING: Definition list ends without a blank line" _build/sphinx.log; then
+            echo "🚨 Sphinx doc build contained WARNING. Please check if the indentation is correct. See _build/sphinx.log for details"
+            exit 1
+          fi

verl/.github/workflows/e2e_ascend.yml

@@ -0,0 +1,156 @@
+# # Tests layout
+
+# Each folder under tests/ corresponds to a test category for a sub-namespace in verl. For instance:
+# - `tests/trainer` for testing functionality related to `verl/trainer`
+# - `tests/models` for testing functionality related to `verl/models`
+# - ...
+
+# There are a few folders with `special_` prefix, created for special purposes:
+# - `special_distributed`: unit tests that must run with multiple GPUs
+# - `special_e2e`: end-to-end tests with training/generation scripts
+# - `special_npu`: tests for NPUs
+# - `special_sanity`: a suite of quick sanity tests
+# - `special_standalone`: a set of test that are designed to run in dedicated environments
+
+# Accelerators for tests 
+# - By default tests are run with GPU available, except for the ones under `special_npu`, and any test script whose name ends with `on_cpu.py`.
+# - For test scripts with `on_cpu.py` name suffix would be tested on CPU resources in linux environment.
+
+# # Workflow layout
+
+# All CI tests are configured by yaml files in `.github/workflows/`. Here's an overview of all test configs:
+# 1. A list of always triggered CPU sanity tests: `check-pr-title.yml`, `secrets_scan.yml`, `check-pr-title,yml`, `pre-commit.yml`, `doc.yml`
+# 2. Some heavy multi-GPU unit tests, such as `model.yml`, `vllm.yml`, `sgl.yml`
+# 3. End-to-end tests: `e2e_*.yml`
+# 4. Unit tests
+#   - `cpu_unit_tests.yml`, run pytest on all scripts with file name pattern `tests/**/test_*_on_cpu.py`
+#   - `gpu_unit_tests.yml`, run pytest on all scripts with file without the `on_cpu.py` suffix.
+#   - Since cpu/gpu unit tests by default runs all tests under `tests`, please make sure tests are manually excluded in them when
+#     - new workflow yaml is added to `.github/workflows`
+#     - new tests are added to workflow mentioned in 2.
+
+
+name: e2e_ascend
+
+on:
+  # Trigger the workflow on push or pull request,
+  # but only for the main branch
+  push:
+    branches:
+      - main
+      - v0.*
+  pull_request:
+    branches:
+      - main
+    paths:
+      - ".github/workflows/e2e_ascend.yml"
+      - "**/*.py"
+      - "docs/ascend_tutorial/**"
+      - "examples/**"
+      - "recipe/**"
+      - "tests/special_npu/**"
+      - "tests/special_sanity/**"
+      - "verl/**"
+      - "pyproject.toml"
+      - "requirements-npu.txt"
+      - "setup.py"
+
+# Cancel jobs on the same ref if a new one is triggered
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: ${{ github.ref != 'refs/heads/main' }}
+
+permissions:
+  contents: read
+
+jobs:
+  test:
+    if: github.repository_owner == 'volcengine'
+    name: verl Ascend test (self-host)
+    runs-on: [self-hosted, npu-0]
+    timeout-minutes: 40 # Increase this timeout value as needed
+    container:
+      image: crispig/verl_npu:cann8.1rc1-py3.10-torch2.5.1-vllm-ascend0.7.3.post1-mindspeed0121-250731
+      volumes:
+        - /usr/local/dcmi:/usr/local/dcmi
+        - /usr/local/bin/npu-smi:/usr/local/bin/npu-smi
+        - /usr/local/Ascend/driver/lib64/:/usr/local/Ascend/driver/lib64/
+        - /usr/local/Ascend/driver/version.info:/usr/local/Ascend/driver/version.info
+        - /etc/ascend_install.info:/etc/ascend_install.info
+        - /data00/dataset:/github/home/dataset
+        - /data00/models:/github/home/models
+        # Use self-host cache speed up pip and model download
+        # - /home/action/actions-runner/_work/cache:/github/home/.cache/
+      options: >-
+        --device /dev/davinci0
+        --device /dev/davinci_manager
+        --device /dev/devmm_svm
+        --device /dev/hisi_hdc
+        --network host
+        --privileged
+        --shm-size 16g
+    env: 
+      HTTP_PROXY: ${{ secrets.PROXY_HTTP }}
+      HTTPS_PROXY: ${{ secrets.PROXY_HTTPS }}
+      NO_PROXY: "localhost,127.0.0.1,hf-mirror.com"
+      HF_ENDPOINT: "https://hf-mirror.com"
+      HF_HUB_ENABLE_HF_TRANSFER: "0" # This is more stable
+    steps:
+      - name: Check npu and CANN info
+        run: |
+          cat /usr/local/Ascend/ascend-toolkit/latest/"$(uname -i)"-linux/ascend_toolkit_install.info
+          npu-smi info
+      - name: Checkout volcengine/verl repo
+        uses: actions/checkout@v4
+      - name: Install the current repository
+        run: |
+          pip3 install hf_transfer peft
+          pip3 install -r requirements-npu.txt
+          pip install -e .
+      - name: Install torchvision
+        run: |
+          pip install torchvision==0.20.1+cpu --index-url https://download.pytorch.org/whl/cpu
+      - name: Uninstall Triton
+        run: |
+          pip uninstall -y triton
+      - name: Preprocess gsm8k dataset
+        run: |
+          python examples/data_preprocess/gsm8k.py --local_dataset_path ${HOME}/dataset/openai/gsm8k
+      - name: Preprocess geo3k dataset
+        run: |
+          python examples/data_preprocess/geo3k.py --local_dataset_path ${HOME}/dataset/hiyouga/geometry3k
+      - name: Running gsm8k e2e qwen3 training tests with PPO on ASCEND NPU
+        run: |
+          ray stop --force
+          bash tests/special_npu/run_qwen3_06b_ppo.sh
+          rm -rf $HOME/ckpts
+      - name: Running gsm8k e2e training tests with peft sft on ASCEND NPU
+        run: |
+          ray stop --force
+          bash tests/special_npu/run_qwen2_5_05b_sft_peft_sp2.sh
+          rm -rf $HOME/ckpts
+      - name: Running gsm8k e2e training tests with GRPO on ASCEND NPU
+        run: |
+          ray stop --force
+          bash tests/special_npu/run_qwen2_5_05b_grpo.sh
+          rm -rf $HOME/ckpts
+      - name: Running geo3k e2e training tests with GRPO on ASCEND NPU
+        run: |
+          ray stop --force
+          bash tests/special_npu/run_qwen2_5_vl_3b_npu.sh
+          rm -rf $HOME/ckpts
+      - name: Running gsm8k e2e training tests with DAPO on ASCEND NPU
+        run: |
+          ray stop --force
+          bash tests/special_npu/run_qwen2_5_05b_dapo.sh
+          rm -rf $HOME/ckpts
+      - name: Running gsm8k e2e training tests with GRPO MindSpeed on ASCEND NPU
+        run: |
+          ray stop --force
+          USE_DIST_CKPT=True bash tests/special_npu/run_qwen2_5_05b_grpo_mindspeed.sh
+          rm -rf $HOME/dist_ckpt/qwen2_5_05b_grpo_mindspeed
+          rm -rf $HOME/ckpts
+      - name: Running NPU profiling unit tests
+        run: |
+          ray stop --force
+          pytest -s -x tests/utils/test_special_mstx_profile.py

verl/.github/workflows/e2e_dapo.yml

@@ -0,0 +1,145 @@
+# # Tests layout
+
+# Each folder under tests/ corresponds to a test category for a sub-namespace in verl. For instance:
+# - `tests/trainer` for testing functionality related to `verl/trainer`
+# - `tests/models` for testing functionality related to `verl/models`
+# - ...
+
+# There are a few folders with `special_` prefix, created for special purposes:
+# - `special_distributed`: unit tests that must run with multiple GPUs
+# - `special_e2e`: end-to-end tests with training/generation scripts
+# - `special_npu`: tests for NPUs
+# - `special_sanity`: a suite of quick sanity tests
+# - `special_standalone`: a set of test that are designed to run in dedicated environments
+
+# Accelerators for tests 
+# - By default tests are run with GPU available, except for the ones under `special_npu`, and any test script whose name ends with `on_cpu.py`.
+# - For test scripts with `on_cpu.py` name suffix would be tested on CPU resources in linux environment.
+
+# # Workflow layout
+
+# All CI tests are configured by yaml files in `.github/workflows/`. Here's an overview of all test configs:
+# 1. A list of always triggered CPU sanity tests: `check-pr-title.yml`, `secrets_scan.yml`, `check-pr-title,yml`, `pre-commit.yml`, `doc.yml`
+# 2. Some heavy multi-GPU unit tests, such as `model.yml`, `vllm.yml`, `sgl.yml`
+# 3. End-to-end tests: `e2e_*.yml`
+# 4. Unit tests
+#   - `cpu_unit_tests.yml`, run pytest on all scripts with file name pattern `tests/**/test_*_on_cpu.py`
+#   - `gpu_unit_tests.yml`, run pytest on all scripts with file without the `on_cpu.py` suffix.
+#   - Since cpu/gpu unit tests by default runs all tests under `tests`, please make sure tests are manually excluded in them when
+#     - new workflow yaml is added to `.github/workflows`
+#     - new tests are added to workflow mentioned in 2.
+
+
+name: e2e_dapo
+
+on:
+  # Trigger the workflow on push or pull request,
+  # but only for the main branch
+  # For push, for now only anti-patterns are specified so it is more conservative
+  # and achieves higher coverage.
+  push:
+    branches:
+      - main
+      - v0.*
+    paths:
+      - "verl/*.py"
+      # Other entrypoints
+      - "!examples/*trainer*"
+      - "!tests/**"
+      - "!verl/trainer/main_*.py"
+      - "!verl/trainer/fsdp_sft_trainer.py"
+      # Megatron
+      - "!verl/workers/**/megatron_*.py"
+      - "!recipe/**"
+      - "recipe/dapo"
+  pull_request:
+    branches:
+      - main
+      - v0.*
+    paths:
+      - "**/*.py"
+      # Other entrypoints
+      - "!examples/**"
+      - "!tests/**"
+      - "!verl/trainer/main_*.py"
+      - "!verl/trainer/fsdp_sft_trainer.py"
+      # Other recipes
+      - "!recipe/**"
+      # Megatron
+      - "!verl/workers/**/megatron_*.py"
+      # Home
+      - "recipe/dapo"
+      # Entrypoints
+      - ".github/workflows/e2e_dapo.yml"
+      - "examples/data_preprocess/gsm8k.py"
+      - "tests/special_e2e/run_dapo.sh"
+
+# Cancel jobs on the same ref if a new one is triggered
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: ${{ github.ref != 'refs/heads/main' }}
+
+# Declare permissions just read content.
+permissions:
+  contents: read
+
+env:
+  IMAGE: "verl-ci-cn-beijing.cr.volces.com/verlai/verl:app-verl0.5-transformers4.55.4-vllm0.10.0-mcore0.13.0-te2.2"
+  DYNAMIC_RUNNER_ENDPOINT: "https://sd10g3clalm04ug7alq90.apigateway-cn-beijing.volceapi.com/runner"
+
+jobs:
+  setup:
+    if: github.repository_owner == 'volcengine'
+    runs-on: ubuntu-latest
+    outputs:
+      runner-label: ${{ steps.create-runner.outputs.runner-label }}
+      mlp-task-id: ${{ steps.create-runner.outputs.mlp-task-id }}
+    steps:
+      - uses: actions/checkout@v4
+      - id: create-runner
+        uses: volcengine/vemlp-github-runner@v1
+        with:
+          mode: "create"
+          faas-url: "${{ env.DYNAMIC_RUNNER_ENDPOINT }}"
+          mlp-image: "${{ env.IMAGE }}"
+
+  e2e_dapo:
+    needs: setup
+    runs-on: [ "${{ needs.setup.outputs.runner-label || 'L20x8' }}" ]
+    timeout-minutes: 40 # Increase this timeout value as needed
+    env:
+      HTTP_PROXY: ${{ secrets.PROXY_HTTP }}
+      HTTPS_PROXY: ${{ secrets.PROXY_HTTPS }}
+      NO_PROXY: "localhost,127.0.0.1,hf-mirror.com"
+      HF_ENDPOINT: "https://hf-mirror.com"
+      HF_HUB_ENABLE_HF_TRANSFER: "0" # This is more stable
+    steps:
+      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+        with:
+          fetch-depth: 0
+      - name: Install the current repository
+        run: |
+          pip3 install --no-deps -e .[test,gpu]
+      - name: Prepare GSM8K dataset
+        run: |
+          python3 examples/data_preprocess/gsm8k.py --local_dataset_path ${HOME}/models/hf_data/gsm8k
+      - name: Running the E2E test with the DAPO algorithm
+        run: |
+          ray stop --force
+          bash tests/special_e2e/run_dapo.sh
+
+  cleanup:
+    runs-on: ubuntu-latest
+    needs:
+      [
+        setup,
+        e2e_dapo
+      ]
+    if: always()
+    steps:
+      - id: destroy-runner
+        uses: volcengine/vemlp-github-runner@v1
+        with:
+          mode: "destroy"
+          faas-url: "${{ env.DYNAMIC_RUNNER_ENDPOINT }}"
+          mlp-task-id: "${{ needs.setup.outputs.mlp-task-id }}"

verl/.github/workflows/e2e_genrm_remote.yml

@@ -0,0 +1,138 @@
+# # Tests layout
+
+# Each folder under tests/ corresponds to a test category for a sub-namespace in verl. For instance:
+# - `tests/trainer` for testing functionality related to `verl/trainer`
+# - `tests/models` for testing functionality related to `verl/models`
+# - ...
+
+# There are a few folders with `special_` prefix, created for special purposes:
+# - `special_distributed`: unit tests that must run with multiple GPUs
+# - `special_e2e`: end-to-end tests with training/generation scripts
+# - `special_npu`: tests for NPUs
+# - `special_sanity`: a suite of quick sanity tests
+# - `special_standalone`: a set of test that are designed to run in dedicated environments
+
+# Accelerators for tests 
+# - By default tests are run with GPU available, except for the ones under `special_npu`, and any test script whose name ends with `on_cpu.py`.
+# - For test scripts with `on_cpu.py` name suffix would be tested on CPU resources in linux environment.
+
+# # Workflow layout
+
+# All CI tests are configured by yaml files in `.github/workflows/`. Here's an overview of all test configs:
+# 1. A list of always triggered CPU sanity tests: `check-pr-title.yml`, `secrets_scan.yml`, `check-pr-title,yml`, `pre-commit.yml`, `doc.yml`
+# 2. Some heavy multi-GPU unit tests, such as `model.yml`, `vllm.yml`, `sgl.yml`
+# 3. End-to-end tests: `e2e_*.yml`
+# 4. Unit tests
+#   - `cpu_unit_tests.yml`, run pytest on all scripts with file name pattern `tests/**/test_*_on_cpu.py`
+#   - `gpu_unit_tests.yml`, run pytest on all scripts with file without the `on_cpu.py` suffix.
+#   - Since cpu/gpu unit tests by default runs all tests under `tests`, please make sure tests are manually excluded in them when
+#     - new workflow yaml is added to `.github/workflows`
+#     - new tests are added to workflow mentioned in 2.
+
+
+name: e2e_genrm_remote
+
+on:
+  # Trigger the workflow on push or pull request,
+  # but only for the main branch
+  push:
+    branches:
+      - main
+      - v0.*
+    paths:
+      - "**/*.py"
+      - "tests/**"
+      - "!recipe/**"
+      - "recipe/genrm_remote"
+  pull_request:
+    branches:
+      - main
+      - v0.*
+    paths:
+      - "**/*.py"
+      # Other entrypoints
+      - "!examples/**"
+      - "!tests/**"
+      - "!verl/trainer/main_*.py"
+      - "!verl/trainer/fsdp_sft_trainer.py"
+      # Other recipes
+      - "!recipe/**"
+      # Megatron
+      - "!verl/workers/**/megatron_*.py"
+      # Home
+      - "recipe/genrm_remote"
+      - "!recipe/genrm_remote/README.md"
+      # Entrypoints
+      - ".github/workflows/e2e_genrm_remote.yml"
+      - "examples/data_preprocess/gsm8k.py"
+      - "tests/special_e2e/run_genrm_remote.sh"
+
+# Cancel jobs on the same ref if a new one is triggered
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: ${{ github.ref != 'refs/heads/main' }}
+
+# Declare permissions just read content.
+permissions:
+  contents: read
+
+env:
+  IMAGE: "verl-ci-cn-beijing.cr.volces.com/verlai/verl:app-verl0.5-transformers4.55.4-vllm0.10.0-mcore0.13.0-te2.2"
+  DYNAMIC_RUNNER_ENDPOINT: "https://sd10g3clalm04ug7alq90.apigateway-cn-beijing.volceapi.com/runner"
+
+jobs:
+  setup:
+    if: github.repository_owner == 'volcengine'
+    runs-on: ubuntu-latest
+    outputs:
+      runner-label: ${{ steps.create-runner.outputs.runner-label }}
+      mlp-task-id: ${{ steps.create-runner.outputs.mlp-task-id }}
+    steps:
+      - uses: actions/checkout@v4
+      - id: create-runner
+        uses: volcengine/vemlp-github-runner@v1
+        with:
+          mode: "create"
+          faas-url: "${{ env.DYNAMIC_RUNNER_ENDPOINT }}"
+          mlp-image: "${{ env.IMAGE }}"
+
+  e2e_genrm_remote:
+    needs: setup
+    runs-on: [ "${{ needs.setup.outputs.runner-label || 'L20x8' }}" ]
+    timeout-minutes: 40 # Increase this timeout value as needed
+    env:
+      HTTP_PROXY: ${{ secrets.PROXY_HTTP }}
+      HTTPS_PROXY: ${{ secrets.PROXY_HTTPS }}
+      NO_PROXY: "localhost,127.0.0.1,hf-mirror.com"
+      HF_ENDPOINT: "https://hf-mirror.com"
+      HF_HUB_ENABLE_HF_TRANSFER: "0" # This is more stable
+    steps:
+      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+        with:
+          fetch-depth: 0
+      - name: Install the current repository
+        run: |
+          pip3 install --no-deps -e .[test,gpu]
+      - name: Prepare GSM8K dataset
+        run: |
+          python3 examples/data_preprocess/gsm8k.py --local_dataset_path ${HOME}/models/hf_data/gsm8k
+      - name: Running the E2E test with the Generative Reward Model
+        run: |
+          ray stop --force
+          bash tests/special_e2e/run_genrm_remote.sh
+
+  cleanup:
+    runs-on: ubuntu-latest
+    needs:
+      [
+        setup,
+        e2e_genrm_remote
+      ]
+    if: always()
+    steps:
+      - id: destroy-runner
+        uses: volcengine/vemlp-github-runner@v1
+        with:
+          mode: "destroy"
+          faas-url: "${{ env.DYNAMIC_RUNNER_ENDPOINT }}"
+          mlp-task-id: "${{ needs.setup.outputs.mlp-task-id }}"