From 8bc321d265b4380a6a9a7b9791bfcbfb9b63ca14 Mon Sep 17 00:00:00 2001
From: jkbennitt <jkbennitt@users.noreply.github.com>
Date: Thu, 11 Jun 2026 17:22:11 -0400
Subject: [PATCH 1/2] feat: OBS production studio automation for benchmark
 capture

- scripts/obs_record.py: start/stop/status recording via obs-websocket,
  per-model filenames (rle_<label>_<timestamp>)
- scripts/obs_studio.py: idempotent scene setup (RLE Game / Dashboard /
  PiP / Vertical), program scene switching, live score ticker watcher
  fed from results/*/latest_tick.json
- run_spread_n1.sh: per-model OBS recording start/stop (OBS_RECORD=0 to
  disable), per-model extra flags column, v0.2.0 validation roster
  (qwen3.7-max, kimi-k2.6, glm-5.1, mistral-medium-3-5, nemotron-120b)

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 CLAUDE.md                |   4 +-
 scripts/obs_record.py    |  86 ++++++++++++
 scripts/obs_studio.py    | 284 +++++++++++++++++++++++++++++++++++++++
 scripts/run_spread_n1.sh |  33 +++--
 uv.lock                  |   2 +-
 5 files changed, 399 insertions(+), 10 deletions(-)
 create mode 100644 scripts/obs_record.py
 create mode 100644 scripts/obs_studio.py

diff --git a/CLAUDE.md b/CLAUDE.md
index 790fe69..05c7d37 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -1,4 +1,4 @@
-# RLE — RimWorld Learning Environment
+# RLE — RimWorld Learning Environment
 
 Multi-agent benchmark where 7 Felix Agent SDK role-specialized LLM agents manage a RimWorld colony. Think FLE (Factorio Learning Environment) but for multi-agent coordination under uncertainty.
 
@@ -382,6 +382,8 @@ scripts/
 ├── analyze_spread.py      # Cross-model leaderboard vs baseline + failure taxonomy
 ├── visualize_results.py   # Matplotlib CSV plotter
 ├── serve_dashboard.py     # CORS-enabled file server for dashboard
+├── obs_record.py          # OBS recording start/stop/status via obs-websocket (per-model files)
+├── obs_studio.py          # OBS scene setup (Game/Dashboard/PiP/Vertical) + live score ticker
 ├── replay_ticks.py        # Replay a run's tick snapshots into the dashboard (for capture)
 ├── record_dashboard.mjs   # Headless Playwright dashboard recording (run with node)
 └── capture_run_media.sh   # During-run game-window stills + tick snapshots
diff --git a/scripts/obs_record.py b/scripts/obs_record.py
new file mode 100644
index 0000000..32c9001
--- /dev/null
+++ b/scripts/obs_record.py
@@ -0,0 +1,86 @@
+# /// script
+# dependencies = ["obsws-python>=1.7"]
+# ///
+"""Control OBS recording via obs-websocket (v5) for benchmark run capture.
+
+Usage (run via uv so the dependency resolves without polluting the venv):
+    uv run scripts/obs_record.py status
+    uv run scripts/obs_record.py start --label fable5
+    uv run scripts/obs_record.py stop
+
+The WebSocket password is read from the OBS_WS_PASSWORD env var, falling back
+to OBS's own plugin config file. `start --label X` sets the recording filename
+to ``rle_<label>_<timestamp>`` so per-model footage is self-identifying.
+
+Requires OBS running with the WebSocket server enabled (Tools > WebSocket
+Server Settings, port 4455).
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import sys
+from pathlib import Path
+
+import obsws_python as obs
+
+
+def _password() -> str:
+    env = os.environ.get("OBS_WS_PASSWORD")
+    if env:
+        return env
+    cfg = (
+        Path(os.environ["APPDATA"])
+        / "obs-studio"
+        / "plugin_config"
+        / "obs-websocket"
+        / "config.json"
+    )
+    data = json.loads(cfg.read_text(encoding="utf-8-sig"))
+    password: str = data["server_password"]
+    return password
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("command", choices=["start", "stop", "status"])
+    parser.add_argument("--label", default="", help="filename label for start")
+    parser.add_argument("--port", type=int, default=4455)
+    args = parser.parse_args()
+
+    client = obs.ReqClient(
+        host="localhost", port=args.port, password=_password(), timeout=10
+    )
+
+    status = client.get_record_status()
+    if args.command == "status":
+        print(f"recording={status.output_active} timecode={status.output_timecode}")
+        return 0
+
+    if args.command == "start":
+        if status.output_active:
+            print("already recording", file=sys.stderr)
+            return 1
+        if args.label:
+            client.set_profile_parameter(
+                "Output",
+                "FilenameFormatting",
+                f"rle_{args.label}_%CCYY-%MM-%DD_%hh-%mm-%ss",
+            )
+        client.start_record()
+        print(f"recording started label={args.label or '(default)'}")
+        return 0
+
+    # stop
+    if not status.output_active:
+        print("not recording", file=sys.stderr)
+        return 1
+    resp = client.stop_record()
+    print(f"recording stopped -> {resp.output_path}")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/scripts/obs_studio.py b/scripts/obs_studio.py
new file mode 100644
index 0000000..bae8445
--- /dev/null
+++ b/scripts/obs_studio.py
@@ -0,0 +1,284 @@
+# /// script
+# dependencies = ["obsws-python>=1.7"]
+# ///
+"""RLE production-studio control for OBS via obs-websocket (v5).
+
+Subcommands:
+    setup    Idempotently create the RLE scene collection:
+               - "RLE Game"      game capture + score ticker overlay
+               - "RLE Dashboard" full-screen dashboard browser source
+               - "RLE PiP"       game capture + dashboard picture-in-picture
+                                 (bottom-right) + score ticker
+               - "RLE Vertical"  narrow (608px) dashboard browser source,
+                                 centered — crop to 9:16 in post for phone clips
+    scene    Switch the program scene:  obs_studio.py scene "RLE PiP"
+    overlay  Watch run output dirs and keep the score ticker text current:
+               obs_studio.py overlay --watch results/spread
+             Picks the most recently updated */latest_tick.json under --watch;
+             the model label is the parent directory name. Runs until killed.
+
+Run via uv: ``uv run scripts/obs_studio.py setup``. The browser sources render
+the dashboard inside OBS itself — no visible browser window is needed, so the
+desktop stays free while runs record. Requires the React dashboard on :3000
+and the tick server on :9000.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import sys
+import time
+from pathlib import Path
+from typing import Any
+
+import obsws_python as obs
+
+SCENE_GAME = "RLE Game"
+SCENE_DASH = "RLE Dashboard"
+SCENE_PIP = "RLE PiP"
+SCENE_VERTICAL = "RLE Vertical"
+GAME_INPUT = "Game Capture"  # pre-existing user source, reused not recreated
+DASH_INPUT = "RLE Dashboard Browser"
+DASH_VERTICAL_INPUT = "RLE Dashboard Vertical"
+OVERLAY_INPUT = "RLE Overlay"
+# ?api skips the dashboard's first-run setup screen; ?preset selects the
+# built-in capture layouts (both ship in rimapi-dashboard for fresh browser
+# profiles like OBS's embedded CEF).
+DASHBOARD_URL = (
+    "http://localhost:3000/rimapi-dashboard"
+    "?api=http%3A%2F%2Flocalhost%3A8765%2Fapi%2Fv1&preset=RLE%20Capture"
+)
+DASHBOARD_VERTICAL_URL = (
+    "http://localhost:3000/rimapi-dashboard"
+    "?api=http%3A%2F%2Flocalhost%3A8765%2Fapi%2Fv1&preset=RLE%20Vertical"
+)
+CANVAS_W, CANVAS_H = 1920, 1080
+VERTICAL_W = 608  # 608x1080 is exactly 9:16 on a 1080p canvas
+
+
+def _password() -> str:
+    env = os.environ.get("OBS_WS_PASSWORD")
+    if env:
+        return env
+    cfg = (
+        Path(os.environ["APPDATA"])
+        / "obs-studio"
+        / "plugin_config"
+        / "obs-websocket"
+        / "config.json"
+    )
+    data = json.loads(cfg.read_text(encoding="utf-8-sig"))
+    password: str = data["server_password"]
+    return password
+
+
+def _client(port: int) -> obs.ReqClient:
+    return obs.ReqClient(host="localhost", port=port, password=_password(), timeout=10)
+
+
+# ---------------------------------------------------------------- setup ----
+
+
+def _ensure_scene(c: obs.ReqClient, name: str) -> None:
+    existing = {s["sceneName"] for s in c.get_scene_list().scenes}
+    if name not in existing:
+        c.create_scene(name)
+        print(f"created scene: {name}")
+
+
+def _ensure_input(
+    c: obs.ReqClient, scene: str, name: str, kind: str, settings: dict[str, Any]
+) -> None:
+    existing = {i["inputName"] for i in c.get_input_list().inputs}
+    if name in existing:
+        c.set_input_settings(name, settings, overlay=True)
+    else:
+        c.create_input(scene, name, kind, settings, True)
+        print(f"created input: {name} ({kind})")
+
+
+def _ensure_item(c: obs.ReqClient, scene: str, source: str) -> int:
+    for item in c.get_scene_item_list(scene).scene_items:
+        if item["sourceName"] == source:
+            return int(item["sceneItemId"])
+    item_id: int = c.create_scene_item(scene, source, True).scene_item_id
+    print(f"added {source} -> {scene}")
+    return item_id
+
+
+def _place(
+    c: obs.ReqClient,
+    scene: str,
+    item_id: int,
+    x: float,
+    y: float,
+    bounds_w: float | None = None,
+    bounds_h: float | None = None,
+) -> None:
+    transform: dict[str, Any] = {"positionX": x, "positionY": y}
+    if bounds_w is not None and bounds_h is not None:
+        transform |= {
+            "boundsType": "OBS_BOUNDS_SCALE_INNER",
+            "boundsAlignment": 0,
+            "boundsWidth": bounds_w,
+            "boundsHeight": bounds_h,
+        }
+    c.set_scene_item_transform(scene, item_id, transform)
+
+
+def _text_kind(c: obs.ReqClient) -> str:
+    kinds = c.get_input_kind_list(False).input_kinds
+    for kind in ("text_gdiplus_v3", "text_gdiplus_v2", "text_ft2_source_v2"):
+        if kind in kinds:
+            return kind
+    raise RuntimeError(f"no text source kind available, found: {kinds}")
+
+
+def cmd_setup(c: obs.ReqClient) -> None:
+    inputs = {i["inputName"] for i in c.get_input_list().inputs}
+    if GAME_INPUT not in inputs:
+        print(
+            f"warning: no '{GAME_INPUT}' input found — game scenes will be "
+            "created without it; add your capture source manually",
+            file=sys.stderr,
+        )
+
+    browser_settings = {
+        "url": DASHBOARD_URL,
+        "width": CANVAS_W,
+        "height": CANVAS_H,
+        # Keep rendering when not in program so scene switches never show a
+        # page reload on stream.
+        "shutdown": False,
+        "restart_when_active": False,
+    }
+    overlay_settings = {
+        "text": "RLE — waiting for tick data",
+        "font": {"face": "Consolas", "size": 30, "style": "Bold"},
+        "outline": True,
+        "outline_size": 2,
+        "outline_color": 0xFF000000,
+    }
+
+    for scene in (SCENE_GAME, SCENE_DASH, SCENE_PIP, SCENE_VERTICAL):
+        _ensure_scene(c, scene)
+
+    _ensure_input(c, SCENE_DASH, DASH_INPUT, "browser_source", browser_settings)
+    _ensure_input(
+        c,
+        SCENE_VERTICAL,
+        DASH_VERTICAL_INPUT,
+        "browser_source",
+        browser_settings | {"width": VERTICAL_W, "url": DASHBOARD_VERTICAL_URL},
+    )
+    _ensure_input(c, SCENE_GAME, OVERLAY_INPUT, _text_kind(c), overlay_settings)
+
+    # RLE Game: game full-canvas, ticker bottom-left
+    if GAME_INPUT in inputs:
+        gid = _ensure_item(c, SCENE_GAME, GAME_INPUT)
+        _place(c, SCENE_GAME, gid, 0, 0, CANVAS_W, CANVAS_H)
+    oid = _ensure_item(c, SCENE_GAME, OVERLAY_INPUT)
+    _place(c, SCENE_GAME, oid, 24, CANVAS_H - 60)
+
+    # RLE Dashboard: browser full-canvas
+    did = _ensure_item(c, SCENE_DASH, DASH_INPUT)
+    _place(c, SCENE_DASH, did, 0, 0, CANVAS_W, CANVAS_H)
+
+    # RLE PiP: game full-canvas, dashboard 30% bottom-right, ticker bottom-left
+    if GAME_INPUT in inputs:
+        gid = _ensure_item(c, SCENE_PIP, GAME_INPUT)
+        _place(c, SCENE_PIP, gid, 0, 0, CANVAS_W, CANVAS_H)
+    pip_w, pip_h, margin = 576, 324, 16
+    pid = _ensure_item(c, SCENE_PIP, DASH_INPUT)
+    _place(
+        c,
+        SCENE_PIP,
+        pid,
+        CANVAS_W - pip_w - margin,
+        CANVAS_H - pip_h - margin,
+        pip_w,
+        pip_h,
+    )
+    oid = _ensure_item(c, SCENE_PIP, OVERLAY_INPUT)
+    _place(c, SCENE_PIP, oid, 24, CANVAS_H - 60)
+
+    # RLE Vertical: narrow dashboard centered (crop the 608px band in post)
+    vid = _ensure_item(c, SCENE_VERTICAL, DASH_VERTICAL_INPUT)
+    _place(c, SCENE_VERTICAL, vid, (CANVAS_W - VERTICAL_W) / 2, 0)
+
+    print("setup complete")
+
+
+# -------------------------------------------------------------- overlay ----
+
+
+def _latest_tick_file(watch: Path) -> Path | None:
+    candidates = list(watch.glob("*/latest_tick.json"))
+    direct = watch / "latest_tick.json"
+    if direct.exists():
+        candidates.append(direct)
+    if not candidates:
+        return None
+    return max(candidates, key=lambda p: p.stat().st_mtime)
+
+
+def cmd_overlay(c: obs.ReqClient, watch: Path, interval: float) -> None:
+    print(f"watching {watch} (ctrl-c to stop)")
+    last_text = ""
+    while True:
+        tick_file = _latest_tick_file(watch)
+        if tick_file is not None:
+            try:
+                data = json.loads(tick_file.read_text())
+                label = tick_file.parent.name
+                score = data.get("score") or {}
+                composite = score.get("composite")
+                score_txt = f"{composite:.3f}" if composite is not None else "—"
+                text = (
+                    f"{label}  •  tick {data.get('tick', '?')}"
+                    f"  •  day {data.get('day', '?')}"
+                    f"  •  score {score_txt}"
+                    f"  •  {data.get('phase', '')}"
+                )
+                if text != last_text:
+                    c.set_input_settings(OVERLAY_INPUT, {"text": text}, overlay=True)
+                    last_text = text
+            except (json.JSONDecodeError, OSError):
+                pass  # mid-write or transient — retry next cycle
+        time.sleep(interval)
+
+
+# ----------------------------------------------------------------- main ----
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description=__doc__)
+    sub = parser.add_subparsers(dest="command", required=True)
+    sub.add_parser("setup")
+    p_scene = sub.add_parser("scene")
+    p_scene.add_argument("name")
+    p_overlay = sub.add_parser("overlay")
+    p_overlay.add_argument("--watch", default="results/spread", type=Path)
+    p_overlay.add_argument("--interval", default=2.0, type=float)
+    parser.add_argument("--port", type=int, default=4455)
+    args = parser.parse_args()
+
+    c = _client(args.port)
+
+    if args.command == "setup":
+        cmd_setup(c)
+    elif args.command == "scene":
+        c.set_current_program_scene(args.name)
+        print(f"program scene -> {args.name}")
+    elif args.command == "overlay":
+        try:
+            cmd_overlay(c, args.watch, args.interval)
+        except KeyboardInterrupt:
+            pass
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/scripts/run_spread_n1.sh b/scripts/run_spread_n1.sh
index 480e9e5..f3d6f86 100644
--- a/scripts/run_spread_n1.sh
+++ b/scripts/run_spread_n1.sh
@@ -7,19 +7,33 @@ PY=./.venv/Scripts/python
 export ROLE_TIMEOUT_S=180
 export PYTHONIOENCODING=utf-8
 
