docs(levels): report what round 2 measured, including the number it overturns

The round accidentally ran every level twice, which turned into the most useful
thing it produced: 45 retest pairs on this exact set. 84% of them replayed the
identical action sequence, so the agent is near-deterministic and a second run
of a level buys almost nothing — the mechanical metrics retest at r = 1.00 for
that reason, not because they survived a hard test.

The ratings do not. Difficulty retests at r = 0.55 here, against the 0.93 this
project had on record from a smaller sample, and every pair that disagreed had
played the same trajectory: same moves, same outcome, different number. The
report now prints the reliability it measured rather than quoting the older
figure, and says which one it replaces.

Averaged by band over ~20 runs, though, the ratings finally track the curve —
2.00 / 2.05 / 2.40 with stuck at 1.21 / 1.15 / 1.74, where round 1 was a flat
line. So the rule is not "ratings are useless", it is "ratings are a band
statistic, never a per-level rank", and that is what the rules section says.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

bench/board.json

@@ -1,7 +1,7 @@
 {
  "goal": "调出 50 关难度合适、好玩的关卡，交付人工审核",
  "updated": "09-14 16:45",
- "round": 1,
+ "round": 2,
  "definition": {
   "title": "「难度合适且好玩」的操作定义",
   "why": "旋转是免费的、是这个游戏的特色，玩家应该频繁做——所以不该限制旋转次数。该限制的是每一次旋转值不值：转了有没有棋子出来、能不能看出来该转哪、以及转完之后有没有「原来这么简单」的反差。评分里只有 difficulty（复测 r=0.93）和 stuck（r=0.85）可信，rotation / clarity / fun 是噪声（0.32 / 0.19 / 0.56），所以「好玩」全部换成机械代理。 另外，演出本身就是奖励——棋子沿弯路走出去的那几秒是减压点，所以开局必须有得看，而不是只有两枚贴边棋子和 0.3 秒。",
@@ -124,14 +124,14 @@
     {
      "id": "T1.5",
      "title": "扩产到 ≥120 候选并去重、家族均衡",
-     "status": "doing",
-     "note": "扩产到 400 种子（8 片并行）。目的不是多，是为了付得起两道新闸门的代价：双向死转态 ≤2 只留 16%，在 94 个候选上会只剩 8 关"
+     "status": "done",
+     "note": "扫了 480 + 240 个种子，得 684 个候选；过两道新闸门后 228 关。扩产的目的是付得起闸门的代价，不是数量本身"
     },
     {
      "id": "T1.6",
      "title": "终局三枚互锁（hero+gate+tail）",
      "status": "blocked",
-     "note": "深关卡的主要死因：5 转以上有 60% 死在「终局单出口」。实测终局是锁链自己的三枚棋子在 6 个朝向里堵死 5 个。双向释放约束只覆盖了 hero/tail 两枚，三枚组合覆盖不到——这是可达状态的性质，构造时难保证。当前对策是提高扫描量靠筛选拿到，不是修构造"
+     "note": "仍是深关卡的瓶颈：684 个候选里深度≥4 的只有 67 个，过闸门后剩 16 个——后档只能做到平均 4.1 转，是供给限制不是设计选择"
     },
     {
      "id": "T1.7",
@@ -184,18 +184,20 @@
     {
      "id": "T3.2",
      "title": "按实测曲线调整选关，重选",
-     "status": "doing",
-     "note": "R1 唯一可用的是总体读数「偏易」，不是逐关排名。据此定的 R2 改动只有一条、且是机械可测的：给 doubleDead（左右转都打不开任何棋子的可达卡住态）设闸门——它此前完全没设，当前 50 关中位 4、最高 27。这正是用户说的「无效转动就会很无聊」，也是 agent 后段反复写的「短暂以为转错了方向」"
+     "status": "done",
+     "note": "连续空转设闸门（≤1）+ 难度曲线改为按旋转深度配额。同一规则机器人对照：盲转 0.24→0.12，最长连续盲转 4→1，决策数不变"
     },
     {
      "id": "T3.3",
      "title": "第 2 轮验证",
-     "status": "todo"
+     "status": "done",
+     "note": "R2：99 局覆盖 50 关，全部通关，空点 0。难度按档 2.00 / 2.05 / 2.40，无解感 1.21 / 1.15 / 1.74 —— 评分第一次出现梯度"
     },
     {
      "id": "T3.4",
      "title": "收敛判定（难度曲线单调、stuck 达标）",
-     "status": "todo"
+     "status": "doing",
+     "note": "机械面已收敛：空点 0、不可解态 0、连续空转≤1、终局朝向≥3。难度未达标：后档 2.40 vs 目标 3。瓶颈是深关卡供给（见 T1.6），正在扫第二批种子。注意逐关评分复测 r=0.55 且同轨迹会打出不同分，只有按档≈20 局才可读"
     }
    ]
   },
@@ -206,7 +208,8 @@
     {
      "id": "T4.1",
      "title": "50 关关卡集",
-     "status": "todo"
+     "status": "done",
+     "note": "levels/campaign-50.json + src/levels-c50.js，已注册为可玩版本 c50，198 项测试全绿"
     },
     {
      "id": "T4.2",
@@ -217,7 +220,8 @@
     {
      "id": "T4.3",
      "title": "后续关卡制作流程的优化总结",
-     "status": "todo"
+     "status": "done",
+     "note": "docs/level-process.html：两轮对照、复测可信度表（本批现算）、五条规则各带证据、被否掉的做法清单"
     }
    ]
   }
@@ -251,6 +255,10 @@
   {
    "at": "R2 依据",
    "text": "后段 14 条抱怨里两类：路线太长（感知，已对照 v0.5 基线否掉）与「转了没反应」（机械，可设闸门）。只改后者：endgameMinOpen 2→3、doubleDead 无闸门→≤2。两条合计只留 16% 候选，所以先扩池"
+  },
+  {
+   "at": "R2 结果",
+   "text": "难度评分按档 2.00/2.05/2.40（R1 是三档全平），无解感 1.21/1.15/1.74。意外把每关跑了两次，得到 45 对复测：84% 重放了完全相同的动作序列，机械指标 r=1.00，难度评分 r=0.55——且评分分歧的那几对全是同轨迹。结论：agent 近乎确定性，同一关不必跑两遍"
   }
  ]
 }

docs/level-board.html

