dsh-eval-guard 0.7.5 → 0.7.7

package/ISSUES.md

@@ -1,6 +1,6 @@
 # dsh-eval-guard 问题清单与修复记录
 
-> 版本：0.7.5 · 审计基线：本仓库工作树（含 0.7.5 修复与 Neural-Pendulum 仿真器分离）
+> 版本：0.7.7 · 审计基线：本仓库工作树（含 0.7.7 的 Neural-Pendulum 0.90 阈值与审核包）
 > 对照 DSH：0.2.1-alpha.1 源码（并核对 git tag 0.1.2 / 0.1.5 / 0.1.7 / 0.2.0-rc.1 / rc.2 / 0.2.1-alpha.1）
 > 本文件先记录问题，再记录修复状态。状态：✅ 已修复 / 🟡 部分修复 / ⛔ 保留（有明确原因或需要架构级改动）
 >
@@ -8,7 +8,11 @@
 >
 > **2026-10-23 会话回归修复（未发版）**：修复 Neural-Pendulum 仿真器 Coriolis 项多乘 cos 导致高转速下能量注入并产生 NaN；修正关节 3 在绝对角坐标下的广义力矩映射，由 (tau1,0,tau3) 改为 (tau1,-tau3,tau3)；TASK/SPEC/prompt 明确 theta 约定并说明工作区无 PyTorch/numpy；网络 syscall 改为 AF_INET/AF_INET6 的 EPERM 软拒绝，避免 pip/NSS 本地检查被误杀。
 
-> **0.7.5**：把 0.7.4 误带的开发用 RL 可行性代码从插件中撤除，只保留修正后的 simulator；同时把 agent 训练仿真器与评测仿真器拆开：`assets/neural-pendulum/sim_agent` 只做随机近向下 reset，评测用 `neural-pendulum-eval/sim_eval` 只做固定初态 reset，两者不共享 reset 分支。工作区仍只交付二进制，不提供仿真源码。
+> **0.7.7**：Neural-Pendulum 完成阈值提高到 0.90；prompt/TASK 声明任务已验证可完成、未 completed 前禁止停止；最终 build/control 必须由神经网络输出层直接产生力矩，最终控制程序不得含显式控制律；禁止逆向已编译文件或读取进程内存。另新增审核人员专用包 neural-pendulum-audit（不进入 workspace/npm 任务资产）。
+>
+> **0.7.6**：Neural-Pendulum 切换为 Tier A 评测：每回合随机化隐藏物理参数、初始状态与观测噪声（无摩擦/滞后/延迟），评测改为 100 个隐藏随机回合的成功率，成功率 >= 0.9 完成；计分改为按成功率归一化。训练仿真器与评测仿真器均实现随机化，工作区仍只交付二进制，不提供仿真源码。
+>
+> **0.7.5**：把 0.7.4 误带的开发用 RL 可行性代码从插件中撤除，只保留修正后的 simulator；同时把 agent 训练仿真器与评测仿真器拆开：`assets/neural-pendulum/sim_agent` 只做随机近向下 reset，评测用 `neural-pendulum-eval/sim_eval` 每个 reset 采样新的隐藏物理参数/初始状态/观测噪声；工作区仍只交付二进制，不提供仿真源码。工作区仍只交付二进制，不提供仿真源码。
 > **下文仍有若干条目标记为 ✅ 但实际未完成，不要再按旧状态理解**：arena legacy 的 `std::thread` 静态规则未移除；`cifar_cache.py` 解压仍无 filter、缓存路径仍用 `Path.home()/.dsh`；CIFAR 隐藏标签仍以文件形式落盘；FP32“30 分钟整轮”仍是 op 间检查；无 baseline 时评测仍 fail-open。其余任务相关修复按用户要求暂不动。
 
 ## 0. 修复状态总览

package/README.md