-# name | provider | model | prompt$/MTok | completion$/MTok | base-url(optional)
+# Per-model OBS capture via scripts/obs_record.py (requires OBS running with
+# WebSocket server enabled). Set OBS_RECORD=0 to disable.
+OBS_RECORD="${OBS_RECORD:-1}"
+obs() {
+  [ "$OBS_RECORD" = "1" ] || return 0
+  uv run scripts/obs_record.py "$@" || echo "(obs $1 failed — continuing)"
+}
+
+# name | provider | model | prompt$/MTok | completion$/MTok | base-url(optional) | extra-flags(optional)
 RUNS=(
-  "fable5|claude-code|claude-fable-5|10|50|"
-  "opus48|claude-code|claude-opus-4-8|5|25|"
-  "gpt55|openai|openai/gpt-5.5|5|30|https://openrouter.ai/api/v1"
-  "gemini35|openai|google/gemini-3.5-flash|1.5|9|https://openrouter.ai/api/v1"
-  "grok43|openai|x-ai/grok-4.3|1.25|2.5|https://openrouter.ai/api/v1"
-  "deepseekv4|openai|deepseek/deepseek-v4-pro|0.435|0.87|https://openrouter.ai/api/v1"
+  "fable5|claude-code|claude-fable-5|10|50||"
+  "opus48|claude-code|claude-opus-4-8|5|25||"
+  "gpt55|openai|openai/gpt-5.5|5|30|https://openrouter.ai/api/v1|"
+  "gemini35|openai|google/gemini-3.5-flash|1.5|9|https://openrouter.ai/api/v1|"
+  "grok43|openai|x-ai/grok-4.3|1.25|2.5|https://openrouter.ai/api/v1|"
+  "deepseekv4|openai|deepseek/deepseek-v4-pro|0.435|0.87|https://openrouter.ai/api/v1|"
+  # v0.2.0 validation spread additions (pricing from OpenRouter /models 2026-06-11)
+  "qwen37max|openai|qwen/qwen3.7-max|1.25|3.75|https://openrouter.ai/api/v1|--no-think"
+  "kimi26|openai|moonshotai/kimi-k2.6|0.67|3.39|https://openrouter.ai/api/v1|"
+  "glm51|openai|z-ai/glm-5.1|0.98|3.08|https://openrouter.ai/api/v1|"
+  "mistralmed35|openai|mistralai/mistral-medium-3-5|1.5|7.5|https://openrouter.ai/api/v1|"
+  "nemotron120b|openai|nvidia/nemotron-3-super-120b-a12b|0.09|0.45|https://openrouter.ai/api/v1|--no-think"
 )
 
 echo "=== STAGE S SPREAD START ==="
 for entry in "${RUNS[@]}"; do
