dsh-vibe-math 2.3.2 → 2.3.4

package/prompt-corpus-v3/formal-verify-v3.md

@@ -4546,3 +4546,407 @@ Reason is MANDATORY and MUST be non-empty; an empty-Reason result (esp. a bare 0
 Reply with ONLY a single JSON object in a ```json code fence, no prose outside it:
 {"Result":0.5,"Reason":"<MANDATORY, non-empty: updated logic chain / counterexample / proof / refutation>","changed":"brief reason if you changed your Result, else null","formal":{"target":"p-fid","decision":"used|blocked|defect","file":"Formal/p-fid.lean","note":"难度判断/阻塞原因/具体偏差"}}
 ```
+
+## [75] spawn · planner:plan-<ID>
+
+```text
+You are the SCHEDULING PLANNER of a multi-agent mathematical research system. Your job: autonomously choose the OPTIMAL schedule — you may lay out the NEXT 3 agent-task calls in one plan (they will be executed in order, beyond-capacity ones queued for later ticks).
+
+CURRENT STATE BRIEF (JSON):
+{
+  "at": "<TIME>",
+  "horizon": 3,
+  "free_slots": <SLOTS>,
+  "maxParallelThreshold": 64,
+  "problems": [],
+  "verify_candidates": [
+    {
+      "rId": "r-p-used",
+      "kind": "proposition",
+      "target": "p-used",
+      "prob": 0.6,
+      "priority": 1
+    },
+    {
+      "rId": "r-p-usedkeep",
+      "kind": "proposition",
+      "target": "p-usedkeep",
+      "prob": 0.6,
+      "priority": 1
+    }
+  ],
+  "active_agents": [],
+  "methods": [],
+  "pending_inventions": 0,
+  "last_plan": null,
+  "recent_events": [
+    {
+      "at": "<TIME>",
+      "event": "plan",
+      "detail": "planner plan-<ID> returned empty plan (no actionable work)"
+    },
+    {
+      "at": "<TIME>",
+      "event": "formal",
+      "detail": "【形式化】c45 的 formal.decision=blocked 未写明 note，已**拒绝**记录（难度判断必须显式、可审计）。"
+    },
+    {
+      "at": "<TIME>",
+      "event": "verdict",
+      "detail": "r-p-nonote = 0.5 (uncertain)"
+    },
+    {
+      "at": "<TIME>",
+      "event": "abort",
+      "detail": "scheduler aborted, 0 child(ren) interrupted"
+    },
+    {
+      "at": "<TIME>",
+      "event": "abort",
+      "detail": "scheduler aborted, 0 child(ren) interrupted"
+    },
+    {
+      "at": "<TIME>",
+      "event": "start",
+      "detail": "scheduler started for project lean-reply（v3：md 知识库 + 规划代理调度 + 方法库）"
+    },
+    {
+      "at": "<TIME>",
+      "event": "verify",
+      "detail": "verification task created for r-p-usedkeep"
+    },
+    {
+      "at": "<TIME>",
+      "event": "formal",
+      "detail": "【形式化】sess-H 为 p-usedkeep 归档形式化证明 Formal/p-usedkeep.lean（运行 **通过**，已归档到 Verified/Lean/p-usedkeep.lean，验证转为忠实性审查）"
+    }
+  ]
+}
+
+ACTION VOCABULARY (code validates every action against hard invariants; invalid actions are dropped):
+- {"action":"spawn","role":"explorer","target":"<qid>","reason":"..."} — problem has no directions yet or all dead (re-derive).
+- {"action":"spawn","role":"solver","target":"<qid>","direction":"<dirId>","reason":"..."} — active direction, needs a solving round.
+- {"action":"spawn","role":"verifier","target":"<rId>","reason":"..."} — verify candidate (from verify_candidates); keep solving AND verifying balanced.
+- {"action":"spawn","role":"method-keeper","reason":"..."} — distill pending inventions / maintain the theory library.
+- {"action":"interrupt","childId":"<childId>","reason":"..."} — stop a running child (direction dead, superseded...).
+- {"action":"promote","target":"<pId>","reason":"..."} — high-value unresolved proposition → judge problem.
+- {"action":"wait","target":"<id>","reason":"..."} — advisory: wait for a dependency.
+
+HARD RULES: never re-schedule verified objects; problems with 依赖未就绪 (依赖就绪=false) should wait unless you explicitly accept a temporary assumption; respect capacity (brief.free_slots); PREFER problems whose dependencies are ready and whose directions have the highest survival; DO NOT forget verification — unresolved solutions/proofs/refutations (verify_candidates) will never be checked unless you schedule a verifier; DO NOT assume a direction is already being worked just because it is shown "active" in a problem — check brief.problems[].running_solver_dirs and brief.active_agents: schedule a solver for a direction ONLY if that direction is NOT in running_solver_dirs (an "active" direction absent from running_solver_dirs is WAITING to be dispatched, not being worked); schedule at most 3 actions.
+Respond with ONLY a single JSON object wrapped in a ```json code fence — no prose:
+{"summary":"one-line plan rationale","plan":[{"action":"...","role":"...","target":"...","direction":"...","childId":"...","reason":"..."}]}
+```
+
+## [76] spawn · verifier:r-p-usedkeep:0
+
+```text
+You are a STRICT peer reviewer verifying one mathematical object. Check it multiple times.
+
+TARGET (r: proposition):
+PROPOSITION (id: p-usedkeep): 已有通过证明后再写一次 used 回执
+
+KNOWLEDGE BASE & DATA MODEL (definition contract you MUST follow):
+
+1) TRUST LAYERS — the single most important rule:
+- Verified/ 中的内容 = 绝对可信（已被验证器判定为真/假并生成只读副本）：可直接引用。
+- Propos/ 中 状态: 已验证·真/假 的命题 = 可信（以 Verified/ 副本为准）。
+- 其余一切（未定论命题、Progress/ 研究日志、Methods/ 中未验证断言、Notes/）= 经验性记录/参考，绝不能当作已成立事实引用。
+- 概率语义：1 = 绝对正确（可当已知事实）；0 = 绝对错误；0 与 1 之间 = 未定论/待验证。
+
+2) OBJECT MODELS（md 卡片，软规范：头部锚点行 + 正文自由叙述）：
+- 问题卡 Problems/<id>.md：{ 标题, ID, 类型:问题, 状态:原始|求解中|等待依赖|已解决|死路, 优先级, 依赖:[], 被依赖:[], 来源:原始|后生, 计划（由调度器按规划代理的计划自动更新：一句话说明下一轮安排）, ## 陈述（完整问题陈述，每个记号/对象都要完整定义）, ## 来源与动机（后生问题：产生流程/动机/如何回填主线）, ## 解法候选（### 解法 N｜标题｜概率X｜状态Y + 叙述式完整解法）}。
+- 命题卡 Propos/<分类>/<id>.md：{ 标题, ID, 类型:命题, 状态:未定论|已验证·真|已验证·假, 概率, 优先级, 依赖:[], ## 陈述（完整）, ## 证明尝试（### 证明 N｜…｜概率X｜状态Y）, ## 证伪尝试（### 证伪 N｜…｜概率X｜状态Y）}。
+- 证明/证伪尝试语义：`## 证明尝试`=为证实而写的论证；`## 证伪尝试`=专门反驳/反例的论证。**失败的"找反例未果"/sanity check 是支持性证据，不属于证伪尝试**；不要写入 `## 证伪尝试`（否则系统会当作待验证的反驳去验证）。对仍未完成的证明/证伪，明确标注缺口而非伪装完成。
+- 方法卡 Methods/<id>.md：{ 标题, ID, 类型:方法, 状态:经验|应用验证|含已验证断言, 可信断言:[]（只允许已进 Verified/ 的 ID）, 上级体系/子方法/相关, 适用场景, ## 核心内容, ## 定义与记号, ## 应用记录, ## 改进历史 }。
+- 收口规则：某个解法/证明/证伪 概率=1 → 问题已解决 / 命题已验证（状态/概率锚点由调度器改写）。
+
+3) FOLDERS：Problems/ 问题清单；Progress/ 研究日志（每问题一个聚合索引 <qid>.md + 每方向一个文件 <qid>/<dirId>.md，按方向按轮续写）；Propos/ 命题库；Methods/ 理论发明库；Verified/ 绝对可信（只读）；Reliable/ 可信参考文献（只读）；Notes/ 自由笔记；Logs/ 审计；State/ 调度器私有——不要读也不要改。
+
+4) OUTPUT QUALITY RULES：完整性、不断章取义——任何输出的问题/命题/结论都要给出完整陈述并补全所依赖的对象/环境/背景定义；引用必须给出处（文件路径 + ID + 锚点/节），事实只引 Verified/；若结论依赖临时假设 p，必须显式写「若 <p 完整陈述> 成立，则：…」。你的机器回复是一个 JSON 对象（```json 围栏内），JSON 之外不要再输出其他文本——任何要写进 md 的内容都通过文件工具写入，不要当作聊天气泡输出。
+
+YOUR PERMISSIONS / CAPABILITIES:
+- Network tools: available; Script/shell tools: available (your actual tool list is enforced by the framework).
+- You may use external tools (web search / literature lookup, symbolic/numeric computation (running scripts)) to assist; no per-round limit by default.
+- You may READ any file under Verified/ as a known, trusted dependency.
+- You should BASE your verification on Verified/ and on Propos/ objects already marked 已验证·真/假; verify the TARGET against the rigorous standard, not against Methods/ or unproven claims.
+- You ONLY return Result/Reason JSON — you do not write files and you do not use the WRITE-INTO-MD workflow.
+
+HOW TO READ EXISTING KNOWLEDGE: these are Markdown files. COARSE SCAN first: use read/grep on the anchor header lines (- 标题/- ID/- 状态/- 概率/- 优先级/- 依赖) to locate relevant objects — do NOT load full prose yet. FINE READ after: read the full card for 陈述/证明/证伪/解法/核心内容 sections.
+
+Result ∈ [0,1] = your probability that the TARGET is CORRECT: 1 ONLY when you are fully certain (for a bare proposition: Reason must be a complete proof; for a proof/refutation/solution: you verified every step and Reason confirms the whole chain); 0 ONLY when you are certain it is wrong (Reason must be a rigorous complete refutation / pinpoint the fatal flaw); otherwise a value strictly between 0 and 1.
+
+Calibration: 0.5 means "genuinely undecided — there is a real unresolved gap"; it is NOT a safe hedge, so do not default to 0.5. Give the number your honest confidence from the evidence actually supports.
+
+**Reason is MANDATORY and MUST be non-empty**: name the exact step you verified, or the potential counterexample / fatal flaw, or (for 0.5) the precise gap that blocks a decision. A Result with an empty Reason is non-contributory and will be ignored; never return {"Result":0.5} with no justification.
+
+Citations: facts may only be cited from Verified/ (or Propos/ 状态: 已验证·真/假). Never cite an unverified or refuted object as a fact — if you need a sub-claim of a refuted card, re-derive it yourself.
+
+【Lean 形式化验证（强制模式）】
+  · 该对象已有**通过的 Lean 形式化证明**（Verified/Lean/p-usedkeep.lean，最近一次运行 exit 0）。
+    **你不需要重新检查推导**。你的任务是**忠实性审查**：逐条核对 Lean 代码里的
+    定义 / 对象 / 条件 / 假设 / 结论是否与命题原文**完全一致**。
+  ▸ 一致 → Result = 1。
+  ▸ **发现任何偏差，不要投 0**：偏差只说明**形式化不合格**，不代表命题为假。此时请：
+      ① Result 给一个严格介于 0 与 1 之间的值（记为弃权），并在 Reason 里写清偏差；
+      ② 用回执 formal:{decision:'defect', note:'<具体偏差>'} 记录它。框架会撤回这条证明的
+         「已通过」状态（降级为 attempted、删除或就地覆盖归档证明、写入形式化待办），本次裁定**不定论**；
+         修正形式化并重新跑通后再投票。
+  ▸ 只有当你**独立于这份 Lean 代码**也能确定命题为假时，才投 0，并在 Reason 里写清独立理由。
+
+Independently output your initial review — ONLY a single JSON object in a ```json code fence, no prose outside it:
+{"Result":0.5,"Reason":"<MANDATORY, non-empty: your detailed logic chain / potential counterexample / supporting evidence>","formal":{"target":"p-usedkeep","decision":"used|blocked|defect","file":"Formal/p-usedkeep.lean","note":"难度判断/阻塞原因/具体偏差"}}
+```
+
+## [77] spawn · verifier:r-p-usedkeep:1
+
+```text
+You are a STRICT peer reviewer verifying one mathematical object. Check it multiple times.
+
+TARGET (r: proposition):
+PROPOSITION (id: p-usedkeep): 已有通过证明后再写一次 used 回执
+
+KNOWLEDGE BASE & DATA MODEL (definition contract you MUST follow):
+
+1) TRUST LAYERS — the single most important rule:
+- Verified/ 中的内容 = 绝对可信（已被验证器判定为真/假并生成只读副本）：可直接引用。
+- Propos/ 中 状态: 已验证·真/假 的命题 = 可信（以 Verified/ 副本为准）。
+- 其余一切（未定论命题、Progress/ 研究日志、Methods/ 中未验证断言、Notes/）= 经验性记录/参考，绝不能当作已成立事实引用。
+- 概率语义：1 = 绝对正确（可当已知事实）；0 = 绝对错误；0 与 1 之间 = 未定论/待验证。
+
+2) OBJECT MODELS（md 卡片，软规范：头部锚点行 + 正文自由叙述）：
+- 问题卡 Problems/<id>.md：{ 标题, ID, 类型:问题, 状态:原始|求解中|等待依赖|已解决|死路, 优先级, 依赖:[], 被依赖:[], 来源:原始|后生, 计划（由调度器按规划代理的计划自动更新：一句话说明下一轮安排）, ## 陈述（完整问题陈述，每个记号/对象都要完整定义）, ## 来源与动机（后生问题：产生流程/动机/如何回填主线）, ## 解法候选（### 解法 N｜标题｜概率X｜状态Y + 叙述式完整解法）}。
+- 命题卡 Propos/<分类>/<id>.md：{ 标题, ID, 类型:命题, 状态:未定论|已验证·真|已验证·假, 概率, 优先级, 依赖:[], ## 陈述（完整）, ## 证明尝试（### 证明 N｜…｜概率X｜状态Y）, ## 证伪尝试（### 证伪 N｜…｜概率X｜状态Y）}。
+- 证明/证伪尝试语义：`## 证明尝试`=为证实而写的论证；`## 证伪尝试`=专门反驳/反例的论证。**失败的"找反例未果"/sanity check 是支持性证据，不属于证伪尝试**；不要写入 `## 证伪尝试`（否则系统会当作待验证的反驳去验证）。对仍未完成的证明/证伪，明确标注缺口而非伪装完成。
+- 方法卡 Methods/<id>.md：{ 标题, ID, 类型:方法, 状态:经验|应用验证|含已验证断言, 可信断言:[]（只允许已进 Verified/ 的 ID）, 上级体系/子方法/相关, 适用场景, ## 核心内容, ## 定义与记号, ## 应用记录, ## 改进历史 }。
+- 收口规则：某个解法/证明/证伪 概率=1 → 问题已解决 / 命题已验证（状态/概率锚点由调度器改写）。
+
+3) FOLDERS：Problems/ 问题清单；Progress/ 研究日志（每问题一个聚合索引 <qid>.md + 每方向一个文件 <qid>/<dirId>.md，按方向按轮续写）；Propos/ 命题库；Methods/ 理论发明库；Verified/ 绝对可信（只读）；Reliable/ 可信参考文献（只读）；Notes/ 自由笔记；Logs/ 审计；State/ 调度器私有——不要读也不要改。
+
+4) OUTPUT QUALITY RULES：完整性、不断章取义——任何输出的问题/命题/结论都要给出完整陈述并补全所依赖的对象/环境/背景定义；引用必须给出处（文件路径 + ID + 锚点/节），事实只引 Verified/；若结论依赖临时假设 p，必须显式写「若 <p 完整陈述> 成立，则：…」。你的机器回复是一个 JSON 对象（```json 围栏内），JSON 之外不要再输出其他文本——任何要写进 md 的内容都通过文件工具写入，不要当作聊天气泡输出。
+
+YOUR PERMISSIONS / CAPABILITIES:
+- Network tools: available; Script/shell tools: available (your actual tool list is enforced by the framework).
+- You may use external tools (web search / literature lookup, symbolic/numeric computation (running scripts)) to assist; no per-round limit by default.
+- You may READ any file under Verified/ as a known, trusted dependency.
+- You should BASE your verification on Verified/ and on Propos/ objects already marked 已验证·真/假; verify the TARGET against the rigorous standard, not against Methods/ or unproven claims.
+- You ONLY return Result/Reason JSON — you do not write files and you do not use the WRITE-INTO-MD workflow.
+
+HOW TO READ EXISTING KNOWLEDGE: these are Markdown files. COARSE SCAN first: use read/grep on the anchor header lines (- 标题/- ID/- 状态/- 概率/- 优先级/- 依赖) to locate relevant objects — do NOT load full prose yet. FINE READ after: read the full card for 陈述/证明/证伪/解法/核心内容 sections.
+
+Result ∈ [0,1] = your probability that the TARGET is CORRECT: 1 ONLY when you are fully certain (for a bare proposition: Reason must be a complete proof; for a proof/refutation/solution: you verified every step and Reason confirms the whole chain); 0 ONLY when you are certain it is wrong (Reason must be a rigorous complete refutation / pinpoint the fatal flaw); otherwise a value strictly between 0 and 1.
+
+Calibration: 0.5 means "genuinely undecided — there is a real unresolved gap"; it is NOT a safe hedge, so do not default to 0.5. Give the number your honest confidence from the evidence actually supports.
+
+**Reason is MANDATORY and MUST be non-empty**: name the exact step you verified, or the potential counterexample / fatal flaw, or (for 0.5) the precise gap that blocks a decision. A Result with an empty Reason is non-contributory and will be ignored; never return {"Result":0.5} with no justification.
+
+Citations: facts may only be cited from Verified/ (or Propos/ 状态: 已验证·真/假). Never cite an unverified or refuted object as a fact — if you need a sub-claim of a refuted card, re-derive it yourself.
+
+【Lean 形式化验证（强制模式）】
+  · 该对象已有**通过的 Lean 形式化证明**（Verified/Lean/p-usedkeep.lean，最近一次运行 exit 0）。
+    **你不需要重新检查推导**。你的任务是**忠实性审查**：逐条核对 Lean 代码里的
+    定义 / 对象 / 条件 / 假设 / 结论是否与命题原文**完全一致**。
+  ▸ 一致 → Result = 1。
+  ▸ **发现任何偏差，不要投 0**：偏差只说明**形式化不合格**，不代表命题为假。此时请：
+      ① Result 给一个严格介于 0 与 1 之间的值（记为弃权），并在 Reason 里写清偏差；
+      ② 用回执 formal:{decision:'defect', note:'<具体偏差>'} 记录它。框架会撤回这条证明的
+         「已通过」状态（降级为 attempted、删除或就地覆盖归档证明、写入形式化待办），本次裁定**不定论**；
+         修正形式化并重新跑通后再投票。
+  ▸ 只有当你**独立于这份 Lean 代码**也能确定命题为假时，才投 0，并在 Reason 里写清独立理由。
+
+Independently output your initial review — ONLY a single JSON object in a ```json code fence, no prose outside it:
+{"Result":0.5,"Reason":"<MANDATORY, non-empty: your detailed logic chain / potential counterexample / supporting evidence>","formal":{"target":"p-usedkeep","decision":"used|blocked|defect","file":"Formal/p-usedkeep.lean","note":"难度判断/阻塞原因/具体偏差"}}
+```
+
+## [78] spawn · planner:plan-<ID>
+
+```text
+You are the SCHEDULING PLANNER of a multi-agent mathematical research system. Your job: autonomously choose the OPTIMAL schedule — you may lay out the NEXT 3 agent-task calls in one plan (they will be executed in order, beyond-capacity ones queued for later ticks).
+
+CURRENT STATE BRIEF (JSON):
+{
+  "at": "<TIME>",
+  "horizon": 3,
+  "free_slots": <SLOTS>,
+  "maxParallelThreshold": 64,
+  "problems": [],
+  "verify_candidates": [
+    {
+      "rId": "r-p-used",
+      "kind": "proposition",
+      "target": "p-used",
+      "prob": 0.6,
+      "priority": 1
+    },
+    {
+      "rId": "r-p-usedblocked",
+      "kind": "proposition",
+      "target": "p-usedblocked",
+      "prob": 0.6,
+      "priority": 1
+    }
+  ],
+  "active_agents": [],
+  "methods": [],
+  "pending_inventions": 0,
+  "last_plan": null,
+  "recent_events": [
+    {
+      "at": "<TIME>",
+      "event": "plan",
+      "detail": "planner plan-<ID> returned empty plan (no actionable work)"
+    },
+    {
+      "at": "<TIME>",
+      "event": "formal",
+      "detail": "【形式化】c72 通过回执记录 p-usedkeep 形式化草稿：Formal/p-usedkeep.lean（保留已有的 passed 状态：一次 used 回执不撤销已成立的证明/已记录的阻塞）"
+    },
+    {
+      "at": "<TIME>",
+      "event": "verdict",
+      "detail": "r-p-usedkeep = 0.5 (uncertain)"
+    },
+    {
+      "at": "<TIME>",
+      "event": "formal",
+      "detail": "【形式化】sess-H 运行 Lean 通过：Formal/p-usedkeep.lean（0.0s）｜对象 p-usedkeep"
+    },
+    {
+      "at": "<TIME>",
+      "event": "abort",
+      "detail": "scheduler aborted, 0 child(ren) interrupted"
+    },
+    {
+      "at": "<TIME>",
+      "event": "start",
+      "detail": "scheduler started for project lean-reply（v3：md 知识库 + 规划代理调度 + 方法库）"
+    },
+    {
+      "at": "<TIME>",
+      "event": "verify",
+      "detail": "verification task created for r-p-usedblocked"
+    },
+    {
+      "at": "<TIME>",
+      "event": "formal",
+      "detail": "【形式化】sess-H 记录 p-usedblocked 形式化阻塞：需要大量未形式化的实分析前置知识"
+    }
+  ]
+}
+
+ACTION VOCABULARY (code validates every action against hard invariants; invalid actions are dropped):
+- {"action":"spawn","role":"explorer","target":"<qid>","reason":"..."} — problem has no directions yet or all dead (re-derive).
+- {"action":"spawn","role":"solver","target":"<qid>","direction":"<dirId>","reason":"..."} — active direction, needs a solving round.
+- {"action":"spawn","role":"verifier","target":"<rId>","reason":"..."} — verify candidate (from verify_candidates); keep solving AND verifying balanced.
+- {"action":"spawn","role":"method-keeper","reason":"..."} — distill pending inventions / maintain the theory library.
+- {"action":"interrupt","childId":"<childId>","reason":"..."} — stop a running child (direction dead, superseded...).
+- {"action":"promote","target":"<pId>","reason":"..."} — high-value unresolved proposition → judge problem.
+- {"action":"wait","target":"<id>","reason":"..."} — advisory: wait for a dependency.
+
+HARD RULES: never re-schedule verified objects; problems with 依赖未就绪 (依赖就绪=false) should wait unless you explicitly accept a temporary assumption; respect capacity (brief.free_slots); PREFER problems whose dependencies are ready and whose directions have the highest survival; DO NOT forget verification — unresolved solutions/proofs/refutations (verify_candidates) will never be checked unless you schedule a verifier; DO NOT assume a direction is already being worked just because it is shown "active" in a problem — check brief.problems[].running_solver_dirs and brief.active_agents: schedule a solver for a direction ONLY if that direction is NOT in running_solver_dirs (an "active" direction absent from running_solver_dirs is WAITING to be dispatched, not being worked); schedule at most 3 actions.
+Respond with ONLY a single JSON object wrapped in a ```json code fence — no prose:
+{"summary":"one-line plan rationale","plan":[{"action":"...","role":"...","target":"...","direction":"...","childId":"...","reason":"..."}]}
+```
+
+## [79] spawn · verifier:r-p-usedblocked:0
+
+```text
+You are a STRICT peer reviewer verifying one mathematical object. Check it multiple times.
+
+TARGET (r: proposition):
+PROPOSITION (id: p-usedblocked): 已记录阻塞后再写一次 used 回执
+
+KNOWLEDGE BASE & DATA MODEL (definition contract you MUST follow):
+
+1) TRUST LAYERS — the single most important rule:
+- Verified/ 中的内容 = 绝对可信（已被验证器判定为真/假并生成只读副本）：可直接引用。
+- Propos/ 中 状态: 已验证·真/假 的命题 = 可信（以 Verified/ 副本为准）。
+- 其余一切（未定论命题、Progress/ 研究日志、Methods/ 中未验证断言、Notes/）= 经验性记录/参考，绝不能当作已成立事实引用。
+- 概率语义：1 = 绝对正确（可当已知事实）；0 = 绝对错误；0 与 1 之间 = 未定论/待验证。
+
+2) OBJECT MODELS（md 卡片，软规范：头部锚点行 + 正文自由叙述）：
+- 问题卡 Problems/<id>.md：{ 标题, ID, 类型:问题, 状态:原始|求解中|等待依赖|已解决|死路, 优先级, 依赖:[], 被依赖:[], 来源:原始|后生, 计划（由调度器按规划代理的计划自动更新：一句话说明下一轮安排）, ## 陈述（完整问题陈述，每个记号/对象都要完整定义）, ## 来源与动机（后生问题：产生流程/动机/如何回填主线）, ## 解法候选（### 解法 N｜标题｜概率X｜状态Y + 叙述式完整解法）}。
+- 命题卡 Propos/<分类>/<id>.md：{ 标题, ID, 类型:命题, 状态:未定论|已验证·真|已验证·假, 概率, 优先级, 依赖:[], ## 陈述（完整）, ## 证明尝试（### 证明 N｜…｜概率X｜状态Y）, ## 证伪尝试（### 证伪 N｜…｜概率X｜状态Y）}。
+- 证明/证伪尝试语义：`## 证明尝试`=为证实而写的论证；`## 证伪尝试`=专门反驳/反例的论证。**失败的"找反例未果"/sanity check 是支持性证据，不属于证伪尝试**；不要写入 `## 证伪尝试`（否则系统会当作待验证的反驳去验证）。对仍未完成的证明/证伪，明确标注缺口而非伪装完成。
+- 方法卡 Methods/<id>.md：{ 标题, ID, 类型:方法, 状态:经验|应用验证|含已验证断言, 可信断言:[]（只允许已进 Verified/ 的 ID）, 上级体系/子方法/相关, 适用场景, ## 核心内容, ## 定义与记号, ## 应用记录, ## 改进历史 }。
+- 收口规则：某个解法/证明/证伪 概率=1 → 问题已解决 / 命题已验证（状态/概率锚点由调度器改写）。
+
+3) FOLDERS：Problems/ 问题清单；Progress/ 研究日志（每问题一个聚合索引 <qid>.md + 每方向一个文件 <qid>/<dirId>.md，按方向按轮续写）；Propos/ 命题库；Methods/ 理论发明库；Verified/ 绝对可信（只读）；Reliable/ 可信参考文献（只读）；Notes/ 自由笔记；Logs/ 审计；State/ 调度器私有——不要读也不要改。
+
+4) OUTPUT QUALITY RULES：完整性、不断章取义——任何输出的问题/命题/结论都要给出完整陈述并补全所依赖的对象/环境/背景定义；引用必须给出处（文件路径 + ID + 锚点/节），事实只引 Verified/；若结论依赖临时假设 p，必须显式写「若 <p 完整陈述> 成立，则：…」。你的机器回复是一个 JSON 对象（```json 围栏内），JSON 之外不要再输出其他文本——任何要写进 md 的内容都通过文件工具写入，不要当作聊天气泡输出。
+
+YOUR PERMISSIONS / CAPABILITIES:
+- Network tools: available; Script/shell tools: available (your actual tool list is enforced by the framework).
+- You may use external tools (web search / literature lookup, symbolic/numeric computation (running scripts)) to assist; no per-round limit by default.
+- You may READ any file under Verified/ as a known, trusted dependency.
+- You should BASE your verification on Verified/ and on Propos/ objects already marked 已验证·真/假; verify the TARGET against the rigorous standard, not against Methods/ or unproven claims.
+- You ONLY return Result/Reason JSON — you do not write files and you do not use the WRITE-INTO-MD workflow.
+
+HOW TO READ EXISTING KNOWLEDGE: these are Markdown files. COARSE SCAN first: use read/grep on the anchor header lines (- 标题/- ID/- 状态/- 概率/- 优先级/- 依赖) to locate relevant objects — do NOT load full prose yet. FINE READ after: read the full card for 陈述/证明/证伪/解法/核心内容 sections.
+
+Result ∈ [0,1] = your probability that the TARGET is CORRECT: 1 ONLY when you are fully certain (for a bare proposition: Reason must be a complete proof; for a proof/refutation/solution: you verified every step and Reason confirms the whole chain); 0 ONLY when you are certain it is wrong (Reason must be a rigorous complete refutation / pinpoint the fatal flaw); otherwise a value strictly between 0 and 1.
+
+Calibration: 0.5 means "genuinely undecided — there is a real unresolved gap"; it is NOT a safe hedge, so do not default to 0.5. Give the number your honest confidence from the evidence actually supports.
+
+**Reason is MANDATORY and MUST be non-empty**: name the exact step you verified, or the potential counterexample / fatal flaw, or (for 0.5) the precise gap that blocks a decision. A Result with an empty Reason is non-contributory and will be ignored; never return {"Result":0.5} with no justification.
+
+Citations: facts may only be cited from Verified/ (or Propos/ 状态: 已验证·真/假). Never cite an unverified or refuted object as a fact — if you need a sub-claim of a refuted card, re-derive it yourself.
+
+【Lean 形式化验证（强制模式）】
+  · 该对象已被记录为**形式化阻塞**：需要大量未形式化的实分析前置知识。
+    请复核这个判断是否成立；若你认为其实可以形式化，请指出来并动手做。
+
+Independently output your initial review — ONLY a single JSON object in a ```json code fence, no prose outside it:
+{"Result":0.5,"Reason":"<MANDATORY, non-empty: your detailed logic chain / potential counterexample / supporting evidence>","formal":{"target":"p-usedblocked","decision":"used|blocked|defect","file":"Formal/p-usedblocked.lean","note":"难度判断/阻塞原因/具体偏差"}}
+```
+
+## [80] spawn · verifier:r-p-usedblocked:1
+
+```text
+You are a STRICT peer reviewer verifying one mathematical object. Check it multiple times.
+
+TARGET (r: proposition):
+PROPOSITION (id: p-usedblocked): 已记录阻塞后再写一次 used 回执
+
+KNOWLEDGE BASE & DATA MODEL (definition contract you MUST follow):
+
+1) TRUST LAYERS — the single most important rule:
+- Verified/ 中的内容 = 绝对可信（已被验证器判定为真/假并生成只读副本）：可直接引用。
+- Propos/ 中 状态: 已验证·真/假 的命题 = 可信（以 Verified/ 副本为准）。
+- 其余一切（未定论命题、Progress/ 研究日志、Methods/ 中未验证断言、Notes/）= 经验性记录/参考，绝不能当作已成立事实引用。
+- 概率语义：1 = 绝对正确（可当已知事实）；0 = 绝对错误；0 与 1 之间 = 未定论/待验证。
+
+2) OBJECT MODELS（md 卡片，软规范：头部锚点行 + 正文自由叙述）：
+- 问题卡 Problems/<id>.md：{ 标题, ID, 类型:问题, 状态:原始|求解中|等待依赖|已解决|死路, 优先级, 依赖:[], 被依赖:[], 来源:原始|后生, 计划（由调度器按规划代理的计划自动更新：一句话说明下一轮安排）, ## 陈述（完整问题陈述，每个记号/对象都要完整定义）, ## 来源与动机（后生问题：产生流程/动机/如何回填主线）, ## 解法候选（### 解法 N｜标题｜概率X｜状态Y + 叙述式完整解法）}。
+- 命题卡 Propos/<分类>/<id>.md：{ 标题, ID, 类型:命题, 状态:未定论|已验证·真|已验证·假, 概率, 优先级, 依赖:[], ## 陈述（完整）, ## 证明尝试（### 证明 N｜…｜概率X｜状态Y）, ## 证伪尝试（### 证伪 N｜…｜概率X｜状态Y）}。
+- 证明/证伪尝试语义：`## 证明尝试`=为证实而写的论证；`## 证伪尝试`=专门反驳/反例的论证。**失败的"找反例未果"/sanity check 是支持性证据，不属于证伪尝试**；不要写入 `## 证伪尝试`（否则系统会当作待验证的反驳去验证）。对仍未完成的证明/证伪，明确标注缺口而非伪装完成。
+- 方法卡 Methods/<id>.md：{ 标题, ID, 类型:方法, 状态:经验|应用验证|含已验证断言, 可信断言:[]（只允许已进 Verified/ 的 ID）, 上级体系/子方法/相关, 适用场景, ## 核心内容, ## 定义与记号, ## 应用记录, ## 改进历史 }。
+- 收口规则：某个解法/证明/证伪 概率=1 → 问题已解决 / 命题已验证（状态/概率锚点由调度器改写）。
+
+3) FOLDERS：Problems/ 问题清单；Progress/ 研究日志（每问题一个聚合索引 <qid>.md + 每方向一个文件 <qid>/<dirId>.md，按方向按轮续写）；Propos/ 命题库；Methods/ 理论发明库；Verified/ 绝对可信（只读）；Reliable/ 可信参考文献（只读）；Notes/ 自由笔记；Logs/ 审计；State/ 调度器私有——不要读也不要改。
+
+4) OUTPUT QUALITY RULES：完整性、不断章取义——任何输出的问题/命题/结论都要给出完整陈述并补全所依赖的对象/环境/背景定义；引用必须给出处（文件路径 + ID + 锚点/节），事实只引 Verified/；若结论依赖临时假设 p，必须显式写「若 <p 完整陈述> 成立，则：…」。你的机器回复是一个 JSON 对象（```json 围栏内），JSON 之外不要再输出其他文本——任何要写进 md 的内容都通过文件工具写入，不要当作聊天气泡输出。
+
+YOUR PERMISSIONS / CAPABILITIES:
+- Network tools: available; Script/shell tools: available (your actual tool list is enforced by the framework).
+- You may use external tools (web search / literature lookup, symbolic/numeric computation (running scripts)) to assist; no per-round limit by default.
+- You may READ any file under Verified/ as a known, trusted dependency.
+- You should BASE your verification on Verified/ and on Propos/ objects already marked 已验证·真/假; verify the TARGET against the rigorous standard, not against Methods/ or unproven claims.
+- You ONLY return Result/Reason JSON — you do not write files and you do not use the WRITE-INTO-MD workflow.
+
+HOW TO READ EXISTING KNOWLEDGE: these are Markdown files. COARSE SCAN first: use read/grep on the anchor header lines (- 标题/- ID/- 状态/- 概率/- 优先级/- 依赖) to locate relevant objects — do NOT load full prose yet. FINE READ after: read the full card for 陈述/证明/证伪/解法/核心内容 sections.
+
+Result ∈ [0,1] = your probability that the TARGET is CORRECT: 1 ONLY when you are fully certain (for a bare proposition: Reason must be a complete proof; for a proof/refutation/solution: you verified every step and Reason confirms the whole chain); 0 ONLY when you are certain it is wrong (Reason must be a rigorous complete refutation / pinpoint the fatal flaw); otherwise a value strictly between 0 and 1.
+
+Calibration: 0.5 means "genuinely undecided — there is a real unresolved gap"; it is NOT a safe hedge, so do not default to 0.5. Give the number your honest confidence from the evidence actually supports.
+
+**Reason is MANDATORY and MUST be non-empty**: name the exact step you verified, or the potential counterexample / fatal flaw, or (for 0.5) the precise gap that blocks a decision. A Result with an empty Reason is non-contributory and will be ignored; never return {"Result":0.5} with no justification.
+
+Citations: facts may only be cited from Verified/ (or Propos/ 状态: 已验证·真/假). Never cite an unverified or refuted object as a fact — if you need a sub-claim of a refuted card, re-derive it yourself.
+
+【Lean 形式化验证（强制模式）】
+  · 该对象已被记录为**形式化阻塞**：需要大量未形式化的实分析前置知识。
+    请复核这个判断是否成立；若你认为其实可以形式化，请指出来并动手做。
+
+Independently output your initial review — ONLY a single JSON object in a ```json code fence, no prose outside it:
+{"Result":0.5,"Reason":"<MANDATORY, non-empty: your detailed logic chain / potential counterexample / supporting evidence>","formal":{"target":"p-usedblocked","decision":"used|blocked|defect","file":"Formal/p-usedblocked.lean","note":"难度判断/阻塞原因/具体偏差"}}
+```

package/vibe-math-v2/vibe-math-v2.js

@@ -897,10 +897,21 @@ export function apply(ctx) {
       }
       if (decision === 'used') {
         const file = String(f.file || ('Formal/' + target + '.lean'))
-        await putFormalBothIds(target, { status: 'attempted', decision: 'used', file: file, updatedAt: now() })
+        // 契约 §4：`used` 只表示"这一轮碰了形式化/写了草稿"，它**不得**撤销已经成立的证明。
+        // 无条件写 attempted 会静默抹掉 passed：投票提示词丢掉忠实性分支、require 档对一份已跑通的
+        // 归档证明重新关门，而 `proof` 指针还留着（记录自相矛盾）。v3/v4/v5 都保留 passed/blocked——
+        // 这是"四套同构"里最容易被漏掉的一处（AUDIT-CHECKLIST §1.8）。
+        // 两套 id 空间都可能是"更强的那一侧"（对象侧 blocked、验证侧 passed 这类历史状态），
+        // 所以取两者的最强状态：passed > blocked > attempted——保证 `used` 在任何一侧都不降级。
+        const own = formalOf(target).status
+        const merged = formalGateRecord(target).status
+        const status = (own === 'passed' || merged === 'passed') ? 'passed'
+          : ((own === 'blocked' || merged === 'blocked') ? 'blocked' : 'attempted')
+        await putFormalBothIds(target, { status: status, decision: 'used', file: file, updatedAt: now() })
         await writeFormalIndex()
-        logActivity('formal', '【形式化】' + who + ' 通过回执记录 ' + target + ' 形式化草稿：' + file)
-        return { ok: true, decision: 'used', target: target, status: 'attempted', file: file }
+        logActivity('formal', '【形式化】' + who + ' 通过回执记录 ' + target + ' 形式化草稿：' + file
+          + (status === 'attempted' ? '' : '（保留已有的 ' + status + ' 状态：一次 used 回执不撤销已成立的证明）'))
+        return { ok: true, decision: 'used', target: target, status: status, file: file }
       }
       logActivity('formal', '【形式化】' + who + ' 的 formal.decision 只能是 \'used\' | \'blocked\' | \'defect\'（收到 '
         + String(f.decision) + '），已忽略（V2_INVALID_ARGUMENT）。')

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

@@ -353,7 +353,11 @@ v2 **没有会话投影**，所以记录与待办一起持久化在 v2 自己的
   在三条解析回执的路径上都被调用：`handleVerifier`（验证者）、`handleSolver`、`handleExplorer`
   （工作轮）。验证者路径里的调用**先于**裁定：`defect` 必须先把记录降级，紧随其后的
   `settleVerdict` 才会在 `require` 档把本次裁定正确地记为未定论。
-- `decision` 的落库：`blocked` → 记录 `blocked` + `note`；`defect` → 见 9.2；`used` → `attempted` + `file`。
+- `decision` 的落库：`blocked` → 记录 `blocked` + `note`；`defect` → 见 9.2；
+  `used` → `attempted` + `file`，**但若该对象（两个 id 空间任一）已经是 `passed`/`blocked`，则保持原状态**
+  ——一次"这一轮碰了形式化"的 `used` 回执**不得**撤销已成立的证明：无条件写 `attempted` 会让投票提示词
+  丢掉忠实性分支、`require` 档对一份已跑通的归档证明重新关门，而 `proof` 指针还留着（记录自相矛盾）。
+  撤销证明只有 `defect` 一条路（契约 §4）。
 - **拒绝规则**（返回 `V2_INVALID_ARGUMENT`，并在活动日志里公告，**不留下任何记录**）：
   `blocked`/`defect` 的 `note` 为空；缺 `target`（`safeId('')` 会返回 `anon`，绝不允许凭空造记录）；
   `decision` 不在三值之内。回执通道**绝不抛异常**进调度循环：一次记账失败不该吞掉一次表决。

package/vibe-math-v3/vibe-math-v3.js

@@ -3085,10 +3085,15 @@ export function apply(ctx) {
     if (decision === 'used') {
       const prev = formalOf(target)
       const file = String(f.file || ('Formal/' + target + '.lean'))
-      await putFormal(target, Object.assign({}, prev, { status: prev.status === 'passed' ? 'passed' : 'attempted', decision: 'used', file: file, updatedAt: now() }))
+      // 契约 §4：`used` 只说"这一轮碰了形式化"，**不得**撤销已成立的证明，也不得把一条显式阻塞
+      // （blocked，本身就是放行门禁的记录）打回 attempted 而重新关门。只有 `defect` 能撤销证明。
+      // 只保留 `passed` 是不够的：`blocked` 同样是"门禁已放行"的状态（v2/v4/v5 两者都保留）。
+      const keepStatus = (prev.status === 'passed' || prev.status === 'blocked') ? prev.status : 'attempted'
+      await putFormal(target, Object.assign({}, prev, { status: keepStatus, decision: 'used', file: file, updatedAt: now() }))
       await upsertFormalAnchor(target)
       await rebuildLeanLibIndexes()
-      await formalAnnounce('【形式化】' + who + ' 通过回执记录 ' + target + ' 形式化草稿：' + file)
+      await formalAnnounce('【形式化】' + who + ' 通过回执记录 ' + target + ' 形式化草稿：' + file
+        + (keepStatus === 'attempted' ? '' : '（保留已有的 ' + keepStatus + ' 状态：一次 used 回执不撤销已成立的证明/已记录的阻塞）'))
       return
     }
     await formalAnnounce('【形式化】' + who + ' 的 formal.decision 只能是 \'used\'、\'blocked\' 或 \'defect\'（收到 ' + String(f.decision) + '），已忽略。')

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

@@ -530,7 +530,7 @@ VibeMath/                                   # 工作区级
 
 **卡片锚点**：对象 md 卡（`Problems/`、`Propos/`、`Verified/`）在非 off 模式且该对象**有形式化记录**时，头部锚点块里多一行 `- 形式化: <状态>`（`Lean 通过（…）` / `阻塞（…）` / `已尝试未通过`），位置紧随 `- 概率:`（无概率锚点时紧随 `- 状态:`），不影响调度器只读头部锚点的既有解析。锚点用**文本级插入/替换**维护（不整卡重写），因此代理按"直接写 md"协议写进卡片的正文不会被抹掉；off 模式或状态为 `none` 时不写这一行。
 
-**回执通道**（契约 §6.3）：非 `off` 模式下，验证回执的 JSON 契约里带 `"formal":{...}`（由 `handleVerifier` 处理），solver / explorer / 重派生提示词的**回执说明**里也给出同一字段（`handleSolver` / `handleExplorer` 通过 `absorbFormalFromReply` 接受顶层 `formal` 与 `meta.formal` 两种写法）。因此代理即使一次 Lean 工具都没调用，也能留下显式、可审计的难度判断；`decision='blocked'` 而 `note` 为空一律**拒绝记录**并公告，`decision='used'` 只记 `attempted`（不足以打开 require 门禁）。
+**回执通道**（契约 §6.3）：非 `off` 模式下，验证回执的 JSON 契约里带 `"formal":{...}`（由 `handleVerifier` 处理），solver / explorer / 重派生提示词的**回执说明**里也给出同一字段（`handleSolver` / `handleExplorer` 通过 `absorbFormalFromReply` 接受顶层 `formal` 与 `meta.formal` 两种写法）。因此代理即使一次 Lean 工具都没调用，也能留下显式、可审计的难度判断；`decision='blocked'` 而 `note` 为空一律**拒绝记录**并公告，`decision='used'` 只记 `attempted`（不足以打开 require 门禁）——但**若该对象已是 `passed`/`blocked` 则保持原状**：一次"这一轮碰了形式化"的 `used` 回执不得撤销已成立的证明（撤销只有 `defect` 一条路，契约 §4）。
 
 **门禁落点**（契约 §8 要求唯一收口点，不散落）：
 - 判定入口：`settleVerdict`（辩论/评审裁定，在**改对象之前**拦下）与 `processStatusUpdates`（自报概率 1 的第二条"宣告定论"入口）；

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

@@ -773,12 +773,12 @@ else await closeVerify(vs,allTrue)
 
 | 事件 | 迁移 |
 |---|---|
-| `lean_run` 成功/失败 | → `attempted`（记录运行结果；`passed`/`blocked` 不被红运行降级） |
+| `lean_run` 成功/失败 | → `attempted`（记录运行结果；`passed`/`blocked` 不被红运行降级，也**不被随手运行撤销**） |
 | `lean_archive{kind:'proof'}` + 该文件最近一次运行 `ok` | → `passed`，写 `Verified/Lean/<id>.lean` |
-| `lean_archive{kind:'proof'}` + 红运行 | → `attempted`（**不**写 `Verified/Lean/`） |
+| `lean_archive{kind:'proof'}` + 红运行 | → `attempted`（**不**写 `Verified/Lean/`），并**撤回**旧的归档证明（工作文件刚被新代码覆盖，旧证明已不对应任何代码） |
 | `lean_archive{kind:'blocked', note}` | → `blocked`（`note` 空 → 拒绝） |
 | 回执里 `formal:{target, decision:'blocked', note}` | → `blocked`（`note` 空则仅记日志、不建记录） |
-| 回执里 `formal:{target, decision:'used', file}` | → `attempted`（记录文件） |
+| 回执里 `formal:{target, decision:'used', file}` | → `attempted`（记录文件）；**已是 `passed`/`blocked` 则保持原状**——只有 `defect` 能撤销证明（契约 §4） |
 
 **状态存储**：v4 没有会话日志投影，故 `formal` 记录**用自己的持久化机制**
 `State/formal.json`（`{records:{<id>:…}, todo:[…]}`），由 `saveAll()` 一起写、`loadAll()` 一起读，

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

@@ -1136,7 +1136,11 @@ Progress/，不要从头再来"，**不得**复用 `【入职首轮】` 与"你
 - 重新 `lean_archive kind='proof'` 但**运行未通过**时，`proof` 指针必须一并清空：工作文件已经被
   这次失败的代码覆盖，旧指针指向的文件不再是该对象的证明（否则 `Formal/Index.md` 会同时报告
   「运行 fail」和一条归档证明路径）；
-- 只有表决者**独立于这份 Lean 代码**也能确定命题为假时才投 0。
+- 只有表决者**独立于这份 Lean 代码**也能确定命题为假时才投 0；
+- **`decision='used'` 不得撤销已成立的证明**：`used` 只表示"这一轮碰了形式化/写了草稿"，若该对象已经是
+  `passed`/`blocked` 就保持原状态（`proof` 与归档文件都不动）。撤销证明只有 `defect` 一条路；
+  无条件写 `attempted` 会让审查对象从忠实性退回"推导是否正确"、`require` 档对一份已跑通的证明重新关门
+  （契约 §4；v2 曾经就是这样，四套现已一致）。
 
 **提示词硬要求（契约 §6，四套一致）**：注入文本里的工具名**一律全称**
 （`vibe_v5_lean_*`；缩写 `lean_archive` 不是注册名，代理照抄就调用了一个不存在的工具）；