dsh-vibe-math 2.3.1 → 2.3.2

package/vibe-math-v4//345/256/236/347/216/260/346/226/271/346/241/210.md

@@ -121,7 +121,7 @@ VibeMath/Projects/<project>/
 | **会议** | `vibe_v4_meeting(agenda)` → 向全体发会议 prompt → 收齐发言 → 写 `Shared/meetings/<id>.md` → 广播结论 | 会议用于分工/方向/任务分配/提出验证/表决"是否已解决" |
 | **任务板** | 常驻在会议/留言提议任务 → 框架记 `Shared/taskboard.md`；认领后被唤醒 | 框架只搬运，不决定谁做什么 |
 | **产物沉淀** | `vibe_v4_publish_progress` / `record_proposition` / `record_method` / `record_subproblem` | **必填**：价值程度 / 动机用途计划 / 自身概率估计（框架校验，缺则提示） |
-| **共识验证** | `vibe_v4_propose_verify(targetId)` → 常驻们同意后开辩论 | 独立初评→公开辩论→**全票真/假才入 Verified/**；否则留库附概率 |
+| **共识验证** | 回执字段 `propose_verify: "<id>"`（常规/心跳轮与会议发言都会读取；v4 **没有** `vibe_v4_propose_verify` 这个工具）→ 框架按 FIFO 排队 → 全体独立初评→公开辩论 | 独立初评→公开辩论→**全票真/假才入 Verified/**；否则留库附概率 |
 | **Lean 形式化验证** | `vibe_v4_lean_run` / `vibe_v4_lean_archive` / `vibe_v4_lean_lib` + `formalVerify` 三档开关 | 见 §31；`passed` 后表决对象从"推导是否正确"变成**忠实性**；`require` 档在收口点加门禁 |
 | **停止条件** | 会议中全体常驻对"原问题已解决"投票，**全部同意** → 停止唤醒 | 人工 `abort` 始终可用 |
 | **上下文/compact** | 监测每常驻上下文占比 ≥ 阈值 → 触发 DSH `/compact` | `compactThreshold` 默认 66，可调 |
@@ -793,12 +793,17 @@ else await closeVerify(vs,allTrue)
 | `LEAN_NOT_FOUND` | `resolveExecutable(leanCommand)` 失败（工具链未安装 → 优雅降级） |
 | `LEAN_SPAWN_FAILED` | `spawn` 本身抛错 |
 | `LEAN_RUN_FAILED` | `await handle.done` 抛错 |
-| `LEAN_TIMEOUT` | 非零退出且耗时达到 `graceMs`（超时上限） |
+| `LEAN_TIMEOUT` | 到 `graceMs` 还没跑完：框架自己起一个 `cap` 计时器，到点**主动调用 `handle.terminate()`** 并返回合成结果（契约 §7；不再只依赖宿主的 `graceMs`）。宿主先于本计时器杀进程时，用"非零退出且耗时达到 `cap`"兜底 |
 | `LEAN_FAILED` | 其它非零退出（编译器输出原样返回 ~4KB 尾巴） |
 | `V4_INVALID_ARGUMENT` | 缺 `file`/`kind`/`name`/`target`/`note`；非 `.lean`；越界路径；未知 `kind` |
 | `V4_NOT_FOUND` | `.lean` 文件不存在（越界被拒 ≠ 不存在：两者码不同） |
 | `V4_WRITE_FAILED` | 目标路径写不进去 |
 
+**超时是主动的**：`leanRunFile` 用 `Promise.race([handle.done, ctx.timeout(cap)])`，计时器一响就
+`terminate()`；`done` 先赢则清掉该计时器（插件 runtime 没有全局 `setTimeout`，只能用 `timer` 服务）。
+**唯一可删文件的路径**（§4.1 撤回归档证明）：删除 → **用 `fs` 复核文件真的没了** → 还在就**覆盖为
+撤回说明**（`-- 已撤回（…）`），并把实际走的那条路（`deleted`/`overwritten`/`failed`）写进活动日志。
+
 **绝不抛异常到调度循环**：`leanRunFile` 把每一种失败都变成可读结果；`onResidentEnd` 里的
 `applyFormalReply` 整体包在 try/catch 内（回执处理失败只记 `activityLog`，不影响本轮结算）。
 
@@ -879,22 +884,40 @@ Lean 这一批改动同时做了一次**静态提示词面**审计（`audit-pers
 - **表决者**：不得投 1 或 0；给一个严格介于 0 与 1 之间的值（记为弃权）并在 `reason` 里写清偏差，
   同时用回执 `formal:{decision:'defect', note:'<具体偏差>'}` 记录（`note` 必填，缺则 `V4_INVALID_ARGUMENT`）。
 - **框架**：把该对象**降级为 `attempted`**（无论此前是 `passed` 还是 `blocked`）、清空 `proof`、
-  撤回归档证明 `Verified/Lean/<id>.lean`（`subprocess` 可删则删，否则用"已撤回"说明覆盖）、
-  `note` 记入记录与 `Formal/TODO.md`、活动日志公告。
+  撤回归档证明 `Verified/Lean/<id>.lean`（**删除 → 用 `fs` 复核真的没了 → 还在就覆盖为"已撤回"说明**，
+  见 §31.14）、`note` 记入记录与 `Formal/TODO.md`、活动日志公告。
 - **`require` 档**：降级后 `formalGateOk` 为假 → 本次裁定**不定论**（`deferForFormal`），
-  对象进「形式化待办」，修正形式化并重新跑通后再投票。
+  对象进「形式化待办」，修正形式化并重新跑通后再投票。**`encourage` 档不得声称这一点**（没有门禁，
+  框架撤不回表决）：注入文本与活动日志都按档位分岔，说明"本档没有门禁：请务必给弃权值"。
 - **只有独立于这份 Lean 代码也能确定命题为假**时才投 0，并在 `reason` 里写清独立理由。
 
 同批补齐的提示词硬要求（契约 §6）：注入文本里的工具名**一律全称**（`vibe_v4_lean_*`；缩写
-`lean_archive` 不是注册名）；归档可复用定义/引理**前先跑通**（`run=true` 或先 `vibe_v4_lean_run`），
-跑不通不许进 `Formal/Lib`/`Proved`；**工具链缺失**（`LEAN_NOT_FOUND`）时把代码归档并在 `note`
-写明"宿主无 Lean 工具链"——这算显式阻塞原因，门禁据此放行，不会因为装不了 Lean 而卡死。
+`lean_archive` 不是注册名，连活动日志行也不例外）；归档可复用定义/引理**前先跑通**（`run=true` 或先 `vibe_v4_lean_run`），
+跑不通不许进 `Formal/Lib`/`Proved`；**工具链不可用**时把代码归档并在 `note`
+写明"宿主无 Lean 工具链"——**两个错误码都写出来**（`LEAN_NOT_FOUND`：没有 Lean 可执行文件；
+`NO_SUBPROCESS`：宿主根本不提供 `subprocess` 服务），两者都算显式阻塞原因，门禁据此放行，
+不会因为装不了 Lean 而卡死。
 
-**测试**：`formal-verify-v4.test.mjs` 增至 **226 条断言**（含 `defect` 端到端：降级 + 撤回归档证明 +
+**测试**：`formal-verify-v4.test.mjs` 增至 **262 条断言**（含 `defect` 端到端：降级 + 撤回归档证明 +
 进待办 + `require` 档不定论 + 缺 `note` 被拒；注入文本不得出现缩写工具名、不得出现"偏离 → 0"），
 并新增随包发布的人工复核语料 `prompt-corpus-v4/formal-verify-v4.{json,md}`
-（覆盖 off 无 Lean 文字、encourage、**require**、passed 忠实性分支、平时工作轮、回执契约；
-工作区路径归一化为 `<WS>`、VibeMath 根为 `<VIBEMATH>`，可 diff、无本机路径）。
+（覆盖 off 无 Lean 文字、encourage、**require**、passed 忠实性分支（require/encourage 两种措辞各一份）、
+平时工作轮、回执契约；工作区路径归一化为 `<WS>`、VibeMath 根为 `<VIBEMATH>`，可 diff、无本机路径）。
+
+### 31.14 深审计轮修复（本轮）
+
+逐条对着共同契约复审后修掉的问题（每条都有断言，见 §31.10 的测试表）：
+
+| 问题 | 症状 | 修复 |
+|---|---|---|
+| **`lean_run` 把 `passed` 降级** | `formalSetRun` 硬编码 `status:'attempted'`（注释却写着"`passed`/`blocked` 不被红运行降级"，v2/v5 也是保留语义）：运行中任何一次 `vibe_v4_lean_run {target}` 都会把已通过的记录打回 `attempted` 而 `proof` 指针留着——下一轮表决提示词因此丢掉**忠实性分支**，`require` 档还会对一份已跑绿的归档证明**重新关门禁** | `status: prev.status==='passed'?'passed':(prev.status==='blocked'?'blocked':'attempted')`；断言"红重跑不降级" |
+| **`off` 模式仍写 `State/formal.json`** | `saveAll()` 无条件落这份状态文件：一个从未用过该功能的 run 也会留下 Lean 状态文件（v3 的守卫是 `formalOn()||有记录`） | 仅当 `formalOn()||formalPersisted||有记录/待办` 才写；`formalPersisted` 保证 `start()` 的清零**真的落盘**（否则 resume 会恢复陈旧 `passed`），纯 `off` 会话不产生该文件 |
+| **超时不主动终止** | 只靠宿主的 `graceMs`，从不调 `handle.terminate()`（契约 §7 明写要求），宿主的宽限失效时 Lean 进程会残留 | `Promise.race([handle.done, ctx.timeout(cap)])`，到点 `terminate()` 并返回 `LEAN_TIMEOUT`；`done` 先赢则清掉计时器（插件 runtime 无全局 `setTimeout`，只能用 `timer` 服务） |
+| **撤回归档证明只是"尽力删除"** | 删除失败（无 `subprocess`／shell 假成功／权限）时，被撤回的证明仍停在 `Verified/Lean/<id>.lean`——所有人找"这条结论的证明"的地方；记录却已降级 | 删除 → **用 `fs` 复核文件真的没了** → 还在就**覆盖为 `-- 已撤回（…）` 说明**；返回并播报实际走的那条路（`deleted`/`overwritten`/`failed`） |
+| **`encourage` 档承诺"不定论"** | 忠实性分支与活动日志都无条件写"本次裁定**不定论**"，但只有 `require` 有门禁——这是在承诺框架没有的行为（契约 §4.1-3/§6.1；v5 已分岔） | 按档位分岔：`require` 保留"不定论"；`encourage` 改为"本档没有门禁：请务必给弃权值，以保证本轮无法得出一致结论" |
+| **注入文本只写 `LEAN_NOT_FOUND`** | `NO_SUBPROCESS`（宿主没有 `subprocess` 服务）这条出路没写进提示词，代理会反复重试而不是记阻塞（契约 §6 硬要求 4；v3/v5 都写了两个码） | 同一句话里补上两个码，并断言该句在插件里只出现一份（不按档位复制） |
+| **活动日志里用缩写工具名** | `'… lean_run …'`（不是注册名；host 会把活动日志念给团队） | 改为 `vibe_v4_lean_run`；注入文本扫描面扩到 `State/session.json` 的 `activityLog` |
+| **`实现方案.md` 写了不存在的工具** | §5 表格里的 `vibe_v4_propose_verify(targetId)` 从未注册（验证对象靠回执字段 `propose_verify`），照着文档找工具会扑空 | 表格改回真实机制（回执字段 → FIFO 排队） |
 
 
 

package/vibe-math-v5/agent.cordis.yml

@@ -109,7 +109,9 @@
           reusable definitions VibeMath/Formal/Lib/; proved lemmas VibeMath/Formal/Proved/.
         - The toolchain knobs leanCommand / leanArgs / leanTimeoutMs are tunable as well
           (e.g. leanCommand='lake' with leanArgs=['env','lean']); a missing Lean binary is
-          reported as LEAN_NOT_FOUND and still lets the code be written and archived.
+          reported as LEAN_NOT_FOUND, a host with no subprocess service as NO_SUBPROCESS
+          (on a timeout the process is terminated first), and in every one of those cases the
+          code can still be written down and archived.
         - vibe_v5_status / vibe_v5_report show the mode, per-object formal status and the
           formalization TODO. The framework never installs Lean and never judges fidelity.
 
@@ -201,7 +203,9 @@
           reusable definitions VibeMath/Formal/Lib/; proved lemmas VibeMath/Formal/Proved/.
         - The toolchain knobs leanCommand / leanArgs / leanTimeoutMs are tunable as well
           (e.g. leanCommand='lake' with leanArgs=['env','lean']); a missing Lean binary is
-          reported as LEAN_NOT_FOUND and still lets the code be written and archived.
+          reported as LEAN_NOT_FOUND, a host with no subprocess service as NO_SUBPROCESS
+          (on a timeout the process is terminated first), and in every one of those cases the
+          code can still be written down and archived.
         - vibe_v5_status / vibe_v5_report show the mode, per-object formal status and the
           formalization TODO. The framework never installs Lean and never judges fidelity.
 

package/vibe-math-v5/vibe-math-v5.js

@@ -1714,10 +1714,39 @@ export function apply(ctx) {
         return { ok: false, code: 'LEAN_SPAWN_FAILED', message: String((e && e.message) || e), file: rel, ms: now() - started }
       }
       let outcome
+      // docs/formal-verification.md §7: a TIMEOUT must actually TERMINATE the process —
+      // `graceMs` is only a request to the host, so relying on it alone could leave a runaway
+      // Lean (or a host that ignores graceMs) alive while we report LEAN_TIMEOUT. Race `done`
+      // against a `cap` timer that calls `handle.terminate()`, exactly like v2/v3/v4. The
+      // timer disposer runs in BOTH outcomes, so a settled run never leaks a timer.
+      let timerDisposer = null
+      let timedOut = false
+      // A `done` that settles AFTER the timeout won the race must not surface as an unhandled
+      // rejection; the guarded `ran` promise is what the race uses, so the chain is attached
+      // once and never re-created after it may already have rejected.
+      const ran = Promise.resolve(handle.done).then(
+        (v) => ({ settled: true, value: v }),
+        (e) => ({ settled: false, error: e }))
       try {
-        outcome = await handle.done
+        const r = await Promise.race([
+          ran,
+          new Promise((resolve) => {
+            timerDisposer = ctx.timeout(() => {
+              timedOut = true
+              try { if (typeof handle.terminate === 'function') handle.terminate() } catch (e) { /* the race result is the report */ }
+              resolve({ settled: true, value: { exitCode: null, signal: 'SIGTERM' } })
+            }, cap)
+          }),
+        ])
+        if (r.settled) outcome = r.value
+        else throw r.error
       } catch (e) {
+        if (timerDisposer) { try { timerDisposer() } catch (e2) { /* already settled */ } }
         return { ok: false, code: 'LEAN_RUN_FAILED', message: String((e && e.message) || e), file: rel, ms: now() - started }
+      } finally {
+        // `done`/error wins -> the timer must not fire later. When the TIMEOUT won, the timer
+        // has already fired and disposing it is a no-op, so this is safe in either order.
+        if (timerDisposer) { try { timerDisposer() } catch (e) { /* already settled */ } }
       }
       let out = '', err = ''
       try { if (handle.collected && handle.collected.stdout) out = handle.collected.stdout.readFrom(0).text } catch (e) { /* best effort */ }
