fix(bench): rebuild each round's level set from its runs, not from a snapshot

The round comparison was about to be wrong. levels/campaign-50-r2.json was copied from levels/campaign-50.json to preserve "the set round 2 played", but select-50 writes that path in place and several selection experiments ran between the round and the copy. The file kept 28 of the 50 boards round 2 had actually played and 46 of round 3's — so the comparison was scoring one round against another round's levels, and it read as round 3 regressing. Runs store the whole board and its campaign index, so a round is its own record and cannot drift. round-set.mjs rebuilds it, the report uses that, and the snapshot file is gone rather than left lying around looking authoritative. With the rounds correctly matched, round 3 is not a regression and not an improvement: back band 2.17 against round 2's 2.39, on a rating that retests at 0.55, which is not enough to separate seventeen levels. The report says that rather than picking whichever reading flatters the change. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-14 17:22:31 +08:00
parent dcdd4a0ada
commit 4aa0c28cef
9 changed files with 223558 additions and 85313 deletions
@@ -125,13 +125,13 @@
     "id": "T1.5",
     "title": "扩产到 ≥120 候选并去重、家族均衡",
     "status": "done",
-     "note": "扫了 480 + 240 个种子，得 684 个候选；过两道新闸门后 228 关。扩产的目的是付得起闸门的代价，不是数量本身"
+     "note": "两批共 720 个种子 → 1113 个候选 → 过闸门 369 关（原 228）。家族 weave 262 / switchback 58 / orbits 39 / spiral 10"
    },
    {
     "id": "T1.6",
     "title": "终局三枚互锁（hero+gate+tail）",
     "status": "blocked",
-     "note": "仍是深关卡的瓶颈：684 个候选里深度≥4 的只有 67 个，过闸门后剩 16 个——后档只能做到平均 4.1 转，是供给限制不是设计选择"
+     "note": "量化了：扫 1113 个候选，过闸门后深度≥4 的只有 23 个（2%）。第二次扩池把种子数翻倍，深关卡只从 16 涨到 23 —— 难度上限是构造的供给瓶颈，不是筛选问题。后档平均 4.0 转就是这个供给能支撑的上限"
    },
    {
     "id": "T1.7",
@@ -259,6 +259,10 @@
  {
   "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 近乎确定性，同一关不必跑两遍"
+  },
+  {
+   "at": "供给瓶颈",
+   "text": "扩池两轮共 720 种子、1113 候选，深度≥4 的过闸门后只有 23 个（2%）。种子翻倍只让深关卡从 16 涨到 23，说明 growDeepLevel 难以造出需要四转以上的关卡——这是后档难度的硬上限"
  }
 ]
 }
@@ -110,7 +110,7 @@ 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.43</div><div class="n">目标 ≥3.0（不无脑）</div></div>
+  <div class="tile ok"><div class="k">猴子 动作÷棋子</div><div class="v">6.11</div><div class="n">目标 ≥3.0（不无脑）</div></div>
 </div>

 <div class="scroll"><table>
