dsh-vibe-math 2.4.1 → 2.6.0

package/prompt-corpus-v5/prompt-corpus-v5.md

@@ -595,7 +595,7 @@
 
 【五、表决与定论（求真门槛）】
   · 任何命题 / 论断 / 方法 / 子问题的结论，要进入 Verified/，必须满足：
-      (a) 至少有 m = 2 名有表决权者（院士 + 常驻研究员）投出**布尔概率值**；
+      (a) 至少有 m = 1 名有表决权者（院士 + 常驻研究员）投出**布尔概率值**；
       (b) 这些票**全部**是 1（绝对为真）或**全部**是 0（绝对为假）；
       (c) 若同时出现 1 和 0（分歧），或投布尔票者不足 m 人 → 不能定论。
   · m 随在册有表决权者人数变化（m = min(所办设定的上限, 人数)）；本规章里的 m 是
@@ -808,7 +808,7 @@
 
 【五、表决与定论（求真门槛）】
   · 任何命题 / 论断 / 方法 / 子问题的结论，要进入 Verified/，必须满足：
-      (a) 至少有 m = 3 名有表决权者（院士 + 常驻研究员）投出**布尔概率值**；
+      (a) 至少有 m = 2 名有表决权者（院士 + 常驻研究员）投出**布尔概率值**；
       (b) 这些票**全部**是 1（绝对为真）或**全部**是 0（绝对为假）；
       (c) 若同时出现 1 和 0（分歧），或投布尔票者不足 m 人 → 不能定论。
   · m 随在册有表决权者人数变化（m = min(所办设定的上限, 人数)）；本规章里的 m 是
@@ -3009,7 +3009,7 @@ r-2：初始见解。
 ### 提示词原文
 
 ```text
-[核心规则] 只有 Verified/（及标记"已验证·真/假"的卡片）算已确立；任何对象要进 Verified/ 必须 ≥m 名有表决权者一致给出 1 或 0，否则留库附平均概率；你只写自己的库（Members/<你>/），可只读任何人的库；组织与分派由院士负责，但判断属于你自己；退出时只输出一个 JSON 对象。
+[核心规则] 只有 Verified/（及标记"已验证·真/假"的卡片）算已确立；任何对象要进 Verified/，必须至少有 m 名有表决权者投出布尔值（恰好 1 或恰好 0）**且没有任何一张反向票**，否则留库附平均概率；你只写自己的库（Members/<你>/），可只读任何人的库；组织与分派由院士负责，但判断属于你自己；退出时只输出一个 JSON 对象。
 [CONTEXT COMPACT — 你的对话已接近上限。不要重新推导历史。
 请把当前工作状态浓缩成一段自述（已有发现、当前方向、已记录的关键成果、下一步具体动作、未决问题），然后照常以 JSON 回答本轮。请在回复里填 "contextPct": 15 与 "compacted": true。]
 
@@ -3234,7 +3234,7 @@ r-2：初始见解。
   "task_done": "t-3",
   "task_update": {"task_id":"t-3","expected_revision":2,"action":"complete|release|reopen|edit|set_dependencies|delete"},
   "input": "本轮会议/辩论的发言正文（会议轮用；也可直接用 say）",
-  "formal": {"target":"p-x","decision":"used|blocked|defect","file":"Formal/p-x.lean","note":"难度判断/阻塞原因"}
+  "formal": {"target":"p-x","decision":"used|blocked|defect","file":"Formal/p-x.lean","note":"难度判断（used）/ 阻塞原因（blocked）/ 具体偏差（defect）"}
              ← Lean 形式化：**鼓励**：按实现难度自行决定；做了就归档，没做就写明难度判断，详见提示词里的【Lean 形式化验证】段
   "reject_assign": {"task_id":"t-3","why":"你对这项分派的异议理由"}   ← 有异议时填；理由会被广播给
              全体表决者（任务仍会执行，但你的理由不会被埋掉），
@@ -3277,7 +3277,7 @@ r-2：初始见解。
     命题原文逐条一致。请把注意力放在这种核对上，而不是重新做一遍推导。
   · 若你判断不值得或无法形式化，可以不做，但请在回执的 formal 字段写明难度判断（decision='blocked' 时必须写明 note）。
   · 归档可复用定义/引理前先跑通（vibe_v5_lean_archive run=true 或先 vibe_v5_lean_run）；跑不通不要入库。
-  · 宿主没有 Lean 工具链（LEAN_NOT_FOUND）或根本没有 subprocess 服务（NO_SUBPROCESS）时：把代码写下来归档，并在回执的 note 里写明"宿主无 Lean 工具链"——这两种都算显式阻塞原因，定论门禁可以据此放行。
+  · 宿主没有 Lean 工具链（LEAN_NOT_FOUND）或根本没有 subprocess 服务（NO_SUBPROCESS）时：把代码写下来归档，并把"宿主无 Lean 工具链"写成**阻塞记录**（vibe_v5_lean_archive kind='blocked' note=… 或回执 formal:{decision:'blocked', note:…}）——这算显式阻塞原因，定论门禁可以据此放行。
   ▸ 若你在本轮把它形式化并跑通（vibe_v5_lean_archive kind='proof'），后续轮次的
     审查对象就会从"推导是否正确"变成"Lean 代码是否忠实于命题"。
 
@@ -3292,7 +3292,7 @@ r-2：初始见解。
 结束时请**只**输出一个 JSON 对象（```json 围栏内）：
 {"verdict":{"target":"p-lean-a","verdict":<0-1 数值>,"reason":"<你的理由>"}, "contextPct": 40}
 若你本轮做了形式化或给出难度判断，请一并加上：