@@ -1729,8 +1758,8 @@ export function apply(ctx) {
         ok, exitCode, signal: (outcome && outcome.signal) || null, ms,
         command: argv.join(' '), file: rel,
         stdout: tail(out, 4000), stderr: tail(err, 4000),
-        timedOut: ms >= cap,
-        code: ok ? undefined : (ms >= cap ? 'LEAN_TIMEOUT' : 'LEAN_FAILED'),
+        timedOut: timedOut || ms >= cap,
+        code: ok ? undefined : ((timedOut || ms >= cap) ? 'LEAN_TIMEOUT' : 'LEAN_FAILED'),
       }
     }
     async function formalSetRun(target, run) {
@@ -1787,8 +1816,13 @@ export function apply(ctx) {
       await putFormal(t, formalOf(t), list)
       await writeFormalTodo()
       await writeFormalIndex()
+      // `removeArchivedProof` can fail on a host whose shell cannot delete AND whose
+      // overwrite also fails. The record is downgraded either way, so say it out loud:
+      // otherwise the stale file stays at the exact path everyone looks for proofs, and
+      // nothing in any prompt or index would disclose that the withdrawal was incomplete.
+      const stillThere = removed ? [] : ['｜⚠ 归档证明 ', proofRel, ' 未能撤回（宿主删除与覆盖均失败）；记录已降级，请不要把它当作该对象的证明。']
       await saveChatLine('【形式化】' + (memberId || '成员') + ' 认定 ' + t + ' 的形式化**不忠实**：' + why
-        + ' —— 已撤回「已通过」状态并从 Verified/Lean/ 删除归档证明；请修正形式化、重新跑通后再投票。')
+        + ' —— 已撤回「已通过」状态' + (removed ? '并从 Verified/Lean/ 删除归档证明' : '') + '；请修正形式化、重新跑通后再投票。' + stillThere.join(''))
       return { ok: true, target: t, status: 'attempted', removed }
     }
     function formalPromptBlock(target) {
@@ -1811,9 +1845,12 @@ export function apply(ctx) {
         L.push("      ② 用回执 formal:{decision:'defect', note:'<具体偏差>'} 记录它。框架会撤回这条证明的")
         // Only `require` actually GATES the conclusion; in `encourage` the framework still
         // withdraws the proof (and records the defect) but must not promise a hold it cannot
-        // enforce — the voter's own abstention is what keeps the ballot from concluding.
+        // enforce. Say the same thing v2/v3/v4 say instead of silently omitting it: the
+        // voter must know that the ABSTENTION is what keeps this round from concluding.
         L.push('         「已通过」状态（降级为 attempted、删除归档证明、写入形式化待办）'
-          + (mode === 'require' ? '，本次裁定**不定论**；' : '；'))
+          + (mode === 'require'
+            ? '，本次裁定**不定论**；'
+            : '。本档没有门禁：请务必给一个严格介于 0 与 1 之间的弃权值，以保证本轮无法得出一致结论；'))
         L.push('         修正形式化并重新跑通后再投票。')
         L.push('  ▸ 只有当你**独立于这份 Lean 代码**也能确定命题为假时，才投 0，并在 reason 里写清独立理由。')
       } else if (rec.status === 'blocked') {
@@ -1834,7 +1871,7 @@ export function apply(ctx) {
           L.push("  · 若你判断不值得或无法形式化，可以不做，但请在回执的 formal 字段写明难度判断（decision='blocked' 时必须写明 note）。")
         }
         L.push('  · 归档可复用定义/引理前先跑通（vibe_v5_lean_archive run=true 或先 vibe_v5_lean_run）；跑不通不要入库。')
-        L.push('  · 宿主没有 Lean 工具链（LEAN_NOT_FOUND）时：把代码写下来归档，并在回执的 note 里写明"宿主无 Lean 工具链"——这算显式阻塞原因，定论门禁可以据此放行。')
+        L.push('  · 宿主没有 Lean 工具链（LEAN_NOT_FOUND）或根本没有 subprocess 服务（NO_SUBPROCESS）时：把代码写下来归档，并在回执的 note 里写明"宿主无 Lean 工具链"——这两种都算显式阻塞原因，定论门禁可以据此放行。')
       }
       return L.join('\n')
     }