@@ -98,10 +98,10 @@ footer{margin-top:56px;padding-top:20px;border-top:1px solid var(--rule);color:v
 <header class="head">
   <div class="eyebrow">HEX TRAILS · 关卡调优</div>
   <h1>调出 50 关难度合适、好玩的关卡，交付人工审核</h1>
-  <p class="meta mono">第 1 轮 · 更新于 09-14 16:45 · 本页每 60 秒自动刷新</p>
+  <p class="meta mono">第 2 轮 · 更新于 09-14 16:45 · 本页每 60 秒自动刷新</p>
   <div class="progress">
-    <div class="bar"><i style="width:62%"></i></div>
-    <div class="lbl"><span>13 / 21 项完成</span><span class="mono">62%</span></div>
+    <div class="bar"><i style="width:86%"></i></div>
+    <div class="lbl"><span>18 / 21 项完成</span><span class="mono">86%</span></div>
   </div>
 </header>
 
@@ -110,20 +110,20 @@ footer{margin-top:56px;padding-top:20px;border-top:1px solid var(--rule);color:v
   <div class="tile ok"><div class="k">候选关卡</div><div class="v">50 <span style="font-size:14px;color:var(--ink3)">/ 50</span></div><div class="n">当前关卡集</div></div>
   <div class="tile ok"><div class="k">盲转 / 关</div><div class="v">0.00</div><div class="n">目标 0</div></div>
   <div class="tile ok"><div class="k">转错方向 / 关</div><div class="v">0.00</div><div class="n">目标 0</div></div>
-  <div class="tile ok"><div class="k">猴子 动作÷棋子</div><div class="v">6.53</div><div class="n">目标 ≥3.0（不无脑）</div></div>
+  <div class="tile ok"><div class="k">猴子 动作÷棋子</div><div class="v">6.43</div><div class="n">目标 ≥3.0（不无脑）</div></div>
 </div>
 
 <div class="scroll"><table>
 <thead><tr><th>最少旋转数</th><th class="n">候选关数</th><th>说明</th></tr></thead>
 <tbody>
-<tr><td>1 转</td><td class="n">3</td><td class="sub">浅</td></tr>
-<tr><td>2 转</td><td class="n">10</td><td class="sub">浅</td></tr>
-<tr><td>3 转</td><td class="n">31</td><td class="sub">浅</td></tr>
-<tr><td>4 转</td><td class="n">3</td><td class="sub">中</td></tr>
-<tr><td>5 转</td><td class="n">3</td><td class="sub">中</td></tr>
+<tr><td>1 转</td><td class="n">5</td><td class="sub">浅</td></tr>
+<tr><td>2 转</td><td class="n">5</td><td class="sub">浅</td></tr>
+<tr><td>3 转</td><td class="n">24</td><td class="sub">浅</td></tr>
+<tr><td>4 转</td><td class="n">12</td><td class="sub">中</td></tr>
+<tr><td>5 转</td><td class="n">4</td><td class="sub">中</td></tr>
 
 </tbody></table></div>
-<p class="sub">路线家族分布：v05 ×13 · switchback ×7 · weave ×18 · orbits ×10 · spiral ×2　终局可走朝向分布：{"1":5,"2":22,"3":21,"4":1,"5":1}</p>
+<p class="sub">路线家族分布：v05 ×10 · spiral ×2 · switchback ×12 · weave ×18 · orbits ×8　终局可走朝向分布：{"3":44,"4":5,"5":1}</p>
 
 <h2><span class="num">B</span>什么叫「难度合适且好玩」</h2>
 <div class="callout"><p class="sub">旋转是免费的、是这个游戏的特色，玩家应该频繁做——所以不该限制旋转次数。该限制的是每一次旋转值不值：转了有没有棋子出来、能不能看出来该转哪、以及转完之后有没有「原来这么简单」的反差。评分里只有 difficulty（复测 r=0.93）和 stuck（r=0.85）可信，rotation / clarity / fun 是噪声（0.32 / 0.19 / 0.56），所以「好玩」全部换成机械代理。 另外，演出本身就是奖励——棋子沿弯路走出去的那几秒是减压点，所以开局必须有得看，而不是只有两枚贴边棋子和 0.3 秒。</p></div>
@@ -162,8 +162,8 @@ footer{margin-top:56px;padding-top:20px;border-top:1px solid var(--rule);color:v
 <li class="done"><div class="t"><span class="tid">T1.2</span><span class="tt">解除 rotations===3 的硬限制，允许 4/5/6+</span><span class="tag good">完成</span></div></li>
 <li class="done"><div class="t"><span class="tid">T1.3</span><span class="tt">反差感指标进 deepLevelStats 并作门槛</span><span class="tag good">完成</span></div><div class="note">contrastStats 已进 deepLevelStats 并作门槛；实测 weave 22–33、switchback 29、spiral 18–24、orbits 12–17，petals 仅 2.0–5.7、crossing 3.8–5.5</div></li>
 <li class="done"><div class="t"><span class="tid">T1.4</span><span class="tt">每转释放 ≥2 枚的门槛</span><span class="tag good">完成</span></div><div class="note">改为按朝向配额插棋（每个朝向 ≥2 枚在等），取代原来的随机比例——随机比例会留下空转的朝向</div></li>
-<li class="doing"><div class="t"><span class="tid">T1.5</span><span class="tt">扩产到 ≥120 候选并去重、家族均衡</span><span class="tag live">进行中</span></div><div class="note">扩产到 400 种子（8 片并行）。目的不是多，是为了付得起两道新闸门的代价：双向死转态 ≤2 只留 16%，在 94 个候选上会只剩 8 关</div></li>
-<li class="blocked"><div class="t"><span class="tid">T1.6</span><span class="tt">终局三枚互锁（hero+gate+tail）</span><span class="tag bad">受阻</span></div><div class="note">深关卡的主要死因：5 转以上有 60% 死在「终局单出口」。实测终局是锁链自己的三枚棋子在 6 个朝向里堵死 5 个。双向释放约束只覆盖了 hero/tail 两枚，三枚组合覆盖不到——这是可达状态的性质，构造时难保证。当前对策是提高扫描量靠筛选拿到，不是修构造</div></li>
+<li class="done"><div class="t"><span class="tid">T1.5</span><span class="tt">扩产到 ≥120 候选并去重、家族均衡</span><span class="tag good">完成</span></div><div class="note">扫了 480 + 240 个种子，得 684 个候选；过两道新闸门后 228 关。扩产的目的是付得起闸门的代价，不是数量本身</div></li>
+<li class="blocked"><div class="t"><span class="tid">T1.6</span><span class="tt">终局三枚互锁（hero+gate+tail）</span><span class="tag bad">受阻</span></div><div class="note">仍是深关卡的瓶颈：684 个候选里深度≥4 的只有 67 个，过闸门后剩 16 个——后档只能做到平均 4.1 转，是供给限制不是设计选择</div></li>
 <li class="done"><div class="t"><span class="tid">T1.7</span><span class="tt">开局展示位（快速爽到）</span><span class="tag good">完成</span></div><div class="note">实测整个构造的开局中位只有 2 枚可点、最佳演出 0.57s——锁链开局全锁死。在构造里预留 2 个开局位（立即可点且路线长到值得看），实测开局可点 2→3 枚、最佳演出 0.72s→1.12s</div></li>
 <li class="done"><div class="t"><span class="tid">T1.8</span><span class="tt">离场演出封顶</span><span class="tag good">完成</span></div><div class="note">计时原本线性无上限，最长一次 17.4s，正式关 18.8% 超过 2s。拐点 2.4s 以下完全不变，以上加速逼近 3.2s 上限。labs/exit-timing 可同步对比</div></li>
   </ul>
@@ -182,18 +182,18 @@ footer{margin-top:56px;padding-top:20px;border-top:1px solid var(--rule);color:v
   <h3><span class="pid">P3</span>迭代：跑几轮把曲线调平</h3>
   <ul class="tasks">
   <li class="done"><div class="t"><span class="tid">T3.1</span><span class="tt">第 1 轮：grok 全量跑 50 关</span><span class="tag good">完成</span></div><div class="note">50 关全部跑完；机械面干净：空点 0、盲转 ~0.3/关、全部通关。总体读数：整批偏易一档（2 分 vs 刚好的 3 分）</div></li>
-<li class="doing"><div class="t"><span class="tid">T3.2</span><span class="tt">按实测曲线调整选关，重选</span><span class="tag live">进行中</span></div><div class="note">R1 唯一可用的是总体读数「偏易」，不是逐关排名。据此定的 R2 改动只有一条、且是机械可测的：给 doubleDead（左右转都打不开任何棋子的可达卡住态）设闸门——它此前完全没设，当前 50 关中位 4、最高 27。这正是用户说的「无效转动就会很无聊」，也是 agent 后段反复写的「短暂以为转错了方向」</div></li>
-<li class="todo"><div class="t"><span class="tid">T3.3</span><span class="tt">第 2 轮验证</span><span class="tag idle">待办</span></div></li>
-<li class="todo"><div class="t"><span class="tid">T3.4</span><span class="tt">收敛判定（难度曲线单调、stuck 达标）</span><span class="tag idle">待办</span></div></li>
+<li class="done"><div class="t"><span class="tid">T3.2</span><span class="tt">按实测曲线调整选关，重选</span><span class="tag good">完成</span></div><div class="note">连续空转设闸门（≤1）+ 难度曲线改为按旋转深度配额。同一规则机器人对照：盲转 0.24→0.12，最长连续盲转 4→1，决策数不变</div></li>
+<li class="done"><div class="t"><span class="tid">T3.3</span><span class="tt">第 2 轮验证</span><span class="tag good">完成</span></div><div class="note">R2：99 局覆盖 50 关，全部通关，空点 0。难度按档 2.00 / 2.05 / 2.40，无解感 1.21 / 1.15 / 1.74 —— 评分第一次出现梯度</div></li>
+<li class="doing"><div class="t"><span class="tid">T3.4</span><span class="tt">收敛判定（难度曲线单调、stuck 达标）</span><span class="tag live">进行中</span></div><div class="note">机械面已收敛：空点 0、不可解态 0、连续空转≤1、终局朝向≥3。难度未达标：后档 2.40 vs 目标 3。瓶颈是深关卡供给（见 T1.6），正在扫第二批种子。注意逐关评分复测 r=0.55 且同轨迹会打出不同分，只有按档≈20 局才可读</div></li>
   </ul>
 </div>
 
 <div class="phase">
   <h3><span class="pid">P4</span>交付</h3>
   <ul class="tasks">
-  <li class="todo"><div class="t"><span class="tid">T4.1</span><span class="tt">50 关关卡集</span><span class="tag idle">待办</span></div></li>
+  <li class="done"><div class="t"><span class="tid">T4.1</span><span class="tt">50 关关卡集</span><span class="tag good">完成</span></div><div class="note">levels/campaign-50.json + src/levels-c50.js，已注册为可玩版本 c50，198 项测试全绿</div></li>
 <li class="done"><div class="t"><span class="tid">T4.2</span><span class="tt">人工审核页（可直接试玩每一关）</span><span class="tag good">完成</span></div><div class="note">docs/review-50.html：50 张开局盘面缩略图 + 机械指标 + agent 实测 + 试玩直达；并标注「哪些数字能信」，把感知类问题（路线长度、紧贴）显式交给人眼</div></li>
-<li class="todo"><div class="t"><span class="tid">T4.3</span><span class="tt">后续关卡制作流程的优化总结</span><span class="tag idle">待办</span></div></li>
+<li class="done"><div class="t"><span class="tid">T4.3</span><span class="tt">后续关卡制作流程的优化总结</span><span class="tag good">完成</span></div><div class="note">docs/level-process.html：两轮对照、复测可信度表（本批现算）、五条规则各带证据、被否掉的做法清单</div></li>
   </ul>
 </div>
 
@@ -204,7 +204,8 @@ footer{margin-top:56px;padding-top:20px;border-top:1px solid var(--rule);color:v
 <div class="scroll"><table>
 <thead><tr><th>批次</th><th class="n">关数</th><th class="n">difficulty</th><th class="n">stuck</th><th class="n">盲转/关</th><th class="n">多转/关</th></tr></thead>
 <tbody>
-<tr><td>R1 · grok xhigh</td><td class="n">49</td><td class="n">2.06</td><td class="n">1.41</td><td class="n">0.16</td><td class="n">0.31</td></tr>
+<tr><td>R2 · grok xhigh</td><td class="n">99</td><td class="n">2.16</td><td class="n">1.37</td><td class="n">0.12</td><td class="n">0.24</td></tr>
+<tr><td>R1 · grok xhigh</td><td class="n">50</td><td class="n">2.10</td><td class="n">1.44</td><td class="n">0.24</td><td class="n">0.38</td></tr>
 <tr><td>Codex CLI · gpt-6-astra low</td><td class="n">18</td><td class="n">2.44</td><td class="n">1.44</td><td class="n">1.17</td><td class="n">1.22</td></tr>
 <tr><td>Codex CLI · spark xhigh</td><td class="n">18</td><td class="n">3.11</td><td class="n">2.28</td><td class="n">1.17</td><td class="n">1.17</td></tr>
 <tr><td>Grok Build CLI · xhigh</td><td class="n">18</td><td class="n">2.39</td><td class="n">1.83</td><td class="n">1.17</td><td class="n">1.22</td></tr>
@@ -219,6 +220,7 @@ footer{margin-top:56px;padding-top:20px;border-top:1px solid var(--rule);color:v
 
 <h2><span class="num">F</span>日志</h2>
 <ul class="log">
+<li><b>R2 结果</b>难度评分按档 2.00/2.05/2.40（R1 是三档全平），无解感 1.21/1.15/1.74。意外把每关跑了两次，得到 45 对复测：84% 重放了完全相同的动作序列，机械指标 r=1.00，难度评分 r=0.55——且评分分歧的那几对全是同轨迹。结论：agent 近乎确定性，同一关不必跑两遍</li>
 <li><b>R2 依据</b>后段 14 条抱怨里两类：路线太长（感知，已对照 v0.5 基线否掉）与「转了没反应」（机械，可设闸门）。只改后者：endgameMinOpen 2→3、doubleDead 无闸门→≤2。两条合计只留 16% 候选，所以先扩池</li>
 <li><b>未擅自改动</b>agent 33 条抱怨里两大主题是路线太长（68 格 27 弯）与紧贴易看漏。但已上线的 v0.5 在这两项上更严重（最长 88 格 vs 84 格），属于游戏本来的性格；且文字盘面会同时夸大和缩小感知问题。因此只在审核页标出，不擅自设闸门</li>
 <li><b>R1 结论</b>难度评分在这批关卡上无区分度（26/27 都是 2 分），原因是文字 bench 把判断白送给了 agent。结论：agent 轮次用于抓缺陷（死局、盲转、空点、演出），难度排序只能靠机械假设 + 人工审核。这条改变了后续流程的设计</li>

docs/level-process.html

@@ -57,33 +57,75 @@ a{color:var(--rail)}
 <div class="wrap">
 <h1>关卡制作流程复盘</h1>
 <p class="lede">这一轮做 50 关的过程里，最有用的结论是一个<b>否定结论</b>：原计划的「agent 打分 → 拟合权重 → 重选关卡」这个闭环<b>合不上</b>，而且不是样本量的问题。下面是它为什么合不上，以及流程该改成什么样。</p>
-<p class="meta">实测批次 R1 · grok-4.6 xhigh · 50 关 · 生成于 2026-09-14 17:06</p>
+<p class="meta">实测批次 R2 · grok-4.6 xhigh · 99 局（50 关，多数跑了两次）· 对照批次 R1 50 局 · 生成于 2026-09-14 17:15</p>
 
-<h2>R1 实测到了什么</h2>
+<h2>第二轮实测到了什么</h2>
 <div class="tiles">
-  <div class="tile ok"><div class="k">通关</div><div class="v">50/50</div><div class="n">无死局</div></div>
+  <div class="tile ok"><div class="k">通关</div><div class="v">99/99</div><div class="n">无死局</div></div>
   <div class="tile ok"><div class="k">空点 / 关</div><div class="v">0.00</div><div class="n">目标 0</div></div>
-  <div class="tile ok"><div class="k">盲转 / 关</div><div class="v">0.24</div><div class="n">目标 0</div></div>
-  <div class="tile ok"><div class="k">转错 / 关</div><div class="v">0.14</div><div class="n">目标 0</div></div>
-  <div class="tile miss"><div class="k">难度评分</div><div class="v">46/50</div><div class="n">都是 2 分 — 不区分</div></div>
+  <div class="tile ok"><div class="k">盲转 / 关</div><div class="v">0.12</div><div class="n">目标 0</div></div>
+  <div class="tile ok"><div class="k">转错 / 关</div><div class="v">0.12</div><div class="n">目标 0</div></div>
+  <div class="tile miss"><div class="k">难度评分</div><div class="v">83/99</div><div class="n">都是 2 分 — 不区分</div></div>
 </div>
-<p>机械面干净，说明生成期的闸门是有效的：「动了很多次没结果」这类结构缺陷已经被挡在关卡集之外。<b>难度评分那一格是这一轮真正的发现</b>——它不是不准（复测 r = 0.93，相当稳），它是<b>不区分</b>：机械上差着三倍的关卡，它一律给 2 分。</p>
+<p>机械面干净，说明生成期的闸门是有效的：「动了很多次没结果」这类结构缺陷已经被挡在关卡集之外。<b>难度评分那一格是这两轮真正的发现</b>：机械上差着三倍的关卡，它一律给 2 分。更早的记录里这项的复测可信度是 0.93，那是个更小的样本——在这一批 49 对复测上实测是 0.55，所以它既不区分、也不像以为的那么稳。</p>
+
+<h2>两轮之间改了什么，效果如何</h2>
+<p>第一轮唯一可用的读数是「整批偏易」，加上抱怨里反复出现的「转了没反应」。据此只改了两件事：给<b>连续空转</b>设闸门（最多一次转动没反应，此前有 11 关能连着两次），以及把难度曲线<b>写成旋转深度的配额</b>而不是指望它从排序里自己长出来。</p>
+<table>
+<thead><tr><th>同一个规则机器人，两套关卡集</th><th class="n">第一版</th><th class="n">第二版</th></tr></thead>
+<tbody>
+
+<tr><td>盲转 / 关</td><td class="n">0.24</td><td class="n yes">0.12</td></tr>
+<tr><td>最长连续盲转</td><td class="n">4</td><td class="n yes">1</td></tr>
+<tr><td>空点 / 关</td><td class="n">0.00</td><td class="n">0.00</td></tr>
+<tr><td>决策 / 关（要做的事）</td><td class="n">10.3</td><td class="n">10.3</td></tr>
+
+</tbody>
+</table>
+<p>要做的事一样多，浪费掉的动作少了一半。这是同一个玩家的对照，所以变的是关卡不是模型的心情。</p>
+<table>
+<thead><tr><th>grok 实测，按档</th><th class="n">难度</th><th class="n">无解感</th><th class="n">盲转/关</th><th class="n">旋转深度</th></tr></thead>
+<tbody>
+<tr><td>前档 L1–L12</td><td class="n">2.00</td><td class="n">1.21</td><td class="n">0.17</td><td class="n">1.8</td></tr>
+<tr><td>中档 L13–L32</td><td class="n">2.05</td><td class="n">1.15</td><td class="n">0.00</td><td class="n">3.0</td></tr>
+<tr><td>后档 L33–L50</td><td class="n">2.40</td><td class="n">1.74</td><td class="n">0.23</td><td class="n">4.1</td></tr>
+</tbody>
+</table>
+<p>第一轮三档的难度评分是一条平线。第二轮后档升到了 2.40，无解感也跟着抬起来——<b>这是评分第一次表现出梯度</b>，但只在按档平均之后。</p>
+
+<h2>哪些信号复测得住</h2>
+<p>下面的 r 是在<b>这一批关卡</b>上现算的：同一个 agent 把每关玩了两次，49 对。不是引用更早、更小的样本。</p>
+<table>
+<thead><tr><th>信号</th><th class="n">复测 r</th><th class="n">n</th><th>怎么用</th></tr></thead>
+<tbody>
+<tr><td>盲转次数</td><td class="n yes">1.00</td><td class="n">49</td><td>可用：驱动了真实修复</td></tr>
+<tr><td>转错方向次数</td><td class="n yes">1.00</td><td class="n">49</td><td>可用</td></tr>
+<tr><td>实际旋转数</td><td class="n yes">1.00</td><td class="n">49</td><td>可用</td></tr>
+<tr><td>步数</td><td class="n yes">1.00</td><td class="n">49</td><td>可用</td></tr>
+<tr><td>决策数</td><td class="n yes">0.90</td><td class="n">49</td><td>可用</td></tr>
+<tr><td>无解感评分</td><td class="n ">0.48</td><td class="n">49</td><td>只按档看</td></tr>
+<tr><td>难度评分</td><td class="n ">0.55</td><td class="n">49</td><td>只按档看，约 20 局起</td></tr>
+<tr><td>好玩评分</td><td class="n no">0.34</td><td class="n">49</td><td>不可用</td></tr>
+<tr><td>清晰度评分</td><td class="n no">0.11</td><td class="n">49</td><td>不可用</td></tr>
+</tbody>
+</table>
+<p>机械指标全部 r ≈ 1.00，但那多半是因为 agent <b>84% 的情况下重放了完全相同的动作序列</b>——这本身才是有用的那条结论：重复跑同一关买不到新信息。评分则相反：同一条轨迹，6 对给出了不同的难度分。</p>
 
 <h2>五条规则，各自的证据</h2>
 <div class="rule">
-  <h3><span class="no">1</span>agent 轮次用来抓缺陷，不用来排难度</h3>
+  <h3><span class="no">1</span>难度评分只能按档看，不能逐关看</h3>
   <dl>
-    <dt>证据</dt><dd class="ev">R1 的 50 关里有 46 关难度评分是 2 分，而这些关卡的决策数从 3 到 15。评分不是不准，是不区分。</dd>
-    <dt>为什么</dt><dd>文字盘面把每颗棋子的路线、挡路者、紧贴者列成清单，agent 不必用眼睛顺线走一遍——而那正是这游戏的难点。agent 自己写过：「挡路名单已经写全，不用顺着格子数」。</dd>
-    <dt>现在怎么做</dt><dd>难度排序改为机械假设（旋转深度、棋子数、互锁），由人工审核裁定；agent 轮次只看死局、盲转、转错、空点、演出。</dd>
+    <dt>证据</dt><dd class="ev">99 局里有 83 局打的是 2 分，而这些关卡的决策数从 3 到 15。逐关复测 r = 0.55，而且 6 对分歧里有 6 对&lt;b&gt;走的是同一条轨迹&lt;/b&gt;——同样的动作、同样的结果，模型给自己打了不同的分。但按档平均约 20 局后，曲线第一次显形了（见上表）。</dd>
+    <dt>为什么</dt><dd>文字盘面把每颗棋子的路线、挡路者、紧贴者列成清单，agent 不必用眼睛顺线走一遍——而那正是这游戏的难点。agent 自己写过：「挡路名单已经写全，不用顺着格子数」。剩下的评分噪声，只有靠聚合才压得下去。</dd>
+    <dt>现在怎么做</dt><dd>逐关排序改为机械假设（旋转深度、棋子数、互锁），由人工审核裁定；评分只用来读整档的高低。</dd>
   </dl>
 </div>
 <div class="rule">
-  <h3><span class="no">2</span>先用规则机器人扫，再花 agent 时间</h3>
+  <h3><span class="no">2</span>先用规则机器人扫，再花 agent 时间；同一关不要跑两遍</h3>
   <dl>
-    <dt>证据</dt><dd class="ev">机械旋转指标已被证明测的是关卡而不是玩家：4 次运行、3 家厂商，18 关里 17 关结论一致。</dd>
-    <dt>为什么</dt><dd>既然同一关在不同模型下得出同样的机械读数，那这个读数不需要模型来产生。</dd>
-    <dt>现在怎么做</dt><dd>12 秒的规则机器人扫描替代一整轮 agent 跑批；agent 只用于抽样确认和读自由文本抱怨。</dd>
+    <dt>证据</dt><dd class="ev">第二轮意外把每关跑了两次，得到 49 对复测：其中 41 对（84%）重放了&lt;b&gt;完全相同&lt;/b&gt;的动作序列，机械指标复测 r = 1.00。规则机器人跑完 50 关只要 1 秒。</dd>
+    <dt>为什么</dt><dd>agent 近乎确定性，重复同一关几乎不产生新信息。为「提高可信度」而重复跑，是把预算花在已经知道的答案上。</dd>
+    <dt>现在怎么做</dt><dd>全量验收交给规则机器人；agent 每关只跑一次，省下的预算用来多覆盖关卡。</dd>
   </dl>
 </div>
 <div class="rule">
@@ -105,7 +147,7 @@ a{color:var(--rail)}
 <div class="rule">
   <h3><span class="no">5</span>抱怨要对照基线，不要直接当缺陷</h3>
   <dl>
-    <dt>证据</dt><dd class="ev">agent 33 条抱怨里最集中的是「路线太长读不完」。但已上线的 v0.5 最长路线 88 格，比这批新关卡的 84 格还长。</dd>
+    <dt>证据</dt><dd class="ev">agent 33 条抱怨里最集中的是「路线太长读不完」。但已上线的 v0.5 最长路线 74 格，比这批新关卡的 74 格还长。</dd>
     <dt>为什么</dt><dd>那是这个游戏本来的性格。把它当缺陷修掉，改的是游戏而不是关卡。</dd>
     <dt>现在怎么做</dt><dd>只在审核页标出，交给人裁定。</dd>
   </dl>
@@ -115,12 +157,12 @@ a{color:var(--rail)}
 <table>
 <thead><tr><th>指标</th><th class="n">可用</th><th>依据</th></tr></thead>
 <tbody>
-<tr><td>盲转 / 多余转 / 转错方向</td><td class="n yes">可用</td><td>复测 r ≈ 0.82–0.92；驱动了真实修复（1.17 / 1.22 / 0.44 → 0）</td></tr>
+<tr><td>盲转 / 多余转 / 转错方向</td><td class="n yes">可用</td><td>本批复测 r = 1.00；驱动了真实修复（盲转 1.17 → 0.12）</td></tr>
 <tr><td>是否通关、空点次数</td><td class="n yes">可用</td><td>直接观察，无主观成分</td></tr>
 <tr><td>自由文本抱怨</td><td class="n yes">可用</td><td>33 条里两个主题高度重复，指标抓不到；但须对照基线（规则 5）</td></tr>
-<tr><td>难度评分</td><td class="n no">只能看总体</td><td>稳定但不区分；单关排序不可用，整批读数（偏易一档）可用</td></tr>
-<tr><td>无解感评分</td><td class="n">谨慎</td><td>复测 r = 0.85，与无效动作相关 0.66，可当挫败感的代理</td></tr>
-<tr><td>好玩 / 清晰度 / 旋转评分</td><td class="n no">不可用</td><td>复测 r ≤ 0.56，是模型噪声</td></tr>
+<tr><td>难度评分</td><td class="n no">只按档看</td><td>逐关复测 r = 0.55，且同一条轨迹会打出不同分；按档平均约 20 局才显出梯度</td></tr>
+<tr><td>无解感评分</td><td class="n">只按档看</td><td>复测 r = 0.48；按档看时与难度同向抬升，可当挫败感的代理</td></tr>
+<tr><td>好玩 / 清晰度评分</td><td class="n no">不可用</td><td>复测 r = 0.34 / 0.11，是模型噪声</td></tr>
 </tbody>
 </table>
 
@@ -138,7 +180,7 @@ a{color:var(--rail)}
 <table>
 <thead><tr><th>试过什么</th><th>结果</th></tr></thead>
 <tbody>
-<tr><td>拟合 difficulty ~ 机械特征，用来重选关卡</td><td>响应几乎无方差（46/50 同分），回归的是常数</td></tr>
+<tr><td>拟合 difficulty ~ 机械特征，用来重选关卡</td><td>响应几乎无方差（83/99 同分），回归的是常数</td></tr>
 <tr><td>legibility（一眼看穿的成本）解释难度评分</td><td>相关 -0.02，无效；降级为纯测量</td></tr>
 <tr><td>路线交叠度当难度轴</td><td>中位已达 89%，没有上升空间</td></tr>
 <tr><td>换开局朝向来提高判断成本</td><td>127 个候选里只有 7 个变好</td></tr>

docs/review-50.html

@@ -62,7 +62,7 @@ footer{margin-top:50px;padding-top:18px;border-top:1px solid var(--rule);color:v
 <div class="wrap">
 <h1>五十关 · 人工审核</h1>
 <p class="lede">缩略图是<b>开局盘面</b>：绿色的棋子开局就能点，灰色的被挡着。点「试玩」用真游戏打开这一关。</p>
-<p class="meta mono">关卡集 levels/campaign-50.json · agent 实测批次 R2 · grok xhigh（50/50 关已评）· 生成于 2026-09-14 17:12</p>
+<p class="meta mono">关卡集 levels/campaign-50.json · agent 实测批次 R2 · grok xhigh（50/50 关已评）· 生成于 2026-09-14 17:14</p>
 
 <h2>难度曲线（agent 实测）</h2>
 <table>
@@ -70,7 +70,7 @@ footer{margin-top:50px;padding-top:18px;border-top:1px solid var(--rule);color:v
 <tbody>
 <tr><td>前档 L1–L12</td><td class="n">12</td><td class="n">2.0</td><td class="n">1.1</td><td class="n">0.2</td><td class="n">0.0</td></tr>
 <tr><td>中档 L13–L32</td><td class="n">20</td><td class="n">2.1</td><td class="n">1.2</td><td class="n">0.0</td><td class="n">0.0</td></tr>
-<tr><td>后档 L33–L50</td><td class="n">18</td><td class="n">2.3</td><td class="n">1.8</td><td class="n">0.2</td><td class="n">0.0</td></tr>
+<tr><td>后档 L33–L50</td><td class="n">18</td><td class="n">2.4</td><td class="n">1.7</td><td class="n">0.2</td><td class="n">0.0</td></tr>
 </tbody>
 </table>
 <p class="meta">难度 3 = 刚刚好；无解感越低越好。这两项是评分里唯二复测可信的（r = 0.93 / 0.85），其余几项是模型噪声，不列。</p>
@@ -78,7 +78,7 @@ footer{margin-top:50px;padding-top:18px;border-top:1px solid var(--rule);color:v
 <h2>这批数字里，哪些能信</h2>
 <div class="note">
 <p><b>机械面是干净的，可以信。</b>agent 跑完 50 关：空点 0.0 次/关、盲转 0.1 次/关、反向转 0.1 次/关，50/50 关通关。「动了半天没结果」这类结构缺陷已经被生成期的闸门挡掉了。</p>
-<p><b>难度评分不能信，它区分不了这批关卡。</b>50 关里有 26 关被打成 2 分，而这些关卡机械上差着三倍（决策数 0–8）。原因不在关卡，在 bench：文字盘面会把每颗棋子的路线、挡路者、紧贴者<b>直接列成清单</b>，agent 从来不需要用眼睛顺着线走一遍——而那正是这个游戏的难点所在。agent 自己在报告里写过这句：「挡路名单已经写全，不用顺着格子数」。</p>
+<p><b>难度评分不能信，它区分不了这批关卡。</b>50 关里有 41 关被打成 2 分，而这些关卡机械上差着三倍（决策数 0–8）。原因不在关卡，在 bench：文字盘面会把每颗棋子的路线、挡路者、紧贴者<b>直接列成清单</b>，agent 从来不需要用眼睛顺着线走一遍——而那正是这个游戏的难点所在。agent 自己在报告里写过这句：「挡路名单已经写全，不用顺着格子数」。</p>
 <p><b>所以难度顺序是机械假设，等你的判定。</b>L1 到 L50 是按旋转深度、棋子数、互锁程度排的，不是按谁测出来更难。评分唯一能用的是它的<b>总体读数</b>：整批偏易一档（2 分 vs 刚刚好的 3 分）。</p>
 <p><b>两件事我没有擅自改，留给你定。</b>agent 的 33 条抱怨里反复出现两个主题：路线太长看不完（「68 格 27 弯」「42 格 42 弯」），以及紧贴容易看漏（「看着能出界却会擦到」）。两项都是感知问题，而<b>已上线的 v0.5 在这两项上更严重</b>（最长路线 88 格 vs 这里 74 格）——它是这个游戏本来的性格，不是这次构造引入的。卡片上「最长路线」超 45 格、「紧贴棋子」超 1 枚会标黄，你试玩时留意。</p>
 </div>
@@ -182,8 +182,8 @@ footer{margin-top:50px;padding-top:18px;border-top:1px solid var(--rule);color:v
     <span>紧贴棋子</span><b class="">0 枚</b>
   </div>
   <div class="verdict">
-    <div class="row"><span>难度 —</span><span>无解感 —</span><span>12 步</span><span>6 决策</span></div>
-    
+    <div class="row"><span>难度 2</span><span>无解感 1</span><span>12 步</span><span>6 决策</span></div>
+    <div class="worst">开局 t0 那条 44 格绕来绕去的路线，摘要能看清挡子，但弯太多跟不上</div>
   </div>
   <a class="play" href="../index.html?campaign=c50&level=6">试玩 →</a>
 </div>
@@ -216,8 +216,8 @@ footer{margin-top:50px;padding-top:18px;border-top:1px solid var(--rule);color:v
     <span>紧贴棋子</span><b class="">0 枚</b>
   </div>
   <div class="verdict">
-    <div class="row"><span>难度 2</span><span>无解感 2</span><span>17 步</span><span>7 决策</span></div>
-    <div class="worst">第14步转到朝向2时t0看似能出界，但紧贴t2会擦到，长路线上不太容易预见到</div>
+    <div class="row"><span>难度 —</span><span>无解感 —</span><span>17 步</span><span>7 决策</span></div>
+    
   </div>
   <a class="play" href="../index.html?campaign=c50&level=8">试玩 →</a>
 </div>
@@ -233,8 +233,8 @@ footer{margin-top:50px;padding-top:18px;border-top:1px solid var(--rule);color:v
     <span>紧贴棋子</span><b class="">1 枚</b>
   </div>
   <div class="verdict">
-    <div class="row"><span>难度 —</span><span>无解感 —</span><span>17 步</span><span>7 决策</span></div>
-    
+    <div class="row"><span>难度 2</span><span>无解感 2</span><span>17 步</span><span>7 决策</span></div>
+    <div class="worst">t1 走后 t0/t2 互挡，右转朝向2时 t0 看似能出却擦到 t2，空转了一步</div>
   </div>
   <a class="play" href="../index.html?campaign=c50&level=9">试玩 →</a>
 </div>
@@ -250,8 +250,8 @@ footer{margin-top:50px;padding-top:18px;border-top:1px solid var(--rule);color:v
     <span>紧贴棋子</span><b class="">1 枚</b>
   </div>
   <div class="verdict">
-    <div class="row"><span>难度 —</span><span>无解感 —</span><span>16 步</span><span>6 决策</span></div>
-    
+    <div class="row"><span>难度 2</span><span>无解感 1</span><span>16 步</span><span>6 决策</span></div>
+    <div class="worst">第12步右转后t0和t2仍互相挡，还得再转一次才拆开；开局长路线（31–49格）也只能靠挡子摘要读</div>
   </div>
   <a class="play" href="../index.html?campaign=c50&level=10">试玩 →</a>
 </div>
@@ -267,8 +267,8 @@ footer{margin-top:50px;padding-top:18px;border-top:1px solid var(--rule);color:v
     <span>紧贴棋子</span><b class="">1 枚</b>
   </div>
   <div class="verdict">
-    <div class="row"><span>难度 —</span><span>无解感 —</span><span>15 步</span><span>8 决策</span></div>
-    
+    <div class="row"><span>难度 2</span><span>无解感 1</span><span>15 步</span><span>8 决策</span></div>
+    <div class="worst">朝向1剩四枚时 t2 擦到 t0、t0 路上又有 t2，看起来互相卡死，只能再转</div>
   </div>
   <a class="play" href="../index.html?campaign=c50&level=11">试玩 →</a>
 </div>
@@ -284,8 +284,8 @@ footer{margin-top:50px;padding-top:18px;border-top:1px solid var(--rule);color:v
     <span>紧贴棋子</span><b class="">1 枚</b>
   </div>
   <div class="verdict">
-    <div class="row"><span>难度 —</span><span>无解感 —</span><span>15 步</span><span>8 决策</span></div>
-    
+    <div class="row"><span>难度 2</span><span>无解感 1</span><span>15 步</span><span>8 决策</span></div>
+    <div class="worst">开局 t0 那条 53 格 16 弯的超长路线把盘面读得很晕，真正能点的其实只有边上的 t8/t9/t11</div>
   </div>
   <a class="play" href="../index.html?campaign=c50&level=12">试玩 →</a>
 </div>
@@ -301,8 +301,8 @@ footer{margin-top:50px;padding-top:18px;border-top:1px solid var(--rule);color:v
     <span>紧贴棋子</span><b class="">1 枚</b>
   </div>
   <div class="verdict">
-    <div class="row"><span>难度 2</span><span>无解感 1</span><span>15 步</span><span>8 决策</span></div>
-    <div class="worst">开局 t0/t2 路线 25–28 格还缠着四五枚棋子，只能靠摘要判断挡谁，盘面本身看不清</div>
+    <div class="row"><span>难度 2</span><span>无解感 2</span><span>15 步</span><span>7 决策</span></div>
+    <div class="worst">朝向1清完t1/t6/t7后，t0↔t2互压、t4↔t5互擦两对死锁叠在一起，不确定再转一次能不能解开</div>
   </div>
   <a class="play" href="../index.html?campaign=c50&level=13">试玩 →</a>
 </div>
@@ -318,8 +318,8 @@ footer{margin-top:50px;padding-top:18px;border-top:1px solid var(--rule);color:v
     <span>紧贴棋子</span><b class="">1 枚</b>
   </div>
   <div class="verdict">
-    <div class="row"><span>难度 —</span><span>无解感 —</span><span>14 步</span><span>7 决策</span></div>
-    
+    <div class="row"><span>难度 2</span><span>无解感 1</span><span>14 步</span><span>7 决策</span></div>
+    <div class="worst">开局 t3 那条 62 格 26 弯的超长轨道几乎读不完，只能靠摘要看挡子</div>
   </div>
   <a class="play" href="../index.html?campaign=c50&level=14">试玩 →</a>
 </div>
@@ -335,8 +335,8 @@ footer{margin-top:50px;padding-top:18px;border-top:1px solid var(--rule);color:v
     <span>紧贴棋子</span><b class="">1 枚</b>
   </div>
   <div class="verdict">
-    <div class="row"><span>难度 2</span><span>无解感 1</span><span>15 步</span><span>11 决策</span></div>
-    <div class="worst">开局 t0 那条 42 格弯路太长，挡谁只能靠摘要判断</div>
+    <div class="row"><span>难度 2</span><span>无解感 1</span><span>15 步</span><span>7 决策</span></div>
+    <div class="worst">开局 t0 那条 42 格长路列了九个挡子，其实先清边上的 t8/t9/t11 就行，长路干扰判断</div>
   </div>
   <a class="play" href="../index.html?campaign=c50&level=15">试玩 →</a>
 </div>
@@ -352,8 +352,8 @@ footer{margin-top:50px;padding-top:18px;border-top:1px solid var(--rule);color:v
     <span>紧贴棋子</span><b class="hot">2 枚</b>
   </div>
   <div class="verdict">
-    <div class="row"><span>难度 2</span><span>无解感 1</span><span>15 步</span><span>8 决策</span></div>
-    <div class="worst">开局 t0/t1/t3 路线 50 多格，只能靠末尾挡子列表判断，中间弯折几乎读不动</div>
+    <div class="row"><span>难度 2</span><span>无解感 1</span><span>15 步</span><span>7 决策</span></div>
+    <div class="worst">开局 t0/t1/t3 路线长达五十多格十六个弯，只能靠路上棋子摘要点，几乎没法在脑子里画出轨道</div>
   </div>
   <a class="play" href="../index.html?campaign=c50&level=16">试玩 →</a>
 </div>
@@ -369,8 +369,8 @@ footer{margin-top:50px;padding-top:18px;border-top:1px solid var(--rule);color:v
     <span>紧贴棋子</span><b class="">0 枚</b>
   </div>
   <div class="verdict">
-    <div class="row"><span>难度 3</span><span>无解感 1</span><span>15 步</span><span>7 决策</span></div>
-    <div class="worst">第二次旋转前剩 5 枚全靠擦碰互卡，一时不确定是漏点了谁还是该转</div>
+    <div class="row"><span>难度 2</span><span>无解感 2</span><span>15 步</span><span>10 决策</span></div>
+    <div class="worst">朝向1清完t1后，t2路上压着t3、t3又紧贴t2，两枚互相卡死，只能转盘</div>
   </div>
   <a class="play" href="../index.html?campaign=c50&level=17">试玩 →</a>
 </div>
@@ -386,8 +386,8 @@ footer{margin-top:50px;padding-top:18px;border-top:1px solid var(--rule);color:v
     <span>紧贴棋子</span><b class="">0 枚</b>
   </div>
   <div class="verdict">
-    <div class="row"><span>难度 —</span><span>无解感 —</span><span>15 步</span><span>7 决策</span></div>
-    
+    <div class="row"><span>难度 2</span><span>无解感 1</span><span>15 步</span><span>7 决策</span></div>
+    <div class="worst">开局 t0/t1 路线 50 多格、挡子名单很长，只能先点边上三枚再转</div>
   </div>
   <a class="play" href="../index.html?campaign=c50&level=18">试玩 →</a>
 </div>
@@ -403,8 +403,8 @@ footer{margin-top:50px;padding-top:18px;border-top:1px solid var(--rule);color:v
     <span>紧贴棋子</span><b class="hot">3 枚</b>
   </div>
   <div class="verdict">
-    <div class="row"><span>难度 —</span><span>无解感 —</span><span>15 步</span><span>10 决策</span></div>
-    
+    <div class="row"><span>难度 2</span><span>无解感 1</span><span>15 步</span><span>10 决策</span></div>
+    <div class="worst">t0/t3 绕几十格的轨道只能靠摘要，空间上绕到哪、会擦谁完全脑补不出来</div>
   </div>
   <a class="play" href="../index.html?campaign=c50&level=19">试玩 →</a>
 </div>
@@ -421,7 +421,7 @@ footer{margin-top:50px;padding-top:18px;border-top:1px solid var(--rule);color:v
   </div>
   <div class="verdict">
     <div class="row"><span>难度 2</span><span>无解感 1</span><span>17 步</span><span>7 决策</span></div>
-    <div class="worst">开局 t0 那条 55 格 16 弯太长，脑子对不上盘面；朝向 0 时 t2/t4 互堵，转一次没拆开还要再转</div>
+    <div class="worst">开局 t0 那条 55 格 16 弯完全读不过来，只能靠「路上有谁」的摘要；t2/t4 对卡看起来像死结，其实该转</div>
   </div>
   <a class="play" href="../index.html?campaign=c50&level=20">试玩 →</a>
 </div>
@@ -438,7 +438,7 @@ footer{margin-top:50px;padding-top:18px;border-top:1px solid var(--rule);color:v
   </div>
   <div class="verdict">
     <div class="row"><span>难度 2</span><span>无解感 1</span><span>15 步</span><span>7 决策</span></div>
-    <div class="worst">开局 t0/t1 那两条 50 多格的超长路线把盘面挤得很满，真正能走的短路径要翻下去找</div>
+    <div class="worst">开局 t0/t1 各绕 50 多格互相穿过，只能靠「路上有」摘要判断，路线本身几乎扫不动</div>
   </div>
   <a class="play" href="../index.html?campaign=c50&level=21">试玩 →</a>
 </div>
@@ -454,8 +454,8 @@ footer{margin-top:50px;padding-top:18px;border-top:1px solid var(--rule);color:v
     <span>紧贴棋子</span><b class="hot">2 枚</b>
   </div>
   <div class="verdict">
-    <div class="row"><span>难度 —</span><span>无解感 —</span><span>17 步</span><span>10 决策</span></div>
-    
+    <div class="row"><span>难度 2</span><span>无解感 1</span><span>17 步</span><span>10 决策</span></div>
+    <div class="worst">开局 t0/t9 路线 50 多格，只能靠摘要判断谁挡谁，格子序列本身看不过来</div>
   </div>
   <a class="play" href="../index.html?campaign=c50&level=22">试玩 →</a>
 </div>
@@ -471,8 +471,8 @@ footer{margin-top:50px;padding-top:18px;border-top:1px solid var(--rule);color:v
     <span>紧贴棋子</span><b class="hot">3 枚</b>
   </div>
   <div class="verdict">
-    <div class="row"><span>难度 —</span><span>无解感 —</span><span>15 步</span><span>7 决策</span></div>
-    
+    <div class="row"><span>难度 2</span><span>无解感 1</span><span>15 步</span><span>7 决策</span></div>
+    <div class="worst">开局 t0/t3/t5 路线 50+ 格叠在一起，虽然能走的棋子标得很清楚，但中间层谁挡谁很难建立直觉</div>
   </div>
   <a class="play" href="../index.html?campaign=c50&level=23">试玩 →</a>
 </div>
@@ -488,8 +488,8 @@ footer{margin-top:50px;padding-top:18px;border-top:1px solid var(--rule);color:v
     <span>紧贴棋子</span><b class="">1 枚</b>
   </div>
   <div class="verdict">
-    <div class="row"><span>难度 —</span><span>无解感 —</span><span>15 步</span><span>10 决策</span></div>
-    
+    <div class="row"><span>难度 2</span><span>无解感 1</span><span>15 步</span><span>10 决策</span></div>
+    <div class="worst">开局 t0/t1 路线 50 多格 16 弯，空间感几乎没有，只能靠路上有谁来点</div>
   </div>
   <a class="play" href="../index.html?campaign=c50&level=24">试玩 →</a>
 </div>
@@ -505,8 +505,8 @@ footer{margin-top:50px;padding-top:18px;border-top:1px solid var(--rule);color:v
     <span>紧贴棋子</span><b class="">1 枚</b>
   </div>
   <div class="verdict">
-    <div class="row"><span>难度 2</span><span>无解感 2</span><span>15 步</span><span>8 决策</span></div>
-    <div class="worst">朝向1清完后剩5枚互相卡住，t4看着能走却擦到t0，一时不知道该转还是继续点</div>
+    <div class="row"><span>难度 3</span><span>无解感 1</span><span>15 步</span><span>7 决策</span></div>
+    <div class="worst">朝向1清完t1/t7/t6后t4只擦t0、t0又被t4压着，像死锁，其实再右转就开了</div>
   </div>
   <a class="play" href="../index.html?campaign=c50&level=25">试玩 →</a>
 </div>
@@ -523,7 +523,7 @@ footer{margin-top:50px;padding-top:18px;border-top:1px solid var(--rule);color:v
   </div>
   <div class="verdict">
     <div class="row"><span>难度 2</span><span>无解感 1</span><span>15 步</span><span>7 决策</span></div>
-    <div class="worst">朝向2时 t2 只差1格出界却擦到 t1，t1 路上又压着 t2，互锁要转才看出来</div>
+    <div class="worst">朝向1清完t7/t6后6枚仍互卡，一时分不清是漏看了能走的还是必须再转</div>
   </div>
   <a class="play" href="../index.html?campaign=c50&level=26">试玩 →</a>
 </div>
@@ -539,8 +539,8 @@ footer{margin-top:50px;padding-top:18px;border-top:1px solid var(--rule);color:v
     <span>紧贴棋子</span><b class="">1 枚</b>
   </div>
   <div class="verdict">
-    <div class="row"><span>难度 —</span><span>无解感 —</span><span>15 步</span><span>7 决策</span></div>
-    
+    <div class="row"><span>难度 2</span><span>无解感 1</span><span>15 步</span><span>7 决策</span></div>
+    <div class="worst">开局 t0 那条 54 格路线列了十来个挡子，眼花，好在先点边上没人的就对了</div>
   </div>
   <a class="play" href="../index.html?campaign=c50&level=27">试玩 →</a>
 </div>
@@ -556,8 +556,8 @@ footer{margin-top:50px;padding-top:18px;border-top:1px solid var(--rule);color:v
     <span>紧贴棋子</span><b class="hot">2 枚</b>
   </div>
   <div class="verdict">
-    <div class="row"><span>难度 —</span><span>无解感 —</span><span>15 步</span><span>7 决策</span></div>
-    
+    <div class="row"><span>难度 2</span><span>无解感 1</span><span>15 步</span><span>7 决策</span></div>
+    <div class="worst">开局 t6 那条 68 格 28 弯的轨道太长，盘面一眼读不清，只能靠挡子列表剥层</div>
   </div>
   <a class="play" href="../index.html?campaign=c50&level=28">试玩 →</a>
 </div>
@@ -573,8 +573,8 @@ footer{margin-top:50px;padding-top:18px;border-top:1px solid var(--rule);color:v
     <span>紧贴棋子</span><b class="">0 枚</b>
   </div>
   <div class="verdict">
-    <div class="row"><span>难度 —</span><span>无解感 —</span><span>16 步</span><span>7 决策</span></div>
-    
+    <div class="row"><span>难度 2</span><span>无解感 2</span><span>16 步</span><span>7 决策</span></div>
+    <div class="worst">朝向0清完边上3枚后，t1/t2对堵还擦t8、t7/t8也对堵，长轨道看不出该先解哪对，只能转</div>
   </div>
   <a class="play" href="../index.html?campaign=c50&level=29">试玩 →</a>
 </div>
@@ -591,7 +591,7 @@ footer{margin-top:50px;padding-top:18px;border-top:1px solid var(--rule);color:v
   </div>
   <div class="verdict">
     <div class="row"><span>难度 2</span><span>无解感 1</span><span>19 步</span><span>10 决策</span></div>
-    <div class="worst">开局 t0/t4 那两条 50 多格路线把几乎所有棋子都列进去，一时不知道从哪下手</div>
+    <div class="worst">开局 t0 一条 54 格长路几乎压着全盘，短出口要在一堆长路线里翻；后面几次卡住都是右转就开了，没真正选过方向</div>
   </div>
   <a class="play" href="../index.html?campaign=c50&level=30">试玩 →</a>
 </div>
@@ -607,8 +607,8 @@ footer{margin-top:50px;padding-top:18px;border-top:1px solid var(--rule);color:v
     <span>紧贴棋子</span><b class="">1 枚</b>
   </div>
   <div class="verdict">
-    <div class="row"><span>难度 2</span><span>无解感 2</span><span>15 步</span><span>8 决策</span></div>
-    <div class="worst">朝向1时 t4 和 t5 路线都出界却互相擦着，谁也走不了，得再转一次才解开</div>
+    <div class="row"><span>难度 2</span><span>无解感 1</span><span>15 步</span><span>7 决策</span></div>
+    <div class="worst">开局 t4 那条 63 格螺旋把盘面读得很乱，其实只要先清边上能出的再转就行</div>
   </div>
   <a class="play" href="../index.html?campaign=c50&level=31">试玩 →</a>
 </div>
@@ -624,8 +624,8 @@ footer{margin-top:50px;padding-top:18px;border-top:1px solid var(--rule);color:v
     <span>紧贴棋子</span><b class="">0 枚</b>
   </div>
   <div class="verdict">
-    <div class="row"><span>难度 —</span><span>无解感 —</span><span>17 步</span><span>8 决策</span></div>
-    
+    <div class="row"><span>难度 2</span><span>无解感 1</span><span>17 步</span><span>8 决策</span></div>
+    <div class="worst">朝向1时 t1 和 t7 都写路上没棋子，其实互相擦着谁也走不了，得再转才开</div>
   </div>
   <a class="play" href="../index.html?campaign=c50&level=32">试玩 →</a>
 </div>
@@ -658,8 +658,8 @@ footer{margin-top:50px;padding-top:18px;border-top:1px solid var(--rule);color:v
     <span>紧贴棋子</span><b class="hot">2 枚</b>
   </div>
   <div class="verdict">
-    <div class="row"><span>难度 —</span><span>无解感 —</span><span>17 步</span><span>7 决策</span></div>
-    
+    <div class="row"><span>难度 2</span><span>无解感 1</span><span>17 步</span><span>7 决策</span></div>
+    <div class="worst">朝向1时t5路上没人却紧贴t4和t6，长直道擦碰差点误点</div>
   </div>
   <a class="play" href="../index.html?campaign=c50&level=34">试玩 →</a>
 </div>
@@ -675,8 +675,8 @@ footer{margin-top:50px;padding-top:18px;border-top:1px solid var(--rule);color:v
     <span>紧贴棋子</span><b class="">1 枚</b>
   </div>
   <div class="verdict">
-    <div class="row"><span>难度 2</span><span>无解感 2</span><span>17 步</span><span>11 决策</span></div>
-    <div class="worst">第14步转到朝向4没有出口，t1仍擦到t2，短暂犹豫还要不要继续转</div>
+    <div class="row"><span>难度 3</span><span>无解感 2</span><span>17 步</span><span>10 决策</span></div>
+    <div class="worst">只剩 t1 t2 互相卡住，转到朝向 4 仍擦碰没出口，一时以为还要绕回去</div>
   </div>
   <a class="play" href="../index.html?campaign=c50&level=35">试玩 →</a>
 </div>
@@ -692,8 +692,8 @@ footer{margin-top:50px;padding-top:18px;border-top:1px solid var(--rule);color:v
     <span>紧贴棋子</span><b class="">1 枚</b>
   </div>
   <div class="verdict">
-    <div class="row"><span>难度 3</span><span>无解感 2</span><span>19 步</span><span>9 决策</span></div>
-    <div class="worst">清完朝向3的五枚后，t5 路上看似没人却擦到 t2，剩下三枚互卡只能再转</div>
+    <div class="row"><span>难度 2</span><span>无解感 2</span><span>19 步</span><span>9 决策</span></div>
+    <div class="worst">朝向2时剩8枚互相挡成环，扫了一圈才确定一枚都点不了</div>
   </div>
   <a class="play" href="../index.html?campaign=c50&level=36">试玩 →</a>
 </div>
@@ -709,8 +709,8 @@ footer{margin-top:50px;padding-top:18px;border-top:1px solid var(--rule);color:v
     <span>紧贴棋子</span><b class="">0 枚</b>
   </div>
   <div class="verdict">
-    <div class="row"><span>难度 2</span><span>无解感 1</span><span>18 步</span><span>9 决策</span></div>
-    <div class="worst">开局 t3、t6 路线 35–36 格织在一起，只能靠路上有/紧贴摘要点，盘面本身几乎读不出</div>
+    <div class="row"><span>难度 2</span><span>无解感 2</span><span>18 步</span><span>9 决策</span></div>
+    <div class="worst">朝向2剩5枚时 t2擦t5、t5擦t0、t0和t3互压，一时看不出该转还是还能点</div>
   </div>
   <a class="play" href="../index.html?campaign=c50&level=37">试玩 →</a>
 </div>
@@ -726,8 +726,8 @@ footer{margin-top:50px;padding-top:18px;border-top:1px solid var(--rule);color:v
     <span>紧贴棋子</span><b class="hot">2 枚</b>
   </div>
   <div class="verdict">
-    <div class="row"><span>难度 —</span><span>无解感 —</span><span>18 步</span><span>11 决策</span></div>
-    
+    <div class="row"><span>难度 3</span><span>无解感 2</span><span>18 步</span><span>11 决策</span></div>
+    <div class="worst">朝向4只剩t2和t3互相堵、提示没有新出口，以为要转回去，其实再转一格就开了</div>
   </div>
   <a class="play" href="../index.html?campaign=c50&level=38">试玩 →</a>
 </div>
@@ -743,8 +743,8 @@ footer{margin-top:50px;padding-top:18px;border-top:1px solid var(--rule);color:v
     <span>紧贴棋子</span><b class="hot">2 枚</b>
   </div>
   <div class="verdict">
-    <div class="row"><span>难度 2</span><span>无解感 2</span><span>20 步</span><span>11 决策</span></div>
-    <div class="worst">朝向3清掉t6/t7/t0后剩5枚两两对卡，一时看不出还要再转两次才解开</div>
+    <div class="row"><span>难度 3</span><span>无解感 2</span><span>20 步</span><span>11 决策</span></div>
+    <div class="worst">朝向3清完t0后剩下t1↔t3、t2↔t5两对互锁，一时看不出再转一次能否拆开</div>
   </div>
   <a class="play" href="../index.html?campaign=c50&level=39">试玩 →</a>
 </div>
@@ -760,8 +760,8 @@ footer{margin-top:50px;padding-top:18px;border-top:1px solid var(--rule);color:v
     <span>紧贴棋子</span><b class="">0 枚</b>
   </div>
   <div class="verdict">
-    <div class="row"><span>难度 3</span><span>无解感 2</span><span>19 步</span><span>10 决策</span></div>
-    <div class="worst">清完 t8/t9 后 t2 与 t6、t0 与 t3 两对互卡，只能再转一次碰朝向</div>
+    <div class="row"><span>难度 2</span><span>无解感 1</span><span>19 步</span><span>9 决策</span></div>
+    <div class="worst">开局t3/t7路线三十多格，只能靠摘要看挡子，具体绕法扫不过来</div>
   </div>
   <a class="play" href="../index.html?campaign=c50&level=40">试玩 →</a>
 </div>
@@ -778,7 +778,7 @@ footer{margin-top:50px;padding-top:18px;border-top:1px solid var(--rule);color:v
   </div>
   <div class="verdict">
     <div class="row"><span>难度 2</span><span>无解感 2</span><span>20 步</span><span>9 决策</span></div>
-    <div class="worst">开局 t0 那条 39 格、11 个挡子的长路线读不清，只能靠摘要先清边上的自由子</div>
+    <div class="worst">朝向2剩7枚时t0和t3互压、t5擦t7，短暂犹豫是再转还是还有能点的</div>
   </div>
   <a class="play" href="../index.html?campaign=c50&level=41">试玩 →</a>
 </div>
@@ -794,8 +794,8 @@ footer{margin-top:50px;padding-top:18px;border-top:1px solid var(--rule);color:v
     <span>紧贴棋子</span><b class="">0 枚</b>
   </div>
   <div class="verdict">
-    <div class="row"><span>难度 2</span><span>无解感 1</span><span>19 步</span><span>9 决策</span></div>
-    <div class="worst">开局 t3/t9 路线三十多格互相编织，挡子名单太长，只能先清边上能走的再转</div>
+    <div class="row"><span>难度 2</span><span>无解感 2</span><span>19 步</span><span>9 决策</span></div>
+    <div class="worst">朝向3清完t3/t6/t7后，剩下t0/t2/t4互相压着擦着，看不出谁能先走，只能再转</div>
   </div>
   <a class="play" href="../index.html?campaign=c50&level=42">试玩 →</a>
 </div>
@@ -812,7 +812,7 @@ footer{margin-top:50px;padding-top:18px;border-top:1px solid var(--rule);color:v
   </div>
   <div class="verdict">
     <div class="row"><span>难度 3</span><span>无解感 2</span><span>20 步</span><span>9 决策</span></div>
-    <div class="worst">开局清完外围后 t2/t10、t9/t11 两对对压，t1 那条 43 格长线看得晕，一时不确定是该硬拆顺序还是该转</div>
+    <div class="worst">朝向2时 t0 和 t3 对堵、旁边 t7 还擦着 t3，看起来像死结，只能再转一次才开</div>
   </div>
   <a class="play" href="../index.html?campaign=c50&level=43">试玩 →</a>
 </div>
@@ -828,8 +828,8 @@ footer{margin-top:50px;padding-top:18px;border-top:1px solid var(--rule);color:v
     <span>紧贴棋子</span><b class="">0 枚</b>
   </div>
   <div class="verdict">
-    <div class="row"><span>难度 —</span><span>无解感 —</span><span>19 步</span><span>9 决策</span></div>
-    
+    <div class="row"><span>难度 3</span><span>无解感 2</span><span>19 步</span><span>9 决策</span></div>
+    <div class="worst">朝向2清完t8/t9后t0和t3对堵、t5还擦着t4，一时拿不准是继续右转还是该回转</div>
   </div>
   <a class="play" href="../index.html?campaign=c50&level=44">试玩 →</a>
 </div>
@@ -846,7 +846,7 @@ footer{margin-top:50px;padding-top:18px;border-top:1px solid var(--rule);color:v
   </div>
   <div class="verdict">
     <div class="row"><span>难度 2</span><span>无解感 1</span><span>20 步</span><span>10 决策</span></div>
-    <div class="worst">开局 t3 那条 40 格 38 弯的路线太长，扫一眼抓不住谁挡谁</div>
+    <div class="worst">朝向0清完外围后 t0 和 t1 对堵，超长路线缠在一起，看不出该往哪转，只能盲转右边</div>
   </div>
   <a class="play" href="../index.html?campaign=c50&level=45">试玩 →</a>
 </div>
@@ -862,8 +862,8 @@ footer{margin-top:50px;padding-top:18px;border-top:1px solid var(--rule);color:v
     <span>紧贴棋子</span><b class="">1 枚</b>
   </div>
   <div class="verdict">
-    <div class="row"><span>难度 2</span><span>无解感 2</span><span>19 步</span><span>9 决策</span></div>
-    <div class="worst">朝向2时 t0 和 t3 对堵、其余全擦挡，一时以为还要来回试朝向</div>
+    <div class="row"><span>难度 2</span><span>无解感 1</span><span>19 步</span><span>9 决策</span></div>
+    <div class="worst">开局 15 枚路线动辄三十多格互相织着，只能先清边上三枚再盲转；之后一直右转就能开，没真正选过方向</div>
   </div>
   <a class="play" href="../index.html?campaign=c50&level=46">试玩 →</a>
 </div>
@@ -879,8 +879,8 @@ footer{margin-top:50px;padding-top:18px;border-top:1px solid var(--rule);color:v
     <span>紧贴棋子</span><b class="hot">3 枚</b>
   </div>
   <div class="verdict">
-    <div class="row"><span>难度 3</span><span>无解感 2</span><span>23 步</span><span>15 决策</span></div>
-    <div class="worst">最后两枚转回朝向0仍对压，要再转到朝向1才双双出界，中间空转了一圈</div>
+    <div class="row"><span>难度 3</span><span>无解感 2</span><span>23 步</span><span>14 决策</span></div>
+    <div class="worst">最后只剩 t0 和 t3 时朝向 5、0 都互相卡住，要再转到朝向 1 才同时能出</div>
   </div>
   <a class="play" href="../index.html?campaign=c50&level=47">试玩 →</a>
 </div>
@@ -896,8 +896,8 @@ footer{margin-top:50px;padding-top:18px;border-top:1px solid var(--rule);color:v
     <span>紧贴棋子</span><b class="">0 枚</b>
   </div>
   <div class="verdict">
-    <div class="row"><span>难度 2</span><span>无解感 2</span><span>22 步</span><span>11 决策</span></div>
-    <div class="worst">朝向4剩 t0/t4/t5 互相卡住，t5 被 t0 挡、t0 又被 t5 挡，一度怀疑转错了方向</div>
+    <div class="row"><span>难度 2</span><span>无解感 1</span><span>22 步</span><span>11 决策</span></div>
+    <div class="worst">朝向2时盘面只剩互相缠着的超长路线，t5路上没人却擦到t1/t7，一时不确定是漏看了能走的还是该转</div>
   </div>
   <a class="play" href="../index.html?campaign=c50&level=48">试玩 →</a>
 </div>
@@ -913,8 +913,8 @@ footer{margin-top:50px;padding-top:18px;border-top:1px solid var(--rule);color:v
     <span>紧贴棋子</span><b class="">1 枚</b>
   </div>
   <div class="verdict">
-    <div class="row"><span>难度 2</span><span>无解感 2</span><span>23 步</span><span>15 决策</span></div>
-    <div class="worst">最后 t0/t3 互挡，转回朝向 0 提示没有新出口，以为转错了</div>
+    <div class="row"><span>难度 2</span><span>无解感 2</span><span>23 步</span><span>14 决策</span></div>
+    <div class="worst">第20步转回朝向0后t0和t3仍对压，短暂以为要回头改出子顺序</div>
   </div>
   <a class="play" href="../index.html?campaign=c50&level=49">试玩 →</a>
 </div>
@@ -931,7 +931,7 @@ footer{margin-top:50px;padding-top:18px;border-top:1px solid var(--rule);color:v
   </div>
   <div class="verdict">
     <div class="row"><span>难度 3</span><span>无解感 2</span><span>24 步</span><span>15 决策</span></div>
-    <div class="worst">开局长路线动辄三十多格三十多个弯，只能靠「路上有谁」摘要，跟不出实际形状</div>
+    <div class="worst">开局长路线三十多格第一眼理不清；后段只剩 t0/t1/t3 互锁时犹豫要不要再转一整圈</div>
   </div>
   <a class="play" href="../index.html?campaign=c50&level=50">试玩 →</a>
 </div>

scripts/build-process-report.mjs

@@ -7,7 +7,7 @@ import { existsSync, readFileSync, readdirSync, writeFileSync } from 'node:fs';
 import { resolve } from 'node:path';
 import { trace } from '../src/core.js';
 import { metrics } from '../src/bench.js';
-import { legibility } from '../src/deep-lock.js';
+import { deepLevelKey, legibility } from '../src/deep-lock.js';
 
 const esc = s => String(s ?? '').replace(/[&<>"]/g, c => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;' }[c]));
 const mean = a => a.length ? a.reduce((x, y) => x + y, 0) / a.length : null;
@@ -29,11 +29,38 @@ for (const f of existsSync(resolve('bench/runs')) ? readdirSync(resolve('bench/r
     runs.push({ raw: d, m: metrics(d) });
   } catch { /* torn read */ }
 }
-const r1 = runs.filter(r => r.raw.agent === 'R1 · grok xhigh' && byId.has(r.raw.level?.id));
-const rated = r1.filter(r => r.m.rating && Number.isFinite(Number(r.m.rating.difficulty)));
+// Rounds are matched to their own level set by board, not by id: the reselect
+// between them reissued ids from the ordinal.
+const inSet = new Set(levels.map(deepLevelKey));
+const oldLevels = (() => { try { return JSON.parse(readFileSync(resolve('levels/campaign-50-r1.json'), 'utf8')).levels; } catch { return []; } })();
+const inOld = new Set(oldLevels.map(deepLevelKey));
+const round = (agent, set) => runs.filter(r => r.raw.agent === agent && r.raw.level?.tiles && set.has(deepLevelKey(r.raw.level)));
+const r1 = round('R1 · grok xhigh', inOld);
+const r2 = round('R2 · grok xhigh', inSet);
+const rated = r2.filter(r => r.m.rating && Number.isFinite(Number(r.m.rating.difficulty)));
 const byDiff = rated.reduce((m, r) => (m[r.m.rating.difficulty] = (m[r.m.rating.difficulty] || 0) + 1, m), {});
 const topDiff = Object.entries(byDiff).sort((a, b) => b[1] - a[1])[0] ?? ['—', 0];
 
+// Retest: the same agent played each level twice, so reliability is measurable
+// on this very set instead of quoted from an older, smaller one.
+const pairsBy = new Map();
+for (const r of r2) { const k = deepLevelKey(r.raw.level); if (!pairsBy.has(k)) pairsBy.set(k, []); pairsBy.get(k).push(r); }
+const pairs = [...pairsBy.values()].filter(v => v.length >= 2).map(v => [v[0], v[1]]);
+const sd = a => { const m = mean(a); return Math.sqrt(mean(a.map(v => (v - m) ** 2))); };
+const pearson = (A, B) => { const sa = sd(A), sb = sd(B); if (!sa || !sb) return null; const ma = mean(A), mb = mean(B); return mean(A.map((v, i) => (v - ma) * (B[i] - mb))) / (sa * sb); };
+const retest = get => {
+  const ok = pairs.filter(p => Number.isFinite(get(p[0])) && Number.isFinite(get(p[1])));
+  if (ok.length < 8) return { r: null, n: ok.length };
+  return { r: pearson(ok.map(p => get(p[0])), ok.map(p => get(p[1]))), n: ok.length };
+};
+const sig = r => (r.raw.steps ?? []).map(s => `${s.action?.type}:${s.action?.id ?? s.action?.direction ?? ''}`).join('|');
+const identical = pairs.filter(([a, b]) => sig(a) === sig(b)).length;
+const ratingDisagreed = pairs.filter(([a, b]) => a.m.rating?.difficulty != null && b.m.rating?.difficulty != null && a.m.rating.difficulty !== b.m.rating.difficulty);
+const disagreedOnSamePlay = ratingDisagreed.filter(([a, b]) => sig(a) === sig(b)).length;
+
+const bandOf = (rows, a, b) => rows.filter(r => { const i = levels.findIndex(l => deepLevelKey(l) === deepLevelKey(r.raw.level)); return i >= a && i < b; });
+const BANDS = [['前档 L1–L12', 0, 12], ['中档 L13–L32', 12, 32], ['后档 L33–L50', 32, 50]];
+
 const longest = l => Math.max(...l.tiles.map(t => trace(l, t, [], true).steps.length));
 const c50Longest = Math.max(...levels.map(longest));
 const loadPool = p => { try { const r = JSON.parse(readFileSync(resolve(p), 'utf8')); return Array.isArray(r) ? r : r.levels; } catch { return []; } };
@@ -43,25 +70,35 @@ const traps = levels.map(l => legibility(l).grazeTraps);
 
 const decisions = rated.map(r => r.m.decisions ?? 0);
 const R1 = {
-  n: r1.length, rated: rated.length,
-  cleared: r1.filter(r => r.m.cleared).length,
-  dead: mean(r1.map(r => r.m.deadTaps ?? 0)),
-  blind: mean(r1.map(r => r.m.blindRotations ?? 0)),
-  wrong: mean(r1.map(r => r.m.wrongWayRotations ?? 0)),
+  n: r2.length, rated: rated.length,
+  cleared: r2.filter(r => r.m.cleared).length,
+  dead: mean(r2.map(r => r.m.deadTaps ?? 0)),
+  blind: mean(r2.map(r => r.m.blindRotations ?? 0)),
+  wrong: mean(r2.map(r => r.m.wrongWayRotations ?? 0)),
   flat: topDiff, decMin: Math.min(...decisions), decMax: Math.max(...decisions),
+  r1n: r1.length, r1blind: mean(r1.map(r => r.m.blindRotations ?? 0)),
+  r1diff: mean(r1.map(r => Number(r.m.rating?.difficulty)).filter(Number.isFinite)),
 };
+// The rule bot over both sets: one player, two level sets, so the change is the
+// levels and not the mood of a model.
+const bot = tag => runs.filter(r => String(r.raw.run ?? '').startsWith(tag));
+const BOT = tag => { const v = bot(tag); return v.length ? {
+  n: v.length, blind: mean(v.map(r => r.m.blindRotations ?? 0)), dead: mean(v.map(r => r.m.deadTaps ?? 0)),
+  streak: Math.max(...v.map(r => r.m.longestBlindStreak ?? 0)), dec: mean(v.map(r => r.m.decisions ?? 0)),
+} : null; };
+const botOld = BOT('r1bot-'), botNew = BOT('r2bot-');
 
 // The rules, each with the observation that forced it. A rule without one is a
 // preference, and preferences do not belong in a process document.
 const RULES = [
-  { n: 1, rule: 'agent 轮次用来抓缺陷，不用来排难度',
-    ev: `R1 的 ${R1.rated} 关里有 ${R1.flat[1]} 关难度评分是 ${R1.flat[0]} 分，而这些关卡的决策数从 ${R1.decMin} 到 ${R1.decMax}。评分不是不准，是不区分。`,
-    why: '文字盘面把每颗棋子的路线、挡路者、紧贴者列成清单，agent 不必用眼睛顺线走一遍——而那正是这游戏的难点。agent 自己写过：「挡路名单已经写全，不用顺着格子数」。',
-    now: '难度排序改为机械假设（旋转深度、棋子数、互锁），由人工审核裁定；agent 轮次只看死局、盲转、转错、空点、演出。' },
-  { n: 2, rule: '先用规则机器人扫，再花 agent 时间',
-    ev: '机械旋转指标已被证明测的是关卡而不是玩家：4 次运行、3 家厂商，18 关里 17 关结论一致。',
-    why: '既然同一关在不同模型下得出同样的机械读数，那这个读数不需要模型来产生。',
-    now: '12 秒的规则机器人扫描替代一整轮 agent 跑批；agent 只用于抽样确认和读自由文本抱怨。' },
+  { n: 1, rule: '难度评分只能按档看，不能逐关看',
+    ev: `${R1.rated} 局里有 ${R1.flat[1]} 局打的是 ${R1.flat[0]} 分，而这些关卡的决策数从 ${R1.decMin} 到 ${R1.decMax}。逐关复测 r = ${f2(retest(r => Number(r.m.rating?.difficulty)).r)}，而且 ${ratingDisagreed.length} 对分歧里有 ${disagreedOnSamePlay} 对<b>走的是同一条轨迹</b>——同样的动作、同样的结果，模型给自己打了不同的分。但按档平均约 20 局后，曲线第一次显形了（见上表）。`,
+    why: '文字盘面把每颗棋子的路线、挡路者、紧贴者列成清单，agent 不必用眼睛顺线走一遍——而那正是这游戏的难点。agent 自己写过：「挡路名单已经写全，不用顺着格子数」。剩下的评分噪声，只有靠聚合才压得下去。',
+    now: '逐关排序改为机械假设（旋转深度、棋子数、互锁），由人工审核裁定；评分只用来读整档的高低。' },
+  { n: 2, rule: '先用规则机器人扫，再花 agent 时间；同一关不要跑两遍',
+    ev: `第二轮意外把每关跑了两次，得到 ${pairs.length} 对复测：其中 ${identical} 对（${pct(identical, pairs.length)}）重放了<b>完全相同</b>的动作序列，机械指标复测 r = 1.00。规则机器人跑完 50 关只要 1 秒。`,
+    why: 'agent 近乎确定性，重复同一关几乎不产生新信息。为「提高可信度」而重复跑，是把预算花在已经知道的答案上。',
+    now: '全量验收交给规则机器人；agent 每关只跑一次，省下的预算用来多覆盖关卡。' },
   { n: 3, rule: '门槛写在生成期，不写在筛选期',
     ev: '把开局门槛提到「可点≥3 枚、演出≥0.8s」后筛选写出了 0 关——池子的中位数是 2 枚 / 0.57s。',
     why: '筛选只能从池子里挑，挑不出池子里没有的东西。分布不对时，要改的是构造。',
@@ -135,9 +172,9 @@ a{color:var(--rail)}
 <div class="wrap">
 <h1>关卡制作流程复盘</h1>
 <p class="lede">这一轮做 50 关的过程里，最有用的结论是一个<b>否定结论</b>：原计划的「agent 打分 → 拟合权重 → 重选关卡」这个闭环<b>合不上</b>，而且不是样本量的问题。下面是它为什么合不上，以及流程该改成什么样。</p>
-<p class="meta">实测批次 R1 · grok-4.6 xhigh · ${R1.n} 关 · 生成于 ${new Date().toLocaleString('sv-SE').slice(0, 16)}</p>
+<p class="meta">实测批次 R2 · grok-4.6 xhigh · ${R1.n} 局（50 关，多数跑了两次）· 对照批次 R1 ${R1.r1n} 局 · 生成于 ${new Date().toLocaleString('sv-SE').slice(0, 16)}</p>
 
-<h2>R1 实测到了什么</h2>
+<h2>第二轮实测到了什么</h2>
 <div class="tiles">
   <div class="tile ${R1.cleared === R1.n ? 'ok' : 'miss'}"><div class="k">通关</div><div class="v">${R1.cleared}/${R1.n}</div><div class="n">无死局</div></div>
   <div class="tile ${R1.dead === 0 ? 'ok' : 'miss'}"><div class="k">空点 / 关</div><div class="v">${f2(R1.dead)}</div><div class="n">目标 0</div></div>
@@ -145,7 +182,56 @@ a{color:var(--rail)}
   <div class="tile ${R1.wrong < .5 ? 'ok' : 'miss'}"><div class="k">转错 / 关</div><div class="v">${f2(R1.wrong)}</div><div class="n">目标 0</div></div>
   <div class="tile miss"><div class="k">难度评分</div><div class="v">${R1.flat[1]}/${R1.rated}</div><div class="n">都是 ${R1.flat[0]} 分 — 不区分</div></div>
 </div>
-<p>机械面干净，说明生成期的闸门是有效的：「动了很多次没结果」这类结构缺陷已经被挡在关卡集之外。<b>难度评分那一格是这一轮真正的发现</b>——它不是不准（复测 r = 0.93，相当稳），它是<b>不区分</b>：机械上差着三倍的关卡，它一律给 ${R1.flat[0]} 分。</p>
+<p>机械面干净，说明生成期的闸门是有效的：「动了很多次没结果」这类结构缺陷已经被挡在关卡集之外。<b>难度评分那一格是这两轮真正的发现</b>：机械上差着三倍的关卡，它一律给 ${R1.flat[0]} 分。更早的记录里这项的复测可信度是 0.93，那是个更小的样本——在这一批 ${pairs.length} 对复测上实测是 ${f2(retest(r => Number(r.m.rating?.difficulty)).r)}，所以它既不区分、也不像以为的那么稳。</p>
+
+<h2>两轮之间改了什么，效果如何</h2>
+<p>第一轮唯一可用的读数是「整批偏易」，加上抱怨里反复出现的「转了没反应」。据此只改了两件事：给<b>连续空转</b>设闸门（最多一次转动没反应，此前有 11 关能连着两次），以及把难度曲线<b>写成旋转深度的配额</b>而不是指望它从排序里自己长出来。</p>
+<table>
+<thead><tr><th>同一个规则机器人，两套关卡集</th><th class="n">第一版</th><th class="n">第二版</th></tr></thead>
+<tbody>
+${botOld && botNew ? `
+<tr><td>盲转 / 关</td><td class="n">${f2(botOld.blind)}</td><td class="n yes">${f2(botNew.blind)}</td></tr>
+<tr><td>最长连续盲转</td><td class="n">${botOld.streak}</td><td class="n yes">${botNew.streak}</td></tr>
+<tr><td>空点 / 关</td><td class="n">${f2(botOld.dead)}</td><td class="n">${f2(botNew.dead)}</td></tr>
+<tr><td>决策 / 关（要做的事）</td><td class="n">${f1(botOld.dec)}</td><td class="n">${f1(botNew.dec)}</td></tr>
+` : '<tr><td colspan="3">规则机器人数据缺失</td></tr>'}
+</tbody>
+</table>
+<p>要做的事一样多，浪费掉的动作少了一半。这是同一个玩家的对照，所以变的是关卡不是模型的心情。</p>
+<table>
+<thead><tr><th>grok 实测，按档</th><th class="n">难度</th><th class="n">无解感</th><th class="n">盲转/关</th><th class="n">旋转深度</th></tr></thead>
+<tbody>
+${BANDS.map(([label, a, b]) => {
+  const rows = bandOf(r2, a, b);
+  const g = k => mean(rows.map(r => Number(r.m.rating?.[k])).filter(Number.isFinite));
+  const rot = mean(levels.slice(a, b).map(l => l.campaign?.rotations ?? 0));
+  return `<tr><td>${label}</td><td class="n">${f2(g('difficulty'))}</td><td class="n">${f2(g('stuck'))}</td><td class="n">${f2(mean(rows.map(r => r.m.blindRotations ?? 0)))}</td><td class="n">${f1(rot)}</td></tr>`;
+}).join('\n')}
+</tbody>
+</table>
+<p>第一轮三档的难度评分是一条平线。第二轮后档升到了 ${f2(mean(bandOf(r2, 32, 50).map(r => Number(r.m.rating?.difficulty)).filter(Number.isFinite)))}，无解感也跟着抬起来——<b>这是评分第一次表现出梯度</b>，但只在按档平均之后。</p>
+
+<h2>哪些信号复测得住</h2>
+<p>下面的 r 是在<b>这一批关卡</b>上现算的：同一个 agent 把每关玩了两次，${pairs.length} 对。不是引用更早、更小的样本。</p>
+<table>
+<thead><tr><th>信号</th><th class="n">复测 r</th><th class="n">n</th><th>怎么用</th></tr></thead>
+<tbody>
+${[['盲转次数', r => r.m.blindRotations, '可用：驱动了真实修复'],
+   ['转错方向次数', r => r.m.wrongWayRotations, '可用'],
+   ['实际旋转数', r => r.m.rotations, '可用'],
+   ['步数', r => r.m.steps, '可用'],
+   ['决策数', r => r.m.decisions, '可用'],
+   ['无解感评分', r => Number(r.m.rating?.stuck), '只按档看'],
+   ['难度评分', r => Number(r.m.rating?.difficulty), '只按档看，约 20 局起'],
+   ['好玩评分', r => Number(r.m.rating?.fun), '不可用'],
+   ['清晰度评分', r => Number(r.m.rating?.clarity), '不可用']].map(([name, get, use]) => {
+  const t = retest(get);
+  const cls = t.r == null ? '' : t.r >= 0.9 ? 'yes' : t.r >= 0.45 ? '' : 'no';
+  return `<tr><td>${name}</td><td class="n ${cls}">${t.r == null ? '—' : f2(t.r)}</td><td class="n">${t.n}</td><td>${use}</td></tr>`;
+}).join('\n')}
+</tbody>
+</table>
+<p>机械指标全部 r ≈ 1.00，但那多半是因为 agent <b>${pct(identical, pairs.length)} 的情况下重放了完全相同的动作序列</b>——这本身才是有用的那条结论：重复跑同一关买不到新信息。评分则相反：同一条轨迹，${disagreedOnSamePlay} 对给出了不同的难度分。</p>
 
 <h2>五条规则，各自的证据</h2>
 ${RULES.map(r => `<div class="rule">
@@ -161,12 +247,12 @@ ${RULES.map(r => `<div class="rule">
 <table>
 <thead><tr><th>指标</th><th class="n">可用</th><th>依据</th></tr></thead>
 <tbody>
-<tr><td>盲转 / 多余转 / 转错方向</td><td class="n yes">可用</td><td>复测 r ≈ 0.82–0.92；驱动了真实修复（1.17 / 1.22 / 0.44 → 0）</td></tr>
+<tr><td>盲转 / 多余转 / 转错方向</td><td class="n yes">可用</td><td>本批复测 r = ${f2(retest(r => r.m.blindRotations).r)}；驱动了真实修复（盲转 1.17 → ${f2(R1.blind)}）</td></tr>
 <tr><td>是否通关、空点次数</td><td class="n yes">可用</td><td>直接观察，无主观成分</td></tr>
 <tr><td>自由文本抱怨</td><td class="n yes">可用</td><td>33 条里两个主题高度重复，指标抓不到；但须对照基线（规则 5）</td></tr>
-<tr><td>难度评分</td><td class="n no">只能看总体</td><td>稳定但不区分；单关排序不可用，整批读数（偏易一档）可用</td></tr>
-<tr><td>无解感评分</td><td class="n">谨慎</td><td>复测 r = 0.85，与无效动作相关 0.66，可当挫败感的代理</td></tr>
-<tr><td>好玩 / 清晰度 / 旋转评分</td><td class="n no">不可用</td><td>复测 r ≤ 0.56，是模型噪声</td></tr>
+<tr><td>难度评分</td><td class="n no">只按档看</td><td>逐关复测 r = ${f2(retest(r => Number(r.m.rating?.difficulty)).r)}，且同一条轨迹会打出不同分；按档平均约 20 局才显出梯度</td></tr>
+<tr><td>无解感评分</td><td class="n">只按档看</td><td>复测 r = ${f2(retest(r => Number(r.m.rating?.stuck)).r)}；按档看时与难度同向抬升，可当挫败感的代理</td></tr>
+<tr><td>好玩 / 清晰度评分</td><td class="n no">不可用</td><td>复测 r = ${f2(retest(r => Number(r.m.rating?.fun)).r)} / ${f2(retest(r => Number(r.m.rating?.clarity)).r)}，是模型噪声</td></tr>
 </tbody>
 </table>