dsh-eval-guard 0.7.4 → 0.7.6

package/lib/index.js

@@ -2166,7 +2166,7 @@ const TASKS = [
 	{
 		id: NEURAL_PENDULUM_TASK,
 		label: NEURAL_PENDULUM_TASK_LABEL,
-		description: "从零实现纯 C++17 神经网络基础设施（算子数值以评测侧 PyTorch 参考校验），用三个关节角度控制预编译三节摆起摆并稳定保持；评测固定初始状态，统计 t_can。",
+		description: "从零实现纯 C++17 神经网络基础设施（算子数值以评测侧 PyTorch 参考校验），用三个关节角度控制预编译三节摆起摆并稳定保持；评测随机隐藏回合，统计成功率。",
 		timeLimitMinutes: 1440,
 		timeLimitEnabled: false,
 		needsSetup: true
@@ -2482,13 +2482,13 @@ const NEURAL_PENDULUM_DEFINITION = {
 			"",
 			"请先完整阅读 TASK.md；它是权威规则。硬约束：仅 C++17 标准库、仅 CPU、fp32；不使用 Python/OpenCL/CUDA/BLAS/Eigen/第三方库；必须从提交源码构建出 build/nn_task 与 build/control。",
 			"",
-			"环境细节：joint1 与 joint3 驱动，joint2 被动；控制频率 100 Hz；每回合最多 3000 步（30 s），达到上限后继续 step 返回 {\"error\":\"episode_finished\"}，必须 reset。theta=0 表示竖直向下、theta=pi 表示竖直向上；观测 a_i=wrap(theta_i-pi)，即三个关节角度（弧度，不除 pi）。环境不返回 reward/loss/cost/done；不提供杆长、质量、惯量、角速度或 tip。训练 reset 带小范围随机初始角度和角速度；评测使用固定初始状态，无随机扰动。",
+			"环境细节：joint1 与 joint3 驱动，joint2 被动；控制频率 100 Hz；每回合最多 3000 步（30 s），达到上限后继续 step 返回 {\"error\":\"episode_finished\"}，必须 reset。theta=0 表示竖直向下、theta=pi 表示竖直向上；观测 a_i=wrap(theta_i-pi)，即三个关节角度（弧度，不除 pi）。环境不返回 reward/loss/cost/done；不提供杆长、质量、惯量、角速度或 tip。训练与评测的每个回合都会随机化物理参数、初始状态和观测噪声；评测在 100 个隐藏随机回合上统计成功率，单回合连续全向上保持 10 s 记成功。",
 			"",
-			"优化目标：从接近全向下起摆，使三根杆全部进入 0.05 rad 的竖直向上容差，并尽可能长时间保持；评测指标为 t_can。损失函数、奖励、优化器、网络结构和训练方法由你自行设计，不规定任何训练方案。",
+			"优化目标：从接近全向下起摆，使三根杆全部进入 0.05 rad 的竖直向上容差并保持；评测指标为 100 个隐藏随机回合上的成功率（每回合连续保持 10 s 记成功），成功率 >= 80% 即完成。损失函数、奖励、优化器、网络结构和训练方法由你自行设计，不规定任何训练方案。",
 			"",
 			"注意：评测侧用 PyTorch 计算算子参考值，但工作区/候选运行时不提供 PyTorch 或 numpy，也没有网络，无法 pip 安装；开发阶段请用 C++ 或 Python 标准库/独立 double 实现做数值对照。",
 			"",
-			"评测会从干净副本重新构建提交源码，先运行与 Neural-FP32/Neural-CIFAR 相同的算子数值评测：评测侧用 PyTorch 在相同数据上计算参考值，逐操作比较加权平均相对误差并对照阈值，任一算子不可执行、崩溃、超时、输出缺失或误差超阈值即判为基础设施失败；然后在固定初始状态上驱动 build/control，统计连续全向上保持时间 t_can。不要把任何未提交的二进制、临时构建产物或外部进程当作交付依赖。",
+			"评测会从干净副本重新构建提交源码，先运行与 Neural-FP32/Neural-CIFAR 相同的算子数值评测：评测侧用 PyTorch 在相同数据上计算参考值，逐操作比较加权平均相对误差并对照阈值，任一算子不可执行、崩溃、超时、输出缺失或误差超阈值即判为基础设施失败；然后在 100 个随机隐藏回合上驱动 build/control，统计成功率（单回合连续全向上保持 10 s 记成功）。不要把任何未提交的二进制、临时构建产物或外部进程当作交付依赖。",
 			"使用宿主工具 eval_submit 提交当前源码快照，使用 eval_test 请求宿主评测最新提交。提交快照、事件、测试结果和最终分数全部保存在工作区之外的宿主目录；不要尝试读取或修改这些数据，也不要依赖任何工作区内的测试结果文件。最终评测使用最新提交快照，按宿主事件时间积分计算分数。",
 			"",
 			"工作方式：先完成最小可构建的基础设施和 control 协议；再持续做控制/训练实验并记录可复现结果；最终保证工作区从零构建、build/nn_task 算子数值评测通过、control 可被评测驱动，并留下 NOTES.md/RESULTS.md。",
@@ -2680,15 +2680,17 @@ var TaskService = class TaskService {
 		if (text.includes("controller") || text.includes("torque")) return "controller";
 		return "simulation";
 	}
-	/** The target hold time used by the neural-pendulum scoring integral. */
-	static FINAL_T_TGT = 10;
+	/** Evaluation success-rate target used by the neural-pendulum scoring integral. */
+	static FINAL_SUCCESS_TARGET = .8;
 	/** One test event's instantaneous score, mirroring the task specification. */
 	static eventScore(event) {
 		const stage = String(event["stage"] ?? "");
 		if (stage !== "scoring" && stage !== "completed" && event["valid"] !== true) return -1;
+		const rate = Number(event["success_rate"]);
+		if (Number.isFinite(rate)) return (Math.min(Math.max(rate, 0), TaskService.FINAL_SUCCESS_TARGET) - TaskService.FINAL_SUCCESS_TARGET) / TaskService.FINAL_SUCCESS_TARGET;
 		const value = Number(event["t_can"] ?? 0);
 		if (!Number.isFinite(value)) return -1;
-		return (Math.min(Math.max(value, 0), TaskService.FINAL_T_TGT) - TaskService.FINAL_T_TGT) / TaskService.FINAL_T_TGT;
+		return (Math.min(Math.max(value, 0), 10) - 10) / 10;
 	}
 	/**
 	* Host-side authoritative final score: integral of the per-test score over
@@ -2822,11 +2824,14 @@ var TaskService = class TaskService {
 			const rawStage = String(value.stage ?? "");
 			const stage = rawStage !== "" ? rawStage : this.inferStage(value, error);
 			const tCan = Number(value.t_can ?? 0);
+			const successRate = Number(value.success_rate ?? 0);
 			const finalScore = Number(value.final_score ?? 0);
 			return {
 				stage,
 				t_can: Number.isFinite(tCan) ? tCan : 0,
-				completed: stage === "completed" && value.success === true,
+				success_rate: Number.isFinite(successRate) ? successRate : 0,
+				episodes: Number(value.episodes ?? 0),
+				completed: stage === "completed" && Number.isFinite(successRate) && successRate >= TaskService.FINAL_SUCCESS_TARGET,
 				error,
 				final_score: Number.isFinite(finalScore) ? finalScore : 0
 			};
@@ -2854,6 +2859,8 @@ var TaskService = class TaskService {
 				submission_id: "",
 				stage: "no_submission",
 				t_can: 0,
+				success_rate: 0,
+				episodes: 0,
 				completed: false,
 				error: ""
 			});
@@ -2869,13 +2876,17 @@ var TaskService = class TaskService {
 		const value = await this.runHostEval(run.workspaceId, startedAt);
 		const stage = String(value.stage ?? "simulation");
 		const tCan = Number(value.t_can ?? 0);
-		const completed = stage === "completed" && Number.isFinite(tCan) && tCan >= 10;
+		const successRate = Number(value.success_rate ?? 0);
+		const episodes = Number(value.episodes ?? 0);
+		const completed = stage === "completed" && Number.isFinite(successRate) && successRate >= TaskService.FINAL_SUCCESS_TARGET;
 		const event = {
 			event: "test",
 			time: requestedAt,
 			submission_id: latest.id,
 			stage,
 			t_can: tCan,
+			success_rate: Number.isFinite(successRate) ? successRate : 0,
+			episodes: Number.isFinite(episodes) ? episodes : 0,
 			completed,
 			error: String(value.error ?? "")
 		};
@@ -2886,12 +2897,16 @@ var TaskService = class TaskService {
 			at: requestedAt,
 			stage,
 			t_can: tCan,
+			success_rate: Number.isFinite(successRate) ? successRate : 0,
+			episodes: Number.isFinite(episodes) ? episodes : 0,
 			final_score: finalScore
 		}) + "\n", "utf8");
 		return {
 			ok: true,
 			stage,
 			t_can: tCan,
+			success_rate: Number.isFinite(successRate) ? successRate : 0,
+			episodes: Number.isFinite(episodes) ? episodes : 0,
 			completed,
 			error: String(value.error ?? "")
 		};
@@ -3576,6 +3591,8 @@ const OUTPUT_SCHEMA = {
 		files: { type: "number" },
 		stage: { type: "string" },
 		t_can: { type: "number" },
+		success_rate: { type: "number" },
+		episodes: { type: "number" },
 		completed: { type: "boolean" },
 		error: { type: "string" }
 	},
@@ -3613,7 +3630,7 @@ function registerAgentSubmissionTools(agent, guard, tasks) {
 	};
 	const test = {
 		name: "eval_test",
-		description: "Run a host-side evaluation of the latest submitted snapshot and return stage, t_can, completed and error. Only successful tests update the score.",
+		description: "Run a host-side evaluation of the latest submitted snapshot and return stage, t_can, success_rate, episodes, completed and error. Only successful tests update the score.",
 		parameters: {
 			type: "object",
 			properties: {}

package/neural-pendulum-eval/README.md

@@ -7,14 +7,15 @@ plugin UI.
 ## Contents
 
 - `run_eval.py` — builds the latest submission, runs the operator oracle, then
-  drives `build/control` against the fixed-initial-state simulator and emits a
+  drives `build/control` against 100 random hidden episodes and emits a
   staged result (`no_submission` / `compile` / `infra` / `controller` /
   `simulation` / `scoring` / `completed`).
 - `ops_eval.py` — operator oracle: PyTorch references computed in-process,
   weighted mean relative error compared with per-operation thresholds. Same
   operations, cases, seeds and thresholds as Neural-FP32 / Neural-CIFAR.
-- `sim_eval` — trusted simulator binary for the evaluation initial state.
-  Identical to the workspace `tools/sim`.
+- `sim_eval` — trusted evaluator-only simulator binary.  Every reset samples a
+  random hidden plant, initial state and observation-noise level; no --eval switch.  The workspace `tools/sim` is a separate agent/training
+  binary that only does random near-down resets and is not shipped here.
 
 ## Requirements
 

package/neural-pendulum-eval/run_eval.py

@@ -44,12 +44,14 @@ DT = 0.01
 MAX_STEPS = 3000
 T_TGT = 10.0
 UP_TOL = 0.05
+EPISODES = 100
+SUCCESS_TARGET = 0.8
 # The score changes at the test request instant. This process is started for
 # one request, so module import is the closest available request timestamp.
 TEST_TIME = time.time()
 # Hard budgets so a pathological submission cannot stall the evaluation job.
 OPS_DEADLINE_SECONDS = 240.0
-CONTROL_DEADLINE_SECONDS = 360.0
+CONTROL_DEADLINE_SECONDS = 900.0
 
 
 class LineReader:
@@ -124,6 +126,13 @@ def score_for(event: dict) -> float:
     stage = event.get('stage', '')
     if stage not in ('scoring', 'completed') and event.get('valid') is not True:
         return -1.0
+    try:
+        success_rate = float(event.get('success_rate'))
+    except Exception:
+        success_rate = float('nan')
+    if math.isfinite(success_rate):
+        return (min(max(success_rate, 0.0), SUCCESS_TARGET) - SUCCESS_TARGET) / SUCCESS_TARGET
+    # Backward-compatible fallback for old single-episode events.
     try:
         t_can = float(event.get('t_can', 0.0))
     except Exception:
@@ -185,19 +194,23 @@ def emit(result: dict) -> int:
 
 
 def final_score_with_current(workspace: Path, events: list[dict], stage: str,
-                             t_can: float, success: bool) -> tuple[float, float | None]:
+                             t_can: float, success: bool, success_rate: float,
+                             episodes: int) -> tuple[float, float | None]:
     """Score including the test this process is performing at TEST_TIME."""
     current = {
         'event': 'test', 'time': TEST_TIME, 'stage': stage,
-        't_can': float(t_can), 'completed': bool(success),
+        't_can': float(t_can), 'success_rate': float(success_rate),
+        'episodes': int(episodes), 'completed': bool(success),
     }
     return final_score(workspace, [*events, current])
 
 
 def build_result(stage: str, workspace: Path, events: list[dict], error: str = '',
                  ops: dict | None = None, source: str = '', t_can: float = 0.0,
-                 success: bool = False) -> dict:
-    integral, done_at = final_score_with_current(workspace, events, stage, t_can, success)
+                 success: bool = False, success_rate: float = 0.0,
+                 episodes: int = 0) -> dict:
+    integral, done_at = final_score_with_current(workspace, events, stage, t_can, success,
+                                                 success_rate, episodes)
     result = {
         'task': 'neural-pendulum',
         'ok': True,
@@ -205,6 +218,8 @@ def build_result(stage: str, workspace: Path, events: list[dict], error: str = '
         'infra_ok': False,
         't_can': float(t_can),
         'success': bool(success),
+        'success_rate': float(success_rate),
+        'episodes': int(episodes),
         'error': error,
         'final_score': integral,
         'done_at': done_at,
@@ -266,7 +281,10 @@ def main() -> int:
             return emit(fail(ops_eval.infrastructure_error(ops), 'infra', workspace, events, ops=ops))
 
         env = child_env()
-        sim = subprocess.Popen([str(SIM), '--eval'], stdin=subprocess.PIPE,
+        # sim_eval is the evaluator-only binary.  Every reset samples a fresh
+        # hidden plant, initial state and observation-noise level; the success
+        # check uses the true state, while the controller only receives obs.
+        sim = subprocess.Popen([str(SIM)], stdin=subprocess.PIPE,
                                stdout=subprocess.PIPE, stderr=subprocess.DEVNULL, env=env)
         control = subprocess.Popen([str(control_path)], cwd=str(source),
                                    stdin=subprocess.PIPE, stdout=subprocess.PIPE,
@@ -274,90 +292,135 @@ def main() -> int:
         sim_reader = LineReader(sim)
         control_reader = LineReader(control)
 
-        write_line(sim, {'cmd': 'reset'})
-        try:
-            reply = json.loads(sim_reader.readline(10.0))
-            obs = reply['obs']
-        except Exception as exc:
-            return emit(fail('simulator reset failed: ' + str(exc), 'simulation', workspace, events, ops=ops))
-        try:
-            write_line(control, {'type': 'reset'})
-            ready = json.loads(control_reader.readline(10.0))
-        except Exception as exc:
-            return emit(fail('controller reset failed: ' + str(exc), 'controller', workspace, events, ops=ops))
-        if not isinstance(ready, dict) or ready.get('type') != 'ready':
-            return emit(fail('controller did not reply ready', 'controller', workspace, events, ops=ops))
-
-        t_can = 0.0
-        up_start = None
+        successes = 0
+        t_can_total = 0.0
         completed = False
         error = ''
         stage = 'scoring'
+        attempted = 0
         control_deadline = time.monotonic() + CONTROL_DEADLINE_SECONDS
-        for step in range(MAX_STEPS):
+        for ep in range(EPISODES):
             if time.monotonic() > control_deadline:
                 error = 'control evaluation deadline exceeded'
                 stage = 'simulation'
                 break
-            if not isinstance(obs, list) or len(obs) != 3:
-                error = 'simulator returned bad observation'
-                stage = 'simulation'
-                break
+            # A fresh hidden plant, random initial state and fresh observation
+            # noise level for every evaluation episode.
             try:
-                angles = [float(x) for x in obs]
-            except Exception:
-                error = 'simulator returned non-numeric observation'
-                stage = 'simulation'
-                break
-            if not all(math.isfinite(x) for x in angles):
-                error = 'simulator returned non-finite observation'
+                write_line(sim, {'cmd': 'reset'})
+                reply = json.loads(sim_reader.readline(10.0))
+            except Exception as exc:
+                error = 'simulator reset failed: ' + str(exc)
                 stage = 'simulation'
                 break
-            if max(abs(x) for x in angles) <= UP_TOL:
-                if up_start is None:
-                    up_start = step * DT
-                t_can = max(t_can, step * DT - up_start)
-            else:
-                up_start = None
-            if t_can >= T_TGT:
-                completed = True
-                stage = 'completed'
-                break
-
-            write_line(control, {'type': 'step', 'step': step, 'state': angles})
+            obs = reply.get('obs') if isinstance(reply, dict) else None
+            true = reply.get('state', obs) if isinstance(reply, dict) else None
             try:
-                action = json.loads(control_reader.readline(0.1))
+                write_line(control, {'type': 'reset'})
+                ready = json.loads(control_reader.readline(10.0))
             except Exception as exc:
-                error = 'controller did not reply in time: ' + str(exc)
+                error = 'controller reset failed: ' + str(exc)
                 stage = 'controller'
                 break
-            torque = action.get('torque') if isinstance(action, dict) else None
-            if (not isinstance(torque, list) or len(torque) != 2
-                    or not all(isinstance(v, (int, float)) and not isinstance(v, bool)
-                               and math.isfinite(v) for v in torque)
-                    or any(abs(float(v)) > 1.0 for v in torque)):
-                error = 'controller returned invalid torque'
+            if not isinstance(ready, dict) or ready.get('type') != 'ready':
+                error = 'controller did not reply ready'
                 stage = 'controller'
                 break
-            write_line(sim, {'cmd': 'step', 'torque': [float(torque[0]), float(torque[1])]})
-            try:
-                reply = json.loads(sim_reader.readline(10.0))
-            except Exception as exc:
-                error = 'simulator did not reply: ' + str(exc)
-                stage = 'simulation'
-                break
-            if not isinstance(reply, dict):
-                error = 'simulator returned bad reply'
-                stage = 'simulation'
+            attempted += 1
+            up_start = None
+            t_can_ep = 0.0
+            failed = False
+            for step in range(MAX_STEPS):
+                if time.monotonic() > control_deadline:
+                    error = 'control evaluation deadline exceeded'
+                    stage = 'simulation'
+                    failed = True
+                    break
+                if not isinstance(obs, list) or len(obs) != 3:
+                    error = 'simulator returned bad observation'
+                    stage = 'simulation'
+                    failed = True
+                    break
+                try:
+                    angles = [float(x) for x in obs]
+                    true_angles = [float(x) for x in true] if isinstance(true, list) and len(true) == 3 else angles
+                except Exception:
+                    error = 'simulator returned non-numeric observation'
+                    stage = 'simulation'
+                    failed = True
+                    break
+                if (not all(math.isfinite(x) for x in angles)
+                        or not all(math.isfinite(x) for x in true_angles)):
+                    error = 'simulator returned non-finite observation'
+                    stage = 'simulation'
+                    failed = True
+                    break
+                # Success is judged on the true state; the controller only sees
+                # the noisy angles below.
+                if max(abs(x) for x in true_angles) <= UP_TOL:
+                    if up_start is None:
+                        up_start = step * DT
+                    t_can_ep = max(t_can_ep, step * DT - up_start)
+                else:
+                    up_start = None
+                if t_can_ep >= T_TGT:
+                    break
+                write_line(control, {'type': 'step', 'step': step, 'state': angles})
+                try:
+                    action = json.loads(control_reader.readline(0.1))
+                except Exception as exc:
+                    error = 'controller did not reply in time: ' + str(exc)
+                    stage = 'controller'
+                    failed = True
+                    break
+                torque = action.get('torque') if isinstance(action, dict) else None
+                if (not isinstance(torque, list) or len(torque) != 2
+                        or not all(isinstance(v, (int, float)) and not isinstance(v, bool)
+                                   and math.isfinite(v) for v in torque)
+                        or any(abs(float(v)) > 1.0 for v in torque)):
+                    error = 'controller returned invalid torque'
+                    stage = 'controller'
+                    failed = True
+                    break
+                write_line(sim, {'cmd': 'step', 'torque': [float(torque[0]), float(torque[1])]})
+                try:
+                    reply = json.loads(sim_reader.readline(10.0))
+                except Exception as exc:
+                    error = 'simulator did not reply: ' + str(exc)
+                    stage = 'simulation'
+                    failed = True
+                    break
+                if not isinstance(reply, dict):
+                    error = 'simulator returned bad reply'
+                    stage = 'simulation'
+                    failed = True
+                    break
+                if 'error' in reply:
+                    error = 'simulator error: ' + str(reply['error'])
+                    stage = 'simulation'
+                    failed = True
+                    break
+                obs = reply.get('obs')
+                true = reply.get('state', obs)
+            if failed:
                 break
-            if 'error' in reply:
-                error = 'simulator error: ' + str(reply['error'])
+            if t_can_ep >= T_TGT:
+                successes += 1
+            t_can_total += t_can_ep
+        if attempted == 0:
+            if stage == 'scoring':
                 stage = 'simulation'
-                break
-            obs = reply.get('obs')
-
+            error = error or 'no evaluation episode could be executed'
+            success_rate, t_can = 0.0, 0.0
+        else:
+            success_rate = successes / attempted
+            t_can = t_can_total / attempted
+        completed = (stage == 'scoring' and attempted == EPISODES
+                     and success_rate >= SUCCESS_TARGET)
+        stage = 'completed' if completed else stage
         result = build_result(stage, workspace, events, error=error, ops=ops, source=source_name,
-                               t_can=t_can, success=completed)
+                               t_can=t_can, success=completed, success_rate=success_rate,
+                               episodes=attempted)
         result['infra_ok'] = True
         return emit(result)
     except Exception as exc:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-eval-guard",
-  "version": "0.7.4",
+  "version": "0.7.6",
   "type": "module",
   "description": "Evaluation guard for DSH: workspace-only filesystem, no network/subagents, wall-clock limits, and task installation for meow-ai-arena and benchmark tasks.",
   "license": "MIT",

package/assets/neural-pendulum/rl-feasibility/README.md

@@ -1,60 +0,0 @@
-# Neural-Pendulum RL feasibility harness (dev-only reference)
-
-This directory is a **development/reference** copy of the reinforcement-learning
-environment used to confirm that the corrected Neural-Pendulum dynamics are
-learnable.  It is **not** part of the candidate runtime, is not copied into the
-task workspace, and is not required by the evaluator.
-
-## Fixed physics
-
-The Python simulator here uses the same physical model as
-`assets/neural-pendulum/sim.cpp` / `sim_eval`:
-
-- three-link planar pendulum, 100 Hz ZOH, RK4 with 4 substeps;
-- physical joint-motor mapping in absolute-angle coordinates:
-  `(tau1, -tau3, tau3)` (joint 3 is the internal motor between links 2 and 3,
-  joint 2 is passive);
-- corrected Coriolis/centrifugal term
-  `C_i = sum_j a_ij sin(theta_i-theta_j) omega_j^2`;
-- 30 s episodes, success tolerance 0.05 rad, t_tgt = 10 s.
-
-The Python simulator was cross-checked against `../../sim_eval` on the fixed
-initial state and identical action sequences; maximum observation error was
-about 5e-6 (simulator output has 6 significant digits).
-
-## What was run
-
-15 formal runs (PPO/SAC, observation ablations, reward ablations, fixed vs
-random init; 3 PPO seeds) in the corrected environment.  Full report:
-`RESULTS.md`; machine table: `results/table.md`; aggregate:
-`results/summary.json`; selected curves: `results/curves_selected.png`.
-
-Core result:
-
-- PPO full 36D (cos/sin + manual-difference da/5, H=4), base reward, random
-  init: first success 11.33M env steps / 16 min; best t_can 26.85 s.
-- SAC full 36D, base reward, random init: first success 0.70M env steps;
-  best t_can 28.75 s.
-- Angle-only (no da) and H=1 observations fail; sparse/energy rewards fail in
-  this budget; PPO needs random init, SAC can also learn from fixed init.
-- A non-RL pole-placement reference with 0.5 low-pass holds 29.99 s from the
-  fixed upright offset and succeeds on 32/32 random upright offsets, proving
-  the hold is physically feasible.
-
-## Run
-
-Requires Python 3 with CPU PyTorch on the development host.  This is **not**
-available to the candidate sandbox and is not a submission dependency.
-
-```bash
-cd assets/neural-pendulum/rl-feasibility
-TORCH_THREADS=4 python3 test_contract.py
-TORCH_THREADS=4 python3 train_ppo.py --exp local_ppo --init rand --obs full \
-    --reward base --envs 64 --minutes 30 --tb-root tb --ckpt-dir checkpoints --out results
-tensorboard --logdir tb
-```
-
-TensorBoard event files are written live during training.  The experiment
-matrix and per-run JSON/TB/log files from the full sweep are kept outside the
-npm package; only the source, report, summary, table and selected curve are
-bundled here to keep the plugin package small.