-{"formal":{"target":"p-lean-a","decision":"used|blocked|defect","file":"Formal/p-lean-a.lean","note":"难度判断/阻塞原因"}}
+{"formal":{"target":"p-lean-a","decision":"used|blocked|defect","file":"Formal/p-lean-a.lean","note":"难度判断（used）/ 阻塞原因（blocked）/ 具体偏差（defect）"}}
 ```
 
 ---
@@ -3325,7 +3325,7 @@ r-2：初始见解。
     命题原文逐条一致。请把注意力放在这种核对上，而不是重新做一遍推导。
   · 若你判断不值得或无法形式化，可以不做，但请在回执的 formal 字段写明难度判断（decision='blocked' 时必须写明 note）。
   · 归档可复用定义/引理前先跑通（vibe_v5_lean_archive run=true 或先 vibe_v5_lean_run）；跑不通不要入库。
-  · 宿主没有 Lean 工具链（LEAN_NOT_FOUND）或根本没有 subprocess 服务（NO_SUBPROCESS）时：把代码写下来归档，并在回执的 note 里写明"宿主无 Lean 工具链"——这两种都算显式阻塞原因，定论门禁可以据此放行。
+  · 宿主没有 Lean 工具链（LEAN_NOT_FOUND）或根本没有 subprocess 服务（NO_SUBPROCESS）时：把代码写下来归档，并把"宿主无 Lean 工具链"写成**阻塞记录**（vibe_v5_lean_archive kind='blocked' note=… 或回执 formal:{decision:'blocked', note:…}）——这算显式阻塞原因，定论门禁可以据此放行。
   ▸ 若你在本轮把它形式化并跑通（vibe_v5_lean_archive kind='proof'），后续轮次的
     审查对象就会从"推导是否正确"变成"Lean 代码是否忠实于命题"。
 
@@ -3340,7 +3340,7 @@ r-2：初始见解。
 结束时请**只**输出一个 JSON 对象（```json 围栏内）：
 {"verdict":{"target":"p-lean-a","verdict":<0-1 数值>,"reason":"<你的理由>"}, "contextPct": 40}
 若你本轮做了形式化或给出难度判断，请一并加上：
-{"formal":{"target":"p-lean-a","decision":"used|blocked|defect","file":"Formal/p-lean-a.lean","note":"难度判断/阻塞原因"}}
+{"formal":{"target":"p-lean-a","decision":"used|blocked|defect","file":"Formal/p-lean-a.lean","note":"难度判断（used）/ 阻塞原因（blocked）/ 具体偏差（defect）"}}
 ```
 
 ---
@@ -3373,7 +3373,7 @@ r-2：初始见解。
     命题原文逐条一致。请把注意力放在这种核对上，而不是重新做一遍推导。
   · 若你判断不值得或无法形式化，可以不做，但请在回执的 formal 字段写明难度判断（decision='blocked' 时必须写明 note）。
   · 归档可复用定义/引理前先跑通（vibe_v5_lean_archive run=true 或先 vibe_v5_lean_run）；跑不通不要入库。
-  · 宿主没有 Lean 工具链（LEAN_NOT_FOUND）或根本没有 subprocess 服务（NO_SUBPROCESS）时：把代码写下来归档，并在回执的 note 里写明"宿主无 Lean 工具链"——这两种都算显式阻塞原因，定论门禁可以据此放行。
+  · 宿主没有 Lean 工具链（LEAN_NOT_FOUND）或根本没有 subprocess 服务（NO_SUBPROCESS）时：把代码写下来归档，并把"宿主无 Lean 工具链"写成**阻塞记录**（vibe_v5_lean_archive kind='blocked' note=… 或回执 formal:{decision:'blocked', note:…}）——这算显式阻塞原因，定论门禁可以据此放行。
   ▸ 若你在本轮把它形式化并跑通（vibe_v5_lean_archive kind='proof'），后续轮次的
     审查对象就会从"推导是否正确"变成"Lean 代码是否忠实于命题"。
 
@@ -3388,7 +3388,7 @@ r-2：初始见解。
 结束时请**只**输出一个 JSON 对象（```json 围栏内）：
 {"verdict":{"target":"p-lean-a","verdict":<0-1 数值>,"reason":"<你的理由>"}, "contextPct": 40}
 若你本轮做了形式化或给出难度判断，请一并加上：
-{"formal":{"target":"p-lean-a","decision":"used|blocked|defect","file":"Formal/p-lean-a.lean","note":"难度判断/阻塞原因"}}
+{"formal":{"target":"p-lean-a","decision":"used|blocked|defect","file":"Formal/p-lean-a.lean","note":"难度判断（used）/ 阻塞原因（blocked）/ 具体偏差（defect）"}}
 ```
 
 ---
@@ -3435,7 +3435,7 @@ r-2：初始见解。
 结束时请**只**输出一个 JSON 对象（```json 围栏内）：
 {"verdict":{"target":"p-lean-b","verdict":<0-1 数值>,"reason":"<你的理由>"}, "contextPct": 40}
 若你本轮做了形式化或给出难度判断，请一并加上：
-{"formal":{"target":"p-lean-b","decision":"used|blocked|defect","file":"Formal/p-lean-b.lean","note":"难度判断/阻塞原因"}}
+{"formal":{"target":"p-lean-b","decision":"used|blocked|defect","file":"Formal/p-lean-b.lean","note":"难度判断（used）/ 阻塞原因（blocked）/ 具体偏差（defect）"}}
 ```
 
 ---
@@ -3482,7 +3482,7 @@ r-2：初始见解。
 结束时请**只**输出一个 JSON 对象（```json 围栏内）：
 {"verdict":{"target":"p-lean-b","verdict":<0-1 数值>,"reason":"<你的理由>"}, "contextPct": 40}
 若你本轮做了形式化或给出难度判断，请一并加上：