-  IFS='|' read -r name provider model pin pout baseurl <<< "$entry"
+  IFS='|' read -r name provider model pin pout baseurl extraflags <<< "$entry"
   out="results/spread/${name}"
   echo ""
   echo ">>> [$name] provider=$provider model=$model"
@@ -29,8 +43,11 @@ for entry in "${RUNS[@]}"; do
         --output "$out"
         --prompt-price-per-mtok "$pin" --completion-price-per-mtok "$pout")
   [ -n "$baseurl" ] && args+=(--base-url "$baseurl")
+  [ -n "$extraflags" ] && args+=($extraflags)
+  obs start --label "$name"
   "$PY" "${args[@]}"
   rc=$?
+  obs stop
   if [ $rc -eq 0 ]; then echo "<<< [$name] OK"; else echo "<<< [$name] FAILED rc=$rc (continuing)"; fi
 done
 echo ""
diff --git a/uv.lock b/uv.lock
index ccd9db1..22383ec 100644
--- a/uv.lock
+++ b/uv.lock
@@ -951,7 +951,7 @@ wheels = [
 
 [[package]]
 name = "rimworld-learning-environment"
-version = "0.1.0"
+version = "0.2.0"
 source = { editable = "." }
 dependencies = [
     { name = "felix-agent-sdk" },

From 0b8e5ba8f6b775b750bb8e968d98dd0e2d338066 Mon Sep 17 00:00:00 2001
From: jkbennitt <jkbennitt@users.noreply.github.com>
Date: Thu, 11 Jun 2026 17:35:41 -0400
Subject: [PATCH 2/2] chore: dedup record_dashboard.mjs into rle-media capture
 rig

The post-run Playwright dashboard recorder was duplicated in RLE/scripts
and rle-media/capture (the latter is the set-up rig with playwright
installed). Remove the RLE copy and repoint the run-analysis skill +
CLAUDE.md package structure at the canonical rle-media location. Also
note the dashboard's new built-in presets and ?api/?preset params.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 .claude/skills/run-analysis/SKILL.md | 16 ++++++-----
 CLAUDE.md                            |  2 +-
 scripts/record_dashboard.mjs         | 42 ----------------------------
 3 files changed, 10 insertions(+), 50 deletions(-)
 delete mode 100644 scripts/record_dashboard.mjs

diff --git a/.claude/skills/run-analysis/SKILL.md b/.claude/skills/run-analysis/SKILL.md
index a6b2bab..42fb62d 100644
--- a/.claude/skills/run-analysis/SKILL.md
+++ b/.claude/skills/run-analysis/SKILL.md
@@ -87,8 +87,9 @@ of every segment (Read the PNGs — never ship an unviewed render).
   data in `src/data.json` regenerated from `leaderboard.json`). Assets must live under
   `public/` (staticFile) — junctions break the bundler.
 - Timelapse source: `ffmpeg -i master.mkv -vf "setpts=PTS/60,fps=24,crop=trunc(iw/2)*2:trunc(ih/2)*2" -an`.
-- **Dashboard clip rig** (source: `scripts/record_dashboard.mjs`) — headless Playwright
-  recording, never screen capture. Four processes, in order:
+- **Dashboard clip rig** (source: `D:\RLE_media\capture\record_dashboard.mjs` — the
+  rle-media repo, which is the set-up scratch dir with playwright already installed) —
+  headless Playwright recording, never screen capture. Four processes, in order:
   1. RimWorld + RIMAPI up (the dashboard's connect gate probes :8765; CORS is fine, but
      the URL field starts EMPTY — the script fills it and clicks Connect).
   2. `./.venv/Scripts/python scripts/serve_dashboard.py results/replay` (CORS server :9000).
@@ -96,11 +97,12 @@ of every segment (Read the PNGs — never ship an unviewed render).
      (Remotion's render server squats on 3000; craco exits "already running" instead of failing loud).
   4. `python scripts/replay_ticks.py --model <name> --interval 2 --loop` (feeds
      results/replay/latest_tick.json from the run's tick_snapshots).
-  Then record: set up a scratch dir once (`bun add playwright && bunx playwright install
-  chromium`), copy record_dashboard.mjs next to it, and run with **node** — Playwright's
-  chromium launch hangs 180s under bun on Windows. The script seeds the 5 RLE widgets via
-  a localStorage `dashboard_presets` preset (fresh browser contexts have no layout, and the
-  RLE widgets aren't in the default). Record 1920x1080 and 1080x1920 passes; trim the
+  Then record from `D:\RLE_media\capture\` (playwright already installed there; if starting
+  fresh elsewhere, `bun add playwright && bunx playwright install chromium` first) and run
+  with **node** — Playwright's chromium launch hangs 180s under bun on Windows. The script
+  seeds the 5 RLE widgets via a localStorage `dashboard_presets` preset (the dashboard now
+  also ships built-in `RLE Capture`/`RLE Vertical` presets selectable via `?preset=`, and
+  `?api=<url>` skips the connect gate — either path works). Record 1920x1080 and 1080x1920 passes; trim the
   connect/load preamble (~8s) when converting webm → mp4
   (`ffmpeg -ss 8 -i in.webm -c:v libx264 -crf 19 -pix_fmt yuv420p -r 30 out.mp4`).
 - Verify every render before calling it done: extract stills of each segment with ffmpeg
diff --git a/CLAUDE.md b/CLAUDE.md
index 05c7d37..b1006b8 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -385,8 +385,8 @@ scripts/
 ├── obs_record.py          # OBS recording start/stop/status via obs-websocket (per-model files)
 ├── obs_studio.py          # OBS scene setup (Game/Dashboard/PiP/Vertical) + live score ticker
 ├── replay_ticks.py        # Replay a run's tick snapshots into the dashboard (for capture)
-├── record_dashboard.mjs   # Headless Playwright dashboard recording (run with node)
 └── capture_run_media.sh   # During-run game-window stills + tick snapshots
+# (post-run Playwright dashboard recording lives in the rle-media repo: capture/record_dashboard.mjs)
 docker/
 ├── Dockerfile             # HeadlessRim + Xvfb (debian:bookworm-slim)
 ├── docker-compose.yml     # Volume mounts for game files, mods, saves
diff --git a/scripts/record_dashboard.mjs b/scripts/record_dashboard.mjs
deleted file mode 100644
index e2bdca7..0000000
--- a/scripts/record_dashboard.mjs
+++ /dev/null
@@ -1,42 +0,0 @@
-// Record the RLE dashboard replaying a run, via Playwright video capture.
-// Usage: node record_dashboard.mjs <url> <seconds> <outDir> [width] [height]
-import { chromium } from 'playwright';
-
-const [url = 'http://localhost:3001', secs = '28', outDir = 'D:/RLE_media/capture/video',
-  w = '1920', h = '1080'] = process.argv.slice(2);
-
-const browser = await chromium.launch();
-const ctx = await browser.newContext({
-  viewport: { width: Number(w), height: Number(h) },
-  recordVideo: { dir: outDir, size: { width: Number(w), height: Number(h) } },
-});
-const page = await ctx.newPage();
-// Seed an RLE-focused widget layout so the 5 RLE widgets render on load.
-const rlePreset = [{
-  name: 'RLE',
-  layout: [
-    { i: 'rleAgentStatus', x: 0, y: 0, w: 4, h: 2, isBounded: true },
-    { i: 'rleScoreTimeline', x: 4, y: 0, w: 8, h: 2, isBounded: true },
-    { i: 'rleAgentLog', x: 0, y: 2, w: 6, h: 3, isBounded: true },
-    { i: 'rleHelixPhase', x: 6, y: 2, w: 3, h: 3, isBounded: true },
-    { i: 'rleConflictResolution', x: 9, y: 2, w: 3, h: 3, isBounded: true },
-  ],
-  cardSettings: {},
-}];
-await page.addInitScript((preset) => {
-  localStorage.setItem('dashboard_presets', JSON.stringify(preset));
-  localStorage.setItem('last_selected_preset', 'RLE');
-}, rlePreset);
-await page.goto(url, { waitUntil: 'networkidle' });
-// Connect screen: fill the server URL, then connect.
-const urlInput = page.locator('input').first();
-if (await urlInput.isVisible().catch(() => false)) {
-  await urlInput.fill('http://localhost:8765/api/v1');
-  await page.getByRole('button', { name: /^connect$/i }).first().click();
-  await page.waitForTimeout(5000);
-}
-await page.waitForTimeout(Number(secs) * 1000);
-const path = await page.video().path();
-await ctx.close();
-await browser.close();
-console.log('saved:', path);