From 7e5c136bda0d5a5344a6ba2bf59960ab7ed53a1a Mon Sep 17 00:00:00 2001 From: Joy Liu Date: Mon, 31 Aug 2026 14:09:57 -0400 Subject: [PATCH 1/7] :new: Add balatrobot rl --- balatro_modal.py | 530 ++++++++++++++ batro_modal_rl.py | 1759 +++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 2289 insertions(+) create mode 100644 balatro_modal.py create mode 100644 batro_modal_rl.py diff --git a/balatro_modal.py b/balatro_modal.py new file mode 100644 index 00000000..7c129d14 --- /dev/null +++ b/balatro_modal.py @@ -0,0 +1,530 @@ +"""Package Balatro + BalatroBot into a Modal image. + +The Balatro game itself is *not* redistributable, so it is never baked into a +public layer: the ``.love`` archive is read from your local Steam install at +build time and copied into your own private Modal image. + +The image runs the game headless on Linux via the native LOVE launcher +(``love `` with ``liblovely.so`` LD_PRELOADed), which is the +combination BalatroBot's ``NativeLauncher`` expects. + +Usage:: + + modal run balatro_modal.py # build + smoke test + modal run balatro_modal.py::demo_run # start a run, print gamestate + +From training-gym (or any other Modal app):: + + from balatro_modal import balatro_image, BalatroEnv +""" + +from __future__ import annotations + +import os +from pathlib import Path + +import modal + +# --- Pinned dependency versions ------------------------------------------- + +LOVE_VERSION = "11.5" # the LOVE version Balatro is built against +LOVELY_VERSION = "0.9.0" # >= 0.8.0 required by BalatroBot +SMODS_VERSION = "1.0.0-beta-1814a" # >= 1.0.0-beta-1221a required by BalatroBot + +# --- Paths inside the image ----------------------------------------------- + +GAME_DIR = "/opt/balatro/game" # unpacked Balatro.love +MODS_DIR = "/opt/balatro/Mods" # smods + balatrobot +LOVELY_SO = "/usr/local/lib/liblovely.so" +LOVE_APPIMAGE_DIR = "/opt/love" # extracted upstream AppImage +# Lovely derives its Mods directory from the *name* of the running executable +# (`/root/.local/share//Mods`). +LOVE_BIN = "/opt/balatro/bin/love" +LOVE_BIN_NAME = "love" +LOVE_WRAPPER = "/usr/local/bin/balatro-love" # love + on-demand Xvfb +LOGS_DIR = "/tmp/balatrobot-logs" +# LOVE derives its save directory from the game's identity, which Balatro's +# conf.lua leaves unset - it relies on being a fused build. `conf.lua` is +# patched below so the location is the same one a real install uses. +SAVE_IDENTITY = "Balatro" +SAVE_DIR = f"/root/.local/share/love/{SAVE_IDENTITY}" + +REPO = Path(__file__).parent + +# --- Locating the local Balatro.love -------------------------------------- + +# `Balatro.love` is a plain zip of Lua + assets and is platform independent, so +# the macOS copy runs fine in the Linux image. +LOVE_ARCHIVE_CANDIDATES = ( + Path.home() + / "Library/Application Support/Steam/steamapps/common/Balatro" + / "Balatro.app/Contents/Resources/Balatro.love", + Path.home() / ".local/share/Steam/steamapps/common/Balatro/Balatro.love", + Path.home() / ".steam/steam/steamapps/common/Balatro/Balatro.love", +) + + +def find_balatro_love() -> Path: + """Locate the local Balatro.love archive. + + Override with ``BALATRO_LOVE_ARCHIVE=/path/to/Balatro.love``. + """ + if override := os.environ.get("BALATRO_LOVE_ARCHIVE"): + path = Path(override).expanduser() + if not path.is_file(): + raise FileNotFoundError(f"BALATRO_LOVE_ARCHIVE does not exist: {path}") + return path + + for candidate in LOVE_ARCHIVE_CANDIDATES: + if candidate.is_file(): + return candidate + + searched = "\n ".join(str(c) for c in LOVE_ARCHIVE_CANDIDATES) + raise FileNotFoundError( + "Could not find Balatro.love. Install Balatro via Steam, or set " + f"BALATRO_LOVE_ARCHIVE.\nSearched:\n {searched}" + ) + + +SAVE_DIR_CANDIDATES = ( + Path.home() / "Library/Application Support/Balatro", # macOS + Path.home() / ".local/share/love/Balatro", # Linux +) + + +def find_balatro_save() -> Path: + """Locate the local Balatro save directory. + + Balatro crashes on a profile that has never been through its first-run + setup (`game.lua`: `G.SETTINGS.tutorial_progress` is nil at the main menu), + so the container starts from the same `settings.jkr` and profile a real + install has. Override with ``BALATRO_SAVE_DIR``. + """ + if override := os.environ.get("BALATRO_SAVE_DIR"): + path = Path(override).expanduser() + else: + path = next( + (c for c in SAVE_DIR_CANDIDATES if (c / "settings.jkr").is_file()), + None, + ) + + if path is None or not (path / "settings.jkr").is_file(): + searched = "\n ".join(str(c) for c in SAVE_DIR_CANDIDATES) + raise FileNotFoundError( + "No Balatro save data found. Launch Balatro once so it creates a " + f"profile, or set BALATRO_SAVE_DIR.\nSearched:\n {searched}" + ) + return path + + +# --- Image ---------------------------------------------------------------- + +# Lovely resolves the Mods directory from LOVE's save/config directories, which +# vary with the game's identity; symlink every candidate at the one real dir. +_MOD_DIR_LINKS = ( + f"/root/.local/share/{LOVE_BIN_NAME}/Mods", # what Lovely actually uses + "/root/.config/love/Mods", + f"{GAME_DIR}/Mods", +) + +# LOVE needs a GL context even when BalatroBot hides the window, so bring up a +# throwaway X server (software rendering) on first launch. Xvfb itself must not +# inherit LD_PRELOAD=liblovely.so - Lovely only belongs in the game process. +_LOVE_WRAPPER_SCRIPT = f"""#!/bin/sh +set -e + +# Lovely belongs in the game process only - not in this shell, Xvfb, or any +# helper it spawns. +LOVELY_PRELOAD="$LD_PRELOAD" +unset LD_PRELOAD + +DISPLAY_NUM="${{BALATRO_DISPLAY:-99}}" +if ! xdpyinfo -display ":$DISPLAY_NUM" >/dev/null 2>&1; then + Xvfb ":$DISPLAY_NUM" -screen 0 1280x720x24 -nolisten tcp >/tmp/xvfb.log 2>&1 & + i=0 + while [ "$i" -lt 100 ]; do + xdpyinfo -display ":$DISPLAY_NUM" >/dev/null 2>&1 && break + i=$((i + 1)) + sleep 0.1 + done +fi + +export DISPLAY=":$DISPLAY_NUM" +export LD_LIBRARY_PATH="{LOVE_APPIMAGE_DIR}/lib:${{LD_LIBRARY_PATH:-}}" +export LD_PRELOAD="$LOVELY_PRELOAD" +exec {LOVE_BIN} "$@" +""" + +_base_image = ( + # Debian trixie ships LOVE 11.5, the version Balatro is built against. + modal.Image.from_registry("debian:trixie-slim", add_python="3.12") + # `debian:*-slim` drops man pages via a dpkg path-exclude, but LOVE's + # postinst registers `love-11.5.6.gz` with update-alternatives and fails + # when it is missing. Keep man pages for packages installed here. + .run_commands( + "sed -i '/path-exclude.*man/d' /etc/dpkg/dpkg.cfg.d/* 2>/dev/null || true", + "rm -f /etc/dpkg/dpkg.cfg.d/docker", + ) + .apt_install( + "love", # not used directly - pulls in LOVE's runtime dependencies + "xvfb", # virtual display + "x11-utils", # xdpyinfo, used to wait for Xvfb + "libgl1-mesa-dri", # llvmpipe software GL + "ca-certificates", + "curl", + "git", + "unzip", + "procps", + ) + # Upstream LOVE build. Debian's `love` statically links PhysFS without + # exporting its symbols, and Steamodded's nativefs resolves PHYSFS_* through + # LuaJIT's FFI at runtime - it only works against the upstream build. + .run_commands( + "curl -fsSL -o /tmp/love.AppImage https://github.com/love2d/love/releases" + f"/download/{LOVE_VERSION}/love-{LOVE_VERSION}-x86_64.AppImage", + "chmod +x /tmp/love.AppImage", + "cd /tmp && ./love.AppImage --appimage-extract >/dev/null", + f"mv /tmp/squashfs-root {LOVE_APPIMAGE_DIR}", + "rm -f /tmp/love.AppImage", + ) + # Lovely Injector + .run_commands( + "curl -fsSL -o /tmp/lovely.tar.gz " + "https://github.com/ethangreen-dev/lovely-injector/releases/download/" + f"v{LOVELY_VERSION}/lovely-x86_64-unknown-linux-gnu.tar.gz", + "tar xzf /tmp/lovely.tar.gz -C /tmp", + f"install -m 755 /tmp/liblovely.so {LOVELY_SO}", + "rm -rf /tmp/lovely.tar.gz /tmp/liblovely.so", + ) + # Steamodded + Mods directory layout + .run_commands( + f"mkdir -p {MODS_DIR} {GAME_DIR} /opt/balatro/bin " + f"/root/.config/love /root/.local/share/{LOVE_BIN_NAME}", + # The AppImage's own layout varies by release; pin a stable path to it. + f"ln -sfn $(find {LOVE_APPIMAGE_DIR} -type f -name love -perm -u+x | head -1)" + f" {LOVE_BIN}", + "git clone --depth 1 --branch " + f"{SMODS_VERSION} https://github.com/Steamodded/smods.git {MODS_DIR}/smods", + *(f"ln -sfn {MODS_DIR} {link}" for link in _MOD_DIR_LINKS), + ) +) + + +def _add_local_content(image: modal.Image) -> modal.Image: + """Layers built from files on this machine: the game and this repo. + + Guarded by `modal.is_local()` below - containers re-import this module with + the image already built, and neither the Steam install nor the repo is + present there. + """ + return ( + image + # The game itself, from the local Steam install. NativeLauncher runs + # `love `, so the archive is expanded rather than passed as .love. + .add_local_file(find_balatro_love(), "/opt/balatro/Balatro.love", copy=True) + .run_commands( + f"unzip -q /opt/balatro/Balatro.love -d {GAME_DIR}", + # A packaged Balatro binary is "fused", which implicitly gives it + # the Balatro save identity. Running the portable .love directory + # does not, so set the same identity explicitly or settings.jkr is + # never found and the main menu crashes on tutorial_progress. + f"sed -i \"/t.title = 'Balatro'/a\\\\\\tt.identity = '{SAVE_IDENTITY}'\" " + f"{GAME_DIR}/conf.lua", + "rm /opt/balatro/Balatro.love", + ) + # A real install's settings + profile, so the game boots past its + # first-run tutorial state. + .add_local_file( + find_balatro_save() / "settings.jkr", f"{SAVE_DIR}/settings.jkr", copy=True + ) + .add_local_file( + find_balatro_save() / "1/profile.jkr", + f"{SAVE_DIR}/1/profile.jkr", + copy=True, + ) + .add_local_file( + find_balatro_save() / "1/meta.jkr", f"{SAVE_DIR}/1/meta.jkr", copy=True + ) + # BalatroBot: the Lua mod... + .add_local_file( + REPO / "balatrobot.json", + f"{MODS_DIR}/balatrobot/balatrobot.json", + copy=True, + ) + .add_local_file( + REPO / "balatrobot.lua", + f"{MODS_DIR}/balatrobot/balatrobot.lua", + copy=True, + ) + .add_local_dir(REPO / "src/lua", f"{MODS_DIR}/balatrobot/src/lua", copy=True) + # ...and the Python package that launches and drives the game + .add_local_dir(REPO / "src/balatrobot", "/opt/balatrobot/balatrobot", copy=True) + ) + + +balatro_image = _base_image +if modal.is_local(): + balatro_image = _add_local_content(balatro_image) + +balatro_image = ( + balatro_image.pip_install("httpx", "typer") + # LOVE launcher wrapper + .run_commands( + f"cat > {LOVE_WRAPPER} <<'BALATRO_LOVE_EOF'\n{_LOVE_WRAPPER_SCRIPT}\nBALATRO_LOVE_EOF", + f"chmod +x {LOVE_WRAPPER}", + ) + .env( + { + "PYTHONPATH": "/opt/balatrobot", + "BALATROBOT_PLATFORM": "native", + "BALATROBOT_BALATRO_PATH": GAME_DIR, + "BALATROBOT_LOVE_PATH": LOVE_WRAPPER, + "BALATROBOT_LOVELY_PATH": LOVELY_SO, + "BALATROBOT_LOGS_PATH": LOGS_DIR, + "BALATROBOT_HEADLESS": "1", + "BALATROBOT_FAST": "1", + "BALATROBOT_AUDIO": "0", + "BALATROBOT_NO_SHADERS": "1", + "LIBGL_ALWAYS_SOFTWARE": "1", + "SDL_AUDIODRIVER": "dummy", + # LOVE plays audio through OpenAL Soft, which ignores + # SDL_AUDIODRIVER and otherwise fails on a container's absent ALSA. + "ALSOFT_DRIVERS": "null", + } + ) +) + + +app = modal.App("balatro-env", image=balatro_image) + + +# --- Environment ---------------------------------------------------------- + + +@app.cls(image=balatro_image, timeout=60 * 60, scaledown_window=60) +class BalatroEnv: + """One long-lived Balatro process, driven over BalatroBot's JSON-RPC API. + + This is the unit a rollout worker holds: `call()` maps 1:1 onto the API's + endpoints (`start`, `play`, `discard`, `gamestate`, ...). + """ + + @modal.enter() + def start_game(self) -> None: + import asyncio + + from balatrobot.manager import BalatroInstance + + self._loop = asyncio.new_event_loop() + self._instance = BalatroInstance() + self._loop.run_until_complete(self._instance.start()) + + @modal.exit() + def stop_game(self) -> None: + self._loop.run_until_complete(self._instance.stop()) + self._loop.close() + + @modal.method() + def call(self, method: str, params: dict | None = None) -> dict: + """Call a BalatroBot endpoint and return its JSON-RPC `result`.""" + import httpx + + payload = { + "jsonrpc": "2.0", + "method": method, + "params": params or {}, + "id": 1, + } + response = httpx.post( + f"http://127.0.0.1:{self._instance.port}", json=payload, timeout=60.0 + ) + data = response.json() + if "error" in data: + raise RuntimeError(f"{method} failed: {data['error']}") + return data["result"] + + @modal.method() + def game_log(self, tail: int = 40) -> str: + """Tail the game's log file - the first place to look when a call fails.""" + log_path = self._instance.log_path + if log_path is None or not log_path.exists(): + return "(no log file)" + return "\n".join(log_path.read_text().splitlines()[-tail:]) + + +# --- Smoke tests ---------------------------------------------------------- + + +@app.function(image=balatro_image, timeout=600) +def check_image() -> dict[str, str]: + """Verify the image layout without launching the game.""" + import subprocess + + def sh(cmd: str) -> str: + return subprocess.run( + cmd, shell=True, capture_output=True, text=True + ).stdout.strip() + + return { + "love": sh(f"LD_LIBRARY_PATH={LOVE_APPIMAGE_DIR}/lib {LOVE_BIN} --version"), + "lovely": sh(f"ls -la {LOVELY_SO}"), + "game_files": sh(f"ls {GAME_DIR} | head -5 | tr '\\n' ' '"), + "mods": sh(f"ls {MODS_DIR} | tr '\\n' ' '"), + "mod_links": sh(f"ls -ld {' '.join(_MOD_DIR_LINKS)} | tr '\\n' ' '"), + "love_bin": sh( + f"ls -la {LOVE_BIN} && " + f"LD_LIBRARY_PATH={LOVE_APPIMAGE_DIR}/lib ldd {LOVE_BIN} | grep liblove" + ), + "balatrobot": sh("python -c 'import balatrobot; print(balatrobot.__file__)'"), + } + + +@app.function(image=balatro_image, timeout=900) +def smoke_test() -> str: + """Boot the game, hit the API, and report what the mod loaded.""" + import asyncio + + import httpx + + from balatrobot.manager import BalatroInstance + + def read_log(instance) -> str: + log = instance.log_path + return log.read_text() if log and log.exists() else "(no log file)" + + async def main() -> str: + instance = BalatroInstance() + try: + await instance.start() + except Exception as exc: # noqa: BLE001 - report, don't re-raise + return f"FAILED to start: {exc!r}\n\n--- game log ---\n{read_log(instance)[-6000:]}" + + try: + async with httpx.AsyncClient(timeout=30.0) as client: + response = await client.post( + f"http://127.0.0.1:{instance.port}", + json={"jsonrpc": "2.0", "method": "health", "id": 1}, + ) + health = str(response.json()) + except Exception as exc: # noqa: BLE001 + health = f"health call failed: {exc!r}" + finally: + log_text = read_log(instance) + await instance.stop() + + interesting = [ + line + for line in log_text.splitlines() + if any( + marker in line + for marker in ("BalatroBot", "Steamodded v", "Lovely", "ERROR", "Error") + ) + ] + return "health: {}\n{}".format(health, "\n".join(interesting[-25:])) + + return asyncio.run(main()) + + +@app.function(image=balatro_image, timeout=1800) +def demo_run(steps: int = 60) -> dict: + """Drive a scripted run for `steps` actions and report where it ended up. + + Not a policy - it always plays the first five cards in hand - but it + exercises every phase transition a rollout has to survive: blind select, + hands, cash out, shop, booster packs. + """ + import asyncio + + import httpx + + from balatrobot.manager import BalatroInstance + + # Phases the game moves through on its own (animations); just wait them out. + TRANSIENT = {"HAND_PLAYED", "DRAW_TO_HAND", "NEW_ROUND", "GAME_OVER"} + + async def main() -> dict: + instance = BalatroInstance() + await instance.start() + url = f"http://127.0.0.1:{instance.port}" + history: list[str] = [] + errors: list[str] = [] + + try: + async with httpx.AsyncClient(timeout=120.0) as client: + + async def call(method: str, params: dict | None = None) -> dict: + response = await client.post( + url, + json={ + "jsonrpc": "2.0", + "method": method, + "params": params or {}, + "id": 1, + }, + ) + data = response.json() + if "error" in data: + raise RuntimeError(f"{method}: {data['error']}") + return data["result"] + + state = await call( + "start", {"deck": "RED", "stake": "WHITE", "seed": "BALATRO"} + ) + + for _ in range(steps): + phase = state.get("state") + + try: + if phase == "BLIND_SELECT": + state = await call("select") + elif phase == "SELECTING_HAND": + hand = state.get("hand") or [] + if not hand: + break + cards = list(range(min(5, len(hand)))) + state = await call("play", {"cards": cards}) + elif phase == "ROUND_EVAL": + state = await call("cash_out") + elif phase == "SHOP": + state = await call("next_round") + elif phase == "TAROT_PACK" or phase.endswith("_PACK"): + state = await call("pack", {"skip": True}) + elif phase in TRANSIENT: + await asyncio.sleep(0.25) + state = await call("gamestate") + continue + else: + errors.append(f"unhandled phase {phase}") + break + except RuntimeError as exc: + errors.append(str(exc)) + break + + history.append(phase) + if state.get("won") or state.get("state") == "GAME_OVER": + break + finally: + await instance.stop() + + summary = { + "final_state": state.get("state"), + "ante": state.get("ante_num"), + "round": state.get("round_num"), + "money": state.get("money"), + "actions": len(history), + "phases_visited": sorted(set(history)), + "errors": errors, + } + print(summary) + return summary + + return asyncio.run(main()) + + +@app.local_entrypoint() +def main() -> None: + print("--- image layout ---") + for key, value in check_image.remote().items(): + print(f"{key}: {value}") + print("\n--- boot + health ---") + print(smoke_test.remote()) diff --git a/batro_modal_rl.py b/batro_modal_rl.py new file mode 100644 index 00000000..4cebccea --- /dev/null +++ b/batro_modal_rl.py @@ -0,0 +1,1759 @@ +"""Train a Balatro policy with Training Gym and one Modal Sandbox per game. + +The macOS ``Balatro.love`` archive is platform independent, but the executable +is not. This file uploads the private game assets to a Modal Volume and runs +them with the official Linux LOVE 11.5 build. Each rollout gets its own +Sandbox, so concurrent games never share a Balatro process or save directory. + +Safe workflow (from the Training Gym Python 3.12 environment):: + + python batro_modal_rl.py --prepare-assets + python batro_modal_rl.py --smoke-env + python batro_modal_rl.py --profile proof --launch + +The first two commands use CPU containers only. Training is never launched +unless ``--launch`` is passed explicitly. +""" + +from __future__ import annotations + +import argparse +import asyncio +import json +import math +import os +import re +import tempfile +import time +from copy import deepcopy +from pathlib import Path +from typing import Any + +import modal +from modal_training_gym import ( + DatasetConfig, + Qwen3_4B, + Qwen3_8_27B, + Qwen3_8_27b_Recipe, + SlimeRecipe, + TrainConfig, +) +from modal_training_gym.common.environments.base import ( + Observation, + SandboxEnvironment, + SandboxEnvironmentPool, + StepResult, +) +from modal_training_gym.common.models.base import ToolCall +from pydantic import ConfigDict +from pydantic.dataclasses import dataclass + +# --------------------------------------------------------------------------- +# Private assets: local Mac -> private Modal Volume +# --------------------------------------------------------------------------- + +LOVE_VERSION = "11.5" +LOVELY_VERSION = "0.9.0" +SMODS_VERSION = "1.0.0-beta-1814a" + +ASSET_VOLUME_NAME = "balatro-rl-assets" +ASSET_MOUNT = "/opt/balatro-assets" +ASSET_APP_NAME = "balatro-rl-assets" +SANDBOX_APP_NAME = "balatro-rl-sandboxes" + +REPO = Path(__file__).resolve().parent + +LOVE_ARCHIVE_CANDIDATES = ( + Path.home() + / "Library/Application Support/Steam/steamapps/common/Balatro" + / "Balatro.app/Contents/Resources/Balatro.love", + Path.home() / ".local/share/Steam/steamapps/common/Balatro/Balatro.love", + Path.home() / ".steam/steam/steamapps/common/Balatro/Balatro.love", +) +SAVE_DIR_CANDIDATES = ( + Path.home() / "Library/Application Support/Balatro", + Path.home() / ".local/share/love/Balatro", +) + + +def _find_balatro_love() -> Path: + if override := os.environ.get("BALATRO_LOVE_ARCHIVE"): + path = Path(override).expanduser() + if path.is_file(): + return path + raise FileNotFoundError(f"BALATRO_LOVE_ARCHIVE does not exist: {path}") + for path in LOVE_ARCHIVE_CANDIDATES: + if path.is_file(): + return path + raise FileNotFoundError( + "Could not find Balatro.love. Install Balatro with Steam or set " + "BALATRO_LOVE_ARCHIVE." + ) + + +def _find_balatro_save() -> Path: + if override := os.environ.get("BALATRO_SAVE_DIR"): + path = Path(override).expanduser() + else: + path = next( + (p for p in SAVE_DIR_CANDIDATES if (p / "settings.jkr").is_file()), + None, + ) + if path is None or not (path / "settings.jkr").is_file(): + raise FileNotFoundError( + "No Balatro settings.jkr found. Launch Balatro once or set " + "BALATRO_SAVE_DIR." + ) + for relative in ("1/profile.jkr", "1/meta.jkr"): + if not (path / relative).is_file(): + raise FileNotFoundError(f"Balatro save is missing {relative}: {path}") + return path + + +assets_app = modal.App(ASSET_APP_NAME) +asset_volume = modal.Volume.from_name(ASSET_VOLUME_NAME, create_if_missing=True) +asset_seed_image = modal.Image.debian_slim(python_version="3.12") + + +@assets_app.function( + image=asset_seed_image, + volumes={"/assets": asset_volume}, + timeout=15 * 60, + serialized=True, + include_source=False, +) +def prepare_assets(release: str, upload_id: str) -> dict[str, Any]: + """Publish a content-addressed Balatro release to the private Volume.""" + import shutil + import uuid + import zipfile + + releases = Path("/assets/releases") + destination = releases / release + releases.mkdir(parents=True, exist_ok=True) + reused = destination.exists() + + if not reused: + seed = Path("/assets/uploads") / upload_id + if not upload_id or not seed.is_dir(): + raise FileNotFoundError(f"Asset upload is missing: {seed}") + staging = Path(f"/assets/.staging-{release}-{uuid.uuid4().hex[:8]}") + game = staging / "game" + game.mkdir(parents=True) + with zipfile.ZipFile(seed / "Balatro.love") as archive: + archive.extractall(game) + + # A packaged Balatro executable is fused and implicitly uses the save + # identity "Balatro". The portable .love directory needs it explicitly. + conf_path = game / "conf.lua" + conf = conf_path.read_text() + if "t.identity" not in conf: + conf = conf.replace( + "t.title = 'Balatro'", + "t.title = 'Balatro'\n\tt.identity = 'Balatro'", + 1, + ) + conf_path.write_text(conf) + + shutil.copytree(seed / "mod", staging / "mods/balatrobot") + shutil.copytree(seed / "python", staging / "python") + shutil.copytree(seed / "save", staging / "save") + (staging / "manifest.json").write_text( + json.dumps( + { + "release": release, + "love": LOVE_VERSION, + "lovely": LOVELY_VERSION, + "smods": SMODS_VERSION, + }, + indent=2, + ) + ) + staging.rename(destination) + + if upload_id: + shutil.rmtree(Path("/assets/uploads") / upload_id, ignore_errors=True) + current_tmp = Path(f"/assets/.CURRENT-{os.getpid()}") + current_tmp.write_text(release + "\n") + current_tmp.replace("/assets/CURRENT") + asset_volume.commit() + return { + "release": release, + "volume": ASSET_VOLUME_NAME, + "path": str(destination), + "reused": reused, + } + + +# --------------------------------------------------------------------------- +# Linux game image and one-sandbox-per-episode environment +# --------------------------------------------------------------------------- + +_LOVE_WRAPPER = """#!/bin/sh +set -eu +LOVELY_PRELOAD="${LD_PRELOAD:-}" +unset LD_PRELOAD +DISPLAY_NUM="${BALATRO_DISPLAY:-99}" +if ! xdpyinfo -display ":$DISPLAY_NUM" >/dev/null 2>&1; then + Xvfb ":$DISPLAY_NUM" -screen 0 1280x720x24 -nolisten tcp >/tmp/xvfb.log 2>&1 & + i=0 + while [ "$i" -lt 100 ]; do + xdpyinfo -display ":$DISPLAY_NUM" >/dev/null 2>&1 && break + i=$((i + 1)) + sleep 0.1 + done +fi +export DISPLAY=":$DISPLAY_NUM" +export LD_LIBRARY_PATH="/opt/love/lib:${LD_LIBRARY_PATH:-}" +export LD_PRELOAD="$LOVELY_PRELOAD" +exec /opt/balatro/bin/love "$@" +""" + +_SANDBOX_ENTRYPOINT = f"""#!/bin/sh +set -eu +if [ ! -s {ASSET_MOUNT}/CURRENT ]; then + echo "Balatro assets are missing. Run: python batro_modal_rl.py --prepare-assets" >&2 + exit 2 +fi +RELEASE="$(tr -d '\\r\\n' < {ASSET_MOUNT}/CURRENT)" +ROOT="{ASSET_MOUNT}/releases/$RELEASE" +test -d "$ROOT/game" +test -d "$ROOT/mods/balatrobot" +test -d "$ROOT/python/balatrobot" + +ln -sfn "$ROOT/game" /opt/balatro/game +ln -sfn "$ROOT/mods/balatrobot" /opt/balatro/Mods/balatrobot + +# Saves are per-sandbox writable copies. Concurrent episodes must not mutate a +# shared profile in the Volume. +rm -rf /root/.local/share/love/Balatro +mkdir -p /root/.local/share/love/Balatro +cp -a "$ROOT/save/." /root/.local/share/love/Balatro/ + +export PYTHONPATH="$ROOT/python" +exec python -m balatrobot serve +""" + + +def _balatro_runtime_image() -> modal.Image: + """Public Linux runtime; private game bytes live only in the Volume.""" + return ( + modal.Image.from_registry("debian:trixie-slim", add_python="3.12") + .run_commands( + "sed -i '/path-exclude.*man/d' /etc/dpkg/dpkg.cfg.d/* 2>/dev/null || true", + "rm -f /etc/dpkg/dpkg.cfg.d/docker", + ) + .apt_install( + "love", # pulls the AppImage's shared runtime dependencies + "xvfb", + "x11-utils", + "libgl1-mesa-dri", + "ca-certificates", + "curl", + "git", + "unzip", + "procps", + ) + .run_commands( + "curl -fsSL -o /tmp/love.AppImage " + "https://github.com/love2d/love/releases/download/" + f"{LOVE_VERSION}/love-{LOVE_VERSION}-x86_64.AppImage", + "chmod +x /tmp/love.AppImage", + "cd /tmp && ./love.AppImage --appimage-extract >/dev/null", + "mv /tmp/squashfs-root /opt/love", + "rm -f /tmp/love.AppImage", + "curl -fsSL -o /tmp/lovely.tar.gz " + "https://github.com/ethangreen-dev/lovely-injector/releases/download/" + f"v{LOVELY_VERSION}/lovely-x86_64-unknown-linux-gnu.tar.gz", + "tar xzf /tmp/lovely.tar.gz -C /tmp", + "install -m 755 /tmp/liblovely.so /usr/local/lib/liblovely.so", + "rm -f /tmp/lovely.tar.gz /tmp/liblovely.so", + "mkdir -p /opt/balatro/bin /opt/balatro/Mods " + "/root/.local/share/love /root/.config/love", + "ln -sfn /opt/love/bin/love /opt/balatro/bin/love", + "git clone --depth 1 --branch " + f"{SMODS_VERSION} https://github.com/Steamodded/smods.git " + "/opt/balatro/Mods/smods", + "ln -sfn /opt/balatro/Mods /root/.local/share/love/Mods", + "ln -sfn /opt/balatro/Mods /root/.config/love/Mods", + "cat > /usr/local/bin/balatro-love <<'LOVE_EOF'\n" + + _LOVE_WRAPPER + + "LOVE_EOF", + "chmod +x /usr/local/bin/balatro-love", + "cat > /usr/local/bin/balatro-sandbox-entrypoint <<'ENTRY_EOF'\n" + + _SANDBOX_ENTRYPOINT + + "ENTRY_EOF", + "chmod +x /usr/local/bin/balatro-sandbox-entrypoint", + ) + .pip_install("httpx", "typer") + .env( + { + "BALATROBOT_PLATFORM": "native", + "BALATROBOT_BALATRO_PATH": "/opt/balatro/game", + "BALATROBOT_LOVE_PATH": "/usr/local/bin/balatro-love", + "BALATROBOT_LOVELY_PATH": "/usr/local/lib/liblovely.so", + "BALATROBOT_LOGS_PATH": "/tmp/balatrobot-logs", + "BALATROBOT_HEADLESS": "1", + # Render a single Xvfb frame on RPC calls. BalatroBot disables + # headless internally when this is set, allowing screenshots + # without continuously rendering the game. + "BALATROBOT_RENDER_ON_API": "1", + "BALATROBOT_FAST": "1", + "BALATROBOT_AUDIO": "0", + "BALATROBOT_NO_SHADERS": "1", + "LIBGL_ALWAYS_SOFTWARE": "1", + "SDL_AUDIODRIVER": "dummy", + "ALSOFT_DRIVERS": "null", + } + ) + ) + + +_RPC_SNIPPET = r""" +import json, sys, urllib.request +method, params = sys.argv[1], json.loads(sys.argv[2]) +payload = json.dumps({"jsonrpc":"2.0","id":1,"method":method,"params":params}).encode() +request = urllib.request.Request( + "http://127.0.0.1:12346", + data=payload, + headers={"Content-Type":"application/json"}, +) +with urllib.request.urlopen(request, timeout=8) as response: + data = json.loads(response.read()) +print("__BALATRO_RPC__" + json.dumps(data, separators=(",", ":"))) +""".strip() + +DECISION_STATES = frozenset({"SELECTING_HAND", "SHOP", "SMODS_BOOSTER_OPENED"}) +TERMINAL_STATES = frozenset({"GAME_OVER"}) + + +class BalatroSandboxEnvironment(SandboxEnvironment): + """One isolated Balatro process and JSON-RPC server.""" + + def __init__(self, sandbox: Any, state: dict[str, Any]) -> None: + super().__init__(sandbox) + self.state = state + + def rpc(self, method: str, params: dict[str, Any] | None = None) -> dict[str, Any]: + process = self.sandbox.exec( + "python", + "-c", + _RPC_SNIPPET, + method, + json.dumps(params or {}, separators=(",", ":")), + timeout=15, + ) + process.wait() + output = process.stdout.read() + for line in reversed(output.splitlines()): + if line.startswith("__BALATRO_RPC__"): + payload = json.loads(line.removeprefix("__BALATRO_RPC__")) + if "error" in payload: + raise RuntimeError(f"{method} failed: {payload['error']}") + return payload["result"] + error = process.stderr.read() + raise RuntimeError( + f"{method} RPC failed (rc={process.returncode}): {(error or output)[-1200:]}" + ) + + @staticmethod + def _terminal(state: dict[str, Any]) -> bool: + return bool(state.get("won")) or state.get("state") in TERMINAL_STATES + + def settle(self, state: dict[str, Any] | None = None) -> dict[str, Any]: + """Advance automatic phases until the next model decision or terminal.""" + current = state or self.rpc("gamestate") + for _ in range(120): + name = current.get("state", "") + if self._terminal(current) or name in DECISION_STATES: + self.state = current + return current + if name == "ROUND_EVAL": + current = self.rpc("cash_out") + elif name == "BLIND_SELECT": + current = self.rpc("select") + else: + time.sleep(0.1) + current = self.rpc("gamestate") + raise TimeoutError( + f"Balatro did not reach a decision state: {current.get('state')}" + ) + + def start(self, seed: str) -> dict[str, Any]: + self.rpc("menu") + state = self.rpc("start", {"deck": "RED", "stake": "WHITE", "seed": seed}) + return self.settle(state) + + def screenshot_data_uri(self) -> str: + """Capture the current game frame for Training Gym's rollout viewer.""" + path = f"/tmp/balatro-rollout-{time.time_ns()}.png" + self.rpc("screenshot", {"path": path}) + process = self.sandbox.exec("base64", "-w", "0", path, timeout=15) + process.wait() + encoded = process.stdout.read().strip() + if process.returncode != 0 or not encoded: + error = process.stderr.read().strip() + raise RuntimeError(f"screenshot encoding failed: {error}") + return f"data:image/png;base64,{encoded}" + + def step(self, action: ToolCall) -> StepResult: + try: + state = self.settle(self.rpc(action.name, action.arguments)) + return StepResult( + observation=Observation( + text=_compact_state(state), metadata={"state": state} + ), + done=self._terminal(state), + info={"state_name": state.get("state", "")}, + ) + except Exception as exc: # action errors are learning signal, not harness death + return StepResult( + observation=Observation( + text=str(exc), is_error=True, metadata={"state": self.state} + ), + done=False, + info={"exception": repr(exc)}, + ) + + +class BalatroEnvironmentPool(SandboxEnvironmentPool): + @property + def app_name(self) -> str: + return SANDBOX_APP_NAME + + def build_image(self) -> modal.Image: + return _balatro_runtime_image() + + def _diagnostics(self, sandbox: Any) -> str: + parts: list[str] = [] + try: + process = sandbox.exec( + "sh", + "-lc", + "find /tmp/balatrobot-logs -type f -name '*.log' -print " + "-exec tail -80 {} \\; 2>/dev/null", + timeout=15, + ) + process.wait() + parts.append(process.stdout.read() + process.stderr.read()) + except Exception as exc: + parts.append(f"diagnostic exec unavailable: {exc!r}") + for name in ("stdout", "stderr"): + try: + parts.append(f"--- sandbox {name} ---\n{getattr(sandbox, name).read()}") + except Exception as exc: + parts.append(f"{name} unavailable: {exc!r}") + return "\n".join(parts)[-8000:] + + def acquire(self, seed: str) -> BalatroSandboxEnvironment: + volume = modal.Volume.from_name(ASSET_VOLUME_NAME, create_if_missing=False) + sandbox = self.create_sandbox( + image=self.build_image(), + command=("/usr/local/bin/balatro-sandbox-entrypoint",), + volumes={ASSET_MOUNT: volume}, + timeout=60 * 60, + idle_timeout=10 * 60, + cpu=2.0, + memory=4096, + ) + env = BalatroSandboxEnvironment(sandbox, {}) + deadline = time.monotonic() + 90 + last_error = "not ready" + while time.monotonic() < deadline: + try: + env.rpc("health") + return env + except Exception as exc: + last_error = repr(exc) + if sandbox.poll() is not None: + break + time.sleep(0.5) + diagnostics = self._diagnostics(sandbox) + env.close() + raise RuntimeError( + f"Balatro sandbox did not become healthy: {last_error}\n{diagnostics}" + ) + + +_ENV_POOL: BalatroEnvironmentPool | None = None + + +def _get_env_pool() -> BalatroEnvironmentPool: + global _ENV_POOL + if _ENV_POOL is None: + _ENV_POOL = BalatroEnvironmentPool() + return _ENV_POOL + + +# --------------------------------------------------------------------------- +# Agent prompt, action parsing, and episode reward +# --------------------------------------------------------------------------- + +_ACTION_HELP = { + "SELECTING_HAND": ( + "play|discard cards=[i,...] (1-5); sell joker|consumable=i; " + "use consumable=i[,cards=[i,...]]; " + "rearrange hand|jokers|consumables=[i,...]" + ), + "SHOP": ( + "buy card|voucher|pack=i; reroll; next_round; " + "sell joker|consumable=i; use consumable=i[,cards=[i,...]]; " + "rearrange jokers|consumables=[i,...]. Respect cost and slots; sell first if full" + ), + "SMODS_BOOSTER_OPENED": "pack card=i[,targets=[i,...]] OR pack skip=true", +} +_ALLOWED_METHODS = { + "SELECTING_HAND": {"play", "discard", "sell", "use", "rearrange"}, + "SHOP": {"buy", "reroll", "next_round", "sell", "use", "rearrange"}, + "SMODS_BOOSTER_OPENED": {"pack"}, +} +_INDEX = r"[0-9]+" +_INDEX_LIST = rf"\[{_INDEX}(,{_INDEX})*\]" +_INDEX_LIST_5 = rf"\[{_INDEX}(,{_INDEX}){{0,4}}\]" +_ACTION_REGEX_BY_STATE = { + "SELECTING_HAND": ( + rf'\{{"method":"(play|discard)","params":\{{"cards":{_INDEX_LIST_5}\}}\}}' + rf'|\{{"method":"sell","params":\{{"(joker|consumable)":{_INDEX}\}}\}}' + rf'|\{{"method":"use","params":\{{"consumable":{_INDEX}' + rf'(,"cards":{_INDEX_LIST_5})?\}}\}}' + rf'|\{{"method":"rearrange","params":\{{"(hand|jokers|consumables)":' + rf'{_INDEX_LIST}\}}\}}' + ), + "SHOP": ( + rf'\{{"method":"buy","params":\{{"(card|voucher|pack)":{_INDEX}\}}\}}' + r'|\{"method":"(reroll|next_round)","params":\{\}\}' + rf'|\{{"method":"sell","params":\{{"(joker|consumable)":{_INDEX}\}}\}}' + rf'|\{{"method":"use","params":\{{"consumable":{_INDEX}' + rf'(,"cards":{_INDEX_LIST_5})?\}}\}}' + rf'|\{{"method":"rearrange","params":\{{"(jokers|consumables)":' + rf'{_INDEX_LIST}\}}\}}' + ), + "SMODS_BOOSTER_OPENED": ( + r'\{"method":"pack","params":\{"skip":true\}\}' + rf'|\{{"method":"pack","params":\{{"card":{_INDEX}' + rf'(,"targets":{_INDEX_LIST_5})?\}}\}}' + ), +} + + +def _action_regex(state_name: str) -> str: + return _ACTION_REGEX_BY_STATE.get( + state_name, + r'\{"method":"(play|discard|buy|reroll|next_round|sell|use|rearrange|pack)",' + r'"params":\{[^{}\n]*\}\}', + ) + + +def _compact_state(state: dict[str, Any], limit: int = 6_000) -> str: + """Return a phase-specific state small enough for an entire ante-8 game.""" + + def card_view( + card: Any, *, playing_card: bool = False, owned: bool = False + ) -> Any: + if not isinstance(card, dict): + return card + value = card.get("value") if isinstance(card.get("value"), dict) else {} + modifier = card.get("modifier") + if isinstance(modifier, dict): + modifier = {key: value for key, value in modifier.items() if value} + else: + modifier = None + card_state = card.get("state") + debuffed = bool( + card.get("debuff") + or (isinstance(card_state, dict) and card_state.get("debuff")) + ) + key = card.get("key") or card.get("label") + if playing_card: + # Most playing cards become a single token-like key such as S_A. + if not modifier and not debuffed: + return key + view = {"id": key, "mod": modifier or None} + if debuffed: + view["debuff"] = True + return {name: item for name, item in view.items() if item is not None} + + view = {"id": key, "effect": card.get("effect") or value.get("effect")} + if modifier: + view["mod"] = modifier + cost = card.get("cost") + buy = cost.get("buy") if isinstance(cost, dict) else card.get("buy") + sell = cost.get("sell") if isinstance(cost, dict) else card.get("sell") + if owned and sell is not None: + view["sell"] = sell + elif not owned and buy is not None: + view["cost"] = buy + return {name: item for name, item in view.items() if item is not None} + + def area_cards( + area: Any, *, playing_cards: bool = False, owned: bool = False + ) -> list[Any]: + if not isinstance(area, dict): + return [] + cards = area.get("cards") if isinstance(area.get("cards"), list) else [] + return [ + card_view(card, playing_card=playing_cards, owned=owned) for card in cards + ] + + def slots(area: Any, default_limit: int) -> str: + if not isinstance(area, dict): + return f"0/{default_limit}" + cards = area.get("cards") if isinstance(area.get("cards"), list) else [] + count = int(area.get("count", len(cards)) or 0) + area_limit = int(area.get("limit", default_limit) or default_limit) + return f"{count}/{area_limit}" + + state_name = str(state.get("state", "")) + phase = { + "SELECTING_HAND": "hand", + "SHOP": "shop", + "SMODS_BOOSTER_OPENED": "pack", + }.get(state_name, state_name) + compact: dict[str, Any] = { + "phase": phase, + "ante": state.get("ante_num"), + "round": state.get("round_num"), + "money": state.get("money"), + } + + round_info = state.get("round") if isinstance(state.get("round"), dict) else {} + blinds = state.get("blinds") if isinstance(state.get("blinds"), dict) else {} + current_blind = next( + ( + blind + for blind in blinds.values() + if isinstance(blind, dict) and blind.get("status") == "CURRENT" + ), + None, + ) + if current_blind: + compact["blind"] = { + "type": str(current_blind.get("type", "")).lower(), + "score": [round_info.get("chips"), current_blind.get("score")], + "hands": round_info.get("hands_left"), + "discards": round_info.get("discards_left"), + "effect": current_blind.get("effect") or None, + } + + boss = blinds.get("boss") + if isinstance(boss, dict) and boss.get("status") != "DEFEATED": + compact["boss"] = [ + item + for item in (boss.get("name"), boss.get("score"), boss.get("effect")) + if item not in (None, "") + ] + + jokers = state.get("jokers") if isinstance(state.get("jokers"), dict) else {} + consumables = ( + state.get("consumables") + if isinstance(state.get("consumables"), dict) + else {} + ) + compact["jokers"] = { + "slots": slots(jokers, 5), + "items": area_cards(jokers, owned=True), + } + compact["consumables"] = { + "slots": slots(consumables, 2), + "items": area_cards(consumables, owned=True), + } + + if state_name == "SELECTING_HAND": + deck_cards = ( + state.get("cards") + if isinstance(state.get("cards"), dict) + else state.get("deck_cards", {}) + ) + compact["deck_left"] = ( + deck_cards.get("count") if isinstance(deck_cards, dict) else None + ) + compact["hand"] = area_cards(state.get("hand", {}), playing_cards=True) + hands = state.get("hands") + if not isinstance(hands, dict): + hands = ( + state.get("poker_hand_changes") + if isinstance(state.get("poker_hand_changes"), dict) + else {} + ) + hand_stats = { + name: [ + int(info.get("level") or 1), + int(info.get("played") or 0), + int(info.get("played_this_round") or 0), + ] + for name, info in hands.items() + if isinstance(info, dict) + and ( + int(info.get("level") or 1) != 1 + or int(info.get("played") or 0) > 0 + or int(info.get("played_this_round") or 0) > 0 + ) + } + if hand_stats: + compact["hand_stats"] = hand_stats + elif state_name == "SHOP": + compact["reroll_cost"] = round_info.get("reroll_cost") + for key in ("shop", "vouchers", "packs"): + cards = area_cards(state.get(key, {})) + if cards: + compact[key] = cards + elif state_name == "SMODS_BOOSTER_OPENED": + compact["pack"] = area_cards(state.get("pack", {})) + + if state.get("won"): + compact["won"] = True + + def clean(value: Any) -> Any: + if isinstance(value, dict): + return { + key: cleaned + for key, item in value.items() + if (cleaned := clean(item)) not in (None, {}, []) + } + if isinstance(value, list): + return [clean(item) for item in value] + return value + + compact = clean(compact) + + text = json.dumps(compact, separators=(",", ":"), ensure_ascii=False) + if len(text) > limit: + text = json.dumps( + { + "phase": compact.get("phase"), + "money": compact.get("money"), + "ante": compact.get("ante"), + "round": compact.get("round"), + "blind": compact.get("blind"), + "hand": compact.get("hand"), + "jokers": compact.get("jokers"), + "consumables": compact.get("consumables"), + "truncated": True, + }, + separators=(",", ":"), + ensure_ascii=False, + ) + return text + + +def _turn_prompt(state: dict[str, Any]) -> str: + name = str(state.get("state", "")) + return ( + "You are playing Balatro. Choose exactly one legal API action. Card and " + "item indices are 0-based. Optimize for winning ante 8. Return only " + 'minified JSON: {"method":"name","params":{...}} with no markdown or ' + "reasoning. State uses slots=used/limit and " + "hand_stats=[level,total_played,played_this_round]. After this first " + "turn, carries only the fields that CHANGED since the " + "previous turn; anything absent is unchanged, null means removed.\n" + f"Legal actions now: {_ACTION_HELP.get(name, 'none')}\n" + f"Gamestate:\n{_compact_state(state)}" + ) + + +def _parse_action(text: str | None, state_name: str) -> ToolCall | None: + if not text: + return None + candidate = text.strip().removeprefix("```json").removeprefix("```") + candidate = candidate.removesuffix("```").strip() + for match in re.finditer(r"\{", candidate): + try: + value, _ = json.JSONDecoder().raw_decode(candidate[match.start() :]) + except json.JSONDecodeError: + continue + if not isinstance(value, dict): + continue + method, params = value.get("method"), value.get("params", {}) + if method not in _ALLOWED_METHODS.get(state_name, set()): + continue + if not isinstance(params, dict): + continue + params.pop("reasoning", None) + for key in ("cards", "targets"): + indices = params.get(key) + if indices is not None and ( + not isinstance(indices, list) + or not 1 <= len(indices) <= 5 + or any(not isinstance(index, int) for index in indices) + ): + break + else: + return ToolCall(name=method, arguments=params) + return None + + +def _fallback_action(state: dict[str, Any]) -> ToolCall: + name = state.get("state") + if name == "SELECTING_HAND": + return ToolCall("play", {"cards": [0]}) + if name == "SHOP": + return ToolCall("next_round", {}) + if name == "SMODS_BOOSTER_OPENED": + return ToolCall("pack", {"skip": True}) + raise RuntimeError(f"No fallback action for state {name!r}") + + +def _episode_reward_parts( + state: dict[str, Any], + *, + invalid_actions: int, + turns: int, + capped: bool, + terminal_reason: str = "", +) -> dict[str, float]: + """Dense progress reward; same-seed GRPO removes seed/luck baselines.""" + rounds = max(0, int(state.get("round_num") or 0)) + round_info = state.get("round") if isinstance(state.get("round"), dict) else {} + chips = float(round_info.get("chips") or 0) + current_blind = 0.0 + blinds = state.get("blinds") if isinstance(state.get("blinds"), dict) else {} + for blind in blinds.values(): + if isinstance(blind, dict) and blind.get("status") == "CURRENT": + current_blind = float(blind.get("score") or 0) + break + fraction = min(1.0, chips / current_blind) if current_blind > 0 else 0.0 + blinds_cleared = max(0, rounds - 1) + progress = float(blinds_cleared + fraction) + blind_clear_bonus = float(3.0 * blinds_cleared) + legal_action_bonus = float(0.1 * max(0, turns - invalid_actions)) + win_bonus = 100.0 if state.get("won") else 0.0 + invalid_penalty = float(-2.0 * invalid_actions) + # Running out of context is the harness's limit, not a policy mistake - + # penalising it taxes exactly the long episodes worth rewarding. Spending + # the whole decision budget without finishing is a real failure. + cap_penalty = -1.0 if capped and terminal_reason != "context_cap" else 0.0 + return { + "progress": progress, + "blind_clear_bonus": blind_clear_bonus, + "legal_action_bonus": legal_action_bonus, + "win_bonus": win_bonus, + "invalid_penalty": invalid_penalty, + "cap_penalty": cap_penalty, + "total": ( + progress + + blind_clear_bonus + + legal_action_bonus + + win_bonus + + invalid_penalty + + cap_penalty + ), + } + + +def _episode_reward( + state: dict[str, Any], + *, + invalid_actions: int, + turns: int, + capped: bool, + terminal_reason: str = "", +) -> float: + return _episode_reward_parts( + state, + invalid_actions=invalid_actions, + turns=turns, + capped=capped, + terminal_reason=terminal_reason, + )["total"] + + +_TOKENIZERS: dict[str, Any] = {} + + +def _tokenizer(checkpoint: str) -> Any: + if checkpoint not in _TOKENIZERS: + from transformers import AutoTokenizer + + _TOKENIZERS[checkpoint] = AutoTokenizer.from_pretrained( + checkpoint, trust_remote_code=True + ) + return _TOKENIZERS[checkpoint] + + +def _chat_prompt(tokenizer: Any, user_message: str) -> str: + messages = [ + { + "role": "system", + "content": "Play Balatro through the provided JSON action interface.", + }, + {"role": "user", "content": user_message}, + ] + try: + return tokenizer.apply_chat_template( + messages, + tokenize=False, + add_generation_prompt=True, + enable_thinking=False, + ) + except TypeError: + return tokenizer.apply_chat_template( + messages, tokenize=False, add_generation_prompt=True + ) + + +async def _generate_action( + args: Any, + sampling_params: dict[str, Any], + prompt_ids: list[int], + state_name: str, +) -> tuple[list[int], str | None, str]: + from slime.utils.http_utils import post + + params = deepcopy(sampling_params) + context_limit = int(getattr(args, "balatro_context_len", 32768)) + params["max_new_tokens"] = min( + int(params.get("max_new_tokens", 96)), 96, context_limit - len(prompt_ids) + ) + if params["max_new_tokens"] <= 0: + return [], None, "context" + # SGLang structured-output constraints belong inside sampling_params. + params["regex"] = _action_regex(state_name) + + output = await post( + f"http://{args.sglang_router_ip}:{args.sglang_router_port}/generate", + { + "input_ids": prompt_ids, + "sampling_params": params, + "return_logprob": True, + }, + ) + finish = output.get("meta_info", {}).get("finish_reason", {}).get("type", "") + if finish == "abort": + return [], None, finish + + response_ids = [ + item[1] for item in output.get("meta_info", {}).get("output_token_logprobs", []) + ] + return response_ids, output.get("text", ""), finish + + +def _action_payload(action: ToolCall) -> dict[str, Any]: + return {"method": action.name, "params": action.arguments} + + +# Sentinel: a subtree that is identical to the previous turn's. +_UNCHANGED = object() + +def _state_delta(previous: Any, current: Any) -> Any: + """Recursive diff of two compact states. + + The transcript is one ever-growing sequence, so re-sending the whole state + every turn means turn N carries N copies of largely identical JSON - the + dominant cost of a long episode. Only what changed is sent instead; the + model reconstructs the rest from earlier turns. + """ + if not isinstance(previous, dict) or not isinstance(current, dict): + return current if current != previous else _UNCHANGED + + delta: dict[str, Any] = {} + for key, value in current.items(): + if key not in previous: + delta[key] = value + continue + nested = _state_delta(previous[key], value) + if nested is not _UNCHANGED: + delta[key] = nested + # Keys the game dropped this turn (a joker sold, a pack closed). + for key in previous: + if key not in current: + delta[key] = None + return delta or _UNCHANGED + + +# Cheap scalars always echoed, so the model never has to scan back to orient. +_DELTA_ANCHORS = ("phase", "ante", "round", "money") + + +def _delta_payload(previous: dict[str, Any] | None, current: dict[str, Any]) -> Any: + """Delta against the previous turn, or the full state when that is smaller.""" + if previous is None: + return current + + delta = _state_delta(previous, current) + delta = {} if delta is _UNCHANGED else delta + for anchor in _DELTA_ANCHORS: + if anchor in current: + delta.setdefault(anchor, current[anchor]) + + # A near-total change (a new round, say) can serialize larger than the + # state itself; send whichever is smaller. + encode = lambda obj: json.dumps(obj, separators=(",", ":"), ensure_ascii=False) + return delta if len(encode(delta)) < len(encode(current)) else current + + +def _environment_feedback( + state: dict[str, Any], + *, + previous_state_name: str, + previous_compact: dict[str, Any] | None, + executed: ToolCall, + valid: bool, + error: str = "", +) -> tuple[str, dict[str, Any]]: + state_name = str(state.get("state", "")) + compact_state = json.loads(_compact_state(state)) + view = _delta_payload(previous_compact, compact_state) + if valid and not error: + payload = view + else: + payload = { + "fallback": _action_payload(executed), + "error": error or "invalid_model_action", + "state": view, + } + feedback = ( + "\n" + + json.dumps(payload, separators=(",", ":"), ensure_ascii=False) + + "" + ) + if state_name != previous_state_name or not valid or error: + feedback += f"\nLegal: {_ACTION_HELP.get(state_name, 'none')}" + return feedback + "\nReturn one JSON action.\n", compact_state + + +def _log_balatro_event(kind: str, payload: dict[str, Any]) -> None: + print( + f"{kind} {json.dumps(payload, separators=(',', ':'), ensure_ascii=False)}", + flush=True, + ) + + +async def generate_balatro_episode( + args: Any, + sample: Any, + sampling_params: dict[str, Any], + evaluation: bool = False, +) -> Any: + """Play one full game and return it as exactly one multi-turn sample.""" + from slime.utils.types import Sample + + del evaluation + source_metadata = dict(getattr(sample, "metadata", None) or {}) + seed = str(source_metadata.get("balatro_seed") or sample.prompt) + max_decisions = int(getattr(args, "balatro_max_decisions", 128)) + context_limit = int(getattr(args, "balatro_context_len", 32768)) + capture_screenshot = bool(getattr(args, "balatro_capture_screenshot", True)) + rollout_id = time.time_ns() & ((1 << 63) - 1) + env: BalatroSandboxEnvironment | None = None + episode_started = time.monotonic() + episode_trace: list[dict[str, Any]] = [] + + def span(name: str, started: float, **attributes: Any) -> None: + episode_trace.append( + { + "name": name, + "start": started - episode_started, + "end": time.monotonic() - episode_started, + "attributes": attributes, + } + ) + + # A transient sandbox startup failure should not kill a whole GPU job. + for attempt in range(3): + acquire_started = time.monotonic() + try: + env = await asyncio.to_thread(_get_env_pool().acquire, seed) + span("balatro.sandbox.acquire", acquire_started, attempt=attempt + 1, ok=True) + break + except Exception as exc: + span( + "balatro.sandbox.acquire", + acquire_started, + attempt=attempt + 1, + ok=False, + ) + _log_balatro_event( + "BALATRO_SANDBOX_ERROR", + {"seed": seed, "attempt": attempt + 1, "error": str(exc)[-1200:]}, + ) + if attempt < 2: + await asyncio.sleep(2 * (attempt + 1)) + if env is None: + sample.status = Sample.Status.ABORTED + return sample + + tokenizer = _tokenizer(args.hf_checkpoint) + initial_prompt = "" + initial_prompt_ids: list[int] = [] + response_token_ids: list[int] = [] + loss_mask: list[int] = [] + trajectory_text = "" + trajectory_messages: list[dict[str, str]] = [ + { + "role": "system", + "content": "Play Balatro through the provided JSON action interface.", + } + ] + invalid_actions = 0 + invalid_turns = 0 + fallback_actions = 0 + api_errors = 0 + turns_taken = 0 + state: dict[str, Any] = {} + # Previous turn's compact state, so feedback can be sent as a delta. + previous_compact: dict[str, Any] | None = None + capped = False + aborted = False + episode_error = "" + terminal_reason = "game_over" + screenshot = "" + try: + game_start = time.monotonic() + state = await asyncio.to_thread(env.start, seed) + span("balatro.game.start", game_start, state=state.get("state", "")) + + first_turn = _turn_prompt(state) + trajectory_messages.append({"role": "user", "content": first_turn}) + initial_prompt = _chat_prompt(tokenizer, first_turn) + initial_prompt_ids = tokenizer(initial_prompt, add_special_tokens=False)[ + "input_ids" + ] + + for turn in range(max_decisions): + if env._terminal(state): + terminal_reason = "won" if state.get("won") else "game_over" + break + if len(initial_prompt_ids) + len(response_token_ids) >= context_limit - 128: + capped = True + terminal_reason = "context_cap" + break + + turns_taken = turn + 1 + state_name = str(state.get("state", "")) + generate_started = time.monotonic() + generated_ids, response, finish = await _generate_action( + args, + sampling_params, + initial_prompt_ids + response_token_ids, + state_name, + ) + span( + "balatro.model.generate", + generate_started, + turn=turn, + state=state_name, + tokens=len(generated_ids), + finish=finish, + ) + if response is None: + aborted = finish == "abort" + capped = finish == "context" + terminal_reason = "model_abort" if aborted else "context_cap" + break + + response_token_ids.extend(generated_ids) + loss_mask.extend([1] * len(generated_ids)) + trajectory_text += response + trajectory_messages.append({"role": "assistant", "content": response}) + + parse_started = time.monotonic() + action = _parse_action(response, state_name) + invalid = action is None + if action is None: + invalid_actions += 1 + invalid_turns += 1 + fallback_actions += 1 + action = _fallback_action(state) + _log_balatro_event( + "BALATRO_ACTION_ERROR", + { + "seed": seed, + "episode_id": rollout_id, + "turn": turn, + "state": state_name, + "error": "invalid_model_output", + "response": response[:500], + "fallback": _action_payload(action), + }, + ) + span("balatro.action.parse", parse_started, turn=turn, valid=not invalid) + + executed = action + rpc_started = time.monotonic() + result = await asyncio.to_thread(env.step, action) + api_error = "" + if result.observation.is_error: + invalid_actions += 1 + api_errors += 1 + api_error = result.observation.text[:500] + fallback = _fallback_action(state) + fallback_actions += 1 + executed = fallback + _log_balatro_event( + "BALATRO_ACTION_ERROR", + { + "seed": seed, + "episode_id": rollout_id, + "turn": turn, + "state": state_name, + "error": api_error, + "requested": _action_payload(action), + "fallback": _action_payload(fallback), + }, + ) + result = await asyncio.to_thread(env.step, fallback) + if result.observation.is_error: + api_errors += 1 + episode_error = result.observation.text[:500] + terminal_reason = "rpc_error" + span( + f"balatro.rpc.{action.name}", + rpc_started, + turn=turn, + valid=False, + fallback=True, + ) + break + span( + f"balatro.rpc.{executed.name}", + rpc_started, + turn=turn, + valid=not result.observation.is_error, + fallback=invalid or bool(api_error), + ) + state = result.observation.metadata["state"] + + feedback, previous_compact = _environment_feedback( + state, + previous_state_name=state_name, + previous_compact=previous_compact, + executed=executed, + valid=not invalid and not api_error, + error=api_error, + ) + trajectory_messages.append({"role": "tool", "content": feedback.strip()}) + trajectory_text += feedback + feedback_ids = tokenizer(feedback, add_special_tokens=False)["input_ids"] + room = context_limit - 128 - len(initial_prompt_ids) - len(response_token_ids) + if len(feedback_ids) > max(0, room): + capped = True + terminal_reason = "context_cap" + break + response_token_ids.extend(feedback_ids) + loss_mask.extend([0] * len(feedback_ids)) + + if result.done: + terminal_reason = "won" if state.get("won") else "game_over" + break + else: + capped = True + terminal_reason = "decision_cap" + except Exception as exc: + episode_error = str(exc)[-1200:] + terminal_reason = "episode_error" + invalid_actions += 3 + _log_balatro_event( + "BALATRO_EPISODE_ERROR", + {"seed": seed, "episode_id": rollout_id, "error": episode_error}, + ) + finally: + if capture_screenshot and env is not None: + screenshot_started = time.monotonic() + try: + screenshot = await asyncio.to_thread(env.screenshot_data_uri) + span("balatro.screenshot", screenshot_started, ok=True) + except Exception as exc: + span("balatro.screenshot", screenshot_started, ok=False) + _log_balatro_event( + "BALATRO_SCREENSHOT_ERROR", + {"seed": seed, "episode_id": rollout_id, "error": str(exc)}, + ) + await asyncio.to_thread(env.close) + + if not initial_prompt_ids or not any(loss_mask): + sample.status = Sample.Status.ABORTED + return sample + + reward_parts = _episode_reward_parts( + state, + invalid_actions=invalid_actions, + turns=turns_taken, + capped=capped, + terminal_reason=terminal_reason, + ) + reward = reward_parts["total"] + won = bool(state.get("won")) + final_ante = int(state.get("ante_num") or 0) + final_round = int(state.get("round_num") or 0) + context_tokens = len(initial_prompt_ids) + len(response_token_ids) + context_utilization = context_tokens / max(1, context_limit) + tokens_per_turn = len(response_token_ids) / max(1, turns_taken) + duration = time.monotonic() - episode_started + span( + "balatro.episode", + episode_started, + turns=turns_taken, + won=won, + capped=capped, + ) + + metadata = dict(getattr(sample, "metadata", None) or {}) + metadata["balatro"] = { + "seed_group": seed, + "episode_id": rollout_id, + "turns": turns_taken, + "terminal_reason": terminal_reason, + "episode_reward": reward, + "final_ante": final_ante, + "final_round": final_round, + "won": won, + "capped": capped, + "invalid_turns": invalid_turns, + "invalid_actions": invalid_actions, + "fallback_actions": fallback_actions, + "api_errors": api_errors, + "context_tokens": context_tokens, + "context_limit": context_limit, + "context_utilization": context_utilization, + "tokens_per_turn": tokens_per_turn, + "duration_s": round(duration, 3), + "error": episode_error, + } + metadata["metrics"] = { + "balatro/reward_total": reward, + "balatro/reward_progress": reward_parts["progress"], + "balatro/reward_blind_clear": reward_parts["blind_clear_bonus"], + "balatro/reward_legal_action": reward_parts["legal_action_bonus"], + "balatro/reward_win_bonus": reward_parts["win_bonus"], + "balatro/reward_invalid_penalty": reward_parts["invalid_penalty"], + "balatro/reward_cap_penalty": reward_parts["cap_penalty"], + "balatro/final_ante": final_ante, + "balatro/final_round": final_round, + "balatro/turns": turns_taken, + "balatro/invalid_actions": invalid_actions, + "balatro/fallback_actions": fallback_actions, + "balatro/api_errors": api_errors, + "balatro/context_tokens": context_tokens, + "balatro/context_utilization": context_utilization, + "balatro/tokens_per_turn": tokens_per_turn, + "balatro/won": int(won), + } + metadata["exit_status"] = terminal_reason + metadata["trajectory_messages"] = trajectory_messages + if screenshot: + metadata["image"] = screenshot + + sample.prompt = initial_prompt + sample.tokens = initial_prompt_ids + response_token_ids + sample.response_length = len(response_token_ids) + sample.response = trajectory_text + sample.loss_mask = loss_mask + sample.status = Sample.Status.ABORTED if aborted else Sample.Status.COMPLETED + sample.reward = reward + sample.metadata = metadata + sample.rollout_id = rollout_id + existing_trace = getattr(sample, "trace", None) + sample.trace = ( + list(existing_trace) if isinstance(existing_trace, list) else [] + ) + episode_trace + + _log_balatro_event( + "BALATRO_EPISODE", + { + "seed": seed, + "episode_id": rollout_id, + "reward": reward, + "ante": final_ante, + "round": final_round, + "turns": turns_taken, + "won": won, + "capped": capped, + "invalid_actions": invalid_actions, + "terminal_reason": terminal_reason, + "duration_s": round(duration, 3), + }, + ) + return sample + + +def _sample_reward(sample: Any) -> float: + reward = getattr(sample, "reward", None) + return float(reward) if reward is not None else 0.0 + + +async def passthrough_reward(args: Any, samples: Any, **kwargs: Any) -> Any: + del args, kwargs + if isinstance(samples, (list, tuple)): + return [_sample_reward(sample) for sample in samples] + return _sample_reward(samples) + + +def normalize_episode_rewards( + args: Any, samples: list[Any] +) -> tuple[list[float], list[float]]: + """Normalize complete-game rewards within each same-seed GRPO group.""" + from collections import defaultdict + + del args + raw = [_sample_reward(sample) for sample in samples] + seed_groups: dict[str, list[int]] = defaultdict(list) + for index, sample in enumerate(samples): + metadata = getattr(sample, "metadata", None) or {} + seed = metadata.get("balatro", {}).get( + "seed_group", str(getattr(sample, "group_index", 0)) + ) + seed_groups[str(seed)].append(index) + + advantages = [0.0] * len(samples) + for indices in seed_groups.values(): + games: dict[int, list[int]] = defaultdict(list) + for index in indices: + games[int(getattr(samples[index], "rollout_id", index))].append(index) + game_ids = list(games) + scores = [sum(raw[i] for i in games[g]) / len(games[g]) for g in game_ids] + mean = sum(scores) / len(scores) + std = math.sqrt(sum((score - mean) ** 2 for score in scores) / len(scores)) + game_advantage = { + game_id: (score - mean) / (std + 1e-6) + for game_id, score in zip(game_ids, scores) + } + for game_id, game_indices in games.items(): + for index in game_indices: + advantages[index] = game_advantage[game_id] + return raw, advantages + + +# --------------------------------------------------------------------------- +# Training Gym dataset and profiles +# --------------------------------------------------------------------------- + + +class BalatroSeedsDataset(DatasetConfig): + input_key = "messages" + label_key = "label" + apply_chat_template = True + output_format = "jsonl" + always_prepare = True + num_seeds = 256 + + def _rows(self, count: int) -> list[dict[str, Any]]: + rows = [] + for index in range(count): + seed = f"BALATRO-RL-{index:08d}" + rows.append( + { + "messages": [{"role": "user", "content": seed}], + "label": "", + "metadata": {"balatro_seed": seed}, + } + ) + return rows + + @staticmethod + def _write(rows: list[dict[str, Any]], path: str) -> None: + os.makedirs(os.path.dirname(path), exist_ok=True) + with open(path, "w") as output: + for row in rows: + output.write(json.dumps(row) + "\n") + + def prepare(self, path: str, eval_paths: dict[str, str] | None = None) -> None: + self._write(self._rows(int(self.num_seeds)), path) + for eval_path in (eval_paths or {}).values(): + self._write(self._rows(min(32, int(self.num_seeds))), eval_path) + + +@dataclass(config=ConfigDict(extra="forbid", arbitrary_types_allowed=True)) +class BalatroGRPORecipe(SlimeRecipe): + gpu_type: str = "H100" + actor_num_nodes: int = 1 + actor_num_gpus_per_node: int = 8 + colocate: bool = True + tensor_model_parallel_size: int = 1 + sequence_parallel: bool = False + rollout_num_gpus_per_engine: int = 1 + sglang_mem_fraction_static: float = 0.70 + + num_rollout: int = 1 + rollout_batch_size: int = 2 + n_samples_per_prompt: int = 4 + rollout_max_response_len: int = 96 + rollout_temperature: float = 1.0 + rollout_shuffle: bool = True + balance_data: bool = True + + advantage_estimator: str = "grpo" + use_kl_loss: bool = True + kl_loss_type: str = "low_var_kl" + kl_loss_coef: float = 0.001 + global_batch_size: int = 8 + use_dynamic_batch_size: bool = True + max_tokens_per_gpu: int = 32768 + save_interval: int = 10 + eval_interval: int | None = None + megatron_to_hf_mode: str = "bridge" + capture_trace: bool = True + trace_sample_limit: int = 16 + + +PROFILES: dict[str, dict[str, int]] = { + "27b-25x32": { + "num_rollout": 25, + "num_seeds": 256, + "max_decisions": 96, + "context_len": 49152, + "trace_sample_limit": 32, + "capture_screenshot": 0, + "tensor_parallel": 4, + "rollout_batch_size": 8, + "n_samples_per_prompt": 4, + "global_batch_size": 32, + # Slime saves iteration 0 and every Nth iteration. Six also lands on + # the final zero-indexed iteration (24), while avoiding 25 expensive + # full-model checkpoints. + "save_interval": 6, + }, + "27b-proof": { + "num_rollout": 1, + "num_seeds": 32, + "max_decisions": 96, + "context_len": 32768, + "trace_sample_limit": 8, + "capture_screenshot": 0, + "tensor_parallel": 4, + }, + "proof": { + "num_rollout": 1, + "num_seeds": 32, + "max_decisions": 32, + "context_len": 16384, + "trace_sample_limit": 8, + "capture_screenshot": 0, + "tensor_parallel": 1, + }, + "observable": { + "num_rollout": 3, + "num_seeds": 128, + "max_decisions": 64, + "context_len": 16384, + "trace_sample_limit": 16, + "capture_screenshot": 0, + "tensor_parallel": 2, + }, + "smoke": { + "num_rollout": 10, + "num_seeds": 128, + "max_decisions": 96, + "context_len": 32768, + "trace_sample_limit": 16, + "capture_screenshot": 0, + "tensor_parallel": 2, + }, + "full": { + "num_rollout": 250, + "num_seeds": 5000, + "max_decisions": 160, + "context_len": 32768, + "trace_sample_limit": 8, + "capture_screenshot": 0, + "tensor_parallel": 2, + }, +} + + +def build_train_config( + profile: str = "proof", num_rollout: int | None = None +) -> TrainConfig: + if profile not in PROFILES: + raise ValueError(f"Unknown profile {profile!r}; choose from {sorted(PROFILES)}") + settings = dict(PROFILES[profile]) + if num_rollout is not None: + if num_rollout < 1: + raise ValueError(f"num_rollout must be >= 1, got {num_rollout}") + # One training step per rollout batch; the dataset cycles once its + # seeds are exhausted (num_seeds / rollout_batch_size steps per epoch). + settings["num_rollout"] = num_rollout + environment = { + "PYTHONPATH": "/root/Megatron-LM/", + "CUDA_DEVICE_MAX_CONNECTIONS": "1", + "NCCL_NVLS_ENABLE": "1", + "TRAINING_GYM_TRAJECTORY_SAMPLE_LIMIT": "64", + "TRAINING_GYM_IMAGE_SAMPLE_LIMIT": "0", + } + extra_config = { + "balatro_max_decisions": settings["max_decisions"], + "balatro_context_len": settings["context_len"], + "balatro_capture_screenshot": bool(settings["capture_screenshot"]), + } + if profile.startswith("27b-"): + return TrainConfig( + model=Qwen3_8_27B(), + dataset=BalatroSeedsDataset(num_seeds=settings["num_seeds"]), + recipe=Qwen3_8_27b_Recipe( + num_rollout=settings["num_rollout"], + rollout_batch_size=settings.get("rollout_batch_size", 2), + n_samples_per_prompt=settings.get("n_samples_per_prompt", 4), + global_batch_size=settings.get("global_batch_size", 8), + rollout_max_response_len=96, + # Qwen3.8-27B uses context parallelism 4, so each GPU holds a + # quarter of the full multi-turn trajectory. + max_tokens_per_gpu=settings["context_len"] // 4, + sglang_speculative_algorithm=None, + sglang_speculative_num_steps=None, + sglang_speculative_eagle_topk=None, + sglang_speculative_num_draft_tokens=None, + save_interval=settings.get("save_interval", 1), + trace_sample_limit=settings["trace_sample_limit"], + custom_generate_function=generate_balatro_episode, + custom_rm_function=passthrough_reward, + custom_reward_post_process_function=normalize_episode_rewards, + apply_chat_template_kwargs='{"enable_thinking": false}', + environment=environment, + extra_config=extra_config, + ), + ) + return TrainConfig( + model=Qwen3_4B(), + dataset=BalatroSeedsDataset(num_seeds=settings["num_seeds"]), + recipe=BalatroGRPORecipe( + num_rollout=settings["num_rollout"], + save_interval=1 if profile in {"proof", "observable"} else 10, + tensor_model_parallel_size=settings["tensor_parallel"], + sequence_parallel=settings["tensor_parallel"] > 1, + max_tokens_per_gpu=settings["context_len"], + trace_sample_limit=settings["trace_sample_limit"], + custom_generate_function=generate_balatro_episode, + custom_rm_function=passthrough_reward, + custom_reward_post_process_function=normalize_episode_rewards, + environment=environment, + extra_config=extra_config, + ), + ) + + +def _local_asset_release() -> tuple[ + str, list[tuple[Path, str]], list[tuple[Path, str]] +]: + """Return the content hash plus file/directory upload manifest.""" + import hashlib + + save = _find_balatro_save() + files = [ + (_find_balatro_love(), "Balatro.love"), + (REPO / "balatrobot.json", "mod/balatrobot.json"), + (REPO / "balatrobot.lua", "mod/balatrobot.lua"), + (save / "settings.jkr", "save/settings.jkr"), + (save / "1/profile.jkr", "save/1/profile.jkr"), + (save / "1/meta.jkr", "save/1/meta.jkr"), + ] + directories = [ + (REPO / "src/lua", "mod/src/lua"), + (REPO / "src/balatrobot", "python/balatrobot"), + ] + + digest = hashlib.sha256() + + def update(path: Path, logical_path: str) -> None: + digest.update(logical_path.encode()) + with path.open("rb") as source: + while chunk := source.read(1024 * 1024): + digest.update(chunk) + + for path, remote in files: + update(path, remote) + for directory, remote in directories: + for path in sorted(p for p in directory.rglob("*") if p.is_file()): + update(path, f"{remote}/{path.relative_to(directory)}") + return digest.hexdigest()[:16], files, directories + + +def _prepare_assets_from_cli() -> dict[str, Any]: + import uuid + + release, files, directories = _local_asset_release() + try: + reused = bool(asset_volume.listdir(f"/releases/{release}")) + except Exception: + reused = False + + upload_id = "" + with modal.enable_output(): + if not reused: + upload_id = f"{release}-{uuid.uuid4().hex[:10]}" + root = f"/uploads/{upload_id}" + with asset_volume.batch_upload() as batch: + for path, remote in files: + batch.put_file(str(path), f"{root}/{remote}") + for path, remote in directories: + batch.put_directory(str(path), f"{root}/{remote}") + with assets_app.run(): + return prepare_assets.remote(release, upload_id) + + +def _smoke_environment(seed: str = "BALATRO-RL-SMOKE") -> dict[str, Any]: + pool = BalatroEnvironmentPool() + env = pool.acquire(seed) + try: + state = env.start(seed) + initial = { + "state": state.get("state"), + "ante": state.get("ante_num"), + "round": state.get("round_num"), + "hand_size": len(state.get("hand") or []), + } + result = env.step(_fallback_action(state)) + next_state = result.observation.metadata.get("state", {}) + return { + "initial": initial, + "one_action": { + "error": result.observation.is_error, + "state": next_state.get("state"), + "ante": next_state.get("ante_num"), + "round": next_state.get("round_num"), + }, + } + finally: + pool.release(env) + + +def main() -> None: + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--prepare-assets", action="store_true") + parser.add_argument("--smoke-env", action="store_true") + parser.add_argument("--profile", choices=sorted(PROFILES), default="proof") + parser.add_argument( + "--num-rollout", + type=int, + default=None, + help="Override the profile's training step count (slime rollouts).", + ) + parser.add_argument( + "--launch", + action="store_true", + help="Actually launch the H100 Training Gym run.", + ) + args = parser.parse_args() + + if args.prepare_assets: + print(json.dumps(_prepare_assets_from_cli(), indent=2)) + if args.smoke_env: + with modal.enable_output(): + smoke_result = _smoke_environment() + print(json.dumps(smoke_result, indent=2)) + + config = build_train_config(args.profile, num_rollout=args.num_rollout) + if not args.launch: + with tempfile.TemporaryDirectory() as directory: + path = str(Path(directory) / "balatro-seeds.jsonl") + config.dataset.prepare(path) + config.dataset.validate_prepared(path) + profile = PROFILES[args.profile] + rollouts = args.num_rollout or profile["num_rollout"] + print( + "Training config validated; no GPUs launched. " + f"profile={args.profile}, rollouts={rollouts}, " + f"max_decisions={profile['max_decisions']}." + ) + if not args.prepare_assets: + print("First run: python batro_modal_rl.py --prepare-assets") + launch_cmd = f"python batro_modal_rl.py --profile {args.profile}" + if args.num_rollout is not None: + launch_cmd += f" --num-rollout {args.num_rollout}" + print(f"Launch explicitly: {launch_cmd} --launch") + return + + run = config.launch() + print(f"Training Gym run id: {run.training_run_id}") + + +if __name__ == "__main__": + main() From 21e3eb7ceedb36db69fc49b98606c4b91c2cd4f1 Mon Sep 17 00:00:00 2001 From: Joy Liu Date: Mon, 14 Sep 2026 22:18:48 -0400 Subject: [PATCH 2/7] :new: My trajectory --- TRAINING.md | 37 + batro_modal_rl.py | 1949 +++++++++++++++++--- dashboard/README.md | 26 + dashboard/TrajectoryViewer.svelte | 540 ++++++ dashboard/TrajectoryViewer.test.mjs | 102 + hi.py | 12 + launch-8node-skip-reward-fix-20260909.json | 1 + launch-perfect-batch64-20260914.json | 1 + launch-perfect-continuation-20260914.json | 1 + launch-reward-guard-20260908.json | 1 + launch-reward-guard-20260908c.json | 1 + launch-skip-reward-fix-20260909.json | 1 + src/lua/core/dispatcher.lua | 20 +- src/lua/core/server.lua | 7 +- src/lua/endpoints/pack.lua | 70 +- src/lua/endpoints/play.lua | 22 +- src/lua/utils/gamestate.lua | 26 + src/lua/utils/openrpc.json | 4 + src/lua/utils/types.lua | 3 + tests/test_training_launch.py | 173 ++ 20 files changed, 2671 insertions(+), 326 deletions(-) create mode 100644 TRAINING.md create mode 100644 dashboard/README.md create mode 100644 dashboard/TrajectoryViewer.svelte create mode 100644 dashboard/TrajectoryViewer.test.mjs create mode 100644 hi.py create mode 100644 launch-8node-skip-reward-fix-20260909.json create mode 100644 launch-perfect-batch64-20260914.json create mode 100644 launch-perfect-continuation-20260914.json create mode 100644 launch-reward-guard-20260908.json create mode 100644 launch-reward-guard-20260908c.json create mode 100644 launch-skip-reward-fix-20260909.json create mode 100644 tests/test_training_launch.py diff --git a/TRAINING.md b/TRAINING.md new file mode 100644 index 00000000..be596f5d --- /dev/null +++ b/TRAINING.md @@ -0,0 +1,37 @@ +# Training launch safety + +Run `batro_modal_rl.py` with the Training Gym dependencies in **Python 3.12**, +matching the remote image. Keep `colocate=True` in the recipe. + +Validate a one-rollout checkpoint continuation without allocating GPUs: + +```sh +python batro_modal_rl.py --resume-run nullary-bezier-022caf585c3e \ + --resume-iteration 199 --num-rollout 201 --save-interval 1 +``` + +Slime resumes at checkpoint iteration + 1; `--num-rollout` is an exclusive +upper bound, not the number of additional rollouts. From checkpoint 199, +target 200 does no work, 201 performs one rollout, and 400 performs 200. + +To submit, add `--launch --launch-record /absolute/path/to/new-launch.json`. +Keep the local command alive until it prints `Training Gym run id` and the +receipt says `submitted`, with both a Modal app ID and function-call ID. +After that, Training Gym's detached app outlives the local process. + +Do not use an auto-restarting supervisor for the submission command. Reuse +the same receipt path if an existing invocation is restarted: its exclusive +creation prevents duplicate submissions. A receipt left at `submitting` +means the outcome is uncertain, not that retrying is safe. Check the launch +log and Training Gym run before deliberately choosing a new receipt path. + +A dashboard cancellation reason of `stale_pre_active_no_modal_app` means +the run record never acquired a persisted Modal app ID before the stale-run +cleanup timeout. It is not evidence of a GPU initialization failure. Look +at the **local submission log**; remote training may never have been spawned. + +CPU-only regression checks: + +```sh +uv run pytest tests/test_training_launch.py -q +``` diff --git a/batro_modal_rl.py b/batro_modal_rl.py index 4cebccea..410f9521 100644 --- a/batro_modal_rl.py +++ b/batro_modal_rl.py @@ -9,7 +9,7 @@ python batro_modal_rl.py --prepare-assets python batro_modal_rl.py --smoke-env - python batro_modal_rl.py --profile proof --launch + python batro_modal_rl.py --launch The first two commands use CPU containers only. Training is never launched unless ``--launch`` is passed explicitly. @@ -23,21 +23,29 @@ import math import os import re +import sys import tempfile import time from copy import deepcopy -from pathlib import Path +from io import BytesIO +from pathlib import Path, PurePosixPath from typing import Any import modal from modal_training_gym import ( DatasetConfig, - Qwen3_4B, Qwen3_8_27B, - Qwen3_8_27b_Recipe, - SlimeRecipe, + Qwen3_8_27B_Recipe, TrainConfig, ) +try: + from modal_training_gym import DashboardComponent +except ImportError: + # Dashboard components were added after the core Training Gym launch API. + # Keep the training entrypoint usable with compatible older clients. + DashboardComponent = None + +from modal_training_gym.common.checkpoint import Checkpoint, _list_checkpoints from modal_training_gym.common.environments.base import ( Observation, SandboxEnvironment, @@ -45,8 +53,7 @@ StepResult, ) from modal_training_gym.common.models.base import ToolCall -from pydantic import ConfigDict -from pydantic.dataclasses import dataclass +from modal_training_gym.common.run import TrainingRun, set_checkpoint_location # --------------------------------------------------------------------------- # Private assets: local Mac -> private Modal Volume @@ -62,6 +69,10 @@ SANDBOX_APP_NAME = "balatro-rl-sandboxes" REPO = Path(__file__).resolve().parent +# The Balatro-specific viewer is shipped with this repository. Keep this +# path relative to the module rather than the caller's working directory so +# ``modal run`` and ``python`` resolve the same local source file. +BALATRO_TRAJECTORY_VIEWER_PATH = REPO / "dashboard" / "TrajectoryViewer.svelte" LOVE_ARCHIVE_CANDIDATES = ( Path.home() @@ -323,7 +334,9 @@ def _balatro_runtime_image() -> modal.Image: print("__BALATRO_RPC__" + json.dumps(data, separators=(",", ":"))) """.strip() -DECISION_STATES = frozenset({"SELECTING_HAND", "SHOP", "SMODS_BOOSTER_OPENED"}) +DECISION_STATES = frozenset( + {"BLIND_SELECT", "SELECTING_HAND", "SHOP", "SMODS_BOOSTER_OPENED"} +) TERMINAL_STATES = frozenset({"GAME_OVER"}) @@ -360,18 +373,47 @@ def rpc(self, method: str, params: dict[str, Any] | None = None) -> dict[str, An def _terminal(state: dict[str, Any]) -> bool: return bool(state.get("won")) or state.get("state") in TERMINAL_STATES + @staticmethod + def _stable(state: dict[str, Any]) -> bool: + """Return whether a raw gamestate is safe to use for an action.""" + # The defaults preserve compatibility with an older BalatroBot asset + # release that predates the readiness fields. + return bool(state.get("state_complete", True)) and not bool( + state.get("controller_locked", False) + ) + + def wait_for_stable_state(self, expected: str) -> dict[str, Any]: + """Wait for a particular non-decision state to finish transitioning.""" + current = self.rpc("gamestate") + for _ in range(120): + if current.get("state") == expected and self._stable(current): + self.state = current + return current + time.sleep(0.1) + current = self.rpc("gamestate") + raise TimeoutError( + f"Balatro did not reach stable state {expected!r}: " + f"{current.get('state')!r}" + ) + def settle(self, state: dict[str, Any] | None = None) -> dict[str, Any]: """Advance automatic phases until the next model decision or terminal.""" current = state or self.rpc("gamestate") for _ in range(120): name = current.get("state", "") - if self._terminal(current) or name in DECISION_STATES: + # A gamestate response can briefly expose the next decision state + # while Balatro is still finishing its UI/event transition. Do + # not hand that frame to the model or use it to issue an action. + # The readiness fields are ignored when talking to an older mod so + # local smoke tests and mixed deployments remain compatible. + stable = self._stable(current) + if self._terminal(current) or ( + name in DECISION_STATES and stable + ): self.state = current return current if name == "ROUND_EVAL": current = self.rpc("cash_out") - elif name == "BLIND_SELECT": - current = self.rpc("select") else: time.sleep(0.1) current = self.rpc("gamestate") @@ -398,7 +440,18 @@ def screenshot_data_uri(self) -> str: def step(self, action: ToolCall) -> StepResult: try: - state = self.settle(self.rpc(action.name, action.arguments)) + # Refresh immediately before every action. This closes the gap + # between the model's previous observation and the live game, and + # also waits out automatic transitions after a blind/round action. + current = self.settle() + action_response = self.rpc(action.name, action.arguments) + # A successful play can return through ROUND_EVAL, after which + # settle() immediately calls cash_out and receives SHOP. Preserve + # its commit record across that automatic transition. + committed_play = action_response.get("play_commit") + state = self.settle(action_response) + if isinstance(committed_play, dict) and "play_commit" not in state: + state["play_commit"] = committed_play return StepResult( observation=Observation( text=_compact_state(state), metadata={"state": state} @@ -407,12 +460,28 @@ def step(self, action: ToolCall) -> StepResult: info={"state_name": state.get("state", "")}, ) except Exception as exc: # action errors are learning signal, not harness death + # An action can race a state transition even after the preflight + # refresh (for example when the server observes a new frame just + # after accepting the request). Return the freshest recoverable + # state so the episode loop can choose a fallback for the actual + # phase rather than blindly retrying a stale select/skip action. + error_text = str(exc) + recovered = self.state + try: + recovered = self.settle() + except Exception as refresh_exc: + error_text += f"; state refresh failed: {refresh_exc}" return StepResult( observation=Observation( - text=str(exc), is_error=True, metadata={"state": self.state} + text=error_text, + is_error=True, + metadata={"state": recovered, "error": error_text}, ), done=False, - info={"exception": repr(exc)}, + info={ + "exception": repr(exc), + "state_refreshed": recovered is not self.state, + }, ) @@ -489,35 +558,60 @@ def _get_env_pool() -> BalatroEnvironmentPool: # Agent prompt, action parsing, and episode reward # --------------------------------------------------------------------------- -_ACTION_HELP = { - "SELECTING_HAND": ( - "play|discard cards=[i,...] (1-5); sell joker|consumable=i; " - "use consumable=i[,cards=[i,...]]; " - "rearrange hand|jokers|consumables=[i,...]" - ), - "SHOP": ( - "buy card|voucher|pack=i; reroll; next_round; " - "sell joker|consumable=i; use consumable=i[,cards=[i,...]]; " - "rearrange jokers|consumables=[i,...]. Respect cost and slots; sell first if full" - ), - "SMODS_BOOSTER_OPENED": "pack card=i[,targets=[i,...]] OR pack skip=true", -} +# A completed ante is a useful curriculum checkpoint, but winning ante 8 must +# remain substantially more valuable than any collection of partial rewards. +ANTE_CHECKPOINT_BONUS = 8.0 +FINAL_ANTE = 8 +# A complete action budget is evidence that the policy failed to finish the +# game, not an environment fault. Keep the cost large enough that a loop of +# otherwise legal no-op actions cannot outrank actual blind progress. +DECISION_CAP_PENALTY = -10.0 + _ALLOWED_METHODS = { - "SELECTING_HAND": {"play", "discard", "sell", "use", "rearrange"}, - "SHOP": {"buy", "reroll", "next_round", "sell", "use", "rearrange"}, + "SELECTING_HAND": { + "play", + "discard", + "sell", + "use", + }, + "SHOP": {"buy", "reroll", "next_round", "sell", "use"}, "SMODS_BOOSTER_OPENED": {"pack"}, + "BLIND_SELECT": {"select", "skip"}, } +BALATRO_SYSTEM_PROMPT = ( + "Play Balatro through the provided JSON action interface. Choose exactly " + "one legal API action and return only minified JSON: " + '{"method":"name","params":{...}}. Card and item indices are 0-based; ' + "every index in a list must be distinct. State uses " + "hand_stats=[level,total_played,played_this_round]. After the first " + "turn, balatro_state contains only fields changed since the previous " + "turn; absent fields are unchanged and null means removed. Poker-hand " + "scoring: the state field hand_values maps each hand to " + "[level, base_chips, base_mult]. A played hand's rough score is " + "(base_chips + scored card chips + bonuses) × (base_mult + bonuses); " + "jokers, enhancements, debuffs, and boss effects can change it. " + "At level 1 the common bases are High Card 5/1, Pair 10/2, Two Pair " + "20/2, Three of a Kind 30/3, Straight 30/4, Flush 35/4, Full House " + "40/4, Four of a Kind 60/7, and Straight Flush 100/8; Five of a Kind, " + "Flush House, and Flush Five are stronger special hands. The exact " + "current values in hand_values are authoritative. " + "Choose hands that clear the blind target, not just the highest raw " + "rank. At BLIND_SELECT, choose select to enter the blind or skip to take " + "the displayed tag (Boss blinds cannot be skipped). After a successful " + "skip, the next state includes action_result with skipped, tag, tag_effect, " + "and next blind details; action_result is one-turn transition metadata, " + "not a replacement for the persistent game state." +) _INDEX = r"[0-9]+" _INDEX_LIST = rf"\[{_INDEX}(,{_INDEX})*\]" _INDEX_LIST_5 = rf"\[{_INDEX}(,{_INDEX}){{0,4}}\]" _ACTION_REGEX_BY_STATE = { + "BLIND_SELECT": r'\{"method":"(select|skip)","params":\{\}\}', "SELECTING_HAND": ( rf'\{{"method":"(play|discard)","params":\{{"cards":{_INDEX_LIST_5}\}}\}}' rf'|\{{"method":"sell","params":\{{"(joker|consumable)":{_INDEX}\}}\}}' rf'|\{{"method":"use","params":\{{"consumable":{_INDEX}' rf'(,"cards":{_INDEX_LIST_5})?\}}\}}' - rf'|\{{"method":"rearrange","params":\{{"(hand|jokers|consumables)":' - rf'{_INDEX_LIST}\}}\}}' ), "SHOP": ( rf'\{{"method":"buy","params":\{{"(card|voucher|pack)":{_INDEX}\}}\}}' @@ -525,8 +619,6 @@ def _get_env_pool() -> BalatroEnvironmentPool: rf'|\{{"method":"sell","params":\{{"(joker|consumable)":{_INDEX}\}}\}}' rf'|\{{"method":"use","params":\{{"consumable":{_INDEX}' rf'(,"cards":{_INDEX_LIST_5})?\}}\}}' - rf'|\{{"method":"rearrange","params":\{{"(jokers|consumables)":' - rf'{_INDEX_LIST}\}}\}}' ), "SMODS_BOOSTER_OPENED": ( r'\{"method":"pack","params":\{"skip":true\}\}' @@ -539,7 +631,7 @@ def _get_env_pool() -> BalatroEnvironmentPool: def _action_regex(state_name: str) -> str: return _ACTION_REGEX_BY_STATE.get( state_name, - r'\{"method":"(play|discard|buy|reroll|next_round|sell|use|rearrange|pack)",' + r'\{"method":"(play|discard|buy|reroll|next_round|sell|use|pack)",' r'"params":\{[^{}\n]*\}\}', ) @@ -547,9 +639,7 @@ def _action_regex(state_name: str) -> str: def _compact_state(state: dict[str, Any], limit: int = 6_000) -> str: """Return a phase-specific state small enough for an entire ante-8 game.""" - def card_view( - card: Any, *, playing_card: bool = False, owned: bool = False - ) -> Any: + def card_view(card: Any, *, playing_card: bool = False, owned: bool = False) -> Any: if not isinstance(card, dict): return card value = card.get("value") if isinstance(card.get("value"), dict) else {} @@ -635,6 +725,26 @@ def slots(area: Any, default_limit: int) -> str: "effect": current_blind.get("effect") or None, } + # Blind selection is a model decision. Preserve every blind's status, + # score, and tag so the agent can choose between selecting and skipping. + # This is also useful during hand/shop phases when planning around the next + # blind's effect or tag. + blind_views = { + name: { + "status": blind.get("status"), + "type": str(blind.get("type", "")).lower(), + "name": blind.get("name"), + "score": blind.get("score"), + "effect": blind.get("effect") or None, + "tag": blind.get("tag_name") or None, + "tag_effect": blind.get("tag_effect") or None, + } + for name, blind in blinds.items() + if isinstance(blind, dict) + } + if blind_views: + compact["blinds"] = blind_views + boss = blinds.get("boss") if isinstance(boss, dict) and boss.get("status") != "DEFEATED": compact["boss"] = [ @@ -645,9 +755,7 @@ def slots(area: Any, default_limit: int) -> str: jokers = state.get("jokers") if isinstance(state.get("jokers"), dict) else {} consumables = ( - state.get("consumables") - if isinstance(state.get("consumables"), dict) - else {} + state.get("consumables") if isinstance(state.get("consumables"), dict) else {} ) compact["jokers"] = { "slots": slots(jokers, 5), @@ -658,12 +766,41 @@ def slots(area: Any, default_limit: int) -> str: "items": area_cards(consumables, owned=True), } - if state_name == "SELECTING_HAND": - deck_cards = ( - state.get("cards") - if isinstance(state.get("cards"), dict) - else state.get("deck_cards", {}) + # Vouchers move out of the shop once purchased. Keep their owned state in + # the compact trajectory so the agent and debugger can distinguish an + # active voucher from the current shop offers. + used_vouchers = state.get("used_vouchers") + if isinstance(used_vouchers, dict) and used_vouchers: + compact["owned_vouchers"] = [ + {"id": key, "effect": value} + for key, value in sorted(used_vouchers.items()) + if value not in (None, "") + ] + + # Expose the known deck composition, not the engine's draw order. The + # composition is what a player can use to plan a build; preserving order + # would leak future draws and would also make every delta unnecessarily + # large. Sort the compact views so draws do not reshuffle this field. + deck_area = state.get("cards") if isinstance(state.get("cards"), dict) else {} + deck = area_cards(deck_area, playing_cards=True) + if deck: + compact["deck"] = sorted( + deck, + key=lambda card: json.dumps( + card, separators=(",", ":"), ensure_ascii=False + ), + ) + discard = area_cards(state.get("discard", {}), playing_cards=True) + if discard: + compact["discard"] = sorted( + discard, + key=lambda card: json.dumps( + card, separators=(",", ":"), ensure_ascii=False + ), ) + + if state_name == "SELECTING_HAND": + deck_cards = deck_area or state.get("deck_cards", {}) compact["deck_left"] = ( deck_cards.get("count") if isinstance(deck_cards, dict) else None ) @@ -691,6 +828,17 @@ def slots(area: Any, default_limit: int) -> str: } if hand_stats: compact["hand_stats"] = hand_stats + hand_values = { + name: [ + int(info.get("level") or 1), + int(info.get("chips") or 0), + int(info.get("mult") or 0), + ] + for name, info in hands.items() + if isinstance(info, dict) + } + if hand_values: + compact["hand_values"] = hand_values elif state_name == "SHOP": compact["reroll_cost"] = round_info.get("reroll_cost") for key in ("shop", "vouchers", "packs"): @@ -699,9 +847,15 @@ def slots(area: Any, default_limit: int) -> str: compact[key] = cards elif state_name == "SMODS_BOOSTER_OPENED": compact["pack"] = area_cards(state.get("pack", {})) + hand = area_cards(state.get("hand", {}), playing_cards=True) + if hand: + compact["hand"] = hand if state.get("won"): compact["won"] = True + for key in ("play_commit",): + if isinstance(state.get(key), dict): + compact[key] = state[key] def clean(value: Any) -> Any: if isinstance(value, dict): @@ -718,42 +872,452 @@ def clean(value: Any) -> Any: text = json.dumps(compact, separators=(",", ":"), ensure_ascii=False) if len(text) > limit: + # Deck/discard composition is useful planning context, but the fields + # below are required to choose a legal action. Do not fall back to a + # summary that silently removes the hand, shop, pack, or hand values. + # The compact card views are already bounded to the information needed + # for indexed actions, so this keeps the important state available even + # in unusually modifier-heavy runs. + essential = ( + "phase", + "ante", + "round", + "money", + "blind", + "blinds", + "reroll_cost", + "deck_left", + "hand", + "hand_stats", + "hand_values", + "jokers", + "consumables", + "owned_vouchers", + "shop", + "vouchers", + "packs", + "pack", + ) + reduced = {key: compact[key] for key in essential if key in compact} + reduced["deck_omitted"] = "deck" in compact + reduced["discard_omitted"] = "discard" in compact + reduced["truncated"] = True text = json.dumps( - { - "phase": compact.get("phase"), - "money": compact.get("money"), - "ante": compact.get("ante"), - "round": compact.get("round"), - "blind": compact.get("blind"), - "hand": compact.get("hand"), - "jokers": compact.get("jokers"), - "consumables": compact.get("consumables"), - "truncated": True, - }, + reduced, separators=(",", ":"), ensure_ascii=False, ) return text +def _area_items(compact: dict[str, Any], name: str) -> list[Any]: + area = compact.get(name) + if isinstance(area, dict) and isinstance(area.get("items"), list): + return area["items"] + value = compact.get(name) + return value if isinstance(value, list) else [] + + +def _slot_usage(compact: dict[str, Any], name: str) -> tuple[int, int]: + area = compact.get(name) + slots = area.get("slots", "0/0") if isinstance(area, dict) else "0/0" + try: + used, limit = str(slots).split("/", 1) + return int(used), int(limit) + except (TypeError, ValueError): + return 0, 0 + + +def _purchasable_indices( + compact: dict[str, Any], kind: str, *, enforce_slots: bool = False +) -> list[int]: + money = float(compact.get("money") or 0) + jokers_used, jokers_limit = _slot_usage(compact, "jokers") + consumables_used, consumables_limit = _slot_usage(compact, "consumables") + allowed: list[int] = [] + for index, item in enumerate(_area_items(compact, kind)): + if not isinstance(item, dict) or float(item.get("cost") or 0) > money: + continue + card_id = str(item.get("id") or "") + if enforce_slots and card_id.startswith("j_") and jokers_used >= jokers_limit: + continue + if ( + enforce_slots + and card_id.startswith("c_") + and consumables_used >= consumables_limit + ): + continue + allowed.append(index) + return allowed + + +_CONSUMABLE_TARGET_BOUNDS: dict[str, tuple[int, int]] = { + # Tarot cards. Balatro permits choosing fewer than the displayed maximum + # for multi-card enhancements/conversions, except Death (exactly two). + "c_magician": (1, 2), + "c_empress": (1, 2), + "c_heirophant": (1, 2), + "c_lovers": (1, 1), + "c_chariot": (1, 1), + "c_justice": (1, 1), + "c_strength": (1, 2), + "c_hanged_man": (1, 2), + "c_death": (2, 2), + "c_devil": (1, 1), + "c_tower": (1, 1), + "c_star": (1, 3), + "c_moon": (1, 3), + "c_sun": (1, 3), + "c_world": (1, 3), + # Spectral cards that highlight a playing card. + "c_talisman": (1, 1), + "c_aura": (1, 1), + "c_deja_vu": (1, 1), + "c_trance": (1, 1), + "c_medium": (1, 1), + "c_cryptid": (1, 1), +} +_CONSUMABLE_REQUIRES_JOKER = frozenset({"c_ankh"}) + + +def _consumable_target_bounds(item: Any) -> tuple[int, int] | None: + if not isinstance(item, dict): + return None + return _CONSUMABLE_TARGET_BOUNDS.get(str(item.get("id") or "")) + + +def _consumable_requires_joker(item: Any) -> bool: + return ( + isinstance(item, dict) + and str(item.get("id") or "") in _CONSUMABLE_REQUIRES_JOKER + ) + + +def _target_action_help( + *, method: str, item_name: str, index: int, item: Any, hand_size: int +) -> str | None: + bounds = _consumable_target_bounds(item) + if bounds is None: + return f"{method} {item_name}={index} (no targets)" + if hand_size <= 0: + return None + low, high = bounds + count = str(low) if low == high else f"{low}-{high}" + key = "cards" if method == "use" else "targets" + return ( + f"{method} {item_name}={index} with {key}={count} distinct " + f"hand indices in 0..{hand_size - 1}" + ) + + +def _action_help(state: dict[str, Any]) -> str: + """Describe only actions that are legal under the current visible state.""" + compact = json.loads(_compact_state(state)) + state_name = str(state.get("state", "")) + jokers = _area_items(compact, "jokers") + consumables = _area_items(compact, "consumables") + + if state_name == "BLIND_SELECT": + blinds = ( + compact.get("blinds") if isinstance(compact.get("blinds"), dict) else {} + ) + selected = next( + ( + (name, blind) + for name, blind in blinds.items() + if isinstance(blind, dict) + and str(blind.get("status") or "").upper() == "SELECT" + ), + None, + ) + if selected is None: + return "select" + name, blind = selected + label = blind.get("name") or name + score = blind.get("score") + actions = [f"select (currently selected: {label}, score {score})"] + if str(blind.get("type") or "").upper() != "BOSS": + tag = blind.get("tag") or "no tag" + tag_effect = blind.get("tag_effect") + tag_text = f"{tag} ({tag_effect})" if tag_effect else tag + actions.append( + f"skip (currently selected: {label}, tag: {tag_text})" + ) + return "; ".join(actions) + + if state_name == "SELECTING_HAND": + hand = compact.get("hand") if isinstance(compact.get("hand"), list) else [] + high = len(hand) - 1 + blind = compact.get("blind") if isinstance(compact.get("blind"), dict) else {} + play_count = ( + "exactly 5" + if "must play 5 cards" in str(blind.get("effect") or "").lower() + else "1-5" + ) + actions = [ + f"play cards={play_count} distinct indices in 0..{high}", + ] + discards = int(blind.get("discards") or 0) + if discards > 0: + actions.append( + f"discard cards=1-5 distinct indices in 0..{high} ({discards} left)" + ) + if jokers: + actions.append(f"sell joker=0..{len(jokers) - 1}") + if consumables: + actions.append(f"sell consumable=0..{len(consumables) - 1}") + actions.extend( + help_text + for index, item in enumerate(consumables) + if (not _consumable_requires_joker(item) or jokers) + and ( + help_text := _target_action_help( + method="use", + item_name="consumable", + index=index, + item=item, + hand_size=len(hand), + ) + ) + ) + return "; ".join(actions) + + if state_name == "SHOP": + actions = ["next_round"] + for kind, indices in ( + ("card", _purchasable_indices(compact, "shop", enforce_slots=True)), + ("voucher", _purchasable_indices(compact, "vouchers")), + ("pack", _purchasable_indices(compact, "packs")), + ): + if indices: + actions.append(f"buy {kind}=one of {indices}") + reroll_cost = float(compact.get("reroll_cost") or 0) + if reroll_cost > 0 and float(compact.get("money") or 0) >= reroll_cost: + actions.append(f"reroll (cost {reroll_cost:g})") + if jokers: + actions.append(f"sell joker=0..{len(jokers) - 1}") + if consumables: + actions.append(f"sell consumable=0..{len(consumables) - 1}") + actions.extend( + help_text + for index, item in enumerate(consumables) + if (not _consumable_requires_joker(item) or jokers) + and _consumable_target_bounds(item) is None + and ( + help_text := _target_action_help( + method="use", + item_name="consumable", + index=index, + item=item, + hand_size=0, + ) + ) + ) + return "; ".join(actions) + + if state_name == "SMODS_BOOSTER_OPENED": + pack = compact.get("pack") if isinstance(compact.get("pack"), list) else [] + jokers_used, jokers_limit = _slot_usage(compact, "jokers") + selectable = [ + index + for index, item in enumerate(pack) + if not ( + isinstance(item, dict) + and str(item.get("id") or "").startswith("j_") + and jokers_used >= jokers_limit + ) + and not ( + isinstance(item, dict) + and str(item.get("id") or "") == "c_ankh" + and jokers_used == 0 + ) + ] + actions = ["pack skip=true"] + hand = compact.get("hand") if isinstance(compact.get("hand"), list) else [] + actions.extend( + help_text + for index in selectable + if ( + help_text := _target_action_help( + method="pack", + item_name="card", + index=index, + item=pack[index], + hand_size=len(hand), + ) + ) + ) + return "; ".join(actions) + + return "none" + + def _turn_prompt(state: dict[str, Any]) -> str: - name = str(state.get("state", "")) return ( "You are playing Balatro. Choose exactly one legal API action. Card and " "item indices are 0-based. Optimize for winning ante 8. Return only " 'minified JSON: {"method":"name","params":{...}} with no markdown or ' - "reasoning. State uses slots=used/limit and " - "hand_stats=[level,total_played,played_this_round]. After this first " + "reasoning. Every index in a list must be distinct. Obey the exact " + "Legal line; omitted actions are illegal. State uses slots=used/limit and " + "hand_stats=[level,total_played,played_this_round] and hand_values=" + "[level,base_chips,base_mult]. After this first " "turn, carries only the fields that CHANGED since the " "previous turn; anything absent is unchanged, null means removed.\n" - f"Legal actions now: {_ACTION_HELP.get(name, 'none')}\n" + "At BLIND_SELECT, blinds contains the selected blind and its tag; use " + "select to enter it or skip to take the tag (Boss blinds cannot be " + "skipped). After skip, action_result explicitly reports the skipped " + "blind, tag/tag_effect, and next blind; action_result is one-turn " + "transition metadata.\n" + "The deck field is the sorted composition of cards remaining in the " + "draw pile (not draw order); discard is the known discarded pile. Use " + "these to plan hand selection and future deck/joker synergies.\n" + f"Legal actions now: {_action_help(state)}\n" f"Gamestate:\n{_compact_state(state)}" ) -def _parse_action(text: str | None, state_name: str) -> ToolCall | None: +def _action_is_locally_legal(action: ToolCall, state: dict[str, Any]) -> bool: + compact = json.loads(_compact_state(state)) + method, params = action.name, action.arguments + state_name = str(state.get("state", "")) + + def valid_indices(value: Any, size: int, *, complete: bool = False) -> bool: + if not isinstance(value, list) or not value or len(value) != len(set(value)): + return False + if any(not isinstance(index, int) or not 0 <= index < size for index in value): + return False + return not complete or sorted(value) == list(range(size)) + + hand = compact.get("hand") if isinstance(compact.get("hand"), list) else [] + jokers = _area_items(compact, "jokers") + consumables = _area_items(compact, "consumables") + blind = compact.get("blind") if isinstance(compact.get("blind"), dict) else {} + compact_blinds = ( + compact.get("blinds") if isinstance(compact.get("blinds"), dict) else {} + ) + + if method in {"select", "skip"}: + if state_name != "BLIND_SELECT" or params: + return False + selected = next( + ( + blind + for blind in compact_blinds.values() + if isinstance(blind, dict) + and str(blind.get("status") or "").upper() == "SELECT" + ), + None, + ) + if selected is None: + return False + return method == "select" or str(selected.get("type") or "").upper() != "BOSS" + + def valid_targets(key: str, item: Any) -> bool: + if _consumable_requires_joker(item) and not jokers: + return False + bounds = _consumable_target_bounds(item) + if bounds is None: + return key not in params + values = params.get(key) + return ( + valid_indices(values, len(hand)) and bounds[0] <= len(values) <= bounds[1] + ) + + if method in {"play", "discard"}: + if set(params) != {"cards"}: + return False + cards = params.get("cards") + if not valid_indices(cards, len(hand)) or len(cards) > 5: + return False + counter = "hands" if method == "play" else "discards" + if int(blind.get(counter) or 0) <= 0: + return False + effect = str(blind.get("effect") or "").lower() + return ( + not (method == "play" and "must play 5 cards" in effect) or len(cards) == 5 + ) + if method == "sell": + if set(params) not in ({"joker"}, {"consumable"}): + return False + if "joker" in params: + return isinstance(params["joker"], int) and 0 <= params["joker"] < len( + jokers + ) + if "consumable" in params: + return isinstance(params["consumable"], int) and 0 <= params[ + "consumable" + ] < len(consumables) + return False + if method == "use": + if set(params) - {"consumable", "cards"}: + return False + index = params.get("consumable") + if not isinstance(index, int) or not 0 <= index < len(consumables): + return False + if _consumable_target_bounds(consumables[index]) is not None: + if str(state.get("state", "")) != "SELECTING_HAND": + return False + return valid_targets("cards", consumables[index]) + if method == "buy": + if len(params) != 1: + return False + for kind, area, enforce_slots in ( + ("card", "shop", True), + ("voucher", "vouchers", False), + ("pack", "packs", False), + ): + if kind in params: + return ( + isinstance(params[kind], int) + and not isinstance(params[kind], bool) + and params[kind] + in _purchasable_indices(compact, area, enforce_slots=enforce_slots) + ) + return False + if method == "reroll": + if params: + return False + cost = float(compact.get("reroll_cost") or 0) + return cost > 0 and float(compact.get("money") or 0) >= cost + if method == "next_round": + return state_name == "SHOP" and not params + if method == "pack": + if params.get("skip") is True: + return set(params) == {"skip"} + if set(params) - {"card", "targets"}: + return False + index = params.get("card") + pack = compact.get("pack") if isinstance(compact.get("pack"), list) else [] + if not isinstance(index, int) or not 0 <= index < len(pack): + return False + item = pack[index] + jokers_used, jokers_limit = _slot_usage(compact, "jokers") + if ( + isinstance(item, dict) + and str(item.get("id") or "").startswith("j_") + and jokers_used >= jokers_limit + ): + return False + if ( + isinstance(item, dict) + and str(item.get("id") or "") == "c_ankh" + and jokers_used == 0 + ): + return False + return valid_targets("targets", item) + return False + + +def _decode_action(text: str | None, state: dict[str, Any]) -> ToolCall | None: + """Decode the first model JSON action allowed in the current phase. + + This deliberately does not enforce index legality; callers can distinguish + malformed-but-repairable model output from output that needs the emergency + fallback action. + """ if not text: return None + state_name = str(state.get("state", "")) candidate = text.strip().removeprefix("```json").removeprefix("```") candidate = candidate.removesuffix("```").strip() for match in re.finditer(r"\{", candidate): @@ -768,22 +1332,68 @@ def _parse_action(text: str | None, state_name: str) -> ToolCall | None: continue if not isinstance(params, dict): continue + params = dict(params) params.pop("reasoning", None) - for key in ("cards", "targets"): - indices = params.get(key) - if indices is not None and ( - not isinstance(indices, list) - or not 1 <= len(indices) <= 5 - or any(not isinstance(index, int) for index in indices) - ): - break - else: - return ToolCall(name=method, arguments=params) + return ToolCall(name=method, arguments=params) + return None + + +def _parse_action(text: str | None, state: dict[str, Any]) -> ToolCall | None: + action = _decode_action(text, state) + if action is None: + return None + params = action.arguments + for key in ("cards", "targets"): + indices = params.get(key) + if indices is not None and ( + not isinstance(indices, list) + or not 1 <= len(indices) <= 5 + or any(not isinstance(index, int) for index in indices) + ): + return None + if _action_is_locally_legal(action, state): + return action return None +def _repair_action(text: str | None, state: dict[str, Any]) -> ToolCall | None: + """Repair common index mistakes without hiding genuinely unknown output. + + Qwen occasionally emits duplicate card indices or an index just outside the + visible hand. Preserve the requested method, deduplicate/filter indices, + and only use the emergency fallback when no meaningful action can be + recovered. The episode still marks the repaired turn invalid for reward. + """ + action = _decode_action(text, state) + if action is None or action.name not in {"play", "discard"}: + return None + compact = json.loads(_compact_state(state)) + hand = compact.get("hand") if isinstance(compact.get("hand"), list) else [] + if not hand: + return None + values = action.arguments.get("cards") + if not isinstance(values, list): + return None + cleaned: list[int] = [] + for value in values: + if isinstance(value, int) and 0 <= value < len(hand) and value not in cleaned: + cleaned.append(value) + if not cleaned: + cleaned = [0] + cleaned = cleaned[:5] + blind = compact.get("blind") if isinstance(compact.get("blind"), dict) else {} + effect = str(blind.get("effect") or "").lower() + if action.name == "play" and "must play 5 cards" in effect: + cleaned.extend(index for index in range(len(hand)) if index not in cleaned) + cleaned = cleaned[:5] + repaired = ToolCall(action.name, {**action.arguments, "cards": cleaned}) + return repaired if _action_is_locally_legal(repaired, state) else None + + def _fallback_action(state: dict[str, Any]) -> ToolCall: name = state.get("state") + if name == "BLIND_SELECT": + return ToolCall("select", {}) if name == "SELECTING_HAND": return ToolCall("play", {"cards": [0]}) if name == "SHOP": @@ -800,38 +1410,75 @@ def _episode_reward_parts( turns: int, capped: bool, terminal_reason: str = "", + partial_rewards: dict[str, float] | None = None, ) -> dict[str, float]: - """Dense progress reward; same-seed GRPO removes seed/luck baselines.""" - rounds = max(0, int(state.get("round_num") or 0)) - round_info = state.get("round") if isinstance(state.get("round"), dict) else {} - chips = float(round_info.get("chips") or 0) - current_blind = 0.0 - blinds = state.get("blinds") if isinstance(state.get("blinds"), dict) else {} - for blind in blinds.values(): - if isinstance(blind, dict) and blind.get("status") == "CURRENT": - current_blind = float(blind.get("score") or 0) - break - fraction = min(1.0, chips / current_blind) if current_blind > 0 else 0.0 - blinds_cleared = max(0, rounds - 1) + """Return the complete-game reward and its components. + + ``partial_rewards`` contains transition-level shaping accumulated while the + game was played. The trainer still consumes one scalar per full-game + sample, so this is accumulated rather than emitted as separate samples. + Keeping the fallback calculation preserves the helper's useful standalone + behavior for callers that only have a terminal state. + """ + del capped + + if partial_rewards is not None: + parts = { + "progress": float(partial_rewards.get("progress", 0.0)), + "blind_clear_bonus": float(partial_rewards.get("blind_clear_bonus", 0.0)), + "ante_checkpoint_bonus": float( + partial_rewards.get("ante_checkpoint_bonus", 0.0) + ), + "legal_action_bonus": float(partial_rewards.get("legal_action_bonus", 0.0)), + "invalid_penalty": float(partial_rewards.get("invalid_penalty", 0.0)), + } + parts["win_bonus"] = 100.0 if state.get("won") else 0.0 + parts["cap_penalty"] = ( + DECISION_CAP_PENALTY if terminal_reason == "decision_cap" else 0.0 + ) + parts["total"] = sum(parts.values()) + parts["partial_total"] = parts["total"] - parts["win_bonus"] + return parts + + # Terminal-only fallback for tests and older callers. + blinds_cleared, fraction = _progress_value(state) progress = float(blinds_cleared + fraction) blind_clear_bonus = float(3.0 * blinds_cleared) - legal_action_bonus = float(0.1 * max(0, turns - invalid_actions)) + ante = max(1, int(state.get("ante_num") or 1)) + ante_checkpoints = max(0, ante - 1) + if state.get("won"): + ante_checkpoints = max(ante_checkpoints, FINAL_ANTE) + ante_checkpoint_bonus = float(ANTE_CHECKPOINT_BONUS * ante_checkpoints) + # Formatting a legal JSON action is a prerequisite, not game progress. + # Rewarding it made repeatable no-op actions (notably rearrange) a policy + # objective. Keep the metric field for dashboard compatibility at zero. + legal_action_bonus = 0.0 win_bonus = 100.0 if state.get("won") else 0.0 invalid_penalty = float(-2.0 * invalid_actions) - # Running out of context is the harness's limit, not a policy mistake - - # penalising it taxes exactly the long episodes worth rewarding. Spending - # the whole decision budget without finishing is a real failure. - cap_penalty = -1.0 if capped and terminal_reason != "context_cap" else 0.0 + # Context exhaustion may be a harness/token-budget limitation. Exhausting + # the explicit decision budget is a policy failure and must not pay. + cap_penalty = ( + DECISION_CAP_PENALTY if terminal_reason == "decision_cap" else 0.0 + ) return { "progress": progress, "blind_clear_bonus": blind_clear_bonus, + "ante_checkpoint_bonus": ante_checkpoint_bonus, "legal_action_bonus": legal_action_bonus, "win_bonus": win_bonus, "invalid_penalty": invalid_penalty, "cap_penalty": cap_penalty, + "partial_total": ( + progress + + blind_clear_bonus + + ante_checkpoint_bonus + + legal_action_bonus + + invalid_penalty + ), "total": ( progress + blind_clear_bonus + + ante_checkpoint_bonus + legal_action_bonus + win_bonus + invalid_penalty @@ -840,6 +1487,99 @@ def _episode_reward_parts( } +def _progress_value(state: dict[str, Any]) -> tuple[int, float]: + """Return rewardable blind progress and current-blind score fraction. + + ``SKIPPED`` does advance the game's blind selector, but it must not count + as progress for reward. Treating it as a clear paid the same +4 shaping + as defeating a blind and trained the policy to skip Small and Big blinds + before immediately losing to the Boss. ``DEFEATED`` is the only status + that represents score-earned game progress. + """ + ante = max(1, int(state.get("ante_num") or 1)) + round_info = state.get("round") if isinstance(state.get("round"), dict) else {} + chips = float(round_info.get("chips") or 0) + blinds = state.get("blinds") if isinstance(state.get("blinds"), dict) else {} + status_values = [ + blind.get("status") + for name in ("small", "big", "boss") + for blind in [blinds.get(name)] + if isinstance(blind, dict) + ] + completed_statuses = {"DEFEATED"} + if status_values: + completed = sum(status in completed_statuses for status in status_values) + else: + # Preserve compatibility with older/partial game-state fixtures. + completed = max(0, int(state.get("round_num") or 0) - 1) + blinds_completed = (ante - 1) * 3 + completed + current_blind = next( + ( + float(blind.get("score") or 0) + for blind in blinds.values() + if isinstance(blind, dict) and blind.get("status") == "CURRENT" + ), + 0.0, + ) + fraction = min(1.0, chips / current_blind) if current_blind > 0 else 0.0 + return blinds_completed, fraction + + +def _transition_reward_parts( + previous_state: dict[str, Any], + state: dict[str, Any], + *, + valid_action: bool, + invalid_events: int = 0, +) -> dict[str, float]: + """Shape reward from one environment transition. + + Progress is potential-based within the currently played blind. A clear is + recognized from the state transition itself rather than reconstructed from + ``ante_num``: the latter cannot distinguish previously skipped blinds from + defeated ones after the game advances to a new ante. + """ + _, previous_fraction = _progress_value(previous_state) + _, fraction = _progress_value(state) + previous_phase = str(previous_state.get("state") or "") + phase = str(state.get("state") or "") + blind_defeated = previous_phase == "SELECTING_HAND" and phase == "SHOP" + if blind_defeated: + # The completed blind has potential 1.0; do not double-pay score + # fraction that was already credited on earlier plays. + progress_delta = float(max(0.0, 1.0 - previous_fraction)) + elif previous_phase == "SELECTING_HAND" and phase == "SELECTING_HAND": + progress_delta = float(max(0.0, fraction - previous_fraction)) + else: + # BLIND_SELECT transitions include skips and tags. They are real game + # actions but create no score-earned progress. + progress_delta = 0.0 + blind_clear_delta = 3.0 if blind_defeated else 0.0 + previous_ante = max(1, int(previous_state.get("ante_num") or 1)) + ante = max(1, int(state.get("ante_num") or 1)) + ante_checkpoints = max(0, ante - previous_ante) + ante_checkpoint_bonus = float(ANTE_CHECKPOINT_BONUS * ante_checkpoints) + # Legal syntax alone is not a rewardable transition. + legal_bonus = 0.0 + invalid_penalty = -2.0 * max(0, int(invalid_events)) + return { + "progress": progress_delta, + "blind_clear_bonus": blind_clear_delta, + "ante_checkpoint_bonus": ante_checkpoint_bonus, + "ante_checkpoints": ante_checkpoints, + "blind_clear_count": int(blind_defeated), + "legal_action_bonus": legal_bonus, + "invalid_penalty": invalid_penalty, + "total": ( + progress_delta + + blind_clear_delta + + ante_checkpoint_bonus + + legal_bonus + + invalid_penalty + ), + } + + def _episode_reward( state: dict[str, Any], *, @@ -874,7 +1614,7 @@ def _chat_prompt(tokenizer: Any, user_message: str) -> str: messages = [ { "role": "system", - "content": "Play Balatro through the provided JSON action interface.", + "content": BALATRO_SYSTEM_PROMPT, }, {"role": "user", "content": user_message}, ] @@ -934,6 +1674,7 @@ def _action_payload(action: ToolCall) -> dict[str, Any]: # Sentinel: a subtree that is identical to the previous turn's. _UNCHANGED = object() + def _state_delta(previous: Any, current: Any) -> Any: """Recursive diff of two compact states. @@ -977,10 +1718,65 @@ def _delta_payload(previous: dict[str, Any] | None, current: dict[str, Any]) -> # A near-total change (a new round, say) can serialize larger than the # state itself; send whichever is smaller. - encode = lambda obj: json.dumps(obj, separators=(",", ":"), ensure_ascii=False) + def encode(obj: Any) -> str: + return json.dumps(obj, separators=(",", ":"), ensure_ascii=False) + return delta if len(encode(delta)) < len(encode(current)) else current +def _selected_blind(compact: dict[str, Any] | None) -> tuple[str, dict[str, Any]] | None: + """Return the blind currently offered at BLIND_SELECT. + + Compact states keep every blind in ``blinds`` so a skipped blind and the + newly offered blind can be explained without consulting the raw engine + state. Keep this helper deliberately tolerant of partial state deltas. + """ + if not isinstance(compact, dict): + return None + blinds = compact.get("blinds") + if not isinstance(blinds, dict): + return None + for name, blind in blinds.items(): + if isinstance(blind, dict) and str(blind.get("status") or "").upper() == "SELECT": + return str(name), blind + return None + + +def _skip_transition( + previous: dict[str, Any] | None, current: dict[str, Any] +) -> dict[str, Any] | None: + """Summarize what a valid ``skip`` action changed for the model/viewer.""" + before = _selected_blind(previous) + after = _selected_blind(current) + if before is None: + return None + before_name, before_blind = before + next_name, next_blind = after if after is not None else (None, None) + result: dict[str, Any] = { + "method": "skip", + "skipped": { + "id": before_name, + "name": before_blind.get("name") or before_name, + "type": before_blind.get("type"), + }, + } + tag = before_blind.get("tag") + tag_effect = before_blind.get("tag_effect") + if tag: + result["tag"] = tag + if tag_effect: + result["tag_effect"] = tag_effect + if next_blind is not None: + result["next"] = { + "id": next_name, + "name": next_blind.get("name") or next_name, + "type": next_blind.get("type"), + "score": next_blind.get("score"), + "effect": next_blind.get("effect"), + } + return result + + def _environment_feedback( state: dict[str, Any], *, @@ -990,11 +1786,17 @@ def _environment_feedback( valid: bool, error: str = "", ) -> tuple[str, dict[str, Any]]: - state_name = str(state.get("state", "")) compact_state = json.loads(_compact_state(state)) view = _delta_payload(previous_compact, compact_state) if valid and not error: payload = view + # A skip is otherwise easy to miss in a sparse delta: the old blind + # becomes SKIPPED and the next one becomes SELECT. Include a compact, + # explicit explanation so both the model and trajectory viewers know + # which tag was earned and what blind is now available. + if executed.name == "skip" and isinstance(payload, dict): + if transition := _skip_transition(previous_compact, compact_state): + payload = {**payload, "action_result": transition} else: payload = { "fallback": _action_payload(executed), @@ -1006,8 +1808,7 @@ def _environment_feedback( + json.dumps(payload, separators=(",", ":"), ensure_ascii=False) + "" ) - if state_name != previous_state_name or not valid or error: - feedback += f"\nLegal: {_ACTION_HELP.get(state_name, 'none')}" + feedback += f"\nLegal: {_action_help(state)}" return feedback + "\nReturn one JSON action.\n", compact_state @@ -1030,7 +1831,8 @@ async def generate_balatro_episode( del evaluation source_metadata = dict(getattr(sample, "metadata", None) or {}) seed = str(source_metadata.get("balatro_seed") or sample.prompt) - max_decisions = int(getattr(args, "balatro_max_decisions", 128)) + # This budget covers only state-changing game decisions. + max_decisions = int(getattr(args, "balatro_max_decisions", 250)) context_limit = int(getattr(args, "balatro_context_len", 32768)) capture_screenshot = bool(getattr(args, "balatro_capture_screenshot", True)) rollout_id = time.time_ns() & ((1 << 63) - 1) @@ -1053,7 +1855,9 @@ def span(name: str, started: float, **attributes: Any) -> None: acquire_started = time.monotonic() try: env = await asyncio.to_thread(_get_env_pool().acquire, seed) - span("balatro.sandbox.acquire", acquire_started, attempt=attempt + 1, ok=True) + span( + "balatro.sandbox.acquire", acquire_started, attempt=attempt + 1, ok=True + ) break except Exception as exc: span( @@ -1081,25 +1885,110 @@ def span(name: str, started: float, **attributes: Any) -> None: trajectory_messages: list[dict[str, str]] = [ { "role": "system", - "content": "Play Balatro through the provided JSON action interface.", + "content": BALATRO_SYSTEM_PROMPT, } ] invalid_actions = 0 invalid_turns = 0 fallback_actions = 0 + repaired_actions = 0 api_errors = 0 turns_taken = 0 state: dict[str, Any] = {} # Previous turn's compact state, so feedback can be sent as a delta. previous_compact: dict[str, Any] | None = None + + def append_tool_feedback(feedback: str) -> bool: + """Append an environment response, including terminal error frames.""" + nonlocal trajectory_text, response_token_ids, loss_mask, capped, terminal_reason + trajectory_messages.append({"role": "tool", "content": feedback.strip()}) + trajectory_text += feedback + feedback_ids = tokenizer(feedback, add_special_tokens=False)["input_ids"] + room = context_limit - 128 - len(initial_prompt_ids) - len(response_token_ids) + if len(feedback_ids) > max(0, room): + capped = True + terminal_reason = "context_cap" + return False + response_token_ids.extend(feedback_ids) + loss_mask.extend([0] * len(feedback_ids)) + return True + capped = False aborted = False episode_error = "" terminal_reason = "game_over" screenshot = "" + partial_reward_parts = { + "progress": 0.0, + "blind_clear_bonus": 0.0, + "ante_checkpoint_bonus": 0.0, + "legal_action_bonus": 0.0, + "invalid_penalty": 0.0, + } + ante_checkpoints = 0 + partial_reward_steps = 0 + # Keep checkpoint-window rewards separate from the episode accumulators. + # A blind-clear event credits everything earned since the previous blind + # clear (all card moves included); an ante-clear event credits everything + # earned across that ante, including skipped blinds. These windows are + # observability/credit-assignment records; ``sample.reward`` remains the + # single additive game-level training signal. + partial_reward_trace: list[dict[str, Any]] = [] + blind_reward_pending = dict(partial_reward_parts) + ante_reward_pending = dict(partial_reward_parts) + blind_window_turn: int | None = None + ante_window_turn: int | None = None + blind_window_token: int | None = None + ante_window_token: int | None = None + + def _add_pending(target: dict[str, float], values: dict[str, float]) -> None: + for key in target: + target[key] += float(values.get(key, 0.0)) + + def _pending_total(values: dict[str, float]) -> float: + return float(sum(values.values())) + + def _reset_pending(values: dict[str, float]) -> None: + for key in values: + values[key] = 0.0 + + def _append_checkpoint_event( + *, + label: str, + state_name: str, + turn: int, + token_start: int | None, + token_end: int, + values: dict[str, float], + ) -> None: + if not any(abs(value) > 1e-12 for value in values.values()): + return + event: dict[str, Any] = { + "turn": turn, + "state": state_name, + "label": label, + "reward": _pending_total(values), + # This is the actual game-level cumulative total. It is preferable + # to summing event rewards because an ante window intentionally + # overlaps its blind-clear windows. + "cumulative_reward": sum(partial_reward_parts.values()), + "progress": values["progress"], + "blind_clear_bonus": values["blind_clear_bonus"], + "ante_checkpoint_bonus": values["ante_checkpoint_bonus"], + "legal_action_bonus": values["legal_action_bonus"], + "invalid_penalty": values["invalid_penalty"], + "total": _pending_total(values), + } + if token_start is not None: + event["token_start"] = token_start + event["token_end"] = token_end + partial_reward_trace.append(event) + + previous_reward_state: dict[str, Any] | None = None try: game_start = time.monotonic() state = await asyncio.to_thread(env.start, seed) + previous_reward_state = state span("balatro.game.start", game_start, state=state.get("state", "")) first_turn = _turn_prompt(state) @@ -1120,6 +2009,11 @@ def span(name: str, started: float, **attributes: Any) -> None: turns_taken = turn + 1 state_name = str(state.get("state", "")) + # Reward events are aligned to the response/loss-mask sequence, + # which excludes the initial prompt. The transition reward is + # emitted after this action and can therefore be attached to the + # action tokens that caused it. + action_token_start = len(response_token_ids) generate_started = time.monotonic() generated_ids, response, finish = await _generate_action( args, @@ -1142,30 +2036,51 @@ def span(name: str, started: float, **attributes: Any) -> None: break response_token_ids.extend(generated_ids) + action_token_end = len(response_token_ids) loss_mask.extend([1] * len(generated_ids)) trajectory_text += response trajectory_messages.append({"role": "assistant", "content": response}) parse_started = time.monotonic() - action = _parse_action(response, state_name) + action = _parse_action(response, state) invalid = action is None + repaired_turn = False if action is None: + repaired = _repair_action(response, state) invalid_actions += 1 invalid_turns += 1 - fallback_actions += 1 - action = _fallback_action(state) - _log_balatro_event( - "BALATRO_ACTION_ERROR", - { - "seed": seed, - "episode_id": rollout_id, - "turn": turn, - "state": state_name, - "error": "invalid_model_output", - "response": response[:500], - "fallback": _action_payload(action), - }, - ) + if repaired is not None: + repaired_actions += 1 + repaired_turn = True + action = repaired + decoded = _decode_action(response, state) + _log_balatro_event( + "BALATRO_ACTION_REPAIRED", + { + "seed": seed, + "episode_id": rollout_id, + "turn": turn, + "state": state_name, + "response": response[:500], + "requested": _action_payload(decoded) if decoded else None, + "repaired": _action_payload(action), + }, + ) + else: + fallback_actions += 1 + action = _fallback_action(state) + _log_balatro_event( + "BALATRO_ACTION_ERROR", + { + "seed": seed, + "episode_id": rollout_id, + "turn": turn, + "state": state_name, + "error": "invalid_model_output", + "response": response[:500], + "fallback": _action_payload(action), + }, + ) span("balatro.action.parse", parse_started, turn=turn, valid=not invalid) executed = action @@ -1176,7 +2091,40 @@ def span(name: str, started: float, **attributes: Any) -> None: invalid_actions += 1 api_errors += 1 api_error = result.observation.text[:500] - fallback = _fallback_action(state) + # ``step`` refreshes the environment after an RPC error. Use + # that state for recovery; ``state`` is the model's previous + # observation and may already be stale. + refreshed_state = result.observation.metadata.get("state") + if isinstance(refreshed_state, dict) and refreshed_state: + state = refreshed_state + try: + fallback = _fallback_action(state) + except Exception as fallback_exc: + episode_error = f"{api_error}; no fallback: {fallback_exc}" + terminal_reason = ( + "game_over" if env._terminal(state) else "rpc_error" + ) + partial_reward_parts["invalid_penalty"] -= 2.0 * ( + int(invalid) + 1 + ) + feedback, previous_compact = _environment_feedback( + state, + previous_state_name=state_name, + previous_compact=previous_compact, + executed=action, + valid=False, + error=episode_error, + ) + append_tool_feedback(feedback) + span( + f"balatro.rpc.{action.name}", + rpc_started, + turn=turn, + valid=False, + fallback=False, + refreshed_state=state.get("state", ""), + ) + break fallback_actions += 1 executed = fallback _log_balatro_event( @@ -1186,6 +2134,7 @@ def span(name: str, started: float, **attributes: Any) -> None: "episode_id": rollout_id, "turn": turn, "state": state_name, + "state_after_error": state.get("state", ""), "error": api_error, "requested": _action_payload(action), "fallback": _action_payload(fallback), @@ -1196,12 +2145,30 @@ def span(name: str, started: float, **attributes: Any) -> None: api_errors += 1 episode_error = result.observation.text[:500] terminal_reason = "rpc_error" + refreshed_state = result.observation.metadata.get("state") + if isinstance(refreshed_state, dict) and refreshed_state: + state = refreshed_state + # Preserve the failed turn in the trajectory. Previously + # this branch broke before adding a tool message, leaving + # viewers with an unpaired final action that looked like a + # spontaneous game over. + feedback, previous_compact = _environment_feedback( + state, + previous_state_name=state_name, + previous_compact=previous_compact, + executed=executed, + valid=False, + error=episode_error, + ) + append_tool_feedback(feedback) + partial_reward_parts["invalid_penalty"] -= 2.0 * (int(invalid) + 1) span( f"balatro.rpc.{action.name}", rpc_started, turn=turn, valid=False, fallback=True, + refreshed_state=state.get("state", ""), ) break span( @@ -1209,10 +2176,67 @@ def span(name: str, started: float, **attributes: Any) -> None: rpc_started, turn=turn, valid=not result.observation.is_error, - fallback=invalid or bool(api_error), + fallback=bool(api_error), + repaired=repaired_turn, ) state = result.observation.metadata["state"] + # Accumulate shaping at the transition where it occurs. The + # trainer still receives one reward for this complete game, but + # the breakdown now reflects the sequence of partial outcomes. + if previous_reward_state is not None: + transition_rewards = _transition_reward_parts( + previous_reward_state, + state, + valid_action=not invalid and not api_error, + invalid_events=int(invalid) + int(bool(api_error)), + ) + for key in partial_reward_parts: + partial_reward_parts[key] += transition_rewards[key] + ante_checkpoints += int(transition_rewards["ante_checkpoints"]) + partial_reward_steps += 1 + _add_pending(blind_reward_pending, transition_rewards) + _add_pending(ante_reward_pending, transition_rewards) + if blind_window_turn is None: + blind_window_turn = turn + 1 + blind_window_token = action_token_start + if ante_window_turn is None: + ante_window_turn = turn + 1 + ante_window_token = action_token_start + + blind_clear_count = int(transition_rewards["blind_clear_count"]) + ante_clear_count = int(transition_rewards["ante_checkpoints"]) + if ante_clear_count: + # An ante event intentionally spans all of its blinds, + # including any that were skipped in one transition. + _append_checkpoint_event( + label="ANTE_CLEAR", + state_name=state_name, + turn=turn + 1, + token_start=ante_window_token, + token_end=action_token_end, + values=ante_reward_pending, + ) + _reset_pending(ante_reward_pending) + _reset_pending(blind_reward_pending) + ante_window_turn = None + blind_window_turn = None + ante_window_token = None + blind_window_token = None + elif blind_clear_count: + _append_checkpoint_event( + label="BLIND_CLEAR", + state_name=state_name, + turn=turn + 1, + token_start=blind_window_token, + token_end=action_token_end, + values=blind_reward_pending, + ) + _reset_pending(blind_reward_pending) + blind_window_turn = None + blind_window_token = None + previous_reward_state = state + feedback, previous_compact = _environment_feedback( state, previous_state_name=state_name, @@ -1221,16 +2245,8 @@ def span(name: str, started: float, **attributes: Any) -> None: valid=not invalid and not api_error, error=api_error, ) - trajectory_messages.append({"role": "tool", "content": feedback.strip()}) - trajectory_text += feedback - feedback_ids = tokenizer(feedback, add_special_tokens=False)["input_ids"] - room = context_limit - 128 - len(initial_prompt_ids) - len(response_token_ids) - if len(feedback_ids) > max(0, room): - capped = True - terminal_reason = "context_cap" + if not append_tool_feedback(feedback): break - response_token_ids.extend(feedback_ids) - loss_mask.extend([0] * len(feedback_ids)) if result.done: terminal_reason = "won" if state.get("won") else "game_over" @@ -1242,6 +2258,7 @@ def span(name: str, started: float, **attributes: Any) -> None: episode_error = str(exc)[-1200:] terminal_reason = "episode_error" invalid_actions += 3 + partial_reward_parts["invalid_penalty"] -= 6.0 _log_balatro_event( "BALATRO_EPISODE_ERROR", {"seed": seed, "episode_id": rollout_id, "error": episode_error}, @@ -1264,12 +2281,46 @@ def span(name: str, started: float, **attributes: Any) -> None: sample.status = Sample.Status.ABORTED return sample + # A win can occur on the ante-8 boss before the game increments + # ``ante_num``. Credit that final checkpoint exactly once, while avoiding + # double-counting if the environment has already advanced the ante. + final_ante = max(1, int(state.get("ante_num") or 1)) + expected_checkpoints = min(FINAL_ANTE, final_ante) + if state.get("won") and ante_checkpoints < expected_checkpoints: + missing_checkpoints = expected_checkpoints - ante_checkpoints + checkpoint_reward = ANTE_CHECKPOINT_BONUS * missing_checkpoints + partial_reward_parts["ante_checkpoint_bonus"] += checkpoint_reward + ante_checkpoints += missing_checkpoints + ante_reward_pending["ante_checkpoint_bonus"] += checkpoint_reward + _append_checkpoint_event( + label="WON", + state_name="WON", + turn=turns_taken, + token_start=ante_window_token, + token_end=len(response_token_ids), + values=ante_reward_pending, + ) + _reset_pending(ante_reward_pending) + _reset_pending(blind_reward_pending) + elif any(abs(value) > 1e-12 for value in blind_reward_pending.values()): + # Preserve the final blind's card-move credit when the game ends or + # hits a context/decision cap before a clear event. + _append_checkpoint_event( + label="GAME_END", + state_name=str(state.get("state", "")), + turn=turns_taken, + token_start=blind_window_token, + token_end=len(response_token_ids), + values=blind_reward_pending, + ) + reward_parts = _episode_reward_parts( state, invalid_actions=invalid_actions, turns=turns_taken, capped=capped, terminal_reason=terminal_reason, + partial_rewards=partial_reward_parts, ) reward = reward_parts["total"] won = bool(state.get("won")) @@ -1294,6 +2345,11 @@ def span(name: str, started: float, **attributes: Any) -> None: "turns": turns_taken, "terminal_reason": terminal_reason, "episode_reward": reward, + "partial_reward": reward_parts["partial_total"], + "partial_reward_steps": partial_reward_steps, + "reward_checkpoint_events": len(partial_reward_trace), + "ante_checkpoints": ante_checkpoints, + "partial_reward_trace": partial_reward_trace, "final_ante": final_ante, "final_round": final_round, "won": won, @@ -1301,6 +2357,7 @@ def span(name: str, started: float, **attributes: Any) -> None: "invalid_turns": invalid_turns, "invalid_actions": invalid_actions, "fallback_actions": fallback_actions, + "repaired_actions": repaired_actions, "api_errors": api_errors, "context_tokens": context_tokens, "context_limit": context_limit, @@ -1309,29 +2366,54 @@ def span(name: str, started: float, **attributes: Any) -> None: "duration_s": round(duration, 3), "error": episode_error, } - metadata["metrics"] = { + episode_metrics = { "balatro/reward_total": reward, "balatro/reward_progress": reward_parts["progress"], "balatro/reward_blind_clear": reward_parts["blind_clear_bonus"], + "balatro/reward_ante_checkpoint": reward_parts["ante_checkpoint_bonus"], "balatro/reward_legal_action": reward_parts["legal_action_bonus"], "balatro/reward_win_bonus": reward_parts["win_bonus"], "balatro/reward_invalid_penalty": reward_parts["invalid_penalty"], "balatro/reward_cap_penalty": reward_parts["cap_penalty"], + "balatro/reward_partial": reward_parts["partial_total"], + "balatro/partial_reward_steps": partial_reward_steps, + "balatro/reward_checkpoint_events": len(partial_reward_trace), + "balatro/ante_checkpoints": ante_checkpoints, "balatro/final_ante": final_ante, "balatro/final_round": final_round, "balatro/turns": turns_taken, "balatro/invalid_actions": invalid_actions, "balatro/fallback_actions": fallback_actions, + "balatro/repaired_actions": repaired_actions, "balatro/api_errors": api_errors, "balatro/context_tokens": context_tokens, "balatro/context_utilization": context_utilization, "balatro/tokens_per_turn": tokens_per_turn, "balatro/won": int(won), } + # Training Gym renders numeric top-level sample metadata as per-rollout + # time-series charts. Keep the nested metrics object for the sample detail + # view, and promote the same values so every Balatro metric is chartable. + metadata["metrics"] = episode_metrics + metadata.update(episode_metrics) metadata["exit_status"] = terminal_reason metadata["trajectory_messages"] = trajectory_messages if screenshot: metadata["image"] = screenshot + # Keep the source compatible with framework Sample implementations that do + # not allow arbitrary attributes. Training Gym promotes these reserved + # metadata keys into its first-class rollout fields during extraction. + metadata["reward_granularity"] = "checkpoint" + metadata["reward_events"] = partial_reward_trace + # Training Gym exposes checkpoint-window rewards as first-class Sample + # fields. + # Slime's sample type is version-dependent, so retain the metadata fallback + # above while promoting the fields whenever the runtime object supports it. + try: + sample.reward_granularity = "checkpoint" + sample.reward_events = partial_reward_trace + except (AttributeError, TypeError, ValueError): + pass sample.prompt = initial_prompt sample.tokens = initial_prompt_ids + response_token_ids @@ -1414,18 +2496,22 @@ def normalize_episode_rewards( # --------------------------------------------------------------------------- -# Training Gym dataset and profiles +# Training Gym dataset and active run configuration # --------------------------------------------------------------------------- class BalatroSeedsDataset(DatasetConfig): - input_key = "messages" - label_key = "label" - apply_chat_template = True - output_format = "jsonl" - always_prepare = True num_seeds = 256 + def input_key(self) -> str: + return "messages" + + def label_key(self) -> str: + return "label" + + def apply_chat_template(self) -> bool: + return True + def _rows(self, count: int) -> list[dict[str, Any]]: rows = [] for index in range(count): @@ -1446,176 +2532,74 @@ def _write(rows: list[dict[str, Any]], path: str) -> None: for row in rows: output.write(json.dumps(row) + "\n") - def prepare(self, path: str, eval_paths: dict[str, str] | None = None) -> None: - self._write(self._rows(int(self.num_seeds)), path) - for eval_path in (eval_paths or {}).values(): - self._write(self._rows(min(32, int(self.num_seeds))), eval_path) - - -@dataclass(config=ConfigDict(extra="forbid", arbitrary_types_allowed=True)) -class BalatroGRPORecipe(SlimeRecipe): - gpu_type: str = "H100" - actor_num_nodes: int = 1 - actor_num_gpus_per_node: int = 8 - colocate: bool = True - tensor_model_parallel_size: int = 1 - sequence_parallel: bool = False - rollout_num_gpus_per_engine: int = 1 - sglang_mem_fraction_static: float = 0.70 - - num_rollout: int = 1 - rollout_batch_size: int = 2 - n_samples_per_prompt: int = 4 - rollout_max_response_len: int = 96 - rollout_temperature: float = 1.0 - rollout_shuffle: bool = True - balance_data: bool = True - - advantage_estimator: str = "grpo" - use_kl_loss: bool = True - kl_loss_type: str = "low_var_kl" - kl_loss_coef: float = 0.001 - global_batch_size: int = 8 - use_dynamic_batch_size: bool = True - max_tokens_per_gpu: int = 32768 - save_interval: int = 10 - eval_interval: int | None = None - megatron_to_hf_mode: str = "bridge" - capture_trace: bool = True - trace_sample_limit: int = 16 - - -PROFILES: dict[str, dict[str, int]] = { - "27b-25x32": { - "num_rollout": 25, - "num_seeds": 256, - "max_decisions": 96, - "context_len": 49152, - "trace_sample_limit": 32, - "capture_screenshot": 0, - "tensor_parallel": 4, - "rollout_batch_size": 8, - "n_samples_per_prompt": 4, - "global_batch_size": 32, - # Slime saves iteration 0 and every Nth iteration. Six also lands on - # the final zero-indexed iteration (24), while avoiding 25 expensive - # full-model checkpoints. - "save_interval": 6, - }, - "27b-proof": { - "num_rollout": 1, - "num_seeds": 32, - "max_decisions": 96, - "context_len": 32768, - "trace_sample_limit": 8, - "capture_screenshot": 0, - "tensor_parallel": 4, - }, - "proof": { - "num_rollout": 1, - "num_seeds": 32, - "max_decisions": 32, - "context_len": 16384, - "trace_sample_limit": 8, - "capture_screenshot": 0, - "tensor_parallel": 1, - }, - "observable": { - "num_rollout": 3, - "num_seeds": 128, - "max_decisions": 64, - "context_len": 16384, - "trace_sample_limit": 16, - "capture_screenshot": 0, - "tensor_parallel": 2, - }, - "smoke": { - "num_rollout": 10, - "num_seeds": 128, - "max_decisions": 96, - "context_len": 32768, - "trace_sample_limit": 16, - "capture_screenshot": 0, - "tensor_parallel": 2, - }, - "full": { - "num_rollout": 250, - "num_seeds": 5000, - "max_decisions": 160, - "context_len": 32768, - "trace_sample_limit": 8, - "capture_screenshot": 0, - "tensor_parallel": 2, - }, -} + def rows(self): + return self._rows(int(self.num_seeds)) def build_train_config( - profile: str = "proof", num_rollout: int | None = None + num_rollout: int | None = None, + load: str | None = None, + no_load_optim: bool = False, ) -> TrainConfig: - if profile not in PROFILES: - raise ValueError(f"Unknown profile {profile!r}; choose from {sorted(PROFILES)}") - settings = dict(PROFILES[profile]) - if num_rollout is not None: - if num_rollout < 1: - raise ValueError(f"num_rollout must be >= 1, got {num_rollout}") - # One training step per rollout batch; the dataset cycles once its - # seeds are exhausted (num_seeds / rollout_batch_size steps per epoch). - settings["num_rollout"] = num_rollout - environment = { - "PYTHONPATH": "/root/Megatron-LM/", - "CUDA_DEVICE_MAX_CONNECTIONS": "1", - "NCCL_NVLS_ENABLE": "1", - "TRAINING_GYM_TRAJECTORY_SAMPLE_LIMIT": "64", - "TRAINING_GYM_IMAGE_SAMPLE_LIMIT": "0", - } - extra_config = { - "balatro_max_decisions": settings["max_decisions"], - "balatro_context_len": settings["context_len"], - "balatro_capture_screenshot": bool(settings["capture_screenshot"]), - } - if profile.startswith("27b-"): - return TrainConfig( - model=Qwen3_8_27B(), - dataset=BalatroSeedsDataset(num_seeds=settings["num_seeds"]), - recipe=Qwen3_8_27b_Recipe( - num_rollout=settings["num_rollout"], - rollout_batch_size=settings.get("rollout_batch_size", 2), - n_samples_per_prompt=settings.get("n_samples_per_prompt", 4), - global_batch_size=settings.get("global_batch_size", 8), - rollout_max_response_len=96, - # Qwen3.8-27B uses context parallelism 4, so each GPU holds a - # quarter of the full multi-turn trajectory. - max_tokens_per_gpu=settings["context_len"] // 4, - sglang_speculative_algorithm=None, - sglang_speculative_num_steps=None, - sglang_speculative_eagle_topk=None, - sglang_speculative_num_draft_tokens=None, - save_interval=settings.get("save_interval", 1), - trace_sample_limit=settings["trace_sample_limit"], - custom_generate_function=generate_balatro_episode, - custom_rm_function=passthrough_reward, - custom_reward_post_process_function=normalize_episode_rewards, - apply_chat_template_kwargs='{"enable_thinking": false}', - environment=environment, - extra_config=extra_config, - ), - ) + if num_rollout is not None and num_rollout < 1: + raise ValueError(f"num_rollout must be >= 1, got {num_rollout}") return TrainConfig( - model=Qwen3_4B(), - dataset=BalatroSeedsDataset(num_seeds=settings["num_seeds"]), - recipe=BalatroGRPORecipe( - num_rollout=settings["num_rollout"], - save_interval=1 if profile in {"proof", "observable"} else 10, - tensor_model_parallel_size=settings["tensor_parallel"], - sequence_parallel=settings["tensor_parallel"] > 1, - max_tokens_per_gpu=settings["context_len"], - trace_sample_limit=settings["trace_sample_limit"], + model=Qwen3_8_27B(), + dataset=BalatroSeedsDataset(), + recipe=Qwen3_8_27B_Recipe( + num_rollout=200 if num_rollout is None else num_rollout, + rollout_batch_size=8, + n_samples_per_prompt=4, + global_batch_size=32, + # Rollout engines share the requested 8×8 actor cluster. A colocated recipe + # must not set ``rollout_num_gpus``: that field describes a + # separate rollout pool and only applies to disaggregated runs. + colocate=True, + actor_num_nodes=8, + actor_num_gpus_per_node=8, + rollout_num_gpus_per_engine=2, + tensor_model_parallel_size=4, + sequence_parallel=True, + pipeline_model_parallel_size=2, + context_parallel_size=4, + rollout_max_response_len=96, + rollout_temperature=1.0, + max_tokens_per_gpu=12288, + sglang_speculative_algorithm=None, + sglang_speculative_num_steps=None, + sglang_speculative_eagle_topk=None, + sglang_speculative_num_draft_tokens=None, + save_interval=50, + load=load or "", + no_load_optim=no_load_optim, + trace_sample_limit=8, + # Long-horizon tool use is especially prone to collapsing into a + # single brittle action line. Keep a light anchor to ref_load and + # a small exploration incentive rather than relying on optimizer + # weight decay as the only regularizer. + use_kl_loss=True, + kl_loss_type="low_var_kl", + kl_loss_coef=0.001, + kl_coef=0.0, + entropy_coef=0.001, + weight_decay=0.01, custom_generate_function=generate_balatro_episode, custom_rm_function=passthrough_reward, custom_reward_post_process_function=normalize_episode_rewards, - environment=environment, - extra_config=extra_config, + apply_chat_template_kwargs='{"enable_thinking": false}', + environment={ + "PYTHONPATH": "/root/Megatron-LM/", + "CUDA_DEVICE_MAX_CONNECTIONS": "1", + "NCCL_NVLS_ENABLE": "1", + "TRAINING_GYM_TRAJECTORY_SAMPLE_LIMIT": "64", + "TRAINING_GYM_IMAGE_SAMPLE_LIMIT": "0", + }, + extra_config={ + "balatro_max_decisions": 250, + "balatro_context_len": 49152, + "balatro_capture_screenshot": False, + }, + train_function_kwargs={"ephemeral_disk": 1_048_576}, ), ) @@ -1690,12 +2674,36 @@ def _smoke_environment(seed: str = "BALATRO-RL-SMOKE") -> dict[str, Any]: "round": state.get("round_num"), "hand_size": len(state.get("hand") or []), } - result = env.step(_fallback_action(state)) - next_state = result.observation.metadata.get("state", {}) + skip_result = env.step(ToolCall("skip", {})) + skip_state = skip_result.observation.metadata.get("state", {}) + skip_big_result = env.step(ToolCall("skip", {})) + skip_big_state = skip_big_result.observation.metadata.get("state", {}) + result = env.step(ToolCall("select", {})) + selected_state = result.observation.metadata.get("state", {}) + commit_result = env.step(_fallback_action(selected_state)) + next_state = commit_result.observation.metadata.get("state", {}) return { "initial": initial, + "skip_action": { + "error": skip_result.observation.is_error, + "state": skip_state.get("state"), + "selected_blinds": { + name: blind.get("status") + for name, blind in (skip_state.get("blinds") or {}).items() + if isinstance(blind, dict) + }, + }, + "skip_big_action": { + "error": skip_big_result.observation.is_error, + "state": skip_big_state.get("state"), + "selected_blinds": { + name: blind.get("status") + for name, blind in (skip_big_state.get("blinds") or {}).items() + if isinstance(blind, dict) + }, + }, "one_action": { - "error": result.observation.is_error, + "error": commit_result.observation.is_error, "state": next_state.get("state"), "ante": next_state.get("ante_num"), "round": next_state.get("round_num"), @@ -1705,16 +2713,295 @@ def _smoke_environment(seed: str = "BALATRO-RL-SMOKE") -> dict[str, Any]: pool.release(env) +def _checkpoint_iteration(checkpoint: Checkpoint) -> int: + match = re.fullmatch(r"iter_(\d+)", checkpoint.name) + if match is None: + raise RuntimeError( + f"Cannot determine iteration from checkpoint {checkpoint.name!r}" + ) + return int(match.group(1)) + + +def _remaining_rollouts(checkpoint_iteration: int, target: int) -> int: + # Slime resumes at the next rollout ID and uses an exclusive upper bound. + start = checkpoint_iteration + 1 + if target <= start: + raise ValueError( + f"Checkpoint {checkpoint_iteration} resumes at rollout {start}, so " + f"--num-rollout {target} would perform no training. " + f"Use at least --num-rollout {start + 1} for one new rollout." + ) + return target - start + + +def _launch_training(config: TrainConfig, record_path: Path | None = None): + """Submit once; retain a receipt even if submission is interrupted. + + Reuse the same record path when a supervisor reruns this command. An + existing receipt blocks submission, including an uncertain/partial one: + automatically retrying those can create duplicate GPU jobs. + """ + record = None + if record_path is not None: + try: + record = record_path.open("x", encoding="utf-8") + except FileExistsError: + raise RuntimeError( + f"Launch record already exists: {record_path}. No run submitted. " + "Inspect its run ID/logs before using a new record for a new run." + ) from None + try: + if record is not None: + json.dump({"state": "submitting", "pid": os.getpid()}, record) + record.flush() + os.fsync(record.fileno()) + if config.checkpoint is not None: + _pin_resume_checkpoint(config.checkpoint) + # Training Gym's public launcher starts a detached Modal app. Keep this + # process alive until it returns the persisted function-call handle. + run = config.launch() + if record is not None: + record.seek(0) + json.dump({ + "state": "submitted", + "training_run_id": run.training_run_id, + "modal_app_id": run.modal_app_id, + "function_call_id": run.function_call_id, + }, record) + record.truncate() + record.flush() + os.fsync(record.fileno()) + return run + finally: + if record is not None: + record.close() + + +def _checkpoint_manifest(checkpoint: Checkpoint) -> dict[str, int]: + volume = modal.Volume.from_name( + checkpoint.checkpoints_volume_name, + create_if_missing=False, + ) + manifest: dict[str, int] = {} + for entry in volume.iterdir(checkpoint.path_relative_to_volume, recursive=False): + path = str(getattr(entry, "path", "")) + size = getattr(entry, "size", None) + if path and isinstance(size, int): + manifest[path.rsplit("/", 1)[-1]] = size + return manifest + + +def _checkpoint_manifest_health( + candidate: dict[str, int], + reference: dict[str, int] | None, +) -> tuple[bool, str]: + required = {".metadata", "metadata.json"} + missing = sorted(required - candidate.keys()) + if missing: + return False, f"missing {', '.join(missing)}" + + candidate_shards = { + name: size for name, size in candidate.items() if name.endswith(".distcp") + } + if not candidate_shards: + return False, "contains no .distcp shards" + if any(size <= 0 for size in candidate_shards.values()): + return False, "contains an empty .distcp shard" + + if reference is None: + return True, "has checkpoint metadata and non-empty shards" + + reference_shards = { + name: size for name, size in reference.items() if name.endswith(".distcp") + } + if candidate_shards.keys() != reference_shards.keys(): + return False, "distributed shard set differs from the previous checkpoint" + + truncated = [ + name + for name, size in candidate_shards.items() + if size < 0.9 * reference_shards[name] + ] + if truncated: + return False, ( + f"{len(truncated)} distributed shards are more than 10% smaller " + "than the previous checkpoint" + ) + return True, "shard manifest matches the previous checkpoint" + + +def _pin_resume_checkpoint(checkpoint: Checkpoint) -> None: + """Point Megatron's run-level tracker at the validated checkpoint. + + Training Gym mounts the parent run directory and passes that directory to + ``--load``. Megatron then follows ``latest_checkpointed_iteration.txt``; + selecting a Checkpoint object alone does not override that tracker. + """ + iteration = _checkpoint_iteration(checkpoint) + run_dir = PurePosixPath(checkpoint.path_relative_to_volume).parent + marker_path = str(run_dir / "latest_checkpointed_iteration.txt") + volume = modal.Volume.from_name( + checkpoint.checkpoints_volume_name, + create_if_missing=False, + ) + marker = f"{iteration}\n".encode() + with volume.batch_upload(force=True) as batch: + batch.put_file(BytesIO(marker), marker_path) + written = b"".join(volume.read_file(marker_path)) + if written.strip() != str(iteration).encode(): + raise RuntimeError( + f"Failed to pin Megatron checkpoint tracker {marker_path!r} " + f"to iteration {iteration}" + ) + print(f"Pinned Megatron checkpoint tracker to iteration {iteration}.") + + +def _resume_result(config: TrainConfig, training_run_id: str) -> TrainingRun: + """Load a run and supply legacy checkpoint metadata when it is absent. + + Older Training Gym launchers wrote the checkpoint directory to the legacy + train-result store but not to ``TrainingRun.metadata``. The current API + discovers checkpoints exclusively from that metadata, so reconstruct the + deterministic Slime location in memory for those older runs. Do not save + this compatibility value back to the record. + """ + run = TrainingRun.from_id(training_run_id) + if run.checkpoints(): + return run + recipe_name = type(config.recipe).__name__.lstrip("_").lower() + set_checkpoint_location( + run, + checkpoint_dir=f"/checkpoints/{training_run_id}", + checkpoints_volume_name=f"slime-{recipe_name}-checkpoints", + checkpoints_mount_path="/checkpoints", + ) + return run + + +def _select_resume_checkpoint( + result: TrainingRun, + requested_iteration: int | None, +) -> Checkpoint: + # Use the persisted run's public helper in the ordinary case. A legacy run + # may have had its location reconstructed in memory by ``_resume_result``; + # calling ``TrainingRun.checkpoints()`` would reload and discard that local + # compatibility metadata, so enumerate the same location directly there. + location = getattr(result, "metadata", {}).get("checkpoint_location") + if isinstance(location, dict): + checkpoints = _list_checkpoints( + str(location["checkpoint_dir"]), + str(location["checkpoints_volume_name"]), + str(location.get("checkpoints_mount_path") or "/checkpoints"), + training_run_id=result.training_run_id, + app_name=getattr(result, "app_name", ""), + ) + else: + checkpoints = result.checkpoints() + checkpoints = sorted(checkpoints, key=_checkpoint_iteration) + if not checkpoints: + raise RuntimeError(f"No checkpoints found for run {result.training_run_id!r}") + + # Only inspect candidates we actually consider and their predecessor. + # Eagerly listing every historical checkpoint can hit VolumeListFiles limits + # before submission, particularly when validating and then launching. + manifests: dict[str, dict[str, int]] = {} + + def manifest(checkpoint: Checkpoint) -> dict[str, int]: + if checkpoint.name not in manifests: + manifests[checkpoint.name] = _checkpoint_manifest(checkpoint) + return manifests[checkpoint.name] + + candidates = checkpoints + if requested_iteration is not None: + candidates = [ + checkpoint + for checkpoint in checkpoints + if _checkpoint_iteration(checkpoint) == requested_iteration + ] + if not candidates: + available = ", ".join(str(_checkpoint_iteration(c)) for c in checkpoints) + raise RuntimeError( + f"Checkpoint iteration {requested_iteration} was not found; " + f"available iterations: {available}" + ) + + for checkpoint in reversed(candidates): + checkpoint_index = checkpoints.index(checkpoint) + reference = ( + manifest(checkpoints[checkpoint_index - 1]) + if checkpoint_index > 0 + else None + ) + healthy, reason = _checkpoint_manifest_health( + manifest(checkpoint), reference + ) + if healthy: + print(f"Checkpoint {checkpoint.name} accepted: {reason}.") + return checkpoint + print(f"Checkpoint {checkpoint.name} rejected: {reason}.") + + raise RuntimeError( + f"No structurally complete checkpoint found for run {result.training_run_id!r}" + ) + + def main() -> None: parser = argparse.ArgumentParser(description=__doc__) parser.add_argument("--prepare-assets", action="store_true") parser.add_argument("--smoke-env", action="store_true") - parser.add_argument("--profile", choices=sorted(PROFILES), default="proof") + parser.add_argument( + "--load", + default=None, + help=( + "Checkpoint directory to resume from, e.g. /checkpoints/. " + "Omit to train from the base model." + ), + ) + parser.add_argument( + "--no-load-optim", + action="store_true", + help=( + "Skip optimizer state when resuming (--load). Required to resume " + "with a different --num-rollout than the checkpoint was written with." + ), + ) parser.add_argument( "--num-rollout", type=int, default=None, - help="Override the profile's training step count (slime rollouts).", + help=( + "Override the active TrainConfig's total target iteration count. When resuming, " + "this exclusive upper bound must exceed checkpoint iteration + 1." + ), + ) + parser.add_argument( + "--resume-run", + default=None, + metavar="TRAINING_RUN_ID", + help="Resume from the latest structurally complete Megatron checkpoint.", + ) + parser.add_argument( + "--resume-iteration", + type=int, + default=None, + help="Require this exact checkpoint iteration when resuming.", + ) + parser.add_argument( + "--save-interval", + type=int, + default=None, + help="Override checkpoint frequency; the final iteration is always saved.", + ) + parser.add_argument( + "--no-fault-tolerance", + action="store_true", + help="Fail once instead of repeatedly resuming from a newly damaged checkpoint.", + ) + parser.add_argument( + "--launch-record", + type=Path, + default=None, + help="One-shot submission receipt; an existing file prevents duplicate launches.", ) parser.add_argument( "--launch", @@ -1722,6 +3009,12 @@ def main() -> None: help="Actually launch the H100 Training Gym run.", ) args = parser.parse_args() + if args.launch and sys.version_info[:2] != (3, 12): + parser.error("Launch with Python 3.12 to match the Training Gym image.") + if args.resume_iteration is not None and not args.resume_run: + parser.error("--resume-iteration requires --resume-run") + if args.resume_run and args.load: + parser.error("Use either --resume-run or --load, not both") if args.prepare_assets: print(json.dumps(_prepare_assets_from_cli(), indent=2)) @@ -1730,28 +3023,70 @@ def main() -> None: smoke_result = _smoke_environment() print(json.dumps(smoke_result, indent=2)) - config = build_train_config(args.profile, num_rollout=args.num_rollout) + config = build_train_config( + num_rollout=args.num_rollout, + load=args.load, + no_load_optim=args.no_load_optim, + ) + if args.save_interval is not None: + if args.save_interval < 1: + raise ValueError("--save-interval must be at least 1") + config.recipe.save_interval = args.save_interval + if args.no_fault_tolerance: + config.recipe.use_fault_tolerance = False + if args.resume_run: + result = _resume_result(config, args.resume_run) + checkpoint = _select_resume_checkpoint(result, args.resume_iteration) + checkpoint_iteration = _checkpoint_iteration(checkpoint) + target_iteration = int(config.recipe.num_rollout) + remaining = _remaining_rollouts(checkpoint_iteration, target_iteration) + config.checkpoint = checkpoint + # The checkpoint's scheduler was built for its original rollout + # horizon. Continuing to a larger target must keep the new schedule + # while still restoring model, optimizer, and RNG state. + resume_extra_config = dict(config.recipe.extra_config or {}) + resume_extra_config["override_opt_param_scheduler"] = True + config.recipe.extra_config = resume_extra_config + print( + f"Resuming {args.resume_run} from {checkpoint.name}; " + f"target iterations={target_iteration}; new rollouts={remaining}." + ) if not args.launch: with tempfile.TemporaryDirectory() as directory: path = str(Path(directory) / "balatro-seeds.jsonl") - config.dataset.prepare(path) - config.dataset.validate_prepared(path) - profile = PROFILES[args.profile] - rollouts = args.num_rollout or profile["num_rollout"] + config.dataset.write(path) + config.dataset.validate_written(path) + rollouts = int(config.recipe.num_rollout) print( - "Training config validated; no GPUs launched. " - f"profile={args.profile}, rollouts={rollouts}, " - f"max_decisions={profile['max_decisions']}." + "TrainConfig validated; no GPUs launched. " + f"rollouts={rollouts}, max_decisions=" + f"{config.recipe.extra_config['balatro_max_decisions']}." ) - if not args.prepare_assets: + if not args.prepare_assets and not args.resume_run: print("First run: python batro_modal_rl.py --prepare-assets") - launch_cmd = f"python batro_modal_rl.py --profile {args.profile}" + launch_cmd = "python batro_modal_rl.py" if args.num_rollout is not None: launch_cmd += f" --num-rollout {args.num_rollout}" + if args.resume_run: + launch_cmd += f" --resume-run {args.resume_run}" + if args.resume_iteration is not None: + launch_cmd += f" --resume-iteration {args.resume_iteration}" + if args.save_interval is not None: + launch_cmd += f" --save-interval {args.save_interval}" + if args.no_fault_tolerance: + launch_cmd += " --no-fault-tolerance" print(f"Launch explicitly: {launch_cmd} --launch") return - run = config.launch() + run = _launch_training(config, args.launch_record) + viewer_path = BALATRO_TRAJECTORY_VIEWER_PATH + + if DashboardComponent is not None and hasattr(run, "add_dashboard_component"): + run.add_dashboard_component( + name="balatro", + component_type=DashboardComponent.TRAJECTORY_VIEWER, + from_path=viewer_path, + ) print(f"Training Gym run id: {run.training_run_id}") diff --git a/dashboard/README.md b/dashboard/README.md new file mode 100644 index 00000000..eb8b2440 --- /dev/null +++ b/dashboard/README.md @@ -0,0 +1,26 @@ +# Balatro dashboard component + +`TrajectoryViewer.svelte` is the Balatro-specific trajectory viewer shipped +with this repository. `batro_modal_rl.py` resolves it relative to its own +file and attaches it to each launched run through Training Gym's +`training-gym-dashboard-overlay` volume. + +Training Gym also ships a framework-default viewer at +`training-gym/dashboards/frontend/src/components/TrajectoryViewer.svelte`. +That file is the fallback used by the dashboard when no Balatro component is +attached (and can be replaced globally with `training-gym setup`). + +The Balatro viewer follows the same Svelte props contract as the default: +`sample`, `samples`, `trajectory`, `rewardEvents`, `rollout`, and `run`. + +The board shows chips scored, the current blind's target, and chips still +needed. Targets are per blind, not per ante; selection starts at zero and +shop/pack screens never reuse the previous blind's score. The initial +selection is available as the `S` frame. Blind selection lists each target, +skip tag, and its recorded effect; skip outcomes distinguish the tag taken +from the next blind's offer. Missing recorded effects are explicitly marked. + +Run compiler and rendered-output regression tests with +`node --test dashboard/TrajectoryViewer.test.mjs`. This uses Svelte installed +in `../training-gym/dashboards/frontend`; set `TRAINING_GYM_FRONTEND` to +override that location. diff --git a/dashboard/TrajectoryViewer.svelte b/dashboard/TrajectoryViewer.svelte new file mode 100644 index 00000000..86d47c95 --- /dev/null +++ b/dashboard/TrajectoryViewer.svelte @@ -0,0 +1,540 @@ + + +{#snippet finish(card)} + {#if modifierValue(card, "edition") && modifierValue(card, "edition") !== "base"} + + {/if} +{/snippet} + +{#snippet badges(card)} + {@const modifiers = modifierBadges(card)} + {#if modifiers.length} +
+ {#each modifiers as badge} + {badge.label} + {/each} +
+ {/if} +{/snippet} + +
+
+
+
BALATRO · TRAJECTORY
+

Run board

+

{groups.length} blinds · {states.length} turns · {Array.isArray(samples) ? samples.length : 0} samples

+
+
{latest.phase || run?.status || "RUN"}{latest.ante != null ? `ANTE ${latest.ante}` : ""}
+
+ + {#if groups.length} + + + {#if activeGroup} +
+ {activeGroup.frames.length} turns + {#each activeGroup.frames as frame, index} + + {/each} +
+ + {#if activeAction} +
+ {activeAction.method.replaceAll("_", " ")} + {#if actionCards.length}cards [{actionCards.join(", ")}]{/if} + {#if actionTarget != null}{actionTargetName} {actionTarget}{#if actionConsumable} · {itemName(actionConsumable)}{/if}{/if} + {#if activeAction.method === "skip"}skip blind · take its tag{/if} + {#if activeAction.method === "next_round"}leave shop · choose next blind{/if} +
+ {#if skipResult} +
+
TAG TAKEN · IN-GAME SKIP REWARD{skipResult.tag || "Tag not recorded"}
+
+
SKIPPED{blindLabel(skipResult.skipped)}
+
EFFECT / WHEN IT APPLIES{skipResult.tag_effect || "Effect not recorded in this trajectory."}
+ {#if skipResult.next}
NEXT BLIND{blindLabel(skipResult.next)}{#if skipResult.next.score != null} · {chips(skipResult.next.score)} chips required{/if}
{/if} +
+
+ {/if} + {/if} + +
+
+
{String(progress?.label || latest.phase || "BLIND").replaceAll("_", " ")}{anteLabel}{latest.round != null ? ` · BLIND ${latest.round}` : ""}
+
+ + {#if progress} +
+
CHIPS SCORED · THIS BLIND{chips(progress.current)}
+
CHIPS REQUIRED TO CLEAR{chips(progress.target)}
+
CHIPS STILL NEEDED{chips(chipsRemaining)}
+
+

{progress.pending ? "Blind not started. Chips start at 0 when you select it." : "Chips are cumulative within this blind and reset for the next blind."} Each ante has separate Small, Big, and Boss targets.

+ {:else} +

No active blind score in this phase. Chips reset when the next blind starts.

+ {/if} + + {#if blindChoices.length} + +
+ {#each blindChoices as blind} + {@const status = String(blind.status || "UNKNOWN").toUpperCase()} + {@const boss = String(blind.type || blind.id).toUpperCase() === "BOSS"} +
+
{blindLabel(blind)}{status === "SELECT" ? "AVAILABLE NOW" : status}
+

Clear target: {chips(blind.score)} chips

+ {#if blind.effect}

{blind.effect}

{/if} + {#if boss} +
Cannot skip the Boss Blind

No skip reward.

+ {:else} +
{status === "SKIPPED" ? "TAG TAKEN" : status === "DEFEATED" ? "SKIP OFFER · NOT TAKEN" : "SKIP TO RECEIVE"}{blind.tag || "Tag not recorded"}

{blind.tag_effect || "Effect not recorded in this trajectory."}

+ {/if} +
+ {/each} +
+

Skipping takes the tag instead of playing that blind. The description above states when its benefit applies; this is an in-game reward, not the training reward.

+ {/if} + +
+
{deckCount ?? "—"}DECK
+
{latest.phase || "HAND"}{#if latest.money != null}${latest.money}{/if}
+
{discardCount ?? "—"}DISCARD
+
+ + + {#if selectedIndices.length} +
{activeAction.method} selected cards [{selectedIndices.join(", ")}]
+ {/if} + {#if handForAction.length} +
+ {#each handForAction as card, index (`${activeFrame?.index}-${index}-${cardTitle(card)}`)} + {@const info = cardInfo(card)} + {@const isSelected = selectedIndices.includes(index)} +
0 && !isSelected}> +
+ {@render finish(card)} + {info.rank}{info.suit}{info.suit || "·"} + {#if modifierValue(card, "seal")}✦{/if} + {#if isSelected}✓{/if} +
+ {@render badges(card)} +
+ {/each} +
+ {:else}
No hand data at this turn.
{/if} + + {#if Object.keys(handValues).length} + +
+ {#each Object.entries(handValues) as [name, values]} + {@const level = Array.isArray(values) ? values[0] : null} + {@const chips = Array.isArray(values) ? values[1] : null} + {@const mult = Array.isArray(values) ? values[2] : null} +
0} class="hand-value"> + {name}{#if level != null && level > 1}lvl {level}{/if} + {chips ?? "—"} × {mult ?? "—"} = {chips != null && mult != null ? chips * mult : "—"} +
+ {/each} +
+ {/if} + + {#if jokers.length || consumablesForView.length || vouchers.length || ownedVouchers.length} +
+ {#if jokers.length}
{#each jokers as joker}
+ {@render finish(joker)}★ {itemName(joker)}{@render badges(joker)} + {#if joker.effect}

{joker.effect}

{/if}{#if joker.sell != null}sell ${joker.sell}{/if} +
{/each}
{/if} + {#if consumablesForView.length}
{#each consumablesForView as item, index}
+ {@render finish(item)}✦ {itemName(item)}{@render badges(item)} + {#if item.effect}

{item.effect}

{/if}{#if activeAction?.method === "use" && actionTarget === index}used this turn{/if} +
{/each}
{/if} + {#if vouchers.length || ownedVouchers.length}
{#each vouchers as item}
◆ {itemName(item)}{#if item.effect}

{item.effect}

{/if}{#if item.cost != null}cost ${item.cost}{/if}
{/each}{#each ownedVouchers as item}
◆ {itemName(item)}{#if item.effect}

{item.effect}

{/if}owned
{/each}
{/if} +
+ {/if} +
+
{latestReward ? `${latestReward.label || "checkpoint"} · ${Number(latestReward.reward || 0).toFixed(3)} reward` : `turn ${activeFrameIndex + 1} / ${activeGroup.frames.length}`}
+ {/if} + {:else}
No structured Balatro state found.
{/if} +
+ + diff --git a/dashboard/TrajectoryViewer.test.mjs b/dashboard/TrajectoryViewer.test.mjs new file mode 100644 index 00000000..17a5b2ee --- /dev/null +++ b/dashboard/TrajectoryViewer.test.mjs @@ -0,0 +1,102 @@ +import assert from "node:assert/strict"; +import { readFileSync } from "node:fs"; +import { createRequire } from "node:module"; +import { resolve } from "node:path"; +import { fileURLToPath, pathToFileURL } from "node:url"; +import test from "node:test"; + +// Use the dashboard's installed Svelte, without a second package/install in +// the game repository. Override for checkouts with a different directory name. +const frontend = process.env.TRAINING_GYM_FRONTEND || fileURLToPath(new URL("../../training-gym/dashboards/frontend", import.meta.url)); +const require = createRequire(resolve(frontend, "package.json")); +const { compile } = require("svelte/compiler"); +const { render } = await import(pathToFileURL(require.resolve("svelte/server"))); +const source = readFileSync(new URL("./TrajectoryViewer.svelte", import.meta.url), "utf8"); +const compiled = compile(source, { generate: "server", filename: "TrajectoryViewer.svelte" }); +const code = compiled.js.code.replace(/from '(svelte[^']*)'/g, (_, id) => `from '${pathToFileURL(require.resolve(id))}'`); +const { default: Viewer } = await import(`data:text/javascript;base64,${Buffer.from(code).toString("base64")}`); +const helpers = new Function(`${source.slice(source.indexOf(" function text("), source.indexOf(" let stateMessages"))}; return { chipProgress, chips, statesFrom, actionsFrom };`)(); + +const blinds = { + small: { name: "Small Blind", type: "small", status: "SELECT", score: 300, tag: "Investment Tag", tag_effect: "After defeating the Boss Blind, gain $25." }, + big: { name: "Big Blind", type: "big", status: "UPCOMING", score: 450, tag: "Coupon Tag", tag_effect: "Initial cards and booster packs in the next shop are free." }, + boss: { name: "The Hook", type: "boss", status: "UPCOMING", score: 600, effect: "Discards 2 random cards per hand played." }, +}; +const initial = { phase: "BLIND_SELECT", ante: 1, round: 0, blinds }; +const stateMessage = (state) => ({ role: "tool", content: `${JSON.stringify(state)}` }); +const htmlFor = (state, action = null) => render(Viewer, { props: { + trajectory: [...(action ? [{ role: "assistant", content: JSON.stringify(action) }] : []), stateMessage(state)], +} }).body; + +test("both Svelte targets compile without warnings", () => { + assert.deepEqual(compiled.warnings, []); + assert.deepEqual(compile(source, { generate: "client" }).warnings, []); +}); + +test("initial blind selection is visible before the first action", () => { + const html = render(Viewer, { props: { trajectory: [{ role: "user", content: `Gamestate: ${JSON.stringify(initial)}` }] } }).body; + for (const label of ["Initial state", "AVAILABLE NOW", "300 chips", "450 chips", "600 chips", "Investment Tag", "gain $25", "Coupon Tag", "Cannot skip the Boss Blind"]) + assert.ok(html.includes(label), label); + assert.ok(!html.includes("No structured Balatro state")); +}); + +test("hand displays explicit scored, required and remaining chips", () => { + const html = htmlFor({ phase: "hand", blind: { type: "big", score: [1200, 2400] } }); + for (const label of ["CHIPS SCORED", "CHIPS REQUIRED TO CLEAR", "CHIPS STILL NEEDED", "1,200", "2,400"]) + assert.ok(html.includes(label), label); +}); + +test("selection resets displayed score instead of inheriting the last hand", () => { + assert.deepEqual(helpers.chipProgress({ ...initial, blind: { score: [999, 300] } }), { + current: 0, target: 300, label: "Small Blind", pending: true, + }); +}); + +test("shop and pack never display stale active-blind chips", () => { + for (const phase of ["shop", "pack"]) { + assert.equal(helpers.chipProgress({ phase, blind: { score: [999, 300] } }), null); + const html = htmlFor({ phase, blind: { score: [999, 300] } }); + assert.ok(html.includes("No active blind score")); + assert.ok(!html.includes("CHIPS SCORED")); + } +}); + +test("zero and missing scores stay distinct; overshoot needs zero more chips", () => { + assert.equal(helpers.chips(0), "0"); + for (const value of [null, undefined, "", "not recorded", Infinity]) assert.equal(helpers.chips(value), "—"); + const html = htmlFor({ phase: "hand", blind: { score: [650, 600] } }); + assert.match(html, /CHIPS STILL NEEDED<\/small>\s*]*>0<\/strong>/); +}); + +test("missing tag effects are acknowledged, not invented", () => { + const html = htmlFor({ ...initial, blinds: { small: { ...blinds.small, tag_effect: null } } }); + assert.ok(html.includes("Effect not recorded in this trajectory.")); +}); + +test("skip outcome shows the earned tag separately from the next offer", () => { + const html = htmlFor({ ...initial, + blinds: { ...blinds, small: { ...blinds.small, status: "SKIPPED" }, big: { ...blinds.big, status: "SELECT" } }, + action_result: { method: "skip", skipped: { name: "Small Blind" }, tag: blinds.small.tag, tag_effect: blinds.small.tag_effect, next: blinds.big }, + }, { method: "skip", params: {} }); + for (const label of ["TAG TAKEN · IN-GAME SKIP REWARD", "Investment Tag", "gain $25", "Coupon Tag", "450 chips required"]) + assert.ok(html.includes(label), label); +}); + +test("a failed skip does not claim a tag was earned", () => { + const html = htmlFor(initial, { method: "skip", params: {} }); + assert.ok(!html.includes("TAG TAKEN · IN-GAME SKIP REWARD")); +}); + +test("initial snapshot seeds sparse deltas without shifting actions", () => { + const messages = [ + { role: "assistant", content: '{"method":"select","params":{}}' }, + stateMessage({ phase: "hand", blind: { type: "small", score: [0, 300] } }), + stateMessage({ blind: null, phase: "shop" }), + ]; + const states = helpers.statesFrom(messages, initial); + assert.equal(states.length, 2); + assert.equal(states[0].ante, 1); + assert.equal(states[0].blinds.small.tag, "Investment Tag"); + assert.equal(states[1].blind, undefined); + assert.deepEqual(helpers.actionsFrom(messages), [{ method: "select", params: {} }]); +}); diff --git a/hi.py b/hi.py new file mode 100644 index 00000000..76e3173a --- /dev/null +++ b/hi.py @@ -0,0 +1,12 @@ +import itertools + +def build(adapters): + units = iter(()) + for lora_name, tensors in adapters: + prefixed = (f"{lora_name}:{t}" for t in tensors) + units = itertools.chain(units, prefixed) + return list(units) # consumption happens here, after the loop + +print(build([("A", ["w1", "w2"]), ("B", ["w1", "w2"])])) +# prints ['B:w1', 'B:w2', 'B:w1', 'B:w2'] +# even though we want ['A:w1', 'A:w2', 'B:w1', 'B:w2'] diff --git a/launch-8node-skip-reward-fix-20260909.json b/launch-8node-skip-reward-fix-20260909.json new file mode 100644 index 00000000..f68fbb62 --- /dev/null +++ b/launch-8node-skip-reward-fix-20260909.json @@ -0,0 +1 @@ +{"state": "submitted", "training_run_id": "perfect-adhesive-da14ace5a831", "modal_app_id": "ap-wtyIJYSq2CfSeJwUqUJK3N", "function_call_id": "fc-01M23SWJV20P6826ZHYH64CFV4"} \ No newline at end of file diff --git a/launch-perfect-batch64-20260914.json b/launch-perfect-batch64-20260914.json new file mode 100644 index 00000000..77c66e31 --- /dev/null +++ b/launch-perfect-batch64-20260914.json @@ -0,0 +1 @@ +{"state": "submitted", "training_run_id": "broad-layover-3a0ce678e7da", "modal_app_id": "ap-3vCPrQh34oPL9P5dsmtUSa", "function_call_id": "fc-01M2HAV5N51FQR76MTYN7KX1KP"} \ No newline at end of file diff --git a/launch-perfect-continuation-20260914.json b/launch-perfect-continuation-20260914.json new file mode 100644 index 00000000..eae60b28 --- /dev/null +++ b/launch-perfect-continuation-20260914.json @@ -0,0 +1 @@ +{"state": "submitted", "training_run_id": "indulgent-inflection-5a69e05e94d9", "modal_app_id": "ap-CxE62tbCf0dqyRkU0xLJsL", "function_call_id": "fc-01M2H54WY72CECY53G86XPQ418"} \ No newline at end of file diff --git a/launch-reward-guard-20260908.json b/launch-reward-guard-20260908.json new file mode 100644 index 00000000..724c9de3 --- /dev/null +++ b/launch-reward-guard-20260908.json @@ -0,0 +1 @@ +{"state": "submitted", "training_run_id": "forward-puffin-82ca43c78d59", "modal_app_id": "ap-NGTekyQwRhnEx4H1ImXCiY", "function_call_id": "fc-01M21QE9FJJH4ERPH3JJ1JBHTZ"} \ No newline at end of file diff --git a/launch-reward-guard-20260908c.json b/launch-reward-guard-20260908c.json new file mode 100644 index 00000000..00abbaa1 --- /dev/null +++ b/launch-reward-guard-20260908c.json @@ -0,0 +1 @@ +{"state": "submitted", "training_run_id": "salty-image-f950e348be06", "modal_app_id": "ap-pCs4oq19MHrDBkBETNLZBs", "function_call_id": "fc-01M21QJ06V10PE8EQYRN7W1MTS"} \ No newline at end of file diff --git a/launch-skip-reward-fix-20260909.json b/launch-skip-reward-fix-20260909.json new file mode 100644 index 00000000..05825242 --- /dev/null +++ b/launch-skip-reward-fix-20260909.json @@ -0,0 +1 @@ +{"state": "submitted", "training_run_id": "zingy-pollen-cc9450b3f685", "modal_app_id": "ap-rApMpmEPA835wi9vKJU7fL", "function_call_id": "fc-01M23NX6C1KQ62VRED9ZARY5RF"} \ No newline at end of file diff --git a/src/lua/core/dispatcher.lua b/src/lua/core/dispatcher.lua index c6642a15..f72ea7b0 100644 --- a/src/lua/core/dispatcher.lua +++ b/src/lua/core/dispatcher.lua @@ -119,7 +119,7 @@ end ---@param message string ---@param error_code string -function BB_DISPATCHER.send_error(message, error_code) +function BB_DISPATCHER.send_error(message, error_code, details) if not BB_DISPATCHER.Server then sendDebugMessage("Cannot send error - Server not initialized", "BB.DISPATCHER") return @@ -127,6 +127,7 @@ function BB_DISPATCHER.send_error(message, error_code) BB_DISPATCHER.Server.send_response({ message = message, name = error_code, + details = details, }) end @@ -188,7 +189,14 @@ function BB_DISPATCHER.dispatch(request) break end end - if not state_valid then + -- MENU is a special case: Balatro normally leaves STATE_COMPLETE false + -- there even when the main-menu UI is fully usable. Gameplay states must + -- still be complete and unlocked before accepting an action. + local state_stable = current_state == (G and G.STATES and G.STATES.MENU) + or (G ~= nil + and G.STATE_COMPLETE == true + and (not G.CONTROLLER or G.CONTROLLER.locked ~= true)) + if not state_valid or not state_stable then local state_names = {} for _, state in ipairs(endpoint.requires_state) do table.insert(state_names, get_state_name(state)) @@ -200,7 +208,13 @@ function BB_DISPATCHER.dispatch(request) ) BB_DISPATCHER.send_error( "Method '" .. request.method .. "' requires one of these states: " .. table.concat(state_names, ", "), - BB_ERROR_NAMES.INVALID_STATE + BB_ERROR_NAMES.INVALID_STATE, + { + current_state = current_state_name, + state_complete = G ~= nil and G.STATE_COMPLETE == true, + controller_locked = G ~= nil and G.CONTROLLER ~= nil and G.CONTROLLER.locked == true, + reason = state_valid and "state_transition_in_progress" or "wrong_state", + } ) return end diff --git a/src/lua/core/server.lua b/src/lua/core/server.lua index cbdeb292..8fc849e7 100644 --- a/src/lua/core/server.lua +++ b/src/lua/core/server.lua @@ -397,7 +397,12 @@ function BB_SERVER.send_response(response) error = { code = error_code, message = response.message, - data = { name = error_name }, + data = { + name = error_name, + -- Endpoints may attach diagnostic context without changing the + -- stable error-name contract used by existing clients. + details = response.details, + }, }, id = BB_SERVER.current_request_id, } diff --git a/src/lua/endpoints/pack.lua b/src/lua/endpoints/pack.lua index d60efa80..b27b0657 100644 --- a/src/lua/endpoints/pack.lua +++ b/src/lua/endpoints/pack.lua @@ -2,6 +2,54 @@ ---@type BB_LOGGER local BB_LOGGER = assert(SMODS.load_file("src/lua/utils/logger.lua"))() +local socket = require("socket") + +-- In fast/headless mode the pack object can be removed on a different frame +-- from the state transition. The destination state and readiness flags are +-- therefore the authoritative completion signal; pack removal is useful +-- corroborating evidence but must not be required for the response. +local function state_stable() + return G.STATE_COMPLETE == true + and (not G.CONTROLLER or G.CONTROLLER.locked ~= true) +end + +local function pack_closed() + return not G.pack_cards + or G.pack_cards.REMOVED + or G.STATE ~= G.STATES.SMODS_BOOSTER_OPENED +end + +local function shop_ready() + return G.STATE == G.STATES.SHOP and state_stable() +end + +-- Packs opened from a Blind tag return to blind selection, not the shop. In +-- fast/headless mode that transition can retain the controller lock longer +-- than the pack UI itself; return it to the Python harness, whose settle() +-- loop owns the readiness wait, instead of misreporting a successful skip as +-- an RPC failure. +local function pack_destination_ready() + return shop_ready() or G.STATE == G.STATES.BLIND_SELECT +end + +local function send_timeout(send_response, operation, started_at) + if socket.gettime() - started_at <= 6 then + return false + end + sendDebugMessage( + string.format("pack() %s timed out in state %s", operation, tostring(G.STATE)), + "BB.ENDPOINTS" + ) + send_response({ + message = string.format( + "Pack %s did not reach a stable destination state (current state: %s)", + operation, + tostring(G.STATE) + ), + name = BB_ERROR_NAMES.INTERNAL_ERROR, + }) + return true +end -- ========================================================================== -- Pack Select Endpoint Params @@ -260,11 +308,12 @@ return { return true end else - -- Pack closes - wait for return to shop - local pack_closed = not G.pack_cards or G.pack_cards.REMOVED - local back_to_shop = G.STATE == G.STATES.SHOP + -- A purchased pack returns to shop; a tag-granted pack returns + -- to blind selection. + local pack_closed_now = pack_closed() + local at_destination = pack_destination_ready() - if pack_closed and back_to_shop then + if pack_closed_now and at_destination then sendDebugMessage("Return pack() after selection", "BB.ENDPOINTS") send_response(BB_GAMESTATE.get_gamestate()) return true @@ -279,24 +328,29 @@ return { -- Handle skip if args.skip then + local started_at = socket.gettime() local pack_count = G.pack_cards.config and G.pack_cards.config.card_count or 0 sendDebugMessage(string.format("Pack: skipping (%d cards remaining)", pack_count), "BB.ENDPOINTS") G.FUNCS.skip_booster({}) - -- Wait for pack to close and return to shop + -- Wait for the destination. Tag-granted packs return to blind select. G.E_MANAGER:add_event(Event({ trigger = "condition", blocking = false, func = function() - local pack_closed = not G.pack_cards or G.pack_cards.REMOVED - local back_to_shop = G.STATE == G.STATES.SHOP + local pack_closed_now = pack_closed() + local at_destination = pack_destination_ready() - if pack_closed and back_to_shop then + if pack_closed_now and at_destination then sendDebugMessage("Return pack() after skip", "BB.ENDPOINTS") send_response(BB_GAMESTATE.get_gamestate()) return true end + if send_timeout(send_response, "skip", started_at) then + return true + end + return false end, })) diff --git a/src/lua/endpoints/play.lua b/src/lua/endpoints/play.lua index 1b9f0a98..2f58d885 100644 --- a/src/lua/endpoints/play.lua +++ b/src/lua/endpoints/play.lua @@ -75,6 +75,17 @@ return { local card_str = BB_LOGGER.format_playing_cards(G.hand.cards, args.cards) sendDebugMessage(string.format("Playing %d cards: %s", #args.cards, card_str), "BB.ENDPOINTS") + local chips_before = G.GAME.chips or 0 + local function send_play_state() + local state_data = BB_GAMESTATE.get_gamestate() + state_data.play_commit = { + cards = args.cards, + score = math.max(0, (G.GAME.chips or chips_before) - chips_before), + hand = G.GAME.last_hand_played, + } + send_response(state_data) + end + ---@diagnostic disable-next-line: undefined-field local play_button = UIBox:get_UIE_by_ID("play_button", G.buttons.UIRoot) assert(play_button ~= nil, "play() play button not found") @@ -87,7 +98,7 @@ return { -- because when G.STATE becomes GAME_OVER, the game sets G.SETTINGS.paused = true, -- which stops all event processing. This callback is set so that love.update -- (which runs even when paused) can detect GAME_OVER immediately. - BB_GAMESTATE.on_game_over = send_response + BB_GAMESTATE.on_game_over = send_play_state G.E_MANAGER:add_event(Event({ trigger = "condition", @@ -124,8 +135,7 @@ return { -- Game is won if G.GAME.won then sendDebugMessage("Return play() - won", "BB.ENDPOINTS") - local state_data = BB_GAMESTATE.get_gamestate() - send_response(state_data) + send_play_state() return true end @@ -144,17 +154,15 @@ return { -- Both first and last scoring rows must be present if has_blind1 and has_cash_out_button then - local state_data = BB_GAMESTATE.get_gamestate() sendDebugMessage("Return play() - cash out", "BB.ENDPOINTS") - send_response(state_data) + send_play_state() return true end end if draw_to_hand and hand_played and G.buttons and G.STATE == G.STATES.SELECTING_HAND then sendDebugMessage("Return play() - same round", "BB.ENDPOINTS") - local state_data = BB_GAMESTATE.get_gamestate() - send_response(state_data) + send_play_state() return true end diff --git a/src/lua/utils/gamestate.lua b/src/lua/utils/gamestate.lua index a7cc2b97..cb8d338b 100644 --- a/src/lua/utils/gamestate.lua +++ b/src/lua/utils/gamestate.lua @@ -729,6 +729,12 @@ function gamestate.get_gamestate() local state_data = { state = get_state_name(G.STATE), + -- These are transport/readiness details for the Python harness. They are + -- deliberately not part of the compact model prompt, but let the client + -- distinguish a stable decision screen from a frame in the middle of a + -- Balatro transition. + state_complete = G.STATE_COMPLETE == true, + controller_locked = G.CONTROLLER and G.CONTROLLER.locked == true or false, } -- Basic game info @@ -788,6 +794,12 @@ function gamestate.get_gamestate() state_data.cards = extract_area(G.deck) end + -- Cards already discarded this round/run. The compact Python prompt sorts + -- this composition, so it does not leak the hidden draw order. + if G.discard then + state_data.discard = extract_area(G.discard) + end + -- Hand (count is 0 during not playing phase) if G.hand then state_data.hand = extract_area(G.hand) @@ -814,6 +826,20 @@ function gamestate.get_gamestate() return state_data end +---Whether the game is ready to accept an action in the requested state. +---@param expected_state integer? +---@return boolean +function gamestate.is_stable(expected_state) + if not G then + return false + end + if expected_state and G.STATE ~= expected_state then + return false + end + return G.STATE_COMPLETE == true + and (not G.CONTROLLER or G.CONTROLLER.locked ~= true) +end + -- ========================================================================== -- GAME_OVER Callback Support -- ========================================================================== diff --git a/src/lua/utils/openrpc.json b/src/lua/utils/openrpc.json index eaea0856..8fabf7e6 100644 --- a/src/lua/utils/openrpc.json +++ b/src/lua/utils/openrpc.json @@ -954,6 +954,10 @@ "$ref": "#/components/schemas/Area", "description": "Cards remaining in deck (available during run)" }, + "discard": { + "$ref": "#/components/schemas/Area", + "description": "Cards already discarded (available during run)" + }, "pack": { "$ref": "#/components/schemas/Area", "description": "Currently open pack (available during pack opening phase)" diff --git a/src/lua/utils/types.lua b/src/lua/utils/types.lua index 53f43b13..96895ae7 100644 --- a/src/lua/utils/types.lua +++ b/src/lua/utils/types.lua @@ -13,6 +13,8 @@ ---@field stake Stake? Current selected stake ---@field seed string? Seed used for the run ---@field state State Current game state +---@field state_complete boolean? Whether the current state has finished loading +---@field controller_locked boolean? Whether Balatro is currently blocking input ---@field round_num integer Current round number ---@field ante_num integer Current ante number ---@field money integer Current money amount @@ -24,6 +26,7 @@ ---@field consumables Area? Consumables area ---@field hand Area? Hand area (available during playing phase) ---@field cards Area? Cards remaining in deck (available during run) +---@field discard Area? Cards already discarded (available during run) ---@field pack Area? Currently open pack (available during opeing pack phase) ---@field shop Area? Shop area (available during shop phase) ---@field vouchers Area? Vouchers area (available during shop phase) diff --git a/tests/test_training_launch.py b/tests/test_training_launch.py new file mode 100644 index 00000000..c91f8779 --- /dev/null +++ b/tests/test_training_launch.py @@ -0,0 +1,173 @@ +"""CPU-only launcher regression tests, without importing the GPU dependencies.""" + +import ast +import json +import os +import re +from pathlib import Path +from types import SimpleNamespace +from unittest.mock import Mock + +import pytest + + +@pytest.fixture +def launcher(): + source = Path(__file__).resolve().parents[1] / "batro_modal_rl.py" + tree = ast.parse(source.read_text()) + selected = { + "_remaining_rollouts", "_launch_training", "_select_resume_checkpoint", + "_checkpoint_iteration", + } + module = ast.Module(body=[ + node for node in tree.body + if isinstance(node, ast.FunctionDef) and node.name in selected + ], type_ignores=[]) + pin = Mock() + manifests = Mock(return_value={"shard": 100}) + checkpoints = Mock() + namespace = { + "TrainConfig": object, "TrainingRun": object, "Checkpoint": object, + "Path": Path, "json": json, "os": os, "re": re, + "_pin_resume_checkpoint": pin, + "_checkpoint_manifest": manifests, + "_checkpoint_manifest_health": Mock(return_value=(True, "complete")), + } + exec(compile(module, str(source), "exec"), namespace) + return SimpleNamespace( + remaining=namespace["_remaining_rollouts"], + launch=namespace["_launch_training"], pin=pin, + select=namespace["_select_resume_checkpoint"], + checkpoints=checkpoints, manifests=manifests, + ) + + +@pytest.mark.parametrize("target", [1, 199, 200]) +def test_empty_resume_rejected(launcher, target): + with pytest.raises(ValueError, match="at least --num-rollout 201"): + launcher.remaining(199, target) + + +@pytest.mark.parametrize("target,expected", [(201, 1), (400, 200)]) +def test_resume_count(launcher, target, expected): + assert launcher.remaining(199, target) == expected + + +def test_checkpoint_zero_is_also_exclusive(launcher): + with pytest.raises(ValueError): + launcher.remaining(0, 1) + assert launcher.remaining(0, 2) == 1 + + +def test_receipt_prevents_duplicate_submission(launcher, tmp_path): + receipt = tmp_path / "launch.json" + run = SimpleNamespace(training_run_id="run", modal_app_id="app", function_call_id="fc") + config = SimpleNamespace(checkpoint="checkpoint", launch=Mock(return_value=run)) + assert launcher.launch(config, receipt) is run + assert json.loads(receipt.read_text()) == { + "state": "submitted", "training_run_id": "run", + "modal_app_id": "app", "function_call_id": "fc", + } + with pytest.raises(RuntimeError, match="No run submitted"): + launcher.launch(config, receipt) + config.launch.assert_called_once() + launcher.pin.assert_called_once_with("checkpoint") + + +@pytest.mark.parametrize("error", [RuntimeError("upload failed"), KeyboardInterrupt()]) +def test_interrupted_submission_is_not_retried(launcher, tmp_path, error): + receipt = tmp_path / "launch.json" + config = SimpleNamespace(checkpoint=None, launch=Mock(side_effect=error)) + with pytest.raises(type(error)): + launcher.launch(config, receipt) + assert json.loads(receipt.read_text())["state"] == "submitting" + with pytest.raises(RuntimeError, match="No run submitted"): + launcher.launch(config, receipt) + config.launch.assert_called_once() + launcher.pin.assert_not_called() + + +def test_partial_receipt_is_safe(launcher, tmp_path): + receipt = tmp_path / "launch.json" + receipt.touch() + config = SimpleNamespace(checkpoint=None, launch=Mock()) + with pytest.raises(RuntimeError, match="No run submitted"): + launcher.launch(config, receipt) + config.launch.assert_not_called() + + +@pytest.mark.parametrize("requested", [None, 199]) +def test_checkpoint_selection_only_reads_two_manifests(launcher, requested): + checkpoints = [SimpleNamespace(name=f"iter_{i:07d}") for i in range(200)] + launcher.checkpoints.return_value = checkpoints + result = SimpleNamespace(training_run_id="run", checkpoints=launcher.checkpoints) + assert launcher.select(result, requested) is checkpoints[-1] + assert launcher.manifests.call_count == 2 + + +def test_missing_checkpoint_does_not_read_manifests(launcher): + launcher.checkpoints.return_value = [SimpleNamespace(name="iter_0000199")] + with pytest.raises(RuntimeError, match="was not found"): + launcher.select( + SimpleNamespace(training_run_id="run", checkpoints=launcher.checkpoints), + 200, + ) + launcher.manifests.assert_not_called() + + +@pytest.fixture +def reward_helpers(): + source = Path(__file__).resolve().parents[1] / "batro_modal_rl.py" + tree = ast.parse(source.read_text()) + selected = {"_progress_value", "_transition_reward_parts"} + module = ast.Module(body=[ + node for node in tree.body + if isinstance(node, ast.FunctionDef) and node.name in selected + ], type_ignores=[]) + namespace = {"Any": object, "ANTE_CHECKPOINT_BONUS": 8.0} + exec(compile(module, str(source), "exec"), namespace) + return SimpleNamespace( + progress=namespace["_progress_value"], + transition=namespace["_transition_reward_parts"], + ) + + +def test_skipped_blind_is_not_rewardable_progress(reward_helpers): + before = { + "ante_num": 1, + "state": "BLIND_SELECT", + "blinds": {"small": {"status": "SELECT"}}, + "round": {"chips": 0}, + } + skipped = { + "ante_num": 1, + "state": "BLIND_SELECT", + "blinds": { + "small": {"status": "SKIPPED"}, + "big": {"status": "SELECT"}, + }, + "round": {"chips": 0}, + } + defeated = { + "ante_num": 1, + "state": "SHOP", + "blinds": { + "small": {"status": "DEFEATED"}, + "big": {"status": "SELECT"}, + }, + "round": {"chips": 0}, + } + assert reward_helpers.progress(skipped) == (0, 0.0) + assert reward_helpers.transition(before, skipped, valid_action=True)["total"] == 0.0 + assert reward_helpers.transition(before, defeated, valid_action=True)["total"] == 0.0 + + playing = {**before, "state": "SELECTING_HAND", "round": {"chips": 120}} + assert reward_helpers.transition(playing, defeated, valid_action=True)["total"] == 4.0 + + # Advancing after a boss clear must not reconstruct two previously skipped + # blinds from the new ante number. + after_boss = {**defeated, "ante_num": 2} + parts = reward_helpers.transition(playing, after_boss, valid_action=True) + assert parts["progress"] == 1.0 + assert parts["blind_clear_bonus"] == 3.0 + assert parts["ante_checkpoint_bonus"] == 8.0 From d3fc0d425a26793845d1fecb0c072ed78b45af15 Mon Sep 17 00:00:00 2001 From: Joy Liu Date: Tue, 15 Sep 2026 00:34:49 -0400 Subject: [PATCH 3/7] :new: Better balatro visualization --- batro_modal_rl.py | 36 +- dashboard/README.md | 85 + dashboard/THIRD_PARTY_NOTICES.md | 42 + dashboard/TrajectoryViewer.svelte | 2635 ++++++++++++++++++++++++++- dashboard/TrajectoryViewer.test.mjs | 271 ++- reports/broad-layover-2026-09-15.md | 149 ++ src/lua/endpoints/pack.lua | 22 + src/lua/utils/gamestate.lua | 27 + src/lua/utils/openrpc.json | 16 + src/lua/utils/types.lua | 6 + tests/test_joker_scoring_state.py | 75 + tests/test_pack_legality.py | 95 + tests/test_training_launch.py | 58 +- 13 files changed, 3411 insertions(+), 106 deletions(-) create mode 100644 dashboard/THIRD_PARTY_NOTICES.md create mode 100644 reports/broad-layover-2026-09-15.md create mode 100644 tests/test_joker_scoring_state.py create mode 100644 tests/test_pack_legality.py diff --git a/batro_modal_rl.py b/batro_modal_rl.py index 410f9521..a57e2f08 100644 --- a/batro_modal_rl.py +++ b/batro_modal_rl.py @@ -558,8 +558,8 @@ def _get_env_pool() -> BalatroEnvironmentPool: # Agent prompt, action parsing, and episode reward # --------------------------------------------------------------------------- -# A completed ante is a useful curriculum checkpoint, but winning ante 8 must -# remain substantially more valuable than any collection of partial rewards. +# Base for first-clear ante rewards: ante k pays k * this value. Re-clearing +# an ante after a lowering voucher pays no additional ante checkpoint bonus. ANTE_CHECKPOINT_BONUS = 8.0 FINAL_ANTE = 8 # A complete action budget is evidence that the policy failed to finish the @@ -664,6 +664,10 @@ def card_view(card: Any, *, playing_card: bool = False, owned: bool = False) -> return {name: item for name, item in view.items() if item is not None} view = {"id": key, "effect": card.get("effect") or value.get("effect")} + # Already-visible round targets (Idol/Ancient/Mail/Castle), not RNG + # seeds. Keep these structured so replay scoring never guesses them. + if isinstance(card.get("scoring_state"), dict): + view["scoring_state"] = card["scoring_state"] if modifier: view["mod"] = modifier cost = card.get("cost") @@ -1448,7 +1452,7 @@ def _episode_reward_parts( ante_checkpoints = max(0, ante - 1) if state.get("won"): ante_checkpoints = max(ante_checkpoints, FINAL_ANTE) - ante_checkpoint_bonus = float(ANTE_CHECKPOINT_BONUS * ante_checkpoints) + ante_checkpoint_bonus = _ante_clear_reward(0, ante_checkpoints) # Formatting a legal JSON action is a prerequisite, not game progress. # Rewarding it made repeatable no-op actions (notably rearrange) a policy # objective. Keep the metric field for dashboard compatibility at zero. @@ -1525,12 +1529,18 @@ def _progress_value(state: dict[str, Any]) -> tuple[int, float]: return blinds_completed, fraction +def _ante_clear_reward(previous_highest: int, highest: int) -> float: + """Pay N * ante once per newly cleared ante, not per selector crossing.""" + return float(ANTE_CHECKPOINT_BONUS * sum(range(previous_highest + 1, highest + 1))) + + def _transition_reward_parts( previous_state: dict[str, Any], state: dict[str, Any], *, valid_action: bool, invalid_events: int = 0, + highest_rewarded_ante: int = 0, ) -> dict[str, float]: """Shape reward from one environment transition. @@ -1557,8 +1567,12 @@ def _transition_reward_parts( blind_clear_delta = 3.0 if blind_defeated else 0.0 previous_ante = max(1, int(previous_state.get("ante_num") or 1)) ante = max(1, int(state.get("ante_num") or 1)) - ante_checkpoints = max(0, ante - previous_ante) - ante_checkpoint_bonus = float(ANTE_CHECKPOINT_BONUS * ante_checkpoints) + # The caller carries this high-water mark across the whole episode. A + # Hieroglyph/Petroglyph purchase must not make an old ante rewardable again. + previous_highest = max(highest_rewarded_ante, previous_ante - 1) + highest = max(previous_highest, ante - 1) + ante_checkpoints = highest - previous_highest + ante_checkpoint_bonus = _ante_clear_reward(previous_highest, highest) # Legal syntax alone is not a rewardable transition. legal_bonus = 0.0 invalid_penalty = -2.0 * max(0, int(invalid_events)) @@ -1567,6 +1581,7 @@ def _transition_reward_parts( "blind_clear_bonus": blind_clear_delta, "ante_checkpoint_bonus": ante_checkpoint_bonus, "ante_checkpoints": ante_checkpoints, + "highest_rewarded_ante": highest, "blind_clear_count": int(blind_defeated), "legal_action_bonus": legal_bonus, "invalid_penalty": invalid_penalty, @@ -1926,6 +1941,7 @@ def append_tool_feedback(feedback: str) -> bool: "invalid_penalty": 0.0, } ante_checkpoints = 0 + highest_rewarded_ante = 0 partial_reward_steps = 0 # Keep checkpoint-window rewards separate from the episode accumulators. # A blind-clear event credits everything earned since the previous blind @@ -2190,10 +2206,12 @@ def _append_checkpoint_event( state, valid_action=not invalid and not api_error, invalid_events=int(invalid) + int(bool(api_error)), + highest_rewarded_ante=highest_rewarded_ante, ) for key in partial_reward_parts: partial_reward_parts[key] += transition_rewards[key] ante_checkpoints += int(transition_rewards["ante_checkpoints"]) + highest_rewarded_ante = int(transition_rewards["highest_rewarded_ante"]) partial_reward_steps += 1 _add_pending(blind_reward_pending, transition_rewards) _add_pending(ante_reward_pending, transition_rewards) @@ -2286,9 +2304,10 @@ def _append_checkpoint_event( # double-counting if the environment has already advanced the ante. final_ante = max(1, int(state.get("ante_num") or 1)) expected_checkpoints = min(FINAL_ANTE, final_ante) - if state.get("won") and ante_checkpoints < expected_checkpoints: - missing_checkpoints = expected_checkpoints - ante_checkpoints - checkpoint_reward = ANTE_CHECKPOINT_BONUS * missing_checkpoints + if state.get("won") and highest_rewarded_ante < expected_checkpoints: + missing_checkpoints = expected_checkpoints - highest_rewarded_ante + checkpoint_reward = _ante_clear_reward(highest_rewarded_ante, expected_checkpoints) + highest_rewarded_ante = expected_checkpoints partial_reward_parts["ante_checkpoint_bonus"] += checkpoint_reward ante_checkpoints += missing_checkpoints ante_reward_pending["ante_checkpoint_bonus"] += checkpoint_reward @@ -2350,6 +2369,7 @@ def _append_checkpoint_event( "reward_checkpoint_events": len(partial_reward_trace), "ante_checkpoints": ante_checkpoints, "partial_reward_trace": partial_reward_trace, + "highest_rewarded_ante": highest_rewarded_ante, "final_ante": final_ante, "final_round": final_round, "won": won, diff --git a/dashboard/README.md b/dashboard/README.md index eb8b2440..25bd4c52 100644 --- a/dashboard/README.md +++ b/dashboard/README.md @@ -24,3 +24,88 @@ Run compiler and rendered-output regression tests with `node --test dashboard/TrajectoryViewer.test.mjs`. This uses Svelte installed in `../training-gym/dashboards/frontend`; set `TRAINING_GYM_FRONTEND` to override that location. + +## Card rendering + +Playing cards and all 150 standard jokers use the sprite atlases and layering +approach from EFHIII's Balatro Calculator, pinned to commit +`55322d59197ba08c16874a54b59ac0d443c8ab32`. Enhancement backgrounds, rank/suit +art, legendary-joker overlays, edition textures, seals and debuff crosses are +composed separately. Polychrome uses the calculator's color blend; Negative +uses an inverted-art treatment. Unknown/modded cards retain a text fallback. +Modifier badges remain visible, including stickers and remaining perishable +rounds. Hover is optional, not required to identify a modifier. + +The four PNG atlases are embedded once as CSS variables in the single-file +component, so viewing a trajectory makes no external image requests. See +[THIRD_PARTY_NOTICES.md](THIRD_PARTY_NOTICES.md) for attribution and license. +## UI-only calculator and joker information + +The viewer now embeds the pinned upstream `balatro-sim.js` scoring logic, +wrapped to isolate mutable hand-value tables between calculations. The only +change inside the upstream implementation is a Svelte performance-warning +annotation; no scoring rules are rewritten. Its result is an **estimate**, +not an engine RPC or a claim of full Balatro accuracy. + +Click 1–5 cards in play order, then **Calculate**. The compact HUD displays +hand type, Chips × Mult, and the upstream worst/best range for random effects. +Recorded play frames calculate automatically. Their actual `play_commit.score` +is shown separately and remains visible even when calculator inputs are missing. +Discard frames highlight the removed pre-action cards in red, independently +of calculator selection. The discard-pile button opens its card inventory. +Historical plays use pre-action cards, jokers, and hand values. Joker order +stays as recorded; this UI does not optimize, commit a play, call a model, +or change harness rewards. Calculations never mutate trajectory state. + +Counters not present in the compact trace must be entered explicitly in the +same units as the upstream calculator (for example Hologram's *Cards Added*, +not its Mult). Known money/discard counters are populated from the trace. +Unsupported cards/jokers block calculation; missing persistent card bonuses +and unmodeled boss/deck effects remain limitations. Flint, Eye, Plasma Deck, +and Observatory settings are available for inspection/editing. Missing hand +levels/history default to level 1 / zero, as in the upstream calculator. + +The Lua gamestate RPC exports `card.scoring_state.target` for The Idol, +Ancient Joker, Mail-In Rebate and Castle, plus Castle's current chip tally. +The compact harness preserves this in each joker's snapshot and sparse deltas. +These are already-selected, player-visible targets—not RNG seeds or future +draws. The calculator converts rank/suit to its internal Card/Suit ID, so no +manual ID is needed. For older traces, exact English target descriptions can +be recovered from recorded effect text. Unknown targets remain unknown; +current live targets are never substituted into historical frames. +Structured capture requires newly built sandboxes; existing running training +workers are not hot-patched by a dashboard upload. + +Joker sprites have hover/focus/tap tooltips with the recorded effect, edition +bonuses, stickers, and sell value. Escape dismisses a focused tooltip. + +## Compact game layout + +The layout follows Balatro's game board: score/status HUD on the left, jokers +and consumables across the top, phase-specific content in the center, hand +and deck inspection below. It uses the embedded m6x11plus pixel font, +blue/red Chips × Mult blocks, chunky controls, and a muted felt table. +Container queries adapt to the dashboard panel's width, not just the window. + +The replay navigation stays expanded above the board, with ante/round/phase +tabs and individual turn buttons for the selected group. Previous/next buttons +can cross group boundaries. There is no continuous frame scrubber. +**Run info**, **Calculator**, and **Trace & rewards** open an inspector below +the board. Deck/discard contents, vouchers, joker counters, hand levels, +calculator settings, raw pre/post-action states and reward events remain +available without keeping every panel expanded. Rewards are explicitly +episode-wide rather than falsely aligned to the selected frame. + +Run Info sections start collapsed, including the empty owned-voucher message. +Expanding inventory sections shows card racks with modifiers and click-to-open +details; raw fields remain under **Recorded data**. Poker hand levels and +history use a compact table, with missing values shown as dashes. The board's +deck/discard buttons still expand the corresponding section directly. + +Shop cards, prices, vouchers, booster offers and reroll cost are visible in +shop frames; pack frames show their choices. Item details retain all recorded +fields. Non-playing, non-joker cards currently use labeled symbolic tiles. +The top inventory and HUD always show the resulting state; historical play +inputs below are explicitly labeled pre-action. Discards left is distinct +from the discard pile size. Unknown counters display a dash, not a guessed +value. No training settings, harness behavior or rewards change with this UI. diff --git a/dashboard/THIRD_PARTY_NOTICES.md b/dashboard/THIRD_PARTY_NOTICES.md new file mode 100644 index 00000000..0d2caf43 --- /dev/null +++ b/dashboard/THIRD_PARTY_NOTICES.md @@ -0,0 +1,42 @@ +# Balatro Calculator rendering assets + +The embedded `m6x11plus.ttf` font is by Daniel Linssen, distributed via the +same pinned calculator repository. Its author's page permits use with +attribution: https://managore.itch.io/m6x11 . The viewer footer includes this +credit. The calculator's MIT notice below does not replace the font credit. + +Card atlas coordinates, sprite sheets, scoring logic, value-input labels, +and the layered rendering approach +are adapted from [EFHIII/balatro-calculator](https://github.com/EFHIII/balatro-calculator) +at commit `55322d59197ba08c16874a54b59ac0d443c8ab32`. + +Included atlases: `8BitDeck.png`, `Jokers.png`, `Enhancers.png`, `Editions.png`. +They are embedded into `TrajectoryViewer.svelte` because Training Gym uploads +a single-file component. `balatro-sim.js` is embedded with its scoring logic +unchanged, plus a Svelte compiler annotation. No external image or code +requests are made when calculating. Original Balatro artwork remains the property of its +respective rights holders; the upstream project's license is reproduced below. + +``` +MIT License + +Copyright (c) 2024 Saffron Haas + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +``` diff --git a/dashboard/TrajectoryViewer.svelte b/dashboard/TrajectoryViewer.svelte index 86d47c95..df17f791 100644 --- a/dashboard/TrajectoryViewer.svelte +++ b/dashboard/TrajectoryViewer.svelte @@ -10,6 +10,1952 @@ run = null, } = $props(); + // Sprite coordinates and compositing adapted from EFHIII/balatro-calculator. + // MIT © 2024 Saffron Haas; see dashboard/THIRD_PARTY_NOTICES.md. + /* MIT License + + Copyright (c) 2024 Saffron Haas + + Permission is hereby granted, free of charge, to any person obtaining a copy + of this software and associated documentation files (the "Software"), to deal + in the Software without restriction, including without limitation the rights + to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + copies of the Software, and to permit persons to whom the Software is + furnished to do so, subject to the following conditions: + + The above copyright notice and this permission notice shall be included in all + copies or substantial portions of the Software. + + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + SOFTWARE. */ + // Pinned upstream commit: 55322d59197ba08c16874a54b59ac0d443c8ab32. + // Embedded because run-scoped dashboard components are single-file artifacts. + const CARD_ATLASES = {"8BitDeck":"data:image/png;base64,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","Jokers":"data:image/png;base64,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","Enhancers":"data:image/png;base64,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","Editions":"data:image/png;base64,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"}; + const JOKER_SPRITES = {"j_joker":{"x":0,"y":0},"j_greedy_joker":{"x":6,"y":1},"j_lusty_joker":{"x":7,"y":1},"j_wrathful_joker":{"x":8,"y":1},"j_gluttenous_joker":{"x":9,"y":1},"j_jolly":{"x":2,"y":0},"j_zany":{"x":3,"y":0},"j_mad":{"x":4,"y":0},"j_crazy":{"x":5,"y":0},"j_droll":{"x":6,"y":0},"j_sly":{"x":0,"y":14},"j_wily":{"x":1,"y":14},"j_clever":{"x":2,"y":14},"j_devious":{"x":3,"y":14},"j_crafty":{"x":4,"y":14},"j_half":{"x":7,"y":0},"j_stencil":{"x":2,"y":5},"j_four_fingers":{"x":6,"y":6},"j_mime":{"x":4,"y":1},"j_credit_card":{"x":5,"y":1},"j_ceremonial":{"x":5,"y":5},"j_banner":{"x":1,"y":2},"j_mystic_summit":{"x":2,"y":2},"j_marble":{"x":3,"y":2},"j_loyalty_card":{"x":4,"y":2},"j_8_ball":{"x":0,"y":5},"j_misprint":{"x":6,"y":2},"j_dusk":{"x":4,"y":7},"j_raised_fist":{"x":8,"y":2},"j_chaos":{"x":1,"y":0},"j_fibonacci":{"x":1,"y":5},"j_steel_joker":{"x":7,"y":2},"j_scary_face":{"x":2,"y":3},"j_abstract":{"x":3,"y":3},"j_delayed_grat":{"x":4,"y":3},"j_hack":{"x":5,"y":2},"j_pareidolia":{"x":6,"y":3},"j_gros_michel":{"x":7,"y":6},"j_even_steven":{"x":8,"y":3},"j_odd_todd":{"x":9,"y":3},"j_scholar":{"x":0,"y":4},"j_business":{"x":1,"y":4},"j_supernova":{"x":2,"y":4},"j_ride_the_bus":{"x":1,"y":6},"j_space":{"x":3,"y":5},"j_egg":{"x":0,"y":10},"j_burglar":{"x":1,"y":10},"j_blackboard":{"x":2,"y":10},"j_runner":{"x":3,"y":10},"j_ice_cream":{"x":4,"y":10},"j_dna":{"x":5,"y":10},"j_splash":{"x":6,"y":10},"j_blue_joker":{"x":7,"y":10},"j_sixth_sense":{"x":8,"y":10},"j_constellation":{"x":9,"y":10},"j_hiker":{"x":0,"y":11},"j_faceless":{"x":1,"y":11},"j_green_joker":{"x":2,"y":11},"j_superposition":{"x":3,"y":11},"j_todo_list":{"x":4,"y":11},"j_cavendish":{"x":5,"y":11},"j_card_sharp":{"x":6,"y":11},"j_red_card":{"x":7,"y":11},"j_madness":{"x":8,"y":11},"j_square":{"x":9,"y":11},"j_seance":{"x":0,"y":12},"j_riff_raff":{"x":1,"y":12},"j_vampire":{"x":2,"y":12},"j_shortcut":{"x":3,"y":12},"j_hologram":{"x":4,"y":12,"soul":[2,9]},"j_vagabond":{"x":5,"y":12},"j_baron":{"x":6,"y":12},"j_cloud_9":{"x":7,"y":12},"j_rocket":{"x":8,"y":12},"j_obelisk":{"x":9,"y":12},"j_midas_mask":{"x":0,"y":13},"j_luchador":{"x":1,"y":13},"j_photograph":{"x":2,"y":13},"j_gift":{"x":3,"y":13},"j_turtle_bean":{"x":4,"y":13},"j_erosion":{"x":5,"y":13},"j_reserved_parking":{"x":6,"y":13},"j_mail":{"x":7,"y":13},"j_to_the_moon":{"x":8,"y":13},"j_hallucination":{"x":9,"y":13},"j_fortune_teller":{"x":7,"y":5},"j_juggler":{"x":0,"y":1},"j_drunkard":{"x":1,"y":1},"j_stone":{"x":9,"y":0},"j_golden":{"x":9,"y":2},"j_lucky_cat":{"x":5,"y":14},"j_baseball":{"x":6,"y":14},"j_bull":{"x":7,"y":14},"j_diet_cola":{"x":8,"y":14},"j_trading":{"x":9,"y":14},"j_flash":{"x":0,"y":15},"j_popcorn":{"x":1,"y":15},"j_trousers":{"x":4,"y":15},"j_ancient":{"x":7,"y":15},"j_ramen":{"x":2,"y":15},"j_walkie_talkie":{"x":8,"y":15},"j_selzer":{"x":3,"y":15},"j_castle":{"x":9,"y":15},"j_smiley":{"x":6,"y":15},"j_campfire":{"x":5,"y":15},"j_ticket":{"x":5,"y":3},"j_mr_bones":{"x":3,"y":4},"j_acrobat":{"x":2,"y":1},"j_sock_and_buskin":{"x":3,"y":1},"j_swashbuckler":{"x":9,"y":5},"j_troubadour":{"x":0,"y":2},"j_certificate":{"x":8,"y":8},"j_smeared":{"x":4,"y":6},"j_throwback":{"x":5,"y":7},"j_hanging_chad":{"x":9,"y":6},"j_rough_gem":{"x":9,"y":7},"j_bloodstone":{"x":0,"y":8},"j_arrowhead":{"x":1,"y":8},"j_onyx_agate":{"x":2,"y":8},"j_glass":{"x":1,"y":3},"j_ring_master":{"x":6,"y":5},"j_flower_pot":{"x":0,"y":6},"j_blueprint":{"x":0,"y":3},"j_wee":{"x":0,"y":0},"j_merry_andy":{"x":8,"y":0},"j_oops":{"x":5,"y":6},"j_idol":{"x":6,"y":7},"j_seeing_double":{"x":4,"y":4},"j_matador":{"x":4,"y":5},"j_hit_the_road":{"x":8,"y":5},"j_duo":{"x":5,"y":4},"j_trio":{"x":6,"y":4},"j_family":{"x":7,"y":4},"j_order":{"x":8,"y":4},"j_tribe":{"x":9,"y":4},"j_stuntman":{"x":8,"y":6},"j_invisible":{"x":1,"y":7},"j_brainstorm":{"x":7,"y":7},"j_satellite":{"x":8,"y":7},"j_shoot_the_moon":{"x":2,"y":6},"j_drivers_license":{"x":0,"y":7},"j_cartomancer":{"x":7,"y":3},"j_astronomer":{"x":2,"y":7},"j_burnt":{"x":3,"y":7},"j_bootstraps":{"x":9,"y":8},"j_Canio":{"x":3,"y":8,"soul":[3,9]},"j_triboulet":{"x":4,"y":8,"soul":[4,9]},"j_yorick":{"x":5,"y":8,"soul":[5,9]},"j_chicot":{"x":6,"y":8,"soul":[6,9]},"j_perkeo":{"x":7,"y":8,"soul":[7,9]}}; + + const CALCULATOR_JOKERS = {"0":{"name":"Joker","label":null},"1":{"name":"Chaos the Clown","label":null},"2":{"name":"Jolly Joker","label":null},"3":{"name":"Zany Joker","label":null},"4":{"name":"Mad Joker","label":null},"5":{"name":"Crazy Joker","label":null},"6":{"name":"Droll Joker","label":null},"7":{"name":"Half Joker","label":null},"8":{"name":"Merry Andy","label":null},"9":{"name":"Stone Joker","label":"Stone Cards"},"10":{"name":"Juggler","label":null},"11":{"name":"Drunkard","label":null},"12":{"name":"Acrobat","label":"Active?"},"13":{"name":"Sock and Buskin","label":null},"14":{"name":"Mime","label":null},"15":{"name":"Credit Card","label":null},"16":{"name":"Greedy Joker","label":null},"17":{"name":"Lusty Joker","label":null},"18":{"name":"Wrathful Joker","label":null},"19":{"name":"Gluttonous Joker","label":null},"20":{"name":"Troubadour","label":null},"21":{"name":"Banner","label":"Discards"},"22":{"name":"Mystic Summit","label":"Active?"},"23":{"name":"Marble Joker","label":null},"24":{"name":"Loyalty Card","label":"Remaining"},"25":{"name":"Hack","label":null},"26":{"name":"Misprint","label":null},"27":{"name":"Steel Joker","label":"Steel Cards"},"28":{"name":"Raised Fist","label":null},"29":{"name":"Golden Joker","label":null},"30":{"name":"Blueprint","label":null},"31":{"name":"Glass Joker","label":"Glass Cards Destroyed"},"32":{"name":"Scary Face","label":null},"33":{"name":"Abstract Joker","label":null},"34":{"name":"Delayed Gratification","label":null},"35":{"name":"Golden Ticket","label":null},"36":{"name":"Pareidolia","label":null},"37":{"name":"Cartomancer","label":null},"38":{"name":"Even Steven","label":null},"39":{"name":"Odd Todd","label":null},"40":{"name":"Wee Joker","label":"Scored 2s"},"41":{"name":"Business Card","label":null},"42":{"name":"Supernova","label":null},"43":{"name":"Mr. Bones","label":null},"44":{"name":"Seeing Double","label":null},"45":{"name":"The Duo","label":null},"46":{"name":"The Trio","label":null},"47":{"name":"The Family","label":null},"48":{"name":"The Order","label":null},"49":{"name":"The Tribe","label":null},"50":{"name":"8 Ball","label":null},"51":{"name":"Fibonacci","label":null},"52":{"name":"Joker Stencil","label":"Other Empty Slots"},"53":{"name":"Space Joker","label":null},"54":{"name":"Matador","label":null},"55":{"name":"Ceremonial Dagger","label":"Mult"},"56":{"name":"Showman","label":null},"57":{"name":"Fortune Teller","label":"Tarots Used"},"58":{"name":"Hit the Road","label":"Jacks Discarded"},"59":{"name":"Swashbuckler","label":null},"60":{"name":"Flower Pot","label":null},"61":{"name":"Ride the Bus","label":"Consecutive Hands Played"},"62":{"name":"Shoot the Moon","label":null},"63":{"name":"Scholar","label":null},"64":{"name":"Smeared Joker","label":null},"65":{"name":"Oops! All 6s","label":null},"66":{"name":"Four Fingers","label":null},"67":{"name":"Gros Michel","label":null},"68":{"name":"Stuntman","label":null},"69":{"name":"Hanging Chad","label":null},"70":{"name":"Driver's License","label":"Enhanced Cards"},"71":{"name":"Invisible Joker","label":"Rounds"},"72":{"name":"Astronomer","label":null},"73":{"name":"Burnt Joker","label":null},"74":{"name":"Dusk","label":"Active?"},"75":{"name":"Throwback","label":"Skipped Blinds"},"76":{"name":"The Idol","label":"Card ID"},"77":{"name":"Brainstorm","label":null},"78":{"name":"Satellite","label":"Unique Planet Cards"},"79":{"name":"Rough Gem","label":null},"80":{"name":"Bloodstone","label":null},"81":{"name":"Arrowhead","label":null},"82":{"name":"Onyx Agate","label":null},"83":{"name":"Canio","label":"Destroyed Face Cards"},"84":{"name":"Triboulet","label":null},"85":{"name":"Yorick","label":"X Mult"},"86":{"name":"Chicot","label":null},"87":{"name":"Perkeo","label":null},"88":{"name":"Certificate","label":null},"89":{"name":"Bootstraps","label":"Mult of $5"},"100":{"name":"Egg","label":null},"101":{"name":"Burglar","label":null},"102":{"name":"Blackboard","label":null},"103":{"name":"Runner","label":"Straights Played"},"104":{"name":"Ice Cream","label":"Hands Played"},"105":{"name":"DNA","label":null},"106":{"name":"Splash","label":null},"107":{"name":"Blue Joker","label":"Cards Remaining"},"108":{"name":"Sixth Sense","label":null},"109":{"name":"Constellation","label":"Planet Cards"},"110":{"name":"Hiker","label":null},"111":{"name":"Faceless Joker","label":null},"112":{"name":"Green Joker","label":"Mult"},"113":{"name":"Superposition","label":null},"114":{"name":"To Do List","label":"Hand Type"},"115":{"name":"Cavendish","label":null},"116":{"name":"Card Sharp","label":null},"117":{"name":"Red Card","label":"Skipped Packs"},"118":{"name":"Madness","label":"Blinds Selected"},"119":{"name":"Square Joker","label":"4 Card Hands"},"120":{"name":"Séance","label":null},"121":{"name":"Riff-raff","label":null},"122":{"name":"Vampire","label":"Enhanced Cards Played"},"123":{"name":"Shortcut","label":null},"124":{"name":"Hologram","label":"Cards Added"},"125":{"name":"Vagabond","label":null},"126":{"name":"Baron","label":null},"127":{"name":"Cloud 9","label":"9s in Deck"},"128":{"name":"Rocket","label":null},"129":{"name":"Obelisk","label":"Consecutive Hands Played"},"130":{"name":"Midas Mask","label":null},"131":{"name":"Luchador","label":null},"132":{"name":"Photograph","label":null},"133":{"name":"Gift Card","label":null},"134":{"name":"Turtle Bean","label":null},"135":{"name":"Erosion","label":"Cards Below 52"},"136":{"name":"Reserved Parking","label":null},"137":{"name":"Mail-In Rebate","label":null},"138":{"name":"To the Moon","label":null},"139":{"name":"Hallucination","label":null},"140":{"name":"Sly Joker","label":null},"141":{"name":"Wily Joker","label":null},"142":{"name":"Clever Joker","label":null},"143":{"name":"Devious Joker","label":null},"144":{"name":"Crafty Joker","label":null},"145":{"name":"Lucky Cat","label":"Lucky Triggers"},"146":{"name":"Baseball Card","label":null},"147":{"name":"Bull","label":"Money"},"148":{"name":"Diet Cola","label":null},"149":{"name":"Trading Card","label":null},"150":{"name":"Flash Card","label":"Rerolls"},"151":{"name":"Popcorn","label":"Rounds Played"},"152":{"name":"Ramen","label":"Cards Discarded"},"153":{"name":"Seltzer","label":"Hands Played"},"154":{"name":"Spare Trousers","label":"Two Pairs Played"},"155":{"name":"Campfire","label":"Cards Sold"},"156":{"name":"Smiley Face","label":null},"157":{"name":"Ancient Joker","label":"Suit ID"},"158":{"name":"Walkie Talkie","label":null},"159":{"name":"Castle","label":"Matching Discarded Cards"}}; + const CALCULATOR_HANDS = ["Flush Five", "Flush House", "Five of a Kind", "Straight Flush", "Four of a Kind", "Full House", "Flush", "Straight", "Three of a Kind", "Two Pair", "Pair", "High Card"]; + // BEGIN UPSTREAM ENGINE — unchanged balatro-sim.js scoring logic at the pinned commit. + function upstreamCalculator() { +"use strict"; + +const handChips = [ + [160, 16, 50, 3], + [140, 14, 40, 4], + [120, 12, 35, 3], + [100, 8, 40, 4], + [ 60, 7, 30, 3], + [ 40, 4, 25, 2], + [ 35, 4, 15, 2], + [ 30, 4, 30, 3], + [ 30, 3, 20, 2], + [ 20, 2, 20, 1], + [ 10, 2, 15, 1], + [ 5, 1, 10, 1] +]; + +const jokerCosts = [ + 2, 4, 3, 4, 4, 4, 4, 5, 7, 6, + 4, 4, 6, 6, 5, 1, 5, 5, 5, 5, + 6, 5, 5, 6, 5, 6, 4, 7, 5, 6, + 10, 6, 4, 4, 4, 5, 5, 6, 4, 4, + 8, 4, 5, 5, 6, 8, 8, 8, 8, 8, + 5, 8, 8, 5, 7, 6, 5, 6, 8, 4, + 6, 6, 5, 4, 7, 4, 7, 5, 7, 4, + 7, 8, 8, 6, 5, 6, 6,10, 6, 7, + 7, 7, 7,20,20,20,20,20, 6, 7, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 4, 6, 6, 5, 5, 8, 3, 5, 6, 6, + 5, 4, 4, 4, 4, 4, 6, 5, 7, 4, + 6, 6, 7, 7, 7, 8, 8, 7, 6, 8, + 7, 5, 5, 6, 6, 6, 6, 4, 5, 4, + 3, 4, 4, 4, 4, 6, 8, 6, 6, 6, + 5, 5, 6, 6, 6, 9, 4, 8, 4, 6 +]; + +const jokerRarity = [ + 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, + 1, 1, 2, 2, 2, 1, 1, 1, 1, 1, + 2, 1, 1, 2, 2, 2, 1, 2, 1, 1, + 3, 2, 1, 1, 1, 1, 2, 2, 1, 1, + 3, 1, 1, 2, 2, 3, 3, 3, 3, 3, + 1, 2, 2, 2, 2, 2, 2, 1, 3, 1, + 2, 1, 1, 1, 2, 2, 2, 1, 3, 1, + 3, 3, 2, 3, 2, 2, 2, 3, 2, 2, + 2, 2, 2, 4, 4, 4, 4, 4, 2, 2, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1, 2, 2, 1, 1, 3, 1, 1, 2, 2, + 2, 1, 1, 1, 1, 1, 2, 1, 2, 1, + 2, 1, 2, 2, 2, 3, 3, 2, 2, 3, + 2, 2, 1, 2, 2, 2, 1, 1, 2, 1, + 1, 1, 1, 1, 1, 2, 3, 2, 2, 2, + 2, 1, 2, 2, 2, 3, 1, 3, 1, 2 +]; + +const powersOfTen = []; +for(let i = 0; i < 632; i++) { + powersOfTen.push(10 ** (i - 323)); +} + +// Lots of constants +const FLUSH_FIVE = 0; +const FLUSH_HOUSE = 1; +const FIVE_OF_A_KIND = 2; +const STRAIGHT_FLUSH = 3; +const FOUR_OF_A_KIND = 4; +const FULL_HOUSE = 5; +const FLUSH = 6; +const STRAIGHT = 7; +const THREE_OF_A_KIND = 8; +const TWO_PAIR = 9; +const PAIR = 10; +const HIGH_CARD = 11; + +const _2 = 0; +const _3 = 1; +const _4 = 2; +const _5 = 3; +const _6 = 4; +const _7 = 5; +const _8 = 6; +const _9 = 7; +const _10 = 8; +const JACK = 9; +const QUEEN = 10; +const KING = 11; +const ACE = 12; + +const HEARTS = 0; +const CLUBS = 1; +const DIAMONDS = 2; +const SPADES = 3; + +const GOLD_SEAL = 1; +const RED_SEAL = 2; +const BLUE_SEAL = 3; +const PURPLE_SEAL = 4; + +const FOIL = 1; +const HOLOGRAPHIC = 2; +const POLYCHROME = 3; +const NEGATIVE = 4; + +const BOUNS = 1; +const MULT = 2; +const WILD = 3; +const GLASS = 4; +const STEEL = 5; +const STONE = 6; +const GOLD = 7; +const LUCKY = 8; + +const RANK = 0; +const SUIT = 1; +const EDITION = 2; +const ENHANCEMENT = 3; +const SEAL = 4; +const EXTRA_CHIPS = 5; +const CARD_DISABLED = 6; +// const CARD_ID = 7; +const EXTRA_EXTRA_CHIPS = 8; + +const JOKER = 0; +const VALUE = 1; +//const EDITION = 2; +const JOKER_DISABLED = 3; +const SELL_VALUE = 4; + +const LEVEL = 0; +const PLANETS = 1; +const PLAYED = 2; +const PLAYED_THIS_ROUND = 3; + +const cardValues = [2, 3, 4, 5, 6, 7, 8, 9, 10, 10, 10, 10, 11]; + +function bigAdd(a, b) { + if(b[1] > 308) { + return b; + } + return [ + a / powersOfTen[b[1] + 323] + b[0], + b[1] + ]; +} + +function bigTimes(a, b) { + const tempM = a * b[0]; + + if(tempM > 1e13) { + const tempE = Math.floor(Math.log10(Math.abs(tempM))) + 13; + + return [ + tempM / powersOfTen[tempE + 323], + b[1] + tempE + ]; + } + else { + return [ + tempM, + b[1] + ]; + } +} + +function bigBigAdd(a, b) { + if(b[1] > a[1]) { + const diff = b[1] - a[1]; + if(diff >= 309) { + return b; + } + return [ + a[0] / powersOfTen[diff + 323] + b[0], + b[1] + ]; + } + else { + const diff = a[1] - b[1]; + if(diff >= 309) { + return a; + } + return [ + b[0] / powersOfTen[diff + 323] + a[0], + a[1] + ]; + } +} + +function bigBigTimes(a, b) { + return [ + a[0] * b[0], + a[1] + b[1] + ]; +} + +function normalizeBig(b) { + const tempE = Math.floor(Math.log10(Math.abs(b[0]))); + + return [ + b[0] / powersOfTen[tempE + 323], + b[1] + tempE + ]; +} + +/* +brute-force order of operations: + +- compileJokers() +- all combinations of joker order + - compileJokerOrder() +- all combinations of cards played + - compileCards() +- all combinations of cards played order + - simulate() +*/ + +// svelte-ignore perf_avoid_nested_class (Each calculation needs isolated mutable hand-value tables.) +class Hand { + hands = []; + jokersExtraValue = []; + jokerRarities = []; + + randomMode = 0; + chips = 0; + mult = [1, 0]; // big-float + + chanceMultiplier = 1; + + FourFingers = false; // straights/flushes with 4 cards + Shortcut = false; // straights can skip numbers + Pareidolia = false; // all cards are faces + SmearedJoker = false; // hearts = diamonds, clubs = spades + Splash = false; // every card is counted in scoring + + hasVampire = false; + Vampire = false; + BaseballCard = 0; + + RaisedFist = false; + + MidasMaskas = false; + + compiledValues = []; + + handType = 11; + involvedCards = []; + + hasPair = false; + hasTwoPair = false; + hasThreeOfAKind = false; + hasFourOfAKind = false; + hasStraight = false; + hasFlush = false; + + compiledChips = 0; + compiledMult = [1, 0]; + + compiledInHandPlusMult = [0, 0]; + compiledInHandTimesMult = [1, 0]; + cardCast = []; + cardExtraExtraChips = []; + + actualCardsInHand = []; + + firstHand = true; + earnedMoney = 0; + + constructor({ + cards = [], + cardsInHand = [], + jokers = [], + hands = false, + TheFlint = false, + TheEye = false, + PlasmaDeck = false, + Observatory = false + } = {}) { + this.cards = cards; + this.cardsInHand = cardsInHand; + this.jokers = jokers; + if(hands) { + this.hands = hands; + + this.firstHand = true; + for(let i = 0; i < this.hands.length; i++) { + if(this.hands[i][PLAYED_THIS_ROUND]) { + this.firstHand = false; + break; + } + } + } + else { + for(let i = 0; i < handChips.length; i++) { + this.hands.push([ + 1, // level + 0, // planets + 0, // played + 0, // played this round + ]); + } + + this.firstHand = true; + } + this.TheFlint = TheFlint; + this.TheEye = TheEye; + this.PlasmaDeck = PlasmaDeck; + this.Observatory = Observatory; + } + + triggerJoker(joker, j) { + if(joker[JOKER_DISABLED]) return; + + if(joker[EDITION] === FOIL) { + this.chips += 50; + } + else if(joker[EDITION] === HOLOGRAPHIC) { + this.mult = bigAdd(10, this.mult); + } + + switch(joker[JOKER]) { + case 0: + // Joker + this.mult = bigAdd(4, this.mult); + break; + case 2: + // Jolly Joker + if(this.hasPair) { + this.mult = bigAdd(8, this.mult); + } + break; + case 3: + // Zany Joker + if(this.hasThreeOfAKind) { + this.mult = bigAdd(12, this.mult); + } + break; + case 4: + // Mad Joker + if(this.hasTwoPair) { + this.mult = bigAdd(10, this.mult); + } + break; + case 5: + // Crazy Joker + if(this.hasStraight) { + this.mult = bigAdd(12, this.mult); + } + break; + case 6: + // Droll Joker + if(this.hasFlush) { + this.mult = bigAdd(10, this.mult); + } + break; + case 7: + // Half Joker + if(this.cards.length <= 3) { + this.mult = bigAdd(20, this.mult); + } + break; + case 12: + // Acrobat + if(joker[VALUE] !== 0) { + this.mult = bigTimes(3, this.mult); + } + break; + case 22: + // Mystic Summit + if(joker[VALUE] !== 0) { + this.mult = bigAdd(15, this.mult); + } + break; + case 24: + // Loyalty Card + if(joker[VALUE] === 0) { + this.mult = bigTimes(4, this.mult); + } + break; + case 26: + // Misprint + switch(this.randomMode) { + case 0: + this.mult = bigAdd(23, this.mult); + break; + case 2: + this.mult = bigAdd(Math.floor(Math.random() * 24), this.mult); + break; + } + break; + case 27: + // Steel Joker + this.mult = bigTimes(this.compiledValues[j], this.mult); + break; + case 31: + // Glass Joker + this.mult = bigTimes(this.compiledValues[j], this.mult); + break; + case 33: + // Abstract Joker + this.mult = bigAdd(this.jokers.length * 3, this.mult); + break; + case 42: + // Supernova + this.mult = bigAdd(this.hands[this.typeOfHand][PLAYED] + 1, this.mult); + break; + case 44: + // Seeing Double + if(this.compiledValues[j]) { + this.mult = bigTimes(2, this.mult); + } + break; + case 45: + // The Duo + if(this.hasPair) { + this.mult = bigTimes(2, this.mult); + } + break; + case 46: + // The Trio + if(this.hasThreeOfAKind) { + this.mult = bigTimes(3, this.mult); + } + break; + case 47: + // The Family + if(this.hasFourOfAKind) { + this.mult = bigTimes(4, this.mult); + } + break; + case 48: + // The Order + if(this.hasStraight) { + this.mult = bigTimes(3, this.mult); + } + break; + case 49: + // The Tribe + if(this.hasFlush) { + this.mult = bigTimes(2, this.mult); + } + break; + case 52: + // Joker Stencil + this.mult = bigTimes(1 + joker[VALUE], this.mult); + break; + case 55: + // Ceremonial Dagger + this.mult = bigAdd(joker[VALUE], this.mult); + break; + case 57: + // Fortune Teller + this.mult = bigAdd(joker[VALUE], this.mult); + break; + case 58: + // Hit the Road + this.mult = bigTimes(1 + joker[VALUE] * 0.5, this.mult); + break; + case 59: + // Swashbuckler + this.mult = bigAdd(this.compiledValues[j], this.mult); + break; + case 60: + // Flower Pot + if(this.compiledValues[j]) { + this.mult = bigTimes(3, this.mult); + } + break; + case 61: + // Ride the Bus + this.mult = bigAdd(this.compiledValues[j], this.mult); + break; + case 67: + // Gros Michel + this.mult = bigAdd(15, this.mult); + break; + case 70: + // Driver's License + if(joker[VALUE] >= 16) { + this.mult = bigTimes(3, this.mult); + } + break; + case 75: + // Throwback + this.mult = bigTimes(1 + joker[VALUE] * 0.25, this.mult); + break; + case 83: + // Canio + this.mult = bigTimes(1 + joker[VALUE], this.mult); + break; + case 85: + // Yorick + this.mult = bigTimes(joker[VALUE], this.mult); + break; + case 89: + // Bootstraps + this.mult = bigAdd((joker[VALUE] + Math.floor(this.earnedMoney / 5)) * 2, this.mult); + break; + case 102: + // Blackboard + if(this.compiledValues[j]) { + this.mult = bigTimes(3, this.mult); + } + break; + case 109: + // Constellation + this.mult = bigTimes(1 + joker[VALUE] / 10, this.mult); + break; + case 112: + // Green Joker + this.mult = bigAdd(1 + joker[VALUE], this.mult); + break; + case 115: + // Cavendish + this.mult = bigTimes(3, this.mult); + break; + case 116: + // Card Sharp + if(this.hands[this.typeOfHand][PLAYED_THIS_ROUND]) { + this.mult = bigTimes(3, this.mult); + } + break; + case 117: + // Red Card + this.mult = bigAdd(joker[VALUE] * 3, this.mult); + break; + case 118: + // Madness + this.mult = bigTimes(1 + joker[VALUE] * 0.5, this.mult); + break; + case 122: + // Vampire + this.mult = bigTimes(1 + this.compiledValues[j] / 10, this.mult); + break; + case 124: + // Hologram + this.mult = bigTimes(1 + joker[VALUE] * 0.25, this.mult); + break; + case 129: + // Obelisk + this.mult = bigTimes(this.compiledValues[j], this.mult); + break; + case 135: + // Erosion + this.mult = bigAdd(joker[VALUE] * 4, this.mult); + break; + case 145: + // Lucky Cat + this.mult = bigTimes(1 + (joker[VALUE] + this.jokersExtraValue[j]) / 4, this.mult); + break; + case 147: + // Bull + this.chips += 2 * (joker[VALUE] + this.earnedMoney) + this.jokersExtraValue[j]; + break; + case 150: + // Flash Card + this.mult = bigAdd(joker[VALUE] * 2, this.mult); + break; + case 151: + // Popcorn + this.mult = bigAdd(20 - joker[VALUE] * 4, this.mult); + break; + case 152: + // Ramen + this.mult = bigTimes(2 - joker[VALUE] / 100, this.mult); + break; + case 154: + // Spare Trousers + if(this.hasTwoPair) { + this.compiledValues[j] = 1; + this.mult = bigAdd(2 + joker[VALUE] * 2, this.mult); + } + else { + this.mult = bigAdd(joker[VALUE] * 2, this.mult); + } + break; + case 155: + // Campfire + this.mult = bigTimes(1 + joker[VALUE] * 0.25, this.mult); + break; + } + + if(joker[EDITION] === POLYCHROME) { + this.mult = bigTimes(1.5, this.mult); + } + } + + triggerCard(card, retrigger = false) { + if(card[CARD_DISABLED]) return; + const notStone = card[ENHANCEMENT] !== STONE; + + if(notStone || this.hasVampire) { + this.chips += cardValues[card[RANK]] + card[EXTRA_CHIPS] + card[EXTRA_EXTRA_CHIPS]; + } + + let luckyMult = 0; + let luckyMoney = 0; + let luckyTriggers = 0; + + if(!this.hasVampire) { + switch(card[ENHANCEMENT]) { + case BOUNS: + this.chips += 30; + break; + case MULT: + this.mult = bigAdd(4, this.mult); + break; + case GLASS: + this.mult = bigTimes(2, this.mult); + break; + case STONE: + this.chips += 50; + break; + case LUCKY: + let triggered = false; + switch(this.randomMode) { + case 0: + this.mult = bigAdd(20, this.mult); + luckyMult++; + luckyMoney++; + luckyTriggers++; + break; + case 1: + if(this.chanceMultiplier >= 5) { + this.mult = bigAdd(20, this.mult); + luckyMult++; + triggered = true; + } + if(this.chanceMultiplier >= 20) { + luckyMoney++; + triggered = true; + } + if(triggered) { + luckyTriggers++; + } + break; + case 2: + if(Math.random() < 0.2 * this.chanceMultiplier) { + this.mult = bigAdd(20, this.mult); + luckyMult++; + triggered = true; + } + if(Math.random() < 1/15 * this.chanceMultiplier) { + luckyMoney++; + triggered = true; + } + if(triggered) { + luckyTriggers++; + } + break; + } + break; + } + } + + switch(card[EDITION]) { + case FOIL: + this.chips += 50; + break; + case HOLOGRAPHIC: + this.mult = bigAdd(10, this.mult); + break; + case POLYCHROME: + this.mult = bigTimes(1.5, this.mult); + break; + } + + const isFace = this.Pareidolia || (notStone && card[RANK] >= JACK && card[RANK] <= KING); + + this.earnedMoney += luckyMoney * 20; + + if(notStone) { + for(let j = 0; j < this.jokers.length; j++) { + const joker = this.jokers[j]; + if(joker[JOKER_DISABLED]) continue; + switch(joker[JOKER]) { + case 16: + // Greedy Joker + if(card[SUIT] === DIAMONDS || (this.SmearedJoker && card[SUIT] === HEARTS)) { + this.mult = bigAdd(3, this.mult); + } + else if(card[SUIT] === true) { + this.mult = bigAdd(3, this.mult); + } + break; + case 17: + // Lusty Joker + if(card[SUIT] === HEARTS || (this.SmearedJoker && card[SUIT] === DIAMONDS)) { + this.mult = bigAdd(3, this.mult); + } + else if(card[SUIT] === true) { + this.mult = bigAdd(3, this.mult); + } + break; + case 18: + // Wrathful Joker + if(card[SUIT] === SPADES || (this.SmearedJoker && card[SUIT] === CLUBS)) { + this.mult = bigAdd(3, this.mult); + } + else if(card[SUIT] === true) { + this.mult = bigAdd(3, this.mult); + } + break; + case 19: + // Gluttonous Joker + if(card[SUIT] === CLUBS || (this.SmearedJoker && card[SUIT] === SPADES)) { + this.mult = bigAdd(3, this.mult); + } + else if(card[SUIT] === true) { + this.mult = bigAdd(3, this.mult); + } + break; + case 32: + // Scary Face + if(isFace) { + this.chips += 30; + } + break; + case 35: + // Golden Ticket + if(card[ENHANCEMENT] === GOLD || (this.MidasMaskas && isFace)) { + this.earnedMoney += 4; + } + break; + case 38: + // Even Steven + if(card[RANK] % 2 === 0 && card[RANK] <= _10) { + this.mult = bigAdd(4, this.mult); + } + break; + case 39: + // Odd Todd + if((card[RANK] % 2 === 1 && card[RANK] <= _9) || card[RANK] === ACE) { + this.chips += 31; + } + break; + case 40: + // Wee Joker + if(card[RANK] === _2) { + this.chips += 8; + } + break; + case 41: + // Business Card + if(isFace) { + switch(this.randomMode) { + case 0: + this.earnedMoney += 2; + break; + case 1: + if(this.chanceMultiplier >= 2) { + this.earnedMoney += 2; + } + break; + case 2: + if(Math.random() < 0.5 * this.chanceMultiplier) { + this.earnedMoney += 2; + } + break; + } + } + break; + case 51: + // Fibonacci + if(card[RANK] === ACE || card[RANK] === _8 || card[RANK] === _5 || card[RANK] === _3 || card[RANK] === _2) { + this.mult = bigAdd(8, this.mult); + } + break; + case 63: + // Scholar + if(card[RANK] === ACE) { + this.chips += 20; + this.mult = bigAdd(4, this.mult); + } + break; + case 76: + // The Idol + if(card[SUIT] === Math.abs(joker[VALUE]) % 4 && card[RANK] === Math.floor(Math.abs(joker[VALUE]) / 4) % 13) { + this.mult = bigTimes(2, this.mult); + } + break; + case 80: + // Bloodstone + if(card[SUIT] === HEARTS || (this.SmearedJoker && card[SUIT] === DIAMONDS)) { + switch(this.randomMode) { + case 0: + this.mult = bigTimes(1.5, this.mult); + break; + case 1: + if(this.chanceMultiplier >= 2) { + this.mult = bigTimes(1.5, this.mult); + } + break; + case 2: + if(Math.random() < 1/2 * this.chanceMultiplier) { + this.mult = bigTimes(1.5, this.mult); + } + break; + } + } + else if(card[SUIT] === true) { + switch(this.randomMode) { + case 0: + this.mult = bigTimes(1.5, this.mult); + break; + case 1: + if(this.chanceMultiplier >= 2) { + this.mult = bigTimes(1.5, this.mult); + } + break; + case 2: + if(Math.random() < 1/2 * this.chanceMultiplier) { + this.mult = bigTimes(1.5, this.mult); + } + break; + } + } + break; + case 81: + // Arrowhead + if(card[SUIT] === SPADES || (this.SmearedJoker && card[SUIT] === CLUBS)) { + this.chips += 50; + } + else if(card[SUIT] === true) { + this.chips += 50; + } + break; + case 82: + // Onyx Agate + if(card[SUIT] === CLUBS || (this.SmearedJoker && card[SUIT] === SPADES)) { + this.mult = bigAdd(7, this.mult); + } + else if(card[SUIT] === true) { + this.mult = bigAdd(7, this.mult); + } + break; + case 84: + // Triboulet + if(card[RANK] === KING || card[RANK] === QUEEN) { + this.mult = bigTimes(2, this.mult); + } + break; + case 110: + // Hiker + card[EXTRA_EXTRA_CHIPS] += 5; + break; + case 132: + // Photograph + if(isFace && (this.jokersExtraValue[j] === card || this.jokersExtraValue[j] === 0)) { + this.jokersExtraValue[j] = card; + this.mult = bigTimes(2, this.mult); + } + break; + case 145: + // Lucky Cat + this.jokersExtraValue[j] += luckyTriggers; + break; + case 156: + // Smiley Face + if(isFace) { + this.mult = bigAdd(5, this.mult); + } + break; + case 157: + // Ancient Joker + if(card[ENHANCEMENT] === WILD || (this.SmearedJoker ? card[SUIT] % 2 === Math.abs(joker[VALUE]) % 2 : card[SUIT] === Math.abs(joker[VALUE]) % 4)) { + this.mult = bigTimes(1.5, this.mult); + } + break; + case 158: + // Walkie Talkie + if(card[RANK] === _4 || card[RANK] === _10) { + this.chips += 10; + this.mult = bigAdd(4, this.mult); + } + break; + } + } + } + else if(isFace) { + for(let j = 0; j < this.jokers.length; j++) { + const joker = this.jokers[j]; + if(joker[JOKER_DISABLED]) continue; + switch(joker[JOKER]) { + case 32: + // Scary Face + this.chips += 30; + break; + case 35: + // Golden Ticket + if(this.MidasMaskas) { + this.earnedMoney += 4; + } + break; + case 41: + // Business Card + switch(this.randomMode) { + case 0: + this.earnedMoney += 2; + break; + case 1: + if(this.chanceMultiplier >= 2) { + this.earnedMoney += 2; + } + break; + case 2: + if(Math.random() < 0.5 * this.chanceMultiplier) { + this.earnedMoney += 2; + } + break; + } + break; + case 110: + // Hiker + card[EXTRA_EXTRA_CHIPS] += 5; + break; + case 132: + // Photograph + if(this.jokersExtraValue[j] === card || this.jokersExtraValue[j] === 0) { + this.jokersExtraValue[j] = card; + this.mult = bigTimes(2, this.mult); + } + break; + case 156: + // Smiley Face + this.mult = bigAdd(5, this.mult); + break; + } + } + } + else { + for(let j = 0; j < this.jokers.length; j++) { + const joker = this.jokers[j]; + if(joker[JOKER_DISABLED]) continue; + switch(joker[JOKER]) { + case 110: + // Hiker + card[EXTRA_EXTRA_CHIPS] += 4; + break; + } + } + } + + // retriggers + if(!retrigger) { + if(card[SEAL] === RED_SEAL) { + this.triggerCard(card, true); + } + + for(let j = 0; j < this.jokers.length; j++) { + const joker = this.jokers[j]; + if(joker[JOKER_DISABLED]) continue; + switch(joker[JOKER]) { + case 13: + // Sock and Buskin + if(isFace) { + this.triggerCard(card, true); + } + break; + case 25: + // Hack + if(card[RANK] <= _5) { + this.triggerCard(card, true); + } + break; + case 69: + // Hanging Chad + if(this.jokersExtraValue[j] === 0) { + this.jokersExtraValue[j]++; + this.triggerCard(card, true); + this.triggerCard(card, true); + } + break; + case 74: + // Dusk + if(joker[VALUE] !== 0) { + this.triggerCard(card, true); + } + break; + case 153: + // Seltzer + this.triggerCard(card, true); + break; + } + } + } + } + + triggerCardInHand(card, retrigger = false) { + if(card[CARD_DISABLED]) return; + + // apply steel cards + if(card[ENHANCEMENT] === STEEL && !card[CARD_DISABLED]) { + this.compiledInHandPlusMult = bigTimes(1.5, this.compiledInHandPlusMult); + this.compiledInHandTimesMult = bigTimes(1.5, this.compiledInHandTimesMult); + } + + for(let j = 0; j < this.jokers.length; j++) { + const joker = this.jokers[j]; + if(joker[JOKER_DISABLED]) continue; + switch (joker[JOKER]) { + case 28: + // Raised Fist + if(card === this.compiledValues[j] && card[ENHANCEMENT] !== STONE) { + this.compiledInHandPlusMult = bigAdd(2 * (card[RANK] === ACE ? 11 : Math.min(10, card[RANK] + 2)), this.compiledInHandPlusMult); + } + break; + case 62: + // Shoot the Moon + if(card[RANK] === QUEEN && card[ENHANCEMENT] !== STONE) { + this.compiledInHandPlusMult = bigAdd(13, this.compiledInHandPlusMult); + } + break; + case 126: + // Baron + if(card[RANK] === KING && card[ENHANCEMENT] !== STONE) { + this.compiledInHandPlusMult = bigTimes(1.5, this.compiledInHandPlusMult); + this.compiledInHandTimesMult = bigTimes(1.5, this.compiledInHandTimesMult); + } + break; + } + } + + // retriggers + if(!retrigger) { + if(card[SEAL] === RED_SEAL) { + this.triggerCardInHand(card, true); + } + + for(let j = 0; j < this.jokers.length; j++) { + const joker = this.jokers[j]; + if(joker[JOKER_DISABLED]) continue; + switch(joker[JOKER]) { + case 14: + this.triggerCardInHand(card, true); + break; + } + } + } + } + + getTypeOfHand() { + // ES2019 apparently mandates stable sort + const sortedCards = this.cards.filter(a => a[ENHANCEMENT] !== STONE).sort((a, b) => b[RANK] - a[RANK]); + + let flush = []; + + let straight = false; + + if(sortedCards.length >= (this.FourFingers ? 4 : 5)) { + const lines = [ + [sortedCards[0]], + [sortedCards[1]], + ]; + if(this.FourFingers) { + lines.push([sortedCards[2]]); + } + + for(let i = 1; i < sortedCards.length; i++) { + for(let l = 0; l < lines.length; l++) { + const val = lines[l][lines[l].length - 1][RANK]; + if(sortedCards[i][RANK] + 1 === val) { + lines.push([...lines[l], sortedCards[i]]); + } + else if(this.Shortcut && sortedCards[i][RANK] + 2 === val) { + lines.push([...lines[l], sortedCards[i]]); + } + } + } + + for(let i = 0; i < sortedCards.length; i++) { + for(let l = 0; l < lines.length; l++) { + const val = lines[l][lines[l].length - 1][RANK]; + if(val === _2 && sortedCards[i][0] === ACE) { + lines.push([...lines[l], sortedCards[i]]); + } + else if(this.Shortcut && val === _3 && sortedCards[i][0] === ACE) { + lines.push([...lines[l], sortedCards[i]]); + } + } + } + + let flushes = [ + [],[],[],[] + ]; + + for(let c = 0; c < this.cards.length; c++) { + const card = this.cards[c]; + for(let i = 0; i < 4; i++) { + if(card[ENHANCEMENT] !== STONE && (card[ENHANCEMENT] === WILD || (this.SmearedJoker ? card[SUIT] % 2 == i : card[SUIT] === i))) { + flushes[i].push(card); + } + } + } + + for(let i = 0; i < flushes.length; i++) { + if(flushes[i].length > flush.length) { + flush = flushes[i]; + } + } + + if(lines[lines.length - 1].length >= (this.FourFingers ? 4 : 5)) { + straight = lines[lines.length - 1]; + } + } + + if(flush.length < (this.FourFingers ? 4 : 5)) flush = false; + + if(flush) { + this.hasFlush = true; + } + + if(straight) { + this.hasStraight = true; + } + + if(sortedCards.length >= 4 && ( + sortedCards[0][RANK] === sortedCards[3][RANK] || + (sortedCards.length >= 5 && sortedCards[1][RANK] === sortedCards[4][RANK]) + )) { + this.hasPair = true; + this.hasThreeOfAKind = true; + this.hasFourOfAKind = true; + } + else if(sortedCards.length >= 3 && ( + (sortedCards[0][RANK] === sortedCards[1][RANK] && sortedCards[1][RANK] === sortedCards[2][RANK]) || + (sortedCards.length >= 4 && ( + (sortedCards[1][RANK] === sortedCards[2][RANK] && sortedCards[2][RANK] === sortedCards[3][RANK]) || + (sortedCards.length >= 5 && sortedCards[2][RANK] === sortedCards[3][RANK] && sortedCards[3][RANK] === sortedCards[4][RANK]) + )))) { + this.hasPair = true; + this.hasThreeOfAKind = true; + } + else if(sortedCards.length >= 2 && + (sortedCards[0][RANK] === sortedCards[1][RANK] || + (sortedCards.length >= 3 && + (sortedCards[1][RANK] === sortedCards[2][RANK] || + (sortedCards.length >= 4 && + (sortedCards[2][RANK] === sortedCards[3][RANK] || + (sortedCards.length >= 5 && sortedCards[3][RANK] === sortedCards[4][RANK]) + )))))) { + this.hasPair = true; + } + + if(sortedCards.length >= 4) { + if(sortedCards[0][RANK] === sortedCards[1][RANK]) { + if(sortedCards[2][RANK] === sortedCards[3][RANK]) { + this.hasTwoPair = true; + } + if(sortedCards.length >= 5 && sortedCards[3][RANK] === sortedCards[4][RANK]) { + this.hasTwoPair = true; + } + } + if(sortedCards.length >= 5 && sortedCards[1][RANK] === sortedCards[2][RANK] && sortedCards[3][RANK] === sortedCards[4][RANK]) { + this.hasTwoPair = true; + } + } + + // flush five + if(flush && sortedCards.length === 5 && sortedCards[0][RANK] === sortedCards[4][RANK]) { + return [FLUSH_FIVE, this.cards]; + } + + // flush house + if(flush && sortedCards.length === 5 && sortedCards[0][RANK] === sortedCards[1][RANK] && sortedCards[3][RANK] === sortedCards[4][RANK] && (sortedCards[1][RANK] === sortedCards[2][RANK] || sortedCards[2][RANK] === sortedCards[3][RANK])) { + return [FLUSH_HOUSE, this.cards]; + } + + // five of a kind + if(sortedCards.length === 5 && sortedCards[0][RANK] === sortedCards[4][RANK]) { + return [FIVE_OF_A_KIND, this.cards]; + } + + // straight flush + if(straight && flush) { + return [STRAIGHT_FLUSH, [...new Set([...straight, ...flush])]]; + } + + // four of a kind + if(sortedCards.length >= 4) { + if(sortedCards[0][RANK] === sortedCards[3][RANK]) { + return [FOUR_OF_A_KIND, [ + sortedCards[0], + sortedCards[1], + sortedCards[2], + sortedCards[3] + ]]; + } + if(sortedCards.length >= 5 && sortedCards[1][RANK] === sortedCards[4][RANK]) { + return [FOUR_OF_A_KIND, [ + sortedCards[1], + sortedCards[2], + sortedCards[3], + sortedCards[4] + ]]; + } + } + + // full house + if(sortedCards.length === 5 && sortedCards[0][RANK] === sortedCards[1][RANK] && sortedCards[3][RANK] === sortedCards[4][RANK] && (sortedCards[1][RANK] === sortedCards[2][RANK] || sortedCards[2][RANK] === sortedCards[3][RANK])) { + return [FULL_HOUSE, this.cards]; + } + + // flush + if(flush) { + return [FLUSH, flush]; + } + + // straight + if(straight) { + return [STRAIGHT, straight]; + } + + // three of a kind + if(sortedCards.length >= 3) { + if(sortedCards[0][RANK] === sortedCards[1][RANK] && sortedCards[1][RANK] === sortedCards[2][RANK]) { + return [THREE_OF_A_KIND, [sortedCards[0], sortedCards[1], sortedCards[2]]]; + } + if(sortedCards.length >= 4) { + if(sortedCards[1][RANK] === sortedCards[2][RANK] && sortedCards[2][RANK] === sortedCards[3][RANK]) { + return [THREE_OF_A_KIND, [sortedCards[1], sortedCards[2], sortedCards[3]]]; + } + if(sortedCards.length >= 5 && sortedCards[2][RANK] === sortedCards[3][RANK] && sortedCards[3][RANK] === sortedCards[4][RANK]) { + return [THREE_OF_A_KIND, [sortedCards[2], sortedCards[3], sortedCards[4]]]; + } + } + } + + // two pair + if(sortedCards.length >= 4) { + if(sortedCards[0][RANK] === sortedCards[1][RANK]) { + if(sortedCards[2][RANK] === sortedCards[3][RANK]) { + return [TWO_PAIR, [sortedCards[0], sortedCards[1], sortedCards[2], sortedCards[3]]]; + } + if(sortedCards.length >= 5 && sortedCards[3][RANK] === sortedCards[4][RANK]) { + return [TWO_PAIR, [sortedCards[0], sortedCards[1], sortedCards[3], sortedCards[4]]]; + } + } + if(sortedCards.length >= 5 && sortedCards[1][RANK] === sortedCards[2][RANK] && sortedCards[3][RANK] === sortedCards[4][RANK]) { + return [TWO_PAIR, [sortedCards[1], sortedCards[2], sortedCards[3], sortedCards[4]]]; + } + } + + // pair + if(sortedCards.length >= 2) { + if(sortedCards[0][RANK] === sortedCards[1][RANK]) { + return [PAIR, [sortedCards[0], sortedCards[1]]]; + } + if(sortedCards.length >= 3) { + if(sortedCards[1][RANK] === sortedCards[2][RANK]) { + return [PAIR, [sortedCards[1], sortedCards[2]]]; + } + if(sortedCards.length >= 4) { + if(sortedCards[2][RANK] === sortedCards[3][RANK]) { + return [PAIR, [sortedCards[2], sortedCards[3]]]; + } + if(sortedCards.length >= 5 && sortedCards[3][RANK] === sortedCards[4][RANK]) { + return [PAIR, [sortedCards[3], sortedCards[4]]]; + } + } + } + } + + // none + if(sortedCards.length === 0) { + return [HIGH_CARD, []]; + } + + // high-card + return [HIGH_CARD, [sortedCards[0]]]; + } + + // knowledge of joker order and cards-played (not their order) + compileCards() { + this.hasPair = false; + this.hasTwoPair = false; + this.hasThreeOfAKind = false; + this.hasFourOfAKind = false; + this.hasStraight = false; + this.hasFlush = false; + + this.Vampire = false; + + this.compiledChips = 0; + this.compiledMult = [1, 0]; + + this.compiledInHandPlusMult = [0, 0]; + this.compiledInHandTimesMult = [1, 0]; + + if(this.actualCardsInHand.length === 0) { + this.actualCardsInHand = this.cardsInHand.slice(); + } + else { + this.cardsInHand = this.actualCardsInHand.slice(); + } + + this.lowestCard = false; + + for(let c = 0; c < this.cards.length; c++) { + if(this.cards[c][ENHANCEMENT] === WILD) { + this.cards[c][SUIT] = true; + } + } + + // get hand type + [this.typeOfHand, this.involvedCards] = this.getTypeOfHand(); + + if(this.Splash) { + this.involvedCards = this.cards; + } + + if(this.typeOfHand >= 0) { + this.compiledChips = handChips[this.typeOfHand][0] + handChips[this.typeOfHand][2] * (this.hands[this.typeOfHand][LEVEL] - 1); + this.compiledMult = [handChips[this.typeOfHand][1] + handChips[this.typeOfHand][3] * (this.hands[this.typeOfHand][LEVEL] - 1), 0]; + + if(this.TheFlint) { + this.compiledChips /= 2; + this.compiledMult[0] /= 2; + } + } + + // resolve jokers that require knowledge of hand + for(let j = 0; j < this.jokers.length; j++) { + const joker = this.jokers[j]; + if(joker[JOKER_DISABLED]) continue; + + const oldCompiledValue = this.compiledValues[j]; + this.compiledValues[j] = 0; + + switch(joker[JOKER]) { + case 9: + // Stone Joker + this.compiledChips += joker[VALUE] * 25; + if(this.hasVampire) { + for(let c = 0; c < this.involvedCards.length; c++) { + if(this.involvedCards[c][ENHANCEMENT] === STONE) { + this.compiledChips -= 25; + } + } + } + break; + case 21: + // Banner + this.compiledChips += joker[VALUE] * 30; + break; + case 27: + // Steel Joker + if(this.hasVampire) { + let amount = joker[VALUE]; + for(let c = 0; c < this.involvedCards.length; c++) { + if(this.involvedCards[c][ENHANCEMENT] === STEEL) { + amount++; + } + } + this.compiledValues[j] = 1 + (joker[VALUE] - amount) * 0.2; + } + else { + this.compiledValues[j] = 1 + joker[VALUE] * 0.2; + } + break; + case 28: + // Raised Fist + // find lowest card + let lowest = 100; + let lowestCards = []; + for(let c = 0; c < this.cardsInHand.length; c++) { + const card = this.cardsInHand[c]; + if(card[ENHANCEMENT] !== STONE) { + if(lowest > card[RANK]) { + lowest = card[RANK]; + lowestCards = [card]; + } + else if(lowest === card[RANK]) { + lowestCards.push(card); + } + } + } + + if(lowestCards.length > 0) { + this.compiledValues[j] = lowestCards[lowestCards.length - 1]; + } + break; + case 31: + // Glass Joker + if(!this.hasVampire) { + let amount = joker[VALUE]; + for(let c = 0; c < this.cards.length; c++) { + if(this.cards[c][ENHANCEMENT] === GLASS) { + switch(this.randomMode) { + case 0: + amount++; + break; + case 1: + if(this.chanceMultiplier >= 4) { + amount++; + } + break; + case 2: + if(Math.random() < 0.25 * this.chanceMultiplier) { + amount++; + } + break; + } + } + } + this.compiledValues[j] = 1 + (joker[VALUE] + amount) * 0.75; + } + else { + this.compiledValues[j] = 1 + joker[VALUE] * 0.75; + } + break; + case 40: + // Wee Joker + this.compiledChips += joker[VALUE] * 8; + break; + case 44: + // Seeing Double + if(this.SmearedJoker) { + let club = 0; + let nonClub = 0; + for(let c = 0; c < this.involvedCards.length; c++) { + if(this.involvedCards[c][CARD_DISABLED]) continue; + if(this.involvedCards[c][ENHANCEMENT] === STONE) continue; + if(this.involvedCards[c][ENHANCEMENT] === WILD || + this.involvedCards[c][SUIT] === CLUBS || + this.involvedCards[c][SUIT] === SPADES) { + club++; + } + else { + nonClub++; + } + } + + if(club > 0 && (club > 1 || nonClub > 0)) { + this.compiledValues[j] = true; + } + } + else { + let club = false; + let nonClub = false; + let wildC = 0; + for(let c = 0; c < this.involvedCards.length; c++) { + if(this.involvedCards[c][CARD_DISABLED]) continue; + if(this.involvedCards[c][ENHANCEMENT] === STONE) continue; + if(this.involvedCards[c][ENHANCEMENT] === WILD) { + wildC++; + } + else if(this.involvedCards[c][SUIT] === CLUBS) { + club = true; + } + else { + nonClub = true; + } + } + for(let i = 0; i < wildC; i++) { + if(!club) club = true; + else nonClub = true; + } + + if(club && nonClub) { + this.compiledValues[j] = true; + } + } + break; + case 60: + // Flower Pot + let hearts = 0; + let diamonds = 0; + let clubs = 0; + let spades = 0; + let wild = 0; + for(let c = 0; c < this.involvedCards.length; c++) { + if(this.involvedCards[c][CARD_DISABLED] && this.involvedCards[c][ENHANCEMENT] === WILD) continue;// seems to be a bug in balatro itself, remove when fixed? + if(this.involvedCards[c][ENHANCEMENT] !== STONE) { + if(this.involvedCards[c][ENHANCEMENT] === WILD && !this.involvedCards[c][CARD_DISABLED]) { + wild++; + } + else if(this.involvedCards[c][SUIT] === HEARTS) { + hearts = 1; + } + else if(this.involvedCards[c][SUIT] === DIAMONDS) { + diamonds = 1; + } + else if(this.involvedCards[c][SUIT] === CLUBS) { + clubs = 1; + } + else if(this.involvedCards[c][SUIT] === SPADES) { + spades = 1; + } + } + } + if(hearts + diamonds + clubs + spades + wild >= 4) { + this.compiledValues[j] = true; + } + break; + case 61: + // Ride the Bus + if(!this.Pareidolia) { + let playedFace = false; + for(let c = 0; c < this.involvedCards.length; c++) { + if(this.involvedCards[c][CARD_DISABLED]) continue; + if(this.involvedCards[c][ENHANCEMENT] !== STONE && this.involvedCards[c][RANK] >= JACK && this.involvedCards[c][RANK] <= KING) { + playedFace = true; + break; + } + } + if(!playedFace) { + this.compiledValues[j] = joker[VALUE] + 1; + } + } + break; + case 68: + // Stuntman + this.compiledChips += 250; + break; + case 102: + // Blackboard + let allBlack = true; + for(let c = 0; c < this.cardsInHand.length; c++) { + if(this.cardsInHand[c][ENHANCEMENT] === STONE || (this.cardsInHand[c][ENHANCEMENT] !== WILD && (this.cardsInHand[c][SUIT] === HEARTS || this.cardsInHand[c][SUIT] === DIAMONDS))) { + allBlack = false; + break; + } + } + if(allBlack) { + this.compiledValues[j] = true; + } + break; + case 103: + // Runner + if(this.hasStraight) { + this.compiledChips += 15 * (joker[VALUE] + 1); + } + else { + this.compiledChips += 15 * joker[VALUE]; + } + break; + case 104: + // Ice Cream + this.compiledChips += 100 - 5 * joker[VALUE]; + break; + case 105: + // DNA + if(this.cards.length === 1 && this.firstHand) { + this.cardsInHand.push(this.cards[0]); + } + break; + case 107: + //Blue joker + this.compiledChips += 104 + 2 * joker[VALUE]; + break; + case 119: + // Square Joker + if(this.cards.length === 4) { + this.compiledChips += 4 * (joker[VALUE] + 1); + } + else { + this.compiledChips += 4 * joker[VALUE]; + } + break; + case 122: + // Vampire + this.compiledValues[j] = joker[VALUE]; + if(this.Vampire) { + break; + } + this.Vampire = true; + for(let c = 0; c < this.involvedCards.length; c++) { + const card = this.involvedCards[c]; + if((this.MidasMaskas && card[RANK] >= JACK && card[RANK] <= KING) || (this.MidasMaskas && this.Pareidolia)) { + this.compiledValues[j]++; + } + else { + if(card[ENHANCEMENT] > 0) { + this.compiledValues[j]++; + } + } + } + break; + case 129: + // Obelisk + let mostPlayed = 0; + for(let h = 0; h < this.hands.length; h++) { + if(this.hands[h][PLAYED] > mostPlayed) { + mostPlayed = this.hands[h][PLAYED]; + } + } + if(this.hands[this.typeOfHand][PLAYED] === mostPlayed) { + this.compiledValues[j] = 1; + } + else { + this.compiledValues[j] = 1 + (joker[VALUE] + 1) / 5; + } + break; + case 140: + // Sly Joker + if(this.hasPair) { + this.compiledChips += 50; + } + break; + case 141: + // Wily Joker + if(this.hasThreeOfAKind) { + this.compiledChips += 100; + } + break; + case 142: + // Clever Joker + if(this.hasTwoPair && !this.hasFourOfAKind) { + this.compiledChips += 80; + } + break; + case 143: + // Devious Joker + if(this.hasStraight) { + this.compiledChips += 100; + } + break; + case 144: + // Crafty Joker + if(this.hasFlush) { + this.compiledChips += 80; + } + break; + case 159: + // Castle + this.compiledChips += joker[VALUE] * 3; + break; + default: + this.compiledValues[j] = oldCompiledValue; + } + } + + // Blueprint or Brainstorm compiled value + for(let j = 0; j < this.actualJokers.length; j++) { + const joker = this.actualJokers[j]; + if(joker[JOKER_DISABLED]) continue; + + switch(joker[JOKER]) { + case 30: + case 77: + // Blueprint + this.compiledValues[j] = this.compiledValues[this.cardCast[j]]; + break; + } + } + + // trigger cards-in-hand + for(let c = 0; c < this.cardsInHand.length; c++) { + this.triggerCardInHand(this.cardsInHand[c]); + } + } + + // knowledge of joker order, not cards-played + compileJokerOrder() { + this.jokerRarities = []; + this.compiledValues = []; + this.cardCast = []; + + this.BaseballCard = 0; + + this.actualJokers = this.jokers.map(a => a.slice()); + + // resolve jokers that are card but not joker order agnostic + for(let j = 0; j < this.jokers.length; j++) { + const joker = this.jokers[j]; + + this.compiledValues.push(0); + this.jokerRarities.push(jokerRarity[this.actualJokers[j][JOKER]]); + + if(joker[JOKER_DISABLED]) continue; + + let resolved = false; + switch(joker[JOKER]) { + case 30: + // resolve Blueprint + if(j + 1 < this.jokers.length) { + let at = j + 1; + let t = 0; + while(!resolved && t++ < this.jokers.length) { + switch(this.jokers[at][JOKER]) { + case 30: + if(at + 1 < this.jokers.length) { + at++; + } + break; + case 77: + if(at !== 0 && this.jokers[0][0] !== 77) { + at = 0; + } + break; + default: + resolved = true; + } + } + if(resolved) { + this.jokers[j][JOKER] = this.jokers[at][JOKER]; + this.jokers[j][VALUE] = this.jokers[at][VALUE]; + this.jokers[j][JOKER_DISABLED] = this.jokers[at][JOKER_DISABLED]; + this.cardCast[j] = at; + j--; + this.compiledValues.pop(); + this.jokerRarities.pop(); + } + } + break; + case 59: + // resolve Swashbuckler + for(let k = 0; k < this.jokers.length; k++) { + if(k == j){ + continue; + } + this.compiledValues[j] += this.jokers[k][SELL_VALUE]; + } + break; + case 77: + // resolve Brainstorm + if(j > 0 && this.jokers[0][0] !== 77) { + let at = 0; + let t = 0; + while(!resolved && t++ < this.jokers.length) { + switch(this.jokers[at][JOKER]) { + case 30: + if(at + 1 < this.jokers.length) { + at++; + } + break; + case 77: + if(at !== 0 && this.jokers[0][0] !== 77) { + at = 0; + } + break; + default: + resolved = true; + } + } + if(resolved) { + this.jokers[j][JOKER] = this.jokers[at][JOKER]; + this.jokers[j][VALUE] = this.jokers[at][VALUE]; + this.jokers[j][JOKER_DISABLED] = this.jokers[at][JOKER_DISABLED]; + this.cardCast[j] = at; + j--; + this.compiledValues.pop(); + this.jokerRarities.pop(); + } + } + break; + case 146: + // Baseball Card + this.BaseballCard++; + break; + } + } + } + + // knowledge of jokers, not joker order or cards-played + compileJokers() { + // set standard values; probability modifier (Oops! All 6s), vampire, etc. + + this.firstHand = true; + for(let i = 0; i < this.hands.length; i++) { + if(this.hands[i][PLAYED_THIS_ROUND]) { + this.firstHand = false; + break; + } + } + + // set global variables' default values + this.actualCardsInHand = []; + + this.chanceMultiplier = 1; + + this.FourFingers = false; + this.Shortcut = false; + this.Pareidolia = false; + this.SmearedJoker = false; + + this.RaisedFist = false; + this.Splash = false; + this.MidasMaskas = false; + + this.hasVampire = false; + + // resolve joker global effects that are card and joker order agnostic + for(let j = 0; j < this.jokers.length; j++) { + const joker = this.jokers[j]; + if(joker[JOKER_DISABLED]) continue; + switch(joker[JOKER]) { + case 28: + this.RaisedFist = true; + break; + case 36: + this.Pareidolia = true; + break; + case 64: + this.SmearedJoker = true; + break; + case 65: + this.chanceMultiplier *= 2; + break; + case 66: + this.FourFingers = true; + break; + case 106: + this.Splash = true; + break; + case 122: + this.hasVampire = true; + break; + case 123: + this.Shortcut = true; + break; + case 130: + this.MidasMaskas = true; + break; + } + } + } + + compileAll() { + this.compileJokers(); + this.compileJokerOrder(); + this.compileCards(); + } + + // simulate what wasn't compiled + simulate() { + this.chips = this.compiledChips; + this.mult = [this.compiledMult[0], this.compiledMult[1]]; + this.jokersExtraValue = []; + + this.earnedMoney = 0; + + if(this.TheEye && this.hands[this.typeOfHand][PLAYED_THIS_ROUND]) { + return [1, -10, 0, [0,0]]; + } + + for(let j = 0; j < this.jokers.length; j++) { + this.jokersExtraValue.push(0); + } + + // score cards + for(let c = 0; c < this.cards.length; c++) { + const card = this.cards[c]; + card[EXTRA_EXTRA_CHIPS] = 0; + + if(card[ENHANCEMENT] === STONE || this.involvedCards.indexOf(card) >= 0) { + this.triggerCard(card); + } + else { + for(let j = 0; j < this.jokers.length; j++) { + const joker = this.jokers[j]; + if(joker[JOKER_DISABLED]) continue; + switch(joker[JOKER]) { + // Hanging Chad + case 69: + this.jokersExtraValue[j]++; + break; + } + } + } + } + + // score cards-in-hand + this.mult = bigBigTimes(this.compiledInHandTimesMult, this.mult); + this.mult = bigBigAdd(this.compiledInHandPlusMult, this.mult); + + // score jokers + for(let j = 0; j < this.jokers.length; j++) { + this.triggerJoker(this.jokers[j], j); + + if(this.BaseballCard && this.jokerRarities[j] === 2 && !this.jokers[j][JOKER_DISABLED]) { + for(let i = 0; i < this.BaseballCard; i++) { + this.mult = bigTimes(1.5, this.mult); + } + } + } + + // Observatory + if(this.Observatory) { + const ObservatoryScore = this.hands[this.typeOfHand][PLANETS]; + this.mult = bigTimes(1.5 ** ObservatoryScore, this.mult); + } + + if(this.PlasmaDeck) { + this.mult = bigAdd(this.chips, this.mult); + this.mult = bigTimes(0.5, this.mult); + + if(this.mult[1] === 0) { + this.mult[0] = Math.floor(this.mult[0]); + } + return [...normalizeBig(bigBigTimes(this.mult, this.mult)), normalizeBig(this.mult), normalizeBig(this.mult)]; + } + + return [...normalizeBig(bigTimes(this.chips, this.mult)), this.chips, normalizeBig(this.mult)]; + } + + simulateBestHand() { + this.randomMode = 0; + return this.simulate(); + } + + simulateWorstHand() { + this.randomMode = 1; + return this.simulate(); + } + + simulateRandomHand() { + this.randomMode = 2; + return this.simulate(); + } +}; + return { Hand, handChips }; + } + // END UPSTREAM ENGINE + function text(value) { return typeof value === "string" ? value : value == null ? "" : String(value); } @@ -18,6 +1964,7 @@ const value = state?.[name]; if (Array.isArray(value)) return value; if (Array.isArray(value?.items)) return value.items; + if (value && typeof value === "object" && Object.hasOwn(value, "slots")) return []; if (value && typeof value === "object") return Object.entries(value).map(([id, effect]) => ({ id, effect })); return []; } @@ -191,8 +2138,46 @@ return badges; } + function spriteStyle(atlas, x, y, columns, rows) { + const position = `${columns > 1 ? x / (columns - 1) * 100 : 0}% ${rows > 1 ? y / (rows - 1) * 100 : 0}%`; + return `background-image:var(--atlas-${atlas});background-size:${columns * 100}% ${rows * 100}%;background-position:${position};`; + } + + function spriteVisual(card, joker = false) { + const key = typeof card === "string" ? card : card?.id || card?.key || card?.label; + const layers = []; + let mask = ""; + if (joker) { + const sprite = JOKER_SPRITES[key]; + if (!sprite) return null; // Unknown/modded jokers retain the text fallback. + layers.push({ kind: "base", style: spriteStyle("Jokers", sprite.x, sprite.y, 10, 16) }); + if (sprite.soul) layers.push({ kind: "soul", style: spriteStyle("Jokers", ...sprite.soul, 10, 16) }); + mask = `mask-image:var(--atlas-Jokers);mask-size:1000% 1600%;mask-position:${sprite.x / 9 * 100}% ${sprite.y / 15 * 100}%;mask-repeat:no-repeat;`; + } else { + const match = String(key || "").match(/^([HCDS])_(2|3|4|5|6|7|8|9|T|10|J|Q|K|A)$/); + if (!match) return null; + const enhancement = modifierValue(card, "enhancement"); + const backgrounds = { bonus: [1, 1], mult: [2, 1], wild: [3, 1], lucky: [4, 1], glass: [5, 1], steel: [6, 1], stone: [5, 0], gold: [6, 0] }; + layers.push({ kind: "base", style: spriteStyle("Enhancers", ...(backgrounds[enhancement] || [1, 0]), 7, 5) }); + if (enhancement !== "stone") { + const ranks = ["2", "3", "4", "5", "6", "7", "8", "9", "T", "J", "Q", "K", "A"]; + layers.push({ kind: "face", style: spriteStyle("8BitDeck", ranks.indexOf(match[2] === "10" ? "T" : match[2]), "HCDS".indexOf(match[1]), 13, 4) }); + } + } + const edition = modifierValue(card, "edition"); + const editionColumn = { foil: 1, holo: 2, holographic: 2, polychrome: 3 }[edition]; + if (editionColumn != null) layers.push({ kind: "edition", style: spriteStyle("Editions", editionColumn, 0, 5, 1) }); + const seal = { gold: [2, 0], purple: [4, 4], red: [5, 4], blue: [6, 4] }[modifierValue(card, "seal")]; + if (seal) layers.push({ kind: "seal", style: spriteStyle("Enhancers", ...seal, 7, 5) }); + if (card?.debuff || card?.state?.debuff) layers.push({ kind: "debuff", style: spriteStyle("Editions", 4, 0, 5, 1) }); + return { layers, mask }; + } + function itemName(item) { const id = String(typeof item === "string" ? item : item?.id || item?.key || item?.label || "item"); + const pos = JOKER_SPRITES[id]; + if (pos && CALCULATOR_JOKERS[pos.y * 10 + pos.x]?.name) return CALCULATOR_JOKERS[pos.y * 10 + pos.x].name; + if (typeof item === "object" && item?.name) return item.name; return id.replace(/^[jcv]_/, "").split(/[_-]+/).filter(Boolean) .map((part) => part[0].toUpperCase() + part.slice(1)).join(" ") || id; } @@ -202,6 +2187,120 @@ return [info.rank + info.suit, ...modifierBadges(card).map((badge) => badge.label)].join(" · "); } + function recordedJokerTarget(joker) { + const key = typeof joker === "string" ? joker : joker?.id || joker?.key; + const ranks = ["2", "3", "4", "5", "6", "7", "8", "9", "T", "J", "Q", "K", "A"]; + const rankNames = { "10": "T", jack: "J", queen: "Q", king: "K", ace: "A" }; + const suits = { h: "H", heart: "H", hearts: "H", c: "C", club: "C", clubs: "C", d: "D", diamond: "D", diamonds: "D", s: "S", spade: "S", spades: "S" }; + let target = joker?.scoring_state?.target; + let source = "structured trace"; + if (!target) { + const effect = String(joker?.effect || "").replace(/\s+/g, " "); + let match; + if (key === "j_idol" && (match = /Each played (Ace|King|Queen|Jack|10|[2-9TJQKA]) of (Hearts?|Clubs?|Diamonds?|Spades?)\b/i.exec(effect))) target = { rank: match[1], suit: match[2] }; + else if (key === "j_ancient" && (match = /Each played card with (Hearts?|Clubs?|Diamonds?|Spades?) suit\b/i.exec(effect))) target = { suit: match[1] }; + else if (key === "j_castle" && (match = /per discarded (Hearts?|Clubs?|Diamonds?|Spades?) card\b/i.exec(effect))) target = { suit: match[1] }; + else if (key === "j_mail" && (match = /each discarded (Ace|King|Queen|Jack|10|[2-9TJQKA])\b/i.exec(effect))) target = { rank: match[1] }; + source = "recorded effect text"; + } + if (!target) return null; + const rawRank = String(target.rank ?? ""); + const rank = rankNames[rawRank.toLowerCase()] || (ranks.includes(rawRank.toUpperCase()) ? rawRank.toUpperCase() : Number.isInteger(target.rank_id) ? ranks[target.rank_id - 2] : null); + const suit = suits[String(target.suit || "").toLowerCase()] || null; + if (!rank && !suit) return null; + return { rank, suit, source, label: (rank || "") + ({ H: "♥", C: "♣", D: "♦", S: "♠" }[suit] || "") }; + } + + function calculatorJokers(state, values = {}) { + return area(state, "jokers").map((joker, index) => { + const key = typeof joker === "string" ? joker : joker.id || joker.key; + const pos = JOKER_SPRITES[key]; + const id = pos ? pos.y * 10 + pos.x : null; + const definition = CALCULATOR_JOKERS[id]; + let automatic = null; + const target = recordedJokerTarget(joker); + if (key === "j_idol" && target?.rank && target?.suit) automatic = ["2", "3", "4", "5", "6", "7", "8", "9", "T", "J", "Q", "K", "A"].indexOf(target.rank) * 4 + "HCDS".indexOf(target.suit); + if (key === "j_ancient" && target?.suit) automatic = "HCDS".indexOf(target.suit); + if (key === "j_castle" && number(joker?.scoring_state?.chips) != null) automatic = number(joker.scoring_state.chips) / 3; + if (definition?.label === "Money") automatic = number(state.money); + if (definition?.label === "Discards") automatic = number(state.blind?.discards); + if (key === "j_acrobat" && state.blind?.hands != null) automatic = Number(state.blind.hands === 1); + if (key === "j_mystic_summit" && state.blind?.discards != null) automatic = Number(state.blind.discards === 0); + const value = Object.hasOwn(values, index) ? number(values[index]) : automatic; + return { joker, index, id, name: definition?.name || itemName(joker), label: definition?.label, value, automatic, target }; + }); + } + + function calculatorCard(card, index) { + const key = typeof card === "string" ? card : card?.id || card?.key; + const match = String(key || "").match(/^([HCDS])_(2|3|4|5|6|7|8|9|T|10|J|Q|K|A)$/); + if (!match) throw new Error(`Card ${index + 1} has no supported rank/suit in this trace.`); + const ranks = ["2", "3", "4", "5", "6", "7", "8", "9", "T", "J", "Q", "K", "A"]; + const editions = { "": 0, base: 0, foil: 1, holo: 2, holographic: 2, polychrome: 3, negative: 4 }; + const enhancements = { "": 0, base: 0, bonus: 1, mult: 2, wild: 3, glass: 4, steel: 5, stone: 6, gold: 7, lucky: 8 }; + const seals = { "": 0, gold: 1, red: 2, blue: 3, purple: 4 }; + const modifiers = [editions[modifierValue(card, "edition")], enhancements[modifierValue(card, "enhancement")], seals[modifierValue(card, "seal")]]; + if (modifiers.some(value => value == null)) throw new Error(`Card ${index + 1} has an unsupported modifier.`); + return [ranks.indexOf(match[2] === "10" ? "T" : match[2]), "HCDS".indexOf(match[1]), ...modifiers, number(card?.extra_chips) ?? 0, Number(Boolean(card?.debuff || card?.state?.debuff)), index, 0]; + } + + function calculatorDefaults(state) { + const current = Object.values(state?.blinds || {}).find(blind => blind?.status === "CURRENT"); + return { TheFlint: current?.name === "The Flint", TheEye: current?.name === "The Eye", PlasmaDeck: false, Observatory: area(state, "owned_vouchers").some(item => (item.id || item) === "v_observatory") }; + } + + function bigNumber(value) { + if (!Array.isArray(value)) return number(value); + return value[0] * 10 ** value[1]; + } + + function bigLabel(value) { + const numeric = bigNumber(value); + if (Number.isFinite(numeric)) return numeric >= 1e12 ? numeric.toExponential(3) : chips(numeric); + return Array.isArray(value) && Number.isFinite(value[0]) && Number.isFinite(value[1]) ? `${value[0].toFixed(3)}e${value[1]}` : "Unavailable"; + } + + function calculateHand(state, selected, values = {}, options = {}) { + if (!Array.isArray(selected) || selected.length < 1 || selected.length > 5 || new Set(selected).size !== selected.length) return { error: "Select 1–5 different cards in play order." }; + const hand = area(state, "hand"); + if (selected.some(index => !Number.isInteger(index) || index < 0 || index >= hand.length)) return { error: "Selected card is not present in this frame." }; + const jokers = calculatorJokers(state, values); + const missing = jokers.filter(joker => joker.id == null || (joker.label && joker.value == null)); + if (missing.length) return { error: `Enter missing calculator inputs: ${missing.map(j => `${j.name} (${j.label || "unsupported joker"})`).join(", ")}.` }; + try { + const cards = hand.map(calculatorCard); + const encodedJokers = jokers.map(({ joker, id, value, name }) => { + const edition = { "": 0, base: 0, foil: 1, holo: 2, holographic: 2, polychrome: 3, negative: 4 }[modifierValue(joker, "edition")]; + if (edition == null) throw new Error(`${name} has an unsupported edition.`); + return [id, value ?? 0, edition, Number(Boolean(joker.debuff || joker.state?.debuff)), number(joker.sell) ?? 0]; + }); + if (jokers.some(j => (j.joker.id || j.joker.key) === "j_swashbuckler") && jokers.some(j => number(j.joker.sell) == null)) throw new Error("Swashbuckler needs every joker's recorded sell value."); + const planets = ["eris", "ceres", "planet_x", "neptune", "mars", "earth", "jupiter", "saturn", "venus", "uranus", "mercury", "pluto"]; + const hands = CALCULATOR_HANDS.map((name, i) => { + const stats = state.hand_stats?.[name] || []; + return [number(state.hand_values?.[name]?.[0]) ?? number(stats[0]) ?? 1, area(state, "consumables").filter(item => (item.id || item) === `c_${planets[i]}`).length, number(stats[1]) ?? 0, number(stats[2]) ?? 0]; + }); + const simulate = (best) => { + const { Hand, handChips } = upstreamCalculator(); + // Use the recorded base values (e.g. after a boss has changed them), + // while retaining the upstream scorer's hand detection and triggers. + CALCULATOR_HANDS.forEach((name, i) => { + const recorded = state.hand_values?.[name]; + if (number(recorded?.[1]) != null) handChips[i][0] = number(recorded[1]) - handChips[i][2] * (hands[i][0] - 1); + if (number(recorded?.[2]) != null) handChips[i][1] = number(recorded[2]) - handChips[i][3] * (hands[i][0] - 1); + }); + const simulation = new Hand({ cards: selected.map(i => cards[i].slice()), cardsInHand: cards.filter((_, i) => !selected.includes(i)).map(card => card.slice()), jokers: encodedJokers.map(j => j.slice()), hands: hands.map(h => h.slice()), ...calculatorDefaults(state), ...options }); + simulation.compileAll(); + const score = best ? simulation.simulateBestHand() : simulation.simulateWorstHand(); + return { hand: CALCULATOR_HANDS[simulation.typeOfHand], score: score.slice(0, 2), chips: score[2], mult: score[3] }; + }; + const low = simulate(false), high = simulate(true); + return { low, high, range: low.score[0] !== high.score[0] || low.score[1] !== high.score[1] }; + } catch (error) { + return { error: `Cannot calculate this frame: ${error.message}` }; + } + } + let stateMessages = $derived( text(sample?.response).includes("") ? [{ role: "assistant", content: sample.response }] @@ -303,8 +2402,21 @@ let discard = $derived(area(latest, "discard")); let deckCount = $derived(latest.deck_left ?? (deck.length > 0 ? deck.length : null)); let discardCount = $derived( - latest.discard_count ?? latest.discards ?? latest.blind?.discards ?? (discard.length > 0 ? discard.length : null), + latest.discard_count ?? (discard.length > 0 ? discard.length : null), ); + let phase = $derived(String(latest.phase || "").toUpperCase()); + let shopItems = $derived(phase === "SHOP" ? area(latest, "shop") : []); + let packOffers = $derived(phase === "SHOP" ? area(latest, "packs") : []); + let packChoices = $derived(phase === "PACK" || phase === "SMODS_BOOSTER_OPENED" ? area(latest, "pack") : []); + let inspector = $state(""); + let inventoryFocus = $state(""); + let flatFrames = $derived(groups.flatMap((group, groupIndex) => group.frames.map((frame, frameIndex) => ({ ...frame, groupIndex, frameIndex })))); + let framePosition = $derived(Math.max(0, flatFrames.findIndex(frame => frame.index === activeFrame?.index))); + + function seekFrame(position) { + const frame = flatFrames[Math.max(0, Math.min(flatFrames.length - 1, Number(position)))]; + if (frame) { activeGroupIndex = frame.groupIndex; activeFrameIndex = frame.frameIndex; } + } let jokers = $derived(area(latest, "jokers")); let consumables = $derived(area(latest, "consumables")); let consumablesForView = $derived( @@ -314,8 +2426,15 @@ ); let vouchers = $derived(area(latest, "vouchers")); let ownedVouchers = $derived(area(latest, "owned_vouchers")); + let recordedHands = $derived([...new Set([ + ...Object.keys(latest.hand_values || {}), ...Object.keys(latest.hand_stats || {}), + ])].map((name) => { + const values = latest.hand_values?.[name] || []; + const stats = latest.hand_stats?.[name] || []; + return { name, level: values[0] ?? stats[0], chips: values[1], mult: values[2], played: stats[1], round: stats[2] }; + })); let handValues = $derived( - latest.hand_values && typeof latest.hand_values === "object" ? latest.hand_values : {}, + calcState?.hand_values && typeof calcState.hand_values === "object" ? calcState.hand_values : {}, ); let latestReward = $derived(Array.isArray(rewardEvents) ? rewardEvents.at(-1) : null); let skipResult = $derived.by(() => { @@ -337,6 +2456,41 @@ }; }); + const viewerId = $props.id(); + let calcDraft = $state({ key: null, selected: [], values: {}, options: {} }); + let calcOutput = $state(null); + let openJoker = $state(null); + let calcState = $derived(actionUsesInputHand ? previousState : latest); + let calcKey = $derived(`${sample?.sample_id || sample?.id || "sample"}:${activeFrame?.index ?? -1}:${JSON.stringify(calcState)}`); + let calcSelected = $derived(calcDraft.key === calcKey ? calcDraft.selected : activeAction?.method === "play" ? [...selectedIndices] : []); + let calcValues = $derived(calcDraft.key === calcKey ? calcDraft.values : {}); + let calcOptions = $derived(calcDraft.key === calcKey ? calcDraft.options : calculatorDefaults(calcState || {})); + let calcJokerInputs = $derived(calculatorJokers(calcState || {}, calcValues)); + let canCalculate = $derived(["HAND", "SELECTING_HAND"].includes(String(calcState?.phase || "").toUpperCase()) && handForAction.length > 0); + let recordedPlay = $derived(activeAction?.method === "play" ? latest.play_commit : null); + let calcResult = $derived.by(() => { + if (calcOutput?.key === calcKey) return calcOutput.result; + if (activeAction?.method === "play" && canCalculate && calcSelected.length) { + return calculateHand(calcState, calcSelected, calcValues, calcOptions); + } + return null; + }); + + function updateCalculator(change) { + calcDraft = { key: calcKey, selected: [...calcSelected], values: { ...calcValues }, options: { ...calcOptions }, ...change }; + calcOutput = null; + } + + function toggleCalculatorCard(index) { + if (!canCalculate) return; + const next = calcSelected.includes(index) ? calcSelected.filter(i => i !== index) : calcSelected.length < 5 ? [...calcSelected, index] : calcSelected; + updateCalculator({ selected: next }); + } + + function runCalculator() { + calcOutput = { key: calcKey, result: calculateHand(calcState, calcSelected, calcValues, calcOptions) }; + } + function selectGroup(index) { activeGroupIndex = index; activeFrameIndex = 0; @@ -360,34 +2514,129 @@ {/if} {/snippet} -
-
-
-
BALATRO · TRAJECTORY
-

Run board

-

{groups.length} blinds · {states.length} turns · {Array.isArray(samples) ? samples.length : 0} samples

+{#snippet spriteArt(card, joker = false)} + {@const visual = spriteVisual(card, joker)} + {#if visual} + -
{latest.phase || run?.status || "RUN"}{latest.ante != null ? `ANTE ${latest.ante}` : ""}
-
+ {/if} +{/snippet} + +{#snippet jokerRack(items)} + +
+ {#each items as joker, index} + {@const tooltipId = `${viewerId}-joker-${index}`} +
+ + {@render badges(joker)} + +
+ {:else}
No jokers in this frame.
{/each} +
+{/snippet} - {#if groups.length} +{#snippet inventoryCard(item, index, kind = "item")} + {@const isJoker = String(typeof item === "string" ? item : item.id || item.key || "").startsWith("j_")} + {@const title = cardInfo(item).suit ? cardTitle(item) : itemName(item)} +
+ + {#if spriteVisual(item, isJoker)}{@render spriteArt(item, isJoker)}{:else}{kind === "pack" ? "✦" : kind === "voucher" ? "◆" : "☾"}{/if} + {title} + #{index}{item.cost != null ? " · $" + item.cost : ""}{kind === "owned" ? " · owned" : ""} + {@render badges(item)} + +
{title}

{item.effect || "Effect not recorded in this trajectory."}

{#if item.sell != null}Sell value: {"$" + item.sell}{/if}
Recorded data
{JSON.stringify(item, null, 2)}
+
+{/snippet} + +
`--atlas-${name}:url('${data}')`).join(";")}> + +
+
BALATROTRAJECTORY REPLAY · READ ONLY
+
{states.length} turns · {groups.length} phase groups · {Array.isArray(samples) ? samples.length : 0} samples
+ {latest.phase || run?.status || "RUN"} +
+ {#if activeGroup} - {#if activeGroup} -
+ +
+ {activeGroup.frames.length} turns {#each activeGroup.frames as frame, index} {/each} +
- +
+ +
+
+
{@render jokerRack(jokers)}
+
+ +
{#each consumables as item, index}{@render inventoryCard(item, index, "consumable")}{:else}No consumables{/each}
+
+
+
{#if activeAction}
{activeAction.method.replaceAll("_", " ")} @@ -408,22 +2657,6 @@ {/if} {/if} -
-
-
{String(progress?.label || latest.phase || "BLIND").replaceAll("_", " ")}{anteLabel}{latest.round != null ? ` · BLIND ${latest.round}` : ""}
-
- - {#if progress} -
-
CHIPS SCORED · THIS BLIND{chips(progress.current)}
-
CHIPS REQUIRED TO CLEAR{chips(progress.target)}
-
CHIPS STILL NEEDED{chips(chipsRemaining)}
-
-

{progress.pending ? "Blind not started. Chips start at 0 when you select it." : "Chips are cumulative within this blind and reset for the next blind."} Each ante has separate Small, Big, and Boss targets.

- {:else} -

No active blind score in this phase. Chips reset when the next blind starts.

- {/if} - {#if blindChoices.length}
@@ -445,13 +2678,24 @@

Skipping takes the tag instead of playing that blind. The description above states when its benefit applies; this is an in-game reward, not the training reward.

{/if} -
-
{deckCount ?? "—"}DECK
-
{latest.phase || "HAND"}{#if latest.money != null}${latest.money}{/if}
-
{discardCount ?? "—"}DISCARD
-
- + {#if phase === "SHOP"} +

SHOP

Reroll {latest.reroll_cost != null ? "$" + latest.reroll_cost : "cost not recorded"}
+
+
{#each shopItems as item, index}{@render inventoryCard(item, index, "shop")}{:else}

No cards recorded.

{/each}
+
{#each vouchers as item, index}{@render inventoryCard(item, index, "voucher")}{/each}{#each packOffers as item, index}{@render inventoryCard(item, index, "pack")}{/each}
+
+ {:else if phase === "PACK" || phase === "SMODS_BOOSTER_OPENED"} +

BOOSTER PACK

{packChoices.length} recorded choices
+
{#each packChoices as item, index}{@render inventoryCard(item, index, "choice")}{:else}

No pack choices recorded.

{/each}
+ {:else if phase === "GAME_OVER"} +

GAME OVER

Recorded terminal state · Ante {latest.ante ?? "—"}, round {latest.round ?? "—"}

+ {:else if !blindChoices.length && !activeAction} +
BALATRO{progress ? "Score the blind to advance" : "Recorded game state"}
+ {/if} +
+
+ {#if selectedIndices.length}
{activeAction.method} selected cards [{selectedIndices.join(", ")}]
{/if} @@ -459,82 +2703,285 @@
{#each handForAction as card, index (`${activeFrame?.index}-${index}-${cardTitle(card)}`)} {@const info = cardInfo(card)} - {@const isSelected = selectedIndices.includes(index)} -
0 && !isSelected}> -
- {@render finish(card)} - {info.rank}{info.suit}{info.suit || "·"} - {#if modifierValue(card, "seal")}✦{/if} - {#if isSelected}✓{/if} -
+ {@const isSelected = calcSelected.includes(index)} + {@const wasDiscarded = activeAction?.method === "discard" && selectedIndices.includes(index)} + {@const hasArt = spriteVisual(card) != null} +
0 ? !isSelected : activeAction?.method === "discard" && !wasDiscarded}> + + {modifierValue(card, "enhancement") === "stone" ? "Stone" : `${info.rank}${info.suit}`} {@render badges(card)}
{/each}
{:else}
No hand data at this turn.
{/if} + + + {#if actionUsesInputHand}

Historical action input. HUD and top inventory show the resulting state; calculation uses the pre-action cards and jokers.

{/if} +
+
+ UI only · never plays a hand + + +
+
+
+
+ +
{latestReward ? "Latest episode reward · " + (latestReward.label || "checkpoint") + " · " + Number(latestReward.reward || 0).toFixed(3) : "Frame " + (framePosition + 1) + " / " + flatFrames.length}Art & scoring: EFHIII · Font: Daniel Linssen
{:else}
No structured Balatro state found.
{/if}
diff --git a/dashboard/TrajectoryViewer.test.mjs b/dashboard/TrajectoryViewer.test.mjs index 17a5b2ee..74f62f27 100644 --- a/dashboard/TrajectoryViewer.test.mjs +++ b/dashboard/TrajectoryViewer.test.mjs @@ -1,4 +1,5 @@ import assert from "node:assert/strict"; +import { createHash } from "node:crypto"; import { readFileSync } from "node:fs"; import { createRequire } from "node:module"; import { resolve } from "node:path"; @@ -15,7 +16,7 @@ const source = readFileSync(new URL("./TrajectoryViewer.svelte", import.meta.url const compiled = compile(source, { generate: "server", filename: "TrajectoryViewer.svelte" }); const code = compiled.js.code.replace(/from '(svelte[^']*)'/g, (_, id) => `from '${pathToFileURL(require.resolve(id))}'`); const { default: Viewer } = await import(`data:text/javascript;base64,${Buffer.from(code).toString("base64")}`); -const helpers = new Function(`${source.slice(source.indexOf(" function text("), source.indexOf(" let stateMessages"))}; return { chipProgress, chips, statesFrom, actionsFrom };`)(); +const helpers = new Function(`${source.slice(source.indexOf(" // Sprite coordinates"), source.indexOf(" let stateMessages"))}; return { chipProgress, chips, statesFrom, actionsFrom, spriteVisual, modifierBadges, JOKER_SPRITES, CARD_ATLASES, calculateHand, calculatorJokers, calculatorCard, upstreamCalculator };`)(); const blinds = { small: { name: "Small Blind", type: "small", status: "SELECT", score: 300, tag: "Investment Tag", tag_effect: "After defeating the Boss Blind, gain $25." }, @@ -26,7 +27,7 @@ const initial = { phase: "BLIND_SELECT", ante: 1, round: 0, blinds }; const stateMessage = (state) => ({ role: "tool", content: `${JSON.stringify(state)}` }); const htmlFor = (state, action = null) => render(Viewer, { props: { trajectory: [...(action ? [{ role: "assistant", content: JSON.stringify(action) }] : []), stateMessage(state)], -} }).body; +} }).body.replace(/data:image\/png;base64,[A-Za-z0-9+/=]+/g, "data:image/png;base64,[embedded]"); test("both Svelte targets compile without warnings", () => { assert.deepEqual(compiled.warnings, []); @@ -100,3 +101,269 @@ test("initial snapshot seeds sparse deltas without shifting actions", () => { assert.equal(states[1].blind, undefined); assert.deepEqual(helpers.actionsFrom(messages), [{ method: "select", params: {} }]); }); + +test("all 52 playing cards map to the correct rank and suit cells", () => { + for (const [y, suit] of [..."HCDS"].entries()) { + for (const [x, rank] of ["2", "3", "4", "5", "6", "7", "8", "9", "T", "J", "Q", "K", "A"].entries()) { + const visual = helpers.spriteVisual(`${suit}_${rank}`); + assert.equal(visual.layers.length, 2); + assert.ok(visual.layers[1].style.includes(`background-position:${x / 12 * 100}% ${y / 3 * 100}%`)); + } + } +}); + +test("all 150 standard jokers have bounded coordinates and real artwork", () => { + assert.equal(Object.keys(helpers.JOKER_SPRITES).length, 150); + for (const [key, position] of Object.entries(helpers.JOKER_SPRITES)) { + assert.ok(position.x >= 0 && position.x < 10 && position.y >= 0 && position.y < 16, key); + const visual = helpers.spriteVisual({ id: key }, true); + assert.ok(visual.layers[0].style.includes("--atlas-Jokers"), key); + assert.ok(visual.mask.includes("mask-image"), key); + } + assert.deepEqual(helpers.JOKER_SPRITES.j_drivers_license, { x: 0, y: 7 }); + assert.equal(helpers.spriteVisual({ id: "j_hologram" }, true).layers[1].kind, "soul"); + assert.equal(helpers.spriteVisual({ id: "j_modded_unknown" }, true), null); +}); + +test("enhancements, editions and seals layer independently", () => { + for (const enhancement of ["BONUS", "MULT", "WILD", "LUCKY", "GLASS", "STEEL", "GOLD", "STONE"]) { + const visual = helpers.spriteVisual({ id: "S_A", mod: { enhancement, edition: "POLYCHROME", seal: "RED" } }); + assert.equal(visual.layers.some(l => l.kind === "face"), enhancement !== "STONE"); + assert.ok(visual.layers.some(l => l.kind === "edition" && l.style.includes("--atlas-Editions"))); + assert.ok(visual.layers.some(l => l.kind === "seal" && l.style.includes("--atlas-Enhancers"))); + } +}); + +test("editions and modifiers are visible on cards and jokers without hovering", () => { + for (const edition of ["FOIL", "HOLO", "POLYCHROME", "NEGATIVE"]) { + const html = htmlFor({ phase: "hand", hand: [{ id: "H_K", mod: { edition, enhancement: "STEEL", seal: "RED" } }], jokers: [{ id: "j_blueprint", effect: "Copies ability", mod: { edition, eternal: true, rental: true, perishable: 2 } }] }); + assert.ok(html.includes(`data-edition="${edition.toLowerCase()}"`)); + assert.ok(html.includes('class="sprite-art')); + assert.ok(html.includes('data-kind="edition"')); + for (const label of ["Steel", "Red Seal", "Eternal", "Rental", "Perishable · 2 rounds", "Blueprint"]) assert.ok(html.includes(label), label); + assert.ok(!html.includes("Object.keys")); + } +}); + +test("unknown cards keep text fallback and debuffed cards show the cross overlay", () => { + assert.equal(helpers.spriteVisual({ id: "unknown", mod: { edition: "FOIL" } }), null); + assert.ok(htmlFor({ phase: "hand", hand: [{ id: "unknown", mod: { edition: "FOIL" } }] }).includes("Foil")); + const visual = helpers.spriteVisual({ id: "S_A", debuff: true }); + assert.equal(visual.layers.at(-1).kind, "debuff"); +}); + +test("sprite sheets are embedded PNGs of the expected dimensions, within upload limit", () => { + const dimensions = { "8BitDeck": [923, 380], Jokers: [710, 1520], Enhancers: [497, 475], Editions: [355, 94] }; + for (const [name, data] of Object.entries(helpers.CARD_ATLASES)) { + const png = Buffer.from(data.split(",")[1], "base64"); + assert.equal(png.subarray(1, 4).toString(), "PNG"); + assert.deepEqual([png.readUInt32BE(16), png.readUInt32BE(20)], dimensions[name]); + } + assert.ok(Buffer.byteLength(source) < 2 * 1024 * 1024); + assert.ok(source.includes("prefers-reduced-motion: reduce")); +}); + +const scoreOf = result => result.low.score[0] * 10 ** result.low.score[1]; +test("embedded engine matches the pinned upstream code apart from the compiler annotation", () => { + const engine = source.split(" function upstreamCalculator() {\n")[1].split("\n return { Hand, handChips };")[0] + .replace("// svelte-ignore perf_avoid_nested_class (Each calculation needs isolated mutable hand-value tables.)\n", "") + "\n"; + assert.equal(createHash("sha256").update(engine).digest("hex"), "27ada8d35202a698ebd30b803e13dd1c765222f2e36ba54e806b5d69f69302a8"); +}); +test("upstream calculator scores a high card, pair and foil joker", () => { + assert.equal(scoreOf(helpers.calculateHand({ hand: ["S_A"] }, [0])), 16); + assert.equal(scoreOf(helpers.calculateHand({ hand: ["H_K", "D_K"] }, [0, 1])), 60); + const result = helpers.calculateHand({ hand: ["S_A"], jokers: [{ id: "j_joker", mod: { edition: "FOIL" } }] }, [0]); + assert.equal(scoreOf(result), 330); +}); + +test("upstream calculator applies Shortcut and Four Fingers", () => { + const shortcut = helpers.calculateHand({ hand: ["S_2", "H_4", "D_6", "C_8", "S_T"], jokers: [{ id: "j_shortcut" }] }, [0, 1, 2, 3, 4]); + assert.equal(shortcut.low.hand, "Straight"); + assert.equal(scoreOf(shortcut), 240); + const four = helpers.calculateHand({ hand: ["S_2", "H_3", "D_4", "C_5"], jokers: [{ id: "j_four_fingers" }] }, [0, 1, 2, 3]); + assert.equal(four.low.hand, "Straight"); + assert.equal(scoreOf(four), 176); +}); + +test("calculator scores held Steel and exposes random outcome ranges", () => { + assert.equal(scoreOf(helpers.calculateHand({ hand: ["S_A", { id: "H_K", mod: { enhancement: "STEEL" } }] }, [0])), 24); + const result = helpers.calculateHand({ hand: ["S_A"], jokers: [{ id: "j_misprint" }] }, [0]); + assert.equal(scoreOf(result), 16); + assert.equal(result.high.score[0] * 10 ** result.high.score[1], 384); + assert.equal(result.range, true); +}); + +test("calculator refuses unknown counters instead of silently assuming zero", () => { + const state = { hand: ["S_A"], jokers: [{ id: "j_hologram", effect: "Currently X2 Mult" }] }; + assert.match(helpers.calculateHand(state, [0]).error, /Hologram.*Cards Added/); + assert.equal(scoreOf(helpers.calculateHand(state, [0], { 0: 4 })), 32); + assert.match(helpers.calculateHand({ hand: ["S_A"], jokers: [{ id: "j_modded_unknown" }] }, [0]).error, /unsupported joker/); +}); + +test("calculator auto-loads known counters and recorded hand values without mutating state", () => { + const state = { hand: ["S_A"], money: 10, jokers: [{ id: "j_bull", sell: 3 }], hand_values: { "High Card": [2, 25, 3] } }; + const before = JSON.stringify(state); + assert.equal(helpers.calculatorJokers(state)[0].value, 10); + assert.equal(scoreOf(helpers.calculateHand(state, [0])), (25 + 11 + 20) * 3); + assert.equal(JSON.stringify(state), before); + assert.equal(scoreOf(helpers.calculateHand({ hand: ["S_A"] }, [0])), 16, "custom base values must not leak into later calculations"); +}); + +test("calculator preserves selected play order and validates unsupported input", () => { + const state = { hand: ["H_2", "D_K"], jokers: [{ id: "j_hanging_chad" }, { id: "j_splash" }] }; + const a = helpers.calculateHand(state, [0, 1]), b = helpers.calculateHand(state, [1, 0]); + assert.notEqual(scoreOf(a), scoreOf(b)); + for (const cards of [[], [0, 0], [9], [0, 1, 2, 3, 4, 5]]) assert.ok(helpers.calculateHand(state, cards).error); + assert.match(helpers.calculateHand({ hand: [{ id: "S_A", mod: { edition: "MODDED" } }] }, [0]).error, /unsupported modifier/); +}); + +test("joker info is an accessible hover/focus tooltip and calculation is UI-only", () => { + const html = htmlFor({ phase: "hand", hand: ["S_A"], jokers: [{ id: "j_joker", effect: "+4 Mult", sell: 2 }] }); + for (const label of ['role="tooltip"', 'aria-describedby=', "+4 Mult", "Sell value: $2", "EFHIII scoring engine", "UI estimate, not a live-game prediction", 'aria-pressed="false"']) assert.ok(html.includes(label), label); + assert.ok(source.includes(".joker-slot:hover .joker-tooltip, .joker-slot:focus-within .joker-tooltip")); + assert.ok(source.includes("#3a5055")); + assert.ok(!source.includes("--felt:")); +}); + +test("compact game layout keeps replay and inspectors without expanding them", () => { + const html = htmlFor({ phase: "hand", ante: 3, round: 7, money: 29, hand: ["S_A"], blind: { score: [42, 2000], hands: 3, discards: 2 } }); + for (const label of ['aria-label="Recorded game status"', 'aria-label="Ante, round, and blind"', 'aria-label="Turns in selected blind"', 'aria-label="Previous frame"', 'aria-label="Next frame"', "Hands left", "Discards left", "$29", "Run info", "Trace & rewards", "UI CALCULATOR · ESTIMATE"]) assert.ok(html.includes(label), label); + assert.match(html, /class="inspector-panel[^\"]*" hidden/); + assert.ok(!html.includes('type="range"')); + assert.ok(html.indexOf('class="blind-strip') < html.indexOf('class="game-layout')); + assert.ok(html.indexOf('class="turn-strip') < html.indexOf('class="game-layout')); + assert.ok(html.includes("ante 3") && html.includes("round 7")); + assert.ok(html.indexOf('class="game-hud') < html.indexOf('class="game-table')); + assert.ok(html.indexOf('class="top-racks') < html.indexOf('class="hand-zone')); + assert.ok(source.includes("@container (max-width: 480px)")); +}); + +test("shop renders prices, offers, vouchers and boosters without an active score", () => { + const html = htmlFor({ phase: "shop", money: 15, reroll_cost: 5, + shop: [{ id: "j_joker", effect: "+4 Mult", cost: 2, mod: { edition: "foil" } }], + vouchers: [{ id: "v_overstock_norm", effect: "+1 card slot in shop", cost: 10 }], + packs: [{ id: "p_arcana_normal_1", name: "Arcana Pack", effect: "Choose 1 of 3 Tarot cards", cost: 4 }], + owned_vouchers: [{ id: "v_hone", effect: "Edition odds doubled" }], blind: { score: [999, 300] }, + }); + for (const label of ["CARDS FOR SALE", "Reroll $5", "VOUCHERS & BOOSTER PACKS", "Arcana Pack", "Choose 1 of 3 Tarot cards", "$4", "$10", "Foil", "Edition odds doubled", "No active blind score"]) assert.ok(html.includes(label), label); + assert.ok(!html.includes("CHIPS SCORED")); +}); + +test("booster choices retain effects and modifiers", () => { + const html = htmlFor({ phase: "pack", pack: [{ id: "S_A", mod: { enhancement: "glass", edition: "polychrome", seal: "red" } }, { id: "c_death", effect: "Convert left card into right card" }] }); + for (const label of ["BOOSTER PACK", "2 recorded choices", "Glass", "Polychrome", "Red Seal", "Convert left card into right card"]) assert.ok(html.includes(label), label); +}); + +test("discards left never masquerade as discard pile size", () => { + const state = { phase: "hand", hand: ["S_A"], blind: { score: [0, 300], hands: 4, discards: 3 }, deck_left: 49 }; + assert.ok(htmlFor(state).includes("Discard pile: —")); + const html = htmlFor({ ...state, discard: ["H_2", "C_3"] }); + assert.match(html, /Discards left<\/small>]*>3<\/strong>/); + assert.ok(html.includes("Discard pile: 2")); + assert.ok(html.includes("DECK 49")); +}); + +test("complete trace and inventory stay inspectable, including fields without dedicated widgets", () => { + const html = htmlFor({ phase: "hand", hand: ["S_A"], deck: ["H_2"], custom_future_field: { unusual: "retained information" }, hand_stats: { Pair: [3, 6, 1] }, owned_vouchers: [{ id: "v_hone", effect: "Edition odds doubled" }] }); + for (const label of ["retained information", "Complete frame state", "Action & input state", "Reward events · entire episode, not frame-aligned", "Deck composition · 1 recorded cards", "Poker hand levels & history", "Edition odds doubled"]) assert.ok(html.includes(label), label); +}); + +test("empty compact inventory does not render slot metadata as a fake card", () => { + const html = htmlFor({ phase: "hand", hand: ["S_A"], jokers: { slots: "0/5" }, consumables: { slots: "0/2" } }); + assert.ok(html.includes("No jokers in this frame.")); + assert.ok(html.includes("No consumables")); + assert.ok(!html.includes("Info: Slots")); + assert.ok(!html.includes("0/0/5")); +}); + +test("inventory sections default collapsed and render cards instead of JSON walls", () => { + const html = htmlFor({ phase: "hand", jokers: [{ id: "j_joker", mod: { edition: "foil" } }], consumables: [{ id: "c_fool", effect: "Create last Tarot" }], deck: ["H_2"], discard: ["C_3"], hand_values: { Pair: [3, 40, 4] }, hand_stats: { Pair: [3, 6, 0], Flush: [1, 0, 0] } }); + for (const label of ["Owned vouchers · 0", "Jokers · 1", "Consumables · 1", "Deck composition · 1 recorded cards", "Discard pile · 1", "Poker hand levels & history · current state"]) + assert.ok(new RegExp(`]*>]*>${label}`).test(html), label); + assert.ok(!/]*\bopen\b[^>]*>]*>(Owned vouchers|Jokers|Consumables|Deck composition|Discard pile|Poker hand levels)/.test(html)); + for (const kind of ["joker", "consumable", "deck", "discard"]) assert.ok(html.includes(`data-kind="${kind}"`), kind); + for (const label of ["No owned vouchers recorded.", "Create last Tarot", "2♥", "3♣", "Foil", "Played total", "This round", "Recorded data"]) assert.ok(html.includes(label), label); + const rows = html.match(/([\s\S]*?)<\/tbody>/)[1].replace(//g, "").replace(/<[^>]*>/g, " ").replace(/\s+/g, " "); + assert.ok(rows.includes("Pair 3 40 4 6 0"), rows); + assert.ok(rows.includes("Flush 1 — — 0 0"), rows); +}); + +// Exercise the same reactive replay state at a selected frame via SSR. This +// changes only initial navigation state in the test build, not viewer logic. +const replayTestComponents = new Map(); +async function replayHtml(before, action, after, groupIndex = 0, frameIndex = 1) { + const key = `${groupIndex}:${frameIndex}`; + if (!replayTestComponents.has(key)) { + const fixtureSource = source.replace('let activeGroupIndex = $state(0);', `let activeGroupIndex = $state(${groupIndex});`).replace('let activeFrameIndex = $state(0);', `let activeFrameIndex = $state(${frameIndex});`); + const built = compile(fixtureSource, { generate: "server" }).js.code.replace(/from '(svelte[^']*)'/g, (_, id) => `from '${pathToFileURL(require.resolve(id))}'`); + const { default: component } = await import(`data:text/javascript;base64,${Buffer.from(built).toString("base64")}`); + replayTestComponents.set(key, component); + } + return render(replayTestComponents.get(key), { props: { trajectory: [{ role: "user", content: `Gamestate: ${JSON.stringify(before)}` }, { role: "assistant", content: JSON.stringify(action) }, stateMessage(after)] } }).body.replace(/data:image\/png;base64,[A-Za-z0-9+/=]+/g, "[embedded]"); +} + +test("discard replay highlights removed input cards, not their replacements", async () => { + const html = await replayHtml({ phase: "hand", ante: 1, round: 1, blind: { type: "small", score: [0,300] }, hand: ["S_A", "H_2", "C_3"] }, { method: "discard", params: { cards: [1,2] } }, { hand: ["S_A", "D_K", "D_Q"], discard: ["H_2", "C_3"] }); + assert.equal((html.match(/class="playing-card[^\"]*recorded-discard/g) || []).length, 2); + assert.ok(html.includes("Discarded this turn. Select 2♥")); + assert.ok(html.includes("DISCARD INPUT")); + assert.ok(html.includes('aria-label="Inspect discard pile"')); + assert.ok(source.includes('open={inventoryFocus === "discard"}')); + assert.ok(!html.includes("ACTUAL PLAY · RECORDED")); +}); + +test("play frames auto-calculate and show recorded score independently", async () => { + const html = await replayHtml({ phase: "hand", ante: 1, round: 1, blind: { type: "small", score: [0,300] }, hand: ["S_A", "H_K"], jokers: { slots: "0/5" } }, { method: "play", params: { cards: [0] } }, { blind: { score: [16,300] }, hand: ["C_2", "H_K"], play_commit: { score: 16, hand: "High Card", cards: [0] } }); + for (const label of ["ACTUAL PLAY · RECORDED", "16 chips", "UI CALCULATOR · ESTIMATE", "High Card"]) assert.ok(html.includes(label), label); + assert.match(html, /class="hud-calculation[\s\S]*?]*>16<\/strong>/); + assert.ok(!html.includes("Select cards to calculate")); +}); + +test("winning play auto-calculates pre-shop inputs and preserves actual random outcome", async () => { + const html = await replayHtml({ phase: "hand", ante: 1, round: 1, blind: { type: "small", score: [280,300] }, hand: ["S_A"], jokers: [{ id: "j_misprint" }] }, { method: "play", params: { cards: [0] } }, { phase: "shop", blind: null, hand: null, play_commit: { score: 128, hand: "High Card", cards: [0] } }, 1, 0); + assert.ok(html.includes("128 chips")); + assert.ok(html.includes("16 – 384")); + assert.ok(html.includes("PLAY INPUT · PRE-SHOP STATE")); + assert.ok(!html.includes("CHIPS SCORED")); +}); + +test("missing calculator inputs never hide the actual recorded play score", async () => { + const html = await replayHtml({ phase: "hand", ante: 1, round: 1, blind: { type: "small", score: [0,300] }, hand: ["S_A"], jokers: [{ id: "j_hologram" }] }, { method: "play", params: { cards: [0] } }, { blind: { score: [32,300] }, play_commit: { score: 32, hand: "High Card", cards: [0] } }); + assert.ok(html.includes("32 chips")); + assert.ok(html.includes("Estimate needs inputs")); +}); + +test("Idol targets auto-populate all 52 upstream Card IDs from structured snapshots", () => { + for (const [rankIndex, rank] of ["2","3","4","5","6","7","8","9","T","J","Q","K","A"].entries()) { + for (const [suitIndex, suit] of [..."HCDS"].entries()) { + const joker = { id: "j_idol", scoring_state: { target: { rank, suit } } }; + assert.equal(helpers.calculatorJokers({ jokers: [joker] })[0].value, rankIndex * 4 + suitIndex); + const plain = scoreOf(helpers.calculateHand({ hand: [suit + "_" + rank] }, [0])); + assert.equal(scoreOf(helpers.calculateHand({ hand: [suit + "_" + rank], jokers: [joker] }, [0])), plain * 2); + } + } +}); + +test("old trace Idol descriptions supply actual round targets without guessing", () => { + const joker = { id: "j_idol", effect: "Each played 3 of Hearts gives X2 Mult when scored Card changes every round" }; + assert.equal(helpers.calculatorJokers({ jokers: [joker] })[0].value, 4); + assert.equal(scoreOf(helpers.calculateHand({ hand: ["H_3"], jokers: [joker] }, [0])), 16); + assert.equal(scoreOf(helpers.calculateHand({ hand: ["C_3"], jokers: [joker] }, [0])), 8); + const unknown = { id: "j_idol", effect: "Each played [rank] of [suit] gives X2 Mult" }; + assert.match(helpers.calculateHand({ hand: ["H_3"], jokers: [unknown] }, [0]).error, /Enter missing calculator inputs/); +}); + +test("structured targets override text and refresh across sparse round deltas", () => { + const first = { jokers: { items: [{ id: "j_idol", effect: "Each played 3 of Hearts gives X2 Mult", scoring_state: { target: { rank: "K", suit: "S" } } }] } }; + const states = helpers.statesFrom([stateMessage(first), stateMessage({ jokers: { items: [{ id: "j_idol", scoring_state: { target: { rank: "2", suit: "H" } } }] } })]); + assert.equal(helpers.calculatorJokers(states[0])[0].value, 47); + assert.equal(helpers.calculatorJokers(states[1])[0].value, 0); +}); + +test("Ancient suit and Castle accumulated chips populate their calculator inputs", () => { + const ancient = { id: "j_ancient", scoring_state: { target: { suit: "C" } } }; + assert.equal(helpers.calculatorJokers({ jokers: [ancient] })[0].value, 1); + assert.equal(scoreOf(helpers.calculateHand({ hand: ["C_A"], jokers: [ancient] }, [0])), 24); + const castle = { id: "j_castle", scoring_state: { target: { suit: "D" }, chips: 27, chip_gain: 3 } }; + assert.equal(scoreOf(helpers.calculateHand({ hand: ["C_A"], jokers: [castle] }, [0])), 43); +}); diff --git a/reports/broad-layover-2026-09-15.md b/reports/broad-layover-2026-09-15.md new file mode 100644 index 00000000..6627d26d --- /dev/null +++ b/reports/broad-layover-2026-09-15.md @@ -0,0 +1,149 @@ +# Broad-layover trace audit — 2026-09-15 + +Run: `broad-layover-3a0ce678e7da`, resumed from +`perfect-adhesive-da14ace5a831`, 8 colocated nodes, 16 seed groups × 4 samples +(64 episodes/update). No training settings or rewards were changed for this audit. + +## Status and learning trend + +At the final status check the job was running, reporting weight sync at +416/600, with rollout 415 reward 46.47. The numbering resumes at 400; this +does not mean this continuation has already performed 416 new updates. + +For the first 14 completed batches (400–413): + +| Window | Episodes | Mean reward | Mean final ante | +|---|---:|---:|---:| +| 400–406 | 448 | 51.70 | 3.27 | +| 407–413 | 448 | 50.52 | 3.18 | +| Parent run 390–399 | 320 | 51.32 | 3.30 | + +The continuation is approximately flat, not demonstrating a clear increase +in depth. Across 400–413 there were no wins in 896 episodes; the highest +recorded final ante was 7. These are training batches with different seeds, +not a controlled fixed-seed evaluation. A single low batch is not sufficient +evidence of parameter/entropy collapse. + +## What happened in the traces + +I reconstructed sparse states (including nested fallback/error results), +read prompts and model responses, and audited all 192 episodes in batches +400, 412 and 413. The dashboard CLI rejected its stored authentication; +the reads used the authenticated Training Gym SDK and persisted rollout data. + +| Rollout | Mean reward | Game over | Context cap | Ended at ante 1 | +|---|---:|---:|---:|---:| +| 400 | 52.23 | 55 | 9 | 12 | +| 412 | 55.67 | 59 | 5 | 11 | +| 413 | 36.45 | 63 | 1 | 29 | + +The latest audited dip is primarily more early game overs, not more context +cutoffs or terminal RPC errors. No audited episode hit the 250-decision cap. +This does not prove every game over is free of harness influence. + +### 1. Narrow hand selection and missed joker synergies + +Of 3,914 executed plays, 2,799 (71.5%) were Pair or Two Pair. Only four were +Straights and two were Flushes. The model made no `sell` or blind `skip` +actions across these batches, and rerolled a shop only three times. +This describes a narrow strategy, not a proof that each such action was bad. + +There were 131 plays of Pair/High Card while a raw five-rank straight existed +in hand, across 91 episodes. This is an opportunity flag, not an exact-regret +metric: debuffs, enhancements and joker synergies can favor a lower hand type. + +One unambiguous example is rollout 413, sample index 0, action 16: + +- Ante 1 Big Blind; 256/450 chips, one hand and one discard remaining. +- Hand indices: `0 H_A, 1 D_K, 2 S_Q, 3 H_J, 4 D_J, 5 H_T, 6 S_8, 7 C_2`. +- Jokers: Superposition and Devious Joker (+100 Chips for a Straight). +- Played `[4,3,5,6,2]`: a Pair, 60 chips; lost at 316/450. +- `[0,1,2,3,5]` is A-K-Q-J-10. From the recorded, unmodified inputs, + `(30 + 51 + 100) × 4 = 724` chips, comfortably enough to clear. + This arithmetic is not a new game-engine replay, but there is no random + scoring modifier in the recorded state. Superposition also benefits from + this exact straight. Sample 2 repeats essentially the same mistake. + +In sample 3, action 24, A-K-Q-J-10 was again available; the policy instead +played Q-J-10-9-5 as High Card, scoring 15 and losing to The Hook. +The relevant card/joker information was present in the model's context. + +### 2. The context budget cuts off deeper attempts + +15/192 episodes (7.8%) hit the 49,152-token context limit, typically after +102–135 decisions, well before the 250-decision limit. Examples include +rollout 400 sample 7 ending alive in the ante-6 shop and rollout 412 sample +38 ending at ante 5 with 17,242/22,000 chips and a hand remaining. + +These traces do not establish that the capped games would have won, but +the model is denied the opportunity to continue. Raising only the decision +budget cannot fix this. Context caps retain earned progress and receive no +cap penalty in the current reward implementation; decision caps get -10. + +### 3. Confirmed pack legality gap: Judgement at full joker capacity + +Rollout 413, sample 39: + +- Action 61: skipped a Buffoon pack while at 5/5 jokers. +- Action 62: bought an Arcana pack containing The Moon, Judgement and Wheel + of Fortune. +- Action 63: `pack {card:1}` used Judgement at 5/5. +- The next raw state contains **six actual joker entries**, slots `6/5`, + adding ordinary Bloodstone with no Negative edition. This is not just a + dashboard counting artifact. + +The pack endpoint checks capacity for a directly selected Joker, but invokes +`G.FUNCS.use_card` for Tarot/Spectral selections without the +`can_use_consumeable()` check used by the normal `use` endpoint. The compact +pack legal-action filter also lacks a Judgement-at-capacity exclusion. +This permits a game-rule violation and should be corrected separately. +No pack behavior was changed during this diagnosis. + +### 4. Repeated ante checkpoint bonuses after ante-lowering vouchers + +Rollout 400, sample 8 went 1→2→3, bought a voucher at action 48 that changed +ante 3→2, then cleared 2→3 again and later 3→4. It therefore recorded four +ante checkpoint bonuses despite finishing at ante 4. + +The ante regression itself is legitimate voucher behavior. The reward +function awards +8 on every positive ante delta and does not distinguish +first attainment from re-clearing an already reached ante. This explains +some reward/final-ante disagreement and creates an objective loophole if the +goal is uniquely advancing toward ante 8. It is separate from UI labeling. +No reward changes were made. + +### 5. Missing machine-readable joker targets + +Rollout 412 already records Idol targets in effect text, e.g. “3 of Hearts” +and “10 of Diamonds.” The prior calculator adapter did not read them. +The viewer now parses exact recorded targets for historical traces; future +RPC snapshots include structured visible round targets for The Idol, Ancient +Joker, Mail-In Rebate and Castle. It does not save/expose private RNG state, +roll RNG during observation, or substitute today's target into older frames. + +The traces also contain unresolved boss-description placeholders such as +`#1# in #2# cards get drawn face down`; structured numerical effect data would +avoid that information loss. This was noted, not repaired in this patch. + +## Interpretation and next steps + +The evidence supports a mixture of a narrow, sometimes plainly incorrect +policy; context-limited long episodes; and remaining legality/reward gaps. +It does not support explaining everything as flaky execution or diagnosing +an optimizer collapse from the reward dip alone. + +The next experiments should first close the Judgement pack legality gap, +decide whether ante bonuses mean first attainment or repeated clears, and +address history growth. Then compare fixed seeds and hand-level decisions. +Larger batches alone do not teach the missing scoring/synergy reasoning. + +## Changes completed for the accompanying UI requests + +- Restored expanded ante/round/phase navigation and per-group turn buttons. +- Restored discarded-card highlighting and a direct discard-pile inspector. +- Automatically calculate recorded play frames; show actual recorded chips + separately from estimates, including when estimate inputs are missing. +- Recover saved Idol targets and add structured target capture for newly + built sandboxes. Existing training workers were not hot-patched. +- 38 viewer tests and 18 CPU serializer/launcher tests passed; the dashboard + bundle compiled. Browser visual verification was unavailable. diff --git a/src/lua/endpoints/pack.lua b/src/lua/endpoints/pack.lua index b27b0657..839c2af6 100644 --- a/src/lua/endpoints/pack.lua +++ b/src/lua/endpoints/pack.lua @@ -265,6 +265,28 @@ return { end end + -- Pack consumables are used immediately. Calling use_card directly + -- bypasses the UI's legality gate (e.g. Judgement at 5/5 joker slots). + -- Ask the game's own rules after targets have been highlighted, just + -- as the owned-consumable endpoint does. Do not gate playing cards or + -- Jokers with a consumable-only predicate. + if card.ability and card.ability.consumeable then + if not card:can_use_consumeable() then + send_response({ + message = "Consumable '" .. (card.ability.name or card_key or "Unknown") .. "' cannot be used at this time", + name = BB_ERROR_NAMES.NOT_ALLOWED, + }) + return true + end + if card:check_use() then + send_response({ + message = "Cannot use consumable: insufficient space", + name = BB_ERROR_NAMES.NOT_ALLOWED, + }) + return true + end + end + -- Log what we're selecting local card_name = card.ability and card.ability.name or "Unknown" local card_set = card.ability and card.ability.set or card.set or "card" diff --git a/src/lua/utils/gamestate.lua b/src/lua/utils/gamestate.lua index cb8d338b..0cdaedc9 100644 --- a/src/lua/utils/gamestate.lua +++ b/src/lua/utils/gamestate.lua @@ -320,6 +320,32 @@ end -- Card Extractor -- ========================================================================== +-- These are the targets already visible on the joker this round, not RNG +-- seeds or future outcomes. Never invoke a reset/random function while reading. +local function extract_joker_scoring_state(card) + local key = card.config and (card.config.center_key or (card.config.center and card.config.center.key)) + local target_keys = { + j_idol = "idol_card", + j_ancient = "ancient_card", + j_mail = "mail_card", + j_castle = "castle_card", + } + local target_key = target_keys[key] + local current_round = G and G.GAME and G.GAME.current_round + local target = target_key and current_round and current_round[target_key] + if type(target) ~= "table" then return nil end + local visible_target = {} + if target.suit then visible_target.suit = convert_suit_to_enum(target.suit) end + if target.rank then visible_target.rank = convert_rank_to_enum(tostring(target.rank)) end + if type(target.id) == "number" then visible_target.rank_id = target.id end + local result = { target = visible_target } + if key == "j_castle" and card.ability and type(card.ability.extra) == "table" then + result.chips = card.ability.extra.chips + result.chip_gain = card.ability.extra.chip_mod + end + return result +end + ---Extracts a complete Card object from a game card ---@param card table The game card object ---@return Card card The Card object @@ -366,6 +392,7 @@ local function extract_card(card) modifier = extract_card_modifier(card), state = extract_card_state(card), cost = extract_card_cost(card), + scoring_state = extract_joker_scoring_state(card), } end diff --git a/src/lua/utils/openrpc.json b/src/lua/utils/openrpc.json index 8fabf7e6..beb58a2b 100644 --- a/src/lua/utils/openrpc.json +++ b/src/lua/utils/openrpc.json @@ -1156,6 +1156,22 @@ }, "cost": { "$ref": "#/components/schemas/CardCost" + }, + "scoring_state": { + "type": "object", + "description": "Already-visible round target for Idol, Ancient Joker, Mail-In Rebate or Castle; never RNG seeds or future outcomes.", + "properties": { + "target": { + "type": "object", + "properties": { + "rank": { "$ref": "#/components/schemas/Rank" }, + "suit": { "$ref": "#/components/schemas/Suit" }, + "rank_id": { "type": "integer" } + } + }, + "chips": { "type": "number" }, + "chip_gain": { "type": "number" } + } } }, "required": [ diff --git a/src/lua/utils/types.lua b/src/lua/utils/types.lua index 96895ae7..8e54bd75 100644 --- a/src/lua/utils/types.lua +++ b/src/lua/utils/types.lua @@ -74,6 +74,12 @@ ---@field modifier Card.Modifier Modifier information (seals, editions, enhancements) ---@field state Card.State Current state information (debuff, hidden, highlighted) ---@field cost Card.Cost Cost information (buy/sell prices) +---@field scoring_state Card.ScoringState? Visible round-specific joker target/counters (never the RNG state) + +---@class Card.ScoringState +---@field target {rank: string?, suit: string?, rank_id: integer?} The current round's already-selected target +---@field chips number? Current Castle chips +---@field chip_gain number? Castle chips gained per matching discarded card ---@class Card.Value ---@field suit Card.Value.Suit? Suit (Hearts, Diamonds, Clubs, Spades) - only for playing cards diff --git a/tests/test_joker_scoring_state.py b/tests/test_joker_scoring_state.py new file mode 100644 index 00000000..3e1b34dd --- /dev/null +++ b/tests/test_joker_scoring_state.py @@ -0,0 +1,75 @@ +"""CPU-only checks of visible joker targets from Lua RPC through compact traces.""" + +import ast +import json +import shutil +import subprocess +from pathlib import Path +from typing import Any + +import pytest + +ROOT = Path(__file__).resolve().parents[1] + + +def test_rpc_reads_targets_without_advancing_randomness(): + lua = shutil.which("luajit") + if not lua: + pytest.skip("LuaJIT is needed for the RPC serializer test") + script = r''' +local gs = dofile("src/lua/utils/gamestate.lua") +function pseudorandom() error("A state read must not roll RNG") end +function pseudoseed() error("A state read must not roll RNG") end +function card(key, extra) + return {config={center_key=key}, ability={set="Joker",extra=extra}, + generate_UIBox_ability_table=function() return {main={}} end} +end +G = {STATE=1,STATES={SELECTING_HAND=1},GAME={current_round={ + idol_card={rank="King",suit="Hearts",id=13,private_seed="not exported"}, + ancient_card={suit="Clubs"},mail_card={rank="Ace",id=14}, + castle_card={suit="Diamonds"},unrelated_rng=999}}, + jokers={config={card_count=5,card_limit=5},cards={ + card("j_idol"),card("j_ancient"),card("j_mail"), + card("j_castle",{chips=27,chip_mod=3}),card("j_joker")}}} +local first=gs.get_gamestate().jokers.cards +assert(first[1].scoring_state.target.rank=="K") +assert(first[1].scoring_state.target.rank_id==13) +assert(first[1].scoring_state.target.suit=="H") +assert(first[1].scoring_state.target.private_seed==nil) +assert(first[2].scoring_state.target.suit=="C") +assert(first[3].scoring_state.target.rank=="A") +assert(first[4].scoring_state.target.suit=="D") +assert(first[4].scoring_state.chips==27 and first[4].scoring_state.chip_gain==3) +assert(first[5].scoring_state==nil) +G.GAME.current_round.idol_card={rank="10",suit="Spades",id=10} +local second=gs.get_gamestate().jokers.cards +assert(second[1].scoring_state.target.rank=="T") +assert(second[1].scoring_state.target.suit=="S") +assert(first[1].scoring_state.target.rank=="K", "snapshot must not alias live tables") +G.GAME.current_round=nil +assert(gs.get_gamestate().jokers.cards[1].scoring_state==nil) +print("ok") +''' + result = subprocess.run([lua, "-"], input=script, text=True, cwd=ROOT, capture_output=True, check=True) + assert result.stdout.strip() == "ok" + + +@pytest.mark.parametrize("limit", [6000, 1]) +def test_compact_trace_preserves_targets_even_when_deck_is_omitted(limit): + tree = ast.parse((ROOT / "batro_modal_rl.py").read_text()) + node = next(n for n in tree.body if isinstance(n, ast.FunctionDef) and n.name == "_compact_state") + namespace = {"Any": Any, "json": json} + exec(compile(ast.Module(body=[node], type_ignores=[]), "batro_modal_rl.py", "exec"), namespace) + target = {"target": {"rank": "K", "rank_id": 13, "suit": "H"}} + state = {"state": "SELECTING_HAND", "jokers": {"count": 1, "limit": 5, "cards": [{"key": "j_idol", "value": {"effect": "X2 Mult on the current target"}, "scoring_state": target}]}} + before = json.dumps(state) + compact = json.loads(namespace["_compact_state"](state, limit)) + assert compact["jokers"]["items"][0]["scoring_state"] == target + assert json.dumps(state) == before + + +def test_rpc_schema_describes_optional_scoring_state(): + schema = json.loads((ROOT / "src/lua/utils/openrpc.json").read_text()) + card = schema["components"]["schemas"]["Card"] + assert "scoring_state" in card["properties"] + assert "scoring_state" not in card["required"] diff --git a/tests/test_pack_legality.py b/tests/test_pack_legality.py new file mode 100644 index 00000000..19557454 --- /dev/null +++ b/tests/test_pack_legality.py @@ -0,0 +1,95 @@ +"""CPU-only regression of the real pack endpoint's game-level legality gate.""" + +import shutil +import subprocess +import zipfile +from pathlib import Path + +import pytest + +ROOT = Path(__file__).resolve().parents[1] + + +@pytest.mark.parametrize("real_game_rules", [False, True]) +def test_pack_checks_consumable_legality_before_using_card(real_game_rules): + lua = shutil.which("luajit") + if not lua: + pytest.skip("LuaJIT is needed for the endpoint regression") + rules = "" + if real_game_rules: + archive = Path.home() / "Library/Application Support/Steam/steamapps/common/Balatro/Balatro.app/Contents/Resources/Balatro.love" + if not archive.exists(): + pytest.skip("Optional check against the installed game's own legality predicate") + with zipfile.ZipFile(archive) as game: + source = game.read("card.lua").decode() + # Exercise the installed game's actual rule without copying proprietary + # game code into the repository. UI/animation dependencies stay stubbed. + predicate = source.split("function Card:can_use_consumeable", 1)[1].split("function Card:check_use", 1)[0] + rules = "Card = {}\nfunction Card:can_use_consumeable" + predicate + script = rules + r''' +package.preload.socket = function() return {gettime=function() return 0 end} end +SMODS = {load_file=function() return function() + return {format_playing_cards=function() return "targets" end} +end end} +function sendDebugMessage() end +function Event(event) return event end +BB_ERROR_NAMES = {NOT_ALLOWED="NOT_ALLOWED", BAD_REQUEST="BAD_REQUEST"} +BB_GAMESTATE = {get_gamestate=function() return {ok=true} end} +G = {STATES={SMODS_BOOSTER_OPENED=1,SHOP=2,BLIND_SELECT=3}} +local endpoint = dofile("src/lua/endpoints/pack.lua") +local function run(set, count, usable, space_blocked, targets) + local used, checked, responses, events = 0, 0, {}, {} + local card = {ability={set=set,name="Judgement",consumeable=set~="Joker" and set~="Default" and {}}, + config={center={key="c_judgement"}}, + can_use_consumeable=function(self) + checked=checked+1 + if targets then assert(#G.hand.highlighted == #targets) end + if usable~=nil then return usable end + if Card then return Card.can_use_consumeable(self) end + return G.jokers.config.card_count < G.jokers.config.card_limit + end, + check_use=function() return space_blocked end} + G.STATE=1; G.STATE_COMPLETE=true; G.GAME={pack_choices=1} + G.P_CENTERS={c_judgement={config=targets and {max_highlighted=1} or {}}} + G.CONTROLLER={locked=false} + G.jokers={cards={},config={card_count=count,card_limit=5}} + for i=1,count do G.jokers.cards[i]={} end + G.pack_cards={cards={card},config={card_count=1}} + G.deck={config={card_count=1}} + G.hand={cards={{T={x=1}}},highlighted={},config={card_limit=1},T={x=1}, + add_to_highlighted=function(self,c) table.insert(self.highlighted,c) end, + remove_from_highlighted=function(self,c) table.remove(self.highlighted) end} + G.E_MANAGER={add_event=function(self,e) table.insert(events,e) end} + G.FUNCS={use_card=function() + used=used+1; G.jokers.config.card_count=count+1 + G.STATE=2; G.pack_cards=nil + end} + endpoint.execute({card=0,targets=targets},function(r) table.insert(responses,r) end) + for _=1,3 do + local pending=events; events={} + for _,e in ipairs(pending) do if not e.func() then table.insert(events,e) end end + end + assert(#responses==1, "must respond exactly once") + return used,checked,responses[1] +end +local used,checked,response=run("Tarot",5) +assert(used==0 and checked==1 and response.name=="NOT_ALLOWED") +assert(G.jokers.config.card_count==5 and G.GAME.pack_choices==1 and G.pack_cards~=nil) +used,checked,response=run("Tarot",4) +assert(used==1 and checked==1 and response.ok) +-- Spectral restrictions and space checks must not be bypassed either. +used,checked,response=run("Spectral",4,false) +assert(used==0 and response.name=="NOT_ALLOWED") +used,checked,response=run("Planet",4,true,true) +assert(used==0 and response.name=="NOT_ALLOWED") +-- Non-joker-generating consumables stay legal at full joker capacity. +used,checked,response=run("Tarot",5,true,false,{0}) +assert(used==1 and checked==1 and response.ok) +for _,set in ipairs({"Joker","Default"}) do + used,checked,response=run(set,4) + assert(used==1 and checked==0 and response.ok) +end +print("ok") +''' + result = subprocess.run([lua, "-"], input=script, text=True, cwd=ROOT, capture_output=True, check=True) + assert result.stdout.strip() == "ok" diff --git a/tests/test_training_launch.py b/tests/test_training_launch.py index c91f8779..ed686ea9 100644 --- a/tests/test_training_launch.py +++ b/tests/test_training_launch.py @@ -119,16 +119,22 @@ def test_missing_checkpoint_does_not_read_manifests(launcher): def reward_helpers(): source = Path(__file__).resolve().parents[1] / "batro_modal_rl.py" tree = ast.parse(source.read_text()) - selected = {"_progress_value", "_transition_reward_parts"} + selected = {"_progress_value", "_transition_reward_parts", "_ante_clear_reward", "_episode_reward_parts"} module = ast.Module(body=[ node for node in tree.body if isinstance(node, ast.FunctionDef) and node.name in selected ], type_ignores=[]) - namespace = {"Any": object, "ANTE_CHECKPOINT_BONUS": 8.0} + namespace = {"Any": object} + for node in tree.body: + if isinstance(node, ast.Assign) and len(node.targets) == 1 and isinstance(node.targets[0], ast.Name): + if node.targets[0].id in {"ANTE_CHECKPOINT_BONUS", "FINAL_ANTE", "DECISION_CAP_PENALTY"}: + namespace[node.targets[0].id] = ast.literal_eval(node.value) exec(compile(module, str(source), "exec"), namespace) return SimpleNamespace( progress=namespace["_progress_value"], transition=namespace["_transition_reward_parts"], + ante_reward=namespace["_ante_clear_reward"], + episode=namespace["_episode_reward_parts"], ) @@ -171,3 +177,51 @@ def test_skipped_blind_is_not_rewardable_progress(reward_helpers): assert parts["progress"] == 1.0 assert parts["blind_clear_bonus"] == 3.0 assert parts["ante_checkpoint_bonus"] == 8.0 + + +@pytest.mark.parametrize("ante", range(1, 9)) +def test_ante_reward_scales_by_cleared_ante(reward_helpers, ante): + parts = reward_helpers.transition( + {"ante_num": ante}, {"ante_num": ante + 1}, + valid_action=True, highest_rewarded_ante=ante - 1, + ) + assert parts["ante_checkpoint_bonus"] == 8.0 * ante + assert parts["ante_checkpoints"] == 1 + assert parts["highest_rewarded_ante"] == ante + + +def test_vouchers_cannot_repeat_ante_rewards(reward_helpers): + highest = 0 + rewards, checkpoints = [], 0 + antes = [1, 2, 3, 2, 3, 2, 3, 4] + for before, after in zip(antes, antes[1:]): + parts = reward_helpers.transition( + {"ante_num": before}, {"ante_num": after}, + valid_action=True, highest_rewarded_ante=highest, + ) + highest = parts["highest_rewarded_ante"] + rewards.append(parts["ante_checkpoint_bonus"]) + checkpoints += parts["ante_checkpoints"] + assert rewards == [8, 16, 0, 0, 0, 0, 24] + assert highest == checkpoints == 3 + + +def test_win_top_up_uses_weighted_missing_antes_only(reward_helpers): + # Before the ante-8 boss: seven unique clears. A win may or may not + # advance the selector to ante 9; either path must total 8*(1+...+8). + assert reward_helpers.ante_reward(0, 7) == 224 + assert reward_helpers.ante_reward(7, 8) == 64 + assert reward_helpers.ante_reward(8, 8) == 0 + for ante in (8, 9): + parts = reward_helpers.episode( + {"ante_num": ante, "won": True}, invalid_actions=0, turns=1, capped=False, + ) + assert parts["ante_checkpoint_bonus"] == 288 + + +def test_multiple_new_antes_sum_their_individual_rewards(reward_helpers): + parts = reward_helpers.transition( + {"ante_num": 2}, {"ante_num": 5}, valid_action=True, highest_rewarded_ante=1, + ) + assert parts["ante_checkpoint_bonus"] == 8 * (2 + 3 + 4) + assert parts["ante_checkpoints"] == 3 From 86a7a8a655be7b894d2377452f01df324c2b1be2 Mon Sep 17 00:00:00 2001 From: Joy Liu Date: Mon, 21 Sep 2026 18:29:20 -0400 Subject: [PATCH 4/7] :art: Model keeps collapsing kms --- batro_modal_rl.py | 895 ++- ...oad-layover-final-evidence-2026-09-15.json | 6690 +++++++++++++++++ ...-layover-final-failure-audit-2026-09-15.md | 111 + src/lua/endpoints/sell.lua | 25 +- src/lua/utils/gamestate.lua | 106 + src/lua/utils/openrpc.json | 37 +- src/lua/utils/types.lua | 8 + tests/fixtures/broad_layover_decisions.json | 209 + tests/test_context_management.py | 427 ++ tests/test_hand_recognition.py | 60 + tests/test_pack_selling.py | 158 + tests/test_training_launch.py | 58 +- 12 files changed, 8607 insertions(+), 177 deletions(-) create mode 100644 reports/broad-layover-final-evidence-2026-09-15.json create mode 100644 reports/broad-layover-final-failure-audit-2026-09-15.md create mode 100644 tests/fixtures/broad_layover_decisions.json create mode 100644 tests/test_context_management.py create mode 100644 tests/test_hand_recognition.py create mode 100644 tests/test_pack_selling.py diff --git a/batro_modal_rl.py b/batro_modal_rl.py index a57e2f08..2ca2d127 100644 --- a/batro_modal_rl.py +++ b/batro_modal_rl.py @@ -27,6 +27,7 @@ import tempfile import time from copy import deepcopy +from dataclasses import dataclass, field from io import BytesIO from pathlib import Path, PurePosixPath from typing import Any @@ -35,9 +36,12 @@ from modal_training_gym import ( DatasetConfig, Qwen3_8_27B, - Qwen3_8_27B_Recipe, + Qwen3_8_27B_Recipe as BaseQwen3_8_27B_Recipe, TrainConfig, ) +from pydantic import ConfigDict +from pydantic.dataclasses import dataclass as recipe_dataclass + try: from modal_training_gym import DashboardComponent except ImportError: @@ -46,12 +50,6 @@ DashboardComponent = None from modal_training_gym.common.checkpoint import Checkpoint, _list_checkpoints -from modal_training_gym.common.environments.base import ( - Observation, - SandboxEnvironment, - SandboxEnvironmentPool, - StepResult, -) from modal_training_gym.common.models.base import ToolCall from modal_training_gym.common.run import TrainingRun, set_checkpoint_location @@ -340,6 +338,65 @@ def _balatro_runtime_image() -> modal.Image: TERMINAL_STATES = frozenset({"GAME_OVER"}) +@dataclass +class Observation: + """Balatro tool feedback, independent of unpublished Training Gym APIs.""" + + text: str = "" + is_error: bool = False + metadata: dict[str, Any] = field(default_factory=dict) + + +@dataclass +class StepResult: + observation: Observation + done: bool = False + info: dict[str, Any] = field(default_factory=dict) + + +class SandboxEnvironment: + def __init__(self, sandbox: Any) -> None: + self.sandbox = sandbox + + def close(self) -> None: + try: + self.sandbox.terminate() + except Exception: + pass + + def __enter__(self): + return self + + def __exit__(self, *exc): + self.close() + + +class SandboxEnvironmentPool: + """Keep the sandbox lifecycle local to the Balatro harness.""" + + def __init__(self) -> None: + self._app = None + + def __getstate__(self) -> dict: + return {**self.__dict__, "_app": None} + + def app_handle(self): + if self._app is None: + self._app = modal.App.lookup(self.app_name, create_if_missing=True) + return self._app + + def create_sandbox(self, *, image=None, command=("sleep", "infinity"), **kwargs): + return modal.Sandbox._experimental_create( + *command, + image=image if image is not None else self.build_image(), + app=self.app_handle(), + **kwargs, + ) + + def release(self, env): + env.close() + + class BalatroSandboxEnvironment(SandboxEnvironment): """One isolated Balatro process and JSON-RPC server.""" @@ -443,7 +500,7 @@ def step(self, action: ToolCall) -> StepResult: # Refresh immediately before every action. This closes the gap # between the model's previous observation and the live game, and # also waits out automatic transitions after a blind/round action. - current = self.settle() + self.settle() action_response = self.rpc(action.name, action.arguments) # A successful play can return through ROUND_EVAL, after which # settle() immediately calls cash_out and receives SHOP. Preserve @@ -575,7 +632,7 @@ def _get_env_pool() -> BalatroEnvironmentPool: "use", }, "SHOP": {"buy", "reroll", "next_round", "sell", "use"}, - "SMODS_BOOSTER_OPENED": {"pack"}, + "SMODS_BOOSTER_OPENED": {"pack", "sell"}, "BLIND_SELECT": {"select", "skip"}, } BALATRO_SYSTEM_PROMPT = ( @@ -585,7 +642,9 @@ def _get_env_pool() -> BalatroEnvironmentPool: "every index in a list must be distinct. State uses " "hand_stats=[level,total_played,played_this_round]. After the first " "turn, balatro_state contains only fields changed since the previous " - "turn; absent fields are unchanged and null means removed. Poker-hand " + "turn; absent fields are unchanged and null means removed. Each new " + "conversation starts with a complete snapshot replacing all old state. " + "Card instance IDs identify visible cards; actions still use area indices. Poker-hand " "scoring: the state field hand_values maps each hand to " "[level, base_chips, base_mult]. A played hand's rough score is " "(base_chips + scored card chips + bonuses) × (base_mult + bonuses); " @@ -595,6 +654,13 @@ def _get_env_pool() -> BalatroEnvironmentPool: "40/4, Four of a Kind 60/7, and Straight Flush 100/8; Five of a Kind, " "Flush House, and Flush Five are stronger special hands. The exact " "current values in hand_values are authoritative. " + "hand_groups gives visible matching ranks, suit groups, and example " + "standard straights using CURRENT action indices. These are recognition " + "aids, not score estimates: account for debuffs, enhancements, jokers, " + "and boss rules. Before play, compare the scoring cards with the other " + "available combinations and the chips still needed. Include all matching " + "cards needed for the intended hand. Consider discarding to improve the " + "hand while discards remain. Re-evaluate indices after every draw. " "Choose hands that clear the blind target, not just the highest raw " "rank. At BLIND_SELECT, choose select to enter the blind or skip to take " "the displayed tag (Boss blinds cannot be skipped). After a successful " @@ -622,6 +688,7 @@ def _get_env_pool() -> BalatroEnvironmentPool: ), "SMODS_BOOSTER_OPENED": ( r'\{"method":"pack","params":\{"skip":true\}\}' + rf'|\{{"method":"sell","params":\{{"(joker|consumable)":{_INDEX}\}}\}}' rf'|\{{"method":"pack","params":\{{"card":{_INDEX}' rf'(,"targets":{_INDEX_LIST_5})?\}}\}}' ), @@ -636,8 +703,13 @@ def _action_regex(state_name: str) -> str: ) -def _compact_state(state: dict[str, Any], limit: int = 6_000) -> str: - """Return a phase-specific state small enough for an entire ante-8 game.""" +def _compact_state(state: dict[str, Any], limit: int | None = None) -> str: + """Serialize decision state without deleting facts to meet a character limit. + + The context manager budgets actual tokens and starts a new conversation + when needed. ``limit`` remains accepted for older callers only. + """ + del limit def card_view(card: Any, *, playing_card: bool = False, owned: bool = False) -> Any: if not isinstance(card, dict): @@ -649,6 +721,10 @@ def card_view(card: Any, *, playing_card: bool = False, owned: bool = False) -> else: modifier = None card_state = card.get("state") + if isinstance(card_state, dict) and card_state.get("hidden"): + # No instance/key/effect: otherwise a shuffled face-down card can + # be identified by joining its ID to an earlier visible snapshot. + return {"hidden": True} debuffed = bool( card.get("debuff") or (isinstance(card_state, dict) and card_state.get("debuff")) @@ -656,14 +732,26 @@ def card_view(card: Any, *, playing_card: bool = False, owned: bool = False) -> key = card.get("key") or card.get("label") if playing_card: # Most playing cards become a single token-like key such as S_A. - if not modifier and not debuffed: + counters = card.get("counters") or {} + instance = card.get("id") + if not modifier and not debuffed and not counters and not instance: return key view = {"id": key, "mod": modifier or None} + if instance: + view["instance"] = instance + if counters: + view["counters"] = counters if debuffed: view["debuff"] = True return {name: item for name, item in view.items() if item is not None} view = {"id": key, "effect": card.get("effect") or value.get("effect")} + if card.get("id"): + view["instance"] = card["id"] + if debuffed: + view["debuff"] = True + if card.get("counters"): + view["counters"] = card["counters"] # Already-visible round targets (Idol/Ancient/Mail/Castle), not RNG # seeds. Keep these structured so replay scoring never guesses them. if isinstance(card.get("scoring_state"), dict): @@ -708,7 +796,12 @@ def slots(area: Any, default_limit: int) -> str: "ante": state.get("ante_num"), "round": state.get("round_num"), "money": state.get("money"), + "deck_type": state.get("deck"), + "stake": state.get("stake"), } + for key in ("run_state", "blind_state", "tags", "pack_choices"): + if key in state: + compact[key] = state[key] round_info = state.get("round") if isinstance(state.get("round"), dict) else {} blinds = state.get("blinds") if isinstance(state.get("blinds"), dict) else {} @@ -769,6 +862,11 @@ def slots(area: Any, default_limit: int) -> str: "slots": slots(consumables, 2), "items": area_cards(consumables, owned=True), } + if isinstance(state.get("joker_inventory"), dict): + compact["joker_inventory"] = sorted( + area_cards(state["joker_inventory"], owned=True), + key=lambda item: json.dumps(item, separators=(",", ":"), sort_keys=True), + ) # Vouchers move out of the shop once purchased. Keep their owned state in # the compact trajectory so the agent and debugger can distinguish an @@ -778,7 +876,6 @@ def slots(area: Any, default_limit: int) -> str: compact["owned_vouchers"] = [ {"id": key, "effect": value} for key, value in sorted(used_vouchers.items()) - if value not in (None, "") ] # Expose the known deck composition, not the engine's draw order. The @@ -803,46 +900,55 @@ def slots(area: Any, default_limit: int) -> str: ), ) + # Complete owned inventory is independent of draws/discards. It has no + # location/order/instance mapping, so it cannot identify face-down cards. + if isinstance(state.get("owned_cards"), dict): + inventory: dict[str, int] = {} + for card in area_cards(state["owned_cards"], playing_cards=True): + if isinstance(card, dict): + card = {key: value for key, value in card.items() if key != "instance"} + encoded = json.dumps(card, separators=(",", ":"), ensure_ascii=False) + inventory[encoded] = inventory.get(encoded, 0) + 1 + compact["owned_deck"] = [ + [json.loads(card), count] for card, count in sorted(inventory.items()) + ] + if state_name == "SELECTING_HAND": deck_cards = deck_area or state.get("deck_cards", {}) compact["deck_left"] = ( deck_cards.get("count") if isinstance(deck_cards, dict) else None ) compact["hand"] = area_cards(state.get("hand", {}), playing_cards=True) - hands = state.get("hands") - if not isinstance(hands, dict): - hands = ( - state.get("poker_hand_changes") - if isinstance(state.get("poker_hand_changes"), dict) - else {} - ) - hand_stats = { - name: [ - int(info.get("level") or 1), - int(info.get("played") or 0), - int(info.get("played_this_round") or 0), - ] - for name, info in hands.items() - if isinstance(info, dict) - and ( - int(info.get("level") or 1) != 1 - or int(info.get("played") or 0) > 0 - or int(info.get("played_this_round") or 0) > 0 - ) - } - if hand_stats: - compact["hand_stats"] = hand_stats - hand_values = { - name: [ - int(info.get("level") or 1), - int(info.get("chips") or 0), - int(info.get("mult") or 0), - ] - for name, info in hands.items() - if isinstance(info, dict) + # Surface relationships already visible in the hand. This addresses + # traces that repeatedly selected positional templates while omitting + # a third King or the other Eight. It neither chooses an action nor + # scores a hand, and never uses hidden card identities or draw order. + ranks: dict[str, list[int]] = {} + suits: dict[str, list[int]] = {} + rank_order = "23456789TJQKA" + for index, card in enumerate(compact["hand"]): + if isinstance(card, dict): + if card.get("hidden") or "STONE" in str(card.get("mod", {})).upper(): + continue + key = card.get("id") + else: + key = card + if not isinstance(key, str) or len(key) != 3 or key[1] != "_": + continue + suit, rank = key[0], key[2] + if suit not in "SHDC" or rank not in rank_order: + continue + ranks.setdefault(rank, []).append(index) + suits.setdefault(suit, []).append(index) + straights = [] + for window in [rank_order[start:start + 5] for start in range(8, -1, -1)] + ["A2345"]: + if all(rank in ranks for rank in window): + straights.append([ranks[rank][0] for rank in window]) + compact["hand_groups"] = { + "same_rank": {rank: indices for rank, indices in ranks.items() if len(indices) >= 2}, + "same_suit": {suit: indices for suit, indices in suits.items() if len(indices) >= 4}, + "straight_examples": straights, } - if hand_values: - compact["hand_values"] = hand_values elif state_name == "SHOP": compact["reroll_cost"] = round_info.get("reroll_cost") for key in ("shop", "vouchers", "packs"): @@ -855,6 +961,41 @@ def slots(area: Any, default_limit: int) -> str: if hand: compact["hand"] = hand + hands = state.get("hands") + if not isinstance(hands, dict): + hands = ( + state.get("poker_hand_changes") + if isinstance(state.get("poker_hand_changes"), dict) + else {} + ) + hand_stats = { + name: [ + int(info.get("level") or 1), + int(info.get("played") or 0), + int(info.get("played_this_round") or 0), + ] + for name, info in hands.items() + if isinstance(info, dict) + and ( + int(info.get("level") or 1) != 1 + or int(info.get("played") or 0) > 0 + or int(info.get("played_this_round") or 0) > 0 + ) + } + if hand_stats: + compact["hand_stats"] = hand_stats + hand_values = { + name: [ + int(info.get("level") or 1), + int(info.get("chips") or 0), + int(info.get("mult") or 0), + ] + for name, info in hands.items() + if isinstance(info, dict) + } + if hand_values: + compact["hand_values"] = hand_values + if state.get("won"): compact["won"] = True for key in ("play_commit",): @@ -874,44 +1015,7 @@ def clean(value: Any) -> Any: compact = clean(compact) - text = json.dumps(compact, separators=(",", ":"), ensure_ascii=False) - if len(text) > limit: - # Deck/discard composition is useful planning context, but the fields - # below are required to choose a legal action. Do not fall back to a - # summary that silently removes the hand, shop, pack, or hand values. - # The compact card views are already bounded to the information needed - # for indexed actions, so this keeps the important state available even - # in unusually modifier-heavy runs. - essential = ( - "phase", - "ante", - "round", - "money", - "blind", - "blinds", - "reroll_cost", - "deck_left", - "hand", - "hand_stats", - "hand_values", - "jokers", - "consumables", - "owned_vouchers", - "shop", - "vouchers", - "packs", - "pack", - ) - reduced = {key: compact[key] for key in essential if key in compact} - reduced["deck_omitted"] = "deck" in compact - reduced["discard_omitted"] = "discard" in compact - reduced["truncated"] = True - text = json.dumps( - reduced, - separators=(",", ":"), - ensure_ascii=False, - ) - return text + return json.dumps(compact, separators=(",", ":"), ensure_ascii=False) def _area_items(compact: dict[str, Any], name: str) -> list[Any]: @@ -932,6 +1036,13 @@ def _slot_usage(compact: dict[str, Any], name: str) -> tuple[int, int]: return 0, 0 +def _sellable_indices(compact: dict[str, Any], name: str) -> list[int]: + return [ + index for index, item in enumerate(_area_items(compact, name)) + if isinstance(item, dict) and not (item.get("mod") or {}).get("eternal") + ] + + def _purchasable_indices( compact: dict[str, Any], kind: str, *, enforce_slots: bool = False ) -> list[int]: @@ -1137,6 +1248,13 @@ def _action_help(state: dict[str, Any]) -> str: ) ] actions = ["pack skip=true"] + for kind, name in (("joker", "jokers"), ("consumable", "consumables")): + sellable = _sellable_indices(compact, name) + if sellable: + actions.append( + f"sell {kind}=one of {sellable} " + "(keeps pack open; can free room before choosing a card)" + ) hand = compact.get("hand") if isinstance(compact.get("hand"), list) else [] actions.extend( help_text @@ -1156,7 +1274,7 @@ def _action_help(state: dict[str, Any]) -> str: return "none" -def _turn_prompt(state: dict[str, Any]) -> str: +def _turn_prompt(state: dict[str, Any], last_result: dict[str, Any] | None = None) -> str: return ( "You are playing Balatro. Choose exactly one legal API action. Card and " "item indices are 0-based. Optimize for winning ante 8. Return only " @@ -1175,6 +1293,13 @@ def _turn_prompt(state: dict[str, Any]) -> str: "The deck field is the sorted composition of cards remaining in the " "draw pile (not draw order); discard is the known discarded pile. Use " "these to plan hand selection and future deck/joker synergies.\n" + "owned_deck lists [card,count] for the whole owned deck, without draw " + "order. instance IDs are not action indices. hidden means unknown; " + "do not infer a hidden card's identity from its position.\n" + "joker_inventory, when present, is the known unordered set of owned " + "jokers; it does not identify their face-down slots.\n" + + ("Previous result (old indices): " + json.dumps(last_result, separators=(",", ":")) + "\n" if last_result else "") + + "This is a complete current snapshot; replace all prior state.\n" f"Legal actions now: {_action_help(state)}\n" f"Gamestate:\n{_compact_state(state)}" ) @@ -1241,17 +1366,15 @@ def valid_targets(key: str, item: Any) -> bool: not (method == "play" and "must play 5 cards" in effect) or len(cards) == 5 ) if method == "sell": + if state_name not in {"SHOP", "SELECTING_HAND", "SMODS_BOOSTER_OPENED"}: + return False if set(params) not in ({"joker"}, {"consumable"}): return False - if "joker" in params: - return isinstance(params["joker"], int) and 0 <= params["joker"] < len( - jokers - ) - if "consumable" in params: - return isinstance(params["consumable"], int) and 0 <= params[ - "consumable" - ] < len(consumables) - return False + kind = "joker" if "joker" in params else "consumable" + index = params[kind] + return type(index) is int and index in _sellable_indices( + compact, "jokers" if kind == "joker" else "consumables" + ) if method == "use": if set(params) - {"consumable", "cards"}: return False @@ -1651,18 +1774,25 @@ async def _generate_action( sampling_params: dict[str, Any], prompt_ids: list[int], state_name: str, -) -> tuple[list[int], str | None, str]: +) -> tuple[list[int], str | None, str, list[float]]: from slime.utils.http_utils import post params = deepcopy(sampling_params) - context_limit = int(getattr(args, "balatro_context_len", 32768)) + context_limit, _ = _balatro_context_limits(args) params["max_new_tokens"] = min( - int(params.get("max_new_tokens", 96)), 96, context_limit - len(prompt_ids) + int(params.get("max_new_tokens", 96)), 96, context_limit - 128 - len(prompt_ids) ) if params["max_new_tokens"] <= 0: - return [], None, "context" - # SGLang structured-output constraints belong inside sampling_params. - params["regex"] = _action_regex(state_name) + return [], None, "context", [] + # The trainer computes unmasked token probabilities. SGLang applies a + # grammar mask BEFORE returning logprobs, so constrained samples are from + # a different policy even at temperature=1/top_p=1. Keep generation aligned + # with training; the prompt and action validator still enforce the API. + for constraint in ("regex", "json_schema", "ebnf"): + if params.get(constraint) is not None: + raise ValueError( + f"Balatro training cannot use {constraint}: the trainer does not replay grammar masks" + ) output = await post( f"http://{args.sglang_router_ip}:{args.sglang_router_port}/generate", @@ -1674,12 +1804,217 @@ async def _generate_action( ) finish = output.get("meta_info", {}).get("finish_reason", {}).get("type", "") if finish == "abort": - return [], None, finish + return [], None, finish, [] response_ids = [ item[1] for item in output.get("meta_info", {}).get("output_token_logprobs", []) ] - return response_ids, output.get("text", ""), finish + log_probs = [ + float(item[0]) for item in output.get("meta_info", {}).get("output_token_logprobs", []) + ] + if len(response_ids) > params["max_new_tokens"]: + raise RuntimeError("Serving returned more tokens than requested") + return response_ids, output.get("text", ""), finish, log_probs + + +def _balatro_context_limits(args: Any) -> tuple[int, int]: + """Account for serving capacity and the pinned trainer's CP/TP padding.""" + cp = max(1, int(getattr(args, "context_parallel_size", 1))) + tp = max(1, int(getattr(args, "tensor_model_parallel_size", 1))) + padding = cp * tp * 128 + limits = [int(getattr(args, "balatro_context_len", 49152))] + for name in ("sglang_context_length", "max_position_embeddings"): + if value := getattr(args, name, None): + limits.append(int(value)) + if value := getattr(args, "max_tokens_per_gpu", None): + limits.append(int(value) * cp) + hard = min(limits) // padding * padding + requested = int(getattr(args, "balatro_context_len", 49152)) // padding * padding + if hard < requested: + raise ValueError( + f"Balatro requested {requested} context tokens but the trainer/serving " + f"limits permit only {hard}. Set max_position_embeddings and " + "sglang_context_length explicitly; do not silently clamp the game history." + ) + target = min(int(getattr(args, "balatro_segment_tokens", 8192)), hard) + if min(target, hard) <= 224: + raise ValueError("Balatro context budgets must leave room for a snapshot and action") + return hard, target + + +def _validate_balatro_context_config(recipe: Any) -> tuple[int, int]: + """Resolve explicit recipe flags before any launch side effects.""" + from types import SimpleNamespace + + extra = getattr(recipe, "extra_config", None) or {} + values = {} + for name in ( + "balatro_context_len", "balatro_segment_tokens", "max_position_embeddings", + "sglang_context_length", "max_tokens_per_gpu", "context_parallel_size", + "tensor_model_parallel_size", + ): + value = extra.get(name, getattr(recipe, name, None)) + if value is not None: + values[name] = value + for name in ("max_position_embeddings", "sglang_context_length"): + if not values.get(name): + raise ValueError(f"Balatro requires explicit {name}; inherited defaults can clamp context to 4096") + backend = extra.get("attention_backend", getattr(recipe, "attention_backend", None)) + if int(values.get("context_parallel_size", 1)) > 1 and backend == "unfused": + raise ValueError("Unfused attention does not support context parallelism; use flash for Balatro CP>1") + return _balatro_context_limits(SimpleNamespace(**values)) + + +def _validate_balatro_loss_config(args: Any) -> None: + """Check loss weighting locally, before launching GPUs, and on workers.""" + extra = getattr(args, "extra_config", None) or {} + per_token = extra.get( + "calculate_per_token_loss", getattr(args, "calculate_per_token_loss", True) + ) + if per_token is not False: + raise ValueError("Segmented Balatro requires calculate_per_token_loss=False (per-game mean)") + mode = extra.get("balatro_credit_assignment", getattr(args, "balatro_credit_assignment", "episode")) + if mode not in {"episode", "reward_to_go"}: + raise ValueError(f"Unknown Balatro credit assignment: {mode}") + if mode == "reward_to_go": + path = extra.get("custom_advantage_function_path", getattr(args, "custom_advantage_function_path", None)) + if path != "balatro_credit.compute_advantages": + raise ValueError("reward_to_go requires the Balatro token-advantage hook") + if extra.get("kl_coef", getattr(args, "kl_coef", 0)) != 0: + raise ValueError("reward_to_go requires kl_coef=0; use the separate KL loss") + + +def _validate_balatro_trainer(args: Any, sample_type: Any) -> None: + """Fail before acquiring a game if a trainer cannot weight sibling samples.""" + import inspect + + _validate_balatro_loss_config(args) + if "rollout_id" not in getattr(sample_type, "__dataclass_fields__", {}): + raise RuntimeError("This Slime Sample lacks shared rollout_id support; use the pinned Training Gym image") + root = Path(inspect.getfile(sample_type)).resolve().parents[1] + if getattr(args, "balatro_credit_assignment", "episode") == "reward_to_go": + if "train_metadata" not in getattr(sample_type, "__dataclass_fields__", {}): + raise RuntimeError("This Slime Sample lacks train_metadata for action credit") + if "BALATRO_TRAIN_METADATA" not in (root / "ray/rollout.py").read_text(): + raise RuntimeError("Trainer is missing the Balatro reward-to-go metadata transport patch") + for relative, required in ( + ("ray/rollout.py", "rollout_mask_sums"), + ("backends/megatron_utils/loss.py", 'batch["rollout_mask_sums"]'), + ("backends/megatron_utils/cp_utils.py", "sample_denoms"), + ): + if required not in (root / relative).read_text(): + raise RuntimeError(f"Slime lacks per-game segment reduction in {relative}") + + +class _StateBudgetExceeded(RuntimeError): + pass + + +class _SnapshotUnavailable(RuntimeError): + pass + + +class _BalatroContext: + """Bounded inference prefixes and their exact, separately trained sequences.""" + + def __init__(self, tokenizer: Any, hard_limit: int, target: int): + self.tokenizer = tokenizer + self.hard_limit = hard_limit + self.target = target + self.segments: list[dict[str, Any]] = [] + self.current: dict[str, Any] | None = None + self.needs_reset = True + self.peak_tokens = 0 + self.snapshot_tokens = 0 + + def begin(self, prompt: str, user_message: str, turn: int) -> None: + ids = self.tokenizer(prompt, add_special_tokens=False)["input_ids"] + if len(ids) + 96 + 128 > self.hard_limit: + raise _StateBudgetExceeded( + f"Current snapshot needs {len(ids)} tokens; input allowance is {self.hard_limit - 224}" + ) + self.finish() + self.current = { + "prompt": prompt, "prompt_ids": ids, "response_ids": [], + "response": "", "loss_mask": [], "log_probs": [], "actions": [], + "turn_start": turn, + "messages": [ + {"role": "system", "content": BALATRO_SYSTEM_PROMPT}, + {"role": "user", "content": user_message}, + ], + } + self.snapshot_tokens += len(ids) + self.needs_reset = False + self.peak_tokens = max(self.peak_tokens, len(ids)) + + def input_ids(self) -> list[int]: + segment = self.current + if segment is None or self.needs_reset: + raise RuntimeError("A fresh snapshot is required before generation") + ids = segment["prompt_ids"] + segment["response_ids"] + if len(ids) + 224 > self.hard_limit: + raise RuntimeError("Context manager produced an oversized request") + return ids + + def add_action(self, ids: list[int], text: str, log_probs: list[float], *, turn: int, archive_start: int) -> None: + segment = self.current + if not ids or len(ids) > 96 or len(ids) != len(log_probs): + raise RuntimeError("Missing or misaligned generated action tokens/log probabilities") + if segment is None or len(self.input_ids()) + len(ids) > self.hard_limit: + raise RuntimeError("Invalid action context") + start = len(segment["response_ids"]) + segment["actions"].append({ + "turn": turn, "token_start": start, "token_end": start + len(ids), + "episode_token_start": archive_start, "episode_token_end": archive_start + len(ids), + }) + segment["response_ids"].extend(ids) + segment["loss_mask"].extend([1] * len(ids)) + segment["log_probs"].extend(log_probs) + segment["response"] += text + segment["messages"].append({"role": "assistant", "content": text}) + self.peak_tokens = max(self.peak_tokens, len(segment["prompt_ids"]) + len(segment["response_ids"])) + + def add_feedback(self, feedback: str, ids: list[int]) -> None: + segment = self.current + if segment is None: + raise RuntimeError("Feedback without an action") + size = len(segment["prompt_ids"]) + len(segment["response_ids"]) + len(ids) + segment["messages"].append({"role": "tool", "content": feedback.strip()}) + if size + 224 > self.target or len(segment["messages"]) >= 126: + # Keep this result in the episode archive. The next request gets + # its resulting state as a full snapshot, not a detached delta. + self.needs_reset = True + return + segment["response_ids"].extend(ids) + segment["loss_mask"].extend([0] * len(ids)) + segment["log_probs"].extend([0.0] * len(ids)) + segment["response"] += feedback + self.peak_tokens = max(self.peak_tokens, size) + + def finish(self) -> None: + if self.current is not None and self.current["actions"]: + self.segments.append(self.current) + self.current = None + + +def _segment_reward_events(events: list[dict[str, Any]], segments: list[dict[str, Any]]) -> list[list[dict[str, Any]]]: + """Attach a checkpoint once, at its last action, with explicit span mappings.""" + result: list[list[dict[str, Any]]] = [[] for _ in segments] + for event in events: + start, end = event.get("token_start", 0), event["token_end"] + spans = [] + for index, segment in enumerate(segments): + actions = [a for a in segment["actions"] if a["episode_token_start"] < end and a["episode_token_end"] > start] + if actions: + spans.append({"segment_id": index, "token_start": actions[0]["token_start"], "token_end": actions[-1]["token_end"]}) + if spans: + final = spans[-1] + result[final["segment_id"]].append({ + **event, "episode_token_start": start, "episode_token_end": end, + "token_start": final["token_start"], "token_end": final["token_end"], + "segment_spans": spans, + }) + return result def _action_payload(action: ToolCall) -> dict[str, Any]: @@ -1693,10 +2028,8 @@ def _action_payload(action: ToolCall) -> dict[str, Any]: def _state_delta(previous: Any, current: Any) -> Any: """Recursive diff of two compact states. - The transcript is one ever-growing sequence, so re-sending the whole state - every turn means turn N carries N copies of largely identical JSON - the - dominant cost of a long episode. Only what changed is sent instead; the - model reconstructs the rest from earlier turns. + Within one bounded conversation, reconstruct state from its initial full + snapshot and these deltas. Arrays replace atomically, null deletes a key. """ if not isinstance(previous, dict) or not isinstance(current, dict): return current if current != previous else _UNCHANGED @@ -1721,7 +2054,7 @@ def _state_delta(previous: Any, current: Any) -> Any: def _delta_payload(previous: dict[str, Any] | None, current: dict[str, Any]) -> Any: - """Delta against the previous turn, or the full state when that is smaller.""" + """Always retain deletion markers; an unmarked full state is not a delta.""" if previous is None: return current @@ -1731,12 +2064,7 @@ def _delta_payload(previous: dict[str, Any] | None, current: dict[str, Any]) -> if anchor in current: delta.setdefault(anchor, current[anchor]) - # A near-total change (a new round, say) can serialize larger than the - # state itself; send whichever is smaller. - def encode(obj: Any) -> str: - return json.dumps(obj, separators=(",", ":"), ensure_ascii=False) - - return delta if len(encode(delta)) < len(encode(current)) else current + return delta def _selected_blind(compact: dict[str, Any] | None) -> tuple[str, dict[str, Any]] | None: @@ -1840,18 +2168,21 @@ async def generate_balatro_episode( sampling_params: dict[str, Any], evaluation: bool = False, ) -> Any: - """Play one full game and return it as exactly one multi-turn sample.""" + """Play one continuous game; return bounded samples with one shared reward.""" from slime.utils.types import Sample - del evaluation + if not evaluation: + _validate_balatro_trainer(args, Sample) source_metadata = dict(getattr(sample, "metadata", None) or {}) seed = str(source_metadata.get("balatro_seed") or sample.prompt) # This budget covers only state-changing game decisions. max_decisions = int(getattr(args, "balatro_max_decisions", 250)) - context_limit = int(getattr(args, "balatro_context_len", 32768)) + context_limit, segment_target = _balatro_context_limits(args) capture_screenshot = bool(getattr(args, "balatro_capture_screenshot", True)) rollout_id = time.time_ns() & ((1 << 63) - 1) env: BalatroSandboxEnvironment | None = None + startup_error = "" + state: dict[str, Any] = {} episode_started = time.monotonic() episode_trace: list[dict[str, Any]] = [] @@ -1873,8 +2204,16 @@ def span(name: str, started: float, **attributes: Any) -> None: span( "balatro.sandbox.acquire", acquire_started, attempt=attempt + 1, ok=True ) + # Health can pass just before the game process exits. Starting the + # seeded game is part of startup, and is safe to retry on a fresh + # sandbox because no policy action has been requested yet. + game_start = time.monotonic() + state = await asyncio.to_thread(env.start, seed) + span("balatro.game.start", game_start, attempt=attempt + 1, + state=state.get("state", "")) break except Exception as exc: + startup_error = str(exc)[-1200:] span( "balatro.sandbox.acquire", acquire_started, @@ -1885,13 +2224,25 @@ def span(name: str, started: float, **attributes: Any) -> None: "BALATRO_SANDBOX_ERROR", {"seed": seed, "attempt": attempt + 1, "error": str(exc)[-1200:]}, ) + if env is not None: + try: + await asyncio.to_thread(env.close) + except Exception as close_exc: + _log_balatro_event("BALATRO_SANDBOX_CLOSE_ERROR", { + "seed": seed, "error": str(close_exc)[-1200:], + }) + env = None if attempt < 2: await asyncio.sleep(2 * (attempt + 1)) if env is None: + if evaluation: + raise RuntimeError(f"Balatro evaluation startup failed for {seed} after 3 attempts: {startup_error}") sample.status = Sample.Status.ABORTED + sample.metadata = {**source_metadata, "exit_status": "sandbox_startup_error", "error": startup_error} return sample tokenizer = _tokenizer(args.hf_checkpoint) + context = _BalatroContext(tokenizer, context_limit, segment_target) initial_prompt = "" initial_prompt_ids: list[int] = [] response_token_ids: list[int] = [] @@ -1909,23 +2260,26 @@ def span(name: str, started: float, **attributes: Any) -> None: repaired_actions = 0 api_errors = 0 turns_taken = 0 - state: dict[str, Any] = {} # Previous turn's compact state, so feedback can be sent as a delta. previous_compact: dict[str, Any] | None = None + last_result: dict[str, Any] | None = None def append_tool_feedback(feedback: str) -> bool: - """Append an environment response, including terminal error frames.""" - nonlocal trajectory_text, response_token_ids, loss_mask, capped, terminal_reason + """Archive every transition; only retain fitting feedback in active context.""" + nonlocal trajectory_text, last_result trajectory_messages.append({"role": "tool", "content": feedback.strip()}) trajectory_text += feedback feedback_ids = tokenizer(feedback, add_special_tokens=False)["input_ids"] - room = context_limit - 128 - len(initial_prompt_ids) - len(response_token_ids) - if len(feedback_ids) > max(0, room): - capped = True - terminal_reason = "context_cap" - return False response_token_ids.extend(feedback_ids) loss_mask.extend([0] * len(feedback_ids)) + context.add_feedback(feedback, feedback_ids) + # The last executed action and any recovery error remain available + # even when the feedback itself is replaced by a fresh snapshot. + payload = json.loads(feedback.split("", 1)[1].split("", 1)[0]) + last_result = {"turn": turns_taken, "executed": _action_payload(executed)} + for key in ("error", "fallback", "action_result"): + if key in payload: + last_result[key] = payload[key] return True capped = False @@ -2002,10 +2356,10 @@ def _append_checkpoint_event( previous_reward_state: dict[str, Any] | None = None try: - game_start = time.monotonic() - state = await asyncio.to_thread(env.start, seed) previous_reward_state = state - span("balatro.game.start", game_start, state=state.get("state", "")) + + if state.get("snapshot_version") != 1: + raise _SnapshotUnavailable("Game assets lack snapshot_version=1; prepare updated assets before training") first_turn = _turn_prompt(state) trajectory_messages.append({"role": "user", "content": first_turn}) @@ -2013,15 +2367,18 @@ def _append_checkpoint_event( initial_prompt_ids = tokenizer(initial_prompt, add_special_tokens=False)[ "input_ids" ] + context.begin(initial_prompt, first_turn, 1) + previous_compact = json.loads(_compact_state(state)) for turn in range(max_decisions): if env._terminal(state): terminal_reason = "won" if state.get("won") else "game_over" break - if len(initial_prompt_ids) + len(response_token_ids) >= context_limit - 128: - capped = True - terminal_reason = "context_cap" - break + if context.needs_reset: + first_turn = _turn_prompt(state, last_result) + context.begin(_chat_prompt(tokenizer, first_turn), first_turn, turn + 1) + previous_compact = json.loads(_compact_state(state)) + span("balatro.context.reset", time.monotonic(), turn=turn + 1, segment_id=len(context.segments)) turns_taken = turn + 1 state_name = str(state.get("state", "")) @@ -2031,10 +2388,10 @@ def _append_checkpoint_event( # action tokens that caused it. action_token_start = len(response_token_ids) generate_started = time.monotonic() - generated_ids, response, finish = await _generate_action( + generated_ids, response, finish, generated_log_probs = await _generate_action( args, sampling_params, - initial_prompt_ids + response_token_ids, + context.input_ids(), state_name, ) span( @@ -2051,6 +2408,15 @@ def _append_checkpoint_event( terminal_reason = "model_abort" if aborted else "context_cap" break + context.add_action( + generated_ids, response, generated_log_probs, + turn=turn + 1, archive_start=action_token_start, + ) + # Store the reward already earned BEFORE this action. Differencing + # against the final total yields a causal return-to-go, including + # invalid-action penalties and terminal bonuses exactly once. + context.current["actions"][-1]["reward_before"] = sum(partial_reward_parts.values()) + response_token_ids.extend(generated_ids) action_token_end = len(response_token_ids) loss_mask.extend([1] * len(generated_ids)) @@ -2272,6 +2638,13 @@ def _append_checkpoint_event( else: capped = True terminal_reason = "decision_cap" + except _SnapshotUnavailable as exc: + episode_error = str(exc) + terminal_reason = "state_schema_mismatch" + except _StateBudgetExceeded as exc: + episode_error = str(exc) + terminal_reason = "state_budget_exceeded" + capped = True except Exception as exc: episode_error = str(exc)[-1200:] terminal_reason = "episode_error" @@ -2295,8 +2668,10 @@ def _append_checkpoint_event( ) await asyncio.to_thread(env.close) - if not initial_prompt_ids or not any(loss_mask): + context.finish() + if not context.segments: sample.status = Sample.Status.ABORTED + sample.metadata = {**source_metadata, "exit_status": terminal_reason, "error": episode_error} return sample # A win can occur on the ante-8 boss before the game increments @@ -2345,7 +2720,7 @@ def _append_checkpoint_event( won = bool(state.get("won")) final_ante = int(state.get("ante_num") or 0) final_round = int(state.get("round_num") or 0) - context_tokens = len(initial_prompt_ids) + len(response_token_ids) + context_tokens = context.peak_tokens context_utilization = context_tokens / max(1, context_limit) tokens_per_turn = len(response_token_ids) / max(1, turns_taken) duration = time.monotonic() - episode_started @@ -2381,6 +2756,11 @@ def _append_checkpoint_event( "api_errors": api_errors, "context_tokens": context_tokens, "context_limit": context_limit, + "context_protocol": 1, + "segment_target": segment_target, + "segment_count": len(context.segments), + "context_rebases": len(context.segments) - 1, + "episode_archive_tokens": len(initial_prompt_ids) + len(response_token_ids), "context_utilization": context_utilization, "tokens_per_turn": tokens_per_turn, "duration_s": round(duration, 3), @@ -2407,6 +2787,12 @@ def _append_checkpoint_event( "balatro/repaired_actions": repaired_actions, "balatro/api_errors": api_errors, "balatro/context_tokens": context_tokens, + "balatro/segment_count": len(context.segments), + "balatro/context_rebases": len(context.segments) - 1, + "balatro/episode_archive_tokens": len(initial_prompt_ids) + len(response_token_ids), + "balatro/action_tokens": sum(loss_mask), + "balatro/feedback_tokens": len(loss_mask) - sum(loss_mask), + "balatro/state_budget_exceeded": int(terminal_reason == "state_budget_exceeded"), "balatro/context_utilization": context_utilization, "balatro/tokens_per_turn": tokens_per_turn, "balatro/won": int(won), @@ -2417,37 +2803,59 @@ def _append_checkpoint_event( metadata["metrics"] = episode_metrics metadata.update(episode_metrics) metadata["exit_status"] = terminal_reason - metadata["trajectory_messages"] = trajectory_messages if screenshot: metadata["image"] = screenshot # Keep the source compatible with framework Sample implementations that do # not allow arbitrary attributes. Training Gym promotes these reserved # metadata keys into its first-class rollout fields during extraction. metadata["reward_granularity"] = "checkpoint" - metadata["reward_events"] = partial_reward_trace - # Training Gym exposes checkpoint-window rewards as first-class Sample - # fields. - # Slime's sample type is version-dependent, so retain the metadata fallback - # above while promoting the fields whenever the runtime object supports it. - try: - sample.reward_granularity = "checkpoint" - sample.reward_events = partial_reward_trace - except (AttributeError, TypeError, ValueError): - pass - - sample.prompt = initial_prompt - sample.tokens = initial_prompt_ids + response_token_ids - sample.response_length = len(response_token_ids) - sample.response = trajectory_text - sample.loss_mask = loss_mask - sample.status = Sample.Status.ABORTED if aborted else Sample.Status.COMPLETED - sample.reward = reward - sample.metadata = metadata - sample.rollout_id = rollout_id - existing_trace = getattr(sample, "trace", None) - sample.trace = ( - list(existing_trace) if isinstance(existing_trace, list) else [] - ) + episode_trace + mapped_events = _segment_reward_events(partial_reward_trace, context.segments) + metadata["balatro"].pop("partial_reward_trace", None) + samples = [] + for index, segment in enumerate(context.segments): + part = deepcopy(sample) + part.prompt = segment["prompt"] + part.tokens = segment["prompt_ids"] + segment["response_ids"] + part.response_length = len(segment["response_ids"]) + part.response = segment["response"] + part.loss_mask = segment["loss_mask"] + part.rollout_log_probs = segment["log_probs"] + part.status = Sample.Status.ABORTED if aborted else Sample.Status.COMPLETED + part.reward = reward + part.rollout_id = rollout_id + part.metadata = { + **metadata, "segment_id": index, "segment_count": len(context.segments), + "context_protocol": 1, "segment_turn_start": segment["turn_start"], + "segment_turn_end": segment["actions"][-1]["turn"], + "segment_context_tokens": len(part.tokens), + "trajectory_messages": segment["messages"], "reward_events": mapped_events[index], + "credit_assignment": getattr(args, "balatro_credit_assignment", "episode"), + "action_credit": [ + {"turn": action["turn"], "token_start": action["token_start"], + "token_end": action["token_end"], "return_to_go": reward - action["reward_before"]} + for action in segment["actions"] + ], + } + # Keep one full episode archive on the original training sample. Each + # dashboard segment also has its own complete snapshot + local moves. + if index == 0: + part.metadata["balatro_episode_archive"] = { + "prompt": initial_prompt, "response": trajectory_text, + "messages": trajectory_messages, "reward_events": partial_reward_trace, + } + part.trace = list(getattr(sample, "trace", None) or []) + episode_trace + else: + part.trace = [] + # Episode-level metrics are emitted once, not once per segment. + part.metadata.pop("metrics", None) + for key in episode_metrics: + part.metadata.pop(key, None) + try: + part.reward_granularity = "checkpoint" + part.reward_events = mapped_events[index] + except (AttributeError, TypeError, ValueError): + pass + samples.append(part) _log_balatro_event( "BALATRO_EPISODE", @@ -2465,7 +2873,7 @@ def _append_checkpoint_event( "duration_s": round(duration, 3), }, ) - return sample + return samples def _sample_reward(sample: Any) -> float: @@ -2480,13 +2888,46 @@ async def passthrough_reward(args: Any, samples: Any, **kwargs: Any) -> Any: return _sample_reward(samples) +async def generate_balatro_comparison(args: Any, sample: Any, sampling_params: dict[str, Any], evaluation: bool = False): + """Train on exact segments, but report one complete game per held-out eval.""" + result = await generate_balatro_episode(args, sample, sampling_params, evaluation=evaluation) + if not evaluation: + return result + parts = result if isinstance(result, list) else [result] + if not parts or any( + getattr(part, "reward", None) is None + or not math.isfinite(float(part.reward)) + or getattr(getattr(part, "status", None), "value", None) == "aborted" + for part in parts + ): + seed = (getattr(sample, "metadata", None) or {}).get("balatro_seed", sample.prompt) + raise RuntimeError(f"Balatro evaluation returned an incomplete/unscored episode for {seed}") + if not isinstance(result, list): + return result + part = result[0] + archive = part.metadata["balatro_episode_archive"] + part.prompt, part.response = archive["prompt"], archive["response"] + tokenizer = _tokenizer(args.hf_checkpoint) + prompt_ids = tokenizer(part.prompt, add_special_tokens=False)["input_ids"] + response_ids = tokenizer(part.response, add_special_tokens=False)["input_ids"] + # Evaluation transcripts are never submitted to the optimizer. Retokenizing + # the archive is safe here and avoids weighting eval games by segment count. + part.tokens = prompt_ids + response_ids + part.response_length = len(response_ids) + part.loss_mask = [0] * len(response_ids) + part.rollout_log_probs = None + part.metadata["trajectory_messages"] = archive["messages"] + part.metadata["reward_events"] = archive["reward_events"] + part.metadata["evaluation_full_episode"] = True + return part + + def normalize_episode_rewards( args: Any, samples: list[Any] ) -> tuple[list[float], list[float]]: - """Normalize complete-game rewards within each same-seed GRPO group.""" + """Normalize episode metrics and optionally attach actual token advantages.""" from collections import defaultdict - del args raw = [_sample_reward(sample) for sample in samples] seed_groups: dict[str, list[int]] = defaultdict(list) for index, sample in enumerate(samples): @@ -2512,14 +2953,88 @@ def normalize_episode_rewards( for game_id, game_indices in games.items(): for index in game_indices: advantages[index] = game_advantage[game_id] + if getattr(args, "balatro_credit_assignment", "episode") == "reward_to_go": + _assign_action_advantages(samples, seed_groups) return raw, advantages +def _assign_action_advantages(samples: list[Any], seed_groups: dict[str, list[int]]) -> None: + """Same-seed, leave-one-game-out baselines at each decision number. + + Ended peers have zero remaining return. Scale once per seed using complete + game returns (floor 1 reward unit), never separately per context segment. + This preserves the existing reward objective; it does not invent a poker + score oracle or treat overlapping dashboard checkpoint events as additive. + """ + for indices in seed_groups.values(): + games: dict[int, dict[int, float]] = {} + totals: dict[int, float] = {} + for index in indices: + sample = samples[index] + game = int(sample.rollout_id) + actions = (sample.metadata or {}).get("action_credit") + if not actions: + raise ValueError("reward_to_go requires recorded action_credit for every sample") + if game in totals and not math.isclose(totals[game], _sample_reward(sample)): + raise ValueError("Segments of one game have inconsistent total rewards") + totals[game] = _sample_reward(sample) + if not math.isfinite(totals[game]): + raise ValueError("Nonfinite game reward") + turns = games.setdefault(game, {}) + for action in actions: + turn, value = int(action["turn"]), float(action["return_to_go"]) + if turn in turns or turn < 1 or not math.isfinite(value): + raise ValueError("Invalid or duplicate action return-to-go") + turns[turn] = value + if len(games) < 2: + raise ValueError("reward_to_go needs at least two complete games per seed") + for turns in games.values(): + if sorted(turns) != list(range(1, len(turns) + 1)): + raise ValueError("reward_to_go requires complete, contiguous game decisions") + mean = sum(totals.values()) / len(totals) + scale = max(1.0, math.sqrt(sum((x - mean) ** 2 for x in totals.values()) / len(totals))) + for index in indices: + sample = samples[index] + game = int(sample.rollout_id) + spans = [] + for action in sample.metadata["action_credit"]: + turn = int(action["turn"]) + baseline = sum(turns.get(turn, 0.0) for peer, turns in games.items() if peer != game) / (len(games) - 1) + spans.append({ + "start": action["token_start"], "end": action["token_end"], + "advantage": (float(action["return_to_go"]) - baseline) / scale, + }) + sample.train_metadata = { + **(getattr(sample, "train_metadata", None) or {}), + "balatro_action_advantages": spans, + } + + # --------------------------------------------------------------------------- # Training Gym dataset and active run configuration # --------------------------------------------------------------------------- +@recipe_dataclass(config=ConfigDict(extra="forbid", arbitrary_types_allowed=True)) +class Qwen3_8_27B_Recipe(BaseQwen3_8_27B_Recipe): + """Explicit Balatro topology on the current upstream Qwen preset. + + Retain the recipe name because Training Gym derives the shared checkpoint + volume name from it. Main's preset now leaves these pipeline fields to the + consumer and uses a different GPU/ref-load default. + """ + + gpu_type: str = "H100" + pipeline_model_parallel_size: int = 2 + conversion_tensor_model_parallel_size: int = 4 + conversion_pipeline_model_parallel_size: int = 2 + decoder_last_pipeline_num_layers: int | None = 30 + ref_load: str = "/checkpoints/Qwen3.8-27B_torch_dist_tp4pp2" + # Main's CP=1 preset uses unfused attention, which cannot run with our CP=4. + # Preserve the FlashAttention backend validated by the prior Balatro runs. + attention_backend: str = "flash" + + class BalatroSeedsDataset(DatasetConfig): num_seeds = 256 @@ -2560,9 +3075,12 @@ def build_train_config( num_rollout: int | None = None, load: str | None = None, no_load_optim: bool = False, + credit_assignment: str = "episode", ) -> TrainConfig: if num_rollout is not None and num_rollout < 1: raise ValueError(f"num_rollout must be >= 1, got {num_rollout}") + if credit_assignment not in {"episode", "reward_to_go"}: + raise ValueError(f"Unknown credit assignment: {credit_assignment}") return TrainConfig( model=Qwen3_8_27B(), dataset=BalatroSeedsDataset(), @@ -2582,6 +3100,8 @@ def build_train_config( sequence_parallel=True, pipeline_model_parallel_size=2, context_parallel_size=4, + # Slime's per-game denominator spans all samples sharing rollout_id. + calculate_per_token_loss=False, rollout_max_response_len=96, rollout_temperature=1.0, max_tokens_per_gpu=12288, @@ -2611,14 +3131,38 @@ def build_train_config( "PYTHONPATH": "/root/Megatron-LM/", "CUDA_DEVICE_MAX_CONNECTIONS": "1", "NCCL_NVLS_ENABLE": "1", + # broad-layover crashed in NCCL's RAS peer-update thread during + # save. Disable that diagnostic subsystem for this recipe. + "NCCL_RAS_ENABLE": "0", "TRAINING_GYM_TRAJECTORY_SAMPLE_LIMIT": "64", "TRAINING_GYM_IMAGE_SAMPLE_LIMIT": "0", }, extra_config={ "balatro_max_decisions": 250, "balatro_context_len": 49152, + "balatro_segment_tokens": 8192, "balatro_capture_screenshot": False, + "max_position_embeddings": 49152, + "sglang_context_length": 49152, + "balatro_credit_assignment": credit_assignment, + **({"custom_advantage_function_path": "balatro_credit.compute_advantages"} + if credit_assignment == "reward_to_go" else {}), }, + patch_files=[ + str(REPO / "training/patch_pipeline_group.py"), + str(REPO / "training/patch_checkpoint_rpc.py"), + str(REPO / "training/checkpoint_rpc.py"), + ] + ( + [str(REPO / "training/balatro_credit.py")] + if credit_assignment == "reward_to_go" else [] + ), + image_run_commands=[ + "python /tmp/patch_pipeline_group.py", + "python /tmp/patch_checkpoint_rpc.py", + ] + ( + ["python /tmp/balatro_credit.py"] + if credit_assignment == "reward_to_go" else [] + ), train_function_kwargs={"ephemeral_disk": 1_048_576}, ), ) @@ -2761,6 +3305,10 @@ def _launch_training(config: TrainConfig, record_path: Path | None = None): existing receipt blocks submission, including an uncertain/partial one: automatically retrying those can create duplicate GPU jobs. """ + # Reject incompatible historical recipes before pinning checkpoints, + # creating a submission receipt, or allocating remote resources. + _validate_balatro_loss_config(config.recipe) + _validate_balatro_context_config(config.recipe) record = None if record_path is not None: try: @@ -2775,8 +3323,14 @@ def _launch_training(config: TrainConfig, record_path: Path | None = None): json.dump({"state": "submitting", "pid": os.getpid()}, record) record.flush() os.fsync(record.fileno()) - if config.checkpoint is not None: - _pin_resume_checkpoint(config.checkpoint) + checkpoint = getattr(config, "checkpoint", None) + if checkpoint is not None: + # Current Training Gym ignores the legacy ``config.checkpoint`` + # attribute. Explicit --load preserves optimizer/RNG and rollout + # numbering; resume_from_checkpoint instead starts a weights-only + # seed run by default. Never silently launch from the base model. + config.recipe.load = str(PurePosixPath(checkpoint.path).parent) + _pin_resume_checkpoint(checkpoint) # Training Gym's public launcher starts a detached Modal app. Keep this # process alive until it returns the persisted function-call handle. run = config.launch() @@ -2967,6 +3521,10 @@ def manifest(checkpoint: Checkpoint) -> dict[str, int]: def main() -> None: parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument( + "--credit-assignment", choices=("episode", "reward_to_go"), default="episode", + help="Keep episode GRPO for the context-only control, or test action reward-to-go.", + ) parser.add_argument("--prepare-assets", action="store_true") parser.add_argument("--smoke-env", action="store_true") parser.add_argument( @@ -3047,7 +3605,10 @@ def main() -> None: num_rollout=args.num_rollout, load=args.load, no_load_optim=args.no_load_optim, + credit_assignment=args.credit_assignment, ) + context_limit, segment_target = _validate_balatro_context_config(config.recipe) + print(f"Context: hard={context_limit}, segment={segment_target}; credit={args.credit_assignment}.") if args.save_interval is not None: if args.save_interval < 1: raise ValueError("--save-interval must be at least 1") @@ -3085,6 +3646,8 @@ def main() -> None: if not args.prepare_assets and not args.resume_run: print("First run: python batro_modal_rl.py --prepare-assets") launch_cmd = "python batro_modal_rl.py" + if args.credit_assignment != "episode": + launch_cmd += f" --credit-assignment {args.credit_assignment}" if args.num_rollout is not None: launch_cmd += f" --num-rollout {args.num_rollout}" if args.resume_run: diff --git a/reports/broad-layover-final-evidence-2026-09-15.json b/reports/broad-layover-final-evidence-2026-09-15.json new file mode 100644 index 00000000..a414e72b --- /dev/null +++ b/reports/broad-layover-final-evidence-2026-09-15.json @@ -0,0 +1,6690 @@ +{ + "run": { + "training_run_id": "broad-layover-3a0ce678e7da", + "modal_app_id": "ap-3vCPrQh34oPL9P5dsmtUSa", + "modal_app_url": "https://modal.com/id/ap-3vCPrQh34oPL9P5dsmtUSa", + "framework": "slime", + "config": { + "model": { + "model_name": "Qwen/Qwen3.8-27B" + }, + "recipe": { + "sequence_parallel": true, + "rollout_max_response_len": 96, + "rollout_temperature": 1.0, + "save_interval": 50, + "gpu_type": "H100", + "colocate": true, + "tensor_model_parallel_size": 4, + "rollout_num_gpus_per_engine": 2, + "num_rollout": 600, + "start_rollout_id": null, + "rollout_batch_size": 16, + "actor_num_nodes": 8, + "actor_num_gpus_per_node": 8, + "rollout_num_gpus": null, + "use_critic": false, + "critic_num_nodes": null, + "critic_num_gpus_per_node": null, + "advantage_estimator": "grpo", + "n_samples_per_prompt": 4, + "eps_clip": 0.2, + "eps_clip_high": null, + "use_kl_loss": true, + "kl_loss_type": "low_var_kl", + "kl_loss_coef": 0.001, + "kl_coef": 0.0, + "entropy_coef": 0.001, + "calculate_per_token_loss": true, + "ref_load": "/checkpoints/Qwen3.8-27B_torch_dist_tp4pp2", + "over_sampling_batch_size": null, + "dynamic_sampling_filter_path": null, + "balance_data": true, + "rollout_shuffle": true, + "rollout_top_p": 1.0, + "rollout_stop_token_ids": null, + "sglang_mem_fraction_static": 0.75, + "use_fault_tolerance": true, + "rollout_health_check_interval": 30, + "rollout_health_check_timeout": 30, + "rollout_health_check_first_wait": 300, + "global_batch_size": 64, + "lr": 1e-06, + "lr_decay_style": "constant", + "weight_decay": 0.01, + "adam_beta1": 0.9, + "adam_beta2": 0.98, + "optimizer": "adam", + "attention_dropout": 0.0, + "hidden_dropout": 0.0, + "attention_softmax_in_fp32": true, + "accumulate_allreduce_grads_in_fp32": true, + "use_distributed_optimizer": false, + "recompute_granularity": "full", + "recompute_method": "uniform", + "recompute_num_layers": 1, + "use_dynamic_batch_size": true, + "max_tokens_per_gpu": 12288, + "qkv_format": "thd", + "eval_interval": null, + "n_samples_per_eval_prompt": 4, + "eval_max_response_len": 16384, + "eval_top_p": 1.0, + "eval_config": null, + "save": "/checkpoints", + "load": "/checkpoints/perfect-adhesive-da14ace5a831", + "no_save_optim": false, + "no_load_optim": false, + "megatron_to_hf_mode": "", + "freeze_params_name_list": null, + "update_weight_mode": "full", + "update_weight_transport": "nccl", + "update_weight_encoding": "indices", + "update_weight_disk_dir": "", + "rm_type": "deepscaler", + "sglang_enable_dp_attention": false, + "sglang_dp_size": null, + "sglang_ep_size": null, + "sglang_enable_dp_lm_head": false, + "sglang_disable_custom_all_reduce": false, + "sglang_cuda_graph_bs": null, + "sglang_cuda_graph_backend_prefill": "disabled", + "sglang_max_running_requests": null, + "sglang_tool_call_parser": null, + "sglang_reasoning_parser": null, + "sglang_config": null, + "apply_chat_template_kwargs": "{\"enable_thinking\": false}", + "train_env_vars": null, + "multimodal_keys": null, + "hf_checkpoint": "Qwen/Qwen3.8-27B", + "pipeline_model_parallel_size": 2, + "decoder_last_pipeline_num_layers": 30, + "context_parallel_size": 4, + "expert_model_parallel_size": 1, + "expert_tensor_parallel_size": 1, + "sglang_speculative_algorithm": null, + "sglang_speculative_num_steps": null, + "sglang_speculative_eagle_topk": null, + "sglang_speculative_num_draft_tokens": null, + "sglang_mamba_scheduler_strategy": "extra_buffer", + "optimizer_cpu_offload": true, + "overlap_cpu_optimizer_d2h_h2d": true, + "use_precision_aware_optimizer": true, + "attention_backend": "flash", + "prompt_data": "/data/2d661a1f-cff4-40fa-9756-a148c8cbbb7f-383b42b9053132de.jsonl", + "eval_prompt_data": null, + "input_key": "messages", + "label_key": "label", + "apply_chat_template": true, + "custom_config_path": { + "balatro_max_decisions": 250, + "balatro_context_len": 49152, + "balatro_capture_screenshot": false, + "custom_generate_function_path": "notebook_custom_generate_ndnib50f.generate_balatro_episode", + "override_opt_param_scheduler": true, + "custom_rm_path": "notebook_custom_rm_v7fr2std.passthrough_reward", + "custom_reward_post_process_path": "notebook_custom_reward_post_process_vvgqtrfs.normalize_episode_rewards" + }, + "custom_rollout_log_function_path": "modal_training_gym.frameworks.slime.phase_reporting.log_rollout_data", + "custom_eval_rollout_log_function_path": "modal_training_gym.frameworks.slime.phase_reporting.log_eval_rollout_data", + "custom_megatron_before_log_prob_hook_path": "modal_training_gym.frameworks.slime.phase_reporting.before_log_prob_hook", + "custom_megatron_before_train_step_hook_path": "modal_training_gym.frameworks.slime.phase_reporting.before_train_step_hook" + }, + "metrics": {}, + "dataset": { + "hf_repo": "", + "name": "BalatroSeedsDataset" + }, + "eval_dataset": null, + "lr": 1e-06, + "global_batch_size": 64 + }, + "dataset_id": "", + "deployment_id": "", + "status": "failed", + "framework_status": "initialize_rollouts", + "created_at": 1789435612, + "started_at": 1789435612, + "ended_at": 1789460930, + "completed_at": 1789460930, + "updated_at": 1789460931, + "duration_seconds": 25318, + "step_times": null, + "substep_times": null, + "error_message": "Job entrypoint command failed with exit code 1, last available logs (truncated to 20,000 chars):\n File \"/usr/lib/python3.12/contextlib.py\", line 137, in __enter__\n return next(self.gen)\n ^^^^^^^^^^^^^^\n File \"/usr/local/lib/python3.12/dist-packages/torch/distributed/checkpoint/filesystem.py\", line 520, in create_stream\n with path.open(mode) as stream:\n ^^^^^^^^^^^^^^^\n File \"/usr/lib/python3.12/pathlib.py\", line 1015, in open\n return io.open(self, mode, buffering, encoding, errors, newline)\n ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\nFileNotFoundError: [Errno 2] No such file or directory: '/checkpoints/broad-layover-3a0ce678e7da/iter_0000449/__44_1.distcp'\n (training_run_id=broad-layover-3a0ce678e7da)", + "metadata": { + "framework_progress": { + "phase": "initialize_rollouts", + "updated_at": 1789460382, + "current": 450, + "total": 600, + "unit": "step", + "rollout_id": 449, + "step_id": 449 + }, + "dashboard_components": { + "balatro": { + "name": "balatro", + "type": "trajectory_viewer", + "sha256": "3f05ebe30f20172fb596b4b9dcb8a4a74a4919354599b017ad3cca65e5a0898b", + "filename": "TrajectoryViewer.svelte", + "size": 1067084, + "path": "components/trajectory_viewer/3f05ebe30f20172fb596b4b9dcb8a4a74a4919354599b017ad3cca65e5a0898b/balatro.svelte", + "contract": "training-gym-dashboard-component/v1", + "training_run_id": "broad-layover-3a0ce678e7da" + } + }, + "checkpoint_location": { + "checkpoint_dir": "/checkpoints/broad-layover-3a0ce678e7da", + "checkpoints_volume_name": "slime-qwen3_8_27b_recipe-checkpoints", + "checkpoints_mount_path": "/checkpoints" + }, + "attempt_count": 4, + "last_attempt_started_at": 1789460314, + "last_attempt_status": "failed", + "attempt_starts": [ + 1789435732, + 1789459044, + 1789459634, + 1789460314 + ], + "latest_rollout": { + "rollout_id": 449, + "mean": 46.390621725063134, + "total": 64, + "created_at": 1789458580 + }, + "last_attempt_ended_at": 1789460930, + "resumed_from_checkpoint": true, + "resume_checkpoint_path": "/checkpoints/broad-layover-3a0ce678e7da/iter_0000449", + "resume_checkpoint_name": "iter_0000449", + "resume_from_iteration": 449 + }, + "function_call_id": "fc-01M2HAV5N51FQR76MTYN7KX1KP", + "app_name": "", + "source_model": null, + "metrics": {}, + "group_id": null + }, + "windows": [ + { + "steps": [ + 400, + 409 + ], + "episodes": 640, + "reward": 51.89420874408144, + "ante": 3.2625, + "wins": 0.0 + }, + { + "steps": [ + 410, + 419 + ], + "episodes": 640, + "reward": 48.308131432094385, + "ante": 3.109375, + "wins": 0.0 + }, + { + "steps": [ + 420, + 429 + ], + "episodes": 640, + "reward": 49.42259042475537, + "ante": 3.165625, + "wins": 0.0 + }, + { + "steps": [ + 430, + 439 + ], + "episodes": 640, + "reward": 50.61567625256471, + "ante": 3.175, + "wins": 0.0 + }, + { + "steps": [ + 440, + 449 + ], + "episodes": 640, + "reward": 39.13122086005141, + "ante": 2.6671875, + "wins": 0.0 + } + ], + "sampled_trajectory_audits": { + "400": { + "rollout": 400, + "episodes": 64, + "reward": 52.22539668560606, + "endings": { + "game_over": 55, + "context_cap": 9 + }, + "antes": { + "4": 26, + "2": 12, + "3": 3, + "5": 10, + "6": 1, + "1": 12 + }, + "actions": { + "select": 600, + "play": 1314, + "discard": 1204, + "buy": 793, + "pack": 392, + "next_round": 536, + "use": 209, + "reroll": 2 + }, + "played_hands": { + "Full House": 184, + "Two Pair": 660, + "Three of a Kind": 218, + "Pair": 208, + "High Card": 25, + "Straight": 1, + "Five of a Kind": 1, + "Four of a Kind": 15, + "Flush": 2 + }, + "pair_or_high_with_raw_straight_available": 30, + "affected_samples": 21, + "total_plays": 1314, + "plays_including_debuffed_card": 126, + "losses_with_discards_left": 21, + "caps": [ + { + "sample": 7, + "ante": 6, + "turns": 131, + "reward": 98.0, + "tokens": 48561, + "phase": "shop", + "remaining": null + }, + { + "sample": 8, + "ante": 4, + "turns": 120, + "reward": 88.0, + "tokens": 48458, + "phase": "shop", + "remaining": null + }, + { + "sample": 10, + "ante": 4, + "turns": 113, + "reward": 84.0, + "tokens": 48874, + "phase": "shop", + "remaining": null + }, + { + "sample": 25, + "ante": 4, + "turns": 123, + "reward": 88.0, + "tokens": 48992, + "phase": "pack", + "remaining": null + }, + { + "sample": 36, + "ante": 5, + "turns": 122, + "reward": 88.0, + "tokens": 48797, + "phase": "hand", + "remaining": { + "type": "boss", + "score": [ + 0, + 22000 + ], + "hands": 4, + "discards": 4, + "effect": "All face cards are drawn face down" + } + }, + { + "sample": 37, + "ante": 5, + "turns": 109, + "reward": 88.19772727272728, + "tokens": 48894, + "phase": "hand", + "remaining": { + "type": "boss", + "score": [ + 4350, + 22000 + ], + "hands": 4, + "discards": 1, + "effect": "All face cards are drawn face down" + } + }, + { + "sample": 38, + "ante": 5, + "turns": 113, + "reward": 88.44136363636363, + "tokens": 48699, + "phase": "hand", + "remaining": { + "type": "boss", + "score": [ + 9710, + 22000 + ], + "hands": 2, + "discards": 2, + "effect": "All face cards are drawn face down" + } + }, + { + "sample": 45, + "ante": 5, + "turns": 103, + "reward": 76.93945454545455, + "tokens": 48781, + "phase": "hand", + "remaining": { + "type": "small", + "score": [ + 10334, + 11000 + ], + "hands": 1, + "discards": 1 + } + }, + { + "sample": 47, + "ante": 5, + "turns": 102, + "reward": 80.0, + "tokens": 48782, + "phase": "hand", + "remaining": { + "type": "big", + "score": [ + 0, + 16500 + ], + "hands": 4, + "discards": 2 + } + } + ], + "groups": { + "3200": [ + { + "index": 0, + "reward": 64.91, + "ante": 4 + }, + { + "index": 1, + "reward": 68.68, + "ante": 4 + }, + { + "index": 2, + "reward": 68.57, + "ante": 4 + }, + { + "index": 3, + "reward": 68.47, + "ante": 4 + } + ], + "3201": [ + { + "index": 4, + "reward": 28.53, + "ante": 2 + }, + { + "index": 5, + "reward": 46.78, + "ante": 3 + }, + { + "index": 6, + "reward": 78.51, + "ante": 5 + }, + { + "index": 7, + "reward": 98.0, + "ante": 6 + } + ], + "3202": [ + { + "index": 8, + "reward": 88.0, + "ante": 4 + }, + { + "index": 9, + "reward": 48.5, + "ante": 2 + }, + { + "index": 10, + "reward": 84.0, + "ante": 4 + }, + { + "index": 11, + "reward": 84.87, + "ante": 4 + } + ], + "3203": [ + { + "index": 12, + "reward": 28.63, + "ante": 2 + }, + { + "index": 13, + "reward": 28.47, + "ante": 2 + }, + { + "index": 14, + "reward": 28.56, + "ante": 2 + }, + { + "index": 15, + "reward": 28.57, + "ante": 2 + } + ], + "3204": [ + { + "index": 16, + "reward": 8.55, + "ante": 1 + }, + { + "index": 17, + "reward": 8.55, + "ante": 1 + }, + { + "index": 18, + "reward": 8.27, + "ante": 1 + }, + { + "index": 19, + "reward": 8.55, + "ante": 1 + } + ], + "3205": [ + { + "index": 20, + "reward": 68.47, + "ante": 4 + }, + { + "index": 21, + "reward": 28.56, + "ante": 2 + }, + { + "index": 22, + "reward": 68.64, + "ante": 4 + }, + { + "index": 23, + "reward": 60.82, + "ante": 4 + } + ], + "3206": [ + { + "index": 24, + "reward": 28.96, + "ante": 2 + }, + { + "index": 25, + "reward": 88.0, + "ante": 4 + }, + { + "index": 26, + "reward": 28.95, + "ante": 2 + }, + { + "index": 27, + "reward": 28.96, + "ante": 2 + } + ], + "3207": [ + { + "index": 28, + "reward": 68.51, + "ante": 4 + }, + { + "index": 29, + "reward": 68.52, + "ante": 4 + }, + { + "index": 30, + "reward": 24.31, + "ante": 2 + }, + { + "index": 31, + "reward": 28.77, + "ante": 2 + } + ], + "3208": [ + { + "index": 32, + "reward": 0.62, + "ante": 1 + }, + { + "index": 33, + "reward": 0.61, + "ante": 1 + }, + { + "index": 34, + "reward": 68.36, + "ante": 4 + }, + { + "index": 35, + "reward": 68.33, + "ante": 4 + } + ], + "3209": [ + { + "index": 36, + "reward": 88.0, + "ante": 5 + }, + { + "index": 37, + "reward": 88.2, + "ante": 5 + }, + { + "index": 38, + "reward": 88.44, + "ante": 5 + }, + { + "index": 39, + "reward": 68.73, + "ante": 4 + } + ], + "3210": [ + { + "index": 40, + "reward": 8.64, + "ante": 1 + }, + { + "index": 41, + "reward": 8.8, + "ante": 1 + }, + { + "index": 42, + "reward": 64.56, + "ante": 4 + }, + { + "index": 43, + "reward": 8.64, + "ante": 1 + } + ], + "3211": [ + { + "index": 44, + "reward": 46.41, + "ante": 3 + }, + { + "index": 45, + "reward": 76.94, + "ante": 5 + }, + { + "index": 46, + "reward": 58.69, + "ante": 4 + }, + { + "index": 47, + "reward": 80.0, + "ante": 5 + } + ], + "3212": [ + { + "index": 48, + "reward": 0.31, + "ante": 1 + }, + { + "index": 49, + "reward": 64.48, + "ante": 4 + }, + { + "index": 50, + "reward": 64.45, + "ante": 4 + }, + { + "index": 51, + "reward": 64.52, + "ante": 4 + } + ], + "3213": [ + { + "index": 52, + "reward": 68.59, + "ante": 4 + }, + { + "index": 53, + "reward": 8.64, + "ante": 1 + }, + { + "index": 54, + "reward": 8.64, + "ante": 1 + }, + { + "index": 55, + "reward": 64.67, + "ante": 4 + } + ], + "3214": [ + { + "index": 56, + "reward": 88.85, + "ante": 5 + }, + { + "index": 57, + "reward": 86.64, + "ante": 5 + }, + { + "index": 58, + "reward": 88.63, + "ante": 5 + }, + { + "index": 59, + "reward": 88.77, + "ante": 5 + } + ], + "3215": [ + { + "index": 60, + "reward": 68.5, + "ante": 4 + }, + { + "index": 61, + "reward": 48.76, + "ante": 3 + }, + { + "index": 62, + "reward": 68.18, + "ante": 4 + }, + { + "index": 63, + "reward": 68.41, + "ante": 4 + } + ] + }, + "opportunity_examples": [ + { + "sample": 7, + "turn": 84, + "ante": 4, + "blind": { + "type": "big", + "score": [ + 0, + 7500 + ], + "hands": 4, + "discards": 2 + }, + "hand": [ + "S_A", + "H_A", + { + "id": "D_K", + "mod": { + "enhancement": "MULT" + } + }, + "H_Q", + "C_J", + "H_T", + "D_T", + "S_3" + ], + "action": { + "method": "play", + "params": { + "cards": [ + 2, + 6, + 5, + 4, + 3 + ] + } + }, + "commit": { + "hand": "Pair", + "cards": [ + 2, + 6, + 5, + 4, + 3 + ], + "score": 1980 + }, + "straight": [ + 5, + 4, + 3, + 2, + 0 + ], + "jokers": [ + { + "id": "j_hanging_chad", + "effect": "Retrigger first played card used in scoring 2 additional times", + "sell": 2 + }, + { + "id": "j_mad", + "effect": "+10 Mult if played hand contains a Two Pair", + "mod": { + "enhancement": "TYPE MULT" + }, + "sell": 2 + }, + { + "id": "j_supernova", + "effect": "Adds the number of times poker hand has been played this run to Mult", + "mod": { + "enhancement": "HAND PLAYED MULT" + }, + "sell": 2 + }, + { + "id": "j_castle", + "effect": "This Joker gains +3 Chips per discarded Spade card, suit changes every round (Currently +15 Chips)", + "mod": { + "edition": "HOLO" + }, + "sell": 4 + }, + { + "id": "j_odd_todd", + "effect": "Played cards with odd rank give +31 Chips when scored (A, 9, 7, 5, 3)", + "mod": { + "enhancement": "ODD BUFF" + }, + "sell": 2 + } + ], + "boss": [ + "The Head", + 10000, + "All Heart cards are debuffed" + ] + }, + { + "sample": 11, + "turn": 103, + "ante": 4, + "blind": { + "type": "small", + "score": [ + 3216, + 5000 + ], + "hands": 2, + "discards": 0 + }, + "hand": [ + "C_A", + "S_K", + "D_K", + "C_Q", + "D_J", + { + "id": "H_T", + "mod": { + "edition": "POLYCHROME" + } + }, + "S_5", + "S_2" + ], + "action": { + "method": "play", + "params": { + "cards": [ + 2, + 1, + 6, + 7, + 5 + ] + } + }, + "commit": { + "hand": "Pair", + "cards": [ + 2, + 1, + 6, + 7, + 5 + ], + "score": 1008 + }, + "straight": [ + 5, + 4, + 3, + 1, + 0 + ], + "jokers": [ + { + "id": "j_misprint", + "effect": " +", + "mod": { + "enhancement": "RANDOM MULT" + }, + "sell": 2 + }, + { + "id": "j_cartomancer", + "effect": "Create a Tarot card when Blind is selected (Must have room)", + "mod": { + "edition": "FOIL", + "enhancement": "TAROT BUFF" + }, + "sell": 4 + }, + { + "id": "j_golden", + "effect": "Earn $4 at end of round", + "mod": { + "enhancement": "BONUS DOLLARS" + }, + "sell": 3 + }, + { + "id": "j_bull", + "effect": "+2 Chips for each $1 you have (Currently +4 Chips)", + "sell": 3 + }, + { + "id": "j_delayed_grat", + "effect": "Earn $2 per discard if no discards are used by end of the round", + "mod": { + "enhancement": "DISCARD DOLLARS" + }, + "sell": 2 + } + ], + "boss": [ + "The Manacle", + 10000, + "-1 Hand Size" + ] + }, + { + "sample": 11, + "turn": 104, + "ante": 4, + "blind": { + "type": "small", + "score": [ + 4224, + 5000 + ], + "hands": 1, + "discards": 0 + }, + "hand": [ + "S_A", + "C_A", + "H_K", + "C_Q", + "D_J", + "S_T", + "H_T", + "H_4" + ], + "action": { + "method": "play", + "params": { + "cards": [ + 2, + 3, + 6, + 5, + 7 + ] + } + }, + "commit": { + "hand": "Pair", + "cards": [ + 2, + 3, + 6, + 5, + 7 + ], + "score": 1008 + }, + "straight": [ + 5, + 4, + 3, + 2, + 0 + ], + "jokers": [ + { + "id": "j_misprint", + "effect": " +", + "mod": { + "enhancement": "RANDOM MULT" + }, + "sell": 2 + }, + { + "id": "j_cartomancer", + "effect": "Create a Tarot card when Blind is selected (Must have room)", + "mod": { + "edition": "FOIL", + "enhancement": "TAROT BUFF" + }, + "sell": 4 + }, + { + "id": "j_golden", + "effect": "Earn $4 at end of round", + "mod": { + "enhancement": "BONUS DOLLARS" + }, + "sell": 3 + }, + { + "id": "j_bull", + "effect": "+2 Chips for each $1 you have (Currently +4 Chips)", + "sell": 3 + }, + { + "id": "j_delayed_grat", + "effect": "Earn $2 per discard if no discards are used by end of the round", + "mod": { + "enhancement": "DISCARD DOLLARS" + }, + "sell": 2 + } + ], + "boss": [ + "The Manacle", + 10000, + "-1 Hand Size" + ] + } + ], + "examples": [ + { + "sample": 0, + "reward": 64.90520000000001, + "ending": "game_over", + "ante": 4, + "last_before": { + "phase": "hand", + "ante": 4, + "round": 11, + "money": 0, + "blind": { + "type": "big", + "score": [ + 6789, + 7500 + ], + "hands": 1, + "discards": 0 + }, + "boss": [ + "The Wall", + 20000, + "Extra large blind" + ], + "hand": [ + "D_A", + "H_K", + "C_Q", + "S_9", + "S_8", + "C_8", + "H_7", + "D_6", + "D_4" + ], + "jokers": { + "slots": "5/5", + "items": [ + { + "id": "j_photograph", + "effect": "First played face card gives X2 Mult when scored", + "sell": 2 + }, + { + "id": "j_misprint", + "effect": " +", + "mod": { + "enhancement": "RANDOM MULT" + }, + "sell": 2 + }, + { + "id": "j_wrathful_joker", + "effect": "Played cards with Spade suit give +3 Mult when scored", + "mod": { + "enhancement": "SUIT MULT" + }, + "sell": 2 + }, + { + "id": "j_lusty_joker", + "effect": "Played cards with Heart suit give +3 Mult when scored", + "mod": { + "enhancement": "SUIT MULT" + }, + "sell": 2 + }, + { + "id": "j_riff_raff", + "effect": "When Blind is selected, create 2 Common Jokers (Must have room)", + "sell": 3 + } + ] + }, + "consumables": { + "slots": "0/2" + }, + "hand_values": { + "Four of a Kind": [ + 2, + 90, + 10 + ], + "Full House": [ + 1, + 40, + 4 + ], + "Flush": [ + 1, + 35, + 4 + ], + "Straight": [ + 2, + 60, + 7 + ], + "Three of a Kind": [ + 2, + 50, + 5 + ], + "Two Pair": [ + 2, + 40, + 3 + ], + "Pair": [ + 1, + 10, + 2 + ], + "High Card": [ + 1, + 5, + 1 + ], + "Flush Five": [ + 1, + 160, + 16 + ], + "Flush House": [ + 1, + 140, + 14 + ], + "Five of a Kind": [ + 1, + 120, + 12 + ], + "Straight Flush": [ + 1, + 100, + 8 + ] + } + }, + "action": { + "method": "play", + "params": { + "cards": [ + 5, + 4, + 3, + 2, + 1 + ] + } + }, + "last_after": { + "phase": "GAME_OVER", + "blind": { + "type": "big", + "score": [ + 7309, + 7500 + ], + "hands": 0, + "discards": 0 + }, + "play_commit": { + "score": 520, + "hand": "Pair", + "cards": [ + 5, + 4, + 3, + 2, + 1 + ] + } + } + }, + { + "sample": 7, + "reward": 98.0, + "ending": "context_cap", + "ante": 6, + "last_before": { + "phase": "hand", + "ante": 5, + "round": 15, + "money": 1, + "blind": { + "type": "boss", + "score": [ + 17756, + 22000 + ], + "hands": 1, + "discards": 1, + "effect": "All face cards are debuffed" + }, + "boss": [ + "The Plant", + 22000, + "All face cards are debuffed" + ], + "hand": [ + "H_A", + "D_A", + { + "id": "C_Q", + "debuff": true + }, + "H_9", + "C_9", + { + "id": "H_8", + "mod": { + "seal": "GOLD" + } + }, + "C_7", + "C_3" + ], + "jokers": { + "slots": "5/5", + "items": [ + { + "id": "j_hanging_chad", + "effect": "Retrigger first played card used in scoring 2 additional times", + "sell": 2 + }, + { + "id": "j_mad", + "effect": "+10 Mult if played hand contains a Two Pair", + "mod": { + "enhancement": "TYPE MULT" + }, + "sell": 2 + }, + { + "id": "j_supernova", + "effect": "Adds the number of times poker hand has been played this run to Mult", + "mod": { + "enhancement": "HAND PLAYED MULT" + }, + "sell": 2 + }, + { + "id": "j_castle", + "effect": "This Joker gains +3 Chips per discarded Heart card, suit changes every round (Currently +48 Chips)", + "mod": { + "edition": "HOLO" + }, + "sell": 4 + }, + { + "id": "j_odd_todd", + "effect": "Played cards with odd rank give +31 Chips when scored (A, 9, 7, 5, 3)", + "mod": { + "enhancement": "ODD BUFF" + }, + "sell": 2 + } + ] + }, + "consumables": { + "slots": "0/2" + }, + "hand_values": { + "Flush House": [ + 1, + 140, + 14 + ], + "Flush Five": [ + 1, + 160, + 16 + ], + "Five of a Kind": [ + 1, + 120, + 12 + ], + "Straight Flush": [ + 1, + 100, + 8 + ], + "Four of a Kind": [ + 1, + 60, + 7 + ], + "Full House": [ + 1, + 40, + 4 + ], + "Flush": [ + 1, + 35, + 4 + ], + "Straight": [ + 2, + 60, + 7 + ], + "Three of a Kind": [ + 1, + 30, + 3 + ], + "Two Pair": [ + 3, + 60, + 4 + ], + "Pair": [ + 5, + 70, + 6 + ], + "High Card": [ + 1, + 5, + 1 + ] + } + }, + "action": { + "method": "play", + "params": { + "cards": [ + 2, + 3, + 4, + 1, + 0 + ] + } + }, + "last_after": { + "phase": "shop", + "blind": null, + "play_commit": { + "hand": "Two Pair", + "cards": [ + 2, + 3, + 4, + 1, + 0 + ], + "score": 14596 + } + } + } + ], + "error_count": 10 + }, + "413": { + "rollout": 413, + "episodes": 64, + "reward": 36.44929845722854, + "endings": { + "game_over": 63, + "context_cap": 1 + }, + "antes": { + "1": 29, + "4": 19, + "3": 7, + "5": 7, + "2": 2 + }, + "actions": { + "select": 440, + "play": 1094, + "discard": 655, + "buy": 568, + "pack": 238, + "next_round": 376, + "use": 151, + "reroll": 1 + }, + "played_hands": { + "Pair": 280, + "Full House": 148, + "Two Pair": 512, + "Three of a Kind": 118, + "High Card": 30, + "Four of a Kind": 5, + "Straight": 1 + }, + "pair_or_high_with_raw_straight_available": 55, + "affected_samples": 38, + "total_plays": 1094, + "plays_including_debuffed_card": 97, + "losses_with_discards_left": 42, + "caps": [ + { + "sample": 14, + "ante": 5, + "turns": 117, + "reward": 86.0, + "tokens": 48508, + "phase": "hand", + "remaining": { + "type": "boss", + "score": [ + 0, + 22000 + ], + "hands": 4, + "discards": 1, + "effect": "#1# in #2# cards get drawn face down" + } + } + ], + "groups": { + "3408": [ + { + "index": 0, + "reward": 4.57, + "ante": 1 + }, + { + "index": 1, + "reward": 4.48, + "ante": 1 + }, + { + "index": 2, + "reward": 4.57, + "ante": 1 + }, + { + "index": 3, + "reward": 8.45, + "ante": 1 + } + ], + "3409": [ + { + "index": 4, + "reward": 8.66, + "ante": 1 + }, + { + "index": 5, + "reward": 0.8, + "ante": 1 + }, + { + "index": 6, + "reward": 0.8, + "ante": 1 + }, + { + "index": 7, + "reward": 8.34, + "ante": 1 + } + ], + "3410": [ + { + "index": 8, + "reward": 66.7, + "ante": 4 + }, + { + "index": 9, + "reward": 48.74, + "ante": 3 + }, + { + "index": 10, + "reward": 60.51, + "ante": 4 + }, + { + "index": 11, + "reward": 64.64, + "ante": 4 + } + ], + "3411": [ + { + "index": 12, + "reward": 82.33, + "ante": 5 + }, + { + "index": 13, + "reward": 48.1, + "ante": 3 + }, + { + "index": 14, + "reward": 86.0, + "ante": 5 + }, + { + "index": 15, + "reward": 0.52, + "ante": 1 + } + ], + "3412": [ + { + "index": 16, + "reward": 64.92, + "ante": 4 + }, + { + "index": 17, + "reward": 66.0, + "ante": 4 + }, + { + "index": 18, + "reward": 68.0, + "ante": 4 + }, + { + "index": 19, + "reward": 68.0, + "ante": 4 + } + ], + "3413": [ + { + "index": 20, + "reward": 4.62, + "ante": 1 + }, + { + "index": 21, + "reward": 4.5, + "ante": 1 + }, + { + "index": 22, + "reward": 4.62, + "ante": 1 + }, + { + "index": 23, + "reward": 4.76, + "ante": 1 + } + ], + "3414": [ + { + "index": 24, + "reward": 0.66, + "ante": 1 + }, + { + "index": 25, + "reward": 0.66, + "ante": 1 + }, + { + "index": 26, + "reward": 48.38, + "ante": 3 + }, + { + "index": 27, + "reward": 0.66, + "ante": 1 + } + ], + "3415": [ + { + "index": 28, + "reward": 68.59, + "ante": 4 + }, + { + "index": 29, + "reward": 64.67, + "ante": 4 + }, + { + "index": 30, + "reward": 64.82, + "ante": 4 + }, + { + "index": 31, + "reward": 64.77, + "ante": 4 + } + ], + "3416": [ + { + "index": 32, + "reward": 4.5, + "ante": 1 + }, + { + "index": 33, + "reward": 4.5, + "ante": 1 + }, + { + "index": 34, + "reward": 4.39, + "ante": 1 + }, + { + "index": 35, + "reward": 24.68, + "ante": 2 + } + ], + "3417": [ + { + "index": 36, + "reward": 88.38, + "ante": 5 + }, + { + "index": 37, + "reward": 48.85, + "ante": 3 + }, + { + "index": 38, + "reward": 88.46, + "ante": 5 + }, + { + "index": 39, + "reward": 88.67, + "ante": 5 + } + ], + "3418": [ + { + "index": 40, + "reward": 0.61, + "ante": 1 + }, + { + "index": 41, + "reward": 0.61, + "ante": 1 + }, + { + "index": 42, + "reward": 64.83, + "ante": 4 + }, + { + "index": 43, + "reward": 0.61, + "ante": 1 + } + ], + "3419": [ + { + "index": 44, + "reward": 0.77, + "ante": 1 + }, + { + "index": 45, + "reward": 64.95, + "ante": 4 + }, + { + "index": 46, + "reward": 64.45, + "ante": 4 + }, + { + "index": 47, + "reward": 28.41, + "ante": 2 + } + ], + "3420": [ + { + "index": 48, + "reward": 68.36, + "ante": 4 + }, + { + "index": 49, + "reward": 64.68, + "ante": 4 + }, + { + "index": 50, + "reward": 60.63, + "ante": 4 + }, + { + "index": 51, + "reward": 62.36, + "ante": 4 + } + ], + "3421": [ + { + "index": 52, + "reward": 66.59, + "ante": 4 + }, + { + "index": 53, + "reward": 48.25, + "ante": 3 + }, + { + "index": 54, + "reward": 80.71, + "ante": 5 + }, + { + "index": 55, + "reward": 82.24, + "ante": 5 + } + ], + "3422": [ + { + "index": 56, + "reward": 8.7, + "ante": 1 + }, + { + "index": 57, + "reward": 48.33, + "ante": 3 + }, + { + "index": 58, + "reward": 44.69, + "ante": 3 + }, + { + "index": 59, + "reward": 0.61, + "ante": 1 + } + ], + "3423": [ + { + "index": 60, + "reward": 4.52, + "ante": 1 + }, + { + "index": 61, + "reward": 4.52, + "ante": 1 + }, + { + "index": 62, + "reward": 4.67, + "ante": 1 + }, + { + "index": 63, + "reward": 8.35, + "ante": 1 + } + ] + }, + "opportunity_examples": [ + { + "sample": 0, + "turn": 16, + "ante": 1, + "blind": { + "type": "big", + "score": [ + 256, + 450 + ], + "hands": 1, + "discards": 1 + }, + "hand": [ + "H_A", + "D_K", + "S_Q", + "H_J", + "D_J", + "H_T", + "S_8", + "C_2" + ], + "action": { + "method": "play", + "params": { + "cards": [ + 4, + 3, + 5, + 6, + 2 + ] + } + }, + "commit": { + "score": 60, + "hand": "Pair", + "cards": [ + 4, + 3, + 5, + 6, + 2 + ] + }, + "straight": [ + 5, + 3, + 2, + 1, + 0 + ], + "jokers": [ + { + "id": "j_superposition", + "effect": "Create a Tarot card if poker hand contains an Ace and a Straight (Must have room)", + "sell": 2 + }, + { + "id": "j_devious", + "effect": "+100 Chips if played hand contains a Straight", + "sell": 2 + } + ], + "boss": [ + "The Hook", + 600, + "Discards 2 random cards per hand played" + ] + }, + { + "sample": 2, + "turn": 16, + "ante": 1, + "blind": { + "type": "big", + "score": [ + 256, + 450 + ], + "hands": 1, + "discards": 1 + }, + "hand": [ + "H_A", + "D_K", + "S_Q", + "H_J", + "D_J", + "H_T", + "S_8", + "C_2" + ], + "action": { + "method": "play", + "params": { + "cards": [ + 4, + 3, + 6, + 5, + 2 + ] + } + }, + "commit": { + "hand": "Pair", + "cards": [ + 4, + 3, + 6, + 5, + 2 + ], + "score": 60 + }, + "straight": [ + 5, + 3, + 2, + 1, + 0 + ], + "jokers": [ + { + "id": "j_superposition", + "effect": "Create a Tarot card if poker hand contains an Ace and a Straight (Must have room)", + "sell": 2 + }, + { + "id": "j_devious", + "effect": "+100 Chips if played hand contains a Straight", + "sell": 2 + } + ], + "boss": [ + "The Hook", + 600, + "Discards 2 random cards per hand played" + ] + }, + { + "sample": 3, + "turn": 24, + "ante": 1, + "blind": { + "type": "boss", + "score": [ + 270, + 600 + ], + "hands": 1, + "discards": 0, + "effect": "Discards 2 random cards per hand played" + }, + "hand": [ + "S_A", + "D_K", + "H_Q", + "S_J", + "S_T", + "C_9", + "C_5", + "D_2" + ], + "action": { + "method": "play", + "params": { + "cards": [ + 6, + 5, + 4, + 3, + 2 + ] + } + }, + "commit": { + "score": 15, + "hand": "High Card", + "cards": [ + 6, + 5, + 4, + 3, + 2 + ] + }, + "straight": [ + 4, + 3, + 2, + 1, + 0 + ], + "jokers": [ + { + "id": "j_superposition", + "effect": "Create a Tarot card if poker hand contains an Ace and a Straight (Must have room)", + "sell": 2 + }, + { + "id": "j_wrathful_joker", + "effect": "Played cards with Spade suit give +3 Mult when scored", + "mod": { + "enhancement": "SUIT MULT" + }, + "sell": 2 + } + ], + "boss": [ + "The Hook", + 600, + "Discards 2 random cards per hand played" + ] + } + ], + "examples": [ + { + "sample": 0, + "reward": 4.568888888888889, + "ending": "game_over", + "ante": 1, + "last_before": { + "phase": "hand", + "ante": 1, + "round": 2, + "money": 1, + "blind": { + "type": "big", + "score": [ + 256, + 450 + ], + "hands": 1, + "discards": 1 + }, + "boss": [ + "The Hook", + 600, + "Discards 2 random cards per hand played" + ], + "hand": [ + "H_A", + "D_K", + "S_Q", + "H_J", + "D_J", + "H_T", + "S_8", + "C_2" + ], + "jokers": { + "slots": "2/5", + "items": [ + { + "id": "j_superposition", + "effect": "Create a Tarot card if poker hand contains an Ace and a Straight (Must have room)", + "sell": 2 + }, + { + "id": "j_devious", + "effect": "+100 Chips if played hand contains a Straight", + "sell": 2 + } + ] + }, + "consumables": { + "slots": "0/2" + }, + "hand_values": { + "Flush Five": [ + 1, + 160, + 16 + ], + "Flush House": [ + 1, + 140, + 14 + ], + "Five of a Kind": [ + 1, + 120, + 12 + ], + "Straight Flush": [ + 1, + 100, + 8 + ], + "Four of a Kind": [ + 1, + 60, + 7 + ], + "Full House": [ + 1, + 40, + 4 + ], + "Flush": [ + 1, + 35, + 4 + ], + "Straight": [ + 1, + 30, + 4 + ], + "Three of a Kind": [ + 1, + 30, + 3 + ], + "Two Pair": [ + 1, + 20, + 2 + ], + "Pair": [ + 1, + 10, + 2 + ], + "High Card": [ + 1, + 5, + 1 + ] + } + }, + "action": { + "method": "play", + "params": { + "cards": [ + 4, + 3, + 5, + 6, + 2 + ] + } + }, + "last_after": { + "phase": "GAME_OVER", + "blind": { + "type": "big", + "score": [ + 316, + 450 + ], + "hands": 0, + "discards": 1 + }, + "play_commit": { + "score": 60, + "hand": "Pair", + "cards": [ + 4, + 3, + 5, + 6, + 2 + ] + } + } + }, + { + "sample": 39, + "reward": 88.66927272727273, + "ending": "game_over", + "ante": 5, + "last_before": { + "phase": "hand", + "ante": 5, + "round": 15, + "money": 2, + "blind": { + "type": "boss", + "score": [ + 14724, + 22000 + ], + "hands": 1, + "discards": 0, + "effect": "All Heart cards are debuffed" + }, + "boss": [ + "The Head", + 22000, + "All Heart cards are debuffed" + ], + "hand": [ + "C_A", + "C_K", + "C_J", + "C_T", + { + "id": "H_8", + "debuff": true + }, + "S_6", + { + "id": "H_6", + "debuff": true + }, + { + "id": "H_4", + "debuff": true + } + ], + "jokers": { + "slots": "6/5", + "items": [ + { + "id": "j_shoot_the_moon", + "effect": "Each Queen held in hand gives +13 Mult", + "mod": { + "edition": "HOLO" + }, + "sell": 4 + }, + { + "id": "j_scary_face", + "effect": "Played face cards give +30 Chips when scored", + "mod": { + "enhancement": "SCARY FACES" + }, + "sell": 2 + }, + { + "id": "j_mad", + "effect": "+10 Mult if played hand contains a Two Pair", + "mod": { + "enhancement": "TYPE MULT" + }, + "sell": 2 + }, + { + "id": "j_hanging_chad", + "effect": "Retrigger first played card used in scoring 2 additional times", + "sell": 2 + }, + { + "id": "j_ice_cream", + "effect": "+5 Chips -5 Chips for every hand played", + "sell": 2 + }, + { + "id": "j_bloodstone", + "effect": "1 in 2 chance for played cards with Heart suit to give X1.5 Mult when scored", + "sell": 3 + } + ] + }, + "consumables": { + "slots": "2/2", + "items": [ + { + "id": "c_justice", + "effect": "Enhances 1 selected card into a Glass Card", + "mod": { + "enhancement": "ENHANCE" + }, + "sell": 1 + }, + { + "id": "c_magician", + "effect": "Enhances 2 selected cards to Lucky Cards", + "mod": { + "enhancement": "ENHANCE" + }, + "sell": 1 + } + ] + }, + "hand_values": { + "Flush Five": [ + 1, + 160, + 16 + ], + "Flush House": [ + 1, + 140, + 14 + ], + "Five of a Kind": [ + 1, + 120, + 12 + ], + "Straight Flush": [ + 1, + 100, + 8 + ], + "Four of a Kind": [ + 2, + 90, + 10 + ], + "Full House": [ + 2, + 65, + 6 + ], + "Flush": [ + 1, + 35, + 4 + ], + "Straight": [ + 1, + 30, + 4 + ], + "Three of a Kind": [ + 2, + 50, + 5 + ], + "Two Pair": [ + 2, + 40, + 3 + ], + "Pair": [ + 1, + 10, + 2 + ], + "High Card": [ + 1, + 5, + 1 + ] + } + }, + "action": { + "method": "play", + "params": { + "cards": [ + 5, + 4, + 6, + 3, + 2 + ] + } + }, + "last_after": { + "phase": "GAME_OVER", + "blind": { + "type": "boss", + "score": [ + 15120, + 22000 + ], + "hands": 0, + "discards": 0, + "effect": "All Heart cards are debuffed" + }, + "play_commit": { + "hand": "Pair", + "cards": [ + 5, + 4, + 6, + 3, + 2 + ], + "score": 396 + } + } + } + ], + "error_count": 7 + }, + "425": { + "rollout": 425, + "episodes": 64, + "reward": 45.764259150094695, + "endings": { + "game_over": 64 + }, + "antes": { + "4": 24, + "3": 9, + "1": 14, + "2": 11, + "5": 5, + "6": 1 + }, + "actions": { + "select": 530, + "discard": 784, + "play": 1384, + "buy": 664, + "pack": 282, + "next_round": 466, + "use": 122 + }, + "played_hands": { + "Pair": 398, + "Two Pair": 640, + "Full House": 134, + "Three of a Kind": 153, + "High Card": 35, + "Four of a Kind": 19, + "Straight": 5 + }, + "pair_or_high_with_raw_straight_available": 55, + "affected_samples": 37, + "total_plays": 1384, + "plays_including_debuffed_card": 163, + "losses_with_discards_left": 47, + "caps": [], + "groups": { + "3600": [ + { + "index": 0, + "reward": 64.36, + "ante": 4 + }, + { + "index": 1, + "reward": 64.2, + "ante": 4 + }, + { + "index": 2, + "reward": 64.29, + "ante": 4 + }, + { + "index": 3, + "reward": 64.21, + "ante": 4 + } + ], + "3601": [ + { + "index": 4, + "reward": 68.44, + "ante": 4 + }, + { + "index": 5, + "reward": 48.0, + "ante": 3 + }, + { + "index": 6, + "reward": 44.18, + "ante": 3 + }, + { + "index": 7, + "reward": 60.68, + "ante": 4 + } + ], + "3602": [ + { + "index": 8, + "reward": 4.58, + "ante": 1 + }, + { + "index": 9, + "reward": 4.58, + "ante": 1 + }, + { + "index": 10, + "reward": 4.58, + "ante": 1 + }, + { + "index": 11, + "reward": 4.58, + "ante": 1 + } + ], + "3603": [ + { + "index": 12, + "reward": 28.0, + "ante": 2 + }, + { + "index": 13, + "reward": 60.75, + "ante": 4 + }, + { + "index": 14, + "reward": 4.5, + "ante": 1 + }, + { + "index": 15, + "reward": 28.0, + "ante": 2 + } + ], + "3604": [ + { + "index": 16, + "reward": 60.85, + "ante": 4 + }, + { + "index": 17, + "reward": 20.54, + "ante": 2 + }, + { + "index": 18, + "reward": 64.62, + "ante": 4 + }, + { + "index": 19, + "reward": 20.6, + "ante": 2 + } + ], + "3605": [ + { + "index": 20, + "reward": 44.36, + "ante": 3 + }, + { + "index": 21, + "reward": 64.61, + "ante": 4 + }, + { + "index": 22, + "reward": 64.87, + "ante": 4 + }, + { + "index": 23, + "reward": 60.89, + "ante": 4 + } + ], + "3606": [ + { + "index": 24, + "reward": 68.49, + "ante": 4 + }, + { + "index": 25, + "reward": 68.6, + "ante": 4 + }, + { + "index": 26, + "reward": 68.66, + "ante": 4 + }, + { + "index": 27, + "reward": 44.68, + "ante": 3 + } + ], + "3607": [ + { + "index": 28, + "reward": 44.63, + "ante": 3 + }, + { + "index": 29, + "reward": 24.52, + "ante": 2 + }, + { + "index": 30, + "reward": 40.77, + "ante": 3 + }, + { + "index": 31, + "reward": 44.9, + "ante": 3 + } + ], + "3608": [ + { + "index": 32, + "reward": 82.53, + "ante": 4 + }, + { + "index": 33, + "reward": 88.32, + "ante": 4 + }, + { + "index": 34, + "reward": 68.51, + "ante": 4 + }, + { + "index": 35, + "reward": 88.2, + "ante": 4 + } + ], + "3609": [ + { + "index": 36, + "reward": 28.52, + "ante": 2 + }, + { + "index": 37, + "reward": 28.32, + "ante": 2 + }, + { + "index": 38, + "reward": 64.59, + "ante": 4 + }, + { + "index": 39, + "reward": 28.36, + "ante": 2 + } + ], + "3610": [ + { + "index": 40, + "reward": 28.27, + "ante": 2 + }, + { + "index": 41, + "reward": 28.17, + "ante": 2 + }, + { + "index": 42, + "reward": 66.23, + "ante": 4 + }, + { + "index": 43, + "reward": 28.29, + "ante": 2 + } + ], + "3611": [ + { + "index": 44, + "reward": 8.32, + "ante": 1 + }, + { + "index": 45, + "reward": 4.55, + "ante": 1 + }, + { + "index": 46, + "reward": 4.55, + "ante": 1 + }, + { + "index": 47, + "reward": 4.55, + "ante": 1 + } + ], + "3612": [ + { + "index": 48, + "reward": 100.76, + "ante": 5 + }, + { + "index": 49, + "reward": 66.73, + "ante": 4 + }, + { + "index": 50, + "reward": 68.62, + "ante": 4 + }, + { + "index": 51, + "reward": 98.69, + "ante": 5 + } + ], + "3613": [ + { + "index": 52, + "reward": 104.95, + "ante": 6 + }, + { + "index": 53, + "reward": 88.27, + "ante": 5 + }, + { + "index": 54, + "reward": 80.54, + "ante": 5 + }, + { + "index": 55, + "reward": 82.62, + "ante": 5 + } + ], + "3614": [ + { + "index": 56, + "reward": 48.45, + "ante": 3 + }, + { + "index": 57, + "reward": 0.48, + "ante": 1 + }, + { + "index": 58, + "reward": 0.72, + "ante": 1 + }, + { + "index": 59, + "reward": 40.5, + "ante": 3 + } + ], + "3615": [ + { + "index": 60, + "reward": 4.17, + "ante": 1 + }, + { + "index": 61, + "reward": 4.13, + "ante": 1 + }, + { + "index": 62, + "reward": 60.3, + "ante": 4 + }, + { + "index": 63, + "reward": 4.17, + "ante": 1 + } + ] + }, + "opportunity_examples": [ + { + "sample": 1, + "turn": 24, + "ante": 1, + "blind": { + "type": "boss", + "score": [ + 466, + 600 + ], + "hands": 2, + "discards": 1, + "effect": "All Club cards are debuffed" + }, + "hand": [ + "H_A", + { + "id": "C_K", + "debuff": true + }, + { + "id": "C_Q", + "debuff": true + }, + "H_J", + { + "id": "C_J", + "debuff": true + }, + "S_T", + "D_7", + "S_4" + ], + "action": { + "method": "play", + "params": { + "cards": [ + 4, + 3, + 2, + 1, + 5 + ] + } + }, + "commit": { + "hand": "Pair", + "cards": [ + 4, + 3, + 2, + 1, + 5 + ], + "score": 140 + }, + "straight": [ + 5, + 3, + 2, + 1, + 0 + ], + "jokers": [ + { + "id": "j_sly", + "effect": "+50 Chips if played hand contains a Pair", + "sell": 1 + } + ], + "boss": [ + "The Club", + 600, + "All Club cards are debuffed" + ] + }, + { + "sample": 2, + "turn": 36, + "ante": 2, + "blind": { + "type": "big", + "score": [ + 0, + 1200 + ], + "hands": 4, + "discards": 1 + }, + "hand": [ + "S_K", + "H_Q", + "S_J", + "S_T", + "H_T", + "D_9", + "S_5", + "H_4" + ], + "action": { + "method": "play", + "params": { + "cards": [ + 4, + 3, + 5, + 6, + 7 + ] + } + }, + "commit": { + "hand": "Pair", + "cards": [ + 4, + 3, + 5, + 6, + 7 + ], + "score": 1360 + }, + "straight": [ + 5, + 3, + 2, + 1, + 0 + ], + "jokers": [ + { + "id": "j_sly", + "effect": "+50 Chips if played hand contains a Pair", + "sell": 1 + }, + { + "id": "j_zany", + "effect": "+12 Mult if played hand contains a Three of a Kind", + "mod": { + "enhancement": "TYPE MULT" + }, + "sell": 2 + }, + { + "id": "j_gros_michel", + "effect": "+15 Mult 1 in 6 chance this card is destroyed at end of round", + "sell": 2 + }, + { + "id": "j_hiker", + "effect": "Every played card permanently gains +5 Chips when scored", + "sell": 2 + } + ], + "boss": [ + "The Wheel", + 1600, + "#1# in #2# cards get drawn face down" + ] + }, + { + "sample": 4, + "turn": 63, + "ante": 3, + "blind": { + "type": "big", + "score": [ + 1068, + 3000 + ], + "hands": 5, + "discards": 0 + }, + "hand": [ + "C_A", + "H_K", + "S_Q", + "H_J", + "H_T", + "C_7", + "C_5", + "D_3" + ], + "action": { + "method": "play", + "params": { + "cards": [ + 2, + 3, + 1, + 0, + 6 + ] + } + }, + "commit": { + "hand": "High Card", + "score": 384, + "cards": [ + 2, + 3, + 1, + 0, + 6 + ] + }, + "straight": [ + 4, + 3, + 2, + 1, + 0 + ], + "jokers": [ + { + "id": "j_fibonacci", + "effect": "Each played Ace, 2, 3, 5, or 8 gives +8 Mult when scored", + "mod": { + "enhancement": "CARD MULT" + }, + "sell": 4 + }, + { + "id": "j_walkie_talkie", + "effect": "Each played 10 or 4 gives +10 Chips and +4 Mult when scored", + "sell": 2 + }, + { + "id": "j_burglar", + "effect": "When Blind is selected, gain +3 Hands and lose all discards", + "sell": 3 + }, + { + "id": "j_luchador", + "effect": "Sell this card to disable the current Boss Blind ", + "sell": 2 + }, + { + "id": "j_mystic_summit", + "effect": "+15 Mult when 0 discards remaining", + "mod": { + "enhancement": "NO DISCARD MULT" + }, + "sell": 2 + } + ], + "boss": [ + "The Needle", + 2000, + "Play only 1 hand" + ] + } + ], + "examples": [ + { + "sample": 0, + "reward": 64.3572, + "ending": "game_over", + "ante": 4, + "last_before": { + "phase": "hand", + "ante": 4, + "round": 11, + "money": 2, + "blind": { + "type": "big", + "score": [ + 2679, + 7500 + ], + "hands": 1, + "discards": 3 + }, + "boss": [ + "The Arm", + 10000, + "Decrease level of played poker hand" + ], + "hand": [ + "D_A", + "S_J", + "H_J", + "C_J", + "S_8", + "C_8", + "H_3", + "D_2" + ], + "jokers": { + "slots": "5/5", + "items": [ + { + "id": "j_sly", + "effect": "+50 Chips if played hand contains a Pair", + "sell": 1 + }, + { + "id": "j_hiker", + "effect": "Every played card permanently gains +5 Chips when scored", + "sell": 2 + }, + { + "id": "j_crafty", + "effect": "+80 Chips if played hand contains a Flush", + "sell": 2 + }, + { + "id": "j_clever", + "effect": "+80 Chips if played hand contains a Two Pair", + "sell": 2 + }, + { + "id": "j_splash", + "effect": "Every played card counts in scoring", + "sell": 1 + } + ] + }, + "consumables": { + "slots": "2/2", + "items": [ + { + "id": "c_sun", + "effect": "Converts up to 3 selected cards to Hearts", + "mod": { + "enhancement": "SUIT CONVERSION" + }, + "sell": 1 + }, + { + "id": "c_justice", + "effect": "Enhances 1 selected card into a Glass Card", + "mod": { + "enhancement": "ENHANCE" + }, + "sell": 1 + } + ] + }, + "hand_values": { + "Straight Flush": [ + 1, + 100, + 8 + ], + "Four of a Kind": [ + 1, + 60, + 7 + ], + "Full House": [ + 2, + 65, + 6 + ], + "Flush": [ + 1, + 35, + 4 + ], + "Straight": [ + 1, + 30, + 4 + ], + "Three of a Kind": [ + 1, + 30, + 3 + ], + "Two Pair": [ + 2, + 40, + 3 + ], + "Pair": [ + 2, + 25, + 3 + ], + "High Card": [ + 1, + 5, + 1 + ], + "Flush Five": [ + 1, + 160, + 16 + ], + "Flush House": [ + 1, + 140, + 14 + ], + "Five of a Kind": [ + 1, + 120, + 12 + ] + } + }, + "action": { + "method": "play", + "params": { + "cards": [ + 3, + 2, + 1, + 5, + 4 + ] + } + }, + "last_after": { + "phase": "GAME_OVER", + "blind": { + "type": "big", + "score": [ + 4155, + 7500 + ], + "hands": 0, + "discards": 3 + }, + "play_commit": { + "cards": [ + 3, + 2, + 1, + 5, + 4 + ], + "hand": "Full House", + "score": 1476 + } + } + }, + { + "sample": 52, + "reward": 104.9491, + "ending": "game_over", + "ante": 6, + "last_before": { + "phase": "hand", + "ante": 6, + "round": 17, + "money": 3, + "blind": { + "type": "big", + "score": [ + 28473, + 30000 + ], + "hands": 1, + "discards": 2 + }, + "boss": [ + "The Ox", + 40000, + "Playing a #1# sets money to $0" + ], + "hand": [ + "H_K", + "D_K", + "H_J", + "C_T", + "D_T", + "D_9", + "C_5", + "D_3" + ], + "jokers": { + "slots": "4/5", + "items": [ + { + "id": "j_madness", + "effect": "When Small Blind or Big Blind is selected, gain X0.5 Mult and destroy a random Joker (Currently X5.5 Mult)", + "sell": 3 + }, + { + "id": "j_swashbuckler", + "effect": "Adds the sell value of all other owned Jokers to Mult (Currently +8 Mult)", + "mod": { + "enhancement": "SET MULT" + }, + "sell": 2 + }, + { + "id": "j_clever", + "effect": "+80 Chips if played hand contains a Two Pair", + "sell": 2 + }, + { + "id": "j_rocket", + "effect": "Earn $1 at end of round Payout increases by $2 when Boss Blind is defeated", + "sell": 3 + } + ] + }, + "consumables": { + "slots": "2/3", + "items": [ + { + "id": "c_sun", + "effect": "Converts up to 3 selected cards to Hearts", + "mod": { + "enhancement": "SUIT CONVERSION" + }, + "sell": 1 + }, + { + "id": "c_chariot", + "effect": "Enhances 1 selected card into a Steel Card", + "mod": { + "enhancement": "ENHANCE" + }, + "sell": 1 + } + ] + }, + "hand_values": { + "Five of a Kind": [ + 1, + 120, + 12 + ], + "Straight Flush": [ + 1, + 100, + 8 + ], + "Four of a Kind": [ + 1, + 60, + 7 + ], + "Full House": [ + 2, + 65, + 6 + ], + "Flush": [ + 2, + 50, + 6 + ], + "Straight": [ + 1, + 30, + 4 + ], + "Three of a Kind": [ + 2, + 50, + 5 + ], + "High Card": [ + 1, + 5, + 1 + ], + "Pair": [ + 1, + 10, + 2 + ], + "Two Pair": [ + 5, + 100, + 6 + ], + "Flush Five": [ + 1, + 160, + 16 + ], + "Flush House": [ + 1, + 140, + 14 + ] + } + }, + "action": { + "method": "play", + "params": { + "cards": [ + 2, + 3, + 4, + 5, + 6 + ] + } + }, + "last_after": { + "phase": "GAME_OVER", + "blind": { + "type": "big", + "score": [ + 29043, + 30000 + ], + "hands": 0, + "discards": 2 + }, + "play_commit": { + "hand": "Pair", + "cards": [ + 2, + 3, + 4, + 5, + 6 + ], + "score": 570 + } + } + } + ], + "error_count": 7 + }, + "440": { + "rollout": 440, + "episodes": 64, + "reward": 26.462248784722224, + "endings": { + "game_over": 64 + }, + "antes": { + "2": 18, + "1": 26, + "3": 13, + "4": 7 + }, + "actions": { + "select": 339, + "play": 956, + "discard": 278, + "buy": 310, + "next_round": 275, + "pack": 84, + "use": 44 + }, + "played_hands": { + "Pair": 423, + "Three of a Kind": 71, + "High Card": 46, + "Two Pair": 344, + "Full House": 68, + "Straight": 2, + "Four of a Kind": 2 + }, + "pair_or_high_with_raw_straight_available": 59, + "affected_samples": 45, + "total_plays": 956, + "plays_including_debuffed_card": 48, + "losses_with_discards_left": 58, + "caps": [], + "groups": { + "3840": [ + { + "index": 0, + "reward": 28.67, + "ante": 2 + }, + { + "index": 1, + "reward": 0.69, + "ante": 1 + }, + { + "index": 2, + "reward": 0.52, + "ante": 1 + }, + { + "index": 3, + "reward": 20.67, + "ante": 2 + } + ], + "3841": [ + { + "index": 4, + "reward": 0.71, + "ante": 1 + }, + { + "index": 5, + "reward": 28.57, + "ante": 2 + }, + { + "index": 6, + "reward": 28.66, + "ante": 2 + }, + { + "index": 7, + "reward": 28.66, + "ante": 2 + } + ], + "3842": [ + { + "index": 8, + "reward": 46.17, + "ante": 3 + }, + { + "index": 9, + "reward": 48.17, + "ante": 3 + }, + { + "index": 10, + "reward": 48.17, + "ante": 3 + }, + { + "index": 11, + "reward": 40.4, + "ante": 3 + } + ], + "3843": [ + { + "index": 12, + "reward": 8.81, + "ante": 1 + }, + { + "index": 13, + "reward": 20.31, + "ante": 2 + }, + { + "index": 14, + "reward": 8.56, + "ante": 1 + }, + { + "index": 15, + "reward": 8.56, + "ante": 1 + } + ], + "3844": [ + { + "index": 16, + "reward": 40.68, + "ante": 3 + }, + { + "index": 17, + "reward": 64.22, + "ante": 4 + }, + { + "index": 18, + "reward": 44.68, + "ante": 3 + }, + { + "index": 19, + "reward": 8.57, + "ante": 1 + } + ], + "3845": [ + { + "index": 20, + "reward": 60.24, + "ante": 3 + }, + { + "index": 21, + "reward": 0.48, + "ante": 1 + }, + { + "index": 22, + "reward": 0.76, + "ante": 1 + }, + { + "index": 23, + "reward": 64.34, + "ante": 3 + } + ], + "3846": [ + { + "index": 24, + "reward": 0.67, + "ante": 1 + }, + { + "index": 25, + "reward": 0.67, + "ante": 1 + }, + { + "index": 26, + "reward": 0.67, + "ante": 1 + }, + { + "index": 27, + "reward": 0.67, + "ante": 1 + } + ], + "3847": [ + { + "index": 28, + "reward": 4.69, + "ante": 1 + }, + { + "index": 29, + "reward": 0.52, + "ante": 1 + }, + { + "index": 30, + "reward": 68.66, + "ante": 4 + }, + { + "index": 31, + "reward": 4.69, + "ante": 1 + } + ], + "3848": [ + { + "index": 32, + "reward": 44.49, + "ante": 3 + }, + { + "index": 33, + "reward": 64.37, + "ante": 4 + }, + { + "index": 34, + "reward": 44.49, + "ante": 3 + }, + { + "index": 35, + "reward": 42.83, + "ante": 3 + } + ], + "3849": [ + { + "index": 36, + "reward": 20.72, + "ante": 2 + }, + { + "index": 37, + "reward": 4.43, + "ante": 1 + }, + { + "index": 38, + "reward": 4.52, + "ante": 1 + }, + { + "index": 39, + "reward": 4.52, + "ante": 1 + } + ], + "3850": [ + { + "index": 40, + "reward": 0.72, + "ante": 1 + }, + { + "index": 41, + "reward": 28.49, + "ante": 2 + }, + { + "index": 42, + "reward": 0.61, + "ante": 1 + }, + { + "index": 43, + "reward": 62.4, + "ante": 4 + } + ], + "3851": [ + { + "index": 44, + "reward": 28.58, + "ante": 2 + }, + { + "index": 45, + "reward": 26.61, + "ante": 2 + }, + { + "index": 46, + "reward": 28.77, + "ante": 2 + }, + { + "index": 47, + "reward": 26.61, + "ante": 2 + } + ], + "3852": [ + { + "index": 48, + "reward": 0.67, + "ante": 1 + }, + { + "index": 49, + "reward": 4.74, + "ante": 1 + }, + { + "index": 50, + "reward": 0.51, + "ante": 1 + }, + { + "index": 51, + "reward": 4.74, + "ante": 1 + } + ], + "3853": [ + { + "index": 52, + "reward": 20.65, + "ante": 2 + }, + { + "index": 53, + "reward": 20.73, + "ante": 2 + }, + { + "index": 54, + "reward": 20.73, + "ante": 2 + }, + { + "index": 55, + "reward": 20.65, + "ante": 2 + } + ], + "3854": [ + { + "index": 56, + "reward": 84.68, + "ante": 4 + }, + { + "index": 57, + "reward": 88.36, + "ante": 4 + }, + { + "index": 58, + "reward": 68.45, + "ante": 3 + }, + { + "index": 59, + "reward": 88.28, + "ante": 4 + } + ], + "3855": [ + { + "index": 60, + "reward": 48.23, + "ante": 3 + }, + { + "index": 61, + "reward": 0.52, + "ante": 1 + }, + { + "index": 62, + "reward": 28.6, + "ante": 2 + }, + { + "index": 63, + "reward": 28.39, + "ante": 2 + } + ] + }, + "opportunity_examples": [ + { + "sample": 0, + "turn": 11, + "ante": 1, + "blind": { + "type": "big", + "score": [ + 0, + 450 + ], + "hands": 4, + "discards": 4 + }, + "hand": [ + "S_Q", + "C_Q", + "H_J", + "D_T", + "H_9", + "D_8", + "S_5", + "H_4" + ], + "action": { + "method": "play", + "params": { + "cards": [ + 2, + 3, + 5, + 6, + 7 + ] + } + }, + "commit": { + "score": 285, + "cards": [ + 2, + 3, + 5, + 6, + 7 + ], + "hand": "High Card" + }, + "straight": [ + 5, + 4, + 3, + 2, + 0 + ], + "jokers": [ + { + "id": "j_raised_fist", + "effect": "Adds double the rank of lowest ranked card held in hand to Mult", + "mod": { + "enhancement": "SOCIALIZED MULT" + }, + "sell": 2 + } + ], + "boss": [ + "The Hook", + 600, + "Discards 2 random cards per hand played" + ] + }, + { + "sample": 0, + "turn": 30, + "ante": 2, + "blind": { + "type": "big", + "score": [ + 0, + 1200 + ], + "hands": 4, + "discards": 4 + }, + "hand": [ + "S_A", + "D_A", + "C_T", + "D_9", + "C_8", + "D_8", + "S_7", + "S_6" + ], + "action": { + "method": "play", + "params": { + "cards": [ + 5, + 4, + 2, + 1, + 3 + ] + } + }, + "commit": { + "score": 364, + "cards": [ + 5, + 4, + 2, + 1, + 3 + ], + "hand": "Pair" + }, + "straight": [ + 7, + 6, + 4, + 3, + 2 + ], + "jokers": [ + { + "id": "j_raised_fist", + "effect": "Adds double the rank of lowest ranked card held in hand to Mult", + "mod": { + "enhancement": "SOCIALIZED MULT" + }, + "sell": 2 + }, + { + "id": "j_shoot_the_moon", + "effect": "Each Queen held in hand gives +13 Mult", + "sell": 2 + } + ], + "boss": [ + "The Psychic", + 1600, + "Must play 5 cards" + ] + }, + { + "sample": 0, + "turn": 41, + "ante": 2, + "blind": { + "type": "boss", + "score": [ + 820, + 1600 + ], + "hands": 2, + "discards": 3, + "effect": "Must play 5 cards" + }, + "hand": [ + "H_A", + "D_A", + "D_K", + "H_Q", + "H_J", + "S_T", + "C_8", + "S_3" + ], + "action": { + "method": "play", + "params": { + "cards": [ + 2, + 3, + 1, + 0, + 5 + ] + } + }, + "commit": { + "score": 256, + "cards": [ + 2, + 3, + 1, + 0, + 5 + ], + "hand": "Pair" + }, + "straight": [ + 5, + 4, + 3, + 2, + 0 + ], + "jokers": [ + { + "id": "j_raised_fist", + "effect": "Adds double the rank of lowest ranked card held in hand to Mult", + "mod": { + "enhancement": "SOCIALIZED MULT" + }, + "sell": 2 + }, + { + "id": "j_shoot_the_moon", + "effect": "Each Queen held in hand gives +13 Mult", + "sell": 2 + } + ], + "boss": [ + "The Psychic", + 1600, + "Must play 5 cards" + ] + } + ], + "examples": [ + { + "sample": 0, + "reward": 28.6725, + "ending": "game_over", + "ante": 2, + "last_before": { + "phase": "hand", + "ante": 2, + "round": 6, + "money": 3, + "blind": { + "type": "boss", + "score": [ + 1076, + 1600 + ], + "hands": 1, + "discards": 3, + "effect": "Must play 5 cards" + }, + "boss": [ + "The Psychic", + 1600, + "Must play 5 cards" + ], + "hand": [ + "S_A", + "S_J", + "H_J", + "C_8", + "S_7", + "C_5", + "D_5", + "S_3" + ], + "jokers": { + "slots": "2/5", + "items": [ + { + "id": "j_raised_fist", + "effect": "Adds double the rank of lowest ranked card held in hand to Mult", + "mod": { + "enhancement": "SOCIALIZED MULT" + }, + "sell": 2 + }, + { + "id": "j_shoot_the_moon", + "effect": "Each Queen held in hand gives +13 Mult", + "sell": 2 + } + ] + }, + "consumables": { + "slots": "2/2", + "items": [ + { + "id": "c_chariot", + "effect": "Enhances 1 selected card into a Steel Card", + "mod": { + "enhancement": "ENHANCE" + }, + "sell": 1 + }, + { + "id": "c_lovers", + "effect": "Enhances 1 selected card into a Wild Card", + "mod": { + "enhancement": "ENHANCE" + }, + "sell": 1 + } + ] + }, + "hand_values": { + "Five of a Kind": [ + 1, + 120, + 12 + ], + "Straight Flush": [ + 1, + 100, + 8 + ], + "Four of a Kind": [ + 1, + 60, + 7 + ], + "Full House": [ + 1, + 40, + 4 + ], + "Flush": [ + 1, + 35, + 4 + ], + "Straight": [ + 1, + 30, + 4 + ], + "Three of a Kind": [ + 1, + 30, + 3 + ], + "Two Pair": [ + 1, + 20, + 2 + ], + "Pair": [ + 1, + 10, + 2 + ], + "High Card": [ + 1, + 5, + 1 + ], + "Flush Five": [ + 1, + 160, + 16 + ], + "Flush House": [ + 1, + 140, + 14 + ] + } + }, + "action": { + "method": "play", + "params": { + "cards": [ + 6, + 5, + 2, + 1, + 3 + ] + } + }, + "last_after": { + "phase": "GAME_OVER", + "blind": { + "type": "boss", + "score": [ + 1476, + 1600 + ], + "hands": 0, + "discards": 3, + "effect": "Must play 5 cards" + }, + "play_commit": { + "score": 400, + "cards": [ + 6, + 5, + 2, + 1, + 3 + ], + "hand": "Two Pair" + } + } + }, + { + "sample": 57, + "reward": 88.3648, + "ending": "game_over", + "ante": 4, + "last_before": { + "phase": "hand", + "ante": 4, + "round": 15, + "money": 50, + "blind": { + "type": "boss", + "score": [ + 7296, + 20000 + ], + "hands": 1, + "discards": 4, + "effect": "Extra large blind" + }, + "boss": [ + "The Wall", + 20000, + "Extra large blind" + ], + "hand": [ + "S_K", + "C_K", + "C_Q", + "H_J", + "C_J", + "H_7", + "D_4", + "C_3" + ], + "jokers": { + "slots": "5/5", + "items": [ + { + "id": "j_mad", + "effect": "+10 Mult if played hand contains a Two Pair", + "mod": { + "enhancement": "TYPE MULT" + }, + "sell": 1 + }, + { + "id": "j_arrowhead", + "effect": "Played cards with Spade suit give +50 Chips when scored", + "sell": 2 + }, + { + "id": "j_banner", + "effect": "+30 Chips for each remaining discard", + "mod": { + "enhancement": "DISCARD CHIPS" + }, + "sell": 2 + }, + { + "id": "j_golden", + "effect": "Earn $4 at end of round", + "mod": { + "enhancement": "BONUS DOLLARS" + }, + "sell": 2 + }, + { + "id": "j_pareidolia", + "effect": "All cards are considered face cards", + "mod": { + "edition": "HOLO", + "enhancement": "ALL FACE CARDS" + }, + "sell": 3 + } + ] + }, + "consumables": { + "slots": "1/2", + "items": [ + { + "id": "c_venus", + "effect": "(lvl.1) Level up Three of a Kind +2 Mult and +20 chips", + "mod": { + "enhancement": "HAND UPGRADE" + }, + "sell": 1 + } + ] + }, + "hand_values": { + "Straight": [ + 1, + 30, + 4 + ], + "Three of a Kind": [ + 1, + 30, + 3 + ], + "Two Pair": [ + 3, + 60, + 4 + ], + "Pair": [ + 5, + 70, + 6 + ], + "High Card": [ + 1, + 5, + 1 + ], + "Flush Five": [ + 1, + 160, + 16 + ], + "Flush House": [ + 1, + 140, + 14 + ], + "Five of a Kind": [ + 1, + 120, + 12 + ], + "Straight Flush": [ + 1, + 100, + 8 + ], + "Four of a Kind": [ + 1, + 60, + 7 + ], + "Full House": [ + 2, + 65, + 6 + ], + "Flush": [ + 1, + 35, + 4 + ] + } + }, + "action": { + "method": "play", + "params": { + "cards": [ + 4, + 3, + 1, + 2, + 5 + ] + } + }, + "last_after": { + "phase": "GAME_OVER", + "blind": { + "type": "boss", + "score": [ + 10656, + 20000 + ], + "hands": 0, + "discards": 4, + "effect": "Extra large blind" + }, + "play_commit": { + "score": 3360, + "hand": "Pair", + "cards": [ + 4, + 3, + 1, + 2, + 5 + ] + } + } + } + ], + "error_count": 5 + }, + "449": { + "rollout": 449, + "episodes": 64, + "reward": 46.390621725063134, + "endings": { + "game_over": 62, + "context_cap": 2 + }, + "antes": { + "4": 19, + "5": 7, + "1": 14, + "6": 2, + "3": 12, + "2": 10 + }, + "actions": { + "select": 539, + "play": 1308, + "discard": 539, + "buy": 602, + "pack": 248, + "next_round": 475, + "use": 134, + "reroll": 1 + }, + "played_hands": { + "Pair": 503, + "Two Pair": 533, + "Three of a Kind": 129, + "Full House": 92, + "High Card": 39, + "Four of a Kind": 8, + "Straight": 4 + }, + "pair_or_high_with_raw_straight_available": 74, + "affected_samples": 41, + "total_plays": 1308, + "plays_including_debuffed_card": 121, + "losses_with_discards_left": 53, + "caps": [ + { + "sample": 8, + "ante": 6, + "turns": 125, + "reward": 104.79385, + "tokens": 48937, + "phase": "hand", + "remaining": { + "type": "boss", + "score": [ + 31754, + 40000 + ], + "hands": 1, + "discards": 3, + "effect": "No repeat hand types this round" + } + }, + { + "sample": 9, + "ante": 6, + "turns": 132, + "reward": 128.247125, + "tokens": 48456, + "phase": "hand", + "remaining": { + "type": "boss", + "score": [ + 9885, + 40000 + ], + "hands": 3, + "discards": 4, + "effect": "All Heart cards are debuffed" + } + } + ], + "groups": { + "3984": [ + { + "index": 0, + "reward": 82.52, + "ante": 4 + }, + { + "index": 1, + "reward": 60.69, + "ante": 4 + }, + { + "index": 2, + "reward": 84.55, + "ante": 4 + }, + { + "index": 3, + "reward": 60.6, + "ante": 4 + } + ], + "3985": [ + { + "index": 4, + "reward": 64.43, + "ante": 4 + }, + { + "index": 5, + "reward": 84.38, + "ante": 5 + }, + { + "index": 6, + "reward": 64.25, + "ante": 4 + }, + { + "index": 7, + "reward": 0.78, + "ante": 1 + } + ], + "3986": [ + { + "index": 8, + "reward": 104.79, + "ante": 6 + }, + { + "index": 9, + "reward": 128.25, + "ante": 6 + }, + { + "index": 10, + "reward": 0.91, + "ante": 1 + }, + { + "index": 11, + "reward": 0.91, + "ante": 1 + } + ], + "3987": [ + { + "index": 12, + "reward": 68.45, + "ante": 4 + }, + { + "index": 13, + "reward": 88.17, + "ante": 5 + }, + { + "index": 14, + "reward": 88.58, + "ante": 5 + }, + { + "index": 15, + "reward": 0.49, + "ante": 1 + } + ], + "3988": [ + { + "index": 16, + "reward": 84.65, + "ante": 5 + }, + { + "index": 17, + "reward": 0.72, + "ante": 1 + }, + { + "index": 18, + "reward": 88.51, + "ante": 5 + }, + { + "index": 19, + "reward": 48.56, + "ante": 3 + } + ], + "3989": [ + { + "index": 20, + "reward": 26.39, + "ante": 2 + }, + { + "index": 21, + "reward": 40.12, + "ante": 3 + }, + { + "index": 22, + "reward": 28.2, + "ante": 2 + }, + { + "index": 23, + "reward": 40.18, + "ante": 3 + } + ], + "3990": [ + { + "index": 24, + "reward": 40.62, + "ante": 3 + }, + { + "index": 25, + "reward": 20.68, + "ante": 2 + }, + { + "index": 26, + "reward": 48.62, + "ante": 3 + }, + { + "index": 27, + "reward": 20.63, + "ante": 2 + } + ], + "3991": [ + { + "index": 28, + "reward": 64.51, + "ante": 4 + }, + { + "index": 29, + "reward": 66.3, + "ante": 4 + }, + { + "index": 30, + "reward": 68.34, + "ante": 4 + }, + { + "index": 31, + "reward": 80.55, + "ante": 5 + } + ], + "3992": [ + { + "index": 32, + "reward": 4.46, + "ante": 1 + }, + { + "index": 33, + "reward": 48.45, + "ante": 3 + }, + { + "index": 34, + "reward": 24.46, + "ante": 2 + }, + { + "index": 35, + "reward": 46.6, + "ante": 3 + } + ], + "3993": [ + { + "index": 36, + "reward": 48.22, + "ante": 3 + }, + { + "index": 37, + "reward": 48.22, + "ante": 3 + }, + { + "index": 38, + "reward": 48.29, + "ante": 3 + }, + { + "index": 39, + "reward": 46.32, + "ante": 3 + } + ], + "3994": [ + { + "index": 40, + "reward": 8.36, + "ante": 1 + }, + { + "index": 41, + "reward": 8.36, + "ante": 1 + }, + { + "index": 42, + "reward": 8.36, + "ante": 1 + }, + { + "index": 43, + "reward": 8.36, + "ante": 1 + } + ], + "3995": [ + { + "index": 44, + "reward": 68.41, + "ante": 4 + }, + { + "index": 45, + "reward": 68.35, + "ante": 4 + }, + { + "index": 46, + "reward": 68.44, + "ante": 4 + }, + { + "index": 47, + "reward": 68.43, + "ante": 4 + } + ], + "3996": [ + { + "index": 48, + "reward": 20.49, + "ante": 2 + }, + { + "index": 49, + "reward": 64.56, + "ante": 4 + }, + { + "index": 50, + "reward": 64.88, + "ante": 4 + }, + { + "index": 51, + "reward": 68.88, + "ante": 4 + } + ], + "3997": [ + { + "index": 52, + "reward": 0.79, + "ante": 1 + }, + { + "index": 53, + "reward": 4.65, + "ante": 1 + }, + { + "index": 54, + "reward": 4.65, + "ante": 1 + }, + { + "index": 55, + "reward": 60.77, + "ante": 4 + } + ], + "3998": [ + { + "index": 56, + "reward": 80.27, + "ante": 5 + }, + { + "index": 57, + "reward": 68.71, + "ante": 4 + }, + { + "index": 58, + "reward": 44.21, + "ante": 3 + }, + { + "index": 59, + "reward": 0.55, + "ante": 1 + } + ], + "3999": [ + { + "index": 60, + "reward": 28.18, + "ante": 2 + }, + { + "index": 61, + "reward": 28.18, + "ante": 2 + }, + { + "index": 62, + "reward": 28.39, + "ante": 2 + }, + { + "index": 63, + "reward": 28.39, + "ante": 2 + } + ] + }, + "opportunity_examples": [ + { + "sample": 0, + "turn": 81, + "ante": 4, + "blind": { + "type": "big", + "score": [ + 0, + 7500 + ], + "hands": 3, + "discards": 5 + }, + "hand": [ + "S_K", + "H_K", + "H_T", + "H_9", + "S_6", + "S_5", + "D_4", + "H_3", + "S_2" + ], + "action": { + "method": "play", + "params": { + "cards": [ + 5, + 4, + 1, + 0, + 6 + ] + } + }, + "commit": { + "cards": [ + 5, + 4, + 1, + 0, + 6 + ], + "score": 1260, + "hand": "Pair" + }, + "straight": [ + 8, + 7, + 6, + 5, + 4 + ], + "jokers": [ + { + "id": "j_abstract", + "effect": "+3 Mult for each Joker card (Currently +15 Mult)", + "mod": { + "enhancement": "JOKER MULT" + }, + "sell": 2 + }, + { + "id": "j_8_ball", + "effect": "1 in 4 chance for each played 8 to create a Tarot card when scored (Must have room)", + "mod": { + "edition": "HOLO", + "enhancement": "SPAWN TAROT" + }, + "sell": 4 + }, + { + "id": "j_riff_raff", + "effect": "When Blind is selected, create 2 Common Jokers (Must have room)", + "sell": 3 + }, + { + "id": "j_juggler", + "effect": "+1 hand size", + "mod": { + "enhancement": "HAND SIZE" + }, + "sell": 2 + }, + { + "id": "j_business", + "effect": "Played face cards have a 1 in 2 chance to give $2 when scored", + "mod": { + "enhancement": "FACE DOLLAR CHANCE" + }, + "sell": 2 + } + ], + "boss": [ + "The Eye", + 10000, + "No repeat hand types this round" + ] + }, + { + "sample": 2, + "turn": 83, + "ante": 4, + "blind": { + "type": "big", + "score": [ + 0, + 7500 + ], + "hands": 3, + "discards": 5 + }, + "hand": [ + "S_K", + "H_K", + "H_T", + "H_9", + "S_6", + "S_5", + "D_4", + "H_3", + "S_2" + ], + "action": { + "method": "play", + "params": { + "cards": [ + 3, + 4, + 1, + 0, + 5 + ] + } + }, + "commit": { + "cards": [ + 3, + 4, + 1, + 0, + 5 + ], + "score": 2160, + "hand": "Pair" + }, + "straight": [ + 8, + 7, + 6, + 5, + 4 + ], + "jokers": [ + { + "id": "j_abstract", + "effect": "+3 Mult for each Joker card (Currently +15 Mult)", + "mod": { + "enhancement": "JOKER MULT" + }, + "sell": 2 + }, + { + "id": "j_8_ball", + "effect": "1 in 4 chance for each played 8 to create a Tarot card when scored (Must have room)", + "mod": { + "edition": "HOLO", + "enhancement": "SPAWN TAROT" + }, + "sell": 4 + }, + { + "id": "j_riff_raff", + "effect": "When Blind is selected, create 2 Common Jokers (Must have room)", + "sell": 3 + }, + { + "id": "j_juggler", + "effect": "+1 hand size", + "mod": { + "enhancement": "HAND SIZE" + }, + "sell": 2 + }, + { + "id": "j_supernova", + "effect": "Adds the number of times poker hand has been played this run to Mult", + "mod": { + "enhancement": "HAND PLAYED MULT" + }, + "sell": 2 + } + ], + "boss": [ + "The Eye", + 10000, + "No repeat hand types this round" + ] + }, + { + "sample": 3, + "turn": 51, + "ante": 3, + "blind": { + "type": "boss", + "score": [ + 3672, + 4000 + ], + "hands": 1, + "discards": 4, + "effect": "Decrease level of played poker hand" + }, + "hand": [ + "H_A", + "H_T", + "D_9", + "S_8", + "H_8", + "C_7", + "S_5", + "S_4", + "D_3", + "D_2" + ], + "action": { + "method": "play", + "params": { + "cards": [ + 4, + 3, + 5, + 6, + 7 + ] + } + }, + "commit": { + "hand": "Pair", + "score": 1312, + "cards": [ + 4, + 3, + 5, + 6, + 7 + ] + }, + "straight": [ + 0, + 9, + 8, + 7, + 6 + ], + "jokers": [ + { + "id": "j_abstract", + "effect": "+3 Mult for each Joker card (Currently +15 Mult)", + "mod": { + "enhancement": "JOKER MULT" + }, + "sell": 2 + }, + { + "id": "j_8_ball", + "effect": "1 in 4 chance for each played 8 to create a Tarot card when scored (Must have room)", + "mod": { + "enhancement": "SPAWN TAROT", + "edition": "HOLO" + }, + "sell": 4 + }, + { + "id": "j_popcorn", + "effect": "+4 Mult -4 Mult per round played", + "sell": 2 + }, + { + "id": "j_gluttenous_joker", + "effect": "Played cards with Club suit give +3 Mult when scored", + "mod": { + "enhancement": "SUIT MULT" + }, + "sell": 2 + }, + { + "id": "j_troubadour", + "effect": "+2 hand size, -1 hand each round", + "mod": { + "enhancement": "HAND SIZE, PLAYS" + }, + "sell": 3 + } + ], + "boss": [ + "The Arm", + 4000, + "Decrease level of played poker hand" + ] + } + ], + "examples": [ + { + "sample": 0, + "reward": 82.52373333333333, + "ending": "game_over", + "ante": 4, + "last_before": { + "phase": "hand", + "ante": 4, + "round": 14, + "money": 9, + "blind": { + "type": "big", + "score": [ + 3928, + 7500 + ], + "hands": 1, + "discards": 5 + }, + "boss": [ + "The Eye", + 10000, + "No repeat hand types this round" + ], + "hand": [ + "D_A", + "S_Q", + "H_Q", + "D_T", + "D_5", + "H_3", + "D_3", + "S_2", + "H_2" + ], + "jokers": { + "slots": "5/5", + "items": [ + { + "id": "j_abstract", + "effect": "+3 Mult for each Joker card (Currently +15 Mult)", + "mod": { + "enhancement": "JOKER MULT" + }, + "sell": 2 + }, + { + "id": "j_8_ball", + "effect": "1 in 4 chance for each played 8 to create a Tarot card when scored (Must have room)", + "mod": { + "edition": "HOLO", + "enhancement": "SPAWN TAROT" + }, + "sell": 4 + }, + { + "id": "j_riff_raff", + "effect": "When Blind is selected, create 2 Common Jokers (Must have room)", + "sell": 3 + }, + { + "id": "j_juggler", + "effect": "+1 hand size", + "mod": { + "enhancement": "HAND SIZE" + }, + "sell": 2 + }, + { + "id": "j_business", + "effect": "Played face cards have a 1 in 2 chance to give $2 when scored", + "mod": { + "enhancement": "FACE DOLLAR CHANCE" + }, + "sell": 2 + } + ] + }, + "consumables": { + "slots": "2/2", + "items": [ + { + "id": "c_devil", + "effect": "Enhances 1 selected card into a Gold Card", + "mod": { + "enhancement": "ENHANCE" + }, + "sell": 1 + }, + { + "id": "c_death", + "effect": "Select 2 cards, convert the left card into the right card (Drag to rearrange)", + "mod": { + "enhancement": "CARD CONVERSION" + }, + "sell": 1 + } + ] + }, + "hand_values": { + "Five of a Kind": [ + 1, + 120, + 12 + ], + "Straight Flush": [ + 1, + 100, + 8 + ], + "Four of a Kind": [ + 1, + 60, + 7 + ], + "Full House": [ + 1, + 40, + 4 + ], + "Flush": [ + 1, + 35, + 4 + ], + "Straight": [ + 1, + 30, + 4 + ], + "Three of a Kind": [ + 3, + 70, + 7 + ], + "Two Pair": [ + 3, + 60, + 4 + ], + "Pair": [ + 2, + 25, + 3 + ], + "High Card": [ + 1, + 5, + 1 + ], + "Flush Five": [ + 1, + 160, + 16 + ], + "Flush House": [ + 1, + 140, + 14 + ] + } + }, + "action": { + "method": "play", + "params": { + "cards": [ + 6, + 5, + 7, + 3, + 2 + ] + } + }, + "last_after": { + "phase": "GAME_OVER", + "blind": { + "type": "big", + "score": [ + 4796, + 7500 + ], + "hands": 0, + "discards": 5 + }, + "play_commit": { + "cards": [ + 6, + 5, + 7, + 3, + 2 + ], + "score": 868, + "hand": "Pair" + } + } + }, + { + "sample": 9, + "reward": 128.247125, + "ending": "context_cap", + "ante": 6, + "last_before": { + "phase": "hand", + "ante": 6, + "round": 21, + "money": 36, + "blind": { + "type": "boss", + "score": [ + 2325, + 40000 + ], + "hands": 4, + "discards": 4, + "effect": "All Heart cards are debuffed" + }, + "boss": [ + "The Head", + 40000, + "All Heart cards are debuffed" + ], + "hand": [ + "S_A", + { + "id": "H_A", + "debuff": true + }, + "C_A", + "C_K", + "D_K", + "S_J", + { + "id": "H_J", + "debuff": true + }, + "D_2" + ], + "jokers": { + "slots": "5/5", + "items": [ + { + "id": "j_raised_fist", + "effect": "Adds double the rank of lowest ranked card held in hand to Mult", + "mod": { + "enhancement": "SOCIALIZED MULT", + "edition": "HOLO" + }, + "sell": 4 + }, + { + "id": "j_mad", + "effect": "+10 Mult if played hand contains a Two Pair", + "mod": { + "enhancement": "TYPE MULT" + }, + "sell": 2 + }, + { + "id": "j_loyalty_card", + "effect": "X4 Mult every 6 hands played 1 remaining", + "mod": { + "enhancement": "1 IN 10 MULT", + "edition": "FOIL" + }, + "sell": 3 + }, + { + "id": "j_wrathful_joker", + "effect": "Played cards with Spade suit give +3 Mult when scored", + "mod": { + "enhancement": "SUIT MULT" + }, + "sell": 2 + }, + { + "id": "j_abstract", + "effect": "+3 Mult for each Joker card (Currently +15 Mult)", + "mod": { + "enhancement": "JOKER MULT" + }, + "sell": 2 + } + ] + }, + "consumables": { + "slots": "3/3", + "items": [ + { + "id": "c_justice", + "effect": "Enhances 1 selected card into a Glass Card", + "mod": { + "enhancement": "ENHANCE" + }, + "sell": 1 + }, + { + "id": "c_devil", + "effect": "Enhances 1 selected card into a Gold Card", + "mod": { + "enhancement": "ENHANCE" + }, + "sell": 1 + }, + { + "id": "c_magician", + "effect": "Enhances 2 selected cards to Lucky Cards", + "mod": { + "enhancement": "ENHANCE" + }, + "sell": 1 + } + ] + }, + "hand_values": { + "Straight Flush": [ + 2, + 140, + 12 + ], + "Four of a Kind": [ + 1, + 60, + 7 + ], + "Full House": [ + 5, + 140, + 12 + ], + "Flush": [ + 1, + 35, + 4 + ], + "Straight": [ + 1, + 30, + 4 + ], + "Three of a Kind": [ + 3, + 70, + 7 + ], + "Two Pair": [ + 2, + 40, + 3 + ], + "Pair": [ + 3, + 40, + 4 + ], + "High Card": [ + 2, + 15, + 2 + ], + "Flush Five": [ + 1, + 160, + 16 + ], + "Flush House": [ + 1, + 140, + 14 + ], + "Five of a Kind": [ + 1, + 120, + 12 + ] + } + }, + "action": { + "method": "play", + "params": { + "cards": [ + 4, + 3, + 6, + 5, + 7 + ] + } + }, + "last_after": { + "phase": "hand", + "blind": { + "type": "boss", + "score": [ + 9885, + 40000 + ], + "hands": 3, + "discards": 4, + "effect": "All Heart cards are debuffed" + }, + "play_commit": { + "hand": "Two Pair", + "score": 7560, + "cards": [ + 4, + 3, + 6, + 5, + 7 + ] + } + } + } + ], + "error_count": 9 + } + }, + "optimizer_metrics_steps_425_449": [ + { + "train/loss": -0.21641286656580772, + "train/pg_loss": -0.21676085531407555, + "train/entropy_loss": 0.026850530799451603, + "train/pg_clipfrac": 0.0, + "train/ppo_kl": 0.0, + "train/kl_loss": 0.37483927906728187, + "train/grad_norm": 1.556913919042798, + "train/lr-pg_0": 1e-06, + "train/lr-pg_1": 1e-06, + "train/global_batch_size": 64, + "train/step": 425 + }, + { + "train/loss": -0.25290070317928504, + "train/pg_loss": -0.2532545805474411, + "train/entropy_loss": 0.026693489603644052, + "train/pg_clipfrac": 0.0, + "train/ppo_kl": 0.0, + "train/kl_loss": 0.3805470976793488, + "train/grad_norm": 1.4719941854310257, + "train/lr-pg_0": 1e-06, + "train/lr-pg_1": 1e-06, + "train/global_batch_size": 64, + "train/step": 426 + }, + { + "train/loss": -0.09779988420306737, + "train/pg_loss": -0.09818589899198055, + "train/entropy_loss": 0.024846588711212557, + "train/pg_clipfrac": 0.0, + "train/ppo_kl": 0.0, + "train/kl_loss": 0.410858464691377, + "train/grad_norm": 1.3478951505017798, + "train/lr-pg_0": 1e-06, + "train/lr-pg_1": 1e-06, + "train/global_batch_size": 64, + "train/step": 427 + }, + { + "train/loss": -0.2005713855381584, + "train/pg_loss": -0.2009324411389266, + "train/entropy_loss": 0.023568182585306324, + "train/pg_clipfrac": 0.0, + "train/ppo_kl": 0.0, + "train/kl_loss": 0.3846095476680247, + "train/grad_norm": 1.132750147714902, + "train/lr-pg_0": 1e-06, + "train/lr-pg_1": 1e-06, + "train/global_batch_size": 64, + "train/step": 428 + }, + { + "train/loss": -0.2632190098633299, + "train/pg_loss": -0.2635800620884814, + "train/entropy_loss": 0.02376489410876715, + "train/pg_clipfrac": 0.0, + "train/ppo_kl": 0.0, + "train/kl_loss": 0.38480287276042074, + "train/grad_norm": 1.3758376777683539, + "train/lr-pg_0": 1e-06, + "train/lr-pg_1": 1e-06, + "train/global_batch_size": 64, + "train/step": 429 + }, + { + "train/loss": -0.189753767478996, + "train/pg_loss": -0.19009753564223683, + "train/entropy_loss": 0.023164339633575354, + "train/pg_clipfrac": 0.0, + "train/ppo_kl": 0.0, + "train/kl_loss": 0.3669177902889512, + "train/grad_norm": 1.211287269530679, + "train/lr-pg_0": 1e-06, + "train/lr-pg_1": 1e-06, + "train/global_batch_size": 64, + "train/step": 430 + }, + { + "train/loss": -0.17889164902430044, + "train/pg_loss": -0.1792404731222386, + "train/entropy_loss": 0.022999692217415317, + "train/pg_clipfrac": 0.0, + "train/ppo_kl": 0.0, + "train/kl_loss": 0.37180209867452135, + "train/grad_norm": 1.5390977419773382, + "train/lr-pg_0": 1e-06, + "train/lr-pg_1": 1e-06, + "train/global_batch_size": 64, + "train/step": 431 + }, + { + "train/loss": -0.1417064817028738, + "train/pg_loss": -0.14206255764107117, + "train/entropy_loss": 0.023387909109281776, + "train/pg_clipfrac": 0.0, + "train/ppo_kl": 0.0, + "train/kl_loss": 0.37945472969895705, + "train/grad_norm": 1.2984481370400687, + "train/lr-pg_0": 1e-06, + "train/lr-pg_1": 1e-06, + "train/global_batch_size": 64, + "train/step": 432 + }, + { + "train/loss": -0.1428134509899688, + "train/pg_loss": -0.14316571841617512, + "train/entropy_loss": 0.02459065635967693, + "train/pg_clipfrac": 0.0, + "train/ppo_kl": 0.0, + "train/kl_loss": 0.37683275921716697, + "train/grad_norm": 1.6206478378858158, + "train/lr-pg_0": 1e-06, + "train/lr-pg_1": 1e-06, + "train/global_batch_size": 64, + "train/step": 433 + }, + { + "train/loss": -0.19920421873860295, + "train/pg_loss": -0.19956531583554182, + "train/entropy_loss": 0.026840993880344464, + "train/pg_clipfrac": 0.0, + "train/ppo_kl": 0.0, + "train/kl_loss": 0.3879405631519123, + "train/grad_norm": 1.4545304259694263, + "train/lr-pg_0": 1e-06, + "train/lr-pg_1": 1e-06, + "train/global_batch_size": 64, + "train/step": 434 + }, + { + "train/loss": -0.17250839789225073, + "train/pg_loss": -0.17285668573581572, + "train/entropy_loss": 0.025975256667529232, + "train/pg_clipfrac": 0.0, + "train/ppo_kl": 0.0, + "train/kl_loss": 0.3742617272316552, + "train/grad_norm": 1.4612392990986611, + "train/lr-pg_0": 1e-06, + "train/lr-pg_1": 1e-06, + "train/global_batch_size": 64, + "train/step": 435 + }, + { + "train/loss": -0.2046804181032993, + "train/pg_loss": -0.20501417527025975, + "train/entropy_loss": 0.029466365412637613, + "train/pg_clipfrac": 0.0, + "train/ppo_kl": 0.0, + "train/kl_loss": 0.36323230457475675, + "train/grad_norm": 1.7085359344677757, + "train/lr-pg_0": 1e-06, + "train/lr-pg_1": 1e-06, + "train/global_batch_size": 64, + "train/step": 436 + }, + { + "train/loss": -0.2769795887647989, + "train/pg_loss": -0.27733529720043276, + "train/entropy_loss": 0.03131602225719658, + "train/pg_clipfrac": 0.0, + "train/ppo_kl": 0.0, + "train/kl_loss": 0.38705226983676994, + "train/grad_norm": 1.6940604653809797, + "train/lr-pg_0": 1e-06, + "train/lr-pg_1": 1e-06, + "train/global_batch_size": 64, + "train/step": 437 + }, + { + "train/loss": -0.21127858486526344, + "train/pg_loss": -0.2116431410062651, + "train/entropy_loss": 0.03200130891719563, + "train/pg_clipfrac": 0.0, + "train/ppo_kl": 0.0, + "train/kl_loss": 0.3965430174099619, + "train/grad_norm": 1.8807736829843311, + "train/lr-pg_0": 1e-06, + "train/lr-pg_1": 1e-06, + "train/global_batch_size": 64, + "train/step": 438 + }, + { + "train/loss": -0.19637107101496615, + "train/pg_loss": -0.19673552752702222, + "train/entropy_loss": 0.035695656077399336, + "train/pg_clipfrac": 0.0, + "train/ppo_kl": 0.0, + "train/kl_loss": 0.40016055706268133, + "train/grad_norm": 1.5856371064225763, + "train/lr-pg_0": 1e-06, + "train/lr-pg_1": 1e-06, + "train/global_batch_size": 64, + "train/step": 439 + }, + { + "train/loss": -0.33900399780766743, + "train/pg_loss": -0.33935344290505953, + "train/entropy_loss": 0.037306210830156526, + "train/pg_clipfrac": 0.0, + "train/ppo_kl": 0.0, + "train/kl_loss": 0.3867309839986664, + "train/grad_norm": 2.1157921278513134, + "train/lr-pg_0": 1e-06, + "train/lr-pg_1": 1e-06, + "train/global_batch_size": 64, + "train/step": 440 + }, + { + "train/loss": -0.2976195042988649, + "train/pg_loss": -0.29795051069450096, + "train/entropy_loss": 0.03832477462661858, + "train/pg_clipfrac": 0.0, + "train/ppo_kl": 0.0, + "train/kl_loss": 0.36929096723855737, + "train/grad_norm": 1.7121164101123858, + "train/lr-pg_0": 1e-06, + "train/lr-pg_1": 1e-06, + "train/global_batch_size": 64, + "train/step": 441 + }, + { + "train/loss": -0.31404900958893645, + "train/pg_loss": -0.3143895102929619, + "train/entropy_loss": 0.04131917257305629, + "train/pg_clipfrac": 0.0, + "train/ppo_kl": 0.0, + "train/kl_loss": 0.3818241269947389, + "train/grad_norm": 1.5922104374334893, + "train/lr-pg_0": 1e-06, + "train/lr-pg_1": 1e-06, + "train/global_batch_size": 64, + "train/step": 442 + }, + { + "train/loss": -0.23800103892900312, + "train/pg_loss": -0.23833649810099633, + "train/entropy_loss": 0.042505249016730466, + "train/pg_clipfrac": 0.0, + "train/ppo_kl": 0.0, + "train/kl_loss": 0.37794794852658375, + "train/grad_norm": 1.7267299242963767, + "train/lr-pg_0": 1e-06, + "train/lr-pg_1": 1e-06, + "train/global_batch_size": 64, + "train/step": 443 + }, + { + "train/loss": -0.27410861749795423, + "train/pg_loss": -0.27445419467147675, + "train/entropy_loss": 0.04275795377148075, + "train/pg_clipfrac": 0.0, + "train/ppo_kl": 0.0, + "train/kl_loss": 0.3883337044438457, + "train/grad_norm": 1.6521907943020282, + "train/lr-pg_0": 1e-06, + "train/lr-pg_1": 1e-06, + "train/global_batch_size": 64, + "train/step": 444 + }, + { + "train/loss": -0.23894212135518872, + "train/pg_loss": -0.23928473406332756, + "train/entropy_loss": 0.04330627421638343, + "train/pg_clipfrac": 0.0, + "train/ppo_kl": 0.0, + "train/kl_loss": 0.3859352525052868, + "train/grad_norm": 1.5906632394447295, + "train/lr-pg_0": 1e-06, + "train/lr-pg_1": 1e-06, + "train/global_batch_size": 64, + "train/step": 445 + }, + { + "train/loss": -0.2720324010924771, + "train/pg_loss": -0.27236221069470984, + "train/entropy_loss": 0.044016578088856485, + "train/pg_clipfrac": 0.0, + "train/ppo_kl": 0.0, + "train/kl_loss": 0.37381386402494216, + "train/grad_norm": 1.641423276425294, + "train/lr-pg_0": 1e-06, + "train/lr-pg_1": 1e-06, + "train/global_batch_size": 64, + "train/step": 446 + }, + { + "train/loss": -0.42918934163696715, + "train/pg_loss": -0.4295173803532614, + "train/entropy_loss": 0.04166895825888049, + "train/pg_clipfrac": 0.0, + "train/ppo_kl": 0.0, + "train/kl_loss": 0.36969821814968573, + "train/grad_norm": 1.4649065741736327, + "train/lr-pg_0": 1e-06, + "train/lr-pg_1": 1e-06, + "train/global_batch_size": 64, + "train/step": 447 + }, + { + "train/loss": -0.2181644219873482, + "train/pg_loss": -0.21850880750722468, + "train/entropy_loss": 0.04093448836954278, + "train/pg_clipfrac": 0.0, + "train/ppo_kl": 0.0, + "train/kl_loss": 0.38532232643547665, + "train/grad_norm": 1.3982791917585196, + "train/lr-pg_0": 1e-06, + "train/lr-pg_1": 1e-06, + "train/global_batch_size": 64, + "train/step": 448 + }, + { + "train/loss": -0.31235448297694496, + "train/pg_loss": -0.31269035147088176, + "train/entropy_loss": 0.03963022837887993, + "train/pg_clipfrac": 0.0, + "train/ppo_kl": 0.0, + "train/kl_loss": 0.37553762350915715, + "train/grad_norm": 1.3689244163552206, + "train/lr-pg_0": 1e-06, + "train/lr-pg_1": 1e-06, + "train/global_batch_size": 64, + "train/step": 449 + } + ], + "failure_log_excerpts": [ + "2026-09-15 03:51:53-04:00 (MegatronTrainRayActor pid=15329) [2026-09-15 07:51:52.360146] saving checkpoint at iteration 449 to /checkpoints/broad-layover-3a0ce678e7da in torch_dist format", + "2026-09-15 03:52:47-04:00 (MegatronTrainRayActor pid=15329) [2026-09-15 07:52:45.419580] successfully saved checkpoint from iteration 449 to /checkpoints/broad-layover-3a0ce678e7da [ t 1/4, p 1/2 ]", + "2026-09-15 03:54:04-04:00 (MegatronTrainRayActor pid=15797) File \"ras/peers.cc\", line 549, in rasMsgHandlePeersUpdate(rasMsg*, rasSocket*)", + "2026-09-15 03:54:05-04:00 (MegatronTrainRayActor pid=4714, ip=10.100.0.3) File \"ras/peers.cc\", line 549, in rasMsgHandlePeersUpdate(rasMsg*, rasSocket*)", + "2026-09-15 03:54:14-04:00 Ray job raysubmit_cMPrxHRXqyvPZ24E finished with status: FAILED: Job entrypoint command failed with exit code 1, last available logs (truncated to 20,000 chars):", + "2026-09-15 03:54:14-04:00 (MegatronTrainRayActor pid=4714, ip=10.100.0.3) File \"ras/peers.cc\", line 549, in rasMsgHandlePeersUpdate(rasMsg*, rasSocket*)", + "2026-09-15 03:54:21-04:00 (MegatronTrainRayActor pid=4714, ip=10.100.0.3) File \"ras/peers.cc\", line 549, in rasMsgHandlePeersUpdate(rasMsg*, rasSocket*)", + "2026-09-15 03:57:24-04:00 WARNING: training run broad-layover-3a0ce678e7da is retrying after preemption or interruption (attempt 2).", + "2026-09-15 04:06:10-04:00 FileNotFoundError: [Errno 2] No such file or directory: '/checkpoints/broad-layover-3a0ce678e7da/iter_0000449/__32_1.distcp'", + "2026-09-15 04:06:10-04:00 FileNotFoundError: [Errno 2] No such file or directory: '/checkpoints/broad-layover-3a0ce678e7da/iter_0000449/__33_1.distcp'", + "2026-09-15 04:06:10-04:00 FileNotFoundError: [Errno 2] No such file or directory: '/checkpoints/broad-layover-3a0ce678e7da/iter_0000449/__34_1.distcp'", + "2026-09-15 04:06:11-04:00 FileNotFoundError: [Errno 2] No such file or directory: '/checkpoints/broad-layover-3a0ce678e7da/iter_0000449/__35_1.distcp'", + "2026-09-15 04:06:16-04:00 Ray job raysubmit_LadGCU76J5BKm2jj finished with status: FAILED: Job entrypoint command failed with exit code 1, last available logs (truncated to 20,000 chars):", + "2026-09-15 04:06:16-04:00 FileNotFoundError: [Errno 2] No such file or directory: '/checkpoints/broad-layover-3a0ce678e7da/iter_0000449/__35_1.distcp'", + "2026-09-15 04:06:21-04:00 FileNotFoundError: [Errno 2] No such file or directory: '/checkpoints/broad-layover-3a0ce678e7da/iter_0000449/__35_1.distcp'", + "2026-09-15 04:07:14-04:00 WARNING: training run broad-layover-3a0ce678e7da is retrying after preemption or interruption (attempt 3).", + "2026-09-15 04:17:28-04:00 FileNotFoundError: [Errno 2] No such file or directory: '/checkpoints/broad-layover-3a0ce678e7da/iter_0000449/__52_1.distcp'", + "2026-09-15 04:17:28-04:00 FileNotFoundError: [Errno 2] No such file or directory: '/checkpoints/broad-layover-3a0ce678e7da/iter_0000449/__52_1.distcp'", + "2026-09-15 04:17:28-04:00 FileNotFoundError: [Errno 2] No such file or directory: '/checkpoints/broad-layover-3a0ce678e7da/iter_0000449/__52_1.distcp'", + "2026-09-15 04:17:28-04:00 FileNotFoundError: [Errno 2] No such file or directory: '/checkpoints/broad-layover-3a0ce678e7da/iter_0000449/__44_1.distcp'", + "2026-09-15 04:17:28-04:00 FileNotFoundError: [Errno 2] No such file or directory: '/checkpoints/broad-layover-3a0ce678e7da/iter_0000449/__44_1.distcp'", + "2026-09-15 04:17:28-04:00 FileNotFoundError: [Errno 2] No such file or directory: '/checkpoints/broad-layover-3a0ce678e7da/iter_0000449/__44_1.distcp'", + "2026-09-15 04:17:28-04:00 OSError: [Errno 22] Invalid argument", + "2026-09-15 04:17:28-04:00 FileNotFoundError: [Errno 2] No such file or directory: '/checkpoints/broad-layover-3a0ce678e7da/iter_0000449/__48_1.distcp'", + "2026-09-15 04:17:28-04:00 FileNotFoundError: [Errno 2] No such file or directory: '/checkpoints/broad-layover-3a0ce678e7da/iter_0000449/__48_1.distcp'", + "2026-09-15 04:17:28-04:00 FileNotFoundError: [Errno 2] No such file or directory: '/checkpoints/broad-layover-3a0ce678e7da/iter_0000449/__48_1.distcp'", + "2026-09-15 04:17:28-04:00 OSError: [Errno 22] Invalid argument", + "2026-09-15 04:17:28-04:00 OSError: [Errno 22] Invalid argument", + "2026-09-15 04:17:28-04:00 OSError: [Errno 22] Invalid argument", + "2026-09-15 04:17:28-04:00 OSError: [Errno 22] Invalid argument", + "2026-09-15 04:17:28-04:00 FileNotFoundError: [Errno 2] No such file or directory: '/checkpoints/broad-layover-3a0ce678e7da/iter_0000449/__48_1.distcp'", + "2026-09-15 04:17:28-04:00 OSError: [Errno 22] Invalid argument", + "2026-09-15 04:17:28-04:00 OSError: [Errno 22] Invalid argument", + "2026-09-15 04:17:28-04:00 OSError: [Errno 22] Invalid argument", + "2026-09-15 04:17:28-04:00 OSError: [Errno 22] Invalid argument", + "2026-09-15 04:17:28-04:00 FileNotFoundError: [Errno 2] No such file or directory: '/checkpoints/broad-layover-3a0ce678e7da/iter_0000449/__44_1.distcp'", + "2026-09-15 04:17:28-04:00 FileNotFoundError: [Errno 2] No such file or directory: '/checkpoints/broad-layover-3a0ce678e7da/iter_0000449/__44_1.distcp'", + "2026-09-15 04:17:28-04:00 FileNotFoundError: [Errno 2] No such file or directory: '/checkpoints/broad-layover-3a0ce678e7da/iter_0000449/__44_1.distcp'", + "2026-09-15 04:17:28-04:00 OSError: [Errno 22] Invalid argument", + "2026-09-15 04:17:28-04:00 OSError: [Errno 22] Invalid argument", + "2026-09-15 04:17:28-04:00 OSError: [Errno 22] Invalid argument", + "2026-09-15 04:17:28-04:00 FileNotFoundError: [Errno 2] No such file or directory: '/checkpoints/broad-layover-3a0ce678e7da/iter_0000449/__44_1.distcp'", + "2026-09-15 04:17:28-04:00 FileNotFoundError: [Errno 2] No such file or directory: '/checkpoints/broad-layover-3a0ce678e7da/iter_0000449/__44_1.distcp'", + "2026-09-15 04:17:29-04:00 FileNotFoundError: [Errno 2] No such file or directory: '/checkpoints/broad-layover-3a0ce678e7da/iter_0000449/__44_1.distcp'", + "2026-09-15 04:17:32-04:00 Ray job raysubmit_K5cNJyjjLwfUnixe finished with status: FAILED: Job entrypoint command failed with exit code 1, last available logs (truncated to 20,000 chars):", + "2026-09-15 04:17:32-04:00 FileNotFoundError: [Errno 2] No such file or directory: '/checkpoints/broad-layover-3a0ce678e7da/iter_0000449/__44_1.distcp'", + "2026-09-15 04:17:38-04:00 FileNotFoundError: [Errno 2] No such file or directory: '/checkpoints/broad-layover-3a0ce678e7da/iter_0000449/__44_1.distcp'", + "2026-09-15 04:18:34-04:00 WARNING: training run broad-layover-3a0ce678e7da is retrying after preemption or interruption (attempt 4).", + "2026-09-15 04:28:44-04:00 FileNotFoundError: [Errno 2] No such file or directory: '/checkpoints/broad-layover-3a0ce678e7da/iter_0000449/__52_1.distcp'", + "2026-09-15 04:28:44-04:00 FileNotFoundError: [Errno 2] No such file or directory: '/checkpoints/broad-layover-3a0ce678e7da/iter_0000449/__52_1.distcp'", + "2026-09-15 04:28:44-04:00 FileNotFoundError: [Errno 2] No such file or directory: '/checkpoints/broad-layover-3a0ce678e7da/iter_0000449/__52_1.distcp'", + "2026-09-15 04:28:44-04:00 FileNotFoundError: [Errno 2] No such file or directory: '/checkpoints/broad-layover-3a0ce678e7da/iter_0000449/__44_1.distcp'", + "2026-09-15 04:28:44-04:00 FileNotFoundError: [Errno 2] No such file or directory: '/checkpoints/broad-layover-3a0ce678e7da/iter_0000449/__44_1.distcp'", + "2026-09-15 04:28:44-04:00 FileNotFoundError: [Errno 2] No such file or directory: '/checkpoints/broad-layover-3a0ce678e7da/iter_0000449/__44_1.distcp'", + "2026-09-15 04:28:44-04:00 OSError: [Errno 22] Invalid argument", + "2026-09-15 04:28:44-04:00 FileNotFoundError: [Errno 2] No such file or directory: '/checkpoints/broad-layover-3a0ce678e7da/iter_0000449/__48_1.distcp'", + "2026-09-15 04:28:44-04:00 FileNotFoundError: [Errno 2] No such file or directory: '/checkpoints/broad-layover-3a0ce678e7da/iter_0000449/__48_1.distcp'", + "2026-09-15 04:28:44-04:00 FileNotFoundError: [Errno 2] No such file or directory: '/checkpoints/broad-layover-3a0ce678e7da/iter_0000449/__48_1.distcp'", + "2026-09-15 04:28:44-04:00 OSError: [Errno 22] Invalid argument", + "2026-09-15 04:28:44-04:00 OSError: [Errno 22] Invalid argument", + "2026-09-15 04:28:44-04:00 OSError: [Errno 22] Invalid argument", + "2026-09-15 04:28:44-04:00 OSError: [Errno 22] Invalid argument", + "2026-09-15 04:28:44-04:00 FileNotFoundError: [Errno 2] No such file or directory: '/checkpoints/broad-layover-3a0ce678e7da/iter_0000449/__48_1.distcp'", + "2026-09-15 04:28:44-04:00 OSError: [Errno 22] Invalid argument", + "2026-09-15 04:28:44-04:00 OSError: [Errno 22] Invalid argument", + "2026-09-15 04:28:44-04:00 OSError: [Errno 22] Invalid argument", + "2026-09-15 04:28:44-04:00 OSError: [Errno 22] Invalid argument", + "2026-09-15 04:28:44-04:00 FileNotFoundError: [Errno 2] No such file or directory: '/checkpoints/broad-layover-3a0ce678e7da/iter_0000449/__44_1.distcp'", + "2026-09-15 04:28:44-04:00 FileNotFoundError: [Errno 2] No such file or directory: '/checkpoints/broad-layover-3a0ce678e7da/iter_0000449/__44_1.distcp'", + "2026-09-15 04:28:44-04:00 FileNotFoundError: [Errno 2] No such file or directory: '/checkpoints/broad-layover-3a0ce678e7da/iter_0000449/__44_1.distcp'", + "2026-09-15 04:28:44-04:00 OSError: [Errno 22] Invalid argument", + "2026-09-15 04:28:44-04:00 OSError: [Errno 22] Invalid argument", + "2026-09-15 04:28:44-04:00 OSError: [Errno 22] Invalid argument", + "2026-09-15 04:28:44-04:00 FileNotFoundError: [Errno 2] No such file or directory: '/checkpoints/broad-layover-3a0ce678e7da/iter_0000449/__44_1.distcp'", + "2026-09-15 04:28:44-04:00 FileNotFoundError: [Errno 2] No such file or directory: '/checkpoints/broad-layover-3a0ce678e7da/iter_0000449/__44_1.distcp'", + "2026-09-15 04:28:45-04:00 FileNotFoundError: [Errno 2] No such file or directory: '/checkpoints/broad-layover-3a0ce678e7da/iter_0000449/__44_1.distcp'", + "2026-09-15 04:28:50-04:00 Ray job raysubmit_HSqKgAqbi6tykF1S finished with status: FAILED: Job entrypoint command failed with exit code 1, last available logs (truncated to 20,000 chars):", + "2026-09-15 04:28:50-04:00 FileNotFoundError: [Errno 2] No such file or directory: '/checkpoints/broad-layover-3a0ce678e7da/iter_0000449/__44_1.distcp'", + "2026-09-15 04:28:55-04:00 FileNotFoundError: [Errno 2] No such file or directory: '/checkpoints/broad-layover-3a0ce678e7da/iter_0000449/__44_1.distcp'" + ], + "checkpoint_metadata_expected_shards": 128, + "checkpoint_present_shards": 112, + "missing_shards": [ + "__40_1.distcp", + "__41_1.distcp", + "__42_1.distcp", + "__43_1.distcp", + "__44_1.distcp", + "__45_1.distcp", + "__46_1.distcp", + "__47_1.distcp", + "__48_1.distcp", + "__49_1.distcp", + "__50_1.distcp", + "__51_1.distcp", + "__52_1.distcp", + "__53_1.distcp", + "__54_1.distcp", + "__55_1.distcp" + ], + "avoidable_loss_examples": [ + { + "batch": 440, + "sample_position": 4, + "sample_index": 15364, + "group_index": 3841, + "seed": "BALATRO-RL-00000255", + "action_number": 7, + "before": { + "phase": "hand", + "ante": 1, + "round": 1, + "money": 4, + "blinds": { + "small": { + "status": "CURRENT", + "type": "small", + "name": "Small Blind", + "score": 300, + "tag": "Economy Tag", + "tag_effect": "Doubles your money (Max of $40)" + }, + "big": { + "status": "UPCOMING", + "type": "big", + "name": "Big Blind", + "score": 450, + "tag": "Economy Tag", + "tag_effect": "Doubles your money (Max of $40)" + }, + "boss": { + "status": "UPCOMING", + "type": "boss", + "name": "The Manacle", + "score": 600, + "effect": "-1 Hand Size" + } + }, + "boss": [ + "The Manacle", + 600, + "-1 Hand Size" + ], + "jokers": { + "slots": "0/5" + }, + "consumables": { + "slots": "0/2" + }, + "deck": [ + "C_2", + "C_8", + "C_9", + "C_A", + "C_Q", + "D_2", + "D_3", + "D_5", + "D_A", + "D_T", + "H_3", + "H_5", + "H_6", + "H_J", + "S_2", + "S_5", + "S_7", + "S_A", + "S_J", + "S_K", + "S_T" + ], + "blind": { + "type": "small", + "score": [ + 212, + 300 + ], + "hands": 1, + "discards": 2 + }, + "deck_left": 21, + "hand": [ + "H_A", + "H_K", + "C_K", + "D_K", + "C_J", + "S_9", + "S_3", + "H_2" + ], + "hand_values": { + "Five of a Kind": [ + 1, + 120, + 12 + ], + "Straight Flush": [ + 1, + 100, + 8 + ], + "Four of a Kind": [ + 1, + 60, + 7 + ], + "Full House": [ + 1, + 40, + 4 + ], + "Flush": [ + 1, + 35, + 4 + ], + "Straight": [ + 1, + 30, + 4 + ], + "Three of a Kind": [ + 1, + 30, + 3 + ], + "Two Pair": [ + 1, + 20, + 2 + ], + "Pair": [ + 1, + 10, + 2 + ], + "High Card": [ + 1, + 5, + 1 + ], + "Flush Five": [ + 1, + 160, + 16 + ], + "Flush House": [ + 1, + 140, + 14 + ] + }, + "discard": [ + "C_3", + "C_4", + "C_5", + "C_6", + "C_7", + "C_T", + "D_4", + "D_6", + "D_7", + "D_8", + "D_9", + "D_J", + "D_Q", + "H_4", + "H_7", + "H_8", + "H_9", + "H_Q", + "H_T", + "S_4", + "S_6", + "S_8", + "S_Q" + ], + "hand_stats": { + "Two Pair": [ + 1, + 1, + 1 + ], + "Pair": [ + 1, + 2, + 2 + ] + }, + "play_commit": { + "score": 44, + "hand": "Pair", + "cards": [ + 6, + 7, + 5, + 4, + 3 + ] + } + }, + "action": { + "method": "play", + "params": { + "cards": [ + 4, + 3, + 2, + 6, + 5 + ] + } + }, + "after": { + "phase": "GAME_OVER", + "ante": 1, + "round": 1, + "money": 4, + "blinds": { + "small": { + "status": "CURRENT", + "type": "small", + "name": "Small Blind", + "score": 300, + "tag": "Economy Tag", + "tag_effect": "Doubles your money (Max of $40)" + }, + "big": { + "status": "UPCOMING", + "type": "big", + "name": "Big Blind", + "score": 450, + "tag": "Economy Tag", + "tag_effect": "Doubles your money (Max of $40)" + }, + "boss": { + "status": "UPCOMING", + "type": "boss", + "name": "The Manacle", + "score": 600, + "effect": "-1 Hand Size" + } + }, + "boss": [ + "The Manacle", + 600, + "-1 Hand Size" + ], + "jokers": { + "slots": "0/5" + }, + "consumables": { + "slots": "0/2" + }, + "deck": [ + "C_2", + "C_8", + "C_9", + "C_A", + "C_Q", + "D_2", + "D_3", + "D_5", + "D_A", + "D_T", + "H_3", + "H_5", + "H_6", + "H_J", + "S_2", + "S_5", + "S_7", + "S_A", + "S_J", + "S_K", + "S_T" + ], + "blind": { + "type": "small", + "score": [ + 272, + 300 + ], + "hands": 0, + "discards": 2 + }, + "discard": [ + "C_3", + "C_4", + "C_5", + "C_6", + "C_7", + "C_J", + "C_K", + "C_T", + "D_4", + "D_6", + "D_7", + "D_8", + "D_9", + "D_J", + "D_K", + "D_Q", + "H_4", + "H_7", + "H_8", + "H_9", + "H_Q", + "H_T", + "S_3", + "S_4", + "S_6", + "S_8", + "S_9", + "S_Q" + ], + "play_commit": { + "score": 60, + "hand": "Pair", + "cards": [ + 4, + 3, + 2, + 6, + 5 + ] + } + } + }, + { + "batch": 449, + "sample_position": 7, + "sample_index": 15943, + "group_index": 3985, + "seed": "BALATRO-RL-00000155", + "action_number": 8, + "before": { + "phase": "hand", + "ante": 1, + "round": 1, + "money": 4, + "blinds": { + "small": { + "status": "CURRENT", + "type": "small", + "name": "Small Blind", + "score": 300, + "tag": "Polychrome Tag", + "tag_effect": "Next base edition shop Joker is free and becomes Polychrome" + }, + "big": { + "status": "UPCOMING", + "type": "big", + "name": "Big Blind", + "score": 450, + "tag": "Uncommon Tag", + "tag_effect": "Shop has a free Uncommon Joker" + }, + "boss": { + "status": "UPCOMING", + "type": "boss", + "name": "The Pillar", + "score": 600, + "effect": "Cards played previously this Ante are debuffed" + } + }, + "boss": [ + "The Pillar", + 600, + "Cards played previously this Ante are debuffed" + ], + "jokers": { + "slots": "0/5" + }, + "consumables": { + "slots": "0/2" + }, + "deck": [ + "C_3", + "C_4", + "C_8", + "C_9", + "C_A", + "C_Q", + "C_T", + "D_9", + "D_A", + "D_J", + "H_2", + "H_9", + "H_Q", + "S_2", + "S_7", + "S_8", + "S_K" + ], + "blind": { + "type": "small", + "score": [ + 235, + 300 + ], + "hands": 1, + "discards": 1 + }, + "deck_left": 17, + "hand": [ + "S_A", + "S_T", + "H_8", + "D_8", + "C_6", + "C_5", + "S_3", + "D_3" + ], + "hand_values": { + "Flush Five": [ + 1, + 160, + 16 + ], + "Flush House": [ + 1, + 140, + 14 + ], + "Five of a Kind": [ + 1, + 120, + 12 + ], + "Straight Flush": [ + 1, + 100, + 8 + ], + "Four of a Kind": [ + 1, + 60, + 7 + ], + "Full House": [ + 1, + 40, + 4 + ], + "Flush": [ + 1, + 35, + 4 + ], + "Straight": [ + 1, + 30, + 4 + ], + "Three of a Kind": [ + 1, + 30, + 3 + ], + "Two Pair": [ + 1, + 20, + 2 + ], + "Pair": [ + 1, + 10, + 2 + ], + "High Card": [ + 1, + 5, + 1 + ] + }, + "discard": [ + "C_2", + "C_7", + "C_J", + "C_K", + "D_2", + "D_4", + "D_5", + "D_6", + "D_7", + "D_K", + "D_Q", + "D_T", + "H_3", + "H_4", + "H_5", + "H_6", + "H_7", + "H_A", + "H_J", + "H_K", + "H_T", + "S_4", + "S_5", + "S_6", + "S_9", + "S_J", + "S_Q" + ], + "hand_stats": { + "Two Pair": [ + 1, + 2, + 2 + ], + "High Card": [ + 1, + 1, + 1 + ] + }, + "play_commit": { + "score": 120, + "cards": [ + 4, + 5, + 3, + 2, + 1 + ], + "hand": "Two Pair" + } + }, + "action": { + "method": "play", + "params": { + "cards": [ + 6, + 7, + 5, + 4, + 3 + ] + } + }, + "after": { + "phase": "GAME_OVER", + "ante": 1, + "round": 1, + "money": 4, + "blinds": { + "small": { + "status": "CURRENT", + "type": "small", + "name": "Small Blind", + "score": 300, + "tag": "Polychrome Tag", + "tag_effect": "Next base edition shop Joker is free and becomes Polychrome" + }, + "big": { + "status": "UPCOMING", + "type": "big", + "name": "Big Blind", + "score": 450, + "tag": "Uncommon Tag", + "tag_effect": "Shop has a free Uncommon Joker" + }, + "boss": { + "status": "UPCOMING", + "type": "boss", + "name": "The Pillar", + "score": 600, + "effect": "Cards played previously this Ante are debuffed" + } + }, + "boss": [ + "The Pillar", + 600, + "Cards played previously this Ante are debuffed" + ], + "jokers": { + "slots": "0/5" + }, + "consumables": { + "slots": "0/2" + }, + "deck": [ + "C_3", + "C_4", + "C_8", + "C_9", + "C_A", + "C_Q", + "C_T", + "D_9", + "D_A", + "D_J", + "H_2", + "H_9", + "H_Q", + "S_2", + "S_7", + "S_8", + "S_K" + ], + "blind": { + "type": "small", + "score": [ + 267, + 300 + ], + "hands": 0, + "discards": 1 + }, + "discard": [ + "C_2", + "C_5", + "C_6", + "C_7", + "C_J", + "C_K", + "D_2", + "D_3", + "D_4", + "D_5", + "D_6", + "D_7", + "D_8", + "D_K", + "D_Q", + "D_T", + "H_3", + "H_4", + "H_5", + "H_6", + "H_7", + "H_A", + "H_J", + "H_K", + "H_T", + "S_3", + "S_4", + "S_5", + "S_6", + "S_9", + "S_J", + "S_Q" + ], + "play_commit": { + "score": 32, + "cards": [ + 6, + 7, + 5, + 4, + 3 + ], + "hand": "Pair" + } + } + } + ] +} \ No newline at end of file diff --git a/reports/broad-layover-final-failure-audit-2026-09-15.md b/reports/broad-layover-final-failure-audit-2026-09-15.md new file mode 100644 index 00000000..e34475af --- /dev/null +++ b/reports/broad-layover-final-failure-audit-2026-09-15.md @@ -0,0 +1,111 @@ +# Broad-layover: final failure and learning audit + +Run: [broad-layover-3a0ce678e7da](https://modal-labs-joy-dev--training-gym-dashboard-fastapi-app.modal.run/training/broad-layover-3a0ce678e7da?tab=summary). Checked September 15, 2026. + +## Conclusion + +Two problems occurred independently: + +1. **The first attempt crashed in NCCL during checkpoint saving. Three automatic retries then loaded the same incomplete checkpoint and failed before another training update.** +2. **The policy already performed poorly and regressed before that crash.** It increasingly played weak combinations, left usable discards, and missed straightforward winning hands. The training setup supplies whole-game relative reward, offering weak guidance about which individual decisions were wrong. + +The crash is established by logs and checkpoint contents. The mechanism behind poor learning is an evidence-based diagnosis, not a controlled causal experiment. + +## Evidence inspected + +- Persisted run configuration, status, attempt history, and all 50 rollout summaries (400–449; 3,200 games). +- Full prompts and responses from batches 400, 413, 425, 440, and 449: 320 episodes, with sparse state reconstruction and 6,056 executed plays. +- Modal logs covering optimizer steps 425–449 and all four failure endings. +- Committed checkpoint directory and `.metadata` references. Metadata was inspected with `pickletools`, without executing the pickle. +- Local checkpoint validation and reward code, including the earlier committed harness for comparison. The currently edited harness has changes that this historical run did not use. + +The dashboard and normal CLI returned authentication errors. Reads used the authenticated Training Gym SDK and Modal CLI. No training configuration, code, running jobs, or remote data was changed. + +## 1. Why it failed four times + +All times below are EDT on September 15. + +| Attempt | Failure time | Evidence | +|---|---|---| +| 1 | 03:54 | Native segfault in `ras/peers.cc:549`, `rasMsgHandlePeersUpdate`, inside the NCCL RAS thread. Ray reports `ActorDiedError` while waiting for `actor_model.save_model(449)`. | +| 2 | 04:06 | Auto-resumes checkpoint 449; loading fails with missing `__32_1.distcp` through `__35_1.distcp`. | +| 3 | 04:17 | Same checkpoint; missing shards including `__44_1.distcp`, `__48_1.distcp`, `__52_1.distcp`, plus invalid-argument reads. | +| 4 | 04:28 | Same load failure. Persisted final error names `__44_1.distcp`. | + +Step 449's optimizer update completed at 03:51:41. Saving began at 03:51:52, and Megatron printed “successfully saved” at 03:52:45. The outer save operation had not returned when actors segfaulted. That message therefore did not establish a durable, reloadable checkpoint. + +The committed checkpoint now has **112 of 128 referenced `.distcp` files**. Every `__40_1.distcp` through `__55_1.distcp` is missing. Different missing files in the earlier retry logs indicate that its visible contents changed; they do not change the finding that the checkpoint was incomplete. We did not validate byte ranges in the remaining files, so there may also be truncated shards. + +### Why the retries did not recover + +`is_complete_torch_dist_checkpoint()` in Training Gym's `common/torch_dist_checkpoint.py` only checks for `.metadata`, `common.pt`, and **any** `.distcp` file. I passed the actual directory listing into that function: it returned `True` despite the 16 missing referenced files. The launcher uses this check when selecting a resume checkpoint. + +Thus automatic recovery accepted an invalid checkpoint and repeated the same deterministic failure three times. The exact underlying NCCL defect and the precise timing of failed volume persistence are not established by these logs. The native stack identifies the first crash; there is no need to infer an OOM from Ray's generic list of possible causes. + +## 2. Learning did not improve before the crash + +This continuation resumed from parent `perfect-adhesive-da14ace5a831` at 400. It completed **50 new updates**, not 450. Retries added none. + +| Batches | Games | Mean reward | Mean final ante | Wins | +|---|---:|---:|---:|---:| +| 400–409 | 640 | 51.89 | 3.26 | 0 | +| 410–419 | 640 | 48.31 | 3.11 | 0 | +| 420–429 | 640 | 49.42 | 3.17 | 0 | +| 430–439 | 640 | 50.62 | 3.18 | 0 | +| 440–449 | 640 | 39.13 | 2.67 | 0 | + +Last-window reward was **24.6% below** the first window. These are changing training seeds, not a fixed-seed evaluation, so the table alone cannot measure causal checkpoint regression. The decision errors below directly establish poor play. + +## 3. What the model actually did + +| Batch | Pair / Two Pair share | Discards per play | Game overs with discards left | Context cutoffs | +|---|---:|---:|---:|---:| +| 400 | 66.1% | 0.92 | 21 / 55 | 9 / 64 | +| 413 | 72.4% | 0.60 | 42 / 63 | 1 / 64 | +| 425 | 75.0% | 0.57 | 47 / 64 | 0 / 64 | +| 440 | 80.2% | 0.29 | 58 / 64 | 0 / 64 | +| 449 | 79.2% | 0.41 | 53 / 62 | 2 / 64 | + +These counts are behavior indicators: a Pair can be optimal with suitable jokers, and an unused discard does not by itself prove a recoverable loss. + +### Directly avoidable losses + +**Batch 440, sample position 4 (sample_index 15364), action 7:** Ante 1 Small Blind, 212/300 chips, one hand and two discards left, no jokers. The hand was: + +`0 H_A, 1 H_K, 2 C_K, 3 D_K, 4 C_J, 5 S_9, 6 S_3, 7 H_2`. + +The model played `[4,3,2,6,5]`: only two Kings, scoring 60 and losing at 272/300. Playing `[1,2,3]` gives Three of a Kind, `(30 + 30) × 3 = 180`, and clears the blind. The state included both the cards and current scoring bases. No boss was active in this Small Blind. + +**Batch 449, sample position 7 (sample_index 15943), action 8:** Ante 1 Small Blind, 235/300 chips, one hand and one discard left, no jokers. The hand contained two Eights and two Threes. The model played `[6,7,5,4,3]`, a Pair of Threes worth 32, and lost. Selecting both pairs `[2,3,6,7]` scores `(20 + 8 + 8 + 3 + 3) × 2 = 84`, enough to clear. + +These alternatives are deterministic arithmetic from recorded unmodified state, not new engine replays. + +### Evidence of reliance on familiar index patterns + +The selected set `{3,4,5,6,7}` rose from 94/1,314 plays (7.2%) in batch 400 to 341/1,308 (26.1%) in batch 449. The losing action in the second example uses exactly that set despite omitting the other Eight. This is consistent with learned positional templates that fail to condition sufficiently on actual cards; frequency alone does not prove the internal mechanism. + +Across all five sampled batches, the policy never sold a joker or skipped a blind and rerolled only four times. This limits adaptation of its early purchases. The 6,056 plays included just 13 Straights and two Flushes. There were 273 Pair/High Card plays with a raw straight available; these are opportunity flags, not 273 proven mistakes. + +## 4. Why this training setup plausibly reinforces the problem + +**Whole-game credit assignment is weak.** The persisted recipe uses GRPO, four games per seed, and `normalize_episode_rewards`. The matching local reward implementation normalizes final game scores within a seed group and produces one relative advantage per game. The checkpoint reward events shown in the dashboard do not by themselves supply hand-level advantages. A relatively better losing game can reinforce poor plays embedded in that game. Better joker luck and many intervening actions obscure which card choice deserved credit. + +**Useful strategic exploration is narrow.** Four samples per seed yielded distinct transcripts, and 77/80 sampled seed groups had nonzero reward variance. Therefore this is not a blanket zero-reward-variance failure. But many trajectories differ in card-index permutations while repeating the same limited approach. Batch size 64 does not ensure the groups contain examples of the missing strategies. + +**The model must select actions without written reasoning.** The run used `enable_thinking=false`, a 96-token generation limit per action, and instructions to return only JSON. It receives scoring rules, but has no demonstrated hand-scoring decision step. This is a plausible constraint on learning the missing combinations, not proof that enabling reasoning would solve it. + +**Context limits censor some deeper games.** The run used a single growing conversation capped at 49,152 tokens. Twelve of the 320 sampled games reached that cap. However, batch 440's entire sample ended in game over with zero context caps, so truncation cannot explain the late reward dip. The newer segmented-context code in the workspace was not used by this run. + +**There is no evidence here of gradients stopping or exploding.** Steps 425–449 log finite gradient norms of 1.13–2.12 and learning rate `1e-6`. The logged entropy metric rises between the ends of that window, so a simple entropy-collapse claim is unsupported. Zero PPO KL and clip fraction in these logs do not, by themselves, establish that weights were unchanged. + +The earlier audit also identified repeated ante bonuses after ante-lowering vouchers and a Judgement pack-capacity gap. Those can distort reward or legality, but do not explain the direct hand-selection failures or the four infrastructure failures. + +## Recommended order of follow-up + +1. **Fix checkpoint durability and resume validation:** verify every metadata-referenced shard and its required byte range, finish commits from every node, then publish a completion marker. Reject incomplete checkpoints and fall back to a verified earlier checkpoint. More retries cannot repair missing files. +2. **Investigate the native NCCL RAS crash** with the recorded native stack and exact deployed library version. The first failure happened during distributed save, not game rollout. +3. **Measure card-selection competence on fixed states**, including the two guaranteed-clear examples above. Compare available checkpoints on the same seeds, scoring win rate, ante, avoidable losses, discard use, and joker replacement. +4. **Test one learning intervention at a time:** verified scoring demonstrations or a short hand-selection curriculum are justified by these traces. Separately test action-level credit assignment. Preserve the actual win metric and validate the intended objective before changing rewards. +5. **Use bounded context and close known harness gaps** before another long continuation. Verify save/reload as part of a short proof run. + +No fix or relaunch was performed during this diagnosis. Structured evidence is in [broad-layover-final-evidence-2026-09-15.json](broad-layover-final-evidence-2026-09-15.json). diff --git a/src/lua/endpoints/sell.lua b/src/lua/endpoints/sell.lua index 5d112222..888fd51a 100644 --- a/src/lua/endpoints/sell.lua +++ b/src/lua/endpoints/sell.lua @@ -32,7 +32,7 @@ return { }, }, - requires_state = { G.STATES.SELECTING_HAND, G.STATES.SHOP }, + requires_state = { G.STATES.SELECTING_HAND, G.STATES.SHOP, G.STATES.SMODS_BOOSTER_OPENED }, ---@param args Request.Endpoint.Sell.Params ---@param send_response fun(response: Response.Endpoint) @@ -95,6 +95,17 @@ return { local card = source_array[pos] + -- Use the game's own gate: in particular Eternal jokers cannot be sold. + if not card:can_sell_card() then + send_response({ + message = "This card cannot be sold at this time", + name = BB_ERROR_NAMES.NOT_ALLOWED, + }) + return + end + local pack_before = G.STATE == G.STATES.SMODS_BOOSTER_OPENED and G.pack_cards or nil + local pack_choices_before = G.GAME.pack_choices + -- Track initial state for completion verification local area = sell_type == "joker" and G.jokers or G.consumeables local initial_count = area.config.card_count @@ -144,7 +155,17 @@ return { local state_stable = G.STATE_COMPLETE == true -- 5. Still in valid state - local valid_state = (G.STATE == G.STATES.SHOP or G.STATE == G.STATES.SELECTING_HAND) + local valid_state + if pack_before then + -- Selling frees inventory capacity; it must not select a pack card, + -- consume a choice, close the pack, or return to the shop. + valid_state = G.STATE == G.STATES.SMODS_BOOSTER_OPENED + and G.pack_cards == pack_before + and not G.pack_cards.REMOVED + and G.GAME.pack_choices == pack_choices_before + else + valid_state = G.STATE == G.STATES.SHOP or G.STATE == G.STATES.SELECTING_HAND + end -- All conditions must be met if count_decreased and money_increased and card_gone and state_stable and valid_state then diff --git a/src/lua/utils/gamestate.lua b/src/lua/utils/gamestate.lua index 0cdaedc9..41620d1b 100644 --- a/src/lua/utils/gamestate.lua +++ b/src/lua/utils/gamestate.lua @@ -346,6 +346,49 @@ local function extract_joker_scoring_state(card) return result end +-- Copy only documented, observable mechanics. Never serialize the engine's +-- whole ability/game tables (they can contain hidden state and references). +local function copy_fields(source, keys) + local result = {} + for _, key in ipairs(keys) do + local value = source and source[key] + if type(value) == "number" or type(value) == "boolean" or type(value) == "string" then + result[key] = value + end + end + return result +end + +local function extract_counters(card) + local ability = card.ability or {} + local result = copy_fields(ability, { + "perma_bonus", "played_this_ante", "forced_selection", "perma_debuff", + "mult", "x_mult", "bonus", "h_mult", "h_x_mult", "h_dollars", "p_dollars", + "t_chips", "t_mult", "extra_value", "loyalty_remaining", "burnt_hand", + "caino_xmult", "yorick_discards", "invis_rounds", "hands_played_at_create", + "to_do_poker_hand", "steel_tally", "stone_tally", "driver_tally", "nine_tally", + "perish_tally", "perishable", + }) + -- Playing-card base values already have an enhancement description. Only + -- permanent bonuses and per-card history need an extra persistent record. + if card.config and card.config.card then + local playing = copy_fields(ability, {"perma_bonus", "played_this_ante", "forced_selection", "perma_debuff"}) + if playing.perma_bonus == 0 then playing.perma_bonus = nil end + return playing + end + if type(ability.extra) == "number" then + result.extra = ability.extra + elseif type(ability.extra) == "table" then + result.extra = copy_fields(ability.extra, { + "Xmult", "xmult", "chips", "chip_mod", "mult", "dollars", "odds", + "every", "discards", "discard_sub", "hand_add", "h_mod", "h_plays", + "h_size", "increase", "size", "min", "max", "faces", "suit", + "s_mult", "poker_hand", "d_remaining", "destroy", + }) + end + return result +end + ---Extracts a complete Card object from a game card ---@param card table The game card object ---@return Card card The Card object @@ -393,6 +436,7 @@ local function extract_card(card) state = extract_card_state(card), cost = extract_card_cost(card), scoring_state = extract_joker_scoring_state(card), + counters = extract_counters(card), } end @@ -755,6 +799,7 @@ function gamestate.get_gamestate() end local state_data = { + snapshot_version = 1, state = get_state_name(G.STATE), -- These are transport/readiness details for the Python harness. They are -- deliberately not part of the compact model prompt, but let the client @@ -770,6 +815,34 @@ function gamestate.get_gamestate() state_data.ante_num = (G.GAME.round_resets and G.GAME.round_resets.ante) or 0 state_data.money = G.GAME.dollars or 0 state_data.won = G.GAME.won + state_data.run_state = copy_fields(G.GAME, { + "last_tarot_planet", "last_hand_played", "hands_played", "unused_discards", + "skips", "bankrupt_at", "interest_cap", "interest_amount", "inflation", + "discount_percent", "ecto_minus", "starting_deck_size", + }) + state_data.run_state.round = copy_fields(G.GAME.current_round, { + "hands_played", "discards_used", "most_played_poker_hand", "free_rerolls", + "reroll_cost_increase", "jokers_purchased", + }) + state_data.run_state.consumable_usage = copy_fields(G.GAME.consumeable_usage_total, {"tarot", "planet", "spectral"}) + state_data.run_state.probabilities = copy_fields(G.GAME.probabilities, {"normal"}) + state_data.blind_state = copy_fields(G.GAME.blind, {"disabled", "only_hand"}) + -- The Eye remembers which hand types have been played this blind. + state_data.blind_state.played_hands = {} + if G.GAME.blind and G.GAME.blind.hands then + for name, played in pairs(G.GAME.blind.hands) do + if type(played) == "boolean" then state_data.blind_state.played_hands[name] = played end + end + end + state_data.tags = {} + for _, tag in ipairs(G.GAME.tags or {}) do + local info = get_tag_info(tag.key) + state_data.tags[#state_data.tags + 1] = { + key = tag.key, name = info.name, effect = info.effect, triggered = tag.triggered == true, + ability = copy_fields(tag.ability, {"orbital_hand", "blind_type"}), + } + end + state_data.pack_choices = G.GAME.pack_choices -- Deck (optional) if G.GAME.selected_back and G.GAME.selected_back.effect and G.GAME.selected_back.effect.center then @@ -815,6 +888,39 @@ function gamestate.get_gamestate() -- Always available areas state_data.jokers = extract_area(G.jokers) state_data.consumables = extract_area(G.consumeables) -- Note: typo in game code + -- Owned joker identities are known even when Amber Acorn hides their new + -- order. Preserve that multiset without revealing which face-down slot is + -- which. Shop/pack cards do not receive this treatment. + if G.jokers then + local hidden = false + for _, card in ipairs(G.jokers.cards or {}) do + if card.facing == "back" then hidden = true end + end + if hidden then + state_data.joker_inventory = {count = #G.jokers.cards, limit = #G.jokers.cards, cards = {}} + for _, card in ipairs(G.jokers.cards) do + local view = extract_card(card) + view.id = 0 + view.state = {} + state_data.joker_inventory.cards[#state_data.joker_inventory.cards + 1] = view + end + table.sort(state_data.joker_inventory.cards, function(a, b) return a.key < b.key end) + end + end + + -- G.playing_cards contains the full owned deck across all areas. Export a + -- sorted composition without per-instance identities or area positions. + -- These are known deck contents, not the identity of any face-down slot. + state_data.owned_cards = {count = #(G.playing_cards or {}), limit = #(G.playing_cards or {}), cards = {}} + for _, card in ipairs(G.playing_cards or {}) do + local view = extract_card(card) + view.id = 0 -- anonymous composition, not an instance ID + view.state = {} + view.counters = copy_fields(card.ability, {"perma_bonus", "played_this_ante"}) + if view.counters.perma_bonus == 0 then view.counters.perma_bonus = nil end + state_data.owned_cards.cards[#state_data.owned_cards.cards + 1] = view + end + table.sort(state_data.owned_cards.cards, function(a, b) return a.key < b.key end) -- Cards remaining in deck if G.deck then diff --git a/src/lua/utils/openrpc.json b/src/lua/utils/openrpc.json index beb58a2b..508780e4 100644 --- a/src/lua/utils/openrpc.json +++ b/src/lua/utils/openrpc.json @@ -577,7 +577,7 @@ { "name": "sell", "summary": "Sell a joker or consumable", - "description": "Sell a joker or consumable from player inventory. Must provide exactly one of: joker or consumable.", + "description": "Sell a joker or consumable from player inventory in the shop, while selecting a hand, or inside an open booster pack. A pack remains open with its choices unchanged after selling. Must provide exactly one of: joker or consumable. Eternal cards cannot be sold.", "tags": [ { "$ref": "#/components/tags/shop" @@ -973,6 +973,37 @@ "packs": { "$ref": "#/components/schemas/Area", "description": "Booster packs area (available during shop phase)" + }, + "snapshot_version": { + "type": "integer", + "description": "Version of the state fields required by context resets; currently 1." + }, + "owned_cards": { + "$ref": "#/components/schemas/Area", + "description": "Full owned deck composition across areas. Cards have anonymous id=0; array order conveys no draw order." + }, + "run_state": { + "type": "object", + "description": "Allowlisted observable run and round counters, prior hand/consumable, and economy values." + }, + "blind_state": { + "type": "object", + "description": "Current blind disabled status and hand-type restrictions/history." + }, + "tags": { + "type": "array", + "items": { + "type": "object" + }, + "description": "Pending/active tags, their effects and visible targets." + }, + "pack_choices": { + "type": "integer", + "description": "Number of selections remaining in the current pack." + }, + "joker_inventory": { + "$ref": "#/components/schemas/Area", + "description": "Known unordered owned-joker composition when slots are face-down; anonymous IDs reveal no slot mapping." } }, "required": [ @@ -1172,6 +1203,10 @@ "chips": { "type": "number" }, "chip_gain": { "type": "number" } } + }, + "counters": { + "type": "object", + "description": "Allowlisted visible persistent card/joker values, including perma_bonus, played_this_ante and accumulated bonuses. No RNG state." } }, "required": [ diff --git a/src/lua/utils/types.lua b/src/lua/utils/types.lua index 8e54bd75..8622f940 100644 --- a/src/lua/utils/types.lua +++ b/src/lua/utils/types.lua @@ -9,6 +9,13 @@ -- ========================================================================== ---@class GameState +---@field snapshot_version integer? Context-reset state schema version +---@field owned_cards Area? Full owned composition; anonymous IDs, no draw order +---@field joker_inventory Area? Known unordered joker composition when slots are hidden +---@field run_state table? Observable run/round counters and previous action facts +---@field blind_state table? Current blind restrictions and hand history +---@field tags table[]? Pending/active tags with visible effects and targets +---@field pack_choices integer? Selections remaining in the open pack ---@field deck Deck? Current selected deck ---@field stake Stake? Current selected stake ---@field seed string? Seed used for the run @@ -75,6 +82,7 @@ ---@field state Card.State Current state information (debuff, hidden, highlighted) ---@field cost Card.Cost Cost information (buy/sell prices) ---@field scoring_state Card.ScoringState? Visible round-specific joker target/counters (never the RNG state) +---@field counters table? Visible persistent bonuses and per-card mechanic counters ---@class Card.ScoringState ---@field target {rank: string?, suit: string?, rank_id: integer?} The current round's already-selected target diff --git a/tests/fixtures/broad_layover_decisions.json b/tests/fixtures/broad_layover_decisions.json new file mode 100644 index 00000000..aa19593d --- /dev/null +++ b/tests/fixtures/broad_layover_decisions.json @@ -0,0 +1,209 @@ +[ + { + "batch": 440, + "sample_index": 15364, + "hand": [ + "H_A", + "H_K", + "C_K", + "D_K", + "C_J", + "S_9", + "S_3", + "H_2" + ], + "blind": { + "type": "small", + "score": [ + 212, + 300 + ], + "hands": 1, + "discards": 2 + }, + "hand_values": { + "Five of a Kind": [ + 1, + 120, + 12 + ], + "Straight Flush": [ + 1, + 100, + 8 + ], + "Four of a Kind": [ + 1, + 60, + 7 + ], + "Full House": [ + 1, + 40, + 4 + ], + "Flush": [ + 1, + 35, + 4 + ], + "Straight": [ + 1, + 30, + 4 + ], + "Three of a Kind": [ + 1, + 30, + 3 + ], + "Two Pair": [ + 1, + 20, + 2 + ], + "Pair": [ + 1, + 10, + 2 + ], + "High Card": [ + 1, + 5, + 1 + ], + "Flush Five": [ + 1, + 160, + 16 + ], + "Flush House": [ + 1, + 140, + 14 + ] + }, + "bad_action": { + "method": "play", + "params": { + "cards": [ + 4, + 3, + 2, + 6, + 5 + ] + } + }, + "winning_cards": [ + 1, + 2, + 3 + ], + "winning_score": 180 + }, + { + "batch": 449, + "sample_index": 15943, + "hand": [ + "S_A", + "S_T", + "H_8", + "D_8", + "C_6", + "C_5", + "S_3", + "D_3" + ], + "blind": { + "type": "small", + "score": [ + 235, + 300 + ], + "hands": 1, + "discards": 1 + }, + "hand_values": { + "Flush Five": [ + 1, + 160, + 16 + ], + "Flush House": [ + 1, + 140, + 14 + ], + "Five of a Kind": [ + 1, + 120, + 12 + ], + "Straight Flush": [ + 1, + 100, + 8 + ], + "Four of a Kind": [ + 1, + 60, + 7 + ], + "Full House": [ + 1, + 40, + 4 + ], + "Flush": [ + 1, + 35, + 4 + ], + "Straight": [ + 1, + 30, + 4 + ], + "Three of a Kind": [ + 1, + 30, + 3 + ], + "Two Pair": [ + 1, + 20, + 2 + ], + "Pair": [ + 1, + 10, + 2 + ], + "High Card": [ + 1, + 5, + 1 + ] + }, + "bad_action": { + "method": "play", + "params": { + "cards": [ + 6, + 7, + 5, + 4, + 3 + ] + } + }, + "winning_cards": [ + 2, + 3, + 6, + 7 + ], + "winning_score": 84 + } +] diff --git a/tests/test_context_management.py b/tests/test_context_management.py new file mode 100644 index 00000000..d74760f7 --- /dev/null +++ b/tests/test_context_management.py @@ -0,0 +1,427 @@ +"""CPU regressions for resets, exact training prefixes and snapshot fidelity.""" + +import ast +import asyncio +import json +import math +import os +import re +import shutil +import subprocess +import sys +import time +from copy import deepcopy +from dataclasses import dataclass, field +from enum import Enum +from pathlib import Path +from types import ModuleType, SimpleNamespace +from typing import Any + +import pytest + +ROOT = Path(__file__).resolve().parents[1] + + +class Tokenizer: + """Deterministic character tokens; different action IDs test prefix fidelity.""" + + def __call__(self, text, **kwargs): + return {"input_ids": list(text.encode())} + + def apply_chat_template(self, messages, **kwargs): + return "SYSTEM\n" + messages[0]["content"] + "\nUSER\n" + messages[1]["content"] + "\nASSISTANT\n" + + +@dataclass +class Action: + name: str + arguments: dict + + +@dataclass +class Sample: + class Status(Enum): + COMPLETED = "completed" + ABORTED = "aborted" + + prompt: str = "TEST-SEED" + metadata: dict = field(default_factory=dict) + rollout_id: int | None = None + index: int = 7 + group_index: int = 1 + status: Any = None + + +@pytest.fixture +def harness(monkeypatch): + names = { + "_compact_state", "_area_items", "_slot_usage", "_purchasable_indices", "_sellable_indices", + "_consumable_target_bounds", "_consumable_requires_joker", "_target_action_help", + "_action_help", "_turn_prompt", "_chat_prompt", "_action_payload", + "_state_delta", "_delta_payload", "_selected_blind", "_skip_transition", + "_environment_feedback", "_balatro_context_limits", "_validate_balatro_trainer", + "_validate_balatro_loss_config", + "_BalatroContext", "_StateBudgetExceeded", "_SnapshotUnavailable", + "_segment_reward_events", "generate_balatro_episode", "_progress_value", + "_transition_reward_parts", "_ante_clear_reward", "_episode_reward_parts", + "normalize_episode_rewards", "_sample_reward", "_generate_action", + } + constants = { + "BALATRO_SYSTEM_PROMPT", "_DELTA_ANCHORS", "_UNCHANGED", + "ANTE_CHECKPOINT_BONUS", "FINAL_ANTE", "DECISION_CAP_PENALTY", + "_CONSUMABLE_TARGET_BOUNDS", "_CONSUMABLE_REQUIRES_JOKER", + } + tree = ast.parse((ROOT / "batro_modal_rl.py").read_text()) + selected = [ast.ImportFrom(module="__future__", names=[ast.alias(name="annotations")], level=0)] + for node in tree.body: + if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef, ast.ClassDef)) and node.name in names: + selected.append(node) + elif isinstance(node, ast.Assign) and any(isinstance(t, ast.Name) and t.id in constants for t in node.targets): + selected.append(node) + elif isinstance(node, ast.AnnAssign) and isinstance(node.target, ast.Name) and node.target.id in constants: + selected.append(node) + ns = dict(Any=Any, json=json, math=math, re=re, time=time, asyncio=asyncio, + Path=Path, deepcopy=deepcopy, ToolCall=Action) + exec(compile(ast.fix_missing_locations(ast.Module(body=selected, type_ignores=[])), "harness", "exec"), ns) + for name in ("slime", "slime.utils", "slime.utils.types"): + monkeypatch.setitem(sys.modules, name, ModuleType(name)) + sys.modules["slime.utils.types"].Sample = Sample + ns["_log_balatro_event"] = lambda *a, **k: None + ns["_tokenizer"] = lambda checkpoint: Tokenizer() + ns["_parse_action"] = lambda text, state: Action(**{"name": json.loads(text)["method"], "arguments": json.loads(text)["params"]}) + return ns + + +def game_state(turn=0, *, done=False): + card = {"id": 19, "key": "S_A", "modifier": {"seal": "GOLD"}, "counters": {"perma_bonus": 30}} + return { + "snapshot_version": 1, "state": "GAME_OVER" if done else "SELECTING_HAND", + "ante_num": 1, "round_num": 1, "money": turn, "won": done, + "round": {"chips": turn * 10, "hands_left": 4, "discards_left": 3}, + "blinds": {"small": {"type": "SMALL", "status": "CURRENT", "score": 1000}}, + "hand": {"cards": [card]}, "cards": {"count": 1, "cards": [{"key": "C_K"}]}, + "owned_cards": {"cards": [card, {"key": "C_K"}]}, + "jokers": {"cards": [{"id": 70, "key": "j_green_joker", "value": {"effect": "gain Mult"}, "counters": {"mult": turn}}]}, + "used_vouchers": {"v_blank": ""}, + "hands": {"Pair": {"level": 3, "chips": 40, "mult": 4, "played": turn}}, + "tags": [{"key": "tag_double"}], "run_state": {"last_tarot_planet": "c_devil"}, + } + + +def run_episode(harness, *, decisions=30, target=7000, hard=12288, final_extra="", fail_initial=False, forced_error=False, phases=False, missing_schema=False): + seen = [] + env = SimpleNamespace(closed=False, steps=0) + env._terminal = lambda state: state.get("state") == "GAME_OVER" + initial = game_state() + if missing_schema: + initial.pop("snapshot_version") + if fail_initial: + initial["jokers"]["cards"][0]["value"]["effect"] = "X" * hard + env.start = lambda seed: deepcopy(initial) + + def step(action): + env.steps += 1 + state = game_state(env.steps, done=env.steps == decisions) + if phases and env.steps < decisions: + state["state"] = ["SELECTING_HAND", "SHOP", "SMODS_BOOSTER_OPENED", "BLIND_SELECT"][env.steps % 4] + if env.steps == decisions: + state["jokers"]["cards"][0]["value"]["effect"] += final_extra + if forced_error: + return SimpleNamespace(observation=SimpleNamespace(metadata={"state": state}, is_error=True, text="bad action")) + return SimpleNamespace(observation=SimpleNamespace(metadata={"state": state}, is_error=False), done=env.steps == decisions) + + env.step = step + env.close = lambda: setattr(env, "closed", True) + harness["_get_env_pool"] = lambda: SimpleNamespace(acquire=lambda seed: env) + harness["_fallback_action"] = lambda state: Action("play", {"cards": [0]}) + + async def generate(args, params, ids, phase): + # IDs intentionally differ from encoding the response text. Training + # must use the original IDs, not re-tokenize the pretty transcript. + action_ids = [100000 + len(seen), 99999] + seen.append((list(ids), action_ids)) + responses = { + "SELECTING_HAND": {"method": "play", "params": {"cards": [0]}}, + "SHOP": {"method": "next_round", "params": {}}, + "SMODS_BOOSTER_OPENED": {"method": "pack", "params": {"skip": True}}, + "BLIND_SELECT": {"method": "select", "params": {}}, + } + return action_ids, json.dumps(responses[phase], separators=(",", ":")), "stop", [-0.2, -0.3] + + harness["_generate_action"] = generate + args = SimpleNamespace(balatro_max_decisions=decisions + 2, balatro_context_len=hard, + balatro_segment_tokens=target, balatro_capture_screenshot=False, + hf_checkpoint="unused") + samples = asyncio.run(harness["generate_balatro_episode"](args, Sample(), {}, evaluation=True)) + return samples, seen, env + + +def test_rebases_keep_game_running_and_train_every_action_with_its_exact_prefix(harness): + samples, seen, env = run_episode(harness) + assert env.closed and env.steps == 30 + assert 1 < len(samples) < 30 + assert {s.rollout_id for s in samples} == {samples[0].rollout_id} + assert {s.reward for s in samples} == {samples[0].reward} + assert {s.metadata["exit_status"] for s in samples} == {"won"} + reconstructed = [] + for index, sample in enumerate(samples): + assert sample.metadata["segment_id"] == index + assert len(sample.tokens) + 128 <= 12288 + assert len(sample.loss_mask) == sample.response_length == len(sample.rollout_log_probs) + assert len(sample.metadata["trajectory_messages"]) <= 128 + offset = len(sample.tokens) - sample.response_length + for token in range(sample.response_length): + if sample.loss_mask[token] and (token == 0 or not sample.loss_mask[token - 1]): + reconstructed.append((sample.tokens[:offset + token], sample.tokens[offset + token:offset + token + 2])) + # Snapshots stand alone and retain changes made before a reset. + assert '"perma_bonus":30' in sample.prompt and '"seal":"GOLD"' in sample.prompt + assert '"owned_vouchers"' in sample.prompt and '"last_tarot_planet":"c_devil"' in sample.prompt + assert reconstructed == seen + assert sum(sum(s.loss_mask) for s in samples) == 60 + assert sum("balatro/won" in s.metadata for s in samples) == 1 + assert sum("balatro_episode_archive" in s.metadata for s in samples) == 1 + events = [e for s in samples for e in s.metadata["reward_events"]] + assert len(events) == 1 and events[0]["label"] == "WON" + assert len(events[0]["segment_spans"]) > 1 + + +def test_oversized_terminal_feedback_does_not_turn_a_win_into_context_cap(harness): + samples, seen, env = run_episode(harness, decisions=2, final_extra="X" * 20000) + assert len(seen) == 2 and env.closed + assert all(s.metadata["exit_status"] == "won" for s in samples) + assert all(len(s.tokens) < 12288 for s in samples) + assert "X" * 20000 in samples[0].metadata["balatro_episode_archive"]["response"] + + +def test_oversized_initial_snapshot_never_calls_model_and_closes_game(harness): + sample, seen, env = run_episode(harness, fail_initial=True) + assert not seen and env.closed and env.steps == 0 + assert sample.status == Sample.Status.ABORTED + assert sample.metadata["exit_status"] == "state_budget_exceeded" + + +def test_old_assets_are_rejected_before_generating_with_incomplete_snapshots(harness): + sample, seen, env = run_episode(harness, missing_schema=True) + assert not seen and env.closed + assert sample.metadata["exit_status"] == "state_schema_mismatch" + + +def test_full_length_game_survives_history_larger_than_the_old_context_cap(harness): + samples, seen, env = run_episode(harness, decisions=250, phases=True) + assert len(seen) == env.steps == 250 and env.closed + assert samples[0].metadata["balatro/episode_archive_tokens"] > 49152 + assert samples[0].metadata["balatro/context_tokens"] < 12288 + assert all(s.metadata["exit_status"] == "won" for s in samples) + assert sum(sum(s.loss_mask) for s in samples) == 500 + assert all(len(prefix) + 224 <= 12288 for prefix, _ in seen) + + +def test_rpc_recovery_error_is_archived_without_dropping_generated_action(harness): + samples, seen, env = run_episode(harness, forced_error=True) + assert len(seen) == 1 and env.closed + assert samples[0].metadata["exit_status"] == "rpc_error" + assert sum(samples[0].loss_mask) == 2 + assert "bad action" in samples[0].metadata["balatro_episode_archive"]["response"] + + +def test_oversized_snapshot_can_exceed_soft_target_but_not_hard_cap(harness): + context = harness["_BalatroContext"](Tokenizer(), 2048, 512) + context.begin("X" * 1000, "snapshot", 1) + assert len(context.input_ids()) == 1000 + context.add_action([1], "a", [-0.1], turn=1, archive_start=0) + context.add_feedback("f", [2]) + assert context.needs_reset + with pytest.raises(RuntimeError, match="fresh snapshot"): + context.input_ids() + + +def test_budget_counts_output_margin_and_training_padding(harness): + args = SimpleNamespace(balatro_context_len=49152, balatro_segment_tokens=8192, + sglang_context_length=49000, tensor_model_parallel_size=4, + context_parallel_size=4, max_tokens_per_gpu=12288) + assert harness["_balatro_context_limits"](args) == (47104, 8192) + context = harness["_BalatroContext"](Tokenizer(), 512, 512) + context.begin("a" * (512 - 224), "snapshot", 1) + with pytest.raises(harness["_StateBudgetExceeded"]): + context.begin("a" * (512 - 223), "snapshot", 1) + + +def test_generation_sends_bounded_ids_and_retains_serving_log_probabilities(harness, monkeypatch): + http = ModuleType("slime.utils.http_utils") + requests = [] + + async def post(url, payload): + requests.append(payload) + return {"text": "action", "meta_info": { + "finish_reason": {"type": "stop"}, + "output_token_logprobs": [[-0.25, 101, None], [-0.5, 102, None]], + }} + + http.post = post + monkeypatch.setitem(sys.modules, "slime.utils.http_utils", http) + harness["_action_regex"] = lambda phase: "action" + args = SimpleNamespace(balatro_context_len=512, balatro_segment_tokens=512, + sglang_router_ip="unused", sglang_router_port=1234) + output = asyncio.run(harness["_generate_action"](args, {"max_new_tokens": 999}, [1] * 288, "hand")) + assert output == ([101, 102], "action", "stop", [-0.25, -0.5]) + assert requests[0]["sampling_params"]["max_new_tokens"] == 96 + assert len(requests[0]["input_ids"]) + 96 + 128 == 512 + assert asyncio.run(harness["_generate_action"](args, {}, [1] * 512, "hand"))[1] is None + assert len(requests) == 1 + + +def test_trainer_refuses_segment_weighting_that_counts_long_games_more(harness): + with pytest.raises(ValueError, match="per-game mean"): + harness["_validate_balatro_trainer"](SimpleNamespace(calculate_per_token_loss=True), Sample) + + +def test_checkpoint_crossing_reset_has_one_reward_and_local_token_offsets(harness): + segments = [ + {"actions": [{"token_start": 0, "token_end": 2, "episode_token_start": 0, "episode_token_end": 2}]}, + {"actions": [{"token_start": 0, "token_end": 3, "episode_token_start": 30, "episode_token_end": 33}]}, + ] + result = harness["_segment_reward_events"]([{"token_start": 0, "token_end": 40, "reward": 8}], segments) + assert result[0] == [] and len(result[1]) == 1 + assert result[1][0]["token_start"] == 0 and result[1][0]["token_end"] == 3 + assert result[1][0]["episode_token_end"] == 40 + assert result[1][0]["segment_spans"] == [ + {"segment_id": 0, "token_start": 0, "token_end": 2}, + {"segment_id": 1, "token_start": 0, "token_end": 3}, + ] + + +def test_snapshot_keeps_inventory_and_zero_counters_in_every_phase(harness): + state = game_state(0) + state["state"] = "SHOP" + state["jokers"]["cards"][0]["state"] = {"debuff": True} + before = deepcopy(state) + compact = json.loads(harness["_compact_state"](state, limit=1)) + assert compact["owned_vouchers"] == [{"id": "v_blank", "effect": ""}] + assert compact["jokers"]["items"][0]["counters"]["mult"] == 0 + assert compact["jokers"]["items"][0]["debuff"] is True + assert compact["hand_values"]["Pair"] == [3, 40, 4] + assert "owned_deck" in compact and "deck" in compact and "truncated" not in compact + assert state == before + + +def test_hidden_card_cannot_be_identified_by_key_instance_or_effect(harness): + state = game_state() + state["hand"]["cards"][0]["state"] = {"hidden": True} + compact = json.loads(harness["_compact_state"](state)) + assert compact["hand"] == [{"hidden": True}] + + +def test_hidden_jokers_keep_known_composition_without_slot_mapping(harness): + state = game_state() + visible = deepcopy(state["jokers"]["cards"][0]) + state["jokers"]["cards"][0]["state"] = {"hidden": True} + state["joker_inventory"] = {"cards": [{**visible, "id": 0}]} + compact = json.loads(harness["_compact_state"](state)) + assert compact["jokers"]["items"] == [{"hidden": True}] + assert compact["joker_inventory"][0]["id"] == "j_green_joker" + assert "instance" not in compact["joker_inventory"][0] + + +def test_delta_never_silently_keeps_stale_shop_fields(harness): + previous = {"phase": "shop", "shop": [{"id": "j_joker"}], "packs": [1], "reroll_cost": 5, "money": 4} + current = {"phase": "BLIND_SELECT", "money": 4} + delta = harness["_delta_payload"](previous, current) + assert delta["shop"] is None and delta["packs"] is None and delta["reroll_cost"] is None + + +def test_segment_count_does_not_change_game_advantage(harness): + def sample(game, reward): + return SimpleNamespace(rollout_id=game, reward=reward, metadata={"balatro": {"seed_group": "same"}}) + original = [sample(1, 10), sample(2, 20)] + split = [sample(1, 10)] * 3 + [sample(2, 20)] * 7 + _, expected = harness["normalize_episode_rewards"](None, original) + _, actual = harness["normalize_episode_rewards"](None, split) + assert actual == [expected[0]] * 3 + [expected[1]] * 7 + + +def test_real_lua_snapshot_preserves_public_mechanics_without_mutation(): + lua = shutil.which("luajit") + if not lua: + pytest.skip("LuaJIT required") + script = r''' +local gs = dofile("src/lua/utils/gamestate.lua") +function pseudorandom() error("must not advance RNG") end +local function card(id, key, ability) + return {sort_id=id, config={card_key=key,card={suit="Spades",value="Ace"}}, + ability=ability, seal="Gold", generate_UIBox_ability_table=function() return {main={}} end} +end +local a=card(10,"S_A",{perma_bonus=30,played_this_ante=true,forced_selection=true,private_seed=999}) +local b=card(11,"S_A",{perma_bonus=0}) +G={STATE=1,STATES={SELECTING_HAND=1},playing_cards={a,b}, + hand={cards={a},config={card_count=1,card_limit=8}}, + deck={cards={b},config={card_count=1,card_limit=52}}, + GAME={current_round={hands_played=2,discards_used=1},last_tarot_planet="c_devil", + used_vouchers={v_blank=true},tags={{key="tag_double",ability={orbital_hand="Pair",private_seed=123}}}, + blind={only_hand="Pair",hands={Pair=true,Flush=false}},pseudorandom={seed="SECRET"}}} +local first=gs.get_gamestate() +assert(first.snapshot_version==1) +assert(first.cards.count==1 and first.owned_cards.count==2) +assert(first.hand.cards[1].id==10 and first.hand.cards[1].counters.perma_bonus==30) +assert(first.hand.cards[1].counters.played_this_ante and first.hand.cards[1].counters.forced_selection) +assert(first.hand.cards[1].counters.private_seed==nil) +assert(first.owned_cards.cards[1].id==0 and first.owned_cards.cards[1].state.hidden==nil) +assert(first.run_state.last_tarot_planet=="c_devil" and first.run_state.round.hands_played==2) +assert(first.blind_state.only_hand=="Pair" and first.blind_state.played_hands.Pair) +assert(first.tags[1].key=="tag_double" and first.tags[1].ability.private_seed==nil) +assert(first.used_vouchers.v_blank=="") +a.ability.perma_bonus=60 +assert(first.hand.cards[1].counters.perma_bonus==30) +assert(gs.get_gamestate().hand.cards[1].counters.perma_bonus==60) +assert(a.sort_id==10 and a.seal=="Gold") +local joker={sort_id=99,config={center_key="j_green_joker"},ability={set="Joker",mult=7}, + facing="back",generate_UIBox_ability_table=function() return {main={}} end} +G.jokers={cards={joker},config={card_count=1,card_limit=5}} +local hidden=gs.get_gamestate() +assert(hidden.jokers.cards[1].state.hidden) +assert(hidden.joker_inventory.cards[1].id==0 and hidden.joker_inventory.cards[1].key=="j_green_joker") +assert(hidden.joker_inventory.cards[1].state.hidden==nil) +print("ok") +''' + result = subprocess.run([lua, "-"], input=script, cwd=ROOT, text=True, capture_output=True, check=True) + assert result.stdout.strip() == "ok" + + +@pytest.mark.parametrize("cp_size", [1, 4]) +def test_pinned_trainer_reducer_weights_unequal_segments_across_microbatches(harness, monkeypatch, cp_size): + """Optional integration with sources read from the actual pinned image.""" + source_dir = os.environ.get("BALATRO_SLIME_SOURCE") + if not source_dir: + pytest.skip("Set BALATRO_SLIME_SOURCE to the pinned image's extracted slime source") + torch = pytest.importorskip("torch") + path = Path(source_dir) / "backends/megatron_utils/cp_utils.py" + tree = ast.parse(path.read_text()) + selected = [n for n in tree.body if isinstance(n, ast.FunctionDef) and n.name in {"get_sum_of_sample_mean", "get_logits_and_tokens_offset_with_cp"}] + mpu = SimpleNamespace(get_context_parallel_world_size=lambda: cp_size) + from collections.abc import Callable + ns = {"torch": torch, "mpu": mpu, "Callable": Callable} + exec(compile(ast.Module(body=selected, type_ignores=[]), str(path), "exec"), ns) + reduce = ns["get_sum_of_sample_mean"] + import inspect + monkeypatch.setattr(inspect, "getfile", lambda cls: str(Path(source_dir) / "utils/types.py")) + harness["_validate_balatro_trainer"](SimpleNamespace(calculate_per_token_loss=False), Sample) + + def contribution(values, denominator): + x = torch.tensor(values) + length = len(values) + total = length + 4 + result = torch.tensor(0.) + for rank in range(cp_size): + mpu.get_context_parallel_rank = lambda: rank + local = x + if cp_size > 1: + *_, offsets = ns["get_logits_and_tokens_offset_with_cp"](total, length) + local = torch.cat([x[lo - 4:hi - 4] for lo, hi in offsets]) + result = result + reduce([total], [length], [torch.ones(length)], [torch.tensor(float(denominator))], False)(local) + return result + + # Two games: A losses [1,3,5,7], B losses [10,20]. Split A into + # unequal segments in different microbatches, keeping its full denominator. + a_first = contribution([1.], 4) + a_later = contribution([3., 5., 7.], 4) + b = contribution([10., 20.], 2) + assert ((a_first + a_later + b) / 2).item() == pytest.approx((4 + 15) / 2) diff --git a/tests/test_hand_recognition.py b/tests/test_hand_recognition.py new file mode 100644 index 00000000..9362bef6 --- /dev/null +++ b/tests/test_hand_recognition.py @@ -0,0 +1,60 @@ +"""Regressions from actual losses; helpers must use only visible card faces.""" + +import ast +import json +from pathlib import Path +from typing import Any + +import pytest + +ROOT = Path(__file__).resolve().parents[1] + + +@pytest.fixture +def compact(): + tree = ast.parse((ROOT / "batro_modal_rl.py").read_text()) + node = next(n for n in tree.body if isinstance(n, ast.FunctionDef) and n.name == "_compact_state") + ns = {"json": json, "Any": Any} + exec(compile(ast.Module(body=[node], type_ignores=[]), "compact", "exec"), ns) + def render(cards): + return json.loads(ns["_compact_state"]({ + "state": "SELECTING_HAND", "hand": {"cards": cards}, + "round": {}, "blinds": {}, + })) + return render + + +@pytest.mark.parametrize("case", json.loads((ROOT / "tests/fixtures/broad_layover_decisions.json").read_text())) +def test_recorded_winning_combination_is_explicit(compact, case): + state = compact([{"key": key} for key in case["hand"]]) + groups = state["hand_groups"]["same_rank"] + assert sorted(i for indices in groups.values() for i in indices) == case["winning_cards"] + assert case["winning_score"] >= case["blind"]["score"][1] - case["blind"]["score"][0] + + +def test_groups_reindex_when_hand_changes(compact): + before = compact([{"key": k} for k in ["H_A", "H_K", "C_K", "D_K"]]) + after = compact([{"key": k} for k in ["D_K", "H_A", "C_K", "H_K"]]) + assert before["hand_groups"]["same_rank"]["K"] == [1, 2, 3] + assert after["hand_groups"]["same_rank"]["K"] == [0, 2, 3] + + +def test_hidden_cards_and_stone_cards_do_not_supply_ranks(compact): + state = compact([ + {"key": "H_K"}, + {"key": "C_K", "state": {"hidden": True}}, + {"key": "D_K", "modifier": {"enhancement": "STONE"}}, + ]) + assert not state.get("hand_groups", {}).get("same_rank") + + +def test_straight_examples_and_suit_groups_use_current_visible_indices(compact): + state = compact([{"key": k} for k in ["H_A", "H_K", "S_Q", "H_J", "D_J", "H_T", "S_8", "C_2"]]) + assert state["hand_groups"]["straight_examples"] == [[5, 3, 2, 1, 0]] + assert state["hand_groups"]["same_suit"] == {"H": [0, 1, 3, 5]} + + +def test_wheel_and_duplicate_ranks(compact): + state = compact([{"key": k} for k in ["S_A", "H_2", "C_3", "D_4", "S_5", "C_5"]]) + assert state["hand_groups"]["straight_examples"] == [[0, 1, 2, 3, 4]] + assert state["hand_groups"]["same_rank"] == {"5": [4, 5]} diff --git a/tests/test_pack_selling.py b/tests/test_pack_selling.py new file mode 100644 index 00000000..e97fe0e6 --- /dev/null +++ b/tests/test_pack_selling.py @@ -0,0 +1,158 @@ +"""Pack replacement regressions: grammar, legal hints, and Lua sale/selection.""" + +import ast +import copy +import json +import re +import shutil +import subprocess +from pathlib import Path +from types import SimpleNamespace +from typing import Any + +import pytest + +ROOT = Path(__file__).resolve().parents[1] + + +@pytest.fixture +def harness(): + tree = ast.parse((ROOT / "batro_modal_rl.py").read_text()) + functions = { + "_compact_state", "_area_items", "_slot_usage", "_sellable_indices", + "_purchasable_indices", "_consumable_target_bounds", "_consumable_requires_joker", + "_target_action_help", "_action_help", "_action_is_locally_legal", "_action_regex", + } + constants = {"_INDEX", "_INDEX_LIST", "_INDEX_LIST_5", "_ALLOWED_METHODS", "_ACTION_REGEX_BY_STATE"} + nodes = [node for node in tree.body if ( + isinstance(node, ast.FunctionDef) and node.name in functions + or isinstance(node, ast.Assign) and any(isinstance(t, ast.Name) and t.id in constants for t in node.targets) + )] + ns = {"Any": Any, "json": json, "ToolCall": SimpleNamespace, "_CONSUMABLE_TARGET_BOUNDS": {}, "_CONSUMABLE_REQUIRES_JOKER": set()} + exec(compile(ast.Module(body=nodes, type_ignores=[]), "batro_modal_rl.py", "exec"), ns) + return ns + + +def pack_state(): + return { + "state": "SMODS_BOOSTER_OPENED", + "jokers": {"count": 5, "limit": 5, "cards": [ + {"key": "j_joker", "cost": {"sell": 1}, "modifier": {"eternal": i == 0}} + for i in range(5) + ]}, + "consumables": {"count": 1, "limit": 2, "cards": [{"key": "c_fool", "cost": {"sell": 1}}]}, + "pack": {"count": 1, "cards": [{"key": "j_blueprint"}]}, + } + + +def test_pack_exposes_sale_then_unlocks_selection(harness): + state = pack_state() + sell = SimpleNamespace(name="sell", arguments={"joker": 1}) + pick = SimpleNamespace(name="pack", arguments={"card": 0}) + assert "sell" in harness["_ALLOWED_METHODS"][state["state"]] + for kind in ("joker", "consumable"): + assert re.fullmatch(harness["_action_regex"](state["state"]), f'{{"method":"sell","params":{{"{kind}":1}}}}') + help_text = harness["_action_help"](state) + assert "sell joker=one of [1, 2, 3, 4]" in help_text + assert "sell consumable=one of [0]" in help_text + assert "keeps pack open" in help_text + assert "pack card=" not in help_text + assert harness["_action_is_locally_legal"](sell, state) + assert not harness["_action_is_locally_legal"](pick, state) + after = copy.deepcopy(state) + after["jokers"]["cards"].pop(1) + after["jokers"]["count"] = 4 + assert "pack card=0" in harness["_action_help"](after) + assert harness["_action_is_locally_legal"](pick, after) + assert after["pack"] == state["pack"] + + +@pytest.mark.parametrize("index", [0, -1, 5, True, "1"]) +def test_pack_sale_rejects_eternal_or_invalid_index(harness, index): + assert not harness["_action_is_locally_legal"]( + SimpleNamespace(name="sell", arguments={"joker": index}), pack_state(), + ) + + +@pytest.mark.parametrize("phase", ["SHOP", "SELECTING_HAND", "BLIND_SELECT"]) +def test_existing_sale_phases(harness, phase): + state = {**pack_state(), "state": phase} + assert harness["_action_is_locally_legal"]( + SimpleNamespace(name="sell", arguments={"joker": 1}), state, + ) is (phase != "BLIND_SELECT") + + +def test_lua_sale_preserves_pack_and_allows_replacement(): + lua = shutil.which("luajit") + if not lua: + pytest.skip("LuaJIT required") + script = r''' +package.preload.socket=function() return {gettime=function() return 0 end} end +SMODS={load_file=function() return function() return {} end end} +function sendDebugMessage() end +function Event(e) return e end +BB_ERROR_NAMES={NOT_ALLOWED="NOT_ALLOWED",BAD_REQUEST="BAD_REQUEST"} +G={STATES={SMODS_BOOSTER_OPENED=1,SHOP=2,SELECTING_HAND=3,BLIND_SELECT=4}, + STATE=1,STATE_COMPLETE=true,GAME={dollars=5,pack_choices=2},P_CENTERS={}} +local function card(id,eternal) + return {sort_id=id,sell_cost=2,ability={name="Joker",set="Joker",eternal=eternal}, + can_sell_card=function(self) return not self.ability.eternal end} +end +G.jokers={cards={card(1,true),card(2),card(3),card(4),card(5)},config={card_count=5,card_limit=5}} +G.consumeables={cards={card(6)},config={card_count=1,card_limit=2}} +G.pack_cards={cards={card(7),card(8)},config={card_count=2}} +local original_pack=G.pack_cards +local events={} +G.E_MANAGER={add_event=function(self,e) table.insert(events,e) end} +G.FUNCS={sell_card=function(e) + for _,area in ipairs({G.jokers,G.consumeables}) do + for i,c in ipairs(area.cards) do + if c==e.config.ref_table then + table.remove(area.cards,i);area.config.card_count=#area.cards + G.GAME.dollars=G.GAME.dollars+c.sell_cost + return + end + end + end +end,use_card=function(e) + assert(#G.jokers.cards Date: Mon, 19 Oct 2026 19:18:59 -0400 Subject: [PATCH 5/7] :new: Bot --- .gitignore | 5 +- TRAINING.md | 621 ++++++++++++++++++- batro_modal_rl.py | 664 ++++++++++++++++----- dashboard/TrajectoryViewer.svelte | 82 ++- dashboard/TrajectoryViewer.test.mjs | 64 +- launch-8node-skip-reward-fix-20260909.json | 1 - launch-perfect-batch64-20260914.json | 1 - launch-perfect-continuation-20260914.json | 1 - launch-reward-guard-20260908.json | 1 - launch-reward-guard-20260908c.json | 1 - launch-skip-reward-fix-20260909.json | 1 - tests/test_context_management.py | 377 +++++++++++- tests/test_pack_selling.py | 35 +- tests/test_training_launch.py | 77 ++- training/cloud_watchdog.py | 101 ++++ 15 files changed, 1833 insertions(+), 199 deletions(-) delete mode 100644 launch-8node-skip-reward-fix-20260909.json delete mode 100644 launch-perfect-batch64-20260914.json delete mode 100644 launch-perfect-continuation-20260914.json delete mode 100644 launch-reward-guard-20260908.json delete mode 100644 launch-reward-guard-20260908c.json delete mode 100644 launch-skip-reward-fix-20260909.json create mode 100644 training/cloud_watchdog.py diff --git a/.gitignore b/.gitignore index b291817f..3b1b759e 100644 --- a/.gitignore +++ b/.gitignore @@ -7,7 +7,8 @@ __MACOSX/ .AppleDouble .LSOverride -Icon[ ] +Icon[ +] # Thumbnails ._* @@ -331,3 +332,5 @@ balatrobot_oldish.lua balatro_oldish.sh balatro.sh +.launch-config-examples +reports \ No newline at end of file diff --git a/TRAINING.md b/TRAINING.md index be596f5d..76d2ce32 100644 --- a/TRAINING.md +++ b/TRAINING.md @@ -1,7 +1,483 @@ -# Training launch safety +# Training experiments -Run `batro_modal_rl.py` with the Training Gym dependencies in **Python 3.12**, -matching the remote image. Keep `colocate=True` in the recipe. +## Define experiments in Python + +[`experiments.py`](experiments.py) is the experiment catalog. Each definition +builds a Dojo `TrainConfig` directly in code. Add variants with +`dataclasses.replace(BASE, ...)`; JSON configuration files are unnecessary. + +```sh +# List experiments, then preview locally (no remote calls or files written). +./training/dojo.sh python experiments.py +./training/dojo.sh python experiments.py thinking_8k_200 + +# Validate datasets and exact checkpoint without allocating GPUs. +./training/dojo.sh python experiments.py thinking_8k_200 --validate + +# Submit and register cloud monitoring. Reusing a trial prevents duplicates. +./training/dojo.sh python experiments.py thinking_8k_200 --trial baseline --launch +``` + +The catalog includes `proof` (1 update), `smoke` (10), `reward_to_go_200`, and +`thinking_8k_200` (200 updates with 8,192 thinking tokens). All start from +`perfect-adhesive-da14ace5a831/iter_0000399` with a fresh optimizer. These names +describe configurations, not evidence that training will succeed. + +Python callers can use the same definitions: + +```python +from experiments import EXPERIMENTS, launch + +config = EXPERIMENTS["thinking_8k_200"].build() # actual Dojo TrainConfig +run = launch("thinking_8k_200", trial="baseline") +``` + +Dojo stores the resolved training configuration with the run. The local launcher +automatically writes only a submission receipt under +`reports/experiments///receipt.json`. This records the run ID +and blocks accidental resubmission, including after an interrupted launch. +Never delete a receipt to retry an uncertain submission; inspect the remote run +first. Choose a new trial name for an intentional new experiment. + +The old `.launch-config-examples/` exports were removed. Historical launch +receipts are retained under `reports/legacy-launches/` for diagnosis; generated +evidence and receipts are not experiment inputs. `balatro_compare.py` remains +available as a lower-level builder/CLI and no longer writes `.config.json` files. + +## Modal Dojo (October 19) + +Replacement run: `overcast-groove-11909ffa4c8f`, 200 updates from +`perfect-adhesive-da14ace5a831/iter_0000399`, fresh optimizer, 8K thinking. +The former `naive-rotation-0d3fe4fb61a0` app was stopped and its zero remaining +containers verified before submission. The Dojo dashboard is +`https://modal-labs-joy-dev--dojo-dashboard-fastapi-app.modal.run`. +Launch receipt and migration evidence are in +`reports/launch-dojo-200step-20261019.json` and `reports/dojo-migration-20261019.json`. + +The active launch and monitoring code now uses `modal_dojo`; the Training Gym +checkout is no longer a dependency. Bootstrap the isolated Python 3.12 project: + +```sh +uv run --no-project --python 3.12 training/setup_dojo.py +uv sync --project training --group test +``` + +For an existing Dojo source checkout, pass `--source ../modal-dojo` to the +bootstrap command. It clones pinned revision `0bd6789d1be43c1eb10928d3d69be55de2d2533e` +into `training/.dojo` and applies `training/dojo-checkpoint-recovery.patch`. +The patch preserves strict shard validation, committed-save verification, +temporary Gloo-group cleanup, and correct optimizer/RNG restoration on retry. +It also supports a project-local configuration file and preserves the dashboard's +Modal environment. It does not edit the source checkout or global Dojo settings. + +Use `training/dojo.sh` for all training commands. It selects the pinned package, +Python 3.12, profile `modal-labs`, environment `joy-dev`, and private configuration +`training/.dojo-config.toml`. Explicit environment overrides take precedence. +The Balatro model, rewards, thinking handoff, topology, and checkpoint-volume +name remain unchanged. The new dashboard uses `modal-dojo-metadata`; historical +Training Gym records stay in their original volume. + +```sh +# Validate configuration, dataset rows, and exact checkpoint 399 without GPUs. +./training/dojo.sh python experiments.py thinking_8k_200 --validate + +# Submit once; wait for the receipt to say "submitted". +./training/dojo.sh python experiments.py thinking_8k_200 --trial baseline --launch + +# Deploy the watchdog when its code changes (launch registers runs automatically). +./training/dojo.sh modal deploy training/cloud_watchdog.py + +./training/dojo.sh modal-dojo run get RUN_ID --verbose +./training/dojo.sh python training/monitor_run.py RUN_ID --learning +``` + +The Dojo watchdog uses its own `balatro-dojo-watchdog` app/registry and metadata +volume, so it cannot confuse an old Training Gym run with a Dojo run. Dashboard +CLI reads still require the dashboard's existing authentication; failed reads +are not evidence of a training failure. + +Migration checks: 237 local harness tests, 35 checkpoint/recovery tests, 3 real +Dojo API checks, 42 viewer tests, and 75 pinned-trainer CPU tests passed. Native +CPU validation also reproduced the old process-group cleanup error and passed +three corrected saves on each of two ranks. These are compatibility checks, +not evidence of improved learning. + +## Thinking-budget handoff (October 12) + +At the 8,192-token thinking limit, the harness now inserts `` and +continues generation with a separate 96-token final-answer allowance. The +inserted token remains in the exact inference/training context, with zero +loss mask and no action advantage. Naturally sampled closing tokens retain +normal training credit. Reaching the thinking budget alone is no longer an +invalid action; malformed or length-limited final answers still receive the +existing penalties and execute no game action. + +Context reservations include up to 8,289 physical response tokens: 8,192 +sampled thinking tokens, one optional control token, and 96 sampled answer +tokens. Sampled-token percentiles exclude the inserted control token. +`thinking_forced_close_count/fraction` track handoffs, and episode metrics +separate `balatro/control_tokens` from feedback tokens. + +Validation and limitations: `reports/thinking-handoff-fix-20261012.md`. +No replacement training run was launched for this fix. + +## Thinking relaunch (October 5) + +`warped-median-9f188a4959eb` uses the same 200-update, 8,192-token thinking +recipe from `perfect-adhesive-da14ace5a831/iter_0000399` with a fresh optimizer. +Thinking runs now checkpoint every five updates and allow ten bounded whole-job +recoveries. The previous thinking run hit the 24-hour Modal invocation limit; +recovery still loads this run's latest complete checkpoint and keeps the same +200-update target. + +The parent run's metadata was unavailable while checkpoint 399 remained intact. +The comparison launcher can now locate its deterministic checkpoint volume and +validate the exact iteration directly; missing or invalid weights still fail +preflight. Checkpoint 399's shard manifest matched its predecessor. + +The dashboard endpoint was unavailable. It was redeployed with its Modal +environment preserved, and an authenticated empty metric request returned HTTP +200 before submission. The cloud watchdog was redeployed as well. Launch +checks: 74 passed, one native-image-only skip. Evidence and source hashes: +`reports/thinking-8k-provenance-20261005.json`. + +## Optional 8K thinking (October 1) + +`balatro_compare.py --thinking-budget 8192` enables the model's thinking chat +template for initial snapshots and every feedback turn. Each decision has up +to 8,192 sampled thinking tokens, including a naturally sampled closing `` token, then +up to 96 tokens for the final JSON action. The serving request pauses at the +sampled closing token and resumes with those exact IDs in its prefix. As of +October 12, exhausting the thinking budget without closing the block inserts +a masked control token and continues to the final answer (see above). + +Both reasoning and final-answer tokens retain their sampled log probabilities +and action advantage. Strict single-action validation applies to the final +answer only. Context reservations include up to 8,289 physical response tokens; +thinking runs use a 16,384-token segment target within the same 49,152-token +hard context limit. Initial checkpoint, optimizer reset, reward, topology, +held-out seeds, and 200-update horizon remain the comparison recipe's defaults. + +Diagnostics report total sampled `action_tokens_*`, plus separate +`thinking_tokens_*` and `final_answer_tokens_*` percentiles and +`thinking_budget_hit_fraction`. Watchdog length-limit and malformed-output +checks still apply to invalid responses. Long reasoning alone is not treated as +repeated-action output. + +## Single-action output contract (September 30) + +The harness now validates the entire generated response: exactly one JSON +object with `method` and `params`, followed by natural termination. Whitespace +and one terminal Qwen end token are allowed. Extra objects, prose, duplicate +keys, malformed parameters, and output-limit finishes reject the response. +Custom stop strings/tokens and `ignore_eos` are rejected at preflight so they +cannot hide trailing output. Generation remains unconstrained by a grammar. + +A rejected response executes no game action. It receives a -2 task-reward +penalty and corrective feedback against the unchanged game state. Three +consecutive rejections end the episode; every sampled attempt counts toward +the 250-decision cap. Original sampled token IDs and log probabilities remain +in training, including all rejected output. The existing invalid-action +advantage ceiling of -5 applies to its entire token span, even if a later retry +wins the game. + +Episode metadata records exact token lengths for every sampled action. +Diagnostics deduplicate context segments and report `action_tokens_mean`, +`action_tokens_p50/p90/p95/p99`, and format-invalid, multiple-object, +length-limit, and normal-stop counts/fractions under `rollout/` and +`eval/{dataset}/`. These evaluation metrics do not depend on the training loss +mask. Historical episodes without the metadata do not get fabricated zeros. + +The deployed watchdog stops immediately when at least half of a batch's +responses violate format, contain multiple objects, or hit the output limit. +It also stops after three consecutive batches with multiple-object rates at +least 5%, length-limit rates at least 25%, or format-invalid rates at least 10%. +Each qualifying batch must contain at least 32 actions. These checks operate +independently of reward and do not require a completed baseline evaluation. + +Validation: 260 local tests passed (8 dependency-related skips), and 54 tests +passed in the pinned Slime image on CPU. Replay rejected all 3,883 responses +from collapsed rollout 179 of `crispy-refresh-69af089563f9`, even assuming a +normal finish. That run remains stopped. No replacement run or GPU validation +has been launched for this change; these checks establish contract behavior, +not improved learning. Evidence: +`reports/single-action-contract-fix-20260930.md`. + +## Ten-update smoke completed (September 23) + +`inventive-groove-c49694376007` completed all ten updates from +`perfect-adhesive-da14ace5a831/iter_0000399`, saved a complete +`iter_0000009`, and finished final evaluation on its first attempt. The recipe +requested 64 H100s with TP4/PP2/CP4; the inspected head node received eight +H200s. Model, sampling correction, reward, context, and parallelism match the +one-update proof. No production code changed for this test. + +On the same 32 greedy held-out seeds, mean reward improved **67.6030 → +88.4506 (+30.8%)**, mean ante **3.1875 → 3.65625**, and invalid actions +**54/2,460 → 27/2,869 turns**. Reward increased on 22 seeds, decreased on +eight, and was unchanged on two. Both evaluations had **0/32 wins** and a +best ante of six. The ten training updates kept trainer/rollout probability +disagreement between **0.00281 and 0.00444**, with gradient norms between +**1.37 and 1.95**. Audits cover every generated action in all ten batches; +none showed the previous one-card collapse. + +The 250-decision cap truncated two viable training games in batch six +(zero-based): one at ante seven and one at ante eight, each with only one +invalid action. Neither counts as a win. This is a demonstrated evaluation +limitation to address before interpreting the win rate or promoting a longer +run. Ten stable updates do not establish stability over 200 updates; the +historical collapse occurred later. + +The run took about two hours including startup, checkpointing, and evaluation. +Its Modal app is stopped, with zero active GPU containers verified. +Evidence: `reports/unconstrained-smoke-20260923.json`, per-batch trace audits, +384 episode summaries, optimizer metrics, and checkpoint validation. + +## Original 27B trainer restored (September 22) + +The JEV experiment has been removed. `batro_modal_rl.py` and +`balatro_compare.py` remain the active Qwen3.8-27B training path, using the +existing game reward, checkpoint recovery and trajectory viewer. + +The grammar correction below is retained. Launch preflight and episode entry +now reject sampling settings this harness cannot reproduce in training: +grammar constraints, top-p/top-k/min-p truncation, logit bias/processors and +non-default repetition/presence/frequency penalties. Training explicitly uses +temperature 1, top-p 1 and top-k -1; greedy held-out evaluation remains allowed. +Invalid settings fail before checkpoint pinning, receipt creation or GPU +submission. Missing/nonfinite serving log probabilities fail rather than +silently entering a training sample. + +The 64-H100 proof `spatial-hot-dog-47bd4700e214` completed one optimizer +update from parent checkpoint 399. Trainer/serving log-probability disagreement +was 0.00433 and gradient norm was 1.951; checkpoint `iter_0000000` passes +distributed shard validation. Its Ray control-plane connection failed after +the save, exhausting all five deduplicated RPC retries before final evaluation. +These results validate one corrected update, not long-term learning stability. + +Proof and smoke configs now allow the same two whole-job retries as full runs. +The checkpoint image patch also evaluates restored final weights when the +last checkpoint leaves no optimizer updates to run. Previously that recovery +path could exit without the interrupted final evaluation. Tests cover explicit +evaluation-only runs, final-checkpoint recovery, and normal mid-run recovery. + +The interrupted 32-seed final evaluation completed separately as +`knurled-kasseri-e6a606c5b791`, loading proof checkpoint 0 with zero additional +training updates. Its evaluation-only allocation is one node of 8 H100s, +TP4/PP2/CP1 (serving TP2), with the same 49,152-token context and seeds. +The earlier 64-GPU evaluation `covering-backpack-f4fc25b5d62f` was stopped +while queued for capacity. Mean held-out reward was **70.5175 before** and +**70.4757 after** the update. Both evaluations averaged ante 3.1875, reached +ante 6, and had 0/32 wins. This is a correctness proof, not evidence of learning +improvement. All five apps are stopped with no active GPU containers. + +Evidence: `reports/unconstrained-gpu-proof-20260922.json`, the training trace +audit, per-game evaluation logs, checkpoint validation, and final app states. +Regression checks: 134 passed, 5 dependency-related skips. + +`build_checkpoint_evaluation` keeps a positive scheduler horizon with an empty +training range (`start_rollout_id=num_rollout=1`); Slime's nominal +`num_rollout=0` evaluation mode otherwise trips Megatron's scheduler assertion. +Comparison recipes explicitly package `balatro_compare.py` so imported +recovery launchers can deserialize the held-out dataset on workers. + +## Generation/training probability correction (September 21) + +`arid-gate-422819ed43e1` was stopped after 60 updates for sustained policy +collapse. Fixed-seed reward rose from 64.61 to 79.46 at update 20, then fell to +60.02, 43.41, 4.50, and -0.18 at updates 30/40/50/60. Every game in the last +eight training batches ended at ante 1. All 124 generated play actions in +batch 59 selected one card. Checkpoints 9 through 59 saved; this was a policy +failure, not a repeat of the checkpoint RPC crash. + +The pinned SGLang image applies the regex vocabulary mask before computing +returned log probabilities. The Megatron loss does not replay that mask. +The harness therefore sampled a constrained policy while optimizing an +unconstrained one. Trainer/rollout log-probability disagreement grew from +about 0.003 to 28.43. PPO used recomputed trainer probabilities for its old +policy; its clipping metric stayed zero and did not expose this discrepancy. + +Generation now omits the regex and rejects inherited regex/JSON-schema/EBNF +constraints. Prompts, parsing, action validation, repair, and reward penalties +remain in effect. Reintroducing constrained decoding requires matching mask +replay in the trainer, not just changing the old-logprob flag. Local regression +checks pass; the September 22 proof and September 23 smoke results above +provide GPU validation and matched baseline evaluations. The exact contribution of +this bug versus other optimization choices is not yet established by ablation. + +Evidence: `reports/arid-gate-collapse-diagnosis-20260921.json`, saved traces, +and the exact pinned implementation in `reports/pinned-probability-source/`. +Do not resume the collapsed checkpoint. Checkpoint 19 is the best saved +held-out result; the original parent 399 is also available for a clean comparison. + +## Pipeline communication correction (September 17) + +The pinned Slime image drops the `group` argument from all four `P2POp` +constructors in Megatron's `_batched_p2p_ops`. Payload transfers therefore use +the default WORLD group, while shape exchanges use the intended pipeline +subgroup. `nearest-dialogue-25c4f89a4658` timed out in this payload path on +WORLD during its first reference forward pass, before any optimizer update. + +`training/patch_pipeline_group.py` restores the subgroup argument, matching +upstream Megatron. Both Balatro credit modes install it at image build; the +patch rejects unfamiliar source and is safe to apply again. It does not +change the topology, checkpoint, context limits, reward, or optimizer settings. + +`tests/test_pipeline_group.py` exercises the pinned image's transfer function. +The bounded four-GPU regression in `training/pipeline_group_modal.py` checks +independent pipeline pairs and repeated Slime process-group reloads without +loading a model or playing games. This isolates communication correctness; +it does not measure training progress or establish that every cause of the +original 64-GPU hang has been eliminated. + +## Context and action-credit correction (September 16) + +The recipe now explicitly sets both `max_position_embeddings` and +`sglang_context_length` to **49,152**, with an **8,192** working-history target. +The previous run inherited `max_position_embeddings=4096`, silently forcing +much more frequent history resets. Local launch validation requires explicit +limits; workers reject a trainer/serving limit below the requested hard budget +before acquiring a game. The 49k hard allowance permits large snapshots; +normal histories still reset around 8k. + +Two experiment modes keep the context change separable from credit assignment: + +- `--credit-assignment episode` (default): corrected context, existing game-level GRPO. +- `--credit-assignment reward_to_go`: corrected context plus per-action returns. + +Reward-to-go records the reward accumulated **before** every generated action. +Each action's remaining return is the final reward minus that prior total, +including terminal bonuses and penalties. A leave-one-game-out baseline uses +the other games on the same seed at the same decision number; ended peers +have zero remaining return. The scale is the standard deviation of complete +game rewards with a floor of one reward unit. This is a variance-reduction +baseline, not a comparison between identical game states or a score oracle. + +The new mode does not sum overlapping dashboard checkpoint events. It retains +the current reward components and shared-game loss denominator. Advantages +cover only the original generated action tokens; state-feedback tokens remain +masked out. An earlier success therefore cannot directly reward a later bad +move. Earlier moves still receive credit for future outcomes, so this alone +does not guarantee that a missed flush or a poor purchase gets penalized. + +`training/balatro_credit.py` installs the native custom-advantage hook and a +small transport patch for the pinned Slime image: training metadata must survive +data-parallel partitioning and be excluded from numeric metric aggregation. +Unsupported source, missing metadata, token gaps/overlaps and mismatched +context-parallel slices fail explicitly instead of falling back to scalar GRPO. + +CPU-only preflight, from the Training Gym Python 3.12 environment: + +```sh +uv run python /Users/joyliu/balatrobot/batro_modal_rl.py --num-rollout 1 +uv run python /Users/joyliu/balatrobot/batro_modal_rl.py --num-rollout 1 \ + --credit-assignment reward_to_go +``` + +Neither command launches GPUs. Existing runs keep their deployed code. For a +training experiment, use fresh run IDs and the same initial weights and seeds: +prove one update, then compare roughly ten updates per mode with matched +held-out evaluations. Inspect effective context limits, actual token advantages, +win rate, final ante, and scoring decisions before promoting a longer run. +Preserving an old optimizer is not a requirement for a changed estimator. + +CPU integration tests can use Slime sources extracted from the pinned image: + +```sh +BALATRO_SLIME_SOURCE=/path/to/extracted/slime uv run --with torch \ + pytest tests/test_action_credit.py tests/test_context_management.py -q +``` + +Those tests execute the pinned converter, DP transport, native advantage hook, +CP slicing and per-game reducer with one and four context-parallel ranks, using +CPU tensors. They establish signal plumbing and gradient weighting, not model +improvement or a successful distributed GPU update. + +## Broad-layover recovery fixes + +The local Training Gym checkout now validates every shard and required byte +range referenced by a checkpoint's `.metadata`, both in public checkpoint +listing and automatic Slime recovery. An invalid latest checkpoint triggers +a search for an older valid checkpoint. The launcher pins that exact actor +iteration and keeps reference-model loading independent of it. + +Checkpoint saving coordinates volume commits over Gloo. After all node +commits, the coordinator reloads the committed view, validates its shards, +and publishes `training_gym_complete.json`. Legacy checkpoints remain usable +when their metadata and byte ranges validate; the marker alone is never +treated as proof of completeness. + +This Balatro recipe sets `NCCL_RAS_ENABLE=0` to avoid the RAS peer-update +subsystem in broad-layover's native crash stack. This is a scoped workaround, +not a claim that the underlying NCCL library defect was repaired. NVIDIA +documents the switch in its [NCCL environment reference](https://docs.nvidia.com/deeplearning/nccl/user-guide/docs/env.html#nccl-ras-enable). + +`broad-layover` checkpoint 449 has 16 missing shards and another 16 truncated +shards. It cannot be repaired by retrying or by creating a completion marker. +The validator rejects it without modifying its data. + +Decision snapshots now include `hand_groups`: visible matching ranks, suit +groups, and example standard straights using current indices. Hidden and +Stone cards do not contribute ranks. These are recognition aids, not score +predictions or action replacements. Joker-specific scoring and hand rules +still matter. Two recorded avoidable losses are permanent fixtures in +`tests/fixtures/broad_layover_decisions.json`. + +The new code needs a fresh run/image to take effect. CPU tests and validation +of stored checkpoints do not establish improved model performance or prove +multi-node save/reload. Compare fixed seeds and the recorded decision +fixtures in a short experiment before extending training. + +## Bounded game context + +The harness now starts a fresh conversation from current game state when the +active conversation would exceed `balatro_segment_tokens` (default **8,192**). +The same game continues. Each conversation is a separate training sample; +all samples share the game's `rollout_id` and final reward. The recipe uses +Slime's per-game loss reduction (`calculate_per_token_loss=False`). + +Historical recipes such as perfect-adhesive used per-token weighting (`True`) +and must override it to `False` when paired with this segmented harness. +`_launch_training` validates this requirement before creating a receipt, +pinning a checkpoint, or allocating GPUs. The worker repeats the same check. + +`balatro_context_len` remains **49,152**. Actual request limits also account +for serving capacity, training padding and the next action. An essential +snapshot that cannot fit reports `state_budget_exceeded`; it is never silently +truncated. A snapshot larger than the 8k working target can use the available +hard-limit space. + +Before the next launch, run `python batro_modal_rl.py --prepare-assets` in the +Training Gym Python 3.12 environment to publish the updated Lua snapshot +fields. Older assets are rejected as `state_schema_mismatch`. The harness +checks trainer support before starting a game. The pinned Training Gym image +was checked on CPU for shared-game loss reduction across unequal segments. + +`balatro/context_tokens` now means **peak active conversation size**. +`balatro/episode_archive_tokens` measures accumulated initial-prompt/action/ +feedback tokens, excluding repeated reset snapshots; `segment_context_tokens` +measures each training sequence. Game-level metrics are emitted once on the +first segment. Reward events include segment-local token offsets and mappings +for checkpoints spanning several segments. + +Each segment has its own snapshot and trajectory messages for dashboard replay. +The first sample also carries `balatro_episode_archive` for full training/debug +serialization. Training Gym's generic dashboard metadata size cap can omit that +large archive; use the individual segments there. Raw training `tokens` and +`response` contain only accepted context; trajectory messages also record the +final state update when it was too large to include in that context. + +CPU regression checks: + +```sh +uv run pytest tests/test_context_management.py tests/test_training_launch.py \ + tests/test_joker_scoring_state.py tests/test_pack_legality.py -q +``` + +## Launching and resuming + +Run `batro_modal_rl.py` through `./training/dojo.sh python` to use the pinned +Modal Dojo dependencies in **Python 3.12**, matching the remote image. Keep `colocate=True` in the recipe. Validate a one-rollout checkpoint continuation without allocating GPUs: @@ -15,15 +491,15 @@ upper bound, not the number of additional rollouts. From checkpoint 199, target 200 does no work, 201 performs one rollout, and 400 performs 200. To submit, add `--launch --launch-record /absolute/path/to/new-launch.json`. -Keep the local command alive until it prints `Training Gym run id` and the +Keep the local command alive until it prints `Modal Dojo run id` and the receipt says `submitted`, with both a Modal app ID and function-call ID. -After that, Training Gym's detached app outlives the local process. +After that, Modal Dojo's detached app outlives the local process. Do not use an auto-restarting supervisor for the submission command. Reuse the same receipt path if an existing invocation is restarted: its exclusive creation prevents duplicate submissions. A receipt left at `submitting` means the outcome is uncertain, not that retrying is safe. Check the launch -log and Training Gym run before deliberately choosing a new receipt path. +log and Modal Dojo run before deliberately choosing a new receipt path. A dashboard cancellation reason of `stale_pre_active_no_modal_app` means the run record never acquired a persisted Modal app ID before the stale-run @@ -35,3 +511,136 @@ CPU-only regression checks: ```sh uv run pytest tests/test_training_launch.py -q ``` + +### Checkpoint RPC recovery + +For the current Balatro training workflow, the user has authorized launching +replacement runs, continuing to monitor them, diagnosing failures, and trying +repairs (2026-09-21). Keep supervising each run through a terminal result; +reassess held-out performance as well as infrastructure health. A background +log collector alone does not provide agent diagnosis or repair. + +The persistent launcher package is `training/.dojo`, created by +`training/setup_dojo.py` with the pinned revision and recovery patch described +above. The source `../modal-dojo` checkout stays untouched. Balatro owns its sandbox lifecycle helpers and pins +the existing H100/TP4/PP2 topology explicitly because current main no longer +provides the branch-only environment helpers or the old model preset defaults. +FlashAttention is pinned explicitly: main's default unfused backend does not +support our CP=4 setup. Local launch validation rejects that incompatible pair. +The patch preserves main's optional `common.pt` support and lazy Modal imports. +It also clears the parent's +fresh-finetune/RNG flags when retrying from the run's own checkpoint, so +optimizer and RNG restoration are not accidentally suppressed. The 200-step +comparison configuration allows two whole-job retries as a fallback; each +retry retains the original 200-step horizon. + +The Balatro training image installs `training/patch_checkpoint_rpc.py` and +`training/checkpoint_rpc.py`. Checkpoint saves now retry an unavailable Ray +worker RPC up to five times, with delays of 2, 4, 8, 16, and 30 seconds. The +whole save has a 30-minute deadline. + +Each save has one operation ID shared across all workers and retries. A worker +records completion only after its original `save_model` returns, including +checkpoint commit and model offload. If its reply is lost, it acknowledges the +same operation without repeating the save or its distributed collectives. A +request lost before execution can run on retry. Successful peers are not +resubmitted. Workers remain single-threaded with in-place restarts disabled, +so their completion records have the same lifetime as their model state. + +This recovery applies to `ActorUnavailableError` at the RPC boundary. Save +exceptions, confirmed worker death, exhausted retries, and deadline expiry +remain failures requiring whole-group recovery. It does not change the +launcher's whole-job retry policy or restart existing runs. + +Run the local regression tests: + +```sh +uv run --group test pytest tests/test_checkpoint_rpc.py tests/test_pipeline_group.py tests/test_training_launch.py -q +``` + +The integration check runs two real Ray workers with CPU Gloo collectives in +the pinned Slime image. It injects lost requests/replies at the client boundary, +verifies each save executes once, verifies the next collective still works, +and checks that application errors, worker death, and exhausted retries fail. +Run from the Python 3.12 Modal Dojo checkout used for launches: + +```sh +./training/dojo.sh modal run training/checkpoint_rpc_modal.py \ + --out /Users/joyliu/balatrobot/reports/checkpoint-rpc-integration.json +``` + +### Strong invalid-action penalties + +The default `reward_to_go` mode assigns rejected model outputs an advantage +of **−5 or more negative**, applied after game-reward normalization. Large +reward variance and successful harness repairs cannot shrink or reverse that +penalty. More negative task credit is retained. Valid-action credit, displayed +game scores, and the exclusion of positive repair rewards are unchanged. + +Both launchers accept `--invalid-action-weight` (default `5`), recorded as +`balatro_invalid_action_weight` in the recipe. This is a magnitude in training +advantage units, not raw game-score points. `normalize_advantages=True` is +rejected at launch and inside the trainer because recentering could weaken or +reverse the penalty. Explicit `--credit-assignment episode` (or comparison +`--mode episode`) selects the legacy control without action-level penalties. + +The pinned-trainer CPU integration tests verify token transport, CP=1/4 +reduction, and a gradient that lowers rejected-output probability. A replay of +179 recorded invalid decisions changed their median penalty magnitude from +0.058 to 5.0. This verifies the training signal; improved gameplay still needs +a new controlled training test. + +## Cloud monitoring (September 25) + +`training/cloud_watchdog.py` is deployed as `balatro-training-watchdog` in +`joy-dev`. Its scheduled CPU function runs every two minutes and reads Training +Gym's metadata volume directly, so laptop sleep does not interrupt monitoring. +Only runs explicitly registered in the `balatro-training-watchdog` Modal Dict +are monitored; each registration pins the exact training app ID. Snapshots and +stop decisions are also persisted in `balatro-training-watchdog-evidence`. + +Automatic stop rules are tested in `tests/test_watchdog_policy.py`: + +- Nonfinite loss, gradient norm, probability-gap metric, or held-out reward. +- Two consecutive held-out evaluations more than 20% below baseline. +- After at least 50 updates, the latest three held-out evaluations are at or + below baseline. + +Read failures never trigger a stop. The watchdog records game-level training +reward, ante, wins, and invalid-action rate without counting context segments +as separate games. It does not change the training recipe or relaunch jobs. +A continue decision is not evidence of learning. Check the Dict's `stop_reason` +when interpreting a terminated run: the training driver's status can report +failure after an intentional watchdog stop. The watchdog does not overwrite +the driver's metadata record. + +The active registration and deployment verification for each run are in its +`reports/-submission.json` and cloud-watchdog evidence files. +# Action contract and reporting correction (2026-09-28) + +The September 25 audit found 51 engine-rejected consumable actions advertised +as legal. `_consumable_available` now shares the joker-capacity gate between +the prompt and Python validator for Judgement, Soul, and Wraith, and retains +Ankh's existing-joker requirement. Recorded failures are regression fixtures; +selling a joker must restore availability. Shop and hand hints also exclude +eternal jokers from sale. The engine remains the final authority on legality. + +Context protocol 2 frames continued observations as user turns through the +actual tokenizer chat template, with the same assistant prefix as fresh +snapshots. A truncated assistant answer gets a masked end-of-turn marker. +Generated action IDs/log probabilities are preserved exactly; feedback and +template tokens have zero loss mask. This fixes the format inconsistency; +reduced malformed-output rates still require validation on new trajectories. + +`training/balatro_diagnostics.py` reports game-deduplicated reward and ante +percentiles (p10/p25/p50/p75/p90/p95), wins, and invalid-action rates during +training and evaluation. `rollout/raw_reward` is the game mean. The trainer's +old segment average is explicitly named `rollout/segment_weighted_raw_reward`. +Sampling/training gap tail fractions above .01, .05, and .1 supplement the mean. +PPO ratio metrics are named `pre_update_ppo_kl` and `pre_update_pg_clipfrac`: +they do not measure policy movement after the optimizer update. + +These changes retain the stronger invalid-action floor, original reward +function, reward-to-go baseline, and exact unmasked sampling distribution. +State-conditioned credit and post-update policy-drift measurement remain +separate experiments rather than unvalidated algorithm changes in this run. diff --git a/batro_modal_rl.py b/batro_modal_rl.py index 2ca2d127..cb58a8ab 100644 --- a/batro_modal_rl.py +++ b/batro_modal_rl.py @@ -1,11 +1,11 @@ -"""Train a Balatro policy with Training Gym and one Modal Sandbox per game. +"""Train a Balatro policy with Modal Dojo and one Modal Sandbox per game. The macOS ``Balatro.love`` archive is platform independent, but the executable is not. This file uploads the private game assets to a Modal Volume and runs them with the official Linux LOVE 11.5 build. Each rollout gets its own Sandbox, so concurrent games never share a Balatro process or save directory. -Safe workflow (from the Training Gym Python 3.12 environment):: +Safe workflow (from the Modal Dojo Python 3.12 environment):: python batro_modal_rl.py --prepare-assets python batro_modal_rl.py --smoke-env @@ -33,7 +33,7 @@ from typing import Any import modal -from modal_training_gym import ( +from modal_dojo import ( DatasetConfig, Qwen3_8_27B, Qwen3_8_27B_Recipe as BaseQwen3_8_27B_Recipe, @@ -43,15 +43,15 @@ from pydantic.dataclasses import dataclass as recipe_dataclass try: - from modal_training_gym import DashboardComponent + from modal_dojo import DashboardComponent except ImportError: - # Dashboard components were added after the core Training Gym launch API. + # Dashboard components were added after the core Modal Dojo launch API. # Keep the training entrypoint usable with compatible older clients. DashboardComponent = None -from modal_training_gym.common.checkpoint import Checkpoint, _list_checkpoints -from modal_training_gym.common.models.base import ToolCall -from modal_training_gym.common.run import TrainingRun, set_checkpoint_location +from modal_dojo.common.checkpoint import Checkpoint, _list_checkpoints +from modal_dojo.common.models.base import ToolCall +from modal_dojo.common.run import TrainingRun, set_checkpoint_location # --------------------------------------------------------------------------- # Private assets: local Mac -> private Modal Volume @@ -340,7 +340,7 @@ def _balatro_runtime_image() -> modal.Image: @dataclass class Observation: - """Balatro tool feedback, independent of unpublished Training Gym APIs.""" + """Balatro tool feedback, independent of unpublished Modal Dojo APIs.""" text: str = "" is_error: bool = False @@ -484,7 +484,7 @@ def start(self, seed: str) -> dict[str, Any]: return self.settle(state) def screenshot_data_uri(self) -> str: - """Capture the current game frame for Training Gym's rollout viewer.""" + """Capture the current game frame for Modal Dojo's rollout viewer.""" path = f"/tmp/balatro-rollout-{time.time_ns()}.png" self.rpc("screenshot", {"path": path}) process = self.sandbox.exec("base64", "-w", "0", path, timeout=15) @@ -639,7 +639,11 @@ def _get_env_pool() -> BalatroEnvironmentPool: "Play Balatro through the provided JSON action interface. Choose exactly " "one legal API action and return only minified JSON: " '{"method":"name","params":{...}}. Card and item indices are 0-based; ' - "every index in a list must be distinct. State uses " + "every index in a list must be distinct. " + "End your response immediately after that one object. Extra objects, prose, " + "or hitting the output limit reject the entire response without executing it. " + '"buy", "sell", "use", and "pack" take scalar item indices, e.g. ' + '{"method":"buy","params":{"pack":0}}; only cards/targets take lists. State uses ' "hand_stats=[level,total_played,played_this_round]. After the first " "turn, balatro_state contains only fields changed since the previous " "turn; absent fields are unchanged and null means removed. Each new " @@ -1108,6 +1112,24 @@ def _consumable_requires_joker(item: Any) -> bool: ) +def _consumable_available(item: Any, compact: dict[str, Any]) -> bool: + """Shared visible-state gate for advertised and accepted consumable uses. + + Creating a Joker is different from requiring an existing Joker (Ankh). + Apply the same capacity rule to owned consumables and immediate pack uses. + Target-card bounds are checked separately because they depend on the action. + """ + if not isinstance(item, dict): + return True + jokers = _area_items(compact, "jokers") + if _consumable_requires_joker(item) and not jokers: + return False + if item.get("id") in {"c_judgement", "c_soul", "c_wraith"}: + used, limit = _slot_usage(compact, "jokers") + return used < limit + return True + + def _target_action_help( *, method: str, item_name: str, index: int, item: Any, hand_size: int ) -> str | None: @@ -1177,14 +1199,14 @@ def _action_help(state: dict[str, Any]) -> str: actions.append( f"discard cards=1-5 distinct indices in 0..{high} ({discards} left)" ) - if jokers: - actions.append(f"sell joker=0..{len(jokers) - 1}") + if sellable := _sellable_indices(compact, "jokers"): + actions.append(f"sell joker=one of {sellable}") if consumables: actions.append(f"sell consumable=0..{len(consumables) - 1}") actions.extend( help_text for index, item in enumerate(consumables) - if (not _consumable_requires_joker(item) or jokers) + if _consumable_available(item, compact) and ( help_text := _target_action_help( method="use", @@ -1209,14 +1231,14 @@ def _action_help(state: dict[str, Any]) -> str: reroll_cost = float(compact.get("reroll_cost") or 0) if reroll_cost > 0 and float(compact.get("money") or 0) >= reroll_cost: actions.append(f"reroll (cost {reroll_cost:g})") - if jokers: - actions.append(f"sell joker=0..{len(jokers) - 1}") + if sellable := _sellable_indices(compact, "jokers"): + actions.append(f"sell joker=one of {sellable}") if consumables: actions.append(f"sell consumable=0..{len(consumables) - 1}") actions.extend( help_text for index, item in enumerate(consumables) - if (not _consumable_requires_joker(item) or jokers) + if _consumable_available(item, compact) and _consumable_target_bounds(item) is None and ( help_text := _target_action_help( @@ -1241,11 +1263,7 @@ def _action_help(state: dict[str, Any]) -> str: and str(item.get("id") or "").startswith("j_") and jokers_used >= jokers_limit ) - and not ( - isinstance(item, dict) - and str(item.get("id") or "") == "c_ankh" - and jokers_used == 0 - ) + and _consumable_available(item, compact) ] actions = ["pack skip=true"] for kind, name in (("joker", "jokers"), ("consumable", "consumables")): @@ -1311,11 +1329,11 @@ def _action_is_locally_legal(action: ToolCall, state: dict[str, Any]) -> bool: state_name = str(state.get("state", "")) def valid_indices(value: Any, size: int, *, complete: bool = False) -> bool: - if not isinstance(value, list) or not value or len(value) != len(set(value)): + if not isinstance(value, list) or not value: return False - if any(not isinstance(index, int) or not 0 <= index < size for index in value): + if any(type(index) is not int or not 0 <= index < size for index in value): return False - return not complete or sorted(value) == list(range(size)) + return len(value) == len(set(value)) and (not complete or sorted(value) == list(range(size))) hand = compact.get("hand") if isinstance(compact.get("hand"), list) else [] jokers = _area_items(compact, "jokers") @@ -1342,7 +1360,7 @@ def valid_indices(value: Any, size: int, *, complete: bool = False) -> bool: return method == "select" or str(selected.get("type") or "").upper() != "BOSS" def valid_targets(key: str, item: Any) -> bool: - if _consumable_requires_joker(item) and not jokers: + if not _consumable_available(item, compact): return False bounds = _consumable_target_bounds(item) if bounds is None: @@ -1379,7 +1397,7 @@ def valid_targets(key: str, item: Any) -> bool: if set(params) - {"consumable", "cards"}: return False index = params.get("consumable") - if not isinstance(index, int) or not 0 <= index < len(consumables): + if type(index) is not int or not 0 <= index < len(consumables): return False if _consumable_target_bounds(consumables[index]) is not None: if str(state.get("state", "")) != "SELECTING_HAND": @@ -1415,7 +1433,7 @@ def valid_targets(key: str, item: Any) -> bool: return False index = params.get("card") pack = compact.get("pack") if isinstance(compact.get("pack"), list) else [] - if not isinstance(index, int) or not 0 <= index < len(pack): + if type(index) is not int or not 0 <= index < len(pack): return False item = pack[index] jokers_used, jokers_limit = _slot_usage(compact, "jokers") @@ -1435,34 +1453,71 @@ def valid_targets(key: str, item: Any) -> bool: return False -def _decode_action(text: str | None, state: dict[str, Any]) -> ToolCall | None: - """Decode the first model JSON action allowed in the current phase. +def _unique_json_keys(pairs: list[tuple[str, Any]]) -> dict[str, Any]: + result = {} + for key, value in pairs: + if key in result: + raise ValueError("Duplicate JSON key") + result[key] = value + return result + - This deliberately does not enforce index legality; callers can distinguish - malformed-but-repairable model output from output that needs the emergency - fallback action. +def _reject_json_constant(value: str) -> Any: + raise ValueError(f"Non-JSON constant: {value}") + + +def _single_action_object(text: str | None) -> dict[str, Any] | None: + """Consume the entire response, allowing only whitespace and one terminal EOS. + + Qwen's decoded text may include its sampled end-of-turn token. Removing + that suffix for validation never changes the sampled training IDs/logprobs. """ if not text: return None - state_name = str(state.get("state", "")) - candidate = text.strip().removeprefix("```json").removeprefix("```") - candidate = candidate.removesuffix("```").strip() - for match in re.finditer(r"\{", candidate): - try: - value, _ = json.JSONDecoder().raw_decode(candidate[match.start() :]) - except json.JSONDecodeError: - continue - if not isinstance(value, dict): - continue - method, params = value.get("method"), value.get("params", {}) - if method not in _ALLOWED_METHODS.get(state_name, set()): + candidate = text.strip().removesuffix("<|im_end|>").strip() + try: + value = json.loads(candidate, object_pairs_hook=_unique_json_keys, + parse_constant=_reject_json_constant) + except (ValueError, RecursionError): + return None + if (not isinstance(value, dict) or set(value) != {"method", "params"} + or not isinstance(value["method"], str) or not isinstance(value["params"], dict)): + return None + return value + + +def _action_object_count(text: str) -> int: + """Diagnostic only: count complete action objects, never select one to run.""" + count = 0 + consumed = 0 + for match in re.finditer(r"\{", text): + if match.start() < consumed: continue - if not isinstance(params, dict): + try: + value, end = json.JSONDecoder().raw_decode(text[match.start():]) + except (ValueError, RecursionError): continue - params = dict(params) - params.pop("reasoning", None) - return ToolCall(name=method, arguments=params) - return None + consumed = match.start() + end + count += isinstance(value, dict) and "method" in value + return count + + +def _action_output_error(text: str, finish: str) -> str: + if finish == "length": + return "length_limit" + if finish != "stop": + return "abnormal_finish" + if _single_action_object(text) is None: + return "invalid_format" + return "" + + +def _decode_action(text: str | None, state: dict[str, Any]) -> ToolCall | None: + """Accept one whole JSON action, without repairing or ignoring any suffix.""" + value = _single_action_object(text) + if value is None or value["method"] not in _ALLOWED_METHODS.get(str(state.get("state", "")), set()): + return None + return ToolCall(name=value["method"], arguments=value["params"]) def _parse_action(text: str | None, state: dict[str, Any]) -> ToolCall | None: @@ -1748,11 +1803,45 @@ def _tokenizer(checkpoint: str) -> Any: return _TOKENIZERS[checkpoint] -def _chat_prompt(tokenizer: Any, user_message: str) -> str: +def _thinking_budget(args: Any) -> int: + budget = getattr(args, "balatro_thinking_budget", 0) + if type(budget) is not int or budget not in (0, 8192): + raise ValueError("balatro_thinking_budget must be 0 or 8192") + return budget + + +def _thinking_action_text(text: str, enabled: bool) -> str | None: + """Only the final answer is an action; reasoning is retained for training.""" + if not enabled: + return text + if text.count("") != 1 or "" in text: + return None + reasoning, answer = text.split("") + if "<|im_end|>" in reasoning or "<|im_start|>" in text: + return None + return answer + + +def _balatro_system_prompt(thinking: bool = False) -> str: + if not thinking: + return BALATRO_SYSTEM_PROMPT + return BALATRO_SYSTEM_PROMPT.replace( + "one legal API action and return only minified JSON:", + "one legal API action. Think within the open thinking block for at most " + "8192 tokens. End thinking with ; if the budget is reached, the " + "harness closes the block. Then return only minified JSON:", + ).replace("Extra objects, prose,", "Extra objects or prose in the final answer,").replace( + "or hitting the output limit", "or hitting the final-answer output limit", + ) + + +def _chat_prompt(tokenizer: Any, user_message: str, *, thinking: bool = False) -> str: + if thinking: + user_message = user_message.replace("with no markdown or reasoning.", "with no markdown or reasoning in the final answer.") messages = [ { "role": "system", - "content": BALATRO_SYSTEM_PROMPT, + "content": _balatro_system_prompt(thinking), }, {"role": "user", "content": user_message}, ] @@ -1761,39 +1850,169 @@ def _chat_prompt(tokenizer: Any, user_message: str) -> str: messages, tokenize=False, add_generation_prompt=True, - enable_thinking=False, + enable_thinking=thinking, ) except TypeError: + if thinking: + raise ValueError("Tokenizer must support enable_thinking for thinking runs") return tokenizer.apply_chat_template( messages, tokenize=False, add_generation_prompt=True ) +def _feedback_chat_turn(tokenizer: Any, feedback: str, *, assistant_ended: bool, thinking: bool = False) -> str: + """Frame every next decision like the fresh-snapshot assistant turn. + + Only append template/control tokens; never retokenize sampled action IDs. + A length-limited answer needs a masked end-of-turn marker before feedback. + """ + messages = [{"role": "user", "content": feedback}] + try: + turn = tokenizer.apply_chat_template( + messages, tokenize=False, add_generation_prompt=True, enable_thinking=thinking, + ) + except TypeError: + if thinking: + raise ValueError("Tokenizer must support enable_thinking for thinking runs") + turn = tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True) + complete = _chat_prompt(tokenizer, feedback, thinking=thinking) + if thinking and not complete.endswith(turn): + # Qwen's thinking template adds a default reasoning-effort system + # message to a user-only render. Keep its user/assistant suffix and + # verify it against the full explicit-system render below. This model + # uses ChatML; unsupported framing still fails rather than guessing. + user_start = turn.find("<|im_start|>user\n") + if user_start >= 0: + turn = turn[user_start:] + if not turn or not complete.endswith(turn) or not tokenizer.eos_token: + raise ValueError("Tokenizer cannot frame a Balatro feedback turn consistently") + return ("" if assistant_ended else tokenizer.eos_token) + "\n" + turn + + +def _validate_balatro_sampling_params(params: dict[str, Any], *, evaluation: bool = False) -> None: + """Require the same unmasked distribution the trainer optimizes.""" + if not isinstance(params, dict): + raise ValueError("sampling_params must be a dictionary") + for constraint in ("regex", "json_schema", "ebnf"): + if params.get(constraint) is not None: + raise ValueError( + f"Balatro training cannot use {constraint}: the trainer does not replay grammar masks" + ) + for name in ("ignore_eos", "stop", "stop_token_ids", "stop_regex"): + if params.get(name): + raise ValueError(f"Balatro training cannot use {name}: actions must end naturally, without suppressing EOS or clipping trailing output") + # This harness does not record/replay top-p masks or logit processors. + # Greedy held-out evaluation is allowed; those samples never train. + defaults = { + "top_p": 1.0, "top_k": -1, "min_p": 0.0, + "presence_penalty": 0.0, "frequency_penalty": 0.0, + "repetition_penalty": 1.0, + } + if not evaluation: + defaults["temperature"] = 1.0 + for name, expected in defaults.items(): + if params.get(name, expected) != expected: + raise ValueError( + f"Balatro training requires {name}={expected}; sampling and training probabilities must match" + ) + for name in ("logit_bias", "custom_logit_processor"): + if params.get(name): + raise ValueError(f"Balatro training cannot use {name}: the trainer does not replay logit processors") + + +def _validate_balatro_sampling_config(recipe: Any) -> None: + """Reject incompatible sampling flags before checkpoint or launch side effects.""" + extra = getattr(recipe, "extra_config", None) or {} + budget = extra.get("balatro_thinking_budget", 0) + if type(budget) is not int or budget not in (0, 8192): + raise ValueError("balatro_thinking_budget must be 0 or 8192") + if budget: + template = json.loads(getattr(recipe, "apply_chat_template_kwargs", "{}") or "{}") + if template.get("enable_thinking") is not True: + raise ValueError("Thinking runs require enable_thinking=True") + for name in ("rollout_max_response_len", "eval_max_response_len"): + if getattr(recipe, name, 0) != budget + 96: + raise ValueError(f"Thinking runs require {name}={budget + 96}") + params = { + name: extra.get(f"rollout_{name}", getattr(recipe, f"rollout_{name}", default)) + for name, default in (("temperature", 1.0), ("top_p", 1.0), ("top_k", -1)) + } + _validate_balatro_sampling_params(params) + request = extra.get("sglang_request_params", getattr(recipe, "sglang_request_params", None)) or {} + if not isinstance(request, dict): + raise ValueError("sglang_request_params must be a dictionary") + _validate_balatro_sampling_params(request) + if "sampling_params" in request: + _validate_balatro_sampling_params(request["sampling_params"]) + + async def _generate_action( args: Any, sampling_params: dict[str, Any], prompt_ids: list[int], state_name: str, +) -> tuple[list[int], str | None, str, list[float], list[int]]: + budget = _thinking_budget(args) + if not budget: + ids, text, finish, probabilities = await _sample_action_tokens(args, sampling_params, prompt_ids, 96) + return ids, text, finish, probabilities, [1] * len(ids) + tokenizer = _tokenizer(args.hf_checkpoint) + closing = tokenizer("", add_special_tokens=False)["input_ids"] + if len(closing) != 1 or closing[0] == tokenizer.unk_token_id: + raise ValueError("Thinking requires a dedicated token") + # A sampled close ends thinking early. At the budget, a masked control + # token ends thinking instead; the final answer gets its own allowance. + ids, text, finish, probabilities = await _sample_action_tokens( + args, sampling_params, prompt_ids, budget, stop_token=closing[0], + ) + mask = [1] * len(ids) + if text is None: + return ids, text, finish, probabilities, mask + text = tokenizer.decode(ids, skip_special_tokens=False) + budget_hit = finish == "length" and len(ids) == budget + if budget_hit and closing[0] not in ids and tokenizer.eos_token_id not in ids: + ids += closing + probabilities += [0.0] # Placeholder only: excluded by loss mask. + mask += [0] + text = tokenizer.decode(ids, skip_special_tokens=False) + if not ids or ids[-1] != closing[0] or not (finish == "stop" or budget_hit): + return ids, text, finish, probabilities, mask + answer_ids, answer, answer_finish, answer_probs = await _sample_action_tokens( + args, sampling_params, prompt_ids + ids, 96, + ) + if answer is None: + # Keep the already sampled reasoning for negative action credit. + return ids, text, answer_finish, probabilities, mask + ids += answer_ids + return (ids, tokenizer.decode(ids, skip_special_tokens=False), answer_finish, + probabilities + answer_probs, mask + [1] * len(answer_ids)) + + +async def _sample_action_tokens( + args: Any, sampling_params: dict[str, Any], prompt_ids: list[int], + limit: int, *, stop_token: int | None = None, ) -> tuple[list[int], str | None, str, list[float]]: from slime.utils.http_utils import post params = deepcopy(sampling_params) + # Training temperature is checked at episode entry. This shared serving + # helper also handles greedy evaluation, which is never used for training. + _validate_balatro_sampling_params(params, evaluation=True) context_limit, _ = _balatro_context_limits(args) params["max_new_tokens"] = min( - int(params.get("max_new_tokens", 96)), 96, context_limit - 128 - len(prompt_ids) + int(params.get("max_new_tokens", limit)), limit, context_limit - 128 - len(prompt_ids) ) if params["max_new_tokens"] <= 0: return [], None, "context", [] + if stop_token is not None: + # Internal phase boundary only. The final action still must end at EOS; + # user-provided stop strings/tokens remain forbidden by validation. + params["stop_token_ids"] = [stop_token] + params["skip_special_tokens"] = False # The trainer computes unmasked token probabilities. SGLang applies a # grammar mask BEFORE returning logprobs, so constrained samples are from # a different policy even at temperature=1/top_p=1. Keep generation aligned # with training; the prompt and action validator still enforce the API. - for constraint in ("regex", "json_schema", "ebnf"): - if params.get(constraint) is not None: - raise ValueError( - f"Balatro training cannot use {constraint}: the trainer does not replay grammar masks" - ) - output = await post( f"http://{args.sglang_router_ip}:{args.sglang_router_port}/generate", { @@ -1814,6 +2033,8 @@ async def _generate_action( ] if len(response_ids) > params["max_new_tokens"]: raise RuntimeError("Serving returned more tokens than requested") + if not response_ids or any(not math.isfinite(value) for value in log_probs): + raise RuntimeError("Serving returned missing or nonfinite token log probabilities") return response_ids, output.get("text", ""), finish, log_probs @@ -1865,6 +2086,21 @@ def _validate_balatro_context_config(recipe: Any) -> tuple[int, int]: return _balatro_context_limits(SimpleNamespace(**values)) +def _invalid_action_weight(args: Any) -> float: + """Penalty magnitude in advantage units, independent of game-score spread.""" + import math + + extra = getattr(args, "extra_config", None) or {} + value = extra.get("balatro_invalid_action_weight", getattr(args, "balatro_invalid_action_weight", 5.0)) + try: + weight = float(value) + except (TypeError, ValueError): + raise ValueError("balatro_invalid_action_weight must be finite and positive") from None + if isinstance(value, bool) or not math.isfinite(weight) or weight <= 0: + raise ValueError("balatro_invalid_action_weight must be finite and positive") + return weight + + def _validate_balatro_loss_config(args: Any) -> None: """Check loss weighting locally, before launching GPUs, and on workers.""" extra = getattr(args, "extra_config", None) or {} @@ -1877,6 +2113,9 @@ def _validate_balatro_loss_config(args: Any) -> None: if mode not in {"episode", "reward_to_go"}: raise ValueError(f"Unknown Balatro credit assignment: {mode}") if mode == "reward_to_go": + _invalid_action_weight(args) + if extra.get("normalize_advantages", getattr(args, "normalize_advantages", False)): + raise ValueError("Action credit requires normalize_advantages=False to preserve invalid-action penalties") path = extra.get("custom_advantage_function_path", getattr(args, "custom_advantage_function_path", None)) if path != "balatro_credit.compute_advantages": raise ValueError("reward_to_go requires the Balatro token-advantage hook") @@ -1890,7 +2129,7 @@ def _validate_balatro_trainer(args: Any, sample_type: Any) -> None: _validate_balatro_loss_config(args) if "rollout_id" not in getattr(sample_type, "__dataclass_fields__", {}): - raise RuntimeError("This Slime Sample lacks shared rollout_id support; use the pinned Training Gym image") + raise RuntimeError("This Slime Sample lacks shared rollout_id support; use the pinned Modal Dojo image") root = Path(inspect.getfile(sample_type)).resolve().parents[1] if getattr(args, "balatro_credit_assignment", "episode") == "reward_to_go": if "train_metadata" not in getattr(sample_type, "__dataclass_fields__", {}): @@ -1917,10 +2156,13 @@ class _SnapshotUnavailable(RuntimeError): class _BalatroContext: """Bounded inference prefixes and their exact, separately trained sequences.""" - def __init__(self, tokenizer: Any, hard_limit: int, target: int): + def __init__(self, tokenizer: Any, hard_limit: int, target: int, *, thinking_budget: int = 0): self.tokenizer = tokenizer self.hard_limit = hard_limit self.target = target + self.thinking = bool(thinking_budget) + self.max_action_tokens = thinking_budget + 96 + int(self.thinking) + self.reserve = self.max_action_tokens + 128 self.segments: list[dict[str, Any]] = [] self.current: dict[str, Any] | None = None self.needs_reset = True @@ -1929,9 +2171,9 @@ def __init__(self, tokenizer: Any, hard_limit: int, target: int): def begin(self, prompt: str, user_message: str, turn: int) -> None: ids = self.tokenizer(prompt, add_special_tokens=False)["input_ids"] - if len(ids) + 96 + 128 > self.hard_limit: + if len(ids) + self.reserve > self.hard_limit: raise _StateBudgetExceeded( - f"Current snapshot needs {len(ids)} tokens; input allowance is {self.hard_limit - 224}" + f"Current snapshot needs {len(ids)} tokens; input allowance is {self.hard_limit - self.reserve}" ) self.finish() self.current = { @@ -1939,7 +2181,7 @@ def begin(self, prompt: str, user_message: str, turn: int) -> None: "response": "", "loss_mask": [], "log_probs": [], "actions": [], "turn_start": turn, "messages": [ - {"role": "system", "content": BALATRO_SYSTEM_PROMPT}, + {"role": "system", "content": _balatro_system_prompt(self.thinking)}, {"role": "user", "content": user_message}, ], } @@ -1952,23 +2194,36 @@ def input_ids(self) -> list[int]: if segment is None or self.needs_reset: raise RuntimeError("A fresh snapshot is required before generation") ids = segment["prompt_ids"] + segment["response_ids"] - if len(ids) + 224 > self.hard_limit: + if len(ids) + self.reserve > self.hard_limit: raise RuntimeError("Context manager produced an oversized request") return ids - def add_action(self, ids: list[int], text: str, log_probs: list[float], *, turn: int, archive_start: int) -> None: + def add_action(self, ids: list[int], text: str, log_probs: list[float], *, turn: int, archive_start: int, + loss_mask: list[int] | None = None) -> None: segment = self.current - if not ids or len(ids) > 96 or len(ids) != len(log_probs): + if not ids or len(ids) > self.max_action_tokens or len(ids) != len(log_probs): raise RuntimeError("Missing or misaligned generated action tokens/log probabilities") if segment is None or len(self.input_ids()) + len(ids) > self.hard_limit: raise RuntimeError("Invalid action context") + mask = [1] * len(ids) if loss_mask is None else loss_mask + if len(mask) != len(ids) or any(type(m) is not int or m not in (0, 1) for m in mask) or not any(mask): + raise RuntimeError("Invalid generated action loss mask") start = len(segment["response_ids"]) + spans = [] + for offset, enabled in enumerate(mask): + if enabled: + if offset == 0 or not mask[offset - 1]: + spans.append([start + offset, start + offset + 1]) + else: + spans[-1][1] = start + offset + 1 segment["actions"].append({ "turn": turn, "token_start": start, "token_end": start + len(ids), "episode_token_start": archive_start, "episode_token_end": archive_start + len(ids), + "policy_token_spans": spans, "sampled_tokens": sum(mask), + "forced_thinking_close": bool(self.thinking and 0 in mask), }) segment["response_ids"].extend(ids) - segment["loss_mask"].extend([1] * len(ids)) + segment["loss_mask"].extend(mask) segment["log_probs"].extend(log_probs) segment["response"] += text segment["messages"].append({"role": "assistant", "content": text}) @@ -1978,9 +2233,15 @@ def add_feedback(self, feedback: str, ids: list[int]) -> None: segment = self.current if segment is None: raise RuntimeError("Feedback without an action") + framed = _feedback_chat_turn( + self.tokenizer, feedback, + assistant_ended=segment["response_ids"][-1] == self.tokenizer.eos_token_id, + thinking=self.thinking, + ) + ids = self.tokenizer(framed, add_special_tokens=False)["input_ids"] size = len(segment["prompt_ids"]) + len(segment["response_ids"]) + len(ids) segment["messages"].append({"role": "tool", "content": feedback.strip()}) - if size + 224 > self.target or len(segment["messages"]) >= 126: + if size + self.reserve > self.target or len(segment["messages"]) >= 126: # Keep this result in the episode archive. The next request gets # its resulting state as a full snapshot, not a detached delta. self.needs_reset = True @@ -1988,7 +2249,7 @@ def add_feedback(self, feedback: str, ids: list[int]) -> None: segment["response_ids"].extend(ids) segment["loss_mask"].extend([0] * len(ids)) segment["log_probs"].extend([0.0] * len(ids)) - segment["response"] += feedback + segment["response"] += framed self.peak_tokens = max(self.peak_tokens, size) def finish(self) -> None: @@ -2125,7 +2386,7 @@ def _environment_feedback( *, previous_state_name: str, previous_compact: dict[str, Any] | None, - executed: ToolCall, + executed: ToolCall | None, valid: bool, error: str = "", ) -> tuple[str, dict[str, Any]]: @@ -2137,12 +2398,12 @@ def _environment_feedback( # becomes SKIPPED and the next one becomes SELECT. Include a compact, # explicit explanation so both the model and trajectory viewers know # which tag was earned and what blind is now available. - if executed.name == "skip" and isinstance(payload, dict): + if executed is not None and executed.name == "skip" and isinstance(payload, dict): if transition := _skip_transition(previous_compact, compact_state): payload = {**payload, "action_result": transition} else: payload = { - "fallback": _action_payload(executed), + **({"fallback": _action_payload(executed)} if executed is not None else {"executed": None}), "error": error or "invalid_model_action", "state": view, } @@ -2171,11 +2432,13 @@ async def generate_balatro_episode( """Play one continuous game; return bounded samples with one shared reward.""" from slime.utils.types import Sample + _validate_balatro_sampling_params(sampling_params, evaluation=evaluation) + thinking_budget = _thinking_budget(args) if not evaluation: _validate_balatro_trainer(args, Sample) source_metadata = dict(getattr(sample, "metadata", None) or {}) seed = str(source_metadata.get("balatro_seed") or sample.prompt) - # This budget covers only state-changing game decisions. + # Bound all sampled decisions, including rejected responses and retries. max_decisions = int(getattr(args, "balatro_max_decisions", 250)) context_limit, segment_target = _balatro_context_limits(args) capture_screenshot = bool(getattr(args, "balatro_capture_screenshot", True)) @@ -2242,7 +2505,7 @@ def span(name: str, started: float, **attributes: Any) -> None: return sample tokenizer = _tokenizer(args.hf_checkpoint) - context = _BalatroContext(tokenizer, context_limit, segment_target) + context = _BalatroContext(tokenizer, context_limit, segment_target, thinking_budget=thinking_budget) initial_prompt = "" initial_prompt_ids: list[int] = [] response_token_ids: list[int] = [] @@ -2251,7 +2514,7 @@ def span(name: str, started: float, **attributes: Any) -> None: trajectory_messages: list[dict[str, str]] = [ { "role": "system", - "content": BALATRO_SYSTEM_PROMPT, + "content": _balatro_system_prompt(bool(thinking_budget)), } ] invalid_actions = 0 @@ -2260,6 +2523,12 @@ def span(name: str, started: float, **attributes: Any) -> None: repaired_actions = 0 api_errors = 0 turns_taken = 0 + consecutive_rejections = 0 + executed_actions = 0 + output_format_errors = 0 + multiple_action_responses = 0 + length_limit_responses = 0 + normal_stop_responses = 0 # Previous turn's compact state, so feedback can be sent as a delta. previous_compact: dict[str, Any] | None = None last_result: dict[str, Any] | None = None @@ -2276,7 +2545,7 @@ def append_tool_feedback(feedback: str) -> bool: # The last executed action and any recovery error remain available # even when the feedback itself is replaced by a fresh snapshot. payload = json.loads(feedback.split("", 1)[1].split("", 1)[0]) - last_result = {"turn": turns_taken, "executed": _action_payload(executed)} + last_result = {"turn": turns_taken, "executed": _action_payload(executed) if executed is not None else None} for key in ("error", "fallback", "action_result"): if key in payload: last_result[key] = payload[key] @@ -2363,7 +2632,7 @@ def _append_checkpoint_event( first_turn = _turn_prompt(state) trajectory_messages.append({"role": "user", "content": first_turn}) - initial_prompt = _chat_prompt(tokenizer, first_turn) + initial_prompt = _chat_prompt(tokenizer, first_turn, thinking=bool(thinking_budget)) initial_prompt_ids = tokenizer(initial_prompt, add_special_tokens=False)[ "input_ids" ] @@ -2376,11 +2645,10 @@ def _append_checkpoint_event( break if context.needs_reset: first_turn = _turn_prompt(state, last_result) - context.begin(_chat_prompt(tokenizer, first_turn), first_turn, turn + 1) + context.begin(_chat_prompt(tokenizer, first_turn, thinking=bool(thinking_budget)), first_turn, turn + 1) previous_compact = json.loads(_compact_state(state)) span("balatro.context.reset", time.monotonic(), turn=turn + 1, segment_id=len(context.segments)) - turns_taken = turn + 1 state_name = str(state.get("state", "")) # Reward events are aligned to the response/loss-mask sequence, # which excludes the initial prompt. The transition reward is @@ -2388,7 +2656,7 @@ def _append_checkpoint_event( # action tokens that caused it. action_token_start = len(response_token_ids) generate_started = time.monotonic() - generated_ids, response, finish, generated_log_probs = await _generate_action( + generated_ids, response, finish, generated_log_probs, generated_mask = await _generate_action( args, sampling_params, context.input_ids(), @@ -2408,68 +2676,89 @@ def _append_checkpoint_event( terminal_reason = "model_abort" if aborted else "context_cap" break + turns_taken = turn + 1 context.add_action( generated_ids, response, generated_log_probs, turn=turn + 1, archive_start=action_token_start, + loss_mask=generated_mask, ) # Store the reward already earned BEFORE this action. Differencing # against the final total yields a causal return-to-go, including # invalid-action penalties and terminal bonuses exactly once. context.current["actions"][-1]["reward_before"] = sum(partial_reward_parts.values()) + # Record interventions separately from the displayed game reward. + # Tokens belong to the requested action, never the harness repair. + action_credit = context.current["actions"][-1] + action_credit["invalid_events"] = 0 response_token_ids.extend(generated_ids) action_token_end = len(response_token_ids) - loss_mask.extend([1] * len(generated_ids)) + loss_mask.extend(generated_mask) trajectory_text += response trajectory_messages.append({"role": "assistant", "content": response}) parse_started = time.monotonic() - action = _parse_action(response, state) + action_text = _thinking_action_text(response, bool(thinking_budget)) + output_error = _action_output_error(action_text or "", finish) + output_format_errors += _single_action_object(action_text) is None + multiple_action_responses += _action_object_count(action_text or "") > 1 + length_limit_responses += finish == "length" + normal_stop_responses += finish == "stop" + action = _parse_action(action_text, state) if not output_error else None + if thinking_budget: + closing = tokenizer("", add_special_tokens=False)["input_ids"][0] + reasoning_tokens = generated_ids.index(closing) + 1 if closing in generated_ids else len(generated_ids) + action_credit["thinking_tokens"] = sum(generated_mask[:reasoning_tokens]) + action_credit["final_answer_tokens"] = len(generated_ids) - reasoning_tokens + action_credit["finish_reason"] = finish + action_credit["output_error"] = output_error or ("illegal_action" if action is None else "") invalid = action is None repaired_turn = False - if action is None: - repaired = _repair_action(response, state) + span("balatro.action.parse", parse_started, turn=turn, valid=not invalid) + if invalid: + # Do not execute a prefix, repair, or fallback on behalf of a + # rejected response. Retain the full sampled span for negative + # credit and retry the unchanged game with explicit feedback. + consecutive_rejections += 1 invalid_actions += 1 invalid_turns += 1 - if repaired is not None: - repaired_actions += 1 - repaired_turn = True - action = repaired - decoded = _decode_action(response, state) - _log_balatro_event( - "BALATRO_ACTION_REPAIRED", - { - "seed": seed, - "episode_id": rollout_id, - "turn": turn, - "state": state_name, - "response": response[:500], - "requested": _action_payload(decoded) if decoded else None, - "repaired": _action_payload(action), - }, - ) - else: - fallback_actions += 1 - action = _fallback_action(state) - _log_balatro_event( - "BALATRO_ACTION_ERROR", - { - "seed": seed, - "episode_id": rollout_id, - "turn": turn, - "state": state_name, - "error": "invalid_model_output", - "response": response[:500], - "fallback": _action_payload(action), - }, - ) - span("balatro.action.parse", parse_started, turn=turn, valid=not invalid) + action_credit["invalid_events"] += 1 + partial_reward_parts["invalid_penalty"] -= 2.0 + partial_reward_steps += 1 + blind_reward_pending["invalid_penalty"] -= 2.0 + ante_reward_pending["invalid_penalty"] -= 2.0 + if blind_window_turn is None: + blind_window_turn, blind_window_token = turn + 1, action_token_start + if ante_window_turn is None: + ante_window_turn, ante_window_token = turn + 1, action_token_start + executed = None + error = (f"Rejected response: {action_credit['output_error']}. No action was executed. " + "Return exactly one complete legal JSON object, no prose or extra objects, " + "then end your response.") + _log_balatro_event("BALATRO_OUTPUT_REJECTED", { + "seed": seed, "episode_id": rollout_id, "turn": turn, + "reason": action_credit["output_error"], "finish": finish, + "tokens": len(generated_ids), "response": response[:500], + "consecutive_rejections": consecutive_rejections, + }) + feedback, previous_compact = _environment_feedback( + state, previous_state_name=state_name, previous_compact=previous_compact, + executed=None, valid=False, error=error, + ) + append_tool_feedback(feedback) + if consecutive_rejections >= 3: + terminal_reason = "invalid_action_limit" + break + continue + consecutive_rejections = 0 + executed_actions += 1 executed = action rpc_started = time.monotonic() result = await asyncio.to_thread(env.step, action) api_error = "" if result.observation.is_error: + action_credit["invalid_events"] += 1 invalid_actions += 1 api_errors += 1 api_error = result.observation.text[:500] @@ -2717,6 +3006,7 @@ def _append_checkpoint_event( partial_rewards=partial_reward_parts, ) reward = reward_parts["total"] + policy_reward = _finalize_action_credit(context.segments, reward) won = bool(state.get("won")) final_ante = int(state.get("ante_num") or 0) final_round = int(state.get("round_num") or 0) @@ -2737,6 +3027,20 @@ def _append_checkpoint_event( "seed_group": seed, "episode_id": rollout_id, "turns": turns_taken, + "output_contract_version": 1, + "thinking_budget": thinking_budget, + "forced_thinking_closures": sum(a["forced_thinking_close"] for segment in context.segments for a in segment["actions"]), + "thinking_token_lengths": [a.get("thinking_tokens", 0) + for segment in context.segments for a in segment["actions"]], + "final_answer_token_lengths": [a.get("final_answer_tokens", a["token_end"] - a["token_start"]) + for segment in context.segments for a in segment["actions"]], + "executed_actions": executed_actions, + "action_token_lengths": [a["sampled_tokens"] + for segment in context.segments for a in segment["actions"]], + "output_format_errors": output_format_errors, + "multiple_action_responses": multiple_action_responses, + "length_limit_responses": length_limit_responses, + "normal_stop_responses": normal_stop_responses, "terminal_reason": terminal_reason, "episode_reward": reward, "partial_reward": reward_parts["partial_total"], @@ -2756,7 +3060,7 @@ def _append_checkpoint_event( "api_errors": api_errors, "context_tokens": context_tokens, "context_limit": context_limit, - "context_protocol": 1, + "context_protocol": 2, "segment_target": segment_target, "segment_count": len(context.segments), "context_rebases": len(context.segments) - 1, @@ -2768,6 +3072,8 @@ def _append_checkpoint_event( } episode_metrics = { "balatro/reward_total": reward, + "balatro/policy_reward_total": policy_reward, + "balatro/intervention_reward_excluded": reward - policy_reward, "balatro/reward_progress": reward_parts["progress"], "balatro/reward_blind_clear": reward_parts["blind_clear_bonus"], "balatro/reward_ante_checkpoint": reward_parts["ante_checkpoint_bonus"], @@ -2791,13 +3097,14 @@ def _append_checkpoint_event( "balatro/context_rebases": len(context.segments) - 1, "balatro/episode_archive_tokens": len(initial_prompt_ids) + len(response_token_ids), "balatro/action_tokens": sum(loss_mask), - "balatro/feedback_tokens": len(loss_mask) - sum(loss_mask), + "balatro/control_tokens": metadata["balatro"]["forced_thinking_closures"], + "balatro/feedback_tokens": len(loss_mask) - sum(loss_mask) - metadata["balatro"]["forced_thinking_closures"], "balatro/state_budget_exceeded": int(terminal_reason == "state_budget_exceeded"), "balatro/context_utilization": context_utilization, "balatro/tokens_per_turn": tokens_per_turn, "balatro/won": int(won), } - # Training Gym renders numeric top-level sample metadata as per-rollout + # Modal Dojo renders numeric top-level sample metadata as per-rollout # time-series charts. Keep the nested metrics object for the sample detail # view, and promote the same values so every Balatro metric is chartable. metadata["metrics"] = episode_metrics @@ -2806,7 +3113,7 @@ def _append_checkpoint_event( if screenshot: metadata["image"] = screenshot # Keep the source compatible with framework Sample implementations that do - # not allow arbitrary attributes. Training Gym promotes these reserved + # not allow arbitrary attributes. Modal Dojo promotes these reserved # metadata keys into its first-class rollout fields during extraction. metadata["reward_granularity"] = "checkpoint" mapped_events = _segment_reward_events(partial_reward_trace, context.segments) @@ -2825,14 +3132,20 @@ def _append_checkpoint_event( part.rollout_id = rollout_id part.metadata = { **metadata, "segment_id": index, "segment_count": len(context.segments), - "context_protocol": 1, "segment_turn_start": segment["turn_start"], + "context_protocol": 2, "segment_turn_start": segment["turn_start"], "segment_turn_end": segment["actions"][-1]["turn"], "segment_context_tokens": len(part.tokens), "trajectory_messages": segment["messages"], "reward_events": mapped_events[index], "credit_assignment": getattr(args, "balatro_credit_assignment", "episode"), + "policy_episode_reward": policy_reward, "action_credit": [ {"turn": action["turn"], "token_start": action["token_start"], - "token_end": action["token_end"], "return_to_go": reward - action["reward_before"]} + "token_end": action["token_end"], + "policy_token_spans": action["policy_token_spans"], + "task_return_to_go": reward - action["reward_before"], + "return_to_go": action["policy_return_to_go"], + "intervention_penalty": action["intervention_penalty"], + "finish_reason": action["finish_reason"], "output_error": action["output_error"]} for action in segment["actions"] ], } @@ -2954,17 +3267,45 @@ def normalize_episode_rewards( for index in game_indices: advantages[index] = game_advantage[game_id] if getattr(args, "balatro_credit_assignment", "episode") == "reward_to_go": - _assign_action_advantages(samples, seed_groups) + _assign_action_advantages(samples, seed_groups, invalid_weight=_invalid_action_weight(args)) return raw, advantages -def _assign_action_advantages(samples: list[Any], seed_groups: dict[str, list[int]]) -> None: +def _finalize_action_credit(segments: list[dict[str, Any]], reward: float) -> float: + """Remove intervention rewards from policy returns, preserving task scores. + + The next action's reward_before includes exactly the preceding transition. + The final delta includes terminal bonuses once. For a rejected action, + credit only its existing invalid-action penalty, never a repair's progress + or win bonus. Earlier valid actions retain subsequent model-earned rewards. + """ + actions = [action for segment in segments for action in segment["actions"]] + remaining = 0.0 + for index in range(len(actions) - 1, -1, -1): + action = actions[index] + after = actions[index + 1]["reward_before"] if index + 1 < len(actions) else reward + delta = float(after - action["reward_before"]) + penalty = -2.0 * action["invalid_events"] + # Retain any larger negative terminal penalty, but never positive + # progress produced by the harness executing a different action. + policy_delta = min(delta, penalty) if penalty < 0 else delta + remaining += policy_delta + action["intervention_penalty"] = min(policy_delta, penalty) if penalty < 0 else 0.0 + action["policy_return_to_go"] = remaining + return remaining + + +def _assign_action_advantages( + samples: list[Any], seed_groups: dict[str, list[int]], *, invalid_weight: float = 5.0, +) -> None: """Same-seed, leave-one-game-out baselines at each decision number. Ended peers have zero remaining return. Scale once per seed using complete - game returns (floor 1 reward unit), never separately per context segment. - This preserves the existing reward objective; it does not invent a poker - score oracle or treat overlapping dashboard checkpoint events as additive. + policy returns (floor 1 reward unit), never per context segment. Task scores + remain unchanged; policy returns exclude progress from harness interventions. + Rejected actions have a negative floor applied AFTER reward scaling. Neither + a successful repaired game nor a large reward spread can weaken it. Preserve + larger negative task credit rather than capping the cost of a bad action. """ for indices in seed_groups.values(): games: dict[int, dict[int, float]] = {} @@ -2975,14 +3316,18 @@ def _assign_action_advantages(samples: list[Any], seed_groups: dict[str, list[in actions = (sample.metadata or {}).get("action_credit") if not actions: raise ValueError("reward_to_go requires recorded action_credit for every sample") - if game in totals and not math.isclose(totals[game], _sample_reward(sample)): + policy_reward = float(sample.metadata["policy_episode_reward"]) + if game in totals and not math.isclose(totals[game], policy_reward): raise ValueError("Segments of one game have inconsistent total rewards") - totals[game] = _sample_reward(sample) + totals[game] = policy_reward if not math.isfinite(totals[game]): raise ValueError("Nonfinite game reward") turns = games.setdefault(game, {}) for action in actions: turn, value = int(action["turn"]), float(action["return_to_go"]) + penalty = float(action["intervention_penalty"]) + if not math.isfinite(penalty) or penalty > 0: + raise ValueError("Invalid intervention penalty") if turn in turns or turn < 1 or not math.isfinite(value): raise ValueError("Invalid or duplicate action return-to-go") turns[turn] = value @@ -3000,10 +3345,14 @@ def _assign_action_advantages(samples: list[Any], seed_groups: dict[str, list[in for action in sample.metadata["action_credit"]: turn = int(action["turn"]) baseline = sum(turns.get(turn, 0.0) for peer, turns in games.items() if peer != game) / (len(games) - 1) - spans.append({ - "start": action["token_start"], "end": action["token_end"], - "advantage": (float(action["return_to_go"]) - baseline) / scale, - }) + penalty = float(action["intervention_penalty"]) + advantage = (float(action["return_to_go"]) - baseline) / scale + if penalty < 0: + advantage = min(advantage, penalty / scale, -invalid_weight) + for start, end in action.get("policy_token_spans", [[action["token_start"], action["token_end"]]]): + if not action["token_start"] <= start < end <= action["token_end"]: + raise ValueError("Policy token span is outside its action") + spans.append({"start": start, "end": end, "advantage": advantage}) sample.train_metadata = { **(getattr(sample, "train_metadata", None) or {}), "balatro_action_advantages": spans, @@ -3011,7 +3360,7 @@ def _assign_action_advantages(samples: list[Any], seed_groups: dict[str, list[in # --------------------------------------------------------------------------- -# Training Gym dataset and active run configuration +# Modal Dojo dataset and active run configuration # --------------------------------------------------------------------------- @@ -3019,7 +3368,7 @@ def _assign_action_advantages(samples: list[Any], seed_groups: dict[str, list[in class Qwen3_8_27B_Recipe(BaseQwen3_8_27B_Recipe): """Explicit Balatro topology on the current upstream Qwen preset. - Retain the recipe name because Training Gym derives the shared checkpoint + Retain the recipe name because Modal Dojo derives the shared checkpoint volume name from it. Main's preset now leaves these pipeline fields to the consumer and uses a different GPU/ref-load default. """ @@ -3075,7 +3424,8 @@ def build_train_config( num_rollout: int | None = None, load: str | None = None, no_load_optim: bool = False, - credit_assignment: str = "episode", + credit_assignment: str = "reward_to_go", + invalid_action_weight: float = 5.0, ) -> TrainConfig: if num_rollout is not None and num_rollout < 1: raise ValueError(f"num_rollout must be >= 1, got {num_rollout}") @@ -3104,6 +3454,7 @@ def build_train_config( calculate_per_token_loss=False, rollout_max_response_len=96, rollout_temperature=1.0, + rollout_top_p=1.0, max_tokens_per_gpu=12288, sglang_speculative_algorithm=None, sglang_speculative_num_steps=None, @@ -3126,6 +3477,8 @@ def build_train_config( custom_generate_function=generate_balatro_episode, custom_rm_function=passthrough_reward, custom_reward_post_process_function=normalize_episode_rewards, + custom_rollout_log_function="balatro_diagnostics.log_rollout", + custom_eval_rollout_log_function="balatro_diagnostics.log_eval", apply_chat_template_kwargs='{"enable_thinking": false}', environment={ "PYTHONPATH": "/root/Megatron-LM/", @@ -3134,8 +3487,8 @@ def build_train_config( # broad-layover crashed in NCCL's RAS peer-update thread during # save. Disable that diagnostic subsystem for this recipe. "NCCL_RAS_ENABLE": "0", - "TRAINING_GYM_TRAJECTORY_SAMPLE_LIMIT": "64", - "TRAINING_GYM_IMAGE_SAMPLE_LIMIT": "0", + "MODAL_DOJO_TRAJECTORY_SAMPLE_LIMIT": "64", + "MODAL_DOJO_IMAGE_SAMPLE_LIMIT": "0", }, extra_config={ "balatro_max_decisions": 250, @@ -3145,6 +3498,9 @@ def build_train_config( "max_position_embeddings": 49152, "sglang_context_length": 49152, "balatro_credit_assignment": credit_assignment, + "balatro_invalid_action_weight": invalid_action_weight, + "normalize_advantages": False, + "rollout_top_k": -1, **({"custom_advantage_function_path": "balatro_credit.compute_advantages"} if credit_assignment == "reward_to_go" else {}), }, @@ -3152,6 +3508,7 @@ def build_train_config( str(REPO / "training/patch_pipeline_group.py"), str(REPO / "training/patch_checkpoint_rpc.py"), str(REPO / "training/checkpoint_rpc.py"), + str(REPO / "training/balatro_diagnostics.py"), ] + ( [str(REPO / "training/balatro_credit.py")] if credit_assignment == "reward_to_go" else [] @@ -3159,6 +3516,7 @@ def build_train_config( image_run_commands=[ "python /tmp/patch_pipeline_group.py", "python /tmp/patch_checkpoint_rpc.py", + "python /tmp/balatro_diagnostics.py", ] + ( ["python /tmp/balatro_credit.py"] if credit_assignment == "reward_to_go" else [] @@ -3309,6 +3667,7 @@ def _launch_training(config: TrainConfig, record_path: Path | None = None): # creating a submission receipt, or allocating remote resources. _validate_balatro_loss_config(config.recipe) _validate_balatro_context_config(config.recipe) + _validate_balatro_sampling_config(config.recipe) record = None if record_path is not None: try: @@ -3325,13 +3684,13 @@ def _launch_training(config: TrainConfig, record_path: Path | None = None): os.fsync(record.fileno()) checkpoint = getattr(config, "checkpoint", None) if checkpoint is not None: - # Current Training Gym ignores the legacy ``config.checkpoint`` + # Current Modal Dojo ignores the legacy ``config.checkpoint`` # attribute. Explicit --load preserves optimizer/RNG and rollout # numbering; resume_from_checkpoint instead starts a weights-only # seed run by default. Never silently launch from the base model. config.recipe.load = str(PurePosixPath(checkpoint.path).parent) _pin_resume_checkpoint(checkpoint) - # Training Gym's public launcher starts a detached Modal app. Keep this + # Modal Dojo's public launcher starts a detached Modal app. Keep this # process alive until it returns the persisted function-call handle. run = config.launch() if record is not None: @@ -3407,7 +3766,7 @@ def _checkpoint_manifest_health( def _pin_resume_checkpoint(checkpoint: Checkpoint) -> None: """Point Megatron's run-level tracker at the validated checkpoint. - Training Gym mounts the parent run directory and passes that directory to + Modal Dojo mounts the parent run directory and passes that directory to ``--load``. Megatron then follows ``latest_checkpointed_iteration.txt``; selecting a Checkpoint object alone does not override that tracker. """ @@ -3433,7 +3792,7 @@ def _pin_resume_checkpoint(checkpoint: Checkpoint) -> None: def _resume_result(config: TrainConfig, training_run_id: str) -> TrainingRun: """Load a run and supply legacy checkpoint metadata when it is absent. - Older Training Gym launchers wrote the checkpoint directory to the legacy + Older Modal Dojo launchers wrote the checkpoint directory to the legacy train-result store but not to ``TrainingRun.metadata``. The current API discovers checkpoints exclusively from that metadata, so reconstruct the deterministic Slime location in memory for those older runs. Do not save @@ -3522,9 +3881,11 @@ def manifest(checkpoint: Checkpoint) -> dict[str, int]: def main() -> None: parser = argparse.ArgumentParser(description=__doc__) parser.add_argument( - "--credit-assignment", choices=("episode", "reward_to_go"), default="episode", - help="Keep episode GRPO for the context-only control, or test action reward-to-go.", + "--credit-assignment", choices=("episode", "reward_to_go"), default="reward_to_go", + help="Action credit with strong invalid penalties; episode is the legacy comparison control.", ) + parser.add_argument("--invalid-action-weight", type=float, default=5.0, + help="Minimum negative advantage magnitude for rejected actions in reward_to_go mode") parser.add_argument("--prepare-assets", action="store_true") parser.add_argument("--smoke-env", action="store_true") parser.add_argument( @@ -3584,11 +3945,11 @@ def main() -> None: parser.add_argument( "--launch", action="store_true", - help="Actually launch the H100 Training Gym run.", + help="Actually launch the H100 Modal Dojo run.", ) args = parser.parse_args() if args.launch and sys.version_info[:2] != (3, 12): - parser.error("Launch with Python 3.12 to match the Training Gym image.") + parser.error("Launch with Python 3.12 to match the Modal Dojo image.") if args.resume_iteration is not None and not args.resume_run: parser.error("--resume-iteration requires --resume-run") if args.resume_run and args.load: @@ -3606,8 +3967,11 @@ def main() -> None: load=args.load, no_load_optim=args.no_load_optim, credit_assignment=args.credit_assignment, + invalid_action_weight=args.invalid_action_weight, ) + _validate_balatro_loss_config(config.recipe) context_limit, segment_target = _validate_balatro_context_config(config.recipe) + _validate_balatro_sampling_config(config.recipe) print(f"Context: hard={context_limit}, segment={segment_target}; credit={args.credit_assignment}.") if args.save_interval is not None: if args.save_interval < 1: @@ -3670,7 +4034,7 @@ def main() -> None: component_type=DashboardComponent.TRAJECTORY_VIEWER, from_path=viewer_path, ) - print(f"Training Gym run id: {run.training_run_id}") + print(f"Modal Dojo run id: {run.training_run_id}") if __name__ == "__main__": diff --git a/dashboard/TrajectoryViewer.svelte b/dashboard/TrajectoryViewer.svelte index df17f791..06fc8be9 100644 --- a/dashboard/TrajectoryViewer.svelte +++ b/dashboard/TrajectoryViewer.svelte @@ -2058,6 +2058,54 @@ class Hand { return null; } + function gameReplay(sample, samples, trajectory = []) { + const episodeId = (part) => part?.metadata?.balatro?.episode_id + ?? part?.metadata?.rollout_id ?? part?.rollout_index; + const id = episodeId(sample); + const candidates = id == null ? [sample] : [sample, ...(Array.isArray(samples) ? samples : [])] + .filter(part => part && String(episodeId(part)) === String(id)); + const parts = [...new Map(candidates.filter(Boolean).map(part => [part.metadata?.segment_id ?? 0, part])).values()] + .sort((a, b) => (a.metadata?.segment_id ?? 0) - (b.metadata?.segment_id ?? 0)); + if (!parts.length) parts.push(null); + const result = { initial: null, states: [], actions: [], inputs: [], turns: [], + segments: parts.length, expectedSegments: sample?.metadata?.segment_count ?? parts.length, + finalAnte: sample?.metadata?.balatro?.final_ante ?? sample?.metadata?.['balatro/final_ante'], + missingResults: 0 }; + let pending = null; + for (const part of parts) { + const messages = typeof part?.response === 'string' && part.response.length + ? [{ content: part.response }] + : part?.metadata?.trajectory_messages || (part === sample || part == null ? trajectory : []); + const snapshot = initialStateFrom(Array.isArray(part?.prompt) ? part.prompt : [{ content: part?.prompt }]) + || initialStateFrom(messages) || (part === sample ? initialStateFrom(trajectory) : null); + const start = part?.metadata?.segment_turn_start; + // A rebase moves the preceding action's result into the next prompt. + // Use that complete snapshot, without inheriting stale fields across it. + if (pending && snapshot && start === pending.turn + 1) { + result.states.push(snapshot); result.actions.push(pending.action); + result.inputs.push(pending.before); result.turns.push(pending.turn); + result.missingResults -= 1; + } + pending = null; + if (!result.initial) result.initial = snapshot; + const states = statesFrom(messages, snapshot); + const actions = actionsFrom(messages); + states.forEach((state, index) => { + result.states.push(state); result.actions.push(actions[index] || null); + result.inputs.push(index ? states[index - 1] : snapshot); + result.turns.push((start ?? 1) + index); + }); + if (actions.length > states.length) { + result.missingResults += actions.length - states.length; + if (actions.length === states.length + 1 && start != null) { + pending = { action: actions.at(-1), before: states.at(-1) || snapshot, + turn: start + actions.length - 1 }; + } + } + } + return result; + } + function selectedBlind(state) { const blinds = state?.blinds; if (!blinds || typeof blinds !== "object" || Array.isArray(blinds)) return null; @@ -2301,18 +2349,10 @@ class Hand { } } - let stateMessages = $derived( - text(sample?.response).includes("") - ? [{ role: "assistant", content: sample.response }] - : trajectory, - ); - let initialState = $derived( - initialStateFrom(trajectory) - || initialStateFrom(Array.isArray(sample?.prompt) ? sample.prompt : [{ content: sample?.prompt }]) - || initialStateFrom(stateMessages), - ); - let states = $derived(statesFrom(stateMessages, initialState)); - let actions = $derived(actionsFrom(stateMessages)); + let replay = $derived(gameReplay(sample, samples, trajectory)); + let initialState = $derived(replay.initial); + let states = $derived(replay.states); + let actions = $derived(replay.actions); let groups = $derived.by(() => { const result = []; const frames = states.map((state, index) => ({ state, index })); @@ -2334,6 +2374,11 @@ class Hand { }); let activeGroupIndex = $state(0); let activeFrameIndex = $state(0); + let navigationKey = $derived(sample?.metadata?.balatro?.episode_id + ?? sample?.metadata?.rollout_id ?? sample?.rollout_index ?? sample ?? trajectory); + $effect(() => { + if (navigationKey != null) { activeGroupIndex = 0; activeFrameIndex = 0; } + }); let activeGroup = $derived(groups[activeGroupIndex] || groups.at(-1) || null); let activeFrame = $derived(activeGroup?.frames[Math.min(activeFrameIndex, Math.max(activeGroup.frames.length - 1, 0))] || null); let latest = $derived(activeFrame?.state || states.at(-1) || {}); @@ -2346,7 +2391,7 @@ class Hand { ? Object.entries(latest.blinds || {}).map(([id, blind]) => ({ id, ...blind })) : [], ); let activeAction = $derived(actions[activeFrame?.index ?? -1] || null); - let previousState = $derived(activeFrame?.index > 0 ? states[activeFrame.index - 1] : initialState); + let previousState = $derived(replay.inputs[activeFrame?.index] || initialState); let selectedIndices = $derived( activeAction && ["play", "discard", "use"].includes(activeAction.method) && Array.isArray(activeAction.params?.cards) ? activeAction.params.cards @@ -2568,10 +2613,12 @@ class Hand {
BALATROTRAJECTORY REPLAY · READ ONLY
-
{states.length} turns · {groups.length} phase groups · {Array.isArray(samples) ? samples.length : 0} samples
+
{states.length} recorded moves · {groups.length} phase groups{#if replay.finalAnte != null} · Final ante {replay.finalAnte}{/if}
{latest.phase || run?.status || "RUN"}
{#if activeGroup} + {#if replay.segments < replay.expectedSegments}

Partial replay: {replay.segments} of {replay.expectedSegments} game segments available.

{/if} + {#if replay.missingResults}

{replay.missingResults} move result{replay.missingResults === 1 ? " was" : "s were"} not saved. Showing recorded states only.

{/if}