-{"formal":{"target":"p-lean-b","decision":"used|blocked|defect","file":"Formal/p-lean-b.lean","note":"难度判断/阻塞原因"}}
+{"formal":{"target":"p-lean-b","decision":"used|blocked|defect","file":"Formal/p-lean-b.lean","note":"难度判断（used）/ 阻塞原因（blocked）/ 具体偏差（defect）"}}
 ```
 
 ---
@@ -3529,7 +3529,7 @@ r-2：初始见解。
 结束时请**只**输出一个 JSON 对象（```json 围栏内）：
 {"verdict":{"target":"p-lean-b","verdict":<0-1 数值>,"reason":"<你的理由>"}, "contextPct": 40}
 若你本轮做了形式化或给出难度判断，请一并加上：
-{"formal":{"target":"p-lean-b","decision":"used|blocked|defect","file":"Formal/p-lean-b.lean","note":"难度判断/阻塞原因"}}
+{"formal":{"target":"p-lean-b","decision":"used|blocked|defect","file":"Formal/p-lean-b.lean","note":"难度判断（used）/ 阻塞原因（blocked）/ 具体偏差（defect）"}}
 ```
 
 ---
@@ -3560,11 +3560,13 @@ r-2：初始见解。
     已证引理放 <VIBEMATH>/Formal/Proved/；写之前先 vibe_v5_lean_lib 查重。
   · **一旦 Lean 通过，你唯一需要确认的就是忠实性**：定义 / 对象 / 条件 / 假设 / 结论是否与
     命题原文逐条一致。请把注意力放在这种核对上，而不是重新做一遍推导。
-  · **本模式要求**：必须产出 Lean 形式化，或**必须**给出显式的阻塞原因（vibe_v5_lean_archive
-    kind='blocked' note=… 或回执 formal.note）。若两者都没有，本次裁定不会生效，
+  · **本模式要求**：必须产出 Lean 形式化，或**必须**给出显式的阻塞原因——用
+    vibe_v5_lean_archive kind='blocked' note=… 记录，或用回执 formal:{decision:'blocked', note:…}。
+    只有 decision='blocked' 的 note 会写成阻塞记录；decision='used' 的 note 只是难度判断，
+    **不会**打开定论门禁。两者都没有时，本次裁定不会生效，
     会被记为未定论（原因 formal-required）并进入「形式化待办」。
   · 归档可复用定义/引理前先跑通（vibe_v5_lean_archive run=true 或先 vibe_v5_lean_run）；跑不通不要入库。
-  · 宿主没有 Lean 工具链（LEAN_NOT_FOUND）或根本没有 subprocess 服务（NO_SUBPROCESS）时：把代码写下来归档，并在回执的 note 里写明"宿主无 Lean 工具链"——这两种都算显式阻塞原因，定论门禁可以据此放行。
+  · 宿主没有 Lean 工具链（LEAN_NOT_FOUND）或根本没有 subprocess 服务（NO_SUBPROCESS）时：把代码写下来归档，并把"宿主无 Lean 工具链"写成**阻塞记录**（vibe_v5_lean_archive kind='blocked' note=… 或回执 formal:{decision:'blocked', note:…}）——这算显式阻塞原因，定论门禁可以据此放行。
   ▸ 若你在本轮把它形式化并跑通（vibe_v5_lean_archive kind='proof'），后续轮次的
     审查对象就会从"推导是否正确"变成"Lean 代码是否忠实于命题"。
 
@@ -3579,7 +3581,7 @@ r-2：初始见解。
 结束时请**只**输出一个 JSON 对象（```json 围栏内）：
 {"verdict":{"target":"p-lean-req","verdict":<0-1 数值>,"reason":"<你的理由>"}, "contextPct": 40}
 若你本轮做了形式化或给出难度判断，请一并加上：
-{"formal":{"target":"p-lean-req","decision":"used|blocked|defect","file":"Formal/p-lean-req.lean","note":"难度判断/阻塞原因"}}
+{"formal":{"target":"p-lean-req","decision":"used|blocked|defect","file":"Formal/p-lean-req.lean","note":"难度判断（used）/ 阻塞原因（blocked）/ 具体偏差（defect）"}}
 ```
 
 ---
@@ -3610,11 +3612,13 @@ r-2：初始见解。
     已证引理放 <VIBEMATH>/Formal/Proved/；写之前先 vibe_v5_lean_lib 查重。
   · **一旦 Lean 通过，你唯一需要确认的就是忠实性**：定义 / 对象 / 条件 / 假设 / 结论是否与
     命题原文逐条一致。请把注意力放在这种核对上，而不是重新做一遍推导。
-  · **本模式要求**：必须产出 Lean 形式化，或**必须**给出显式的阻塞原因（vibe_v5_lean_archive
-    kind='blocked' note=… 或回执 formal.note）。若两者都没有，本次裁定不会生效，
+  · **本模式要求**：必须产出 Lean 形式化，或**必须**给出显式的阻塞原因——用
+    vibe_v5_lean_archive kind='blocked' note=… 记录，或用回执 formal:{decision:'blocked', note:…}。
+    只有 decision='blocked' 的 note 会写成阻塞记录；decision='used' 的 note 只是难度判断，
+    **不会**打开定论门禁。两者都没有时，本次裁定不会生效，
     会被记为未定论（原因 formal-required）并进入「形式化待办」。
   · 归档可复用定义/引理前先跑通（vibe_v5_lean_archive run=true 或先 vibe_v5_lean_run）；跑不通不要入库。
-  · 宿主没有 Lean 工具链（LEAN_NOT_FOUND）或根本没有 subprocess 服务（NO_SUBPROCESS）时：把代码写下来归档，并在回执的 note 里写明"宿主无 Lean 工具链"——这两种都算显式阻塞原因，定论门禁可以据此放行。
+  · 宿主没有 Lean 工具链（LEAN_NOT_FOUND）或根本没有 subprocess 服务（NO_SUBPROCESS）时：把代码写下来归档，并把"宿主无 Lean 工具链"写成**阻塞记录**（vibe_v5_lean_archive kind='blocked' note=… 或回执 formal:{decision:'blocked', note:…}）——这算显式阻塞原因，定论门禁可以据此放行。
   ▸ 若你在本轮把它形式化并跑通（vibe_v5_lean_archive kind='proof'），后续轮次的
     审查对象就会从"推导是否正确"变成"Lean 代码是否忠实于命题"。
 
@@ -3629,7 +3633,7 @@ r-2：初始见解。
 结束时请**只**输出一个 JSON 对象（```json 围栏内）：
 {"verdict":{"target":"p-lean-req","verdict":<0-1 数值>,"reason":"<你的理由>"}, "contextPct": 40}
 若你本轮做了形式化或给出难度判断，请一并加上：
