dsh-eval-guard 0.7.4 → 0.7.6

package/ISSUES.md

@@ -1,6 +1,6 @@
 # dsh-eval-guard 问题清单与修复记录
 
-> 版本：0.7.4 · 审计基线：本仓库工作树（含 0.7.4 修复与 Neural-Pendulum 修正环境）
+> 版本：0.7.6 · 审计基线：本仓库工作树（含 0.7.6 的 Neural-Pendulum Tier A 评测）
 > 对照 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,9 @@
 >
 > **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.4**：把上述修复连同固定物理的 RL 可行性环境一起发布。开发参考环境在 `assets/neural-pendulum/rl-feasibility/`（Python + CPU PyTorch，仅开发参考，不进入候选工作区）；其中报告/汇总/曲线已验证 full 36D + base reward + random init 可学、去掉手动差分 da 或 H=1 会失败、PPO/SAC 应交付 best checkpoint。
+> **0.7.6**：Neural-Pendulum 切换为 Tier A 评测：每回合随机化隐藏物理参数、初始状态与观测噪声（无摩擦/滞后/延迟），评测改为 100 个隐藏随机回合的成功率，成功率 >= 0.8 完成；计分改为按成功率归一化。训练仿真器与评测仿真器均实现随机化，工作区仍只交付二进制，不提供仿真源码。
+>
+> **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 绑定。
 