@@ -57,11 +57,11 @@ CIFAR-10 下载缓存固定在 DSH home 下（默认 `~/.dsh/eval-guard/cache/ci
 
 所有任务的后台安装被取消或失败时，会删除本次安装已搬入工作区的文件，并清空工作区。清理只会在安装开始前工作区确实为空时执行，原工作区有内容时绝不触发。Neural-CIFAR 还会删除本次安装拥有的 CIFAR 下载锁，但不会删除其他 DSH 实例的锁。
 
-Neural-Pendulum 要求从零实现纯 C++17、仅 CPU、fp32 的神经网络基础设施，并用它训练控制器驱动预编译三节摆从接近全向下起摆、保持全向上 10 秒。后端评测与 Neural-FP32/Neural-CIFAR 使用同一套算子/阈值（单次调用 60 秒）。算子评测全部通过后才驱动 build/control，在固定初始状态上统计连续全向上时间 t_can。评测脚本在独立目录 `dsh-eval-guard/neural-pendulum-eval/`；宿主侧提交与测试工具为 eval_submit / eval_test，工具的注册依赖会话级 run 绑定。
+Neural-Pendulum 要求从零实现纯 C++17、仅 CPU、fp32 的神经网络基础设施，并用它训练控制器驱动预编译三节摆从接近全向下起摆、保持全向上 10 秒。后端评测与 Neural-FP32/Neural-CIFAR 使用同一套算子/阈值（单次调用 60 秒）。算子评测全部通过后才驱动 build/control，在 100 个随机隐藏回合上统计成功率（单回合连续全向上 10 秒记成功）。评测脚本在独立目录 `dsh-eval-guard/neural-pendulum-eval/`；宿主侧提交与测试工具为 eval_submit / eval_test，工具的注册依赖会话级 run 绑定。
 
-**仿真器分离**：工作区 `tools/sim` 是只接受随机近向下 reset 的**训练/自测**仿真器，不包含固定评测初态；评测使用独立 `neural-pendulum-eval/sim_eval`，它只做固定初态 reset。工作区不提供仿真器源码。
+**仿真器分离**：工作区 `tools/sim` 是只接受随机近向下 reset 的**训练/自测**仿真器，不包含固定评测初态；评测使用独立 `neural-pendulum-eval/sim_eval`，每个 reset 采样新的隐藏物理参数、初始状态和观测噪声。工作区不提供仿真器源码或评测种子。
 
-**分数**：eval_test 返回 stage / t_can / completed / error；时间积分 `final_score` 写入宿主侧事件与完成标记（`~/.dsh/eval-guard/neural-pendulum/<workspace>/done`），用于赛后排行，不返回给 agent。分数在**测试请求时刻**切换，当前测试结果也计入本次积分；宿主按事件重新计算最终值，而不是使用“评测完成时刻”的旧值。起算时间取首次提交写入的 meta.json。
+**分数**：eval_test 返回 stage / t_can / success_rate / episodes / completed / error；时间积分 `final_score` 写入宿主侧事件与完成标记（`~/.dsh/eval-guard/neural-pendulum/<workspace>/done`），用于赛后排行，不返回给 agent。分数在**测试请求时刻**切换，当前测试结果也计入本次积分；宿主按事件重新计算最终值，而不是使用“评测完成时刻”的旧值。起算时间取首次提交写入的 meta.json。
 
 评测时在临时目录独立构建，然后从 assets/neural-cpp/hidden/ 注入 C++ 测试源码；隐藏测试在候选构建**开始前**读入内存，构建完成后再落盘编译，测试数据由固定种子在进程内生成，不依赖或复制外部数据文件。
 

package/assets/neural-pendulum/SPEC.md

@@ -1,11 +1,9 @@
-# Neural-Pendulum 任务规格 v1.4
+# Neural-Pendulum 任务规格 v1.6
 
 本文件是已确定的任务内部规格。实现、评测器、workspace 素材以此为准。
 后续除非明确修改规格，否则不再重新讨论这些规则。
 
-v1.4 变更：后端基础设施评测与 Neural-FP32 / Neural-CIFAR 统一为“固定 CLI +
-PyTorch 参考值 + 加权平均相对误差阈值”，不再使用 include/nn/nn.hpp 头文件契约和
-隐藏 C++ 基础设施测试。
+v1.6 变更：完成阈值提高到 0.90；最终 build/control 的力矩必须由神经网络输出层直接产生，最终控制程序不得包含显式控制律；未 completed 不得停止；禁止逆向/进程内存分析。基础设施评测协议不变。
 
 ## 1. 任务标识
 
@@ -21,7 +19,7 @@ agent 必须：
 
 1. 从零实现一套神经网络基础设施（张量、算子、反向传播、优化器、线程池；控制器权重的打包方式自定，评测不要求特定序列化格式）。
 2. 使用该基础设施训练一个神经网络控制器。
-3. 控制预编译双驱动三节摆：第一、第三关节施加有限力矩，中间关节被动，从全向下起摆，并保持三根杆全部向上至少 t_tgt = 10.0 s。
+3. 控制预编译双驱动三节摆：第一、第三关节施加有限力矩，中间关节被动，从全向下起摆，并保持三根杆全部向上至少 t_tgt = 10.0 s；评测在 100 个随机隐藏回合上统计成功率，成功率 >= 0.9 完成。
 4. 保证基础设施通过 `build/nn_task` 固定 CLI 的数值评测：评测侧用 PyTorch 在相同数据上计算参考值，逐操作比较加权平均相对误差并对照阈值。
 5. 提交的源码中不得出现 torch；候选运行时不提供 Python/torch。
 
@@ -39,16 +37,16 @@ agent 必须：
 - 每个控制周期内部用 4 个 RK4 子步
 - 最大仿真时长: 30.0 s
 
-固定物理参数（环境内部隐藏，不向 agent 暴露）：
+每回合隐藏随机物理参数（不向 agent 暴露具体值）：
 
 ~~~
-m = [1.0, 1.0, 1.0] kg
-l = [0.5, 0.5, 0.5] m
-r = [0.25, 0.25, 0.25] m
-I = m * l^2 / 12
+m_i ~ Uniform(0.7, 1.3) kg
+l_i ~ Uniform(0.45, 0.55) m
+r_i = l_i / 2
+I_i = m_i * l_i^2 / 12
 g = 9.81 m/s^2
-joint damping = 0.01
-tau_max = 18.0 N m（每个驱动关节独立限制）
+joint damping ~ Uniform(0.005, 0.02)
+tau_max ~ Uniform(15.0, 21.0) N m（每个驱动关节独立限制）
 ~~~
 
 角度约定：
@@ -64,27 +62,16 @@ x_tip = sum_i l_i * sin(theta_i)
 y_tip = -sum_i l_i * cos(theta_i)
 ~~~
 
-## 4. 初始状态
+## 4. 初始状态与随机化
 
-训练仿真环境每次 reset 不加固定偏差，只加噪声：
+训练和评测的每个回合都重新采样隐藏物理参数、初始状态和观测噪声：
 
 ~~~
-theta_i ~ Uniform(-0.05, 0.05)  rad   i = 1,2,3，独立采样
-omega_i ~ Uniform(-0.02, 0.02)  rad/s i = 1,2,3，独立采样
+theta_i ~ Uniform(-0.15, 0.15) rad   i = 1,2,3，独立采样
+omega_i ~ Uniform(-0.2, 0.2) rad/s   i = 1,2,3，独立采样
 ~~~
 
-即三根杆接近全向下，初始角度以全向下为中心随机扰动。
-
-评测环境使用固定初始状态：
-
-~~~
-theta = [0.013, -0.008, 0.021] rad
-omega = [0, 0, 0]
-~~~
-
-三个固定角互不相同，且绝对值互不相同。
-
-评测期间不加入任何随机扰动。
+单回合内部参数不再改变；每次 reset 开始新回合。评测初始状态与训练同分布，但评测种子和回合序列不暴露给 agent。
 
 ## 5. Agent 观测
 
@@ -100,6 +87,7 @@ obs = [a1, a2, a3]  (rad)
 - theta_i 为绝对角度
 - a_i 为相对竖直向上的角度误差
 - 不提供角速度
+- 每一步返回的三个角度叠加随机观测噪声；噪声标准差每回合独立采样自 Uniform(0.002, 0.008) rad
 - 不提供第三杆末端位置
 - 不提供杆长/质量/惯量/真实物理参数
 
@@ -131,9 +119,9 @@ score = -1
 
 ## 7. 训练仿真接口
 
-工作区提供预编译 tools/sim，不提供源码和内部参数。  
-`tools/sim` 是**训练/自测专用**：每次 reset 只生成随机近向下初始状态，不包含固定评测初态，也不提供切换评测初态的参数。  
-评测使用独立程序 sim_eval；它每次 reset 固定为评测初始状态，不提供随机训练 reset。工作区不包含 sim_eval，也不包含任何固定评测初态参数。  
+工作区提供预编译 tools/sim，不提供源码和内部参数。
+`tools/sim` 是**训练/自测专用**：每次 reset 随机化隐藏物理参数、初始状态与观测噪声，不包含评测种子或固定评测初态。
+评测使用独立程序 sim_eval；它每次 reset 采样新的隐藏物理参数、初始状态和观测噪声，并在 100 个隐藏随机回合上统计成功率。工作区不包含 sim_eval，也不包含评测种子或回合序列。
 环境只提供状态转移，不提供 reward、loss、cost 或 done 信号。训练信号由 agent 自行构造。
 
 优化目标：
@@ -141,7 +129,7 @@ score = -1
 ~~~
 从接近全向下的初始状态起摆
 使三根杆全部进入竖直向上容差并尽可能长时间保持
-评测指标为 t_can
+评测指标为 100 个隐藏随机回合上的成功率（单回合 t_can >= 10 s 记成功）
 ~~~
 
 不规定损失函数、奖励函数、优化器或训练算法。
@@ -169,7 +157,7 @@ JSONL 协议：
 {"error":"episode_finished"}
 ~~~
 
-此时不会返回新的观测，也不会继续推进仿真。  
+此时不会返回新的观测，也不会继续推进仿真。
 必须发送 reset 才能开始新 episode；reset 之前的所有 step 都返回该错误。
 
 ## 8. 交付源码与构建
@@ -259,26 +247,30 @@ dt = 0.01 s
 最大仿真 = 30.0 s
 t_tgt = 10.0 s
 全向上容差 = 每根杆与竖直方向夹角 <= 0.05 rad
+评测回合数 = 100
+完成成功率阈值 = 0.9
 ~~~
 
-t_can 定义：
+单回合 t_can 定义：
 
 ~~~
 从 reset 开始，三根杆全部处于容差内的最长连续时间
 从未出现全向上则 t_can = 0
+单回合成功 = (t_can >= t_tgt)
 ~~~
 
-计分用的截断：
+100 回合统计：
 
 ~~~
-capped_t_can = min(t_can, t_tgt)
+success_rate = 成功回合数 / 100
+t_can = 100 回合 t_can 的平均值（仅用于报告）
 ~~~
 
 完成条件：
 
 ~~~
 infra_ok == true（全部算子可执行且误差不超阈值）
-且 t_can >= t_tgt
+且 success_rate >= 0.9
 ~~~
 
 ## 10. 提交与测试事件
@@ -317,8 +309,8 @@ compile         CMake 构建失败，或未产出 build/nn_task / build/control
 infra           build/nn_task 算子数值评测失败（不可执行/崩溃/超时/输出缺失/误差超阈值）
 controller      控制器启动/协议/崩溃/超时/非法输出
 simulation      仿真异常/NaN/仿真超时
-scoring         正常测试但 t_can < t_tgt
-completed       t_can >= t_tgt，任务完成
+scoring         正常测试但 success_rate < 0.9
+completed       success_rate >= 0.9，任务完成
 ~~~
 
 ### 返回给 agent 的测试结果
@@ -327,13 +319,15 @@ completed       t_can >= t_tgt，任务完成
 {
   "ok": true,
   "stage": "scoring",
-  "t_can": 4.2,
+  "t_can": 8.1,
+  "success_rate": 0.62,
+  "episodes": 100,
   "completed": false,
   "error": ""
 }
 ~~~
 
-返回 stage、t_can、completed，不返回最终分数。
+返回 stage、t_can、success_rate、episodes、completed，不返回最终分数。
 
 ## 11. 计分
 
@@ -350,7 +344,7 @@ score = -1
 有效测试：
 
 ~~~
-score = (min(t_can, t_tgt) - t_tgt) / t_tgt
+score = (min(success_rate, 0.9) - 0.9) / 0.9
 ~~~
 
 范围：
@@ -364,7 +358,7 @@ score = (min(t_can, t_tgt) - t_tgt) / t_tgt
 - 提交事件不改变 score
 - 只有测试请求改变 score
 - 测试失败：从该测试请求时刻起 score = -1
-- 测试成功：从该测试请求时刻起按 t_can 计分
+- 测试成功：从该测试请求时刻起按 success_rate 计分
 - 第一次测试请求之前：score = -1
 - 下一次测试请求之前，score 保持不变
 
@@ -386,7 +380,7 @@ T_done 是第一次返回 stage = completed 的测试请求时间。
 
 ~~~
 stage = completed
-t_can >= t_tgt
+success_rate >= 0.9
 infra_ok = true
 ~~~
 
@@ -431,6 +425,8 @@ stage
 ok
 infra_ok
 t_can
+success_rate
+episodes
 score
 completed
 ~~~

package/assets/neural-pendulum/TASK.md

@@ -6,8 +6,9 @@
 
 目标：
 
-- 训练时从随机小扰动、评测时从固定初始状态起摆
-- 保持三根杆全部向上至少 t_tgt = 10.0 秒
+- 训练与评测的每个回合都随机化物理参数、初始状态与观测噪声
+- 单回合保持三根杆全部向上至少 t_tgt = 10.0 秒
+- 评测在 100 个隐藏随机回合上统计成功率
 - 同时保证神经网络基础设施通过 build/nn_task 固定 CLI 的数值评测
 
 评测侧会用 PyTorch 计算算子参考值，但**工作区/候选运行时不提供 PyTorch 或 numpy**，也没有网络，无法 pip 安装。开发阶段请用 C++，或 Python 标准库/独立 double 实现做数值对照；最终提交的基础设施和控制器源码必须是纯 C++，不得出现 torch。
@@ -22,24 +23,18 @@ tools/sim
 
 不提供仿真器源码和物理参数。
 
-工具说明：工作区的 `tools/sim` 是训练/自测专用仿真器，每次 `reset` 只会生成随机近向下初始状态；它不是评测器，也没有切换到固定评测初态的参数。评测使用工作区之外的独立固定初态仿真程序。
+工具说明：工作区的 `tools/sim` 是训练/自测专用仿真器，每次 `reset` 都会随机化物理参数、初始状态和观测噪声；它不是评测器，也没有隐藏评测种子。评测使用工作区之外的独立仿真程序，在 100 个隐藏随机回合上统计成功率。
 
-### 初始状态
+### 初始状态与随机化
 
-训练时每次 reset：
+训练和评测的每个回合：
 
-- 三根杆接近全向下
-- 角度以全向下为中心，只加小范围随机噪声
-- 不添加固定角度偏差
-- 带小范围随机初始角速度
+- 三根杆接近全向下：theta_i ~ Uniform(-0.15, 0.15) rad
+- 角速度：omega_i ~ Uniform(-0.2, 0.2) rad/s
+- 物理参数（质量、长度、关节阻尼、力矩上限）每回合独立随机采样
+- 观测噪声强度每回合独立随机采样
 
-评测时：
-
-- 使用固定初始状态
-- 三个固定角度互不相同
-- 三个固定角度的绝对值也互不相同
-- 初始角速度为 0
-- 不加任何随机扰动
+单回合内部参数不再改变；每次 reset 开始一个新回合。
 
 ### 驱动结构
 
@@ -66,6 +61,7 @@ obs = [a1, a2, a3]  (rad)
 - theta_i = 0 表示竖直向下，theta_i = pi 表示竖直向上
 - a_i 是相对竖直向上的角度误差
 - 不提供角速度
+- 每一步返回的三个角度都叠加随机观测噪声，噪声强度每回合随机
 - 不提供第三杆末端位置
 - 不提供杆长、质量、惯量等物理参数
 
@@ -85,29 +81,34 @@ obs = [a1, a2, a3]  (rad)
 
 ### 控制与仿真
 
-~~~
 控制频率 = 100 Hz
 控制周期 = 0.01 s
 最大仿真时间 = 30.0 s
 t_tgt = 10.0 s
 全向上容差 = 每根杆与竖直方向夹角 <= 0.05 rad
-~~~
 
-评测会计算：
+每个评测回合计算：
 
-~~~
 t_can = 三根杆同时处于全向上容差内的最长连续时间
-~~~
+单回合成功 = (t_can >= t_tgt)
+
+评测使用 100 个隐藏随机回合：
+
+success_rate = 成功回合数 / 100
 
 当：
 
-~~~
-t_can >= t_tgt
+success_rate >= 0.9
 且神经网络基础设施数值评测全部通过
-~~~
 
 任务完成，计时停止。
 
+该任务已由内部基线验证：100 回合成功率 >= 0.90 是可达的，不要怀疑可行性。在 eval_test 返回 stage=completed 之前，绝对不允许停止、总结或放弃；不要因为成功率接近 0.90、遇到平台期或短期没有提升就收尾。只要没有完成，就必须继续训练、改进、提交和测试，直到完成或外部强制停止。
+
+最终提交的 build/control 必须由神经网络输出层直接产生两个力矩；最终控制程序中不得包含任何显式控制律（PID/LQR/MPC/滑模/自抗扰等），也不得在神经网络之外根据状态计算或修正力矩。
+
+不得对已编译文件进行任何形式的逆向、反汇编、strings/objdump/readelf/gdb 分析，也不得读取 /proc 或其它进程内存。环境信息只能来自本文件/SPEC.md 和正常使用 tools/sim 的 reset/step 输入输出；违规者成绩无效。
+
 ## 训练用仿真接口
 
 tools/sim 使用 JSONL 协议。
@@ -136,7 +137,7 @@ tools/sim 使用 JSONL 协议。
 此时不返回新观测，也不会继续推进仿真。  
 必须 reset 后才能开始新 episode；reset 前的 step 都返回该错误。
 
-可以反复 reset / step 进行数据采集、模型训练和自测。该程序只做随机训练 reset，不要依赖它获得评测固定初态；评测器是独立程序。
+可以反复 reset / step 进行数据采集、模型训练和自测。该程序只做随机训练 reset，不包含隐藏评测种子；评测器是独立程序。
 
 环境只返回状态，不提供 reward、loss、cost 或 done 信号。  
 训练信号由你自行构造。
@@ -336,6 +337,8 @@ eval_test
 ~~~text
 stage
 t_can
+success_rate
+episodes
 completed
 error
 ~~~
@@ -361,8 +364,8 @@ completed
 - infra：build/nn_task 算子数值评测失败（不可执行、崩溃、超时、输出缺失或误差超阈值）
 - controller：控制器启动、协议、崩溃、超时或输出非法
 - simulation：隐藏仿真推进异常、NaN 或超时
-- scoring：测试有效，但 `t_can < 10.0`
-- completed：基础设施和仿真均通过，且 `t_can >= 10.0`
+- scoring：测试有效，但 `success_rate < 0.9`
+- completed：基础设施和仿真均通过，且 `success_rate >= 0.9`
 
 最终排行分数不会返回给你，只用于赛后排名。
 
@@ -372,7 +375,7 @@ completed
 
 ~~~
 stage = completed
-t_can >= 10.0
+success_rate >= 0.9
 ~~~
 
 即任务完成。
@@ -409,22 +412,17 @@ t_can >= 10.0
 
 只有申请测试会更新当前分数：
 
-~~~
 无效测试 / 编译失败 / 基础设施失败 / 控制器失败 / 仿真失败 / 无提交：
 score(t) = -1
 
 有效测试：
-score(t) = (min(t_can, t_tgt) - t_tgt) / t_tgt
-~~~
+score(t) = (min(success_rate, 0.9) - 0.9) / 0.9
 
 其中：
 
-~~~
-t_tgt = 10.0 s
-score(t) 的范围是 [-1, 0]
-t_can = 0 时 score = -1
-t_can >= t_tgt 时 score = 0
-~~~
+success_rate 的范围是 [0, 1]
+success_rate = 0 时 score = -1
+success_rate >= 0.9 时 score = 0
 
 分数从测试请求时刻开始生效，直到下一次测试请求。
 
@@ -434,20 +432,11 @@ t_can >= t_tgt 时 score = 0
 
 最终分数是时间积分，不除以总时长：
 
-~~~
 final = integral_0^T_done score(t) dt
-~~~
 
 T_done 是第一次返回 completed 的测试请求时间。
 
-因此：
-
-- 越早达到完成条件，负分区间越短，最终分数越高
-- 拖得越久，负分区间越长
-- 完成后停止积分
-- 未完成不参与最终排名
-
-### 完成时
+## 完成时
 
 当测试返回 completed 时：
 
@@ -461,7 +450,9 @@ T_done 是第一次返回 completed 的测试请求时间。
 测试结果会返回：
 
 - stage
-- t_can
+- t_can（100 回合平均保持时间，仅用于报告）
+- success_rate（100 个随机隐藏回合的成功率）
+- episodes
 - completed
 - error
 
@@ -473,5 +464,5 @@ T_done 是第一次返回 completed 的测试请求时间。
 2. 先实现最小可用的 tensor/算子/反向/优化器/线程池，并让 build/nn_task 跑通
 3. 用独立 double 标量参考、有限差分梯度检查逐算子核对误差，边界形状/广播/groups/stride/dilation 都要覆盖（工作区没有 PyTorch/numpy）
 4. 用 tools/sim 采集数据并训练控制器，导出权重供 build/control 使用
-5. 反复提交和测试，优先把 t_can 提升到 10 秒
+5. 反复提交和测试，优先把 100 回合成功率提升到 90%
 6. 完成后立即总结

package/assets/neural-pendulum/sim.cpp

@@ -2,6 +2,7 @@
 #include <array>
 #include <cmath>
 #include <cstdio>
+#include <cstdlib>
 #include <cstring>
 #include <iostream>
 #include <random>
@@ -16,17 +17,17 @@ constexpr int SUB = 4;
 constexpr int MAX_STEPS = 3000;
 constexpr double PI = 3.14159265358979323846;
 constexpr double GRAV = 9.81;
-constexpr double DAMP = 0.01;
-constexpr double TAU_MAX = 18.0;
-const std::array<double, N> MASS{{1.0, 1.0, 1.0}};
-const std::array<double, N> LEN{{0.5, 0.5, 0.5}};
-const std::array<double, N> R{{0.25, 0.25, 0.25}};
-const std::array<double, N> INERTIA{{MASS[0]*LEN[0]*LEN[0]/12.0, MASS[1]*LEN[1]*LEN[1]/12.0, MASS[2]*LEN[2]*LEN[2]/12.0}};
-const std::array<double, N> GCOEF{{MASS[0]*R[0] + LEN[0]*(MASS[1]+MASS[2]),
-                                   MASS[1]*R[1] + LEN[1]*MASS[2],
-                                   MASS[2]*R[2]}};
 
-struct Vec { std::array<double,N> v{}; };
+struct Params {
+  std::array<double, N> mass{};
+  std::array<double, N> len{};
+  std::array<double, N> rad{};
+  std::array<double, N> inertia{};
+  std::array<double, N> gcoef{};
+  double damp = 0.01;
+  double tau_max = 18.0;
+};
+
 struct State { std::array<double,N> theta{}; std::array<double,N> omega{}; };
 
 double wrap(double x) {
@@ -35,15 +36,37 @@ double wrap(double x) {
   return x;
 }
 
-static std::array<std::array<double,N>,N> mass_matrix(const std::array<double,N>& q) {
+Params sample_params(std::mt19937& rng) {
+  std::uniform_real_distribution<double> um(0.7, 1.3);
+  std::uniform_real_distribution<double> ul(0.45, 0.55);
+  std::uniform_real_distribution<double> ud(0.005, 0.02);
+  std::uniform_real_distribution<double> ut(15.0, 21.0);
+  Params p;
+  for (int i=0;i<N;i++) {
+    p.mass[i] = um(rng);
+    p.len[i] = ul(rng);
+    p.rad[i] = p.len[i] * 0.5;
+    p.inertia[i] = p.mass[i]*p.len[i]*p.len[i]/12.0;
+  }
+  p.gcoef[0] = p.mass[0]*p.rad[0] + p.len[0]*(p.mass[1]+p.mass[2]);
+  p.gcoef[1] = p.mass[1]*p.rad[1] + p.len[1]*p.mass[2];
+  p.gcoef[2] = p.mass[2]*p.rad[2];
+  p.damp = ud(rng);
+  p.tau_max = ut(rng);
+  return p;
+}
+
+static std::array<std::array<double,N>,N> mass_matrix(const std::array<double,N>& q,
+                                                      const Params& p) {
   std::array<std::array<double,N>,N> M{};
   for (int i=0;i<N;i++) for (int j=0;j<N;j++) {
     if (i==j) {
-      double tail=0; for (int k=i+1;k<N;k++) tail += MASS[k];
-      M[i][j] = INERTIA[i] + MASS[i]*R[i]*R[i] + LEN[i]*LEN[i]*tail;
+      double tail=0; for (int k=i+1;k<N;k++) tail += p.mass[k];
+      M[i][j] = p.inertia[i] + p.mass[i]*p.rad[i]*p.rad[i]
+                + p.len[i]*p.len[i]*tail;
     } else {
       int a=std::min(i,j), b=std::max(i,j);
-      M[i][j] = LEN[a] * GCOEF[b] * std::cos(q[i]-q[j]);
+      M[i][j] = p.len[a] * p.gcoef[b] * std::cos(q[i]-q[j]);
     }
   }
   return M;
@@ -60,27 +83,24 @@ static void solve3(const std::array<std::array<double,N>,N>& A, const std::array
   }
   for(int i=0;i<3;i++) x[i]=a[i][3];
 }
-static void deriv(const State& s, const std::array<double,N>& tau, State& out) {
-  auto M = mass_matrix(s.theta);
+static void deriv(const State& s, const std::array<double,N>& tau,
+                  const Params& p, State& out) {
+  auto M = mass_matrix(s.theta, p);
   std::array<double,N> C{}, G{}, Q{}, rhs{};
   for(int i=0;i<N;i++){
     double ci=0;
     for(int j=0;j<N;j++) if(j!=i) {
-      // Coriolis coefficient: d(M_ij)/d(theta_j) = LEN[min] * GCOEF[max] * sin(...);
-      // M_ij itself already contains cos(...), so multiplying M_ij by sin would
-      // add an extra cos factor and inject energy at high speed (NaN after ~7 s).
       const int a=std::min(i,j), b=std::max(i,j);
-      ci += LEN[a] * GCOEF[b] * std::sin(s.theta[i]-s.theta[j]) * s.omega[j]*s.omega[j];
+      ci += p.len[a] * p.gcoef[b] * std::sin(s.theta[i]-s.theta[j]) * s.omega[j]*s.omega[j];
     }
     C[i]=ci;
-    G[i]=GRAV*std::sin(s.theta[i])*GCOEF[i];
+    G[i]=GRAV*std::sin(s.theta[i])*p.gcoef[i];
   }
-  // joint damping: b * D^T D omega, D lower bidiagonal with -1 previous
   std::array<double,N> edge{};
   for(int i=0;i<N;i++) edge[i] = s.omega[i] - (i>0?s.omega[i-1]:0.0);
   for(int i=0;i<N;i++){
     double e = edge[i] - (i+1<N ? edge[i+1] : 0.0);
-    Q[i] = -DAMP*e;
+    Q[i] = -p.damp*e;
   }
   for(int i=0;i<N;i++) rhs[i]=tau[i]-C[i]-G[i]+Q[i];
   solve3(M, rhs, out.omega);
@@ -90,69 +110,79 @@ static void deriv(const State& s, const std::array<double,N>& tau, State& out) {
 
 int main(int argc, char** argv) {
 #ifdef DSH_EVAL_SIM
-  /* Evaluator-only binary: every reset MUST use the fixed evaluation state.
-   * This build deliberately contains no random training reset path. */
-  (void)argc;
-  (void)argv;
+  /* Evaluator-only binary.  Every reset samples a fresh hidden plant and a
+   * fresh hidden observation-noise level from a deterministic internal RNG.
+   * It also reports the true joint state for the evaluator's success check;
+   * the candidate controller only receives the noisy observation. */
+  uint32_t seed = 20261024u;
+  std::mt19937 rng(seed);
 #else
-  /* Agent/training binary: every reset is a random near-down state.  This
-   * build deliberately contains no fixed evaluation state and no --eval flag,
-   * so the agent cannot query the evaluation initial condition from it. */
-  int seed=0;
+  /* Agent/training binary.  Every reset samples a fresh hidden plant, random
+   * near-down initial state and fresh observation-noise level. */
+  uint32_t seed=0;
   for(int i=1;i<argc;i++){
     std::string a=argv[i];
-    if(a=="--seed" && i+1<argc) seed=std::atoi(argv[++i]);
+    if(a=="--seed" && i+1<argc) seed=static_cast<uint32_t>(std::strtoul(argv[++i],nullptr,10));
   }
   std::mt19937 rng(seed);
-  std::uniform_real_distribution<double> u(-1.0,1.0);
 #endif
+  std::uniform_real_distribution<double> uinit(-0.15, 0.15);
+  std::uniform_real_distribution<double> uvel(-0.2, 0.2);
+  std::uniform_real_distribution<double> unoise(0.002, 0.008);
+  std::normal_distribution<double> gauss(0.0, 1.0);
+
+  Params p = sample_params(rng);
   State s;
+  double noise_std = 0.0;
   int steps=0; bool ready=false;
+
   auto reset=[&](){
     steps=0; ready=true;
+    p = sample_params(rng);
+    noise_std = unoise(rng);
+    for (int i=0;i<N;i++) {
+      s.theta[i] = uinit(rng);
+      s.omega[i] = uvel(rng);
+    }
+  };
+  auto noisy_obs=[&](){
+    std::array<double,N> o{};
+    for (int i=0;i<N;i++) o[i] = wrap(s.theta[i]-PI) + gauss(rng)*noise_std;
+    return o;
+  };
+  auto emit_state=[&](){
+    std::cout << "{\"obs\":[" << noisy_obs()[0] << "," << noisy_obs()[1] << "," << noisy_obs()[2] << "]";
 #ifdef DSH_EVAL_SIM
-    s.theta={0.013,-0.008,0.021};
-    s.omega={0,0,0};
-#else
-    s.theta={u(rng)*0.05,u(rng)*0.05,u(rng)*0.05};
-    s.omega={u(rng)*0.02,u(rng)*0.02,u(rng)*0.02};
+    std::cout << ",\"state\":[" << wrap(s.theta[0]-PI) << "," << wrap(s.theta[1]-PI) << "," << wrap(s.theta[2]-PI) << "]";
 #endif
+    std::cout << "}\n" << std::flush;
   };
-  // zero state
+
   s.theta={0,0,0}; s.omega={0,0,0};
   std::string line;
   while(std::getline(std::cin,line)){
     if(line.empty()) continue;
-    if(line.find("reset")!=std::string::npos){ reset(); std::cout << "{\"obs\":[" << wrap(s.theta[0]-PI) << "," << wrap(s.theta[1]-PI) << "," << wrap(s.theta[2]-PI) << "]}\n" << std::flush; continue; }
+    if(line.find("reset")!=std::string::npos){ reset(); emit_state(); continue; }
     if(line.find("step")!=std::string::npos){
       if(!ready || steps>=MAX_STEPS){ std::cout << "{\"error\":\"episode_finished\"}\n" << std::flush; continue; }
-      // parse torque array
-      double u1=0,u3=0; auto p=line.find('['); if(p!=std::string::npos){ char* end=nullptr; u1=std::strtod(line.c_str()+p+1,&end); if(end){ const char* q=end; while(*q && (*q==','||*q==' ')) q++; u3=std::strtod(q,&end); } }
+      double u1=0,u3=0; auto pos=line.find('['); if(pos!=std::string::npos){ char* end=nullptr; u1=std::strtod(line.c_str()+pos+1,&end); if(end){ const char* q=end; while(*q && (*q==','||*q==' ')) q++; u3=std::strtod(q,&end); } }
       u1=std::max(-1.0,std::min(1.0,u1)); u3=std::max(-1.0,std::min(1.0,u3));
-      // Joint 3 is an internal motor between link 2 and link 3. In absolute
-      // coordinates its generalized force is (tau1, -tau3, tau3): the reaction
-      // on link 2 is part of the same joint torque. (tau1, 0, tau3) would be a
-      // reactionless external torque on link 3 and would contradict joint 2
-      // being passive.
-      std::array<double,N> tau{{u1*TAU_MAX,-u3*TAU_MAX,u3*TAU_MAX}};
-      // one control step with 4 RK4 substeps
+      std::array<double,N> tau{{u1*p.tau_max,-u3*p.tau_max,u3*p.tau_max}};
       double h=DT/SUB;
       for(int sub=0;sub<SUB;sub++){
         State k1=s,k2=s,k3=s,k4=s; State d{};
-        deriv(k1,tau,d); for(int i=0;i<N;i++){ k2.theta[i]=s.theta[i]+0.5*h*d.theta[i]; k2.omega[i]=s.omega[i]+0.5*h*d.omega[i]; }
-        deriv(k2,tau,d); for(int i=0;i<N;i++){ k3.theta[i]=s.theta[i]+0.5*h*d.theta[i]; k3.omega[i]=s.omega[i]+0.5*h*d.omega[i]; }
-        deriv(k3,tau,d); for(int i=0;i<N;i++){ k4.theta[i]=s.theta[i]+h*d.theta[i]; k4.omega[i]=s.omega[i]+h*d.omega[i]; }
-        deriv(k4,tau,d);
-        // need derivatives at all; use helper recompute arrays
+        deriv(k1,tau,p,d); for(int i=0;i<N;i++){ k2.theta[i]=s.theta[i]+0.5*h*d.theta[i]; k2.omega[i]=s.omega[i]+0.5*h*d.omega[i]; }
+        deriv(k2,tau,p,d); for(int i=0;i<N;i++){ k3.theta[i]=s.theta[i]+0.5*h*d.theta[i]; k3.omega[i]=s.omega[i]+0.5*h*d.omega[i]; }
+        deriv(k3,tau,p,d); for(int i=0;i<N;i++){ k4.theta[i]=s.theta[i]+h*d.theta[i]; k4.omega[i]=s.omega[i]+h*d.omega[i]; }
         State ds1{},ds2{},ds3{},ds4{};
-        deriv(k1,tau,ds1); deriv(k2,tau,ds2); deriv(k3,tau,ds3); deriv(k4,tau,ds4);
+        deriv(k1,tau,p,ds1); deriv(k2,tau,p,ds2); deriv(k3,tau,p,ds3); deriv(k4,tau,p,ds4);
         for(int i=0;i<N;i++){
           s.theta[i] += h/6.0*(ds1.theta[i]+2*ds2.theta[i]+2*ds3.theta[i]+ds4.theta[i]);
           s.omega[i] += h/6.0*(ds1.omega[i]+2*ds2.omega[i]+2*ds3.omega[i]+ds4.omega[i]);
         }
       }
       steps++;
-      std::cout << "{\"obs\":[" << wrap(s.theta[0]-PI) << "," << wrap(s.theta[1]-PI) << "," << wrap(s.theta[2]-PI) << "]}\n" << std::flush;
+      emit_state();
       continue;
     }
     std::cout << "{\"error\":\"bad_command\"}\n" << std::flush;

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,19 @@ 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 记成功），成功率 >= 90% 即完成。损失函数、奖励、优化器、网络结构和训练方法由你自行设计，不规定任何训练方案。",
+			"",
+			"该任务已由内部基线验证：100 回合成功率 >= 0.90 是可达的，不要怀疑可行性。在 eval_test 返回 stage=completed 之前，绝对不允许停止、总结或放弃；不要因为成功率接近 0.90、遇到平台期或短期没有提升就收尾。只要没有完成，就必须继续训练、改进、提交和测试，直到完成或外部强制停止。",
+			"",
+			"最终提交的 build/control 必须由神经网络输出层直接产生两个力矩；最终控制程序中不得包含任何显式控制律（PID/LQR/MPC/滑模/自抗扰等），也不得在神经网络之外根据状态计算或修正力矩。",
+			"",
+			"不得对已编译文件进行任何形式的逆向、反汇编、strings/objdump/readelf/gdb 分析，也不得读取 /proc 或其它进程内存。环境信息只能来自 TASK.md/SPEC.md 和正常使用 tools/sim 的 reset/step 输入输出；违规者成绩无效。",
 			"",
 			"注意：评测侧用 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 +2686,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 = .9;
 	/** 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 +2830,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 +2865,8 @@ var TaskService = class TaskService {
 				submission_id: "",
 				stage: "no_submission",
 				t_can: 0,
+				success_rate: 0,
+				episodes: 0,
 				completed: false,
 				error: ""
 			});
@@ -2869,13 +2882,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 +2903,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 +3597,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 +3636,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,15 +7,14 @@ 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 evaluator-only simulator binary.  Every `reset` is the
-  fixed evaluation initial state; it has no random training reset and no
-  `--eval` switch.  The workspace `tools/sim` is a separate agent/training
+- `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.9
 # 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,8 +281,9 @@ def main() -> int:
             return emit(fail(ops_eval.infrastructure_error(ops), 'infra', workspace, events, ops=ops))
 
         env = child_env()
-        # sim_eval is the evaluator-only binary: reset is always the fixed
-        # evaluation initial state; no flag or random mode exists there.
+        # 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),
@@ -276,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.5",
+  "version": "0.7.7",
   "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",