@@ -118,12 +118,12 @@ footer{margin-top:56px;padding-top:20px;border-top:1px solid var(--rule);color:v
 <tbody>
 <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>3 转</td><td class="n">26</td><td class="sub">浅</td></tr>
+<tr><td>4 转</td><td class="n">10</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 ×10 · spiral ×2 · switchback ×12 · weave ×18 · orbits ×8　终局可走朝向分布：{"3":44,"4":5,"5":1}</p>
+<p class="sub">路线家族分布：v05 ×10 · spiral ×5 · switchback ×13 · orbits ×9 · weave ×13　终局可走朝向分布：{"3":44,"4":6}</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="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.5</span><span class="tt">扩产到 ≥120 候选并去重、家族均衡</span><span class="tag good">完成</span></div><div class="note">两批共 720 个种子 → 1113 个候选 → 过闸门 369 关（原 228）。家族 weave 262 / switchback 58 / orbits 39 / spiral 10</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">量化了：扫 1113 个候选，过闸门后深度≥4 的只有 23 个（2%）。第二次扩池把种子数翻倍，深关卡只从 16 涨到 23 —— 难度上限是构造的供给瓶颈，不是筛选问题。后档平均 4.0 转就是这个供给能支撑的上限</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>
@@ -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>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>R2 · grok xhigh</td><td class="n">100</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>R3 · grok xhigh</td><td class="n">50</td><td class="n">2.08</td><td class="n">1.32</td><td class="n">0.14</td><td class="n">0.26</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>
@@ -220,6 +221,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>供给瓶颈</b>扩池两轮共 720 种子、1113 候选，深度≥4 的过闸门后只有 23 个（2%）。种子翻倍只让深关卡从 16 涨到 23，说明 growDeepLevel 难以造出需要四转以上的关卡——这是后档难度的硬上限</li>
 <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>
@@ -57,20 +57,20 @@ a{color:var(--rail)}
 <div class="wrap">
 <h1>关卡制作流程复盘</h1>
 <p class="lede">这一轮做 50 关的过程里，最有用的结论是一个<b>否定结论</b>：原计划的「agent 打分 → 拟合权重 → 重选关卡」这个闭环<b>合不上</b>，而且不是样本量的问题。下面是它为什么合不上，以及流程该改成什么样。</p>
-<p class="meta">实测批次 R2 · grok-4.6 xhigh · 99 局（50 关，多数跑了两次）· 对照批次 R1 50 局 · 生成于 2026-09-14 17:15</p>
+<p class="meta">最新批次 R3 · 50 局 · 对照批次 R2 100 局 · 生成于 2026-09-14 17:22</p>

-<h2>第二轮实测到了什么</h2>
+<h2>最新一轮实测到了什么</h2>
 <div class="tiles">
-  <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">50/50</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.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 class="tile ok"><div class="k">盲转 / 关</div><div class="v">0.14</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">44/50</div><div class="n">都是 2 分 — 不区分</div></div>
 </div>
-<p>机械面干净，说明生成期的闸门是有效的：「动了很多次没结果」这类结构缺陷已经被挡在关卡集之外。<b>难度评分那一格是这两轮真正的发现</b>：机械上差着三倍的关卡，它一律给 2 分。更早的记录里这项的复测可信度是 0.93，那是个更小的样本——在这一批 49 对复测上实测是 0.55，所以它既不区分、也不像以为的那么稳。</p>
+<p>机械面干净，说明生成期的闸门是有效的：「动了很多次没结果」这类结构缺陷已经被挡在关卡集之外。<b>难度评分那一格是这两轮真正的发现</b>：机械上差着三倍的关卡，它一律给 2 分。更早的记录里这项的复测可信度是 0.93，那是个更小的样本——在这一批 50 对复测上实测是 0.55，所以它既不区分、也不像以为的那么稳。</p>

 <h2>两轮之间改了什么，效果如何</h2>
-<p>第一轮唯一可用的读数是「整批偏易」，加上抱怨里反复出现的「转了没反应」。据此只改了两件事：给<b>连续空转</b>设闸门（最多一次转动没反应，此前有 11 关能连着两次），以及把难度曲线<b>写成旋转深度的配额</b>而不是指望它从排序里自己长出来。</p>
+<p>第一轮唯一可用的读数是「整批偏易」，加上抱怨里反复出现的「转了没反应」。据此只改了两件事：给<b>连续空转</b>设闸门（最多一次转动没反应，此前有 11 关能连着两次），以及把难度曲线<b>写成旋转深度的配额</b>而不是指望它从排序里自己长出来。第三轮又只改了一件：桶内改按<b>反差</b>取。每轮一个变量，才看得出是哪个变量起的作用。</p>
 <table>
 <thead><tr><th>同一个规则机器人，两套关卡集</th><th class="n">第一版</th><th class="n">第二版</th></tr></thead>
 <tbody>
@@ -84,29 +84,32 @@ a{color:var(--rail)}
 </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>
+<thead><tr><th>grok 实测，按档（每关计一次，与它自己玩的那一版对齐）</th><th class="n" colspan="2">R1</th><th class="n" colspan="2">R2</th><th class="n" colspan="2">R3</th></tr>
+<tr><th></th><th class="n">难度</th><th class="n">无解感</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>
+<tr><td>前档 L1–L12</td><td class="n">2.00</td><td class="n">1.33</td><td class="n">2.00</td><td class="n">1.21</td><td class="n">2.00</td><td class="n">1.08</td></tr>
+<tr><td>中档 L13–L32</td><td class="n">2.10</td><td class="n">1.35</td><td class="n">2.05</td><td class="n">1.15</td><td class="n">2.05</td><td class="n">1.20</td></tr>
+<tr><td>后档 L33–L50</td><td class="n">2.17</td><td class="n">1.61</td><td class="n">2.39</td><td class="n">1.72</td><td class="n">2.17</td><td class="n">1.61</td></tr>
+<tr><td>后档的关卡参数</td><td class="n">3.5 转</td><td class="n">反差 21.7</td><td class="n">4.1 转</td><td class="n">反差 27.9</td><td class="n">4.0 转</td><td class="n">反差 28.5</td></tr>
 </tbody>
 </table>
-<p>第一轮三档的难度评分是一条平线。第二轮后档升到了 2.40，无解感也跟着抬起来——<b>这是评分第一次表现出梯度</b>，但只在按档平均之后。</p>
+<p>第一轮三档几乎是一条平线。第二轮把后档的旋转深度从 3.5 提到 4.1 转，后档评分随之升到 2.39——<b>评分第一次表现出梯度</b>，但只在按档平均之后。</p>
+<p><b>第三轮是一次没被证实的假设。</b>第二轮的数据显示打 3 分的关比打 2 分的关反差高 59%，于是第三轮按反差选关，把后档反差从 27.9 提到 28.5、旋转深度不变。后档评分没有升，反而是 2.17。以这项评分 r = 0.55 的复测可信度，十几关上的这点差距读不出胜负——<b>该说的是「两版分不出来」，不是「反差有用」，也不是「反差没用」</b>。第三版留下来的理由是设计上的：反差是策划点名的好玩机制，而且它的家族分布更均衡（两家族 30/50 → 26/50），这两条要靠人工审核裁定。</p>

 <h2>哪些信号复测得住</h2>
-<p>下面的 r 是在<b>这一批关卡</b>上现算的：同一个 agent 把每关玩了两次，49 对。不是引用更早、更小的样本。</p>
+<p>下面的 r 是在<b>这一批关卡</b>上现算的：同一个 agent 把每关玩了两次，50 对。不是引用更早、更小的样本。</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>
+<tr><td>盲转次数</td><td class="n yes">1.00</td><td class="n">50</td><td>可用：驱动了真实修复</td></tr>
+<tr><td>转错方向次数</td><td class="n yes">1.00</td><td class="n">50</td><td>可用</td></tr>
+<tr><td>实际旋转数</td><td class="n yes">1.00</td><td class="n">50</td><td>可用</td></tr>
+<tr><td>步数</td><td class="n yes">1.00</td><td class="n">50</td><td>可用</td></tr>
+<tr><td>决策数</td><td class="n ">0.90</td><td class="n">50</td><td>可用</td></tr>
+<tr><td>无解感评分</td><td class="n no">0.45</td><td class="n">50</td><td>只按档看</td></tr>
+<tr><td>难度评分</td><td class="n ">0.55</td><td class="n">50</td><td>只按档看，约 20 局起</td></tr>
+<tr><td>好玩评分</td><td class="n no">0.34</td><td class="n">50</td><td>不可用</td></tr>
+<tr><td>清晰度评分</td><td class="n no">0.14</td><td class="n">50</td><td>不可用</td></tr>
 </tbody>
 </table>
 <p>机械指标全部 r ≈ 1.00，但那多半是因为 agent <b>84% 的情况下重放了完全相同的动作序列</b>——这本身才是有用的那条结论：重复跑同一关买不到新信息。评分则相反：同一条轨迹，6 对给出了不同的难度分。</p>
@@ -115,7 +118,7 @@ a{color:var(--rail)}
 <div class="rule">
  <h3><span class="no">1</span>难度评分只能按档看，不能逐关看</h3>
  <dl>
-    <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 class="ev">50 局里有 44 局打的是 2 分，而这些关卡的决策数从 3 到 17。逐关复测 r = 0.55，而且 6 对分歧里有 6 对&lt;b&gt;走的是同一条轨迹&lt;/b&gt;——同样的动作、同样的结果，模型给自己打了不同的分。但按档平均约 20 局后，曲线第一次显形了（见上表）。</dd>
    <dt>为什么</dt><dd>文字盘面把每颗棋子的路线、挡路者、紧贴者列成清单，agent 不必用眼睛顺线走一遍——而那正是这游戏的难点。agent 自己写过：「挡路名单已经写全，不用顺着格子数」。剩下的评分噪声，只有靠聚合才压得下去。</dd>
    <dt>现在怎么做</dt><dd>逐关排序改为机械假设（旋转深度、棋子数、互锁），由人工审核裁定；评分只用来读整档的高低。</dd>
  </dl>
@@ -123,7 +126,7 @@ a{color:var(--rail)}
 <div class="rule">
  <h3><span class="no">2</span>先用规则机器人扫，再花 agent 时间；同一关不要跑两遍</h3>
  <dl>
-    <dt>证据</dt><dd class="ev">第二轮意外把每关跑了两次，得到 49 对复测：其中 41 对（84%）重放了&lt;b&gt;完全相同&lt;/b&gt;的动作序列，机械指标复测 r = 1.00。规则机器人跑完 50 关只要 1 秒。</dd>
+    <dt>证据</dt><dd class="ev">第二轮意外把每关跑了两次，得到 50 对复测：其中 42 对（84%）重放了&lt;b&gt;完全相同&lt;/b&gt;的动作序列，机械指标复测 r = 1.00。规则机器人跑完 50 关只要 1 秒。</dd>
    <dt>为什么</dt><dd>agent 近乎确定性，重复同一关几乎不产生新信息。为「提高可信度」而重复跑，是把预算花在已经知道的答案上。</dd>
    <dt>现在怎么做</dt><dd>全量验收交给规则机器人；agent 每关只跑一次，省下的预算用来多覆盖关卡。</dd>
  </dl>
@@ -157,12 +160,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 = 1.00；驱动了真实修复（盲转 1.17 → 0.12）</td></tr>
+<tr><td>盲转 / 多余转 / 转错方向</td><td class="n yes">可用</td><td>本批复测 r = 1.00；驱动了真实修复（盲转 1.17 → 0.14）</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>逐关复测 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>
+<tr><td>无解感评分</td><td class="n">只按档看</td><td>复测 r = 0.45；按档看时与难度同向抬升，可当挫败感的代理</td></tr>
+<tr><td>好玩 / 清晰度评分</td><td class="n no">不可用</td><td>复测 r = 0.34 / 0.14，是模型噪声</td></tr>
 </tbody>
 </table>

@@ -180,7 +183,7 @@ a{color:var(--rail)}
 <table>
 <thead><tr><th>试过什么</th><th>结果</th></tr></thead>
 <tbody>
-<tr><td>拟合 difficulty ~ 机械特征，用来重选关卡</td><td>响应几乎无方差（83/99 同分），回归的是常数</td></tr>
+<tr><td>拟合 difficulty ~ 机械特征，用来重选关卡</td><td>响应几乎无方差（44/50 同分），回归的是常数</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>
@@ -7,6 +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 { roundSet } from './round-set.mjs';
 import { deepLevelKey, legibility } from '../src/deep-lock.js';

 const esc = s => String(s ?? '').replace(/[&<>"]/g, c => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;' }[c]));
@@ -29,23 +30,30 @@ for (const f of existsSync(resolve('bench/runs')) ? readdirSync(resolve('bench/r
    runs.push({ raw: d, m: metrics(d) });
  } catch { /* torn read */ }
 }
-// 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);
+// Each round is rebuilt from its own runs. A disk snapshot of "the set round N
+// played" cannot be trusted — select-50 writes campaign-50.json in place, so a
+// selection experiment between the round and the copy replaces it silently, and
+// one such copy kept only 28 of its round's 50 boards.
+const ROUND_IDS = ['R1', 'R2', 'R3', 'R4'];
+const sets = Object.fromEntries(ROUND_IDS.map(id => [id, roundSet(id)]).filter(([, rows]) => rows.length));
+const present = Object.keys(sets);
+const LATEST = present[present.length - 1] ?? 'R1';
+const PREV = present[present.length - 2] ?? null;
+const flat = id => (sets[id] ?? []).flatMap(e => e.runs.map(raw => ({ raw, m: metrics(raw) })));
+const r1 = PREV ? flat(PREV) : [];
+const r2 = flat(LATEST);
 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.
+// Retest pairs, wherever a round happened to play a level twice. Round 2 did it
+// across the board by accident, which is where the reliability figures come from.
 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]]);
+for (const id of present) for (const e of sets[id]) {
+  const rows = e.runs.map(raw => ({ raw, m: metrics(raw) }));
+  if (rows.length >= 2) pairsBy.set(`${id}:${deepLevelKey(e.level)}`, rows);
+}
+const pairs = [...pairsBy.values()].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 => {
@@ -58,6 +66,20 @@ 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;

+// A band is a slice of the round's own ordering, and each level counts once no
+// matter how many times it was played.
+const bandStats = (id, a, b) => {
+  const slice = (sets[id] ?? []).slice(a, b);
+  const per = get => slice.map(e => mean(e.runs.map(raw => get(metrics(raw))).filter(Number.isFinite))).filter(Number.isFinite);
+  return {
+    n: slice.length,
+    difficulty: mean(per(m => Number(m.rating?.difficulty))),
+    stuck: mean(per(m => Number(m.rating?.stuck))),
+    blind: mean(per(m => m.blindRotations ?? 0)),
+    contrast: mean(slice.map(e => e.level.campaign?.contrast ?? 0)),
+    rotations: mean(slice.map(e => e.level.campaign?.rotations ?? 0)),
+  };
+};
 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]];