-{"formal":{"target":"p-lean-req","decision":"used|blocked|defect","file":"Formal/p-lean-req.lean","note":"难度判断/阻塞原因"}}
+{"formal":{"target":"p-lean-req","decision":"used|blocked|defect","file":"Formal/p-lean-req.lean","note":"难度判断（used）/ 阻塞原因（blocked）/ 具体偏差（defect）"}}
 ```
 
 ---
@@ -3660,11 +3664,13 @@ r-2：初始见解。
     已证引理放 <VIBEMATH>/Formal/Proved/；写之前先 vibe_v5_lean_lib 查重。
   · **一旦 Lean 通过，你唯一需要确认的就是忠实性**：定义 / 对象 / 条件 / 假设 / 结论是否与
     命题原文逐条一致。请把注意力放在这种核对上，而不是重新做一遍推导。
-  · **本模式要求**：必须产出 Lean 形式化，或**必须**给出显式的阻塞原因（vibe_v5_lean_archive
-    kind='blocked' note=… 或回执 formal.note）。若两者都没有，本次裁定不会生效，
+  · **本模式要求**：必须产出 Lean 形式化，或**必须**给出显式的阻塞原因——用
+    vibe_v5_lean_archive kind='blocked' note=… 记录，或用回执 formal:{decision:'blocked', note:…}。
+    只有 decision='blocked' 的 note 会写成阻塞记录；decision='used' 的 note 只是难度判断，
+    **不会**打开定论门禁。两者都没有时，本次裁定不会生效，
     会被记为未定论（原因 formal-required）并进入「形式化待办」。
   · 归档可复用定义/引理前先跑通（vibe_v5_lean_archive run=true 或先 vibe_v5_lean_run）；跑不通不要入库。
-  · 宿主没有 Lean 工具链（LEAN_NOT_FOUND）或根本没有 subprocess 服务（NO_SUBPROCESS）时：把代码写下来归档，并在回执的 note 里写明"宿主无 Lean 工具链"——这两种都算显式阻塞原因，定论门禁可以据此放行。
+  · 宿主没有 Lean 工具链（LEAN_NOT_FOUND）或根本没有 subprocess 服务（NO_SUBPROCESS）时：把代码写下来归档，并把"宿主无 Lean 工具链"写成**阻塞记录**（vibe_v5_lean_archive kind='blocked' note=… 或回执 formal:{decision:'blocked', note:…}）——这算显式阻塞原因，定论门禁可以据此放行。
   ▸ 若你在本轮把它形式化并跑通（vibe_v5_lean_archive kind='proof'），后续轮次的
     审查对象就会从"推导是否正确"变成"Lean 代码是否忠实于命题"。
 
@@ -3679,7 +3685,7 @@ r-2：初始见解。
 结束时请**只**输出一个 JSON 对象（```json 围栏内）：
 {"verdict":{"target":"p-lean-req","verdict":<0-1 数值>,"reason":"<你的理由>"}, "contextPct": 40}
 若你本轮做了形式化或给出难度判断，请一并加上：