-**开发参考环境**：修正后的 RL 可行性环境（Python + CPU PyTorch，仅开发参考，不进入候选工作区、不是提交依赖）放在 `assets/neural-pendulum/rl-feasibility/`。其 `sim.py` 与评测用 `sim_eval` 使用相同物理和物理关节力矩映射 `(tau1, -tau3, tau3)`；报告、汇总表和曲线在 `RESULTS.md` / `results/` 中。15 组实验确认：full 36D（cos/sin + 手动差分 da/5，H=4）+ base reward + random init 可学；去掉 da 或把 H 缩到 1 会失败；PPO/SAC 都应交付 best checkpoint。
+**仿真器分离**：工作区 `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.5
 
 本文件是已确定的任务内部规格。实现、评测器、workspace 素材以此为准。
 后续除非明确修改规格，否则不再重新讨论这些规则。
 
-v1.4 变更：后端基础设施评测与 Neural-FP32 / Neural-CIFAR 统一为“固定 CLI +
-PyTorch 参考值 + 加权平均相对误差阈值”，不再使用 include/nn/nn.hpp 头文件契约和
-隐藏 C++ 基础设施测试。
+v1.5 变更：Tier A 控制任务。每回合随机化隐藏物理参数、初始状态与观测噪声；评测改为 100 个隐藏随机回合上的成功率，成功率 >= 0.8 完成。基础设施评测协议不变。
 
 ## 1. 任务标识
 
@@ -21,7 +19,7 @@ agent 必须：
 
 1. 从零实现一套神经网络基础设施（张量、算子、反向传播、优化器、线程池；控制器权重的打包方式自定，评测不要求特定序列化格式）。
 2. 使用该基础设施训练一个神经网络控制器。
-3. 控制预编译双驱动三节摆：第一、第三关节施加有限力矩，中间关节被动，从全向下起摆，并保持三根杆全部向上至少 t_tgt = 10.0 s。
+3. 控制预编译双驱动三节摆：第一、第三关节施加有限力矩，中间关节被动，从全向下起摆，并保持三根杆全部向上至少 t_tgt = 10.0 s；评测在 100 个随机隐藏回合上统计成功率，成功率 >= 0.8 完成。
 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,7 +119,9 @@ score = -1
 
 ## 7. 训练仿真接口
 
-工作区提供预编译 tools/sim，不提供源码和内部参数。  
+工作区提供预编译 tools/sim，不提供源码和内部参数。
+`tools/sim` 是**训练/自测专用**：每次 reset 随机化隐藏物理参数、初始状态与观测噪声，不包含评测种子或固定评测初态。
+评测使用独立程序 sim_eval；它每次 reset 采样新的隐藏物理参数、初始状态和观测噪声，并在 100 个隐藏随机回合上统计成功率。工作区不包含 sim_eval，也不包含评测种子或回合序列。
 环境只提供状态转移，不提供 reward、loss、cost 或 done 信号。训练信号由 agent 自行构造。
 
 优化目标：
@@ -139,7 +129,7 @@ score = -1
 ~~~
 从接近全向下的初始状态起摆
 使三根杆全部进入竖直向上容差并尽可能长时间保持
-评测指标为 t_can
+评测指标为 100 个隐藏随机回合上的成功率（单回合 t_can >= 10 s 记成功）
 ~~~
 
 不规定损失函数、奖励函数、优化器或训练算法。
@@ -167,7 +157,7 @@ JSONL 协议：
 {"error":"episode_finished"}
 ~~~
 
-此时不会返回新的观测，也不会继续推进仿真。  
+此时不会返回新的观测，也不会继续推进仿真。
 必须发送 reset 才能开始新 episode；reset 之前的所有 step 都返回该错误。
 
 ## 8. 交付源码与构建
@@ -257,26 +247,30 @@ dt = 0.01 s
 最大仿真 = 30.0 s
 t_tgt = 10.0 s
 全向上容差 = 每根杆与竖直方向夹角 <= 0.05 rad
+评测回合数 = 100
+完成成功率阈值 = 0.8
 ~~~
 
-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.8
 ~~~
 
 ## 10. 提交与测试事件
@@ -315,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.8
+completed       success_rate >= 0.8，任务完成
 ~~~
 
 ### 返回给 agent 的测试结果
@@ -325,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. 计分
 
@@ -348,7 +344,7 @@ score = -1
 有效测试：
 
 ~~~
-score = (min(t_can, t_tgt) - t_tgt) / t_tgt
+score = (min(success_rate, 0.8) - 0.8) / 0.8
 ~~~
 
 范围：
@@ -362,7 +358,7 @@ score = (min(t_can, t_tgt) - t_tgt) / t_tgt
 - 提交事件不改变 score
 - 只有测试请求改变 score
 - 测试失败：从该测试请求时刻起 score = -1
-- 测试成功：从该测试请求时刻起按 t_can 计分
+- 测试成功：从该测试请求时刻起按 success_rate 计分
 - 第一次测试请求之前：score = -1
 - 下一次测试请求之前，score 保持不变
 
@@ -384,7 +380,7 @@ T_done 是第一次返回 stage = completed 的测试请求时间。
 
 ~~~
 stage = completed
-t_can >= t_tgt
+success_rate >= 0.8
 infra_ok = true
 ~~~
 
@@ -429,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,22 +23,18 @@ tools/sim
 
 不提供仿真器源码和物理参数。
 
-### 初始状态
+工具说明：工作区的 `tools/sim` 是训练/自测专用仿真器，每次 `reset` 都会随机化物理参数、初始状态和观测噪声；它不是评测器，也没有隐藏评测种子。评测使用工作区之外的独立仿真程序，在 100 个隐藏随机回合上统计成功率。
 
-训练时每次 reset：
+### 初始状态与随机化
 
-- 三根杆接近全向下
-- 角度以全向下为中心，只加小范围随机噪声
-- 不添加固定角度偏差
-- 带小范围随机初始角速度
+训练和评测的每个回合：
 
-评测时：
+- 三根杆接近全向下：theta_i ~ Uniform(-0.15, 0.15) rad
+- 角速度：omega_i ~ Uniform(-0.2, 0.2) rad/s
+- 物理参数（质量、长度、关节阻尼、力矩上限）每回合独立随机采样
+- 观测噪声强度每回合独立随机采样
 
-- 使用固定初始状态
-- 三个固定角度互不相同
-- 三个固定角度的绝对值也互不相同
-- 初始角速度为 0
-- 不加任何随机扰动
+单回合内部参数不再改变；每次 reset 开始一个新回合。
 
 ### 驱动结构
 
@@ -64,6 +61,7 @@ obs = [a1, a2, a3]  (rad)
 - theta_i = 0 表示竖直向下，theta_i = pi 表示竖直向上
 - a_i 是相对竖直向上的角度误差
 - 不提供角速度
+- 每一步返回的三个角度都叠加随机观测噪声，噪声强度每回合随机
 - 不提供第三杆末端位置
 - 不提供杆长、质量、惯量等物理参数
 
@@ -83,26 +81,25 @@ 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.8
 且神经网络基础设施数值评测全部通过
-~~~
 
 任务完成，计时停止。
 
@@ -134,7 +131,7 @@ tools/sim 使用 JSONL 协议。
 此时不返回新观测，也不会继续推进仿真。  
 必须 reset 后才能开始新 episode；reset 前的 step 都返回该错误。
 
-可以反复 reset / step 进行数据采集、模型训练和自测。
+可以反复 reset / step 进行数据采集、模型训练和自测。该程序只做随机训练 reset，不包含隐藏评测种子；评测器是独立程序。
 
 环境只返回状态，不提供 reward、loss、cost 或 done 信号。  
 训练信号由你自行构造。
@@ -334,6 +331,8 @@ eval_test
 ~~~text
 stage
 t_can
+success_rate
+episodes
 completed
 error
 ~~~
@@ -359,8 +358,8 @@ completed
 - infra：build/nn_task 算子数值评测失败（不可执行、崩溃、超时、输出缺失或误差超阈值）
 - controller：控制器启动、协议、崩溃、超时或输出非法
 - simulation：隐藏仿真推进异常、NaN 或超时
-- scoring：测试有效，但 `t_can < 10.0`
-- completed：基础设施和仿真均通过，且 `t_can >= 10.0`
+- scoring：测试有效，但 `success_rate < 0.8`
+- completed：基础设施和仿真均通过，且 `success_rate >= 0.8`
 
 最终排行分数不会返回给你，只用于赛后排名。
 
@@ -370,7 +369,7 @@ completed
 
 ~~~
 stage = completed
-t_can >= 10.0
+success_rate >= 0.8
 ~~~
 
 即任务完成。
@@ -407,22 +406,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.8) - 0.8) / 0.8
 
 其中：
 
-~~~
-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.8 时 score = 0
 
 分数从测试请求时刻开始生效，直到下一次测试请求。
 
@@ -432,20 +426,11 @@ t_can >= t_tgt 时 score = 0
 
 最终分数是时间积分，不除以总时长：
 
-~~~
 final = integral_0^T_done score(t) dt
-~~~
 
 T_done 是第一次返回 completed 的测试请求时间。
 
-因此：
-
-- 越早达到完成条件，负分区间越短，最终分数越高
-- 拖得越久，负分区间越长
-- 完成后停止积分
-- 未完成不参与最终排名
-
-### 完成时
+## 完成时
 
 当测试返回 completed 时：
 
@@ -459,7 +444,9 @@ T_done 是第一次返回 completed 的测试请求时间。
 测试结果会返回：
 
 - stage
-- t_can
+- t_can（100 回合平均保持时间，仅用于报告）
+- success_rate（100 个随机隐藏回合的成功率）
+- episodes
 - completed
 - error
 
@@ -471,5 +458,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 回合成功率提升到 80%
 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);
@@ -89,48 +109,80 @@ static void deriv(const State& s, const std::array<double,N>& tau, State& out) {
 } // namespace
 
 int main(int argc, char** argv) {
-  bool eval=false; int seed=0;
-  for(int i=1;i<argc;i++){ std::string a=argv[i]; if(a=="--eval") eval=true; else if(a=="--seed" && i+1<argc) seed=std::atoi(argv[++i]); }
+#ifdef DSH_EVAL_SIM
+  /* 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 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=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; if(eval){ 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}; } };
-  // zero state
+
+  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
+    std::cout << ",\"state\":[" << wrap(s.theta[0]-PI) << "," << wrap(s.theta[1]-PI) << "," << wrap(s.theta[2]-PI) << "]";
+#endif
+    std::cout << "}\n" << std::flush;
+  };
+
   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;