@@ -172,9 +194,9 @@ a{color:var(--rail)}
 <div class="wrap">
 <h1>关卡制作流程复盘</h1>
 <p class="lede">这一轮做 50 关的过程里，最有用的结论是一个<b>否定结论</b>：原计划的「agent 打分 → 拟合权重 → 重选关卡」这个闭环<b>合不上</b>，而且不是样本量的问题。下面是它为什么合不上，以及流程该改成什么样。</p>
-<p class="meta">实测批次 R2 · grok-4.6 xhigh · ${R1.n} 局（50 关，多数跑了两次）· 对照批次 R1 ${R1.r1n} 局 · 生成于 ${new Date().toLocaleString('sv-SE').slice(0, 16)}</p>
+<p class="meta">最新批次 ${esc(LATEST)} · ${R1.n} 局 · 对照批次 ${esc(PREV ?? '—')} ${R1.r1n} 局 · 生成于 ${new Date().toLocaleString('sv-SE').slice(0, 16)}</p>

-<h2>第二轮实测到了什么</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>
@@ -185,7 +207,7 @@ a{color:var(--rail)}
 <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>
+<p>第一轮唯一可用的读数是「整批偏易」，加上抱怨里反复出现的「转了没反应」。据此只改了两件事：给<b>连续空转</b>设闸门（最多一次转动没反应，此前有 11 关能连着两次），以及把难度曲线<b>写成旋转深度的配额</b>而不是指望它从排序里自己长出来。第三轮又只改了一件：桶内改按<b>反差</b>取。每轮一个变量，才看得出是哪个变量起的作用。</p>
 <table>
 <thead><tr><th>同一个规则机器人，两套关卡集</th><th class="n">第一版</th><th class="n">第二版</th></tr></thead>
 <tbody>