-{"formal":{"target":"p-lean-req","decision":"used|blocked|defect","file":"Formal/p-lean-req.lean","note":"难度判断/阻塞原因"}}
+{"formal":{"target":"p-lean-req","decision":"used|blocked|defect","file":"Formal/p-lean-req.lean","note":"难度判断（used）/ 阻塞原因（blocked）/ 具体偏差（defect）"}}
 ```
 
 ---
@@ -3721,7 +3727,7 @@ r-2：初始见解。
   "task_done": "t-3",
   "task_update": {"task_id":"t-3","expected_revision":2,"action":"complete|release|reopen|edit|set_dependencies|delete"},
   "input": "本轮会议/辩论的发言正文（会议轮用；也可直接用 say）",
-  "formal": {"target":"p-x","decision":"used|blocked|defect","file":"Formal/p-x.lean","note":"难度判断/阻塞原因"}
+  "formal": {"target":"p-x","decision":"used|blocked|defect","file":"Formal/p-x.lean","note":"难度判断（used）/ 阻塞原因（blocked）/ 具体偏差（defect）"}
              ← Lean 形式化：**鼓励**：按实现难度自行决定；做了就归档，没做就写明难度判断，详见提示词里的【Lean 形式化验证】段
   "reject_assign": {"task_id":"t-3","why":"你对这项分派的异议理由"}   ← 有异议时填；理由会被广播给
              全体表决者（任务仍会执行，但你的理由不会被埋掉），

package/tests/audit-installer-compat.test.mjs

@@ -15,13 +15,16 @@
 //
 // Run: node tests/audit-installer-compat.test.mjs      (part of `node tests/run-tests.mjs`)
 // ============================================================================================
-import { readFileSync } from 'node:fs'
-import { fileURLToPath } from 'node:url'
-import { join } from 'node:path'
-import { satisfiesDshRange, dshVersionVerdict } from '../installer.js'
+import { readFileSync, mkdtempSync, mkdirSync, writeFileSync, existsSync, rmSync, cpSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { fileURLToPath, pathToFileURL } from 'node:url'
+import { join, resolve } from 'node:path'
+import { satisfiesDshRange, dshVersionVerdict, PRESETS } from '../installer.js'
 
 const HERE = fileURLToPath(new URL('../', import.meta.url))
 const pkg = JSON.parse(readFileSync(join(HERE, 'package.json'), 'utf8'))
+// §4 drives the real apply(); INSTALLER_JS lets the sensitivity probe run it against a reverted copy
+const INSTALLER_SRC = process.env.INSTALLER_JS ? resolve(process.env.INSTALLER_JS) : join(HERE, 'installer.js')
 
 let passed = 0, failed = 0
 const failures = []
@@ -136,6 +139,69 @@ eq(satisfiesDshRange('not-a-version', pkg.engines.dsh), null, 'an unparseable ho
   ok(missedByRange.length === 0, 'the declared range can be evaluated for every release in the matrix', missedByRange.join(', '))
 }
 
+// ---------------------------------------------------------------------------------------------
+// 4. the version probe must not be able to hold the installer ROW's activation
+//
+// `detectDshVersion` asks `pluginManager.listBundles()` for the runtime version, and it runs at the
+// top of apply(). The result is diagnostic only — the preset mechanism is decided by the loader tree
+// / the service's `register`, never by the version — so a slow or stuck plugin manager must fall
+// through to the next source instead of stalling the boot. (Round B, machinery audit.)
+// ---------------------------------------------------------------------------------------------
+console.log('=== 4. a pluginManager that never answers must not hold the row ===')
+{
+  const tmp = mkdtempSync(join(tmpdir(), 'vibe-installer-timeout-'))
+  const pkg = join(tmp, 'pkg')
+  mkdirSync(pkg, { recursive: true })
+  cpSync(INSTALLER_SRC, join(pkg, 'installer.js'))
+  writeFileSync(join(pkg, 'package.json'), JSON.stringify({ name: 'dsh-vibe-math', version: '9.9.9', type: 'module' }, null, 2))
+  for (const p of PRESETS) {
+    mkdirSync(join(pkg, p.src), { recursive: true })
+    for (const f of p.files) cpSync(join(HERE, p.src, f), join(pkg, p.src, f))
+  }
+  const home = join(tmp, 'dshhome')
+  mkdirSync(home, { recursive: true })
+  process.env.DSH_HOME = home
+  delete process.env.DSH_VERSION // leave the pluginManager as the only source
+  const presetRoot = join(home, '.agent-presets')
+  // import the COPY, so `here` inside installer.js is the throwaway package (manifest + preset dirs)
+  const mod = await import(pathToFileURL(join(pkg, 'installer.js')).href + '?t=' + Date.now())
+
+  const run = (services) => {
+    const logs = []
+    const ctx = {
+      get: (n) => (n === 'pluginManager' ? services : undefined),
+      logger: { info: (m) => logs.push('info: ' + m), warn: (m) => logs.push('warn: ' + m), error: (m) => logs.push('error: ' + m) },
+    }
+    return { ctx, logs }
+  }
+
+  // a promise that never settles: without a timeout apply() would await it forever
+  const HARD_LIMIT_MS = 8000
+  const { ctx, logs } = run({ listBundles: () => new Promise(() => {}) })
+  let verdict = 'hung'
+  const t0 = Date.now()
+  let hardTimer
+  await Promise.race([
+    mod.apply(ctx).then(() => { verdict = 'returned' }, (e) => { verdict = 'threw: ' + String(e && e.message) }),
+    new Promise((resolve) => { hardTimer = setTimeout(resolve, HARD_LIMIT_MS) }),
+  ])
+  clearTimeout(hardTimer) // the shipped installer wins the race in ~1.5 s; do not hold the suite open
+  const elapsed = Date.now() - t0
+  ok(verdict === 'returned', 'apply() returns instead of waiting on a pluginManager that never answers', verdict)
+  ok(elapsed < 6000, '...within a short timeout, not at the hard test limit', elapsed + 'ms')
+  const copied = PRESETS.every((p) => p.files.every((f) => existsSync(join(presetRoot, p.dst, f))))
+  ok(copied, '...and the preset copy still happens (the version probe gates nothing)')
+  ok(!logs.some((l) => l.includes('preset install/update failed')), 'the timeout is handled as a fallback, not as an error')
+
+  // the timeout must NOT replace a working probe: a prompt service still supplies the version
+  const quick = run({ listBundles: async () => [{ name: '@deepseek-ai/dsh-base', version: '0.2.0-rc.2' }] })
+  await mod.apply(quick.ctx)
+  ok(quick.logs.some((l) => l.includes('0.2.0-rc.2')),
+    'a prompt listBundles() still supplies the version (the timeout is a fallback, not a replacement)',
+    quick.logs.filter((l) => l.includes('source')).join(' | ').slice(0, 160))
+  rmSync(tmp, { recursive: true, force: true })
+}
+
 console.log('')
 console.log('=== INSTALLER COMPAT: ' + passed + ' passed, ' + failed + ' failed ===')
 if (failed) { for (const f of failures) console.error('  - ' + f); process.exit(1) }

package/tests/audit-installer-policy.test.mjs

@@ -23,7 +23,7 @@
 //                        (_oneoff/probe-installer-policy.mjs) uses this to prove these assertions
 //                        really do detect the previous, edit-preserving policy.
 // ============================================================================================
-import { mkdtempSync, mkdirSync, readFileSync, writeFileSync, appendFileSync, existsSync, rmSync, cpSync, readdirSync } from 'node:fs'
+import { mkdtempSync, mkdirSync, readFileSync, writeFileSync, appendFileSync, existsSync, rmSync, cpSync, readdirSync, statSync, symlinkSync } from 'node:fs'
 import { createHash } from 'node:crypto'
 import { tmpdir } from 'node:os'
 import { join, dirname, resolve } from 'node:path'
@@ -43,10 +43,15 @@ function ok(cond, label, detail) {
   return false
 }
 
-/** A throwaway copy of the package at a chosen version; every managed file is version-marked. */
-function buildPackage(version, dir) {
+/**
+ * A throwaway copy of the package at a chosen version; every managed file is version-marked.
+ * `transform` (optional) rewrites the copied installer source — used by §14 to build the package
+ * that DROPS a preset, which no shipped package can express.
+ */
+function buildPackage(version, dir, transform) {
   mkdirSync(dir, { recursive: true })
-  cpSync(INSTALLER_SRC, join(dir, 'installer.js'))
+  if (typeof transform === 'function') writeFileSync(join(dir, 'installer.js'), transform(readFileSync(INSTALLER_SRC, 'utf8')))
+  else cpSync(INSTALLER_SRC, join(dir, 'installer.js'))
   writeFileSync(join(dir, 'package.json'), JSON.stringify({
     name: 'dsh-vibe-math', version, type: 'module', dsh: { bundle: { patch: './cordis.patch.yml' } },
   }, null, 2))
@@ -253,6 +258,226 @@ console.log('=== 9. a recorded version NEWER than this package (a downgrade) say
   ok(!logs.some((l) => l.includes('preset install/update failed')), 'apply() swallowed no failure')
 }
 
+// ============================================================================================
+// The Round-B machinery findings. Each of these sections was RED before its fix; see
+// _oneoff/probe-installer-policy.mjs and _oneoff/rC-probe-mechanism-sensitivity.mjs for the
+// sensitivity runs (the shipped suite must be green while the previous logic is red ON THE NAMED
+// ASSERTION).
+// ============================================================================================
+
+// fresh home + helpers for the sections below, so the edits accumulated above cannot leak in
+// (the readers never throw: a mutant that deletes or half-writes a file must show up as a FAIL on
+// the assertion that names it, not as a crashed suite)
+const readText = (p) => { try { return readFileSync(p, 'utf8') } catch (e) { return null } }
+const readJson = (p) => { try { return JSON.parse(readFileSync(p, 'utf8')) } catch (e) { return null } }
+const tmpHome = (n) => {
+  const home = join(tmp, 'dshhome' + n)
+  mkdirSync(home, { recursive: true })
+  const root = join(home, '.agent-presets')
+  return {
+    home, root,
+    state: join(root, '.vibe-math-installed.json'),
+    backup: join(root, '.vibe-math-backup'),
+    at: (p, f) => join(root, p.dst, f),
+    isCopyOf: (p, f, from) => {
+      try { return readFileSync(join(root, p.dst, f)).equals(readFileSync(join(from, p.src, f))) } catch (e) { return false }
+    },
+  }
+}
+
+console.log('=== 10. preset writes are ATOMIC: a failed write cannot touch the destination ===')
+{
+  const H = tmpHome('10')
+  await applyFrom(pkgA, H.home, [])
+  const target = { p: PRESETS[1], f: 'preset.yml' }
+  const userBytes = Buffer.from('# USER EDIT (must survive a failed write)\n')
+  writeFileSync(H.at(target.p, target.f), userBytes)
+  // `writePresetFile` writes `<dest>.<pid>.<seq>.vibe-math-tmp` and renames it over the destination,
+  // so a DIRECTORY squatting on that temp path makes the temp write fail while the destination stays
+  // untouched. An in-place `writeFileSync(dest)` would not care: it would overwrite the user's bytes
+  // and log nothing. The squat covers every sequence number a full run can use.
+  const MANY = 32
+  const squat = (n) => H.at(target.p, target.f) + '.' + process.pid + '.' + n + '.vibe-math-tmp'
+  for (let n = 0; n < MANY; n++) mkdirSync(squat(n), { recursive: true })
+  const logs = await applyFrom(pkgB, H.home, [])
+  ok(readText(H.at(target.p, target.f)) === userBytes.toString(),
+    'a failed preset write leaves the destination byte-for-byte intact (tmp+rename, never in place)')
+  ok(logs.some((l) => l.includes('preset install/update failed')),
+    '...and the failure is reported instead of being swallowed', logs.filter((l) => l.includes('failed')).join(' | ').slice(0, 200))
+  ok((readJson(H.state) || {}).version === '1.0.0',
+    'the state still describes the bytes that are actually on disk, so the next boot self-heals')
+  for (let n = 0; n < MANY; n++) rmSync(squat(n), { recursive: true, force: true })
+  await applyFrom(pkgB, H.home, [])
+  ok(H.isCopyOf(target.p, target.f, pkgB), 'with the obstruction gone the next boot replaces the file normally')
+  ok((readJson(H.state) || {}).version === '2.0.0', '...and records the new version')
+  const leftovers = []
+  const walk = (dir) => {
+    for (const e of readdirSync(dir, { withFileTypes: true })) {
+      const p = join(dir, e.name)
+      if (e.isDirectory()) walk(p)
+      else if (e.name.endsWith('.vibe-math-tmp')) leftovers.push(p)
+    }
+  }
+  walk(H.root)
+  ok(leftovers.length === 0, 'no `.vibe-math-tmp` file is left behind by a clean run', leftovers.join(', '))
+}
+
+console.log('=== 11. the state file is not rewritten (or even touched) when nothing changed ===')
+{
+  const H = tmpHome('11')
+  await applyFrom(pkgA, H.home, [])
+  const before = readText(H.state)
+  const mtime = statSync(H.state).mtimeMs
+  await new Promise((r) => setTimeout(r, 30))
+  await applyFrom(pkgA, H.home, [])
+  ok(readText(H.state) === before, 'a same-version boot leaves the state file byte-identical (no churn)')
+  ok(statSync(H.state).mtimeMs === mtime, '...and does not move its mtime either')
+  // ...but a same-version boot that LEARNS something (a file was edited) must record it
+  appendFileSync(H.at(PRESETS[0], 'preset.yml'), '\n# USER EDIT\n')
+  await applyFrom(pkgA, H.home, [])
+  const after = readJson(H.state) || {}
+  ok(readText(H.state) !== before, 'a same-version boot that learns something DOES rewrite the state')
+  ok(after.files && after.files[PRESETS[0].src + '/preset.yml'] && after.files[PRESETS[0].src + '/preset.yml'].provenance === 'user',
+    'the drift is recorded as user-owned — by the real code path (the audit found this value was never written)')
+}
+
+console.log('=== 12. a legacy hash-less record is reported as UNKNOWN, never as a proven edit ===')
+{
+  const H = tmpHome('12')
+  await applyFrom(pkgA, H.home, [])
+  const state = readJson(H.state) || { files: {} }
+  delete state.files[PRESETS[2].src + '/preset.yml'].hash // the shape a pre-hash installer wrote
+  writeFileSync(H.state, JSON.stringify(state, null, 2) + '\n')
+  appendFileSync(H.at(PRESETS[2], 'preset.yml'), '\n# edit while the recorded hash is unknown\n')
+  const editBytes = readText(H.at(PRESETS[2], 'preset.yml'))
+  const logs = await applyFrom(pkgB, H.home, [])
+  ok(logs.some((l) => l.includes('没有哈希')),
+    'the file whose previous hash is unknown is reported as "cannot tell whether you changed it"')
+  ok(!logs.some((l) => l.includes('被改过')),
+    '...and is NOT called an edit the installer can prove', logs.filter((l) => l.includes('被改过')).join(' | '))
+  const backup = join(H.backup, '1.0.0', PRESETS[2].dst, 'preset.yml')
+  ok(existsSync(backup) && readText(backup) === editBytes,
+    '...while its bytes are still copied to the backup root before the replacement')
+}
+
+console.log('=== 13. deleting a file with a dropped preset backs it up FIRST and names it ===')
+{
+  const H = tmpHome('13')
+  await applyFrom(pkgA, H.home, [])
+  mkdirSync(join(H.root, 'vibe-math-v1'), { recursive: true })
+  writeFileSync(join(H.root, 'vibe-math-v1', 'legacy.js'), 'MY VALUABLE EDIT\n')
+  writeFileSync(join(H.root, 'vibe-math-v1', 'stock.yml'), 'package bytes\n')
+  const state = readJson(H.state) || { files: {} }
+  state.files['vibe-math-v1/legacy.js'] = { hash: sha('the bytes the installer wrote long ago\n'), provenance: 'package' }
+  state.files['vibe-math-v1/stock.yml'] = { hash: sha('package bytes\n'), provenance: 'package' }
+  writeFileSync(H.state, JSON.stringify(state, null, 2) + '\n')
+  const logs = await applyFrom(pkgA, H.home, [])
+  ok(!existsSync(join(H.root, 'vibe-math-v1', 'legacy.js')), 'the changed file of a dropped preset is removed (the preset is gone)')
+  const backup = join(H.backup, '1.0.0', 'vibe-math-v1', 'legacy.js')
+  ok(existsSync(backup) && readText(backup) === 'MY VALUABLE EDIT\n',
+    '...AFTER its bytes were copied to .vibe-math-backup/<fromVersion>/<preset>/<file>')
+  ok(logs.some((l) => l.includes('vibe-math-v1/legacy.js') && l.includes('.vibe-math-backup')),
+    '...and the log names both the file it deleted and where the copy is')
+  ok(!existsSync(join(H.backup, '1.0.0', 'vibe-math-v1', 'stock.yml')),
+    'a file that still matches its recorded hash is deleted WITHOUT a backup (it was the package copy)')
+  ok(logs.some((l) => l.includes('仍是本安装器写入的字节')), '...and that is stated in the log')
+}
+
+console.log('=== 14. a user edit inside a preset a NEWER package drops is KEPT ===')
+{
+  const H = tmpHome('14')
+  const edited = { p: PRESETS[1], f: 'agent.cordis.yml' }
+  await applyFrom(pkgA, H.home, [])
+  appendFileSync(H.at(edited.p, edited.f), '\n# MY EDIT\n')
+  await applyFrom(pkgA, H.home, [])
+  const recorded = (readJson(H.state) || {}).files || {}
+  ok(recorded[edited.p.src + '/' + edited.f] && recorded[edited.p.src + '/' + edited.f].provenance === 'user',
+    'the same-version edit is recorded as user-owned before the preset is dropped')
+  // "a newer package no longer ships this preset": rename its src in the copied installer, so the copy
+  // loop cannot rebuild it and the old keys become stale — exactly what the cleanup must handle.
+  const dropper = buildPackage('2.0.0', join(tmp, 'pkg-dropper'),
+    (src) => src.replace("src: 'vibe-math-v3',", "src: 'vibe-math-v3-dropped',"))
+  const logs = await applyFrom(dropper, H.home, [])
+  ok(existsSync(H.at(edited.p, edited.f)), 'the edited file of the dropped preset SURVIVES')
+  ok((readText(H.at(edited.p, edited.f)) || '').includes('MY EDIT'), '...with the user\'s bytes intact')
+  ok(!existsSync(H.at(edited.p, 'preset.yml')), 'the unedited files of the dropped preset are still removed')
+  ok(logs.some((l) => l.includes('记为用户所有的文件被保留')), '...and the log says the user-owned file was kept')
+}
+
+console.log('=== 15. a failed state write is reported (not swallowed), and does not abort the run ===')
+{
+  const H = tmpHome('15')
+  await applyFrom(pkgA, H.home, [])
+  appendFileSync(H.at(PRESETS[0], 'preset.yml'), '\n# USER EDIT (the state must be updated)\n')
+  // the first state write of a fresh module instance uses sequence 0: squat that exact temp path
+  mkdirSync(H.state + '.' + process.pid + '.0.tmp', { recursive: true })
+  const logs = await applyFrom(pkgA, H.home, [])
+  ok(logs.some((l) => l.includes('状态文件写入失败')),
+    'a failed state write is REPORTED (it used to fail silently)', logs.filter((l) => l.includes('写入失败')).join(' | ').slice(0, 160))
+  ok(!logs.some((l) => l.includes('preset install/update failed')), '...without aborting the preset step')
+  ok((readJson(H.state) || {}).version === '1.0.0',
+    'the previous state file is still parseable (tmp+rename left no half-written file)')
+  rmSync(H.state + '.' + process.pid + '.0.tmp', { recursive: true, force: true })
+  await applyFrom(pkgA, H.home, [])
+  const healed = ((readJson(H.state) || {}).files || {})[PRESETS[0].src + '/preset.yml'] || {}
+  ok(healed.provenance === 'user',
+    'the next boot records what the failed write lost (self-healing)')
+  ok(!existsSync(H.state + '.' + process.pid + '.0.tmp'), 'the temp path is free again after the successful write')
+}
+
+console.log('=== 16. an UNREADABLE stale file is not deleted (there is no backup it could make) ===')
+{
+  const H = tmpHome('16')
+  await applyFrom(pkgA, H.home, [])
+  const staleDir = join(H.root, 'vibe-math-v1')
+  mkdirSync(staleDir, { recursive: true })
+  // A directory junction sitting at the stale FILE path: existsSync() is true, readFileSync()
+  // throws (EISDIR), and unlinkSync() WOULD succeed — exactly the shape the policy must refuse.
+  // (POSIX ignores the 'junction' type and makes a plain symlink to the directory, which behaves
+  // identically here.) The previous code unlinked it with no backup; the rule is now
+  // "back up before deleting, or do not delete".
+  const target = join(tmp, 'unreadable-target-16')
+  mkdirSync(target, { recursive: true })
+  symlinkSync(target, join(staleDir, 'legacy.js'), 'junction')
+  const state = readJson(H.state) || { files: {} }
+  state.files['vibe-math-v1/legacy.js'] = { hash: sha('bytes this installer wrote long ago\n'), provenance: 'package' }
+  writeFileSync(H.state, JSON.stringify(state, null, 2) + '\n')
+  const logs = await applyFrom(pkgA, H.home, [])
+  ok(existsSync(join(staleDir, 'legacy.js')),
+    'a stale file whose bytes cannot be read is KEPT (the delete is skipped, not performed unbacked)')
+  ok(logs.some((l) => l.includes('无法读取')), '...and the log names it as unreadable',
+    logs.filter((l) => l.includes('无法读取')).join(' | ').slice(0, 200))
+  ok(!logs.some((l) => l.includes('被改过')),
+    '...and it is NOT called a proven edit the installer can see', logs.filter((l) => l.includes('被改过')).join(' | '))
+  ok(!logs.some((l) => l.includes('legacy.js') && l.includes('.vibe-math-backup')),
+    '...and no backup is claimed for it (there were no bytes to back up)')
+  ok(existsSync(staleDir), 'the stale preset directory is kept too, while the file inside it is kept')
+}
+
+console.log('=== 16b. a stale file whose BACKUP FAILS is kept, not deleted unbacked ===')
+{
+  const H = tmpHome('16b')
+  await applyFrom(pkgA, H.home, [])
+  const staleDir = join(H.root, 'vibe-math-v1')
+  mkdirSync(staleDir, { recursive: true })
+  writeFileSync(join(staleDir, 'legacy.js'), "the user's own bytes\n")
+  // Every backup attempt must fail: a FILE sits where the backup ROOT directory would be, so the
+  // recursive mkdir throws (ENOTDIR/EEXIST). This is the rule's hardest case — the bytes exist,
+  // they differ from the package, and preserving them is impossible — so the delete must be
+  // skipped. (Round C's fix only covered the UNREADABLE case; a failed backup still deleted.)
+  writeFileSync(join(H.root, '.vibe-math-backup'), 'not a directory\n')
+  const state = readJson(H.state) || { files: {} }
+  state.files['vibe-math-v1/legacy.js'] = { hash: sha('bytes this installer wrote long ago\n'), provenance: 'package' }
+  writeFileSync(H.state, JSON.stringify(state, null, 2) + '\n')
+  const logs = await applyFrom(pkgA, H.home, [])
+  ok(existsSync(join(staleDir, 'legacy.js')) && readFileSync(join(staleDir, 'legacy.js'), 'utf8') === "the user's own bytes\n",
+    'a stale file whose BACKUP fails is KEPT (the delete is skipped, not performed unbacked)')
+  ok(logs.some((l) => l.includes('备份失败') && l.includes('跳过删除')),
+    "...and the log reports the failed backup as a skipped delete (not as 'the original was lost')",
+    logs.filter((l) => l.includes('备份失败')).join(' | ').slice(0, 220))
+  rmSync(join(H.root, '.vibe-math-backup'), { force: true })
+}
+
 rmSync(tmp, { recursive: true, force: true })
 
 console.log('')