@@ -1983,7 +2020,12 @@ export function apply(ctx) {
         const rec = Object.assign({}, prev, {
           status: passed ? 'passed' : 'attempted',
           file: workRel,
-          proof: passed ? 'Verified/Lean/' + target + '.lean' : (prev.proof || ''),
+          // A FAILED re-archive must also drop the pointer to the previous proof: the code
+          // that proof referred to has just been overwritten by `body` (the file that failed),
+          // so keeping it would advertise `Verified/Lean/<id>.lean` as this object's proof
+          // while the object's own last run is a failure — a self-contradicting record, and
+          // a pointer that the reviewer's `formalPromptBlock(rec.proof)` would print.
+          proof: passed ? 'Verified/Lean/' + target + '.lean' : '',
           decision: 'used',
           note: String(args.note || prev.note || ''),
           run: { at: now(), ok: !!run.ok, exitCode: run.exitCode === undefined ? null : run.exitCode, ms: run.ms || 0, stdoutTail: tail(run.stdout, 800), stderrTail: tail(run.stderr, 800) },
@@ -3455,7 +3497,11 @@ export function apply(ctx) {
       // (4b) Lean formalization signal — the mandatory difficulty judgement. This is the
       // path that matters in practice: a member that never calls a Lean tool still has to
       // say "used / blocked", and `require` mode refuses to conclude without it.
-      if (p.formal && typeof p.formal === 'object') {
+      //
+      // `formalOn()` gates it: off mode is a TRUE no-op, and the field is not even offered in the
+      // reply contract there, so a stray / stale / hallucinated reply must not create Lean state.
+      // (The TOOLS stay usable in off mode on purpose — a tool call is deliberate.)
+      if (formalOn() && p.formal && typeof p.formal === 'object') {
         const f = p.formal
         const target = idSafe(String(f.target || ''))
         if (target) {
@@ -4212,7 +4258,7 @@ export function apply(ctx) {
   // dynamic registration would depend on a runtime knob and break the effect discipline),
   // while the MODE only decides whether the framework TELLS members about them. In 'off'
   // mode they still work if a human or agent calls them deliberately.
-  registerTool('vibe_v5_lean_run', '(member) Execute the Lean toolchain on one .lean file inside the workspace and report the result. Never throws: a missing toolchain returns LEAN_NOT_FOUND, a non-zero exit returns the compiler output. Pass target=<object id> to also record the run against that object.', objParams({ file: S, target: S, timeout_ms: I }, ['file']), (s, a, x) => s.leanRunTool(s.memberIdOfAgent(x), a))
+  registerTool('vibe_v5_lean_run', '(member) Execute the Lean toolchain on one .lean file inside the workspace and report the result. Never throws: a host with no subprocess service returns NO_SUBPROCESS and a missing toolchain returns LEAN_NOT_FOUND (in both cases the code can still be written down with vibe_v5_lean_archive), a timeout terminates the process and returns LEAN_TIMEOUT, and a non-zero exit returns the compiler output. Pass target=<object id> to also record the run against that object.', objParams({ file: S, target: S, timeout_ms: I }, ['file']), (s, a, x) => s.leanRunTool(s.memberIdOfAgent(x), a))
   registerTool('vibe_v5_lean_archive', '(member) Archive Lean code. kind="def": a REUSABLE definition/object/assumption → the global cross-project library (Formal/Lib). kind="lemma": a machine-checked lemma → Formal/Proved. kind="proof": the formal proof of a project object → Formal/<target>.lean, and (when the run passes) also Verified/Lean/<target>.lean, marking the object Lean-passed. kind="blocked": record an explicit, reasoned "cannot/not worth formalizing" decision (note required).', objParams({ kind: { type: 'string', enum: ['def', 'lemma', 'proof', 'blocked'] }, name: S, target: S, content: S, from: S, note: S, run: B }, ['kind']), (s, a, x) => s.leanArchive(s.memberIdOfAgent(x), a))
   registerTool('vibe_v5_lean_lib', '(member) List (and by default rebuild) the Lean reuse library: your institute\'s Formal/Index.md, plus the global cross-project Formal/Lib and Formal/Proved indexes. Look here BEFORE writing a new definition so you reuse instead of redefining.', objParams({ refresh: B }), async (s, a) => {
     const r = a && a.refresh === false ? { lib: null, proved: null, objects: Object.keys(s.formalRecords()).length } : await s.rebuildLeanLibIndexes()

package/vibe-math-v5//345/256/236/347/216/260/346/226/271/346/241/210.md

@@ -1092,6 +1092,11 @@ Progress/，不要从头再来"，**不得**复用 `【入职首轮】` 与"你
 
 - `off`（默认）——提示词里不出现任何 Lean 内容，验证流程与门禁完全不变（`off` 是**真正的无操作**，
   这是测试第 1 条断言）；三个 Lean 工具仍然注册（注册是静态的），只是框架不告诉成员它们存在。
+  `off` 约束的是**框架主动做的事**：它不注入 Lean 文本、不设门禁、不改验证流程，回执里的 `formal`
+  通道在 `off` 档**完全不解析**（一个残留/幻觉出来的 `formal` 字段不会产生任何形式化状态）。
+  工具本身在任何档位下都照常执行并照实记录——**"主动调用是一个明确的动作"**，不会被静默忽略；
+  要"连工具也不留痕迹"，请用 `leanCommand` 指向一个不存在的可执行文件（`LEAN_NOT_FOUND`），
+  而不是指望 `off` 去拦截人的显式调用。
 - `encourage`——验证提示词给出"按实现难度决定是否形式化"的要求与工具/路径；
   常规轮与心跳轮给出"顺手形式化可复用对象"的要求；**不设门禁**。
 - `require`——同样的提示词（语气为必须），**加门禁**：真/假结论必须
@@ -1122,24 +1127,39 @@ Progress/，不要从头再来"，**不得**复用 `【入职首轮】` 与"你
   `formal:{decision:'defect', note:'<具体偏差>'}` 记录；
 - `recordFidelityDefect` 把该对象**降级为 `attempted`**、清空 `proof`、撤回
   `Verified/Lean/<id>.lean`（`subprocess` 可删则删，否则用"已撤回"说明覆盖，见
-  `removeArchivedProof`）、写入 `Formal/TODO.md` 并群聊公告；
+  `removeArchivedProof`）、写入 `Formal/TODO.md` 并群聊公告；**撤回失败**（宿主既不能删也不能
+  覆盖）时必须在群聊公告里明说"归档证明未能撤回"，不能让一个已被判定不忠实的形式化继续躺在
+  `Verified/Lean/` 里而无人知晓；
 - `require` 档下这次裁定**不定论**，对象进「形式化待办」，修正形式化并重新跑通后再投票；
+  `encourage` 档**没有门禁**，因此注入文本必须明说"本档没有门禁：请务必给一个严格介于 0 与 1
+  之间的弃权值，以保证本轮无法得出一致结论"——不能只把"框架会搁置本次裁定"这句删掉了事；
+- 重新 `lean_archive kind='proof'` 但**运行未通过**时，`proof` 指针必须一并清空：工作文件已经被
+  这次失败的代码覆盖，旧指针指向的文件不再是该对象的证明（否则 `Formal/Index.md` 会同时报告
+  「运行 fail」和一条归档证明路径）；
 - 只有表决者**独立于这份 Lean 代码**也能确定命题为假时才投 0。
 
 **提示词硬要求（契约 §6，四套一致）**：注入文本里的工具名**一律全称**
 （`vibe_v5_lean_*`；缩写 `lean_archive` 不是注册名，代理照抄就调用了一个不存在的工具）；
 归档可复用定义/引理**前先跑通**（`run=true` 或先 `lean_run`），跑不通不许入库；
-**工具链缺失**（`LEAN_NOT_FOUND`）时把代码归档并在 `note` 写明"宿主无 Lean 工具链"——
-这算显式阻塞原因，门禁可以据此放行，代理不会因为装不了 Lean 而卡死。
-
-**测试**：`formal-verify-v5.test.mjs`（117 断言，含 `defect` 的端到端路径：降级 + 撤回归档证明 +
-进待办 + `require` 档不定论；以及"注入文本不得出现缩写工具名"），fake-Lean 通过 `subprocess`
-服务注入，因此不需要真的装 Lean；`audit-v5-sensitivity.mjs` 里 9 个专打形式化的探针；
-`prompt-v5-integrity.test.mjs`（588 断言）把 Lean 相关提示词原文写进语料
-（`lean-work` / `lean-verify` / `lean-fidelity` / **`lean-require`** / **`lean-after-defect`**，
-共 70 条提示词），供人工复核"忠实性审查"那段与缺陷撤回后的状态；语料把工作区路径
-**大小写无关**地归一化为 `<WS>`（首版因 Windows 路径大小写差异漏掉了 VibeMath 根的绝对路径，
-语料因此不确定且泄露本机路径——已修）。
+**没有工具链**（`LEAN_NOT_FOUND`）或**宿主没有 subprocess 服务**（`NO_SUBPROCESS`）时把代码
+归档并在 `note` 写明"宿主无 Lean 工具链"——两种都要在注入文本里点名（只认前者的代理会把后者
+当成未知故障反复重试），这算显式阻塞原因，门禁可以据此放行，代理不会因为装不了 Lean 而卡死。
+
+**运行（契约 §7）**：`lean_run` 用 `handle.done` 与 `cap` 毫秒计时器 **race**，超时一侧先调用
+`handle.terminate()`（存在才调）再返回 `LEAN_TIMEOUT`——只给 `graceMs` 是"请求"而非保证，
+runaway 的编译器会在框架已经报告超时之后继续存活；`done` 先到则释放计时器，不泄漏。
+
+**测试**：`formal-verify-v5.test.mjs`（138 断言，含 `defect` 的端到端路径：降级 + 撤回归档证明 +
+进待办 + `require` 档不定论；"注入文本不得出现缩写工具名"；"超时路径真的调用 `terminate()`"；
+"宿主没有 `subprocess` 服务时返回 `NO_SUBPROCESS` 且代码仍能写下来归档"；`encourage` 档的
+弃权措辞），fake-Lean 通过 `subprocess` 服务注入，因此不需要真的装 Lean；
+`audit-formal-sensitivity.mjs --only=v5` 里 13 个专打形式化的探针；
+`prompt-v5-integrity.test.mjs`（595 断言）把 Lean 相关提示词原文写进语料
+（`lean-work` / `lean-verify` / `lean-fidelity` / **`lean-require`** / **`lean-after-defect`** /
+**`lean-tool-hint`**，共 71 条提示词），供人工复核"忠实性审查"那段、缺陷撤回后的状态、
+以及三个 Lean 工具自己的 `hint` / 失败消息；语料把工作区路径**大小写无关**地归一化为 `<WS>`、
+把 VibeMath 根归一化为 **`<VIBEMATH>`**（与 v2/v3/v4 的语料一致，可并排 diff；首版因 Windows
+路径大小写差异漏掉了 VibeMath 根的绝对路径，语料因此不确定且泄露本机路径——已修）。
 
 
 ---
@@ -1184,7 +1204,7 @@ Progress/，不要从头再来"，**不得**复用 `【入职首轮】` 与"你
 
 | 工具 | 参数 | 说明 |
 |---|---|---|
-| `vibe_v5_lean_run` | `{ file, target?, timeout_ms? }` | 在 `subprocess` 服务上执行 Lean，返回 `{ok, exitCode, ms, command, stdout, stderr}`。绝不抛异常：缺工具链 → `LEAN_NOT_FOUND`，超时 → `LEAN_TIMEOUT`，路径越界 → `V5_INVALID_ARGUMENT`。给了 `target` 就把这次运行记到该对象上 |
+| `vibe_v5_lean_run` | `{ file, target?, timeout_ms? }` | 在 `subprocess` 服务上执行 Lean，返回 `{ok, exitCode, ms, command, stdout, stderr}`。绝不抛异常：宿主没有 `subprocess` 服务 → `NO_SUBPROCESS`，缺工具链 → `LEAN_NOT_FOUND`，**超时 → 先 `handle.terminate()` 再返回 `LEAN_TIMEOUT`**，文件不存在 → `V5_NOT_FOUND`，路径越界或非 `.lean` → `V5_INVALID_ARGUMENT`。给了 `target` 就把这次运行记到该对象上 |
 | `vibe_v5_lean_archive` | `{ kind, name?, target?, content?, from?, note?, run? }` | `kind='def'/'lemma'` → 归档到**全局** `VibeMath/Formal/{Lib,Proved}/`；`kind='proof'` → 写 `Formal/<target>.lean`，运行通过则同时写 **`Verified/Lean/<target>.lean`** 并把对象标为 `passed`；`kind='blocked'` → 记录显式难度判断/阻塞原因（`note` 必填） |
 | `vibe_v5_lean_lib` | `{ refresh? }` | **重建并返回**三处索引（本所 `Formal/Index.md`、全局 `Lib/Index.md`、`Proved/Index.md`）与逐对象形式化状态；写新定义前先查重、直接复用 |
 
@@ -1213,6 +1233,13 @@ Progress/，不要从头再来"，**不得**复用 `【入职首轮】` 与"你
 
 Lean 工具另外会返回**非错误码**的失败原因（都属于"可读结果"而非异常）：`NO_SUBPROCESS`（宿主没有 subprocess 服务）、`LEAN_NOT_FOUND`（解析不到 `leanCommand`）、`LEAN_SPAWN_FAILED`、`LEAN_RUN_FAILED`、`LEAN_FAILED`（编译器非零退出）、`LEAN_TIMEOUT`。
 
+> ⚠ **尚未实现的已登记错误码**（本轮审计发现，予以显式登记而非默默留在文档里）：
+> `V5_LEAD_REQUIRED`、`V5_NOT_MEMBER`、`V5_MEMBER_NAME_TAKEN`、`V5_INVALID_MEMBER_NAME`、
+> `V5_MAILBOX_FULL`、`V5_MESSAGE_TOO_LARGE`、`V5_TASK_LIMIT` —— 这些名字在代码里**一次都没有出现**。
+> 原因：v5 的成员 id 由框架分配（成员不命名自己），邮箱不做容量上限，任务不做数量上限，
+> 职权不足一律用 `V5_NOT_ACADEMICIAN` / `V5_MEMBER_NOT_FOUND`。**新增调用点时必须二选一**：
+> 要么真的用上该错误码，要么把它从本节删掉（不要留一个"文档里有、代码里没有"的契约）。
+
 ### 15.4 每轮回执契约（`replySpec`）
 
 每轮提示词末尾都附一份 JSON 契约。**凡框架实际处理的字段，必须在此出现**，否则该通道对成员

package/vibe-math-v5//346/236/266/346/236/204/345/233/276.md

@@ -36,7 +36,7 @@ flowchart TB
     end
 
     subgraph L3["💾 状态与产物"]
-        PROJ["会话日志的 host-only 投影单元<br/>键 vibeMathV5<br/>11 类事件 · 纯折叠 applyV5Event"]
+        PROJ["会话日志的 host-only 投影单元<br/>键 vibeMathV5<br/>12 类事件 · 纯折叠 applyV5Event"]
         FS["人可读产物<br/>Members/&lt;id&gt;/* · Shared/* · Verified/ · Problems/"]
     end
 
@@ -176,6 +176,8 @@ stateDiagram-v2
     attempted --> passed : lean_archive kind='proof' 且该文件运行 exit 0
     attempted --> blocked : lean_archive kind='blocked'（note 必填）
     none --> blocked : 同上
+    passed --> attempted : 回执 formal.decision='defect'（忠实性缺陷）<br/>清空 proof · 撤回 Verified/Lean/&lt;id&gt;.lean · 写 Formal/TODO.md · 公告
+    blocked --> attempted : 同上（缺陷优先于阻塞判断）
     passed --> [*] : 归档到 Verified/Lean/&lt;id&gt;.lean
     blocked --> [*] : 记入 Formal/Index.md 的难度判断列
 
@@ -184,6 +186,12 @@ stateDiagram-v2
       「你不需要重新检查推导，
       任务是忠实性审查」
     end note
+    note left of attempted
+      忠实性缺陷不是"命题为假"（契约 §4.1）：
+      表决者不得投 0，只给 0 与 1 之间的弃权值；
+      require 档本轮因此不定论（formal-required），
+      encourage 档没有门禁，靠该弃权值阻止一致结论。
+    end note
 ```
 
 ```mermaid
@@ -201,9 +209,14 @@ flowchart TB
     style OK2 fill:#eef7f1,stroke:#1f7a52
 ```
 
-**三档**：`off`（默认，**真正的无操作**）｜`encourage`（按实现难度自行决定，不设门禁）｜
+**三档**：`off`（默认，**真正的无操作**：不注入任何 Lean 文本、不设门禁、不改验证流程）｜
+`encourage`（按实现难度自行决定，不设门禁）｜
 `require`（真/假结论必须先有 Lean 通过或**显式、可审计**的阻塞记录）。
 
+> `off` 的"无操作"约束的是**框架主动做的事**（提示词、门禁、验证流程、回执里的 formal 通道）。
+> 三个 Lean 工具仍然无条件注册、任何档位下都可被代理或人**主动**调用，并且会照实执行与记录
+> ——"调用是一个明确的动作，不会被静默忽略"。
+
 **"根据实现难度决定不做"是被允许的，但必须说出来**：`blocked` 记录要求 `note` 非空 ——
 决定权在代理，静默跳过不行。
 
@@ -419,6 +432,7 @@ flowchart LR
 | Lean 通过后，审查对象切换为**忠实性**（"你不需要重新检查推导"） | `formal-verify-v5.test.mjs` |
 | `require` 模式：无形式化记录的真/假结论被记为未定论 + 形式化待办，不写 `Verified/` | `formal-verify-v5.test.mjs` |
 | 「因难度决定不做形式化」必须显式记录原因（`note` 非空） | `formal-verify-v5.test.mjs` |
+| 忠实性缺陷**不得**记成"命题为假"：撤回 `passed`、删除 `Verified/Lean/<id>.lean`、写待办，`require` 档不定论 | `formal-verify-v5.test.mjs` |
 | 命题的证明归档到 `Verified/Lean/<id>.lean`；可复用定义归档到**跨项目** `Formal/Lib/` | `formal-verify-v5.test.mjs` |
 | Lean 路径守卫按词法归一 `..`（字符串前缀检查会被穿越绕过） | `formal-verify-v5.test.mjs` |
 | 解雇是真实的（释放子会话、收回任务） | `selfdrive-v5.mjs` |

package//347/244/272/344/276/213/345/233/276//346/241/206/346/236/266/345/233/276-v5.svg

@@ -103,11 +103,12 @@
 <text x="1430.3333333333333" y="743.3" font-size="10.5" font-weight="400" fill="#2c4557" text-anchor="middle">院士/研究员可雇自己的临时工</text>
 <text x="1430.3333333333333" y="759.8" font-size="10.5" font-weight="400" fill="#2c4557" text-anchor="middle">雇主或院士可真实解雇（释放子会话）</text>
 <text x="1430.3333333333333" y="776.3" font-size="10.5" font-weight="400" fill="#2c4557" text-anchor="middle">代号永不复用 · 按人/全所双配额</text>
-<rect x="248" y="796" width="1410" height="76" rx="10" fill="#ffffff" stroke="#b3202c" stroke-width="1.6"/>
-<text x="953" y="813.8" font-size="12.5" font-weight="700" fill="#10202e" text-anchor="middle">Lean 形式化验证（可调参数 formalVerify = off / encourage / require）</text>
-<text x="953" y="830.3" font-size="10.5" font-weight="400" fill="#2c4557" text-anchor="middle">encourage：验证时按实现难度决定是否形式化；require：真/假结论必须先有「Lean 通过」或显式阻塞记录</text>
-<text x="953" y="846.8" font-size="10.5" font-weight="400" fill="#2c4557" text-anchor="middle">★ 一旦 Lean 通过，审查对象就变了：不再是「推导对不对」，而是「Lean 的定义/对象/条件/假设/结论是否忠实于命题原文」</text>
-<text x="953" y="863.3" font-size="10.5" font-weight="400" fill="#2c4557" text-anchor="middle">归档：证明 → Verified/Lean/&lt;对象&gt;.lean｜可复用定义 → VibeMath/Formal/Lib/｜已证引理 → VibeMath/Formal/Proved/</text>
+<rect x="248" y="796" width="1410" height="90" rx="10" fill="#ffffff" stroke="#b3202c" stroke-width="1.6"/>
+<text x="953" y="812.5" font-size="12.5" font-weight="700" fill="#10202e" text-anchor="middle">Lean 形式化验证（可调参数 formalVerify = off / encourage / require）</text>
+<text x="953" y="829.0" font-size="10.5" font-weight="400" fill="#2c4557" text-anchor="middle">encourage：验证时按实现难度决定是否形式化；require：真/假结论必须先有「Lean 通过」或显式阻塞记录</text>
+<text x="953" y="845.5" font-size="10.5" font-weight="400" fill="#2c4557" text-anchor="middle">★ 一旦 Lean 通过，审查对象就变了：不再是「推导对不对」，而是「Lean 的定义/对象/条件/假设/结论是否忠实于命题原文」</text>
+<text x="953" y="862.0" font-size="10.5" font-weight="400" fill="#2c4557" text-anchor="middle">★ 忠实性缺陷（decision=defect）≠ 命题为假：撤回「已通过」+ 撤回归档证明 + 进「形式化待办」，绝不记成 0/假</text>
+<text x="953" y="878.5" font-size="10.5" font-weight="400" fill="#2c4557" text-anchor="middle">归档：证明 → Verified/Lean/&lt;对象&gt;.lean｜可复用定义 → VibeMath/Formal/Lib/｜已证引理 → VibeMath/Formal/Proved/</text>
 <rect x="248" y="880" width="1410" height="38" rx="10" fill="#ffffff" stroke="#0b6fb8" stroke-width="1.6"/>
 <text x="953" y="903.1" font-size="11.5" font-weight="700" fill="#10202e" text-anchor="middle">调度器优先级：进行中的会议或验证（二者互斥，永不同时）→ 队列中的验证 → 暂存会议 → 已认领/被分派的在办任务（按 activityTimeoutMs 节流）→ 加急邮件 → 群聊摘要 → 停滞自动开会 → 兜底心跳</text>
 <rect x="40" y="964" width="790" height="196" rx="14" fill="#eef7f1" stroke="#1f7a52" stroke-width="2"/>