@@ -199,17 +221,21 @@ ${botOld && botNew ? `
 </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>
+<thead><tr><th>grok 实测，按档（每关计一次，与它自己玩的那一版对齐）</th>${present.map(id => `<th class="n" colspan="2">${id}</th>`).join('')}</tr>
+<tr><th></th>${present.map(() => '<th class="n">难度</th><th class="n">无解感</th>').join('')}</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')}
+${BANDS.map(([label, a, b]) => `<tr><td>${label}</td>${present.map(id => {
+  const st = bandStats(id, a, b);
+  return `<td class="n">${f2(st.difficulty)}</td><td class="n">${f2(st.stuck)}</td>`;
+}).join('')}</tr>`).join('\n')}
+<tr><td>后档的关卡参数</td>${present.map(id => {
+  const st = bandStats(id, 32, 50);
+  return `<td class="n">${f1(st.rotations)} 转</td><td class="n">反差 ${f1(st.contrast)}</td>`;
+}).join('')}</tr>
 </tbody>
 </table>
-<p>第一轮三档的难度评分是一条平线。第二轮后档升到了 ${f2(mean(bandOf(r2, 32, 50).map(r => Number(r.m.rating?.difficulty)).filter(Number.isFinite)))}，无解感也跟着抬起来——<b>这是评分第一次表现出梯度</b>，但只在按档平均之后。</p>
+<p>第一轮三档几乎是一条平线。第二轮把后档的旋转深度从 ${f1(bandStats(present[0], 32, 50).rotations)} 提到 ${f1(bandStats(present[1] ?? present[0], 32, 50).rotations)} 转，后档评分随之升到 ${f2(bandStats(present[1] ?? present[0], 32, 50).difficulty)}——<b>评分第一次表现出梯度</b>，但只在按档平均之后。</p>
+<p><b>第三轮是一次没被证实的假设。</b>第二轮的数据显示打 3 分的关比打 2 分的关反差高 59%，于是第三轮按反差选关，把后档反差从 ${f1(bandStats(present[1] ?? present[0], 32, 50).contrast)} 提到 ${f1(bandStats(LATEST, 32, 50).contrast)}、旋转深度不变。后档评分没有升，反而是 ${f2(bandStats(LATEST, 32, 50).difficulty)}。以这项评分 r = ${f2(retest(r => Number(r.m.rating?.difficulty)).r)} 的复测可信度，十几关上的这点差距读不出胜负——<b>该说的是「两版分不出来」，不是「反差有用」，也不是「反差没用」</b>。第三版留下来的理由是设计上的：反差是策划点名的好玩机制，而且它的家族分布更均衡（${present.length >= 2 ? '两家族 30/50 → 26/50' : ''}），这两条要靠人工审核裁定。</p>

 <h2>哪些信号复测得住</h2>
 <p>下面的 r 是在<b>这一批关卡</b>上现算的：同一个 agent 把每关玩了两次，${pairs.length} 对。不是引用更早、更小的样本。</p>
@@ -14,7 +14,7 @@ import { layout } from '../src/geometry.js';
 import { metrics } from '../src/bench.js';

 const args = Object.fromEntries(process.argv.slice(2).map(a => { const [k, ...v] = a.replace(/^--/, '').split('='); return [k, v.length ? v.join('=') : true]; }));
-const AGENT = args.agent ?? 'R1 · grok xhigh';
+const AGENT = args.agent ?? 'R3 · grok xhigh';
 const OUT = resolve(args.out ?? 'docs/review-50.html');

 const raw = JSON.parse(readFileSync(resolve('levels/campaign-50.json'), 'utf8'));
@@ -0,0 +1,43 @@
+#!/usr/bin/env node
+// Rebuild the level set a bench round actually played, from the round's runs.
+//
+//   node scripts/round-set.mjs --round=R2 [--out=…]
+//
+// Disk snapshots of "the set round N played" are not trustworthy: select-50
+// writes levels/campaign-50.json in place, so any selection experiment run
+// between the round and the copy silently replaces it. One such copy kept only
+// 28 of the 50 boards its round had played, which would have made the round
+// comparison compare a set against somebody else's levels.
+//
+// Runs store the whole board and its campaign index, so the round is its own
+// record. That record cannot drift.
+import { readdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { deepLevelKey } from '../src/deep-lock.js';
+
+const args = Object.fromEntries(process.argv.slice(2).map(a => { const [k, ...v] = a.replace(/^--/, '').split('='); return [k, v.length ? v.join('=') : true]; }));
+const ROUND = String(args.round ?? 'R2');
+
+export function roundSet(round, dir = resolve('bench/runs')) {
+  const byBoard = new Map();
+  for (const f of readdirSync(dir)) {
+    if (!f.endsWith('.json') || f === 'index.json') continue;
+    try {
+      const d = JSON.parse(readFileSync(resolve(dir, f), 'utf8'));
+      if (d.status === 'playing' || !d.level?.tiles) continue;
+      if (!new RegExp(`^${round} · `).test(String(d.agent))) continue;
+      const k = deepLevelKey(d.level);
+      if (!byBoard.has(k)) byBoard.set(k, { level: d.level, runs: [] });
+      byBoard.get(k).runs.push(d);
+    } catch { /* torn read */ }
+  }
+  return [...byBoard.values()].sort((a, b) => (a.level.campaign?.index ?? 0) - (b.level.campaign?.index ?? 0));
+}
+
+if (import.meta.url === `file://${process.argv[1]}`) {
+  const rows = roundSet(ROUND);
+  const levels = rows.map(r => r.level);
+  console.log(`${ROUND}：${levels.length} 关，共 ${rows.reduce((s, r) => s + r.runs.length, 0)} 局`);
+  console.log(`旋转深度 ${JSON.stringify(levels.reduce((m, l) => (m[l.campaign?.rotations ?? '?'] = (m[l.campaign?.rotations ?? '?'] || 0) + 1, m), {}))}`);
+  if (args.out) { writeFileSync(resolve(args.out), JSON.stringify({ generated: `round-set ${ROUND}`, count: levels.length, levels }, null, 1)); console.log(`已写入 ${args.out}`); }
+}